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.1111 and 1.1159

version 1.1111, 2011/06/06 23:28:48	version 1.1159, 2012/03/15 18:15:55
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 %loncaparevs %serverhomeIDs %needsrelease);	$_64bit %env %protocol %loncaparevs %serverhomeIDs %needsrelease
	%managerstab);

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

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

my $readit;	my $readit;
Line 305 sub get_server_homeID {	Line 307 sub get_server_homeID {
return &do_cache_new('serverhomeID',$hostname,$serverhomeID,$cachetime);	return &do_cache_new('serverhomeID',$hostname,$serverhomeID,$cachetime);
}	}

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

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

# -------------------------------------------------- Non-critical communication	# -------------------------------------------------- Non-critical communication
sub subreply {	sub subreply {
my ($cmd,$server)=@_;	my ($cmd,$server)=@_;
Line 547 sub transfer_profile_to_env {	Line 595 sub transfer_profile_to_env {

# ---------------------------------------------------- Check for valid session	# ---------------------------------------------------- Check for valid session
sub check_for_valid_session {	sub check_for_valid_session {
my ($r) = @_;	my ($r,$name) = @_;
my %cookies=CGI::Cookie->parse($r->header_in('Cookie'));	my %cookies=CGI::Cookie->parse($r->header_in('Cookie'));
my $lonid=$cookies{'lonID'};	if ($name eq '') {
	$name = 'lonID';
	}
	my $lonid=$cookies{$name};
return undef if (!$lonid);	return undef if (!$lonid);

my $handle=&LONCAPA::clean_handle($lonid->value);	my $handle=&LONCAPA::clean_handle($lonid->value);
my $lonidsdir=$r->dir_config('lonIDsDir');	my $lonidsdir;
	if ($name eq 'lonDAV') {
	$lonidsdir=$r->dir_config('lonDAVsessDir');
	} else {
	$lonidsdir=$r->dir_config('lonIDsDir');
	}
return undef if (!-e "$lonidsdir/$handle.id");	return undef if (!-e "$lonidsdir/$handle.id");

my $opened = open(my $idf,'+<',"$lonidsdir/$handle.id");	my $opened = open(my $idf,'+<',"$lonidsdir/$handle.id");
Line 772 sub spareserver {	Line 828 sub spareserver {
my %udomdefaults = &Apache::lonnet::get_domain_defaults($udom);	my %udomdefaults = &Apache::lonnet::get_domain_defaults($udom);
$remotesessions = $udomdefaults{'remotesessions'};	$remotesessions = $udomdefaults{'remotesessions'};
}	}
foreach my $try_server (@{ $spareid{'primary'} }) {	my $spareshash = &this_host_spares($udom);
if ($uint_dom) {	if (ref($spareshash) eq 'HASH') {
next unless (&spare_can_host($udom,$uint_dom,$remotesessions,	if (ref($spareshash->{'primary'}) eq 'ARRAY') {
$try_server));	foreach my $try_server (@{ $spareshash->{'primary'} }) {
	if ($uint_dom) {
	next unless (&spare_can_host($udom,$uint_dom,$remotesessions,
	$try_server));
	}
	($spare_server, $lowest_load) =
	&compare_server_load($try_server, $spare_server, $lowest_load);
	}
}	}
($spare_server, $lowest_load) =
&compare_server_load($try_server, $spare_server, $lowest_load);
}

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

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

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

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

my $load;	my $load;
Line 842 sub compare_server_load {	Line 905 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 862 sub has_user_session {	Line 934 sub has_user_session {
# --------- determine least loaded server in a user's domain which allows login	# --------- determine least loaded server in a user's domain which allows login

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

# --------------------------------------------- Try to change a user's password	# --------------------------------------------- Try to change a user's password
Line 1018 sub can_host_session {	Line 1108 sub can_host_session {
}	}
if ($canhost) {	if ($canhost) {
if (ref($hostedsessions) eq 'HASH') {	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 (ref($hostedsessions->{'excludedomain'}) eq 'ARRAY') {
if (grep(/^\Q$udom\E$/,@{$hostedsessions->{'excludedomain'}})) {	if (($uint_dom ne '') &&
	(grep(/^\Q$uint_dom\E$/,@{$hostedsessions->{'excludedomain'}}))) {
$canhost = 0;	$canhost = 0;
} else {	} else {
$canhost = 1;	$canhost = 1;
}	}
}	}
if (ref($hostedsessions->{'includedomain'}) eq 'ARRAY') {	if (ref($hostedsessions->{'includedomain'}) eq 'ARRAY') {
if (grep(/^\Q$udom\E$/,@{$hostedsessions->{'includedomain'}})) {	if (($uint_dom ne '') &&
	(grep(/^\Q$uint_dom\E$/,@{$hostedsessions->{'includedomain'}}))) {
$canhost = 1;	$canhost = 1;
} else {	} else {
$canhost = 0;	$canhost = 0;
Line 1057 sub spare_can_host {	Line 1151 sub spare_can_host {
return $canhost;	return $canhost;
}	}

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

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

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

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

	my $cachetime = 606024;

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

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

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

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

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

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

my %homecache;	my %homecache;
Line 1540 sub get_domain_defaults {	Line 1930 sub get_domain_defaults {
$domdefaults{'auth_arg_def'} = $domconfig{'defaults'}{'auth_arg_def'};	$domdefaults{'auth_arg_def'} = $domconfig{'defaults'}{'auth_arg_def'};
$domdefaults{'timezone_def'} = $domconfig{'defaults'}{'timezone_def'};	$domdefaults{'timezone_def'} = $domconfig{'defaults'}{'timezone_def'};
$domdefaults{'datelocale_def'} = $domconfig{'defaults'}{'datelocale_def'};	$domdefaults{'datelocale_def'} = $domconfig{'defaults'}{'datelocale_def'};
	$domdefaults{'portal_def'} = $domconfig{'defaults'}{'portal_def'};
} else {	} else {
$domdefaults{'lang_def'} = &domain($domain,'lang_def');	$domdefaults{'lang_def'} = &domain($domain,'lang_def');
$domdefaults{'auth_def'} = &domain($domain,'auth_def');	$domdefaults{'auth_def'} = &domain($domain,'auth_def');
Line 1833 sub is_cached_new {	Line 2224 sub is_cached_new {
my ($name,$id,$debug) = @_;	my ($name,$id,$debug) = @_;
$id=&make_key($name,$id);	$id=&make_key($name,$id);
if (exists($remembered{$id})) {	if (exists($remembered{$id})) {
if ($debug) { &Apache::lonnet::logthis("Earyl return $id of $remembered{$id} "); }	if ($debug) { &Apache::lonnet::logthis("Early return $id of $remembered{$id} "); }
$accessed{$id}=[&gettimeofday()];	$accessed{$id}=[&gettimeofday()];
$hits++;	$hits++;
return ($remembered{$id},1);	return ($remembered{$id},1);
Line 1999 sub getversion {	Line 2390 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;
}	}

#	#
Line 2051 sub subscribe {	Line 2440 sub subscribe {
sub repcopy {	sub repcopy {
my $filename=shift;	my $filename=shift;
$filename=~s/\/+/\//g;	$filename=~s/\/+/\//g;
if ($filename=~m\|^/home/httpd/html/adm/\|) { return 'ok'; }	my $londocroot = $perlvar{'lonDocRoot'};
if ($filename=~m\|^/home/httpd/html/lonUsers/\|) { return 'ok'; }	if ($filename=~m{^\Q$londocroot/adm/\E}) { return 'ok'; }
if ($filename=~m\|^/home/httpd/html/userfiles/\| or	if ($filename=~m{^\Q$londocroot/lonUsers/\E}) { return 'ok'; }
$filename=~m -^/*(uploaded\|editupload)/-) {	if ($filename=~m{^\Q$londocroot/userfiles/\E} or
	$filename=~m{^/*(uploaded\|editupload)/}) {
return &repcopy_userfile($filename);	return &repcopy_userfile($filename);
}	}
$filename=~s/[\n\r]//g;	$filename=~s/[\n\r]//g;
Line 2081 sub repcopy {	Line 2471 sub repcopy {
unless ($home eq $perlvar{'lonHostID'}) {	unless ($home eq $perlvar{'lonHostID'}) {
my @parts=split(/\//,$filename);	my @parts=split(/\//,$filename);
my $path="/$parts[1]/$parts[2]/$parts[3]/$parts[4]";	my $path="/$parts[1]/$parts[2]/$parts[3]/$parts[4]";
if ($path ne "$perlvar{'lonDocRoot'}/res") {	if ($path ne "$londocroot/res") {
&logthis("Malconfiguration for replication: $filename");	&logthis("Malconfiguration for replication: $filename");
return 'bad_request';	return 'bad_request';
}	}
Line 2419 sub resizeImage {	Line 2809 sub resizeImage {
# $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	# $mimetype - reference to scalar to accommodate mime type determined
# from File::MMagic if $parser = parse.	# from File::MMagic.
#	#
# 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
Line 2559 sub finishuserfileupload {	Line 2949 sub finishuserfileupload {
return '/adm/notfound.html';	return '/adm/notfound.html';
}	}
if ($context eq 'overwrite') {	if ($context eq 'overwrite') {
my $source = $perlvar{'lonDaemons'}.'/tmp/overwrites/'.$docudom.'/'.$docuname.'/'.$fname;	my $source = LONCAPA::tempdir().'/overwrites/'.$docudom.'/'.$docuname.'/'.$fname;
my $target = $filepath.'/'.$file;	my $target = $filepath.'/'.$file;
if (-e $source) {	if (-e $source) {
my @info = stat($source);	my @info = stat($source);
Line 2588 sub finishuserfileupload {	Line 2978 sub finishuserfileupload {
}	}
}	}
}	}
	if (($context eq 'coursedoc') \|\| ($parser eq 'parse')) {
	if (ref($mimetype)) {
	if ($$mimetype eq '') {
	my $mm = new File::MMagic;
	my $type = $mm->checktype_filename($filepath.'/'.$file);
	$$mimetype = $type;
	}
	}
	}
if ($parser eq 'parse') {	if ($parser eq 'parse') {
my $mm = new File::MMagic;	if ((ref($mimetype)) && ($$mimetype eq 'text/html')) {
my $type = $mm->checktype_filename($filepath.'/'.$file);
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 2599 sub finishuserfileupload {	Line 2996 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 2872 sub flushcourselogs {	Line 3266 sub flushcourselogs {
my $result = &inc('nohist_accesscount',\%temphash,$dom,$name);	my $result = &inc('nohist_accesscount',\%temphash,$dom,$name);
if ($result eq 'ok') {	if ($result eq 'ok') {
delete $accesshash{$entry};	delete $accesshash{$entry};
} elsif ($result eq 'unknown_cmd') {
# Target server has old code running on it.
my %temphash=($entry => $value);
if (&put('nohist_resevaldata',\%temphash,$dom,$name) eq 'ok') {
delete $accesshash{$entry};
}
}	}
} else {	} else {
my ($dom,$name) = ($entry=~m{___($match_domain)/($match_name)/(.*)___(\w+)$});	my ($dom,$name) = ($entry=~m{___($match_domain)/($match_name)/(.*)___(\w+)$});
	if (($dom eq 'uploaded') \|\| ($dom eq 'adm')) { next; }
my %temphash=($entry => $accesshash{$entry});	my %temphash=($entry => $accesshash{$entry});
if (&put('nohist_resevaldata',\%temphash,$dom,$name) eq 'ok') {	if (&put('nohist_resevaldata',\%temphash,$dom,$name) eq 'ok') {
delete $accesshash{$entry};	delete $accesshash{$entry};
Line 2959 sub courseacclog {	Line 3348 sub courseacclog {
my $fnsymb=shift;	my $fnsymb=shift;
unless ($env{'request.course.id'}) { return ''; }	unless ($env{'request.course.id'}) { return ''; }
my $what=$fnsymb.':'.$env{'user.name'}.':'.$env{'user.domain'};	my $what=$fnsymb.':'.$env{'user.name'}.':'.$env{'user.domain'};
if ($fnsymb=~/(problem\|exam\|quiz\|assess\|survey\|form\|task\|page)$/) {	if ($fnsymb=~/$LONCAPA::assess_re/) {
$what.=':POST';	$what.=':POST';
# FIXME: Probably ought to escape things....	# FIXME: Probably ought to escape things....
foreach my $key (keys(%env)) {	foreach my $key (keys(%env)) {
Line 2991 sub countacc {	Line 3380 sub countacc {
my $url=&declutter(shift);	my $url=&declutter(shift);
return if (! defined($url) \|\| $url eq '');	return if (! defined($url) \|\| $url eq '');
unless ($env{'request.course.id'}) { return ''; }	unless ($env{'request.course.id'}) { return ''; }
	#
	# Mark that this url was used in this course
	#
$accesshash{$env{'request.course.id'}.'___'.$url.'___course'}=1;	$accesshash{$env{'request.course.id'}.'___'.$url.'___course'}=1;
	#
	# Increase the access count for this resource in this child process
	#
my $key=$$.$processmarker.'_'.$dumpcount.'___'.$url.'___count';	my $key=$$.$processmarker.'_'.$dumpcount.'___'.$url.'___count';
$accesshash{$key}++;	$accesshash{$key}++;
}	}
Line 3158 sub get_my_roles {	Line 3553 sub get_my_roles {
foreach my $entry (keys(%dumphash)) {	foreach my $entry (keys(%dumphash)) {
my ($role,$tend,$tstart);	my ($role,$tend,$tstart);
if ($context eq 'userroles') {	if ($context eq 'userroles') {
	next if ($entry =~ /^rolesdef/);
($role,$tend,$tstart)=split(/_/,$dumphash{$entry});	($role,$tend,$tstart)=split(/_/,$dumphash{$entry});
} else {	} else {
($tend,$tstart)=split(/\:/,$dumphash{$entry});	($tend,$tstart)=split(/\:/,$dumphash{$entry});
Line 3471 sub get_domain_roles {	Line 3867 sub get_domain_roles {

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

	{
	# Caches needed for speedup of navmaps
	# We don't want to cache this for very long at all (5 seconds at most)
	#
	# The user for whom we cache
	my $cachedkey='';
	# The cached times for this user
	my %cachedtimes=();
	# When this was last done
	my $cachedtime=();

	sub load_all_first_access {
	my ($uname,$udom)=@_;
	if (($cachedkey eq $uname.':'.$udom) &&
	(abs($cachedtime-time)<5)) {
	return;
	}
	$cachedtime=time;
	$cachedkey=$uname.':'.$udom;
	%cachedtimes=&dump('firstaccesstimes',$udom,$uname);
	}

sub get_first_access {	sub get_first_access {
my ($type,$argsymb)=@_;	my ($type,$argsymb)=@_;
my ($symb,$courseid,$udom,$uname)=&whichuser();	my ($symb,$courseid,$udom,$uname)=&whichuser();
Line 3483 sub get_first_access {	Line 3901 sub get_first_access {
} else {	} else {
$res=$symb;	$res=$symb;
}	}
my %times=&get('firstaccesstimes',["$courseid\0$res"],$udom,$uname);	&load_all_first_access($uname,$udom);
return $times{"$courseid\0$res"};	return $cachedtimes{"$courseid\0$res"};
}	}

sub set_first_access {	sub set_first_access {
Line 3498 sub set_first_access {	Line 3916 sub set_first_access {
} else {	} else {
$res=$symb;	$res=$symb;
}	}
	$cachedkey='';
my $firstaccess=&get_first_access($type,$symb);	my $firstaccess=&get_first_access($type,$symb);
if (!$firstaccess) {	if (!$firstaccess) {
return &put('firstaccesstimes',{"$courseid\0$res"=>time},$udom,$uname);	return &put('firstaccesstimes',{"$courseid\0$res"=>time},$udom,$uname);
}	}
return 'already_set';	return 'already_set';
}	}
	}
# --------------------------------------------- Set Expire Date for Spreadsheet	# --------------------------------------------- Set Expire Date for Spreadsheet

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

if(ref($hashref->{$key}) eq 'ARRAY') {	if(ref($hashref->{$key}) eq 'ARRAY') {
Line 3761 sub tmpreset {	Line 4180 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 3800 sub tmpstore {	Line 4219 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 3846 sub tmprestore {	Line 4265 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 3983 sub restore {	Line 4402 sub restore {
}	}

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

sub coursedescription {	sub coursedescription {
my ($courseid,$args)=@_;	my ($courseid,$args)=@_;
Line 4012 sub coursedescription {	Line 4433 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 4020 sub coursedescription {	Line 4442 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 4030 sub coursedescription {	Line 4456 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 4814 sub tmpget {	Line 5240 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 5212 sub is_advanced_user {	Line 5638 sub is_advanced_user {
my ($udom,$uname) = @_;	my ($udom,$uname) = @_;
if ($udom ne '' && $uname ne '') {	if ($udom ne '' && $uname ne '') {
if (($udom eq $env{'user.domain'}) && ($uname eq $env{'user.name'})) {	if (($udom eq $env{'user.domain'}) && ($uname eq $env{'user.name'})) {
return $env{'user.adv'};	if (wantarray) {
	return ($env{'user.adv'},$env{'user.author'});
	} else {
	return $env{'user.adv'};
	}
}	}
}	}
my %roleshash = &get_my_roles($uname,$udom,'userroles',undef,undef,undef,1);	my %roleshash = &get_my_roles($uname,$udom,'userroles',undef,undef,undef,1);
my %allroles;	my %allroles;
my $is_adv;	my ($is_adv,$is_author);
foreach my $role (keys(%roleshash)) {	foreach my $role (keys(%roleshash)) {
my ($trest,$tdomain,$trole,$sec) = split(/:/,$role);	my ($trest,$tdomain,$trole,$sec) = split(/:/,$role);
my $area = '/'.$tdomain.'/'.$trest;	my $area = '/'.$tdomain.'/'.$trest;
Line 5231 sub is_advanced_user {	Line 5661 sub is_advanced_user {
} elsif ($trole ne 'gr') {	} elsif ($trole ne 'gr') {
&standard_roleprivs(\%allroles,$trole,$tdomain,$spec,$trest,$area);	&standard_roleprivs(\%allroles,$trole,$tdomain,$spec,$trest,$area);
}	}
	if ($trole eq 'au') {
	$is_author = 1;
	}
}	}
}	}
foreach my $role (keys(%allroles)) {	foreach my $role (keys(%allroles)) {
Line 5245 sub is_advanced_user {	Line 5678 sub is_advanced_user {
}	}
}	}
}	}
	if (wantarray) {
	return ($is_adv,$is_author);
	}
return $is_adv;	return $is_adv;
}	}

Line 5515 sub allowed {	Line 5951 sub allowed {
}	}
}	}

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

# Course: uri itself is a course	# Course: uri itself is a course
my $courseuri=$uri;	my $courseuri=$uri;
$courseuri=~s/\_(\d)/\/$1/;	$courseuri=~s/\_(\d)/\/$1/;
Line 5785 sub allowed {	Line 6230 sub allowed {
}	}
return 'F';	return 'F';
}	}
	#
	# Removes the versino from a URI and
	# splits it in to its filename and path to the filename.
	# Seems like File::Basename could have done this more clearly.
	# Parameters:
	# $uri - input URI
	# Returns:
	# Two element list consisting of
	# $pathname - the URI up to and excluding the trailing /
	# $filename - The part of the URI following the last /
	# NOTE:
	# Another realization of this is simply:
	# use File::Basename;
	# ...
	# $uri = shift;
	# $filename = basename($uri);
	# $path = dirname($uri);
	# return ($filename, $path);
	#
	# The implementation below is probably faster however.
	#
sub split_uri_for_cond {	sub split_uri_for_cond {
my $uri=&deversion(&declutter(shift));	my $uri=&deversion(&declutter(shift));
my @uriparts=split(/\//,$uri);	my @uriparts=split(/\//,$uri);
Line 5981 sub fetch_enrollment_query {	Line 6446 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 6011 sub fetch_enrollment_query {	Line 6476 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 6681 sub assignrole {	Line 7146 sub assignrole {
return 'refused';	return 'refused';
}	}
}	}
	} elsif ($role eq 'au') {
	if ($url ne '/'.$udom.'/') {
	&logthis('Attempt by '.$env{'user.name'}.':'.$env{'user.domain'}.
	' to assign author role for '.$uname.':'.$udom.
	' in domain: '.$url.' refused (wrong domain).');
	return 'refused';
	}
}	}
$mrole=$role;	$mrole=$role;
}	}
Line 7082 sub modify_student_enrollment {	Line 7554 sub modify_student_enrollment {
$uid = $tmp{'id'} if (!defined($uid) \|\| $uid eq '');	$uid = $tmp{'id'} if (!defined($uid) \|\| $uid eq '');
}	}
my $fullname = &format_name($first,$middle,$last,$gene,'lastname');	my $fullname = &format_name($first,$middle,$last,$gene,'lastname');
	my $user = "$uname:$udom";
	my %old_entry = &Apache::lonnet::get('classlist',[$user],$cdom,$cnum);
my $reply=cput('classlist',	my $reply=cput('classlist',
{"$uname:$udom" =>	{$user =>
join(':',$end,$start,$uid,$usec,$fullname,$type,$locktype) },	join(':',$end,$start,$uid,$usec,$fullname,$type,$locktype) },
$cdom,$cnum);	$cdom,$cnum);
unless (($reply eq 'ok') \|\| ($reply eq 'delayed')) {	if (($reply eq 'ok') \|\| ($reply eq 'delayed')) {
	&devalidate_getsection_cache($udom,$uname,$cid);
	} else {
return 'error: '.$reply;	return 'error: '.$reply;
} else {
&devalidate_getsection_cache($udom,$uname,$cid);
}	}
# Add student role to user	# Add student role to user
my $uurl='/'.$cid;	my $uurl='/'.$cid;
Line 7097 sub modify_student_enrollment {	Line 7571 sub modify_student_enrollment {
if ($usec) {	if ($usec) {
$uurl.='/'.$usec;	$uurl.='/'.$usec;
}	}
return &assignrole($udom,$uname,$uurl,'st',$end,$start,undef,$selfenroll,$context);	my $result = &assignrole($udom,$uname,$uurl,'st',$end,$start,undef,
	$selfenroll,$context);
	if ($result ne 'ok') {
	if ($old_entry{$user} ne '') {
	$reply = &cput('classlist',\%old_entry,$cdom,$cnum);
	} else {
	$reply = &del('classlist',[$user],$cdom,$cnum);
	}
	}
	return $result;
}	}

sub format_name {	sub format_name {
Line 7448 sub save_selected_files {	Line 7931 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 7458 sub files_in_path {	Line 7941 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 7480 sub files_not_in_path {	Line 7963 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 7828 sub dirlist {	Line 8311 sub dirlist {

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

Line 7904 sub GetFileTimestamp {	Line 8393 sub GetFileTimestamp {
my ($studentDomain,$studentName,$filename,$getuserdir)=@_;	my ($studentDomain,$studentName,$filename,$getuserdir)=@_;
$studentDomain = &LONCAPA::clean_domain($studentDomain);	$studentDomain = &LONCAPA::clean_domain($studentDomain);
$studentName = &LONCAPA::clean_username($studentName);	$studentName = &LONCAPA::clean_username($studentName);
my ($fileStat) =	my ($fileref,$error) = &dirlist($filename,$studentDomain,$studentName,
&Apache::lonnet::dirlist($filename,$studentDomain,$studentName,	undef,$getuserdir);
undef,$getuserdir);	if (($error eq 'empty') \|\| ($error eq 'no_such_dir')) {
my @stats = split('&', $fileStat);	return -1;
if($stats[0] ne 'empty' && $stats[0] ne 'no_such_dir') {	}
	if (ref($fileref) eq 'ARRAY') {
	my @stats = split('&',$fileref->[0]);
# @stats contains first the filename, then the stat output	# @stats contains first the filename, then the stat output
return $stats[10]; # so this is 10 instead of 9.	return $stats[10]; # so this is 10 instead of 9.
} else {	} else {
Line 7940 sub stat_file {	Line 8431 sub stat_file {
if ($file =~ /^userfiles\//) {	if ($file =~ /^userfiles\//) {
$getpropath = 1;	$getpropath = 1;
}	}
my ($result) = &dirlist($file,$udom,$uname,$getpropath);	my ($listref,$error) = &dirlist($file,$udom,$uname,$getpropath);
my @stats = split('&', $result);	if (($error eq 'empty') \|\| ($error eq 'no_such_dir')) {
	return ();
if($stats[0] ne 'empty' && $stats[0] ne 'no_such_dir') {	} else {
shift(@stats); #filename is first	if (ref($listref) eq 'ARRAY') {
return @stats;	my @stats = split('&',$listref->[0]);
	shift(@stats); #filename is first
	return @stats;
	}
}	}
return ();	return ();
}	}
Line 8266 sub EXT {	Line 8760 sub EXT {
} elsif ($realm eq 'request') {	} elsif ($realm eq 'request') {
# ------------------------------------------------------------- request.browser	# ------------------------------------------------------------- request.browser
if ($space eq 'browser') {	if ($space eq 'browser') {
if ($qualifier eq 'textremote') {	return $env{'browser.'.$qualifier};
if (&Apache::lonlocal::mt('textual_remote_display') eq 'on') {
return 1;
} else {
return 0;
}
} else {
return $env{'browser.'.$qualifier};
}
# ------------------------------------------------------------ request.filename	# ------------------------------------------------------------ request.filename
} else {	} else {
return $env{'request.'.$spacequalifierrest};	return $env{'request.'.$spacequalifierrest};
Line 8558 sub metadata {	Line 9044 sub metadata {
($uri =~ m\|/$\|) \|\| ($uri =~ m\|/.meta$\|) \|\| ($uri =~ m{^/*uploaded/.+\.sequence$})) {	($uri =~ m\|/$\|) \|\| ($uri =~ m\|/.meta$\|) \|\| ($uri =~ m{^/*uploaded/.+\.sequence$})) {
return undef;	return undef;
}	}
if (($uri =~ /^~/ \|\| $uri =~ m{home/$match_username/public_html/})	if (($uri =~ /^priv/ \|\| $uri=~/home\/httpd\/html\/priv/)
&& &Apache::lonxml::get_state('target') =~ /^(\|meta)$/) {	&& &Apache::lonxml::get_state('target') =~ /^(\|meta)$/) {
return undef;	return undef;
}	}
Line 8595 sub metadata {	Line 9081 sub metadata {
my %metathesekeys=();	my %metathesekeys=();
unless ($filename=~/\.meta$/) { $filename.='.meta'; }	unless ($filename=~/\.meta$/) { $filename.='.meta'; }
my $metastring;	my $metastring;
if ($uri =~ /^~/ \|\| $uri =~ m{home/$match_username/public_html/}) {	if ($uri =~ /^priv/ \|\| $uri=~/home\/httpd\/html\/priv/) {
my $which = &hreflocation('','/'.($liburi \|\| $uri));	my $which = &hreflocation('','/'.($liburi \|\| $uri));
$metastring =	$metastring =
&Apache::lonnet::ssi_body($which,	&Apache::lonnet::ssi_body($which,
Line 8919 sub gettitle {	Line 9405 sub gettitle {
}	}
$title=~s/\&colon\;/\:/gs;	$title=~s/\&colon\;/\:/gs;
if ($title) {	if ($title) {
	# Remember both $symb and $title for dynamic metadata
	$accesshash{$symb.'___crstitle'}=$title;
	# Cache this title and then return it
return &do_cache_new('title',$key,$title,600);	return &do_cache_new('title',$key,$title,600);
}	}
$urlsymb=$url;	$urlsymb=$url;
Line 8951 sub get_slot {	Line 9440 sub get_slot {
}	}
return $slotinfo{$which};	return $slotinfo{$which};
}	}

	sub get_reservable_slots {
	my ($cnum,$cdom,$uname,$udom) = @_;
	my $now = time;
	my $reservable_info;
	my $key=join("\0",'reservableslots',$cdom,$cnum,$uname,$udom);
	if (exists($remembered{$key})) {
	$reservable_info = $remembered{$key};
	} else {
	my %resv;
	($resv{'now_order'},$resv{'now'},$resv{'future_order'},$resv{'future'}) =
	&Apache::loncommon::get_future_slots($cnum,$cdom,$now);
	$reservable_info = \%resv;
	$remembered{$key} = $reservable_info;
	}
	return $reservable_info;
	}

	sub get_course_slots {
	my ($cnum,$cdom) = @_;
	my $hashid=$cnum.':'.$cdom;
	my ($result,$cached) = &Apache::lonnet::is_cached_new('allslots',$hashid);
	if (defined($cached)) {
	if (ref($result) eq 'HASH') {
	return %{$result};
	}
	} else {
	my %slots=&Apache::lonnet::dump('slots',$cdom,$cnum);
	my ($tmp) = keys(%slots);
	if ($tmp !~ /^(con_lost\|error\|no_such_host)/i) {
	&Apache::lonnet::do_cache_new('allslots',$hashid,\%slots,600);
	return %slots;
	}
	}
	return;
	}

	sub devalidate_slots_cache {
	my ($cnum,$cdom)=@_;
	my $hashid=$cnum.':'.$cdom;
	&devalidate_cache_new('allslots',$hashid);
	}

# ------------------------------------------------- Update symbolic store links	# ------------------------------------------------- Update symbolic store links

sub symblist {	sub symblist {
Line 9292 sub getCODE {	Line 9824 sub getCODE {
}	}
return undef;	return undef;
}	}
	#
	# Determines the random seed for a specific context:
	#
	# parameters:
	# symb - in course context the symb for the seed.
	# course_id - The course id of the form domain_coursenum.
	# domain - Domain for the user.
	# course - Course for the user.
	# cenv - environment of the course.
	#
	# NOTE:
	# All parameters are picked out of the environment if missing
	# or not defined.
	# If a symb cannot be determined the current time is used instead.
	#
	# For a given well defined symb, courside, domain, username,
	# and course environment, the seed is reproducible.
	#
sub rndseed {	sub rndseed {
my ($symb,$courseid,$domain,$username)=@_;	my ($symb,$courseid,$domain,$username, $cenv)=@_;
my ($wsymb,$wcourseid,$wdomain,$wusername)=&whichuser();	my ($wsymb,$wcourseid,$wdomain,$wusername)=&whichuser();
if (!defined($symb)) {	if (!defined($symb)) {
unless ($symb=$wsymb) { return time; }	unless ($symb=$wsymb) { return time; }
}	}
if (!$courseid) { $courseid=$wcourseid; }	if (!defined $courseid) {
if (!$domain) { $domain=$wdomain; }	$courseid=$wcourseid;
if (!$username) { $username=$wusername }	}
my $which=&get_rand_alg();	if (!defined $domain) { $domain=$wdomain; }
	if (!defined $username) { $username=$wusername }

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

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

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

if ($file=~m:^/~:) { # is a contruction space reference	if ($file =~ m-^\Q$Apache::lonnet::perlvar{'lonTabDir'}\E/-) {
$location = $file;
$location =~ s:/~(.?)/(.):/home/$1/public_html/$2:;
} elsif ($file=~m{^/home/$match_username/public_html/}) {
# is a correct contruction space reference
$location = $file;
} elsif ($file =~ m-^\Q$Apache::lonnet::perlvar{'lonTabDir'}\E/-) {
$location = $file;	$location = $file;
} elsif ($file=~/^\/*(uploaded\|editupload)/) { # is an uploaded file	} elsif ($file=~/^\/*(uploaded\|editupload)/) { # is an uploaded file
my ($udom,$uname,$filename)=	my ($udom,$uname,$filename)=
Line 9774 sub filelocation {	Line 10326 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 9783 sub filelocation {	Line 10335 sub filelocation {
$location = $perlvar{'lonDocRoot'}.'/'.$file;	$location = $perlvar{'lonDocRoot'}.'/'.$file;
} else {	} else {
$file=~s/^\Q$perlvar{'lonDocRoot'}\E//;	$file=~s/^\Q$perlvar{'lonDocRoot'}\E//;
$file=~s:^/res/:/:;	$file=~s:^/(res\|priv)/:/:;
	my $space=$1;
if ( !( $file =~ m:^/:) ) {	if ( !( $file =~ m:^/:) ) {
$location = $dir. '/'.$file;	$location = $dir. '/'.$file;
} else {	} else {
$location = '/home/httpd/html/res'.$file;	$location = $perlvar{'lonDocRoot'}.'/'.$space.$file;
}	}
}	}
$location=~s://+:/:g; # remove duplicate /	$location=~s://+:/:g; # remove duplicate /
Line 9812 sub hreflocation {	Line 10365 sub hreflocation {
}	}
if ($file=~m-^\Q$perlvar{'lonDocRoot'}\E-) {	if ($file=~m-^\Q$perlvar{'lonDocRoot'}\E-) {
$file=~s-^\Q$perlvar{'lonDocRoot'}\E--;	$file=~s-^\Q$perlvar{'lonDocRoot'}\E--;
} elsif ($file=~m-/home/($match_username)/public_html/-) {
$file=~s-^/home/($match_username)/public_html/-/~$1/-;
} elsif ($file=~m-^\Q$perlvar{'lonUsersDir'}\E-) {	} elsif ($file=~m-^\Q$perlvar{'lonUsersDir'}\E-) {
$file=~s-^/home/httpd/lonUsers/($match_domain)/./././($match_name)/userfiles/	$file=~s{^/home/httpd/lonUsers/($match_domain)/./././($match_name)/userfiles/}
-/uploaded/$1/$2/-x;	{/uploaded/$1/$2/}x;
}	}
if ($file=~ m{^/userfiles/}) {	if ($file=~ m{^/userfiles/}) {
$file =~ s{^/userfiles/}{/uploaded/};	$file =~ s{^/userfiles/}{/uploaded/};
Line 9824 sub hreflocation {	Line 10375 sub hreflocation {
return $file;	return $file;
}	}





sub current_machine_domains {	sub current_machine_domains {
return &machine_domains(&hostname($perlvar{'lonHostID'}));	return &machine_domains(&hostname($perlvar{'lonHostID'}));
}	}
Line 10012 sub get_dns {	Line 10567 sub get_dns {
while (%alldns) {	while (%alldns) {
my ($dns) = keys(%alldns);	my ($dns) = keys(%alldns);
my $ua=new LWP::UserAgent;	my $ua=new LWP::UserAgent;
	$ua->timeout(30);
my $request=new HTTP::Request('GET',"$alldns{$dns}://$dns$url");	my $request=new HTTP::Request('GET',"$alldns{$dns}://$dns$url");
my $response=$ua->request($request);	my $response=$ua->request($request);
delete($alldns{$dns});	delete($alldns{$dns});
Line 10527 BEGIN {	Line 11083 BEGIN {
}	}
}	}

	# ---------------------------------------------------------- Read managers table
	{
	if (-e "$perlvar{'lonTabDir'}/managers.tab") {
	if (open(my $config,"<$perlvar{'lonTabDir'}/managers.tab")) {
	while (my $configline=<$config>) {
	chomp($configline);
	next if ($configline =~ /^\#/);
	if (($configline =~ /^[\w\-]+$/) \|\| ($configline =~ /^[\w\-]+\:[\w\-]+$/)) {
	$managerstab{$configline} = 1;
	}
	}
	close($config);
	}
	}
	}

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

}	}

Line 11023 revokecustomrole($udom,$uname,$url,$role	Line 11595 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 11358 or lonTabs/domain.tab.	Line 11951 or lonTabs/domain.tab.

=item *	=item *

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

	Inputs: 1 required, 5 optional.

	=over

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

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

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

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

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

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

	=back

	Returns: Array of up to two items.

	=over

	a reference to an array of files/subdirectories

	=over

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

	=back

	a scalar containing error condition (if encountered).

	=over

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

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

	=item
	con_lost (connection to remote server failed).

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

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

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

	=over

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

	=back

	=back

	=back

=item *	=item *

Line 11420 splitting on '&', supports elements that	Line 12088 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 11440 logperm() : append a permanent message t	Line 12109 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

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

Removed from v.1.1111
changed lines
	Added in v.1.1159