Look at the perldoc for IO::Socket, for the send and recv methods. In a simple single process socket communication scheme, you need to setup a protocol telling the respective sockets when to go into send mode or recv mode. If you don't do this correctly, they will block each other. It's sort of like the old 2-way radio, where you needed to say "over", to signal the other end that you were stopping sending, and going into receive mode.

Usually a better method is to have forking or threading servers, and clients, that setup 2 socket pairs, one going one way and the other going back. Google for "perl forking chat" , etc.

But here are is a simple example of an echoing server client pair that goes both ways. It can get more complex where you can have the server accpet input on it's stdin and send to all, or just 1 of the clients. You just need to keep track of the sockets, and which belongs to who.

####### SERVER:

#!/usr/bin/perl
use IO::Socket;
use IO::Select;

my @sockets;
my $machine_addr = '192.168.0.9';
$main_sock = new IO::Socket::INET(LocalAddr=>$machine_addr,
      LocalPort=>1200,
      Proto=>'tcp',
      Listen=>3,
            Reuse=>1,
            );

die "Could not connect: $!" unless $main_sock;
print "Starting Server\n";

$readable_handles = new IO::Select();
$readable_handles->add($main_sock);

while (1)
{
  ($new_readable) = IO::Select->select($readable_handles, undef, undef
+, 0);

  foreach $sock (@$new_readable)
  {
    if ($sock == $main_sock)
    {
      $new_sock = $sock->accept();
      $readable_handles->add($new_sock);
    }
    else
    {
      $buf = <$sock>;
      if ($buf)
      { 
        print "$buf\n";
        my @sockets = $readable_handles->can_write();
    #print $sock "You sent $buf\n";
    foreach my $sck(@sockets){print $sck "$buf\n";}
        
      }
      else
      {
        $readable_handles->remove($sock);
        close($sock);
      }
    }
  }

}
print "Terminating Server\n";
close $main_sock;
getc();
[download]

##### Bi-directional client #######################

#!/usr/bin/perl -w
use strict;
use IO::Socket;

my ( $host, $port, $kidpid, $handle, $line );

( $host, $port ) = ('192.168.0.9',1200);

my $name = shift || '';
if($name eq ''){print "What's your name?\n"}
chomp ($name = <>);


# create a tcp connection to the specified host and port
$handle = IO::Socket::INET->new(
    Proto    => "tcp",
    PeerAddr => $host,
    PeerPort => $port
  )
  or die "can't connect to port $port on $host: $!";
$handle->autoflush(1);    # so output gets there right away
print STDERR "[Connected to $host:$port]\n";

# split the program into two processes, identical twins
die "can't fork: $!" unless defined( $kidpid = fork() );

# the if{} block runs only in the parent process
if ($kidpid) {

    # copy the socket to standard output
    while ( defined( $line = <$handle> ) ) {
                      print STDOUT $line;
                      }
    kill( "TERM", $kidpid );    # send SIGTERM to child
}

# the else{} block runs only in the child process
else {

    # copy standard input to the socket
    while ( defined( $line = <STDIN> ) ) {
        print $handle "$name->$line";
    }
}
[download]

There are numerous examples on groups.google.com, just get out there, and dig them out.