[BACK]Return to lonc CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom

Diff for /loncom/Attic/lonc between versions 1.1 and 1.30

version 1.1, 1999/10/13 17:48:51 version 1.30, 2002/02/25 20:43:15
Line 5 Line 5
 # provides persistent TCP connections to the other servers in the network  # provides persistent TCP connections to the other servers in the network
 # through multiplexed domain sockets  # through multiplexed domain sockets
 #  #
   # $Id$
   #
   # Copyright Michigan State University Board of Trustees
   #
   # This file is part of the LearningOnline Network with CAPA (LON-CAPA).
   #
   # LON-CAPA is free software; you can redistribute it and/or modify
   # it under the terms of the GNU General Public License as published by
   # the Free Software Foundation; either version 2 of the License, or
   # (at your option) any later version.
   #
   # LON-CAPA is distributed in the hope that it will be useful,
   # but WITHOUT ANY WARRANTY; without even the implied warranty of
   # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   # GNU General Public License for more details.
   #
   # You should have received a copy of the GNU General Public License
   # along with LON-CAPA; if not, write to the Free Software
   # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   #
   # /home/httpd/html/adm/gpl.txt
   #
   # http://www.lon-capa.org/
   #
 # PID in subdir logs/lonc.pid  # PID in subdir logs/lonc.pid
 # kill kills  # kill kills
 # HUP restarts  # HUP restarts
 # USR1 tries to open connections again  # USR1 tries to open connections again
   
 # 6/4/99,6/5,6/7,6/8,6/9,6/10,6/11,6/12,7/14,7/19,10/8,10/9 Gerd Kortemeyer   # 6/4/99,6/5,6/7,6/8,6/9,6/10,6/11,6/12,7/14,7/19,
   # 10/8,10/9,10/15,11/18,12/22,
   # 2/8,7/25 Gerd Kortemeyer
   # 12/05 Scott Harrison
   # 12/05 Gerd Kortemeyer
   # YEAR=2001
   # 01/10/01 Scott Harrison
   # 03/14/01,03/15,06/12,11/26,11/27,11/28 Gerd Kortemeyer
   # 12/20 Scott Harrison
   # YEAR=2002
   # 2/19/02,02/22/02,02/25/02 Gerd Kortemeyer
   # 
 # based on nonforker from Perl Cookbook  # based on nonforker from Perl Cookbook
 # - server who multiplexes without forking  # - server who multiplexes without forking
   
Line 22  use Socket; Line 57  use Socket;
 use Fcntl;  use Fcntl;
 use Tie::RefHash;  use Tie::RefHash;
 use Crypt::IDEA;  use Crypt::IDEA;
   use Net::Ping;
   use LWP::UserAgent();
   
 # ------------------------------------ Read httpd access.conf and get variables  $status='';
   $lastlog='';
   $conserver='SHELL';
   
   # -------------------------------- Set signal handlers to record abnormal exits
   
   &status("Init exception handlers");
   $SIG{QUIT}=\&catchexception;
   $SIG{__DIE__}=\&catchexception;
   
   # ------------------------------------ Read httpd access.conf and get variables
   &status("Read access.conf");
 open (CONFIG,"/etc/httpd/conf/access.conf") || die "Can't read access.conf";  open (CONFIG,"/etc/httpd/conf/access.conf") || die "Can't read access.conf";
   
 while ($configline=<CONFIG>) {  while ($configline=<CONFIG>) {
     if ($configline =~ /PerlSetVar/) {      if ($configline =~ /PerlSetVar/) {
  my ($dummy,$varname,$varvalue)=split(/\s+/,$configline);   my ($dummy,$varname,$varvalue)=split(/\s+/,$configline);
           chomp($varvalue);
         $perlvar{$varname}=$varvalue;          $perlvar{$varname}=$varvalue;
     }      }
 }  }
 close(CONFIG);  close(CONFIG);
   
   # ----------------------------- Make sure this process is running from user=www
   &status("Check user ID");
   my $wwwid=getpwnam('www');
   if ($wwwid!=$<) {
      $emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}";
      $subj="LON: $perlvar{'lonHostID'} User ID mismatch";
      system("echo 'User ID mismatch.  lonc must be run as user www.' |\
    mailto $emailto -s '$subj' > /dev/null");
      exit 1;
   }
   
   # --------------------------------------------- Check if other instance running
   
   my $pidfile="$perlvar{'lonDaemons'}/logs/lonc.pid";
   
   if (-e $pidfile) {
      my $lfh=IO::File->new("$pidfile");
      my $pide=<$lfh>;
      chomp($pide);
      if (kill 0 => $pide) { die "already running"; }
   }
   
 # ------------------------------------------------------------- Read hosts file  # ------------------------------------------------------------- Read hosts file
   
 open (CONFIG,"$perlvar{'lonTabDir'}/hosts.tab") || die "Can't read host file";  open (CONFIG,"$perlvar{'lonTabDir'}/hosts.tab") || die "Can't read host file";
Line 42  open (CONFIG,"$perlvar{'lonTabDir'}/host Line 112  open (CONFIG,"$perlvar{'lonTabDir'}/host
 while ($configline=<CONFIG>) {  while ($configline=<CONFIG>) {
     my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);      my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);
     chomp($ip);      chomp($ip);
     $hostip{$id}=$ip;      if ($ip) {
        $hostip{$id}=$ip;
        $hostname{$id}=$name;
       }
 }  }
   
 close(CONFIG);  close(CONFIG);
   
 # -------------------------------------------------------- Routines for forking  # -------------------------------------------------------- Routines for forking
Line 55  close(CONFIG); Line 129  close(CONFIG);
 %childatt               = ();       # number of attempts to start server  %childatt               = ();       # number of attempts to start server
                                     # for ID                                      # for ID
   
 sub REAPER {                        # takes care of dead children  $childmaxattempts=5;
     $SIG{CHLD} = \&REAPER;  
     my $pid = wait;  
     my $wasserver=$children{$pid};  
     &logthis("Child $pid for server $wasserver died");  
     delete $children{$pid};  
     delete $childpid{$wasserver};  
     my $port = "$perlvar{'lonSockDir'}/$wasserver";  
     unlink($port);  
 }  
   
 sub HUNTSMAN {                      # signal handler for SIGINT  
     local($SIG{CHLD}) = 'IGNORE';   # we're going to kill our children  
     kill 'INT' => keys %children;  
     my $execdir=$perlvar{'lonDaemons'};  
     unlink("$execdir/logs/lonc.pid");  
     &logthis("Shutting down");  
     exit;                           # clean up with dignity  
 }  
   
 sub HUPSMAN {                      # signal handler for SIGHUP  
     local($SIG{CHLD}) = 'IGNORE';  # we're going to kill our children  
     kill 'INT' => keys %children;  
     &logthis("Restarting");  
     my $execdir=$perlvar{'lonDaemons'};  
     exec("$execdir/lonc");         # here we go again  
 }  
   
 sub USRMAN {  
     %childatt=();  
     &logthis("USR1: Trying to establish connections again");  
     foreach $thisserver (keys %hostip) {  
  $answer=subreply("ping",$thisserver);  
         &logthis(  
           "USR1: Ping $thisserver (pid >$childpid{$thisserver}<): >$answer<");  
     }  
 }  
   
 # -------------------------------------------------- Non-critical communication  
 sub subreply {   
  my ($cmd,$server)=@_;  
  if ($server ne $perlvar{'lonHostID'}) {   
     my $peerfile="$perlvar{'lonSockDir'}/$server";  
     my $sclient=IO::Socket::UNIX->new(Peer    =>"$peerfile",  
                                       Type    => SOCK_STREAM,  
                                       Timeout => 10)  
        or return "con_lost";  
     print $sclient "$cmd\n";  
     my $answer=<$sclient>;  
     chomp($answer);  
     if (!$answer) { $answer="con_lost"; }  
  } else { $answer='self_reply'; }  
  return $answer;  
 }  
   
 # --------------------------------------------------------------------- Logging  
   
 sub logthis {  
     my $message=shift;  
     my $execdir=$perlvar{'lonDaemons'};  
     my $fh=IO::File->new(">>$execdir/logs/lonc.log");  
     my $now=time;  
     my $local=localtime($now);  
     print $fh "$local ($$): $message\n";  
 }  
   
 # ---------------------------------------------------- Fork once and dissociate  # ---------------------------------------------------- Fork once and dissociate
   &status("Fork and dissociate");
 $fpid=fork;  $fpid=fork;
 exit if $fpid;  exit if $fpid;
 die "Couldn't fork: $!" unless defined ($fpid);  die "Couldn't fork: $!" unless defined ($fpid);
   
 POSIX::setsid() or die "Can't start new session: $!";  POSIX::setsid() or die "Can't start new session: $!";
   
 # ------------------------------------------------------- Write our PID on disk  $conserver='PARENT';
   
   # ------------------------------------------------------- Write our PID on disk
   &status("Write PID");
 $execdir=$perlvar{'lonDaemons'};  $execdir=$perlvar{'lonDaemons'};
 open (PIDSAVE,">$execdir/logs/lonc.pid");  open (PIDSAVE,">$execdir/logs/lonc.pid");
 print PIDSAVE "$$\n";  print PIDSAVE "$$\n";
 close(PIDSAVE);  close(PIDSAVE);
 &logthis("---------- Starting ----------");  &logthis("<font color=red>CRITICAL: ---------- Starting ----------</font>");
   
 # ----------------------------- Ignore signals generated during initial startup  # ----------------------------- Ignore signals generated during initial startup
 $SIG{HUP}=$SIG{USR1}='IGNORE';  $SIG{HUP}=$SIG{USR1}='IGNORE';
Line 143  $SIG{HUP}=$SIG{USR1}='IGNORE'; Line 155  $SIG{HUP}=$SIG{USR1}='IGNORE';
           
 # Fork off our children, one for every server  # Fork off our children, one for every server
   
   &status("Forking ...");
   
 foreach $thisserver (keys %hostip) {  foreach $thisserver (keys %hostip) {
     make_new_child($thisserver);      if (&online($hostname{$thisserver})) {
          make_new_child($thisserver);
       }
 }  }
   
 &logthis("Done starting initial servers");  &logthis("Done starting initial servers");
Line 157  $SIG{USR1} = \&USRMAN; Line 173  $SIG{USR1} = \&USRMAN;
   
 # And maintain the population.  # And maintain the population.
 while (1) {  while (1) {
       &status("Sleeping");
     sleep;                          # wait for a signal (i.e., child's death)      sleep;                          # wait for a signal (i.e., child's death)
                                     # See who died and start new one                                      # See who died and start new one
       &status("Woke up");
       my $skipping='';
     foreach $thisserver (keys %hostip) {      foreach $thisserver (keys %hostip) {
         if (!$childpid{$thisserver}) {          if (!$childpid{$thisserver}) {
     if ($childatt{$thisserver}<5) {      if (($childatt{$thisserver}<$childmaxattempts) &&
                   (&online($hostname{$thisserver}))) {
          $childatt{$thisserver}++;
                  &logthis(
      "<font color=yellow>INFO: Trying to reconnect for $thisserver "
     ."($childatt{$thisserver} of $childmaxattempts attempts)</font>"); 
                make_new_child($thisserver);                 make_new_child($thisserver);
                $childatt{$thisserver}++;     } else {
     }                 $skipping.=$thisserver.' ';
              } 
                  
         }                 }       
     }      }
       if ($skipping) { 
          &logthis("<font color=blue>WARNING: Skipped $skipping</font>");
       }
 }  }
   
   
 sub make_new_child {  sub make_new_child {
         
     my $conserver=shift;      $newserver=shift;
     my $pid;      my $pid;
     my $sigset;      my $sigset;
     &logthis("Attempting to start child for server $conserver");      &logthis("Attempting to start child for server $newserver");
     # block signal for fork      # block signal for fork
     $sigset = POSIX::SigSet->new(SIGINT);      $sigset = POSIX::SigSet->new(SIGINT);
     sigprocmask(SIG_BLOCK, $sigset)      sigprocmask(SIG_BLOCK, $sigset)
Line 187  sub make_new_child { Line 216  sub make_new_child {
         # Parent records the child's birth and returns.          # Parent records the child's birth and returns.
         sigprocmask(SIG_UNBLOCK, $sigset)          sigprocmask(SIG_UNBLOCK, $sigset)
             or die "Can't unblock SIGINT for fork: $!\n";              or die "Can't unblock SIGINT for fork: $!\n";
         $children{$pid} = $conserver;          $children{$pid} = $newserver;
         $childpid{$conserver} = $pid;          $childpid{$conserver} = $pid;
         return;          return;
     } else {      } else {
           $conserver=$newserver;
         # Child can *not* return from this subroutine.          # Child can *not* return from this subroutine.
         $SIG{INT} = 'DEFAULT';      # make SIGINT kill us as it did before          $SIG{INT} = 'DEFAULT';      # make SIGINT kill us as it did before
               $SIG{USR1}= \&logstatus;
      
         # unblock signals          # unblock signals
         sigprocmask(SIG_UNBLOCK, $sigset)          sigprocmask(SIG_UNBLOCK, $sigset)
             or die "Can't unblock SIGINT for fork: $!\n";              or die "Can't unblock SIGINT for fork: $!\n";
Line 203  sub make_new_child { Line 234  sub make_new_child {
 $port = "$perlvar{'lonSockDir'}/$conserver";  $port = "$perlvar{'lonSockDir'}/$conserver";
   
 unlink($port);  unlink($port);
 # ---------------------------------------------------- Client to network server  
 unless (  
   $remotesock = IO::Socket::INET->new(PeerAddr => $hostip{$conserver},  
                                       PeerPort => $perlvar{'londPort'},  
                                       Proto    => "tcp",  
                                       Type     => SOCK_STREAM)  
    ) { &logthis("Couldn't connect $conserver: $@");  
        sleep(5);  
        exit;   
      };  
 # --------------------------------------- Send a ping to make other end do USR1  
 print $remotesock "ping\n";  
 $answer=<$remotesock>;  
 chomp($answer);  
 &logthis("Ping reply for $conserver: >$answer<");  
 sleep 5;  
 print $remotesock "pong\n";  
 $answer=<$remotesock>;  
 chomp($answer);  
 &logthis("Pong reply for $conserver: >$answer<");  
 # ----------------------------------------------------------- Initialize cipher  
   
 print $remotesock "ekey\n";  # -------------------------------------------------------------- Open other end
 my $buildkey=<$remotesock>;  
 my $key=$conserver.$perlvar{'lonHostID'};  
 $key=~tr/a-z/A-Z/;  
 $key=~tr/G-P/0-9/;  
 $key=~tr/Q-Z/0-9/;  
 $key=$key.$buildkey.$key.$buildkey.$key.$buildkey;  
 $key=substr($key,0,32);  
 my $cipherkey=pack("H32",$key);  
 if ($cipher=new IDEA $cipherkey) {  
    &logthis("Secure connection inititalized: $conserver");  
 } else {  
    &logthis("Error: Could not establish secure connection, $conserver!");  
 }  
   
   &openremote($conserver);
   
   # ----------------------------------------- We're online, send delayed messages
       &status("Checking for delayed messages");
       my @allbuffered;
       my $path="$perlvar{'lonSockDir'}/delayed";
       opendir(DIRHANDLE,$path);
       @allbuffered=grep /\.$conserver$/, readdir DIRHANDLE;
       closedir(DIRHANDLE);
       my $dfname;
       foreach (@allbuffered) {
           &status("Sending delayed: $_");
           $dfname="$path/$_";
           &logthis('Sending '.$dfname);
           my $wcmd;
           {
            my $dfh=IO::File->new($dfname);
            $cmd=<$dfh>;
           }
           chomp($cmd);
           my $bcmd=$cmd;
           if ($cmd =~ /^encrypt\:/) {
       my $rcmd=$cmd;
               $rcmd =~ s/^encrypt\://;
               chomp($rcmd);
               my $cmdlength=length($rcmd);
               $rcmd.="         ";
               my $encrequest='';
               for (my $encidx=0;$encidx<=$cmdlength;$encidx+=8) {
                   $encrequest.=
                       unpack("H16",$cipher->encrypt(substr($rcmd,$encidx,8)));
               }
               $cmd="enc:$cmdlength:$encrequest\n";
           }
       $SIG{ALRM}=sub { die "timeout" };
       $SIG{__DIE__}='DEFAULT';
       eval {
           alarm(60);
           print $remotesock "$cmd\n";
           $answer=<$remotesock>;
    chomp($answer);
           alarm(0);
       };
       $SIG{ALRM}='DEFAULT';
       $SIG{__DIE__}=\&catchexception;
   
           if (($answer ne '') && ($@!~/timeout/)) {
       unlink("$dfname");
               &logthis("Delayed $cmd: >$answer<");
               &logperm("S:$conserver:$bcmd");
           }        
       }
   
 # ------------------------------------------------------- Listen to UNIX socket  # ------------------------------------------------------- Listen to UNIX socket
   &status("Opening socket");
 unless (  unless (
   $server = IO::Socket::UNIX->new(Local  => $port,    $server = IO::Socket::UNIX->new(Local  => $port,
                                   Type   => SOCK_STREAM,                                    Type   => SOCK_STREAM,
                                   Listen => 10 )                                    Listen => 10 )
    ) { &logthis("Can't make server socket $conserver: $@");     ) { 
        sleep(5);         my $st=120+int(rand(240));
          &logthis(
            "<font color=blue>WARNING: ".
            "Can't make server socket ($st secs): $@</font>");
          sleep($st);
        exit;          exit; 
      };       };
   
 # -----------------------------------------------------------------------------  # -----------------------------------------------------------------------------
   
   &logthis("<font color=green>$conserver online</font>");
   
   # -----------------------------------------------------------------------------
 # begin with empty buffers  # begin with empty buffers
 %inbuffer  = ();  %inbuffer  = ();
 %outbuffer = ();  %outbuffer = ();
Line 272  while (1) { Line 329  while (1) {
     # check for new information on the connections we have      # check for new information on the connections we have
   
     # anything to read or accept?      # anything to read or accept?
     foreach $client ($select->can_read(1)) {      foreach $client ($select->can_read(0.1)) {
   
         if ($client == $server) {          if ($client == $server) {
             # accept a new connection              # accept a new connection
               &status("Accept new connection: $conserver");
             $client = $server->accept();              $client = $server->accept();
             $select->add($client);              $select->add($client);
             nonblock($client);              nonblock($client);
Line 291  while (1) { Line 348  while (1) {
                 delete $outbuffer{$client};                  delete $outbuffer{$client};
                 delete $ready{$client};                  delete $ready{$client};
   
                   &status("Idle");
                 $select->remove($client);                  $select->remove($client);
                 close $client;                  close $client;
                 next;                  next;
Line 319  while (1) { Line 377  while (1) {
         next unless exists $outbuffer{$client};          next unless exists $outbuffer{$client};
   
         $rv = $client->send($outbuffer{$client}, 0);          $rv = $client->send($outbuffer{$client}, 0);
   
         unless ($outbuffer{$client} eq "con_lost\n") {
         unless (defined $rv) {          unless (defined $rv) {
             # Whine, but move on.              # Whine, but move on.
             warn "I was told I could write, but I can't.\n";              &logthis("I was told I could write, but I can't.\n");
             next;              next;
         }          }
           $errno=$!;
         if (($rv == length $outbuffer{$client}) ||          if (($rv == length $outbuffer{$client}) ||
             ($! == POSIX::EWOULDBLOCK)) {              ($errno == POSIX::EWOULDBLOCK) || ($errno == 0)) {
             substr($outbuffer{$client}, 0, $rv) = '';              substr($outbuffer{$client}, 0, $rv) = '';
             delete $outbuffer{$client} unless length $outbuffer{$client};              delete $outbuffer{$client} unless length $outbuffer{$client};
         } else {          } else {
             # Couldn't write all the data, and it wasn't because              # Couldn't write all the data, and it wasn't because
             # it would have blocked.  Shutdown and move on.              # it would have blocked.  Shutdown and move on.
   
       &logthis("Dropping data with ".$errno.": ".
                        length($outbuffer{$client}).", $rv");
   
             delete $inbuffer{$client};              delete $inbuffer{$client};
             delete $outbuffer{$client};              delete $outbuffer{$client};
             delete $ready{$client};              delete $ready{$client};
Line 339  while (1) { Line 404  while (1) {
             close($client);              close($client);
             next;              next;
         }          }
         } else {
   # -------------------------------------------------------- Wow, connection lost
            &logthis(
        "<font color=red>CRITICAL: Closing connection</font>");
    &status("Connection lost");
            $remotesock->shutdown(2);
            &logthis("Attempting to open new connection");
            &openremote($conserver);          
         }
     }      }
      
 }  }
 }  }
   
Line 356  sub handle { Line 431  sub handle {
 # ============================================================= Process request  # ============================================================= Process request
         # $request is the text of the request          # $request is the text of the request
         # put text of reply into $outbuffer{$client}          # put text of reply into $outbuffer{$client}
   # ------------------------------------------------------------ Is this the end?
           if ($request eq "close_connection_exit\n") {
       &status("Request close connection");
              &logthis(
        "<font color=red>CRITICAL: Request Close Connection</font>");
              $remotesock->shutdown(2);
              $server->close();
              exit;
           }
 # -----------------------------------------------------------------------------  # -----------------------------------------------------------------------------
         if ($request =~ /^encrypt\:/) {          if ($request =~ /^encrypt\:/) {
     my $cmd=$request;      my $cmd=$request;
Line 370  sub handle { Line 454  sub handle {
             }              }
             $request="enc:$cmdlength:$encrequest\n";              $request="enc:$cmdlength:$encrequest\n";
         }          }
   # --------------------------------------------------------------- Main exchange
       $SIG{ALRM}=sub { die "timeout" };
       $SIG{__DIE__}='DEFAULT';
       eval {
           alarm(300);
           &status("Sending: $request");
         print $remotesock "$request";          print $remotesock "$request";
           &status("Waiting for reply from $conserver: $request");
         $answer=<$remotesock>;          $answer=<$remotesock>;
           &status("Received reply: $request");
           alarm(0);
       };
       if ($@=~/timeout/) { 
          $answer='';
          &logthis(
           "<font color=red>CRITICAL: Timeout: $request</font>");
       }  
       $SIG{ALRM}='DEFAULT';
       $SIG{__DIE__}=\&catchexception;
   
   
         if ($answer) {          if ($answer) {
    if ($answer =~ /^enc/) {     if ($answer =~ /^enc/) {
                my ($cmd,$cmdlength,$encinput)=split(/:/,$answer);                 my ($cmd,$cmdlength,$encinput)=split(/:/,$answer);
Line 390  sub handle { Line 493  sub handle {
            $outbuffer{$client} .= "con_lost\n";             $outbuffer{$client} .= "con_lost\n";
         }          }
   
        &status("Completed: $request");
   
 # ===================================================== Done processing request  # ===================================================== Done processing request
     }      }
     delete $ready{$client};      delete $ready{$client};
Line 411  sub nonblock { Line 516  sub nonblock {
 }  }
   
   
   sub openremote {
   # ---------------------------------------------------- Client to network server
   
       my $conserver=shift;
   
   &status("Opening TCP");
   
   unless (
     $remotesock = IO::Socket::INET->new(PeerAddr => $hostip{$conserver},
                                         PeerPort => $perlvar{'londPort'},
                                         Proto    => "tcp",
                                         Type     => SOCK_STREAM)
      ) { 
          my $st=120+int(rand(240));
          &logthis(
   "<font color=blue>WARNING: Couldn't connect ($st secs): $@</font>");
          sleep($st);
          exit; 
        };
   # ----------------------------------------------------------------- Init dialog
   
   &status("Init dialogue: $conserver");
   
        $SIG{ALRM}=sub { die "timeout" };
        $SIG{__DIE__}='DEFAULT';
        eval {
            alarm(60);
   print $remotesock "init\n";
   $answer=<$remotesock>;
   print $remotesock "$answer";
   $answer=<$remotesock>;
   chomp($answer);
             alarm(0);
        };
        $SIG{ALRM}='DEFAULT';
        $SIG{__DIE__}=\&catchexception;
    
        if ($@=~/timeout/) {
    &logthis("Timed out during init");
            exit;
        }
   
   if ($answer ne 'ok') {
          &logthis("Init reply: >$answer<");
          my $st=120+int(rand(240));
          &logthis(
   "<font color=blue>WARNING: Init failed ($st secs)</font>");
          sleep($st);
          exit; 
   }
   
   sleep 5;
   &status("Ponging");
   print $remotesock "pong\n";
   $answer=<$remotesock>;
   chomp($answer);
   if ($answer!~/^$conserver/) {
      &logthis("Pong reply: >$answer<");
   }
   # ----------------------------------------------------------- Initialize cipher
   
   &status("Initialize cipher");
   print $remotesock "ekey\n";
   my $buildkey=<$remotesock>;
   my $key=$conserver.$perlvar{'lonHostID'};
   $key=~tr/a-z/A-Z/;
   $key=~tr/G-P/0-9/;
   $key=~tr/Q-Z/0-9/;
   $key=$key.$buildkey.$key.$buildkey.$key.$buildkey;
   $key=substr($key,0,32);
   my $cipherkey=pack("H32",$key);
   if ($cipher=new IDEA $cipherkey) {
      &logthis("Secure connection initialized");
   } else {
      my $st=120+int(rand(240));
      &logthis(
        "<font color=blue>WARNING: ".
        "Could not establish secure connection ($st secs)!</font>");
      sleep($st);
      exit;
   }
   
   }
   
   
   
   # grabs exception and records it to log before exiting
   sub catchexception {
       my ($signal)=@_;
       $SIG{QUIT}='DEFAULT';
       $SIG{__DIE__}='DEFAULT';
       chomp($signal);
       &logthis("<font color=red>CRITICAL: "
        ."ABNORMAL EXIT. Child $$ for server [$wasserver] died through "
        ."\"$signal\" with parameter [$@]</font>");
       die($@);
   }
   
   # -------------------------------------- Routines to see if other box available
   
   sub online {
       my $host=shift;
       &status("Pinging ".$host);
       my $p=Net::Ping->new("tcp",20);
       my $online=$p->ping("$host");
       $p->close();
       undef ($p);
       return $online;
   }
   
   sub connected {
       my ($local,$remote)=@_;
       &status("Checking connection $local to $remote");
       $local=~s/\W//g;
       $remote=~s/\W//g;
   
       unless ($hostname{$local}) { return 'local_unknown'; }
       unless ($hostname{$remote}) { return 'remote_unknown'; }
   
       unless (&online($hostname{$local})) { return 'local_offline'; }
   
       my $ua=new LWP::UserAgent;
       
       my $request=new HTTP::Request('GET',
         "http://".$hostname{$local}.'/cgi-bin/ping.pl?'.$remote);
   
       my $response=$ua->request($request);
   
       unless ($response->is_success) { return 'local_error'; }
   
       my $reply=$response->content;
       $reply=(split("\n",$reply))[0];
       $reply=~s/\W//g;
       if ($reply ne $remote) { return $reply; }
       return 'ok';
   }
   
   
   sub REAPER {                        # takes care of dead children
       $SIG{CHLD} = \&REAPER;
       my $pid = wait;
       my $wasserver=$children{$pid};
       &logthis("<font color=red>CRITICAL: "
        ."Child $pid for server $wasserver died ($childatt{$wasserver})</font>");
       delete $children{$pid};
       delete $childpid{$wasserver};
       my $port = "$perlvar{'lonSockDir'}/$wasserver";
       unlink($port);
   }
   
   sub hangup {
       foreach (keys %children) {
           $wasserver=$children{$_};
           &status("Closing $wasserver");
           &logthis('Closing '.$wasserver.': '.&subreply('exit',$wasserver));
           &status("Kill PID $_ for $wasserver");
    kill ('INT',$_);
       }
   }
   
   sub HUNTSMAN {                      # signal handler for SIGINT
       local($SIG{CHLD}) = 'IGNORE';   # we're going to kill our children
       &hangup();
       my $execdir=$perlvar{'lonDaemons'};
       unlink("$execdir/logs/lonc.pid");
       &logthis("<font color=red>CRITICAL: Shutting down</font>");
       exit;                           # clean up with dignity
   }
   
   sub HUPSMAN {                      # signal handler for SIGHUP
       local($SIG{CHLD}) = 'IGNORE';  # we're going to kill our children
       &hangup();
       &logthis("<font color=red>CRITICAL: Restarting</font>");
       unlink("$execdir/logs/lonc.pid");
       my $execdir=$perlvar{'lonDaemons'};
       exec("$execdir/lonc");         # here we go again
   }
   
   sub checkchildren {
       &initnewstatus();
       &logstatus();
       &logthis('Going to check on the children');
       foreach (sort keys %children) {
    sleep 1;
           unless (kill 'USR1' => $_) {
       &logthis ('<font color=red>CRITICAL: Child '.$_.' is dead</font>');
               &logstatus($$.' is dead');
           } 
       }
   }
   
   sub USRMAN {
       &logthis("USR1: Trying to establish connections again");
       %childatt=();
       &checkchildren();
   }
   
   # -------------------------------------------------- Non-critical communication
   sub subreply { 
    my ($cmd,$server)=@_;
    my $answer='';
    if ($server ne $perlvar{'lonHostID'}) { 
       my $peerfile="$perlvar{'lonSockDir'}/$server";
       my $sclient=IO::Socket::UNIX->new(Peer    =>"$peerfile",
                                         Type    => SOCK_STREAM,
                                         Timeout => 10)
          or return "con_lost";
   
   
       $SIG{ALRM}=sub { die "timeout" };
       $SIG{__DIE__}='DEFAULT';
       eval {
        alarm(10);
        print $sclient "$cmd\n";
        $answer=<$sclient>;
        chomp($answer);
        alarm(0);
       };
       if ((!$answer) || ($@=~/timeout/)) { $answer="con_lost"; }
       $SIG{ALRM}='DEFAULT';
       $SIG{__DIE__}=\&catchexception;
    } else { $answer='self_reply'; }
    return $answer;
   }
   
   # --------------------------------------------------------------------- Logging
   
   sub logthis {
       my $message=shift;
       my $execdir=$perlvar{'lonDaemons'};
       my $fh=IO::File->new(">>$execdir/logs/lonc.log");
       my $now=time;
       my $local=localtime($now);
       $lastlog=$local.': '.$message;
       print $fh "$local ($$) [$conserver] [$status]: $message\n";
   }
   
   
   sub logperm {
       my $message=shift;
       my $execdir=$perlvar{'lonDaemons'};
       my $now=time;
       my $local=localtime($now);
       my $fh=IO::File->new(">>$execdir/logs/lonnet.perm.log");
       print $fh "$now:$message:$local\n";
   }
   # ------------------------------------------------------------------ Log status
   
   sub logstatus {
       my $docdir=$perlvar{'lonDocRoot'};
       my $fh=IO::File->new(">>$docdir/lon-status/loncstatus.txt");
       print $fh $$."\t".$conserver."\t".$status."\t".$lastlog."\n";
   }
   
   sub initnewstatus {
       my $docdir=$perlvar{'lonDocRoot'};
       my $fh=IO::File->new(">$docdir/lon-status/loncstatus.txt");
       my $now=time;
       my $local=localtime($now);
       print $fh "LONC status $local - parent $$\n\n";
   }
   
   # -------------------------------------------------------------- Status setting
   
   sub status {
       my $what=shift;
       my $now=time;
       my $local=localtime($now);
       $status=$local.': '.$what;
   }
   
   
   
   # ----------------------------------- POD (plain old documentation, CPAN style)
   
   =head1 NAME
   
   lonc - LON TCP-MySQL-Server Daemon for handling database requests.
   
   =head1 SYNOPSIS
   
   Should only be run as user=www.  This is a command-line script which
   is invoked by loncron.
   
   =head1 DESCRIPTION
   
   Provides persistent TCP connections to the other servers in the network
   through multiplexed domain sockets
   
    PID in subdir logs/lonc.pid
    kill kills
    HUP restarts
    USR1 tries to open connections again
   
   =head1 README
   
   Not yet written.
   
   =head1 PREREQUISITES
   
   POSIX
   IO::Socket
   IO::Select
   IO::File
   Socket
   Fcntl
   Tie::RefHash
   Crypt::IDEA
   
   =head1 COREQUISITES
   
   =head1 OSNAMES
   
   linux
   
   =head1 SCRIPT CATEGORIES
   
   Server/Process
   
   =cut
Removed from v.1.1  
changed lines
  Added in v.1.30

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
500 Internal Server Error

Internal Server Error

The server encountered an internal error or misconfiguration and was unable to complete your request.

Please contact the server administrator at root@localhost to inform them of the time this error occurred, and the actions you performed just before this error.

More information about this error may be available in the server error log.