Return to lond CVS log

Up to [LON-CAPA] / loncom

Diff for /loncom/lond between versions 1.30 and 1.66

version 1.30, 2000/12/06 20:38:21	version 1.66, 2002/02/05 18:05:47
Line 1	Line 1
#!/usr/bin/perl	#!/usr/bin/perl
# The LearningOnline Network	# The LearningOnline Network
# lond "LON Daemon" Server (port "LOND" 5663)	# lond "LON Daemon" Server (port "LOND" 5663)
	#
	# $Id$
	#
	# Copyright Michigan State University Board of Trustees
	#
	# This file is part of the LearningOnline Network with CAPA (LON-CAPA).
	#
	# LON-CAPA is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License as published by
	# the Free Software Foundation; either version 2 of the License, or
	# (at your option) any later version.
	#
	# LON-CAPA is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with LON-CAPA; if not, write to the Free Software
	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	#
	# /home/httpd/html/adm/gpl.txt
	#
	# http://www.lon-capa.org/
	#
# 5/26/99,6/4,6/10,6/11,6/14,6/15,6/26,6/28,6/30,	# 5/26/99,6/4,6/10,6/11,6/14,6/15,6/26,6/28,6/30,
# 7/8,7/9,7/10,7/12,7/17,7/19,9/21,	# 7/8,7/9,7/10,7/12,7/17,7/19,9/21,
# 10/7,10/8,10/9,10/11,10/13,10/15,11/4,11/16,	# 10/7,10/8,10/9,10/11,10/13,10/15,11/4,11/16,
Line 9	Line 34
# 06/26 Scott Harrison	# 06/26 Scott Harrison
# 06/29,06/30,07/14,07/15,07/17,07/20,07/25,09/18 Gerd Kortemeyer	# 06/29,06/30,07/14,07/15,07/17,07/20,07/25,09/18 Gerd Kortemeyer
# 12/05 Scott Harrison	# 12/05 Scott Harrison
# 12/05 Gerd Kortemeyer	# 12/05,12/13,12/29 Gerd Kortemeyer
#	# YEAR=2001
	# Jan 01 Scott Harrison
	# 02/12 Gerd Kortemeyer
	# 03/15 Scott Harrison
	# 03/24 Gerd Kortemeyer
	# 04/02 Scott Harrison
	# 05/11,05/28,08/30 Gerd Kortemeyer
	# 9/30,10/22,11/13,11/15,11/16 Scott Harrison
	# 11/26,11/27 Gerd Kortemeyer
	# 12/20 Scott Harrison
	# 12/22 Gerd Kortemeyer
	# YEAR=2002
	# 01/20/02,02/05 Gerd Kortemeyer
	###

# based on "Perl Cookbook" ISBN 1-56592-243-3	# based on "Perl Cookbook" ISBN 1-56592-243-3
# preforker - server who forks first	# preforker - server who forks first
# runs as a daemon	# runs as a daemon
Line 26 use Crypt::IDEA;	Line 65 use Crypt::IDEA;
use LWP::UserAgent();	use LWP::UserAgent();
use GDBM_File;	use GDBM_File;
use Authen::Krb4;	use Authen::Krb4;
	use lib '/home/httpd/lib/perl/';
	use localauth;

	my $status='';
	my $lastlog='';

# grabs exception and records it to log before exiting	# grabs exception and records it to log before exiting
sub catchexception {	sub catchexception {
Line 35 sub catchexception {	Line 79 sub catchexception {
&logthis("<font color=red>CRITICAL: "	&logthis("<font color=red>CRITICAL: "
."ABNORMAL EXIT. Child $$ for server $wasserver died through "	."ABNORMAL EXIT. Child $$ for server $wasserver died through "
."a crash with this error msg->[$error]</font>");	."a crash with this error msg->[$error]</font>");
	&logthis('Famous last words: '.$status.' - '.$lastlog);
if ($client) { print $client "error: $error\n"; }	if ($client) { print $client "error: $error\n"; }
	$server->close();
die($error);	die($error);
}	}

	sub timeout {
	&logthis("<font color=ref>CRITICAL: TIME OUT ".$$."</font>");
	&catchexception('Timeout');
	}
# -------------------------------- Set signal handlers to record abnormal exits	# -------------------------------- Set signal handlers to record abnormal exits

$SIG{'QUIT'}=\&catchexception;	$SIG{'QUIT'}=\&catchexception;
Line 57 while ($configline=<CONFIG>) {	Line 107 while ($configline=<CONFIG>) {
}	}
close(CONFIG);	close(CONFIG);

	# ----------------------------- Make sure this process is running from user=www
	my $wwwid=getpwnam('www');
	if ($wwwid!=$<) {
	$emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}";
	$subj="LON: $perlvar{'lonHostID'} User ID mismatch";
	system("echo 'User ID mismatch. lond must be run as user www.' \|\
	mailto $emailto -s '$subj' > /dev/null");
	exit 1;
	}

# --------------------------------------------- Check if other instance running	# --------------------------------------------- Check if other instance running

my $pidfile="$perlvar{'lonDaemons'}/logs/lond.pid";	my $pidfile="$perlvar{'lonDaemons'}/logs/lond.pid";
Line 111 sub REAPER { # ta	Line 171 sub REAPER { # ta
sub HUNTSMAN { # signal handler for SIGINT	sub HUNTSMAN { # signal handler for SIGINT
local($SIG{CHLD}) = 'IGNORE'; # we're going to kill our children	local($SIG{CHLD}) = 'IGNORE'; # we're going to kill our children
kill 'INT' => keys %children;	kill 'INT' => keys %children;
	&logthis("Free socket: ".shutdown($server,2)); # free up socket
my $execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
unlink("$execdir/logs/lond.pid");	unlink("$execdir/logs/lond.pid");
&logthis("<font color=red>CRITICAL: Shutting down</font>");	&logthis("<font color=red>CRITICAL: Shutting down</font>");
Line 120 sub HUNTSMAN { # si	Line 181 sub HUNTSMAN { # si
sub HUPSMAN { # signal handler for SIGHUP	sub HUPSMAN { # signal handler for SIGHUP
local($SIG{CHLD}) = 'IGNORE'; # we're going to kill our children	local($SIG{CHLD}) = 'IGNORE'; # we're going to kill our children
kill 'INT' => keys %children;	kill 'INT' => keys %children;
close($server); # free up socket	&logthis("Free socket: ".shutdown($server,2)); # free up socket
&logthis("<font color=red>CRITICAL: Restarting</font>");	&logthis("<font color=red>CRITICAL: Restarting</font>");
unlink("$execdir/logs/lond.pid");	unlink("$execdir/logs/lond.pid");
my $execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
exec("$execdir/lond"); # here we go again	exec("$execdir/lond"); # here we go again
}	}

	sub checkchildren {
	&initnewstatus();
	&logstatus();
	&logthis('Going to check on the children');
	$docdir=$perlvar{'lonDocRoot'};
	foreach (sort keys %children) {
	sleep 1;
	unless (kill 'USR1' => $_) {
	&logthis ('Child '.$_.' is dead');
	&logstatus($$.' is dead');
	}
	}
	sleep 5;
	foreach (sort keys %children) {
	unless (-e "$docdir/lon-status/londchld/$_.txt") {
	&logthis('Child '.$_.' did not respond');
	kill 9 => $_;
	$emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}";
	$subj="LON: $perlvar{'lonHostID'} killed lond process $_";
	system("echo 'Killed lond process $_.' \|\
	mailto $emailto -s '$subj' > /dev/null");
	$execdir=$perlvar{'lonDaemons'};
	system("cp $execdir/logs/lond.log $execdir/logs/lond.log.".$_);
	}
	}
	}

# --------------------------------------------------------------------- Logging	# --------------------------------------------------------------------- Logging

sub logthis {	sub logthis {
Line 135 sub logthis {	Line 223 sub logthis {
my $fh=IO::File->new(">>$execdir/logs/lond.log");	my $fh=IO::File->new(">>$execdir/logs/lond.log");
my $now=time;	my $now=time;
my $local=localtime($now);	my $local=localtime($now);
	$lastlog=$local.': '.$message;
print $fh "$local ($$): $message\n";	print $fh "$local ($$): $message\n";
}	}

	# ------------------------------------------------------------------ Log status

	sub logstatus {
	my $docdir=$perlvar{'lonDocRoot'};
	{
	my $fh=IO::File->new(">>$docdir/lon-status/londstatus.txt");
	print $fh $$."\t".$status."\t".$lastlog."\n";
	$fh->close();
	}
	{
	my $fh=IO::File->new(">$docdir/lon-status/londchld/$$.txt");
	print $fh $status."\n".$lastlog."\n".time;
	$fh->close();
	}
	}

	sub initnewstatus {
	my $docdir=$perlvar{'lonDocRoot'};
	my $fh=IO::File->new(">$docdir/lon-status/londstatus.txt");
	my $now=time;
	my $local=localtime($now);
	print $fh "LOND status $local - parent $$\n\n";
	opendir(DIR,"$docdir/lon-status/londchld");
	while ($filename=readdir(DIR)) {
	unlink("$docdir/lon-status/londchld/$filename");
	}
	closedir(DIR);
	}

	# -------------------------------------------------------------- Status setting

	sub status {
	my $what=shift;
	my $now=time;
	my $local=localtime($now);
	$status=$local.': '.$what;
	}

# -------------------------------------------------------- Escape Special Chars	# -------------------------------------------------------- Escape Special Chars

Line 284 open (PIDSAVE,">$execdir/logs/lond.pid")	Line 410 open (PIDSAVE,">$execdir/logs/lond.pid")
print PIDSAVE "$$\n";	print PIDSAVE "$$\n";
close(PIDSAVE);	close(PIDSAVE);
&logthis("<font color=red>CRITICAL: ---------- Starting ----------</font>");	&logthis("<font color=red>CRITICAL: ---------- Starting ----------</font>");
	&status('Starting');

# ------------------------------------------------------- Now we are on our own	# ------------------------------------------------------- Now we are on our own

Line 294 for (1 .. $PREFORK) {	Line 421 for (1 .. $PREFORK) {

# ----------------------------------------------------- Install signal handlers	# ----------------------------------------------------- Install signal handlers

	&status('Forked children');

$SIG{CHLD} = \&REAPER;	$SIG{CHLD} = \&REAPER;
$SIG{INT} = $SIG{TERM} = \&HUNTSMAN;	$SIG{INT} = $SIG{TERM} = \&HUNTSMAN;
$SIG{HUP} = \&HUPSMAN;	$SIG{HUP} = \&HUPSMAN;
	$SIG{USR1} = \&checkchildren;

# And maintain the population.	# And maintain the population.
while (1) {	while (1) {
	&status('Sleeping');
sleep; # wait for a signal (i.e., child's death)	sleep; # wait for a signal (i.e., child's death)
	&logthis('Woke up');
	&status('Woke up');
for ($i = $children; $i < $PREFORK; $i++) {	for ($i = $children; $i < $PREFORK; $i++) {
make_new_child(); # top up the child pool	make_new_child(); # top up the child pool
}	}
Line 324 sub make_new_child {	Line 457 sub make_new_child {
or die "Can't unblock SIGINT for fork: $!\n";	or die "Can't unblock SIGINT for fork: $!\n";
$children{$pid} = 1;	$children{$pid} = 1;
$children++;	$children++;
	&status('Started child '.$pid);
return;	return;
} else {	} else {
# Child can not return from this subroutine.	# Child can not return from this subroutine.
$SIG{INT} = 'DEFAULT'; # make SIGINT kill us as it did before	$SIG{INT} = 'DEFAULT'; # make SIGINT kill us as it did before
	$SIG{USR1}= \&logstatus;
	$SIG{ALRM}= \&timeout;
	$lastlog='Forked ';
	$status='Forked';

# unblock signals	# unblock signals
sigprocmask(SIG_UNBLOCK, $sigset)	sigprocmask(SIG_UNBLOCK, $sigset)
or die "Can't unblock SIGINT for fork: $!\n";	or die "Can't unblock SIGINT for fork: $!\n";
Line 337 sub make_new_child {	Line 475 sub make_new_child {

# handle connections until we've reached $MAX_CLIENTS_PER_CHILD	# handle connections until we've reached $MAX_CLIENTS_PER_CHILD
for ($i=0; $i < $MAX_CLIENTS_PER_CHILD; $i++) {	for ($i=0; $i < $MAX_CLIENTS_PER_CHILD; $i++) {
	&status('Idle, waiting for connection');
$client = $server->accept() or last;	$client = $server->accept() or last;
	&status('Accepted connection');
# =============================================================================	# =============================================================================
# do something with the connection	# do something with the connection
# -----------------------------------------------------------------------------	# -----------------------------------------------------------------------------
Line 348 sub make_new_child {	Line 487 sub make_new_child {
my $clientip=inet_ntoa($iaddr);	my $clientip=inet_ntoa($iaddr);
my $clientrec=($hostid{$clientip} ne undef);	my $clientrec=($hostid{$clientip} ne undef);
&logthis(	&logthis(
"<font color=yellow>INFO: Connect from $clientip ($hostid{$clientip})</font>");	"<font color=yellow>INFO: Connection $i, $clientip ($hostid{$clientip})</font>"
	);
	&status("Connecting $clientip ($hostid{$clientip})");
my $clientok;	my $clientok;
if ($clientrec) {	if ($clientrec) {
	&status("Waiting for init from $clientip ($hostid{$clientip})");
my $remotereq=<$client>;	my $remotereq=<$client>;
$remotereq=~s/\W//g;	$remotereq=~s/\W//g;
if ($remotereq eq 'init') {	if ($remotereq eq 'init') {
my $challenge="$$".time;	my $challenge="$$".time;
print $client "$challenge\n";	print $client "$challenge\n";
	&status(
	"Waiting for challenge reply from $clientip ($hostid{$clientip})");
$remotereq=<$client>;	$remotereq=<$client>;
$remotereq=~s/\W//g;	$remotereq=~s/\W//g;
if ($challenge eq $remotereq) {	if ($challenge eq $remotereq) {
Line 364 sub make_new_child {	Line 508 sub make_new_child {
} else {	} else {
&logthis(	&logthis(
"<font color=blue>WARNING: $clientip did not reply challenge</font>");	"<font color=blue>WARNING: $clientip did not reply challenge</font>");
print $client "bye\n";	&status('No challenge reply '.$clientip);
}	}
} else {	} else {
&logthis(	&logthis(
"<font color=blue>WARNING: "	"<font color=blue>WARNING: "
."$clientip failed to initialize: >$remotereq< </font>");	."$clientip failed to initialize: >$remotereq< </font>");
print $client "bye\n";	&status('No init '.$clientip);
}	}
} else {	} else {
&logthis(	&logthis(
"<font color=blue>WARNING: Unknown client $clientip</font>");	"<font color=blue>WARNING: Unknown client $clientip</font>");
print $client "bye\n";	&status('Hung up on '.$clientip);
}	}
if ($clientok) {	if ($clientok) {
# ---------------- New known client connecting, could mean machine online again	# ---------------- New known client connecting, could mean machine online again
&reconlonc("$perlvar{'lonSockDir'}/$hostid{$clientip}");	&reconlonc("$perlvar{'lonSockDir'}/$hostid{$clientip}");
&logthis(	&logthis(
"<font color=green>Established connection: $hostid{$clientip}</font>");	"<font color=green>Established connection: $hostid{$clientip}</font>");
	&status('Will listen to '.$hostid{$clientip});
# ------------------------------------------------------------ Process requests	# ------------------------------------------------------------ Process requests
while (my $userinput=<$client>) {	while (my $userinput=<$client>) {
chomp($userinput);	chomp($userinput);
	&status('Processing '.$hostid{$clientip}.': '.$userinput);
my $wasenc=0;	my $wasenc=0;
	alarm(120);
# ------------------------------------------------------------ See if encrypted	# ------------------------------------------------------------ See if encrypted
if ($userinput =~ /^enc/) {	if ($userinput =~ /^enc/) {
if ($cipher) {	if ($cipher) {
Line 433 sub make_new_child {	Line 580 sub make_new_child {
$loadavg =~ s/\s.*//g;	$loadavg =~ s/\s.*//g;
my $loadpercent=100*$loadavg/$perlvar{'lonLoadLim'};	my $loadpercent=100*$loadavg/$perlvar{'lonLoadLim'};
print $client "$loadpercent\n";	print $client "$loadpercent\n";
	# ----------------------------------------------------------------- currentauth
	} elsif ($userinput =~ /^currentauth/) {
	if ($wasenc==1) {
	my ($cmd,$udom,$uname)=split(/:/,$userinput);
	my $proname=propath($udom,$uname);
	my $passfilename="$proname/passwd";
	if (-e $passfilename) {
	my $pf = IO::File->new($passfilename);
	my $realpasswd=<$pf>;
	chomp($realpasswd);
	my ($howpwd,$contentpwd)=split(/:/,$realpasswd);
	my $availablecontent='';
	if ($howpwd eq 'krb4') {
	$availablecontent=$contentpwd;
	}
	print $client "$howpwd:$availablecontent\n";
	} else {
	print $client "unknown_user\n";
	}
	} else {
	print $client "refused\n";
	}
# ------------------------------------------------------------------------ auth	# ------------------------------------------------------------------------ auth
} elsif ($userinput =~ /^auth/) {	} elsif ($userinput =~ /^auth/) {
if ($wasenc==1) {	if ($wasenc==1) {
Line 452 sub make_new_child {	Line 621 sub make_new_child {
(crypt($upass,$contentpwd) eq $contentpwd);	(crypt($upass,$contentpwd) eq $contentpwd);
} elsif ($howpwd eq 'unix') {	} elsif ($howpwd eq 'unix') {
$contentpwd=(getpwnam($uname))[1];	$contentpwd=(getpwnam($uname))[1];
$pwdcorrect=	my $pwauth_path="/usr/local/sbin/pwauth";
(crypt($upass,$contentpwd) eq $contentpwd);	unless ($contentpwd eq 'x') {
	$pwdcorrect=
	(crypt($upass,$contentpwd) eq $contentpwd);
	}
	elsif (-e $pwauth_path) {
	open PWAUTH, "\|$pwauth_path" or
	die "Cannot invoke authentication";
	print PWAUTH "$uname\n$upass\n";
	close PWAUTH;
	$pwdcorrect=!$?;
	}
} elsif ($howpwd eq 'krb4') {	} elsif ($howpwd eq 'krb4') {
$pwdcorrect=(	$pwdcorrect=(
Authen::Krb4::get_pw_in_tkt($uname,"",	Authen::Krb4::get_pw_in_tkt($uname,"",
$contentpwd,'krbtgt',$contentpwd,1,	$contentpwd,'krbtgt',$contentpwd,1,
$upass) == 0);	$upass) == 0);
}	} elsif ($howpwd eq 'localauth') {
	$pwdcorrect=&localauth::localauth($uname,$upass,
	$contentpwd);
	}
if ($pwdcorrect) {	if ($pwdcorrect) {
print $client "authorized\n";	print $client "authorized\n";
} else {	} else {
Line 477 sub make_new_child {	Line 659 sub make_new_child {
my	my
($cmd,$udom,$uname,$upass,$npass)=split(/:/,$userinput);	($cmd,$udom,$uname,$upass,$npass)=split(/:/,$userinput);
chomp($npass);	chomp($npass);
	$upass=&unescape($upass);
	$npass=&unescape($npass);
my $proname=propath($udom,$uname);	my $proname=propath($udom,$uname);
my $passfilename="$proname/passwd";	my $passfilename="$proname/passwd";
if (-e $passfilename) {	if (-e $passfilename) {
Line 491 sub make_new_child {	Line 675 sub make_new_child {
$salt=substr($salt,6,2);	$salt=substr($salt,6,2);
my $ncpass=crypt($npass,$salt);	my $ncpass=crypt($npass,$salt);
{ my $pf = IO::File->new(">$passfilename");	{ my $pf = IO::File->new(">$passfilename");
print $pf "internal:$ncpass\n";; }	print $pf "internal:$ncpass\n"; }
print $client "ok\n";	print $client "ok\n";
} else {	} else {
print $client "non_authorized\n";	print $client "non_authorized\n";
Line 505 sub make_new_child {	Line 689 sub make_new_child {
} else {	} else {
print $client "refused\n";	print $client "refused\n";
}	}
	# -------------------------------------------------------------------- makeuser
	} elsif ($userinput =~ /^makeuser/) {
	my $oldumask=umask(0077);
	if ($wasenc==1) {
	my
	($cmd,$udom,$uname,$umode,$npass)=split(/:/,$userinput);
	chomp($npass);
	$npass=&unescape($npass);
	my $proname=propath($udom,$uname);
	my $passfilename="$proname/passwd";
	if (-e $passfilename) {
	print $client "already_exists\n";
	} elsif ($udom ne $perlvar{'lonDefDomain'}) {
	print $client "not_right_domain\n";
	} else {
	@fpparts=split(/\//,$proname);
	$fpnow=$fpparts[0].'/'.$fpparts[1].'/'.$fpparts[2];
	$fperror='';
	for ($i=3;$i<=$#fpparts;$i++) {
	$fpnow.='/'.$fpparts[$i];
	unless (-e $fpnow) {
	unless (mkdir($fpnow,0777)) {
	$fperror="error:$!";
	}
	}
	}
	unless ($fperror) {
	if ($umode eq 'krb4') {
	{
	my $pf = IO::File->new(">$passfilename");
	print $pf "krb4:$npass\n";
	}
	print $client "ok\n";
	} elsif ($umode eq 'internal') {
	my $salt=time;
	$salt=substr($salt,6,2);
	my $ncpass=crypt($npass,$salt);
	{
	my $pf = IO::File->new(">$passfilename");
	print $pf "internal:$ncpass\n";
	}
	print $client "ok\n";
	} elsif ($umode eq 'localauth') {
	{
	my $pf = IO::File->new(">$passfilename");
	print $pf "localauth:$npass\n";
	}
	print $client "ok\n";
	} elsif ($umode eq 'unix') {
	{
	my $execpath="$perlvar{'lonDaemons'}/".
	"lcuseradd";
	{
	my $se = IO::File->new("\|$execpath");
	print $se "$uname\n";
	print $se "$npass\n";
	print $se "$npass\n";
	}
	my $pf = IO::File->new(">$passfilename");
	print $pf "unix:\n";
	}
	print $client "ok\n";
	} elsif ($umode eq 'none') {
	{
	my $pf = IO::File->new(">$passfilename");
	print $pf "none:\n";
	}
	print $client "ok\n";
	} else {
	print $client "auth_mode_error\n";
	}
	} else {
	print $client "$fperror\n";
	}
	}
	} else {
	print $client "refused\n";
	}
	umask($oldumask);
	# -------------------------------------------------------------- changeuserauth
	} elsif ($userinput =~ /^changeuserauth/) {
	if ($wasenc==1) {
	my
	($cmd,$udom,$uname,$umode,$npass)=split(/:/,$userinput);
	chomp($npass);
	$npass=&unescape($npass);
	my $proname=propath($udom,$uname);
	my $passfilename="$proname/passwd";
	if ($udom ne $perlvar{'lonDefDomain'}) {
	print $client "not_right_domain\n";
	} else {
	if ($umode eq 'krb4') {
	{
	my $pf = IO::File->new(">$passfilename");
	print $pf "krb4:$npass\n";
	}
	print $client "ok\n";
	} elsif ($umode eq 'internal') {
	my $salt=time;
	$salt=substr($salt,6,2);
	my $ncpass=crypt($npass,$salt);
	{
	my $pf = IO::File->new(">$passfilename");
	print $pf "internal:$ncpass\n";
	}
	print $client "ok\n";
	} elsif ($umode eq 'localauth') {
	{
	my $pf = IO::File->new(">$passfilename");
	print $pf "localauth:$npass\n";
	}
	print $client "ok\n";
	} elsif ($umode eq 'unix') {
	{
	my $execpath="$perlvar{'lonDaemons'}/".
	"lcuseradd";
	{
	my $se = IO::File->new("\|$execpath");
	print $se "$uname\n";
	print $se "$npass\n";
	print $se "$npass\n";
	}
	my $pf = IO::File->new(">$passfilename");
	print $pf "unix:\n";
	}
	print $client "ok\n";
	} elsif ($umode eq 'none') {
	{
	my $pf = IO::File->new(">$passfilename");
	print $pf "none:\n";
	}
	print $client "ok\n";
	} else {
	print $client "auth_mode_error\n";
	}
	}
	} else {
	print $client "refused\n";
	}
# ------------------------------------------------------------------------ home	# ------------------------------------------------------------------------ home
} elsif ($userinput =~ /^home/) {	} elsif ($userinput =~ /^home/) {
my ($cmd,$udom,$uname)=split(/:/,$userinput);	my ($cmd,$udom,$uname)=split(/:/,$userinput);
Line 596 sub make_new_child {	Line 919 sub make_new_child {
print $sh "$clientip:$now\n";	print $sh "$clientip:$now\n";
}	}
}	}
	unless ($fname=~/\.meta$/) {
	unlink("$fname.meta.$hostid{$clientip}");
	}
$fname=~s/\/home\/httpd\/html\/res/raw/;	$fname=~s/\/home\/httpd\/html\/res/raw/;
$fname="http://$thisserver/".$fname;	$fname="http://$thisserver/".$fname;
print $client "$fname\n";	print $client "$fname\n";
Line 631 sub make_new_child {	Line 957 sub make_new_child {
chomp($what);	chomp($what);
my $proname=propath($udom,$uname);	my $proname=propath($udom,$uname);
my $now=time;	my $now=time;
{	unless ($namespace=~/^nohist\_/) {
my $hfh;	my $hfh;
if (	if (
$hfh=IO::File->new(">>$proname/$namespace.hist")	$hfh=IO::File->new(">>$proname/$namespace.hist")
Line 756 sub make_new_child {	Line 1082 sub make_new_child {
chomp($what);	chomp($what);
my $proname=propath($udom,$uname);	my $proname=propath($udom,$uname);
my $now=time;	my $now=time;
{	unless ($namespace=~/^nohist\_/) {
my $hfh;	my $hfh;
if (	if (
$hfh=IO::File->new(">>$proname/$namespace.hist")	$hfh=IO::File->new(">>$proname/$namespace.hist")
Line 798 sub make_new_child {	Line 1124 sub make_new_child {
}	}
# ------------------------------------------------------------------------ dump	# ------------------------------------------------------------------------ dump
} elsif ($userinput =~ /^dump/) {	} elsif ($userinput =~ /^dump/) {
my ($cmd,$udom,$uname,$namespace)	my ($cmd,$udom,$uname,$namespace,$regexp)
=split(/:/,$userinput);	=split(/:/,$userinput);
$namespace=~s/\//\_/g;	$namespace=~s/\//\_/g;
$namespace=~s/\W//g;	$namespace=~s/\W//g;
	if (defined($regexp)) {
	$regexp=&unescape($regexp);
	} else {
	$regexp='.';
	}
my $proname=propath($udom,$uname);	my $proname=propath($udom,$uname);
my $qresult='';	my $qresult='';
if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER,0640)) {	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER,0640)) {
foreach $key (keys %hash) {	foreach $key (keys %hash) {
$qresult.="$key=$hash{$key}&";	if (eval('$key=~/$regexp/')) {
	$qresult.="$key=$hash{$key}&";
	}
}	}
if (untie(%hash)) {	if (untie(%hash)) {
$qresult=~s/\&$//;	$qresult=~s/\&$//;
Line 827 sub make_new_child {	Line 1160 sub make_new_child {
chomp($what);	chomp($what);
my $proname=propath($udom,$uname);	my $proname=propath($udom,$uname);
my $now=time;	my $now=time;
{	unless ($namespace=~/^nohist\_/) {
my $hfh;	my $hfh;
if (	if (
$hfh=IO::File->new(">>$proname/$namespace.hist")	$hfh=IO::File->new(">>$proname/$namespace.hist")
Line 846 sub make_new_child {	Line 1179 sub make_new_child {
$allkeys.=$key.':';	$allkeys.=$key.':';
$hash{"$version:$rid:$key"}=$value;	$hash{"$version:$rid:$key"}=$value;
}	}
$allkeys=~s/:$//;	$hash{"$version:$rid:timestamp"}=$now;
	$allkeys.='timestamp';
$hash{"$version:keys:$rid"}=$allkeys;	$hash{"$version:keys:$rid"}=$allkeys;
if (untie(%hash)) {	if (untie(%hash)) {
print $client "ok\n";	print $client "ok\n";
Line 892 sub make_new_child {	Line 1226 sub make_new_child {
}	}
# ------------------------------------------------------------------- querysend	# ------------------------------------------------------------------- querysend
} elsif ($userinput =~ /^querysend/) {	} elsif ($userinput =~ /^querysend/) {
my ($cmd,$query)=split(/:/,$userinput);	my ($cmd,$query,
	$custom,$customshow)=split(/:/,$userinput);
$query=~s/\n*$//g;	$query=~s/\n*$//g;
print $client sqlreply("$hostid{$clientip}\&$query")."\n";	unless ($custom or $customshow) {
	print $client "".
	sqlreply("$hostid{$clientip}\&$query")."\n";
	}
	else {
	print $client "".
	sqlreply("$hostid{$clientip}\&$query".
	"\&$custom"."\&$customshow")."\n";
	}
# ------------------------------------------------------------------ queryreply	# ------------------------------------------------------------------ queryreply
} elsif ($userinput =~ /^queryreply/) {	} elsif ($userinput =~ /^queryreply/) {
my ($cmd,$id,$reply)=split(/:/,$userinput);	my ($cmd,$id,$reply)=split(/:/,$userinput);
my $store;	my $store;
my $execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
if ($store=IO::File->new(">$execdir/tmp/$id")) {	if ($store=IO::File->new(">$execdir/tmp/$id")) {
	$reply=~s/\&/\n/g;
print $store $reply;	print $store $reply;
close $store;	close $store;
	my $store2=IO::File->new(">$execdir/tmp/$id.end");
	print $store2 "done\n";
	close $store2;
print $client "ok\n";	print $client "ok\n";
}	}
else {	else {
Line 996 sub make_new_child {	Line 1343 sub make_new_child {
my $ulsout='';	my $ulsout='';
my $ulsfn;	my $ulsfn;
if (-e $ulsdir) {	if (-e $ulsdir) {
while ($ulsfn=<$ulsdir/*>) {	if (opendir(LSDIR,$ulsdir)) {
my @ulsstats=stat($ulsfn);	while ($ulsfn=readdir(LSDIR)) {
	my @ulsstats=stat($ulsdir.'/'.$ulsfn);
$ulsout.=$ulsfn.'&'.join('&',@ulsstats).':';	$ulsout.=$ulsfn.'&'.join('&',@ulsstats).':';
}	}
	closedir(LSDIR);
	}
} else {	} else {
$ulsout='no_such_dir';	$ulsout='no_such_dir';
}	}
if ($ulsout eq '') { $ulsout='empty'; }	if ($ulsout eq '') { $ulsout='empty'; }
print $client "$ulsout\n";	print $client "$ulsout\n";
	# ------------------------------------------------------------------ Hanging up
	} elsif (($userinput =~ /^exit/) \|\|
	($userinput =~ /^init/)) {
	&logthis(
	"Client $clientip ($hostid{$clientip}) hanging up: $userinput");
	print $client "bye\n";
	$client->close();
	last;
# ------------------------------------------------------------- unknown command	# ------------------------------------------------------------- unknown command
} else {	} else {
# unknown command	# unknown command
print $client "unknown_cmd\n";	print $client "unknown_cmd\n";
}	}
# ------------------------------------------------------ client unknown, refuse	# -------------------------------------------------------------------- complete
	alarm(0);
	&status('Listening to '.$hostid{$clientip});
}	}
	# --------------------------------------------- client unknown or fishy, refuse
} else {	} else {
print $client "refused\n";	print $client "refused\n";
	$client->close();
&logthis("<font color=blue>WARNING: "	&logthis("<font color=blue>WARNING: "
."Rejected client $clientip, closing connection</font>");	."Rejected client $clientip, closing connection</font>");
}	}
Line 1024 sub make_new_child {	Line 1386 sub make_new_child {

# tidy up gracefully and finish	# tidy up gracefully and finish

	$client->close();
	$server->close();

# this exit is VERY important, otherwise the child will become	# this exit is VERY important, otherwise the child will become
# a producer of more and more children, forking yourself into	# a producer of more and more children, forking yourself into
# process death.	# process death.
Line 1031 sub make_new_child {	Line 1396 sub make_new_child {
}	}
}	}

	# ----------------------------------- POD (plain old documentation, CPAN style)

	=head1 NAME

	lond - "LON Daemon" Server (port "LOND" 5663)

	=head1 SYNOPSIS

	Should only be run as user=www. Invoked by loncron.

	=head1 DESCRIPTION

	Preforker - server who forks first. Runs as a daemon. HUPs.
	Uses IDEA encryption

	=head1 README

	Not yet written.

	=head1 PREREQUISITES

	IO::Socket
	IO::File
	Apache::File
	Symbol
	POSIX
	Crypt::IDEA
	LWP::UserAgent()
	GDBM_File
	Authen::Krb4

	=head1 COREQUISITES

	=head1 OSNAMES

	linux

	=head1 SCRIPT CATEGORIES

	Server/Process

	=cut

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>

500 Internal Server Error

Internal Server Error

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

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

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

Removed from v.1.30
changed lines
	Added in v.1.66