Of course there's not usually just one path from a user's workstation to a server and the actual path depends on the state of each router's tables as the packet passes through them. But often--usually--the shortest path (in terms of # of edges or nodes) is the one taken.

I have taken a look at Graph before. The problem I have is that I cannot find any tutorials on how to use it. Most of what I seen in the way of examples, the programmer refers to everything in a way that imply you know what he is talking about.

If you could point me at a tutorial for Graph I would certainly appreciate it.

The tutorial for the Graph module is Mastering Algorithms with Perl by Jon Orwant, Jarkko Hietaniemi, and John Macdonald. I enjoyed this book very much and I use it as a reference for the Graph modules, which I use a lot.
It should work perfectly the first time! - toma

%network_map = (
12567 =>            # the machine id
[335, 456, 338],    # the id's of machines it is directly connected to
335 => [12657, 558, 667, 333]
# etc
)
[download]

Sorry for my English :)

This is completely untested:

# Call as path( $workstation, $server )
sub path {
    my ( $workstation, $server, @start ) = @_;

    # initial invocation; make the ws the whole of the path
    if ( !@start ) {
        return path( $workstation, $server, $workstation );
    }

    my $last_hop = $start[ -1 ];

    # found the server; we're done!
    if ( $last_hop eq $server ) {
        return @start;
    }

    # for every possible next hop,
    NEXT_HOP:
    foreach my $next_hop ( get_next_hops( $last_hop ) ) {
        # if it's already in our path somewhere, skip it.
        foreach my $previous_hop ( @start ) {
            next NEXT_HOP if ( $previous_hop eq $next_hop );
        }
        # look for a path with this as the next hop
        my @out = path( $workstation, $server, @start, $next_hop );

        # if a path was found, return it
        return @out if @out;
    }

    # dead end
    return ();
}
[download]

There's probably a module to do this better, but I don't know what it is. The above may not be as efficient as an iterative version could be. It makes no attempt to find the shortest path. get_next_hops is left to you (it has to return a list).

package Tree;

sub new {
    my $class = shift;

    my $self = { 
            'name'  => $name,
            'root'  => undef,
        };
    return bless $self, $class;
}

sub addParent {
    my $self = shift; 
    my $parent = shift;

    $self->{'parent'} = $parent;
}

sub getParent {
    my $self = shift; 
    return $self->{'parent'};
}

sub setInherits {
    my $self = shift; 
    my $inherits = shift;

    $self->{'inherits'} = $inherits;
}

sub getInherits {
    my $self = shift; 
    return $self->{'inherits'};
}

sub getRoot {
    my $self = shift;
    return $self->{"root"} if (exists $self->{"root"});


    if (defined $self->{"parent"}) {
        $self->{"root"} = $self->{"parent"}->getRoot();
    } else {
        $self->{"root"} = $self;
    }

    return $self->{"root"};
}

return "Tree";
[download]