loncom/lond - diff

Return to lond CVS log

Up to [LON-CAPA] / loncom

Diff for /loncom/lond between versions 1.27 and 1.59

version 1.27, 2000/12/05 19:45:36	version 1.59, 2001/11/27 21:59:07
Line 9	Line 9
# 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
	# 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
#	#
	# $Id$
	###

# 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 37 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 51 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);
}	}

# grabs exception and records it to log before exiting
# NOTE: we must NOT use the regular (non-overrided) die function in
# the code because a handler CANNOT be attached to it
# (despite what some of the documentation says about SIG{__DIE__}.

sub catchdie {
my ($message)=@_;
$SIG{'QUIT'}='DEFAULT';
$SIG{__DIE__}='DEFAULT';
&logthis("<font color=red>CRITICAL: "
."ABNORMAL EXIT. Child $$ for server $wasserver died through "
."\_\_DIE\_\_ with this error msg->[$message]</font>");
if ($client) { print $client "error: $message\n"; }
die($message);
}

# -------------------------------- Set signal handlers to record abnormal exits	# -------------------------------- Set signal handlers to record abnormal exits

$SIG{'QUIT'}=\&catchexception;	$SIG{'QUIT'}=\&catchexception;
Line 62 $SIG{__DIE__}=\&catchexception;	Line 64 $SIG{__DIE__}=\&catchexception;

# ------------------------------------ Read httpd access.conf and get variables	# ------------------------------------ Read httpd access.conf and get variables

open (CONFIG,"/etc/httpd/conf/access.conf")	open (CONFIG,"/etc/httpd/conf/access.conf") \|\| die "Can't read access.conf";
\|\| catchdie "Can't read access.conf";

while ($configline=<CONFIG>) {	while ($configline=<CONFIG>) {
if ($configline =~ /PerlSetVar/) {	if ($configline =~ /PerlSetVar/) {
Line 74 while ($configline=<CONFIG>) {	Line 75 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 82 if (-e $pidfile) {	Line 93 if (-e $pidfile) {
my $lfh=IO::File->new("$pidfile");	my $lfh=IO::File->new("$pidfile");
my $pide=<$lfh>;	my $pide=<$lfh>;
chomp($pide);	chomp($pide);
if (kill 0 => $pide) { catchdie "already running"; }	if (kill 0 => $pide) { die "already running"; }
}	}

$PREFORK=4; # number of children to maintain, at least four spare	$PREFORK=4; # number of children to maintain, at least four spare

# ------------------------------------------------------------- Read hosts file	# ------------------------------------------------------------- Read hosts file

open (CONFIG,"$perlvar{'lonTabDir'}/hosts.tab")	open (CONFIG,"$perlvar{'lonTabDir'}/hosts.tab") \|\| die "Can't read host file";
\|\| catchdie "Can't read host file";

while ($configline=<CONFIG>) {	while ($configline=<CONFIG>) {
my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);	my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);
Line 107 $server = IO::Socket::INET->new(LocalPor	Line 117 $server = IO::Socket::INET->new(LocalPor
Proto => 'tcp',	Proto => 'tcp',
Reuse => 1,	Reuse => 1,
Listen => 10 )	Listen => 10 )
or catchdie "making socket: $@\n";	or die "making socket: $@\n";

# --------------------------------------------------------- Do global variables	# --------------------------------------------------------- Do global variables

Line 129 sub REAPER { # ta	Line 139 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 138 sub HUNTSMAN { # si	Line 149 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");
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');
	map {
	sleep 1;
	unless (kill 'USR1' => $_) {
	&logthis ('Child '.$_.' is dead');
	&logstatus($$.' is dead');
	}
	} sort keys %children;
	}

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

sub logthis {	sub logthis {
Line 152 sub logthis {	Line 177 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";
	}

	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";
	}

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

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

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

Line 290 sub ishome {	Line 340 sub ishome {

$fpid=fork;	$fpid=fork;
exit if $fpid;	exit if $fpid;
catchdie "Couldn't fork: $!" unless defined ($fpid);	die "Couldn't fork: $!" unless defined ($fpid);

POSIX::setsid() or catchdie "Can't start new session: $!";	POSIX::setsid() or die "Can't start new session: $!";

# ------------------------------------------------------- Write our PID on disk	# ------------------------------------------------------- Write our PID on disk

Line 301 open (PIDSAVE,">$execdir/logs/lond.pid")	Line 351 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 311 for (1 .. $PREFORK) {	Line 362 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 331 sub make_new_child {	Line 388 sub make_new_child {
# block signal for fork	# block signal for fork
$sigset = POSIX::SigSet->new(SIGINT);	$sigset = POSIX::SigSet->new(SIGINT);
sigprocmask(SIG_BLOCK, $sigset)	sigprocmask(SIG_BLOCK, $sigset)
or catchdie "Can't block SIGINT for fork: $!\n";	or die "Can't block SIGINT for fork: $!\n";

catchdie "fork: $!" unless defined ($pid = fork);	die "fork: $!" unless defined ($pid = fork);

if ($pid) {	if ($pid) {
# Parent records the child's birth and returns.	# Parent records the child's birth and returns.
sigprocmask(SIG_UNBLOCK, $sigset)	sigprocmask(SIG_UNBLOCK, $sigset)
or catchdie "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;
	$lastlog='Forked ';
	$status='Forked';

# unblock signals	# unblock signals
sigprocmask(SIG_UNBLOCK, $sigset)	sigprocmask(SIG_UNBLOCK, $sigset)
or catchdie "Can't unblock SIGINT for fork: $!\n";	or die "Can't unblock SIGINT for fork: $!\n";

$tmpsnum=0;	$tmpsnum=0;

# 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 365 sub make_new_child {	Line 427 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 381 sub make_new_child {	Line 448 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;
# ------------------------------------------------------------ See if encrypted	# ------------------------------------------------------------ See if encrypted
if ($userinput =~ /^enc/) {	if ($userinput =~ /^enc/) {
Line 450 sub make_new_child {	Line 519 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 469 sub make_new_child {	Line 560 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 494 sub make_new_child {	Line 598 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 508 sub make_new_child {	Line 614 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 522 sub make_new_child {	Line 628 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:$!\n";
	}
	}
	}
	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 565 sub make_new_child {	Line 810 sub make_new_child {
"LWP GET: $message for $fname ($remoteurl)");	"LWP GET: $message for $fname ($remoteurl)");
} else {	} else {
if ($remoteurl!~/\.meta$/) {	if ($remoteurl!~/\.meta$/) {
	my $ua=new LWP::UserAgent;
my $mrequest=	my $mrequest=
new HTTP::Request('GET',$remoteurl.'.meta');	new HTTP::Request('GET',$remoteurl.'.meta');
my $mresponse=	my $mresponse=
Line 612 sub make_new_child {	Line 858 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 647 sub make_new_child {	Line 896 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 772 sub make_new_child {	Line 1021 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 843 sub make_new_child {	Line 1092 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 862 sub make_new_child {	Line 1111 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 908 sub make_new_child {	Line 1158 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 1012 sub make_new_child {	Line 1275 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
	&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 1040 sub make_new_child {	Line 1317 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.

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

Removed from v.1.27
changed lines
	Added in v.1.59