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.1054 and 1.1123

version 1.1054, 2010/03/13 19:47:33	version 1.1123, 2011/08/01 22:13:49
Line 76 use HTTP::Date;	Line 76 use HTTP::Date;
use Image::Magick;	use Image::Magick;

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

my (%badServerCache, $memcache, %courselogs, %accesshash, %domainrolehash,	my (%badServerCache, $memcache, %courselogs, %accesshash, %domainrolehash,
%userrolehash, $processmarker, $dumpcount, %coursedombuf,	%userrolehash, $processmarker, $dumpcount, %coursedombuf,
Line 96 use File::MMagic;	Line 96 use File::MMagic;
use LONCAPA qw(:DEFAULT :match);	use LONCAPA qw(:DEFAULT :match);
use LONCAPA::Configuration;	use LONCAPA::Configuration;

	use File::Copy;

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

Line 195 sub get_server_timezone {	Line 197 sub get_server_timezone {
}	}
}	}

	sub get_server_distarch {
	my ($lonhost,$ignore_cache) = @_;
	if (defined($lonhost)) {
	if (!defined(&hostname($lonhost))) {
	return;
	}
	my $cachetime = 12*3600;
	if (!$ignore_cache) {
	my ($distarch,$cached)=&is_cached_new('serverdistarch',$lonhost);
	if (defined($cached)) {
	return $distarch;
	}
	}
	my $rep = &reply('serverdistarch',$lonhost);
	unless ($rep eq 'unknown_command' \|\| $rep eq 'no_such_host' \|\|
	$rep eq 'con_lost' \|\| $rep eq 'rejected' \|\| $rep eq 'refused' \|\|
	$rep eq '') {
	return &do_cache_new('serverdistarch',$lonhost,$rep,$cachetime);
	}
	}
	return;
	}

sub get_server_loncaparev {	sub get_server_loncaparev {
my ($dom,$lonhost) = @_;	my ($dom,$lonhost,$ignore_cache,$caller) = @_;
if (defined($lonhost)) {	if (defined($lonhost)) {
if (!defined(&hostname($lonhost))) {	if (!defined(&hostname($lonhost))) {
undef($lonhost);	undef($lonhost);
Line 211 sub get_server_loncaparev {	Line 236 sub get_server_loncaparev {
}	}
}	}
if (defined($lonhost)) {	if (defined($lonhost)) {
my $cachetime = 24*3600;	my $cachetime = 12*3600;
my ($loncaparev,$cached)=&is_cached_new('serverloncaparev',$lonhost);	if (!$ignore_cache) {
	my ($loncaparev,$cached)=&is_cached_new('serverloncaparev',$lonhost);
	if (defined($cached)) {
	return $loncaparev;
	}
	}
	my ($answer,$loncaparev);
	my @ids=&current_machine_ids();
	if (grep(/^\Q$lonhost\E$/,@ids)) {
	$answer = $perlvar{'lonVersion'};
	if ($answer =~ /^[\'\"]?([\w.\-]+)[\'\"]?$/) {
	$loncaparev = $1;
	}
	} else {
	$answer = &reply('serverloncaparev',$lonhost);
	if (($answer eq 'unknown_cmd') \|\| ($answer eq 'con_lost')) {
	if ($caller eq 'loncron') {
	my $ua=new LWP::UserAgent;
	$ua->timeout(4);
	my $protocol = $protocol{$lonhost};
	$protocol = 'http' if ($protocol ne 'https');
	my $url = $protocol.'://'.&hostname($lonhost).'/adm/about.html';
	my $request=new HTTP::Request('GET',$url);
	my $response=$ua->request($request);
	unless ($response->is_error()) {
	my $content = $response->content;
	if ($content =~ /<p>VERSION\:\s*([\w.\-]+)<\/p>/) {
	$loncaparev = $1;
	}
	}
	} else {
	$loncaparev = $loncaparevs{$lonhost};
	}
	} elsif ($answer =~ /^[\'\"]?([\w.\-]+)[\'\"]?$/) {
	$loncaparev = $1;
	}
	}
	return &do_cache_new('serverloncaparev',$lonhost,$loncaparev,$cachetime);
	}
	}

	sub get_server_homeID {
	my ($hostname,$ignore_cache,$caller) = @_;
	unless ($ignore_cache) {
	my ($serverhomeID,$cached)=&is_cached_new('serverhomeID',$hostname);
if (defined($cached)) {	if (defined($cached)) {
return $loncaparev;	return $serverhomeID;
} else {	}
my $loncaparev = &reply('serverloncaparev',$lonhost);	}
return &do_cache_new('serverloncaparev',$lonhost,$loncaparev,$cachetime);	my $cachetime = 12*3600;
	my $serverhomeID;
	if ($caller eq 'loncron') {
	my @machine_ids = &machine_ids($hostname);
	foreach my $id (@machine_ids) {
	my $response = &reply('serverhomeID',$id);
	unless (($response eq 'unknown_cmd') \|\| ($response eq 'con_lost')) {
	$serverhomeID = $response;
	last;
	}
}	}
	if ($serverhomeID eq '') {
	$serverhomeID = $machine_ids[-1];
	}
	} else {
	$serverhomeID = $serverhomeIDs{$hostname};
}	}
	return &do_cache_new('serverhomeID',$hostname,$serverhomeID,$cachetime);
	}

	sub get_remote_globals {
	my ($lonhost,$whathash,$ignore_cache) = @_;
	my (%returnhash,%whatneeded);
	if (ref($whathash) eq 'ARRAY') {
	foreach my $what (sort(keys(%{$whathash}))) {
	my $type = $whathash->{$what};
	my $hashid = $lonhost.'-'.$what;
	my ($result,$cached);
	unless ($ignore_cache) {
	($result,$cached)=&is_cached_new('lonnetglobal',$hashid);
	$returnhash{$what} = $result;
	}
	if (defined($cached)) {
	$returnhash{$what} = $result;
	} else {
	$whatneeded{$what} = $type;
	}
	}
	if (keys(%whatneeded) > 0) {
	my $requested = &freeze_escape(\%whatneeded);
	my $rep=&reply('readlonnetglobal:'.$requested,$lonhost);
	unless (($rep=~/^refused/) \|\| ($rep=~/^rejected/) \|\| ($rep eq 'con_lost')) {
	my @pairs=split(/\&/,$rep);
	if ($rep !~ /^error/) {
	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 %returnhash;
}	}

# -------------------------------------------------- Non-critical communication	# -------------------------------------------------- Non-critical communication
Line 552 sub appenv {	Line 674 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 665 sub userload {	Line 796 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 {
my ($loadpercent,$userloadpercent,$want_server_name) = @_;	my ($loadpercent,$userloadpercent,$want_server_name,$udom) = @_;
my $spare_server;	my $spare_server;
if ($userloadpercent !~ /\d/) { $userloadpercent=0; }	if ($userloadpercent !~ /\d/) { $userloadpercent=0; }
my $lowest_load=($loadpercent > $userloadpercent) ? $loadpercent	my $lowest_load=($loadpercent > $userloadpercent) ? $loadpercent
: $userloadpercent;	: $userloadpercent;
	my ($uint_dom,$remotesessions);
foreach my $try_server (@{ $spareid{'primary'} }) {	if (($udom ne '') && (&domain($udom) ne '')) {
($spare_server, $lowest_load) =	my $uprimary_id = &Apache::lonnet::domain($udom,'primary');
&compare_server_load($try_server, $spare_server, $lowest_load);	$uint_dom = &Apache::lonnet::internet_dom($uprimary_id);
}	my %udomdefaults = &Apache::lonnet::get_domain_defaults($udom);
	$remotesessions = $udomdefaults{'remotesessions'};
my $found_server = ($spare_server ne '' && $lowest_load < 100);	}
	my $spareshash = &this_host_spares($udom);
	if (ref($spareshash) eq 'HASH') {
	if (ref($spareshash->{'primary'}) eq 'ARRAY') {
	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);
	}
	}

if (!$found_server) {	my $found_server = ($spare_server ne '' && $lowest_load < 100);
foreach my $try_server (@{ $spareid{'default'} }) {
($spare_server, $lowest_load) =	if (!$found_server) {
&compare_server_load($try_server, $spare_server, $lowest_load);	if (ref($spareshash->{'default'}) eq 'ARRAY') {
}	foreach my $try_server (@{ $spareshash->{'default'} }) {
	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);
	}
	}
	}
}	}

if (!$want_server_name) {	if (!$want_server_name) {
Line 719 sub spareserver {	Line 847 sub spareserver {
}	}
if (defined($spare_server)) {	if (defined($spare_server)) {
my $hostname = &hostname($spare_server);	my $hostname = &hostname($spare_server);
if (defined($hostname)) {	if (defined($hostname)) {
$spare_server = $protocol.'://'.$hostname;	$spare_server = $protocol.'://'.$hostname;
}	}
}	}
Line 734 sub compare_server_load {	Line 862 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/) {
next; #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 760 sub compare_server_load {	Line 888 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 777 sub has_user_session {	Line 914 sub has_user_session {
return 0;	return 0;
}	}

	# --------- determine least loaded server in a user's domain which allows login

	sub choose_server {
	my ($udom,$checkloginvia) = @_;
	my %domconfhash = &Apache::loncommon::get_domainconf($udom);
	my %servers = &get_servers($udom);
	my $lowest_load = 30000;
	my ($login_host,$hostname,$portal_path);
	foreach my $lonhost (keys(%servers)) {
	my $loginvia;
	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) =
	&compare_server_load($lonhost, $login_host, $lowest_load);
	}
	}
	if ($login_host ne '') {
	$hostname = &hostname($login_host);
	}
	return ($login_host,$hostname,$portal_path);
	}

# --------------------------------------------- Try to change a user's password	# --------------------------------------------- Try to change a user's password

sub changepass {	sub changepass {
Line 835 sub queryauthenticate {	Line 1009 sub queryauthenticate {
# --------- Try to authenticate user from domain's lib servers (first this one)	# --------- Try to authenticate user from domain's lib servers (first this one)

sub authenticate {	sub authenticate {
my ($uname,$upass,$udom,$checkdefauth)=@_;	my ($uname,$upass,$udom,$checkdefauth,$clientcancheckhost)=@_;
$upass=&escape($upass);	$upass=&escape($upass);
$uname= &LONCAPA::clean_username($uname);	$uname= &LONCAPA::clean_username($uname);
my $uhome=&homeserver($uname,$udom,1);	my $uhome=&homeserver($uname,$udom,1);
Line 858 sub authenticate {	Line 1032 sub authenticate {
return 'no_host';	return 'no_host';
}	}
}	}
my $answer=reply("encrypt:auth:$udom:$uname:$upass:$checkdefauth",$uhome);	my $answer=reply("encrypt:auth:$udom:$uname:$upass:$checkdefauth:$clientcancheckhost",$uhome);
if ($answer eq 'authorized') {	if ($answer eq 'authorized') {
if ($newhome) {	if ($newhome) {
&logthis("User $uname at $udom authorized by $uhome, but needs account");	&logthis("User $uname at $udom authorized by $uhome, but needs account");
Line 876 sub authenticate {	Line 1050 sub authenticate {
return 'no_host';	return 'no_host';
}	}

	sub can_host_session {
	my ($udom,$lonhost,$remoterev,$remotesessions,$hostedsessions) = @_;
	my $canhost = 1;
	my $host_idn = &Apache::lonnet::internet_dom($lonhost);
	if (ref($remotesessions) eq 'HASH') {
	if (ref($remotesessions->{'excludedomain'}) eq 'ARRAY') {
	if (grep(/^\Q$host_idn\E$/,@{$remotesessions->{'excludedomain'}})) {
	$canhost = 0;
	} else {
	$canhost = 1;
	}
	}
	if (ref($remotesessions->{'includedomain'}) eq 'ARRAY') {
	if (grep(/^\Q$host_idn\E$/,@{$remotesessions->{'includedomain'}})) {
	$canhost = 1;
	} else {
	$canhost = 0;
	}
	}
	if ($canhost) {
	if ($remotesessions->{'version'} ne '') {
	my ($reqmajor,$reqminor) = ($remotesessions->{'version'} =~ /^(\d+)\.(\d+)$/);
	if ($reqmajor ne '' && $reqminor ne '') {
	if ($remoterev =~ /^\'?(\d+)\.(\d+)/) {
	my $major = $1;
	my $minor = $2;
	if (($major < $reqmajor ) \|\|
	(($major == $reqmajor) && ($minor < $reqminor))) {
	$canhost = 0;
	}
	} else {
	$canhost = 0;
	}
	}
	}
	}
	}
	if ($canhost) {
	if (ref($hostedsessions) eq 'HASH') {
	my $uprimary_id = &Apache::lonnet::domain($udom,'primary');
	my $uint_dom = &Apache::lonnet::internet_dom($uprimary_id);
	if (ref($hostedsessions->{'excludedomain'}) eq 'ARRAY') {
	if (($uint_dom ne '') &&
	(grep(/^\Q$uint_dom\E$/,@{$hostedsessions->{'excludedomain'}}))) {
	$canhost = 0;
	} else {
	$canhost = 1;
	}
	}
	if (ref($hostedsessions->{'includedomain'}) eq 'ARRAY') {
	if (($uint_dom ne '') &&
	(grep(/^\Q$uint_dom\E$/,@{$hostedsessions->{'includedomain'}}))) {
	$canhost = 1;
	} else {
	$canhost = 0;
	}
	}
	}
	}
	return $canhost;
	}

	sub spare_can_host {
	my ($udom,$uint_dom,$remotesessions,$try_server)=@_;
	my $canhost=1;
	my @intdoms;
	my $internet_names = &Apache::lonnet::get_internet_names($try_server);
	if (ref($internet_names) eq 'ARRAY') {
	@intdoms = @{$internet_names};
	}
	unless (grep(/^\Q$uint_dom\E$/,@intdoms)) {
	my $serverhomeID = &Apache::lonnet::get_server_homeID($try_server);
	my $serverhomedom = &Apache::lonnet::host_domain($serverhomeID);
	my %defdomdefaults = &Apache::lonnet::get_domain_defaults($serverhomedom);
	my $remoterev = &Apache::lonnet::get_server_loncaparev(undef,$try_server);
	$canhost = &can_host_session($udom,$try_server,$remoterev,
	$remotesessions,
	$defdomdefaults{'hostedsessions'});
	}
	return $canhost;
	}

	sub this_host_spares {
	my ($dom) = @_;
	my $cachetime = 606024;
	my @hosts = &current_machine_ids();
	foreach my $lonhost (@hosts) {
	if (&host_domain($lonhost) eq $dom) {
	my ($result,$cached)=&is_cached_new('spares',$dom);
	if (defined($cached)) {
	return $result;
	} else {
	my %domconfig =
	&Apache::lonnet::get_dom('configuration',['usersessions'],$dom);
	if (ref($domconfig{'usersessions'}) eq 'HASH') {
	if (ref($domconfig{'usersessions'}{'spares'}) eq 'HASH') {
	if (ref($domconfig{'usersessions'}{'spares'}{$lonhost}) eq 'HASH') {
	return &do_cache_new('spares',$dom,$domconfig{'usersessions'}{'spares'}{$lonhost},$cachetime);
	}
	}
	}
	}
	last;
	}
	}
	my $serverhomedom = &host_domain($perlvar{'lonHostID'});
	my ($result,$cached)=&is_cached_new('spares',$serverhomedom);
	if (defined($cached)) {
	return $result;
	} else {
	my %homedomconfig =
	&Apache::lonnet::get_dom('configuration',['usersessions'],$serverhomedom);
	if (ref($homedomconfig{'usersessions'}) eq 'HASH') {
	if (ref($homedomconfig{'usersessions'}{'spares'}) eq 'HASH') {
	if (ref($homedomconfig{'usersessions'}{'spares'}{$perlvar{'lonHostID'}}) eq 'HASH') {
	return &do_cache_new('spares',$serverhomedom,$homedomconfig{'usersessions'}{'spares'}{$perlvar{'lonHostID'}},$cachetime);
	}
	}
	}
	}
	return \%spareid;
	}

# ---------------------- 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 1352 sub get_domain_defaults {	Line 1649 sub get_domain_defaults {
my %domconfig =	my %domconfig =
&Apache::lonnet::get_dom('configuration',['defaults','quotas',	&Apache::lonnet::get_dom('configuration',['defaults','quotas',
'requestcourses','inststatus',	'requestcourses','inststatus',
'coursedefaults'],$domain);	'coursedefaults','usersessions'],$domain);
if (ref($domconfig{'defaults'}) eq 'HASH') {	if (ref($domconfig{'defaults'}) eq 'HASH') {
$domdefaults{'lang_def'} = $domconfig{'defaults'}{'lang_def'};	$domdefaults{'lang_def'} = $domconfig{'defaults'}{'lang_def'};
$domdefaults{'auth_def'} = $domconfig{'defaults'}{'auth_def'};	$domdefaults{'auth_def'} = $domconfig{'defaults'}{'auth_def'};
Line 1392 sub get_domain_defaults {	Line 1689 sub get_domain_defaults {
$domdefaults{$item} = $domconfig{'coursedefaults'}{$item};	$domdefaults{$item} = $domconfig{'coursedefaults'}{$item};
}	}
}	}
	if (ref($domconfig{'usersessions'}) eq 'HASH') {
	if (ref($domconfig{'usersessions'}{'remote'}) eq 'HASH') {
	$domdefaults{'remotesessions'} = $domconfig{'usersessions'}{'remote'};
	}
	if (ref($domconfig{'usersessions'}{'hosted'}) eq 'HASH') {
	$domdefaults{'hostedsessions'} = $domconfig{'usersessions'}{'hosted'};
	}
	}
&Apache::lonnet::do_cache_new('domdefaults',$domain,\%domdefaults,	&Apache::lonnet::do_cache_new('domdefaults',$domain,\%domdefaults,
$cachetime);	$cachetime);
return %domdefaults;	return %domdefaults;
Line 1577 sub getsection {	Line 1882 sub getsection {
# If there is a role which has expired, return it.	# If there is a role which has expired, return it.
#	#
$courseid = &courseid_to_courseurl($courseid);	$courseid = &courseid_to_courseurl($courseid);
my %roleshash = &dump('roles',$udom,$unam,$courseid);	my $extra = &freeze_escape({'skipcheck' => 1});
	my %roleshash = &dump('roles',$udom,$unam,$courseid,undef,$extra);
foreach my $key (keys(%roleshash)) {	foreach my $key (keys(%roleshash)) {
next if ($key !~/^\Q$courseid\E(?:\/)(\w+)\_st$/);	next if ($key !~/^\Q$courseid\E(?:\/)(\w+)\_st$/);
my $section=$1;	my $section=$1;
Line 1809 sub getversion {	Line 2115 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 2018 sub allowuploaded {	Line 2333 sub allowuploaded {
# path to file, source of file, instruction to parse file for objects,	# path to file, source of file, instruction to parse file for objects,
# ref to hash for embedded objects,	# ref to hash for embedded objects,
# ref to hash for codebase of java objects.	# ref to hash for codebase of java objects.
	# reference to scalar to accommodate mime type determined
	# from File::MMagic if $parser = parse.
#	#
# output: url to file (if action was uploaddoc),	# output: url to file (if action was uploaddoc),
# ok if successful, or diagnostic message otherwise (if action was propagate or copy)	# ok if successful, or diagnostic message otherwise (if action was propagate or copy)
Line 2044 sub allowuploaded {	Line 2361 sub allowuploaded {
#	#

sub process_coursefile {	sub process_coursefile {
my ($action,$docuname,$docudom,$file,$source,$parser,$allfiles,$codebase)=@_;	my ($action,$docuname,$docudom,$file,$source,$parser,$allfiles,$codebase,
	$mimetype)=@_;
my $fetchresult;	my $fetchresult;
my $home=&homeserver($docuname,$docudom);	my $home=&homeserver($docuname,$docudom);
if ($action eq 'propagate') {	if ($action eq 'propagate') {
Line 2072 sub process_coursefile {	Line 2390 sub process_coursefile {
close($fh);	close($fh);
if ($parser eq 'parse') {	if ($parser eq 'parse') {
my $mm = new File::MMagic;	my $mm = new File::MMagic;
my $mime_type = $mm->checktype_filename($filepath.'/'.$fname);	my $type = $mm->checktype_filename($filepath.'/'.$fname);
if ($mime_type eq 'text/html') {	if ($type eq 'text/html') {
my $parse_result = &extract_embedded_items($filepath.'/'.$fname,$allfiles,$codebase);	my $parse_result = &extract_embedded_items($filepath.'/'.$fname,$allfiles,$codebase);
unless ($parse_result eq 'ok') {	unless ($parse_result eq 'ok') {
&logthis('Failed to parse '.$filepath.'/'.$fname.' for embedded media: '.$parse_result);	&logthis('Failed to parse '.$filepath.'/'.$fname.' for embedded media: '.$parse_result);
}	}
}	}
	if (ref($mimetype)) {
	$$mimetype = $type;
	}
}	}
$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,	$fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,
$home);	$home);
Line 2194 sub resizeImage {	Line 2515 sub resizeImage {

# --------------- Take an uploaded file and put it into the userfiles directory	# --------------- Take an uploaded file and put it into the userfiles directory
# 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 filenam is in $env{"form.$formname.filename"}	# the desired filename is in $env{"form.$formname.filename"}
# $coursedoc - if true up to the current course	# $context - possible values: coursedoc, existingfile, overwrite,
# if false	# canceloverwrite, or ''.
	# if 'coursedoc': upload to the current course
	# if 'existingfile': write file to tmp/overwrites directory
	# if 'canceloverwrite': delete file written to tmp/overwrites directory
	# $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 2207 sub resizeImage {	Line 2532 sub resizeImage {
# $thumbheight - height (pixels) of thumbnail to make for uploaded image	# $thumbheight - height (pixels) of thumbnail to make for uploaded image
# $resizewidth - width (pixels) to which to resize uploaded image	# $resizewidth - width (pixels) to which to resize uploaded image
# $resizeheight - height (pixels) to which to resize uploaded image	# $resizeheight - height (pixels) to which to resize uploaded image
	# $mimetype - reference to scalar to accommodate mime type determined
	# from File::MMagic if $parser = parse.
#	#
# output: url of file in userspace, or error: <message>	# output: url of file in userspace, or error: <message>
# or /adm/notfound.html if failure to upload occurse	# or /adm/notfound.html if failure to upload occurse

sub userfileupload {	sub userfileupload {
my ($formname,$coursedoc,$subdir,$parser,$allfiles,$codebase,$destuname,	my ($formname,$context,$subdir,$parser,$allfiles,$codebase,$destuname,
$destudom,$thumbwidth,$thumbheight,$resizewidth,$resizeheight)=@_;	$destudom,$thumbwidth,$thumbheight,$resizewidth,$resizeheight,$mimetype)=@_;
if (!defined($subdir)) { $subdir='unknown'; }	if (!defined($subdir)) { $subdir='unknown'; }
my $fname=$env{'form.'.$formname.'.filename'};	my $fname=$env{'form.'.$formname.'.filename'};
$fname=&clean_filename($fname);	$fname=&clean_filename($fname);
# See if there is anything left	# See if there is anything left
unless ($fname) { return 'error: no uploaded file'; }	unless ($fname) { return 'error: no uploaded file'; }
chop($env{'form.'.$formname});	# Files uploaded to help request form, or uploaded to "create course" page are handled differently
if (($formname eq 'screenshot') && ($subdir eq 'helprequests')) { #files uploaded to help request form are handled differently	if ((($formname eq 'screenshot') && ($subdir eq 'helprequests')) \|\|
	(($formname eq 'coursecreatorxml') && ($subdir eq 'batchupload')) \|\|
	($context eq 'existingfile') \|\| ($context eq 'canceloverwrite')) {
my $now = time;	my $now = time;
my $filepath = 'tmp/helprequests/'.$now;	my $filepath;
my @parts=split(/\//,$filepath);	if (($formname eq 'screenshot') && ($subdir eq 'helprequests')) {
my $fullpath = $perlvar{'lonDaemons'};	$filepath = 'tmp/helprequests/'.$now;
for (my $i=0;$i<@parts;$i++) {	} elsif (($formname eq 'coursecreatorxml') && ($subdir eq 'batchupload')) {
$fullpath .= '/'.$parts[$i];	$filepath = 'tmp/addcourse/'.$destudom.'/web/'.$env{'user.name'}.
if ((-e $fullpath)!=1) {	'_'.$env{'user.domain'}.'/pending';
mkdir($fullpath,0777);	} elsif (($context eq 'existingfile') \|\| ($context eq 'canceloverwrite')) {
	my ($docuname,$docudom);
	if ($destudom) {
	$docudom = $destudom;
	} else {
	$docudom = $env{'user.domain'};
	}
	if ($destuname) {
	$docuname = $destuname;
	} else {
	$docuname = $env{'user.name'};
	}
	if (exists($env{'form.group'})) {
	$docuname=$env{'course.'.$env{'request.course.id'}.'.num'};
	$docudom=$env{'course.'.$env{'request.course.id'}.'.domain'};
	}
	$filepath = 'tmp/overwrites/'.$docudom.'/'.$docuname.'/'.$subdir;
	if ($context eq 'canceloverwrite') {
	my $tempfile = $perlvar{'lonDaemons'}.'/'.$filepath.'/'.$fname;
	if (-e $tempfile) {
	my @info = stat($tempfile);
	if ($info[9] eq $env{'form.timestamp'}) {
	unlink($tempfile);
	}
	}
	return;
}	}
}	}
open(my $fh,'>'.$fullpath.'/'.$fname);	# Create the directory if not present
print $fh $env{'form.'.$formname};
close($fh);
return $fullpath.'/'.$fname;
} elsif (($formname eq 'coursecreatorxml') && ($subdir eq 'batchupload')) { #files uploaded to create course page are handled differently
my $filepath = 'tmp/addcourse/'.$destudom.'/web/'.$env{'user.name'}.
'_'.$env{'user.domain'}.'/pending';
my @parts=split(/\//,$filepath);	my @parts=split(/\//,$filepath);
my $fullpath = $perlvar{'lonDaemons'};	my $fullpath = $perlvar{'lonDaemons'};
for (my $i=0;$i<@parts;$i++) {	for (my $i=0;$i<@parts;$i++) {
Line 2249 sub userfileupload {	Line 2597 sub userfileupload {
open(my $fh,'>'.$fullpath.'/'.$fname);	open(my $fh,'>'.$fullpath.'/'.$fname);
print $fh $env{'form.'.$formname};	print $fh $env{'form.'.$formname};
close($fh);	close($fh);
return $fullpath.'/'.$fname;	if ($context eq 'existingfile') {
	my @info = stat($fullpath.'/'.$fname);
	return ($fullpath.'/'.$fname,$info[9]);
	} else {
	return $fullpath.'/'.$fname;
	}
}	}
if ($subdir eq 'scantron') {	if ($subdir eq 'scantron') {
$fname = 'scantron_orig_'.$fname;	$fname = 'scantron_orig_'.$fname;
} else {	} else {
# Create the directory if not present
$fname="$subdir/$fname";	$fname="$subdir/$fname";
}	}
if ($coursedoc) {	if ($context eq 'coursedoc') {
my $docuname=$env{'course.'.$env{'request.course.id'}.'.num'};	my $docuname=$env{'course.'.$env{'request.course.id'}.'.num'};
my $docudom=$env{'course.'.$env{'request.course.id'}.'.domain'};	my $docudom=$env{'course.'.$env{'request.course.id'}.'.domain'};
if ($env{'form.folder'} =~ m/^(default\|supplemental)/) {	if ($env{'form.folder'} =~ m/^(default\|supplemental)/) {
return &finishuserfileupload($docuname,$docudom,	return &finishuserfileupload($docuname,$docudom,
$formname,$fname,$parser,$allfiles,	$formname,$fname,$parser,$allfiles,
$codebase,$thumbwidth,$thumbheight,	$codebase,$thumbwidth,$thumbheight,
$resizewidth,$resizeheight);	$resizewidth,$resizeheight,$context,$mimetype);
} else {	} else {
$fname=$env{'form.folder'}.'/'.$fname;	$fname=$env{'form.folder'}.'/'.$fname;
return &process_coursefile('uploaddoc',$docuname,$docudom,	return &process_coursefile('uploaddoc',$docuname,$docudom,
$fname,$formname,$parser,	$fname,$formname,$parser,
$allfiles,$codebase);	$allfiles,$codebase,$mimetype);
}	}
} elsif (defined($destuname)) {	} elsif (defined($destuname)) {
my $docuname=$destuname;	my $docuname=$destuname;
Line 2277 sub userfileupload {	Line 2629 sub userfileupload {
return &finishuserfileupload($docuname,$docudom,$formname,$fname,	return &finishuserfileupload($docuname,$docudom,$formname,$fname,
$parser,$allfiles,$codebase,	$parser,$allfiles,$codebase,
$thumbwidth,$thumbheight,	$thumbwidth,$thumbheight,
$resizewidth,$resizeheight);	$resizewidth,$resizeheight,$context,$mimetype);

} else {	} else {
my $docuname=$env{'user.name'};	my $docuname=$env{'user.name'};
my $docudom=$env{'user.domain'};	my $docudom=$env{'user.domain'};
Line 2289 sub userfileupload {	Line 2640 sub userfileupload {
return &finishuserfileupload($docuname,$docudom,$formname,$fname,	return &finishuserfileupload($docuname,$docudom,$formname,$fname,
$parser,$allfiles,$codebase,	$parser,$allfiles,$codebase,
$thumbwidth,$thumbheight,	$thumbwidth,$thumbheight,
$resizewidth,$resizeheight);	$resizewidth,$resizeheight,$context,$mimetype);
}	}
}	}

sub finishuserfileupload {	sub finishuserfileupload {
my ($docuname,$docudom,$formname,$fname,$parser,$allfiles,$codebase,	my ($docuname,$docudom,$formname,$fname,$parser,$allfiles,$codebase,
$thumbwidth,$thumbheight,$resizewidth,$resizeheight) = @_;	$thumbwidth,$thumbheight,$resizewidth,$resizeheight,$context,$mimetype) = @_;
my $path=$docudom.'/'.$docuname.'/';	my $path=$docudom.'/'.$docuname.'/';
my $filepath=$perlvar{'lonDocRoot'};	my $filepath=$perlvar{'lonDocRoot'};

Line 2321 sub finishuserfileupload {	Line 2672 sub finishuserfileupload {
print STDERR ('Failed to create '.$filepath.'/'.$file."\n");	print STDERR ('Failed to create '.$filepath.'/'.$file."\n");
return '/adm/notfound.html';	return '/adm/notfound.html';
}	}
if (!print FH ($env{'form.'.$formname})) {	if ($context eq 'overwrite') {
	my $source = LONCAPA::tempdir().'/overwrites/'.$docudom.'/'.$docuname.'/'.$fname;
	my $target = $filepath.'/'.$file;
	if (-e $source) {
	my @info = stat($source);
	if ($info[9] eq $env{'form.timestamp'}) {
	unless (&File::Copy::move($source,$target)) {
	&logthis('Failed to overwrite '.$filepath.'/'.$file);
	return "Moving from $source failed";
	}
	} else {
	return "Temporary file: $source had unexpected date/time for last modification";
	}
	} else {
	return "Temporary file: $source missing";
	}
	} 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 2337 sub finishuserfileupload {	Line 2704 sub finishuserfileupload {
}	}
if ($parser eq 'parse') {	if ($parser eq 'parse') {
my $mm = new File::MMagic;	my $mm = new File::MMagic;
my $mime_type = $mm->checktype_filename($filepath.'/'.$file);	my $type = $mm->checktype_filename($filepath.'/'.$file);
if ($mime_type eq 'text/html') {	if ($type eq 'text/html') {
my $parse_result = &extract_embedded_items($filepath.'/'.$file,	my $parse_result = &extract_embedded_items($filepath.'/'.$file,
$allfiles,$codebase);	$allfiles,$codebase);
unless ($parse_result eq 'ok') {	unless ($parse_result eq 'ok') {
Line 2346 sub finishuserfileupload {	Line 2713 sub finishuserfileupload {
' for embedded media: '.$parse_result);	' for embedded media: '.$parse_result);
}	}
}	}
	if (ref($mimetype)) {
	$$mimetype = $type;
	}
}	}
if (($thumbwidth =~ /^\d+$/) && ($thumbheight =~ /^\d+$/)) {	if (($thumbwidth =~ /^\d+$/) && ($thumbheight =~ /^\d+$/)) {
my $input = $filepath.'/'.$file;	my $input = $filepath.'/'.$file;
Line 2879 sub get_my_roles {	Line 3249 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') {
%dumphash = &dump('roles',$udom,$uname);	my $extra = &freeze_escape({'skipcheck' => 1});
	%dumphash = &dump('roles',$udom,$uname,'.',undef,$extra);
} else {	} else {
%dumphash=	%dumphash=
&dump('nohist_userroles',$udom,$uname);	&dump('nohist_userroles',$udom,$uname);
Line 2940 sub get_my_roles {	Line 3311 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 3059 sub courseiddump {	Line 3434 sub courseiddump {
my ($domfilter,$descfilter,$sincefilter,$instcodefilter,$ownerfilter,	my ($domfilter,$descfilter,$sincefilter,$instcodefilter,$ownerfilter,
$coursefilter,$hostidflag,$hostidref,$typefilter,$regexp_ok,	$coursefilter,$hostidflag,$hostidref,$typefilter,$regexp_ok,
$selfenrollonly,$catfilter,$showhidden,$caller,$cloner,$cc_clone,	$selfenrollonly,$catfilter,$showhidden,$caller,$cloner,$cc_clone,
$cloneonly,$createdbefore,$createdafter,$creationcontext)=@_;	$cloneonly,$createdbefore,$createdafter,$creationcontext,$domcloner)=@_;
my $as_hash = 1;	my $as_hash = 1;
my %returnhash;	my %returnhash;
if (!$domfilter) { $domfilter=''; }	if (!$domfilter) { $domfilter=''; }
Line 3081 sub courseiddump {	Line 3456 sub courseiddump {
$showhidden.':'.$caller.':'.&escape($cloner).':'.	$showhidden.':'.$caller.':'.&escape($cloner).':'.
&escape($cc_clone).':'.$cloneonly.':'.	&escape($cc_clone).':'.$cloneonly.':'.
&escape($createdbefore).':'.&escape($createdafter).':'.	&escape($createdbefore).':'.&escape($createdafter).':'.
&escape($creationcontext),$tryserver);	&escape($creationcontext).':'.$domcloner,
	$tryserver);
my @pairs=split(/\&/,$rep);	my @pairs=split(/\&/,$rep);
foreach my $item (@pairs) {	foreach my $item (@pairs) {
my ($key,$value)=split(/\=/,$item,2);	my ($key,$value)=split(/\=/,$item,2);
Line 3104 sub courseiddump {	Line 3480 sub courseiddump {
return %returnhash;	return %returnhash;
}	}

	sub courselastaccess {
	my ($cdom,$cnum,$hostidref) = @_;
	my %returnhash;
	if ($cdom && $cnum) {
	my $chome = &homeserver($cnum,$cdom);
	if ($chome ne 'no_host') {
	my $rep = &reply('courselastaccess:'.$cdom.':'.$cnum,$chome);
	&extract_lastaccess(\%returnhash,$rep);
	}
	} else {
	if (!$cdom) { $cdom=''; }
	my %libserv = &all_library();
	foreach my $tryserver (keys(%libserv)) {
	if (ref($hostidref) eq 'ARRAY') {
	next unless (grep(/^\Q$tryserver\E$/,@{$hostidref}));
	}
	if (($cdom eq '') \|\| (&host_domain($tryserver) eq $cdom)) {
	my $rep = &reply('courselastaccess:'.&host_domain($tryserver).':',$tryserver);
	&extract_lastaccess(\%returnhash,$rep);
	}
	}
	}
	return %returnhash;
	}

	sub extract_lastaccess {
	my ($returnhash,$rep) = @_;
	if (ref($returnhash) eq 'HASH') {
	unless ($rep eq 'unknown_command' \|\| $rep eq 'no_such_host' \|\|
	$rep eq 'con_lost' \|\| $rep eq 'rejected' \|\| $rep eq 'refused' \|\|
	$rep eq '') {
	my @pairs=split(/\&/,$rep);
	foreach my $item (@pairs) {
	my ($key,$value)=split(/\=/,$item,2);
	$key = &unescape($key);
	next if ($key =~ /^error: 2 /);
	$returnhash->{$key} = &thaw_unescape($value);
	}
	}
	}
	return;
	}

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

sub dcmailput {	sub dcmailput {
Line 3164 sub get_domain_roles {	Line 3583 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 3200 sub set_first_access {	Line 3619 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 3541 sub tmpreset {	Line 3875 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 3580 sub tmpstore {	Line 3914 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 3626 sub tmprestore {	Line 3960 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 3763 sub restore {	Line 4097 sub restore {
}	}

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

sub coursedescription {	sub coursedescription {
my ($courseid,$args)=@_;	my ($courseid,$args)=@_;
Line 3792 sub coursedescription {	Line 4128 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 3800 sub coursedescription {	Line 4137 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 3810 sub coursedescription {	Line 4151 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 3823 sub coursedescription {	Line 4164 sub coursedescription {
return %returnhash;	return %returnhash;
}	}

	sub update_released_required {
	my ($needsrelease,$cdom,$cnum,$chome,$cid) = @_;
	if ($cdom eq '' \|\| $cnum eq '' \|\| $chome eq '' \|\| $cid eq '') {
	$cid = $env{'request.course.id'};
	$cdom = $env{'course.'.$cid.'.domain'};
	$cnum = $env{'course.'.$cid.'.num'};
	$chome = $env{'course.'.$cid.'.home'};
	}
	if ($needsrelease) {
	my %curr_reqd_hash = &userenvironment($cdom,$cnum,'internal.releaserequired');
	my $needsupdate;
	if ($curr_reqd_hash{'internal.releaserequired'} eq '') {
	$needsupdate = 1;
	} else {
	my ($currmajor,$currminor) = split(/\./,$curr_reqd_hash{'internal.releaserequired'});
	my ($needsmajor,$needsminor) = split(/\./,$needsrelease);
	if (($currmajor < $needsmajor) \|\| ($currmajor == $needsmajor && $currminor < $needsminor)) {
	$needsupdate = 1;
	}
	}
	if ($needsupdate) {
	my %needshash = (
	'internal.releaserequired' => $needsrelease,
	);
	my $putresult = &put('environment',\%needshash,$cdom,$cnum);
	if ($putresult eq 'ok') {
	&appenv({'course.'.$cid.'.internal.releaserequired' => $needsrelease});
	my %crsinfo = &courseiddump($cdom,'.',1,'.','.',$cnum,undef,undef,'.');
	if (ref($crsinfo{$cid}) eq 'HASH') {
	$crsinfo{$cid}{'releaserequired'} = $needsrelease;
	&courseidput($cdom,\%crsinfo,$chome,'notime');
	}
	}
	}
	}
	return;
	}

# -------------------------------------------------See if a user is privileged	# -------------------------------------------------See if a user is privileged

sub privileged {	sub privileged {
Line 3862 sub rolesinit {	Line 4241 sub rolesinit {
my ($domain,$username,$authhost)=@_;	my ($domain,$username,$authhost)=@_;
my $now=time;	my $now=time;
my %userroles = ('user.login.time' => $now);	my %userroles = ('user.login.time' => $now);
my $rolesdump=reply("dump:$domain:$username:roles",$authhost);	my $extra = &freeze_escape({'skipcheck' => 1});
	my $rolesdump=reply("dump:$domain:$username:roles:.::$extra",$authhost);
if (($rolesdump eq 'con_lost') \|\| ($rolesdump eq '') \|\|	if (($rolesdump eq 'con_lost') \|\| ($rolesdump eq '') \|\|
($rolesdump =~ /^error:/)) {	($rolesdump =~ /^error:/)) {
return \%userroles;	return \%userroles;
}	}
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 3886 sub rolesinit {	Line 4265 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 3985 sub standard_roleprivs {	Line 4365 sub standard_roleprivs {
}	}

sub set_userprivs {	sub set_userprivs {
my ($userroles,$allroles,$allgroups) = @_;	my ($userroles,$allroles,$allgroups,$groups_roles) = @_;
my $author=0;	my $author=0;
my $adv=0;	my $adv=0;
my %grouproles = ();	my %grouproles = ();
if (keys(%{$allgroups}) > 0) {	if (keys(%{$allgroups}) > 0) {
	my @groupkeys;
foreach my $role (keys(%{$allroles})) {	foreach my $role (keys(%{$allroles})) {
my ($trole,$area,$sec,$extendedarea);	push(@groupkeys,$role);
if ($role =~ m-^(\w+\|cr/$match_domain/$match_username/\w+)\.(/$match_domain/$match_courseid)(/?\w*)\.-) {	}
$trole = $1;	if (ref($groups_roles) eq 'HASH') {
$area = $2;	foreach my $key (keys(%{$groups_roles})) {
$sec = $3;	unless (grep(/^\Q$key\E$/,@groupkeys)) {
$extendedarea = $area.$sec;	push(@groupkeys,$key);
if (exists($$allgroups{$area})) {	}
foreach my $group (keys(%{$$allgroups{$area}})) {	}
my $spec = $trole.'.'.$extendedarea;	}
$grouproles{$spec.'.'.$area.'/'.$group} =	if (@groupkeys > 0) {
	foreach my $role (@groupkeys) {
	my ($trole,$area,$sec,$extendedarea);
	if ($role =~ m-^(\w+\|cr/$match_domain/$match_username/\w+)\.(/$match_domain/$match_courseid)(/?\w*)\.-) {
	$trole = $1;
	$area = $2;
	$sec = $3;
	$extendedarea = $area.$sec;
	if (exists($$allgroups{$area})) {
	foreach my $group (keys(%{$$allgroups{$area}})) {
	my $spec = $trole.'.'.$extendedarea;
	$grouproles{$spec.'.'.$area.'/'.$group} =
$$allgroups{$area}{$group};	$$allgroups{$area}{$group};
	}
}	}
}	}
}	}
Line 4025 sub set_userprivs {	Line 4418 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 4034 sub set_userprivs {	Line 4427 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 4043 sub role_status {	Line 4436 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) {
if (($$where ne '') && ($$role ne '')) {	if (($$where ne '') && ($$role ne '')) {
my (%allroles,%allgroups,$group_privs);	my (%allroles,%allgroups,$group_privs,
	%groups_roles,@rolecodes);
my %userroles = (	my %userroles = (
'user.role.'.$$role.'.'.$$where => $$tstart.'.'.$$tend	'user.role.'.$$role.'.'.$$where => $$tstart.'.'.$$tend
);	);
	@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\//) {
&custom_roleprivs(\%allroles,$$role,$tdomain,$trest,$spec,$$where);	&custom_roleprivs(\%allroles,$$role,$tdomain,$trest,$spec,$$where);
	push(@rolecodes,'cr');
} elsif ($$role eq 'gr') {	} elsif ($$role eq 'gr') {
	push(@rolecodes,$$role);
my %rolehash = &get('roles',[$$where.'_'.$$role],$env{'user.domain'},	my %rolehash = &get('roles',[$$where.'_'.$$role],$env{'user.domain'},
$env{'user.name'});	$env{'user.name'});
my $trole = split('_',$rolehash{$$where.'_'.$$role},1);	my ($trole) = split('_',$rolehash{$$where.'_'.$$role},2);
(undef,my $group_privs) = split(/\//,$trole);	(undef,my $group_privs) = split(/\//,$trole);
$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);
	&get_groups_roles($tdomain,$trest,
	\%course_roles,\@rolecodes,
	\%groups_roles);
} else {	} else {
	push(@rolecodes,$$role);
&standard_roleprivs(\%allroles,$$role,$tdomain,$spec,$trest,$$where);	&standard_roleprivs(\%allroles,$$role,$tdomain,$spec,$trest,$$where);
}	}
my ($author,$adv)= &set_userprivs(\%userroles,\%allroles,\%allgroups);	my ($author,$adv)= &set_userprivs(\%userroles,\%allroles,\%allgroups,\%groups_roles);
&appenv(\%userroles,[$$role,'cm']);	&appenv(\%userroles,\@rolecodes);
&log($env{'user.domain'},$env{'user.name'},$env{'user.home'},"Role ".$role);	&log($env{'user.domain'},$env{'user.name'},$env{'user.home'},"Role ".$role);
}	}
}	}
Line 4075 sub role_status {	Line 4477 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 4085 sub role_status {	Line 4487 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) = @_;	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);	&set_adhoc_privileges($cdom,$cnum,$checkrole,$caller);
}	}
} else {	} else {
&set_adhoc_privileges($cdom,$cnum,$checkrole);	&set_adhoc_privileges($cdom,$cnum,$checkrole,$caller);
}	}
}	}

sub set_adhoc_privileges {	sub set_adhoc_privileges {
# role can be cc or ca	# role can be cc or ca
my ($dcdom,$pickedcourse,$role) = @_;	my ($dcdom,$pickedcourse,$role,$caller) = @_;
my $area = '/'.$dcdom.'/'.$pickedcourse;	my $area = '/'.$dcdom.'/'.$pickedcourse;
my $spec = $role.'.'.$area;	my $spec = $role.'.'.$area;
my %userroles = &set_arearole($role,$area,'','',$env{'user.domain'},	my %userroles = &set_arearole($role,$area,'','',$env{'user.domain'},
Line 4111 sub set_adhoc_privileges {	Line 4571 sub set_adhoc_privileges {
my ($author,$adv)= &set_userprivs(\%userroles,\%ccrole);	my ($author,$adv)= &set_userprivs(\%userroles,\%ccrole);
&appenv(\%userroles,[$role,'cm']);	&appenv(\%userroles,[$role,'cm']);
&log($env{'user.domain'},$env{'user.name'},$env{'user.home'},"Role ".$role);	&log($env{'user.domain'},$env{'user.name'},$env{'user.home'},"Role ".$role);
&appenv( {'request.role' => $spec,	unless ($caller eq 'constructaccess' && $env{'request.course.id'}) {
'request.role.domain' => $dcdom,	&appenv( {'request.role' => $spec,
'request.course.sec' => ''	'request.role.domain' => $dcdom,
}	'request.course.sec' => ''
);	}
my $tadv=0;	);
if (&allowed('adv') eq 'F') { $tadv=1; }	my $tadv=0;
&appenv({'request.role.adv' => $tadv});	if (&allowed('adv') eq 'F') { $tadv=1; }
	&appenv({'request.role.adv' => $tadv});
	}
}	}

# --------------------------------------------------------------- get interface	# --------------------------------------------------------------- get interface
Line 4167 sub del {	Line 4629 sub del {
# -------------------------------------------------------------- dump interface	# -------------------------------------------------------------- dump interface

sub dump {	sub dump {
my ($namespace,$udomain,$uname,$regexp,$range)=@_;	my ($namespace,$udomain,$uname,$regexp,$range,$extra)=@_;
if (!$udomain) { $udomain=$env{'user.domain'}; }	if (!$udomain) { $udomain=$env{'user.domain'}; }
if (!$uname) { $uname=$env{'user.name'}; }	if (!$uname) { $uname=$env{'user.name'}; }
my $uhome=&homeserver($uname,$udomain);	my $uhome=&homeserver($uname,$udomain);
Line 4176 sub dump {	Line 4638 sub dump {
} else {	} else {
$regexp='.';	$regexp='.';
}	}
my $rep=&reply("dump:$udomain:$uname:$namespace:$regexp:$range",$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 4470 sub tmpget {	Line 4935 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 4581 sub get_portfolio_access {	Line 5046 sub get_portfolio_access {
my (%allgroups,%allroles);	my (%allgroups,%allroles);
my ($start,$end,$role,$sec,$group);	my ($start,$end,$role,$sec,$group);
foreach my $envkey (%env) {	foreach my $envkey (%env) {
if ($envkey =~ m-^user\.role\.(gr\|cc\|in\|ta\|ep\|st)\./($match_domain)/($match_courseid)/?([^/]*)$-) {	if ($envkey =~ m-^user\.role\.(gr\|cc\|co\|in\|ta\|ep\|ad\|st)\./($match_domain)/($match_courseid)/?([^/]*)$-) {
my $cid = $2.'_'.$3;	my $cid = $2.'_'.$3;
if ($1 eq 'gr') {	if ($1 eq 'gr') {
$group = $4;	$group = $4;
Line 4721 sub is_portfolio_file {	Line 5186 sub is_portfolio_file {
}	}

sub usertools_access {	sub usertools_access {
my ($uname,$udom,$tool,$action,$context) = @_;	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 4763 sub usertools_access {	Line 5228 sub usertools_access {
$toolstatus = $env{'environment.'.$context.'.'.$tool};	$toolstatus = $env{'environment.'.$context.'.'.$tool};
$inststatus = $env{'environment.inststatus'};	$inststatus = $env{'environment.inststatus'};
} else {	} else {
my %userenv = &userenvironment($udom,$uname,$context.'.'.$tool,'inststatus');	if (ref($userenvref) eq 'HASH') {
$toolstatus = $userenv{$context.'.'.$tool};	$toolstatus = $userenvref->{$context.'.'.$tool};
$inststatus = $userenv{'inststatus'};	$inststatus = $userenvref->{'inststatus'};
	} else {
	my %userenv = &userenvironment($udom,$uname,$context.'.'.$tool,'inststatus');
	$toolstatus = $userenv{$context.'.'.$tool};
	$inststatus = $userenv{'inststatus'};
	}
}	}

if ($toolstatus ne '') {	if ($toolstatus ne '') {
Line 4777 sub usertools_access {	Line 5247 sub usertools_access {
return $access;	return $access;
}	}

my $is_adv = &is_advanced_user($udom,$uname);	my ($is_adv,%domdef);
my %domdef = &get_domain_defaults($udom);	if (ref($is_advref) eq 'HASH') {
	$is_adv = $is_advref->{'is_adv'};
	} else {
	$is_adv = &is_advanced_user($udom,$uname);
	}
	if (ref($domdefref) eq 'HASH') {
	%domdef = %{$domdefref};
	} else {
	%domdef = &get_domain_defaults($udom);
	}
if (ref($domdef{$tool}) eq 'HASH') {	if (ref($domdef{$tool}) eq 'HASH') {
if ($is_adv) {	if ($is_adv) {
if ($domdef{$tool}{'_LC_adv'} ne '') {	if ($domdef{$tool}{'_LC_adv'} ne '') {
Line 4852 sub is_course_owner {	Line 5331 sub is_course_owner {

sub is_advanced_user {	sub is_advanced_user {
my ($udom,$uname) = @_;	my ($udom,$uname) = @_;
	if ($udom ne '' && $uname ne '') {
	if (($udom eq $env{'user.domain'}) && ($uname eq $env{'user.name'})) {
	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;
Line 5367 sub allowed {	Line 5851 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') {	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 5377 sub allowed {	Line 5861 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') {	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 5391 sub allowed {	Line 5875 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') {	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 5574 sub update_allusers_table {	Line 6058 sub update_allusers_table {
'generation='.&escape($names->{'generation'}).'%%'.	'generation='.&escape($names->{'generation'}).'%%'.
'permanentemail='.&escape($names->{'permanentemail'}).'%%'.	'permanentemail='.&escape($names->{'permanentemail'}).'%%'.
'id='.&escape($names->{'id'}),$homeserver);	'id='.&escape($names->{'id'}),$homeserver);
my $reply = &get_query_reply($queryid);	return;
return $reply;
}	}

# ------- Request retrieval of institutional classlists for course(s)	# ------- Request retrieval of institutional classlists for course(s)
Line 5619 sub fetch_enrollment_query {	Line 6102 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 5649 sub fetch_enrollment_query {	Line 6132 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 5745 sub auto_get_sections {	Line 6228 sub auto_get_sections {
}	}

sub auto_new_course {	sub auto_new_course {
my ($cnum,$cdom,$inst_course_id,$owner) = @_;	my ($cnum,$cdom,$inst_course_id,$owner,$coowners) = @_;
my $homeserver = &homeserver($cnum,$cdom);	my $homeserver = &homeserver($cnum,$cdom);
my $response=&unescape(&reply('autonewcourse:'.$inst_course_id.':'.$owner.':'.$cdom,$homeserver));	my $response=&unescape(&reply('autonewcourse:'.$inst_course_id.':'.&escape($owner).':'.$cdom.':'.&escape($coowners),$homeserver));
return $response;	return $response;
}	}

Line 5769 sub auto_validate_instcode {	Line 6252 sub auto_validate_instcode {
$homeserver = &domain($cdom,'primary');	$homeserver = &domain($cdom,'primary');
}	}
}	}
my $response=&unescape(&reply('autovalidateinstcode:'.$cdom.':'.	$response=&unescape(&reply('autovalidateinstcode:'.$cdom.':'.
&escape($instcode).':'.&escape($owner),$homeserver));	&escape($instcode).':'.&escape($owner),$homeserver));
my ($outcome,$description) = map { &unescape($_); } split('&',$response,2);	my ($outcome,$description) = map { &unescape($_); } split('&',$response,2);
return ($outcome,$description);	return ($outcome,$description);
}	}
Line 6138 sub get_users_groups {	Line 6621 sub get_users_groups {
} else {	} else {
$grouplist = '';	$grouplist = '';
my $courseurl = &courseid_to_courseurl($courseid);	my $courseurl = &courseid_to_courseurl($courseid);
my %roleshash = &dump('roles',$udom,$uname,$courseurl);	my $extra = &freeze_escape({'skipcheck' => 1});
	my %roleshash = &dump('roles',$udom,$uname,$courseurl,undef,$extra);
my $access_end = $env{'course.'.$courseid.	my $access_end = $env{'course.'.$courseid.
'.default_enrollment_end_date'};	'.default_enrollment_end_date'};
my $now = time;	my $now = time;
Line 6375 sub autoupdate_coowners {	Line 6859 sub autoupdate_coowners {
my %coursehash = &coursedescription($cdom.'_'.$cnum);	my %coursehash = &coursedescription($cdom.'_'.$cnum);
my $instcode = $coursehash{'internal.coursecode'};	my $instcode = $coursehash{'internal.coursecode'};
if ($instcode ne '') {	if ($instcode ne '') {
unless ($coursehash{'internal.courseowner'} eq $uname.':'.$udom) {	if (($start && $start <= $now) && ($end == 0) \|\| ($end > $now)) {
my ($result,$desc) = &auto_validate_instcode($cnum,$cdom,$instcode,$uname.':'.$udom);	unless ($coursehash{'internal.courseowner'} eq $uname.':'.$udom) {
if ($result eq 'valid') {
my ($delcoowners,@newcoowners,$putresult,$delresult,$coowners);	my ($delcoowners,@newcoowners,$putresult,$delresult,$coowners);
if (($end == 0) \|\| ($end > $now)) {	my ($result,$desc) = &auto_validate_instcode($cnum,$cdom,$instcode,$uname.':'.$udom);
if ($coursehash{'internal.co-owners'}) {	if ($result eq 'valid') {
	if ($coursehash{'internal.co-owners'}) {
foreach my $coowner (split(',',$coursehash{'internal.co-owners'})) {	foreach my $coowner (split(',',$coursehash{'internal.co-owners'})) {
push(@newcoowners,$coowner);	push(@newcoowners,$coowner);
}	}
Line 6481 sub modifyuser {	Line 6965 sub modifyuser {
my ($udom, $uname, $uid,	my ($udom, $uname, $uid,
$umode, $upass, $first,	$umode, $upass, $first,
$middle, $last, $gene,	$middle, $last, $gene,
$forceid, $desiredhome, $email, $inststatus)=@_;	$forceid, $desiredhome, $email, $inststatus, $candelete)=@_;
$udom= &LONCAPA::clean_domain($udom);	$udom= &LONCAPA::clean_domain($udom);
$uname=&LONCAPA::clean_username($uname);	$uname=&LONCAPA::clean_username($uname);
	my $showcandelete = 'none';
	if (ref($candelete) eq 'ARRAY') {
	if (@{$candelete} > 0) {
	$showcandelete = join(', ',@{$candelete});
	}
	}
&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.')'.	$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'}.
' in domain '.$env{'request.role.domain'});	' in domain '.$env{'request.role.domain'});
my $uhome=&homeserver($uname,$udom,'true');	my $uhome=&homeserver($uname,$udom,'true');
	my $newuser;
	if ($uhome eq 'no_host') {
	$newuser = 1;
	}
# ----------------------------------------------------------------- Create User	# ----------------------------------------------------------------- Create User
if (($uhome eq 'no_host') &&	if (($uhome eq 'no_host') &&
(($umode && $upass) \|\| ($umode eq 'localauth'))) {	(($umode && $upass) \|\| ($umode eq 'localauth'))) {
Line 6544 sub modifyuser {	Line 7038 sub modifyuser {
['firstname','middlename','lastname','generation','id',	['firstname','middlename','lastname','generation','id',
'permanentemail','inststatus'],	'permanentemail','inststatus'],
$udom,$uname);	$udom,$uname);
my %names;	my (%names,%oldnames);
if ($tmp[0] =~ m/^error:.*/) {	if ($tmp[0] =~ m/^error:.*/) {
%names=();	%names=();
} else {	} else {
%names = @tmp;	%names = @tmp;
	%oldnames = %names;
}	}
#	#
# Make sure to not trash student environment if instructor does not bother	# If name, email and/or uid are blank (e.g., because an uploaded file
# to supply name and email information	# of users did not contain them), do not overwrite existing values
#	# unless field is in $candelete array ref.
	#

	my @fields = ('firstname','middlename','lastname','generation',
	'permanentemail','id');
	my %newvalues;
	if (ref($candelete) eq 'ARRAY') {
	foreach my $field (@fields) {
	if (grep(/^\Q$field\E$/,@{$candelete})) {
	if ($field eq 'firstname') {
	$names{$field} = $first;
	} elsif ($field eq 'middlename') {
	$names{$field} = $middle;
	} elsif ($field eq 'lastname') {
	$names{$field} = $last;
	} elsif ($field eq 'generation') {
	$names{$field} = $gene;
	} elsif ($field eq 'permanentemail') {
	$names{$field} = $email;
	} elsif ($field eq 'id') {
	$names{$field} = $uid;
	}
	}
	}
	}
if ($first) { $names{'firstname'} = $first; }	if ($first) { $names{'firstname'} = $first; }
if (defined($middle)) { $names{'middlename'} = $middle; }	if (defined($middle)) { $names{'middlename'} = $middle; }
if ($last) { $names{'lastname'} = $last; }	if ($last) { $names{'lastname'} = $last; }
Line 6578 sub modifyuser {	Line 7097 sub modifyuser {
}	}
}	}
}	}
my $reply = &put('environment', \%names, $udom,$uname);	my $logmsg = $udom.', '.$uname.', '.$uid.', '.
if ($reply ne 'ok') { return 'error: '.$reply; }
my $sqlresult = &update_allusers_table($uname,$udom,\%names);
&devalidate_cache_new('namescache',$uname.':'.$udom);
my $logmsg = 'Success modifying user '.$udom.', '.$uname.', '.$uid.', '.
$umode.', '.$first.', '.$middle.', '.	$umode.', '.$first.', '.$middle.', '.
$last.', '.$gene.', '.$email.', '.$inststatus;	$last.', '.$gene.', '.$email.', '.$inststatus;
if ($env{'user.name'} ne '' && $env{'user.domain'}) {	if ($env{'user.name'} ne '' && $env{'user.domain'}) {
$logmsg .= ' by '.$env{'user.name'}.' at '.$env{'user.domain'};	$logmsg .= ' by '.$env{'user.name'}.' at '.$env{'user.domain'};
} else {	} else {
$logmsg .= ' during self creation';	$logmsg .= ' during self creation';
}	}
	my $changed;
	if ($newuser) {
	$changed = 1;
	} else {
	foreach my $field (@fields) {
	if ($names{$field} ne $oldnames{$field}) {
	$changed = 1;
	last;
	}
	}
	}
	unless ($changed) {
	$logmsg = 'No changes in user information needed for: '.$logmsg;
	&logthis($logmsg);
	return 'ok';
	}
	my $reply = &put('environment', \%names, $udom,$uname);
	if ($reply ne 'ok') {
	return 'error: '.$reply;
	}
	if ($names{'permanentemail'} ne $oldnames{'permanentemail'}) {
	&Apache::lonnet::devalidate_cache_new('emailscache',$uname.':'.$udom);
	}
	my $sqlresult = &update_allusers_table($uname,$udom,\%names);
	&devalidate_cache_new('namescache',$uname.':'.$udom);
	$logmsg = 'Success modifying user '.$logmsg;
&logthis($logmsg);	&logthis($logmsg);
return 'ok';	return 'ok';
}	}
Line 6830 ENDINITMAP	Line 7371 ENDINITMAP
}	}
# ----------------------------------------------------------- Write preferences	# ----------------------------------------------------------- Write preferences
&writecoursepref($udom.'_'.$uname,	&writecoursepref($udom.'_'.$uname,
('description' => $description,	('description' => $description,
'url' => $topurl));	'url' => $topurl,
	'internal.creator' => $env{'user.name'}.':'.
	$env{'user.domain'},
	'internal.created' => $now,
	'internal.creationcontext' => $context)
	);
return '/'.$udom.'/'.$uname;	return '/'.$udom.'/'.$uname;
}	}

Line 6901 sub store_userdata {	Line 7447 sub store_userdata {
$namevalue.=&escape($key).'='.&freeze_escape($$storehash{$key}).'&';	$namevalue.=&escape($key).'='.&freeze_escape($$storehash{$key}).'&';
}	}
$namevalue=~s/\&$//;	$namevalue=~s/\&$//;
$result = &reply("store:$env{'user.domain'}:$env{'user.name'}:".	$result = &reply("store:$udom:$uname:$namespace:$datakey:".
"$namespace:$datakey:$namevalue",$uhome);	$namevalue,$uhome);
}	}
} else {	} else {
$result = 'error: data to store was not a hash reference';	$result = 'error: data to store was not a hash reference';
Line 6955 sub diskusage {	Line 7501 sub diskusage {
}	}

sub is_locked {	sub is_locked {
my ($file_name, $domain, $user) = @_;	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 6967 sub is_locked {	Line 7513 sub is_locked {
if (ref($locked{$file_name}) eq 'ARRAY') {	if (ref($locked{$file_name}) eq 'ARRAY') {
$is_locked = 'false';	$is_locked = 'false';
foreach my $entry (@{$locked{$file_name}}) {	foreach my $entry (@{$locked{$file_name}}) {
if (ref($entry) eq 'ARRAY') {	if (ref($entry) eq 'ARRAY') {
$is_locked = 'true';	$is_locked = 'true';
last;	if (ref($which) eq 'ARRAY') {
	push(@{$which},$entry);
	} else {
	last;
	}
}	}
}	}
} else {	} else {
$is_locked = 'false';	$is_locked = 'false';
}	}
	return $is_locked;
}	}

sub declutter_portfile {	sub declutter_portfile {
Line 7018 sub save_selected_files {	Line 7569 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 7028 sub files_in_path {	Line 7579 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 7050 sub files_not_in_path {	Line 7601 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 8117 sub add_prefix_and_part {	Line 8668 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 8124 sub metadata {	Line 8676 sub metadata {
if (($uri eq '') \|\|	if (($uri eq '') \|\|
(($uri =~ m\|^/*adm/\|) &&	(($uri =~ m\|^/*adm/\|) &&
($uri !~ m\|^adm/includes\|) && ($uri !~ m\|/bulletinboard$\|)) \|\|	($uri !~ m\|^adm/includes\|) && ($uri !~ m\|/bulletinboard$\|)) \|\|
($uri =~ m\|/$\|) \|\| ($uri =~ m\|/.meta$\|) ) {	($uri =~ m\|/$\|) \|\| ($uri =~ m\|/.meta$\|) \|\| ($uri =~ m{^/*uploaded/.+\.sequence$})) {
return undef;	return undef;
}	}
if (($uri =~ /^~/ \|\| $uri =~ m{home/$match_username/public_html/})	if (($uri =~ /^~/ \|\| $uri =~ m{home/$match_username/public_html/})
Line 8143 sub metadata {	Line 8695 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 8166 sub metadata {	Line 8722 sub metadata {
&Apache::lonnet::ssi_body($which,	&Apache::lonnet::ssi_body($which,
('grade_target' => 'meta'));	('grade_target' => 'meta'));
$cachetime = 1; # only want this cached in the child not long term	$cachetime = 1; # only want this cached in the child not long term
} elsif ($uri !~ m -^(editupload)/-) {	} elsif (($uri !~ m -^(editupload)/-) &&
	($uri !~ m{^/*uploaded/$match_domain/$match_courseid/docs/})) {
my $file=&filelocation('',&clutter($filename));	my $file=&filelocation('',&clutter($filename));
#push(@{$metaentry{$uri.'.file'}},$file);	#push(@{$metaentry{$uri.'.file'}},$file);
$metastring=&getfile($file);	$metastring=&getfile($file);
Line 8226 sub metadata {	Line 8783 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 8254 sub metadata {	Line 8839 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 8330 sub metadata {	Line 8922 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 8514 sub symbverify {	Line 9122 sub symbverify {
$thisurl =~ s/\?.+$//;	$thisurl =~ s/\?.+$//;
}	}
my $ids=$bighash{'ids_'.&clutter($thisurl)};	my $ids=$bighash{'ids_'.&clutter($thisurl)};
unless ($ids) {	unless ($ids) {
$ids=$bighash{'ids_/'.$thisurl};	my $idkey = 'ids_'.($thisurl =~ m{^/}? '' : '/').$thisurl;
	$ids=$bighash{$idkey};
}	}
if ($ids) {	if ($ids) {
# ------------------------------------------------------------------- Has ID(s)	# ------------------------------------------------------------------- Has ID(s)
Line 8528 sub symbverify {	Line 9137 sub symbverify {
&symbclean(&declutter($bighash{'map_id_'.$mapid}).'___'.$resid.'___'.$thisfn)	&symbclean(&declutter($bighash{'map_id_'.$mapid}).'___'.$resid.'___'.$thisfn)
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')) {
$okay=1;	$okay=1;
}	}
}	}
Line 9285 sub filelocation {	Line 9895 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 9606 sub get_dns {	Line 10216 sub get_dns {
my %libserv;	my %libserv;
my $loaded;	my $loaded;
my %name_to_host;	my %name_to_host;
	my %internetdom;
	my %LC_dns_serv;

sub parse_hosts_tab {	sub parse_hosts_tab {
my ($file) = @_;	my ($file) = @_;
foreach my $configline (@$file) {	foreach my $configline (@$file) {
next if ($configline =~ /^(\#\|\s*$ )/x);	next if ($configline =~ /^(\#\|\s*$ )/x);
next if ($configline =~ /^\^/);	chomp($configline);
chomp($configline);	if ($configline =~ /^\^/) {
my ($id,$domain,$role,$name,$protocol)=split(/:/,$configline);	if ($configline =~ /^\^([\w.\-]+)/) {
	$LC_dns_serv{$1} = 1;
	}
	next;
	}
	my ($id,$domain,$role,$name,$protocol,$intdom)=split(/:/,$configline);
$name=~s/\s//g;	$name=~s/\s//g;
if ($id && $domain && $role && $name) {	if ($id && $domain && $role && $name) {
$hostname{$id}=$name;	$hostname{$id}=$name;
Line 9629 sub get_dns {	Line 10246 sub get_dns {
} else {	} else {
$protocol{$id} = 'http';	$protocol{$id} = 'http';
}	}
	if (defined($intdom)) {
	$internetdom{$id} = $intdom;
	}
}	}
}	}
}	}
Line 9690 sub get_dns {	Line 10310 sub get_dns {
return %libserv;	return %libserv;
}	}

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

sub get_servers {	sub get_servers {
&load_hosts_tab() if (!$loaded);	&load_hosts_tab() if (!$loaded);

Line 9713 sub get_dns {	Line 10339 sub get_dns {
return %result;	return %result;
}	}

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

sub host_domain {	sub host_domain {
&load_hosts_tab() if (!$loaded);	&load_hosts_tab() if (!$loaded);

Line 9727 sub get_dns {	Line 10358 sub get_dns {
my @uniq = grep(!$seen{$_}++, values(%hostdom));	my @uniq = grep(!$seen{$_}++, values(%hostdom));
return @uniq;	return @uniq;
}	}

	sub internet_dom {
	&load_hosts_tab() if (!$loaded);

	my ($lonid) = @_;
	return $internetdom{$lonid};
	}

	sub is_LC_dns {
	&load_hosts_tab() if (!$loaded);

	my ($hostname) = @_;
	return exists($LC_dns_serv{$hostname});
	}

}	}

{	{
Line 9844 sub get_dns {	Line 10490 sub get_dns {
return undef;	return undef;
}	}

	sub get_internet_names {
	my ($lonid) = @_;
	return if ($lonid eq '');
	my ($idnref,$cached)=
	&Apache::lonnet::is_cached_new('internetnames',$lonid);
	if ($cached) {
	return $idnref;
	}
	my $ip = &get_host_ip($lonid);
	my @hosts = &get_hosts_from_ip($ip);
	my %iphost = &get_iphost();
	my (@idns,%seen);
	foreach my $id (@hosts) {
	my $dom = &host_domain($id);
	my $prim_id = &domain($dom,'primary');
	my $prim_ip = &get_host_ip($prim_id);
	next if ($seen{$prim_ip});
	if (ref($iphost{$prim_ip}) eq 'ARRAY') {
	foreach my $id (@{$iphost{$prim_ip}}) {
	my $intdom = &internet_dom($id);
	unless (grep(/^\Q$intdom\E$/,@idns)) {
	push(@idns,$intdom);
	}
	}
	}
	$seen{$prim_ip} = 1;
	}
	return &Apache::lonnet::do_cache_new('internetnames',$lonid,\@idns,126060);
	}

	}

	sub all_loncaparevs {
	return qw(1.1 1.2 1.3 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 2.10);
}	}

BEGIN {	BEGIN {
Line 9921 BEGIN {	Line 10601 BEGIN {
close($config);	close($config);
}	}

	# ---------------------------------------------------------- Read loncaparev table
	{
	if (-e "$perlvar{'lonTabDir'}/loncaparevs.tab") {
	if (open(my $config,"<$perlvar{'lonTabDir'}/loncaparevs.tab")) {
	while (my $configline=<$config>) {
	chomp($configline);
	my ($hostid,$loncaparev)=split(/:/,$configline);
	$loncaparevs{$hostid}=$loncaparev;
	}
	close($config);
	}
	}
	}

	# ---------------------------------------------------------- Read serverhostID table
	{
	if (-e "$perlvar{'lonTabDir'}/serverhomeIDs.tab") {
	if (open(my $config,"<$perlvar{'lonTabDir'}/serverhomeIDs.tab")) {
	while (my $configline=<$config>) {
	chomp($configline);
	my ($name,$id)=split(/:/,$configline);
	$serverhomeIDs{$name}=$id;
	}
	close($config);
	}
	}
	}

	{
	my $file = $Apache::lonnet::perlvar{'lonTabDir'}.'/releaseslist.xml';
	if (-e $file) {
	my $parser = HTML::LCParser->new($file);
	while (my $token = $parser->get_token()) {
	if ($token->[0] eq 'S') {
	my $item = $token->[1];
	my $name = $token->[2]{'name'};
	my $value = $token->[2]{'value'};
	if ($item ne '' && $name ne '' && $value ne '') {
	my $release = $parser->get_text();
	$release =~ s/(^\s\|\s$ )//gx;
	$needsrelease{$item.':'.$name.':'.$value} = $release;
	}
	}
	}
	}
	}

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

}	}

Line 10151 authentication scheme	Line 10878 authentication scheme

=item *	=item *
X<authenticate()>	X<authenticate()>
B<authenticate($uname,$upass,$udom)>: try to	B<authenticate($uname,$upass,$udom,$checkdefauth,$clientcancheckhost)>: try to
authenticate user from domain's lib servers (first use the current	authenticate user from domain's lib servers (first use the current
one). C<$upass> should be the users password.	one). C<$upass> should be the users password.
	$checkdefauth is optional (value is 1 if a check should be made to
	authenticate user using default authentication method, and allow
	account creation if username does not have account in the domain).
	$clientcancheckhost is optional (value is 1 if checking whether the
	server can host will occur on the client side in lonauth.pm).

=item *	=item *
X<homeserver()>	X<homeserver()>
Line 10275 modifyuserauth($udom,$uname,$umode,$upas	Line 11007 modifyuserauth($udom,$uname,$umode,$upas

=item *	=item *

modifyuser($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,	modifyuser($udom,$uname,$uid,$umode,$upass,$first,$middle,$last, $gene,
$forceid,$desiredhome,$email,$inststatus) :	$forceid,$desiredhome,$email,$inststatus,$candelete) :
modify user
	will update user information (firstname,middlename,lastname,generation,
	permanentemail), and if forceid is true, student/employee ID also.
	A user's institutional affiliation(s) can also be updated.
	User information fields will not be overwritten with empty entries
	unless the field is included in the $candelete array reference.
	This array is included when a single user is modified via "Manage Users",
	or when Autoupdate.pl is run by cron in a domain.

=item *	=item *

Line 10405 revokecustomrole($udom,$uname,$url,$role	Line 11144 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 10802 splitting on '&', supports elements that	Line 11562 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 10822 logperm() : append a permanent message t	Line 11583 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 10895 userfileupload(): main rotine for puttin	Line 11657 userfileupload(): main rotine for puttin
filename, and the contents of the file to create/modifed exist	filename, and the contents of the file to create/modifed exist
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}
coursedoc - if true, 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 '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/
if undefined, it will be placed in "unknown"	if undefined, it will be placed in "unknown"

Line 10918 returns: the new clean filename	Line 11682 returns: the new clean filename

=item *	=item *

finishuserfileupload(): routine that creaes and sends the file to	finishuserfileupload(): routine that creates and sends the file to
userspace, probably shouldn't be called directly	userspace, probably shouldn't be called directly

docuname: username or courseid of destination for the file	docuname: username or courseid of destination for the file
docudom: domain of user/course of destination for the file	docudom: domain of user/course of destination for the file
formname: same as for userfileupload()	formname: same as for userfileupload()
fname: filename (inculding subdirectories) for the file	fname: filename (including subdirectories) for the file
	parser: if 'parse', will parse (html) file to extract references to objects, links etc.
	allfiles: reference to hash used to store objects found by parser
	codebase: reference to hash used for codebases of java objects found by parser
	thumbwidth: width (pixels) of thumbnail to be created for uploaded image
	thumbheight: height (pixels) of thumbnail to be created for uploaded image
	resizewidth: width to be used to resize image using resizeImage from ImageMagick
	resizeheight: height to be used to resize image using resizeImage from ImageMagick
	context: if 'overwrite', will move the uploaded file from its temporary location to
	userfiles to facilitate overwriting a previously uploaded file with same name.
	mimetype: reference to scalar to accommodate mime type determined
	from File::MMagic if $parser = parse.

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	and /adm/notfound.html if unsuccessful (or an error message if context
	was 'overwrite').


=item *	=item *

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

Removed from v.1.1054
changed lines
	Added in v.1.1123