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.28 and 1.1134

version 1.1056.4.28, 2011/07/28 18:30:16	version 1.1134, 2011/10/14 22:05:19
Line 95 use Math::Random;	Line 95 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 287 sub get_server_homeID {	Line 288 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 305 sub get_server_homeID {	Line 306 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 635 sub appenv {	Line 682 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 748 sub userload {	Line 804 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 787 sub spareserver {	Line 819 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);	my $found_server = ($spare_server ne '' && $lowest_load < 100);

if (!$found_server) {	if (!$found_server) {
foreach my $try_server (@{ $spareid{'default'} }) {	if (ref($spareshash->{'default'}) eq 'ARRAY') {
if ($uint_dom) {	foreach my $try_server (@{ $spareshash->{'default'} }) {
next unless (&spare_can_host($udom,$uint_dom,$remotesessions,	if ($uint_dom) {
$try_server));	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);
	}
	}
	}
}	}

if (!$want_server_name) {	if (!$want_server_name) {
Line 831 sub compare_server_load {	Line 870 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; #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 857 sub compare_server_load {	Line 896 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 877 sub has_user_session {	Line 925 sub has_user_session {
# --------- determine least loaded server in a user's domain which allows login	# --------- determine least loaded server in a user's domain which allows login

sub choose_server {	sub choose_server {
my ($udom) = @_;	my ($udom,$checkloginvia) = @_;
my %domconfhash = &Apache::loncommon::get_domainconf($udom);	my %domconfhash = &Apache::loncommon::get_domainconf($udom);
my %servers = &get_servers($udom);	my %servers = &get_servers($udom);
my $lowest_load = 30000;	my $lowest_load = 30000;
my ($login_host,$hostname);	my ($login_host,$hostname,$portal_path);
foreach my $lonhost (keys(%servers)) {	foreach my $lonhost (keys(%servers)) {
my $loginvia = $domconfhash{$udom.'.login.loginvia_'.$lonhost};	my $loginvia;
if ($loginvia eq '') {	if ($checkloginvia) {
	$loginvia = $domconfhash{$udom.'.login.loginvia_'.$lonhost};
	if ($loginvia) {
	my ($server,$path) = split(/:/,$loginvia);
	($login_host, $lowest_load) =
	&compare_server_load($server, $login_host, $lowest_load);
	if ($login_host eq $server) {
	$portal_path = $path;
	}
	} else {
	($login_host, $lowest_load) =
	&compare_server_load($lonhost, $login_host, $lowest_load);
	if ($login_host eq $lonhost) {
	$portal_path = '';
	}
	}
	} else {
($login_host, $lowest_load) =	($login_host, $lowest_load) =
&compare_server_load($lonhost, $login_host, $lowest_load);	&compare_server_load($lonhost, $login_host, $lowest_load);
}	}
}	}
if ($login_host ne '') {	if ($login_host ne '') {
$hostname = $servers{$login_host};	$hostname = &hostname($login_host);
}	}
return ($login_host,$hostname);	return ($login_host,$hostname,$portal_path);
}	}

# --------------------------------------------- Try to change a user's password	# --------------------------------------------- Try to change a user's password
Line 1076 sub spare_can_host {	Line 1140 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 1852 sub is_cached_new {	Line 2212 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 2018 sub getversion {	Line 2378 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 2293 sub process_coursefile {	Line 2662 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 2411 sub resizeImage {	Line 2780 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 2567 sub finishuserfileupload {	Line 2936 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 2582 sub finishuserfileupload {	Line 2951 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 3143 sub get_my_roles {	Line 3512 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 3205 sub get_my_roles {	Line 3574 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 3473 sub get_domain_roles {	Line 3846 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 3509 sub set_first_access {	Line 3882 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 3698 sub hashref2str {	Line 3986 sub hashref2str {
$result.='=';	$result.='=';
#print("Got a ref of ".(ref($key))." skipping.");	#print("Got a ref of ".(ref($key))." skipping.");
} else {	} else {
if ($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 3850 sub tmpreset {	Line 4138 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 3889 sub tmpstore {	Line 4177 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 3935 sub tmprestore {	Line 4223 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 4072 sub restore {	Line 4360 sub restore {
}	}

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

sub coursedescription {	sub coursedescription {
my ($courseid,$args)=@_;	my ($courseid,$args)=@_;
Line 4101 sub coursedescription {	Line 4391 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 4109 sub coursedescription {	Line 4400 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 4119 sub coursedescription {	Line 4414 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 4217 sub rolesinit {	Line 4512 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 4234 sub rolesinit {	Line 4528 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 4338 sub set_userprivs {	Line 4633 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 4386 sub set_userprivs {	Line 4681 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 4395 sub set_userprivs {	Line 4690 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 4404 sub role_status {	Line 4699 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 4414 sub role_status {	Line 4709 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 4429 sub role_status {	Line 4724 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 4468 sub role_status {	Line 4740 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 4478 sub role_status {	Line 4750 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 4574 sub dump {	Line 4904 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 4865 sub tmpget {	Line 5198 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 5116 sub is_portfolio_file {	Line 5449 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 5263 sub is_advanced_user {	Line 5596 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 5282 sub is_advanced_user {	Line 5619 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 5296 sub is_advanced_user {	Line 5636 sub is_advanced_user {
}	}
}	}
}	}
	if (wantarray) {
	return ($is_adv,$is_author);
	}
return $is_adv;	return $is_adv;
}	}

Line 5781 sub allowed {	Line 6124 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 5791 sub allowed {	Line 6134 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 5805 sub allowed {	Line 6148 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 5836 sub allowed {	Line 6179 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 6032 sub fetch_enrollment_query {	Line 6395 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 6062 sub fetch_enrollment_query {	Line 6425 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 6732 sub assignrole {	Line 7095 sub assignrole {
return 'refused';	return 'refused';
}	}
}	}
	} elsif ($role eq 'au') {
	if ($url ne '/'.$udom.'/') {
	&logthis('Attempt by '.$env{'user.name'}.':'.$env{'user.domain'}.
	' to assign author role for '.$uname.':'.$udom.
	' in domain: '.$url.' refused (wrong domain).');
	return 'refused';
	}
}	}
$mrole=$role;	$mrole=$role;
}	}
Line 6906 sub modifyuser {	Line 7276 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 7052 sub modifyuser {	Line 7422 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 7434 sub is_locked {	Line 7804 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 7499 sub save_selected_files {	Line 7869 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 7509 sub files_in_path {	Line 7879 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 7531 sub files_not_in_path {	Line 7901 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 8598 sub add_prefix_and_part {	Line 8968 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 8624 sub metadata {	Line 8995 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 8708 sub metadata {	Line 9083 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 8736 sub metadata {	Line 9139 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 8811 sub metadata {	Line 9222 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 8995 sub symbverify {	Line 9422 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 9011 sub symbverify {	Line 9438 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 9286 sub getCODE {	Line 9713 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; }
Line 9296 sub rndseed {	Line 9740 sub rndseed {
if (!$courseid) { $courseid=$wcourseid; }	if (!$courseid) { $courseid=$wcourseid; }
if (!$domain) { $domain=$wdomain; }	if (!$domain) { $domain=$wdomain; }
if (!$username) { $username=$wusername }	if (!$username) { $username=$wusername }
my $which=&get_rand_alg();
	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 9768 sub filelocation {	Line 10219 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 10006 sub get_dns {	Line 10457 sub get_dns {
while (%alldns) {	while (%alldns) {
my ($dns) = keys(%alldns);	my ($dns) = keys(%alldns);
my $ua=new LWP::UserAgent;	my $ua=new LWP::UserAgent;
	$ua->timeout(30);
my $request=new HTTP::Request('GET',"$alldns{$dns}://$dns$url");	my $request=new HTTP::Request('GET',"$alldns{$dns}://$dns$url");
my $response=$ua->request($request);	my $response=$ua->request($request);
delete($alldns{$dns});	delete($alldns{$dns});
Line 10097 sub get_dns {	Line 10549 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 10184 sub get_dns {	Line 10636 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 10214 sub get_dns {	Line 10666 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 10523 BEGIN {	Line 10975 BEGIN {

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

}	}

Line 10758 $checkdefauth is optional (value is 1 if	Line 11210 $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 11017 revokecustomrole($udom,$uname,$url,$role	Line 11469 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 11414 splitting on '&', supports elements that	Line 11887 splitting on '&', supports elements that

=head2 Logging Routines	=head2 Logging Routines

=over 4

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.

	=over 4

=item *	=item *

logtouch() : make sure the logfile, lonnet.log, exists	logtouch() : make sure the logfile, lonnet.log, exists
Line 11434 logperm() : append a permanent message t	Line 11908 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 11508 userfileupload(): main rotine for puttin	Line 11983 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 11554 userspace, probably shouldn't be called	Line 12029 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.28
changed lines
	Added in v.1.1134