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.627 and 1.734

version 1.627, 2005/04/18 22:28:19	version 1.734, 2006/05/01 16:00:44
Line 37 use HTTP::Date;	Line 37 use HTTP::Date;
use vars	use vars
qw(%perlvar %hostname %badServerCache %iphost %spareid %hostdom	qw(%perlvar %hostname %badServerCache %iphost %spareid %hostdom
%libserv %pr %prp $memcache %packagetab	%libserv %pr %prp $memcache %packagetab
%courselogs %accesshash %userrolehash $processmarker $dumpcount	%courselogs %accesshash %userrolehash %domainrolehash $processmarker $dumpcount
%coursedombuf %coursenumbuf %coursehombuf %coursedescrbuf %courseinstcodebuf %courseownerbuf	%coursedombuf %coursenumbuf %coursehombuf %coursedescrbuf %courseinstcodebuf %courseownerbuf
%domaindescription %domain_auth_def %domain_auth_arg_def	%domaindescription %domain_auth_def %domain_auth_arg_def
%domain_lang_def %domain_city %domain_longi %domain_lati $tmpdir $_64bit	%domain_lang_def %domain_city %domain_longi %domain_lati %domain_primary
%env);	$tmpdir $_64bit %env);

use IO::Socket;	use IO::Socket;
use GDBM_File;	use GDBM_File;
use Apache::Constants qw(:common :http);
use HTML::LCParser;	use HTML::LCParser;
	use HTML::Parser;
use Fcntl qw(:flock);	use Fcntl qw(:flock);
use Apache::lonlocal;
use Storable qw(lock_store lock_nstore lock_retrieve freeze thaw nfreeze);	use Storable qw(lock_store lock_nstore lock_retrieve freeze thaw nfreeze);
use Time::HiRes qw( gettimeofday tv_interval );	use Time::HiRes qw( gettimeofday tv_interval );
use Cache::Memcached;	use Cache::Memcached;
	use Digest::MD5;

my $readit;	my $readit;
my $max_connection_retries = 10; # Or some such value.	my $max_connection_retries = 10; # Or some such value.

Line 84 delayed.	Line 85 delayed.


# --------------------------------------------------------------------- Logging	# --------------------------------------------------------------------- Logging
	{
	my $logid;
	sub instructor_log {
	my ($hash_name,$storehash,$delflag,$uname,$udom)=@_;
	$logid++;
	my $id=time().'00000'.$$.'00000'.$logid;
	return &Apache::lonnet::put('nohist_'.$hash_name,
	{ $id => {
	'exe_uname' => $env{'user.name'},
	'exe_udom' => $env{'user.domain'},
	'exe_time' => time(),
	'exe_ip' => $ENV{'REMOTE_ADDR'},
	'delflag' => $delflag,
	'logentry' => $storehash,
	'uname' => $uname,
	'udom' => $udom,
	}
	},
	$env{'course.'.$env{'request.course.id'}.'.domain'},
	$env{'course.'.$env{'request.course.id'}.'.num'}
	);
	}
	}

sub logtouch {	sub logtouch {
my $execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
Line 122 sub logperm {	Line 146 sub logperm {
# -------------------------------------------------- Non-critical communication	# -------------------------------------------------- Non-critical communication
sub subreply {	sub subreply {
my ($cmd,$server)=@_;	my ($cmd,$server)=@_;
my $peerfile="$perlvar{'lonSockDir'}/$server";	my $peerfile="$perlvar{'lonSockDir'}/".$hostname{$server};
#	#
# With loncnew process trimming, there's a timing hole between lonc server	# With loncnew process trimming, there's a timing hole between lonc server
# process exit and the master server picking up the listen on the AF_UNIX	# process exit and the master server picking up the listen on the AF_UNIX
Line 150 sub subreply {	Line 174 sub subreply {
}	}
my $answer;	my $answer;
if ($client) {	if ($client) {
print $client "$cmd\n";	print $client "sethost:$server:$cmd\n";
$answer=<$client>;	$answer=<$client>;
if (!$answer) { $answer="con_lost"; }	if (!$answer) { $answer="con_lost"; }
chomp($answer);	chomp($answer);
Line 165 sub reply {	Line 189 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=~/^refused/) \|\| ($answer=~/^rejected/)) {	if (($answer=~/^refused/) \|\| ($answer=~/^rejected/)) {
&logthis("<font color=blue>WARNING:".	&logthis("<font color=\"blue\">WARNING:".
" $cmd to $server returned $answer</font>");	" $cmd to $server returned $answer</font>");
}	}
return $answer;	return $answer;
Line 189 sub reconlonc {	Line 213 sub reconlonc {
sleep 5;	sleep 5;
if (-e "$peerfile") { return; }	if (-e "$peerfile") { return; }
&logthis(	&logthis(
"<font color=blue>WARNING: $peerfile still not there, giving up</font>");	"<font color=\"blue\">WARNING: $peerfile still not there, giving up</font>");
} else {	} else {
&logthis(	&logthis(
"<font color=blue>WARNING:".	"<font color=\"blue\">WARNING:".
" lonc at pid $loncpid not responding, giving up</font>");	" lonc at pid $loncpid not responding, giving up</font>");
}	}
} else {	} else {
&logthis('<font color=blue>WARNING: lonc not running, giving up</font>');	&logthis('<font color="blue">WARNING: lonc not running, giving up</font>');
}	}
}	}

Line 205 sub reconlonc {	Line 229 sub reconlonc {
sub critical {	sub critical {
my ($cmd,$server)=@_;	my ($cmd,$server)=@_;
unless ($hostname{$server}) {	unless ($hostname{$server}) {
&logthis("<font color=blue>WARNING:".	&logthis("<font color=\"blue\">WARNING:".
" Critical message to unknown server ($server)</font>");	" Critical message to unknown server ($server)</font>");
return 'no_such_host';	return 'no_such_host';
}	}
Line 239 sub critical {	Line 263 sub critical {
}	}
chomp($wcmd);	chomp($wcmd);
if ($wcmd eq $cmd) {	if ($wcmd eq $cmd) {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=\"blue\">WARNING: ".
"Connection buffer $dfilename: $cmd</font>");	"Connection buffer $dfilename: $cmd</font>");
&logperm("D:$server:$cmd");	&logperm("D:$server:$cmd");
return 'con_delayed';	return 'con_delayed';
} else {	} else {
&logthis("<font color=red>CRITICAL:"	&logthis("<font color=\"red\">CRITICAL:"
." Critical connection failed: $server $cmd</font>");	." Critical connection failed: $server $cmd</font>");
&logperm("F:$server:$cmd");	&logperm("F:$server:$cmd");
return 'con_failed';	return 'con_failed';
Line 258 sub critical {	Line 282 sub critical {

sub transfer_profile_to_env {	sub transfer_profile_to_env {
my ($lonidsdir,$handle)=@_;	my ($lonidsdir,$handle)=@_;
	if (!defined($lonidsdir)) {
	$lonidsdir = $perlvar{'lonIDsDir'};
	}
	if (!defined($handle)) {
	($handle) = ($env{'user.environment'} =~m\|/([^/]+)\.id$\| );
	}

my @profile;	my @profile;
{	{
open(my $idf,"$lonidsdir/$handle.id");	open(my $idf,"$lonidsdir/$handle.id");
Line 269 sub transfer_profile_to_env {	Line 300 sub transfer_profile_to_env {
my %Remove;	my %Remove;
for ($envi=0;$envi<=$#profile;$envi++) {	for ($envi=0;$envi<=$#profile;$envi++) {
chomp($profile[$envi]);	chomp($profile[$envi]);
my ($envname,$envvalue)=split(/=/,$profile[$envi]);	my ($envname,$envvalue)=split(/=/,$profile[$envi],2);
	$envname=&unescape($envname);
	$envvalue=&unescape($envvalue);
$env{$envname} = $envvalue;	$env{$envname} = $envvalue;
if (my ($key,$time) = ($envname =~ /^(cgi\.(\d+)_\d+\.)/)) {	if (my ($key,$time) = ($envname =~ /^(cgi\.(\d+)_\d+\.)/)) {
if ($time < time-300) {	if ($time < time-300) {
Line 287 sub transfer_profile_to_env {	Line 320 sub transfer_profile_to_env {

sub appenv {	sub appenv {
my %newenv=@_;	my %newenv=@_;
foreach (keys %newenv) {	foreach my $key (keys(%newenv)) {
if (($newenv{$_}=~/^user\.role/) \|\| ($newenv{$_}=~/^user\.priv/)) {	if (($newenv{$key}=~/^user\.role/) \|\| ($newenv{$key}=~/^user\.priv/)) {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=\"blue\">WARNING: ".
"Attempt to modify environment ".$_." to ".$newenv{$_}	"Attempt to modify environment ".$key." to ".$newenv{$key}
.'</font>');	.'</font>');
delete($newenv{$_});	delete($newenv{$key});
} else {	} else {
$env{$_}=$newenv{$_};	$env{$key}=$newenv{$key};
}	}
}	}

Line 303 sub appenv {	Line 336 sub appenv {
return 'error: '.$!;	return 'error: '.$!;
}	}
unless (flock($lockfh,LOCK_EX)) {	unless (flock($lockfh,LOCK_EX)) {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=\"blue\">WARNING: ".
'Could not obtain exclusive lock in appenv: '.$!);	'Could not obtain exclusive lock in appenv: '.$!);
close($lockfh);	close($lockfh);
return 'error: '.$!;	return 'error: '.$!;
Line 321 sub appenv {	Line 354 sub appenv {
for (my $i=0; $i<=$#oldenv; $i++) {	for (my $i=0; $i<=$#oldenv; $i++) {
chomp($oldenv[$i]);	chomp($oldenv[$i]);
if ($oldenv[$i] ne '') {	if ($oldenv[$i] ne '') {
my ($name,$value)=split(/=/,$oldenv[$i]);	my ($name,$value)=split(/=/,$oldenv[$i],2);
	$name=&unescape($name);
	$value=&unescape($value);
unless (defined($newenv{$name})) {	unless (defined($newenv{$name})) {
$newenv{$name}=$value;	$newenv{$name}=$value;
}	}
Line 334 sub appenv {	Line 369 sub appenv {
}	}
my $newname;	my $newname;
foreach $newname (keys %newenv) {	foreach $newname (keys %newenv) {
print $fh "$newname=$newenv{$newname}\n";	print $fh &escape($newname).'='.&escape($newenv{$newname})."\n";
}	}
close($fh);	close($fh);
}	}
Line 346 sub appenv {	Line 381 sub appenv {

sub delenv {	sub delenv {
my $delthis=shift;	my $delthis=shift;
my %newenv=();
if (($delthis=~/user\.role/) \|\| ($delthis=~/user\.priv/)) {	if (($delthis=~/user\.role/) \|\| ($delthis=~/user\.priv/)) {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=\"blue\">WARNING: ".
"Attempt to delete from environment ".$delthis);	"Attempt to delete from environment ".$delthis);
return 'error';	return 'error';
}	}
Line 359 sub delenv {	Line 393 sub delenv {
return 'error';	return 'error';
}	}
unless (flock($fh,LOCK_SH)) {	unless (flock($fh,LOCK_SH)) {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=\"blue\">WARNING: ".
'Could not obtain shared lock in delenv: '.$!);	'Could not obtain shared lock in delenv: '.$!);
close($fh);	close($fh);
return 'error: '.$!;	return 'error: '.$!;
Line 373 sub delenv {	Line 407 sub delenv {
return 'error';	return 'error';
}	}
unless (flock($fh,LOCK_EX)) {	unless (flock($fh,LOCK_EX)) {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=\"blue\">WARNING: ".
'Could not obtain exclusive lock in delenv: '.$!);	'Could not obtain exclusive lock in delenv: '.$!);
close($fh);	close($fh);
return 'error: '.$!;	return 'error: '.$!;
}	}
foreach (@oldenv) {	foreach my $cur_key (@oldenv) {
if ($_=~/^$delthis/) {	my $unescaped_cur_key = &unescape($cur_key);
my ($key,undef) = split('=',$_);	if ($unescaped_cur_key=~/^$delthis/) {
	my ($key) = split('=',$cur_key,2);
	$key = &unescape($key);
delete($env{$key});	delete($env{$key});
} else {	} else {
print $fh $_;	print $fh $cur_key;
}	}
}	}
close($fh);	close($fh);
Line 442 sub overloaderror {	Line 478 sub overloaderror {
# ------------------------------ Find server with least workload from spare.tab	# ------------------------------ Find server with least workload from spare.tab

sub spareserver {	sub spareserver {
my ($loadpercent,$userloadpercent) = @_;	my ($loadpercent,$userloadpercent,$want_server_name) = @_;
my $tryserver;	my $tryserver;
my $spareserver='';	my $spareserver='';
if ($userloadpercent !~ /\d/) { $userloadpercent=0; }	if ($userloadpercent !~ /\d/) { $userloadpercent=0; }
my $lowestserver=$loadpercent > $userloadpercent?	my $lowestserver=$loadpercent > $userloadpercent?
$loadpercent : $userloadpercent;	$loadpercent : $userloadpercent;
foreach $tryserver (keys %spareid) {	foreach $tryserver (keys(%spareid)) {
my $loadans=reply('load',$tryserver);	my $loadans=&reply('load',$tryserver);
my $userloadans=reply('userload',$tryserver);	my $userloadans=&reply('userload',$tryserver);
if ($loadans !~ /\d/ && $userloadans !~ /\d/) {	if ($loadans !~ /\d/ && $userloadans !~ /\d/) {
next; #didn't get a number from the server	next; #didn't get a number from the server
}	}
Line 467 sub spareserver {	Line 503 sub spareserver {
$answer = $userloadans;	$answer = $userloadans;
}	}
if (($answer =~ /\d/) && ($answer<$lowestserver)) {	if (($answer =~ /\d/) && ($answer<$lowestserver)) {
$spareserver="http://$hostname{$tryserver}";	if ($want_server_name) {
	$spareserver=$tryserver;
	} else {
	$spareserver="http://$hostname{$tryserver}";
	}
$lowestserver=$answer;	$lowestserver=$answer;
}	}
}	}
Line 766 sub validate_access_key {	Line 806 sub validate_access_key {
}	}

# ------------------------------------- Find the section of student in a course	# ------------------------------------- Find the section of student in a course
	sub devalidate_getsection_cache {
	my ($udom,$unam,$courseid)=@_;
	$courseid=~s/\_/\//g;
	$courseid=~s/^(\w)/\/$1/;
	my $hashid="$udom:$unam:$courseid";
	&devalidate_cache_new('getsection',$hashid);
	}

sub getsection {	sub getsection {
my ($udom,$unam,$courseid)=@_;	my ($udom,$unam,$courseid)=@_;
Line 828 sub getsection {	Line 875 sub getsection {

sub save_cache {	sub save_cache {
&purge_remembered();	&purge_remembered();
	#&Apache::loncommon::validate_page();
undef(%env);	undef(%env);
}	}

Line 931 sub userenvironment {	Line 979 sub userenvironment {
sub studentphoto {	sub studentphoto {
my ($udom,$unam,$ext) = @_;	my ($udom,$unam,$ext) = @_;
my $home=&Apache::lonnet::homeserver($unam,$udom);	my $home=&Apache::lonnet::homeserver($unam,$udom);
my $ret=&Apache::lonnet::reply("studentphoto:$udom:$unam:$ext",$home);	if (defined($env{'request.course.id'})) {
my $url="/uploaded/$udom/$unam/internal/studentphoto.".$ext;	if ($env{'course.'.$env{'request.course.id'}.'.internal.showphoto'}) {
if ($ret ne 'ok') {	if ($udom eq $env{'course.'.$env{'request.course.id'}.'.domain'}) {
return '/adm/lonKaputt/lonlogo_broken.gif';	return(&retrievestudentphoto($udom,$unam,$ext));
	} else {
	my ($result,$perm_reqd)=
	&Apache::lonnet::auto_photo_permission($unam,$udom);
	if ($result eq 'ok') {
	if (!($perm_reqd eq 'yes')) {
	return(&retrievestudentphoto($udom,$unam,$ext));
	}
	}
	}
	}
	} else {
	my ($result,$perm_reqd) =
	&Apache::lonnet::auto_photo_permission($unam,$udom);
	if ($result eq 'ok') {
	if (!($perm_reqd eq 'yes')) {
	return(&retrievestudentphoto($udom,$unam,$ext));
	}
	}
	}
	return '/adm/lonKaputt/lonlogo_broken.gif';
	}

	sub retrievestudentphoto {
	my ($udom,$unam,$ext,$type) = @_;
	my $home=&Apache::lonnet::homeserver($unam,$udom);
	my $ret=&Apache::lonnet::reply("studentphoto:$udom:$unam:$ext:$type",$home);
	if ($ret eq 'ok') {
	my $url="/uploaded/$udom/$unam/internal/studentphoto.$ext";
	if ($type eq 'thumbnail') {
	$url="/uploaded/$udom/$unam/internal/studentphoto_tn.$ext";
	}
	my $tokenurl=&Apache::lonnet::tokenwrapper($url);
	return $tokenurl;
	} else {
	if ($type eq 'thumbnail') {
	return '/adm/lonKaputt/genericstudent_tn.gif';
	} else {
	return '/adm/lonKaputt/lonlogo_broken.gif';
	}
}	}
my $tokenurl=&Apache::lonnet::tokenwrapper($url);
return $tokenurl;
}	}

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

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

# ------------------------------------------ Find current version of a resource	# ------------------------------------------ Find current version of a resource
Line 1049 sub repcopy {	Line 1134 sub repcopy {
if ($response->is_error()) {	if ($response->is_error()) {
unlink($transname);	unlink($transname);
my $message=$response->status_line;	my $message=$response->status_line;
&logthis("<font color=blue>WARNING:"	&logthis("<font color=\"blue\">WARNING:"
." LWP get: $message: $filename</font>");	." LWP get: $message: $filename</font>");
return 'unavailable';	return 'unavailable';
} else {	} else {
Line 1059 sub repcopy {	Line 1144 sub repcopy {
if ($mresponse->is_error()) {	if ($mresponse->is_error()) {
unlink($filename.'.meta');	unlink($filename.'.meta');
&logthis(	&logthis(
"<font color=yellow>INFO: No metadata: $filename</font>");	"<font color=\"yellow\">INFO: No metadata: $filename</font>");
}	}
}	}
rename($transname,$filename);	rename($transname,$filename);
Line 1092 sub ssi {	Line 1177 sub ssi {
my $ua=new LWP::UserAgent;	my $ua=new LWP::UserAgent;

my $request;	my $request;

	$form{'no_update_last_known'}=1;

if (%form) {	if (%form) {
$request=new HTTP::Request('POST',"http://".$ENV{'HTTP_HOST'}.$fn);	$request=new HTTP::Request('POST',"http://".$ENV{'HTTP_HOST'}.$fn);
$request->content(join('&',map { &escape($_).'='.&escape($form{$_}) } keys %form));	$request->content(join('&',map { &escape($_).'='.&escape($form{$_}) } keys %form));
Line 1128 sub allowuploaded {	Line 1215 sub allowuploaded {
}	}

# --------- File operations in /home/httpd/html/userfiles/$domain/1/2/3/$course	# --------- File operations in /home/httpd/html/userfiles/$domain/1/2/3/$course
# input: action, courseID, current domain, home server for course, intended	# input: action, courseID, current domain, intended
# path to file, source of file.	# path to file, source of file, instruction to parse file for objects,
	# ref to hash for embedded objects,
	# ref to hash for codebase of java objects.
	#
# output: url to file (if action was uploaddoc),	# output: url to file (if action was uploaddoc),
# ok if successful, or diagnostic message otherwise (if action was propagate or copy)	# ok if successful, or diagnostic message otherwise (if action was propagate or copy)
#	#
Line 1152 sub allowuploaded {	Line 1242 sub allowuploaded {
# /home/httpd/html/userfiles/$domain/1/2/3/$course/$file	# /home/httpd/html/userfiles/$domain/1/2/3/$course/$file
# and will then be copied to /home/httpd/lonUsers/1/2/3/$course/userfiles/$file	# and will then be copied to /home/httpd/lonUsers/1/2/3/$course/userfiles/$file
# in course's home server.	# in course's home server.
	#

sub process_coursefile {	sub process_coursefile {
my ($action,$docuname,$docudom,$docuhome,$file,$source)=@_;	my ($action,$docuname,$docudom,$file,$source,$parser,$allfiles,$codebase)=@_;
my $fetchresult;	my $fetchresult;
	my $home=&homeserver($docuname,$docudom);
if ($action eq 'propagate') {	if ($action eq 'propagate') {
$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file	$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,
,$docuhome);	$home);
} else {	} else {
my $fetchresult = '';
my $fpath = '';	my $fpath = '';
my $fname = $file;	my $fname = $file;
($fpath,$fname) = ($file =~ m\|^(.*)/([^/]+)$\|);	($fpath,$fname) = ($file =~ m\|^(.*)/([^/]+)$\|);
$fpath=$docudom.'/'.$docuname.'/'.$fpath;	$fpath=$docudom.'/'.$docuname.'/'.$fpath;
my $filepath=$perlvar{'lonDocRoot'}.'/userfiles';	my $filepath = &build_filepath($fpath);
unless ($fpath eq '') {
my @parts=split('/',$fpath);
foreach my $part (@parts) {
$filepath.= '/'.$part;
if ((-e $filepath)!=1) {
mkdir($filepath,0777);
}
}
}
if ($action eq 'copy') {	if ($action eq 'copy') {
if ($source eq '') {	if ($source eq '') {
$fetchresult = 'no source file';	$fetchresult = 'no source file';
Line 1184 sub process_coursefile {	Line 1265 sub process_coursefile {
my $destination = $filepath.'/'.$fname;	my $destination = $filepath.'/'.$fname;
rename($source,$destination);	rename($source,$destination);
$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,	$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,
$docuhome);	$home);
}	}
} elsif ($action eq 'uploaddoc') {	} elsif ($action eq 'uploaddoc') {
open(my $fh,'>'.$filepath.'/'.$fname);	open(my $fh,'>'.$filepath.'/'.$fname);
print $fh $env{'form.'.$source};	print $fh $env{'form.'.$source};
close($fh);	close($fh);
	if ($parser eq 'parse') {
	my $parse_result = &extract_embedded_items($filepath,$fname,$allfiles,$codebase);
	unless ($parse_result eq 'ok') {
	&logthis('Failed to parse '.$filepath.'/'.$fname.' for embedded media: '.$parse_result);
	}
	}
$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,	$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,
$docuhome);	$home);
if ($fetchresult eq 'ok') {	if ($fetchresult eq 'ok') {
return '/uploaded/'.$fpath.'/'.$fname;	return '/uploaded/'.$fpath.'/'.$fname;
} else {	} else {
&logthis('Failed to transfer '.$docudom.'/'.$docuname.'/'.$file.	&logthis('Failed to transfer '.$docudom.'/'.$docuname.'/'.$file.
' to host '.$docuhome.': '.$fetchresult);	' to host '.$home.': '.$fetchresult);
return '/adm/notfound.html';	return '/adm/notfound.html';
}	}
}	}
}	}
unless ( $fetchresult eq 'ok') {	unless ( $fetchresult eq 'ok') {
&logthis('Failed to transfer '.$docudom.'/'.$docuname.'/'.$file.	&logthis('Failed to transfer '.$docudom.'/'.$docuname.'/'.$file.
' to host '.$docuhome.': '.$fetchresult);	' to host '.$home.': '.$fetchresult);
}	}
return $fetchresult;	return $fetchresult;
}	}

	sub build_filepath {
	my ($fpath) = @_;
	my $filepath=$perlvar{'lonDocRoot'}.'/userfiles';
	unless ($fpath eq '') {
	my @parts=split('/',$fpath);
	foreach my $part (@parts) {
	$filepath.= '/'.$part;
	if ((-e $filepath)!=1) {
	mkdir($filepath,0777);
	}
	}
	}
	return $filepath;
	}

	sub store_edited_file {
	my ($primary_url,$content,$docudom,$docuname,$fetchresult) = @_;
	my $file = $primary_url;
	$file =~ s#^/uploaded/$docudom/$docuname/##;
	my $fpath = '';
	my $fname = $file;
	($fpath,$fname) = ($file =~ m\|^(.*)/([^/]+)$\|);
	$fpath=$docudom.'/'.$docuname.'/'.$fpath;
	my $filepath = &build_filepath($fpath);
	open(my $fh,'>'.$filepath.'/'.$fname);
	print $fh $content;
	close($fh);
	my $home=&homeserver($docuname,$docudom);
	$$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,
	$home);
	if ($$fetchresult eq 'ok') {
	return '/uploaded/'.$fpath.'/'.$fname;
	} else {
	&logthis('Failed to transfer '.$docudom.'/'.$docuname.'/'.$file.
	' to host '.$home.': '.$$fetchresult);
	return '/adm/notfound.html';
	}
	}

sub clean_filename {	sub clean_filename {
my ($fname)=@_;	my ($fname)=@_;
# Replace Windows backslashes by forward slashes	# Replace Windows backslashes by forward slashes
Line 1225 sub clean_filename {	Line 1351 sub clean_filename {
}	}

# --------------- Take an uploaded file and put it into the userfiles directory	# --------------- Take an uploaded file and put it into the userfiles directory
# input: name of form element, coursedoc=1 means this is for the course	# input: $formname - the contents of the file are in $env{"form.$formname"}
# output: url of file in userspace	# the desired filenam is in $env{"form.$formname.filename"}
	# $coursedoc - if true up to the current course
	# if false
	# $subdir - directory in userfile to store the file into
	# $parser, $allfiles, $codebase - unknown
	#
	# output: url of file in userspace, or error: <message>
	# or /adm/notfound.html if failure to upload occurse


sub userfileupload {	sub userfileupload {
my ($formname,$coursedoc,$subdir)=@_;	my ($formname,$coursedoc,$subdir,$parser,$allfiles,$codebase,$destuname,$destudom)=@_;
if (!defined($subdir)) { $subdir='unknown'; }	if (!defined($subdir)) { $subdir='unknown'; }
my $fname=$env{'form.'.$formname.'.filename'};	my $fname=$env{'form.'.$formname.'.filename'};
$fname=&clean_filename($fname);	$fname=&clean_filename($fname);
Line 1253 sub userfileupload {	Line 1386 sub userfileupload {
close($fh);	close($fh);
return $fullpath.'/'.$fname;	return $fullpath.'/'.$fname;
}	}

# Create the directory if not present	# Create the directory if not present
my $docuname='';
my $docudom='';
my $docuhome='';
$fname="$subdir/$fname";	$fname="$subdir/$fname";
if ($coursedoc) {	if ($coursedoc) {
$docuname=$env{'course.'.$env{'request.course.id'}.'.num'};	my $docuname=$env{'course.'.$env{'request.course.id'}.'.num'};
$docudom=$env{'course.'.$env{'request.course.id'}.'.domain'};	my $docudom=$env{'course.'.$env{'request.course.id'}.'.domain'};
$docuhome=$env{'course.'.$env{'request.course.id'}.'.home'};	if ($env{'form.folder'} =~ m/^(default\|supplemental)/) {
if ($env{'form.folder'} =~ m/^default/) {	return &finishuserfileupload($docuname,$docudom,
return &finishuserfileupload($docuname,$docudom,$docuhome,$formname,$fname);	$formname,$fname,$parser,$allfiles,
	$codebase);
} else {	} else {
$fname=$env{'form.folder'}.'/'.$fname;	$fname=$env{'form.folder'}.'/'.$fname;
return &process_coursefile('uploaddoc',$docuname,$docudom,$docuhome,$fname,$formname);	return &process_coursefile('uploaddoc',$docuname,$docudom,
	$fname,$formname,$parser,
	$allfiles,$codebase);
	}
	} elsif (defined($destuname)) {
	my $docuname=$destuname;
	my $docudom=$destudom;
	return &finishuserfileupload($docuname,$docudom,$formname,
	$fname,$parser,$allfiles,$codebase);

	} else {
	my $docuname=$env{'user.name'};
	my $docudom=$env{'user.domain'};
	if (exists($env{'form.group'})) {
	$docuname=$env{'course.'.$env{'request.course.id'}.'.num'};
	$docudom=$env{'course.'.$env{'request.course.id'}.'.domain'};
}	}
} else {	return &finishuserfileupload($docuname,$docudom,$formname,
$docuname=$env{'user.name'};	$fname,$parser,$allfiles,$codebase);
$docudom=$env{'user.domain'};
$docuhome=$env{'user.home'};
return &finishuserfileupload($docuname,$docudom,$docuhome,$formname,$fname);
}	}
}	}

sub finishuserfileupload {	sub finishuserfileupload {
my ($docuname,$docudom,$docuhome,$formname,$fname)=@_;	my ($docuname,$docudom,$formname,$fname,$parser,$allfiles,$codebase) = @_;
my $path=$docudom.'/'.$docuname.'/';	my $path=$docudom.'/'.$docuname.'/';
my $filepath=$perlvar{'lonDocRoot'};	my $filepath=$perlvar{'lonDocRoot'};
my ($fnamepath,$file);	my ($fnamepath,$file);
Line 1296 sub finishuserfileupload {	Line 1440 sub finishuserfileupload {
}	}
# Save the file	# Save the file
{	{
open(FH,'>'.$filepath.'/'.$file);	if (!open(FH,'>'.$filepath.'/'.$file)) {
print FH $env{'form.'.$formname};	&logthis('Failed to create '.$filepath.'/'.$file);
	print STDERR ('Failed to create '.$filepath.'/'.$file."\n");
	return '/adm/notfound.html';
	}
	if (!print FH ($env{'form.'.$formname})) {
	&logthis('Failed to write to '.$filepath.'/'.$file);
	print STDERR ('Failed to write to '.$filepath.'/'.$file."\n");
	return '/adm/notfound.html';
	}
close(FH);	close(FH);
}	}
	if ($parser eq 'parse') {
	my $parse_result = &extract_embedded_items($filepath,$file,$allfiles,
	$codebase);
	unless ($parse_result eq 'ok') {
	&logthis('Failed to parse '.$filepath.$file.
	' for embedded media: '.$parse_result);
	}
	}
# Notify homeserver to grep it	# Notify homeserver to grep it
#	#
	my $docuhome=&homeserver($docuname,$docudom);
my $fetchresult= &reply('fetchuserfile:'.$path.$file,$docuhome);	my $fetchresult= &reply('fetchuserfile:'.$path.$file,$docuhome);
if ($fetchresult eq 'ok') {	if ($fetchresult eq 'ok') {
#	#
Line 1314 sub finishuserfileupload {	Line 1475 sub finishuserfileupload {
}	}
}	}

	sub extract_embedded_items {
	my ($filepath,$file,$allfiles,$codebase,$content) = @_;
	my @state = ();
	my %javafiles = (
	codebase => '',
	code => '',
	archive => ''
	);
	my %mediafiles = (
	src => '',
	movie => '',
	);
	my $p;
	if ($content) {
	$p = HTML::LCParser->new($content);
	} else {
	$p = HTML::LCParser->new($filepath.'/'.$file);
	}
	while (my $t=$p->get_token()) {
	if ($t->[0] eq 'S') {
	my ($tagname, $attr) = ($t->[1],$t->[2]);
	push (@state, $tagname);
	if (lc($tagname) eq 'allow') {
	&add_filetype($allfiles,$attr->{'src'},'src');
	}
	if (lc($tagname) eq 'img') {
	&add_filetype($allfiles,$attr->{'src'},'src');
	}
	if (lc($tagname) eq 'script') {
	if ($attr->{'archive'} =~ /\.jar$/i) {
	&add_filetype($allfiles,$attr->{'archive'},'archive');
	} else {
	&add_filetype($allfiles,$attr->{'src'},'src');
	}
	}
	if (lc($tagname) eq 'link') {
	if (lc($attr->{'rel'}) eq 'stylesheet') {
	&add_filetype($allfiles,$attr->{'href'},'href');
	}
	}
	if (lc($tagname) eq 'object' \|\|
	(lc($tagname) eq 'embed' && lc($state[-2]) ne 'object')) {
	foreach my $item (keys(%javafiles)) {
	$javafiles{$item} = '';
	}
	}
	if (lc($state[-2]) eq 'object' && lc($tagname) eq 'param') {
	my $name = lc($attr->{'name'});
	foreach my $item (keys(%javafiles)) {
	if ($name eq $item) {
	$javafiles{$item} = $attr->{'value'};
	last;
	}
	}
	foreach my $item (keys(%mediafiles)) {
	if ($name eq $item) {
	&add_filetype($allfiles, $attr->{'value'}, 'value');
	last;
	}
	}
	}
	if (lc($tagname) eq 'embed' \|\| lc($tagname) eq 'applet') {
	foreach my $item (keys(%javafiles)) {
	if ($attr->{$item}) {
	$javafiles{$item} = $attr->{$item};
	last;
	}
	}
	foreach my $item (keys(%mediafiles)) {
	if ($attr->{$item}) {
	&add_filetype($allfiles,$attr->{$item},$item);
	last;
	}
	}
	}
	} elsif ($t->[0] eq 'E') {
	my ($tagname) = ($t->[1]);
	if ($javafiles{'codebase'} ne '') {
	$javafiles{'codebase'} .= '/';
	}
	if (lc($tagname) eq 'applet' \|\|
	lc($tagname) eq 'object' \|\|
	(lc($tagname) eq 'embed' && lc($state[-2]) ne 'object')
	) {
	foreach my $item (keys(%javafiles)) {
	if ($item ne 'codebase' && $javafiles{$item} ne '') {
	my $file=$javafiles{'codebase'}.$javafiles{$item};
	&add_filetype($allfiles,$file,$item);
	}
	}
	}
	pop @state;
	}
	}
	return 'ok';
	}

	sub add_filetype {
	my ($allfiles,$file,$type)=@_;
	if (exists($allfiles->{$file})) {
	unless (grep/^\Q$type\E$/, @{$allfiles->{$file}}) {
	push(@{$allfiles->{$file}}, &escape($type));
	}
	} else {
	@{$allfiles->{$file}} = (&escape($type));
	}
	}

sub removeuploadedurl {	sub removeuploadedurl {
my ($url)=@_;	my ($url)=@_;
my (undef,undef,$udom,$uname,$fname)=split('/',$url,5);	my (undef,undef,$udom,$uname,$fname)=split('/',$url,5);
Line 1371 sub flushcourselogs {	Line 1640 sub flushcourselogs {
} else {	} else {
&logthis('Failed to flush log buffer for '.$crsid);	&logthis('Failed to flush log buffer for '.$crsid);
if (length($courselogs{$crsid})>40000) {	if (length($courselogs{$crsid})>40000) {
&logthis("<font color=blue>WARNING: Buffer for ".$crsid.	&logthis("<font color=\"blue\">WARNING: Buffer for ".$crsid.
" exceeded maximum size, deleting.</font>");	" exceeded maximum size, deleting.</font>");
delete $courselogs{$crsid};	delete $courselogs{$crsid};
}	}
Line 1442 sub flushcourselogs {	Line 1711 sub flushcourselogs {
delete $userrolehash{$entry};	delete $userrolehash{$entry};
}	}
}	}
	#
	# Reverse lookup of domain roles (dc, ad, li, sc, au)
	#
	my %domrolebuffer = ();
	foreach my $entry (keys %domainrolehash) {
	my ($role,$uname,$udom,$runame,$rudom,$rsec)=split/:/,$entry;
	if ($domrolebuffer{$rudom}) {
	$domrolebuffer{$rudom}.='&'.&escape($entry).
	'='.&escape($domainrolehash{$entry});
	} else {
	$domrolebuffer{$rudom}.=&escape($entry).
	'='.&escape($domainrolehash{$entry});
	}
	delete $domainrolehash{$entry};
	}
	foreach my $dom (keys(%domrolebuffer)) {
	foreach my $tryserver (keys %libserv) {
	if ($hostdom{$tryserver} eq $dom) {
	unless (&reply('domroleput:'.$dom.':'.
	$domrolebuffer{$dom},$tryserver) eq 'ok') {
	&logthis('Put of domain roles failed for '.$dom.' and '.$tryserver);
	}
	}
	}
	}
$dumpcount++;	$dumpcount++;
}	}

Line 1475 sub courseacclog {	Line 1769 sub courseacclog {
my $fnsymb=shift;	my $fnsymb=shift;
unless ($env{'request.course.id'}) { return ''; }	unless ($env{'request.course.id'}) { return ''; }
my $what=$fnsymb.':'.$env{'user.name'}.':'.$env{'user.domain'};	my $what=$fnsymb.':'.$env{'user.name'}.':'.$env{'user.domain'};
if ($fnsymb=~/(problem\|exam\|quiz\|assess\|survey\|form\|page)$/) {	if ($fnsymb=~/(problem\|exam\|quiz\|assess\|survey\|form\|task\|page)$/) {
$what.=':POST';	$what.=':POST';
# FIXME: Probably ought to escape things....	# FIXME: Probably ought to escape things....
foreach (keys %env) {	foreach (keys %env) {
Line 1517 sub linklog {	Line 1811 sub linklog {

sub userrolelog {	sub userrolelog {
my ($trole,$username,$domain,$area,$tstart,$tend)=@_;	my ($trole,$username,$domain,$area,$tstart,$tend)=@_;
if (($trole=~/^ca/) \|\| ($trole=~/^in/) \|\|	if (($trole=~/^ca/) \|\| ($trole=~/^aa/) \|\|
($trole=~/^cc/) \|\| ($trole=~/^ep/) \|\|	($trole=~/^in/) \|\| ($trole=~/^cc/) \|\|
($trole=~/^cr/) \|\| ($trole=~/^ta/)) {	($trole=~/^ep/) \|\| ($trole=~/^cr/) \|\|
	($trole=~/^ta/)) {
my (undef,$rudom,$runame,$rsec)=split(/\//,$area);	my (undef,$rudom,$runame,$rsec)=split(/\//,$area);
$userrolehash	$userrolehash
{$trole.':'.$username.':'.$domain.':'.$runame.':'.$rudom.':'.$rsec}	{$trole.':'.$username.':'.$domain.':'.$runame.':'.$rudom.':'.$rsec}
=$tend.':'.$tstart;	=$tend.':'.$tstart;
}	}
	if (($trole=~/^dc/) \|\| ($trole=~/^ad/) \|\|
	($trole=~/^li/) \|\| ($trole=~/^li/) \|\|
	($trole=~/^au/) \|\| ($trole=~/^dg/) \|\|
	($trole=~/^sc/)) {
	my (undef,$rudom,$runame,$rsec)=split(/\//,$area);
	$domainrolehash
	{$trole.':'.$username.':'.$domain.':'.$runame.':'.$rudom.':'.$rsec}
	= $tend.':'.$tstart;
	}
}	}

sub get_course_adv_roles {	sub get_course_adv_roles {
Line 1548 sub get_course_adv_roles {	Line 1852 sub get_course_adv_roles {
if ($username eq '' \|\| $domain eq '') { next; }	if ($username eq '' \|\| $domain eq '') { next; }
if ((&privileged($username,$domain)) &&	if ((&privileged($username,$domain)) &&
(!$nothide{$username.':'.$domain})) { next; }	(!$nothide{$username.':'.$domain})) { next; }
	if ($role eq 'cr') { next; }
my $key=&plaintext($role);	my $key=&plaintext($role);
	if ($role =~ /^cr/) {
	$key=(split('/',$role))[3];
	}
if ($section) { $key.=' (Sec/Grp '.$section.')'; }	if ($section) { $key.=' (Sec/Grp '.$section.')'; }
if ($returnhash{$key}) {	if ($returnhash{$key}) {
$returnhash{$key}.=','.$username.':'.$domain;	$returnhash{$key}.=','.$username.':'.$domain;
Line 1639 sub courseiddump {	Line 1947 sub courseiddump {
return %returnhash;	return %returnhash;
}	}

#	# ---------------------------------------------------------- DC e-mail

	sub dcmailput {
	my ($domain,$msgid,$message,$server)=@_;
	my $status = &Apache::lonnet::critical(
	'dcmailput:'.$domain.':'.&Apache::lonnet::escape($msgid).'='.
	&Apache::lonnet::escape($message),$server);
	return $status;
	}

	sub dcmaildump {
	my ($dom,$startdate,$enddate,$senders) = @_;
	my %returnhash=();
	if (exists($domain_primary{$dom})) {
	my $cmd='dcmaildump:'.$dom.':'.&escape($startdate).':'.
	&escape($enddate).':';
	my @esc_senders=map { &escape($_)} @$senders;
	$cmd.=&escape(join('&',@esc_senders));
	foreach (split(/\&/,&reply($cmd,$domain_primary{$dom}))) {
	my ($key,$value) = split(/\=/,$_);
	if (($key) && ($value)) {
	$returnhash{&unescape($key)} = &unescape($value);
	}
	}
	}
	return %returnhash;
	}
	# ---------------------------------------------------------- Domain roles

	sub get_domain_roles {
	my ($dom,$roles,$startdate,$enddate)=@_;
	if (undef($startdate) \|\| $startdate eq '') {
	$startdate = '.';
	}
	if (undef($enddate) \|\| $enddate eq '') {
	$enddate = '.';
	}
	my $rolelist = join(':',@{$roles});
	my %personnel = ();
	foreach my $tryserver (keys(%libserv)) {
	if ($hostdom{$tryserver} eq $dom) {
	%{$personnel{$tryserver}}=();
	foreach (
	split(/\&/,&reply('domrolesdump:'.$dom.':'.
	&escape($startdate).':'.&escape($enddate).':'.
	&escape($rolelist), $tryserver))) {
	my($key,$value) = split(/\=/,$_);
	if (($key) && ($value)) {
	$personnel{$tryserver}{&unescape($key)} = &unescape($value);
	}
	}
	}
	}
	return %personnel;
	}

# ----------------------------------------------------------- Check out an item	# ----------------------------------------------------------- Check out an item

sub get_first_access {	sub get_first_access {
Line 1685 sub checkout {	Line 2048 sub checkout {
$now.'&'.$ENV{'REMOTE_ADDR'});	$now.'&'.$ENV{'REMOTE_ADDR'});
my $token=&reply('tmpput:'.$infostr,$lonhost);	my $token=&reply('tmpput:'.$infostr,$lonhost);
if ($token=~/^error\:/) {	if ($token=~/^error\:/) {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=\"blue\">WARNING: ".
"Checkout tmpput failed ".$tudom.' - '.$tuname.' - '.$symb.	"Checkout tmpput failed ".$tudom.' - '.$tuname.' - '.$symb.
"</font>");	"</font>");
return '';	return '';
Line 1701 sub checkout {	Line 2064 sub checkout {
unless (&cstore(\%infohash,$symb,$tcrsid,$tudom,$tuname) eq 'ok') {	unless (&cstore(\%infohash,$symb,$tcrsid,$tudom,$tuname) eq 'ok') {
return '';	return '';
} else {	} else {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=\"blue\">WARNING: ".
"Checkout cstore failed ".$tudom.' - '.$tuname.' - '.$symb.	"Checkout cstore failed ".$tudom.' - '.$tuname.' - '.$symb.
"</font>");	"</font>");
}	}
Line 1711 sub checkout {	Line 2074 sub checkout {
$token)) ne 'ok') {	$token)) ne 'ok') {
return '';	return '';
} else {	} else {
&logthis("<font color=blue>WARNING: ".	&logthis("<font color=\"blue\">WARNING: ".
"Checkout log failed ".$tudom.' - '.$tuname.' - '.$symb.	"Checkout log failed ".$tudom.' - '.$tuname.' - '.$symb.
"</font>");	"</font>");
}	}
Line 2237 sub restore {	Line 2600 sub restore {
# ---------------------------------------------------------- Course Description	# ---------------------------------------------------------- Course Description

sub coursedescription {	sub coursedescription {
my $courseid=shift;	my ($courseid,$args)=@_;
$courseid=~s/^\///;	$courseid=~s/^\///;
$courseid=~s/\_/\//g;	$courseid=~s/\_/\//g;
my ($cdomain,$cnum)=split(/\//,$courseid);	my ($cdomain,$cnum)=split(/\//,$courseid);
Line 2247 sub coursedescription {	Line 2610 sub coursedescription {
# trying and trying and trying to get the course description.	# trying and trying and trying to get the course description.
my %envhash=();	my %envhash=();
my %returnhash=();	my %returnhash=();
$envhash{'course.'.$normalid.'.last_cache'}=time;
	my $expiretime=600;
	if ($env{'request.course.id'} eq $normalid) {
	$expiretime=120;
	}

	my $prefix='course.'.$cdomain.'_'.$cnum.'.';
	if (!$args->{'freshen_cache'}
	&& ((time-$env{$prefix.'last_cache'}) < $expiretime) ) {
	foreach my $key (keys(%env)) {
	next if ($key !~ /^\Q$prefix\E(.*)/);
	my ($setting) = $1;
	$returnhash{$setting} = $env{$key};
	}
	return %returnhash;
	}

	# get the data agin
	if (!$args->{'one_time'}) {
	$envhash{'course.'.$normalid.'.last_cache'}=time;
	}
if ($chome ne 'no_host') {	if ($chome ne 'no_host') {
%returnhash=&dump('environment',$cdomain,$cnum);	%returnhash=&dump('environment',$cdomain,$cnum);
if (!exists($returnhash{'con_lost'})) {	if (!exists($returnhash{'con_lost'})) {
Line 2265 sub coursedescription {	Line 2648 sub coursedescription {
$envhash{'course.'.$normalid.'.num'}=$cnum;	$envhash{'course.'.$normalid.'.num'}=$cnum;
}	}
}	}
&appenv(%envhash);	if (!$args->{'one_time'}) {
	&appenv(%envhash);
	}
return %returnhash;	return %returnhash;
}	}

Line 2306 sub rolesinit {	Line 2691 sub rolesinit {
my $rolesdump=reply("dump:$domain:$username:roles",$authhost);	my $rolesdump=reply("dump:$domain:$username:roles",$authhost);
if (($rolesdump eq 'con_lost') \|\| ($rolesdump eq '')) { return ''; }	if (($rolesdump eq 'con_lost') \|\| ($rolesdump eq '')) { return ''; }
my %allroles=();	my %allroles=();
	my %allgroups=();
my $now=time;	my $now=time;
my $userroles="user.login.time=$now\n";	my $userroles="user.login.time=$now\n";
	my $group_privs;

if ($rolesdump ne '') {	if ($rolesdump ne '') {
foreach (split(/&/,$rolesdump)) {	foreach (split(/&/,$rolesdump)) {
if ($_!~/^rolesdef_/) {	if ($_!~/^rolesdef_/) {
my ($area,$role)=split(/=/,$_);	my ($area,$role)=split(/=/,$_);
$area=~s/\_\w\w$//;	$area=~s/\_\w\w$//;
	my ($trole,$tend,$tstart,$group_privs);
my ($trole,$tend,$tstart);
if ($role=~/^cr/) {	if ($role=~/^cr/) {
($trole,my $trest)=($role=~m\|^(cr/\w+/\w+/[a-zA-Z0-9]+)_(.*)$\|);	if ($role=~m\|^(cr/\w+/\w+/[a-zA-Z0-9]+)_(.*)$\|) {
($tend,$tstart)=split('_',$trest);	($trole,my $trest)=($role=~m\|^(cr/\w+/\w+/[a-zA-Z0-9]+)_(.*)$\|);
	($tend,$tstart)=split('_',$trest);
	} else {
	$trole=$role;
	}
	} elsif ($role =~ m\|^gr/\|) {
	($trole,$tend,$tstart) = split(/_/,$role);
	($trole,$group_privs) = split(/\//,$trole);
	$group_privs = &unescape($group_privs);
} else {	} else {
($trole,$tend,$tstart)=split(/_/,$role);	($trole,$tend,$tstart)=split(/_/,$role);
}	}
Line 2330 sub rolesinit {	Line 2724 sub rolesinit {
my ($tdummy,$tdomain,$trest)=split(/\//,$area);	my ($tdummy,$tdomain,$trest)=split(/\//,$area);
if ($trole =~ /^cr\//) {	if ($trole =~ /^cr\//) {
&custom_roleprivs(\%allroles,$trole,$tdomain,$trest,$spec,$area);	&custom_roleprivs(\%allroles,$trole,$tdomain,$trest,$spec,$area);
	} elsif ($trole eq 'gr') {
	&group_roleprivs(\%allgroups,$area,$group_privs,$tend,$tstart);
} else {	} else {
&standard_roleprivs(\%allroles,$trole,$tdomain,$spec,$trest,$area);	&standard_roleprivs(\%allroles,$trole,$tdomain,$spec,$trest,$area);
}	}
}	}
}	}
}	}
my ($author,$adv) = &set_userprivs(\$userroles,\%allroles);	my ($author,$adv) = &set_userprivs(\$userroles,\%allroles,\%allgroups);
$userroles.='user.adv='.$adv."\n".	$userroles.='user.adv='.$adv."\n".
'user.author='.$author."\n";	'user.author='.$author."\n";
$env{'user.adv'}=$adv;	$env{'user.adv'}=$adv;
Line 2378 sub custom_roleprivs {	Line 2774 sub custom_roleprivs {
}	}
}	}

	sub group_roleprivs {
	my ($allgroups,$area,$group_privs,$tend,$tstart) = @_;
	my $access = 1;
	my $now = time;
	if (($tend!=0) && ($tend<$now)) { $access = 0; }
	if (($tstart!=0) && ($tstart>$now)) { $access=0; }
	if ($access) {
	my ($course,$group) = ($area =~ m\|(/\w+/\w+)/([^/]+)$\|);
	$$allgroups{$course}{$group} .=':'.$group_privs;
	}
	}

sub standard_roleprivs {	sub standard_roleprivs {
my ($allroles,$trole,$tdomain,$spec,$trest,$area) = @_;	my ($allroles,$trole,$tdomain,$spec,$trest,$area) = @_;
Line 2398 sub standard_roleprivs {	Line 2805 sub standard_roleprivs {
}	}

sub set_userprivs {	sub set_userprivs {
my ($userroles,$allroles) = @_;	my ($userroles,$allroles,$allgroups) = @_;
my $author=0;	my $author=0;
my $adv=0;	my $adv=0;
	my %grouproles = ();
	if (keys(%{$allgroups}) > 0) {
	foreach my $role (keys %{$allroles}) {
	my ($trole,$area,$sec,$extendedarea);
	if ($role =~ m\|^(\w+)\.(/\w+/\w+)(/?\w*)\|) {
	$trole = $1;
	$area = $2;
	$sec = $3;
	$extendedarea = $area.$sec;
	if (exists($$allgroups{$area})) {
	foreach my $group (keys(%{$$allgroups{$area}})) {
	my $spec = $trole.'.'.$extendedarea;
	$grouproles{$spec.'.'.$area.'/'.$group} =
	$$allgroups{$area}{$group};
	}
	}
	}
	}
	}
	foreach (keys(%grouproles)) {
	$$allroles{$_} = $grouproles{$_};
	}
foreach (keys %{$allroles}) {	foreach (keys %{$allroles}) {
my %thesepriv=();	my %thesepriv=();
if (($_=~/^au/) \|\| ($_=~/^ca/)) { $author=1; }	if (($_=~/^au/) \|\| ($_=~/^ca/)) { $author=1; }
Line 2468 sub del {	Line 2897 sub del {
# -------------------------------------------------------------- dump interface	# -------------------------------------------------------------- dump interface

sub dump {	sub dump {
my ($namespace,$udomain,$uname,$regexp)=@_;	my ($namespace,$udomain,$uname,$regexp,$range)=@_;
if (!$udomain) { $udomain=$env{'user.domain'}; }	if (!$udomain) { $udomain=$env{'user.domain'}; }
if (!$uname) { $uname=$env{'user.name'}; }	if (!$uname) { $uname=$env{'user.name'}; }
my $uhome=&homeserver($uname,$udomain);	my $uhome=&homeserver($uname,$udomain);
Line 2477 sub dump {	Line 2906 sub dump {
} else {	} else {
$regexp='.';	$regexp='.';
}	}
my $rep=reply("dump:$udomain:$uname:$namespace:$regexp",$uhome);	my $rep=reply("dump:$udomain:$uname:$namespace:$regexp:$range",$uhome);
my @pairs=split(/\&/,$rep);	my @pairs=split(/\&/,$rep);
my %returnhash=();	my %returnhash=();
foreach (@pairs) {	foreach (@pairs) {
my ($key,$value)=split(/=/,$_);	my ($key,$value)=split(/=/,$_,2);
$returnhash{unescape($key)}=&thaw_unescape($value);	$returnhash{unescape($key)}=&thaw_unescape($value);
}	}
return %returnhash;	return %returnhash;
}	}

	# --------------------------------------------------------- dumpstore interface

	sub dumpstore {
	my ($namespace,$udomain,$uname,$regexp,$range)=@_;
	return &dump($namespace,$udomain,$uname,$regexp,$range);
	}

# -------------------------------------------------------------- keys interface	# -------------------------------------------------------------- keys interface

sub getkeys {	sub getkeys {
Line 2610 sub put {	Line 3046 sub put {
return &reply("put:$udomain:$uname:$namespace:$items",$uhome);	return &reply("put:$udomain:$uname:$namespace:$items",$uhome);
}	}

# ---------------------------------------------------------- putstore interface	# ------------------------------------------------------------ newput interface

sub putstore {	sub newput {
my ($namespace,$storehash,$udomain,$uname)=@_;	my ($namespace,$storehash,$udomain,$uname)=@_;
if (!$udomain) { $udomain=$env{'user.domain'}; }	if (!$udomain) { $udomain=$env{'user.domain'}; }
if (!$uname) { $uname=$env{'user.name'}; }	if (!$uname) { $uname=$env{'user.name'}; }
my $uhome=&homeserver($uname,$udomain);	my $uhome=&homeserver($uname,$udomain);
my $items='';	my $items='';
my %allitems = ();	foreach my $key (keys(%$storehash)) {
foreach (keys %$storehash) {	$items.=&escape($key).'='.&freeze_escape($$storehash{$key}).'&';
if ($_ =~ m/^([^\:]+):([^\:]+):([^\:]+)$/) {
my $key = $1.':keys:'.$2;
$allitems{$key} .= $3.':';
}
$items.=$_.'='.&freeze_escape($$storehash{$_}).'&';
}	}
foreach (keys %allitems) {	$items=~s/\&$//;
$allitems{$_} =~ s/\:$//;	return &reply("newput:$udomain:$uname:$namespace:$items",$uhome);
$items.= $_.'='.$allitems{$_}.'&';	}

	# --------------------------------------------------------- putstore interface

	sub putstore {
	my ($namespace,$symb,$version,$storehash,$udomain,$uname)=@_;
	if (!$udomain) { $udomain=$env{'user.domain'}; }
	if (!$uname) { $uname=$env{'user.name'}; }
	my $uhome=&homeserver($uname,$udomain);
	my $items='';
	foreach my $key (keys(%$storehash)) {
	$items.= &escape($key).'='.&freeze_escape($storehash->{$key}).'&';
}	}
$items=~s/\&$//;	$items=~s/\&$//;
return &reply("put:$udomain:$uname:$namespace:$items",$uhome);	my $esc_symb=&escape($symb);
	my $esc_v=&escape($version);
	my $reply =
	&reply("putstore:$udomain:$uname:$namespace:$esc_symb:$esc_v:$items",
	$uhome);
	if ($reply eq 'unknown_cmd') {
	# gfall back to way things use to be done
	return &old_putstore($namespace,$symb,$version,$storehash,$udomain,
	$uname);
	}
	return $reply;
	}

	sub old_putstore {
	my ($namespace,$symb,$version,$storehash,$udomain,$uname)=@_;
	if (!$udomain) { $udomain=$env{'user.domain'}; }
	if (!$uname) { $uname=$env{'user.name'}; }
	my $uhome=&homeserver($uname,$udomain);
	my %newstorehash;
	foreach (keys %$storehash) {
	my $key = $version.':'.&escape($symb).':'.$_;
	$newstorehash{$key} = $storehash->{$_};
	}
	my $items='';
	my %allitems = ();
	foreach (keys %newstorehash) {
	if ($_ =~ m/^([^\:]+):([^\:]+):([^\:]+)$/) {
	my $key = $1.':keys:'.$2;
	$allitems{$key} .= $3.':';
	}
	$items.=$_.'='.&freeze_escape($newstorehash{$_}).'&';
	}
	foreach (keys %allitems) {
	$allitems{$_} =~ s/\:$//;
	$items.= $_.'='.$allitems{$_}.'&';
	}
	$items=~s/\&$//;
	return &reply("put:$udomain:$uname:$namespace:$items",$uhome);
}	}

# ------------------------------------------------------ critical put interface	# ------------------------------------------------------ critical put interface
Line 2643 sub cput {	Line 3122 sub cput {
my $uhome=&homeserver($uname,$udomain);	my $uhome=&homeserver($uname,$udomain);
my $items='';	my $items='';
foreach (keys %$storehash) {	foreach (keys %$storehash) {
$items.=escape($_).'='.&freeze_escape($$storehash{$_}).'&';	$items.=&escape($_).'='.&freeze_escape($$storehash{$_}).'&';
}	}
$items=~s/\&$//;	$items=~s/\&$//;
return &critical("put:$udomain:$uname:$namespace:$items",$uhome);	return &critical("put:$udomain:$uname:$namespace:$items",$uhome);
Line 2672 sub eget {	Line 3151 sub eget {
return %returnhash;	return %returnhash;
}	}

	# ------------------------------------------------------------ tmpput interface
	sub tmpput {
	my ($storehash,$server)=@_;
	my $items='';
	foreach (keys(%$storehash)) {
	$items.=&escape($_).'='.&freeze_escape($$storehash{$_}).'&';
	}
	$items=~s/\&$//;
	return &reply("tmpput:$items",$server);
	}

	# ------------------------------------------------------------ tmpget interface
	sub tmpget {
	my ($token,$server)=@_;
	if (!defined($server)) { $server = $perlvar{'lonHostID'}; }
	my $rep=&reply("tmpget:$token",$server);
	my %returnhash;
	foreach my $item (split(/\&/,$rep)) {
	my ($key,$value)=split(/=/,$item);
	$returnhash{&unescape($key)}=&thaw_unescape($value);
	}
	return %returnhash;
	}

	# ------------------------------------------------------------ tmpget interface
	sub tmpdel {
	my ($token,$server)=@_;
	if (!defined($server)) { $server = $perlvar{'lonHostID'}; }
	return &reply("tmpdel:$token",$server);
	}

# ---------------------------------------------- Custom access rule evaluation	# ---------------------------------------------- Custom access rule evaluation

sub customaccess {	sub customaccess {
Line 2710 sub customaccess {	Line 3220 sub customaccess {

sub allowed {	sub allowed {
my ($priv,$uri,$symb)=@_;	my ($priv,$uri,$symb)=@_;
	my $ver_orguri=$uri;
$uri=&deversion($uri);	$uri=&deversion($uri);
my $orguri=$uri;	my $orguri=$uri;
$uri=&declutter($uri);	$uri=&declutter($uri);



if (defined($env{'allowed.'.$priv})) { return $env{'allowed.'.$priv}; }	if (defined($env{'allowed.'.$priv})) { return $env{'allowed.'.$priv}; }
# Free bre access to adm and meta resources	# Free bre access to adm and meta resources
if (((($uri=~/^adm\//) && ($uri !~ m\|/bulletinboard$\|))	if (((($uri=~/^adm\//) && ($uri !~ m\|/bulletinboard$\|))
Line 2724 sub allowed {	Line 3233 sub allowed {
}	}

# Free bre access to user's own portfolio contents	# Free bre access to user's own portfolio contents
my ($space,$domain,$name,$dir)=split('/',$uri);	my ($space,$domain,$name,@dir)=split('/',$uri);
if (($space=~/^(uploaded\|ediupload)$/) && ($env{'user.name'} eq $name) &&	if (($space=~/^(uploaded\|editupload)$/) && ($env{'user.name'} eq $name) &&
($env{'user.domain'} eq $domain) && ('portfolio' eq $dir)) {	($env{'user.domain'} eq $domain) && ('portfolio' eq $dir[0])) {
return 'F';	return 'F';
}	}

	# bre access to group if user has rgf priv for this group and course.
	if (($space=~/^(uploaded\|editupload)$/) && ($dir[0] eq 'groups')
	&& ($dir[2] eq 'portfolio') && ($priv eq 'bre')) {
	if (exists($env{'request.course.id'})) {
	my $cdom = $env{'course.'.$env{'request.course.id'}.'.domain'};
	my $cnum = $env{'course.'.$env{'request.course.id'}.'.num'};
	if (($domain eq $cdom) && ($name eq $cnum)) {
	my $courseprivid=$env{'request.course.id'};
	$courseprivid=~s/\_/\//;
	if ($env{'user.priv.'.$env{'request.role'}.'./'.$courseprivid
	.'/'.$dir[1]} =~/rgf\&([^\:]*)/) {
	return $1;
	}
	}
	}
	}

# Free bre to public access	# Free bre to public access

if ($priv eq 'bre') {	if ($priv eq 'bre') {
Line 2762 sub allowed {	Line 3288 sub allowed {
if (($priv eq 'ccc') && ($env{'request.role'} =~ /^dc\./)) {	if (($priv eq 'ccc') && ($env{'request.role'} =~ /^dc\./)) {
# uri is the requested domain in this case.	# uri is the requested domain in this case.
# comparison to 'request.role.domain' shows if the user has selected	# comparison to 'request.role.domain' shows if the user has selected
# a role of dc for the domain in question.	# a role of dc for the domain in question.
return 'F' if ($uri eq $env{'request.role.domain'});	return 'F' if ($uri eq $env{'request.role.domain'});
}	}

Line 2793 sub allowed {	Line 3319 sub allowed {
$thisallowed.=$1;	$thisallowed.=$1;
}	}

# URI is an uploaded document for this course	# Group: uri itself is a group
	my $groupuri=$uri;
	$groupuri=~s/^([^\/])/\/$1/;
	if ($env{'user.priv.'.$env{'request.role'}.'.'.$groupuri}
	=~/\Q$priv\E\&([^\:]*)/) {
	$thisallowed.=$1;
	}

	# URI is an uploaded document for this course, default permissions don't matter
# not allowing 'edit' access (editupload) to uploaded course docs	# not allowing 'edit' access (editupload) to uploaded course docs
if (($priv eq 'bre') && ($uri=~m\|^uploaded/\|)) {	if (($priv eq 'bre') && ($uri=~m\|^uploaded/\|)) {
my $refuri=$env{'httpref.'.$orguri};	$thisallowed='';
if ($refuri) {	my ($match)=&is_on_map($uri);
if ($refuri =~ m\|^/adm/\|) {	if ($match) {
$thisallowed='F';	if ($env{'user.priv.'.$env{'request.role'}.'./'}
}	=~/\Q$priv\E\&([^\:]*)/) {
}	$thisallowed.=$1;
	}
	} else {
	my $refuri = $env{'httpref.'.$orguri} \|\| $env{'httpref.'.$ver_orguri};
	if ($refuri) {
	if ($refuri =~ m\|^/adm/\|) {
	$thisallowed='F';
	} else {
	$refuri=&declutter($refuri);
	my ($match) = &is_on_map($refuri);
	if ($match) {
	$thisallowed='F';
	}
	}
	}
	}
}	}

# Full access at system, domain or course-wide level? Exit.	# Full access at system, domain or course-wide level? Exit.
Line 2812 sub allowed {	Line 3361 sub allowed {

# If this is generating or modifying users, exit with special codes	# If this is generating or modifying users, exit with special codes

if (':csu:cdc:ccc:cin:cta:cep:ccr:cst:cad:cli:cau:cdg:cca:'=~/\:\Q$priv\E\:/) {	if (':csu:cdc:ccc:cin:cta:cep:ccr:cst:cad:cli:cau:cdg:cca:caa:'=~/\:\Q$priv\E\:/) {
	if (($priv eq 'cca') \|\| ($priv eq 'caa')) {
	my ($audom,$auname)=split('/',$uri);
	# no author name given, so this just checks on the general right to make a co-author in this domain
	unless ($auname) { return $thisallowed; }
	# an author name is given, so we are about to actually make a co-author for a certain account
	if (($auname ne $env{'user.name'} && $env{'request.role'} !~ /^dc\./) \|\|
	(($audom ne $env{'user.domain'} && $env{'request.role'} !~ /^dc\./) &&
	($audom ne $env{'request.role.domain'}))) { return ''; }
	}
return $thisallowed;	return $thisallowed;
}	}
#	#
Line 2912 sub allowed {	Line 3470 sub allowed {
my ($cdom,$cnum,$csec)=split(/\//,$courseid);	my ($cdom,$cnum,$csec)=split(/\//,$courseid);
my $prefix='course.'.$cdom.'_'.$cnum.'.';	my $prefix='course.'.$cdom.'_'.$cnum.'.';
if ((time-$env{$prefix.'last_cache'})>$expiretime) {	if ((time-$env{$prefix.'last_cache'})>$expiretime) {
&coursedescription($courseid);	&coursedescription($courseid,{'freshen_cache' => 1});
}	}
if (($env{$prefix.'res.'.$uri.'.lock.sections'}=~/\,\Q$csec\E\,/)	if (($env{$prefix.'res.'.$uri.'.lock.sections'}=~/\,\Q$csec\E\,/)
\|\| ($env{$prefix.'res.'.$uri.'.lock.sections'} eq 'all')) {	\|\| ($env{$prefix.'res.'.$uri.'.lock.sections'} eq 'all')) {
Line 2960 sub allowed {	Line 3518 sub allowed {
my $unamedom=$env{'user.name'}.':'.$env{'user.domain'};	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'}
=~/\Q$rolecode\E/) {	=~/\Q$rolecode\E/) {
&log($env{'user.domain'},$env{'user.name'},$env{'user.host'},	if ($priv ne 'pch') {
'Denied by role: '.$priv.' for '.$uri.' as '.$rolecode.' in '.	&logthis($env{'user.domain'}.':'.$env{'user.name'}.':'.$env{'user.home'}.':'.
$env{'request.course.id'});	'Denied by role: '.$priv.' for '.$uri.' as '.$rolecode.' in '.
	$env{'request.course.id'});
	}
return '';	return '';
}	}

if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.users.denied'}	if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.users.denied'}
=~/\Q$unamedom\E/) {	=~/\Q$unamedom\E/) {
&log($env{'user.domain'},$env{'user.name'},$env{'user.host'},	if ($priv ne 'pch') {
'Denied by user: '.$priv.' for '.$uri.' as '.$unamedom.' in '.	&logthis($env{'user.domain'}.':'.$env{'user.name'}.':'.$env{'user.home'}.
$env{'request.course.id'});	'Denied by user: '.$priv.' for '.$uri.' as '.$unamedom.' in '.
	$env{'request.course.id'});
	}
return '';	return '';
}	}
}	}
Line 2980 sub allowed {	Line 3542 sub allowed {
if ($thisallowed=~/R/) {	if ($thisallowed=~/R/) {
my $rolecode=(split(/\./,$env{'request.role'}))[0];	my $rolecode=(split(/\./,$env{'request.role'}))[0];
if (&metadata($uri,'roledeny')=~/\Q$rolecode\E/) {	if (&metadata($uri,'roledeny')=~/\Q$rolecode\E/) {
&log($env{'user.domain'},$env{'user.name'},$env{'user.host'},	if ($priv ne 'pch') {
'Denied by role: '.$priv.' for '.$uri.' as '.$rolecode);	&logthis($env{'user.domain'}.':'.$env{'user.name'}.':'.$env{'user.home'}.':'.
return '';	'Denied by role: '.$priv.' for '.$uri.' as '.$rolecode);
	}
	return '';
}	}
}	}

Line 3005 sub allowed {	Line 3569 sub allowed {
return 'F';	return 'F';
}	}

	sub split_uri_for_cond {
	my $uri=&deversion(&declutter(shift));
	my @uriparts=split(/\//,$uri);
	my $filename=pop(@uriparts);
	my $pathname=join('/',@uriparts);
	return ($pathname,$filename);
	}
# --------------------------------------------------- Is a resource on the map?	# --------------------------------------------------- Is a resource on the map?

sub is_on_map {	sub is_on_map {
my $uri=&declutter(shift);	my ($pathname,$filename) = &split_uri_for_cond(shift);
$uri=~s/\.\d+\.(\w+)$/\.$1/;
my @uriparts=split(/\//,$uri);
my $filename=$uriparts[$#uriparts];
my $pathname=$uri;
$pathname=~s\|/\Q$filename\E$\|\|;
$pathname=~s/^adm\/wrapper\///;
#Trying to find the conditional for the file	#Trying to find the conditional for the file
my $match=($env{'acc.res.'.$env{'request.course.id'}.'.'.$pathname}=~	my $match=($env{'acc.res.'.$env{'request.course.id'}.'.'.$pathname}=~
/\&\Q$filename\E\:([\d\\|]+)\&/);	/\&\Q$filename\E\:([\d\\|]+)\&/);
Line 3287 sub auto_create_password {	Line 3852 sub auto_create_password {
return ($authparam,$create_passwd,$authchk);	return ($authparam,$create_passwd,$authchk);
}	}

	sub auto_photo_permission {
	my ($cnum,$cdom,$students) = @_;
	my $homeserver = &homeserver($cnum,$cdom);
	my ($outcome,$perm_reqd,$conditions) =
	split(/:/,&unescape(&reply('autophotopermission:'.$cdom,$homeserver)),3);
	if ($outcome =~ /^(con_lost\|unknown_cmd\|no_such_host)$/) {
	return (undef,undef);
	}
	return ($outcome,$perm_reqd,$conditions);
	}

	sub auto_checkphotos {
	my ($uname,$udom,$pid) = @_;
	my $homeserver = &homeserver($uname,$udom);
	my ($result,$resulttype);
	my $outcome = &unescape(&reply('autophotocheck:'.&escape($udom).':'.
	&escape($uname).':'.&escape($pid),
	$homeserver));
	if ($outcome =~ /^(con_lost\|unknown_cmd\|no_such_host)$/) {
	return (undef,undef);
	}
	if ($outcome) {
	($result,$resulttype) = split(/:/,$outcome);
	}
	return ($result,$resulttype);
	}

	sub auto_photochoice {
	my ($cnum,$cdom) = @_;
	my $homeserver = &homeserver($cnum,$cdom);
	my ($update,$comment) = split(/:/,&unescape(&reply('autophotochoice:'.
	&escape($cdom),
	$homeserver)));
	if ($update =~ /^(con_lost\|unknown_cmd\|no_such_host)$/) {
	return (undef,undef);
	}
	return ($update,$comment);
	}

	sub auto_photoupdate {
	my ($affiliatesref,$dom,$cnum,$photo) = @_;
	my $homeserver = &homeserver($cnum,$dom);
	my $host=$hostname{$homeserver};
	my $cmd = '';
	my $maxtries = 1;
	foreach (keys %{$affiliatesref}) {
	$cmd .= $_.'='.join(",",@{$$affiliatesref{$_}}).'%%';
	}
	$cmd =~ s/%%$//;
	$cmd = &escape($cmd);
	my $query = 'institutionalphotos';
	my $queryid=&reply("querysend:".$query.':'.$dom.':'.$cnum.':'.$cmd,$homeserver);
	unless ($queryid=~/^\Q$host\E\_/) {
	&logthis('institutionalphotos: invalid queryid: '.$queryid.' for host: '.$host.' and homeserver: '.$homeserver.' and course: '.$cnum);
	return 'error: '.$queryid;
	}
	my $reply = &get_query_reply($queryid);
	my $tries = 1;
	while (($reply=~/^timeout/) && ($tries < $maxtries)) {
	$reply = &get_query_reply($queryid);
	$tries ++;
	}
	if ( ($reply =~/^timeout/) \|\| ($reply =~/^error/) ) {
	&logthis('institutionalphotos error: '.$reply.' for '.$dom.' '.$env{'user.name'}.' for '.$queryid.' course: '.$cnum.' maxtries: '.$maxtries.' tries: '.$tries);
	} else {
	my @responses = split(/:/,$reply);
	my $outcome = shift(@responses);
	foreach my $item (@responses) {
	my ($key,$value) = split(/=/,$item);
	$$photo{$key} = $value;
	}
	return $outcome;
	}
	return 'error';
	}

sub auto_instcode_format {	sub auto_instcode_format {
my ($caller,$codedom,$instcodes,$codes,$codetitles,$cat_titles,$cat_order) = @_;	my ($caller,$codedom,$instcodes,$codes,$codetitles,$cat_titles,$cat_order) = @_;
my $courses = '';	my $courses = '';
Line 3320 sub auto_instcode_format {	Line 3961 sub auto_instcode_format {
return $response;	return $response;
}	}

	# ------------------------------------------------------- Course Group routines

	sub get_coursegroups {
	my ($cdom,$cnum,$group) = @_;
	return(&dump('coursegroups',$cdom,$cnum,$group));
	}

	sub modify_coursegroup {
	my ($cdom,$cnum,$groupsettings) = @_;
	return(&put('coursegroups',$groupsettings,$cdom,$cnum));
	}

	sub modify_group_roles {
	my ($cdom,$cnum,$group_id,$user,$end,$start,$userprivs) = @_;
	my $url = '/'.$cdom.'/'.$cnum.'/'.$group_id;
	my $role = 'gr/'.&escape($userprivs);
	my ($uname,$udom) = split(/:/,$user);
	my $result = &assignrole($udom,$uname,$url,$role,$end,$start);
	if ($result eq 'ok') {
	&devalidate_getgroups_cache($udom,$uname,$cdom,$cnum);
	}

	return $result;
	}

	sub modify_coursegroup_membership {
	my ($cdom,$cnum,$membership) = @_;
	my $result = &put('groupmembership',$membership,$cdom,$cnum);
	return $result;
	}

	sub get_active_groups {
	my ($udom,$uname,$cdom,$cnum) = @_;
	my $now = time;
	my %groups = ();
	foreach my $key (keys(%env)) {
	if ($key =~ m-user\.role\.gr\./([^/]+)/([^/]+)/(\w+)$-) {
	my ($start,$end) = split(/\./,$env{$key});
	if (($end!=0) && ($end<$now)) { next; }
	if (($start!=0) && ($start>$now)) { next; }
	if ($1 eq $cdom && $2 eq $cnum) {
	$groups{$3} = $env{$key} ;
	}
	}
	}
	return %groups;
	}

	sub get_group_membership {
	my ($cdom,$cnum,$group) = @_;
	return(&dump('groupmembership',$cdom,$cnum,$group));
	}

	sub get_users_groups {
	my ($udom,$uname,$courseid) = @_;
	my @usersgroups;
	my $cachetime=1800;
	$courseid=~s/\_/\//g;
	$courseid=~s/^(\w)/\/$1/;

	my $hashid="$udom:$uname:$courseid";
	my ($grouplist,$cached)=&is_cached_new('getgroups',$hashid);
	if (defined($cached)) {
	@usersgroups = split(/:/,$grouplist);
	} else {
	$grouplist = '';
	my %roleshash = &dump('roles',$udom,$uname,$courseid);
	my ($tmp) = keys(%roleshash);
	if ($tmp=~/^error:/) {
	&logthis('Error retrieving roles: '.$tmp.' for '.$uname.':'.$udom);
	} else {
	my $access_end = $env{'course.'.$courseid.
	'.default_enrollment_end_date'};
	my $now = time;
	foreach my $key (keys(%roleshash)) {
	if ($key =~ /^\Q$courseid\E\/(\w+)\_gr$/) {
	my $group = $1;
	if ($roleshash{$key} =~ /_(\d+)_(\d+)$/) {
	my $start = $2;
	my $end = $1;
	if ($start == -1) { next; } # deleted from group
	if (($start!=0) && ($start>$now)) { next; }
	if (($end!=0) && ($end<$now)) {
	if ($access_end && $access_end < $now) {
	if ($access_end - $end < 86400) {
	push(@usersgroups,$group);
	}
	}
	next;
	}
	push(@usersgroups,$group);
	}
	}
	}
	@usersgroups = &sort_course_groups($courseid,@usersgroups);
	$grouplist = join(':',@usersgroups);
	&do_cache_new('getgroups',$hashid,$grouplist,$cachetime);
	}
	}
	return @usersgroups;
	}

	sub devalidate_getgroups_cache {
	my ($udom,$uname,$cdom,$cnum)=@_;
	my $courseid = $cdom.'_'.$cnum;
	$courseid=~s/\_/\//g;
	$courseid=~s/^(\w)/\/$1/;
	my $hashid="$udom:$uname:$courseid";
	&devalidate_cache_new('getgroups',$hashid);
	}

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

sub plaintext {	sub plaintext {
my $short=shift;	my $short=shift;
return &mt($prp{$short});	return &Apache::lonlocal::mt($prp{$short});
}	}

# ----------------------------------------------------------------- Assign Role	# ----------------------------------------------------------------- Assign Role
Line 3342 sub assignrole {	Line 4094 sub assignrole {
return 'refused';	return 'refused';
}	}
$mrole='cr';	$mrole='cr';
	} elsif ($role =~ /^gr\//) {
	my $cwogrp=$url;
	$cwogrp=~s/^\/(\w+)\/(\w+)\/.*/$1\/$2/;
	unless (&allowed('mdg',$cwogrp)) {
	&logthis('Refused group assignrole: '.
	$udom.' '.$uname.' '.$url.' '.$role.' '.$end.' '.$start.' by '.
	$env{'user.name'}.' at '.$env{'user.domain'});
	return 'refused';
	}
	$mrole='gr';
} else {	} else {
my $cwosec=$url;	my $cwosec=$url;
$cwosec=~s/^\/(\w+)\/(\w+)\/.*/$1\/$2/;	$cwosec=~s/^\/(\w+)\/(\w+)\/.*/$1\/$2/;
Line 3379 sub assignrole {	Line 4141 sub assignrole {
my $answer=&reply($command,&homeserver($uname,$udom));	my $answer=&reply($command,&homeserver($uname,$udom));
# log new user role if status is ok	# log new user role if status is ok
if ($answer eq 'ok') {	if ($answer eq 'ok') {
&userrolelog($mrole,$uname,$udom,$url,$start,$end);	&userrolelog($role,$uname,$udom,$url,$start,$end);
}	}
return $answer;	return $answer;
}	}
Line 3502 sub modifyuser {	Line 4264 sub modifyuser {
}	}
my $reply = &put('environment', \%names, $udom,$uname);	my $reply = &put('environment', \%names, $udom,$uname);
if ($reply ne 'ok') { return 'error: '.$reply; }	if ($reply ne 'ok') { return 'error: '.$reply; }
	&devalidate_cache_new('namescache',$uname.':'.$udom);
&logthis('Success modifying user '.$udom.', '.$uname.', '.$uid.', '.	&logthis('Success modifying user '.$udom.', '.$uname.', '.$uid.', '.
$umode.', '.$first.', '.$middle.', '.	$umode.', '.$first.', '.$middle.', '.
$last.', '.$gene.' by '.	$last.', '.$gene.' by '.
Line 3582 sub modify_student_enrollment {	Line 4345 sub modify_student_enrollment {
$cdom,$cnum);	$cdom,$cnum);
unless (($reply eq 'ok') \|\| ($reply eq 'delayed')) {	unless (($reply eq 'ok') \|\| ($reply eq 'delayed')) {
return 'error: '.$reply;	return 'error: '.$reply;
	} else {
	&devalidate_getsection_cache($udom,$uname,$cid);
}	}
# Add student role to user	# Add student role to user
my $uurl='/'.$cid;	my $uurl='/'.$cid;
Line 3640 sub createcourse {	Line 4405 sub createcourse {
return 'refused';	return 'refused';
}	}
# ------------------------------------------------------------------- Create ID	# ------------------------------------------------------------------- Create ID
my $uname=substr($$.time,0,5).unpack("H8",pack("I32",time)).	my $uname=int(1+rand(9)).
	('a'..'z','A'..'Z','0'..'9')[int(rand(62))].
	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,'true');	my $uhome=&homeserver($uname,$udom,'true');
Line 3686 sub createcourse {	Line 4453 sub createcourse {
</map>	</map>
ENDINITMAP	ENDINITMAP
$topurl=&declutter(	$topurl=&declutter(
&finishuserfileupload($uname,$udom,$uhome,'initmap','default.sequence')	&finishuserfileupload($uname,$udom,'initmap','default.sequence')
);	);
}	}
# ----------------------------------------------------------- Write preferences	# ----------------------------------------------------------- Write preferences
Line 3753 sub mark_as_readonly {	Line 4520 sub mark_as_readonly {
my %current_permissions = &dump('file_permissions',$domain,$user);	my %current_permissions = &dump('file_permissions',$domain,$user);
my ($tmp)=keys(%current_permissions);	my ($tmp)=keys(%current_permissions);
if ($tmp=~/^error:/) { undef(%current_permissions); }	if ($tmp=~/^error:/) { undef(%current_permissions); }

foreach my $file (@{$files}) {	foreach my $file (@{$files}) {
push(@{$current_permissions{$file}},$what);	push(@{$current_permissions{$file}},$what);
}	}
Line 3832 sub files_not_in_path {	Line 4598 sub files_not_in_path {

#--------------------------------------------------------------Get Marked as Read Only	#--------------------------------------------------------------Get Marked as Read Only


sub get_marked_as_readonly {	sub get_marked_as_readonly {
my ($domain,$user,$what) = @_;	my ($domain,$user,$what) = @_;
my %current_permissions = &dump('file_permissions',$domain,$user);	my %current_permissions = &dump('file_permissions',$domain,$user);
my ($tmp)=keys(%current_permissions);	my ($tmp)=keys(%current_permissions);
if ($tmp=~/^error:/) { undef(%current_permissions); }	if ($tmp=~/^error:/) { undef(%current_permissions); }

my @readonly_files;	my @readonly_files;
	my $cmp1=$what;
	if (ref($what)) { $cmp1=join('',@{$what}) };
while (my ($file_name,$value) = each(%current_permissions)) {	while (my ($file_name,$value) = each(%current_permissions)) {
if (ref($value) eq "ARRAY"){	if (ref($value) eq "ARRAY"){
foreach my $stored_what (@{$value}) {	foreach my $stored_what (@{$value}) {
if ($stored_what eq $what) {	my $cmp2=$stored_what;
	if (ref($stored_what)) { $cmp2=join('',@{$stored_what}) };
	if ($cmp1 eq $cmp2) {
push(@readonly_files, $file_name);	push(@readonly_files, $file_name);
} elsif (!defined($what)) {	} elsif (!defined($what)) {
push(@readonly_files, $file_name);	push(@readonly_files, $file_name);
Line 3877 sub get_marked_as_readonly_hash {	Line 4647 sub get_marked_as_readonly_hash {
# ------------------------------------------------------------ Unmark as Read Only	# ------------------------------------------------------------ Unmark as Read Only

sub unmark_as_readonly {	sub unmark_as_readonly {
# unmarks all files locked by $what	# unmarks $file_name (if $file_name is defined), or all files locked by $what
# for portfolio submissions, $what contains $crsid and $symb	# for portfolio submissions, $what contains [$symb,$crsid]
my ($domain,$user,$what) = @_;	my ($domain,$user,$what,$file_name) = @_;
	my $symb_crs = $what;
	if (ref($what)) { $symb_crs=join('',@$what); }
my %current_permissions = &dump('file_permissions',$domain,$user);	my %current_permissions = &dump('file_permissions',$domain,$user);
my ($tmp)=keys(%current_permissions);	my ($tmp)=keys(%current_permissions);
if ($tmp=~/^error:/) { undef(%current_permissions); }	if ($tmp=~/^error:/) { undef(%current_permissions); }

my @readonly_files = &get_marked_as_readonly($domain,$user,$what);	my @readonly_files = &get_marked_as_readonly($domain,$user,$what);
foreach my $file(@readonly_files){	foreach my $file (@readonly_files) {
my $current_locks = $current_permissions{$file};	if (defined($file_name) && ($file_name ne $file)) { next; }
	my $current_locks = $current_permissions{$file};
my @new_locks;	my @new_locks;
my @del_keys;	my @del_keys;
if (ref($current_locks) eq "ARRAY"){	if (ref($current_locks) eq "ARRAY"){
foreach my $locker (@{$current_locks}) {	foreach my $locker (@{$current_locks}) {
unless ($locker eq $what) {	my $compare=$locker;
push(@new_locks, $what);	if (ref($locker)) { $compare=join('',@{$locker}) };
	if ($compare ne $symb_crs) {
	push(@new_locks, $locker);
}	}
}	}
if (@new_locks > 0) {	if (scalar(@new_locks) > 0) {
$current_permissions{$file} = \@new_locks;	$current_permissions{$file} = \@new_locks;
} else {	} else {
push(@del_keys, $file);	push(@del_keys, $file);
&del('file_permissions',\@del_keys, $domain, $user);	&del('file_permissions',\@del_keys, $domain, $user);
delete $current_permissions{$file};	delete($current_permissions{$file});
}	}
}	}
}	}
Line 4030 sub GetFileTimestamp {	Line 4804 sub GetFileTimestamp {
}	}
}	}

	sub stat_file {
	my ($uri) = @_;
	$uri = &clutter($uri);

	# we want just the url part without the unneeded accessor url bits
	if ($uri =~ m-^/adm/-) {
	$uri=~s-^/adm/wrapper/-/-;
	$uri=~s-^/adm/coursedocs/showdoc/-/-;
	}
	my ($udom,$uname,$file,$dir);
	if ($uri =~ m-^/(uploaded\|editupload)/-) {
	($udom,$uname,$file) =
	($uri =~ m-/(?:uploaded\|editupload)/?([^/])/?([^/])/?(.*)-);
	$file = 'userfiles/'.$file;
	$dir = &Apache::loncommon::propath($udom,$uname);
	}
	if ($uri =~ m-^/res/-) {
	($udom,$uname) =
	($uri =~ m-/(?:res)/?([^/])/?([^/])/-);
	$file = $uri;
	}

	if (!$udom \|\| !$uname \|\| !$file) {
	# unable to handle the uri
	return ();
	}

	my ($result) = &dirlist($file,$udom,$uname,$dir);
	my @stats = split('&', $result);

	if($stats[0] ne 'empty' && $stats[0] ne 'no_such_dir') {
	shift(@stats); #filename is first
	return @stats;
	}
	return ();
	}

# -------------------------------------------------------- Value of a Condition	# -------------------------------------------------------- Value of a Condition

	# gets the value of a specific preevaluated condition
	# stored in the string $env{user.state.<cid>}
	# or looks up a condition reference in the bighash and if if hasn't
	# already been evaluated recurses into docondval to get the value of
	# the condition, then memoizing it to
	# $env{user.state.<cid>.<condition>}
sub directcondval {	sub directcondval {
my $number=shift;	my $number=shift;
if (!defined($env{'user.state.'.$env{'request.course.id'}})) {	if (!defined($env{'user.state.'.$env{'request.course.id'}})) {
&Apache::lonuserstate::evalstate();	&Apache::lonuserstate::evalstate();
}	}
	if (exists($env{'user.state.'.$env{'request.course.id'}.".$number"})) {
	return $env{'user.state.'.$env{'request.course.id'}.".$number"};
	} elsif ($number =~ /^_/) {
	my $sub_condition;
	if (tie(my %bighash,'GDBM_File',$env{'request.course.fn'}.'.db',
	&GDBM_READER(),0640)) {
	$sub_condition=$bighash{'conditions'.$number};
	untie(%bighash);
	}
	my $value = &docondval($sub_condition);
	&appenv('user.state.'.$env{'request.course.id'}.".$number" => $value);
	return $value;
	}
if ($env{'user.state.'.$env{'request.course.id'}}) {	if ($env{'user.state.'.$env{'request.course.id'}}) {
return substr($env{'user.state.'.$env{'request.course.id'}},$number,1);	return substr($env{'user.state.'.$env{'request.course.id'}},$number,1);
} else {	} else {
Line 4044 sub directcondval {	Line 4874 sub directcondval {
}	}
}	}

	# get the collection of conditions for this resource
sub condval {	sub condval {
my $condidx=shift;	my $condidx=shift;
my $result=0;
my $allpathcond='';	my $allpathcond='';
foreach (split(/\\|/,$condidx)) {	foreach my $cond (split(/\\|/,$condidx)) {
if (defined($env{'acc.cond.'.$env{'request.course.id'}.'.'.$_})) {	if (defined($env{'acc.cond.'.$env{'request.course.id'}.'.'.$cond})) {
$allpathcond.=	$allpathcond.=
'('.$env{'acc.cond.'.$env{'request.course.id'}.'.'.$_}.')\|';	'('.$env{'acc.cond.'.$env{'request.course.id'}.'.'.$cond}.')\|';
}	}
}	}
$allpathcond=~s/\\|$//;	$allpathcond=~s/\\|$//;
if ($env{'request.course.id'}) {	return &docondval($allpathcond);
if ($allpathcond) {	}
my $operand='\|';
my @stack;	#evaluates an expression of conditions
foreach ($allpathcond=~/(\d+\|$\|$\|\&\|\\|)/g) {	sub docondval {
if ($_ eq '(') {	my ($allpathcond) = @_;
push @stack,($operand,$result)	my $result=0;
} elsif ($_ eq ')') {	if ($env{'request.course.id'}
my $before=pop @stack;	&& defined($allpathcond)) {
if (pop @stack eq '&') {	my $operand='\|';
$result=$result>$before?$before:$result;	my @stack;
} else {	foreach my $chunk ($allpathcond=~/(\d+\|_\d+\.\d+\|$\|$\|\&\|\\|)/g) {
$result=$result>$before?$result:$before;	if ($chunk eq '(') {
}	push @stack,($operand,$result);
} elsif (($_ eq '&') \|\| ($_ eq '\|')) {	} elsif ($chunk eq ')') {
$operand=$_;	my $before=pop @stack;
} else {	if (pop @stack eq '&') {
my $new=directcondval($_);	$result=$result>$before?$before:$result;
if ($operand eq '&') {	} else {
$result=$result>$new?$new:$result;	$result=$result>$before?$result:$before;
} else {	}
$result=$result>$new?$result:$new;	} elsif (($chunk eq '&') \|\| ($chunk eq '\|')) {
}	$operand=$chunk;
}	} else {
}	my $new=directcondval($chunk);
}	if ($operand eq '&') {
	$result=$result>$new?$new:$result;
	} else {
	$result=$result>$new?$result:$new;
	}
	}
	}
}	}
return $result;	return $result;
}	}
Line 4117 sub get_courseresdata {	Line 4953 sub get_courseresdata {
return $result;	return $result;
}	}

	sub devalidateuserresdata {
	my ($uname,$udom)=@_;
	my $hashid="$udom:$uname";
	&devalidate_cache_new('userres',$hashid);
	}

sub get_userresdata {	sub get_userresdata {
my ($uname,$udom)=@_;	my ($uname,$udom)=@_;
#most student don\'t have any data set, check if there is some data	#most student don\'t have any data set, check if there is some data
Line 4135 sub get_userresdata {	Line 4977 sub get_userresdata {
}	}
#error 2 occurs when the .db doesn't exist	#error 2 occurs when the .db doesn't exist
if ($tmp!~/error: 2 /) {	if ($tmp!~/error: 2 /) {
&logthis("<font color=blue>WARNING:".	&logthis("<font color=\"blue\">WARNING:".
" Trying to get resource data for ".	" Trying to get resource data for ".
$uname." at ".$udom.": ".	$uname." at ".$udom.": ".
$tmp."</font>");	$tmp."</font>");
} elsif ($tmp=~/error: 2 /) {	} elsif ($tmp=~/error: 2 /) {
&EXT_cache_set($udom,$uname);	#&EXT_cache_set($udom,$uname);
	&do_cache_new('userres',$hashid,undef,600);
	undef($tmp); # not really an error so don't send it back
}	}
return $tmp;	return $tmp;
}	}
Line 4184 sub EXT_cache_status {	Line 5028 sub EXT_cache_status {
sub EXT_cache_set {	sub EXT_cache_set {
my ($target_domain,$target_user) = @_;	my ($target_domain,$target_user) = @_;
my $cachename = 'cache.EXT.'.$target_user.'.'.$target_domain;	my $cachename = 'cache.EXT.'.$target_user.'.'.$target_domain;
&appenv($cachename => time);	#&appenv($cachename => time);
}	}

# --------------------------------------------------------- Value of a Variable	# --------------------------------------------------------- Value of a Variable
sub EXT {	sub EXT {
my ($varname,$symbparm,$udom,$uname,$usection,$recurse)=@_;

	my ($varname,$symbparm,$udom,$uname,$usection,$recurse)=@_;
unless ($varname) { return ''; }	unless ($varname) { return ''; }
#get real user name/domain, courseid and symb	#get real user name/domain, courseid and symb
my $courseid;	my $courseid;
Line 4220 sub EXT {	Line 5064 sub EXT {
if ($realm eq 'user') {	if ($realm eq 'user') {
# --------------------------------------------------------------- user.resource	# --------------------------------------------------------------- user.resource
if ($space eq 'resource') {	if ($space eq 'resource') {
if (defined($Apache::lonhomework::parsing_a_problem) \|\|	if ( (defined($Apache::lonhomework::parsing_a_problem)
defined($Apache::lonhomework::parsing_a_task)) {	\|\| defined($Apache::lonhomework::parsing_a_task))
	&&
	($symbparm eq &symbread()) ) {
return $Apache::lonhomework::history{$qualifierrest};	return $Apache::lonhomework::history{$qualifierrest};
} else {	} else {
my %restored;	my %restored;
Line 4285 sub EXT {	Line 5131 sub EXT {
# ------------------------------------------------------------- request.browser	# ------------------------------------------------------------- request.browser
if ($space eq 'browser') {	if ($space eq 'browser') {
if ($qualifier eq 'textremote') {	if ($qualifier eq 'textremote') {
if (&mt('textual_remote_display') eq 'on') {	if (&Apache::lonlocal::mt('textual_remote_display') eq 'on') {
return 1;	return 1;
} else {	} else {
return 0;	return 0;
Line 4302 sub EXT {	Line 5148 sub EXT {
return $env{'course.'.$courseid.'.'.$spacequalifierrest};	return $env{'course.'.$courseid.'.'.$spacequalifierrest};
} elsif ($realm eq 'resource') {	} elsif ($realm eq 'resource') {

my $section;
if (defined($courseid) && $courseid eq $env{'request.course.id'}) {	if (defined($courseid) && $courseid eq $env{'request.course.id'}) {
if (!$symbparm) { $symbparm=&symbread(); }	if (!$symbparm) { $symbparm=&symbread(); }
}	}

	if ($space eq 'title') {
	if (!$symbparm) { $symbparm = $env{'request.filename'}; }
	return &gettitle($symbparm);
	}

	if ($space eq 'map') {
	my ($map) = &decode_symb($symbparm);
	return &symbread($map);
	}

	my ($section, $group, @groups);
my ($courselevelm,$courselevel);	my ($courselevelm,$courselevel);
if ($symbparm && defined($courseid) &&	if ($symbparm && defined($courseid) &&
$courseid eq $env{'request.course.id'}) {	$courseid eq $env{'request.course.id'}) {
Line 4322 sub EXT {	Line 5179 sub EXT {
if (($env{'user.name'} eq $uname) &&	if (($env{'user.name'} eq $uname) &&
($env{'user.domain'} eq $udom)) {	($env{'user.domain'} eq $udom)) {
$section=$env{'request.course.sec'};	$section=$env{'request.course.sec'};
	@groups = split(/:/,$env{'request.course.groups'});
	@groups=&sort_course_groups($courseid,@groups);
} else {	} else {
if (! defined($usection)) {	if (! defined($usection)) {
$section=&getsection($udom,$uname,$courseid);	$section=&getsection($udom,$uname,$courseid);
} else {	} else {
$section = $usection;	$section = $usection;
}	}
	@groups = &get_users_groups($udom,$uname,$courseid);
}	}

my $seclevel=$courseid.'.['.$section.'].'.$spacequalifierrest;	my $seclevel=$courseid.'.['.$section.'].'.$spacequalifierrest;
Line 4343 sub EXT {	Line 5203 sub EXT {
my $userreply=&resdata($uname,$udom,'user',	my $userreply=&resdata($uname,$udom,'user',
($courselevelr,$courselevelm,	($courselevelr,$courselevelm,
$courselevel));	$courselevel));

if (defined($userreply)) { return $userreply; }	if (defined($userreply)) { return $userreply; }

# ------------------------------------------------ second, check some of course	# ------------------------------------------------ second, check some of course
	my $coursereply;
	if (@groups > 0) {
	$coursereply = &check_group_parms($courseid,\@groups,$symbparm,
	$mapparm,$spacequalifierrest);
	if (defined($coursereply)) { return $coursereply; }
	}

my $coursereply=&resdata($env{'course.'.$courseid.'.num'},	$coursereply=&resdata($env{'course.'.$courseid.'.num'},
$env{'course.'.$courseid.'.domain'},	$env{'course.'.$courseid.'.domain'},
'course',	'course',
($seclevelr,$seclevelm,$seclevel,	($seclevelr,$seclevelm,$seclevel,
Line 4419 sub EXT {	Line 5284 sub EXT {
if ($space eq 'time') {	if ($space eq 'time') {
return time;	return time;
}	}
	} elsif ($realm eq 'server') {
	# ----------------------------------------------------------------- system.time
	if ($space eq 'name') {
	return $ENV{'SERVER_NAME'};
	}
}	}
return '';	return '';
}	}

	sub check_group_parms {
	my ($courseid,$groups,$symbparm,$mapparm,$what) = @_;
	my @groupitems = ();
	my $resultitem;
	my @levels = ($symbparm,$mapparm,$what);
	foreach my $group (@{$groups}) {
	foreach my $level (@levels) {
	my $item = $courseid.'.['.$group.'].'.$level;
	push(@groupitems,$item);
	}
	}
	my $coursereply = &resdata($env{'course.'.$courseid.'.num'},
	$env{'course.'.$courseid.'.domain'},
	'course',@groupitems);
	return $coursereply;
	}

	sub sort_course_groups { # Sort groups based on defined rankings. Default is sort().
	my ($courseid,@groups) = @_;
	@groups = sort(@groups);
	return @groups;
	}

sub packages_tab_default {	sub packages_tab_default {
my ($uri,$varname)=@_;	my ($uri,$varname)=@_;
my (undef,$part,$name)=split(/\./,$varname);	my (undef,$part,$name)=split(/\./,$varname);
Line 4615 sub metadata {	Line 5508 sub metadata {
}	}
my ($extension) = ($uri =~ /\.(\w+)$/);	my ($extension) = ($uri =~ /\.(\w+)$/);
foreach my $key (sort(keys(%packagetab))) {	foreach my $key (sort(keys(%packagetab))) {
#&logthis("extsion1 $extension $key !!");
#no specific packages #how's our extension	#no specific packages #how's our extension
if ($key!~/^extension_\Q$extension\E&/) { next; }	if ($key!~/^extension_\Q$extension\E&/) { next; }
&metadata_create_package_def($uri,$key,'extension_'.$extension,	&metadata_create_package_def($uri,$key,'extension_'.$extension,
Line 4651 sub metadata {	Line 5543 sub metadata {
$metaentry{':keys'}=join(',',keys %metathesekeys);	$metaentry{':keys'}=join(',',keys %metathesekeys);
&metadata_generate_part0(\%metathesekeys,\%metaentry,$uri);	&metadata_generate_part0(\%metathesekeys,\%metaentry,$uri);
$metaentry{':allpossiblekeys'}=join(',',keys %metathesekeys);	$metaentry{':allpossiblekeys'}=join(',',keys %metathesekeys);
&do_cache_new('meta',$uri,\%metaentry,606024);	&do_cache_new('meta',$uri,\%metaentry,60*60);
# this is the end of "was not already recently cached	# this is the end of "was not already recently cached
}	}
return $metaentry{':'.$what};	return $metaentry{':'.$what};
Line 4703 sub metadata_generate_part0 {	Line 5595 sub metadata_generate_part0 {
'.type'};	'.type'};
my $olddis=$$metacache{':parameter_'.$allnames{$name}.'_'.$name.	my $olddis=$$metacache{':parameter_'.$allnames{$name}.'_'.$name.
'.display'};	'.display'};
my $expr='\\[Part: '.$allnames{$name}.'\\]';	my $expr='[Part: '.$allnames{$name}.']';
$olddis=~s/\Q$expr\E/\[Part: 0\]/;	$olddis=~s/\Q$expr\E/\[Part: 0\]/;
$$metacache{"$key.display"}=$olddis;	$$metacache{"$key.display"}=$olddis;
}	}
Line 4747 sub get_slot {	Line 5639 sub get_slot {
$cdom=$env{'course.'.$courseid.'.domain'};	$cdom=$env{'course.'.$courseid.'.domain'};
$cnum=$env{'course.'.$courseid.'.num'};	$cnum=$env{'course.'.$courseid.'.num'};
}	}
my %slotinfo=&get('slots',[$which],$cdom,$cnum);	my $key=join("\0",'slots',$cdom,$cnum,$which);
&Apache::lonhomework::showhash(%slotinfo);	my %slotinfo;
my ($tmp)=keys(%slotinfo);	if (exists($remembered{$key})) {
if ($tmp=~/^error:/) { return (); }	$slotinfo{$which} = $remembered{$key};
	} else {
	%slotinfo=&get('slots',[$which],$cdom,$cnum);
	&Apache::lonhomework::showhash(%slotinfo);
	my ($tmp)=keys(%slotinfo);
	if ($tmp=~/^error:/) { return (); }
	$remembered{$key} = $slotinfo{$which};
	}
if (ref($slotinfo{$which}) eq 'HASH') {	if (ref($slotinfo{$which}) eq 'HASH') {
return %{$slotinfo{$which}};	return %{$slotinfo{$which}};
}	}
Line 4765 sub symblist {	Line 5664 sub symblist {
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 my $url (keys %newhash) {
$hash{declutter($_)}=&encode_symb($mapname,$newhash{$_}->[1],	next if ($url eq 'last_known'
$newhash{$_}->[0]);	&& $env{'form.no_update_last_known'});
	$hash{declutter($url)}=&encode_symb($mapname,
	$newhash{$url}->[1],
	$newhash{$url}->[0]);
}	}
if (untie(%hash)) {	if (untie(%hash)) {
return 'ok';	return 'ok';
Line 4784 sub symbverify {	Line 5686 sub symbverify {
my $thisfn=$thisurl;	my $thisfn=$thisurl;
# wrapper not part of symbs	# wrapper not part of symbs
$thisfn=~s/^\/adm\/wrapper//;	$thisfn=~s/^\/adm\/wrapper//;
	$thisfn=~s/^\/adm\/coursedocs\/showdoc\///;
$thisfn=&declutter($thisfn);	$thisfn=&declutter($thisfn);
# direct jump to resource in page or to a sequence - will construct own symbs	# direct jump to resource in page or to a sequence - will construct own symbs
if ($thisfn=~/\.(page\|sequence)$/) { return 1; }	if ($thisfn=~/\.(page\|sequence)$/) { return 1; }
Line 4808 sub symbverify {	Line 5711 sub symbverify {
if ($ids) {	if ($ids) {
# ------------------------------------------------------------------- Has ID(s)	# ------------------------------------------------------------------- Has ID(s)
foreach (split(/\,/,$ids)) {	foreach (split(/\,/,$ids)) {
my ($mapid,$resid)=split(/\./,$_);	my ($mapid,$resid)=split(/\./,$_);
if (	if (
&symbclean(&declutter($bighash{'map_id_'.$mapid}).'___'.$resid.'___'.$thisfn)	&symbclean(&declutter($bighash{'map_id_'.$mapid}).'___'.$resid.'___'.$thisfn)
eq $symb) {	eq $symb) {
Line 4838 sub symbclean {	Line 5741 sub symbclean {
# remove wrapper	# remove wrapper

$symb=~s/(\_\_\_\d+\_\_\_)adm\/wrapper\/(res\/)*/$1/;	$symb=~s/(\_\_\_\d+\_\_\_)adm\/wrapper\/(res\/)*/$1/;
	$symb=~s/(\_\_\_\d+\_\_\_)adm\/coursedocs\/showdoc\/(res\/)*/$1/;
return $symb;	return $symb;
}	}

Line 4914 sub symbread {	Line 5818 sub symbread {
if ( ($thisfn =~ m/^(uploaded\|editupload)\//) && ($thisfn !~ m/\.(page\|sequence)$/) ) {	if ( ($thisfn =~ m/^(uploaded\|editupload)\//) && ($thisfn !~ m/\.(page\|sequence)$/) ) {
$targetfn = 'adm/wrapper/'.$thisfn;	$targetfn = 'adm/wrapper/'.$thisfn;
}	}
	if ($targetfn =~ m\|^adm/wrapper/(ext/.*)\|) {
	$targetfn=$1;
	}
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{$targetfn};	$syval=$hash{$targetfn};
Line 5027 sub numval3 {	Line 5934 sub numval3 {
return $total;	return $total;
}	}

	sub digest {
	my ($data)=@_;
	my $digest=&Digest::MD5::md5($data);
	my ($a,$b,$c,$d)=unpack("iiii",$digest);
	my ($e,$f);
	{
	use integer;
	$e=($a+$b);
	$f=($c+$d);
	if ($_64bit) {
	$e=(($e<<32)>>32);
	$f=(($f<<32)>>32);
	}
	}
	if (wantarray) {
	return ($e,$f);
	} else {
	my $g;
	{
	use integer;
	$g=($e+$f);
	if ($_64bit) {
	$g=(($g<<32)>>32);
	}
	}
	return $g;
	}
	}

sub latest_rnd_algorithm_id {	sub latest_rnd_algorithm_id {
return '64bit4';	return '64bit5';
}	}

sub get_rand_alg {	sub get_rand_alg {
Line 5068 sub rndseed {	Line 6004 sub rndseed {
if (!$username) { $username=$wusername }	if (!$username) { $username=$wusername }
my $which=&get_rand_alg();	my $which=&get_rand_alg();
if (defined(&getCODE())) {	if (defined(&getCODE())) {
if ($which eq '64bit4') {	if ($which eq '64bit5') {
	return &rndseed_CODE_64bit5($symb,$courseid,$domain,$username);
	} elsif ($which eq '64bit4') {
return &rndseed_CODE_64bit4($symb,$courseid,$domain,$username);	return &rndseed_CODE_64bit4($symb,$courseid,$domain,$username);
} else {	} else {
return &rndseed_CODE_64bit($symb,$courseid,$domain,$username);	return &rndseed_CODE_64bit($symb,$courseid,$domain,$username);
}	}
	} elsif ($which eq '64bit5') {
	return &rndseed_64bit5($symb,$courseid,$domain,$username);
} elsif ($which eq '64bit4') {	} elsif ($which eq '64bit4') {
return &rndseed_64bit4($symb,$courseid,$domain,$username);	return &rndseed_64bit4($symb,$courseid,$domain,$username);
} elsif ($which eq '64bit3') {	} elsif ($which eq '64bit3') {
Line 5195 sub rndseed_64bit4 {	Line 6135 sub rndseed_64bit4 {
}	}
}	}

	sub rndseed_64bit5 {
	my ($symb,$courseid,$domain,$username)=@_;
	my ($num1,$num2)=&digest("$symb,$courseid,$domain,$username");
	return "$num1:$num2";
	}

sub rndseed_CODE_64bit {	sub rndseed_CODE_64bit {
my ($symb,$courseid,$domain,$username)=@_;	my ($symb,$courseid,$domain,$username)=@_;
{	{
Line 5233 sub rndseed_CODE_64bit4 {	Line 6179 sub rndseed_CODE_64bit4 {
}	}
}	}

	sub rndseed_CODE_64bit5 {
	my ($symb,$courseid,$domain,$username)=@_;
	my $code = &getCODE();
	my ($num1,$num2)=&digest("$symb,$courseid,$code");
	return "$num1:$num2";
	}

sub setup_random_from_rndseed {	sub setup_random_from_rndseed {
my ($rndseed)=@_;	my ($rndseed)=@_;
if ($rndseed =~/([,:])/) {	if ($rndseed =~/([,:])/) {
Line 5439 sub filelocation {	Line 6392 sub filelocation {
my ($dir,$file) = @_;	my ($dir,$file) = @_;
my $location;	my $location;
$file=~ s/^\s(\S+)\s$/$1/; ## strip off leading and trailing spaces	$file=~ s/^\s(\S+)\s$/$1/; ## strip off leading and trailing spaces

	if ($file =~ m-^/adm/-) {
	$file=~s-^/adm/wrapper/-/-;
	$file=~s-^/adm/coursedocs/showdoc/-/-;
	}
if ($file=~m:^/~:) { # is a contruction space reference	if ($file=~m:^/~:) { # is a contruction space reference
$location = $file;	$location = $file;
$location =~ s:/~(.?)/(.):/home/$1/public_html/$2:;	$location =~ s:/~(.?)/(.):/home/$1/public_html/$2:;
	} elsif ($file=~m:^/home/[^/]*/public_html/:) {
	# is a correct contruction space reference
	$location = $file;
} elsif ($file=~/^\/*(uploaded\|editupload)/) { # is an uploaded file	} elsif ($file=~/^\/*(uploaded\|editupload)/) { # is an uploaded file
my ($udom,$uname,$filename)=	my ($udom,$uname,$filename)=
($file=~m -^/+(?:uploaded\|editupload)/+([^/]+)/+([^/]+)/+(.*)$-);	($file=~m -^/+(?:uploaded\|editupload)/+([^/]+)/+([^/]+)/+(.*)$-);
Line 5474 sub filelocation {	Line 6435 sub filelocation {
sub hreflocation {	sub hreflocation {
my ($dir,$file)=@_;	my ($dir,$file)=@_;
unless (($file=~m-^http://-i) \|\| ($file=~m-^/-)) {	unless (($file=~m-^http://-i) \|\| ($file=~m-^/-)) {
my $finalpath=filelocation($dir,$file);	$file=filelocation($dir,$file);
$finalpath=~s-^/home/httpd/html--;	} elsif ($file=~m-^/adm/-) {
$finalpath=~s-^/home/(\w+)/public_html/-/~$1/-;	$file=~s-^/adm/wrapper/-/-;
return $finalpath;	$file=~s-^/adm/coursedocs/showdoc/-/-;
} elsif ($file=~m-^/home-) {	}
$file=~s-^/home/httpd/html--;	if ($file=~m-^\Q$perlvar{'lonDocRoot'}\E-) {
	$file=~s-^\Q$perlvar{'lonDocRoot'}\E--;
	} elsif ($file=~m-/home/(\w+)/public_html/-) {
$file=~s-^/home/(\w+)/public_html/-/~$1/-;	$file=~s-^/home/(\w+)/public_html/-/~$1/-;
return $file;	} elsif ($file=~m-^\Q$perlvar{'lonUsersDir'}\E-) {
	$file=~s-^/home/httpd/lonUsers/([^/])/./././([^/])/userfiles/
	-/uploaded/$1/$2/-x;
}	}
return $file;	return $file;
}	}
Line 5517 sub declutter {	Line 6482 sub declutter {
if ($thisfn=~m\|^/enc/\|) { $thisfn=&Apache::lonenc::unencrypted($thisfn); }	if ($thisfn=~m\|^/enc/\|) { $thisfn=&Apache::lonenc::unencrypted($thisfn); }
$thisfn=~s/^\Q$perlvar{'lonDocRoot'}\E//;	$thisfn=~s/^\Q$perlvar{'lonDocRoot'}\E//;
$thisfn=~s/^\///;	$thisfn=~s/^\///;
	$thisfn=~s\|^adm/wrapper/\|\|;
	$thisfn=~s\|^adm/coursedocs/showdoc/\|\|;
$thisfn=~s/^res\///;	$thisfn=~s/^res\///;
$thisfn=~s/\?.+$//;	$thisfn=~s/\?.+$//;
return $thisfn;	return $thisfn;
Line 5529 sub clutter {	Line 6496 sub clutter {
unless ($thisfn=~/^\/(uploaded\|editupload\|adm\|userfiles\|ext\|raw\|priv\|public)\//) {	unless ($thisfn=~/^\/(uploaded\|editupload\|adm\|userfiles\|ext\|raw\|priv\|public)\//) {
$thisfn='/res'.$thisfn;	$thisfn='/res'.$thisfn;
}	}
	if ($thisfn !~m\|/adm\|) {
	if ($thisfn =~ m\|/ext/\|) {
	$thisfn='/adm/wrapper'.$thisfn;
	} else {
	my ($ext) = ($thisfn =~ /\.(\w+)$/);
	my $embstyle=&Apache::loncommon::fileembstyle($ext);
	if ($embstyle eq 'ssi'
	\|\| ($embstyle eq 'hdn')
	\|\| ($embstyle eq 'rat')
	\|\| ($embstyle eq 'prv')
	\|\| ($embstyle eq 'ign')) {
	#do nothing with these
	} elsif (($embstyle eq 'img')
	\|\| ($embstyle eq 'emb')
	\|\| ($embstyle eq 'wrp')) {
	$thisfn='/adm/wrapper'.$thisfn;
	} elsif ($embstyle eq 'unk'
	&& $thisfn!~/\.(sequence\|page)$/) {
	$thisfn='/adm/coursedocs/showdoc'.$thisfn;
	} else {
	# &logthis("Got a blank emb style");
	}
	}
	}
return $thisfn;	return $thisfn;
}	}

Line 5567 sub thaw_unescape {	Line 6558 sub thaw_unescape {
return &unescape($value);	return &unescape($value);
}	}

sub mod_perl_version {
return 1;
if (defined($perlvar{'MODPERL2'})) {
return 2;
}
}

sub correct_line_ends {	sub correct_line_ends {
my ($result)=@_;	my ($result)=@_;
$$result =~s/\r\n/\n/mg;	$$result =~s/\r\n/\n/mg;
Line 5600 sub goodbye {	Line 6584 sub goodbye {
&logthis(sprintf("%-20s is %s",'hits',$hits));	&logthis(sprintf("%-20s is %s",'hits',$hits));
&flushcourselogs();	&flushcourselogs();
&logthis("Shutting down");	&logthis("Shutting down");
return DONE;
}	}

BEGIN {	BEGIN {
Line 5644 BEGIN {	Line 6627 BEGIN {
# next if /^\#/;	# next if /^\#/;
chomp;	chomp;
my ($domain, $domain_description, $def_auth, $def_auth_arg,	my ($domain, $domain_description, $def_auth, $def_auth_arg,
$def_lang, $city, $longi, $lati) = split(/:/,$_);	$def_lang, $city, $longi, $lati, $primary) = split(/:/,$_);
$domain_auth_def{$domain}=$def_auth;	$domain_auth_def{$domain}=$def_auth;
$domain_auth_arg_def{$domain}=$def_auth_arg;	$domain_auth_arg_def{$domain}=$def_auth_arg;
$domaindescription{$domain}=$domain_description;	$domaindescription{$domain}=$domain_description;
Line 5652 BEGIN {	Line 6635 BEGIN {
$domain_city{$domain}=$city;	$domain_city{$domain}=$city;
$domain_longi{$domain}=$longi;	$domain_longi{$domain}=$longi;
$domain_lati{$domain}=$lati;	$domain_lati{$domain}=$lati;
	$domain_primary{$domain}=$primary;

# &logthis("Domain.tab: $domain, $domain_auth_def{$domain}, $domain_auth_arg_def{$domain},$domaindescription{$domain}");	# &logthis("Domain.tab: $domain, $domain_auth_def{$domain}, $domain_auth_arg_def{$domain},$domaindescription{$domain}");
# &logthis("Domain.tab: $domain ".$domaindescription{$domain} );	# &logthis("Domain.tab: $domain ".$domaindescription{$domain} );
Line 5683 BEGIN {	Line 6667 BEGIN {

sub get_iphost {	sub get_iphost {
if (%iphost) { return %iphost; }	if (%iphost) { return %iphost; }
	my %name_to_ip;
foreach my $id (keys(%hostname)) {	foreach my $id (keys(%hostname)) {
my $name=$hostname{$id};	my $name=$hostname{$id};
my $ip = gethostbyname($name);	my $ip;
if (!$ip \|\| length($ip) ne 4) {	if (!exists($name_to_ip{$name})) {
&logthis("Skipping host $id name $name no IP found\n");	$ip = gethostbyname($name);
next;	if (!$ip \|\| length($ip) ne 4) {
	&logthis("Skipping host $id name $name no IP found\n");
	next;
	}
	$ip=inet_ntoa($ip);
	$name_to_ip{$name} = $ip;
	} else {
	$ip = $name_to_ip{$name};
}	}
$ip=inet_ntoa($ip);
push(@{$iphost{$ip}},$id);	push(@{$iphost{$ip}},$id);
}	}
return %iphost;	return %iphost;
Line 5765 $processmarker='_'.time.'_'.$perlvar{'lo	Line 6756 $processmarker='_'.time.'_'.$perlvar{'lo
$dumpcount=0;	$dumpcount=0;

&logtouch();	&logtouch();
&logthis('<font color=yellow>INFO: Read configuration</font>');	&logthis('<font color="yellow">INFO: Read configuration</font>');
$readit=1;	$readit=1;
{	{
use integer;	use integer;
Line 6167 revokecustomrole($udom,$uname,$url,$role	Line 7158 revokecustomrole($udom,$uname,$url,$role

=item *	=item *

coursedescription($courseid) : course description	coursedescription($courseid) : returns a hash of information about the
	specified course id, including all environment settings for the
	course, the description of the course will be in the hash under the
	key 'description'

=item *	=item *

Line 6342 all args are optional	Line 7336 all args are optional

=item *	=item *

	dumpstore($namespace,$udom,$uname,$regexp,$range) :
	dumps the complete (or key matching regexp) namespace into a hash
	($udom, $uname, $regexp, $range are optional) for a namespace that is
	normally &store()ed into

	$range should be either an integer '100' (give me the first 100
	matching records)
	or be two integers sperated by a - with no spaces
	'30-50' (give me the 30th through the 50th matching
	records)


	=item *

	putstore($namespace,$symb,$version,$storehash,$udomain,$uname) :
	replaces a &store() version of data with a replacement set of data
	for a particular resource in a namespace passed in the $storehash hash
	reference

	=item *

tmpstore($storehash,$symb,$namespace,$udom,$uname) : storage that	tmpstore($storehash,$symb,$namespace,$udom,$uname) : storage that
works very similar to store/cstore, but all data is stored in a	works very similar to store/cstore, but all data is stored in a
temporary location and can be reset using tmpreset, $storehash should	temporary location and can be reset using tmpreset, $storehash should
Line 6371 namesp ($udom and $uname are optional)	Line 7386 namesp ($udom and $uname are optional)

=item *	=item *

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

	$range should be either an integer '100' (give me the first 100
	matching records)
	or be two integers sperated by a - with no spaces
	'30-50' (give me the 30th through the 50th matching
	records)
=item *	=item *

inc($namespace,$store,$udom,$uname) : increments $store in $namespace.	inc($namespace,$store,$udom,$uname) : increments $store in $namespace.
Line 6390 put($namespace,$storehash,$udom,$uname)	Line 7410 put($namespace,$storehash,$udom,$uname)

=item *	=item *

putstore($namespace,$storehash,$udomain,$uname) : stores hash in namesp
keys used in storehash include version information (e.g., 1:$symb:message etc.) as
used in records written by &store and retrieved by &restore. This function
was created for use in editing discussion posts, without incrementing the
version number included in the key for a particular post. The colon
separated list of attribute names (e.g., the value associated with the key
1:keys:$symb) is also generated and passed in the ampersand separated
items sent to lonnet::reply().

=item *

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

Line 6530 getfile($file,$caller) : two cases - req	Line 7539 getfile($file,$caller) : two cases - req
- returns the entire contents of a file or -1;	- returns the entire contents of a file or -1;
it properly subscribes to and replicates the file if neccessary.	it properly subscribes to and replicates the file if neccessary.


	=item *

	stat_file($url) : $url is expected to be a /res/ or /uploaded/ style file
	reference

	returns either a stat() list of data about the file or an empty list
	if the file doesn't exist or couldn't find out about it (connection
	problems or user unknown)

=item *	=item *

filelocation($dir,$file) : returns file system location of a file	filelocation($dir,$file) : returns file system location of a file
Line 6589 userspace, probably shouldn't be called	Line 7608 userspace, probably shouldn't be called

docuname: username or courseid of destination for the file	docuname: username or courseid of destination for the file
docudom: domain of user/course of destination for the file	docudom: domain of user/course of destination for the file
docuhome: loncapa id of the library server that is getting the file
formname: same as for userfileupload()	formname: same as for userfileupload()
fname: filename (inculding subdirectories) for the file	fname: filename (inculding subdirectories) for the file

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

Removed from v.1.627
changed lines
	Added in v.1.734