added perl socket blocking where available

[spider.git] / perl / Msg.pm

diff --git a/perl/Msg.pm b/perl/Msg.pm
index ef43b0bc24618b6033aa52520a009defdae1318e..e13be8f31d90f00329ff08a628c66fa79ac5cffb 100644 (file)
--- a/perl/Msg.pm
+++ b/perl/Msg.pm
@@ -23,7 +23,7 @@ use IO::Socket;
 use DXDebug;
 use Timer;
 
-use vars qw(%rd_callbacks %wt_callbacks %er_callbacks $rd_handles $wt_handles $er_handles $now %conns $noconns $blocking_supported $cnum);
+use vars qw(%rd_callbacks %wt_callbacks %er_callbacks $rd_handles $wt_handles $er_handles $now %conns $noconns $blocking_supported $cnum $total_in $total_out);
 
 %rd_callbacks = ();
 %wt_callbacks = ();
@@ -31,6 +31,7 @@ use vars qw(%rd_callbacks %wt_callbacks %er_callbacks $rd_handles $wt_handles $e
 $rd_handles   = IO::Select->new();
 $wt_handles   = IO::Select->new();
 $er_handles   = IO::Select->new();
+$total_in = $total_out = 0;
 
 $now = time;
 
@@ -41,11 +42,9 @@ BEGIN {
         require POSIX; POSIX->import(qw(O_NONBLOCK F_SETFL F_GETFL))
     };
        if ($@ || $main::is_win) {
-#              print STDERR "POSIX Blocking *** NOT *** supported $@\n";
-               $blocking_supported = 0;
+               $blocking_supported = IO::Socket->can('blocking') ? 2 : 0;
        } else {
-               $blocking_supported = 1;
-#              print STDERR "POSIX Blocking enabled\n";
+               $blocking_supported = IO::Socket->can('blocking') ? 2 : 1;
        }
 
 
@@ -138,12 +137,8 @@ sub blocking
        return unless $blocking_supported;
 
        # Make the handle stop blocking, the Windows way.
-       if ($main::is_win) { 
-         # 126 is FIONBIO (some docs say 0x7F << 16)
-               ioctl( $_[0],
-                          0x80000000 | (4 << 16) | (ord('f') << 8) | 126,
-                          "$_[1]"
-                        );
+       if ($blocking_supported) { 
+               $_[0]->blocking($_[1]);
        } else {
                my $flags = fcntl ($_[0], F_GETFL, 0);
                if ($_[1]) {
@@ -212,8 +207,10 @@ sub connect {
        blocking($sock, 0);
        $conn->{blocking} = 0;
 
+       # does the host resolve?
        my $ip = gethostbyname($to_host);
-#      my $r = $sock->connect($to_port, $ip);
+       return undef unless $ip;
+       
        my $r = connect($sock, pack_sockaddr_in($to_port, $ip));
        return undef unless $r || _err_will_block($!);
        
@@ -226,7 +223,57 @@ sub connect {
     return $conn;
 }
 
-sub disconnect {
+sub start_program
+{
+       my ($conn, $line, $sort) = @_;
+       my $pid;
+       
+       local $^F = 10000;              # make sure it ain't closed on exec
+       my ($a, $b) = IO::Socket->socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC);
+       if ($a && $b) {
+               $a->autoflush(1);
+               $b->autoflush(1);
+               $pid = fork;
+               if (defined $pid) {
+                       if ($pid) {
+                               close $b;
+                               $conn->{sock} = $a;
+                               $conn->{csort} = $sort;
+                               $conn->{lineend} = "\cM" if $sort eq 'ax25';
+                               $conn->{pid} = $pid;
+                               if ($conn->{rproc}) {
+                                       my $callback = sub {$conn->_rcv};
+                                       Msg::set_event_handler ($a, read => $callback);
+                               }
+                               dbg("connect $conn->{cnum}: started pid: $conn->{pid} as $line") if isdbg('connect');
+                       } else {
+                               $^W = 0;
+                               dbgclose();
+                               STDIN->close;
+                               STDOUT->close;
+                               STDOUT->close;
+                               *STDIN = IO::File->new_from_fd($b, 'r') or die;
+                               *STDOUT = IO::File->new_from_fd($b, 'w') or die;
+                               *STDERR = IO::File->new_from_fd($b, 'w') or die;
+                               close $a;
+                               unless ($main::is_win) {
+                                       #                                               $SIG{HUP} = 'IGNORE';
+                                       $SIG{HUP} = $SIG{CHLD} = $SIG{TERM} = $SIG{INT} = 'DEFAULT';
+                                       alarm(0);
+                               }
+                               exec "$line" or dbg("exec '$line' failed $!");
+                       } 
+               } else {
+                       dbg("cannot fork for $line");
+               }
+       } else {
+               dbg("no socket pair $! for $line");
+       }
+       return $pid;
+}
+
+sub disconnect 
+{
     my $conn = shift;
        return if exists $conn->{disconnecting};
 
@@ -260,7 +307,6 @@ sub disconnect {
        unless ($main::is_win) {
                kill 'TERM', $conn->{pid} if exists $conn->{pid};
        }
-
 }
 
 sub send_now {
@@ -294,10 +340,10 @@ sub _send {
     # return to the event loop only after every message, or if it
     # is likely to block in the middle of a message.
 
-       if ($conn->{blocking} != $flush) {
-               blocking($sock, $flush);
-               $conn->{blocking} = $flush;
-       }
+#      if ($conn->{blocking} != $flush) {
+#              blocking($sock, $flush);
+#              $conn->{blocking} = $flush;
+#      }
     my $offset = (exists $conn->{send_offset}) ? $conn->{send_offset} : 0;
 
     while (@$rq) {
@@ -326,6 +372,7 @@ sub _send {
                                my $call = $conn->{call} || 'none';
                                dbgdump('raw', "$call send $bytes_written: ", $msg);
                        }
+                       $total_out      += $bytes_written;
             $offset         += $bytes_written;
             $bytes_to_write -= $bytes_written;
         }
@@ -451,6 +498,7 @@ sub _rcv {                     # Complement to _send
        $bytes_read = sysread ($sock, $msg, 1024, 0);
        if (defined ($bytes_read)) {
                if ($bytes_read > 0) {
+                       $total_in += $bytes_read;
                        if (isdbg('raw')) {
                                my $call = $conn->{call} || 'none';
                                dbgdump('raw', "$call read $bytes_read: ", $msg);