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.

isnt the documentation supposed to lead a coder so that he can code his own. why is there need to look up examples written by others. everyone here probably has some self-respect

why is there need to look up examples written by others. everyone here probably has some self-respect

Well, the perldocs do not always show complete working code examples, especially if you are on windows. Furthermore, you didn't take that example from the perldoc, it was some "perlfect site mini-tutorial". Bi-directional sockets are tricky to make work correctly, and you may as well benefit from other people who have already solved a problem. You almost always need IO::Select with Sockets. The Perlfect tutorial should have mentioned that. If you have "self-respect", don't ask here. :-) Self-respect is another word for "ego", and a good monk is ego-less and humble.

---

I'm not really a human, but I play one on earth. Cogito ergo sum a bum

thank you zentara
the code you just posted is much more than i want
but it is very nice and i'll try to study it soon

Since you seem to be starting to learn Sockets, you may be interested in looking at these nice self-documenting code examples, which don't use high-level modules, that show how sockets really work. UNO Golden Socket examples (Scroll down to Perl ) After a few socket scripts, you will come to appreciate the higher-level-socket modules, but it's also nice to see the real thing.

---

I'm not really a human, but I play one on earth. Cogito ergo sum a bum

More information about POE "A Beginner's Introduction to POE".

Likewise, POE, as suggested by another user, will likely pose problems on Windows. At least, many of the tests, when installing, simply appear to hang. Use with caution.

POE works absolutely fine on MSWin32, especially for sockets.

For ease of installation I provide PAR::Dist installable PAR files of the latest POE at my poco-irc webpage.

Then, can you explain the hangs when running the tests (from the installation distribution on CPAN) on Win32?

It's not just for me, and I've tried it on several Perl ports, but Corion has told me the same thing in the Chatterbox.

I am on windows

I am on windows

Aha. That's the root of your problem.

Unfortunately I still have too little experience in this field to know exactly just what works and what doesn't work. I'm working on it, on and off, I'm still learning this stuff and Windows is a platform I use a lot.