Annotation of nsdl/bin/gatewayc, revision 1.1
1.1 ! harris41 1: #!/usr/bin/perl
! 2:
! 3: # gatewayc - LONCAPA-NSDL Gateway TCP-Client Domain-Socket-Server
! 4: # provides persistent TCP connections to the LON-CAPA servers in the network
! 5: # through multiplexed domain sockets
! 6: #
! 7: # $Id$
! 8:
! 9: # This is derived from LON-CAPA's lonc.
! 10:
! 11: use lib '/home/httpd/lib/perl/';
! 12: use LONCAPA::Configuration;
! 13:
! 14: use POSIX;
! 15: use IO::Socket;
! 16: use IO::Select;
! 17: use IO::File;
! 18: use Socket;
! 19: use Fcntl;
! 20: use Tie::RefHash;
! 21: use Crypt::IDEA;
! 22: #use Net::Ping;
! 23: use LWP::UserAgent();
! 24:
! 25: $status='';
! 26: $lastlog='';
! 27: $conserver='SHELL';
! 28: $DEBUG = 0; # Set to 1 for annoyingly complete logs.
! 29:
! 30: # -------------------------------- Set signal handlers to record abnormal exits
! 31:
! 32: &status("Init exception handlers");
! 33: $SIG{QUIT}=\&catchexception;
! 34: $SIG{__DIE__}=\&catchexception;
! 35:
! 36: # ---------------------------------- Read loncapa_apache.conf and loncapa.conf
! 37: &status("Read loncapa_apache.conf and loncapa.conf");
! 38: my $perlvarref=LONCAPA::Configuration::read_conf('loncapa_apache.conf',
! 39: 'loncapa.conf');
! 40: my %perlvar=%{$perlvarref};
! 41: undef $perlvarref;
! 42:
! 43: # ----------------------------- Make sure this process is running from user=www
! 44: &status("Check user ID");
! 45: my $wwwid=getpwnam('www');
! 46: if ($wwwid!=$<) {
! 47: $emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}";
! 48: $subj="LON: $perlvar{'lonHostID'} User ID mismatch";
! 49: system("echo 'User ID mismatch. lonc must be run as user www.' |\
! 50: mailto $emailto -s '$subj' > /dev/null");
! 51: exit 1;
! 52: }
! 53:
! 54: # --------------------------------------------- Check if other instance running
! 55:
! 56: my $pidfile="$perlvar{'lonDaemons'}/logs/lonc.pid";
! 57:
! 58: if (-e $pidfile) {
! 59: my $lfh=IO::File->new("$pidfile");
! 60: my $pide=<$lfh>;
! 61: chomp($pide);
! 62: if (kill 0 => $pide) { die "already running"; }
! 63: }
! 64:
! 65: # ------------------------------------------------------------- Read hosts file
! 66:
! 67: open (CONFIG,"$perlvar{'lonTabDir'}/hosts.tab") || die "Can't read host file";
! 68:
! 69: while ($configline=<CONFIG>) {
! 70: my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);
! 71: chomp($ip);
! 72: if ($ip) {
! 73: $hostip{$id}=$ip;
! 74: $hostname{$id}=$name;
! 75: }
! 76: }
! 77:
! 78: close(CONFIG);
! 79:
! 80: # -------------------------------------------------------- Routines for forking
! 81:
! 82: %children = (); # keys are current child process IDs,
! 83: # values are hosts
! 84: %childpid = (); # the other way around
! 85:
! 86: %childatt = (); # number of attempts to start server
! 87: # for ID
! 88:
! 89: $childmaxattempts=5;
! 90:
! 91: # ---------------------------------------------------- Fork once and dissociate
! 92: &status("Fork and dissociate");
! 93: $fpid=fork;
! 94: exit if $fpid;
! 95: die "Couldn't fork: $!" unless defined ($fpid);
! 96:
! 97: POSIX::setsid() or die "Can't start new session: $!";
! 98:
! 99: $conserver='PARENT';
! 100:
! 101: # ------------------------------------------------------- Write our PID on disk
! 102: &status("Write PID");
! 103: $execdir=$perlvar{'lonDaemons'};
! 104: open (PIDSAVE,">$execdir/logs/lonc.pid");
! 105: print PIDSAVE "$$\n";
! 106: close(PIDSAVE);
! 107: &logthis("<font color=red>CRITICAL: ---------- Starting ----------</font>");
! 108:
! 109: # ----------------------------- Ignore signals generated during initial startup
! 110: $SIG{HUP}=$SIG{USR1}='IGNORE';
! 111: # ------------------------------------------------------- Now we are on our own
! 112:
! 113: # Fork off our children, one for every server
! 114:
! 115: &status("Forking ...");
! 116:
! 117: foreach $thisserver (keys %hostip) {
! 118: #if (&online($hostname{$thisserver})) {
! 119: make_new_child($thisserver);
! 120: #}
! 121: }
! 122:
! 123: &logthis("Done starting initial servers");
! 124: # ----------------------------------------------------- Install signal handlers
! 125:
! 126:
! 127: $SIG{INT} = $SIG{TERM} = \&HUNTSMAN;
! 128: $SIG{HUP} = \&HUPSMAN;
! 129: $SIG{USR1} = \&USRMAN;
! 130:
! 131: # And maintain the population.
! 132: while (1) {
! 133: my $deadpid = wait; # Wait for the next child to die.
! 134: # See who died and start new one
! 135: # or a signal (e.g. USR1 for restart).
! 136: # if a signal, the wait will fail
! 137: # This is ordinarily detected by
! 138: # checking for the existence of the
! 139: # pid index inthe children hash since
! 140: # the return value from a failed wait is -1
! 141: # which is an impossible PID.
! 142: &status("Woke up");
! 143: my $skipping='';
! 144:
! 145: if(exists($children{$deadpid})) {
! 146:
! 147: $thisserver = $children{$deadpid}; # Look name of dead guy's peer.
! 148:
! 149: delete($children{$deadpid}); # Get rid of dead hash entry.
! 150:
! 151: if($childatt{$thisserver} < $childmaxattempts) {
! 152: $childatt{$thisserver}++;
! 153: &logthis(
! 154: "<font color=yellow>INFO: Trying to reconnect for $thisserver "
! 155: ."($childatt{$thisserver} of $childmaxattempts attempts)</font>");
! 156: make_new_child($thisserver);
! 157:
! 158: }
! 159: else {
! 160: $skipping .= $thisserver.' ';
! 161: }
! 162: if($skipping) {
! 163: &logthis("<font color=blue>WARNING: Skipped $skipping</font>");
! 164:
! 165: }
! 166: }
! 167:
! 168: }
! 169:
! 170:
! 171:
! 172: sub make_new_child {
! 173:
! 174: $newserver=shift;
! 175: my $pid;
! 176: my $sigset;
! 177: &logthis("Attempting to start child for server $newserver");
! 178: # block signal for fork
! 179: $sigset = POSIX::SigSet->new(SIGINT);
! 180: sigprocmask(SIG_BLOCK, $sigset)
! 181: or die "Can't block SIGINT for fork: $!\n";
! 182:
! 183: die "fork: $!" unless defined ($pid = fork);
! 184:
! 185: if ($pid) {
! 186: # Parent records the child's birth and returns.
! 187: sigprocmask(SIG_UNBLOCK, $sigset)
! 188: or die "Can't unblock SIGINT for fork: $!\n";
! 189: $children{$pid} = $newserver;
! 190: $childpid{$newserver} = $pid;
! 191: return;
! 192: } else {
! 193: $conserver=$newserver;
! 194: # Child can *not* return from this subroutine.
! 195: $SIG{INT} = 'DEFAULT'; # make SIGINT kill us as it did before
! 196: $SIG{USR1}= \&logstatus;
! 197:
! 198: # unblock signals
! 199: sigprocmask(SIG_UNBLOCK, $sigset)
! 200: or die "Can't unblock SIGINT for fork: $!\n";
! 201:
! 202: # ----------------------------- This is the modified main program of non-forker
! 203:
! 204: $port = "$perlvar{'lonSockDir'}/$conserver";
! 205:
! 206: unlink($port);
! 207:
! 208: # -------------------------------------------------------------- Open other end
! 209:
! 210: &openremote($conserver);
! 211: &logthis("<font color=green> Connection to $conserver open </font>");
! 212: # ----------------------------------------- We're online, send delayed messages
! 213: &status("Checking for delayed messages");
! 214:
! 215: my @allbuffered;
! 216: my $path="$perlvar{'lonSockDir'}/delayed";
! 217: opendir(DIRHANDLE,$path);
! 218: @allbuffered=grep /\.$conserver$/, readdir DIRHANDLE;
! 219: closedir(DIRHANDLE);
! 220: my $dfname;
! 221: foreach (@allbuffered) {
! 222: &status("Sending delayed: $_");
! 223: $dfname="$path/$_";
! 224: if($DEBUG) { &logthis('Sending '.$dfname); }
! 225: my $wcmd;
! 226: {
! 227: my $dfh=IO::File->new($dfname);
! 228: $cmd=<$dfh>;
! 229: }
! 230: chomp($cmd);
! 231: my $bcmd=$cmd;
! 232: if ($cmd =~ /^encrypt\:/) {
! 233: my $rcmd=$cmd;
! 234: $rcmd =~ s/^encrypt\://;
! 235: chomp($rcmd);
! 236: my $cmdlength=length($rcmd);
! 237: $rcmd.=" ";
! 238: my $encrequest='';
! 239: for (my $encidx=0;$encidx<=$cmdlength;$encidx+=8) {
! 240: $encrequest.=
! 241: unpack("H16",$cipher->encrypt(substr($rcmd,$encidx,8)));
! 242: }
! 243: $cmd="enc:$cmdlength:$encrequest\n";
! 244: }
! 245: $answer = londtransaction($remotesock, $cmd, 60);
! 246: chomp($answer);
! 247:
! 248: if (($answer ne '') && ($@!~/timeout/)) {
! 249: unlink("$dfname");
! 250: &logthis("Delayed $cmd: >$answer<");
! 251: &logperm("S:$conserver:$bcmd");
! 252: }
! 253: }
! 254: if($DEBUG) { &logthis("<font color=green> Delayed transactions sent"); }
! 255:
! 256: # ------------------------------------------------------- Listen to UNIX socket
! 257: &status("Opening socket");
! 258: unless (
! 259: $server = IO::Socket::UNIX->new(Local => $port,
! 260: Type => SOCK_STREAM,
! 261: Listen => 10 )
! 262: ) {
! 263: my $st=120+int(rand(240));
! 264: &logthis(
! 265: "<font color=blue>WARNING: ".
! 266: "Can't make server socket ($st secs): .. exiting</font>");
! 267: sleep($st);
! 268: exit;
! 269: };
! 270:
! 271: # -----------------------------------------------------------------------------
! 272:
! 273: &logthis("<font color=green>$conserver online</font>");
! 274:
! 275: # -----------------------------------------------------------------------------
! 276: # begin with empty buffers
! 277: %inbuffer = ();
! 278: %outbuffer = ();
! 279: %ready = ();
! 280: %servers = (); # To be compatible with make filevector. indexed by
! 281: # File ids, values are sockets.
! 282: # note that the accept socket is omitted.
! 283:
! 284: tie %ready, 'Tie::RefHash';
! 285:
! 286: # nonblock($server);
! 287: # $select = IO::Select->new($server);
! 288:
! 289: # Main loop: check reads/accepts, check writes, check ready to process
! 290:
! 291: status("Main loop");
! 292: while (1) {
! 293: my $client;
! 294: my $rv;
! 295: my $data;
! 296:
! 297: my $infdset; # bit vec of fd's to select on input.
! 298:
! 299: my $outfdset; # Bit vec of fd's to select on output.
! 300:
! 301:
! 302: $infdset = MakeFileVector(\%servers);
! 303: $outfdset= MakeFileVector(\%outbuffer);
! 304: vec($infdset, $server->fileno, 1) = 1;
! 305: if($DEBUG) {
! 306: &logthis("Adding ".$server->fileno.
! 307: " to input select vector (listner)".
! 308: unpack("b*",$infdset)."\n");
! 309: }
! 310: DoSelect(\$infdset, \$outfdset); # Wait for input.
! 311: if($DEBUG) {
! 312: &logthis("Doselect completed!");
! 313: &logthis("ins = ".unpack("b*",$infdset)."\n");
! 314: &logthis("outs= ".unpack("b*",$outfdset)."\n");
! 315:
! 316: }
! 317:
! 318: # Checkfor new connections:
! 319: if (vec($infdset, $server->fileno, 1)) {
! 320: if($DEBUG) {
! 321: &logthis("New connection established");
! 322: }
! 323: # accept a new connection
! 324: &status("Accept new connection: $conserver");
! 325: $client = $server->accept();
! 326: if($DEBUG) {
! 327: &logthis("New client fd = ".$client->fileno."\n");
! 328: }
! 329: $servers{$client->fileno} = $client;
! 330: nonblock($client);
! 331: }
! 332: HandleInput($infdset, \%servers, \%inbuffer, \%outbuffer, \%ready);
! 333: HandleOutput($outfdset, \%servers, \%outbuffer, \%inbuffer,
! 334: \%ready);
! 335: # -------------------------------------------------------- Wow, connection lost
! 336:
! 337: }
! 338:
! 339: }
! 340: }
! 341:
! 342: # ------------------------------------------------------- End of make_new_child
! 343:
! 344:
! 345: #
! 346: # Make a vector of file descriptors to wait for in a select.
! 347: # parameters:
! 348: # \%fdhash -reference to a hash which has IO::Socket's as indices.
! 349: # We only care about the indices, not the values.
! 350: # A select vector is created from all indices of the hash.
! 351:
! 352: sub MakeFileVector
! 353: {
! 354: my $fdhash = shift;
! 355: my $selvar = "";
! 356:
! 357: foreach $socket (keys %$fdhash) {
! 358: if($DEBUG) {
! 359: &logthis("Adding ".$socket.
! 360: "to select vector. (client)\n");
! 361: }
! 362: vec($selvar, $socket, 1) = 1;
! 363: }
! 364: return $selvar;
! 365: }
! 366:
! 367:
! 368: #
! 369: # HandleOutput:
! 370: # Processes output on a buffered set of file descriptors which are
! 371: # ready to be read.
! 372: # Parameters:
! 373: # $selvector - Vector of file descriptors which are writable.
! 374: # \%sockets - Vector of socket references indexed by socket.
! 375: # \%buffers - Reference to a hash containing output buffers.
! 376: # Hashes are indexed by sockets. The file descriptors of some
! 377: # of those sockets will be present in $selvector.
! 378: # For each one of those, we will attempt to write the output
! 379: # buffer to the socket. Note that we will assume that
! 380: # the sockets are being run in non blocking mode.
! 381: # \%inbufs - Reference to hash containing input buffers.
! 382: # \%readys - Reference to hash containing flags for items with complete
! 383: # requests.
! 384: #
! 385: sub HandleOutput
! 386: {
! 387: my $selvector = shift;
! 388: my $sockets = shift;
! 389: my $buffers = shift;
! 390: my $inbufs = shift;
! 391: my $readys = shift;
! 392: my $sock;
! 393:
! 394: if($DEBUG) {
! 395: &logthis("HandleOutput entered\n");
! 396: }
! 397:
! 398: foreach $sock (keys %$sockets) {
! 399: my $socket = $sockets->{$sock};
! 400: if(vec($selvector, $sock, 1)) { # $socket is writable.
! 401: if($DEBUG) {
! 402: &logthis("Sending $buffers->{$sock} \n");
! 403: }
! 404: my $rv = $socket->send($buffers->{$sock}, 0);
! 405: $errno = $!;
! 406: unless ($buffers->{$sock} eq "con_lost\n") {
! 407: unless (defined $rv) { # Write failed... could be EINTR
! 408: unless ($errno == POSIX::EINTR) {
! 409: &logthis("Write failed on writable socket");
! 410: } # EINTR is not an error .. just retry.
! 411: next;
! 412: }
! 413: if( ($rv == length $buffers->{$sock}) ||
! 414: ($errno == POSIX::EWOULDBLOCK) ||
! 415: ($errno == POSIX::EAGAIN) || # same as above.
! 416: ($errno == POSIX::EINTR) || # signal during IO
! 417: ($errno == 0)) {
! 418: substr($buffers->{$sock}, 0, $rv)=""; # delete written part
! 419: delete $buffers->{$sock} unless length $buffers->{$sock};
! 420: } else {
! 421: # For some reason the write failed with an error code
! 422: # we didn't look for. Shutdown the socket.
! 423: &logthis("Unable to write data with ".$errno.": ".
! 424: "Dropping data: ".length($buffers->{$sock}).
! 425: ", $rv");
! 426: #
! 427: # kill off the buffers in the hash:
! 428:
! 429: delete $buffers->{$sock};
! 430: delete $inbufs->{$sock};
! 431: delete $readys->{$sock};
! 432:
! 433: close($socket); # Close the client socket.
! 434: next;
! 435: }
! 436: } else { # Kludgy way to mark lond connection lost.
! 437: &logthis(
! 438: "<font color=red>CRITICAL lond connection lost</font>");
! 439: status("Connection lost");
! 440: $remotesock->shutdown(2);
! 441: &logthis("Attempting to open a new connection");
! 442: &openremote($conserver);
! 443: }
! 444:
! 445: }
! 446: }
! 447:
! 448: }
! 449: #
! 450: # HandleInput - Deals with input on client sockets.
! 451: # Each socket has an associated input buffer.
! 452: # For each readable socket, the currently available
! 453: # data is appended to this buffer.
! 454: # If necessary, the buffer is created.
! 455: # On various failures, we may shutdown the client.
! 456: # Parameters:
! 457: # $selvec - Vector of readable sockets.
! 458: # \%sockets - Refers to the Hash of sockets indexed by sockets.
! 459: # Each of these may or may not have it's fd bit set
! 460: # in the $selvec.
! 461: # \%ibufs - Refers to the hash of input buffers indexed by socket.
! 462: # \%obufs - Hash of output buffers indexed by socket.
! 463: # \%ready - Hash of ready flags indicating the existence of a completed
! 464: # Request.
! 465: sub HandleInput
! 466: {
! 467:
! 468: # Marshall the parameters. Note that the hashes are actually
! 469: # references not values.
! 470:
! 471: my $selvec = shift;
! 472: my $sockets = shift;
! 473: my $ibufs = shift;
! 474: my $obufs = shift;
! 475: my $ready = shift;
! 476: my $sock;
! 477:
! 478: if($DEBUG) {
! 479: &logthis("Entered HandleInput\n");
! 480: }
! 481: foreach $sock (keys %$sockets) {
! 482: my $socket = $sockets->{$sock};
! 483: if(vec($selvec, $sock, 1)) { # Socket which is readable.
! 484:
! 485: # Attempt to read the data and do error management.
! 486: my $data = '';
! 487: my $rv = $socket->recv($data, POSIX::BUFSIZ, 0);
! 488: if($DEBUG) {
! 489: &logthis("Received $data from socket");
! 490: }
! 491: unless (defined($rv) && length $data) {
! 492:
! 493: # Read an end of file.. this is a disconnect from the peer.
! 494:
! 495: delete $sockets->{$sock};
! 496: delete $ibufs->{$sock};
! 497: delete $obufs->{$sock};
! 498: delete $ready->{$sock};
! 499:
! 500: status("Idle");
! 501: close $socket;
! 502: next;
! 503: }
! 504: # Append the read data to the input buffer. If the buffer
! 505: # now contains a \n the request is complete and we can
! 506: # mark this in the $ready hash (one request for each \n.)
! 507:
! 508: $ibufs->{$sock} .= $data;
! 509: while($ibufs->{$sock} =~ s/(.*\n)//) {
! 510: push(@{$ready->{$sock}}, $1);
! 511: }
! 512:
! 513: }
! 514: }
! 515: # Now handle any requests which are ready:
! 516:
! 517: foreach $client (keys %ready) {
! 518: handle($client);
! 519: }
! 520: }
! 521:
! 522: # DoSelect: does a select with no timeout. On signal (errno == EINTR),
! 523: # the select is retried until there are items in the returned
! 524: # vectors.
! 525: #
! 526: # Parameters:
! 527: # \$readvec - Reference to a vector of file descriptors to
! 528: # check for readability.
! 529: # \$writevec - Reference to a vector of file descriptors to check for
! 530: # writability.
! 531: # On exit, the referents are modified with vectors indicating which
! 532: # file handles are readable/writable.
! 533: #
! 534: sub DoSelect {
! 535: my $readvec = shift;
! 536: my $writevec= shift;
! 537: my $outs;
! 538: my $ins;
! 539:
! 540: while (1) {
! 541: my $nfds = select( $ins = $$readvec, $outs = $$writevec, undef, undef);
! 542: if($nfds) {
! 543: if($DEBUG) {
! 544: &logthis("select exited with ".$nfds." fds\n");
! 545: &logthis("ins = ".unpack("b*",$ins).
! 546: " readvec = ".unpack("b*",$$readvec)."\n");
! 547: &logthis("outs = ".unpack("b*",$outs).
! 548: " writevec = ".unpack("b*",$$writevec)."\n");
! 549: }
! 550: $$readvec = $ins;
! 551: $$writevec = $outs;
! 552: return;
! 553: } else {
! 554: if($DEBUG) {
! 555: &logthis("Select exited with no bits set in mask\n");
! 556: }
! 557: die "Select failed" unless $! == EINTR;
! 558: }
! 559: }
! 560: }
! 561:
! 562: # handle($socket) deals with all pending requests for $client
! 563: #
! 564: sub handle {
! 565: # requests are in $ready{$client}
! 566: # send output to $outbuffer{$client}
! 567: my $client = shift;
! 568: my $request;
! 569: foreach $request (@{$ready{$client}}) {
! 570: # ============================================================= Process request
! 571: # $request is the text of the request
! 572: # put text of reply into $outbuffer{$client}
! 573: # ------------------------------------------------------------ Is this the end?
! 574: chomp($request);
! 575: if($DEBUG) {
! 576: &logthis("<font color=green> Request $request processing starts</font>");
! 577: }
! 578: if ($request eq "close_connection_exit\n") {
! 579: &status("Request close connection");
! 580: &logthis(
! 581: "<font color=red>CRITICAL: Request Close Connection ... exiting</font>");
! 582: $remotesock->shutdown(2);
! 583: $server->close();
! 584: exit;
! 585: }
! 586: # -----------------------------------------------------------------------------
! 587: if ($request =~ /^encrypt\:/) {
! 588: my $cmd=$request;
! 589: $cmd =~ s/^encrypt\://;
! 590: chomp($cmd);
! 591: my $cmdlength=length($cmd);
! 592: $cmd.=" ";
! 593: my $encrequest='';
! 594: for (my $encidx=0;$encidx<=$cmdlength;$encidx+=8) {
! 595: $encrequest.=
! 596: unpack("H16",$cipher->encrypt(substr($cmd,$encidx,8)));
! 597: }
! 598: $request="enc:$cmdlength:$encrequest";
! 599: }
! 600: # --------------------------------------------------------------- Main exchange
! 601: $answer = londtransaction($remotesock, $request, 300);
! 602:
! 603: if($DEBUG) {
! 604: &logthis("<font color=green> Request data exchange complete");
! 605: }
! 606: if ($@=~/timeout/) {
! 607: $answer='';
! 608: &logthis(
! 609: "<font color=red>CRITICAL: Timeout: $request</font>");
! 610: }
! 611:
! 612:
! 613: if ($answer) {
! 614: if ($answer =~ /^enc/) {
! 615: my ($cmd,$cmdlength,$encinput)=split(/:/,$answer);
! 616: chomp($encinput);
! 617: $answer='';
! 618: for (my $encidx=0;$encidx<length($encinput);$encidx+=16) {
! 619: $answer.=$cipher->decrypt(
! 620: pack("H16",substr($encinput,$encidx,16))
! 621: );
! 622: }
! 623: $answer=substr($answer,0,$cmdlength);
! 624: $answer.="\n";
! 625: }
! 626: if($DEBUG) {
! 627: &logthis("sending $answer to client\n");
! 628: }
! 629: $outbuffer{$client} .= $answer;
! 630: } else {
! 631: $outbuffer{$client} .= "con_lost\n";
! 632: }
! 633:
! 634: &status("Completed: $request");
! 635: if($DEBUG) {
! 636: &logthis("<font color=green> Request processing complete</font>");
! 637: }
! 638: # ===================================================== Done processing request
! 639: }
! 640: delete $ready{$client};
! 641: # -------------------------------------------------------------- End non-forker
! 642: if($DEBUG) {
! 643: &logthis("<font color=green> requests for child handled</font>");
! 644: }
! 645: }
! 646: # ---------------------------------------------------------- End make_new_child
! 647:
! 648: # nonblock($socket) puts socket into nonblocking mode
! 649: sub nonblock {
! 650: my $socket = shift;
! 651: my $flags;
! 652:
! 653:
! 654: $flags = fcntl($socket, F_GETFL, 0)
! 655: or die "Can't get flags for socket: $!\n";
! 656: fcntl($socket, F_SETFL, $flags | O_NONBLOCK)
! 657: or die "Can't make socket nonblocking: $!\n";
! 658: }
! 659:
! 660:
! 661: sub openremote {
! 662: # ---------------------------------------------------- Client to network server
! 663:
! 664: my $conserver=shift;
! 665:
! 666: &status("Opening TCP");
! 667: my $st=120+int(rand(240)); # Sleep before opening:
! 668:
! 669: unless (
! 670: $remotesock = IO::Socket::INET->new(PeerAddr => $hostip{$conserver},
! 671: PeerPort => $perlvar{'londPort'},
! 672: Proto => "tcp",
! 673: Type => SOCK_STREAM)
! 674: ) {
! 675:
! 676: &logthis(
! 677: "<font color=blue>WARNING: Couldn't connect to $conserver ($st secs): </font>");
! 678: sleep($st);
! 679: exit;
! 680: };
! 681: # ----------------------------------------------------------------- Init dialog
! 682:
! 683: &logthis("<font color=green>INFO Connected to $conserver, initing </font>");
! 684: &status("Init dialogue: $conserver");
! 685:
! 686: $answer = londtransaction($remotesock, "init", 60);
! 687: chomp($answer);
! 688: $answer = londtransaction($remotesock, $answer, 60);
! 689: chomp($answer);
! 690:
! 691: if ($@=~/timeout/) {
! 692: &logthis("Timed out during init.. exiting");
! 693: exit;
! 694: }
! 695:
! 696: if ($answer ne 'ok') {
! 697: &logthis("Init reply: >$answer<");
! 698: my $st=120+int(rand(240));
! 699: &logthis(
! 700: "<font color=blue>WARNING: Init failed ($st secs)</font>");
! 701: sleep($st);
! 702: exit;
! 703: }
! 704:
! 705: sleep 5;
! 706: &status("Ponging");
! 707: print $remotesock "pong\n";
! 708: $answer=<$remotesock>;
! 709: chomp($answer);
! 710: if ($answer!~/^$conserver/) {
! 711: &logthis("Pong reply: >$answer<");
! 712: }
! 713: # ----------------------------------------------------------- Initialize cipher
! 714:
! 715: &status("Initialize cipher");
! 716: print $remotesock "ekey\n";
! 717: my $buildkey=<$remotesock>;
! 718: my $key=$conserver.$perlvar{'lonHostID'};
! 719: $key=~tr/a-z/A-Z/;
! 720: $key=~tr/G-P/0-9/;
! 721: $key=~tr/Q-Z/0-9/;
! 722: $key=$key.$buildkey.$key.$buildkey.$key.$buildkey;
! 723: $key=substr($key,0,32);
! 724: my $cipherkey=pack("H32",$key);
! 725: if ($cipher=new IDEA $cipherkey) {
! 726: &logthis("Secure connection initialized");
! 727: } else {
! 728: my $st=120+int(rand(240));
! 729: &logthis(
! 730: "<font color=blue>WARNING: ".
! 731: "Could not establish secure connection ($st secs)!</font>");
! 732: sleep($st);
! 733: exit;
! 734: }
! 735: &logthis("<font color=green> Remote open success </font>");
! 736: }
! 737:
! 738:
! 739:
! 740: # grabs exception and records it to log before exiting
! 741: sub catchexception {
! 742: my ($signal)=@_;
! 743: $SIG{QUIT}='DEFAULT';
! 744: $SIG{__DIE__}='DEFAULT';
! 745: chomp($signal);
! 746: &logthis("<font color=red>CRITICAL: "
! 747: ."ABNORMAL EXIT. Child $$ for server [$wasserver] died through "
! 748: ."\"$signal\" with parameter </font>");
! 749: die("Signal abend");
! 750: }
! 751:
! 752: # -------------------------------------- Routines to see if other box available
! 753:
! 754: #sub online {
! 755: # my $host=shift;
! 756: # &status("Pinging ".$host);
! 757: # my $p=Net::Ping->new("tcp",20);
! 758: # my $online=$p->ping("$host");
! 759: # $p->close();
! 760: # undef ($p);
! 761: # return $online;
! 762: #}
! 763:
! 764: sub connected {
! 765: my ($local,$remote)=@_;
! 766: &status("Checking connection $local to $remote");
! 767: $local=~s/\W//g;
! 768: $remote=~s/\W//g;
! 769:
! 770: unless ($hostname{$local}) { return 'local_unknown'; }
! 771: unless ($hostname{$remote}) { return 'remote_unknown'; }
! 772:
! 773: #unless (&online($hostname{$local})) { return 'local_offline'; }
! 774:
! 775: my $ua=new LWP::UserAgent;
! 776:
! 777: my $request=new HTTP::Request('GET',
! 778: "http://".$hostname{$local}.'/cgi-bin/ping.pl?'.$remote);
! 779:
! 780: my $response=$ua->request($request);
! 781:
! 782: unless ($response->is_success) { return 'local_error'; }
! 783:
! 784: my $reply=$response->content;
! 785: $reply=(split("\n",$reply))[0];
! 786: $reply=~s/\W//g;
! 787: if ($reply ne $remote) { return $reply; }
! 788: return 'ok';
! 789: }
! 790:
! 791:
! 792:
! 793: sub hangup {
! 794: foreach (keys %children) {
! 795: $wasserver=$children{$_};
! 796: &status("Closing $wasserver");
! 797: &logthis('Closing '.$wasserver.': '.&subreply('exit',$wasserver));
! 798: &status("Kill PID $_ for $wasserver");
! 799: kill ('INT',$_);
! 800: }
! 801: }
! 802:
! 803: sub HUNTSMAN { # signal handler for SIGINT
! 804: local($SIG{CHLD}) = 'IGNORE'; # we're going to kill our children
! 805: &hangup();
! 806: my $execdir=$perlvar{'lonDaemons'};
! 807: unlink("$execdir/logs/lonc.pid");
! 808: &logthis("<font color=red>CRITICAL: Shutting down</font>");
! 809: exit; # clean up with dignity
! 810: }
! 811:
! 812: sub HUPSMAN { # signal handler for SIGHUP
! 813: local($SIG{CHLD}) = 'IGNORE'; # we're going to kill our children
! 814: &hangup();
! 815: &logthis("<font color=red>CRITICAL: Restarting</font>");
! 816: unlink("$execdir/logs/lonc.pid");
! 817: my $execdir=$perlvar{'lonDaemons'};
! 818: exec("$execdir/lonc"); # here we go again
! 819: }
! 820:
! 821: sub checkchildren {
! 822: &initnewstatus();
! 823: &logstatus();
! 824: &logthis('Going to check on the children');
! 825: foreach (sort keys %children) {
! 826: sleep 1;
! 827: unless (kill 'USR1' => $_) {
! 828: &logthis ('<font color=red>CRITICAL: Child '.$_.' is dead</font>');
! 829: &logstatus($$.' is dead');
! 830: }
! 831: }
! 832: }
! 833:
! 834: sub USRMAN {
! 835: &logthis("USR1: Trying to establish connections again");
! 836: #
! 837: # It is really important not to just clear the childatt hash or we will
! 838: # lose all memory of the children. What we really want to do is this:
! 839: # For each index where childatt is >= $childmaxattempts
! 840: # Zero the associated counter and do a make_child for the host.
! 841: # Regardles, the childatt entry is zeroed:
! 842: my $host;
! 843: foreach $host (keys %childatt) {
! 844: if ($childatt{$host} >= $childmaxattempts) {
! 845: $childatt{$host} = 0;
! 846: &logthis("<font color=green>INFO: Restarting child for server: "
! 847: .$host."</font>\n");
! 848: make_new_child($host);
! 849: }
! 850: else {
! 851: $childatt{$host} = 0;
! 852: }
! 853: }
! 854: &checkchildren(); # See if any children are still dead...
! 855: }
! 856:
! 857: # -------------------------------------------------- Non-critical communication
! 858: sub subreply {
! 859: my ($cmd,$server)=@_;
! 860: my $answer='';
! 861: if ($server ne $perlvar{'lonHostID'}) {
! 862: my $peerfile="$perlvar{'lonSockDir'}/$server";
! 863: my $sclient=IO::Socket::UNIX->new(Peer =>"$peerfile",
! 864: Type => SOCK_STREAM,
! 865: Timeout => 10)
! 866: or return "con_lost";
! 867:
! 868:
! 869: $answer = londtransaction($sclient, $cmd, 10);
! 870:
! 871: if ((!$answer) || ($@=~/timeout/)) { $answer="con_lost"; }
! 872: $SIG{ALRM}='DEFAULT';
! 873: $SIG{__DIE__}=\&catchexception;
! 874: } else { $answer='self_reply'; }
! 875: return $answer;
! 876: }
! 877:
! 878: # --------------------------------------------------------------------- Logging
! 879:
! 880: sub logthis {
! 881: my $message=shift;
! 882: my $execdir=$perlvar{'lonDaemons'};
! 883: my $fh=IO::File->new(">>$execdir/logs/lonc.log");
! 884: my $now=time;
! 885: my $local=localtime($now);
! 886: $lastlog=$local.': '.$message;
! 887: print $fh "$local ($$) [$conserver] [$status]: $message\n";
! 888: }
! 889:
! 890: #-------------------------------------- londtransaction:
! 891: #
! 892: # Performs a transaction with lond with timeout support.
! 893: # result = londtransaction(socket,request,timeout)
! 894: #
! 895: sub londtransaction {
! 896: my ($socket, $request, $tmo) = @_;
! 897:
! 898: if($DEBUG) {
! 899: &logthis("londtransaction request: $request");
! 900: }
! 901:
! 902: # Set the signal handlers: ALRM for timeout and disble the others.
! 903:
! 904: $SIG{ALRM} = sub { die "timeout" };
! 905: $SIG{__DIE__} = 'DEFAULT';
! 906:
! 907: # Disable all but alarm so that only that can interupt the
! 908: # send /receive.
! 909: #
! 910: my $sigset = POSIX::SigSet->new(QUIT, USR1, HUP, INT, TERM);
! 911: my $priorsigs = POSIX::SigSet->new;
! 912: unless (defined sigprocmask(SIG_BLOCK, $sigset, $priorsigs)) {
! 913: &logthis("<font color=red> CRITICAL -- londtransaction ".
! 914: "failed to block signals </font>");
! 915: die "could not block signals in londtransaction";
! 916: }
! 917: $answer = '';
! 918: #
! 919: # Send request to lond.
! 920: #
! 921: eval {
! 922: alarm($tmo);
! 923: print $socket "$request\n";
! 924: alarm(0);
! 925: };
! 926: # If request didn't timeout, try for the response.
! 927: #
! 928:
! 929: if ($@!~/timeout/) {
! 930: eval {
! 931: alarm($tmo);
! 932: $answer = <$socket>;
! 933: if($DEBUG) {
! 934: &logthis("Received $answer in londtransaction");
! 935: }
! 936: alarm(0);
! 937: };
! 938: } else {
! 939: if($DEBUG) {
! 940: &logthis("Timeout on send in londtransaction");
! 941: }
! 942: }
! 943: if( ($@ =~ /timeout/) && ($DEBUG)) {
! 944: &logthis("Timeout on receive in londtransaction");
! 945: }
! 946: #
! 947: # Restore the initial sigmask set.
! 948: #
! 949: unless (defined sigprocmask(SIG_UNBLOCK, $priorsigs)) {
! 950: &logthis("<font color=red> CRITICAL -- londtransaction ".
! 951: "failed to re-enable signal processing. </font>");
! 952: die "londtransaction failed to re-enable signals";
! 953: }
! 954: #
! 955: # go back to the prior handler set.
! 956: #
! 957: $SIG{ALRM} = 'DEFAULT';
! 958: $SIG{__DIE__} = \&cathcexception;
! 959:
! 960: # chomp $answer;
! 961: if ($DEBUG) {
! 962: &logthis("Returning $answer in londtransaction");
! 963: }
! 964: return $answer;
! 965:
! 966: }
! 967:
! 968: sub logperm {
! 969: my $message=shift;
! 970: my $execdir=$perlvar{'lonDaemons'};
! 971: my $now=time;
! 972: my $local=localtime($now);
! 973: my $fh=IO::File->new(">>$execdir/logs/lonnet.perm.log");
! 974: print $fh "$now:$message:$local\n";
! 975: }
! 976: # ------------------------------------------------------------------ Log status
! 977:
! 978: sub logstatus {
! 979: my $docdir=$perlvar{'lonDocRoot'};
! 980: my $fh=IO::File->new(">>$docdir/lon-status/loncstatus.txt");
! 981: print $fh $$."\t".$conserver."\t".$status."\t".$lastlog."\n";
! 982: }
! 983:
! 984: sub initnewstatus {
! 985: my $docdir=$perlvar{'lonDocRoot'};
! 986: my $fh=IO::File->new(">$docdir/lon-status/loncstatus.txt");
! 987: my $now=time;
! 988: my $local=localtime($now);
! 989: print $fh "LONC status $local - parent $$\n\n";
! 990: }
! 991:
! 992: # -------------------------------------------------------------- Status setting
! 993:
! 994: sub status {
! 995: my $what=shift;
! 996: my $now=time;
! 997: my $local=localtime($now);
! 998: $status=$local.': '.$what;
! 999: }
! 1000:
! 1001:
! 1002:
! 1003: # ----------------------------------- POD (plain old documentation, CPAN style)
! 1004:
! 1005: =head1 NAME
! 1006:
! 1007: lonc - LON TCP-MySQL-Server Daemon for handling database requests.
! 1008:
! 1009: =head1 SYNOPSIS
! 1010:
! 1011: Usage: B<gatewayc>
! 1012:
! 1013: Should only be run as user=www. This is a command-line script which
! 1014: is invoked by B<loncron>. There is no expectation that a typical user
! 1015: will manually start B<lonc> from the command-line. (In other words,
! 1016: DO NOT START B<lonc> YOURSELF.)
! 1017:
! 1018: =head1 DESCRIPTION
! 1019:
! 1020: Provides persistent TCP connections to the other servers in the network
! 1021: through multiplexed domain sockets
! 1022:
! 1023: B<lonc> forks off children processes that correspond to the other servers
! 1024: in the network. Management of these processes can be done at the
! 1025: parent process level or the child process level.
! 1026:
! 1027: After forking off the children, B<lonc> the B<parent>
! 1028: executes a main loop which simply waits for processes to exit.
! 1029: As a process exits, a new process managing a link to the same
! 1030: peer as the exiting process is created.
! 1031:
! 1032: B<logs/lonc.log> is the location of log messages.
! 1033:
! 1034: The process management is now explained in terms of linux shell commands,
! 1035: subroutines internal to this code, and signal assignments:
! 1036:
! 1037: =over 4
! 1038:
! 1039: =item *
! 1040:
! 1041: PID is stored in B<logs/gatewayc.pid>
! 1042:
! 1043: This is the process id number of the parent B<gatewayc> process.
! 1044:
! 1045: =item *
! 1046:
! 1047: SIGTERM and SIGINT
! 1048:
! 1049: Parent signal assignment:
! 1050: $SIG{INT} = $SIG{TERM} = \&HUNTSMAN;
! 1051:
! 1052: Child signal assignment:
! 1053: $SIG{INT} = 'DEFAULT'; (and SIGTERM is DEFAULT also)
! 1054: (The child dies and a SIGALRM is sent to parent, awaking parent from slumber
! 1055: to restart a new child.)
! 1056:
! 1057: Command-line invocations:
! 1058: B<kill> B<-s> SIGTERM I<PID>
! 1059: B<kill> B<-s> SIGINT I<PID>
! 1060:
! 1061: Subroutine B<HUNTSMAN>:
! 1062: This is only invoked for the B<lonc> parent I<PID>.
! 1063: This kills all the children, and then the parent.
! 1064: The B<lonc.pid> file is cleared.
! 1065:
! 1066: =item *
! 1067:
! 1068: SIGHUP
! 1069:
! 1070: Current bug:
! 1071: This signal can only be processed the first time
! 1072: on the parent process. Subsequent SIGHUP signals
! 1073: have no effect.
! 1074:
! 1075: Parent signal assignment:
! 1076: $SIG{HUP} = \&HUPSMAN;
! 1077:
! 1078: Child signal assignment:
! 1079: none (nothing happens)
! 1080:
! 1081: Command-line invocations:
! 1082: B<kill> B<-s> SIGHUP I<PID>
! 1083:
! 1084: Subroutine B<HUPSMAN>:
! 1085: This is only invoked for the B<lonc> parent I<PID>,
! 1086: This kills all the children, and then the parent.
! 1087: The B<lonc.pid> file is cleared.
! 1088:
! 1089: =item *
! 1090:
! 1091: SIGUSR1
! 1092:
! 1093: Parent signal assignment:
! 1094: $SIG{USR1} = \&USRMAN;
! 1095:
! 1096: Child signal assignment:
! 1097: $SIG{USR1}= \&logstatus;
! 1098:
! 1099: Command-line invocations:
! 1100: B<kill> B<-s> SIGUSR1 I<PID>
! 1101:
! 1102: Subroutine B<USRMAN>:
! 1103: When invoked for the B<lonc> parent I<PID>,
! 1104: SIGUSR1 is sent to all the children, and the status of
! 1105: each connection is logged.
! 1106:
! 1107:
! 1108: =back
! 1109:
! 1110: =head1 PREREQUISITES
! 1111:
! 1112: POSIX
! 1113: IO::Socket
! 1114: IO::Select
! 1115: IO::File
! 1116: Socket
! 1117: Fcntl
! 1118: Tie::RefHash
! 1119: Crypt::IDEA
! 1120:
! 1121: =head1 COREQUISITES
! 1122:
! 1123: =head1 OSNAMES
! 1124:
! 1125: linux
! 1126:
! 1127: =head1 SCRIPT CATEGORIES
! 1128:
! 1129: Server/Process
! 1130:
! 1131: =cut
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to gatewayc CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / nsdl / bin