Annotation of loncom/lonc, revision 1.32
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.32 ! foxr 8: # $Id: lonc,v 1.31 2002/03/03 18:13:07 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 Scott Harrison
41: # 12/05 Gerd Kortemeyer
1.23 harris41 42: # YEAR=2001
1.14 www 43: # 01/10/01 Scott Harrison
1.21 www 44: # 03/14/01,03/15,06/12,11/26,11/27,11/28 Gerd Kortemeyer
1.23 harris41 45: # 12/20 Scott Harrison
1.26 www 46: # YEAR=2002
1.29 www 47: # 2/19/02,02/22/02,02/25/02 Gerd Kortemeyer
1.10 www 48: #
1.1 albertel 49: # based on nonforker from Perl Cookbook
50: # - server who multiplexes without forking
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.1 albertel 74: # ------------------------------------ Read httpd access.conf and get variables
1.29 www 75: &status("Read access.conf");
1.11 harris41 76: open (CONFIG,"/etc/httpd/conf/access.conf") || die "Can't read access.conf";
1.1 albertel 77:
78: while ($configline=<CONFIG>) {
79: if ($configline =~ /PerlSetVar/) {
80: my ($dummy,$varname,$varvalue)=split(/\s+/,$configline);
1.4 www 81: chomp($varvalue);
1.1 albertel 82: $perlvar{$varname}=$varvalue;
83: }
84: }
85: close(CONFIG);
1.7 www 86:
1.13 harris41 87: # ----------------------------- Make sure this process is running from user=www
1.29 www 88: &status("Check user ID");
1.13 harris41 89: my $wwwid=getpwnam('www');
90: if ($wwwid!=$<) {
91: $emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}";
92: $subj="LON: $perlvar{'lonHostID'} User ID mismatch";
1.14 www 93: system("echo 'User ID mismatch. lonc must be run as user www.' |\
1.13 harris41 94: mailto $emailto -s '$subj' > /dev/null");
95: exit 1;
96: }
97:
1.7 www 98: # --------------------------------------------- Check if other instance running
99:
100: my $pidfile="$perlvar{'lonDaemons'}/logs/lonc.pid";
101:
102: if (-e $pidfile) {
103: my $lfh=IO::File->new("$pidfile");
104: my $pide=<$lfh>;
105: chomp($pide);
1.11 harris41 106: if (kill 0 => $pide) { die "already running"; }
1.7 www 107: }
1.1 albertel 108:
109: # ------------------------------------------------------------- Read hosts file
110:
1.11 harris41 111: open (CONFIG,"$perlvar{'lonTabDir'}/hosts.tab") || die "Can't read host file";
1.1 albertel 112:
113: while ($configline=<CONFIG>) {
114: my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);
115: chomp($ip);
1.28 www 116: if ($ip) {
117: $hostip{$id}=$ip;
118: $hostname{$id}=$name;
119: }
1.1 albertel 120: }
1.27 www 121:
1.1 albertel 122: close(CONFIG);
123:
124: # -------------------------------------------------------- Routines for forking
125:
126: %children = (); # keys are current child process IDs,
127: # values are hosts
128: %childpid = (); # the other way around
129:
130: %childatt = (); # number of attempts to start server
131: # for ID
132:
1.30 www 133: $childmaxattempts=5;
1.3 www 134:
1.1 albertel 135: # ---------------------------------------------------- Fork once and dissociate
1.29 www 136: &status("Fork and dissociate");
1.1 albertel 137: $fpid=fork;
138: exit if $fpid;
1.11 harris41 139: die "Couldn't fork: $!" unless defined ($fpid);
1.1 albertel 140:
1.11 harris41 141: POSIX::setsid() or die "Can't start new session: $!";
1.1 albertel 142:
1.30 www 143: $conserver='PARENT';
144:
1.1 albertel 145: # ------------------------------------------------------- Write our PID on disk
1.29 www 146: &status("Write PID");
1.1 albertel 147: $execdir=$perlvar{'lonDaemons'};
148: open (PIDSAVE,">$execdir/logs/lonc.pid");
149: print PIDSAVE "$$\n";
150: close(PIDSAVE);
1.5 www 151: &logthis("<font color=red>CRITICAL: ---------- Starting ----------</font>");
1.1 albertel 152:
153: # ----------------------------- Ignore signals generated during initial startup
154: $SIG{HUP}=$SIG{USR1}='IGNORE';
155: # ------------------------------------------------------- Now we are on our own
156:
157: # Fork off our children, one for every server
158:
1.18 www 159: &status("Forking ...");
160:
1.1 albertel 161: foreach $thisserver (keys %hostip) {
1.32 ! foxr 162: #if (&online($hostname{$thisserver})) {
1.26 www 163: make_new_child($thisserver);
1.32 ! foxr 164: #}
1.1 albertel 165: }
166:
167: &logthis("Done starting initial servers");
168: # ----------------------------------------------------- Install signal handlers
169:
1.32 ! foxr 170:
1.1 albertel 171: $SIG{INT} = $SIG{TERM} = \&HUNTSMAN;
172: $SIG{HUP} = \&HUPSMAN;
173: $SIG{USR1} = \&USRMAN;
174:
175: # And maintain the population.
176: while (1) {
1.32 ! foxr 177: my $deadpid = wait; # Wait for the next child to die.
1.1 albertel 178: # See who died and start new one
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.23 harris41 258: foreach (@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.20 www 282: $SIG{ALRM}=sub { die "timeout" };
283: $SIG{__DIE__}='DEFAULT';
284: eval {
285: alarm(60);
1.3 www 286: print $remotesock "$cmd\n";
287: $answer=<$remotesock>;
288: chomp($answer);
1.20 www 289: alarm(0);
290: };
291: $SIG{ALRM}='DEFAULT';
292: $SIG{__DIE__}=\&catchexception;
293:
294: if (($answer ne '') && ($@!~/timeout/)) {
1.3 www 295: unlink("$dfname");
1.30 www 296: &logthis("Delayed $cmd: >$answer<");
1.3 www 297: &logperm("S:$conserver:$bcmd");
298: }
1.23 harris41 299: }
1.32 ! foxr 300: if($DEBUG) { &logthis("<font color=green> Delayed transactions sent"); }
1.1 albertel 301:
302: # ------------------------------------------------------- Listen to UNIX socket
1.30 www 303: &status("Opening socket");
1.1 albertel 304: unless (
305: $server = IO::Socket::UNIX->new(Local => $port,
306: Type => SOCK_STREAM,
307: Listen => 10 )
1.5 www 308: ) {
309: my $st=120+int(rand(240));
310: &logthis(
311: "<font color=blue>WARNING: ".
1.32 ! foxr 312: "Can't make server socket ($st secs): $@ .. exiting</font>");
1.5 www 313: sleep($st);
1.1 albertel 314: exit;
315: };
1.32 ! foxr 316:
1.1 albertel 317: # -----------------------------------------------------------------------------
318:
1.5 www 319: &logthis("<font color=green>$conserver online</font>");
320:
321: # -----------------------------------------------------------------------------
1.1 albertel 322: # begin with empty buffers
323: %inbuffer = ();
324: %outbuffer = ();
325: %ready = ();
326:
327: tie %ready, 'Tie::RefHash';
328:
329: nonblock($server);
330: $select = IO::Select->new($server);
331:
332: # Main loop: check reads/accepts, check writes, check ready to process
333: while (1) {
334: my $client;
335: my $rv;
336: my $data;
337:
338: # check for new information on the connections we have
339:
340: # anything to read or accept?
341:
1.32 ! foxr 342: foreach $client ($select->can_read(100.0)) {
1.1 albertel 343: if ($client == $server) {
344: # accept a new connection
1.18 www 345: &status("Accept new connection: $conserver");
1.1 albertel 346: $client = $server->accept();
347: $select->add($client);
348: nonblock($client);
349: } else {
350: # read data
351: $data = '';
352: $rv = $client->recv($data, POSIX::BUFSIZ, 0);
353:
354: unless (defined($rv) && length $data) {
355: # This would be the end of file, so close the client
356: delete $inbuffer{$client};
357: delete $outbuffer{$client};
358: delete $ready{$client};
359:
1.30 www 360: &status("Idle");
1.1 albertel 361: $select->remove($client);
362: close $client;
363: next;
364: }
365:
366: $inbuffer{$client} .= $data;
367:
1.32 ! foxr 368:
1.1 albertel 369: # test whether the data in the buffer or the data we
370: # just read means there is a complete request waiting
371: # to be fulfilled. If there is, set $ready{$client}
372: # to the requests waiting to be fulfilled.
373: while ($inbuffer{$client} =~ s/(.*\n)//) {
374: push( @{$ready{$client}}, $1 );
375: }
376: }
377: }
1.32 ! foxr 378:
1.1 albertel 379: # Any complete requests to process?
380: foreach $client (keys %ready) {
1.25 albertel 381: handle($client);
1.1 albertel 382: }
1.32 ! foxr 383:
1.1 albertel 384: # Buffers to flush?
385: foreach $client ($select->can_write(1)) {
386: # Skip this client if we have nothing to say
387: next unless exists $outbuffer{$client};
1.25 albertel 388:
1.1 albertel 389: $rv = $client->send($outbuffer{$client}, 0);
1.29 www 390:
1.30 www 391: unless ($outbuffer{$client} eq "con_lost\n") {
1.1 albertel 392: unless (defined $rv) {
393: # Whine, but move on.
1.15 www 394: &logthis("I was told I could write, but I can't.\n");
1.1 albertel 395: next;
396: }
1.15 www 397: $errno=$!;
1.1 albertel 398: if (($rv == length $outbuffer{$client}) ||
1.15 www 399: ($errno == POSIX::EWOULDBLOCK) || ($errno == 0)) {
1.1 albertel 400: substr($outbuffer{$client}, 0, $rv) = '';
401: delete $outbuffer{$client} unless length $outbuffer{$client};
402: } else {
403: # Couldn't write all the data, and it wasn't because
404: # it would have blocked. Shutdown and move on.
1.15 www 405:
406: &logthis("Dropping data with ".$errno.": ".
407: length($outbuffer{$client}).", $rv");
408:
1.1 albertel 409: delete $inbuffer{$client};
410: delete $outbuffer{$client};
411: delete $ready{$client};
412:
413: $select->remove($client);
414: close($client);
415: next;
416: }
1.29 www 417: } else {
418: # -------------------------------------------------------- Wow, connection lost
419: &logthis(
1.30 www 420: "<font color=red>CRITICAL: Closing connection</font>");
421: &status("Connection lost");
1.29 www 422: $remotesock->shutdown(2);
423: &logthis("Attempting to open new connection");
424: &openremote($conserver);
425: }
1.1 albertel 426: }
1.29 www 427:
1.1 albertel 428: }
429: }
1.25 albertel 430:
1.1 albertel 431: # ------------------------------------------------------- End of make_new_child
432:
433: # handle($socket) deals with all pending requests for $client
434: sub handle {
435: # requests are in $ready{$client}
436: # send output to $outbuffer{$client}
437: my $client = shift;
438: my $request;
439: foreach $request (@{$ready{$client}}) {
440: # ============================================================= Process request
441: # $request is the text of the request
442: # put text of reply into $outbuffer{$client}
1.29 www 443: # ------------------------------------------------------------ Is this the end?
1.32 ! foxr 444: if($DEBUG) {
! 445: &logthis("<font color=green> Request $request processing starts</font>");
! 446: }
1.29 www 447: if ($request eq "close_connection_exit\n") {
1.30 www 448: &status("Request close connection");
1.29 www 449: &logthis(
1.32 ! foxr 450: "<font color=red>CRITICAL: Request Close Connection ... exiting</font>");
1.29 www 451: $remotesock->shutdown(2);
452: $server->close();
453: exit;
454: }
1.1 albertel 455: # -----------------------------------------------------------------------------
456: if ($request =~ /^encrypt\:/) {
457: my $cmd=$request;
458: $cmd =~ s/^encrypt\://;
459: chomp($cmd);
460: my $cmdlength=length($cmd);
461: $cmd.=" ";
462: my $encrequest='';
463: for (my $encidx=0;$encidx<=$cmdlength;$encidx+=8) {
464: $encrequest.=
465: unpack("H16",$cipher->encrypt(substr($cmd,$encidx,8)));
466: }
467: $request="enc:$cmdlength:$encrequest\n";
468: }
1.19 www 469: # --------------------------------------------------------------- Main exchange
470: $SIG{ALRM}=sub { die "timeout" };
471: $SIG{__DIE__}='DEFAULT';
472: eval {
473: alarm(300);
1.30 www 474: &status("Sending: $request");
1.1 albertel 475: print $remotesock "$request";
1.18 www 476: &status("Waiting for reply from $conserver: $request");
1.1 albertel 477: $answer=<$remotesock>;
1.18 www 478: &status("Received reply: $request");
1.19 www 479: alarm(0);
480: };
1.32 ! foxr 481: if($DEBUG) {
! 482: &logthis("<font color=green> Request data exchange complete");
! 483: }
1.19 www 484: if ($@=~/timeout/) {
485: $answer='';
486: &logthis(
1.30 www 487: "<font color=red>CRITICAL: Timeout: $request</font>");
1.19 www 488: }
489: $SIG{ALRM}='DEFAULT';
490: $SIG{__DIE__}=\&catchexception;
491:
492:
1.1 albertel 493: if ($answer) {
494: if ($answer =~ /^enc/) {
495: my ($cmd,$cmdlength,$encinput)=split(/:/,$answer);
496: chomp($encinput);
497: $answer='';
498: for (my $encidx=0;$encidx<length($encinput);$encidx+=16) {
499: $answer.=$cipher->decrypt(
500: pack("H16",substr($encinput,$encidx,16))
501: );
502: }
503: $answer=substr($answer,0,$cmdlength);
504: $answer.="\n";
505: }
506: $outbuffer{$client} .= $answer;
507: } else {
508: $outbuffer{$client} .= "con_lost\n";
509: }
510:
1.30 www 511: &status("Completed: $request");
1.32 ! foxr 512: if($DEBUG) {
! 513: &logthis("<font color=green> Request processing complete</font>");
! 514: }
1.1 albertel 515: # ===================================================== Done processing request
516: }
517: delete $ready{$client};
518: # -------------------------------------------------------------- End non-forker
1.32 ! foxr 519: if($DEBUG) {
! 520: &logthis("<font color=green> requests for child handled</font>");
! 521: }
1.1 albertel 522: }
523: # ---------------------------------------------------------- End make_new_child
1.25 albertel 524: }
1.1 albertel 525:
526: # nonblock($socket) puts socket into nonblocking mode
527: sub nonblock {
528: my $socket = shift;
529: my $flags;
530:
531:
532: $flags = fcntl($socket, F_GETFL, 0)
1.11 harris41 533: or die "Can't get flags for socket: $!\n";
1.1 albertel 534: fcntl($socket, F_SETFL, $flags | O_NONBLOCK)
1.11 harris41 535: or die "Can't make socket nonblocking: $!\n";
1.29 www 536: }
537:
538:
539: sub openremote {
540: # ---------------------------------------------------- Client to network server
541:
542: my $conserver=shift;
543:
1.30 www 544: &status("Opening TCP");
1.32 ! foxr 545: my $st=120+int(rand(240)); # Sleep before opening:
1.29 www 546:
547: unless (
548: $remotesock = IO::Socket::INET->new(PeerAddr => $hostip{$conserver},
549: PeerPort => $perlvar{'londPort'},
550: Proto => "tcp",
551: Type => SOCK_STREAM)
552: ) {
1.32 ! foxr 553:
1.29 www 554: &logthis(
1.32 ! foxr 555: "<font color=blue>WARNING: Couldn't connect to $conserver ($st secs): $@</font>");
1.29 www 556: sleep($st);
557: exit;
558: };
559: # ----------------------------------------------------------------- Init dialog
560:
1.32 ! foxr 561: &logthis("<font color=green>INFO Connected to $conserver, initing </font>");
1.29 www 562: &status("Init dialogue: $conserver");
563:
564: $SIG{ALRM}=sub { die "timeout" };
565: $SIG{__DIE__}='DEFAULT';
566: eval {
567: alarm(60);
568: print $remotesock "init\n";
569: $answer=<$remotesock>;
570: print $remotesock "$answer";
571: $answer=<$remotesock>;
572: chomp($answer);
573: alarm(0);
574: };
575: $SIG{ALRM}='DEFAULT';
576: $SIG{__DIE__}=\&catchexception;
577:
578: if ($@=~/timeout/) {
1.32 ! foxr 579: &logthis("Timed out during init.. exiting");
1.29 www 580: exit;
581: }
582:
583: if ($answer ne 'ok') {
1.30 www 584: &logthis("Init reply: >$answer<");
1.29 www 585: my $st=120+int(rand(240));
586: &logthis(
1.30 www 587: "<font color=blue>WARNING: Init failed ($st secs)</font>");
1.29 www 588: sleep($st);
589: exit;
590: }
591:
592: sleep 5;
1.30 www 593: &status("Ponging");
1.29 www 594: print $remotesock "pong\n";
595: $answer=<$remotesock>;
596: chomp($answer);
1.30 www 597: if ($answer!~/^$conserver/) {
598: &logthis("Pong reply: >$answer<");
1.29 www 599: }
600: # ----------------------------------------------------------- Initialize cipher
601:
1.30 www 602: &status("Initialize cipher");
1.29 www 603: print $remotesock "ekey\n";
604: my $buildkey=<$remotesock>;
605: my $key=$conserver.$perlvar{'lonHostID'};
606: $key=~tr/a-z/A-Z/;
607: $key=~tr/G-P/0-9/;
608: $key=~tr/Q-Z/0-9/;
609: $key=$key.$buildkey.$key.$buildkey.$key.$buildkey;
610: $key=substr($key,0,32);
611: my $cipherkey=pack("H32",$key);
612: if ($cipher=new IDEA $cipherkey) {
1.30 www 613: &logthis("Secure connection initialized");
1.29 www 614: } else {
615: my $st=120+int(rand(240));
616: &logthis(
617: "<font color=blue>WARNING: ".
1.30 www 618: "Could not establish secure connection ($st secs)!</font>");
1.29 www 619: sleep($st);
620: exit;
621: }
1.32 ! foxr 622: &logthis("<font color=green> Remote open success </font>");
1.8 harris41 623: }
1.30 www 624:
625:
626:
627: # grabs exception and records it to log before exiting
628: sub catchexception {
629: my ($signal)=@_;
630: $SIG{QUIT}='DEFAULT';
631: $SIG{__DIE__}='DEFAULT';
632: chomp($signal);
633: &logthis("<font color=red>CRITICAL: "
634: ."ABNORMAL EXIT. Child $$ for server [$wasserver] died through "
635: ."\"$signal\" with parameter [$@]</font>");
636: die($@);
637: }
638:
639: # -------------------------------------- Routines to see if other box available
640:
1.32 ! foxr 641: #sub online {
! 642: # my $host=shift;
! 643: # &status("Pinging ".$host);
! 644: # my $p=Net::Ping->new("tcp",20);
! 645: # my $online=$p->ping("$host");
! 646: # $p->close();
! 647: # undef ($p);
! 648: # return $online;
! 649: #}
1.30 www 650:
651: sub connected {
652: my ($local,$remote)=@_;
653: &status("Checking connection $local to $remote");
654: $local=~s/\W//g;
655: $remote=~s/\W//g;
656:
657: unless ($hostname{$local}) { return 'local_unknown'; }
658: unless ($hostname{$remote}) { return 'remote_unknown'; }
659:
1.32 ! foxr 660: #unless (&online($hostname{$local})) { return 'local_offline'; }
1.30 www 661:
662: my $ua=new LWP::UserAgent;
663:
664: my $request=new HTTP::Request('GET',
665: "http://".$hostname{$local}.'/cgi-bin/ping.pl?'.$remote);
666:
667: my $response=$ua->request($request);
668:
669: unless ($response->is_success) { return 'local_error'; }
670:
671: my $reply=$response->content;
672: $reply=(split("\n",$reply))[0];
673: $reply=~s/\W//g;
674: if ($reply ne $remote) { return $reply; }
675: return 'ok';
676: }
677:
678:
679:
680: sub hangup {
681: foreach (keys %children) {
682: $wasserver=$children{$_};
683: &status("Closing $wasserver");
684: &logthis('Closing '.$wasserver.': '.&subreply('exit',$wasserver));
685: &status("Kill PID $_ for $wasserver");
686: kill ('INT',$_);
687: }
688: }
689:
690: sub HUNTSMAN { # signal handler for SIGINT
691: local($SIG{CHLD}) = 'IGNORE'; # we're going to kill our children
692: &hangup();
693: my $execdir=$perlvar{'lonDaemons'};
694: unlink("$execdir/logs/lonc.pid");
695: &logthis("<font color=red>CRITICAL: Shutting down</font>");
696: exit; # clean up with dignity
697: }
698:
699: sub HUPSMAN { # signal handler for SIGHUP
700: local($SIG{CHLD}) = 'IGNORE'; # we're going to kill our children
701: &hangup();
702: &logthis("<font color=red>CRITICAL: Restarting</font>");
703: unlink("$execdir/logs/lonc.pid");
704: my $execdir=$perlvar{'lonDaemons'};
705: exec("$execdir/lonc"); # here we go again
706: }
707:
708: sub checkchildren {
709: &initnewstatus();
710: &logstatus();
711: &logthis('Going to check on the children');
712: foreach (sort keys %children) {
713: sleep 1;
714: unless (kill 'USR1' => $_) {
715: &logthis ('<font color=red>CRITICAL: Child '.$_.' is dead</font>');
716: &logstatus($$.' is dead');
717: }
718: }
719: }
720:
721: sub USRMAN {
722: &logthis("USR1: Trying to establish connections again");
723: %childatt=();
724: &checkchildren();
725: }
726:
727: # -------------------------------------------------- Non-critical communication
728: sub subreply {
729: my ($cmd,$server)=@_;
730: my $answer='';
731: if ($server ne $perlvar{'lonHostID'}) {
732: my $peerfile="$perlvar{'lonSockDir'}/$server";
733: my $sclient=IO::Socket::UNIX->new(Peer =>"$peerfile",
734: Type => SOCK_STREAM,
735: Timeout => 10)
736: or return "con_lost";
737:
738:
739: $SIG{ALRM}=sub { die "timeout" };
740: $SIG{__DIE__}='DEFAULT';
741: eval {
742: alarm(10);
743: print $sclient "$cmd\n";
744: $answer=<$sclient>;
745: chomp($answer);
746: alarm(0);
747: };
748: if ((!$answer) || ($@=~/timeout/)) { $answer="con_lost"; }
749: $SIG{ALRM}='DEFAULT';
750: $SIG{__DIE__}=\&catchexception;
751: } else { $answer='self_reply'; }
752: return $answer;
753: }
754:
755: # --------------------------------------------------------------------- Logging
756:
757: sub logthis {
758: my $message=shift;
759: my $execdir=$perlvar{'lonDaemons'};
760: my $fh=IO::File->new(">>$execdir/logs/lonc.log");
761: my $now=time;
762: my $local=localtime($now);
763: $lastlog=$local.': '.$message;
764: print $fh "$local ($$) [$conserver] [$status]: $message\n";
765: }
766:
767:
768: sub logperm {
769: my $message=shift;
770: my $execdir=$perlvar{'lonDaemons'};
771: my $now=time;
772: my $local=localtime($now);
773: my $fh=IO::File->new(">>$execdir/logs/lonnet.perm.log");
774: print $fh "$now:$message:$local\n";
775: }
776: # ------------------------------------------------------------------ Log status
777:
778: sub logstatus {
779: my $docdir=$perlvar{'lonDocRoot'};
780: my $fh=IO::File->new(">>$docdir/lon-status/loncstatus.txt");
781: print $fh $$."\t".$conserver."\t".$status."\t".$lastlog."\n";
782: }
783:
784: sub initnewstatus {
785: my $docdir=$perlvar{'lonDocRoot'};
786: my $fh=IO::File->new(">$docdir/lon-status/loncstatus.txt");
787: my $now=time;
788: my $local=localtime($now);
789: print $fh "LONC status $local - parent $$\n\n";
790: }
791:
792: # -------------------------------------------------------------- Status setting
793:
794: sub status {
795: my $what=shift;
796: my $now=time;
797: my $local=localtime($now);
798: $status=$local.': '.$what;
799: }
800:
801:
1.1 albertel 802:
1.23 harris41 803: # ----------------------------------- POD (plain old documentation, CPAN style)
804:
805: =head1 NAME
806:
807: lonc - LON TCP-MySQL-Server Daemon for handling database requests.
808:
809: =head1 SYNOPSIS
810:
1.31 harris41 811: Usage: B<lonc>
812:
1.23 harris41 813: Should only be run as user=www. This is a command-line script which
1.31 harris41 814: is invoked by B<loncron>. There is no expectation that a typical user
815: will manually start B<lonc> from the command-line. (In other words,
816: DO NOT START B<lonc> YOURSELF.)
1.23 harris41 817:
818: =head1 DESCRIPTION
819:
820: Provides persistent TCP connections to the other servers in the network
821: through multiplexed domain sockets
822:
1.31 harris41 823: B<lonc> forks off children processes that correspond to the other servers
824: in the network. Management of these processes can be done at the
825: parent process level or the child process level.
826:
827: B<logs/lonc.log> is the location of log messages.
828:
829: The process management is now explained in terms of linux shell commands,
830: subroutines internal to this code, and signal assignments:
831:
832: =over 4
833:
834: =item *
835:
836: PID is stored in B<logs/lonc.pid>
837:
838: This is the process id number of the parent B<lonc> process.
839:
840: =item *
841:
842: SIGTERM and SIGINT
843:
844: Parent signal assignment:
845: $SIG{INT} = $SIG{TERM} = \&HUNTSMAN;
846:
847: Child signal assignment:
848: $SIG{INT} = 'DEFAULT'; (and SIGTERM is DEFAULT also)
849: (The child dies and a SIGALRM is sent to parent, awaking parent from slumber
850: to restart a new child.)
851:
852: Command-line invocations:
853: B<kill> B<-s> SIGTERM I<PID>
854: B<kill> B<-s> SIGINT I<PID>
855:
856: Subroutine B<HUNTSMAN>:
857: This is only invoked for the B<lonc> parent I<PID>.
858: This kills all the children, and then the parent.
859: The B<lonc.pid> file is cleared.
860:
861: =item *
862:
863: SIGHUP
864:
865: Current bug:
866: This signal can only be processed the first time
867: on the parent process. Subsequent SIGHUP signals
868: have no effect.
869:
870: Parent signal assignment:
871: $SIG{HUP} = \&HUPSMAN;
872:
873: Child signal assignment:
874: none (nothing happens)
875:
876: Command-line invocations:
877: B<kill> B<-s> SIGHUP I<PID>
878:
879: Subroutine B<HUPSMAN>:
880: This is only invoked for the B<lonc> parent I<PID>,
881: This kills all the children, and then the parent.
882: The B<lonc.pid> file is cleared.
883:
884: =item *
885:
886: SIGUSR1
887:
888: Parent signal assignment:
889: $SIG{USR1} = \&USRMAN;
890:
891: Child signal assignment:
892: $SIG{USR1}= \&logstatus;
893:
894: Command-line invocations:
895: B<kill> B<-s> SIGUSR1 I<PID>
896:
897: Subroutine B<USRMAN>:
898: When invoked for the B<lonc> parent I<PID>,
899: SIGUSR1 is sent to all the children, and the status of
900: each connection is logged.
901:
902: =item *
903:
904: SIGCHLD
905:
906:
907: Child signal assignment:
908: none
909:
910: Command-line invocations:
911: B<kill> B<-s> SIGCHLD I<PID>
1.23 harris41 912:
1.31 harris41 913: Subroutine B<REAPER>:
914: This is only invoked for the B<lonc> parent I<PID>.
915: Information pertaining to the child is removed.
916: The socket port is cleaned up.
1.23 harris41 917:
1.31 harris41 918: =back
1.23 harris41 919:
920: =head1 PREREQUISITES
921:
922: POSIX
923: IO::Socket
924: IO::Select
925: IO::File
926: Socket
927: Fcntl
928: Tie::RefHash
929: Crypt::IDEA
930:
931: =head1 COREQUISITES
932:
933: =head1 OSNAMES
934:
935: linux
936:
937: =head1 SCRIPT CATEGORIES
938:
939: Server/Process
940:
941: =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