loncom/lond - diff

Return to lond CVS log

Up to [LON-CAPA] / loncom

Diff for /loncom/lond between versions 1.94 and 1.142

version 1.94, 2002/09/03 02:01:14	version 1.142, 2003/09/09 20:47:46
Line 31	Line 31
# 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,
# 12/7,12/15,01/06,01/11,01/12,01/14,2/8,	# 12/7,12/15,01/06,01/11,01/12,01/14,2/8,
# 03/07,05/31 Gerd Kortemeyer	# 03/07,05/31 Gerd Kortemeyer
# 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,12/13,12/29 Gerd Kortemeyer	# 12/05,12/13,12/29 Gerd Kortemeyer
# YEAR=2001	# YEAR=2001
# Jan 01 Scott Harrison
# 02/12 Gerd Kortemeyer	# 02/12 Gerd Kortemeyer
# 03/15 Scott Harrison
# 03/24 Gerd Kortemeyer	# 03/24 Gerd Kortemeyer
# 04/02 Scott Harrison
# 05/11,05/28,08/30 Gerd Kortemeyer	# 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	# 11/26,11/27 Gerd Kortemeyer
# 12/20 Scott Harrison
# 12/22 Gerd Kortemeyer	# 12/22 Gerd Kortemeyer
# YEAR=2002	# YEAR=2002
# 01/20/02,02/05 Gerd Kortemeyer	# 01/20/02,02/05 Gerd Kortemeyer
# 02/05 Guy Albertelli	# 02/05 Guy Albertelli
# 02/07 Scott Harrison
# 02/12 Gerd Kortemeyer	# 02/12 Gerd Kortemeyer
# 02/19 Matthew Hall	# 02/19 Matthew Hall
# 02/25 Gerd Kortemeyer	# 02/25 Gerd Kortemeyer
# 05/11 Scott Harrison	# 01/xx/2003 Ron Fox.. Remove preforking. This makes the general daemon
###	# logic simpler (and there were problems maintaining the preforked
	# population). Since the time averaged connection rate is close to zero
	# because lonc's purpose is to maintain near continuous connnections,
	# 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.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)
	#

# based on "Perl Cookbook" ISBN 1-56592-243-3
# preforker - server who forks first
# runs as a daemon
# HUPs
# uses IDEA encryption

	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 83 my $DEBUG = 0; # Non zero to ena	Line 93 my $DEBUG = 0; # Non zero to ena
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."
	#
	my $lastpwderror = 13; # Largest error number from lcpasswd.
	my @passwderrors = ("ok",
	"lcpasswd must be run as user 'www'",
	"lcpasswd got incorrect number of arguments",
	"lcpasswd did not get the right nubmer of input text lines",
	"lcpasswd too many simultaneous pwd changes in progress",
	"lcpasswd User does not exist.",
	"lcpasswd Incorrect current passwd",
	"lcpasswd Unable to su to root.",
	"lcpasswd Cannot set new passwd.",
	"lcpasswd Username has invalid characters",
	"lcpasswd Invalid characters in password",
	"11", "12",
	"lcpasswd Password mismatch");


	# The array below are lcuseradd error strings.:

	my $lastadderror = 13;
	my @adderrors = ("ok",
	"User ID mismatch, lcuseradd must run as user www",
	"lcuseradd Incorrect number of command line parameters must be 3",
	"lcuseradd Incorrect number of stdinput lines, must be 3",
	"lcuseradd Too many other simultaneous pwd changes in progress",
	"lcuseradd User does not exist",
	"lcuseradd Unabel to mak ewww member of users's group",
	"lcuseradd Unable to su to root",
	"lcuseradd Unable to set password",
	"lcuseradd Usrname has invbalid charcters",
	"lcuseradd Password has an invalid character",
	"lcuseradd User already exists",
	"lcuseradd Could not add user.",
	"lcuseradd Password mismatch");


	#
	# 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>");
	}
	}
	#
	# 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/;
	# CopyFile($tablefile, $backupfile);
	&logthis('<font color="green"> Pushfile: backed up '
	.$tablefile." to $backupfile</font>");

	# Install the new file:

	# InstallFile($tablefile, $contents);

	# Indicate success:

	return "ok";

	}
	#
	# Convert an error return code from lcpasswd to a string value.
	#
	sub lcpasswdstrerror {
	my $ErrorCode = shift;
	if(($ErrorCode < 0) \|\| ($ErrorCode > $lastpwderror)) {
	return "lcpasswd Unrecognized error return value ".$ErrorCode;
	} else {
	return $passwderrors[$ErrorCode];
	}
	}

	#
	# Convert an error return code from lcuseradd to a string value:
	#
	sub lcuseraddstrerror {
	my $ErrorCode = shift;
	if(($ErrorCode < 0) \|\| ($ErrorCode > $lastadderror)) {
	return "lcuseradd - Unrecognized error code: ".$ErrorCode;
	} else {
	return $adderrors[$ErrorCode];
	}
	}

# grabs exception and records it to log before exiting	# grabs exception and records it to log before exiting
sub catchexception {	sub catchexception {
my ($error)=@_;	my ($error)=@_;
$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 107 $SIG{'QUIT'}=\&catchexception;	Line 290 $SIG{'QUIT'}=\&catchexception;
$SIG{__DIE__}=\&catchexception;	$SIG{__DIE__}=\&catchexception;

# ---------------------------------- Read loncapa_apache.conf and loncapa.conf	# ---------------------------------- Read loncapa_apache.conf and loncapa.conf
&status("Read loncapa_apache.conf and loncapa.conf");	&status("Read loncapa.conf and loncapa_apache.conf");
my $perlvarref=LONCAPA::Configuration::read_conf('loncapa_apache.conf',	my $perlvarref=LONCAPA::Configuration::read_conf('loncapa.conf');
'loncapa.conf');	%perlvar=%{$perlvarref};
my %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 134 if (-e $pidfile) {	Line 316 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 161 $server = IO::Socket::INET->new(LocalPor	Line 342 $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 193 sub HUPSMAN { # sig	Line 372 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
}	}

Line 202 sub checkchildren {	Line 381 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 211 sub checkchildren {	Line 390 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 249 sub logstatus {	Line 436 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 266 sub initnewstatus {	Line 453 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 279 sub status {	Line 466 sub status {
my $now=time;	my $now=time;
my $local=localtime($now);	my $local=localtime($now);
$status=$local.': '.$what;	$status=$local.': '.$what;
	$0='lond: '.$what.' '.$local;
}	}

# -------------------------------------------------------- Escape Special Chars	# -------------------------------------------------------- Escape Special Chars
Line 309 sub reconlonc {	Line 497 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 345 sub subreply {	Line 526 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 414 sub ishome {	Line 595 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 422 POSIX::setsid() or die "Can't start new	Line 603 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);
&logthis("<font color=red>CRITICAL: ---------- Starting ----------</font>");	&logthis("<font color=red>CRITICAL: ---------- Starting ----------</font>");
&status('Starting');	&status('Starting');

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

# Fork off our children.
for (1 .. $PREFORK) {
make_new_child();
}

# ----------------------------------------------------- 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;	$SIG{USR1} = \&checkchildren;

# And maintain the population.

	# --------------------------------------------------------------
	# Accept connections. When a connection comes in, it is validated
	# and if good, a child process is created to process transactions
	# along the connection.

while (1) {	while (1) {
&status('Sleeping');	$client = $server->accept() or next;
sleep; # wait for a signal (i.e., child's death)	make_new_child($client);
&logthis('Woke up');
&status('Woke up');
for ($i = $children; $i < $PREFORK; $i++) {
make_new_child(); # top up the child pool
}
}	}

sub make_new_child {	sub make_new_child {
my $pid;	my $pid;
my $cipher;	my $cipher;
my $sigset;	my $sigset;

	$client = shift;
&logthis("Attempting to start child");	&logthis("Attempting to start 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 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 479 sub make_new_child {	Line 657 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 488 sub make_new_child {	Line 668 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();

# handle connections until we've reached $MAX_CLIENTS_PER_CHILD
for ($i=0; $i < $MAX_CLIENTS_PER_CHILD; $i++) {
&status('Idle, waiting for connection');
$client = $server->accept() or last;
&status('Accepted connection');	&status('Accepted connection');
# =============================================================================	# =============================================================================
# do something with the connection	# do something with the connection
Line 504 sub make_new_child {	Line 680 sub make_new_child {
$client->sockopt(SO_KEEPALIVE, 1);# Enable monitoring of	$client->sockopt(SO_KEEPALIVE, 1);# Enable monitoring of
# connection liveness.	# connection liveness.
# 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 546 sub make_new_child {	Line 723 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 576 sub make_new_child {	Line 759 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 603 sub make_new_child {	Line 786 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 619 sub make_new_child {	Line 810 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)) {
	print $client "ok\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 634 sub make_new_child {	Line 850 sub make_new_child {
my ($howpwd,$contentpwd)=split(/:/,$realpasswd);	my ($howpwd,$contentpwd)=split(/:/,$realpasswd);
my $pwdcorrect=0;	my $pwdcorrect=0;
if ($howpwd eq 'internal') {	if ($howpwd eq 'internal') {
	&Debug("Internal auth");
$pwdcorrect=	$pwdcorrect=
(crypt($upass,$contentpwd) eq $contentpwd);	(crypt($upass,$contentpwd) eq $contentpwd);
} elsif ($howpwd eq 'unix') {	} elsif ($howpwd eq 'unix') {
$contentpwd=(getpwnam($uname))[1];	&Debug("Unix auth");
my $pwauth_path="/usr/local/sbin/pwauth";	if((getpwnam($uname))[1] eq "") { #no such user!
unless ($contentpwd eq 'x') {	$pwdcorrect = 0;
$pwdcorrect=	} else {
(crypt($upass,$contentpwd) eq $contentpwd);	$contentpwd=(getpwnam($uname))[1];
}	my $pwauth_path="/usr/local/sbin/pwauth";
	unless ($contentpwd eq 'x') {
	$pwdcorrect=
	(crypt($upass,$contentpwd) eq
	$contentpwd);
	}

elsif (-e $pwauth_path) {	elsif (-e $pwauth_path) {
open PWAUTH, "\|$pwauth_path" or	open PWAUTH, "\|$pwauth_path" or
die "Cannot invoke authentication";	die "Cannot invoke authentication";
Line 650 sub make_new_child {	Line 873 sub make_new_child {
close PWAUTH;	close PWAUTH;
$pwdcorrect=!$?;	$pwdcorrect=!$?;
}	}
	}
} elsif ($howpwd eq 'krb4') {	} elsif ($howpwd eq 'krb4') {
$null=pack("C",0);	my $null=pack("C",0);
unless ($upass=~/$null/) {	unless ($upass=~/$null/) {
$pwdcorrect=(	my $krb4_error = &Authen::Krb4::get_pw_in_tkt
Authen::Krb4::get_pw_in_tkt($uname,"",	($uname,"",$contentpwd,'krbtgt',
$contentpwd,'krbtgt',$contentpwd,1,	$contentpwd,1,$upass);
$upass) == 0);	if (!$krb4_error) {
} else { $pwdcorrect=0; }	$pwdcorrect = 1;
	} else {
	$pwdcorrect=0;
	# log error if it is not a bad password
	if ($krb4_error != 62) {
	&logthis('krb4:'.$uname.','.$contentpwd.','.
	&Authen::Krb4::get_err_txt($Authen::Krb4::error));
	}
	}
	}
} 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 698 sub make_new_child {	Line 931 sub make_new_child {
chomp($npass);	chomp($npass);
$upass=&unescape($upass);	$upass=&unescape($upass);
$npass=&unescape($npass);	$npass=&unescape($npass);
&logthis("Trying to change password for $uname");	&Debug("Trying to change password for $uname");
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 708 sub make_new_child {	Line 941 sub make_new_child {
chomp($realpasswd);	chomp($realpasswd);
my ($howpwd,$contentpwd)=split(/:/,$realpasswd);	my ($howpwd,$contentpwd)=split(/:/,$realpasswd);
if ($howpwd eq 'internal') {	if ($howpwd eq 'internal') {
	&Debug("internal auth");
if (crypt($upass,$contentpwd) eq $contentpwd) {	if (crypt($upass,$contentpwd) eq $contentpwd) {
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 724 sub make_new_child {	Line 966 sub make_new_child {
# one way or another.	# one way or another.
# First: Make sure the current password is	# First: Make sure the current password is
# correct	# correct
	&Debug("auth is unix");
$contentpwd=(getpwnam($uname))[1];	$contentpwd=(getpwnam($uname))[1];
my $pwdcorrect = "0";	my $pwdcorrect = "0";
my $pwauth_path="/usr/local/sbin/pwauth";	my $pwauth_path="/usr/local/sbin/pwauth";
Line 735 sub make_new_child {	Line 978 sub make_new_child {
die "Cannot invoke authentication";	die "Cannot invoke authentication";
print PWAUTH "$uname\n$upass\n";	print PWAUTH "$uname\n$upass\n";
close PWAUTH;	close PWAUTH;
$pwdcorrect=!$?;	&Debug("exited pwauth with $? ($uname,$upass) ");
	$pwdcorrect=($? == 0);
}	}
if ($pwdcorrect) {	if ($pwdcorrect) {
my $execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
my $pf = IO::File->new("\|$execdir/lcpasswd");	&Debug("Opening lcpasswd pipeline");
	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 $result = ($?>0 ? 'pwchange_failure'	my $err = $?;
	my $result = ($err>0 ? 'pwchange_failure'
: 'ok');	: 'ok');
&logthis("Result of password change for $uname: $result");	&logthis("Result of password change for $uname: ".
	&lcpasswdstrerror($?));
print $client "$result\n";	print $client "$result\n";
} else {	} else {
print $client "non_authorized\n";	print $client "non_authorized\n";
Line 775 sub make_new_child {	Line 1022 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:$!";	$fperror="error: ".($!+0)
	." mkdir failed while attempting "
	."makeuser\n";
}	}
}	}
}	}
unless ($fperror) {	unless ($fperror) {
my $result=&make_passwd_file($umode,$npass,	my $result=&make_passwd_file($uname, $umode,$npass,
$passfilename);	$passfilename);
print $client $result;	print $client $result;
} else {	} else {
Line 813 sub make_new_child {	Line 1062 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($umode,$npass,	my $result=&make_passwd_file($uname, $umode,$npass,
$passfilename);	$passfilename);
print $client $result;	print $client $result;
}	}
Line 843 sub make_new_child {	Line 1092 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 918 sub make_new_child {	Line 1167 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 940 sub make_new_child {	Line 1189 sub make_new_child {
# ------------------------------------------------------------------- subscribe	# ------------------------------------------------------------------- subscribe
} elsif ($userinput =~ /^sub/) {	} elsif ($userinput =~ /^sub/) {
print $client &subscribe($userinput,$clientip);	print $client &subscribe($userinput,$clientip);
	# ------------------------------------------------------------- current version
	} elsif ($userinput =~ /^currentversion/) {
	my ($cmd,$fname)=split(/:/,$userinput);
	print $client &currentversion($fname)."\n";
# ------------------------------------------------------------------------- log	# ------------------------------------------------------------------------- log
} elsif ($userinput =~ /^log/) {	} elsif ($userinput =~ /^log/) {
my ($cmd,$udom,$uname,$what)=split(/:/,$userinput);	my ($cmd,$udom,$uname,$what)=split(/:/,$userinput);
Line 952 sub make_new_child {	Line 1205 sub make_new_child {
print $hfh "$now:$hostid{$clientip}:$what\n";	print $hfh "$now:$hostid{$clientip}:$what\n";
print $client "ok\n";	print $client "ok\n";
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." IO::File->new Failed "
	."while attempting log\n";
}	}
}	}
# ------------------------------------------------------------------------- put	# ------------------------------------------------------------------------- put
Line 972 sub make_new_child {	Line 1227 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:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) failed ".
	"while attempting put\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!)
	." tie(GDBM) Failed ".
	"while attempting put\n";
}	}
} else {	} else {
print $client "refused\n";	print $client "refused\n";
Line 1010 sub make_new_child {	Line 1270 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:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting rolesput\n";
}	}
} else {	} else {
print $client "error:$!\n";	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 {
	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting rolesdel\n";
}	}
} else {	} else {
print $client "refused\n";	print $client "refused\n";
Line 1040 sub make_new_child {	Line 1346 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)) {
$qresult=~s/\&$//;	$qresult=~s/\&$//;
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting get\n";
}	}
} else {	} else {
print $client "error:$!\n";	if ($!+0 == 2) {
	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 1063 sub make_new_child {	Line 1379 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 1084 sub make_new_child {	Line 1401 sub make_new_child {
print $client "error:no_key\n";	print $client "error:no_key\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting eget\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting eget\n";
}	}
# ------------------------------------------------------------------------- del	# ------------------------------------------------------------------------- del
} elsif ($userinput =~ /^del/) {	} elsif ($userinput =~ /^del/) {
Line 1105 sub make_new_child {	Line 1426 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:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting del\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting del\n";
}	}
# ------------------------------------------------------------------------ keys	# ------------------------------------------------------------------------ keys
} elsif ($userinput =~ /^keys/) {	} elsif ($userinput =~ /^keys/) {
Line 1125 sub make_new_child {	Line 1451 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)) {
$qresult=~s/\&$//;	$qresult=~s/\&$//;
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting keys\n";
	}
	} else {
	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting keys\n";
	}
	# ----------------------------------------------------------------- dumpcurrent
	} elsif ($userinput =~ /^currentdump/) {
	my ($cmd,$udom,$uname,$namespace)
	=split(/:/,$userinput);
	$namespace=~s/\//\_/g;
	$namespace=~s/\W//g;
	my $qresult='';
	my $proname=propath($udom,$uname);
	my %hash;
	if (tie(%hash,'GDBM_File',
	"$proname/$namespace.db",
	&GDBM_READER(),0640)) {
	# Structure of %data:
	# $data{$symb}->{$parameter}=$value;
	# $data{$symb}->{'v.'.$parameter}=$version;
	# since $parameter will be unescaped, we do not
	# have to worry about silly parameter names...
	my %data = ();
	while (my ($key,$value) = each(%hash)) {
	my ($v,$symb,$param) = split(/:/,$key);
	next if ($v eq 'version' \|\| $symb eq 'keys');
	next if (exists($data{$symb}) &&
	exists($data{$symb}->{$param}) &&
	$data{$symb}->{'v.'.$param} > $v);
	$data{$symb}->{$param}=$value;
	$data{$symb}->{'v.'.$param}=$v;
	}
	if (untie(%hash)) {
	while (my ($symb,$param_hash) = each(%data)) {
	while(my ($param,$value) = each (%$param_hash)){
	next if ($param =~ /^v\./);
	$qresult.=$symb.':'.$param.'='.$value.'&';
	}
	}
	chop($qresult);
	print $client "$qresult\n";
	} else {
	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting currentdump\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting currentdump\n";
}	}
# ------------------------------------------------------------------------ dump	# ------------------------------------------------------------------------ dump
} elsif ($userinput =~ /^dump/) {	} elsif ($userinput =~ /^dump/) {
Line 1149 sub make_new_child {	Line 1526 sub make_new_child {
} else {	} else {
$regexp='.';	$regexp='.';
}	}
my $proname=propath($udom,$uname);
my $qresult='';	my $qresult='';
if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER,0640)) {	my $proname=propath($udom,$uname);
	my %hash;
	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {
study($regexp);	study($regexp);
foreach $key (keys %hash) {	while (my ($key,$value) = each(%hash)) {
my $unescapeKey = &unescape($key);	if ($regexp eq '.') {
if (eval('$unescapeKey=~/$regexp/')) {	$qresult.=$key.'='.$value.'&';
$qresult.="$key=$hash{$key}&";	} else {
}	my $unescapeKey = &unescape($key);
	if (eval('$unescapeKey=~/$regexp/')) {
	$qresult.="$key=$value&";
	}
	}
}	}
if (untie(%hash)) {	if (untie(%hash)) {
$qresult=~s/\&$//;	chop($qresult);
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting dump\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting dump\n";
}	}
# ----------------------------------------------------------------------- store	# ----------------------------------------------------------------------- store
} elsif ($userinput =~ /^store/) {	} elsif ($userinput =~ /^store/) {
Line 1185 sub make_new_child {	Line 1571 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 1203 sub make_new_child {	Line 1589 sub make_new_child {
if (untie(%hash)) {	if (untie(%hash)) {
print $client "ok\n";	print $client "ok\n";
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting store\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting store\n";
}	}
} else {	} else {
print $client "refused\n";	print $client "refused\n";
Line 1220 sub make_new_child {	Line 1610 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 1237 sub make_new_child {	Line 1628 sub make_new_child {
$qresult=~s/\&$//;	$qresult=~s/\&$//;
print $client "$qresult\n";	print $client "$qresult\n";
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting restore\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting restore\n";
}	}
# -------------------------------------------------------------------- chatsend	# -------------------------------------------------------------------- chatsend
} elsif ($userinput =~ /^chatsend/) {	} elsif ($userinput =~ /^chatsend/) {
Line 1249 sub make_new_child {	Line 1644 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 1279 sub make_new_child {	Line 1675 sub make_new_child {
print $client "ok\n";	print $client "ok\n";
}	}
else {	else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." 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 1295 sub make_new_child {	Line 1760 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:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting idput\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting idput\n";
}	}
# ----------------------------------------------------------------------- idget	# ----------------------------------------------------------------------- idget
} elsif ($userinput =~ /^idget/) {	} elsif ($userinput =~ /^idget/) {
Line 1316 sub make_new_child {	Line 1786 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:$!\n";	print $client "error: ".($!+0)
	." untie(GDBM) Failed ".
	"while attempting idget\n";
}	}
} else {	} else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	." tie(GDBM) Failed ".
	"while attempting idget\n";
}	}
# ---------------------------------------------------------------------- tmpput	# ---------------------------------------------------------------------- tmpput
} elsif ($userinput =~ /^tmpput/) {	} elsif ($userinput =~ /^tmpput/) {
Line 1344 sub make_new_child {	Line 1819 sub make_new_child {
print $client "$id\n";	print $client "$id\n";
}	}
else {	else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	."IO::File->new Failed ".
	"while attempting tmpput\n";
}	}

# ---------------------------------------------------------------------- tmpget	# ---------------------------------------------------------------------- tmpget
Line 1360 sub make_new_child {	Line 1837 sub make_new_child {
close $store;	close $store;
}	}
else {	else {
print $client "error:$!\n";	print $client "error: ".($!+0)
	."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 1387 sub make_new_child {	Line 1879 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 1396 sub make_new_child {	Line 1901 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 1411 sub make_new_child {	Line 1920 sub make_new_child {
&logthis("<font color=blue>WARNING: "	&logthis("<font color=blue>WARNING: "
."Rejected client $clientip, closing connection</font>");	."Rejected client $clientip, closing connection</font>");
}	}
}	}

# =============================================================================	# =============================================================================

&logthis("<font color=red>CRITICAL: "	&logthis("<font color=red>CRITICAL: "
."Disconnect from $clientip ($hostid{$clientip})</font>");	."Disconnect from $clientip ($hostid{$clientip})</font>");
# tidy up gracefully and finish

$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.
exit;	exit;
}
}	}


Line 1448 sub ManagePermissions	Line 1955 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 1495 sub addline {	Line 2002 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 1509 sub addline {	Line 2017 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 1518 sub getchat {	Line 2026 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 1526 sub chatadd {	Line 2046 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 1549 sub chatadd {	Line 2069 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 1568 sub unsub {	Line 2094 sub unsub {
return $result;	return $result;
}	}

	sub currentversion {
	my $fname=shift;
	my $version=-1;
	my $ulsdir='';
	if ($fname=~/^(.+)\/[^\/]+$/) {
	$ulsdir=$1;
	}
	my ($fnamere1,$fnamere2);
	# remove version if already specified
	$fname=~s/\.\d+\.(\w+(?:\.meta)*)$/\.$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 $ulsdir) {
	if(-d $ulsdir) {
	if (opendir(LSDIR,$ulsdir)) {
	my $ulsfn;
	while ($ulsfn=readdir(LSDIR)) {
	# see if this is a regular file (ignore links produced earlier)
	my $thisfile=$ulsdir.'/'.$ulsfn;
	unless (-l $thisfile) {
	if ($thisfile=~/\Q$fnamere1\E(\d+)\Q$fnamere2\E/) {
	if ($1>$version) { $version=$1; }
	}
	}
	}
	closedir(LSDIR);
	$version++;
	}
	}
	}
	return $version;
	}

	sub thisversion {
	my $fname=shift;
	my $version=-1;
	if ($fname=~/\.(\d+)\.\w+(?:\.meta)*$/) {
	$version=$1;
	}
	return $version;
	}

sub subscribe {	sub subscribe {
my ($userinput,$clientip)=@_;	my ($userinput,$clientip)=@_;
my $result;	my $result;
my ($cmd,$fname)=split(/:/,$userinput);	my ($cmd,$fname)=split(/:/,$userinput);
my $ownership=&ishome($fname);	my $ownership=&ishome($fname);
if ($ownership eq 'owner') {	if ($ownership eq 'owner') {
	# explitly asking for the current version?
	unless (-e $fname) {
	my $currentversion=&currentversion($fname);
	if (&thisversion($fname)==$currentversion) {
	if ($fname=~/^(.+)\.\d+\.(\w+(?:\.meta)*)$/) {
	my $root=$1;
	my $extension=$2;
	symlink($root.'.'.$extension,
	$root.'.'.$currentversion.'.'.$extension);
	unless ($extension=~/\.meta$/) {
	symlink($root.'.'.$extension.'.meta',
	$root.'.'.$currentversion.'.'.$extension.'.meta');
	}
	}
	}
	}
if (-e $fname) {	if (-e $fname) {
if (-d $fname) {	if (-d $fname) {
$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 1601 sub subscribe {	Line 2189 sub subscribe {
}	}

sub make_passwd_file {	sub make_passwd_file {
my ($umode,$npass,$passfilename)=@_;	my ($uname, $umode,$npass,$passfilename)=@_;
my $result="ok\n";	my $result="ok\n";
if ($umode eq 'krb4' or $umode eq 'krb5') {	if ($umode eq 'krb4' or $umode eq 'krb5') {
{	{
Line 1627 sub make_passwd_file {	Line 2215 sub make_passwd_file {
my $execpath="$perlvar{'lonDaemons'}/"."lcuseradd";	my $execpath="$perlvar{'lonDaemons'}/"."lcuseradd";
{	{
&Debug("Executing external: ".$execpath);	&Debug("Executing external: ".$execpath);
my $se = IO::File->new("\|$execpath");	&Debug("user = ".$uname.", Password =". $npass);
	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";
}	}
	my $useraddok = $?;
	if($useraddok > 0) {
	&logthis("Failed lcuseradd: ".&lcuseraddstrerror($useraddok));
	}
my $pf = IO::File->new(">$passfilename");	my $pf = IO::File->new(">$passfilename");
print $pf "unix:\n";	print $pf "unix:\n";
}	}
Line 1646 sub make_passwd_file {	Line 2239 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 1915 Send along temporarily stored informatio	Line 2553 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 1925 are leaving the network.	Line 2574 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.94
changed lines
	Added in v.1.142