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.1172.2.57 and 1.1172.2.107

version 1.1172.2.57, 2014/10/26 13:02:42	version 1.1172.2.107, 2019/08/01 19:13:26
Line 74 use strict;	Line 74 use strict;
use LWP::UserAgent();	use LWP::UserAgent();
use HTTP::Date;	use HTTP::Date;
use Image::Magick;	use Image::Magick;
	use CGI::Cookie;

use vars qw(%perlvar %spareid %pr %prp $memcache %packagetab $tmpdir	use vars qw(%perlvar %spareid %pr %prp $memcache %packagetab $tmpdir $deftex
$_64bit %env %protocol %loncaparevs %serverhomeIDs %needsrelease	$_64bit %env %protocol %loncaparevs %serverhomeIDs %needsrelease
%managerstab);	%managerstab);

Line 89 use GDBM_File;	Line 90 use GDBM_File;
use HTML::LCParser;	use HTML::LCParser;
use Fcntl qw(:flock);	use Fcntl qw(:flock);
use Storable qw(thaw nfreeze);	use Storable qw(thaw nfreeze);
use Time::HiRes qw( gettimeofday tv_interval );	use Time::HiRes qw( sleep gettimeofday tv_interval );
use Cache::Memcached;	use Cache::Memcached;
use Digest::MD5;	use Digest::MD5;
use Math::Random;	use Math::Random;
Line 102 use LONCAPA::Lond;	Line 103 use LONCAPA::Lond;
use File::Copy;	use File::Copy;

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

require Exporter;	require Exporter;

Line 142 our @EXPORT = qw(%env);	Line 143 our @EXPORT = qw(%env);
sub logtouch {	sub logtouch {
my $execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
unless (-e "$execdir/logs/lonnet.log") {	unless (-e "$execdir/logs/lonnet.log") {
open(my $fh,">>$execdir/logs/lonnet.log");	open(my $fh,">>","$execdir/logs/lonnet.log");
close $fh;	close $fh;
}	}
my ($wwwuid,$wwwgid)=(getpwnam('www'))[2,3];	my ($wwwuid,$wwwgid)=(getpwnam('www'))[2,3];
Line 154 sub logthis {	Line 155 sub logthis {
my $execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
my $now=time;	my $now=time;
my $local=localtime($now);	my $local=localtime($now);
if (open(my $fh,">>$execdir/logs/lonnet.log")) {	if (open(my $fh,">>","$execdir/logs/lonnet.log")) {
my $logstring = $local. " ($$): ".$message."\n"; # Keep any \'s in string.	my $logstring = $local. " ($$): ".$message."\n"; # Keep any \'s in string.
print $fh $logstring;	print $fh $logstring;
close($fh);	close($fh);
Line 167 sub logperm {	Line 168 sub logperm {
my $execdir=$perlvar{'lonDaemons'};	my $execdir=$perlvar{'lonDaemons'};
my $now=time;	my $now=time;
my $local=localtime($now);	my $local=localtime($now);
if (open(my $fh,">>$execdir/logs/lonnet.perm.log")) {	if (open(my $fh,">>","$execdir/logs/lonnet.perm.log")) {
print $fh "$now:$message:$local\n";	print $fh "$now:$message:$local\n";
close($fh);	close($fh);
}	}
Line 370 sub subreply {	Line 371 sub subreply {

my $lockfile=$peerfile.".lock";	my $lockfile=$peerfile.".lock";
while (-e $lockfile) { # Need to wait for the lockfile to disappear.	while (-e $lockfile) { # Need to wait for the lockfile to disappear.
sleep(1);	sleep(0.1);
}	}
# At this point, either a loncnew parent is listening or an old lonc	# At this point, either a loncnew parent is listening or an old lonc
# or loncnew child is listening so we can connect or everything's dead.	# or loncnew child is listening so we can connect or everything's dead.
Line 388 sub subreply {	Line 389 sub subreply {
} else {	} else {
&create_connection(&hostname($server),$server);	&create_connection(&hostname($server),$server);
}	}
sleep(1); # Try again later if failed connection.	sleep(0.1); # Try again later if failed connection.
}	}
my $answer;	my $answer;
if ($client) {	if ($client) {
Line 417 sub reply {	Line 418 sub reply {

sub reconlonc {	sub reconlonc {
my ($lonid) = @_;	my ($lonid) = @_;
my $hostname = &hostname($lonid);
if ($lonid) {	if ($lonid) {
	my $hostname = &hostname($lonid);
my $peerfile="$perlvar{'lonSockDir'}/$hostname";	my $peerfile="$perlvar{'lonSockDir'}/$hostname";
if ($hostname && -e $peerfile) {	if ($hostname && -e $peerfile) {
&logthis("Trying to reconnect lonc for $lonid ($hostname)");	&logthis("Trying to reconnect lonc for $lonid ($hostname)");
Line 436 sub reconlonc {	Line 437 sub reconlonc {

&logthis("Trying to reconnect lonc");	&logthis("Trying to reconnect lonc");
my $loncfile="$perlvar{'lonDaemons'}/logs/lonc.pid";	my $loncfile="$perlvar{'lonDaemons'}/logs/lonc.pid";
if (open(my $fh,"<$loncfile")) {	if (open(my $fh,"<",$loncfile)) {
my $loncpid=<$fh>;	my $loncpid=<$fh>;
chomp($loncpid);	chomp($loncpid);
if (kill 0 => $loncpid) {	if (kill 0 => $loncpid) {
Line 464 sub critical {	Line 465 sub critical {
}	}
my $answer=reply($cmd,$server);	my $answer=reply($cmd,$server);
if ($answer eq 'con_lost') {	if ($answer eq 'con_lost') {
&reconlonc("$perlvar{'lonSockDir'}/$server");	&reconlonc($server);
my $answer=reply($cmd,$server);	my $answer=reply($cmd,$server);
if ($answer eq 'con_lost') {	if ($answer eq 'con_lost') {
my $now=time;	my $now=time;
Line 476 sub critical {	Line 477 sub critical {
$dumpcount++;	$dumpcount++;
{	{
my $dfh;	my $dfh;
if (open($dfh,">$dfilename")) {	if (open($dfh,">",$dfilename)) {
print $dfh "$cmd\n";	print $dfh "$cmd\n";
close($dfh);	close($dfh);
}	}
}	}
sleep 2;	sleep 1;
my $wcmd='';	my $wcmd='';
{	{
my $dfh;	my $dfh;
if (open($dfh,"<$dfilename")) {	if (open($dfh,"<",$dfilename)) {
$wcmd=<$dfh>;	$wcmd=<$dfh>;
close($dfh);	close($dfh);
}	}
Line 601 sub transfer_profile_to_env {	Line 602 sub transfer_profile_to_env {

# ---------------------------------------------------- Check for valid session	# ---------------------------------------------------- Check for valid session
sub check_for_valid_session {	sub check_for_valid_session {
my ($r,$name,$userhashref) = @_;	my ($r,$name,$userhashref,$domref) = @_;
my %cookies=CGI::Cookie->parse($r->header_in('Cookie'));	my %cookies=CGI::Cookie->parse($r->header_in('Cookie'));
if ($name eq '') {	if ($name eq '') {
$name = 'lonID';	$name = 'lonID';
Line 616 sub check_for_valid_session {	Line 617 sub check_for_valid_session {
} else {	} else {
$lonidsdir=$r->dir_config('lonIDsDir');	$lonidsdir=$r->dir_config('lonIDsDir');
}	}
return undef if (!-e "$lonidsdir/$handle.id");	if (!-e "$lonidsdir/$handle.id") {
	if ((ref($domref)) && ($name eq 'lonID') &&
	($handle =~ /^($match_username)\_\d+\_($match_domain)\_(.+)$/)) {
	my ($possuname,$possudom,$possuhome) = ($1,$2,$3);
	if ((&domain($possudom) ne '') && (&homeserver($possuname,$possudom) eq $possuhome)) {
	$$domref = $possudom;
	}
	}
	return undef;
	}

my $opened = open(my $idf,'+<',"$lonidsdir/$handle.id");	my $opened = open(my $idf,'+<',"$lonidsdir/$handle.id");
return undef if (!$opened);	return undef if (!$opened);
Line 630 sub check_for_valid_session {	Line 640 sub check_for_valid_session {

if (!defined($disk_env{'user.name'})	if (!defined($disk_env{'user.name'})
\|\| !defined($disk_env{'user.domain'})) {	\|\| !defined($disk_env{'user.domain'})) {
	untie(%disk_env);
return undef;	return undef;
}	}

Line 637 sub check_for_valid_session {	Line 648 sub check_for_valid_session {
$userhashref->{'name'} = $disk_env{'user.name'};	$userhashref->{'name'} = $disk_env{'user.name'};
$userhashref->{'domain'} = $disk_env{'user.domain'};	$userhashref->{'domain'} = $disk_env{'user.domain'};
}	}
	untie(%disk_env);

return $handle;	return $handle;
}	}
Line 661 sub timed_flock {	Line 673 sub timed_flock {
}	}
}	}

	sub get_sessionfile_vars {
	my ($handle,$lonidsdir,$storearr) = @_;
	my %returnhash;
	unless (ref($storearr) eq 'ARRAY') {
	return %returnhash;
	}
	if (-l "$lonidsdir/$handle.id") {
	my $link = readlink("$lonidsdir/$handle.id");
	if ((-e $link) && ($link =~ m{^\Q$lonidsdir\E/(.+)\.id$})) {
	$handle = $1;
	}
	}
	if ((-e "$lonidsdir/$handle.id") &&
	($handle =~ /^($match_username)\_\d+\_($match_domain)\_(.+)$/)) {
	my ($possuname,$possudom,$possuhome) = ($1,$2,$3);
	if ((&domain($possudom) ne '') && (&homeserver($possuname,$possudom) eq $possuhome)) {
	if (open(my $idf,'+<',"$lonidsdir/$handle.id")) {
	flock($idf,LOCK_SH);
	if (tie(my %disk_env,'GDBM_File',"$lonidsdir/$handle.id",
	&GDBM_READER(),0640)) {
	foreach my $item (@{$storearr}) {
	$returnhash{$item} = $disk_env{$item};
	}
	untie(%disk_env);
	}
	}
	}
	}
	return %returnhash;
	}

# ---------------------------------------------------------- Append Environment	# ---------------------------------------------------------- Append Environment

sub appenv {	sub appenv {
Line 686 sub appenv {	Line 729 sub appenv {
$env{$key}=$newenv->{$key};	$env{$key}=$newenv->{$key};
}	}
}	}
my $opened = open(my $env_file,'+<',$env{'user.environment'});	my $lonids = $perlvar{'lonIDsDir'};
if ($opened	if ($env{'user.environment'} =~ m{^\Q$lonids/\E$match_username\_\d+\_$match_domain\_[\w\-.]+\.id$}) {
&& &timed_flock($env_file,LOCK_EX)	my $opened = open(my $env_file,'+<',$env{'user.environment'});
&&	if ($opened
tie(my %disk_env,'GDBM_File',$env{'user.environment'},	&& &timed_flock($env_file,LOCK_EX)
(&GDBM_WRITER()\|&GDBM_NOLOCK()),0640)) {	&&
while (my ($key,$value) = each(%{$newenv})) {	tie(my %disk_env,'GDBM_File',$env{'user.environment'},
$disk_env{$key} = $value;	(&GDBM_WRITER()\|&GDBM_NOLOCK()),0640)) {
}	while (my ($key,$value) = each(%{$newenv})) {
untie(%disk_env);	$disk_env{$key} = $value;
	}
	untie(%disk_env);
	}
}	}
}	}
return 'ok';	return 'ok';
Line 844 sub spareserver {	Line 890 sub spareserver {
if (ref($spareshash) eq 'HASH') {	if (ref($spareshash) eq 'HASH') {
if (ref($spareshash->{'primary'}) eq 'ARRAY') {	if (ref($spareshash->{'primary'}) eq 'ARRAY') {
foreach my $try_server (@{ $spareshash->{'primary'} }) {	foreach my $try_server (@{ $spareshash->{'primary'} }) {
if ($uint_dom) {	next unless (&spare_can_host($udom,$uint_dom,$remotesessions,
next unless (&spare_can_host($udom,$uint_dom,$remotesessions,	$try_server));
$try_server));
}
($spare_server, $lowest_load) =	($spare_server, $lowest_load) =
&compare_server_load($try_server, $spare_server, $lowest_load);	&compare_server_load($try_server, $spare_server, $lowest_load);
}	}
Line 858 sub spareserver {	Line 902 sub spareserver {
if (!$found_server) {	if (!$found_server) {
if (ref($spareshash->{'default'}) eq 'ARRAY') {	if (ref($spareshash->{'default'}) eq 'ARRAY') {
foreach my $try_server (@{ $spareshash->{'default'} }) {	foreach my $try_server (@{ $spareshash->{'default'} }) {
if ($uint_dom) {	next unless (&spare_can_host($udom,$uint_dom,
next unless (&spare_can_host($udom,$uint_dom,	$remotesessions,$try_server));
$remotesessions,$try_server));
}
($spare_server, $lowest_load) =	($spare_server, $lowest_load) =
&compare_server_load($try_server, $spare_server, $lowest_load);	&compare_server_load($try_server, $spare_server, $lowest_load);
}	}
Line 943 sub find_existing_session {	Line 985 sub find_existing_session {
return;	return;
}	}

	# check if user's browser sent load balancer cookie and server still has session
	# and is not overloaded.
	sub check_for_balancer_cookie {
	my ($r,$update_mtime) = @_;
	my ($otherserver,$cookie);
	my %cookies=CGI::Cookie->parse($r->header_in('Cookie'));
	if (exists($cookies{'balanceID'})) {
	my $balid = $cookies{'balanceID'};
	$cookie=&LONCAPA::clean_handle($balid->value);
	my $balancedir=$r->dir_config('lonBalanceDir');
	if ((-d $balancedir) && (-e "$balancedir/$cookie.id")) {
	if ($cookie =~ /^($match_domain)_($match_username)_[a-f0-9]+$/) {
	my ($possudom,$possuname) = ($1,$2);
	my $has_session = 0;
	if ((&domain($possudom) ne '') &&
	(&homeserver($possuname,$possudom) ne 'no_host')) {
	my $try_server;
	my $opened = open(my $idf,'+<',"$balancedir/$cookie.id");
	if ($opened) {
	flock($idf,LOCK_SH);
	while (my $line = <$idf>) {
	chomp($line);
	if (&hostname($line) ne '') {
	$try_server = $line;
	last;
	}
	}
	close($idf);
	if (($try_server) &&
	(&has_user_session($try_server,$possudom,$possuname))) {
	my $lowest_load = 30000;
	($otherserver,$lowest_load) =
	&compare_server_load($try_server,undef,$lowest_load);
	if ($otherserver ne '' && $lowest_load < 100) {
	$has_session = 1;
	} else {
	undef($otherserver);
	}
	}
	}
	}
	if ($has_session) {
	if ($update_mtime) {
	my $atime = my $mtime = time;
	utime($atime,$mtime,"$balancedir/$cookie.id");
	}
	} else {
	unlink("$balancedir/$cookie.id");
	}
	}
	}
	}
	return ($otherserver,$cookie);
	}

	sub delbalcookie {
	my ($cookie,$balancer) =@_;
	if ($cookie =~ /^($match_domain)\_($match_username)\_[a-f0-9]{32}$/) {
	my ($udom,$uname) = ($1,$2);
	my $uprimary_id = &domain($udom,'primary');
	my $uintdom = &internet_dom($uprimary_id);
	my $intdom = &internet_dom($balancer);
	my $serverhomedom = &host_domain($balancer);
	if (($uintdom ne '') && ($uintdom eq $intdom)) {
	return &reply("delbalcookie:$cookie",$balancer);
	}
	}
	}

# -------------------------------- ask if server already has a session for user	# -------------------------------- ask if server already has a session for user
sub has_user_session {	sub has_user_session {
my ($lonid,$udom,$uname) = @_;	my ($lonid,$udom,$uname) = @_;
Line 1006 sub choose_server {	Line 1117 sub choose_server {
if ($login_host ne '') {	if ($login_host ne '') {
$hostname = &hostname($login_host);	$hostname = &hostname($login_host);
}	}
return ($login_host,$hostname,$portal_path,$isredirect);	return ($login_host,$hostname,$portal_path,$isredirect,$lowest_load);
}	}

# --------------------------------------------- Try to change a user's password	# --------------------------------------------- Try to change a user's password
Line 1173 sub can_host_session {	Line 1284 sub can_host_session {
sub spare_can_host {	sub spare_can_host {
my ($udom,$uint_dom,$remotesessions,$try_server)=@_;	my ($udom,$uint_dom,$remotesessions,$try_server)=@_;
my $canhost=1;	my $canhost=1;
my @intdoms;	my $try_server_hostname = &hostname($try_server);
my $internet_names = &Apache::lonnet::get_internet_names($try_server);	my $serverhomeID = &get_server_homeID($try_server_hostname);
if (ref($internet_names) eq 'ARRAY') {	my $serverhomedom = &host_domain($serverhomeID);
@intdoms = @{$internet_names};	my %defdomdefaults = &get_domain_defaults($serverhomedom);
}	if (ref($defdomdefaults{'offloadnow'}) eq 'HASH') {
unless (grep(/^\Q$uint_dom\E$/,@intdoms)) {	if ($defdomdefaults{'offloadnow'}{$try_server}) {
my $serverhomeID = &Apache::lonnet::get_server_homeID($try_server);	$canhost = 0;
my $serverhomedom = &Apache::lonnet::host_domain($serverhomeID);	}
my %defdomdefaults = &Apache::lonnet::get_domain_defaults($serverhomedom);	}
my $remoterev = &Apache::lonnet::get_server_loncaparev(undef,$try_server);	if (($canhost) && ($uint_dom)) {
$canhost = &can_host_session($udom,$try_server,$remoterev,	my @intdoms;
$remotesessions,	my $internet_names = &get_internet_names($try_server);
$defdomdefaults{'hostedsessions'});	if (ref($internet_names) eq 'ARRAY') {
	@intdoms = @{$internet_names};
	}
	unless (grep(/^\Q$uint_dom\E$/,@intdoms)) {
	my $remoterev = &get_server_loncaparev(undef,$try_server);
	$canhost = &can_host_session($udom,$try_server,$remoterev,
	$remotesessions,
	$defdomdefaults{'hostedsessions'});
	}
}	}
return $canhost;	return $canhost;
}	}
Line 1270 sub get_lonbalancer_config {	Line 1389 sub get_lonbalancer_config {
}	}

sub check_loadbalancing {	sub check_loadbalancing {
my ($uname,$udom) = @_;	my ($uname,$udom,$caller) = @_;
my ($is_balancer,$currtargets,$currrules,$dom_in_use,$homeintdom,	my ($is_balancer,$currtargets,$currrules,$dom_in_use,$homeintdom,
$rule_in_effect,$offloadto,$otherserver);	$rule_in_effect,$offloadto,$otherserver,$setcookie);
my $lonhost = $perlvar{'lonHostID'};	my $lonhost = $perlvar{'lonHostID'};
my @hosts = &current_machine_ids();	my @hosts = &current_machine_ids();
my $uprimary_id = &Apache::lonnet::domain($udom,'primary');	my $uprimary_id = &Apache::lonnet::domain($udom,'primary');
my $uintdom = &Apache::lonnet::internet_dom($uprimary_id);	my $uintdom = &Apache::lonnet::internet_dom($uprimary_id);
my $intdom = &Apache::lonnet::internet_dom($lonhost);	my $intdom = &Apache::lonnet::internet_dom($lonhost);
my $serverhomedom = &host_domain($lonhost);	my $serverhomedom = &host_domain($lonhost);
	my $domneedscache;
my $cachetime = 606024;	my $cachetime = 606024;

if (($uintdom ne '') && ($uintdom eq $intdom)) {	if (($uintdom ne '') && ($uintdom eq $intdom)) {
Line 1294 sub check_loadbalancing {	Line 1413 sub check_loadbalancing {
&Apache::lonnet::get_dom('configuration',['loadbalancing'],$dom_in_use);	&Apache::lonnet::get_dom('configuration',['loadbalancing'],$dom_in_use);
if (ref($domconfig{'loadbalancing'}) eq 'HASH') {	if (ref($domconfig{'loadbalancing'}) eq 'HASH') {
$result = &do_cache_new('loadbalancing',$dom_in_use,$domconfig{'loadbalancing'},$cachetime);	$result = &do_cache_new('loadbalancing',$dom_in_use,$domconfig{'loadbalancing'},$cachetime);
	} else {
	$domneedscache = $dom_in_use;
}	}
}	}
if (ref($result) eq 'HASH') {	if (ref($result) eq 'HASH') {
($is_balancer,$currtargets,$currrules) =	($is_balancer,$currtargets,$currrules,$setcookie) =
&check_balancer_result($result,@hosts);	&check_balancer_result($result,@hosts);
if ($is_balancer) {	if ($is_balancer) {
if (ref($currrules) eq 'HASH') {	if (ref($currrules) eq 'HASH') {
Line 1352 sub check_loadbalancing {	Line 1473 sub check_loadbalancing {
my %domconfig =	my %domconfig =
&Apache::lonnet::get_dom('configuration',['loadbalancing'],$serverhomedom);	&Apache::lonnet::get_dom('configuration',['loadbalancing'],$serverhomedom);
if (ref($domconfig{'loadbalancing'}) eq 'HASH') {	if (ref($domconfig{'loadbalancing'}) eq 'HASH') {
$result = &do_cache_new('loadbalancing',$dom_in_use,$domconfig{'loadbalancing'},$cachetime);	$result = &do_cache_new('loadbalancing',$serverhomedom,$domconfig{'loadbalancing'},$cachetime);
	} else {
	$domneedscache = $serverhomedom;
}	}
}	}
if (ref($result) eq 'HASH') {	if (ref($result) eq 'HASH') {
($is_balancer,$currtargets,$currrules) =	($is_balancer,$currtargets,$currrules,$setcookie) =
&check_balancer_result($result,@hosts);	&check_balancer_result($result,@hosts);
if ($is_balancer) {	if ($is_balancer) {
if (ref($currrules) eq 'HASH') {	if (ref($currrules) eq 'HASH') {
Line 1372 sub check_loadbalancing {	Line 1495 sub check_loadbalancing {
$is_balancer = 1;	$is_balancer = 1;
$offloadto = &this_host_spares($dom_in_use);	$offloadto = &this_host_spares($dom_in_use);
}	}
	unless (defined($cached)) {
	$domneedscache = $serverhomedom;
	}
}	}
} else {	} else {
if ($perlvar{'lonBalancer'} eq 'yes') {	if ($perlvar{'lonBalancer'} eq 'yes') {
$is_balancer = 1;	$is_balancer = 1;
$offloadto = &this_host_spares($dom_in_use);	$offloadto = &this_host_spares($dom_in_use);
}	}
	unless (defined($cached)) {
	$domneedscache = $serverhomedom;
	}
	}
	if ($domneedscache) {
	&do_cache_new('loadbalancing',$domneedscache,$is_balancer,$cachetime);
}	}
if ($is_balancer) {	if ($is_balancer) {
my $lowest_load = 30000;	my $lowest_load = 30000;
Line 1408 sub check_loadbalancing {	Line 1540 sub check_loadbalancing {
}	}
}	}
}	}
if (($otherserver ne '') && (grep(/^\Q$otherserver\E$/,@hosts))) {	unless ($caller eq 'login') {
$is_balancer = 0;	if (($otherserver ne '') && (grep(/^\Q$otherserver\E$/,@hosts))) {
if ($uname ne '' && $udom ne '') {	$is_balancer = 0;
if (($env{'user.name'} eq $uname) && ($env{'user.domain'} eq $udom)) {	if ($uname ne '' && $udom ne '') {
	if (($env{'user.name'} eq $uname) && ($env{'user.domain'} eq $udom)) {
&appenv({'user.loadbalexempt' => $lonhost,	&appenv({'user.loadbalexempt' => $lonhost,
'user.loadbalcheck.time' => time});	'user.loadbalcheck.time' => time});
	}
}	}
}	}
}	}
	unless ($homeintdom) {
	undef($setcookie);
	}
}	}
return ($is_balancer,$otherserver);	return ($is_balancer,$otherserver,$setcookie);
}	}

sub check_balancer_result {	sub check_balancer_result {
my ($result,@hosts) = @_;	my ($result,@hosts) = @_;
my ($is_balancer,$currtargets,$currrules);	my ($is_balancer,$currtargets,$currrules,$setcookie);
if (ref($result) eq 'HASH') {	if (ref($result) eq 'HASH') {
if ($result->{'lonhost'} ne '') {	if ($result->{'lonhost'} ne '') {
my $currbalancer = $result->{'lonhost'};	my $currbalancer = $result->{'lonhost'};
Line 1440 sub check_balancer_result {	Line 1576 sub check_balancer_result {
$is_balancer = 1;	$is_balancer = 1;
$currrules = $result->{$key}{'rules'};	$currrules = $result->{$key}{'rules'};
$currtargets = $result->{$key}{'targets'};	$currtargets = $result->{$key}{'targets'};
	$setcookie = $result->{$key}{'cookie'};
last;	last;
}	}
}	}
}	}
}	}
return ($is_balancer,$currtargets,$currrules);	return ($is_balancer,$currtargets,$currrules,$setcookie);
}	}

sub get_loadbalancer_targets {	sub get_loadbalancer_targets {
Line 1550 sub idget {	Line 1687 sub idget {

my %servers = &get_servers($udom,'library');	my %servers = &get_servers($udom,'library');
foreach my $tryserver (keys(%servers)) {	foreach my $tryserver (keys(%servers)) {
my $idlist=join('&',@ids);	my $idlist=join('&', map { &escape($_); } @ids);
$idlist=~tr/A-Z/a-z/;	$idlist=~tr/A-Z/a-z/;
my $reply=&reply("idget:$udom:".$idlist,$tryserver);	my $reply=&reply("idget:$udom:".$idlist,$tryserver);
my @answer=();	my @answer=();
Line 1560 sub idget {	Line 1697 sub idget {
my $i;	my $i;
for ($i=0;$i<=$#ids;$i++) {	for ($i=0;$i<=$#ids;$i++) {
if ($answer[$i]) {	if ($answer[$i]) {
$returnhash{$ids[$i]}=$answer[$i];	$returnhash{$ids[$i]}=&unescape($answer[$i]);
}	}
}	}
}	}
Line 1789 sub retrieve_inst_usertypes {	Line 1926 sub retrieve_inst_usertypes {

sub is_domainimage {	sub is_domainimage {
my ($url) = @_;	my ($url) = @_;
if ($url=~m-^/+res/+($match_domain)/+\1\-domainconfig/+(img\|logo\|domlogo)/+-) {	if ($url=~m-^/+res/+($match_domain)/+\1\-domainconfig/+(img\|logo\|domlogo)/+[^/]-) {
if (&domain($1) ne '') {	if (&domain($1) ne '') {
return '1';	return '1';
}	}
Line 1810 sub inst_directory_query {	Line 1947 sub inst_directory_query {
&escape($srch->{'srchtype'}),$homeserver);	&escape($srch->{'srchtype'}),$homeserver);
my $host=&hostname($homeserver);	my $host=&hostname($homeserver);
if ($queryid !~/^\Q$host\E\_/) {	if ($queryid !~/^\Q$host\E\_/) {
&logthis('instituional directory search invalid queryid: '.$queryid.' for host: '.$homeserver.'in domain '.$udom);	&logthis('institutional directory search invalid queryid: '.$queryid.' for host: '.$homeserver.' in domain '.$udom);
return;	return;
}	}
my $response = &get_query_reply($queryid);	my $response = &get_query_reply($queryid);
Line 1930 sub get_instuser {	Line 2067 sub get_instuser {
return ($outcome,%userinfo);	return ($outcome,%userinfo);
}	}

	sub get_multiple_instusers {
	my ($udom,$users,$caller) = @_;
	my ($outcome,$results);
	if (ref($users) eq 'HASH') {
	my $count = keys(%{$users});
	my $requested = &freeze_escape($users);
	my $homeserver = &domain($udom,'primary');
	if ($homeserver ne '') {
	my $queryid=&reply('querysend:getmultinstusers:::'.$caller.'='.$requested,$homeserver);
	my $host=&hostname($homeserver);
	if ($queryid !~/^\Q$host\E\_/) {
	&logthis('get_multiple_instusers invalid queryid: '.$queryid.
	' for host: '.$homeserver.'in domain '.$udom);
	return ($outcome,$results);
	}
	my $response = &get_query_reply($queryid);
	my $maxtries = 5;
	if ($count > 100) {
	$maxtries = 1+int($count/20);
	}
	my $tries = 1;
	while (($response=~/^timeout/) && ($tries <= $maxtries)) {
	$response = &get_query_reply($queryid);
	$tries ++;
	}
	if ($response eq '') {
	$results = {};
	foreach my $key (keys(%{$users})) {
	my ($uname,$id);
	if ($caller eq 'id') {
	$id = $key;
	} else {
	$uname = $key;
	}
	my ($resp,%info) = &get_instuser($udom,$uname,$id);
	$outcome = $resp;
	if ($resp eq 'ok') {
	%{$results} = (%{$results}, %info);
	} else {
	last;
	}
	}
	} elsif(!&error($response) && ($response ne 'refused')) {
	if (($response eq 'unavailable') \|\| ($response eq 'invalid') \|\| ($response eq 'timeout')) {
	$outcome = $response;
	} else {
	($outcome,my $userdata) = split(/=/,$response,2);
	if ($outcome eq 'ok') {
	$results = &thaw_unescape($userdata);
	}
	}
	}
	}
	}
	return ($outcome,$results);
	}

sub inst_rulecheck {	sub inst_rulecheck {
my ($udom,$uname,$id,$item,$rules) = @_;	my ($udom,$uname,$id,$item,$rules) = @_;
my %returnhash;	my %returnhash;
Line 2026 sub get_domain_defaults {	Line 2220 sub get_domain_defaults {
'requestcourses','inststatus',	'requestcourses','inststatus',
'coursedefaults','usersessions',	'coursedefaults','usersessions',
'requestauthor','selfenrollment',	'requestauthor','selfenrollment',
'coursecategories'],$domain);	'coursecategories','autoenroll',
	'helpsettings'],$domain);
my @coursetypes = ('official','unofficial','community','textbook');	my @coursetypes = ('official','unofficial','community','textbook');
if (ref($domconfig{'defaults'}) eq 'HASH') {	if (ref($domconfig{'defaults'}) eq 'HASH') {
$domdefaults{'lang_def'} = $domconfig{'defaults'}{'lang_def'};	$domdefaults{'lang_def'} = $domconfig{'defaults'}{'lang_def'};
Line 2035 sub get_domain_defaults {	Line 2230 sub get_domain_defaults {
$domdefaults{'timezone_def'} = $domconfig{'defaults'}{'timezone_def'};	$domdefaults{'timezone_def'} = $domconfig{'defaults'}{'timezone_def'};
$domdefaults{'datelocale_def'} = $domconfig{'defaults'}{'datelocale_def'};	$domdefaults{'datelocale_def'} = $domconfig{'defaults'}{'datelocale_def'};
$domdefaults{'portal_def'} = $domconfig{'defaults'}{'portal_def'};	$domdefaults{'portal_def'} = $domconfig{'defaults'}{'portal_def'};
	$domdefaults{'intauth_cost'} = $domconfig{'defaults'}{'intauth_cost'};
	$domdefaults{'intauth_switch'} = $domconfig{'defaults'}{'intauth_switch'};
	$domdefaults{'intauth_check'} = $domconfig{'defaults'}{'intauth_check'};
} else {	} else {
$domdefaults{'lang_def'} = &domain($domain,'lang_def');	$domdefaults{'lang_def'} = &domain($domain,'lang_def');
$domdefaults{'auth_def'} = &domain($domain,'auth_def');	$domdefaults{'auth_def'} = &domain($domain,'auth_def');
Line 2070 sub get_domain_defaults {	Line 2268 sub get_domain_defaults {
}	}
}	}
if (ref($domconfig{'coursedefaults'}) eq 'HASH') {	if (ref($domconfig{'coursedefaults'}) eq 'HASH') {
	$domdefaults{'usejsme'} = $domconfig{'coursedefaults'}{'usejsme'};
	$domdefaults{'uselcmath'} = $domconfig{'coursedefaults'}{'uselcmath'};
	if (ref($domconfig{'coursedefaults'}{'postsubmit'}) eq 'HASH') {
	$domdefaults{'postsubmit'} = $domconfig{'coursedefaults'}{'postsubmit'}{'client'};
	}
foreach my $type (@coursetypes) {	foreach my $type (@coursetypes) {
if (ref($domconfig{'coursedefaults'}{'coursecredits'}) eq 'HASH') {	if (ref($domconfig{'coursedefaults'}{'coursecredits'}) eq 'HASH') {
unless ($type eq 'community') {	unless ($type eq 'community') {
Line 2079 sub get_domain_defaults {	Line 2282 sub get_domain_defaults {
if (ref($domconfig{'coursedefaults'}{'uploadquota'}) eq 'HASH') {	if (ref($domconfig{'coursedefaults'}{'uploadquota'}) eq 'HASH') {
$domdefaults{$type.'quota'} = $domconfig{'coursedefaults'}{'uploadquota'}{$type};	$domdefaults{$type.'quota'} = $domconfig{'coursedefaults'}{'uploadquota'}{$type};
}	}
	if ($domdefaults{'postsubmit'} eq 'on') {
	if (ref($domconfig{'coursedefaults'}{'postsubmit'}{'timeout'}) eq 'HASH') {
	$domdefaults{$type.'postsubtimeout'} =
	$domconfig{'coursedefaults'}{'postsubmit'}{'timeout'}{$type};
	}
	}
	}
	if (ref($domconfig{'coursedefaults'}{'canclone'}) eq 'HASH') {
	if (ref($domconfig{'coursedefaults'}{'canclone'}{'instcode'}) eq 'ARRAY') {
	my @clonecodes = @{$domconfig{'coursedefaults'}{'canclone'}{'instcode'}};
	if (@clonecodes) {
	$domdefaults{'canclone'} = join('+',@clonecodes);
	}
	}
	} elsif ($domconfig{'coursedefaults'}{'canclone'}) {
	$domdefaults{'canclone'}=$domconfig{'coursedefaults'}{'canclone'};
	}
	if ($domconfig{'coursedefaults'}{'texengine'}) {
	$domdefaults{'texengine'} = $domconfig{'coursedefaults'}{'texengine'};
}	}
}	}
if (ref($domconfig{'usersessions'}) eq 'HASH') {	if (ref($domconfig{'usersessions'}) eq 'HASH') {
Line 2088 sub get_domain_defaults {	Line 2310 sub get_domain_defaults {
if (ref($domconfig{'usersessions'}{'hosted'}) eq 'HASH') {	if (ref($domconfig{'usersessions'}{'hosted'}) eq 'HASH') {
$domdefaults{'hostedsessions'} = $domconfig{'usersessions'}{'hosted'};	$domdefaults{'hostedsessions'} = $domconfig{'usersessions'}{'hosted'};
}	}
	if (ref($domconfig{'usersessions'}{'offloadnow'}) eq 'HASH') {
	$domdefaults{'offloadnow'} = $domconfig{'usersessions'}{'offloadnow'};
	}
}	}
if (ref($domconfig{'selfenrollment'}) eq 'HASH') {	if (ref($domconfig{'selfenrollment'}) eq 'HASH') {
if (ref($domconfig{'selfenrollment'}{'admin'}) eq 'HASH') {	if (ref($domconfig{'selfenrollment'}{'admin'}) eq 'HASH') {
Line 2127 sub get_domain_defaults {	Line 2352 sub get_domain_defaults {
$domdefaults{'catunauth'} = $domconfig{'coursecategories'}{'unauth'};	$domdefaults{'catunauth'} = $domconfig{'coursecategories'}{'unauth'};
}	}
}	}
	if (ref($domconfig{'autoenroll'}) eq 'HASH') {
	$domdefaults{'autofailsafe'} = $domconfig{'autoenroll'}{'autofailsafe'};
	}
	if (ref($domconfig{'helpsettings'}) eq 'HASH') {
	$domdefaults{'submitbugs'} = $domconfig{'helpsettings'}{'submitbugs'};
	if (ref($domconfig{'helpsettings'}{'adhoc'}) eq 'HASH') {
	$domdefaults{'adhocroles'} = $domconfig{'helpsettings'}{'adhoc'};
	}
	}
&do_cache_new('domdefaults',$domain,\%domdefaults,$cachetime);	&do_cache_new('domdefaults',$domain,\%domdefaults,$cachetime);
return %domdefaults;	return %domdefaults;
}	}

	sub get_dom_cats {
	my ($dom) = @_;
	return unless (&domain($dom));
	my ($cats,$cached)=&is_cached_new('cats',$dom);
	unless (defined($cached)) {
	my %domconfig = &get_dom('configuration',['coursecategories'],$dom);
	if (ref($domconfig{'coursecategories'}) eq 'HASH') {
	if (ref($domconfig{'coursecategories'}{'cats'}) eq 'HASH') {
	%{$cats} = %{$domconfig{'coursecategories'}{'cats'}};
	} else {
	$cats = {};
	}
	} else {
	$cats = {};
	}
	&Apache::lonnet::do_cache_new('cats',$dom,$cats,3600);
	}
	return $cats;
	}

	sub get_dom_instcats {
	my ($dom) = @_;
	return unless (&domain($dom));
	my ($instcats,$cached)=&is_cached_new('instcats',$dom);
	unless (defined($cached)) {
	my (%coursecodes,%codes,@codetitles,%cat_titles,%cat_order);
	my $totcodes = &retrieve_instcodes(\%coursecodes,$dom);
	if ($totcodes > 0) {
	my $caller = 'global';
	if (&auto_instcode_format($caller,$dom,\%coursecodes,\%codes,
	\@codetitles,\%cat_titles,\%cat_order) eq 'ok') {
	$instcats = {
	codes => \%codes,
	codetitles => \@codetitles,
	cat_titles => \%cat_titles,
	cat_order => \%cat_order,
	};
	&do_cache_new('instcats',$dom,$instcats,3600);
	}
	}
	}
	return $instcats;
	}

	sub retrieve_instcodes {
	my ($coursecodes,$dom) = @_;
	my $totcodes;
	my %courses = &courseiddump($dom,'.',1,'.','.','.',undef,undef,'Course');
	foreach my $course (keys(%courses)) {
	if (ref($courses{$course}) eq 'HASH') {
	if ($courses{$course}{'inst_code'} ne '') {
	$$coursecodes{$course} = $courses{$course}{'inst_code'};
	$totcodes ++;
	}
	}
	}
	return $totcodes;
	}

# --------------------------------------------------- Assign a key to a student	# --------------------------------------------------- Assign a key to a student

sub assign_access_key {	sub assign_access_key {
Line 2367 sub make_key {	Line 2660 sub make_key {
sub devalidate_cache_new {	sub devalidate_cache_new {
my ($name,$id,$debug) = @_;	my ($name,$id,$debug) = @_;
if ($debug) { &Apache::lonnet::logthis("deleting $name:$id"); }	if ($debug) { &Apache::lonnet::logthis("deleting $name:$id"); }
	my $remembered_id=$name.':'.$id;
$id=&make_key($name,$id);	$id=&make_key($name,$id);
$memcache->delete($id);	$memcache->delete($id);
delete($remembered{$id});	delete($remembered{$remembered_id});
delete($accessed{$id});	delete($accessed{$remembered_id});
}	}

sub is_cached_new {	sub is_cached_new {
my ($name,$id,$debug) = @_;	my ($name,$id,$debug) = @_;
$id=&make_key($name,$id);	my $remembered_id=$name.':'.$id; # this is to avoid make_key (which is slow) for
if (exists($remembered{$id})) {	# keys in %remembered hash, which persists for
if ($debug) { &Apache::lonnet::logthis("Early return $id of $remembered{$id} "); }	# duration of request (no restriction on key length).
$accessed{$id}=[&gettimeofday()];	if (exists($remembered{$remembered_id})) {
	if ($debug) { &Apache::lonnet::logthis("Early return $remembered_id of $remembered{$remembered_id} "); }
	$accessed{$remembered_id}=[&gettimeofday()];
$hits++;	$hits++;
return ($remembered{$id},1);	return ($remembered{$remembered_id},1);
}	}
	$id=&make_key($name,$id);
my $value = $memcache->get($id);	my $value = $memcache->get($id);
if (!(defined($value))) {	if (!(defined($value))) {
if ($debug) { &Apache::lonnet::logthis("getting $id is not defined"); }	if ($debug) { &Apache::lonnet::logthis("getting $id is not defined"); }
Line 2391 sub is_cached_new {	Line 2688 sub is_cached_new {
if ($debug) { &Apache::lonnet::logthis("getting $id is __undef__"); }	if ($debug) { &Apache::lonnet::logthis("getting $id is __undef__"); }
$value=undef;	$value=undef;
}	}
&make_room($id,$value,$debug);	&make_room($remembered_id,$value,$debug);
if ($debug) { &Apache::lonnet::logthis("getting $id is $value"); }	if ($debug) { &Apache::lonnet::logthis("getting $id is $value"); }
return ($value,1);	return ($value,1);
}	}

sub do_cache_new {	sub do_cache_new {
my ($name,$id,$value,$time,$debug) = @_;	my ($name,$id,$value,$time,$debug) = @_;
	my $remembered_id=$name.':'.$id;
$id=&make_key($name,$id);	$id=&make_key($name,$id);
my $setvalue=$value;	my $setvalue=$value;
if (!defined($setvalue)) {	if (!defined($setvalue)) {
Line 2413 sub do_cache_new {	Line 2711 sub do_cache_new {
$memcache->disconnect_all();	$memcache->disconnect_all();
}	}
# need to make a copy of $value	# need to make a copy of $value
&make_room($id,$value,$debug);	&make_room($remembered_id,$value,$debug);
return $value;	return $value;
}	}

sub make_room {	sub make_room {
my ($id,$value,$debug)=@_;	my ($remembered_id,$value,$debug)=@_;

$remembered{$id}= (ref($value)) ? &Storable::dclone($value)	$remembered{$remembered_id}= (ref($value)) ? &Storable::dclone($value)
: $value;	: $value;
if ($to_remember<0) { return; }	if ($to_remember<0) { return; }
$accessed{$id}=[&gettimeofday()];	$accessed{$remembered_id}=[&gettimeofday()];
if (scalar(keys(%remembered)) <= $to_remember) { return; }	if (scalar(keys(%remembered)) <= $to_remember) { return; }
my $to_kick;	my $to_kick;
my $max_time=0;	my $max_time=0;
Line 2710 sub absolute_url {	Line 3008 sub absolute_url {
sub ssi {	sub ssi {

my ($fn,%form)=@_;	my ($fn,%form)=@_;
my $ua=new LWP::UserAgent;	my ($request,$response);
my $request;

$form{'no_update_last_known'}=1;	$form{'no_update_last_known'}=1;
&Apache::lonenc::check_encrypt(\$fn);	&Apache::lonenc::check_encrypt(\$fn);
if (%form) {	if (%form) {
$request=new HTTP::Request('POST',&absolute_url().$fn);	$request=new HTTP::Request('POST',&absolute_url().$fn);
$request->content(join('&',map { &escape($_).'='.&escape($form{$_}) } keys(%form)));	$request->content(join('&',map {
	my $name = escape($_);
	"$name=" . ( ref($form{$_}) eq 'ARRAY'
	? join("&$name=", map {escape($_) } @{$form{$_}})
	: &escape($form{$_}) );
	} keys(%form)));
} else {	} else {
$request=new HTTP::Request('GET',&absolute_url().$fn);	$request=new HTTP::Request('GET',&absolute_url().$fn);
}	}

$request->header(Cookie => $ENV{'HTTP_COOKIE'});	$request->header(Cookie => $ENV{'HTTP_COOKIE'});
my $response= $ua->request($request);
	if (($env{'request.course.id'}) &&
	($form{'grade_courseid'} eq $env{'request.course.id'}) &&
	($form{'grade_username'} ne '') && ($form{'grade_domain'} ne '') &&
	($form{'grade_symb'} ne '') &&
	(&Apache::lonnet::allowed('mgr',$env{'request.course.id'}.
	($env{'request.course.sec'}?'/'.$env{'request.course.sec'}:'')))) {
	if (LWP::UserAgent->VERSION >= 5.834) {
	my $ua=new LWP::UserAgent;
	$ua->local_address('127.0.0.1');
	$response = $ua->request($request);
	} else {
	{
	require LWP::Protocol::http;
	local @LWP::Protocol::http::EXTRA_SOCK_OPTS = (LocalAddr => '127.0.0.1');
	my $ua=new LWP::UserAgent;
	$response = $ua->request($request);
	@LWP::Protocol::http::EXTRA_SOCK_OPTS = ();
	}
	}
	} else {
	my $ua=new LWP::UserAgent;
	$response = $ua->request($request);
	}
if (wantarray) {	if (wantarray) {
return ($response->content, $response);	return ($response->content, $response);
} else {	} else {
Line 2743 sub externalssi {	Line 3068 sub externalssi {
}	}
}	}

	# If the local copy of a replicated resource is outdated, trigger a
	# connection from the homeserver to flush the delayed queue. If no update
	# happens, remove local copies of outdated resource (and corresponding
	# metadata file).

	sub remove_stale_resfile {
	my ($url) = @_;
	my $removed;
	if ($url=~m{^/res/($match_domain)/($match_username)/}) {
	my $audom = $1;
	my $auname = $2;
	unless (($url =~ /\.\d+\.\w+$/) \|\| ($url =~ m{^/res/lib/templates/})) {
	my $homeserver = &homeserver($auname,$audom);
	unless (($homeserver eq 'no_host') \|\|
	(grep { $_ eq $homeserver } &current_machine_ids())) {
	my $fname = &filelocation('',$url);
	if (-e $fname) {
	my $ua=new LWP::UserAgent;
	$ua->timeout(5);
	my $protocol = $protocol{$homeserver};
	$protocol = 'http' if ($protocol ne 'https');
	my $hostname = &hostname($homeserver);
	if ($hostname) {
	my $uri = $protocol.'://'.$hostname.'/raw/'.&declutter($url);
	my $request=new HTTP::Request('HEAD',$uri);
	my $response=$ua->request($request);
	if ($response->is_success()) {
	my $remmodtime = &HTTP::Date::str2time( $response->header('Last-modified') );
	my $locmodtime = (stat($fname))[9];
	if ($locmodtime < $remmodtime) {
	my $stale;
	my $answer = &reply('pong',$homeserver);
	if ($answer eq $homeserver.':'.$perlvar{'lonHostID'}) {
	sleep(0.2);
	$locmodtime = (stat($fname))[9];
	if ($locmodtime < $remmodtime) {
	my $posstransfer = $fname.'.in.transfer';
	if ((-e $posstransfer) && ($remmodtime < (stat($posstransfer))[9])) {
	$removed = 1;
	} else {
	$stale = 1;
	}
	} else {
	$removed = 1;
	}
	} else {
	$stale = 1;
	}
	if ($stale) {
	unlink($fname);
	if ($uri!~/\.meta$/) {
	unlink($fname.'.meta');
	}
	&reply("unsub:$fname",$homeserver);
	$removed = 1;
	}
	}
	}
	}
	}
	}
	}
	}
	return $removed;
	}

# -------------------------------- Allow a /uploaded/ URI to be vouched for	# -------------------------------- Allow a /uploaded/ URI to be vouched for

sub allowuploaded {	sub allowuploaded {
Line 3071 sub process_coursefile {	Line 3462 sub process_coursefile {
$home);	$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') {	if ($parser eq 'parse') {
Line 3129 sub store_edited_file {	Line 3520 sub store_edited_file {
($fpath,$fname) = ($file =~ m\|^(.*)/([^/]+)$\|);	($fpath,$fname) = ($file =~ m\|^(.*)/([^/]+)$\|);
$fpath=$docudom.'/'.$docuname.'/'.$fpath;	$fpath=$docudom.'/'.$docuname.'/'.$fpath;
my $filepath = &build_filepath($fpath);	my $filepath = &build_filepath($fpath);
open(my $fh,'>'.$filepath.'/'.$fname);	open(my $fh,'>',$filepath.'/'.$fname);
print $fh $content;	print $fh $content;
close($fh);	close($fh);
my $home=&homeserver($docuname,$docudom);	my $home=&homeserver($docuname,$docudom);
Line 3245 sub userfileupload {	Line 3636 sub userfileupload {
'_'.$env{'user.domain'}.'/pending';	'_'.$env{'user.domain'}.'/pending';
} elsif (($context eq 'existingfile') \|\| ($context eq 'canceloverwrite')) {	} elsif (($context eq 'existingfile') \|\| ($context eq 'canceloverwrite')) {
my ($docuname,$docudom);	my ($docuname,$docudom);
if ($destudom) {	if ($destudom =~ /^$match_domain$/) {
$docudom = $destudom;	$docudom = $destudom;
} else {	} else {
$docudom = $env{'user.domain'};	$docudom = $env{'user.domain'};
}	}
if ($destuname) {	if ($destuname =~ /^$match_username$/) {
$docuname = $destuname;	$docuname = $destuname;
} else {	} else {
$docuname = $env{'user.name'};	$docuname = $env{'user.name'};
Line 3280 sub userfileupload {	Line 3671 sub userfileupload {
mkdir($fullpath,0777);	mkdir($fullpath,0777);
}	}
}	}
open(my $fh,'>'.$fullpath.'/'.$fname);	open(my $fh,'>',$fullpath.'/'.$fname);
print $fh $env{'form.'.$formname};	print $fh $env{'form.'.$formname};
close($fh);	close($fh);
if ($context eq 'existingfile') {	if ($context eq 'existingfile') {
Line 3355 sub finishuserfileupload {	Line 3746 sub finishuserfileupload {

# Save the file	# Save the file
{	{
if (!open(FH,'>'.$filepath.'/'.$file)) {	if (!open(FH,'>',$filepath.'/'.$file)) {
&logthis('Failed to create '.$filepath.'/'.$file);	&logthis('Failed to create '.$filepath.'/'.$file);
print STDERR ('Failed to create '.$filepath.'/'.$file."\n");	print STDERR ('Failed to create '.$filepath.'/'.$file."\n");
return '/adm/notfound.html';	return '/adm/notfound.html';
Line 3413 sub finishuserfileupload {	Line 3804 sub finishuserfileupload {
my $input = $filepath.'/'.$file;	my $input = $filepath.'/'.$file;
my $output = $filepath.'/'.'tn-'.$file;	my $output = $filepath.'/'.'tn-'.$file;
my $thumbsize = $thumbwidth.'x'.$thumbheight;	my $thumbsize = $thumbwidth.'x'.$thumbheight;
system("convert -sample $thumbsize $input $output");	my @args = ('convert','-sample',$thumbsize,$input,$output);
	system({$args[0]} @args);
if (-e $filepath.'/'.'tn-'.$file) {	if (-e $filepath.'/'.'tn-'.$file) {
$fetchthumb = 1;	$fetchthumb = 1;
}	}
Line 3797 sub flushcourselogs {	Line 4189 sub flushcourselogs {
}	}
}	}
#	#
# Reverse lookup of domain roles (dc, ad, li, sc, au)	# Reverse lookup of domain roles (dc, ad, li, sc, dh, da, au)
#	#
my %domrolebuffer = ();	my %domrolebuffer = ();
foreach my $entry (keys(%domainrolehash)) {	foreach my $entry (keys(%domainrolehash)) {
Line 3812 sub flushcourselogs {	Line 4204 sub flushcourselogs {
delete $domainrolehash{$entry};	delete $domainrolehash{$entry};
}	}
foreach my $dom (keys(%domrolebuffer)) {	foreach my $dom (keys(%domrolebuffer)) {
my %servers = &get_servers($dom,'library');	my %servers;
	if (defined(&domain($dom,'primary'))) {
	my $primary=&domain($dom,'primary');
	my $hostname=&hostname($primary);
	$servers{$primary} = $hostname;
	} else {
	%servers = &get_servers($dom,'library');
	}
foreach my $tryserver (keys(%servers)) {	foreach my $tryserver (keys(%servers)) {
unless (&reply('domroleput:'.$dom.':'.	if (&reply('domroleput:'.$dom.':'.
$domrolebuffer{$dom},$tryserver) eq 'ok') {	$domrolebuffer{$dom},$tryserver) eq 'ok') {
	last;
	} else {
&logthis('Put of domain roles failed for '.$dom.' and '.$tryserver);	&logthis('Put of domain roles failed for '.$dom.' and '.$tryserver);
}	}
}	}
Line 3935 sub userrolelog {	Line 4336 sub userrolelog {
{$trole.':'.$username.':'.$domain.':'.$env{'user.name'}.':'.$env{'user.domain'}.':'}	{$trole.':'.$username.':'.$domain.':'.$env{'user.name'}.':'.$env{'user.domain'}.':'}
=$tend.':'.$tstart;	=$tend.':'.$tstart;
}	}
if ($trole =~ /^(dc\|ad\|li\|au\|dg\|sc)/ ) {	if ($trole =~ /^(dc\|ad\|li\|au\|dg\|sc\|dh\|da)/ ) {
my (undef,$rudom,$runame,$rsec)=split(/\//,$area);	my (undef,$rudom,$runame,$rsec)=split(/\//,$area);
$domainrolehash	$domainrolehash
{$trole.':'.$username.':'.$domain.':'.$runame.':'.$rudom.':'.$rsec}	{$trole.':'.$username.':'.$domain.':'.$runame.':'.$rudom.':'.$rsec}
Line 4162 sub get_my_roles {	Line 4563 sub get_my_roles {
return %returnhash;	return %returnhash;
}	}

	sub get_all_adhocroles {
	my ($dom) = @_;
	my @roles_by_num = ();
	my %domdefaults = &get_domain_defaults($dom);
	my (%description,%access_in_dom,%access_info);
	if (ref($domdefaults{'adhocroles'}) eq 'HASH') {
	my $count = 0;
	my %domcurrent = %{$domdefaults{'adhocroles'}};
	my %ordered;
	foreach my $role (sort(keys(%domcurrent))) {
	my ($order,$desc,$access_in_dom);
	if (ref($domcurrent{$role}) eq 'HASH') {
	$order = $domcurrent{$role}{'order'};
	$desc = $domcurrent{$role}{'desc'};
	$access_in_dom{$role} = $domcurrent{$role}{'access'};
	$access_info{$role} = $domcurrent{$role}{$access_in_dom{$role}};
	}
	if ($order eq '') {
	$order = $count;
	}
	$ordered{$order} = $role;
	if ($desc ne '') {
	$description{$role} = $desc;
	} else {
	$description{$role}= $role;
	}
	$count++;
	}
	foreach my $item (sort {$a <=> $b } (keys(%ordered))) {
	push(@roles_by_num,$ordered{$item});
	}
	}
	return (\@roles_by_num,\%description,\%access_in_dom,\%access_info);
	}

	sub get_my_adhocroles {
	my ($cid,$checkreg) = @_;
	my ($cdom,$cnum,%info,@possroles,$description,$roles_by_num);
	if ($env{'request.course.id'} eq $cid) {
	$cdom = $env{'course.'.$cid.'.domain'};
	$cnum = $env{'course.'.$cid.'.num'};
	$info{'internal.coursecode'} = $env{'course.'.$cid.'.internal.coursecode'};
	} elsif ($cid =~ /^($match_domain)_($match_courseid)$/) {
	$cdom = $1;
	$cnum = $2;
	%info = &Apache::lonnet::get('environment',['internal.coursecode'],
	$cdom,$cnum);
	}
	if (($info{'internal.coursecode'} ne '') && ($checkreg)) {
	my $user = $env{'user.name'}.':'.$env{'user.domain'};
	my %rosterhash = &get('classlist',[$user],$cdom,$cnum);
	if ($rosterhash{$user} ne '') {
	my $type = (split(/:/,$rosterhash{$user}))[5];
	return ([],{}) if ($type eq 'auto');
	}
	}
	if (($cdom ne '') && ($cnum ne '')) {
	if (($env{"user.role.dh./$cdom/"}) \|\| ($env{"user.role.da./$cdom/"})) {
	my $then=$env{'user.login.time'};
	my $update=$env{'user.update.time'};
	if (!$update) {
	$update = $then;
	}
	my @liveroles;
	foreach my $role ('dh','da') {
	if ($env{"user.role.$role./$cdom/"}) {
	my ($tstart,$tend)=split(/\./,$env{"user.role.$role./$cdom/"});
	my $limit = $update;
	if ($env{'request.role'} eq "$role./$cdom/") {
	$limit = $then;
	}
	my $activerole = 1;
	if ($tstart && $tstart>$limit) { $activerole = 0; }
	if ($tend && $tend <$limit) { $activerole = 0; }
	if ($activerole) {
	push(@liveroles,$role);
	}
	}
	}
	if (@liveroles) {
	if (&homeserver($cnum,$cdom) ne 'no_host') {
	my ($accessref,$accessinfo,%access_in_dom);
	($roles_by_num,$description,$accessref,$accessinfo) = &get_all_adhocroles($cdom);
	if (ref($roles_by_num) eq 'ARRAY') {
	if (@{$roles_by_num}) {
	my %settings;
	if ($env{'request.course.id'} eq $cid) {
	foreach my $envkey (keys(%env)) {
	if ($envkey =~ /^\Qcourse.$cid.\E(internal\.adhoc.+)$/) {
	$settings{$1} = $env{$envkey};
	}
	}
	} else {
	%settings = &dump('environment',$cdom,$cnum,'internal\.adhoc');
	}
	my %setincrs;
	if ($settings{'internal.adhocaccess'}) {
	map { $setincrs{$_} = 1; } split(/,/,$settings{'internal.adhocaccess'});
	}
	my @statuses;
	if ($env{'environment.inststatus'}) {
	@statuses = split(/,/,$env{'environment.inststatus'});
	}
	my $user = $env{'user.name'}.':'.$env{'user.domain'};
	if (ref($accessref) eq 'HASH') {
	%access_in_dom = %{$accessref};
	}
	foreach my $role (@{$roles_by_num}) {
	my ($curraccess,@okstatus,@personnel);
	if ($setincrs{$role}) {
	($curraccess,my $rest) = split(/=/,$settings{'internal.adhoc.'.$role});
	if ($curraccess eq 'status') {
	@okstatus = split(/\&/,$rest);
	} elsif (($curraccess eq 'exc') \|\| ($curraccess eq 'inc')) {
	@personnel = split(/\&/,$rest);
	}
	} else {
	$curraccess = $access_in_dom{$role};
	if (ref($accessinfo) eq 'HASH') {
	if ($curraccess eq 'status') {
	if (ref($accessinfo->{$role}) eq 'ARRAY') {
	@okstatus = @{$accessinfo->{$role}};
	}
	} elsif (($curraccess eq 'exc') \|\| ($curraccess eq 'inc')) {
	if (ref($accessinfo->{$role}) eq 'ARRAY') {
	@personnel = @{$accessinfo->{$role}};
	}
	}
	}
	}
	if ($curraccess eq 'none') {
	next;
	} elsif ($curraccess eq 'all') {
	push(@possroles,$role);
	} elsif ($curraccess eq 'dh') {
	if (grep(/^dh$/,@liveroles)) {
	push(@possroles,$role);
	} else {
	next;
	}
	} elsif ($curraccess eq 'da') {
	if (grep(/^da$/,@liveroles)) {
	push(@possroles,$role);
	} else {
	next;
	}
	} elsif ($curraccess eq 'status') {
	if (@okstatus) {
	if (!@statuses) {
	if (grep(/^default$/,@okstatus)) {
	push(@possroles,$role);
	}
	} else {
	foreach my $status (@okstatus) {
	if (grep(/^\Q$status\E$/,@statuses)) {
	push(@possroles,$role);
	last;
	}
	}
	}
	}
	} elsif (($curraccess eq 'exc') \|\| ($curraccess eq 'inc')) {
	if (grep(/^\Q$user\E$/,@personnel)) {
	if ($curraccess eq 'exc') {
	push(@possroles,$role);
	}
	} elsif ($curraccess eq 'inc') {
	push(@possroles,$role);
	}
	}
	}
	}
	}
	}
	}
	}
	}
	unless (ref($description) eq 'HASH') {
	if (ref($roles_by_num) eq 'ARRAY') {
	my %desc;
	map { $desc{$_} = $_; } (@{$roles_by_num});
	$description = \%desc;
	} else {
	$description = {};
	}
	}
	return (\@possroles,$description);
	}

# ----------------------------------------------------- Frontpage Announcements	# ----------------------------------------------------- Frontpage Announcements
#	#
#	#
Line 4175 sub postannounce {	Line 4765 sub postannounce {

sub getannounce {	sub getannounce {

if (open(my $fh,$perlvar{'lonDocRoot'}.'/announcement.txt')) {	if (open(my $fh,"<",$perlvar{'lonDocRoot'}.'/announcement.txt')) {
my $announcement='';	my $announcement='';
while (my $line = <$fh>) { $announcement .= $line; }	while (my $line = <$fh>) { $announcement .= $line; }
close($fh);	close($fh);
Line 4238 sub courseiddump {	Line 4828 sub courseiddump {
$coursefilter,$hostidflag,$hostidref,$typefilter,$regexp_ok,	$coursefilter,$hostidflag,$hostidref,$typefilter,$regexp_ok,
$selfenrollonly,$catfilter,$showhidden,$caller,$cloner,$cc_clone,	$selfenrollonly,$catfilter,$showhidden,$caller,$cloner,$cc_clone,
$cloneonly,$createdbefore,$createdafter,$creationcontext,$domcloner,	$cloneonly,$createdbefore,$createdafter,$creationcontext,$domcloner,
$hasuniquecode)=@_;	$hasuniquecode,$reqcrsdom,$reqinstcode)=@_;
my $as_hash = 1;	my $as_hash = 1;
my %returnhash;	my %returnhash;
if (!$domfilter) { $domfilter=''; }	if (!$domfilter) { $domfilter=''; }
Line 4261 sub courseiddump {	Line 4851 sub courseiddump {
&escape($catfilter), $showhidden, $caller,	&escape($catfilter), $showhidden, $caller,
&escape($cloner), &escape($cc_clone), $cloneonly,	&escape($cloner), &escape($cc_clone), $cloneonly,
&escape($createdbefore), &escape($createdafter),	&escape($createdbefore), &escape($createdafter),
&escape($creationcontext), $domcloner, $hasuniquecode)));	&escape($creationcontext),$domcloner,$hasuniquecode,
	$reqcrsdom,&escape($reqinstcode))));
} else {	} else {
$rep = &reply('courseiddump:'.&host_domain($tryserver).':'.	$rep = &reply('courseiddump:'.&host_domain($tryserver).':'.
$sincefilter.':'.&escape($descfilter).':'.	$sincefilter.':'.&escape($descfilter).':'.
Line 4272 sub courseiddump {	Line 4863 sub courseiddump {
$showhidden.':'.$caller.':'.&escape($cloner).':'.	$showhidden.':'.$caller.':'.&escape($cloner).':'.
&escape($cc_clone).':'.$cloneonly.':'.	&escape($cc_clone).':'.$cloneonly.':'.
&escape($createdbefore).':'.&escape($createdafter).':'.	&escape($createdbefore).':'.&escape($createdafter).':'.
&escape($creationcontext).':'.$domcloner.':'.$hasuniquecode,	&escape($creationcontext).':'.$domcloner.':'.$hasuniquecode.
$tryserver);	':'.$reqcrsdom.':'.&escape($reqinstcode),$tryserver);
}	}

my @pairs=split(/\&/,$rep);	my @pairs=split(/\&/,$rep);
Line 4401 sub get_domain_roles {	Line 4992 sub get_domain_roles {
return %personnel;	return %personnel;
}	}

	sub get_active_domroles {
	my ($dom,$roles) = @_;
	return () unless (ref($roles) eq 'ARRAY');
	my $now = time;
	my %dompersonnel = &get_domain_roles($dom,$roles,$now,$now);
	my %domroles;
	foreach my $server (keys(%dompersonnel)) {
	foreach my $user (sort(keys(%{$dompersonnel{$server}}))) {
	my ($trole,$uname,$udom,$runame,$rudom,$rsec) = split(/:/,$user);
	$domroles{$uname.':'.$udom} = $dompersonnel{$server}{$user};
	}
	}
	return %domroles;
	}

# ----------------------------------------------------------- Interval timing	# ----------------------------------------------------------- Interval timing

{	{
Line 4412 my $cachedkey='';	Line 5018 my $cachedkey='';
# The cached times for this user	# The cached times for this user
my %cachedtimes=();	my %cachedtimes=();
# When this was last done	# When this was last done
my $cachedtime=();	my $cachedtime='';

sub load_all_first_access {	sub load_all_first_access {
my ($uname,$udom)=@_;	my ($uname,$udom)=@_;
Line 4455 sub set_first_access {	Line 5061 sub set_first_access {
}	}
$cachedkey='';	$cachedkey='';
my $firstaccess=&get_first_access($type,$symb,$map);	my $firstaccess=&get_first_access($type,$symb,$map);
if (!$firstaccess) {	if ($firstaccess) {
	&logthis("First access time already set ($firstaccess) when attempting ".
	"to set new value (type: $type, extent: $res) for $uname:$udom ".
	"in $courseid");
	return 'already_set';
	} else {
my $start = time;	my $start = time;
my $putres = &put('firstaccesstimes',{"$courseid\0$res"=>$start},	my $putres = &put('firstaccesstimes',{"$courseid\0$res"=>$start},
$udom,$uname);	$udom,$uname);
Line 4468 sub set_first_access {	Line 5079 sub set_first_access {
'course.'.$courseid.'.timerinterval.'.$res => $interval,	'course.'.$courseid.'.timerinterval.'.$res => $interval,
}	}
);	);
	if (($cachedtime) && (abs($start-$cachedtime) < 5)) {
	$cachedtimes{"$courseid\0$res"} = $start;
	}
	} elsif ($putres ne 'refused') {
	&logthis("Result: $putres when attempting to set first access time ".
	"(type: $type, extent: $res) for $uname:$udom in $courseid");
}	}
return $putres;	return $putres;
}	}
Line 4930 sub tmprestore {	Line 5547 sub tmprestore {
# ----------------------------------------------------------------------- Store	# ----------------------------------------------------------------------- Store

sub store {	sub store {
my ($storehash,$symb,$namespace,$domain,$stuname) = @_;	my ($storehash,$symb,$namespace,$domain,$stuname,$laststore) = @_;
my $home='';	my $home='';

if ($stuname) { $home=&homeserver($stuname,$domain); }	if ($stuname) { $home=&homeserver($stuname,$domain); }
Line 4960 sub store {	Line 5577 sub store {
}	}
$namevalue=~s/\&$//;	$namevalue=~s/\&$//;
&courselog($symb.':'.$stuname.':'.$domain.':STORE:'.$namevalue);	&courselog($symb.':'.$stuname.':'.$domain.':STORE:'.$namevalue);
return reply("store:$domain:$stuname:$namespace:$symb:$namevalue","$home");	return reply("store:$domain:$stuname:$namespace:$symb:$namevalue:$laststore","$home");
}	}

# -------------------------------------------------------------- Critical Store	# -------------------------------------------------------------- Critical Store

sub cstore {	sub cstore {
my ($storehash,$symb,$namespace,$domain,$stuname) = @_;	my ($storehash,$symb,$namespace,$domain,$stuname,$laststore) = @_;
my $home='';	my $home='';

if ($stuname) { $home=&homeserver($stuname,$domain); }	if ($stuname) { $home=&homeserver($stuname,$domain); }
Line 4997 sub cstore {	Line 5614 sub cstore {
$namevalue=~s/\&$//;	$namevalue=~s/\&$//;
&courselog($symb.':'.$stuname.':'.$domain.':CSTORE:'.$namevalue);	&courselog($symb.':'.$stuname.':'.$domain.':CSTORE:'.$namevalue);
return critical	return critical
("store:$domain:$stuname:$namespace:$symb:$namevalue","$home");	("store:$domain:$stuname:$namespace:$symb:$namevalue:$laststore","$home");
}	}

# --------------------------------------------------------------------- Restore	# --------------------------------------------------------------------- Restore
Line 5177 sub privileged {	Line 5794 sub privileged {
my %rolesdump = &dump("roles", $domain, $username) or return 0;	my %rolesdump = &dump("roles", $domain, $username) or return 0;
my $now = time;	my $now = time;

for my $role (@rolesdump{grep { ! /^rolesdef_/ } keys %rolesdump}) {	for my $role (@rolesdump{grep { ! /^rolesdef_/ } keys(%rolesdump)}) {
my ($trole, $tend, $tstart) = split(/_/, $role);	my ($trole, $tend, $tstart) = split(/_/, $role);
if (grep(/^\Q$trole\E$/,@{$roles})) {	if (grep(/^\Q$trole\E$/,@{$roles})) {
return 1 unless ($tend && $tend < $now)	return 1 unless ($tend && $tend < $now)
Line 5266 sub rolesinit {	Line 5883 sub rolesinit {
my %allroles=();	my %allroles=();
my %allgroups=();	my %allgroups=();

for my $area (grep { ! /^rolesdef_/ } keys %rolesdump) {	for my $area (grep { ! /^rolesdef_/ } keys(%rolesdump)) {
my $role = $rolesdump{$area};	my $role = $rolesdump{$area};
$area =~ s/\_\w\w$//;	$area =~ s/\_\w\w$//;

Line 5339 sub rolesinit {	Line 5956 sub rolesinit {
}	}
}	}

@userroles{'user.author', 'user.adv'} = &set_userprivs(\%userroles,	@userroles{'user.author','user.adv','user.rar'} = &set_userprivs(\%userroles,
\%allroles, \%allgroups);	\%allroles, \%allgroups);
$env{'user.adv'} = $userroles{'user.adv'};	$env{'user.adv'} = $userroles{'user.adv'};
	$env{'user.rar'} = $userroles{'user.rar'};

return (\%userroles,\%firstaccenv,\%timerintenv);	return (\%userroles,\%firstaccenv,\%timerintenv);
}	}
Line 5377 sub custom_roleprivs {	Line 5995 sub custom_roleprivs {
$$allroles{$spec.'./'.$tdomain.'/'}.=':'.$dompriv;	$$allroles{$spec.'./'.$tdomain.'/'}.=':'.$dompriv;
}	}
if (($trest ne '') && (defined($coursepriv))) {	if (($trest ne '') && (defined($coursepriv))) {
	if ($trole =~ m{^cr/$tdomain/$tdomain\Q-domainconfig\E/([^/]+)$}) {
	my $rolename = $1;
	$coursepriv = &course_adhocrole_privs($rolename,$tdomain,$trest,$coursepriv);
	}
$$allroles{'cm.'.$area}.=':'.$coursepriv;	$$allroles{'cm.'.$area}.=':'.$coursepriv;
$$allroles{$spec.'.'.$area}.=':'.$coursepriv;	$$allroles{$spec.'.'.$area}.=':'.$coursepriv;
}	}
Line 5385 sub custom_roleprivs {	Line 6007 sub custom_roleprivs {
}	}
}	}

	sub course_adhocrole_privs {
	my ($rolename,$cdom,$cnum,$coursepriv) = @_;
	my %overrides = &get('environment',["internal.adhocpriv.$rolename"],$cdom,$cnum);
	if ($overrides{"internal.adhocpriv.$rolename"}) {
	my (%currprivs,%storeprivs);
	foreach my $item (split(/:/,$coursepriv)) {
	my ($priv,$restrict) = split(/\&/,$item);
	$currprivs{$priv} = $restrict;
	}
	my (%possadd,%possremove,%full);
	foreach my $item (split(/\:/,$Apache::lonnet::pr{'cr:c'})) {
	my ($priv,$restrict)=split(/\&/,$item);
	$full{$priv} = $restrict;
	}
	foreach my $item (split(/,/,$overrides{"internal.adhocpriv.$rolename"})) {
	next if ($item eq '');
	my ($rule,$rest) = split(/=/,$item);
	next unless (($rule eq 'off') \|\| ($rule eq 'on'));
	foreach my $priv (split(/:/,$rest)) {
	if ($priv ne '') {
	if ($rule eq 'off') {
	$possremove{$priv} = 1;
	} else {
	$possadd{$priv} = 1;
	}
	}
	}
	}
	foreach my $priv (sort(keys(%full))) {
	if (exists($currprivs{$priv})) {
	unless (exists($possremove{$priv})) {
	$storeprivs{$priv} = $currprivs{$priv};
	}
	} elsif (exists($possadd{$priv})) {
	$storeprivs{$priv} = $full{$priv};
	}
	}
	$coursepriv = ':'.join(':',map { $_.'&'.$storeprivs{$_}; } sort(keys(%storeprivs)));
	}
	return $coursepriv;
	}

sub group_roleprivs {	sub group_roleprivs {
my ($allgroups,$area,$group_privs,$tend,$tstart) = @_;	my ($allgroups,$area,$group_privs,$tend,$tstart) = @_;
my $access = 1;	my $access = 1;
Line 5419 sub set_userprivs {	Line 6083 sub set_userprivs {
my ($userroles,$allroles,$allgroups,$groups_roles) = @_;	my ($userroles,$allroles,$allgroups,$groups_roles) = @_;
my $author=0;	my $author=0;
my $adv=0;	my $adv=0;
	my $rar=0;
my %grouproles = ();	my %grouproles = ();
if (keys(%{$allgroups}) > 0) {	if (keys(%{$allgroups}) > 0) {
my @groupkeys;	my @groupkeys;
Line 5466 sub set_userprivs {	Line 6131 sub set_userprivs {
$thesepriv{$privilege}.=$restrictions;	$thesepriv{$privilege}.=$restrictions;
}	}
if ($thesepriv{'adv'} eq 'F') { $adv=1; }	if ($thesepriv{'adv'} eq 'F') { $adv=1; }
	if ($thesepriv{'rar'} eq 'F') { $rar=1; }
}	}
}	}
my $thesestr='';	my $thesestr='';
Line 5474 sub set_userprivs {	Line 6140 sub set_userprivs {
}	}
$userroles->{'user.priv.'.$role} = $thesestr;	$userroles->{'user.priv.'.$role} = $thesestr;
}	}
return ($author,$adv);	return ($author,$adv,$rar);
}	}

sub role_status {	sub role_status {
Line 5519 sub role_status {	Line 6185 sub role_status {
push(@rolecodes,$$role);	push(@rolecodes,$$role);
&standard_roleprivs(\%allroles,$$role,$tdomain,$spec,$trest,$$where);	&standard_roleprivs(\%allroles,$$role,$tdomain,$spec,$trest,$$where);
}	}
my ($author,$adv)= &set_userprivs(\%userroles,\%allroles,\%allgroups,\%groups_roles);	my ($author,$adv,$rar)= &set_userprivs(\%userroles,\%allroles,\%allgroups,
	\%groups_roles);
&appenv(\%userroles,\@rolecodes);	&appenv(\%userroles,\@rolecodes);
&log($env{'user.domain'},$env{'user.name'},$env{'user.home'},"Role ".$role);	&log($env{'user.domain'},$env{'user.name'},$env{'user.home'},"Role ".$spec);
}	}
}	}
$$tstatus = 'is';	$$tstatus = 'is';
Line 5597 sub delete_env_groupprivs {	Line 6264 sub delete_env_groupprivs {
}	}

sub check_adhoc_privs {	sub check_adhoc_privs {
my ($cdom,$cnum,$update,$refresh,$now,$checkrole,$caller) = @_;	my ($cdom,$cnum,$update,$refresh,$now,$checkrole,$caller,$sec) = @_;
my $cckey = 'user.role.'.$checkrole.'./'.$cdom.'/'.$cnum;	my $cckey = 'user.role.'.$checkrole.'./'.$cdom.'/'.$cnum;
	if ($sec) {
	$cckey .= '/'.$sec;
	}
my $setprivs;	my $setprivs;
if ($env{$cckey}) {	if ($env{$cckey}) {
my ($role,$where,$trolecode,$tstart,$tend,$tremark,$tstatus,$tpstart,$tpend);	my ($role,$where,$trolecode,$tstart,$tend,$tremark,$tstatus,$tpstart,$tpend);
&role_status($cckey,$update,$refresh,$now,\$role,\$where,\$trolecode,\$tstatus,\$tstart,\$tend);	&role_status($cckey,$update,$refresh,$now,\$role,\$where,\$trolecode,\$tstatus,\$tstart,\$tend);
unless (($tstatus eq 'is') \|\| ($tstatus eq 'will_not')) {	unless (($tstatus eq 'is') \|\| ($tstatus eq 'will_not')) {
&set_adhoc_privileges($cdom,$cnum,$checkrole,$caller);	&set_adhoc_privileges($cdom,$cnum,$checkrole,$caller,$sec);
$setprivs = 1;	$setprivs = 1;
}	}
} else {	} else {
&set_adhoc_privileges($cdom,$cnum,$checkrole,$caller);	&set_adhoc_privileges($cdom,$cnum,$checkrole,$caller,$sec);
$setprivs = 1;	$setprivs = 1;
}	}
return $setprivs;	return $setprivs;
}	}

sub set_adhoc_privileges {	sub set_adhoc_privileges {
# role can be cc or ca	# role can be cc, ca, or cr/<dom>/<dom>-domainconfig/role
my ($dcdom,$pickedcourse,$role,$caller) = @_;	my ($dcdom,$pickedcourse,$role,$caller,$sec) = @_;
my $area = '/'.$dcdom.'/'.$pickedcourse;	my $area = '/'.$dcdom.'/'.$pickedcourse;
	if ($sec ne '') {
	$area .= '/'.$sec;
	}
my $spec = $role.'.'.$area;	my $spec = $role.'.'.$area;
my %userroles = &set_arearole($role,$area,'','',$env{'user.domain'},	my %userroles = &set_arearole($role,$area,'','',$env{'user.domain'},
$env{'user.name'},1);	$env{'user.name'},1);
my %ccrole = ();	my %rolehash = ();
&standard_roleprivs(\%ccrole,$role,$dcdom,$spec,$pickedcourse,$area);	if ($role =~ m{^\Qcr/$dcdom/$dcdom\E\-domainconfig/(\w+)$}) {
my ($author,$adv)= &set_userprivs(\%userroles,\%ccrole);	my $rolename = $1;
	&custom_roleprivs(\%rolehash,$role,$dcdom,$pickedcourse,$spec,$area);
	my %domdef = &get_domain_defaults($dcdom);
	if (ref($domdef{'adhocroles'}) eq 'HASH') {
	if (ref($domdef{'adhocroles'}{$rolename}) eq 'HASH') {
	&appenv({'request.role.desc' => $domdef{'adhocroles'}{$rolename}{'desc'},});
	}
	}
	} else {
	&standard_roleprivs(\%rolehash,$role,$dcdom,$spec,$pickedcourse,$area);
	}
	my ($author,$adv,$rar)= &set_userprivs(\%userroles,\%rolehash);
&appenv(\%userroles,[$role,'cm']);	&appenv(\%userroles,[$role,'cm']);
&log($env{'user.domain'},$env{'user.name'},$env{'user.home'},"Role ".$role);	&log($env{'user.domain'},$env{'user.name'},$env{'user.home'},"Role ".$spec);
unless ($caller eq 'constructaccess' && $env{'request.course.id'}) {	unless ($caller eq 'constructaccess' && $env{'request.course.id'}) {
&appenv( {'request.role' => $spec,	&appenv( {'request.role' => $spec,
'request.role.domain' => $dcdom,	'request.role.domain' => $dcdom,
'request.course.sec' => ''	'request.course.sec' => $sec,
}	}
);	);
my $tadv=0;	my $tadv=0;
Line 5893 sub newput {	Line 6577 sub newput {
# --------------------------------------------------------- putstore interface	# --------------------------------------------------------- putstore interface

sub putstore {	sub putstore {
my ($namespace,$symb,$version,$storehash,$udomain,$uname)=@_;	my ($namespace,$symb,$version,$storehash,$udomain,$uname,$tolog)=@_;
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 5907 sub putstore {	Line 6591 sub putstore {
my $reply =	my $reply =
&reply("putstore:$udomain:$uname:$namespace:$esc_symb:$esc_v:$items",	&reply("putstore:$udomain:$uname:$namespace:$esc_symb:$esc_v:$items",
$uhome);	$uhome);
	if (($tolog) && ($reply eq 'ok')) {
	my $namevalue='';
	foreach my $key (keys(%{$storehash})) {
	$namevalue.=&escape($key).'='.&freeze_escape($storehash->{$key}).'&';
	}
	$namevalue .= 'ip='.&escape($ENV{'REMOTE_ADDR'}).
	'&host='.&escape($perlvar{'lonHostID'}).
	'&version='.$esc_v.
	'&by='.&escape($env{'user.name'}.':'.$env{'user.domain'});
	&Apache::lonnet::courselog($symb.':'.$uname.':'.$udomain.':PUTSTORE:'.$namevalue);
	}
if ($reply eq 'unknown_cmd') {	if ($reply eq 'unknown_cmd') {
# gfall back to way things use to be done	# gfall back to way things use to be done
return &old_putstore($namespace,$symb,$version,$storehash,$udomain,	return &old_putstore($namespace,$symb,$version,$storehash,$udomain,
Line 6000 sub tmpget {	Line 6695 sub tmpget {
if (!defined($server)) { $server = $perlvar{'lonHostID'}; }	if (!defined($server)) { $server = $perlvar{'lonHostID'}; }
my $rep=&reply("tmpget:$token",$server);	my $rep=&reply("tmpget:$token",$server);
my %returnhash;	my %returnhash;
	if ($rep =~ /^(con_lost\|error\|no_such_host)/i) {
	return %returnhash;
	}
foreach my $item (split(/\&/,$rep)) {	foreach my $item (split(/\&/,$rep)) {
my ($key,$value)=split(/=/,$item);	my ($key,$value)=split(/=/,$item);
next if ($key =~ /^error: 2 /);
$returnhash{&unescape($key)}=&thaw_unescape($value);	$returnhash{&unescape($key)}=&thaw_unescape($value);
}	}
return %returnhash;	return %returnhash;
Line 6099 sub get_timebased_id {	Line 6796 sub get_timebased_id {
} else {	} else {
$error = "error: could not obtain lockfile\n";	$error = "error: could not obtain lockfile\n";
$dellock = 'ok';	$dellock = 'ok';
	if (($prefix eq 'paste') && ($namespace eq 'courseeditor') && ($keyid eq 'num')) {
	$dellock = 'nolock';
	}
}	}
return ($newid,$dellock,$error);	return ($newid,$dellock,$error);
}	}
Line 6114 sub sixnum_code {	Line 6814 sub sixnum_code {
# -------------------------------------------------- portfolio access checking	# -------------------------------------------------- portfolio access checking

sub portfolio_access {	sub portfolio_access {
my ($requrl) = @_;	my ($requrl,$clientip) = @_;
my (undef,$udom,$unum,$file_name,$group) = &parse_portfolio_url($requrl);	my (undef,$udom,$unum,$file_name,$group) = &parse_portfolio_url($requrl);
my $result = &get_portfolio_access($udom,$unum,$file_name,$group);	my $result = &get_portfolio_access($udom,$unum,$file_name,$group,$clientip);
if ($result) {	if ($result) {
my %setters;	my %setters;
if ($env{'user.name'} eq 'public' && $env{'user.domain'} eq 'public') {	if ($env{'user.name'} eq 'public' && $env{'user.domain'} eq 'public') {
Line 6142 sub portfolio_access {	Line 6842 sub portfolio_access {
}	}

sub get_portfolio_access {	sub get_portfolio_access {
my ($udom,$unum,$file_name,$group,$access_hash) = @_;	my ($udom,$unum,$file_name,$group,$clientip,$access_hash) = @_;

if (!ref($access_hash)) {	if (!ref($access_hash)) {
my $current_perms = &get_portfile_permissions($udom,$unum);	my $current_perms = &get_portfile_permissions($udom,$unum);
Line 6151 sub get_portfolio_access {	Line 6851 sub get_portfolio_access {
$access_hash = $access_controls{$file_name};	$access_hash = $access_controls{$file_name};
}	}

my ($public,$guest,@domains,@users,@courses,@groups);	my ($public,$guest,@domains,@users,@courses,@groups,@ips);
my $now = time;	my $now = time;
if (ref($access_hash) eq 'HASH') {	if (ref($access_hash) eq 'HASH') {
foreach my $key (keys(%{$access_hash})) {	foreach my $key (keys(%{$access_hash})) {
Line 6175 sub get_portfolio_access {	Line 6875 sub get_portfolio_access {
push(@courses,$key);	push(@courses,$key);
} elsif ($scope eq 'group') {	} elsif ($scope eq 'group') {
push(@groups,$key);	push(@groups,$key);
	} elsif ($scope eq 'ip') {
	push(@ips,$key);
}	}
}	}
if ($public) {	if ($public) {
return 'ok';	return 'ok';
	} elsif (@ips > 0) {
	my $allowed;
	foreach my $ipkey (@ips) {
	if (ref($access_hash->{$ipkey}{'ip'}) eq 'ARRAY') {
	if (&Apache::loncommon::check_ip_acc(join(',',@{$access_hash->{$ipkey}{'ip'}}),$clientip)) {
	$allowed = 1;
	last;
	}
	}
	}
	if ($allowed) {
	return 'ok';
	}
}	}
if ($env{'user.name'} eq 'public' && $env{'user.domain'} eq 'public') {	if ($env{'user.name'} eq 'public' && $env{'user.domain'} eq 'public') {
if ($guest) {	if ($guest) {
Line 6662 sub customaccess {	Line 7377 sub customaccess {
# ------------------------------------------------- Check for a user privilege	# ------------------------------------------------- Check for a user privilege

sub allowed {	sub allowed {
my ($priv,$uri,$symb,$role)=@_;	my ($priv,$uri,$symb,$role,$clientip,$noblockcheck)=@_;
my $ver_orguri=$uri;	my $ver_orguri=$uri;
$uri=&deversion($uri);	$uri=&deversion($uri);
my $orguri=$uri;	my $orguri=$uri;
Line 6857 sub allowed {	Line 7572 sub allowed {
if ($match) {	if ($match) {
if ($env{'user.priv.'.$env{'request.role'}.'./'}	if ($env{'user.priv.'.$env{'request.role'}.'./'}
=~/\Q$priv\E\&([^\:]*)/) {	=~/\Q$priv\E\&([^\:]*)/) {
my @blockers = &has_comm_blocking($priv,$symb,$uri);	my $value = $1;
if (@blockers > 0) {	if ($noblockcheck) {
$thisallowed = 'B';	$thisallowed.=$value;
} else {	} else {
$thisallowed.=$1;	my @blockers = &has_comm_blocking($priv,$symb,$uri);
	if (@blockers > 0) {
	$thisallowed = 'B';
	} else {
	$thisallowed.=$value;
	}
}	}
}	}
} else {	} else {
Line 6873 sub allowed {	Line 7593 sub allowed {
$refuri=&declutter($refuri);	$refuri=&declutter($refuri);
my ($match) = &is_on_map($refuri);	my ($match) = &is_on_map($refuri);
if ($match) {	if ($match) {
my @blockers = &has_comm_blocking($priv,$symb,$refuri);	if ($noblockcheck) {
if (@blockers > 0) {
$thisallowed = 'B';
} else {
$thisallowed='F';	$thisallowed='F';
	} else {
	my @blockers = &has_comm_blocking($priv,$symb,$refuri);
	if (@blockers > 0) {
	$thisallowed = 'B';
	} else {
	$thisallowed='F';
	}
}	}
}	}
}	}
Line 6889 sub allowed {	Line 7613 sub allowed {
&& $thisallowed ne 'F'	&& $thisallowed ne 'F'
&& $thisallowed ne '2'	&& $thisallowed ne '2'
&& &is_portfolio_url($uri)) {	&& &is_portfolio_url($uri)) {
$thisallowed = &portfolio_access($uri);	$thisallowed = &portfolio_access($uri,$clientip);
}	}

# Full access at system, domain or course-wide level? Exit.	# Full access at system, domain or course-wide level? Exit.
Line 6932 sub allowed {	Line 7656 sub allowed {
=~/\Q$priv\E\&([^\:]*)/) {	=~/\Q$priv\E\&([^\:]*)/) {
my $value = $1;	my $value = $1;
if ($priv eq 'bre') {	if ($priv eq 'bre') {
my @blockers = &has_comm_blocking($priv,$symb,$uri);	if ($noblockcheck) {
if (@blockers > 0) {
$thisallowed = 'B';
} else {
$thisallowed.=$value;	$thisallowed.=$value;
	} else {
	my @blockers = &has_comm_blocking($priv,$symb,$uri);
	if (@blockers > 0) {
	$thisallowed = 'B';
	} else {
	$thisallowed.=$value;
	}
}	}
} else {	} else {
$thisallowed.=$value;	$thisallowed.=$value;
Line 6970 sub allowed {	Line 7698 sub allowed {
=~/\Q$priv\E\&([^\:]*)/) {	=~/\Q$priv\E\&([^\:]*)/) {
my $value = $1;	my $value = $1;
if ($priv eq 'bre') {	if ($priv eq 'bre') {
my @blockers = &has_comm_blocking($priv,$symb,$refuri);	if ($noblockcheck) {
if (@blockers > 0) {
$thisallowed = 'B';
} else {
$thisallowed.=$value;	$thisallowed.=$value;
	} else {
	my @blockers = &has_comm_blocking($priv,$symb,$refuri);
	if (@blockers > 0) {
	$thisallowed = 'B';
	} else {
	$thisallowed.=$value;
	}
}	}
} else {	} else {
$thisallowed.=$value;	$thisallowed.=$value;
Line 7150 sub constructaccess {	Line 7882 sub constructaccess {
my ($ownername,$ownerdomain,$ownerhome);	my ($ownername,$ownerdomain,$ownerhome);

($ownerdomain,$ownername) =	($ownerdomain,$ownername) =
($url=~ m{^(?:\Q$perlvar{'lonDocRoot'}\E\|)/priv/($match_domain)/($match_username)/});	($url=~ m{^(?:\Q$perlvar{'lonDocRoot'}\E\|)/priv/($match_domain)/($match_username)(?:/\|$)});

# The URL does not really point to any authorspace, forget it	# The URL does not really point to any authorspace, forget it
unless (($ownername) && ($ownerdomain)) { return ''; }	unless (($ownername) && ($ownerdomain)) { return ''; }
Line 7205 sub constructaccess {	Line 7937 sub constructaccess {
return '';	return '';
}	}

	# ----------------------------------------------------------- Content Blocking

	{
	# Caches for faster Course Contents display where content blocking
	# is in operation (i.e., interval param set) for timed quiz.
	#
	# User for whom data are being temporarily cached.
	my $cacheduser='';
	# Cached blockers for this user (a hash of blocking items).
	my %cachedblockers=();
	# When the data were last cached.
	my $cachedlast='';

	sub load_all_blockers {
	my ($uname,$udom,$blocks)=@_;
	if (($uname ne '') && ($udom ne '')) {
	if (($cacheduser eq $uname.':'.$udom) &&
	(abs($cachedlast-time)<5)) {
	return;
	}
	}
	$cachedlast=time;
	$cacheduser=$uname.':'.$udom;
	%cachedblockers = &get_commblock_resources($blocks);
	}

sub get_comm_blocks {	sub get_comm_blocks {
my ($cdom,$cnum) = @_;	my ($cdom,$cnum) = @_;
if ($cdom eq '' \|\| $cnum eq '') {	if ($cdom eq '' \|\| $cnum eq '') {
Line 7225 sub get_comm_blocks {	Line 7983 sub get_comm_blocks {
return %commblocks;	return %commblocks;
}	}

sub has_comm_blocking {	sub get_commblock_resources {
my ($priv,$symb,$uri,$blocks) = @_;	my ($blocks) = @_;
return unless ($env{'request.course.id'});	my %blockers = ();
return unless ($priv eq 'bre');	return %blockers unless ($env{'request.course.id'});
return if ($env{'user.priv.'.$env{'request.role'}} =~/evb\&([^\:]*)/);	return %blockers if ($env{'user.priv.'.$env{'request.role'}} =~/evb\&([^\:]*)/);
my %commblocks;	my %commblocks;
if (ref($blocks) eq 'HASH') {	if (ref($blocks) eq 'HASH') {
%commblocks = %{$blocks};	%commblocks = %{$blocks};
} else {	} else {
%commblocks = &get_comm_blocks();	%commblocks = &get_comm_blocks();
}	}
return unless (keys(%commblocks) > 0);	return %blockers unless (keys(%commblocks) > 0);
if (!$symb) { $symb=&symbread($uri,1); }
my ($map,$resid,undef)=&decode_symb($symb);
my %tocheck = (
maps => $map,
resources => $symb,
);
my @blockers;
my $now = time;
my $navmap = Apache::lonnavmaps::navmap->new();	my $navmap = Apache::lonnavmaps::navmap->new();
	return %blockers unless (ref($navmap));
	my $now = time;
foreach my $block (keys(%commblocks)) {	foreach my $block (keys(%commblocks)) {
if ($block =~ /^(\d+)____(\d+)$/) {	if ($block =~ /^(\d+)____(\d+)$/) {
my ($start,$end) = ($1,$2);	my ($start,$end) = ($1,$2);
Line 7253 sub has_comm_blocking {	Line 8005 sub has_comm_blocking {
if (ref($commblocks{$block}{'blocks'}) eq 'HASH') {	if (ref($commblocks{$block}{'blocks'}) eq 'HASH') {
if (ref($commblocks{$block}{'blocks'}{'docs'}) eq 'HASH') {	if (ref($commblocks{$block}{'blocks'}{'docs'}) eq 'HASH') {
if (ref($commblocks{$block}{'blocks'}{'docs'}{'maps'}) eq 'HASH') {	if (ref($commblocks{$block}{'blocks'}{'docs'}{'maps'}) eq 'HASH') {
if ($commblocks{$block}{'blocks'}{'docs'}{'maps'}{$map}) {	if (keys(%{$commblocks{$block}{'blocks'}{'docs'}{'maps'}})) {
unless (grep(/^\Q$block\E$/,@blockers)) {	$blockers{$block}{maps} = $commblocks{$block}{'blocks'}{'docs'}{'maps'};
push(@blockers,$block);
}
}	}
}	}
if (ref($commblocks{$block}{'blocks'}{'docs'}{'resources'}) eq 'HASH') {	if (ref($commblocks{$block}{'blocks'}{'docs'}{'resources'}) eq 'HASH') {
if ($commblocks{$block}{'blocks'}{'docs'}{'resources'}{$symb}) {	if (keys(%{$commblocks{$block}{'blocks'}{'docs'}{'resources'}})) {
unless (grep(/^\Q$block\E$/,@blockers)) {	$blockers{$block}{'resources'} = $commblocks{$block}{'blocks'}{'docs'}{'resources'};
push(@blockers,$block);
}
}	}
}	}
}	}
Line 7274 sub has_comm_blocking {	Line 8022 sub has_comm_blocking {
my @to_test;	my @to_test;
if (ref($commblocks{$block}{'blocks'}) eq 'HASH') {	if (ref($commblocks{$block}{'blocks'}) eq 'HASH') {
if (ref($commblocks{$block}{'blocks'}{'docs'}) eq 'HASH') {	if (ref($commblocks{$block}{'blocks'}{'docs'}) eq 'HASH') {
my $check_interval;	my @interval;
if (&check_docs_block($commblocks{$block}{'blocks'}{'docs'},\%tocheck)) {	my $type = 'map';
my @interval;	if ($item eq 'course') {
my $type = 'map';	$type = 'course';
if ($item eq 'course') {	@interval=&EXT("resource.0.interval");
$type = 'course';	} else {
@interval=&EXT("resource.0.interval");	if ($item =~ /___\d+___/) {
	$type = 'resource';
	@interval=&EXT("resource.0.interval",$item);
	if (ref($navmap)) {
	my $res = $navmap->getBySymb($item);
	push(@to_test,$res);
	}
} else {	} else {
if ($item =~ /___\d+___/) {	my $mapsymb = &symbread($item,1);
$type = 'resource';	if ($mapsymb) {
@interval=&EXT("resource.0.interval",$item);	if (ref($navmap)) {
if (ref($navmap)) {	my $mapres = $navmap->getBySymb($mapsymb);
my $res = $navmap->getBySymb($item);	@to_test = $mapres->retrieveResources($mapres,undef,0,0,0,1);
push(@to_test,$res);	foreach my $res (@to_test) {
}	my $symb = $res->symb();
} else {	next if ($symb eq $mapsymb);
my $mapsymb = &symbread($item,1);	if ($symb ne '') {
if ($mapsymb) {	@interval=&EXT("resource.0.interval",$symb);
if (ref($navmap)) {	if ($interval[1] eq 'map') {
my $mapres = $navmap->getBySymb($mapsymb);
@to_test = $mapres->retrieveResources($mapres,undef,0,1);
foreach my $res (@to_test) {
my $symb = $res->symb();
next if ($symb eq $mapsymb);
if ($symb ne '') {
@interval=&EXT("resource.0.interval",$symb);
last;	last;
}	}
}	}
Line 7307 sub has_comm_blocking {	Line 8054 sub has_comm_blocking {
}	}
}	}
}	}
if ($interval[0] =~ /\d+/) {	}
my $first_access;	if ($interval[0] =~ /^\d+$/) {
if ($type eq 'resource') {	my $first_access;
$first_access=&get_first_access($interval[1],$item);	if ($type eq 'resource') {
} elsif ($type eq 'map') {	$first_access=&get_first_access($interval[1],$item);
$first_access=&get_first_access($interval[1],undef,$item);	} elsif ($type eq 'map') {
} else {	$first_access=&get_first_access($interval[1],undef,$item);
$first_access=&get_first_access($interval[1]);	} else {
}	$first_access=&get_first_access($interval[1]);
if ($first_access) {	}
my $timesup = $first_access+$interval[0];	if ($first_access) {
if ($timesup > $now) {	my $timesup = $first_access+$interval[0];
foreach my $res (@to_test) {	if ($timesup > $now) {
if ($res->is_problem()) {	my $activeblock;
if ($res->completable()) {	foreach my $res (@to_test) {
unless (grep(/^\Q$block\E$/,@blockers)) {	if ($res->answerable()) {
push(@blockers,$block);	$activeblock = 1;
}	last;
last;	}
}	}
	if ($activeblock) {
	if (ref($commblocks{$block}{'blocks'}{'docs'}{'maps'}) eq 'HASH') {
	if (keys(%{$commblocks{$block}{'blocks'}{'docs'}{'maps'}})) {
	$blockers{$block}{'maps'} = $commblocks{$block}{'blocks'}{'docs'}{'maps'};
	}
	}
	if (ref($commblocks{$block}{'blocks'}{'docs'}{'resources'}) eq 'HASH') {
	if (keys(%{$commblocks{$block}{'blocks'}{'docs'}{'resources'}})) {
	$blockers{$block}{'resources'} = $commblocks{$block}{'blocks'}{'docs'}{'resources'};
}	}
}	}
}	}
Line 7337 sub has_comm_blocking {	Line 8093 sub has_comm_blocking {
}	}
}	}
}	}
return @blockers;	return %blockers;
}	}

sub check_docs_block {	sub has_comm_blocking {
my ($docsblock,$tocheck) =@_;	my ($priv,$symb,$uri,$blocks) = @_;
if ((ref($docsblock) ne 'HASH') \|\| (ref($tocheck) ne 'HASH')) {	my @blockers;
return;	return unless ($env{'request.course.id'});
	return unless ($priv eq 'bre');
	return if ($env{'user.priv.'.$env{'request.role'}} =~/evb\&([^\:]*)/);
	return if ($env{'request.state'} eq 'construct');
	&load_all_blockers($env{'user.name'},$env{'user.domain'},$blocks);
	return unless (keys(%cachedblockers) > 0);
	my (%possibles,@symbs);
	if (!$symb) {
	$symb = &symbread($uri,1,1,1,\%possibles);
}	}
if (ref($docsblock->{'maps'}) eq 'HASH') {	if ($symb) {
if ($tocheck->{'maps'}) {	@symbs = ($symb);
if ($docsblock->{'maps'}{$tocheck->{'maps'}}) {	} elsif (keys(%possibles)) {
return 1;	@symbs = keys(%possibles);
	}
	my $noblock;
	foreach my $symb (@symbs) {
	last if ($noblock);
	my ($map,$resid,$resurl)=&decode_symb($symb);
	foreach my $block (keys(%cachedblockers)) {
	if ($block =~ /^firstaccess____(.+)$/) {
	my $item = $1;
	if (($item eq $map) \|\| ($item eq $symb)) {
	$noblock = 1;
	last;
	}
}	}
}	if (ref($cachedblockers{$block}) eq 'HASH') {
}	if (ref($cachedblockers{$block}{'resources'}) eq 'HASH') {
if (ref($docsblock->{'resources'}) eq 'HASH') {	if ($cachedblockers{$block}{'resources'}{$symb}) {
if ($tocheck->{'resources'}) {	unless (grep(/^\Q$block\E$/,@blockers)) {
if ($docsblock->{'resources'}{$tocheck->{'resources'}}) {	push(@blockers,$block);
return 1;	}
	}
	}
	}
	if (ref($cachedblockers{$block}{'maps'}) eq 'HASH') {
	if ($cachedblockers{$block}{'maps'}{$map}) {
	unless (grep(/^\Q$block\E$/,@blockers)) {
	push(@blockers,$block);
	}
	}
}	}
}	}
}	}
return;	return if ($noblock);
	return @blockers;
	}
}	}

	# -------------------------------- Deversion and split uri into path an filename

#	#
# Removes the versino from a URI and	# Removes the version from a URI and
# splits it in to its filename and path to the filename.	# splits it in to its filename and path to the filename.
# Seems like File::Basename could have done this more clearly.	# Seems like File::Basename could have done this more clearly.
# Parameters:	# Parameters:
Line 7431 sub get_symb_from_alias {	Line 8220 sub get_symb_from_alias {

sub definerole {	sub definerole {
if (allowed('mcr','/')) {	if (allowed('mcr','/')) {
my ($rolename,$sysrole,$domrole,$courole)=@_;	my ($rolename,$sysrole,$domrole,$courole,$uname,$udom)=@_;
foreach my $role (split(':',$sysrole)) {	foreach my $role (split(':',$sysrole)) {
my ($crole,$cqual)=split(/\&/,$role);	my ($crole,$cqual)=split(/\&/,$role);
if ($pr{'cr:s'}!~/\Q$crole\E/) { return "refused:s:$crole"; }	if ($pr{'cr:s'}!~/\Q$crole\E/) { return "refused:s:$crole"; }
Line 7459 sub definerole {	Line 8248 sub definerole {
}	}
}	}
}	}
	my $uhome;
	if (($uname ne '') && ($udom ne '')) {
	$uhome = &homeserver($uname,$udom);
	return $uhome if ($uhome eq 'no_host');
	} else {
	$uname = $env{'user.name'};
	$udom = $env{'user.domain'};
	$uhome = $env{'user.home'};
	}
my $command="encrypt:rolesput:$env{'user.domain'}:$env{'user.name'}:".	my $command="encrypt:rolesput:$env{'user.domain'}:$env{'user.name'}:".
"$env{'user.domain'}:$env{'user.name'}:".	"$udom:$uname:rolesdef_$rolename=".
"rolesdef_$rolename=".
escape($sysrole.'_'.$domrole.'_'.$courole);	escape($sysrole.'_'.$domrole.'_'.$courole);
return reply($command,$env{'user.home'});	return reply($command,$uhome);
} else {	} else {
return 'refused';	return 'refused';
}	}
Line 7545 sub update_allusers_table {	Line 8342 sub update_allusers_table {

sub fetch_enrollment_query {	sub fetch_enrollment_query {
my ($context,$affiliatesref,$replyref,$dom,$cnum) = @_;	my ($context,$affiliatesref,$replyref,$dom,$cnum) = @_;
my $homeserver;	my ($homeserver,$sleep,$loopmax);
my $maxtries = 1;	my $maxtries = 1;
if ($context eq 'automated') {	if ($context eq 'automated') {
$homeserver = $perlvar{'lonHostID'};	$homeserver = $perlvar{'lonHostID'};
	$sleep = 2;
	$loopmax = 100;
$maxtries = 10; # will wait for up to 2000s for retrieval of classlist data before timeout	$maxtries = 10; # will wait for up to 2000s for retrieval of classlist data before timeout
} else {	} else {
$homeserver = &homeserver($cnum,$dom);	$homeserver = &homeserver($cnum,$dom);
Line 7566 sub fetch_enrollment_query {	Line 8365 sub fetch_enrollment_query {
&logthis('fetch_enrollment_query: invalid queryid: '.$queryid.' for host: '.$host.' and homeserver: '.$homeserver.' context: '.$context.' '.$cnum);	&logthis('fetch_enrollment_query: invalid queryid: '.$queryid.' for host: '.$host.' and homeserver: '.$homeserver.' context: '.$context.' '.$cnum);
return 'error: '.$queryid;	return 'error: '.$queryid;
}	}
my $reply = &get_query_reply($queryid);	my $reply = &get_query_reply($queryid,$sleep,$loopmax);
my $tries = 1;	my $tries = 1;
while (($reply=~/^timeout/) && ($tries < $maxtries)) {	while (($reply=~/^timeout/) && ($tries < $maxtries)) {
$reply = &get_query_reply($queryid);	$reply = &get_query_reply($queryid,$sleep,$loopmax);
$tries ++;	$tries ++;
}	}
if ( ($reply =~/^timeout/) \|\| ($reply =~/^error/) ) {	if ( ($reply =~/^timeout/) \|\| ($reply =~/^error/) ) {
&logthis('fetch_enrollment_query error: '.$reply.' for '.$dom.' '.$env{'user.name'}.' for '.$queryid.' context: '.$context.' '.$cnum.' maxtries: '.$maxtries.' tries: '.$tries);	&logthis('fetch_enrollment_query error: '.$reply.' for '.$dom.' '.$env{'user.name'}.' for '.$queryid.' context: '.$context.' '.$cnum.' maxtries: '.$maxtries.' tries: '.$tries);
} else {	} else {
my @responses = split(/:/,$reply);	my @responses = split(/:/,$reply);
if ($homeserver eq $perlvar{'lonHostID'}) {	if (grep { $_ eq $homeserver } &current_machine_ids()) {
foreach my $line (@responses) {	foreach my $line (@responses) {
my ($key,$value) = split(/=/,$line,2);	my ($key,$value) = split(/=/,$line,2);
$$replyref{$key} = $value;	$$replyref{$key} = $value;
Line 7594 sub fetch_enrollment_query {	Line 8393 sub fetch_enrollment_query {
if ($xml_classlist =~ /^error/) {	if ($xml_classlist =~ /^error/) {
&logthis('fetch_enrollment_query - autoretrieve error: '.$xml_classlist.' for '.$filename.' from server: '.$homeserver.' '.$context.' '.$cnum);	&logthis('fetch_enrollment_query - autoretrieve error: '.$xml_classlist.' for '.$filename.' from server: '.$homeserver.' '.$context.' '.$cnum);
} else {	} else {
if ( open(FILE,">$destname") ) {	if ( open(FILE,">",$destname) ) {
print FILE &unescape($xml_classlist);	print FILE &unescape($xml_classlist);
close(FILE);	close(FILE);
} else {	} else {
Line 7611 sub fetch_enrollment_query {	Line 8410 sub fetch_enrollment_query {
}	}

sub get_query_reply {	sub get_query_reply {
my $queryid=shift;	my ($queryid,$sleep,$loopmax) = @_;
	if (($sleep eq '') \|\| ($sleep !~ /^\d+\.?\d*$/)) {
	$sleep = 0.2;
	}
	if (($loopmax eq '') \|\| ($loopmax =~ /\D/)) {
	$loopmax = 100;
	}
my $replyfile=LONCAPA::tempdir().$queryid;	my $replyfile=LONCAPA::tempdir().$queryid;
my $reply='';	my $reply='';
for (1..100) {	for (1..$loopmax) {
sleep 2;	sleep($sleep);
if (-e $replyfile.'.end') {	if (-e $replyfile.'.end') {
if (open(my $fh,$replyfile)) {	if (open(my $fh,"<",$replyfile)) {
$reply = join('',<$fh>);	$reply = join('',<$fh>);
close($fh);	close($fh);
} else { return 'error: reply_file_error'; }	} else { return 'error: reply_file_error'; }
Line 8009 sub auto_validate_class_sec {	Line 8814 sub auto_validate_class_sec {
return $response;	return $response;
}	}

	sub auto_validate_instclasses {
	my ($cdom,$cnum,$owners,$classesref) = @_;
	my ($homeserver,%validations);
	$homeserver = &homeserver($cnum,$cdom);
	unless ($homeserver eq 'no_host') {
	my $ownerlist;
	if (ref($owners) eq 'ARRAY') {
	$ownerlist = join(',',@{$owners});
	} else {
	$ownerlist = $owners;
	}
	if (ref($classesref) eq 'HASH') {
	my $classes = &freeze_escape($classesref);
	my $response=&reply('autovalidateinstclasses:'.&escape($ownerlist).
	':'.$cdom.':'.$classes,$homeserver);
	unless ($response =~ /(con_lost\|error\|no_such_host\|refused)/) {
	my @items = split(/&/,$response);
	foreach my $item (@items) {
	my ($key,$value) = split('=',$item);
	$validations{&unescape($key)} = &thaw_unescape($value);
	}
	}
	}
	}
	return %validations;
	}

sub auto_crsreq_update {	sub auto_crsreq_update {
my ($cdom,$cnum,$crstype,$action,$ownername,$ownerdomain,$fullname,$title,	my ($cdom,$cnum,$crstype,$action,$ownername,$ownerdomain,$fullname,$title,
$code,$accessstart,$accessend,$inbound) = @_;	$code,$accessstart,$accessend,$inbound) = @_;
Line 8037 sub auto_crsreq_update {	Line 8869 sub auto_crsreq_update {
return \%crsreqresponse;	return \%crsreqresponse;
}	}

	sub auto_export_grades {
	my ($cdom,$cnum,$inforef,$gradesref) = @_;
	my ($homeserver,%exportresponse);
	if ($cdom =~ /^$match_domain$/) {
	$homeserver = &domain($cdom,'primary');
	}
	unless (($homeserver eq 'no_host') \|\| ($homeserver eq '')) {
	my $info;
	if (ref($inforef) eq 'HASH') {
	$info = &freeze_escape($inforef);
	}
	if (ref($gradesref) eq 'HASH') {
	my $grades = &freeze_escape($gradesref);
	my $response=&reply('encrypt:autoexportgrades:'.$cdom.':'.$cnum.':'.
	$info.':'.$grades,$homeserver);
	unless ($response =~ /(con_lost\|error\|no_such_host\|refused\|unknown_command)/) {
	my @items = split(/&/,$response);
	foreach my $item (@items) {
	my ($key,$value) = split('=',$item);
	$exportresponse{&unescape($key)} = &thaw_unescape($value);
	}
	}
	}
	}
	return \%exportresponse;
	}

	sub check_instcode_cloning {
	my ($codedefaults,$code_order,$cloner,$clonefromcode,$clonetocode) = @_;
	unless ((ref($codedefaults) eq 'HASH') && (ref($code_order) eq 'ARRAY')) {
	return;
	}
	my $canclone;
	if (@{$code_order} > 0) {
	my $instcoderegexp ='^';
	my @clonecodes = split(/\&/,$cloner);
	foreach my $item (@{$code_order}) {
	if (grep(/^\Q$item\E=/,@clonecodes)) {
	foreach my $pair (@clonecodes) {
	my ($key,$val) = split(/\=/,$pair,2);
	$val = &unescape($val);
	if ($key eq $item) {
	$instcoderegexp .= '('.$val.')';
	last;
	}
	}
	} else {
	$instcoderegexp .= $codedefaults->{$item};
	}
	}
	$instcoderegexp .= '$';
	my (@from,@to);
	eval {
	(@from) = ($clonefromcode =~ /$instcoderegexp/);
	(@to) = ($clonetocode =~ /$instcoderegexp/);
	};
	if ((@from > 0) && (@to > 0)) {
	my @diffs = &Apache::loncommon::compare_arrays(\@from,\@to);
	if (!@diffs) {
	$canclone = 1;
	}
	}
	}
	return $canclone;
	}

	sub default_instcode_cloning {
	my ($clonedom,$domdefclone,$clonefromcode,$clonetocode,$codedefaultsref,$codeorderref) = @_;
	my (%codedefaults,@code_order,$canclone);
	if ((ref($codedefaultsref) eq 'HASH') && (ref($codeorderref) eq 'ARRAY')) {
	%codedefaults = %{$codedefaultsref};
	@code_order = @{$codeorderref};
	} elsif ($clonedom) {
	&auto_instcode_defaults($clonedom,\%codedefaults,\@code_order);
	}
	if (($domdefclone) && (@code_order)) {
	my @clonecodes = split(/\+/,$domdefclone);
	my $instcoderegexp ='^';
	foreach my $item (@code_order) {
	if (grep(/^\Q$item\E$/,@clonecodes)) {
	$instcoderegexp .= '('.$codedefaults{$item}.')';
	} else {
	$instcoderegexp .= $codedefaults{$item};
	}
	}
	$instcoderegexp .= '$';
	my (@from,@to);
	eval {
	(@from) = ($clonefromcode =~ /$instcoderegexp/);
	(@to) = ($clonetocode =~ /$instcoderegexp/);
	};
	if ((@from > 0) && (@to > 0)) {
	my @diffs = &Apache::loncommon::compare_arrays(\@from,\@to);
	if (!@diffs) {
	$canclone = 1;
	}
	}
	}
	return $canclone;
	}

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

sub get_coursegroups {	sub get_coursegroups {
Line 8401 sub assignrole {	Line 9334 sub assignrole {
&courserolelog($role,$uname,$udom,$url,$origstart,$origend,$delflag,	&courserolelog($role,$uname,$udom,$url,$origstart,$origend,$delflag,
$selfenroll,$context);	$selfenroll,$context);
} elsif (($role eq 'li') \|\| ($role eq 'dg') \|\| ($role eq 'sc') \|\|	} elsif (($role eq 'li') \|\| ($role eq 'dg') \|\| ($role eq 'sc') \|\|
($role eq 'au') \|\| ($role eq 'dc')) {	($role eq 'au') \|\| ($role eq 'dc') \|\| ($role eq 'dh') \|\|
	($role eq 'da')) {
&domainrolelog($role,$uname,$udom,$url,$origstart,$origend,$delflag,	&domainrolelog($role,$uname,$udom,$url,$origstart,$origend,$delflag,
$context);	$context);
} elsif (($role eq 'ca') \|\| ($role eq 'aa')) {	} elsif (($role eq 'ca') \|\| ($role eq 'aa')) {
Line 8706 sub modifyuser {	Line 9640 sub modifyuser {
sub modifystudent {	sub modifystudent {
my ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec,	my ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec,
$end,$start,$forceid,$desiredhome,$email,$type,$locktype,$cid,	$end,$start,$forceid,$desiredhome,$email,$type,$locktype,$cid,
$selfenroll,$context,$inststatus,$credits)=@_;	$selfenroll,$context,$inststatus,$credits,$instsec)=@_;
if (!$cid) {	if (!$cid) {
unless ($cid=$env{'request.course.id'}) {	unless ($cid=$env{'request.course.id'}) {
return 'not_in_class';	return 'not_in_class';
Line 8722 sub modifystudent {	Line 9656 sub modifystudent {
$uid = undef if (!$forceid);	$uid = undef if (!$forceid);
$reply = &modify_student_enrollment($udom,$uname,$uid,$first,$middle,$last,	$reply = &modify_student_enrollment($udom,$uname,$uid,$first,$middle,$last,
$gene,$usec,$end,$start,$type,$locktype,	$gene,$usec,$end,$start,$type,$locktype,
$cid,$selfenroll,$context,$credits);	$cid,$selfenroll,$context,$credits,$instsec);
return $reply;	return $reply;
}	}

sub modify_student_enrollment {	sub modify_student_enrollment {
my ($udom,$uname,$uid,$first,$middle,$last,$gene,$usec,$end,$start,$type,	my ($udom,$uname,$uid,$first,$middle,$last,$gene,$usec,$end,$start,$type,
$locktype,$cid,$selfenroll,$context,$credits) = @_;	$locktype,$cid,$selfenroll,$context,$credits,$instsec) = @_;
my ($cdom,$cnum,$chome);	my ($cdom,$cnum,$chome);
if (!$cid) {	if (!$cid) {
unless ($cid=$env{'request.course.id'}) {	unless ($cid=$env{'request.course.id'}) {
Line 8775 sub modify_student_enrollment {	Line 9709 sub modify_student_enrollment {
my %old_entry = &Apache::lonnet::get('classlist',[$user],$cdom,$cnum);	my %old_entry = &Apache::lonnet::get('classlist',[$user],$cdom,$cnum);
my $reply=cput('classlist',	my $reply=cput('classlist',
{$user =>	{$user =>
join(':',$end,$start,$uid,$usec,$fullname,$type,$locktype,$credits) },	join(':',$end,$start,$uid,$usec,$fullname,$type,$locktype,$credits,$instsec) },
$cdom,$cnum);	$cdom,$cnum);
if (($reply eq 'ok') \|\| ($reply eq 'delayed')) {	if (($reply eq 'ok') \|\| ($reply eq 'delayed')) {
&devalidate_getsection_cache($udom,$uname,$cid);	&devalidate_getsection_cache($udom,$uname,$cid);
Line 8998 sub generate_coursenum {	Line 9932 sub generate_coursenum {
sub is_course {	sub is_course {
my ($cdom, $cnum) = scalar(@_) == 1 ?	my ($cdom, $cnum) = scalar(@_) == 1 ?
($_[0] =~ /^($match_domain)_($match_courseid)$/) : @_;	($_[0] =~ /^($match_domain)_($match_courseid)$/) : @_;
	return unless (($cdom =~ /^$match_domain$/) && ($cnum =~ /^$match_courseid$/));
return unless $cdom and $cnum;	my $uhome=&homeserver($cnum,$cdom);
	my $iscourse;
my %courses = &courseiddump($cdom, '.', 1, '.', '.', $cnum, undef, undef,	if (grep { $_ eq $uhome } current_machine_ids()) {
'.');	$iscourse = &LONCAPA::Lond::is_course($cdom,$cnum);
	} else {
return unless(exists($courses{$cdom.'_'.$cnum}));	my $hashid = $cdom.':'.$cnum;
	($iscourse,my $cached) = &is_cached_new('iscourse',$hashid);
	unless (defined($cached)) {
	my %courses = &courseiddump($cdom, '.', 1, '.', '.',
	$cnum,undef,undef,'.');
	$iscourse = 0;
	if (exists($courses{$cdom.'_'.$cnum})) {
	$iscourse = 1;
	}
	&do_cache_new('iscourse',$hashid,$iscourse,3600);
	}
	}
	return unless($iscourse);
return wantarray ? ($cdom, $cnum) : $cdom.'_'.$cnum;	return wantarray ? ($cdom, $cnum) : $cdom.'_'.$cnum;
}	}

Line 9140 sub save_selected_files {	Line 10086 sub save_selected_files {
my ($user, $path, @files) = @_;	my ($user, $path, @files) = @_;
my $filename = $user."savedfiles";	my $filename = $user."savedfiles";
my @other_files = &files_not_in_path($user, $path);	my @other_files = &files_not_in_path($user, $path);
open (OUT, '>'.$tmpdir.$filename);	open (OUT,'>',LONCAPA::tempdir().$filename);
foreach my $file (@files) {	foreach my $file (@files) {
print (OUT $env{'form.currentpath'}.$file."\n");	print (OUT $env{'form.currentpath'}.$file."\n");
}	}
Line 9154 sub save_selected_files {	Line 10100 sub save_selected_files {
sub clear_selected_files {	sub clear_selected_files {
my ($user) = @_;	my ($user) = @_;
my $filename = $user."savedfiles";	my $filename = $user."savedfiles";
open (OUT, '>'.LONCAPA::tempdir().$filename);	open (OUT,'>',LONCAPA::tempdir().$filename);
print (OUT undef);	print (OUT undef);
close (OUT);	close (OUT);
return ("ok");	return ("ok");
Line 9164 sub files_in_path {	Line 10110 sub files_in_path {
my ($user, $path) = @_;	my ($user, $path) = @_;
my $filename = $user."savedfiles";	my $filename = $user."savedfiles";
my %return_files;	my %return_files;
open (IN, '<'.LONCAPA::tempdir().$filename);	open (IN,'<',LONCAPA::tempdir().$filename);
while (my $line_in = <IN>) {	while (my $line_in = <IN>) {
chomp ($line_in);	chomp ($line_in);
my @paths_and_file = split (m!/!, $line_in);	my @paths_and_file = split (m!/!, $line_in);
Line 9186 sub files_not_in_path {	Line 10132 sub files_not_in_path {
my $filename = $user."savedfiles";	my $filename = $user."savedfiles";
my @return_files;	my @return_files;
my $path_part;	my $path_part;
open(IN, '<'.LONCAPA::.$filename);	open(IN, '<',LONCAPA::tempdir().$filename);
while (my $line = <IN>) {	while (my $line = <IN>) {
#ok, I know it's clunky, but I want it to work	#ok, I know it's clunky, but I want it to work
my @paths_and_file = split(m\|/\|, $line);	my @paths_and_file = split(m\|/\|, $line);
Line 9299 sub modify_access_controls {	Line 10245 sub modify_access_controls {
my $tries = 0;	my $tries = 0;
my $gotlock = &newput('file_permissions',$lockhash,$domain,$user);	my $gotlock = &newput('file_permissions',$lockhash,$domain,$user);

while (($gotlock ne 'ok') && $tries <3) {	while (($gotlock ne 'ok') && $tries < 10) {
$tries ++;	$tries ++;
sleep 1;	sleep(0.1);
$gotlock = &newput('file_permissions',$lockhash,$domain,$user);	$gotlock = &newput('file_permissions',$lockhash,$domain,$user);
}	}
if ($gotlock eq 'ok') {	if ($gotlock eq 'ok') {
Line 9594 sub dirlist {	Line 10540 sub dirlist {
foreach my $user (sort(keys(%allusers))) {	foreach my $user (sort(keys(%allusers))) {
push(@alluserslist,$user.'&user');	push(@alluserslist,$user.'&user');
}	}
return (\@alluserslist);	if (!%listerror) {
	# no errors
	return (\@alluserslist);
	} elsif (scalar(keys(%servers)) == 1) {
	# one library server, one error
	my ($key) = keys(%listerror);
	return (\@alluserslist, $listerror{$key});
	} elsif ( grep { $_ eq 'con_lost' } values(%listerror) ) {
	# con_lost indicates that we might miss data from at least one
	# library server
	return (\@alluserslist, 'con_lost');
	} else {
	# multiple library servers and no con_lost -> data should be
	# complete.
	return (\@alluserslist);
	}

} else {	} else {
return ([],'missing username');	return ([],'missing username');
}	}
Line 9811 sub get_userresdata {	Line 10773 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:".	if ((!defined($cached)) \|\| ($tmp ne 'con_lost')) {
" Trying to get resource data for ".	&logthis("<font color=\"blue\">WARNING:".
$uname." at ".$udom.": ".	" Trying to get resource data for ".
$tmp."</font>");	$uname." at ".$udom.": ".
	$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);	&do_cache_new('userres',$hashid,undef,600);
Line 10302 sub add_prefix_and_part {	Line 11266 sub add_prefix_and_part {

my %metaentry;	my %metaentry;
my %importedpartids;	my %importedpartids;
	my %importedrespids;
sub metadata {	sub metadata {
my ($uri,$what,$liburi,$prefix,$depthcount)=@_;	my ($uri,$what,$liburi,$prefix,$depthcount)=@_;
$uri=&declutter($uri);	$uri=&declutter($uri);
Line 10329 sub metadata {	Line 11294 sub metadata {
}	}
{	{
# Imported parts would go here	# Imported parts would go here
my %importedids=();	my @origfiletagids=();
my @origfileimportpartids=();
my $importedparts=0;	my $importedparts=0;

	# Imported responseids would go here
	my $importedresponses=0;
#	#
# Is this a recursive call for a library?	# Is this a recursive call for a library?
#	#
Line 10426 sub metadata {	Line 11393 sub metadata {
my $dir=$filename;	my $dir=$filename;
$dir=~s\|[^/]*$\|\|;	$dir=~s\|[^/]*$\|\|;
$location=&filelocation($dir,$location);	$location=&filelocation($dir,$location);

	my $importid=$token->[2]->{'id'};
my $importmode=$token->[2]->{'importmode'};	my $importmode=$token->[2]->{'importmode'};
	#
	# Check metadata for imported file to
	# see if it contained response items
	#
	my %currmetaentry = %metaentry;
	my $libresponseorder = &metadata($location,'responseorder');
	my $origfile;
	if ($libresponseorder ne '') {
	if ($#origfiletagids<0) {
	undef(%importedrespids);
	undef(%importedpartids);
	}
	@{$importedrespids{$importid}} = split(/\s,\s/,$libresponseorder);
	if (@{$importedrespids{$importid}} > 0) {
	$importedresponses = 1;
	# We need to get the original file and the imported file to get the response order correct
	# Load and inspect original file
	if ($#origfiletagids<0) {
	my $origfilelocation=$perlvar{'lonDocRoot'}.&clutter($uri);
	$origfile=&getfile($origfilelocation);
	@origfiletagids=($origfile=~/<((?:\w+)response\|import\|part)[^>]id\s=\s[\"\']([^\"\']+)[\"\'][^>]>/gs);
	}
	}
	}
	# Do not overwrite contents of %metaentry hash for resource itself with
	# hash populated for imported library file
	%metaentry = %currmetaentry;
	undef(%currmetaentry);
if ($importmode eq 'problem') {	if ($importmode eq 'problem') {
# Import as problem/response	# Import as problem/response
$unikey=&add_prefix_and_part($prefix,$token->[2]->{'part'});	$unikey=&add_prefix_and_part($prefix,$token->[2]->{'part'});
Line 10436 sub metadata {	Line 11432 sub metadata {
$importedparts=1;	$importedparts=1;
# We need to get the original file and the imported file to get the part order correct	# We need to get the original file and the imported file to get the part order correct
# Good news: we do not need to worry about nested libraries, since parts cannot be nested	# Good news: we do not need to worry about nested libraries, since parts cannot be nested
# Load and inspect original file	# Load and inspect original file if we didn't do that already
if ($#origfileimportpartids<0) {	if ($#origfiletagids<0) {
undef(%importedpartids);	undef(%importedrespids);
my $origfilelocation=$perlvar{'lonDocRoot'}.&clutter($uri);	undef(%importedpartids);
my $origfile=&getfile($origfilelocation);	if ($origfile eq '') {
@origfileimportpartids=($origfile=~/<(part\|import)[^>]id\s=\s[\"\']([^\"\']+)[\"\'][^>]>/gs);	my $origfilelocation=$perlvar{'lonDocRoot'}.&clutter($uri);
	$origfile=&getfile($origfilelocation);
	@origfiletagids=($origfile=~/<(part\|import)[^>]id\s=\s[\"\']([^\"\']+)[\"\'][^>]>/gs);
	}
}	}

# Load and inspect imported file	# Load and inspect imported file
Line 10555 sub metadata {	Line 11554 sub metadata {
grep { ! $seen{$_} ++ } (split(',',$metaentry{':packages'}));	grep { ! $seen{$_} ++ } (split(',',$metaentry{':packages'}));
$metaentry{':packages'} = join(',',@uniq_packages);	$metaentry{':packages'} = join(',',@uniq_packages);

if ($importedparts) {	if (($importedresponses) \|\| ($importedparts)) {
	if ($importedparts) {
# We had imported parts and need to rebuild partorder	# We had imported parts and need to rebuild partorder
$metaentry{':partorder'}='';	$metaentry{':partorder'}='';
$metathesekeys{'partorder'}=1;	$metathesekeys{'partorder'}=1;
for (my $index=0;$index<$#origfileimportpartids;$index+=2) {	}
if ($origfileimportpartids[$index] eq 'part') {	if ($importedresponses) {
# original part, part of the problem	# We had imported responses and need to rebuild responseorder
$metaentry{':partorder'}.=','.$origfileimportpartids[$index+1];	$metaentry{':responseorder'}='';
} else {	$metathesekeys{'responseorder'}=1;
# we have imported parts at this position	}
$metaentry{':partorder'}.=','.$importedpartids{$origfileimportpartids[$index+1]};	for (my $index=0;$index<$#origfiletagids;$index+=2) {
}	my $origid = $origfiletagids[$index+1];
}	if ($origfiletagids[$index] eq 'part') {
$metaentry{':partorder'}=~s/^\,//;	# Original part, part of the problem
	if ($importedparts) {
	$metaentry{':partorder'}.=','.$origid;
	}
	} elsif ($origfiletagids[$index] eq 'import') {
	if ($importedparts) {
	# We have imported parts at this position
	$metaentry{':partorder'}.=','.$importedpartids{$origid};
	}
	if ($importedresponses) {
	# We have imported responses at this position
	if (ref($importedrespids{$origid}) eq 'ARRAY') {
	$metaentry{':responseorder'}.=','.join(',',map { $origid.'_'.$_ } @{$importedrespids{$origid}});
	}
	}
	} else {
	# Original response item, part of the problem
	if ($importedresponses) {
	$metaentry{':responseorder'}.=','.$origid;
	}
	}
	}
	if ($importedparts) {
	$metaentry{':partorder'}=~s/^\,//;
	}
	if ($importedresponses) {
	$metaentry{':responseorder'}=~s/^\,//;
	}
}	}

$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,$cachetime);	&do_cache_new('meta',$uri,\%metaentry,$cachetime);
# this is the end of "was not already recently cached	# this is the end of "was not already recently cached
}	}
Line 10944 sub deversion {	Line 11971 sub deversion {
# ------------------------------------------------------ Return symb list entry	# ------------------------------------------------------ Return symb list entry

sub symbread {	sub symbread {
my ($thisfn,$donotrecurse)=@_;	my ($thisfn,$donotrecurse,$ignorecachednull,$checkforblock,$possibles)=@_;
my $cache_str='request.symbread.cached.'.$thisfn;	my $cache_str='request.symbread.cached.'.$thisfn;
if (defined($env{$cache_str})) { return $env{$cache_str}; }	if (defined($env{$cache_str})) {
	if ($ignorecachednull) {
	return $env{$cache_str} unless ($env{$cache_str} eq '');
	} else {
	return $env{$cache_str};
	}
	}
# no filename provided? try from environment	# no filename provided? try from environment
unless ($thisfn) {	unless ($thisfn) {
if ($env{'request.symb'}) {	if ($env{'request.symb'}) {
Line 11008 sub symbread {	Line 12041 sub symbread {
my ($mapid,$resid)=split(/\./,$ids);	my ($mapid,$resid)=split(/\./,$ids);
$syval=&encode_symb($bighash{'map_id_'.$mapid},	$syval=&encode_symb($bighash{'map_id_'.$mapid},
$resid,$thisfn);	$resid,$thisfn);
} elsif (!$donotrecurse) {	if (ref($possibles) eq 'HASH') {
	$possibles->{$syval} = 1;
	}
	if ($checkforblock) {
	my @blockers = &has_comm_blocking('bre',$syval,$bighash{'src_'.$ids});
	if (@blockers) {
	$syval = '';
	return;
	}
	}
	} elsif ((!$donotrecurse) \|\| ($checkforblock) \|\| (ref($possibles) eq 'HASH')) {
# ------------------------------------------ There is more than one possibility	# ------------------------------------------ There is more than one possibility
my $realpossible=0;	my $realpossible=0;
foreach my $id (@possibilities) {	foreach my $id (@possibilities) {
my $file=$bighash{'src_'.$id};	my $file=$bighash{'src_'.$id};
if (&allowed('bre',$file)) {	my $canaccess;
my ($mapid,$resid)=split(/\./,$id);	if (($donotrecurse) \|\| ($checkforblock) \|\| (ref($possibles) eq 'HASH')) {
if ($bighash{'map_type_'.$mapid} ne 'page') {	$canaccess = 1;
$realpossible++;	} else {
$syval=&encode_symb($bighash{'map_id_'.$mapid},	$canaccess = &allowed('bre',$file);
$resid,$thisfn);	}
}	if ($canaccess) {
	my ($mapid,$resid)=split(/\./,$id);
	if ($bighash{'map_type_'.$mapid} ne 'page') {
	my $poss_syval=&encode_symb($bighash{'map_id_'.$mapid},
	$resid,$thisfn);
	if (ref($possibles) eq 'HASH') {
	$possibles->{$syval} = 1;
	}
	if ($checkforblock) {
	my @blockers = &has_comm_blocking('bre',$poss_syval,$file);
	unless (@blockers > 0) {
	$syval = $poss_syval;
	$realpossible++;
	}
	} else {
	$syval = $poss_syval;
	$realpossible++;
	}
	}
}	}
}	}
if ($realpossible!=1) { $syval=''; }	if ($realpossible!=1) { $syval=''; }
Line 11027 sub symbread {	Line 12088 sub symbread {
$syval='';	$syval='';
}	}
}	}
untie(%bighash)	untie(%bighash);
}	}
}	}
if ($syval) {	if ($syval) {
Line 11622 sub readfile {	Line 12683 sub readfile {
my $file = shift;	my $file = shift;
if ( (! -e $file ) \|\| ($file eq '') ) { return -1; };	if ( (! -e $file ) \|\| ($file eq '') ) { return -1; };
my $fh;	my $fh;
open($fh,"<$file");	open($fh,"<",$file);
my $a='';	my $a='';
while (my $line = <$fh>) { $a .= $line; }	while (my $line = <$fh>) { $a .= $line; }
return $a;	return $a;
Line 11735 sub machine_ids {	Line 12796 sub machine_ids {

sub additional_machine_domains {	sub additional_machine_domains {
my @domains;	my @domains;
open(my $fh,"<$perlvar{'lonTabDir'}/expected_domains.tab");	open(my $fh,"<","$perlvar{'lonTabDir'}/expected_domains.tab");
while( my $line = <$fh>) {	while( my $line = <$fh>) {
$line =~ s/\s//g;	$line =~ s/\s//g;
push(@domains,$line);	push(@domains,$line);
Line 11756 sub default_login_domain {	Line 12817 sub default_login_domain {
return $domain;	return $domain;
}	}

	sub shared_institution {
	my ($dom) = @_;
	my $same_intdom;
	my $hostintdom = &internet_dom($perlvar{'lonHostID'});
	if ($hostintdom ne '') {
	my %iphost = &get_iphost();
	my $primary_id = &domain($dom,'primary');
	my $primary_ip = &get_host_ip($primary_id);
	if (ref($iphost{$primary_ip}) eq 'ARRAY') {
	foreach my $id (@{$iphost{$primary_ip}}) {
	my $intdom = &internet_dom($id);
	if ($intdom eq $hostintdom) {
	$same_intdom = 1;
	last;
	}
	}
	}
	}
	return $same_intdom;
	}

# ------------------------------------------------------------- Declutters URLs	# ------------------------------------------------------------- Declutters URLs

sub declutter {	sub declutter {
Line 11879 sub get_dns {	Line 12961 sub get_dns {
}	}

my %alldns;	my %alldns;
open(my $config,"<$perlvar{'lonTabDir'}/hosts.tab");	if (open(my $config,"<","$perlvar{'lonTabDir'}/hosts.tab")) {
foreach my $dns (<$config>) {	foreach my $dns (<$config>) {
next if ($dns !~ /^\^(\S*)/x);	next if ($dns !~ /^\^(\S*)/x);
my $line = $1;	my $line = $1;
my ($host,$protocol) = split(/:/,$line);	my ($host,$protocol) = split(/:/,$line);
if ($protocol ne 'https') {	if ($protocol ne 'https') {
$protocol = 'http';	$protocol = 'http';
	}
	$alldns{$host} = $protocol;
}	}
$alldns{$host} = $protocol;	close($config);
}	}
while (%alldns) {	while (%alldns) {
my ($dns) = sort { $b cmp $a } keys(%alldns);	my ($dns) = sort { $b cmp $a } keys(%alldns);
Line 11904 sub get_dns {	Line 12988 sub get_dns {
&$func(\@content,$hashref);	&$func(\@content,$hashref);
return;	return;
}	}
close($config);
my $which = (split('/',$url))[3];	my $which = (split('/',$url))[3];
&logthis("unable to contact DNS defaulting to on disk file dns_$which.tab\n");	&logthis("unable to contact DNS defaulting to on disk file dns_$which.tab\n");
open($config,"<$perlvar{'lonTabDir'}/dns_$which.tab");	if (open(my $config,"<","$perlvar{'lonTabDir'}/dns_$which.tab")) {
my @content = <$config>;	my @content = <$config>;
&$func(\@content,$hashref);	&$func(\@content,$hashref);
	}
return;	return;
}	}

Line 11997 sub fetch_dns_checksums {	Line 13081 sub fetch_dns_checksums {
}	}

sub load_domain_tab {	sub load_domain_tab {
my ($ignore_cache) = @_;	my ($ignore_cache,$nocache) = @_;
&get_dns('/adm/dns/domain',\&parse_domain_tab,$ignore_cache);	&get_dns('/adm/dns/domain',\&parse_domain_tab,$ignore_cache,$nocache);
my $fh;	my $fh;
if (open($fh,"<".$perlvar{'lonTabDir'}.'/domain.tab')) {	if (open($fh,"<",$perlvar{'lonTabDir'}.'/domain.tab')) {
my @lines = <$fh>;	my @lines = <$fh>;
&parse_domain_tab(\@lines);	&parse_domain_tab(\@lines);
}	}
Line 12052 sub fetch_dns_checksums {	Line 13136 sub fetch_dns_checksums {
my ($id,$domain,$role,$name,$protocol,$intdom)=split(/:/,$configline);	my ($id,$domain,$role,$name,$protocol,$intdom)=split(/:/,$configline);
$name=~s/\s//g;	$name=~s/\s//g;
if ($id && $domain && $role && $name) {	if ($id && $domain && $role && $name) {
	if ((exists($hostname{$id})) && ($hostname{$id} ne '')) {
	my $curr = $hostname{$id};
	my $skip;
	if (ref($name_to_host{$curr}) eq 'ARRAY') {
	if (($curr eq $name) && (@{$name_to_host{$curr}} == 1)) {
	$skip = 1;
	} else {
	@{$name_to_host{$curr}} = grep { $_ ne $id } @{$name_to_host{$curr}};
	}
	}
	unless ($skip) {
	push(@{$name_to_host{$name}},$id);
	}
	} else {
	push(@{$name_to_host{$name}},$id);
	}
$hostname{$id}=$name;	$hostname{$id}=$name;
push(@{$name_to_host{$name}}, $id);
$hostdom{$id}=$domain;	$hostdom{$id}=$domain;
if ($role eq 'library') { $libserv{$id}=$name; }	if ($role eq 'library') { $libserv{$id}=$name; }
if (defined($protocol)) {	if (defined($protocol)) {
Line 12084 sub fetch_dns_checksums {	Line 13183 sub fetch_dns_checksums {
}	}

sub load_hosts_tab {	sub load_hosts_tab {
my ($ignore_cache) = @_;	my ($ignore_cache,$nocache) = @_;
&get_dns('/adm/dns/hosts',\&parse_hosts_tab,$ignore_cache);	&get_dns('/adm/dns/hosts',\&parse_hosts_tab,$ignore_cache,$nocache);
open(my $config,"<$perlvar{'lonTabDir'}/hosts.tab");	open(my $config,"<","$perlvar{'lonTabDir'}/hosts.tab");
my @config = <$config>;	my @config = <$config>;
&parse_hosts_tab(\@config);	&parse_hosts_tab(\@config);
close($config);	close($config);
Line 12107 sub fetch_dns_checksums {	Line 13206 sub fetch_dns_checksums {
}	}

sub all_names {	sub all_names {
&load_hosts_tab() if (!$loaded);	my ($ignore_cache,$nocache) = @_;
	&load_hosts_tab($ignore_cache,$nocache) if (!$loaded);

return %name_to_host;	return %name_to_host;
}	}
Line 12229 sub fetch_dns_checksums {	Line 13329 sub fetch_dns_checksums {
}	}

sub get_iphost {	sub get_iphost {
my ($ignore_cache) = @_;	my ($ignore_cache,$nocache) = @_;

if (!$ignore_cache) {	if (!$ignore_cache) {
if (%iphost) {	if (%iphost) {
Line 12253 sub fetch_dns_checksums {	Line 13353 sub fetch_dns_checksums {
%old_name_to_ip = %{$ip_info->[1]};	%old_name_to_ip = %{$ip_info->[1]};
}	}

my %name_to_host = &all_names();	my %name_to_host = &all_names($ignore_cache,$nocache);
foreach my $name (keys(%name_to_host)) {	foreach my $name (keys(%name_to_host)) {
my $ip;	my $ip;
if (!exists($name_to_ip{$name})) {	if (!exists($name_to_ip{$name})) {
Line 12278 sub fetch_dns_checksums {	Line 13378 sub fetch_dns_checksums {
}	}
push(@{$iphost{$ip}},@{$name_to_host{$name}});	push(@{$iphost{$ip}},@{$name_to_host{$name}});
}	}
&do_cache_new('iphost','iphost',	unless ($nocache) {
[\%iphost,\%name_to_ip,\%lonid_to_ip],	&do_cache_new('iphost','iphost',
486060);	[\%iphost,\%name_to_ip,\%lonid_to_ip],
	486060);
	}

return %iphost;	return %iphost;
}	}
Line 12349 sub all_loncaparevs {	Line 13451 sub all_loncaparevs {
{	{
sub load_loncaparevs {	sub load_loncaparevs {
if (-e "$perlvar{'lonTabDir'}/loncaparevs.tab") {	if (-e "$perlvar{'lonTabDir'}/loncaparevs.tab") {
if (open(my $config,"<$perlvar{'lonTabDir'}/loncaparevs.tab")) {	if (open(my $config,"<","$perlvar{'lonTabDir'}/loncaparevs.tab")) {
while (my $configline=<$config>) {	while (my $configline=<$config>) {
chomp($configline);	chomp($configline);
my ($hostid,$loncaparev)=split(/:/,$configline);	my ($hostid,$loncaparev)=split(/:/,$configline);
Line 12365 sub all_loncaparevs {	Line 13467 sub all_loncaparevs {
{	{
sub load_serverhomeIDs {	sub load_serverhomeIDs {
if (-e "$perlvar{'lonTabDir'}/serverhomeIDs.tab") {	if (-e "$perlvar{'lonTabDir'}/serverhomeIDs.tab") {
if (open(my $config,"<$perlvar{'lonTabDir'}/serverhomeIDs.tab")) {	if (open(my $config,"<","$perlvar{'lonTabDir'}/serverhomeIDs.tab")) {
while (my $configline=<$config>) {	while (my $configline=<$config>) {
chomp($configline);	chomp($configline);
my ($name,$id)=split(/:/,$configline);	my ($name,$id)=split(/:/,$configline);
Line 12390 BEGIN {	Line 13492 BEGIN {

# ------------------------------------------------------ Read spare server file	# ------------------------------------------------------ Read spare server file
{	{
open(my $config,"<$perlvar{'lonTabDir'}/spare.tab");	open(my $config,"<","$perlvar{'lonTabDir'}/spare.tab");

while (my $configline=<$config>) {	while (my $configline=<$config>) {
chomp($configline);	chomp($configline);
Line 12404 BEGIN {	Line 13506 BEGIN {
}	}
# ------------------------------------------------------------ Read permissions	# ------------------------------------------------------------ Read permissions
{	{
open(my $config,"<$perlvar{'lonTabDir'}/roles.tab");	open(my $config,"<","$perlvar{'lonTabDir'}/roles.tab");

while (my $configline=<$config>) {	while (my $configline=<$config>) {
chomp($configline);	chomp($configline);
Line 12418 BEGIN {	Line 13520 BEGIN {

# -------------------------------------------- Read plain texts for permissions	# -------------------------------------------- Read plain texts for permissions
{	{
open(my $config,"<$perlvar{'lonTabDir'}/rolesplain.tab");	open(my $config,"<","$perlvar{'lonTabDir'}/rolesplain.tab");

while (my $configline=<$config>) {	while (my $configline=<$config>) {
chomp($configline);	chomp($configline);
Line 12438 BEGIN {	Line 13540 BEGIN {

# ---------------------------------------------------------- Read package table	# ---------------------------------------------------------- Read package table
{	{
open(my $config,"<$perlvar{'lonTabDir'}/packages.tab");	open(my $config,"<","$perlvar{'lonTabDir'}/packages.tab");

while (my $configline=<$config>) {	while (my $configline=<$config>) {
if ($configline !~ /\S/ \|\| $configline=~/^#/) { next; }	if ($configline !~ /\S/ \|\| $configline=~/^#/) { next; }
Line 12484 BEGIN {	Line 13586 BEGIN {
# ---------------------------------------------------------- Read managers table	# ---------------------------------------------------------- Read managers table
{	{
if (-e "$perlvar{'lonTabDir'}/managers.tab") {	if (-e "$perlvar{'lonTabDir'}/managers.tab") {
if (open(my $config,"<$perlvar{'lonTabDir'}/managers.tab")) {	if (open(my $config,"<","$perlvar{'lonTabDir'}/managers.tab")) {
while (my $configline=<$config>) {	while (my $configline=<$config>) {
chomp($configline);	chomp($configline);
next if ($configline =~ /^\#/);	next if ($configline =~ /^\#/);
Line 12503 BEGIN {	Line 13605 BEGIN {

}	}

	# ------------- set default texengine (domain default overrides this)
	{
	$deftex = LONCAPA::texengine();
	}

$memcache=new Cache::Memcached({'servers' => ['127.0.0.1:11211'],	$memcache=new Cache::Memcached({'servers' => ['127.0.0.1:11211'],
'compress_threshold'=> 20_000,	'compress_threshold'=> 20_000,
});	});
Line 12661 were new keys. I.E. 1:foo will become 1:	Line 13768 were new keys. I.E. 1:foo will become 1:
Calling convention:	Calling convention:

my %record=&Apache::lonnet::restore($symb,$courseid,$domain,$uname);	my %record=&Apache::lonnet::restore($symb,$courseid,$domain,$uname);
&Apache::lonnet::cstore(\%newrecord,$symb,$courseid,$domain,$uname);	&Apache::lonnet::cstore(\%newrecord,$symb,$courseid,$domain,$uname,$laststore);

For more detailed information, see lonnet specific documentation.	For more detailed information, see lonnet specific documentation.

Line 12797 escaped strings of the action recorded i	Line 13904 escaped strings of the action recorded i

=item *	=item *

allowed($priv,$uri,$symb,$role) : check for a user privilege; returns codes for allowed actions	allowed($priv,$uri,$symb,$role,$clientip,$noblockcheck) : check for a user privilege;
	returns codes for allowed actions.

	The first argument is required, all others are optional.

	$priv is the privilege being checked.
	$uri contains additional information about what is being checked for access (e.g.,
	URL, course ID etc.).
	$symb is the unique resource instance identifier in a course; if needed,
	but not provided, it will be retrieved via a call to &symbread().
	$role is the role for which a priv is being checked (only used if priv is evb).
	$clientip is the user's IP address (only used when checking for access to portfolio
	files).
	$noblockcheck, if true, skips calls to &has_comm_blocking() for the bre priv. This
	prevents recursive calls to &allowed.

F: full access	F: full access
U,I,K: authentication modes (cxx only)	U,I,K: authentication modes (cxx only)
'': forbidden	'': forbidden
1: user needs to choose course	1: user needs to choose course
2: browse allowed	2: browse allowed
A: passphrase authentication needed	A: passphrase authentication needed
	B: access temporarily blocked because of a blocking event in a course.

=item *	=item *

Line 12822 in which case the null string is returne	Line 13945 in which case the null string is returne

=item *	=item *

definerole($rolename,$sysrole,$domrole,$courole) : define role; define a custom	definerole($rolename,$sysrole,$domrole,$courole,$uname,$udom) : define role;
role rolename set privileges in format of lonTabs/roles.tab for system, domain,	define a custom role rolename set privileges in format of lonTabs/roles.tab
and course level	for system, domain, and course level. $uname and $udom are optional (current
	user's username and domain will be used when either of $uname or $udom are absent.

=item *	=item *

Line 13028 Inputs:	Line 14152 Inputs:

=item $credits, number of credits student will earn from this class	=item $credits, number of credits student will earn from this class

	=item $instsec, institutional course section code for student

=back	=back


Line 13197 will be stored for query	Line 14323 will be stored for query

=item *	=item *

symbread($filename) : return symbolic list entry (filename argument optional);	symbread($filename,$donotrecurse,$ignorecachednull,$checkforblock,$possibles) :
	return symbolic list entry (all arguments optional).

	Args: filename is the filename (including path) for the file for which a symb
	is required; donotrecurse, if true will prevent calls to allowed() being made
	to check access status if more than one resource was found in the bighash
	(see rev. 1.249) to avoid an infinite loop if an ambiguous resource is part of
	a randompick); ignorecachednull, if true will prevent a symb of '' being
	returned if $env{$cache_str} is defined as ''; checkforblock if true will
	cause possible symbs to be checked to determine if they are subject to content
	blocking, if so they will not be included as possible symbs; possibles is a
	ref to a hash, which, as a side effect, will be populated with all possible
	symbs (content blocking not tested).

returns the data handle	returns the data handle

=item *	=item *
Line 13298 homeserver.	Line 14437 homeserver.

=item *	=item *

store($storehash,$symb,$namespace,$udom,$uname) : stores hash permanently	store($storehash,$symb,$namespace,$udom,$uname,$laststore) : stores hash
for this url; hashref needs to be given and should be a \%hashname; the	permanently for this url; hashref needs to be given and should be a \%hashname;
remaining args aren't required and if they aren't passed or are '' they will	the remaining args aren't required and if they aren't passed or are '' they will
be derived from the env	be derived from the env (with the exception of $laststore, which is an
	optional arg used when a user's submission is stored in grading).
	$laststore is $version=$timestamp, where $version is the most recent version
	number retrieved for the corresponding $symb in the $namespace db file, and
	$timestamp is the timestamp for that transaction (UNIX time).
	$laststore is currently only passed when cstore() is called by
	structuretags::finalize_storage().

=item *	=item *

cstore($storehash,$symb,$namespace,$udom,$uname) : same as store but	cstore($storehash,$symb,$namespace,$udom,$uname,$laststore) : same as store
uses critical subroutine	but uses critical subroutine

=item *	=item *

Line 13329 $range should be either an integer '100'	Line 14474 $range should be either an integer '100'

=item *	=item *

putstore($namespace,$symb,$version,$storehash,$udomain,$uname) :	putstore($namespace,$symb,$version,$storehash,$udomain,$uname,$tolog) :
replaces a &store() version of data with a replacement set of data	replaces a &store() version of data with a replacement set of data
for a particular resource in a namespace passed in the $storehash hash	for a particular resource in a namespace passed in the $storehash hash
reference	reference. If $tolog is true, the transaction is logged in the courselog
	with an action=PUTSTORE.

=item *	=item *

Line 13497 for course's uploaded content.	Line 14643 for course's uploaded content.
=over	=over

=item	=item
canuse_pdfforms, officialcredits, unofficialcredits, textbookcredits, officialquota, unofficialquota, communityquota, textbookquota	canuse_pdfforms, officialcredits, unofficialcredits, textbookcredits, officialquota, unofficialquota,
	communityquota, textbookquota

=back	=back

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

Removed from v.1.1172.2.57
changed lines
	Added in v.1.1172.2.107