You can't rely on the commands making it through in one piece.

Furthermore, there are recommendations to avoid using buffered IO (<SOCK>, read, eof, getline, getlines) in the docs. sysread is not buffered.

• For each socket with data available (as returned by select),
  • Read (using sysread) from the socket.
  • If sysread returned undef,
    • Remove socket from the select object.
    • Handle error socket.
  • If sysread returned zero,
    • Remove socket from the select object.
    • Handle closed socket.
  • Append to the socket's buffer the data that was read from the socket.
  • While the buffer has a full line/command in it,
    • Extract the line/command from the buffer (leaving the rest in the buffer).
    • Process the extracted line/command.

my ($r_ready, $w_ready) = IO::Select::select($r_sel, $w_sel);

foreach my $sock (@$r_ready) {
   # Create alias to the appropriate buffer.
   our $buf; local *buf = \$in_bufs{$sock};

   my $rv = sysread($sock, $buf, 4096, length($buf));

   # Read error.
   if (not defined $rv) {
      $r_sel->remove($sock);
      # ... Handle error socket ...
      next;
   }

   # Socket EOF
   if (not $rv) {
      $r_sel->remove($sock);
      # ... Handle closed socket ...
      next;
   }

   for (;;) {
      # Search for a complete command.
      my $pos = index($buf, "\x0A");
      last if $pos < 0;

      my $cmd = substr($buf, 0, $pos+1, '');
      # ... process $cmd ...
   }
}

foreach my $sock (@$w_ready) {
   # ...
}
[download]

Update: Added code.
Update: Bug fix to handle the case where multiple commands in the buffer.

hm. for this socket should be in non-blocking mode, right ?

No. The whole point of using select is to let us know when reading from the socket won't block and when writing to the socket won't block.

Unfortunately, it doesn't tell us how much we can write to it without blocking. We only know that we can write one byte without blocking. Maybe non-blocking sockets would help in the writing half. Ideally, there would be a system call that tells us how much we can write without writing. I don't know if there is one.

I was thinking of the same thing. I ran into this once, and and I believe that it was this very thing, but it was so long ago that I can't recall. I do recommend trying it, however.

--
tbone1, YAPS (Yet Another Perl Schlub)
And remember, if he succeeds, so what.
- Chick McGee

Good one,

I have modified the code to log also the $! variable. Now we wait for the error to occur again. The question remains why these partial commands are received. Sometimes it takes up to 5 seconds to receive the second part, which might indicate that TCP packets are being delayed somewhere.

Regards,
Marcel