loncom/lond - diff

Return to lond CVS log

Up to [LON-CAPA] / loncom

Diff for /loncom/lond between versions 1.128 and 1.154

version 1.128, 2003/05/08 21:35:48	version 1.154, 2003/10/08 20:29:46
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:
	#


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

Line 67 use Authen::Krb4;	Line 78 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.

Line 77 my $VERSION='$Revision$'; #' stupid emac	Line 89 my $VERSION='$Revision$'; #' stupid emac
my $remoteVERSION;	my $remoteVERSION;
my $currenthostid;	my $currenthostid;
my $currentdomainid;	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 105 my @adderrors = ("ok",	Line 129 my @adderrors = ("ok",
"lcuseradd Incorrect number of stdinput lines, must be 3",	"lcuseradd Incorrect number of stdinput lines, must be 3",
"lcuseradd Too many other simultaneous pwd changes in progress",	"lcuseradd Too many other simultaneous pwd changes in progress",
"lcuseradd User does not exist",	"lcuseradd User does not exist",
"lcuseradd Unabel to mak ewww member of users's group",	"lcuseradd Unable to make www member of users's group",
"lcuseradd Unable to su to root",	"lcuseradd Unable to su to root",
"lcuseradd Unable to set password",	"lcuseradd Unable to set password",
"lcuseradd Usrname has invbalid charcters",	"lcuseradd Usrname has invalid characters",
"lcuseradd Password has an invalid character",	"lcuseradd Password has an invalid character",
"lcuseradd User already exists",	"lcuseradd User already exists",
"lcuseradd Could not add user.",	"lcuseradd Could not add user.",
Line 116 my @adderrors = ("ok",	Line 140 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;


	# separate the request (reinit) from the process identifier and
	# validate it producing the name of the .pid file for the process.
	#
	#
	my ($junk, $process) = split(":", $request);
	my $processpidfile = $perlvar{'lonDaemons'}.'/logs/';
	if($process eq 'lonc') {
	$processpidfile = $processpidfile."lonc.pid";
	if (!open(PIDFILE, "< $processpidfile")) {
	return "error:Open failed for $processpidfile";
	}
	my $loncpid = <PIDFILE>;
	close(PIDFILE);
	logthis('<font color="red"> Reinitializing lonc pid='.$loncpid
	."</font>");
	kill("USR2", $loncpid);
	} elsif ($process eq 'lond') {
	logthis('<font color="red"> Reinitializing self (lond) </font>');
	&UpdateHosts; # Lond is us!!
	} else {
	&logthis('<font color="yellow" Invalid reinit request for '.$process
	."</font>");
	return "error:Invalid process identifier $process";
	}
	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 145 sub catchexception {	Line 415 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 165 $SIG{__DIE__}=\&catchexception;	Line 435 $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: $currenthostid 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 189 if (-e $pidfile) {	Line 459 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";

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

# establish SERVER socket, bind and listen.	# establish SERVER socket, bind and listen.
$server = IO::Socket::INET->new(LocalPort => $perlvar{'londPort'},	$server = IO::Socket::INET->new(LocalPort => $perlvar{'londPort'},
Line 218 $server = IO::Socket::INET->new(LocalPor	Line 475 $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 250 sub HUPSMAN { # sig	Line 505 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
}	}

	#
	# Kill off hashes that describe the host table prior to re-reading it.
	# Hashes affected are:
	# %hostid, %hostdom %hostip
	#
	sub KillHostHashes {
	foreach my $key (keys %hostid) {
	delete $hostid{$key};
	}
	foreach my $key (keys %hostdom) {
	delete $hostdom{$key};
	}
	foreach my $key (keys %hostip) {
	delete $hostip{$key};
	}
	}
	#
	# Read in the host table from file and distribute it into the various hashes:
	#
	# - %hostid - Indexed by IP, the loncapa hostname.
	# - %hostdom - Indexed by loncapa hostname, the domain.
	# - %hostip - Indexed by hostid, the Ip address of the host.
	sub ReadHostTable {

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

	while (my $configline=<CONFIG>) {
	my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);
	chomp($ip); $ip=~s/\D+$//;
	$hostid{$ip}=$id;
	$hostdom{$id}=$domain;
	$hostip{$id}=$ip;
	if ($id eq $perlvar{'lonHostID'}) { $thisserver=$name; }
	}
	close(CONFIG);
	}
	#
	# Reload the Apache daemon's state.
	# This is done by invoking /home/httpd/perl/apachereload
	# a setuid perl script that can be root for us to do this job.
	#
	sub ReloadApache {
	my $execdir = $perlvar{'lonDaemons'};
	my $script = $execdir."/apachereload";
	system($script);
	}

	#
	# 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 {
	logthis('<font color="blue"> Updating connections </font>');
	#
	# The %children hash has the set of IP's we currently have children
	# on. These need to be matched against records in the hosts.tab
	# Any ip's no longer in the table get killed off they correspond to
	# either dropped or changed hosts. Note that the re-read of the table
	# will take care of new and changed hosts as connections come into being.


	KillHostHashes;
	ReadHostTable;

	foreach my $child (keys %children) {
	my $childip = $children{$child};
	if(!$hostid{$childip}) {
	logthis('<font color="blue"> UpdateHosts killing child '
	." $child for ip $childip </font>");
	kill('INT', $child);
	} else {
	logthis('<font color="green"> keeping child for ip '
	." $childip (pid=$child) </font>");
	}
	}
	ReloadApache;
	}


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 276 sub checkchildren {	Line 616 sub checkchildren {
alarm(300);	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: $currenthostid 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);	alarm(0);
}	}
}	}
}	}
$SIG{ALRM} = 'DEFAULT';	$SIG{ALRM} = 'DEFAULT';
$SIG{__DIE__} = \&cathcexception;	$SIG{__DIE__} = \&catchcexception;
}	}

# --------------------------------------------------------------------- Logging	# --------------------------------------------------------------------- Logging
Line 331 sub initnewstatus {	Line 671 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 473 sub ishome {	Line 813 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 481 POSIX::setsid() or die "Can't start new	Line 821 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 497 $SIG{CHLD} = \&REAPER;	Line 837 $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;

	# Read the host hashes:

	ReadHostTable;

# --------------------------------------------------------------	# --------------------------------------------------------------
# Accept connections. When a connection comes in, it is validated	# Accept connections. When a connection comes in, it is validated
Line 511 while (1) {	Line 854 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 522 sub make_new_child {	Line 864 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);

	$client->sockopt(SO_KEEPALIVE, 1); # Enable monitoring of
	# connection liveness.

	#
	# Figure out who we're talking to so we can record the peer in
	# the pid hash.
	#
	my $caller = getpeername($client);
	my ($port,$iaddr)=unpack_sockaddr_in($caller);
	$clientip=inet_ntoa($iaddr);

if ($pid) {	if ($pid) {
# Parent records the child's birth and returns.	# Parent records the child's birth and returns.
sigprocmask(SIG_UNBLOCK, $sigset)	sigprocmask(SIG_UNBLOCK, $sigset)
or die "Can't unblock SIGINT for fork: $!\n";	or die "Can't unblock SIGINT for fork: $!\n";
$children{$pid} = 1;	$children{$pid} = $clientip;
$children++;	$children++;
&status('Started child '.$pid);	&status('Started child '.$pid);
return;	return;
Line 547 sub make_new_child {	Line 900 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 556 sub make_new_child {	Line 909 sub make_new_child {
# =============================================================================	# =============================================================================
# do something with the connection	# do something with the connection
# -----------------------------------------------------------------------------	# -----------------------------------------------------------------------------
$client->sockopt(SO_KEEPALIVE, 1);# Enable monitoring of	# see if we know client and check for spoof IP by challenge
# connection liveness.
# see if we know client and check for spoof IP by challenge
my $caller = getpeername($client);
my ($port,$iaddr)=unpack_sockaddr_in($caller);
my $clientip=inet_ntoa($iaddr);
my $clientrec=($hostid{$clientip} ne undef);	my $clientrec=($hostid{$clientip} ne undef);
&logthis(	&logthis(
"<font color=yellow>INFO: Connection, $clientip ($hostid{$clientip})</font>"	"<font color=yellow>INFO: Connection, $clientip ($hostid{$clientip})</font>"
Line 640 sub make_new_child {	Line 989 sub make_new_child {
if ($userinput =~ /^ping/) {	if ($userinput =~ /^ping/) {
print $client "$currenthostid\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 "$currenthostid:$reply\n";	print $client "$currenthostid:$reply\n";
# ------------------------------------------------------------------------ ekey	# ------------------------------------------------------------------------ ekey
} elsif ($userinput =~ /^ekey/) {	} elsif ($userinput =~ /^ekey/) {
Line 671 sub make_new_child {	Line 1020 sub make_new_child {
} elsif ($userinput =~ /^userload/) {	} elsif ($userinput =~ /^userload/) {
my $userloadpercent=&userload();	my $userloadpercent=&userload();
print $client "$userloadpercent\n";	print $client "$userloadpercent\n";

	#
	# Transactions requiring encryption:
	#
# ----------------------------------------------------------------- currentauth	# ----------------------------------------------------------------- currentauth
} elsif ($userinput =~ /^currentauth/) {	} elsif ($userinput =~ /^currentauth/) {
if ($wasenc==1) {	if ($wasenc==1) {
Line 685 sub make_new_child {	Line 1038 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)) {
	chomp($userinput);
	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 725 sub make_new_child {	Line 1105 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 742 sub make_new_child {	Line 1122 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 796 sub make_new_child {	Line 1176 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 826 sub make_new_child {	Line 1214 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 867 sub make_new_child {	Line 1255 sub make_new_child {
} elsif ($udom ne $currentdomainid) {	} 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)) {
Line 934 sub make_new_child {	Line 1322 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 978 sub make_new_child {	Line 1366 sub make_new_child {
}	}
# -------------------------------------- fetch a user file from a remote server	# -------------------------------------- fetch a user file from a remote server
} elsif ($userinput =~ /^fetchuserfile/) {	} elsif ($userinput =~ /^fetchuserfile/) {
my ($cmd,$fname)=split(/:/,$userinput);	my ($cmd,$fname)=split(/:/,$userinput);
my ($udom,$uname,$ufile)=split(/\//,$fname);	my ($udom,$uname,$ufile)=split(/\//,$fname);
my $udir=propath($udom,$uname).'/userfiles';	my $udir=propath($udom,$uname).'/userfiles';
unless (-e $udir) { mkdir($udir,0770); }	unless (-e $udir) { mkdir($udir,0770); }
if (-e $udir) {	if (-e $udir) {
$ufile=~s/^[\.\~]+//;	$ufile=~s/^[\.\~]+//;
$ufile=~s/\///g;	$ufile=~s/\///g;
my $transname=$udir.'/'.$ufile;	my $destname=$udir.'/'.$ufile;
my $remoteurl='http://'.$clientip.'/userfiles/'.$fname;	my $transname=$udir.'/'.$ufile.'.in.transit';
my $response;	my $remoteurl='http://'.$clientip.'/userfiles/'.$fname;
{	my $response;
my $ua=new LWP::UserAgent;	{
my $request=new HTTP::Request('GET',"$remoteurl");	my $ua=new LWP::UserAgent;
$response=$ua->request($request,$transname);	my $request=new HTTP::Request('GET',"$remoteurl");
}	$response=$ua->request($request,$transname);
if ($response->is_error()) {	}
unlink($transname);	if ($response->is_error()) {
my $message=$response->status_line;	unlink($transname);
&logthis(	my $message=$response->status_line;
"LWP GET: $message for $fname ($remoteurl)");	&logthis("LWP GET: $message for $fname ($remoteurl)");
print $client "failed\n";	print $client "failed\n";
} else {	} else {
print $client "ok\n";	if (!rename($transname,$destname)) {
}	&logthis("Unable to move $transname to $destname");
} else {	unlink($transname);
print $client "not_home\n";	print $client "failed\n";
}	} else {
	print $client "ok\n";
	}
	}
	} else {
	print $client "not_home\n";
	}
# ------------------------------------------ authenticate access to a user file	# ------------------------------------------ authenticate access to a user file
} 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 1069 sub make_new_child {	Line 1463 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)) {
Line 1111 sub make_new_child {	Line 1506 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";
Line 1157 sub make_new_child {	Line 1552 sub make_new_child {
}	}
}	}
my @rolekeys=split(/\&/,$what);	my @rolekeys=split(/\&/,$what);
if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {	my %hash;
foreach $key (@rolekeys) {	if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {
	foreach my $key (@rolekeys) {
delete $hash{$key};	delete $hash{$key};

}	}
if (untie(%hash)) {	if (untie(%hash)) {
print $client "ok\n";	print $client "ok\n";
Line 1187 sub make_new_child {	Line 1582 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 1219 sub make_new_child {	Line 1615 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 1265 sub make_new_child {	Line 1662 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)) {
Line 1289 sub make_new_child {	Line 1687 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 1314 sub make_new_child {	Line 1713 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 1364 sub make_new_child {	Line 1764 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 1406 sub make_new_child {	Line 1807 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 1445 sub make_new_child {	Line 1846 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 1522 sub make_new_child {	Line 1924 sub make_new_child {
"$perlvar{'lonUsersDir'}/$udom/nohist_courseids";	"$perlvar{'lonUsersDir'}/$udom/nohist_courseids";
my $now=time;	my $now=time;
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.':'.$now;	$hash{$key}=$value.':'.$now;
}	}
if (untie(%hash)) {	if (untie(%hash)) {
Line 1552 sub make_new_child {	Line 1955 sub make_new_child {
my $qresult='';	my $qresult='';
my $proname=	my $proname=
"$perlvar{'lonUsersDir'}/$udom/nohist_courseids";	"$perlvar{'lonUsersDir'}/$udom/nohist_courseids";
if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_READER(),0640)) {	my %hash;
while (($key,$value) = each(%hash)) {	if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_READER(),0640)) {
	while (my ($key,$value) = each(%hash)) {
my ($descr,$lasttime)=split(/\:/,$value);	my ($descr,$lasttime)=split(/\:/,$value);
if ($lasttime<$since) { next; }	if ($lasttime<$since) { next; }
if ($regexp eq '.') {	if ($description eq '.') {
$qresult.=$key.'='.$descr.'&';	$qresult.=$key.'='.$descr.'&';
} else {	} else {
my $unescapeVal = &unescape($descr);	my $unescapeVal = &unescape($descr);
Line 1592 sub make_new_child {	Line 1996 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)) {
Line 1617 sub make_new_child {	Line 2022 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 ".	." untie(GDBM) Failed ".
"while attempting idget\n";	"while attempting idget\n";
}	}
} else {	} else {
print $client "error: ".($!+0)	print $client "error: ".($!+0)
Line 1709 sub make_new_child {	Line 2115 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 1772 sub ManagePermissions	Line 2191 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 1819 sub addline {	Line 2238 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 1843 sub getchat {	Line 2263 sub getchat {
untie %hash;	untie %hash;
}	}
my @participants=();	my @participants=();
$cutoff=time-60;	my $cutoff=time-60;
if (tie(%hash,'GDBM_File',"$proname/nohist_inchatroom.db",	if (tie(%hash,'GDBM_File',"$proname/nohist_inchatroom.db",
&GDBM_WRCREAT(),0640)) {	&GDBM_WRCREAT(),0640)) {
$hash{$uname.':'.$udom}=time;	$hash{$uname.':'.$udom}=time;
Line 1862 sub chatadd {	Line 2282 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 1885 sub chatadd {	Line 2305 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 1921 sub currentversion {	Line 2347 sub currentversion {
}	}
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)) {
	my $ulsfn;
while ($ulsfn=readdir(LSDIR)) {	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=~/\Q$fnamere1\E(\d+)\Q$fnamere2\E/) {	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 1977 sub subscribe {	Line 2403 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 2026 sub make_passwd_file {	Line 2452 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 2080 sub userload {	Line 2506 sub userload {
my $curtime=time;	my $curtime=time;
while ($filename=readdir(LONIDS)) {	while ($filename=readdir(LONIDS)) {
if ($filename eq '.' \|\| $filename eq '..') {next;}	if ($filename eq '.' \|\| $filename eq '..') {next;}
my ($atime)=(stat($perlvar{'lonIDsDir'}.'/'.$filename))[8];	my ($mtime)=(stat($perlvar{'lonIDsDir'}.'/'.$filename))[9];
if ($curtime-$atime < 3600) { $num_users++; }	if ($curtime-$mtime < 3600) { $numusers++; }
}	}
closedir(LONIDS);	closedir(LONIDS);
}	}
my $userloadpercent=0;	my $userloadpercent=0;
my $maxuserload=$perlvar{'lonUserLoadLim'};	my $maxuserload=$perlvar{'lonUserLoadLim'};
if ($maxuserload) {	if ($maxuserload) {
$userloadpercent=100*$num_users/$maxuserload;	$userloadpercent=100*$numusers/$maxuserload;
}	}
	$userloadpercent=sprintf("%.2f",$userloadpercent);
return $userloadpercent;	return $userloadpercent;
}	}

Line 2202 each connection is logged.	Line 2629 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 2362 Send along temporarily stored informatio	Line 2800 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 2372 are leaving the network.	Line 2821 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.128
changed lines
	Added in v.1.154