loncom/lond - diff

Return to lond CVS log

Up to [LON-CAPA] / loncom

Diff for /loncom/lond between versions 1.109 and 1.145

version 1.109, 2003/03/01 04:18:22	version 1.145, 2003/09/16 10:13:20
Line 50	Line 50
# population). Since the time averaged connection rate is close to zero	# population). Since the time averaged connection rate is close to zero
# because lonc's purpose is to maintain near continuous connnections,	# because lonc's purpose is to maintain near continuous connnections,
# preforking is not really needed.	# preforking is not really needed.
###	# 08/xx/2003 Ron Fox: Add management requests. Management requests
	# will be validated via a call to ValidateManager. At present, this
	# is done by simple host verification. In the future we can modify
	# this function to do a certificate check.
	# Management functions supported include:
	# - pushing /home/httpd/lonTabs/hosts.tab
	# - pushing /home/httpd/lonTabs/domain.tab
	# 09/08/2003 Ron Fox: Told lond to take care of change logging so we
	# don't have to remember it:
	# $Log$
	# Revision 1.145 2003/09/16 10:13:20 foxr
	# Added ReinitProcess function to oversee the parsing and processing of the
	# reinit:<process> client request.
	#
	# Revision 1.144 2003/09/16 09:47:01 foxr
	# Added skeletal support for SIGUSR2 (update hosts.tab)
	#
	# Revision 1.143 2003/09/15 10:03:52 foxr
	# Completed and tested code for pushfile.
	#
	# Revision 1.142 2003/09/09 20:47:46 www
	# Permanently store chatroom entries in chatroom.log
	#
	# Revision 1.141 2003/09/08 10:32:07 foxr
	# Added PushFile sub This sub oversees the push of a new configuration table file
	# Currently supported files are:
	# - hosts.tab (transaction pushfile:hosts:contents)
	# - domain.tab (transaction pushfile:domain:contents)
	#


	use strict;
use lib '/home/httpd/lib/perl/';	use lib '/home/httpd/lib/perl/';
use LONCAPA::Configuration;	use LONCAPA::Configuration;

use IO::Socket;	use IO::Socket;
use IO::File;	use IO::File;
use Apache::File;	#use Apache::File;
use Symbol;	use Symbol;
use POSIX;	use POSIX;
use Crypt::IDEA;	use Crypt::IDEA;
Line 68 use Authen::Krb4;	Line 97 use Authen::Krb4;
use Authen::Krb5;	use Authen::Krb5;
use lib '/home/httpd/lib/perl/';	use lib '/home/httpd/lib/perl/';
use localauth;	use localauth;
	use File::Copy;

my $DEBUG = 0; # Non zero to enable debug log entries.	my $DEBUG = 0; # Non zero to enable debug log entries.

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

	my $VERSION='$Revision$'; #' stupid emacs
	my $remoteVERSION;
	my $currenthostid;
	my $currentdomainid;

	my $client;
	my $clientip;

	my $server;
	my $thisserver;

	my %hostid;
	my %hostdom;
	my %hostip;
	my %perlvar; # Will have the apache conf defined perl vars.

#	#
# The array below are password error strings."	# The array below are password error strings."
#	#
Line 113 my @adderrors = ("ok",	Line 159 my @adderrors = ("ok",


#	#
	# GetCertificate: Given a transaction that requires a certificate,
	# this function will extract the certificate from the transaction
	# request. Note that at this point, the only concept of a certificate
	# is the hostname to which we are connected.
	#
	# Parameter:
	# request - The request sent by our client (this parameterization may
	# need to change when we really use a certificate granting
	# authority.
	#
	sub GetCertificate {
	my $request = shift;

	return $clientip;
	}


	#
	# ValidManager: Determines if a given certificate represents a valid manager.
	# in this primitive implementation, the 'certificate' is
	# just the connecting loncapa client name. This is checked
	# against a valid client list in the configuration.
	#
	#
	sub ValidManager {
	my $certificate = shift;

	my $hostentry = $hostid{$certificate};
	if ($hostentry ne undef) {
	&logthis('<font color="yellow">Authenticating manager'.
	" $hostentry</font>");
	return 1;
	} else {
	&logthis('<font color="red"> Failed manager authentication '.
	"$certificate </font>");
	}
	}
	#
	# CopyFile: Called as part of the process of installing a
	# new configuration file. This function copies an existing
	# file to a backup file.
	# Parameters:
	# oldfile - Name of the file to backup.
	# newfile - Name of the backup file.
	# Return:
	# 0 - Failure (errno has failure reason).
	# 1 - Success.
	#
	sub CopyFile {
	my $oldfile = shift;
	my $newfile = shift;

	# The file must exist:

	if(-e $oldfile) {

	# Read the old file.

	my $oldfh = IO::File->new("< $oldfile");
	if(!$oldfh) {
	return 0;
	}
	my @contents = <$oldfh>; # Suck in the entire file.

	# write the backup file:

	my $newfh = IO::File->new("> $newfile");
	if(!(defined $newfh)){
	return 0;
	}
	my $lines = scalar @contents;
	for (my $i =0; $i < $lines; $i++) {
	print $newfh ($contents[$i]);
	}

	$oldfh->close;
	$newfh->close;

	chmod(0660, $newfile);

	return 1;

	} else {
	return 0;
	}
	}

	#
	# InstallFile: Called to install an administrative file:
	# - The file is created with <name>.tmp
	# - The <name>.tmp file is then mv'd to <name>
	# This lugubrious procedure is done to ensure that we are never without
	# a valid, even if dated, version of the file regardless of who crashes
	# and when the crash occurs.
	#
	# Parameters:
	# Name of the file
	# File Contents.
	# Return:
	# nonzero - success.
	# 0 - failure and $! has an errno.
	#
	sub InstallFile {
	my $Filename = shift;
	my $Contents = shift;
	my $TempFile = $Filename.".tmp";

	# Open the file for write:

	my $fh = IO::File->new("> $TempFile"); # Write to temp.
	if(!(defined $fh)) {
	&logthis('<font color="red"> Unable to create '.$TempFile."</font>");
	return 0;
	}
	# write the contents of the file:

	print $fh ($Contents);
	$fh->close; # In case we ever have a filesystem w. locking

	chmod(0660, $TempFile);

	# Now we can move install the file in position.

	move($TempFile, $Filename);

	return 1;
	}

	#
	# PushFile: Called to do an administrative push of a file.
	# - Ensure the file being pushed is one we support.
	# - Backup the old file to <filename.saved>
	# - Separate the contents of the new file out from the
	# rest of the request.
	# - Write the new file.
	# Parameter:
	# Request - The entire user request. This consists of a : separated
	# string pushfile:tablename:contents.
	# NOTE: The contents may have :'s in it as well making things a bit
	# more interesting... but not much.
	# Returns:
	# String to send to client ("ok" or "refused" if bad file).
	#
	sub PushFile {
	my $request = shift;
	my ($command, $filename, $contents) = split(":", $request, 3);

	# At this point in time, pushes for only the following tables are
	# supported:
	# hosts.tab ($filename eq host).
	# domain.tab ($filename eq domain).
	# Construct the destination filename or reject the request.
	#
	# lonManage is supposed to ensure this, however this session could be
	# part of some elaborate spoof that managed somehow to authenticate.
	#

	my $tablefile = $perlvar{'lonTabDir'}.'/'; # need to precede with dir.
	if ($filename eq "host") {
	$tablefile .= "hosts.tab";
	} elsif ($filename eq "domain") {
	$tablefile .= "domain.tab";
	} else {
	return "refused";
	}
	#
	# >copy< the old table to the backup table
	# don't rename in case system crashes/reboots etc. in the time
	# window between a rename and write.
	#
	my $backupfile = $tablefile;
	$backupfile =~ s/\.tab$/.old/;
	if(!CopyFile($tablefile, $backupfile)) {
	&logthis('<font color="green"> CopyFile from '.$tablefile." to ".$backupfile." failed </font>");
	return "error:$!";
	}
	&logthis('<font color="green"> Pushfile: backed up '
	.$tablefile." to $backupfile</font>");

	# Install the new file:

	if(!InstallFile($tablefile, $contents)) {
	&logthis('<font color="red"> Pushfile: unable to install '
	.$tablefile." $! </font>");
	return "error:$!";
	}
	else {
	&logthis('<font color="green"> Installed new '.$tablefile
	."</font>");

	}


	# Indicate success:

	return "ok";

	}

	#
	# Called to re-init either lonc or lond.
	#
	# Parameters:
	# request - The full request by the client. This is of the form
	# reinit:<process>
	# where <process> is allowed to be either of
	# lonc or lond
	#
	# Returns:
	# The string to be sent back to the client either:
	# ok - Everything worked just fine.
	# error:why - There was a failure and why describes the reason.
	#
	#
	sub ReinitProcess {
	my $request = shift;

	return 'ok';
	}

	#
# Convert an error return code from lcpasswd to a string value.	# Convert an error return code from lcpasswd to a string value.
#	#
sub lcpasswdstrerror {	sub lcpasswdstrerror {
Line 142 sub catchexception {	Line 409 sub catchexception {
$SIG{'QUIT'}='DEFAULT';	$SIG{'QUIT'}='DEFAULT';
$SIG{__DIE__}='DEFAULT';	$SIG{__DIE__}='DEFAULT';
&logthis("<font color=red>CRITICAL: "	&logthis("<font color=red>CRITICAL: "
."ABNORMAL EXIT. Child $$ for server $wasserver died through "	."ABNORMAL EXIT. Child $$ for server $thisserver died through "
."a crash with this error msg->[$error]</font>");	."a crash with this error msg->[$error]</font>");
&logthis('Famous last words: '.$status.' - '.$lastlog);	&logthis('Famous last words: '.$status.' - '.$lastlog);
if ($client) { print $client "error: $error\n"; }	if ($client) { print $client "error: $error\n"; }
Line 162 $SIG{__DIE__}=\&catchexception;	Line 429 $SIG{__DIE__}=\&catchexception;
# ---------------------------------- Read loncapa_apache.conf and loncapa.conf	# ---------------------------------- Read loncapa_apache.conf and loncapa.conf
&status("Read loncapa.conf and loncapa_apache.conf");	&status("Read loncapa.conf and loncapa_apache.conf");
my $perlvarref=LONCAPA::Configuration::read_conf('loncapa.conf');	my $perlvarref=LONCAPA::Configuration::read_conf('loncapa.conf');
my %perlvar=%{$perlvarref};	%perlvar=%{$perlvarref};
undef $perlvarref;	undef $perlvarref;

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

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

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

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

while ($configline=<CONFIG>) {	while (my $configline=<CONFIG>) {
my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);	my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);
chomp($ip); $ip=~s/\D+$//;	chomp($ip); $ip=~s/\D+$//;
$hostid{$ip}=$id;	$hostid{$ip}=$id;
	$hostdom{$id}=$domain;
	$hostip{$id}=$ip;
if ($id eq $perlvar{'lonHostID'}) { $thisserver=$name; }	if ($id eq $perlvar{'lonHostID'}) { $thisserver=$name; }
$PREFORK++;
}	}
close(CONFIG);	close(CONFIG);

Line 213 $server = IO::Socket::INET->new(LocalPor	Line 479 $server = IO::Socket::INET->new(LocalPor

# global variables	# global variables

$MAX_CLIENTS_PER_CHILD = 50; # number of clients each child should	my %children = (); # keys are current child process IDs
# process	my $children = 0; # current number of children
%children = (); # keys are current child process IDs
$children = 0; # current number of children

sub REAPER { # takes care of dead children	sub REAPER { # takes care of dead children
$SIG{CHLD} = \&REAPER;	$SIG{CHLD} = \&REAPER;
Line 245 sub HUPSMAN { # sig	Line 509 sub HUPSMAN { # sig
kill 'INT' => keys %children;	kill 'INT' => keys %children;
&logthis("Free socket: ".shutdown($server,2)); # 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'};
	unlink("$execdir/logs/lond.pid");
exec("$execdir/lond"); # here we go again	exec("$execdir/lond"); # here we go again
}	}

	#
	# Called in response to a USR2 signal.
	# - Reread hosts.tab
	# - All children connected to hosts that were removed from hosts.tab
	# are killed via SIGINT
	# - All children connected to previously existing hosts are sent SIGUSR1
	# - Our internal hosts hash is updated to reflect the new contents of
	# hosts.tab causing connections from hosts added to hosts.tab to
	# now be honored.
	#
	sub UpdateHosts {
	}

sub checkchildren {	sub checkchildren {
&initnewstatus();	&initnewstatus();
&logstatus();	&logstatus();
&logthis('Going to check on the children');	&logthis('Going to check on the children');
$docdir=$perlvar{'lonDocRoot'};	my $docdir=$perlvar{'lonDocRoot'};
foreach (sort keys %children) {	foreach (sort keys %children) {
sleep 1;	sleep 1;
unless (kill 'USR1' => $_) {	unless (kill 'USR1' => $_) {
Line 263 sub checkchildren {	Line 540 sub checkchildren {
}	}
}	}
sleep 5;	sleep 5;
	$SIG{ALRM} = sub { die "timeout" };
	$SIG{__DIE__} = 'DEFAULT';
foreach (sort keys %children) {	foreach (sort keys %children) {
unless (-e "$docdir/lon-status/londchld/$_.txt") {	unless (-e "$docdir/lon-status/londchld/$_.txt") {
	eval {
	alarm(300);
&logthis('Child '.$_.' did not respond');	&logthis('Child '.$_.' did not respond');
kill 9 => $_;	kill 9 => $_;
$emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}";	#$emailto="$perlvar{'lonAdmEMail'},$perlvar{'lonSysEMail'}";
$subj="LON: $perlvar{'lonHostID'} killed lond process $_";	#$subj="LON: $currenthostid killed lond process $_";
my $result=`echo 'Killed lond process $_.' \| mailto $emailto -s '$subj' > /dev/null`;	#my $result=`echo 'Killed lond process $_.' \| mailto $emailto -s '$subj' > /dev/null`;
$execdir=$perlvar{'lonDaemons'};	#$execdir=$perlvar{'lonDaemons'};
$result=`/bin/cp $execdir/logs/lond.log $execdir/logs/lond.log.$_`	#$result=`/bin/cp $execdir/logs/lond.log $execdir/logs/lond.log.$_`;
	alarm(0);
	}
}	}
}	}
	$SIG{ALRM} = 'DEFAULT';
	$SIG{__DIE__} = \&cathcexception;
}	}

# --------------------------------------------------------------------- Logging	# --------------------------------------------------------------------- Logging
Line 301 sub logstatus {	Line 586 sub logstatus {
my $docdir=$perlvar{'lonDocRoot'};	my $docdir=$perlvar{'lonDocRoot'};
{	{
my $fh=IO::File->new(">>$docdir/lon-status/londstatus.txt");	my $fh=IO::File->new(">>$docdir/lon-status/londstatus.txt");
print $fh $$."\t".$status."\t".$lastlog."\n";	print $fh $$."\t".$currenthostid."\t".$status."\t".$lastlog."\n";
$fh->close();	$fh->close();
}	}
{	{
Line 318 sub initnewstatus {	Line 603 sub initnewstatus {
my $local=localtime($now);	my $local=localtime($now);
print $fh "LOND status $local - parent $$\n\n";	print $fh "LOND status $local - parent $$\n\n";
opendir(DIR,"$docdir/lon-status/londchld");	opendir(DIR,"$docdir/lon-status/londchld");
while ($filename=readdir(DIR)) {	while (my $filename=readdir(DIR)) {
unlink("$docdir/lon-status/londchld/$filename");	unlink("$docdir/lon-status/londchld/$filename");
}	}
closedir(DIR);	closedir(DIR);
Line 362 sub reconlonc {	Line 647 sub reconlonc {
if (kill 0 => $loncpid) {	if (kill 0 => $loncpid) {
&logthis("lonc at pid $loncpid responding, sending USR1");	&logthis("lonc at pid $loncpid responding, sending USR1");
kill USR1 => $loncpid;	kill USR1 => $loncpid;
sleep 5;
if (-e "$peerfile") { return; }
&logthis("$peerfile still not there, give it another try");
sleep 10;
if (-e "$peerfile") { return; }
&logthis(
"<font color=blue>WARNING: $peerfile still not there, giving up</font>");
} else {	} else {
&logthis(	&logthis(
"<font color=red>CRITICAL: "	"<font color=red>CRITICAL: "
Line 398 sub subreply {	Line 676 sub subreply {
sub reply {	sub reply {
my ($cmd,$server)=@_;	my ($cmd,$server)=@_;
my $answer;	my $answer;
if ($server ne $perlvar{'lonHostID'}) {	if ($server ne $currenthostid) {
$answer=subreply($cmd,$server);	$answer=subreply($cmd,$server);
if ($answer eq 'con_lost') {	if ($answer eq 'con_lost') {
$answer=subreply("ping",$server);	$answer=subreply("ping",$server);
if ($answer ne $server) {	if ($answer ne $server) {
&logthis("sub reply: answer != server");	&logthis("sub reply: answer != server answer is $answer, server is $server");
&reconlonc("$perlvar{'lonSockDir'}/$server");	&reconlonc("$perlvar{'lonSockDir'}/$server");
}	}
$answer=subreply($cmd,$server);	$answer=subreply($cmd,$server);
Line 467 sub ishome {	Line 745 sub ishome {
# ======================================================= Continue main program	# ======================================================= Continue main program
# ---------------------------------------------------- Fork once and dissociate	# ---------------------------------------------------- Fork once and dissociate

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

Line 475 POSIX::setsid() or die "Can't start new	Line 753 POSIX::setsid() or die "Can't start new

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

$execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
open (PIDSAVE,">$execdir/logs/lond.pid");	open (PIDSAVE,">$execdir/logs/lond.pid");
print PIDSAVE "$$\n";	print PIDSAVE "$$\n";
close(PIDSAVE);	close(PIDSAVE);
Line 491 $SIG{CHLD} = \&REAPER;	Line 769 $SIG{CHLD} = \&REAPER;
$SIG{INT} = $SIG{TERM} = \&HUNTSMAN;	$SIG{INT} = $SIG{TERM} = \&HUNTSMAN;
$SIG{HUP} = \&HUPSMAN;	$SIG{HUP} = \&HUPSMAN;
$SIG{USR1} = \&checkchildren;	$SIG{USR1} = \&checkchildren;
	$SIG{USR2} = \&UpdateHosts;


# --------------------------------------------------------------	# --------------------------------------------------------------
Line 505 while (1) {	Line 783 while (1) {
}	}

sub make_new_child {	sub make_new_child {
my $client;
my $pid;	my $pid;
my $cipher;	my $cipher;
my $sigset;	my $sigset;
Line 516 sub make_new_child {	Line 793 sub make_new_child {
$sigset = POSIX::SigSet->new(SIGINT);	$sigset = POSIX::SigSet->new(SIGINT);
sigprocmask(SIG_BLOCK, $sigset)	sigprocmask(SIG_BLOCK, $sigset)
or die "Can't block SIGINT for fork: $!\n";	or die "Can't block SIGINT for fork: $!\n";

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

if ($pid) {	if ($pid) {
Line 530 sub make_new_child {	Line 807 sub make_new_child {
} 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{CHLD} = 'DEFAULT'; #make this default so that pwauth returns
	#don't get intercepted
$SIG{USR1}= \&logstatus;	$SIG{USR1}= \&logstatus;
$SIG{ALRM}= \&timeout;	$SIG{ALRM}= \&timeout;
$lastlog='Forked ';	$lastlog='Forked ';
Line 539 sub make_new_child {	Line 818 sub make_new_child {
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";

$tmpsnum=0;	my $tmpsnum=0;
#---------------------------------------------------- kerberos 5 initialization	#---------------------------------------------------- kerberos 5 initialization
&Authen::Krb5::init_context();	&Authen::Krb5::init_context();
&Authen::Krb5::init_ets();	&Authen::Krb5::init_ets();
Line 553 sub make_new_child {	Line 832 sub make_new_child {
# see if we know client and check for spoof IP by challenge	# see if we know client and check for spoof IP by challenge
my $caller = getpeername($client);	my $caller = getpeername($client);
my ($port,$iaddr)=unpack_sockaddr_in($caller);	my ($port,$iaddr)=unpack_sockaddr_in($caller);
my $clientip=inet_ntoa($iaddr);	$clientip=inet_ntoa($iaddr);
my $clientrec=($hostid{$clientip} ne undef);	my $clientrec=($hostid{$clientip} ne undef);
&logthis(	&logthis(
"<font color=yellow>INFO: Connection $i, $clientip ($hostid{$clientip})</font>"	"<font color=yellow>INFO: Connection, $clientip ($hostid{$clientip})</font>"
);	);
&status("Connecting $clientip ($hostid{$clientip})");	&status("Connecting $clientip ($hostid{$clientip})");
my $clientok;	my $clientok;
if ($clientrec) {	if ($clientrec) {
&status("Waiting for init from $clientip ($hostid{$clientip})");	&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 =~ /^init/) {
	&sethost("sethost:$perlvar{'lonHostID'}");
my $challenge="$$".time;	my $challenge="$$".time;
print $client "$challenge\n";	print $client "$challenge\n";
&status(	&status(
Line 593 sub make_new_child {	Line 873 sub make_new_child {
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}");	foreach my $id (keys(%hostip)) {
&logthis(	if ($hostip{$id} ne $clientip \|\|
"<font color=green>Established connection: $hostid{$clientip}</font>");	$hostip{$currenthostid} eq $clientip) {
	# no need to try to do recon's to myself
	next;
	}
	&reconlonc("$perlvar{'lonSockDir'}/$id");
	}
	&logthis("<font color=green>Established connection: $hostid{$clientip}</font>");
&status('Will listen to '.$hostid{$clientip});	&status('Will listen to '.$hostid{$clientip});
# ------------------------------------------------------------ Process requests	# ------------------------------------------------------------ Process requests
while (my $userinput=<$client>) {	while (my $userinput=<$client>) {
Line 623 sub make_new_child {	Line 909 sub make_new_child {
# ------------------------------------------------------------- Normal commands	# ------------------------------------------------------------- Normal commands
# ------------------------------------------------------------------------ ping	# ------------------------------------------------------------------------ ping
if ($userinput =~ /^ping/) {	if ($userinput =~ /^ping/) {
print $client "$perlvar{'lonHostID'}\n";	print $client "$currenthostid\n";
# ------------------------------------------------------------------------ pong	# ------------------------------------------------------------------------ pong
} elsif ($userinput =~ /^pong/) {	}elsif ($userinput =~ /^pong/) {
$reply=reply("ping",$hostid{$clientip});	my $reply=&reply("ping",$hostid{$clientip});
print $client "$perlvar{'lonHostID'}:$reply\n";	print $client "$currenthostid:$reply\n";
# ------------------------------------------------------------------------ ekey	# ------------------------------------------------------------------------ ekey
} elsif ($userinput =~ /^ekey/) {	} elsif ($userinput =~ /^ekey/) {
my $buildkey=time.$$.int(rand 100000);	my $buildkey=time.$$.int(rand 100000);
$buildkey=~tr/1-6/A-F/;	$buildkey=~tr/1-6/A-F/;
$buildkey=int(rand 100000).$buildkey.int(rand 100000);	$buildkey=int(rand 100000).$buildkey.int(rand 100000);
my $key=$perlvar{'lonHostID'}.$hostid{$clientip};	my $key=$currenthostid.$hostid{$clientip};
$key=~tr/a-z/A-Z/;	$key=~tr/a-z/A-Z/;
$key=~tr/G-P/0-9/;	$key=~tr/G-P/0-9/;
$key=~tr/Q-Z/0-9/;	$key=~tr/Q-Z/0-9/;
Line 650 sub make_new_child {	Line 936 sub make_new_child {
$loadavg=<$loadfile>;	$loadavg=<$loadfile>;
}	}
$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";
	# -------------------------------------------------------------------- userload
	} elsif ($userinput =~ /^userload/) {
	my $userloadpercent=&userload();
	print $client "$userloadpercent\n";

	#
	# Transactions requiring encryption:
	#
# ----------------------------------------------------------------- currentauth	# ----------------------------------------------------------------- currentauth
} elsif ($userinput =~ /^currentauth/) {	} elsif ($userinput =~ /^currentauth/) {
if ($wasenc==1) {	if ($wasenc==1) {
Line 666 sub make_new_child {	Line 960 sub make_new_child {
} else {	} else {
print $client "refused\n";	print $client "refused\n";
}	}
	#--------------------------------------------------------------------- pushfile
	} elsif($userinput =~ /^pushfile/) {
	if($wasenc == 1) {
	my $cert = GetCertificate($userinput);
	if(ValidManager($cert)) {
	my $reply = PushFile($userinput);
	print $client "$reply\n";
	} else {
	print $client "refused\n";
	}
	} else {
	print $client "refused\n";
	}
	#--------------------------------------------------------------------- reinit
	} elsif($userinput =~ /^reinit/) {
	if ($wasenc == 1) {
	my $cert = GetCertificate($userinput);
	if(ValidManager($cert)) {
	my $reply = ReinitProcess($userinput);
	print $client "$reply\n";
	} else {
	print $client "refused\n";
	}
	} else {
	print $client "refused\n";
	}
# ------------------------------------------------------------------------ auth	# ------------------------------------------------------------------------ auth
} elsif ($userinput =~ /^auth/) {	} elsif ($userinput =~ /^auth/) {
if ($wasenc==1) {	if ($wasenc==1) {
Line 706 sub make_new_child {	Line 1026 sub make_new_child {
}	}
}	}
} elsif ($howpwd eq 'krb4') {	} elsif ($howpwd eq 'krb4') {
$null=pack("C",0);	my $null=pack("C",0);
unless ($upass=~/$null/) {	unless ($upass=~/$null/) {
my $krb4_error = &Authen::Krb4::get_pw_in_tkt	my $krb4_error = &Authen::Krb4::get_pw_in_tkt
($uname,"",$contentpwd,'krbtgt',	($uname,"",$contentpwd,'krbtgt',
Line 723 sub make_new_child {	Line 1043 sub make_new_child {
}	}
}	}
} elsif ($howpwd eq 'krb5') {	} elsif ($howpwd eq 'krb5') {
$null=pack("C",0);	my $null=pack("C",0);
unless ($upass=~/$null/) {	unless ($upass=~/$null/) {
my $krbclient=&Authen::Krb5::parse_name($uname.'@'.$contentpwd);	my $krbclient=&Authen::Krb5::parse_name($uname.'@'.$contentpwd);
my $krbservice="krbtgt/".$contentpwd."\@".$contentpwd;	my $krbservice="krbtgt/".$contentpwd."\@".$contentpwd;
Line 777 sub make_new_child {	Line 1097 sub make_new_child {
my $salt=time;	my $salt=time;
$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");	{
print $pf "internal:$ncpass\n"; }	my $pf;
&logthis("Result of password change for $uname: pwchange_success");	if ($pf = IO::File->new(">$passfilename")) {
print $client "ok\n";	print $pf "internal:$ncpass\n";
	&logthis("Result of password change for $uname: pwchange_success");
	print $client "ok\n";
	} else {
	&logthis("Unable to open $uname passwd to change password");
	print $client "non_authorized\n";
	}
	}

} else {	} else {
print $client "non_authorized\n";	print $client "non_authorized\n";
}	}
Line 807 sub make_new_child {	Line 1135 sub make_new_child {
if ($pwdcorrect) {	if ($pwdcorrect) {
my $execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
&Debug("Opening lcpasswd pipeline");	&Debug("Opening lcpasswd pipeline");
my $pf = IO::File->new("\|$execdir/lcpasswd > /home/www/lcpasswd.log");	my $pf = IO::File->new("\|$execdir/lcpasswd > $perlvar{'lonDaemons'}/logs/lcpasswd.log");
print $pf "$uname\n$npass\n$npass\n";	print $pf "$uname\n$npass\n$npass\n";
close $pf;	close $pf;
my $err = $?;	my $err = $?;
Line 845 sub make_new_child {	Line 1173 sub make_new_child {
$passfilename);	$passfilename);
if (-e $passfilename) {	if (-e $passfilename) {
print $client "already_exists\n";	print $client "already_exists\n";
} elsif ($udom ne $perlvar{'lonDefDomain'}) {	} elsif ($udom ne $currentdomainid) {
print $client "not_right_domain\n";	print $client "not_right_domain\n";
} else {	} else {
@fpparts=split(/\//,$proname);	my @fpparts=split(/\//,$proname);
$fpnow=$fpparts[0].'/'.$fpparts[1].'/'.$fpparts[2];	my $fpnow=$fpparts[0].'/'.$fpparts[1].'/'.$fpparts[2];
$fperror='';	my $fperror='';
for ($i=3;$i<=$#fpparts;$i++) {	for (my $i=3;$i<=$#fpparts;$i++) {
$fpnow.='/'.$fpparts[$i];	$fpnow.='/'.$fpparts[$i];
unless (-e $fpnow) {	unless (-e $fpnow) {
unless (mkdir($fpnow,0777)) {	unless (mkdir($fpnow,0777)) {
$fperror="error: ".($!+0)	$fperror="error: ".($!+0)
." mkdir failed\n";	." mkdir failed while attempting "
	."makeuser\n";
}	}
}	}
}	}
Line 884 sub make_new_child {	Line 1213 sub make_new_child {
$npass=&unescape($npass);	$npass=&unescape($npass);
my $proname=&propath($udom,$uname);	my $proname=&propath($udom,$uname);
my $passfilename="$proname/passwd";	my $passfilename="$proname/passwd";
if ($udom ne $perlvar{'lonDefDomain'}) {	if ($udom ne $currentdomainid) {
print $client "not_right_domain\n";	print $client "not_right_domain\n";
} else {	} else {
my $result=&make_passwd_file($uname, $umode,$npass,	my $result=&make_passwd_file($uname, $umode,$npass,
Line 914 sub make_new_child {	Line 1243 sub make_new_child {
$uid,$gid,$rdev,$size,	$uid,$gid,$rdev,$size,
$atime,$mtime,$ctime,	$atime,$mtime,$ctime,
$blksize,$blocks)=stat($fname);	$blksize,$blocks)=stat($fname);
$now=time;	my $now=time;
$since=$now-$atime;	my $since=$now-$atime;
if ($since>$perlvar{'lonExpire'}) {	if ($since>$perlvar{'lonExpire'}) {
$reply=	my $reply=
reply("unsub:$fname","$hostid{$clientip}");	&reply("unsub:$fname","$hostid{$clientip}");
unlink("$fname");	unlink("$fname");
} else {	} else {
my $transname="$fname.in.transfer";	my $transname="$fname.in.transfer";
Line 989 sub make_new_child {	Line 1318 sub make_new_child {
} elsif ($userinput =~ /^tokenauthuserfile/) {	} elsif ($userinput =~ /^tokenauthuserfile/) {
my ($cmd,$fname,$session)=split(/:/,$userinput);	my ($cmd,$fname,$session)=split(/:/,$userinput);
chomp($session);	chomp($session);
$reply='non_auth';	my $reply='non_auth';
if (open(ENVIN,$perlvar{'lonIDsDir'}.'/'.	if (open(ENVIN,$perlvar{'lonIDsDir'}.'/'.
$session.'.id')) {	$session.'.id')) {
while ($line=<ENVIN>) {	while (my $line=<ENVIN>) {
if ($line=~/userfile\.$fname\=/) { $reply='ok'; }	if ($line=~/userfile\.$fname\=/) { $reply='ok'; }
}	}
close(ENVIN);	close(ENVIN);
print $client $reply."\n";	print $client $reply."\n";
} else {	} else {
print $client "invalid_token\n";	print $client "invalid_token\n";
}	}
# ----------------------------------------------------------------- unsubscribe	# ----------------------------------------------------------------- unsubscribe
} elsif ($userinput =~ /^unsub/) {	} elsif ($userinput =~ /^unsub/) {
Line 1028 sub make_new_child {	Line 1357 sub make_new_child {
print $client "ok\n";	print $client "ok\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." IO::File->new Failed\n";	." IO::File->new Failed "
	."while attempting log\n";
}	}
}	}
# ------------------------------------------------------------------------- put	# ------------------------------------------------------------------------- put
Line 1048 sub make_new_child {	Line 1378 sub make_new_child {
) { print $hfh "P:$now:$what\n"; }	) { print $hfh "P:$now:$what\n"; }
}	}
my @pairs=split(/\&/,$what);	my @pairs=split(/\&/,$what);
if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT,0640)) {	my %hash;
foreach $pair (@pairs) {	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {
($key,$value)=split(/=/,$pair);	foreach my $pair (@pairs) {
	my ($key,$value)=split(/=/,$pair);
$hash{$key}=$value;	$hash{$key}=$value;
}	}
if (untie(%hash)) {	if (untie(%hash)) {
print $client "ok\n";	print $client "ok\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) failed\n";	." untie(GDBM) failed ".
	"while attempting put\n";
}	}
} else {	} else {
print $client "error: ".($!)	print $client "error: ".($!)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting put\n";
}	}
} else {	} else {
print $client "refused\n";	print $client "refused\n";
Line 1088 sub make_new_child {	Line 1421 sub make_new_child {
}	}
}	}
my @pairs=split(/\&/,$what);	my @pairs=split(/\&/,$what);
if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT,0640)) {	my %hash;
foreach $pair (@pairs) {	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {
($key,$value)=split(/=/,$pair);	foreach my $pair (@pairs) {
	my ($key,$value)=split(/=/,$pair);
&ManagePermissions($key, $udom, $uname,	&ManagePermissions($key, $udom, $uname,
&GetAuthType( $udom,	&GetAuthType( $udom,
$uname));	$uname));
$hash{$key}=$value;	$hash{$key}=$value;

}	}
if (untie(%hash)) {	if (untie(%hash)) {
print $client "ok\n";	print $client "ok\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting rolesput\n";
	}
	} else {
	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting rolesput\n";
	}
	} else {
	print $client "refused\n";
	}
	# -------------------------------------------------------------------- rolesdel
	} elsif ($userinput =~ /^rolesdel/) {
	&Debug("rolesdel");
	if ($wasenc==1) {
	my ($cmd,$exedom,$exeuser,$udom,$uname,$what)
	=split(/:/,$userinput);
	&Debug("cmd = ".$cmd." exedom= ".$exedom.
	"user = ".$exeuser." udom=".$udom.
	"what = ".$what);
	my $namespace='roles';
	chomp($what);
	my $proname=propath($udom,$uname);
	my $now=time;
	{
	my $hfh;
	if (
	$hfh=IO::File->new(">>$proname/$namespace.hist")
	) {
	print $hfh "D:$now:$exedom:$exeuser:$what\n";
	}
	}
	my @rolekeys=split(/\&/,$what);
	my %hash;
	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {
	foreach my $key (@rolekeys) {
	delete $hash{$key};
	}
	if (untie(%hash)) {
	print $client "ok\n";
	} else {
	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting rolesdel\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting rolesdel\n";
}	}
} else {	} else {
print $client "refused\n";	print $client "refused\n";
Line 1120 sub make_new_child {	Line 1497 sub make_new_child {
my @queries=split(/\&/,$what);	my @queries=split(/\&/,$what);
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)) {	my %hash;
for ($i=0;$i<=$#queries;$i++) {	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {
	for (my $i=0;$i<=$#queries;$i++) {
$qresult.="$hash{$queries[$i]}&";	$qresult.="$hash{$queries[$i]}&";
}	}
if (untie(%hash)) {	if (untie(%hash)) {
Line 1129 sub make_new_child {	Line 1507 sub make_new_child {
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting get\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	if ($!+0 == 2) {
." tie(GDBM) Failed\n";	print $client "error:No such file or ".
	"GDBM reported bad block error\n";
	} else {
	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting get\n";
	}
}	}
# ------------------------------------------------------------------------ eget	# ------------------------------------------------------------------------ eget
} elsif ($userinput =~ /^eget/) {	} elsif ($userinput =~ /^eget/) {
Line 1145 sub make_new_child {	Line 1530 sub make_new_child {
my @queries=split(/\&/,$what);	my @queries=split(/\&/,$what);
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)) {	my %hash;
for ($i=0;$i<=$#queries;$i++) {	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {
	for (my $i=0;$i<=$#queries;$i++) {
$qresult.="$hash{$queries[$i]}&";	$qresult.="$hash{$queries[$i]}&";
}	}
if (untie(%hash)) {	if (untie(%hash)) {
Line 1167 sub make_new_child {	Line 1553 sub make_new_child {
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting eget\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting eget\n";
}	}
# ------------------------------------------------------------------------- del	# ------------------------------------------------------------------------- del
} elsif ($userinput =~ /^del/) {	} elsif ($userinput =~ /^del/) {
Line 1189 sub make_new_child {	Line 1577 sub make_new_child {
) { print $hfh "D:$now:$what\n"; }	) { print $hfh "D:$now:$what\n"; }
}	}
my @keys=split(/\&/,$what);	my @keys=split(/\&/,$what);
if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT,0640)) {	my %hash;
foreach $key (@keys) {	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {
	foreach my $key (@keys) {
delete($hash{$key});	delete($hash{$key});
}	}
if (untie(%hash)) {	if (untie(%hash)) {
print $client "ok\n";	print $client "ok\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting del\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting del\n";
}	}
# ------------------------------------------------------------------------ keys	# ------------------------------------------------------------------------ keys
} elsif ($userinput =~ /^keys/) {	} elsif ($userinput =~ /^keys/) {
Line 1211 sub make_new_child {	Line 1602 sub make_new_child {
$namespace=~s/\W//g;	$namespace=~s/\W//g;
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)) {	my %hash;
foreach $key (keys %hash) {	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {
	foreach my $key (keys %hash) {
$qresult.="$key&";	$qresult.="$key&";
}	}
if (untie(%hash)) {	if (untie(%hash)) {
Line 1220 sub make_new_child {	Line 1612 sub make_new_child {
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting keys\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting keys\n";
}	}
# ----------------------------------------------------------------- dumpcurrent	# ----------------------------------------------------------------- dumpcurrent
} elsif ($userinput =~ /^currentdump/) {	} elsif ($userinput =~ /^currentdump/) {
Line 1234 sub make_new_child {	Line 1628 sub make_new_child {
$namespace=~s/\W//g;	$namespace=~s/\W//g;
my $qresult='';	my $qresult='';
my $proname=propath($udom,$uname);	my $proname=propath($udom,$uname);
	my %hash;
if (tie(%hash,'GDBM_File',	if (tie(%hash,'GDBM_File',
"$proname/$namespace.db",	"$proname/$namespace.db",
&GDBM_READER(),0640)) {	&GDBM_READER(),0640)) {
Line 1263 sub make_new_child {	Line 1658 sub make_new_child {
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting currentdump\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting currentdump\n";
}	}
# ------------------------------------------------------------------------ dump	# ------------------------------------------------------------------------ dump
} elsif ($userinput =~ /^dump/) {	} elsif ($userinput =~ /^dump/) {
Line 1282 sub make_new_child {	Line 1679 sub make_new_child {
}	}
my $qresult='';	my $qresult='';
my $proname=propath($udom,$uname);	my $proname=propath($udom,$uname);
if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {	my %hash;
	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {
study($regexp);	study($regexp);
while (($key,$value) = each(%hash)) {	while (my ($key,$value) = each(%hash)) {
if ($regexp eq '.') {	if ($regexp eq '.') {
$qresult.=$key.'='.$value.'&';	$qresult.=$key.'='.$value.'&';
} else {	} else {
Line 1299 sub make_new_child {	Line 1697 sub make_new_child {
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting dump\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting dump\n";
}	}
# ----------------------------------------------------------------------- store	# ----------------------------------------------------------------------- store
} elsif ($userinput =~ /^store/) {	} elsif ($userinput =~ /^store/) {
Line 1322 sub make_new_child {	Line 1722 sub make_new_child {
) { print $hfh "P:$now:$rid:$what\n"; }	) { print $hfh "P:$now:$rid:$what\n"; }
}	}
my @pairs=split(/\&/,$what);	my @pairs=split(/\&/,$what);
	my %hash;
if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT,0640)) {	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {
my @previouskeys=split(/&/,$hash{"keys:$rid"});	my @previouskeys=split(/&/,$hash{"keys:$rid"});
my $key;	my $key;
$hash{"version:$rid"}++;	$hash{"version:$rid"}++;
my $version=$hash{"version:$rid"};	my $version=$hash{"version:$rid"};
my $allkeys='';	my $allkeys='';
foreach $pair (@pairs) {	foreach my $pair (@pairs) {
($key,$value)=split(/=/,$pair);	my ($key,$value)=split(/=/,$pair);
$allkeys.=$key.':';	$allkeys.=$key.':';
$hash{"$version:$rid:$key"}=$value;	$hash{"$version:$rid:$key"}=$value;
}	}
Line 1341 sub make_new_child {	Line 1741 sub make_new_child {
print $client "ok\n";	print $client "ok\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting store\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting store\n";
}	}
} else {	} else {
print $client "refused\n";	print $client "refused\n";
Line 1359 sub make_new_child {	Line 1761 sub make_new_child {
chomp($rid);	chomp($rid);
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)) {	my %hash;
	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {
my $version=$hash{"version:$rid"};	my $version=$hash{"version:$rid"};
$qresult.="version=$version&";	$qresult.="version=$version&";
my $scope;	my $scope;
Line 1377 sub make_new_child {	Line 1780 sub make_new_child {
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting restore\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting restore\n";
}	}
# -------------------------------------------------------------------- chatsend	# -------------------------------------------------------------------- chatsend
} elsif ($userinput =~ /^chatsend/) {	} elsif ($userinput =~ /^chatsend/) {
Line 1390 sub make_new_child {	Line 1795 sub make_new_child {
print $client "ok\n";	print $client "ok\n";
# -------------------------------------------------------------------- chatretr	# -------------------------------------------------------------------- chatretr
} elsif ($userinput =~ /^chatretr/) {	} elsif ($userinput =~ /^chatretr/) {
my ($cmd,$cdom,$cnum)=split(/\:/,$userinput);	my
	($cmd,$cdom,$cnum,$udom,$uname)=split(/\:/,$userinput);
my $reply='';	my $reply='';
foreach (&getchat($cdom,$cnum)) {	foreach (&getchat($cdom,$cnum,$udom,$uname)) {
$reply.=&escape($_).':';	$reply.=&escape($_).':';
}	}
$reply=~s/\:$//;	$reply=~s/\:$//;
Line 1421 sub make_new_child {	Line 1827 sub make_new_child {
}	}
else {	else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." IO::File->new Failed\n";	." IO::File->new Failed ".
	"while attempting queryreply\n";
}	}
	# ----------------------------------------------------------------- courseidput
	} elsif ($userinput =~ /^courseidput/) {
	my ($cmd,$udom,$what)=split(/:/,$userinput);
	chomp($what);
	$udom=~s/\W//g;
	my $proname=
	"$perlvar{'lonUsersDir'}/$udom/nohist_courseids";
	my $now=time;
	my @pairs=split(/\&/,$what);
	my %hash;
	if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_WRCREAT(),0640)) {
	foreach my $pair (@pairs) {
	my ($key,$value)=split(/=/,$pair);
	$hash{$key}=$value.':'.$now;
	}
	if (untie(%hash)) {
	print $client "ok\n";
	} else {
	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting courseidput\n";
	}
	} else {
	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting courseidput\n";
	}
	# ---------------------------------------------------------------- courseiddump
	} elsif ($userinput =~ /^courseiddump/) {
	my ($cmd,$udom,$since,$description)
	=split(/:/,$userinput);
	if (defined($description)) {
	$description=&unescape($description);
	} else {
	$description='.';
	}
	unless (defined($since)) { $since=0; }
	my $qresult='';
	my $proname=
	"$perlvar{'lonUsersDir'}/$udom/nohist_courseids";
	my %hash;
	if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_READER(),0640)) {
	while (my ($key,$value) = each(%hash)) {
	my ($descr,$lasttime)=split(/\:/,$value);
	if ($lasttime<$since) { next; }
	if ($description eq '.') {
	$qresult.=$key.'='.$descr.'&';
	} else {
	my $unescapeVal = &unescape($descr);
	if (eval('$unescapeVal=~/$description/i')) {
	$qresult.="$key=$descr&";
	}
	}
	}
	if (untie(%hash)) {
	chop($qresult);
	print $client "$qresult\n";
	} else {
	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting courseiddump\n";
	}
	} else {
	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting courseiddump\n";
	}
# ----------------------------------------------------------------------- idput	# ----------------------------------------------------------------------- idput
} elsif ($userinput =~ /^idput/) {	} elsif ($userinput =~ /^idput/) {
my ($cmd,$udom,$what)=split(/:/,$userinput);	my ($cmd,$udom,$what)=split(/:/,$userinput);
Line 1437 sub make_new_child {	Line 1911 sub make_new_child {
) { print $hfh "P:$now:$what\n"; }	) { print $hfh "P:$now:$what\n"; }
}	}
my @pairs=split(/\&/,$what);	my @pairs=split(/\&/,$what);
if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_WRCREAT,0640)) {	my %hash;
foreach $pair (@pairs) {	if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_WRCREAT(),0640)) {
($key,$value)=split(/=/,$pair);	foreach my $pair (@pairs) {
	my ($key,$value)=split(/=/,$pair);
$hash{$key}=$value;	$hash{$key}=$value;
}	}
if (untie(%hash)) {	if (untie(%hash)) {
print $client "ok\n";	print $client "ok\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting idput\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting idput\n";
}	}
# ----------------------------------------------------------------------- idget	# ----------------------------------------------------------------------- idget
} elsif ($userinput =~ /^idget/) {	} elsif ($userinput =~ /^idget/) {
Line 1460 sub make_new_child {	Line 1937 sub make_new_child {
my $proname="$perlvar{'lonUsersDir'}/$udom/ids";	my $proname="$perlvar{'lonUsersDir'}/$udom/ids";
my @queries=split(/\&/,$what);	my @queries=split(/\&/,$what);
my $qresult='';	my $qresult='';
if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_READER,0640)) {	my %hash;
for ($i=0;$i<=$#queries;$i++) {	if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_READER(),0640)) {
	for (my $i=0;$i<=$#queries;$i++) {
$qresult.="$hash{$queries[$i]}&";	$qresult.="$hash{$queries[$i]}&";
}	}
if (untie(%hash)) {	if (untie(%hash)) {
$qresult=~s/\&$//;	$qresult=~s/\&$//;
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." untie(GDBM) Failed\n";	." untie(GDBM) Failed ".
	"while attempting idget\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
." tie(GDBM) Failed\n";	." tie(GDBM) Failed ".
	"while attempting idget\n";
}	}
# ---------------------------------------------------------------------- tmpput	# ---------------------------------------------------------------------- tmpput
} elsif ($userinput =~ /^tmpput/) {	} elsif ($userinput =~ /^tmpput/) {
Line 1491 sub make_new_child {	Line 1971 sub make_new_child {
}	}
else {	else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
."IO::File->new Failed\n";	."IO::File->new Failed ".
	"while attempting tmpput\n";
}	}

# ---------------------------------------------------------------------- tmpget	# ---------------------------------------------------------------------- tmpget
Line 1508 sub make_new_child {	Line 1989 sub make_new_child {
}	}
else {	else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
."IO::File->new Failed\n";	."IO::File->new Failed ".
	"while attempting tmpget\n";
}	}

	# ---------------------------------------------------------------------- tmpdel
	} elsif ($userinput =~ /^tmpdel/) {
	my ($cmd,$id)=split(/:/,$userinput);
	chomp($id);
	$id=~s/\W/\_/g;
	my $execdir=$perlvar{'lonDaemons'};
	if (unlink("$execdir/tmp/$id.tmp")) {
	print $client "ok\n";
	} else {
	print $client "error: ".($!+0)
	."Unlink tmp Failed ".
	"while attempting tmpdel\n";
	}
# -------------------------------------------------------------------------- ls	# -------------------------------------------------------------------------- ls
} elsif ($userinput =~ /^ls/) {	} elsif ($userinput =~ /^ls/) {
my ($cmd,$ulsdir)=split(/:/,$userinput);	my ($cmd,$ulsdir)=split(/:/,$userinput);
Line 1535 sub make_new_child {	Line 2030 sub make_new_child {
}	}
if ($ulsout eq '') { $ulsout='empty'; }	if ($ulsout eq '') { $ulsout='empty'; }
print $client "$ulsout\n";	print $client "$ulsout\n";
	# ----------------------------------------------------------------- setannounce
	} elsif ($userinput =~ /^setannounce/) {
	my ($cmd,$announcement)=split(/:/,$userinput);
	chomp($announcement);
	$announcement=&unescape($announcement);
	if (my $store=IO::File->new('>'.$perlvar{'lonDocRoot'}.
	'/announcement.txt')) {
	print $store $announcement;
	close $store;
	print $client "ok\n";
	} else {
	print $client "error: ".($!+0)."\n";
	}
# ------------------------------------------------------------------ Hanging up	# ------------------------------------------------------------------ Hanging up
} elsif (($userinput =~ /^exit/) \|\|	} elsif (($userinput =~ /^exit/) \|\|
($userinput =~ /^init/)) {	($userinput =~ /^init/)) {
Line 1544 sub make_new_child {	Line 2052 sub make_new_child {
$client->close();	$client->close();
last;	last;
# ------------------------------------------------------------- unknown command	# ------------------------------------------------------------- unknown command
	} elsif ($userinput =~ /^sethost:/) {
	print $client &sethost($userinput)."\n";
	} elsif ($userinput =~/^version:/) {
	print $client &version($userinput)."\n";
} else {	} else {
# unknown command	# unknown command
print $client "unknown_cmd\n";	print $client "unknown_cmd\n";
Line 1594 sub ManagePermissions	Line 2106 sub ManagePermissions
my $authtype= shift;	my $authtype= shift;

# See if the request is of the form /$domain/_au	# See if the request is of the form /$domain/_au
	&logthis("ruequest is $request");
if($request =~ /^(\/$domain\/_au)$/) { # It's an author rolesput...	if($request =~ /^(\/$domain\/_au)$/) { # It's an author rolesput...
my $execdir = $perlvar{'lonDaemons'};	my $execdir = $perlvar{'lonDaemons'};
my $userhome= "/home/$user" ;	my $userhome= "/home/$user" ;
Debug("system $execdir/lchtmldir $userhome $system $authtype");	&logthis("system $execdir/lchtmldir $userhome $user $authtype");
system("$execdir/lchtmldir $userhome $user $authtype");	system("$execdir/lchtmldir $userhome $user $authtype");
}	}
}	}
Line 1641 sub addline {	Line 2153 sub addline {
my $found=0;	my $found=0;
my $expr='^'.$hostid.':'.$ip.':';	my $expr='^'.$hostid.':'.$ip.':';
$expr =~ s/\./\\\./g;	$expr =~ s/\./\\\./g;
	my $sh;
if ($sh=IO::File->new("$fname.subscription")) {	if ($sh=IO::File->new("$fname.subscription")) {
while (my $subline=<$sh>) {	while (my $subline=<$sh>) {
if ($subline !~ /$expr/) {$contents.= $subline;} else {$found=1;}	if ($subline !~ /$expr/) {$contents.= $subline;} else {$found=1;}
Line 1655 sub addline {	Line 2168 sub addline {
}	}

sub getchat {	sub getchat {
my ($cdom,$cname)=@_;	my ($cdom,$cname,$udom,$uname)=@_;
my %hash;	my %hash;
my $proname=&propath($cdom,$cname);	my $proname=&propath($cdom,$cname);
my @entries=();	my @entries=();
Line 1664 sub getchat {	Line 2177 sub getchat {
@entries=map { $_.':'.$hash{$_} } sort keys %hash;	@entries=map { $_.':'.$hash{$_} } sort keys %hash;
untie %hash;	untie %hash;
}	}
return @entries;	my @participants=();
	my $cutoff=time-60;
	if (tie(%hash,'GDBM_File',"$proname/nohist_inchatroom.db",
	&GDBM_WRCREAT(),0640)) {
	$hash{$uname.':'.$udom}=time;
	foreach (sort keys %hash) {
	if ($hash{$_}>$cutoff) {
	$participants[$#participants+1]='active_participant:'.$_;
	}
	}
	untie %hash;
	}
	return (@participants,@entries);
}	}

sub chatadd {	sub chatadd {
Line 1672 sub chatadd {	Line 2197 sub chatadd {
my %hash;	my %hash;
my $proname=&propath($cdom,$cname);	my $proname=&propath($cdom,$cname);
my @entries=();	my @entries=();
	my $time=time;
if (tie(%hash,'GDBM_File',"$proname/nohist_chatroom.db",	if (tie(%hash,'GDBM_File',"$proname/nohist_chatroom.db",
&GDBM_WRCREAT(),0640)) {	&GDBM_WRCREAT(),0640)) {
@entries=map { $_.':'.$hash{$_} } sort keys %hash;	@entries=map { $_.':'.$hash{$_} } sort keys %hash;
my $time=time;
my ($lastid)=($entries[$#entries]=~/^(\w+)\:/);	my ($lastid)=($entries[$#entries]=~/^(\w+)\:/);
my ($thentime,$idnum)=split(/\_/,$lastid);	my ($thentime,$idnum)=split(/\_/,$lastid);
my $newid=$time.'_000000';	my $newid=$time.'_000000';
Line 1695 sub chatadd {	Line 2220 sub chatadd {
}	}
untie %hash;	untie %hash;
}	}
	{
	my $hfh;
	if ($hfh=IO::File->new(">>$proname/chatroom.log")) {
	print $hfh "$time:".&unescape($newchat)."\n";
	}
	}
}	}

sub unsub {	sub unsub {
Line 1721 sub currentversion {	Line 2252 sub currentversion {
if ($fname=~/^(.+)\/[^\/]+$/) {	if ($fname=~/^(.+)\/[^\/]+$/) {
$ulsdir=$1;	$ulsdir=$1;
}	}
	my ($fnamere1,$fnamere2);
	# remove version if already specified
$fname=~s/\.\d+\.(\w+(?:\.meta)*)$/\.$1/;	$fname=~s/\.\d+\.(\w+(?:\.meta)*)$/\.$1/;
$fname=~s/\.(\w+(?:\.meta)*)$/\.$\\d\+$\.$1\$/;	# get the bits that go before and after the version number
	if ( $fname=~/^(.\.)(\w+(?:\.meta))$/ ) {
	$fnamere1=$1;
	$fnamere2='.'.$2;
	}
if (-e $fname) { $version=1; }	if (-e $fname) { $version=1; }
if (-e $ulsdir) {	if (-e $ulsdir) {
if(-d $ulsdir) {	if(-d $ulsdir) {
if (opendir(LSDIR,$ulsdir)) {	if (opendir(LSDIR,$ulsdir)) {
while ($ulsfn=readdir(LSDIR)) {	my $ulsfn;
	while ($ulsfn=readdir(LSDIR)) {
# see if this is a regular file (ignore links produced earlier)	# see if this is a regular file (ignore links produced earlier)
my $thisfile=$ulsdir.'/'.$ulsfn;	my $thisfile=$ulsdir.'/'.$ulsfn;
unless (-l $thisfile) {	unless (-l $thisfile) {
if ($thisfile=~/$fname/) {	if ($thisfile=~/\Q$fnamere1\E(\d+)\Q$fnamere2\E/) {
if ($1>$version) { $version=$1; }	if ($1>$version) { $version=$1; }
}	}
}	}
}	}
closedir(LSDIR);	closedir(LSDIR);
$version++;	$version++;
}	}
}	}
}	}
return $version;	return $version;
}	}

sub thisversion {	sub thisversion {
Line 1781 sub subscribe {	Line 2318 sub subscribe {
$result="directory\n";	$result="directory\n";
} else {	} else {
if (-e "$fname.$hostid{$clientip}") {&unsub($fname,$clientip);}	if (-e "$fname.$hostid{$clientip}") {&unsub($fname,$clientip);}
$now=time;	my $now=time;
my $found=&addline($fname,$hostid{$clientip},$clientip,	my $found=&addline($fname,$hostid{$clientip},$clientip,
"$hostid{$clientip}:$clientip:$now\n");	"$hostid{$clientip}:$clientip:$now\n");
if ($found) { $result="$fname\n"; }	if ($found) { $result="$fname\n"; }
Line 1830 sub make_passwd_file {	Line 2367 sub make_passwd_file {
{	{
&Debug("Executing external: ".$execpath);	&Debug("Executing external: ".$execpath);
&Debug("user = ".$uname.", Password =". $npass);	&Debug("user = ".$uname.", Password =". $npass);
my $se = IO::File->new("\|$execpath > /home/www/lcuseradd.log");	my $se = IO::File->new("\|$execpath > $perlvar{'lonDaemons'}/logs/lcuseradd.log");
print $se "$uname\n";	print $se "$uname\n";
print $se "$npass\n";	print $se "$npass\n";
print $se "$npass\n";	print $se "$npass\n";
Line 1853 sub make_passwd_file {	Line 2390 sub make_passwd_file {
return $result;	return $result;
}	}

	sub sethost {
	my ($remotereq) = @_;
	my (undef,$hostid)=split(/:/,$remotereq);
	if (!defined($hostid)) { $hostid=$perlvar{'lonHostID'}; }
	if ($hostip{$perlvar{'lonHostID'}} eq $hostip{$hostid}) {
	$currenthostid=$hostid;
	$currentdomainid=$hostdom{$hostid};
	&logthis("Setting hostid to $hostid, and domain to $currentdomainid");
	} else {
	&logthis("Requested host id $hostid not an alias of ".
	$perlvar{'lonHostID'}." refusing connection");
	return 'unable_to_set';
	}
	return 'ok';
	}

	sub version {
	my ($userinput)=@_;
	$remoteVERSION=(split(/:/,$userinput))[1];
	return "version:$VERSION";
	}

	#There is a copy of this in lonnet.pm
	sub userload {
	my $numusers=0;
	{
	opendir(LONIDS,$perlvar{'lonIDsDir'});
	my $filename;
	my $curtime=time;
	while ($filename=readdir(LONIDS)) {
	if ($filename eq '.' \|\| $filename eq '..') {next;}
	my ($mtime)=(stat($perlvar{'lonIDsDir'}.'/'.$filename))[9];
	if ($curtime-$mtime < 3600) { $numusers++; }
	}
	closedir(LONIDS);
	}
	my $userloadpercent=0;
	my $maxuserload=$perlvar{'lonUserLoadLim'};
	if ($maxuserload) {
	$userloadpercent=100*$numusers/$maxuserload;
	}
	$userloadpercent=sprintf("%.2f",$userloadpercent);
	return $userloadpercent;
	}

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

=head1 NAME	=head1 NAME
Line 1962 each connection is logged.	Line 2544 each connection is logged.

=item *	=item *

	SIGUSR2

	Parent Signal assignment:
	$SIG{USR2} = \&UpdateHosts

	Child signal assignment:
	NONE


	=item *

SIGCHLD	SIGCHLD

Parent signal assignment:	Parent signal assignment:
Line 2122 Send along temporarily stored informatio	Line 2715 Send along temporarily stored informatio

List part of a user's directory.	List part of a user's directory.

	=item pushtable

	Pushes a file in /home/httpd/lonTab directory. Currently limited to:
	hosts.tab and domain.tab. The old file is copied to *.tab.backup but
	must be restored manually in case of a problem with the new table file.
	pushtable requires that the request be encrypted and validated via
	ValidateManager. The form of the command is:
	enc:pushtable tablename <tablecontents> \n
	where pushtable, tablename and <tablecontents> will be encrypted, but \n is a
	cleartext newline.

=item Hanging up (exit or init)	=item Hanging up (exit or init)

What to do when a client tells the server that they (the client)	What to do when a client tells the server that they (the client)
Line 2132 are leaving the network.	Line 2736 are leaving the network.
If B<lond> is sent an unknown command (not in the list above),	If B<lond> is sent an unknown command (not in the list above),
it replys to the client "unknown_cmd".	it replys to the client "unknown_cmd".


=item UNKNOWN CLIENT	=item UNKNOWN CLIENT

If the anti-spoofing algorithm cannot verify the client,	If the anti-spoofing algorithm cannot verify the client,

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

Removed from v.1.109
changed lines
	Added in v.1.145