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.1056.4.35 and 1.1148

version 1.1056.4.35, 2012/01/08 22:58:21	version 1.1148, 2011/12/14 16:16:50
Line 96 use Math::Random;	Line 96 use Math::Random;
use File::MMagic;	use File::MMagic;
use LONCAPA qw(:DEFAULT :match);	use LONCAPA qw(:DEFAULT :match);
use LONCAPA::Configuration;	use LONCAPA::Configuration;

use File::Copy;	use File::Copy;

my $readit;	my $readit;
Line 288 sub get_server_homeID {	Line 289 sub get_server_homeID {
}	}
my $cachetime = 12*3600;	my $cachetime = 12*3600;
my $serverhomeID;	my $serverhomeID;
if ($caller eq 'loncron') {	if ($caller eq 'loncron') {
my @machine_ids = &machine_ids($hostname);	my @machine_ids = &machine_ids($hostname);
foreach my $id (@machine_ids) {	foreach my $id (@machine_ids) {
my $response = &reply('serverhomeID',$id);	my $response = &reply('serverhomeID',$id);
Line 306 sub get_server_homeID {	Line 307 sub get_server_homeID {
return &do_cache_new('serverhomeID',$hostname,$serverhomeID,$cachetime);	return &do_cache_new('serverhomeID',$hostname,$serverhomeID,$cachetime);
}	}

	sub get_remote_globals {
	my ($lonhost,$whathash,$ignore_cache) = @_;
	my ($result,%returnhash,%whatneeded);
	if (ref($whathash) eq 'HASH') {
	foreach my $what (sort(keys(%{$whathash}))) {
	my $hashid = $lonhost.'-'.$what;
	my ($response,$cached);
	unless ($ignore_cache) {
	($response,$cached)=&is_cached_new('lonnetglobal',$hashid);
	}
	if (defined($cached)) {
	$returnhash{$what} = $response;
	} else {
	$whatneeded{$what} = 1;
	}
	}
	if (keys(%whatneeded) == 0) {
	$result = 'ok';
	} else {
	my $requested = &freeze_escape(\%whatneeded);
	my $rep=&reply('readlonnetglobal:'.$requested,$lonhost);
	if (($rep=~/^(refused\|rejected\|error)/) \|\| ($rep eq 'con_lost') \|\|
	($rep eq 'unknown_cmd')) {
	$result = $rep;
	} else {
	$result = 'ok';
	my @pairs=split(/\&/,$rep);
	foreach my $item (@pairs) {
	my ($key,$value)=split(/=/,$item,2);
	my $what = &unescape($key);
	my $hashid = $lonhost.'-'.$what;
	$returnhash{$what}=&thaw_unescape($value);
	&do_cache_new('lonnetglobal',$hashid,$returnhash{$what},600);
	}
	}
	}
	}
	return ($result,\%returnhash);
	}

	sub remote_devalidate_cache {
	my ($lonhost,$name,$id) = @_;
	my $response = &reply('devalidatecache:'.&escape($name).':'.&escape($id),$lonhost);
	return $response;
	}

# -------------------------------------------------- Non-critical communication	# -------------------------------------------------- Non-critical communication
sub subreply {	sub subreply {
my ($cmd,$server)=@_;	my ($cmd,$server)=@_;
Line 636 sub appenv {	Line 683 sub appenv {
# ----------------------------------------------------- Delete from Environment	# ----------------------------------------------------- Delete from Environment

sub delenv {	sub delenv {
my ($delthis,$regexp) = @_;	my ($delthis,$regexp,$roles) = @_;
if (($delthis=~/user\.role/) \|\| ($delthis=~/user\.priv/)) {	if (($delthis=~/^user\.role/) \|\| ($delthis=~/^user\.priv/)) {
&logthis("<font color=\"blue\">WARNING: ".	my $refused = 1;
"Attempt to delete from environment ".$delthis);	if (ref($roles) eq 'ARRAY') {
return 'error';	my ($type,$role) = ($delthis =~ /^user\.(role\|priv)\.([^.]+)\./);
	if (grep(/^\Q$role\E$/,@{$roles})) {
	$refused = 0;
	}
	}
	if ($refused) {
	&logthis("<font color=\"blue\">WARNING: ".
	"Attempt to delete from environment ".$delthis);
	return 'error';
	}
}	}
my $opened = open(my $env_file,'+<',$env{'user.environment'});	my $opened = open(my $env_file,'+<',$env{'user.environment'});
if ($opened	if ($opened
Line 749 sub userload {	Line 805 sub userload {
return $userloadpercent;	return $userloadpercent;
}	}

# ------------------------------------------ Fight off request when overloaded

sub overloaderror {
my ($r,$checkserver)=@_;
unless ($checkserver) { $checkserver=$perlvar{'lonHostID'}; }
my $loadavg;
if ($checkserver eq $perlvar{'lonHostID'}) {
open(my $loadfile,'/proc/loadavg');
$loadavg=<$loadfile>;
$loadavg =~ s/\s.*//g;
$loadavg = 100*$loadavg/$perlvar{'lonLoadLim'};
close($loadfile);
} else {
$loadavg=&reply('load',$checkserver);
}
my $overload=$loadavg-100;
if ($overload>0) {
$r->err_headers_out->{'Retry-After'}=$overload;
$r->log_error('Overload of '.$overload.' on '.$checkserver);
return 413;
}
return '';
}

# ------------------------------ Find server with least workload from spare.tab	# ------------------------------ Find server with least workload from spare.tab

sub spareserver {	sub spareserver {
Line 788 sub spareserver {	Line 820 sub spareserver {
my %udomdefaults = &Apache::lonnet::get_domain_defaults($udom);	my %udomdefaults = &Apache::lonnet::get_domain_defaults($udom);
$remotesessions = $udomdefaults{'remotesessions'};	$remotesessions = $udomdefaults{'remotesessions'};
}	}
foreach my $try_server (@{ $spareid{'primary'} }) {	my $spareshash = &this_host_spares($udom);
if ($uint_dom) {	if (ref($spareshash) eq 'HASH') {
next unless (&spare_can_host($udom,$uint_dom,$remotesessions,	if (ref($spareshash->{'primary'}) eq 'ARRAY') {
$try_server));	foreach my $try_server (@{ $spareshash->{'primary'} }) {
	if ($uint_dom) {
	next unless (&spare_can_host($udom,$uint_dom,$remotesessions,
	$try_server));
	}
	($spare_server, $lowest_load) =
	&compare_server_load($try_server, $spare_server, $lowest_load);
	}
}	}
($spare_server, $lowest_load) =
&compare_server_load($try_server, $spare_server, $lowest_load);
}

my $found_server = ($spare_server ne '' && $lowest_load < 100);

if (!$found_server) {	my $found_server = ($spare_server ne '' && $lowest_load < 100);
foreach my $try_server (@{ $spareid{'default'} }) {
if ($uint_dom) {	if (!$found_server) {
next unless (&spare_can_host($udom,$uint_dom,$remotesessions,	if (ref($spareshash->{'default'}) eq 'ARRAY') {
$try_server));	foreach my $try_server (@{ $spareshash->{'default'} }) {
}	if ($uint_dom) {
($spare_server, $lowest_load) =	next unless (&spare_can_host($udom,$uint_dom,
&compare_server_load($try_server, $spare_server, $lowest_load);	$remotesessions,$try_server));
}	}
	($spare_server, $lowest_load) =
	&compare_server_load($try_server, $spare_server, $lowest_load);
	}
	}
	}
}	}

if (!$want_server_name) {	if (!$want_server_name) {
Line 832 sub compare_server_load {	Line 871 sub compare_server_load {
my $userloadans = &reply('userload',$try_server);	my $userloadans = &reply('userload',$try_server);

if ($loadans !~ /\d/ && $userloadans !~ /\d/) {	if ($loadans !~ /\d/ && $userloadans !~ /\d/) {
return ($spare_server, $lowest_load); #didn't get a number from the server	return ($spare_server, $lowest_load); #didn't get a number from the server
}	}

my $load;	my $load;
Line 858 sub compare_server_load {	Line 897 sub compare_server_load {
# --------------------------- ask offload servers if user already has a session	# --------------------------- ask offload servers if user already has a session
sub find_existing_session {	sub find_existing_session {
my ($udom,$uname) = @_;	my ($udom,$uname) = @_;
foreach my $try_server (@{ $spareid{'primary'} },	my $spareshash = &this_host_spares($udom);
@{ $spareid{'default'} }) {	if (ref($spareshash) eq 'HASH') {
return $try_server if (&has_user_session($try_server, $udom, $uname));	if (ref($spareshash->{'primary'}) eq 'ARRAY') {
	foreach my $try_server (@{ $spareshash->{'primary'} }) {
	return $try_server if (&has_user_session($try_server, $udom, $uname));
	}
	}
	if (ref($spareshash->{'default'}) eq 'ARRAY') {
	foreach my $try_server (@{ $spareshash->{'default'} }) {
	return $try_server if (&has_user_session($try_server, $udom, $uname));
	}
	}
}	}
return;	return;
}	}
Line 890 sub choose_server {	Line 938 sub choose_server {
if ($loginvia) {	if ($loginvia) {
my ($server,$path) = split(/:/,$loginvia);	my ($server,$path) = split(/:/,$loginvia);
($login_host, $lowest_load) =	($login_host, $lowest_load) =
&compare_server_load($lonhost, $login_host, $lowest_load);	&compare_server_load($server, $login_host, $lowest_load);
if ($login_host eq $server) {	if ($login_host eq $server) {
$portal_path = $path;	$portal_path = $path;
}	}
Line 1093 sub spare_can_host {	Line 1141 sub spare_can_host {
return $canhost;	return $canhost;
}	}

	sub this_host_spares {
	my ($dom) = @_;
	my ($dom_in_use,$lonhost_in_use,$result);
	my @hosts = &current_machine_ids();
	foreach my $lonhost (@hosts) {
	if (&host_domain($lonhost) eq $dom) {
	$dom_in_use = $dom;
	$lonhost_in_use = $lonhost;
	last;
	}
	}
	if ($dom_in_use ne '') {
	$result = &spares_for_offload($dom_in_use,$lonhost_in_use);
	}
	if (ref($result) ne 'HASH') {
	$lonhost_in_use = $perlvar{'lonHostID'};
	$dom_in_use = &host_domain($lonhost_in_use);
	$result = &spares_for_offload($dom_in_use,$lonhost_in_use);
	if (ref($result) ne 'HASH') {
	$result = \%spareid;
	}
	}
	return $result;
	}

	sub spares_for_offload {
	my ($dom_in_use,$lonhost_in_use) = @_;
	my ($result,$cached)=&is_cached_new('spares',$dom_in_use);
	if (defined($cached)) {
	return $result;
	} else {
	my $cachetime = 606024;
	my %domconfig =
	&Apache::lonnet::get_dom('configuration',['usersessions'],$dom_in_use);
	if (ref($domconfig{'usersessions'}) eq 'HASH') {
	if (ref($domconfig{'usersessions'}{'spares'}) eq 'HASH') {
	if (ref($domconfig{'usersessions'}{'spares'}{$lonhost_in_use}) eq 'HASH') {
	return &do_cache_new('spares',$dom_in_use,$domconfig{'usersessions'}{'spares'}{$lonhost_in_use},$cachetime);
	}
	}
	}
	}
	return;
	}

	sub get_lonbalancer_config {
	my ($servers) = @_;
	my ($currbalancer,$currtargets);
	if (ref($servers) eq 'HASH') {
	foreach my $server (keys(%{$servers})) {
	my %what = (
	spareid => 1,
	perlvar => 1,
	);
	my ($result,$returnhash) = &get_remote_globals($server,\%what);
	if ($result eq 'ok') {
	if (ref($returnhash) eq 'HASH') {
	if (ref($returnhash->{'perlvar'}) eq 'HASH') {
	if ($returnhash->{'perlvar'}->{'lonBalancer'} eq 'yes') {
	$currbalancer = $server;
	$currtargets = {};
	if (ref($returnhash->{'spareid'}) eq 'HASH') {
	if (ref($returnhash->{'spareid'}->{'primary'}) eq 'ARRAY') {
	$currtargets->{'primary'} = $returnhash->{'spareid'}->{'primary'};
	}
	if (ref($returnhash->{'spareid'}->{'default'}) eq 'ARRAY') {
	$currtargets->{'default'} = $returnhash->{'spareid'}->{'default'};
	}
	}
	last;
	}
	}
	}
	}
	}
	}
	return ($currbalancer,$currtargets);
	}

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

	my $cachetime = 606024;

	if (($uintdom ne '') && ($uintdom eq $intdom)) {
	$dom_in_use = $udom;
	$homeintdom = 1;
	} else {
	$dom_in_use = $serverhomedom;
	}
	my ($result,$cached)=&is_cached_new('loadbalancing',$dom_in_use);
	unless (defined($cached)) {
	my %domconfig =
	&Apache::lonnet::get_dom('configuration',['loadbalancing'],$dom_in_use);
	if (ref($domconfig{'loadbalancing'}) eq 'HASH') {
	$result = &do_cache_new('loadbalancing',$dom_in_use,$domconfig{'loadbalancing'},$cachetime);
	}
	}
	if (ref($result) eq 'HASH') {
	my $currbalancer = $result->{'lonhost'};
	my $currtargets = $result->{'targets'};
	my $currrules = $result->{'rules'};
	if ($currbalancer ne '') {
	my @hosts = &current_machine_ids();
	if (grep(/^\Q$currbalancer\E$/,@hosts)) {
	$is_balancer = 1;
	}
	}
	if ($is_balancer) {
	if (ref($currrules) eq 'HASH') {
	if ($homeintdom) {
	if ($uname ne '') {
	if (($currrules->{'_LC_adv'} ne '') \|\| ($currrules->{'_LC_author'} ne '')) {
	my ($is_adv,$is_author) = &is_advanced_user($udom,$uname);
	if (($currrules->{'_LC_author'} ne '') && ($is_author)) {
	$rule_in_effect = $currrules->{'_LC_author'};
	} elsif (($currrules->{'_LC_adv'} ne '') && ($is_adv)) {
	$rule_in_effect = $currrules->{'_LC_adv'}
	}
	}
	if ($rule_in_effect eq '') {
	my %userenv = &userenvironment($udom,$uname,'inststatus');
	if ($userenv{'inststatus'} ne '') {
	my @statuses = map { &unescape($_); } split(/:/,$userenv{'inststatus'});
	my ($othertitle,$usertypes,$types) =
	&Apache::loncommon::sorted_inst_types($udom);
	if (ref($types) eq 'ARRAY') {
	foreach my $type (@{$types}) {
	if (grep(/^\Q$type\E$/,@statuses)) {
	if (exists($currrules->{$type})) {
	$rule_in_effect = $currrules->{$type};
	}
	}
	}
	}
	} else {
	if (exists($currrules->{'default'})) {
	$rule_in_effect = $currrules->{'default'};
	}
	}
	}
	} else {
	if (exists($currrules->{'default'})) {
	$rule_in_effect = $currrules->{'default'};
	}
	}
	} else {
	if ($currrules->{'_LC_external'} ne '') {
	$rule_in_effect = $currrules->{'_LC_external'};
	}
	}
	$offloadto = &get_loadbalancer_targets($rule_in_effect,$currtargets,
	$uname,$udom);
	}
	}
	} elsif (($homeintdom) && ($udom ne $serverhomedom)) {
	my ($result,$cached)=&is_cached_new('loadbalancing',$serverhomedom);
	unless (defined($cached)) {
	my %domconfig =
	&Apache::lonnet::get_dom('configuration',['loadbalancing'],$serverhomedom);
	if (ref($domconfig{'loadbalancing'}) eq 'HASH') {
	$result = &do_cache_new('loadbalancing',$dom_in_use,$domconfig{'loadbalancing'},$cachetime);
	}
	}
	if (ref($result) eq 'HASH') {
	my $currbalancer = $result->{'lonhost'};
	my $currtargets = $result->{'targets'};
	my $currrules = $result->{'rules'};

	if ($currbalancer eq $lonhost) {
	$is_balancer = 1;
	if (ref($currrules) eq 'HASH') {
	if ($currrules->{'_LC_internetdom'} ne '') {
	$rule_in_effect = $currrules->{'_LC_internetdom'};
	}
	}
	$offloadto = &get_loadbalancer_targets($rule_in_effect,$currtargets,
	$uname,$udom);
	}
	} else {
	if ($perlvar{'lonBalancer'} eq 'yes') {
	$is_balancer = 1;
	$offloadto = &this_host_spares($dom_in_use);
	}
	}
	} else {
	if ($perlvar{'lonBalancer'} eq 'yes') {
	$is_balancer = 1;
	$offloadto = &this_host_spares($dom_in_use);
	}
	}
	my $lowest_load = 30000;
	if (ref($offloadto) eq 'HASH') {
	if (ref($offloadto->{'primary'}) eq 'ARRAY') {
	foreach my $try_server (@{$offloadto->{'primary'}}) {
	($otherserver,$lowest_load) =
	&compare_server_load($try_server,$otherserver,$lowest_load);
	}
	}
	my $found_server = ($otherserver ne '' && $lowest_load < 100);

	if (!$found_server) {
	if (ref($offloadto->{'default'}) eq 'ARRAY') {
	foreach my $try_server (@{$offloadto->{'default'}}) {
	($otherserver,$lowest_load) =
	&compare_server_load($try_server,$otherserver,$lowest_load);
	}
	}
	}
	} elsif (ref($offloadto) eq 'ARRAY') {
	if (@{$offloadto} == 1) {
	$otherserver = $offloadto->[0];
	} elsif (@{$offloadto} > 1) {
	foreach my $try_server (@{$offloadto}) {
	($otherserver,$lowest_load) =
	&compare_server_load($try_server,$otherserver,$lowest_load);
	}
	}
	}
	return ($is_balancer,$otherserver);
	}

	sub get_loadbalancer_targets {
	my ($rule_in_effect,$currtargets,$uname,$udom) = @_;
	my $offloadto;
	if ($rule_in_effect eq '') {
	$offloadto = $currtargets;
	} else {
	if ($rule_in_effect eq 'homeserver') {
	my $homeserver = &homeserver($uname,$udom);
	if ($homeserver ne 'no_host') {
	$offloadto = [$homeserver];
	}
	} elsif ($rule_in_effect eq 'externalbalancer') {
	my %domconfig =
	&Apache::lonnet::get_dom('configuration',['loadbalancing'],$udom);
	if (ref($domconfig{'loadbalancing'}) eq 'HASH') {
	if ($domconfig{'loadbalancing'}{'lonhost'} ne '') {
	if (&hostname($domconfig{'loadbalancing'}{'lonhost'}) ne '') {
	$offloadto = [$domconfig{'loadbalancing'}{'lonhost'}];
	}
	}
	} else {
	my %servers = &dom_servers($udom);
	my ($remotebalancer,$remotetargets) = &get_lonbalancer_config(\%servers);
	if (&hostname($remotebalancer) ne '') {
	$offloadto = [$remotebalancer];
	}
	}
	} elsif (&hostname($rule_in_effect) ne '') {
	$offloadto = [$rule_in_effect];
	}
	}
	return $offloadto;
	}

	sub internet_dom_servers {
	my ($dom) = @_;
	my (%uniqservers,%servers);
	my $primaryserver = &hostname(&domain($dom,'primary'));
	my @machinedoms = &machine_domains($primaryserver);
	foreach my $mdom (@machinedoms) {
	my %currservers = %servers;
	my %server = &get_servers($mdom);
	%servers = (%currservers,%server);
	}
	my %by_hostname;
	foreach my $id (keys(%servers)) {
	push(@{$by_hostname{$servers{$id}}},$id);
	}
	foreach my $hostname (sort(keys(%by_hostname))) {
	if (@{$by_hostname{$hostname}} > 1) {
	my $match = 0;
	foreach my $id (@{$by_hostname{$hostname}}) {
	if (&host_domain($id) eq $dom) {
	$uniqservers{$id} = $hostname;
	$match = 1;
	}
	}
	unless ($match) {
	$uniqservers{$by_hostname{$hostname}[0]} = $hostname;
	}
	} else {
	$uniqservers{$by_hostname{$hostname}[0]} = $hostname;
	}
	}
	return %uniqservers;
	}

# ---------------------- Find the homebase for a user from domain's lib servers	# ---------------------- Find the homebase for a user from domain's lib servers

my %homecache;	my %homecache;
Line 1870 sub is_cached_new {	Line 2214 sub is_cached_new {
my ($name,$id,$debug) = @_;	my ($name,$id,$debug) = @_;
$id=&make_key($name,$id);	$id=&make_key($name,$id);
if (exists($remembered{$id})) {	if (exists($remembered{$id})) {
if ($debug) { &Apache::lonnet::logthis("Earyl return $id of $remembered{$id} "); }	if ($debug) { &Apache::lonnet::logthis("Early return $id of $remembered{$id} "); }
$accessed{$id}=[&gettimeofday()];	$accessed{$id}=[&gettimeofday()];
$hits++;	$hits++;
return ($remembered{$id},1);	return ($remembered{$id},1);
Line 2036 sub getversion {	Line 2380 sub getversion {

sub currentversion {	sub currentversion {
my $fname=shift;	my $fname=shift;
my ($result,$cached)=&is_cached_new('resversion',$fname);
if (defined($cached)) { return $result; }
my $author=$fname;	my $author=$fname;
$author=~s/\/home\/httpd\/html\/res\/([^\/])\/([^\/]).*/$1\/$2/;	$author=~s/\/home\/httpd\/html\/res\/([^\/])\/([^\/]).*/$1\/$2/;
my ($udom,$uname)=split(/\//,$author);	my ($udom,$uname)=split(/\//,$author);
my $home=homeserver($uname,$udom);	my $home=&homeserver($uname,$udom);
if ($home eq 'no_host') {	if ($home eq 'no_host') {
return -1;	return -1;
}	}
my $answer=reply("currentversion:$fname",$home);	my $answer=&reply("currentversion:$fname",$home);
if (($answer eq 'con_lost') \|\| ($answer eq 'rejected')) {	if (($answer eq 'con_lost') \|\| ($answer eq 'rejected')) {
return -1;	return -1;
}	}
return &do_cache_new('resversion',$fname,$answer,600);	return $answer;
	}

	#
	# Return special version number of resource if set by override, empty otherwise
	#
	sub usedversion {
	my $fname=shift;
	unless ($fname) { $fname=$env{'request.uri'}; }
	my ($urlversion)=($fname=~/\.(\d+)\.\w+$/);
	if ($urlversion) { return $urlversion; }
	return '';
}	}

# ----------------------------- Subscribe to a resource, return URL if possible	# ----------------------------- Subscribe to a resource, return URL if possible
Line 2077 sub subscribe {	Line 2430 sub subscribe {
sub repcopy {	sub repcopy {
my $filename=shift;	my $filename=shift;
$filename=~s/\/+/\//g;	$filename=~s/\/+/\//g;
if ($filename=~m\|^/home/httpd/html/adm/\|) { return 'ok'; }	my $londocroot = $perlvar{'lonDocRoot'};
if ($filename=~m\|^/home/httpd/html/lonUsers/\|) { return 'ok'; }	if ($filename=~m{^\Q$londocroot/adm/\E}) { return 'ok'; }
if ($filename=~m\|^/home/httpd/html/userfiles/\| or	if ($filename=~m{^\Q$londocroot/lonUsers/\E}) { return 'ok'; }
$filename=~m -^/*(uploaded\|editupload)/-) {	if ($filename=~m{^\Q$londocroot/userfiles/\E} or
	$filename=~m{^/*(uploaded\|editupload)/}) {
return &repcopy_userfile($filename);	return &repcopy_userfile($filename);
}	}
$filename=~s/[\n\r]//g;	$filename=~s/[\n\r]//g;
Line 2107 sub repcopy {	Line 2461 sub repcopy {
unless ($home eq $perlvar{'lonHostID'}) {	unless ($home eq $perlvar{'lonHostID'}) {
my @parts=split(/\//,$filename);	my @parts=split(/\//,$filename);
my $path="/$parts[1]/$parts[2]/$parts[3]/$parts[4]";	my $path="/$parts[1]/$parts[2]/$parts[3]/$parts[4]";
if ($path ne "$perlvar{'lonDocRoot'}/res") {	if ($path ne "$londocroot/res") {
&logthis("Malconfiguration for replication: $filename");	&logthis("Malconfiguration for replication: $filename");
return 'bad_request';	return 'bad_request';
}	}
Line 2311 sub process_coursefile {	Line 2665 sub process_coursefile {
}	}
if (ref($mimetype)) {	if (ref($mimetype)) {
$$mimetype = $type;	$$mimetype = $type;
}	}
}	}
$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,	$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,
$home);	$home);
Line 2429 sub resizeImage {	Line 2783 sub resizeImage {
# input: $formname - the contents of the file are in $env{"form.$formname"}	# input: $formname - the contents of the file are in $env{"form.$formname"}
# the desired filename is in $env{"form.$formname.filename"}	# the desired filename is in $env{"form.$formname.filename"}
# $context - possible values: coursedoc, existingfile, overwrite,	# $context - possible values: coursedoc, existingfile, overwrite,
# canceloverwrite, or ''.	# canceloverwrite, or ''.
# if 'coursedoc': upload to the current course	# if 'coursedoc': upload to the current course
# if 'existingfile': write file to tmp/overwrites directory	# if 'existingfile': write file to tmp/overwrites directory
# if 'canceloverwrite': delete file written to tmp/overwrites directory	# if 'canceloverwrite': delete file written to tmp/overwrites directory
# $context is passed as argument to &finishuserfileupload	# $context is passed as argument to &finishuserfileupload
# $subdir - directory in userfile to store the file into	# $subdir - directory in userfile to store the file into
# $parser - instruction to parse file for objects ($parser = parse)	# $parser - instruction to parse file for objects ($parser = parse)
# $allfiles - reference to hash for embedded objects	# $allfiles - reference to hash for embedded objects
Line 2585 sub finishuserfileupload {	Line 2939 sub finishuserfileupload {
return '/adm/notfound.html';	return '/adm/notfound.html';
}	}
if ($context eq 'overwrite') {	if ($context eq 'overwrite') {
my $source = $perlvar{'lonDaemons'}.'/tmp/overwrites/'.$docudom.'/'.$docuname.'/'.$fname;	my $source = LONCAPA::tempdir().'/overwrites/'.$docudom.'/'.$docuname.'/'.$fname;
my $target = $filepath.'/'.$file;	my $target = $filepath.'/'.$file;
if (-e $source) {	if (-e $source) {
my @info = stat($source);	my @info = stat($source);
if ($info[9] eq $env{'form.timestamp'}) {	if ($info[9] eq $env{'form.timestamp'}) {
unless (&File::Copy::move($source,$target)) {	unless (&File::Copy::move($source,$target)) {
&logthis('Failed to overwrite '.$filepath.'/'.$file);	&logthis('Failed to overwrite '.$filepath.'/'.$file);
return "Moving from $source failed";	return "Moving from $source failed";
Line 2600 sub finishuserfileupload {	Line 2954 sub finishuserfileupload {
} else {	} else {
return "Temporary file: $source missing";	return "Temporary file: $source missing";
}	}
} elsif (!print FH ($env{'form.'.$formname})) {	} elsif (!print FH ($env{'form.'.$formname})) {
&logthis('Failed to write to '.$filepath.'/'.$file);	&logthis('Failed to write to '.$filepath.'/'.$file);
print STDERR ('Failed to write to '.$filepath.'/'.$file."\n");	print STDERR ('Failed to write to '.$filepath.'/'.$file."\n");
return '/adm/notfound.html';	return '/adm/notfound.html';
Line 2985 sub courseacclog {	Line 3339 sub courseacclog {
my $fnsymb=shift;	my $fnsymb=shift;
unless ($env{'request.course.id'}) { return ''; }	unless ($env{'request.course.id'}) { return ''; }
my $what=$fnsymb.':'.$env{'user.name'}.':'.$env{'user.domain'};	my $what=$fnsymb.':'.$env{'user.name'}.':'.$env{'user.domain'};
if ($fnsymb=~/(problem\|exam\|quiz\|assess\|survey\|form\|task\|page)$/) {	if ($fnsymb=~/$LONCAPA::assess_re/) {
$what.=':POST';	$what.=':POST';
# FIXME: Probably ought to escape things....	# FIXME: Probably ought to escape things....
foreach my $key (keys(%env)) {	foreach my $key (keys(%env)) {
Line 3161 sub get_my_roles {	Line 3515 sub get_my_roles {
unless (defined($uname)) { $uname=$env{'user.name'}; }	unless (defined($uname)) { $uname=$env{'user.name'}; }
unless (defined($udom)) { $udom=$env{'user.domain'}; }	unless (defined($udom)) { $udom=$env{'user.domain'}; }
my (%dumphash,%nothide);	my (%dumphash,%nothide);
if ($context eq 'userroles') {	if ($context eq 'userroles') {
my $extra = &freeze_escape({'skipcheck' => 1});	my $extra = &freeze_escape({'skipcheck' => 1});
%dumphash = &dump('roles',$udom,$uname,'.',undef,$extra);	%dumphash = &dump('roles',$udom,$uname,'.',undef,$extra);
} else {	} else {
Line 3223 sub get_my_roles {	Line 3577 sub get_my_roles {
if (!grep(/^cr$/,@{$roles})) {	if (!grep(/^cr$/,@{$roles})) {
next;	next;
}	}
	} elsif ($role =~ /^gr\//) {
	if (!grep(/^gr$/,@{$roles})) {
	next;
	}
} else {	} else {
next;	next;
}	}
Line 3491 sub get_domain_roles {	Line 3849 sub get_domain_roles {
return %personnel;	return %personnel;
}	}

# ----------------------------------------------------------- Check out an item	# ----------------------------------------------------------- Interval timing

sub get_first_access {	sub get_first_access {
my ($type,$argsymb)=@_;	my ($type,$argsymb)=@_;
Line 3527 sub set_first_access {	Line 3885 sub set_first_access {
return 'already_set';	return 'already_set';
}	}

sub checkout {
my ($symb,$tuname,$tudom,$tcrsid)=@_;
my $now=time;
my $lonhost=$perlvar{'lonHostID'};
my $infostr=&escape(
'CHECKOUTTOKEN&'.
$tuname.'&'.
$tudom.'&'.
$tcrsid.'&'.
$symb.'&'.
$now.'&'.$ENV{'REMOTE_ADDR'});
my $token=&reply('tmpput:'.$infostr,$lonhost);
if ($token=~/^error\:/) {
&logthis("<font color=\"blue\">WARNING: ".
"Checkout tmpput failed ".$tudom.' - '.$tuname.' - '.$symb.
"</font>");
return '';
}

$token=~s/^(\d+)\_.\_(\d+)$/$1\$2\*$lonhost/;
$token=~tr/a-z/A-Z/;

my %infohash=('resource.0.outtoken' => $token,
'resource.0.checkouttime' => $now,
'resource.0.outremote' => $ENV{'REMOTE_ADDR'});

unless (&cstore(\%infohash,$symb,$tcrsid,$tudom,$tuname) eq 'ok') {
return '';
} else {
&logthis("<font color=\"blue\">WARNING: ".
"Checkout cstore failed ".$tudom.' - '.$tuname.' - '.$symb.
"</font>");
}

if (&log($tudom,$tuname,&homeserver($tuname,$tudom),
&escape('Checkout '.$infostr.' - '.
$token)) ne 'ok') {
return '';
} else {
&logthis("<font color=\"blue\">WARNING: ".
"Checkout log failed ".$tudom.' - '.$tuname.' - '.$symb.
"</font>");
}
return $token;
}

# ------------------------------------------------------------ Check in an item

sub checkin {
my $token=shift;
my $now=time;
my ($ta,$tb,$lonhost)=split(/\*/,$token);
$lonhost=~tr/A-Z/a-z/;
my $dtoken=$ta.'_'.&hostname($lonhost).'_'.$tb;
$dtoken=~s/\W/\_/g;
my ($dummy,$tuname,$tudom,$tcrsid,$symb,$chtim,$rmaddr)=
split(/\&/,&unescape(&reply('tmpget:'.$dtoken,$lonhost)));

unless (($tuname) && ($tudom)) {
&logthis('Check in '.$token.' ('.$dtoken.') failed');
return '';
}

unless (&allowed('mgr',$tcrsid)) {
&logthis('Check in '.$token.' ('.$dtoken.') unauthorized: '.
$env{'user.name'}.' - '.$env{'user.domain'});
return '';
}

my %infohash=('resource.0.intoken' => $token,
'resource.0.checkintime' => $now,
'resource.0.inremote' => $ENV{'REMOTE_ADDR'});

unless (&cstore(\%infohash,$symb,$tcrsid,$tudom,$tuname) eq 'ok') {
return '';
}

if (&log($tudom,$tuname,&homeserver($tuname,$tudom),
&escape('Checkin - '.$token)) ne 'ok') {
return '';
}

return ($symb,$tuname,$tudom,$tcrsid);
}

# --------------------------------------------- Set Expire Date for Spreadsheet	# --------------------------------------------- Set Expire Date for Spreadsheet

sub expirespread {	sub expirespread {
Line 3716 sub hashref2str {	Line 3989 sub hashref2str {
$result.='=';	$result.='=';
#print("Got a ref of ".(ref($key))." skipping.");	#print("Got a ref of ".(ref($key))." skipping.");
} else {	} else {
if (defined($key)) {$result.=&escape($key).'=';} else { last; }	if (defined($key)) {$result.=&escape($key).'=';} else { last; }
}	}

if(ref($hashref->{$key}) eq 'ARRAY') {	if(ref($hashref->{$key}) eq 'ARRAY') {
Line 3868 sub tmpreset {	Line 4141 sub tmpreset {
if ($domain eq 'public' && $stuname eq 'public') {	if ($domain eq 'public' && $stuname eq 'public') {
$stuname=$ENV{'REMOTE_ADDR'};	$stuname=$ENV{'REMOTE_ADDR'};
}	}
my $path=$perlvar{'lonDaemons'}.'/tmp';	my $path=LONCAPA::tempdir();
my %hash;	my %hash;
if (tie(%hash,'GDBM_File',	if (tie(%hash,'GDBM_File',
$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',	$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',
Line 3907 sub tmpstore {	Line 4180 sub tmpstore {
}	}
my $now=time;	my $now=time;
my %hash;	my %hash;
my $path=$perlvar{'lonDaemons'}.'/tmp';	my $path=LONCAPA::tempdir();
if (tie(%hash,'GDBM_File',	if (tie(%hash,'GDBM_File',
$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',	$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',
&GDBM_WRCREAT(),0640)) {	&GDBM_WRCREAT(),0640)) {
Line 3953 sub tmprestore {	Line 4226 sub tmprestore {
$namespace=~s/\//\_/g;	$namespace=~s/\//\_/g;
$namespace=~s/\W//g;	$namespace=~s/\W//g;
my %hash;	my %hash;
my $path=$perlvar{'lonDaemons'}.'/tmp';	my $path=LONCAPA::tempdir();
if (tie(%hash,'GDBM_File',	if (tie(%hash,'GDBM_File',
$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',	$path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',
&GDBM_READER(),0640)) {	&GDBM_READER(),0640)) {
Line 4090 sub restore {	Line 4363 sub restore {
}	}

# ---------------------------------------------------------- Course Description	# ---------------------------------------------------------- Course Description
	#
	#

sub coursedescription {	sub coursedescription {
my ($courseid,$args)=@_;	my ($courseid,$args)=@_;
Line 4119 sub coursedescription {	Line 4394 sub coursedescription {
return %returnhash;	return %returnhash;
}	}

# get the data agin	# get the data again

if (!$args->{'one_time'}) {	if (!$args->{'one_time'}) {
$envhash{'course.'.$normalid.'.last_cache'}=time;	$envhash{'course.'.$normalid.'.last_cache'}=time;
}	}
Line 4127 sub coursedescription {	Line 4403 sub coursedescription {
if ($chome ne 'no_host') {	if ($chome ne 'no_host') {
%returnhash=&dump('environment',$cdomain,$cnum);	%returnhash=&dump('environment',$cdomain,$cnum);
if (!exists($returnhash{'con_lost'})) {	if (!exists($returnhash{'con_lost'})) {
	my $username = $env{'user.name'}; # Defult username
	if(defined $args->{'user'}) {
	$username = $args->{'user'};
	}
$returnhash{'home'}= $chome;	$returnhash{'home'}= $chome;
$returnhash{'domain'} = $cdomain;	$returnhash{'domain'} = $cdomain;
$returnhash{'num'} = $cnum;	$returnhash{'num'} = $cnum;
Line 4137 sub coursedescription {	Line 4417 sub coursedescription {
$envhash{'course.'.$normalid.'.'.$name}=$value;	$envhash{'course.'.$normalid.'.'.$name}=$value;
}	}
$returnhash{'url'}=&clutter($returnhash{'url'});	$returnhash{'url'}=&clutter($returnhash{'url'});
$returnhash{'fn'}=$perlvar{'lonDaemons'}.'/tmp/'.	$returnhash{'fn'}=LONCAPA::tempdir() .
$env{'user.name'}.'_'.$cdomain.'_'.$cnum;	$username.'_'.$cdomain.'_'.$cnum;
$envhash{'course.'.$normalid.'.home'}=$chome;	$envhash{'course.'.$normalid.'.home'}=$chome;
$envhash{'course.'.$normalid.'.domain'}=$cdomain;	$envhash{'course.'.$normalid.'.domain'}=$cdomain;
$envhash{'course.'.$normalid.'.num'}=$cnum;	$envhash{'course.'.$normalid.'.num'}=$cnum;
Line 4235 sub rolesinit {	Line 4515 sub rolesinit {
}	}
my %allroles=();	my %allroles=();
my %allgroups=();	my %allgroups=();
my $group_privs;

if ($rolesdump ne '') {	if ($rolesdump ne '') {
foreach my $entry (split(/&/,$rolesdump)) {	foreach my $entry (split(/&/,$rolesdump)) {
Line 4252 sub rolesinit {	Line 4531 sub rolesinit {
}	}
} elsif ($role =~ m\|^gr/\|) {	} elsif ($role =~ m\|^gr/\|) {
($trole,$tend,$tstart) = split(/_/,$role);	($trole,$tend,$tstart) = split(/_/,$role);
	next if ($tstart eq '-1');
($trole,$group_privs) = split(/\//,$trole);	($trole,$group_privs) = split(/\//,$trole);
$group_privs = &unescape($group_privs);	$group_privs = &unescape($group_privs);
} else {	} else {
Line 4356 sub set_userprivs {	Line 4636 sub set_userprivs {
my $adv=0;	my $adv=0;
my %grouproles = ();	my %grouproles = ();
if (keys(%{$allgroups}) > 0) {	if (keys(%{$allgroups}) > 0) {
my @groupkeys;	my @groupkeys;
foreach my $role (keys(%{$allroles})) {	foreach my $role (keys(%{$allroles})) {
push(@groupkeys,$role);	push(@groupkeys,$role);
}	}
Line 4404 sub set_userprivs {	Line 4684 sub set_userprivs {
}	}
}	}
my $thesestr='';	my $thesestr='';
foreach my $priv (keys(%thesepriv)) {	foreach my $priv (sort(keys(%thesepriv))) {
$thesestr.=':'.$priv.'&'.$thesepriv{$priv};	$thesestr.=':'.$priv.'&'.$thesepriv{$priv};
}	}
$userroles->{'user.priv.'.$role} = $thesestr;	$userroles->{'user.priv.'.$role} = $thesestr;
Line 4413 sub set_userprivs {	Line 4693 sub set_userprivs {
}	}

sub role_status {	sub role_status {
my ($rolekey,$then,$refresh,$now,$role,$where,$trolecode,$tstatus,$tstart,$tend) = @_;	my ($rolekey,$update,$refresh,$now,$role,$where,$trolecode,$tstatus,$tstart,$tend) = @_;
my @pwhere = ();	my @pwhere = ();
if (exists($env{$rolekey}) && $env{$rolekey} ne '') {	if (exists($env{$rolekey}) && $env{$rolekey} ne '') {
(undef,undef,$$role,@pwhere)=split(/\./,$rolekey);	(undef,undef,$$role,@pwhere)=split(/\./,$rolekey);
Line 4422 sub role_status {	Line 4702 sub role_status {
$$trolecode=$$role.'.'.$$where;	$$trolecode=$$role.'.'.$$where;
($$tstart,$$tend)=split(/\./,$env{$rolekey});	($$tstart,$$tend)=split(/\./,$env{$rolekey});
$$tstatus='is';	$$tstatus='is';
if ($$tstart && $$tstart>$then) {	if ($$tstart && $$tstart>$update) {
$$tstatus='future';	$$tstatus='future';
if ($$tstart<$now) {	if ($$tstart<$now) {
if ($$tstart && $$tstart>$refresh) {	if ($$tstart && $$tstart>$refresh) {
Line 4432 sub role_status {	Line 4712 sub role_status {
my %userroles = (	my %userroles = (
'user.role.'.$$role.'.'.$$where => $$tstart.'.'.$$tend	'user.role.'.$$role.'.'.$$where => $$tstart.'.'.$$tend
);	);
@rolecodes = ('cm');	@rolecodes = ('cm');
my $spec=$$role.'.'.$$where;	my $spec=$$role.'.'.$$where;
my ($tdummy,$tdomain,$trest)=split(/\//,$$where);	my ($tdummy,$tdomain,$trest)=split(/\//,$$where);
if ($$role =~ /^cr\//) {	if ($$role =~ /^cr\//) {
Line 4447 sub role_status {	Line 4727 sub role_status {
$group_privs = &unescape($group_privs);	$group_privs = &unescape($group_privs);
&group_roleprivs(\%allgroups,$$where,$group_privs,$$tend,$$tstart);	&group_roleprivs(\%allgroups,$$where,$group_privs,$$tend,$$tstart);
my %course_roles = &get_my_roles($env{'user.name'},$env{'user.domain'},'userroles',['active'],['cc','co','in','ta','ep','ad','st','cr'],[$tdomain],1);	my %course_roles = &get_my_roles($env{'user.name'},$env{'user.domain'},'userroles',['active'],['cc','co','in','ta','ep','ad','st','cr'],[$tdomain],1);
if (keys(%course_roles) > 0) {	&get_groups_roles($tdomain,$trest,
my ($tnum) = ($trest =~ /^($match_courseid)/);	\%course_roles,\@rolecodes,
if ($tdomain ne '' && $tnum ne '') {	\%groups_roles);
foreach my $key (keys(%course_roles)) {
if ($key =~ /^\Q$tnum\E:\Q$tdomain\E:([^:]+):?([^:]*)/) {
my $crsrole = $1;
my $crssec = $2;
if ($crsrole =~ /^cr/) {
unless (grep(/^cr$/,@rolecodes)) {
push(@rolecodes,'cr');
}
} else {
unless(grep(/^\Q$crsrole\E$/,@rolecodes)) {
push(@rolecodes,$crsrole);
}
}
my $rolekey = $crsrole.'./'.$tdomain.'/'.$tnum;
if ($crssec ne '') {
$rolekey .= '/'.$crssec;
}
$rolekey .= './';
$groups_roles{$rolekey} = \@rolecodes;
}
}
}
}
} else {	} else {
push(@rolecodes,$$role);	push(@rolecodes,$$role);
&standard_roleprivs(\%allroles,$$role,$tdomain,$spec,$trest,$$where);	&standard_roleprivs(\%allroles,$$role,$tdomain,$spec,$trest,$$where);
Line 4486 sub role_status {	Line 4743 sub role_status {
}	}
}	}
if ($$tend) {	if ($$tend) {
if ($$tend<$then) {	if ($$tend<$update) {
$$tstatus='expired';	$$tstatus='expired';
} elsif ($$tend<$now) {	} elsif ($$tend<$now) {
$$tstatus='will_not';	$$tstatus='will_not';
Line 4496 sub role_status {	Line 4753 sub role_status {
}	}
}	}

	sub get_groups_roles {
	my ($cdom,$rest,$cdom_courseroles,$rolecodes,$groups_roles) = @_;
	return unless((ref($cdom_courseroles) eq 'HASH') &&
	(ref($rolecodes) eq 'ARRAY') &&
	(ref($groups_roles) eq 'HASH'));
	if (keys(%{$cdom_courseroles}) > 0) {
	my ($cnum) = ($rest =~ /^($match_courseid)/);
	if ($cdom ne '' && $cnum ne '') {
	foreach my $key (keys(%{$cdom_courseroles})) {
	if ($key =~ /^\Q$cnum\E:\Q$cdom\E:([^:]+):?([^:]*)/) {
	my $crsrole = $1;
	my $crssec = $2;
	if ($crsrole =~ /^cr/) {
	unless (grep(/^cr$/,@{$rolecodes})) {
	push(@{$rolecodes},'cr');
	}
	} else {
	unless(grep(/^\Q$crsrole\E$/,@{$rolecodes})) {
	push(@{$rolecodes},$crsrole);
	}
	}
	my $rolekey = "$crsrole./$cdom/$cnum";
	if ($crssec ne '') {
	$rolekey .= "/$crssec";
	}
	$rolekey .= './';
	$groups_roles->{$rolekey} = $rolecodes;
	}
	}
	}
	}
	return;
	}

	sub delete_env_groupprivs {
	my ($where,$courseroles,$possroles) = @_;
	return unless((ref($courseroles) eq 'HASH') && (ref($possroles) eq 'ARRAY'));
	my ($dummy,$udom,$uname,$group) = split(/\//,$where);
	unless (ref($courseroles->{$udom}) eq 'HASH') {
	%{$courseroles->{$udom}} =
	&get_my_roles('','','userroles',['active'],
	$possroles,[$udom],1);
	}
	if (ref($courseroles->{$udom}) eq 'HASH') {
	foreach my $item (keys(%{$courseroles->{$udom}})) {
	my ($cnum,$cdom,$crsrole,$crssec) = split(/:/,$item);
	my $area = '/'.$cdom.'/'.$cnum;
	my $privkey = "user.priv.$crsrole.$area";
	if ($crssec ne '') {
	$privkey .= '/'.$crssec;
	}
	$privkey .= ".$area/$group";
	&Apache::lonnet::delenv($privkey,undef,[$crsrole]);
	}
	}
	return;
	}

sub check_adhoc_privs {	sub check_adhoc_privs {
my ($cdom,$cnum,$then,$refresh,$now,$checkrole,$caller) = @_;	my ($cdom,$cnum,$update,$refresh,$now,$checkrole,$caller) = @_;
my $cckey = 'user.role.'.$checkrole.'./'.$cdom.'/'.$cnum;	my $cckey = 'user.role.'.$checkrole.'./'.$cdom.'/'.$cnum;
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,$then,$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);
}	}
Line 4592 sub dump {	Line 4907 sub dump {
my $rep=&reply("dump:$udomain:$uname:$namespace:$regexp:$range:$extra",$uhome);	my $rep=&reply("dump:$udomain:$uname:$namespace:$regexp:$range:$extra",$uhome);
my @pairs=split(/\&/,$rep);	my @pairs=split(/\&/,$rep);
my %returnhash=();	my %returnhash=();
foreach my $item (@pairs) {	if (!($rep =~ /^error/ )) {
my ($key,$value)=split(/=/,$item,2);	foreach my $item (@pairs) {
$key = &unescape($key);	my ($key,$value)=split(/=/,$item,2);
next if ($key =~ /^error: 2 /);	$key = &unescape($key);
$returnhash{$key}=&thaw_unescape($value);	next if ($key =~ /^error: 2 /);
	$returnhash{$key}=&thaw_unescape($value);
	}
}	}
return %returnhash;	return %returnhash;
}	}


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

sub dumpstore {	sub dumpstore {
Line 4883 sub tmpget {	Line 5201 sub tmpget {
return %returnhash;	return %returnhash;
}	}

# ------------------------------------------------------------ tmpget interface	# ------------------------------------------------------------ tmpdel interface
sub tmpdel {	sub tmpdel {
my ($token,$server)=@_;	my ($token,$server)=@_;
if (!defined($server)) { $server = $perlvar{'lonHostID'}; }	if (!defined($server)) { $server = $perlvar{'lonHostID'}; }
Line 5134 sub is_portfolio_file {	Line 5452 sub is_portfolio_file {
}	}

sub usertools_access {	sub usertools_access {
my ($uname,$udom,$tool,$action,$context,$userenvref,$domdefref,$is_advref) = @_;	my ($uname,$udom,$tool,$action,$context,$userenvref,$domdefref,$is_advref)=@_;
my ($access,%tools);	my ($access,%tools);
if ($context eq '') {	if ($context eq '') {
$context = 'tools';	$context = 'tools';
Line 5281 sub is_advanced_user {	Line 5599 sub is_advanced_user {
my ($udom,$uname) = @_;	my ($udom,$uname) = @_;
if ($udom ne '' && $uname ne '') {	if ($udom ne '' && $uname ne '') {
if (($udom eq $env{'user.domain'}) && ($uname eq $env{'user.name'})) {	if (($udom eq $env{'user.domain'}) && ($uname eq $env{'user.name'})) {
return $env{'user.adv'};	if (wantarray) {
	return ($env{'user.adv'},$env{'user.author'});
	} else {
	return $env{'user.adv'};
	}
}	}
}	}
my %roleshash = &get_my_roles($uname,$udom,'userroles',undef,undef,undef,1);	my %roleshash = &get_my_roles($uname,$udom,'userroles',undef,undef,undef,1);
my %allroles;	my %allroles;
my $is_adv;	my ($is_adv,$is_author);
foreach my $role (keys(%roleshash)) {	foreach my $role (keys(%roleshash)) {
my ($trest,$tdomain,$trole,$sec) = split(/:/,$role);	my ($trest,$tdomain,$trole,$sec) = split(/:/,$role);
my $area = '/'.$tdomain.'/'.$trest;	my $area = '/'.$tdomain.'/'.$trest;
Line 5300 sub is_advanced_user {	Line 5622 sub is_advanced_user {
} elsif ($trole ne 'gr') {	} elsif ($trole ne 'gr') {
&standard_roleprivs(\%allroles,$trole,$tdomain,$spec,$trest,$area);	&standard_roleprivs(\%allroles,$trole,$tdomain,$spec,$trest,$area);
}	}
	if ($trole eq 'au') {
	$is_author = 1;
	}
}	}
}	}
foreach my $role (keys(%allroles)) {	foreach my $role (keys(%allroles)) {
Line 5314 sub is_advanced_user {	Line 5639 sub is_advanced_user {
}	}
}	}
}	}
	if (wantarray) {
	return ($is_adv,$is_author);
	}
return $is_adv;	return $is_adv;
}	}

Line 5584 sub allowed {	Line 5912 sub allowed {
}	}
}	}

	# User who is not author or co-author might still be able to edit
	# resource of an author in the domain (e.g., if Domain Coordinator).
	if (($priv eq 'eco') && ($thisallowed eq '') && ($env{'request.course.id'}) &&
	(&allowed('mdc',$env{'request.course.id'}))) {
	if ($env{"user.priv.cm./$uri/"}=~/\Q$priv\E\&([^\:]*)/) {
	$thisallowed.=$1;
	}
	}

# Course: uri itself is a course	# Course: uri itself is a course
my $courseuri=$uri;	my $courseuri=$uri;
$courseuri=~s/\_(\d)/\/$1/;	$courseuri=~s/\_(\d)/\/$1/;
Line 5799 sub allowed {	Line 6136 sub allowed {
my $unamedom=$env{'user.name'}.':'.$env{'user.domain'};	my $unamedom=$env{'user.name'}.':'.$env{'user.domain'};
if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.roles.denied'}	if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.roles.denied'}
=~/\Q$rolecode\E/) {	=~/\Q$rolecode\E/) {
if (($priv ne 'pch') && ($priv ne 'plc')) {	if (($priv ne 'pch') && ($priv ne 'plc')) {
&logthis($env{'user.domain'}.':'.$env{'user.name'}.':'.$env{'user.home'}.':'.	&logthis($env{'user.domain'}.':'.$env{'user.name'}.':'.$env{'user.home'}.':'.
'Denied by role: '.$priv.' for '.$uri.' as '.$rolecode.' in '.	'Denied by role: '.$priv.' for '.$uri.' as '.$rolecode.' in '.
$env{'request.course.id'});	$env{'request.course.id'});
Line 5809 sub allowed {	Line 6146 sub allowed {

if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.users.denied'}	if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.users.denied'}
=~/\Q$unamedom\E/) {	=~/\Q$unamedom\E/) {
if (($priv ne 'pch') && ($priv ne 'plc')) {	if (($priv ne 'pch') && ($priv ne 'plc')) {
&logthis($env{'user.domain'}.':'.$env{'user.name'}.':'.$env{'user.home'}.	&logthis($env{'user.domain'}.':'.$env{'user.name'}.':'.$env{'user.home'}.
'Denied by user: '.$priv.' for '.$uri.' as '.$unamedom.' in '.	'Denied by user: '.$priv.' for '.$uri.' as '.$unamedom.' in '.
$env{'request.course.id'});	$env{'request.course.id'});
Line 5823 sub allowed {	Line 6160 sub allowed {
if ($thisallowed=~/R/) {	if ($thisallowed=~/R/) {
my $rolecode=(split(/\./,$env{'request.role'}))[0];	my $rolecode=(split(/\./,$env{'request.role'}))[0];
if (&metadata($uri,'roledeny')=~/\Q$rolecode\E/) {	if (&metadata($uri,'roledeny')=~/\Q$rolecode\E/) {
if (($priv ne 'pch') && ($priv ne 'plc')) {	if (($priv ne 'pch') && ($priv ne 'plc')) {
&logthis($env{'user.domain'}.':'.$env{'user.name'}.':'.$env{'user.home'}.':'.	&logthis($env{'user.domain'}.':'.$env{'user.name'}.':'.$env{'user.home'}.':'.
'Denied by role: '.$priv.' for '.$uri.' as '.$rolecode);	'Denied by role: '.$priv.' for '.$uri.' as '.$rolecode);
}	}
Line 5854 sub allowed {	Line 6191 sub allowed {
}	}
return 'F';	return 'F';
}	}
	#
	# Removes the versino from a URI and
	# splits it in to its filename and path to the filename.
	# Seems like File::Basename could have done this more clearly.
	# Parameters:
	# $uri - input URI
	# Returns:
	# Two element list consisting of
	# $pathname - the URI up to and excluding the trailing /
	# $filename - The part of the URI following the last /
	# NOTE:
	# Another realization of this is simply:
	# use File::Basename;
	# ...
	# $uri = shift;
	# $filename = basename($uri);
	# $path = dirname($uri);
	# return ($filename, $path);
	#
	# The implementation below is probably faster however.
	#
sub split_uri_for_cond {	sub split_uri_for_cond {
my $uri=&deversion(&declutter(shift));	my $uri=&deversion(&declutter(shift));
my @uriparts=split(/\//,$uri);	my @uriparts=split(/\//,$uri);
Line 6050 sub fetch_enrollment_query {	Line 6407 sub fetch_enrollment_query {
$$replyref{$key} = $value;	$$replyref{$key} = $value;
}	}
} else {	} else {
my $pathname = $perlvar{'lonDaemons'}.'/tmp';	my $pathname = LONCAPA::tempdir();
foreach my $line (@responses) {	foreach my $line (@responses) {
my ($key,$value) = split(/=/,$line);	my ($key,$value) = split(/=/,$line);
$$replyref{$key} = $value;	$$replyref{$key} = $value;
Line 6080 sub fetch_enrollment_query {	Line 6437 sub fetch_enrollment_query {

sub get_query_reply {	sub get_query_reply {
my $queryid=shift;	my $queryid=shift;
my $replyfile=$perlvar{'lonDaemons'}.'/tmp/'.$queryid;	my $replyfile=LONCAPA::tempdir().$queryid;
my $reply='';	my $reply='';
for (1..100) {	for (1..100) {
sleep 2;	sleep 2;
Line 6931 sub modifyuser {	Line 7288 sub modifyuser {
}	}
&logthis('Call to modify user '.$udom.', '.$uname.', '.$uid.', '.	&logthis('Call to modify user '.$udom.', '.$uname.', '.$uid.', '.
$umode.', '.$first.', '.$middle.', '.	$umode.', '.$first.', '.$middle.', '.
$last.', '.$gene.'(forceid: '.$forceid.'; candelete: '.$showcandelete.')'.	$last.', '.$gene.'(forceid: '.$forceid.'; candelete: '.$showcandelete.')'.
(defined($desiredhome) ? ' desiredhome = '.$desiredhome :	(defined($desiredhome) ? ' desiredhome = '.$desiredhome :
' desiredhome not specified').	' desiredhome not specified').
' by '.$env{'user.name'}.' at '.$env{'user.domain'}.	' by '.$env{'user.name'}.' at '.$env{'user.domain'}.
Line 7077 sub modifyuser {	Line 7434 sub modifyuser {
return 'ok';	return 'ok';
}	}
my $reply = &put('environment', \%names, $udom,$uname);	my $reply = &put('environment', \%names, $udom,$uname);
if ($reply ne 'ok') {	if ($reply ne 'ok') {
return 'error: '.$reply;	return 'error: '.$reply;
}	}
if ($names{'permanentemail'} ne $oldnames{'permanentemail'}) {	if ($names{'permanentemail'} ne $oldnames{'permanentemail'}) {
Line 7158 sub modify_student_enrollment {	Line 7515 sub modify_student_enrollment {
$uid = $tmp{'id'} if (!defined($uid) \|\| $uid eq '');	$uid = $tmp{'id'} if (!defined($uid) \|\| $uid eq '');
}	}
my $fullname = &format_name($first,$middle,$last,$gene,'lastname');	my $fullname = &format_name($first,$middle,$last,$gene,'lastname');
	my $user = "$uname:$udom";
	my %old_entry = &Apache::lonnet::get('classlist',[$user],$cdom,$cnum);
my $reply=cput('classlist',	my $reply=cput('classlist',
{"$uname:$udom" =>	{$user =>
join(':',$end,$start,$uid,$usec,$fullname,$type,$locktype) },	join(':',$end,$start,$uid,$usec,$fullname,$type,$locktype) },
$cdom,$cnum);	$cdom,$cnum);
unless (($reply eq 'ok') \|\| ($reply eq 'delayed')) {	if (($reply eq 'ok') \|\| ($reply eq 'delayed')) {
	&devalidate_getsection_cache($udom,$uname,$cid);
	} else {
return 'error: '.$reply;	return 'error: '.$reply;
} else {
&devalidate_getsection_cache($udom,$uname,$cid);
}	}
# Add student role to user	# Add student role to user
my $uurl='/'.$cid;	my $uurl='/'.$cid;
Line 7173 sub modify_student_enrollment {	Line 7532 sub modify_student_enrollment {
if ($usec) {	if ($usec) {
$uurl.='/'.$usec;	$uurl.='/'.$usec;
}	}
return &assignrole($udom,$uname,$uurl,'st',$end,$start,undef,$selfenroll,$context);	my $result = &assignrole($udom,$uname,$uurl,'st',$end,$start,undef,
	$selfenroll,$context);
	if ($result ne 'ok') {
	if ($old_entry{$user} ne '') {
	$reply = &cput('classlist',\%old_entry,$cdom,$cnum);
	} else {
	$reply = &del('classlist',[$user],$cdom,$cnum);
	}
	}
	return $result;
}	}

sub format_name {	sub format_name {
Line 7459 sub is_locked {	Line 7827 sub is_locked {
my ($file_name, $domain, $user, $which) = @_;	my ($file_name, $domain, $user, $which) = @_;
my @check;	my @check;
my $is_locked;	my $is_locked;
push(@check,$file_name);	push (@check,$file_name);
my %locked = &get('file_permissions',\@check,	my %locked = &get('file_permissions',\@check,
$env{'user.domain'},$env{'user.name'});	$env{'user.domain'},$env{'user.name'});
my ($tmp)=keys(%locked);	my ($tmp)=keys(%locked);
Line 7524 sub save_selected_files {	Line 7892 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, '>'.$Apache::lonnet::perlvar{'lonDaemons'}.'/tmp/'.$filename);	open (OUT, '>'.LONCAPA::tempdir().$filename);
print (OUT undef);	print (OUT undef);
close (OUT);	close (OUT);
return ("ok");	return ("ok");
Line 7534 sub files_in_path {	Line 7902 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, '<'.$Apache::lonnet::perlvar{'lonDaemons'}.'/tmp/'.$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 7556 sub files_not_in_path {	Line 7924 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, '<'.$Apache::lonnet::perlvar{'lonDaemons'}.'/tmp/'.$filename);	open(IN, '<'.LONCAPA::.$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 7904 sub dirlist {	Line 8272 sub dirlist {

if($udom) {	if($udom) {
if($uname) {	if($uname) {
	my $uhome = &homeserver($uname,$udom);
	if ($uhome eq 'no_host') {
	return ([],'no_host');
	}
$listing = &reply('ls3:'.&escape('/'.$uri).':'.$getpropath.':'	$listing = &reply('ls3:'.&escape('/'.$uri).':'.$getpropath.':'
.$getuserdir.':'.&escape($dirRoot)	.$getuserdir.':'.&escape($dirRoot)
.':'.&escape($uname).':'.&escape($udom),	.':'.&escape($uname).':'.&escape($udom),$uhome);
&homeserver($uname,$udom));
if ($listing eq 'unknown_cmd') {	if ($listing eq 'unknown_cmd') {
$listing = &reply('ls2:'.$dirRoot.'/'.$uri,	$listing = &reply('ls2:'.$dirRoot.'/'.$uri,$uhome);
&homeserver($uname,$udom));
} else {	} else {
@listing_results = map { &unescape($_); } split(/:/,$listing);	@listing_results = map { &unescape($_); } split(/:/,$listing);
}	}
if ($listing eq 'unknown_cmd') {	if ($listing eq 'unknown_cmd') {
$listing = &reply('ls:'.$dirRoot.'/'.$uri,	$listing = &reply('ls:'.$dirRoot.'/'.$uri,$uhome);
&homeserver($uname,$udom));
@listing_results = split(/:/,$listing);	@listing_results = split(/:/,$listing);
} else {	} else {
@listing_results = map { &unescape($_); } split(/:/,$listing);	@listing_results = map { &unescape($_); } split(/:/,$listing);
}	}
return @listing_results;	if (($listing eq 'no_such_host') \|\| ($listing eq 'con_lost') \|\|
	($listing eq 'rejected') \|\| ($listing eq 'refused') \|\|
	($listing eq 'no_such_dir') \|\| ($listing eq 'empty')) {
	return ([],$listing);
	} else {
	return (\@listing_results);
	}
} elsif(!$alternateRoot) {	} elsif(!$alternateRoot) {
my %allusers;	my (%allusers,%listerror);
my %servers = &get_servers($udom,'library');	my %servers = &get_servers($udom,'library');
foreach my $tryserver (keys(%servers)) {	foreach my $tryserver (keys(%servers)) {
$listing = &reply('ls3:'.&escape("/res/$udom").':::::'.	$listing = &reply('ls3:'.&escape("/res/$udom").':::::'.
Line 7942 sub dirlist {	Line 8317 sub dirlist {
@listing_results =	@listing_results =
map { &unescape($_); } split(/:/,$listing);	map { &unescape($_); } split(/:/,$listing);
}	}
if ($listing_results[0] ne 'no_such_dir' &&	if (($listing eq 'no_such_host') \|\| ($listing eq 'con_lost') \|\|
$listing_results[0] ne 'empty' &&	($listing eq 'rejected') \|\| ($listing eq 'refused') \|\|
$listing_results[0] ne 'con_lost') {	($listing eq 'no_such_dir') \|\| ($listing eq 'empty')) {
	$listerror{$tryserver} = $listing;
	} else {
foreach my $line (@listing_results) {	foreach my $line (@listing_results) {
my ($entry) = split(/&/,$line,2);	my ($entry) = split(/&/,$line,2);
$allusers{$entry} = 1;	$allusers{$entry} = 1;
}	}
}	}
}	}
my $alluserstr='';	my @alluserslist=();
foreach my $user (sort(keys(%allusers))) {	foreach my $user (sort(keys(%allusers))) {
$alluserstr.=$user.'&user:';	push(@alluserslist,$user.'&user');
}	}
$alluserstr=~s/:$//;	return (\@alluserslist);
return split(/:/,$alluserstr);
} else {	} else {
return ('missing user name');	return ([],'missing username');
}	}
} elsif(!defined($getpropath)) {	} elsif(!defined($getpropath)) {
my @all_domains = sort(&all_domains());	my $path = $perlvar{'lonDocRoot'}.'/res/';
foreach my $domain (@all_domains) {	my @all_domains = map { $path.$_.'/&domain'; } (sort(&all_domains()));
$domain = $perlvar{'lonDocRoot'}.'/res/'.$domain.'/&domain';	return (\@all_domains);
}
return @all_domains;
} else {	} else {
return ('missing domain');	return ([],'missing domain');
}	}
}	}

Line 7980 sub GetFileTimestamp {	Line 8354 sub GetFileTimestamp {
my ($studentDomain,$studentName,$filename,$getuserdir)=@_;	my ($studentDomain,$studentName,$filename,$getuserdir)=@_;
$studentDomain = &LONCAPA::clean_domain($studentDomain);	$studentDomain = &LONCAPA::clean_domain($studentDomain);
$studentName = &LONCAPA::clean_username($studentName);	$studentName = &LONCAPA::clean_username($studentName);
my ($fileStat) =	my ($fileref,$error) = &dirlist($filename,$studentDomain,$studentName,
&Apache::lonnet::dirlist($filename,$studentDomain,$studentName,	undef,$getuserdir);
undef,$getuserdir);	if (($error eq 'empty') \|\| ($error eq 'no_such_dir')) {
my @stats = split('&', $fileStat);	return -1;
if($stats[0] ne 'empty' && $stats[0] ne 'no_such_dir') {	}
	if (ref($fileref) eq 'ARRAY') {
	my @stats = split('&',$fileref->[0]);
# @stats contains first the filename, then the stat output	# @stats contains first the filename, then the stat output
return $stats[10]; # so this is 10 instead of 9.	return $stats[10]; # so this is 10 instead of 9.
} else {	} else {
Line 8016 sub stat_file {	Line 8392 sub stat_file {
if ($file =~ /^userfiles\//) {	if ($file =~ /^userfiles\//) {
$getpropath = 1;	$getpropath = 1;
}	}
my ($result) = &dirlist($file,$udom,$uname,$getpropath);	my ($listref,$error) = &dirlist($file,$udom,$uname,$getpropath);
my @stats = split('&', $result);	if (($error eq 'empty') \|\| ($error eq 'no_such_dir')) {
	return ();
if($stats[0] ne 'empty' && $stats[0] ne 'no_such_dir') {	} else {
shift(@stats); #filename is first	if (ref($listref) eq 'ARRAY') {
return @stats;	my @stats = split('&',$listref->[0]);
	shift(@stats); #filename is first
	return @stats;
	}
}	}
return ();	return ();
}	}
Line 8342 sub EXT {	Line 8721 sub EXT {
} elsif ($realm eq 'request') {	} elsif ($realm eq 'request') {
# ------------------------------------------------------------- request.browser	# ------------------------------------------------------------- request.browser
if ($space eq 'browser') {	if ($space eq 'browser') {
if ($qualifier eq 'textremote') {	return $env{'browser.'.$qualifier};
if (&Apache::lonlocal::mt('textual_remote_display') eq 'on') {
return 1;
} else {
return 0;
}
} else {
return $env{'browser.'.$qualifier};
}
# ------------------------------------------------------------ request.filename	# ------------------------------------------------------------ request.filename
} else {	} else {
return $env{'request.'.$spacequalifierrest};	return $env{'request.'.$spacequalifierrest};
Line 8623 sub add_prefix_and_part {	Line 8994 sub add_prefix_and_part {
# ---------------------------------------------------------------- Get metadata	# ---------------------------------------------------------------- Get metadata

my %metaentry;	my %metaentry;
	my %importedpartids;
sub metadata {	sub metadata {
my ($uri,$what,$liburi,$prefix,$depthcount)=@_;	my ($uri,$what,$liburi,$prefix,$depthcount)=@_;
$uri=&declutter($uri);	$uri=&declutter($uri);
Line 8633 sub metadata {	Line 9005 sub metadata {
($uri =~ m\|/$\|) \|\| ($uri =~ m\|/.meta$\|) \|\| ($uri =~ m{^/*uploaded/.+\.sequence$})) {	($uri =~ m\|/$\|) \|\| ($uri =~ m\|/.meta$\|) \|\| ($uri =~ m{^/*uploaded/.+\.sequence$})) {
return undef;	return undef;
}	}
if (($uri =~ /^~/ \|\| $uri =~ m{home/$match_username/public_html/})	if (($uri =~ /^priv/ \|\| $uri=~/home\/httpd\/html\/priv/)
&& &Apache::lonxml::get_state('target') =~ /^(\|meta)$/) {	&& &Apache::lonxml::get_state('target') =~ /^(\|meta)$/) {
return undef;	return undef;
}	}
Line 8649 sub metadata {	Line 9021 sub metadata {
if (defined($cached)) { return $result->{':'.$what}; }	if (defined($cached)) { return $result->{':'.$what}; }
}	}
{	{
	# Imported parts would go here
	my %importedids=();
	my @origfileimportpartids=();
	my $importedparts=0;
#	#
# Is this a recursive call for a library?	# Is this a recursive call for a library?
#	#
Line 8666 sub metadata {	Line 9042 sub metadata {
my %metathesekeys=();	my %metathesekeys=();
unless ($filename=~/\.meta$/) { $filename.='.meta'; }	unless ($filename=~/\.meta$/) { $filename.='.meta'; }
my $metastring;	my $metastring;
if ($uri =~ /^~/ \|\| $uri =~ m{home/$match_username/public_html/}) {	if ($uri =~ /^priv/ \|\| $uri=~/home\/httpd\/html\/priv/) {
my $which = &hreflocation('','/'.($liburi \|\| $uri));	my $which = &hreflocation('','/'.($liburi \|\| $uri));
$metastring =	$metastring =
&Apache::lonnet::ssi_body($which,	&Apache::lonnet::ssi_body($which,
Line 8733 sub metadata {	Line 9109 sub metadata {
# This is not a package - some other kind of start tag	# This is not a package - some other kind of start tag
#	#
my $entry=$token->[1];	my $entry=$token->[1];
my $unikey;	my $unikey='';
if ($entry eq 'import') {
$unikey='';
} else {
$unikey=$entry;
}
$unikey.=&add_prefix_and_part($prefix,$token->[2]->{'part'});

if (defined($token->[2]->{'id'})) {
$unikey.='_'.$token->[2]->{'id'};
}

if ($entry eq 'import') {	if ($entry eq 'import') {
#	#
# Importing a library here	# Importing a library here
#	#
	my $location=$parser->get_text('/import');
	my $dir=$filename;
	$dir=~s\|[^/]*$\|\|;
	$location=&filelocation($dir,$location);

	my $importmode=$token->[2]->{'importmode'};
	if ($importmode eq 'problem') {
	# Import as problem/response
	$unikey=&add_prefix_and_part($prefix,$token->[2]->{'part'});
	} elsif ($importmode eq 'part') {
	# Import as part(s)
	$importedparts=1;
	# 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
	# Load and inspect original file
	if ($#origfileimportpartids<0) {
	undef(%importedpartids);
	my $origfilelocation=$perlvar{'lonDocRoot'}.&clutter($uri);
	my $origfile=&getfile($origfilelocation);
	@origfileimportpartids=($origfile=~/<(part\|import)[^>]id\s=\s[\"\']([^\"\']+)[\"\'][^>]>/gs);
	}

	# Load and inspect imported file
	my $impfile=&getfile($location);
	my @impfilepartids=($impfile=~/<part[^>]id\s=\s[\"\']([^\"\']+)[\"\'][^>]>/gs);
	if ($#impfilepartids>=0) {
	# This problem had parts
	$importedpartids{$token->[2]->{'id'}}=join(',',@impfilepartids);
	} else {
	# Importing by turning a single problem into a problem part
	# It gets the import-tags ID as part-ID
	$unikey=&add_prefix_and_part($prefix,$token->[2]->{'id'});
	$importedpartids{$token->[2]->{'id'}}=$token->[2]->{'id'};
	}
	} else {
	# Normal import
	$unikey=&add_prefix_and_part($prefix,$token->[2]->{'part'});
	if (defined($token->[2]->{'id'})) {
	$unikey.='_'.$token->[2]->{'id'};
	}
	}

if ($depthcount<20) {	if ($depthcount<20) {
my $location=$parser->get_text('/import');
my $dir=$filename;
$dir=~s\|[^/]*$\|\|;
$location=&filelocation($dir,$location);
my $metadata =	my $metadata =
&metadata($uri,'keys', $location,$unikey,	&metadata($uri,'keys', $location,$unikey,
$depthcount+1);	$depthcount+1);
Line 8761 sub metadata {	Line 9165 sub metadata {
$metaentry{':'.$meta}=$metaentry{':'.$meta};	$metaentry{':'.$meta}=$metaentry{':'.$meta};
$metathesekeys{$meta}=1;	$metathesekeys{$meta}=1;
}	}
}
} else {	}
	} else {
	#
	# Not importing, some other kind of non-package, non-library start tag
	#
	$unikey=$entry.&add_prefix_and_part($prefix,$token->[2]->{'part'});
	if (defined($token->[2]->{'id'})) {
	$unikey.='_'.$token->[2]->{'id'};
	}
if (defined($token->[2]->{'name'})) {	if (defined($token->[2]->{'name'})) {
$unikey.='_'.$token->[2]->{'name'};	$unikey.='_'.$token->[2]->{'name'};
}	}
Line 8836 sub metadata {	Line 9248 sub metadata {
grep { ! $seen{$_} ++ } (split(',',$metaentry{':packages'}));	grep { ! $seen{$_} ++ } (split(',',$metaentry{':packages'}));
$metaentry{':packages'} = join(',',@uniq_packages);	$metaentry{':packages'} = join(',',@uniq_packages);

	if ($importedparts) {
	# We had imported parts and need to rebuild partorder
	$metaentry{':partorder'}='';
	$metathesekeys{'partorder'}=1;
	for (my $index=0;$index<$#origfileimportpartids;$index+=2) {
	if ($origfileimportpartids[$index] eq 'part') {
	# original part, part of the problem
	$metaentry{':partorder'}.=','.$origfileimportpartids[$index+1];
	} else {
	# we have imported parts at this position
	$metaentry{':partorder'}.=','.$importedpartids{$origfileimportpartids[$index+1]};
	}
	}
	$metaentry{':partorder'}=~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);
Line 9020 sub symbverify {	Line 9448 sub symbverify {
$thisurl =~ s/\?.+$//;	$thisurl =~ s/\?.+$//;
}	}
my $ids=$bighash{'ids_'.&clutter($thisurl)};	my $ids=$bighash{'ids_'.&clutter($thisurl)};
unless ($ids) {	unless ($ids) {
my $idkey = 'ids_'.($thisurl =~ m{^/}? '' : '/').$thisurl;	my $idkey = 'ids_'.($thisurl =~ m{^/}? '' : '/').$thisurl;
$ids=$bighash{$idkey};	$ids=$bighash{$idkey};
}	}
if ($ids) {	if ($ids) {
# ------------------------------------------------------------------- Has ID(s)	# ------------------------------------------------------------------- Has ID(s)
Line 9036 sub symbverify {	Line 9464 sub symbverify {
eq $symb) {	eq $symb) {
if (($env{'request.role.adv'}) \|\|	if (($env{'request.role.adv'}) \|\|
($bighash{'encrypted_'.$id} eq $env{'request.enc'}) \|\|	($bighash{'encrypted_'.$id} eq $env{'request.enc'}) \|\|
($thisurl eq '/adm/navmaps')) {	($thisurl eq '/adm/navmaps')) {
$okay=1;	$okay=1;
}	}
}	}
Line 9311 sub getCODE {	Line 9739 sub getCODE {
}	}
return undef;	return undef;
}	}
	#
	# Determines the random seed for a specific context:
	#
	# parameters:
	# symb - in course context the symb for the seed.
	# course_id - The course id of the form domain_coursenum.
	# domain - Domain for the user.
	# course - Course for the user.
	# cenv - environment of the course.
	#
	# NOTE:
	# All parameters are picked out of the environment if missing
	# or not defined.
	# If a symb cannot be determined the current time is used instead.
	#
	# For a given well defined symb, courside, domain, username,
	# and course environment, the seed is reproducible.
	#
sub rndseed {	sub rndseed {
my ($symb,$courseid,$domain,$username)=@_;	my ($symb,$courseid,$domain,$username, $cenv)=@_;
my ($wsymb,$wcourseid,$wdomain,$wusername)=&whichuser();	my ($wsymb,$wcourseid,$wdomain,$wusername)=&whichuser();
if (!defined($symb)) {	if (!defined($symb)) {
unless ($symb=$wsymb) { return time; }	unless ($symb=$wsymb) { return time; }
}	}
if (!$courseid) { $courseid=$wcourseid; }	if (!defined $courseid) {
if (!$domain) { $domain=$wdomain; }	$courseid=$wcourseid;
if (!$username) { $username=$wusername }	}
my $which=&get_rand_alg();	if (!defined $domain) { $domain=$wdomain; }
	if (!defined $username) { $username=$wusername }

	my $which;
	if (defined($cenv->{'rndseed'})) {
	$which = $cenv->{'rndseed'};
	} else {
	$which =&get_rand_alg($courseid);
	}
if (defined(&getCODE())) {	if (defined(&getCODE())) {

if ($which eq '64bit5') {	if ($which eq '64bit5') {
return &rndseed_CODE_64bit5($symb,$courseid,$domain,$username);	return &rndseed_CODE_64bit5($symb,$courseid,$domain,$username);
} elsif ($which eq '64bit4') {	} elsif ($which eq '64bit4') {
Line 9647 sub getfile {	Line 10100 sub getfile {

sub repcopy_userfile {	sub repcopy_userfile {
my ($file)=@_;	my ($file)=@_;
if ($file =~ m -^/*(uploaded\|editupload)/-) { $file=&filelocation("",$file); }	my $londocroot = $perlvar{'lonDocRoot'};
if ($file =~ m\|^/home/httpd/html/lonUsers/\|) { return 'ok'; }	if ($file =~ m{^/*(uploaded\|editupload)/}) { $file=&filelocation("",$file); }
	if ($file =~ m{^\Q$londocroot/lonUsers/\E}) { return 'ok'; }
my ($cdom,$cnum,$filename) =	my ($cdom,$cnum,$filename) =
($file=~m\|^\Q$perlvar{'lonDocRoot'}\E/+userfiles/+($match_domain)/+($match_name)/+(.*)\|);	($file=~m\|^\Q$perlvar{'lonDocRoot'}\E/+userfiles/+($match_domain)/+($match_name)/+(.*)\|);
my $uri="/uploaded/$cdom/$cnum/$filename";	my $uri="/uploaded/$cdom/$cnum/$filename";
Line 9777 sub filelocation {	Line 10231 sub filelocation {
$file=~s-^/adm/coursedocs/showdoc/-/-;	$file=~s-^/adm/coursedocs/showdoc/-/-;
}	}

if ($file=~m:^/~:) { # is a contruction space reference	if ($file =~ m-^\Q$Apache::lonnet::perlvar{'lonTabDir'}\E/-) {
$location = $file;
$location =~ s:/~(.?)/(.):/home/$1/public_html/$2:;
} elsif ($file=~m{^/home/$match_username/public_html/}) {
# is a correct contruction space reference
$location = $file;
} elsif ($file =~ m-^\Q$Apache::lonnet::perlvar{'lonTabDir'}\E/-) {
$location = $file;	$location = $file;
} elsif ($file=~/^\/*(uploaded\|editupload)/) { # is an uploaded file	} elsif ($file=~/^\/*(uploaded\|editupload)/) { # is an uploaded file
my ($udom,$uname,$filename)=	my ($udom,$uname,$filename)=
Line 9793 sub filelocation {	Line 10241 sub filelocation {
my @ids=&current_machine_ids();	my @ids=&current_machine_ids();
foreach my $id (@ids) { if ($id eq $home) { $is_me=1; } }	foreach my $id (@ids) { if ($id eq $home) { $is_me=1; } }
if ($is_me) {	if ($is_me) {
$location=&propath($udom,$uname).'/userfiles/'.$filename;	$location=propath($udom,$uname).'/userfiles/'.$filename;
} else {	} else {
$location=$Apache::lonnet::perlvar{'lonDocRoot'}.'/userfiles/'.	$location=$Apache::lonnet::perlvar{'lonDocRoot'}.'/userfiles/'.
$udom.'/'.$uname.'/'.$filename;	$udom.'/'.$uname.'/'.$filename;
Line 9802 sub filelocation {	Line 10250 sub filelocation {
$location = $perlvar{'lonDocRoot'}.'/'.$file;	$location = $perlvar{'lonDocRoot'}.'/'.$file;
} else {	} else {
$file=~s/^\Q$perlvar{'lonDocRoot'}\E//;	$file=~s/^\Q$perlvar{'lonDocRoot'}\E//;
$file=~s:^/res/:/:;	$file=~s:^/(res\|priv)/:/:;
	my $space=$1;
if ( !( $file =~ m:^/:) ) {	if ( !( $file =~ m:^/:) ) {
$location = $dir. '/'.$file;	$location = $dir. '/'.$file;
} else {	} else {
$location = '/home/httpd/html/res'.$file;	$location = $perlvar{'lonDocRoot'}.'/'.$space.$file;
}	}
}	}
$location=~s://+:/:g; # remove duplicate /	$location=~s://+:/:g; # remove duplicate /
Line 9831 sub hreflocation {	Line 10280 sub hreflocation {
}	}
if ($file=~m-^\Q$perlvar{'lonDocRoot'}\E-) {	if ($file=~m-^\Q$perlvar{'lonDocRoot'}\E-) {
$file=~s-^\Q$perlvar{'lonDocRoot'}\E--;	$file=~s-^\Q$perlvar{'lonDocRoot'}\E--;
} elsif ($file=~m-/home/($match_username)/public_html/-) {
$file=~s-^/home/($match_username)/public_html/-/~$1/-;
} elsif ($file=~m-^\Q$perlvar{'lonUsersDir'}\E-) {	} elsif ($file=~m-^\Q$perlvar{'lonUsersDir'}\E-) {
$file=~s-^/home/httpd/lonUsers/($match_domain)/./././($match_name)/userfiles/	$file=~s{^/home/httpd/lonUsers/($match_domain)/./././($match_name)/userfiles/}
-/uploaded/$1/$2/-x;	{/uploaded/$1/$2/}x;
}	}
if ($file=~ m{^/userfiles/}) {	if ($file=~ m{^/userfiles/}) {
$file =~ s{^/userfiles/}{/uploaded/};	$file =~ s{^/userfiles/}{/uploaded/};
Line 9843 sub hreflocation {	Line 10290 sub hreflocation {
return $file;	return $file;
}	}





sub current_machine_domains {	sub current_machine_domains {
return &machine_domains(&hostname($perlvar{'lonHostID'}));	return &machine_domains(&hostname($perlvar{'lonHostID'}));
}	}
Line 10123 sub get_dns {	Line 10574 sub get_dns {
foreach my $configline (@$file) {	foreach my $configline (@$file) {
next if ($configline =~ /^(\#\|\s*$ )/x);	next if ($configline =~ /^(\#\|\s*$ )/x);
chomp($configline);	chomp($configline);
if ($configline =~ /^\^/) {	if ($configline =~ /^\^/) {
if ($configline =~ /^\^([\w.\-]+)/) {	if ($configline =~ /^\^([\w.\-]+)/) {
$LC_dns_serv{$1} = 1;	$LC_dns_serv{$1} = 1;
}	}
Line 10210 sub get_dns {	Line 10661 sub get_dns {
}	}

sub unique_library {	sub unique_library {
#2x reverse removes all hostnames that appear more than once	#2x reverse removes all hostnames that appear more than once
my %unique = reverse &all_library();	my %unique = reverse &all_library();
return reverse %unique;	return reverse %unique;
}	}
Line 10240 sub get_dns {	Line 10691 sub get_dns {

sub get_unique_servers {	sub get_unique_servers {
my %unique = reverse &get_servers(@_);	my %unique = reverse &get_servers(@_);
return reverse %unique;	return reverse %unique;
}	}

sub host_domain {	sub host_domain {
Line 10565 BEGIN {	Line 11016 BEGIN {

# ------------- set up temporary directory	# ------------- set up temporary directory
{	{
$tmpdir = $perlvar{'lonDaemons'}.'/tmp/';	$tmpdir = LONCAPA::tempdir();

}	}

Line 10800 $checkdefauth is optional (value is 1 if	Line 11251 $checkdefauth is optional (value is 1 if
authenticate user using default authentication method, and allow	authenticate user using default authentication method, and allow
account creation if username does not have account in the domain).	account creation if username does not have account in the domain).
$clientcancheckhost is optional (value is 1 if checking whether the	$clientcancheckhost is optional (value is 1 if checking whether the
server can host will occur on the client side in lonauth.pm).	server can host will occur on the client side in lonauth.pm).

=item *	=item *
X<homeserver()>	X<homeserver()>
Line 11059 revokecustomrole($udom,$uname,$url,$role	Line 11510 revokecustomrole($udom,$uname,$url,$role

=item *	=item *

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

	$options is an optional parameter that if supplied is a hash reference that controls
	what how this function works. It has the following key/values:

	=over 4

	=item freshen_cache

	If defined, and the environment cache for the course is valid, it is
	returned in the returned hash.

	=item one_time

	If defined, the last cache time is set to _now_

	=item user

	If defined, the supplied username is used instead of the current user.


	=back

=item *	=item *

resdata($name,$domain,$type,@which) : request for current parameter	resdata($name,$domain,$type,@which) : request for current parameter
Line 11394 or lonTabs/domain.tab.	Line 11866 or lonTabs/domain.tab.

=item *	=item *

dirlist($uri) : return directory list based on URI	dirlist() : return directory list based on URI (first arg).

	Inputs: 1 required, 5 optional.

	=over

	=item
	$uri - path to file in filesystem (starts: /res or /userfiles/). Required.

	=item
	$userdomain - domain of user/course to be listed. Extracted from $uri if absent.

	=item
	$username - username of user/course to be listed. Extracted from $uri if absent.

	=item
	$getpropath - boolean: 1 if prepend path using &propath().

	=item
	$getuserdir - boolean: 1 if prepend path for "userfiles".

	=item
	$alternateRoot - path to prepend in place of path from $uri.

	=back

	Returns: Array of up to two items.

	=over

	a reference to an array of files/subdirectories

	=over

	Each element in the array of files/subdirectories is a & separated list of
	item name and the result of running stat on the item. If dirlist was requested
	for a file instead of a directory, the item name will be ''. For a directory
	listing, if the item is a metadata file, the element will end &N&M
	(where N amd M are either 0 or 1, corresponding to obsolete set (1), or
	default copyright set (1).

	=back

	a scalar containing error condition (if encountered).

	=over

	=item
	no_host (no homeserver identified for $username:$domain).

	=item
	no_such_host (server contacted for listing not identified as valid host).

	=item
	con_lost (connection to remote server failed).

	=item
	refused (invalid $username:$domain received on lond side).

	=item
	no_such_dir (directory at specified path on lond side does not exist).

	=item
	empty (directory at specified path on lond side is empty).

	=over

	This is currently not encountered because the &ls3, &ls2,
	&ls (_handler) routines on the lond side do not filter out
	. and .. from a directory listing.

	=back

	=back

	=back

=item *	=item *

Line 11456 splitting on '&', supports elements that	Line 12003 splitting on '&', supports elements that

=head2 Logging Routines	=head2 Logging Routines


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

Line 11476 logperm() : append a permanent message t	Line 12024 logperm() : append a permanent message t
file never gets deleted by any automated portion of the system, only	file never gets deleted by any automated portion of the system, only
messages of critical importance should go in here.	messages of critical importance should go in here.


=back	=back

=head2 General File Helper Routines	=head2 General File Helper Routines
Line 11550 userfileupload(): main rotine for puttin	Line 12099 userfileupload(): main rotine for puttin
the filename is in $env{'form.'.$formname.'.filename'} and the	the filename is in $env{'form.'.$formname.'.filename'} and the
contents of the file is located in $env{'form.'.$formname}	contents of the file is located in $env{'form.'.$formname}
context - if coursedoc, store the file in the course of the active role	context - if coursedoc, store the file in the course of the active role
of the current user;	of the current user;
if 'existingfile': store in 'overwrites' in /home/httpd/perl/tmp	if 'existingfile': store in 'overwrites' in /home/httpd/perl/tmp
if 'canceloverwrite': delete file in tmp/overwrites directory	if 'canceloverwrite': delete file in tmp/overwrites directory
subdir - required - subdirectory to put the file in under ../userfiles/	subdir - required - subdirectory to put the file in under ../userfiles/
Line 11596 userspace, probably shouldn't be called	Line 12145 userspace, probably shouldn't be called
returns either the url of the uploaded file (/uploaded/....) if successful	returns either the url of the uploaded file (/uploaded/....) if successful
and /adm/notfound.html if unsuccessful (or an error message if context	and /adm/notfound.html if unsuccessful (or an error message if context
was 'overwrite').	was 'overwrite').


=item *	=item *

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

Removed from v.1.1056.4.35
changed lines
	Added in v.1.1148