loncom/lonnet/perl/lonnet.pm - diff

Return to lonnet.pm CVS log

Up to [LON-CAPA] / loncom / lonnet / perl

Diff for /loncom/lonnet/perl/lonnet.pm between versions 1.231 and 1.263

version 1.231, 2002/05/22 13:56:43	version 1.263, 2002/08/08 13:42:01
Line 80 use vars	Line 80 use vars
qw(%perlvar %hostname %homecache %badServerCache %hostip %spareid %hostdom	qw(%perlvar %hostname %homecache %badServerCache %hostip %spareid %hostdom
%libserv %pr %prp %metacache %packagetab	%libserv %pr %prp %metacache %packagetab
%courselogs %accesshash $processmarker $dumpcount	%courselogs %accesshash $processmarker $dumpcount
%coursedombuf %coursehombuf %courseresdatacache);	%coursedombuf %coursehombuf %courseresdatacache %domaindescription);
use IO::Socket;	use IO::Socket;
use GDBM_File;	use GDBM_File;
use Apache::Constants qw(:common :http);	use Apache::Constants qw(:common :http);
Line 140 sub reply {	Line 140 sub reply {
unless (defined($hostname{$server})) { return 'no_such_host'; }	unless (defined($hostname{$server})) { return 'no_such_host'; }
my $answer=subreply($cmd,$server);	my $answer=subreply($cmd,$server);
if ($answer eq 'con_lost') {	if ($answer eq 'con_lost') {
sleep 5;	#sleep 5;
$answer=subreply($cmd,$server);	#$answer=subreply($cmd,$server);
if ($answer eq 'con_lost') {	#if ($answer eq 'con_lost') {
&logthis("Second attempt con_lost on $server");	# &logthis("Second attempt con_lost on $server");
my $peerfile="$perlvar{'lonSockDir'}/$server";	# my $peerfile="$perlvar{'lonSockDir'}/$server";
my $client=IO::Socket::UNIX->new(Peer =>"$peerfile",	# my $client=IO::Socket::UNIX->new(Peer =>"$peerfile",
Type => SOCK_STREAM,	# Type => SOCK_STREAM,
Timeout => 10)	# Timeout => 10)
or return "con_lost";	# or return "con_lost";
&logthis("Killing socket");	# &logthis("Killing socket");
print $client "close_connection_exit\n";	# print $client "close_connection_exit\n";
sleep 5;	#sleep 5;
$answer=subreply($cmd,$server);	# $answer=subreply($cmd,$server);
}	#}
}	}
if (($answer=~/^refused/) \|\| ($answer=~/^rejected/)) {	if (($answer=~/^refused/) \|\| ($answer=~/^rejected/)) {
&logthis("<font color=blue>WARNING:".	&logthis("<font color=blue>WARNING:".
Line 608 sub userenvironment {	Line 608 sub userenvironment {
return %returnhash;	return %returnhash;
}	}

	# -------------------------------------------------------------------- New chat

	sub chatsend {
	my ($newentry,$anon)=@_;
	my $cnum=$ENV{'course.'.$ENV{'request.course.id'}.'.num'};
	my $cdom=$ENV{'course.'.$ENV{'request.course.id'}.'.domain'};
	my $chome=$ENV{'course.'.$ENV{'request.course.id'}.'.home'};
	&reply('chatsend:'.$cdom.':'.$cnum.':'.
	&escape($ENV{'user.domain'}.':'.$ENV{'user.name'}.':'.$anon.':'.
	&escape($newentry)),$chome);
	}

# ----------------------------- Subscribe to a resource, return URL if possible	# ----------------------------- Subscribe to a resource, return URL if possible

sub subscribe {	sub subscribe {
Line 708 sub ssi {	Line 720 sub ssi {
return $response->content;	return $response->content;
}	}

	# ------- Add a token to a remote URI's query string to vouch for access rights

	sub tokenwrapper {
	my $uri=shift;
	$uri=~s/^http\:\/\/([^\/]+)//;
	$uri=~s/^\///;
	$ENV{'user.environment'}=~/\/([^\/]+)\.id/;
	my $token=$1;
	if ($uri=~/^uploaded\/([^\/]+)\/([^\/]+)\/([^\/]+)(\?\.)$/) {
	&appenv('userfile.'.$1.'/'.$2.'/'.$3 => $ENV{'request.course.id'});
	return 'http://'.$hostname{ &homeserver($2,$1)}.'/'.$uri.
	(($uri=~/\?/)?'&':'?').'token='.$token;
	} else {
	return '/adm/notfound.html';
	}
	}

	# --------------- Take an uploaded file and put it into the userfiles directory
	# input: name of form element, coursedoc=1 means this is for the course
	# output: url of file in userspace

	sub userfileupload {
	my ($formname,$coursedoc)=@_;
	my $fname=$ENV{'form.'.$formname.'.filename'};
	$fname=~s/\\/\//g;
	$fname=~s/^.*\/([^\/]+)$/$1/;
	unless ($fname) { return 'error: no uploaded file'; }
	chop($ENV{'form.'.$formname});
	# Create the directory if not present
	my $docuname='';
	my $docudom='';
	my $docuhome='';
	if ($coursedoc) {
	$docuname=$ENV{'course.'.$ENV{'request.course.id'}.'.num'};
	$docudom=$ENV{'course.'.$ENV{'request.course.id'}.'.domain'};
	$docuhome=$ENV{'course.'.$ENV{'request.course.id'}.'.home'};
	} else {
	$docuname=$ENV{'user.name'};
	$docudom=$ENV{'user.domain'};
	$docuhome=$ENV{'user.home'};
	}
	my $path=$docudom.'/'.$docuname.'/';
	my $filepath=$perlvar{'lonDocRoot'};
	my @parts=split(/\//,$filepath.'/userfiles/'.$path);
	my $count;
	for ($count=4;$count<=$#parts;$count++) {
	$filepath.="/$parts[$count]";
	if ((-e $filepath)!=1) {
	mkdir($filepath,0777);
	}
	}
	# Save the file
	{
	my $fh=Apache::File->new('>'.$filepath.'/'.$fname);
	print $fh $ENV{'form.'.$formname};
	}
	# Notify homeserver to grep it
	#
	if
	(&reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$fname,$docuhome) eq 'ok')
	{
	#
	# Return the URL to it
	return '/uploaded/'.$path.$fname;
	} else {
	return '/adm/notfound.html';
	}
	}

# ------------------------------------------------------------------------- Log	# ------------------------------------------------------------------------- Log

sub log {	sub log {
Line 799 sub checkout {	Line 880 sub checkout {
my $now=time;	my $now=time;
my $lonhost=$perlvar{'lonHostID'};	my $lonhost=$perlvar{'lonHostID'};
my $infostr=&escape(	my $infostr=&escape(
	'CHECKOUTTOKEN&'.
$tuname.'&'.	$tuname.'&'.
$tudom.'&'.	$tudom.'&'.
$tcrsid.'&'.	$tcrsid.'&'.
Line 848 sub checkin {	Line 930 sub checkin {
$lonhost=~tr/A-Z/a-z/;	$lonhost=~tr/A-Z/a-z/;
my $dtoken=$ta.'_'.$hostip{$lonhost}.'_'.$tb;	my $dtoken=$ta.'_'.$hostip{$lonhost}.'_'.$tb;
$dtoken=~s/\W/\_/g;	$dtoken=~s/\W/\_/g;
my ($tuname,$tudom,$tcrsid,$symb,$chtim,$rmaddr)=	my ($dummy,$tuname,$tudom,$tcrsid,$symb,$chtim,$rmaddr)=
split(/\&/,&unescape(&reply('tmpget:'.$dtoken,$lonhost)));	split(/\&/,&unescape(&reply('tmpget:'.$dtoken,$lonhost)));

unless (($tuname) && ($tudom)) {	unless (($tuname) && ($tudom)) {
Line 1032 sub tmpreset {	Line 1114 sub tmpreset {
my %hash;	my %hash;
if (tie(%hash,'GDBM_File',	if (tie(%hash,'GDBM_File',
$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',	$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',
&GDBM_WRCREAT,0640)) {	&GDBM_WRCREAT(),0640)) {
foreach my $key (keys %hash) {	foreach my $key (keys %hash) {
if ($key=~ /:$symb/) {	if ($key=~ /:$symb/) {
delete($hash{$key});	delete($hash{$key});
Line 1068 sub tmpstore {	Line 1150 sub tmpstore {
my $path=$perlvar{'lonDaemons'}.'/tmp';	my $path=$perlvar{'lonDaemons'}.'/tmp';
if (tie(%hash,'GDBM_File',	if (tie(%hash,'GDBM_File',
$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',	$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',
&GDBM_WRCREAT,0640)) {	&GDBM_WRCREAT(),0640)) {
$hash{"version:$symb"}++;	$hash{"version:$symb"}++;
my $version=$hash{"version:$symb"};	my $version=$hash{"version:$symb"};
my $allkeys='';	my $allkeys='';
Line 1112 sub tmprestore {	Line 1194 sub tmprestore {
my $path=$perlvar{'lonDaemons'}.'/tmp';	my $path=$perlvar{'lonDaemons'}.'/tmp';
if (tie(%hash,'GDBM_File',	if (tie(%hash,'GDBM_File',
$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',	$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',
&GDBM_READER,0640)) {	&GDBM_READER(),0640)) {
my $version=$hash{"version:$symb"};	my $version=$hash{"version:$symb"};
$returnhash{'version'}=$version;	$returnhash{'version'}=$version;
my $scope;	my $scope;
Line 1500 sub allowed {	Line 1582 sub allowed {
# Free bre to public access	# Free bre to public access

if ($priv eq 'bre') {	if ($priv eq 'bre') {
if (&metadata($uri,'copyright') eq 'public') { return 'F'; }	my $copyright=&metadata($uri,'copyright');
	if ($copyright eq 'public') { return 'F'; }
	if ($copyright eq 'priv') {
	$uri=~/([^\/]+)\/([^\/]+)\//;
	unless (($ENV{'user.name'} eq $2) && ($ENV{'user.domain'} eq $1)) {
	return '';
	}
	}
	if ($copyright eq 'domain') {
	$uri=~/([^\/]+)\/([^\/]+)\//;
	unless (($ENV{'user.domain'} eq $1) \|\|
	($ENV{'course.'.$ENV{'request.course.id'}.'.domain'} eq $1)) {
	return '';
	}
	}
	if ($ENV{'request.role'}=~ /li\.\//) {
	# Library role, so allow browsing of resources in this domain.
	return 'F';
	}
}	}

my $thisallowed='';	my $thisallowed='';
Line 1548 sub allowed {	Line 1648 sub allowed {
# the course	# the course

if ($ENV{'request.course.id'}) {	if ($ENV{'request.course.id'}) {

$courseprivid=$ENV{'request.course.id'};	$courseprivid=$ENV{'request.course.id'};
if ($ENV{'request.course.sec'}) {	if ($ENV{'request.course.sec'}) {
$courseprivid.='/'.$ENV{'request.course.sec'};	$courseprivid.='/'.$ENV{'request.course.sec'};
}	}
$courseprivid=~s/\_/\//;	$courseprivid=~s/\_/\//;
my $checkreferer=1;	my $checkreferer=1;
my @uriparts=split(/\//,$uri);	my ($match,$cond)=&is_on_map($uri);
my $filename=$uriparts[$#uriparts];	if ($match) {
my $pathname=$uri;	$statecond=$cond;
$pathname=~s/\/$filename$//;
if ($ENV{'acc.res.'.$ENV{'request.course.id'}.'.'.$pathname}=~
/\&$filename\:([\d\\|]+)\&/) {
$statecond=$1;
if ($ENV{'user.priv.'.$ENV{'request.role'}.'./'.$courseprivid}	if ($ENV{'user.priv.'.$ENV{'request.role'}.'./'.$courseprivid}
=~/$priv\&([^\:]*)/) {	=~/$priv\&([^\:]*)/) {
$thisallowed.=$1;	$thisallowed.=$1;
Line 1570 sub allowed {	Line 1667 sub allowed {

if ($checkreferer) {	if ($checkreferer) {
my $refuri=$ENV{'httpref.'.$orguri};	my $refuri=$ENV{'httpref.'.$orguri};

unless ($refuri) {	unless ($refuri) {
foreach (keys %ENV) {	foreach (keys %ENV) {
if ($_=~/^httpref\..\/) {	if ($_=~/^httpref\..\/) {
Line 1584 sub allowed {	Line 1680 sub allowed {
}	}
}	}
}	}

if ($refuri) {	if ($refuri) {
$refuri=&declutter($refuri);	$refuri=&declutter($refuri);
my @uriparts=split(/\//,$refuri);	my ($match,$cond)=&is_on_map($refuri);
my $filename=$uriparts[$#uriparts];	if ($match) {
my $pathname=$refuri;	my $refstatecond=$cond;
$pathname=~s/\/$filename$//;
if ($ENV{'acc.res.'.$ENV{'request.course.id'}.'.'.$pathname}=~
/\&$filename\:([\d\\|]+)\&/) {
my $refstatecond=$1;
if ($ENV{'user.priv.'.$ENV{'request.role'}.'./'.$courseprivid}	if ($ENV{'user.priv.'.$ENV{'request.role'}.'./'.$courseprivid}
=~/$priv\&([^\:]*)/) {	=~/$priv\&([^\:]*)/) {
$thisallowed.=$1;	$thisallowed.=$1;
Line 1651 sub allowed {	Line 1744 sub allowed {
\|\| ($ENV{$prefix.'res.'.$uri.'.lock.sections'} eq 'all')) {	\|\| ($ENV{$prefix.'res.'.$uri.'.lock.sections'} eq 'all')) {
if ($ENV{$prefix.'res.'.$uri.'.lock.expire'}>time) {	if ($ENV{$prefix.'res.'.$uri.'.lock.expire'}>time) {
&log($ENV{'user.domain'},$ENV{'user.name'},	&log($ENV{'user.domain'},$ENV{'user.name'},
$ENV{'user.host'},	$ENV{'user.home'},
'Locked by res: '.$priv.' for '.$uri.' due to '.	'Locked by res: '.$priv.' for '.$uri.' due to '.
$cdom.'/'.$cnum.'/'.$csec.' expire '.	$cdom.'/'.$cnum.'/'.$csec.' expire '.
$ENV{$prefix.'priv.'.$priv.'.lock.expire'});	$ENV{$prefix.'priv.'.$priv.'.lock.expire'});
Line 1662 sub allowed {	Line 1755 sub allowed {
\|\| ($ENV{$prefix.'priv.'.$priv.'.lock.sections'} eq 'all')) {	\|\| ($ENV{$prefix.'priv.'.$priv.'.lock.sections'} eq 'all')) {
if ($ENV{'priv.'.$priv.'.lock.expire'}>time) {	if ($ENV{'priv.'.$priv.'.lock.expire'}>time) {
&log($ENV{'user.domain'},$ENV{'user.name'},	&log($ENV{'user.domain'},$ENV{'user.name'},
$ENV{'user.host'},	$ENV{'user.home'},
'Locked by priv: '.$priv.' for '.$uri.' due to '.	'Locked by priv: '.$priv.' for '.$uri.' due to '.
$cdom.'/'.$cnum.'/'.$csec.' expire '.	$cdom.'/'.$cnum.'/'.$csec.' expire '.
$ENV{$prefix.'priv.'.$priv.'.lock.expire'});	$ENV{$prefix.'priv.'.$priv.'.lock.expire'});
Line 1690 sub allowed {	Line 1783 sub allowed {

if ($thisallowed=~/C/) {	if ($thisallowed=~/C/) {
my $rolecode=(split(/\./,$ENV{'request.role'}))[0];	my $rolecode=(split(/\./,$ENV{'request.role'}))[0];
	my $unamedom=$ENV{'user.name'}.':'.$ENV{'user.domain'};
if ($ENV{'course.'.$ENV{'request.course.id'}.'.'.$priv.'.roles.denied'}	if ($ENV{'course.'.$ENV{'request.course.id'}.'.'.$priv.'.roles.denied'}
=~/$rolecode/) {	=~/$rolecode/) {
&log($ENV{'user.domain'},$ENV{'user.name'},$ENV{'user.host'},	&log($ENV{'user.domain'},$ENV{'user.name'},$ENV{'user.host'},
Line 1697 sub allowed {	Line 1791 sub allowed {
$ENV{'request.course.id'});	$ENV{'request.course.id'});
return '';	return '';
}	}

	if ($ENV{'course.'.$ENV{'request.course.id'}.'.'.$priv.'.users.denied'}
	=~/$unamedom/) {
	&log($ENV{'user.domain'},$ENV{'user.name'},$ENV{'user.host'},
	'Denied by user: '.$priv.' for '.$uri.' as '.$unamedom.' in '.
	$ENV{'request.course.id'});
	return '';
	}
}	}

# Resource preferences	# Resource preferences
Line 1720 sub allowed {	Line 1822 sub allowed {
}	}
}	}

# Restricted by state?	# Restricted by state or randomout?

if ($thisallowed=~/X/) {	if ($thisallowed=~/X/) {
	if ($ENV{'acc.randomout'}) {
	my $symb=&symbread($uri,1);
	if (($symb) && ($ENV{'acc.randomout'}=~/\&$symb\&/)) {
	return '';
	}
	}
if (&condval($statecond)) {	if (&condval($statecond)) {
return '2';	return '2';
} else {	} else {
Line 1733 sub allowed {	Line 1841 sub allowed {
return 'F';	return 'F';
}	}

	# --------------------------------------------------- Is a resource on the map?

	sub is_on_map {
	my $uri=&declutter(shift);
	my @uriparts=split(/\//,$uri);
	my $filename=$uriparts[$#uriparts];
	my $pathname=$uri;
	$pathname=~s/\/$filename$//;
	my $match=($ENV{'acc.res.'.$ENV{'request.course.id'}.'.'.$pathname}=~
	/\&$filename\:([\d\\|]+)\&/);
	if ($match) {
	return (1,$1);
	} else {
	return (0,0);
	}
	}

# ----------------------------------------------------------------- Define Role	# ----------------------------------------------------------------- Define Role

sub definerole {	sub definerole {
Line 1778 sub definerole {	Line 1903 sub definerole {
# ---------------- Make a metadata query against the network of library servers	# ---------------- Make a metadata query against the network of library servers

sub metadata_query {	sub metadata_query {
my ($query,$custom,$customshow)=@_;	my ($query,$custom,$customshow,$server_array)=@_;
my %rhash;	my %rhash;
for my $server (keys %libserv) {	my @server_list = (defined($server_array) ? @$server_array
	: keys(%libserv) );
	for my $server (@server_list) {
unless ($custom or $customshow) {	unless ($custom or $customshow) {
my $reply=&reply("querysend:".&escape($query),$server);	my $reply=&reply("querysend:".&escape($query),$server);
$rhash{$server}=$reply;	$rhash{$server}=$reply;
Line 1795 sub metadata_query {	Line 1922 sub metadata_query {
return \%rhash;	return \%rhash;
}	}

	# ----------------------------------------- Send log queries and wait for reply

	sub log_query {
	my ($uname,$udom,$query,%filters)=@_;
	my $uhome=&homeserver($uname,$udom);
	if ($uhome eq 'no_host') { return 'error: no_host'; }
	my $uhost=$hostname{$uhome};
	my $command=&escape(join(':',map{$_.'='.$filters{$_}} keys %filters));
	my $queryid=&reply("querysend:".$query.':'.$udom.':'.$uname.':'.$command,
	$uhome);
	unless ($queryid=~/^$uhost\_/) { return 'error: '.$queryid; }
	return get_query_reply($queryid);
	}

	sub get_query_reply {
	my $queryid=shift;
	my $replyfile=$perlvar{'lonDaemons'}.'/tmp/'.$queryid;
	my $reply='';
	for (1..100) {
	sleep 2;
	if (-e $replyfile.'.end') {
	if (my $fh=Apache::File->new($replyfile)) {
	$reply.=<$fh>;
	$fh->close;
	} else { return 'error: reply_file_error'; }
	return &unescape($reply);
	}
	}
	return 'timeout:'.$queryid;
	}

	sub courselog_query {
	#
	# possible filters:
	# url: url or symb
	# username
	# domain
	# action: view, submit, grade
	# start: timestamp
	# end: timestamp
	#
	my (%filters)=@_;
	unless ($ENV{'request.course.id'}) { return 'no_course'; }
	if ($filters{'url'}) {
	$filters{'url'}=&symbclean(&declutter($filters{'url'}));
	$filters{'url'}=~s/\.(\w+)$/(\\.\\d+)*\\.$1/;
	$filters{'url'}=~s/\.(\w+)\_\_\_/(\\.\\d+)*\\.$1/;
	}
	my $cname=$ENV{'course.'.$ENV{'request.course.id'}.'.num'};
	my $cdom=$ENV{'course.'.$ENV{'request.course.id'}.'.domain'};
	return &log_query($cname,$cdom,'courselog',%filters);
	}

	sub userlog_query {
	my ($uname,$udom,%filters)=@_;
	return &log_query($uname,$udom,'userlog',%filters);
	}

# ------------------------------------------------------------------ Plain Text	# ------------------------------------------------------------------ Plain Text

sub plaintext {	sub plaintext {
Line 2066 sub revokecustomrole {	Line 2251 sub revokecustomrole {
# ------------------------------------------------------------ Directory lister	# ------------------------------------------------------------ Directory lister

sub dirlist {	sub dirlist {
my $uri=shift;	my ($uri,$userdomain,$username,$alternateDirectoryRoot)=@_;

$uri=~s/^\///;	$uri=~s/^\///;
$uri=~s/\/$//;	$uri=~s/\/$//;
my ($res,$udom,$uname,@rest)=split(/\//,$uri);	my ($udom, $uname);
if ($udom) {	(undef,$udom,$uname)=split(/\//,$uri);
if ($uname) {	if(defined($userdomain)) {
my $listing=reply('ls:'.$perlvar{'lonDocRoot'}.'/'.$uri,	$udom = $userdomain;
homeserver($uname,$udom));	}
return split(/:/,$listing);	if(defined($username)) {
} else {	$uname = $username;
my $tryserver;	}
my %allusers=();
foreach $tryserver (keys %libserv) {	my $dirRoot = $perlvar{'lonDocRoot'};
if ($hostdom{$tryserver} eq $udom) {	if(defined($alternateDirectoryRoot)) {
my $listing=reply('ls:'.$perlvar{'lonDocRoot'}.'/res/'.$udom,	$dirRoot = $alternateDirectoryRoot;
$tryserver);	$dirRoot =~ s/\/$//;
if (($listing ne 'no_such_dir') && ($listing ne 'empty')	}
&& ($listing ne 'con_lost')) {
foreach (split(/:/,$listing)) {	if($udom) {
my ($entry,@stat)=split(/&/,$_);	if($uname) {
$allusers{$entry}=1;	my $listing=reply('ls:'.$dirRoot.'/'.$uri,
	homeserver($uname,$udom));
	return split(/:/,$listing);
	} elsif(!defined($alternateDirectoryRoot)) {
	my $tryserver;
	my %allusers=();
	foreach $tryserver (keys %libserv) {
	if($hostdom{$tryserver} eq $udom) {
	my $listing=reply('ls:'.$perlvar{'lonDocRoot'}.'/res/'.
	$udom, $tryserver);
	if (($listing ne 'no_such_dir') && ($listing ne 'empty')
	&& ($listing ne 'con_lost')) {
	foreach (split(/:/,$listing)) {
	my ($entry,@stat)=split(/&/,$_);
	$allusers{$entry}=1;
	}
	}
}	}
}	}
}	my $alluserstr='';
}	foreach (sort keys %allusers) {
my $alluserstr='';	$alluserstr.=$_.'&user:';
foreach (sort keys %allusers) {	}
$alluserstr.=$_.'&user:';	$alluserstr=~s/:$//;
}	return split(/:/,$alluserstr);
$alluserstr=~s/:$//;	} else {
return split(/:/,$alluserstr);	my @emptyResults = ();
}	push(@emptyResults, 'missing user name');
} else {	return split(':',@emptyResults);
my $tryserver;	}
my %alldom=();	} elsif(!defined($alternateDirectoryRoot)) {
foreach $tryserver (keys %libserv) {	my $tryserver;
$alldom{$hostdom{$tryserver}}=1;	my %alldom=();
}	foreach $tryserver (keys %libserv) {
my $alldomstr='';	$alldom{$hostdom{$tryserver}}=1;
foreach (sort keys %alldom) {	}
$alldomstr.=$perlvar{'lonDocRoot'}.'/res/'.$_.'&domain:';	my $alldomstr='';
}	foreach (sort keys %alldom) {
$alldomstr=~s/:$//;	$alldomstr.=$perlvar{'lonDocRoot'}.'/res/'.$_.'&domain:';
return split(/:/,$alldomstr);	}
}	$alldomstr=~s/:$//;
	return split(/:/,$alldomstr);
	} else {
	my @emptyResults = ();
	push(@emptyResults, 'missing domain');
	return split(':',@emptyResults);
	}
}	}

# -------------------------------------------------------- Value of a Condition	# -------------------------------------------------------- Value of a Condition
Line 2171 sub courseresdata {	Line 2379 sub courseresdata {
my ($coursenum,$coursedomain,@which)=@_;	my ($coursenum,$coursedomain,@which)=@_;
my $coursehom=&homeserver($coursenum,$coursedomain);	my $coursehom=&homeserver($coursenum,$coursedomain);
my $hashid=$coursenum.':'.$coursedomain;	my $hashid=$coursenum.':'.$coursedomain;
unless (defined($courseresdatacache{$hashid.'.time'})) {	my $dodump=0;
unless (time-$courseresdatacache{$hashid.'.time'}<300) {	if (!defined($courseresdatacache{$hashid.'.time'})) {
my $coursehom=&homeserver($coursenum,$coursedomain);	$dodump=1;
if ($coursehom) {	} else {
my $dumpreply=&reply('dump:'.$coursedomain.':'.$coursenum.	if (time-$courseresdatacache{$hashid.'.time'}>300) { $dodump=1; }
':resourcedata:.',$coursehom);
unless ($dumpreply=~/^error\:/) {
$courseresdatacache{$hashid.'.time'}=time;
$courseresdatacache{$hashid}=$dumpreply;
}
}
}
}	}
my @pairs=split(/\&/,$courseresdatacache{$hashid});	if ($dodump) {
my %returnhash=();	my %dumpreply=&dump('resourcedata',$coursedomain,$coursenum);
foreach (@pairs) {	my ($tmp) = keys(%dumpreply);
my ($key,$value)=split(/=/,$_);	if ($tmp !~ /^(con_lost\|error\|no_such_host)/i) {
$returnhash{unescape($key)}=unescape($value);	$courseresdatacache{$hashid.'.time'}=time;
}	$courseresdatacache{$hashid}=\%dumpreply;
my $item;	}
foreach $item (@which) {	}
if ($returnhash{$item}) { return $returnhash{$item}; }	foreach my $item (@which) {
}	if ($courseresdatacache{$hashid}->{$item}) {
return '';	return $courseresdatacache{$hashid}->{$item};
	}
	}
	return '';
}	}

# --------------------------------------------------------- Value of a Variable	# --------------------------------------------------------- Value of a Variable
Line 2267 sub EXT {	Line 2471 sub EXT {
my %reply=&get($space,[$item]);	my %reply=&get($space,[$item]);
return $reply{$item};	return $reply{$item};
}	}
} elsif ($realm eq 'request') {	} elsif ($realm eq 'query') {
	# ---------------------------------------------- pull stuff out of query string
	&Apache::loncommon::get_unprocessed_cgi($ENV{'QUERY_STRING'},[$space]);
	return $ENV{'form.'.$space};
	} elsif ($realm eq 'request') {
# ------------------------------------------------------------- request.browser	# ------------------------------------------------------------- request.browser
if ($space eq 'browser') {	if ($space eq 'browser') {
return $ENV{'browser.'.$qualifier};	return $ENV{'browser.'.$qualifier};
Line 2295 sub EXT {	Line 2503 sub EXT {
my $section;	my $section;
if (($ENV{'user.name'} eq $uname) &&	if (($ENV{'user.name'} eq $uname) &&
($ENV{'user.domain'} eq $udom)) {	($ENV{'user.domain'} eq $udom)) {
$section={'request.course.sec'};	$section=$ENV{'request.course.sec'};
} else {	} else {
$section=&usection($udom,$uname,$courseid);	$section=&usection($udom,$uname,$courseid);
}	}
Line 2344 sub EXT {	Line 2552 sub EXT {
my $thisparm='';	my $thisparm='';
if (tie(%parmhash,'GDBM_File',	if (tie(%parmhash,'GDBM_File',
$ENV{'request.course.fn'}.'_parms.db',	$ENV{'request.course.fn'}.'_parms.db',
&GDBM_READER,0640)) {	&GDBM_READER(),0640)) {
$thisparm=$parmhash{$symbparm};	$thisparm=$parmhash{$symbparm};
untie(%parmhash);	untie(%parmhash);
}	}
Line 2516 sub metadata {	Line 2724 sub metadata {
# the next is the end of "start tag"	# the next is the end of "start tag"
}	}
}	}
	&metadata_generate_part0(\%metathesekeys,\%metacache,$uri);
$metacache{$uri.':keys'}=join(',',keys %metathesekeys);	$metacache{$uri.':keys'}=join(',',keys %metathesekeys);
$metacache{$uri.':cachedtimestamp'}=time;	$metacache{$uri.':cachedtimestamp'}=time;
# this is the end of "was not already recently cached	# this is the end of "was not already recently cached
Line 2523 sub metadata {	Line 2732 sub metadata {
return $metacache{$uri.':'.$what};	return $metacache{$uri.':'.$what};
}	}

	sub metadata_generate_part0 {
	my ($metadata,$metacache,$uri) = @_;
	my %allnames;
	foreach my $metakey (sort keys %$metadata) {
	if ($metakey=~/^parameter\_(.*)/) {
	my $part=$$metacache{$uri.':'.$metakey.'.part'};
	my $name=$$metacache{$uri.':'.$metakey.'.name'};
	if (! exists($$metadata{'parameter_0_'.$name})) {
	$allnames{$name}=$part;
	}
	}
	}
	foreach my $name (keys(%allnames)) {
	$$metadata{"parameter_0_$name"}=1;
	my $key="$uri:parameter_0_$name";
	$$metacache{"$key.part"}='0';
	$$metacache{"$key.name"}=$name;
	$$metacache{"$key.type"}=$$metacache{$uri.':parameter_'.
	$allnames{$name}.'_'.$name.
	'.type'};
	my $olddis=$$metacache{$uri.':parameter_'.$allnames{$name}.'_'.$name.
	'.display'};
	my $expr='\\[Part: '.$allnames{$name}.'\\]';
	$olddis=~s/$expr/\[Part: 0\]/;
	$$metacache{"$key.display"}=$olddis;
	}
	}

# ------------------------------------------------- Update symbolic store links	# ------------------------------------------------- Update symbolic store links

sub symblist {	sub symblist {
Line 2531 sub symblist {	Line 2768 sub symblist {
my %hash;	my %hash;
if (($ENV{'request.course.fn'}) && (%newhash)) {	if (($ENV{'request.course.fn'}) && (%newhash)) {
if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',	if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',
&GDBM_WRCREAT,0640)) {	&GDBM_WRCREAT(),0640)) {
foreach (keys %newhash) {	foreach (keys %newhash) {
$hash{declutter($_)}=$mapname.'___'.$newhash{$_};	$hash{declutter($_)}=$mapname.'___'.$newhash{$_};
}	}
Line 2559 sub symbverify {	Line 2796 sub symbverify {
my %bighash;	my %bighash;
my $okay=0;	my $okay=0;
if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',	if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',
&GDBM_READER,0640)) {	&GDBM_READER(),0640)) {
my $ids=$bighash{'ids_/res/'.$thisfn};	my $ids=$bighash{'ids_/res/'.$thisfn};
unless ($ids) {	unless ($ids) {
$ids=$bighash{'ids_/'.$thisfn};	$ids=$bighash{'ids_/'.$thisfn};
Line 2597 sub symbclean {	Line 2834 sub symbclean {
# ------------------------------------------------------ Return symb list entry	# ------------------------------------------------------ Return symb list entry

sub symbread {	sub symbread {
my $thisfn=shift;	my ($thisfn,$donotrecurse)=@_;
	# no filename provided? try from environment
unless ($thisfn) {	unless ($thisfn) {
if ($ENV{'request.symb'}) { return &symbclean($ENV{'request.symb'}); }	if ($ENV{'request.symb'}) { return &symbclean($ENV{'request.symb'}); }
$thisfn=$ENV{'request.filename'};	$thisfn=$ENV{'request.filename'};
}	}
	# is that filename actually a symb? Verify, clean, and return
	if ($thisfn=~/\_\_\_\d+\_\_\_(.*)$/) {
	if (&symbverify($thisfn,$1)) { return &symbclean($thisfn); }
	}
$thisfn=declutter($thisfn);	$thisfn=declutter($thisfn);
my %hash;	my %hash;
my %bighash;	my %bighash;
my $syval='';	my $syval='';
if (($ENV{'request.course.fn'}) && ($thisfn)) {	if (($ENV{'request.course.fn'}) && ($thisfn)) {
if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',	if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',
&GDBM_READER,0640)) {	&GDBM_READER(),0640)) {
$syval=$hash{$thisfn};	$syval=$hash{$thisfn};
untie(%hash);	untie(%hash);
}	}
Line 2624 sub symbread {	Line 2866 sub symbread {
} else {	} else {
# ------------------------------------------------------- Was not in symb table	# ------------------------------------------------------- Was not in symb table
if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',	if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',
&GDBM_READER,0640)) {	&GDBM_READER(),0640)) {
# ---------------------------------------------- Get ID(s) for current resource	# ---------------------------------------------- Get ID(s) for current resource
my $ids=$bighash{'ids_/res/'.$thisfn};	my $ids=$bighash{'ids_/res/'.$thisfn};
unless ($ids) {	unless ($ids) {
$ids=$bighash{'ids_/'.$thisfn};	$ids=$bighash{'ids_/'.$thisfn};
}	}
	unless ($ids) {
	# alias?
	$ids=$bighash{'mapalias_'.$thisfn};
	}
if ($ids) {	if ($ids) {
# ------------------------------------------------------------------- Has ID(s)	# ------------------------------------------------------------------- Has ID(s)
my @possibilities=split(/\,/,$ids);	my @possibilities=split(/\,/,$ids);
Line 2637 sub symbread {	Line 2883 sub symbread {
# ----------------------------------------------- There is only one possibility	# ----------------------------------------------- There is only one possibility
my ($mapid,$resid)=split(/\./,$ids);	my ($mapid,$resid)=split(/\./,$ids);
$syval=declutter($bighash{'map_id_'.$mapid}).'___'.$resid;	$syval=declutter($bighash{'map_id_'.$mapid}).'___'.$resid;
} else {	} elsif (!$donotrecurse) {
# ------------------------------------------ There is more than one possibility	# ------------------------------------------ There is more than one possibility
my $realpossible=0;	my $realpossible=0;
foreach (@possibilities) {	foreach (@possibilities) {
Line 2652 sub symbread {	Line 2898 sub symbread {
}	}
}	}
if ($realpossible!=1) { $syval=''; }	if ($realpossible!=1) { $syval=''; }
	} else {
	$syval='';
}	}
}	}
untie(%bighash)	untie(%bighash)
Line 2720 sub ireceipt {	Line 2968 sub ireceipt {
}	}

sub receipt {	sub receipt {
return &ireceipt($ENV{'user.name'},$ENV{'user.domain'},	my ($symb,$courseid,$domain,$name) = &Apache::lonxml::whichuser();
$ENV{'request.course.id'},&symbread());	return &ireceipt($name,$domain,$courseid,$symb);
}	}

# ------------------------------------------------------------ Serves up a file	# ------------------------------------------------------------ Serves up a file
# returns either the contents of the file or a -1	# returns either the contents of the file or a -1
sub getfile {	sub getfile {
Line 2776 sub declutter {	Line 3024 sub declutter {
$thisfn=~s/^$perlvar{'lonDocRoot'}//;	$thisfn=~s/^$perlvar{'lonDocRoot'}//;
$thisfn=~s/^\///;	$thisfn=~s/^\///;
$thisfn=~s/^res\///;	$thisfn=~s/^res\///;
	$thisfn=~s/\?.+$//;
return $thisfn;	return $thisfn;
}	}

Line 2835 BEGIN {	Line 3084 BEGIN {

while (my $configline=<$config>) {	while (my $configline=<$config>) {
chomp($configline);	chomp($configline);
my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);	my ($id,$domain,$role,$name,$ip,$domdescr)=split(/:/,$configline);
$hostname{$id}=$name;	if ($id && $domain && $role && $name && $ip) {
$hostdom{$id}=$domain;	$hostname{$id}=$name;
$hostip{$id}=$ip;	$hostdom{$id}=$domain;
if ($role eq 'library') { $libserv{$id}=$name; }	$hostip{$id}=$ip;
	if ($domdescr) { $domaindescription{$domain}=$domdescr; }
	if ($role eq 'library') { $libserv{$id}=$name; }
	} else {
	if ($configline) {
	&logthis("Skipping hosts.tab line -$configline-");
	}
	}
}	}
}	}

Line 2909 $readit=1;	Line 3165 $readit=1;
1;	1;
__END__	__END__

	=pod

=head1 NAME	=head1 NAME

Apache::lonnet - TCP networking package	Apache::lonnet - Subroutines to ask questions about things in the network.

=head1 SYNOPSIS	=head1 SYNOPSIS

Invoked by other LON-CAPA modules.	Invoked by other LON-CAPA modules, when they need to talk to or about objects in the network.

&Apache::lonnet::SUBROUTINENAME(ARGUMENTS);	&Apache::lonnet::SUBROUTINENAME(ARGUMENTS);

	Common parameters:

	=over 4

	=item *

	$uname : an internal username (if $cname expecting a course Id specifically)

	=item *

	$udom : a domain (if $cdom expecting a course's domain specifically)

	=item *

	$symb : a resource instance identifier

	=item *

	$namespace : the name of a .db file that contains the data needed or
	being set.

	=back

=head1 INTRODUCTION	=head1 INTRODUCTION

This module provides subroutines which interact with the	This module provides subroutines which interact with the
lonc/lond (TCP) network layer of LON-CAPA.	lonc/lond (TCP) network layer of LON-CAPA. And Can be used to ask about
	- classes
	- users
	- resources

	For many of these objects you can also use this to store data about
	them or modify them in various ways.

This is part of the LearningOnline Network with CAPA project	This is part of the LearningOnline Network with CAPA project
described at http://www.lon-capa.org.	described at http://www.lon-capa.org.

=head1 HANDLER SUBROUTINE	=head1 RETURN MESSAGES

There is no handler routine for this module.

=head1 OTHER SUBROUTINES

=over 4	=over 4

=item *	=item *

logtouch() : make sure the logfile, lonnet.log, exists	con_lost : unable to contact remote host

=item *	=item *

logthis() : append message to lonnet.log	con_delayed : unable to contact remote host, message will be delivered
	when the connection is brought back up

=item *	=item *

logperm() : append a permanent message to lonnet.perm.log	con_failed : unable to contact remote host and unable to save message
	for later delivery

=item *	=item *

subreply() : non-critical communication, called by &reply	error: : an error a occured, a description of the error follows the :

=item *	=item *

reply() : makes two attempts to pass message; logs refusals and rejections	no_such_host : unable to fund a host associated with the user/domain
	that was requested

=item *	=back

reconlonc() : tries to reconnect lonc client processes.	=head1 PUBLIC SUBROUTINES

=item *	=head2 Session Environment Functions

critical() : passes a critical message to another server; if cannot get	=over 4
through then place message in connection buffer

=item *	=item *

appenv(%hash) : read in current user environment, append new environment	appenv(%hash) : the value of %hash is written to the user envirnoment
values to make new user environment	file, and will be restored for each access this user makes during this
	session, also modifies the %ENV for the current process

=item *	=item *

delenv($varname) : read in current user environment, remove all values	delenv($regexp) : removes all items from the session environment file that matches the regular expression in $regexp. The values are also delted from the current processes %ENV.
beginning with $varname, write new user environment (note: flock is used
to prevent conflicting shared read/writes with file)

=item *	=back

spareserver() : find server with least workload from spare.tab	=head2 User Information

	=over 4

=item *	=item *

Line 2987 authentication scheme	Line 3273 authentication scheme
=item *	=item *

authenticate($uname,$upass,$udom) : try to authenticate user from domain's lib	authenticate($uname,$upass,$udom) : try to authenticate user from domain's lib
servers (first use the current one)	servers (first use the current one), $upass should be the users password

=item *	=item *

homeserver($uname,$udom) : find the homebase for a user from domain's lib	homeserver($uname,$udom) : find the server which has the user's
servers	directory and files (there must be only one), this caches the answer,
	and also caches if there is a borken connection.

=item *	=item *

idget($udom,@ids) : find the usernames behind a list of IDs (returns hash:	idget($udom,@ids) : find the usernames behind a list of IDs (IDs are a
	unique resource in a domain, there must be only 1 ID per username, and
	only 1 username per ID in a specific domain) (returns hash:
id=>name,id=>name)	id=>name,id=>name)

=item *	=item *
Line 3010 idput($udom,%ids) : store away a list of	Line 3299 idput($udom,%ids) : store away a list of

=item *	=item *

usection($domain,$user,$courseid) : output of section name/number or '' for	rolesinit($udom,$username,$authhost) : get user privileges
"not in course" and '-1' for "no section"

=item *	=item *

userenvironment($domain,$user,$what) : puts out any environment parameter	usection($udom,$uname,$cname) : finds the section of student in the
for a user	course $cname, return section name/number or '' for "not in course"
	and '-1' for "no section"

=item *	=item *

subscribe($fname) : subscribe to a resource, return URL if possible	userenvironment($udom,$uname,@what) : gets the values of the keys
	passed in @what from the requested user's environment, returns a hash

	=back

	=head2 User Roles

	=over 4

=item *	=item *

repcopy($filename) : replicate file	allowed($priv,$uri) : check for a user privilege; returns codes for allowed
	actions
	F: full access
	U,I,K: authentication modes (cxx only)
	'': forbidden
	1: user needs to choose course
	2: browse allowed

=item *	=item *

ssi($url,%hash) : server side include, does a complete request cycle on url to	definerole($rolename,$sysrole,$domrole,$courole) : define role; define a custom
localhost, posts hash	role rolename set privileges in format of lonTabs/roles.tab for system, domain,
	and course level

=item *	=item *

log($domain,$name,$home,$message) : write to permanent log for user; use	plaintext($short) : return value in %prp hash (rolesplain.tab); plain text
critical subroutine	explanation of a user role term

	=back

	=head2 User Modification

	=over 4

=item *	=item *

flushcourselogs() : flush (save) buffer logs and access logs	assignrole($udom,$uname,$url,$role,$end,$start) : assign role; give a role to a
	user for the level given by URL. Optional start and end dates (leave empty
	string or zero for "no date")

=item *	=item *

courselog($what) : save message for course in hash	changepass($uname,$udom,$currentpass,$newpass,$server) : attempts to
	change a users, password, possible return values are: ok,
	pwchange_failure, non_authorized, auth_mode_error, unknown_user,
	refused

=item *	=item *

courseacclog($what) : save message for course using &courselog(). Perform	modifyuserauth($udom,$uname,$umode,$upass) : modify user authentication
special processing for specific resource types (problems, exams, quizzes, etc).

=item *	=item *

countacc($url) : count the number of accesses to a given URL	modifyuser($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene) :
	modify user

=item *	=item *

sub checkout($symb,$tuname,$tudom,$tcrsid) : check out an item	modifystudent($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec,$end,$start) : modify student

=item *	=item *

sub checkin($token) : check in an item	assigncustomrole($udom,$uname,$url,$rdom,$rnam,$rolename,$end,$start) : assign
	custom role; give a custom role to a user for the level given by URL. Specify
	name and domain of role author, and role name

=item *	=item *

sub expirespread($uname,$udom,$stype,$usymb) : set expire date for spreadsheet	revokerole($udom,$uname,$url,$role) : revoke a role for url

=item *	=item *

devalidate($symb) : devalidate spreadsheets	revokecustomrole($udom,$uname,$url,$role) : revoke a custom role

	=back

	=head2 Course Infomation

	=over 4

=item *	=item *

hash2str(%hash) : convert a hash into a string complete with escaping and '='	coursedescription($courseid) : course description
and '&' separators, supports elements that are arrayrefs and hashrefs

=item *	=item *

hashref2str($hashref) : convert a hashref into a string complete with	courseresdata($coursenum,$coursedomain,@which) : request for current
escaping and '=' and '&' separators, supports elements that are	parameter setting for a specific course, @what should be a list of
arrayrefs and hashrefs	parameters to ask about. This routine caches answers for 5 minutes.

	=back

	=head2 Course Modification

	=over 4

=item *	=item *

arrayref2str($arrayref) : convert an arrayref into a string complete	writecoursepref($courseid,%prefs) : write preferences (environment
with escaping and '&' separators, supports elements that are arrayrefs	database) for a course
and hashrefs

=item *	=item *

str2hash($string) : convert string to hash using unescaping and	createcourse($udom,$description,$url) : make/modify course
splitting on '=' and '&', supports elements that are arrayrefs and
hashrefs	=back

	=head2 Resource Subroutines

	=over 4

=item *	=item *

str2array($string) : convert string to hash using unescaping and	subscribe($fname) : subscribe to a resource, returns URL if possible (probably should use repcopy instead)
splitting on '&', supports elements that are arrayrefs and hashrefs

=item *	=item *

tmpreset($symb,$namespace,$domain,$stuname) : temporary storage	repcopy($filename) : subscribes to the requested file, and attempts to
	replicate from the owning library server, Might return
	HTTP_SERVICE_UNAVAILABLE, HTTP_NOT_FOUND, FORBIDDEN, OK, or
	HTTP_BAD_REQUEST, also attempts to grab the metadata for the
	resource. Expects the local filesystem pathname
	(/home/httpd/html/res/....)

	=back

	=head2 Resource Information

	=over 4

=item *	=item *

tmprestore($symb,$namespace,$domain,$stuname) : temporary restore	EXT($varname,$symb,$udom,$uname) : evaluates and returns the value of
	a vairety of different possible values, $varname should be a request
	string, and the other parameters can be used to specify who and what
	one is asking about.

	Possible values for $varname are environment.lastname (or other item
	from the envirnment hash), user.name (or someother aspect about the
	user), resource.0.maxtries (or some other part and parameter of a
	resource)

=item *	=item *

store($storehash,$symb,$namespace,$domain,$stuname) : stores hash permanently	directcondval($number) : get current value of a condition; reads from a state
for this url; hashref needs to be given and should be a \%hashname; the	string
remaining args aren't required and if they aren't passed or are '' they will
be derived from the ENV

=item *	=item *

cstore($storehash,$symb,$namespace,$domain,$stuname) : same as store but	condval($condidx) : value of condition index based on state
uses critical subroutine

=item *	=item *

restore($symb,$namespace,$domain,$stuname) : returns hash for this symb;	metadata($uri,$what,$liburi,$prefix,$depthcount) : request a
all args are optional	resource's metadata, $what should be either a specific key, or either
	'keys' (to get a list of possible keys) or 'packages' to get a list of
	packages that this resource currently uses, the last 3 arguments are only used internally for recursive metadata.

	this function automatically caches all requests

=item *	=item *

coursedescription($courseid) : course description	metadata_query($query,$custom,$customshow) : make a metadata query against the
	network of library servers; returns file handle of where SQL and regex results
	will be stored for query

=item *	=item *

rolesinit($domain,$username,$authhost) : get user privileges	symbread($filename) : return symbolic list entry (filename argument optional);
	returns the data handle

=item *	=item *

get($namespace,$storearr,$udomain,$uname) : returns hash with keys from array	symbverify($symb,$thisfn) : verifies that $symb actually exists and is
reference filled in from namesp ($udomain and $uname are optional)	a possible symb for the URL in $thisfn, returns a 1 on success, 0 on
	failure, user must be in a course, as it assumes the existance of the
	course initi hash, and uses $ENV('request.course.id'}


=item *	=item *

del($namespace,$storearr,$udomain,$uname) : deletes keys out of array from	symbclean($symb) : removes versions numbers from a symb, returns the
namesp ($udomain and $uname are optional)	cleaned symb

=item *	=item *

dump($namespace,$udomain,$uname,$regexp) :	is_on_map($uri) : checks if the $uri is somewhere on the current
dumps the complete (or key matching regexp) namespace into a hash	course map, user must be in a course for it to work.
($udomain, $uname and $regexp are optional)

=item *	=item *

put($namespace,$storehash,$udomain,$uname) : stores hash in namesp	numval($salt) : return random seed value (addend for rndseed)
($udomain and $uname are optional)

=item *	=item *

cput($namespace,$storehash,$udomain,$uname) : critical put	rndseed($symb,$courseid,$udom,$uname) : create a random sum; returns
($udomain and $uname are optional)	a random seed, all arguments are optional, if they aren't sent it uses the
	environment to derive them. Note: if symb isn't sent and it can't get one
	from &symbread it will use the current time as its return value

=item *	=item *

eget($namespace,$storearr,$udomain,$uname) : returns hash with keys from array	ireceipt($funame,$fudom,$fucourseid,$fusymb) : return unique,
reference filled in from namesp (encrypts the return communication)	unfakeable, receipt
($udomain and $uname are optional)

=item *	=item *

allowed($priv,$uri) : check for a user privilege; returns codes for allowed	receipt() : API to ireceipt working off of ENV values; given out to users
actions
F: full access
U,I,K: authentication modes (cxx only)
'': forbidden
1: user needs to choose course
2: browse allowed

=item *	=item *

definerole($rolename,$sysrole,$domrole,$courole) : define role; define a custom	countacc($url) : count the number of accesses to a given URL
role rolename set privileges in format of lonTabs/roles.tab for system, domain,
and course level

=item *	=item *

metadata_query($query,$custom,$customshow) : make a metadata query against the	checkout($symb,$tuname,$tudom,$tcrsid) : creates a record of a user having looked at an item, most likely printed out or otherwise using a resource
network of library servers; returns file handle of where SQL and regex results
will be stored for query

=item *	=item *

plaintext($short) : return value in %prp hash (rolesplain.tab); plain text	checkin($token) : updates that a resource has beeen returned (a hard copy version for instance) and returns the data that $token was Checkout with ($symb, $tuname, $tudom, and $tcrsid)
explanation of a user role term

=item *	=item *

assignrole($udom,$uname,$url,$role,$end,$start) : assign role; give a role to a	expirespread($uname,$udom,$stype,$usymb) : set expire date for spreadsheet
user for the level given by URL. Optional start and end dates (leave empty
string or zero for "no date")

=item *	=item *

modifyuserauth($udom,$uname,$umode,$upass) : modify user authentication	devalidate($symb) : devalidate temporary spreadsheet calculations,
	forcing spreadsheet to reevaluate the resource scores next time.

	=back

	=head2 Storing/Retreiving Data

	=over 4

=item *	=item *

modifyuser($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene) :	store($storehash,$symb,$namespace,$udom,$uname) : stores hash permanently
modify user	for this url; hashref needs to be given and should be a \%hashname; the
	remaining args aren't required and if they aren't passed or are '' they will
	be derived from the ENV

=item *	=item *

modifystudent($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec,	cstore($storehash,$symb,$namespace,$udom,$uname) : same as store but
$end,$start) : modify student	uses critical subroutine

=item *	=item *

writecoursepref($courseid,%prefs) : write preferences for a course	restore($symb,$namespace,$udom,$uname) : returns hash for this symb;
	all args are optional

=item *	=item *

createcourse($udom,$description,$url) : make/modify course	tmpstore($storehash,$symb,$namespace,$udom,$uname) : storage that
	works very similar to store/cstore, but all data is stored in a
	temporary location and can be reset using tmpreset, $storehash should
	be a hash reference, returns nothing on success

=item *	=item *

assigncustomrole($udom,$uname,$url,$rdom,$rnam,$rolename,$end,$start) : assign	tmprestore($symb,$namespace,$udom,$uname) : storage that works very
custom role; give a custom role to a user for the level given by URL. Specify	similar to restore, but all data is stored in a temporary location and
name and domain of role author, and role name	can be reset using tmpreset. Returns a hash of values on success,
	error string otherwise.

=item *	=item *

revokerole($udom,$uname,$url,$role) : revoke a role for url	tmpreset($symb,$namespace,$udom,$uname) : temporary storage reset,
	deltes all keys for $symb form the temporary storage hash.

=item *	=item *

revokecustomrole($udom,$uname,$url,$role) : revoke a custom role	get($namespace,$storearr,$udom,$uname) : returns hash with keys from array
	reference filled in from namesp ($udom and $uname are optional)

	=item *

	del($namespace,$storearr,$udom,$uname) : deletes keys out of array from
	namesp ($udom and $uname are optional)

	=item *

	dump($namespace,$udom,$uname,$regexp) :
	dumps the complete (or key matching regexp) namespace into a hash
	($udom, $uname and $regexp are optional)

	=item *

	put($namespace,$storehash,$udom,$uname) : stores hash in namesp
	($udom and $uname are optional)

	=item *

	cput($namespace,$storehash,$udom,$uname) : critical put
	($udom and $uname are optional)

	=item *

	eget($namespace,$storearr,$udom,$uname) : returns hash with keys from array
	reference filled in from namesp (encrypts the return communication)
	($udom and $uname are optional)

	=item *

	log($udom,$name,$home,$message) : write to permanent log for user; use
	critical subroutine

	=back

	=head2 Network Status Functions

	=over 4

=item *	=item *

Line 3237 dirlist($uri) : return directory list ba	Line 3632 dirlist($uri) : return directory list ba

=item *	=item *

directcondval($number) : get current value of a condition; reads from a state	spareserver() : find server with least workload from spare.tab
string
	=back

	=head2 Apache Request

	=over 4

=item *	=item *

condval($condidx) : value of condition index based on state	ssi($url,%hash) : server side include, does a complete request cycle on url to
	localhost, posts hash

	=back

	=head2 Data to String to Data

	=over 4

=item *	=item *

EXT($varname,$symbparm) : value of a variable	hash2str(%hash) : convert a hash into a string complete with escaping and '='
	and '&' separators, supports elements that are arrayrefs and hashrefs

=item *	=item *

metadata($uri,$what,$liburi,$prefix,$depthcount) : get metadata; returns the	hashref2str($hashref) : convert a hashref into a string complete with
metadata entry for a file; entry='keys', returns a comma separated list of keys	escaping and '=' and '&' separators, supports elements that are
	arrayrefs and hashrefs

=item *	=item *

symblist($mapname,%newhash) : update symbolic storage links	arrayref2str($arrayref) : convert an arrayref into a string complete
	with escaping and '&' separators, supports elements that are arrayrefs
	and hashrefs

=item *	=item *

symbread($filename) : return symbolic list entry (filename argument optional);	str2hash($string) : convert string to hash using unescaping and
returns the data handle	splitting on '=' and '&', supports elements that are arrayrefs and
	hashrefs

=item *	=item *

numval($salt) : return random seed value (addend for rndseed)	str2array($string) : convert string to hash using unescaping and
	splitting on '&', supports elements that are arrayrefs and hashrefs

	=back

	=head2 Logging Routines

	=over 4

	These routines allow one to make log messages in the lonnet.log and
	lonnet.perm logfiles.

=item *	=item *

rndseed($symb,$courseid,$domain,$username) : create a random sum; returns	logtouch() : make sure the logfile, lonnet.log, exists
a random seed, all arguments are optional, if they aren't sent it uses the
environment to derive them. Note: if symb isn't sent and it can't get one
from &symbread it will use the current time as its return value

=item *	=item *

ireceipt($funame,$fudom,$fucourseid,$fusymb) : return unique,	logthis() : append message to the normal lonnet.log file, it gets
unfakeable, receipt	preiodically rolled over and deleted.

=item *	=item *

receipt() : API to ireceipt working off of ENV values; given out to users	logperm() : append a permanent message to lonnet.perm.log, this log
	file never gets deleted by any automated portion of the system, only
	messages of critical importance should go in here.

	=back

	=head2 General File Helper Routines

	=over 4

=item *	=item *

getfile($file) : serves up a file, returns the contents of a file or -1;	getfile($file) : returns the entire contents of a file or -1; it
replicates and subscribes to the file	properly subscribes to and replicates the file if neccessary.

=item *	=item *

filelocation($dir,$file) : returns file system location of a file based on URI;	filelocation($dir,$file) : returns file system location of a file
meant to be "fairly clean" absolute reference, $dir is a directory that relative $file lookups are to looked in ($dir of /a/dir and a file of ../bob will become /a/bob)	based on URI; meant to be "fairly clean" absolute reference, $dir is a
	directory that relative $file lookups are to looked in ($dir of /a/dir
	and a file of ../bob will become /a/bob)

=item *	=item *

Line 3301 filelocation except for hrefs	Line 3730 filelocation except for hrefs

declutter() : declutters URLs (remove docroot, beginning slashes, 'res' etc)	declutter() : declutters URLs (remove docroot, beginning slashes, 'res' etc)

	=back

	=head2 HTTP Helper Routines

	=over 4

=item *	=item *

escape() : unpack non-word characters into CGI-compatible hex codes	escape() : unpack non-word characters into CGI-compatible hex codes
Line 3309 escape() : unpack non-word characters in	Line 3744 escape() : unpack non-word characters in

unescape() : pack CGI-compatible hex codes into actual non-word ASCII character	unescape() : pack CGI-compatible hex codes into actual non-word ASCII character

	=back

	=head1 PRIVATE SUBROUTINES

	=head2 Underlying communication routines (Shouldn't call)

	=over 4

	=item *

	subreply() : tries to pass a message to lonc, returns con_lost if incapable

	=item *

	reply() : uses subreply to send a message to remote machine, logs all failures

	=item *

	critical() : passes a critical message to another server; if cannot
	get through then place message in connection buffer directory and
	returns con_delayed, if incapable of saving message, returns
	con_failed

	=item *

	reconlonc() : tries to reconnect lonc client processes.

	=back

	=head2 Resource Access Logging

	=over 4

	=item *

	flushcourselogs() : flush (save) buffer logs and access logs

	=item *

	courselog($what) : save message for course in hash

	=item *

	courseacclog($what) : save message for course using &courselog(). Perform
	special processing for specific resource types (problems, exams, quizzes, etc).

=item *	=item *

goodbye() : flush course logs and log shutting down; it is called in srm.conf	goodbye() : flush course logs and log shutting down; it is called in srm.conf
Line 3316 as a PerlChildExitHandler	Line 3797 as a PerlChildExitHandler

=back	=back

	=head2 Other

	=over 4

	=item *

	symblist($mapname,%newhash) : update symbolic storage links

	=back

=cut	=cut

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

Removed from v.1.231
changed lines
	Added in v.1.263