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.211 and 1.246

version 1.211, 2002/05/06 13:46:41	version 1.246, 2002/06/27 14:08:06
Line 77 use Apache::File;	Line 77 use Apache::File;
use LWP::UserAgent();	use LWP::UserAgent();
use HTTP::Headers;	use HTTP::Headers;
use vars	use vars
qw(%perlvar %hostname %homecache %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 481 sub authenticate {	Line 481 sub authenticate {
# ---------------------- Find the homebase for a user from domain's lib servers	# ---------------------- Find the homebase for a user from domain's lib servers

sub homeserver {	sub homeserver {
my ($uname,$udom)=@_;	my ($uname,$udom,$ignoreBadCache)=@_;

my $index="$uname:$udom";	my $index="$uname:$udom";
if ($homecache{$index}) { return "$homecache{$index}"; }	if ($homecache{$index}) {
	return "$homecache{$index}";
	}
my $tryserver;	my $tryserver;
foreach $tryserver (keys %libserv) {	foreach $tryserver (keys %libserv) {
	next if ($ignoreBadCache ne 'true' &&
	exists($badServerCache{$tryserver}));
if ($hostdom{$tryserver} eq $udom) {	if ($hostdom{$tryserver} eq $udom) {
my $answer=reply("home:$udom:$uname",$tryserver);	my $answer=reply("home:$udom:$uname",$tryserver);
if ($answer eq 'found') {	if ($answer eq 'found') {
$homecache{$index}=$tryserver;	$homecache{$index}=$tryserver;
return $tryserver;	return $tryserver;
}	} elsif ($answer eq 'no_host') {
	$badServerCache{$tryserver}=1;
	}
}	}
}	}
return 'no_host';	return 'no_host';
Line 627 sub subscribe {	Line 631 sub subscribe {
sub repcopy {	sub repcopy {
my $filename=shift;	my $filename=shift;
$filename=~s/\/+/\//g;	$filename=~s/\/+/\//g;
	if ($filename=~/^\/home\/httpd\/html\/adm\//) { return OK; }
my $transname="$filename.in.transfer";	my $transname="$filename.in.transfer";
if ((-e $filename) \|\| (-e $transname)) { return OK; }	if ((-e $filename) \|\| (-e $transname)) { return OK; }
my $remoteurl=subscribe($filename);	my $remoteurl=subscribe($filename);
Line 716 sub flushcourselogs {	Line 721 sub flushcourselogs {
&logthis('Flushing course log buffers');	&logthis('Flushing course log buffers');
foreach (keys %courselogs) {	foreach (keys %courselogs) {
my $crsid=$_;	my $crsid=$_;
&logthis(":$crsid:$coursehombuf{$crsid}");
if (&reply('log:'.$coursedombuf{$crsid}.':'.	if (&reply('log:'.$coursedombuf{$crsid}.':'.
&escape($courselogs{$crsid}),	&escape($courselogs{$crsid}),
$coursehombuf{$crsid}) eq 'ok') {	$coursehombuf{$crsid}) eq 'ok') {
Line 795 sub checkout {	Line 799 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 844 sub checkin {	Line 849 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 1139 sub store {	Line 1144 sub store {

if ($stuname) { $home=&homeserver($stuname,$domain); }	if ($stuname) { $home=&homeserver($stuname,$domain); }

	$symb=&symbclean($symb);
if (!$symb) { unless ($symb=&symbread()) { return ''; } }	if (!$symb) { unless ($symb=&symbread()) { return ''; } }

&devalidate($symb);	&devalidate($symb);
Line 1169 sub cstore {	Line 1175 sub cstore {

if ($stuname) { $home=&homeserver($stuname,$domain); }	if ($stuname) { $home=&homeserver($stuname,$domain); }

	$symb=&symbclean($symb);
if (!$symb) { unless ($symb=&symbread()) { return ''; } }	if (!$symb) { unless ($symb=&symbread()) { return ''; } }

&devalidate($symb);	&devalidate($symb);
Line 1204 sub restore {	Line 1211 sub restore {
if (!$symb) {	if (!$symb) {
unless ($symb=escape(&symbread())) { return ''; }	unless ($symb=escape(&symbread())) { return ''; }
} else {	} else {
$symb=&escape($symb);	$symb=&escape(&symbclean($symb));
}	}
if (!$namespace) {	if (!$namespace) {
unless ($namespace=$ENV{'request.course.id'}) {	unless ($namespace=$ENV{'request.course.id'}) {
Line 1494 sub allowed {	Line 1501 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 '';
	}
	}
}	}

my $thisallowed='';	my $thisallowed='';
Line 1542 sub allowed {	Line 1563 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 1564 sub allowed {	Line 1582 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 1578 sub allowed {	Line 1595 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 1645 sub allowed {	Line 1659 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 1656 sub allowed {	Line 1670 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 1684 sub allowed {	Line 1698 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 1691 sub allowed {	Line 1706 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 1714 sub allowed {	Line 1737 sub allowed {
}	}
}	}

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

if ($thisallowed=~/X/) {	if ($thisallowed=~/X/) {
if (&condval($statecond)) {	if ((&condval($statecond)) &&
	(!$ENV{'acc.randomout'}=~/\&$ENV{'request.symb'}\&/)) {
return '2';	return '2';
} else {	} else {
return '';	return '';
Line 1727 sub allowed {	Line 1751 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 1772 sub definerole {	Line 1813 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 1789 sub metadata_query {	Line 1832 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 1873 sub modifyuser {	Line 1974 sub modifyuser {
(defined($desiredhome) ? ' desiredhome = '.$desiredhome :	(defined($desiredhome) ? ' desiredhome = '.$desiredhome :
' desiredhome not specified').	' desiredhome not specified').
' by '.$ENV{'user.name'}.' at '.$ENV{'user.domain'});	' by '.$ENV{'user.name'}.' at '.$ENV{'user.domain'});
my $uhome=&homeserver($uname,$udom);	my $uhome=&homeserver($uname,$udom,'true');
# ----------------------------------------------------------------- Create User	# ----------------------------------------------------------------- Create User
if (($uhome eq 'no_host') && ($umode) && ($upass)) {	if (($uhome eq 'no_host') && ($umode) && ($upass)) {
my $unhome='';	my $unhome='';
Line 1903 sub modifyuser {	Line 2004 sub modifyuser {
unless ($reply eq 'ok') {	unless ($reply eq 'ok') {
return 'error: '.$reply;	return 'error: '.$reply;
}	}
$uhome=&homeserver($uname,$udom);	$uhome=&homeserver($uname,$udom,'true');
if (($uhome eq '') \|\| ($uhome eq 'no_host') \|\| ($uhome ne $unhome)) {	if (($uhome eq '') \|\| ($uhome eq 'no_host') \|\| ($uhome ne $unhome)) {
return 'error: verify home';	return 'error: verify home';
}	}
Line 2010 sub createcourse {	Line 2111 sub createcourse {
my $uname=substr($$.time,0,5).unpack("H8",pack("I32",time)).	my $uname=substr($$.time,0,5).unpack("H8",pack("I32",time)).
unpack("H2",pack("I32",int(rand(255)))).$perlvar{'lonHostID'};	unpack("H2",pack("I32",int(rand(255)))).$perlvar{'lonHostID'};
# ----------------------------------------------- Make sure that does not exist	# ----------------------------------------------- Make sure that does not exist
my $uhome=&homeserver($uname,$udom);	my $uhome=&homeserver($uname,$udom,'true');
unless (($uhome eq '') \|\| ($uhome eq 'no_host')) {	unless (($uhome eq '') \|\| ($uhome eq 'no_host')) {
$uname=substr($$.time,0,5).unpack("H8",pack("I32",time)).	$uname=substr($$.time,0,5).unpack("H8",pack("I32",time)).
unpack("H2",pack("I32",int(rand(255)))).$perlvar{'lonHostID'};	unpack("H2",pack("I32",int(rand(255)))).$perlvar{'lonHostID'};
$uhome=&homeserver($uname,$udom);	$uhome=&homeserver($uname,$udom,'true');
unless (($uhome eq '') \|\| ($uhome eq 'no_host')) {	unless (($uhome eq '') \|\| ($uhome eq 'no_host')) {
return 'error: unable to generate unique course-ID';	return 'error: unable to generate unique course-ID';
}	}
Line 2023 sub createcourse {	Line 2124 sub createcourse {
my $reply=&reply('encrypt:makeuser:'.$udom.':'.$uname.':none::',	my $reply=&reply('encrypt:makeuser:'.$udom.':'.$uname.':none::',
$ENV{'user.home'});	$ENV{'user.home'});
unless ($reply eq 'ok') { return 'error: '.$reply; }	unless ($reply eq 'ok') { return 'error: '.$reply; }
$uhome=&homeserver($uname,$udom);	$uhome=&homeserver($uname,$udom,'true');
if (($uhome eq '') \|\| ($uhome eq 'no_host')) {	if (($uhome eq '') \|\| ($uhome eq 'no_host')) {
return 'error: no such course';	return 'error: no such course';
}	}
Line 2194 sub courseresdata {	Line 2295 sub courseresdata {
# --------------------------------------------------------- Value of a Variable	# --------------------------------------------------------- Value of a Variable

sub EXT {	sub EXT {
my ($varname,$symbparm)=@_;	my ($varname,$symbparm,$udom,$uname)=@_;

unless ($varname) { return ''; }	unless ($varname) { return ''; }

	#get real user name/domain, courseid and symb
	my $courseid;
	if (!($uname && $udom)) {
	(my $cursymb,$courseid,$udom,$uname)=&Apache::lonxml::whichuser();
	if (!$symbparm) { $symbparm=$cursymb; }
	} else {
	$courseid=$ENV{'request.course.id'};
	}

my ($realm,$space,$qualifier,@therest)=split(/\./,$varname);	my ($realm,$space,$qualifier,@therest)=split(/\./,$varname);
my $rest;	my $rest;
if ($therest[0]) {	if ($therest[0]) {
Line 2210 sub EXT {	Line 2322 sub EXT {
if ($realm eq 'user') {	if ($realm eq 'user') {
# --------------------------------------------------------------- user.resource	# --------------------------------------------------------------- user.resource
if ($space eq 'resource') {	if ($space eq 'resource') {
my %restored=&restore();	my %restored=&restore(undef,undef,$udom,$uname);
return $restored{$qualifierrest};	return $restored{$qualifierrest};
# ----------------------------------------------------------------- user.access	# ----------------------------------------------------------------- user.access
} elsif ($space eq 'access') {	} elsif ($space eq 'access') {
	# FIXME - not supporting calls for a specific user
return &allowed($qualifier,$rest);	return &allowed($qualifier,$rest);
# ------------------------------------------ user.preferences, user.environment	# ------------------------------------------ user.preferences, user.environment
} elsif (($space eq 'preferences') \|\| ($space eq 'environment')) {	} elsif (($space eq 'preferences') \|\| ($space eq 'environment')) {
return $ENV{join('.',('environment',$qualifierrest))};	if (($uname eq $ENV{'user.name'}) &&
	($udom eq $ENV{'user.domain'})) {
	return $ENV{join('.',('environment',$qualifierrest))};
	} else {
	my %returnhash=&userenvironment($udom,$uname,$qualifierrest);
	return $returnhash{$qualifierrest};
	}
# ----------------------------------------------------------------- user.course	# ----------------------------------------------------------------- user.course
} elsif ($space eq 'course') {	} elsif ($space eq 'course') {
	# FIXME - not supporting calls for a specific user
return $ENV{join('.',('request.course',$qualifier))};	return $ENV{join('.',('request.course',$qualifier))};
# ------------------------------------------------------------------- user.role	# ------------------------------------------------------------------- user.role
} elsif ($space eq 'role') {	} elsif ($space eq 'role') {
	# FIXME - not supporting calls for a specific user
my ($role,$where)=split(/\./,$ENV{'request.role'});	my ($role,$where)=split(/\./,$ENV{'request.role'});
if ($qualifier eq 'value') {	if ($qualifier eq 'value') {
return $role;	return $role;
Line 2231 sub EXT {	Line 2352 sub EXT {
}	}
# ----------------------------------------------------------------- user.domain	# ----------------------------------------------------------------- user.domain
} elsif ($space eq 'domain') {	} elsif ($space eq 'domain') {
return $ENV{'user.domain'};	return $udom;
# ------------------------------------------------------------------- user.name	# ------------------------------------------------------------------- user.name
} elsif ($space eq 'name') {	} elsif ($space eq 'name') {
return $ENV{'user.name'};	return $uname;
# ---------------------------------------------------- Any other user namespace	# ---------------------------------------------------- Any other user namespace
} else {	} else {
my $item=($rest)?$qualifier.'.'.$rest:$qualifier;	my $item=($rest)?$qualifier.'.'.$rest:$qualifier;
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 2251 sub EXT {	Line 2376 sub EXT {
}	}
} elsif ($realm eq 'course') {	} elsif ($realm eq 'course') {
# ---------------------------------------------------------- course.description	# ---------------------------------------------------------- course.description
return $ENV{'course.'.$ENV{'request.course.id'}.'.'.	return $ENV{'course.'.$courseid.'.'.$spacequalifierrest};
$spacequalifierrest};
} elsif ($realm eq 'resource') {	} elsif ($realm eq 'resource') {
if ($ENV{'request.course.id'}) {

# print '<br>'.$space.' - '.$qualifier.' - '.$spacequalifierrest;	if ($courseid eq $ENV{'request.course.id'}) {

	#print '<br>'.$space.' - '.$qualifier.' - '.$spacequalifierrest;

# ----------------------------------------------------- Cascading lookup scheme	# ----------------------------------------------------- Cascading lookup scheme
my $symbp;	if (!$symbparm) { $symbparm=&symbread(); }
if ($symbparm) {	my $symbp=$symbparm;
$symbp=$symbparm;	my $mapp=(split(/\_\_\_/,$symbp))[0];
} else {
$symbp=&symbread();	my $symbparm=$symbp.'.'.$spacequalifierrest;
}	my $mapparm=$mapp.'___(all).'.$spacequalifierrest;
my $mapp=(split(/\_\_\_/,$symbp))[0];
	my $section;
my $symbparm=$symbp.'.'.$spacequalifierrest;	if (($ENV{'user.name'} eq $uname) &&
my $mapparm=$mapp.'___(all).'.$spacequalifierrest;	($ENV{'user.domain'} eq $udom)) {
	$section={'request.course.sec'};
my $seclevel=	} else {
$ENV{'request.course.id'}.'.['.	$section=&usection($udom,$uname,$courseid);
$ENV{'request.course.sec'}.'].'.$spacequalifierrest;	}
my $seclevelr=
$ENV{'request.course.id'}.'.['.
$ENV{'request.course.sec'}.'].'.$symbparm;
my $seclevelm=
$ENV{'request.course.id'}.'.['.
$ENV{'request.course.sec'}.'].'.$mapparm;

my $courselevel=
$ENV{'request.course.id'}.'.'.$spacequalifierrest;
my $courselevelr=
$ENV{'request.course.id'}.'.'.$symbparm;
my $courselevelm=
$ENV{'request.course.id'}.'.'.$mapparm;

# ----------------------------------------------------------- first, check user	my $seclevel=$courseid.'.['.$section.'].'.$spacequalifierrest;
my %resourcedata=get('resourcedata',	my $seclevelr=$courseid.'.['.$section.'].'.$symbparm;
[$courselevelr,$courselevelm,$courselevel]);	my $seclevelm=$courseid.'.['.$section.'].'.$mapparm;
if (($resourcedata{$courselevelr}!~/^error\:/) &&
($resourcedata{$courselevelr}!~/^con_lost/)) {	my $courselevel=$courseid.'.'.$spacequalifierrest;
	my $courselevelr=$courseid.'.'.$symbparm;
if ($resourcedata{$courselevelr}) {	my $courselevelm=$courseid.'.'.$mapparm;
return $resourcedata{$courselevelr}; }
if ($resourcedata{$courselevelm}) {
return $resourcedata{$courselevelm}; }
if ($resourcedata{$courselevel}) { return $resourcedata{$courselevel}; }

} else {	# ----------------------------------------------------------- first, check user
if ($resourcedata{$courselevelr}!~/No such file/) {	my %resourcedata=&get('resourcedata',
&logthis("<font color=blue>WARNING:".	[$courselevelr,$courselevelm,$courselevel],
" Trying to get resource data for ".$ENV{'user.name'}." at "	$udom,$uname);
.$ENV{'user.domain'}.": ".$resourcedata{$courselevelr}.	if (($resourcedata{$courselevelr}!~/^error\:/) &&
"</font>");	($resourcedata{$courselevelr}!~/^con_lost/)) {
}
}	if ($resourcedata{$courselevelr}) {
	return $resourcedata{$courselevelr}; }
	if ($resourcedata{$courselevelm}) {
	return $resourcedata{$courselevelm}; }
	if ($resourcedata{$courselevel}) {
	return $resourcedata{$courselevel}; }
	} else {
	if ($resourcedata{$courselevelr}!~/No such file/) {
	&logthis("<font color=blue>WARNING:".
	" Trying to get resource data for ".
	$uname." at ".$udom.": ".
	$resourcedata{$courselevelr}."</font>");
	}
	}

# -------------------------------------------------------- second, check course	# -------------------------------------------------------- second, check course

my $coursereply=&courseresdata(	my $coursereply=&courseresdata($ENV{'course.'.$courseid.'.num'},
$ENV{'course.'.$ENV{'request.course.id'}.'.num'},	$ENV{'course.'.$courseid.'.domain'},
$ENV{'course.'.$ENV{'request.course.id'}.'.domain'},	($seclevelr,$seclevelm,$seclevel,
($seclevelr,$seclevelm,$seclevel,	$courselevelr,$courselevelm,
$courselevelr,$courselevelm,$courselevel));	$courselevel));
if ($coursereply) { return $coursereply; }	if ($coursereply) { return $coursereply; }

# ------------------------------------------------------ third, check map parms	# ------------------------------------------------------ third, check map parms
my %parmhash=();	my %parmhash=();
my $thisparm='';	my $thisparm='';
if (tie(%parmhash,'GDBM_File',	if (tie(%parmhash,'GDBM_File',
$ENV{'request.course.fn'}.'_parms.db',&GDBM_READER,0640)) {	$ENV{'request.course.fn'}.'_parms.db',
$thisparm=$parmhash{$symbparm};	&GDBM_READER,0640)) {
untie(%parmhash);	$thisparm=$parmhash{$symbparm};
}	untie(%parmhash);
if ($thisparm) { return $thisparm; }	}
}	if ($thisparm) { return $thisparm; }
	}
# --------------------------------------------- last, look in resource metadata	# --------------------------------------------- last, look in resource metadata

$spacequalifierrest=~s/\./\_/;	$spacequalifierrest=~s/\./\_/;
my $metadata=&metadata($ENV{'request.filename'},$spacequalifierrest);	my $metadata=&metadata($ENV{'request.filename'},$spacequalifierrest);
if ($metadata) { return $metadata; }	if ($metadata) { return $metadata; }
$metadata=&metadata($ENV{'request.filename'},	$metadata=&metadata($ENV{'request.filename'},
'parameter_'.$spacequalifierrest);	'parameter_'.$spacequalifierrest);
if ($metadata) { return $metadata; }	if ($metadata) { return $metadata; }

# ------------------------------------------------------------------ Cascade up	# ------------------------------------------------------------------ Cascade up
	unless ($space eq '0') {
unless ($space eq '0') {	my ($part,$id)=split(/\_/,$space);
my ($part,$id)=split(/\_/,$space);	if ($id) {
if ($id) {	my $partgeneral=&EXT('resource.'.$part.'.'.$qualifierrest,
my $partgeneral=&EXT('resource.'.$part.'.'.$qualifierrest,	$symbparm,$udom,$uname);
$symbparm);	if ($partgeneral) { return $partgeneral; }
if ($partgeneral) { return $partgeneral; }	} else {
} else {	my $resourcegeneral=&EXT('resource.0.'.$qualifierrest,
my $resourcegeneral=&EXT('resource.0.'.$qualifierrest,	$symbparm,$udom,$uname);
$symbparm);	if ($resourcegeneral) { return $resourcegeneral; }
if ($resourcegeneral) { return $resourcegeneral; }	}
}	}
}

# ---------------------------------------------------- Any other user namespace	# ---------------------------------------------------- Any other user namespace
} elsif ($realm eq 'environment') {	} elsif ($realm eq 'environment') {
# ----------------------------------------------------------------- environment	# ----------------------------------------------------------------- environment
return $ENV{'environment.'.$spacequalifierrest};	if (($uname eq $ENV{'user.name'})&&($udom eq $ENV{'user.domain'})) {
	return $ENV{'environment.'.$spacequalifierrest};
	} else {
	my %returnhash=&userenvironment($udom,$uname,
	$spacequalifierrest);
	return $returnhash{$spacequalifierrest};
	}
} elsif ($realm eq 'system') {	} elsif ($realm eq 'system') {
# ----------------------------------------------------------------- system.time	# ----------------------------------------------------------------- system.time
if ($space eq 'time') {	if ($space eq 'time') {
Line 2517 sub symblist {	Line 2642 sub symblist {
return 'error';	return 'error';
}	}

	# --------------------------------------------------------------- Verify a symb

	sub symbverify {
	my ($symb,$thisfn)=@_;
	$thisfn=&declutter($thisfn);
	# direct jump to resource in page or to a sequence - will construct own symbs
	if ($thisfn=~/\.(page\|sequence)$/) { return 1; }
	# check URL part
	my ($map,$resid,$url)=split(/\_\_\_/,$symb);
	unless (&symbclean($url) eq &symbclean($thisfn)) { return 0; }

	$symb=&symbclean($symb);

	my %bighash;
	my $okay=0;
	if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',
	&GDBM_READER,0640)) {
	my $ids=$bighash{'ids_/res/'.$thisfn};
	unless ($ids) {
	$ids=$bighash{'ids_/'.$thisfn};
	}
	if ($ids) {
	# ------------------------------------------------------------------- Has ID(s)
	foreach (split(/\,/,$ids)) {
	my ($mapid,$resid)=split(/\./,$_);
	if (
	&symbclean(&declutter($bighash{'map_id_'.$mapid}).'___'.$resid.'___'.$thisfn)
	eq $symb) {
	$okay=1;
	}
	}
	}
	untie(%bighash);
	}
	return $okay;
	}

# --------------------------------------------------------------- Clean-up symb	# --------------------------------------------------------------- Clean-up symb

sub symbclean {	sub symbclean {
my $symb=shift;	my $symb=shift;

# remove version from map	# remove version from map
$symb=~s/\.(\d+)\.(\w+)\_\_\_/\.$2\_\_\_/;	$symb=~s/\.(\d+)\.(\w+)\_\_\_/\.$2\_\_\_/;

# remove version from URL	# remove version from URL
$symb=~s/\.(\d+)\.(\w+)$/\.$2/;	$symb=~s/\.(\d+)\.(\w+)$/\.$2/;

return $symb;	return $symb;
}	}

Line 2532 sub symbclean {	Line 2697 sub symbclean {

sub symbread {	sub symbread {
my $thisfn=shift;	my $thisfn=shift;
	# 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;
Line 2564 sub symbread {	Line 2734 sub symbread {
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 2696 sub hreflocation {	Line 2870 sub hreflocation {
unless (($file=~/^http:\/\//i) \|\| ($file=~/^\//)) {	unless (($file=~/^http:\/\//i) \|\| ($file=~/^\//)) {
my $finalpath=filelocation($dir,$file);	my $finalpath=filelocation($dir,$file);
$finalpath=~s/^\/home\/httpd\/html//;	$finalpath=~s/^\/home\/httpd\/html//;
	$finalpath=~s-/home/(\w+)/public_html/-/~$1/-;
return $finalpath;	return $finalpath;
} else {	} else {
return $file;	return $file;
Line 2709 sub declutter {	Line 2884 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 2737 sub goodbye {	Line 2913 sub goodbye {
}	}

BEGIN {	BEGIN {
# ------------------------------------------------------------ Read access.conf	# ----------------------------------- Read loncapa.conf and loncapa_apache.conf
unless ($readit) {	unless ($readit) {
{	{
my $config=Apache::File->new("/etc/httpd/conf/access.conf");	my $config=Apache::File->new("/etc/httpd/conf/loncapa.conf");

	while (my $configline=<$config>) {
	if ($configline =~ /^[^\#]*PerlSetVar/) {
	my ($dummy,$varname,$varvalue)=split(/\s+/,$configline);
	chomp($varvalue);
	$perlvar{$varname}=$varvalue;
	}
	}
	}
	{
	my $config=Apache::File->new("/etc/httpd/conf/loncapa_apache.conf");

while (my $configline=<$config>) {	while (my $configline=<$config>) {
if ($configline =~ /PerlSetVar/) {	if ($configline =~ /^[^\#]*PerlSetVar/) {
my ($dummy,$varname,$varvalue)=split(/\s+/,$configline);	my ($dummy,$varname,$varvalue)=split(/\s+/,$configline);
chomp($varvalue);	chomp($varvalue);
$perlvar{$varname}=$varvalue;	$perlvar{$varname}=$varvalue;
Line 2757 BEGIN {	Line 2944 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;	$hostname{$id}=$name;
$hostdom{$id}=$domain;	$hostdom{$id}=$domain;
$hostip{$id}=$ip;	$hostip{$id}=$ip;
	if ($domdescr) {
	$domaindescription{$domain}=$domdescr;
	}
if ($role eq 'library') { $libserv{$id}=$name; }	if ($role eq 'library') { $libserv{$id}=$name; }
}	}
}	}
Line 2831 $readit=1;	Line 3021 $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 2909 authentication scheme	Line 3129 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 2932 idput($udom,%ids) : store away a list of	Line 3155 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 3159 dirlist($uri) : return directory list ba	Line 3488 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	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 3223 filelocation except for hrefs	Line 3586 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 3231 escape() : unpack non-word characters in	Line 3600 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 3238 as a PerlChildExitHandler	Line 3653 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.211
changed lines
	Added in v.1.246