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