|
version 1.999, 2009/05/08 14:33:16
|
version 1.1141, 2011/10/31 13:44:37
|
|
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 |
| |
%managerstab); |
| |
|
| my (%badServerCache, $memcache, %courselogs, %accesshash, %domainrolehash, |
my (%badServerCache, $memcache, %courselogs, %accesshash, %domainrolehash, |
| %userrolehash, $processmarker, $dumpcount, %coursedombuf, |
%userrolehash, $processmarker, $dumpcount, %coursedombuf, |
|
Line 92 use Time::HiRes qw( gettimeofday tv_inte
|
Line 93 use Time::HiRes qw( gettimeofday tv_inte
|
| use Cache::Memcached; |
use Cache::Memcached; |
| use Digest::MD5; |
use Digest::MD5; |
| use Math::Random; |
use Math::Random; |
| |
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. |
| |
|
| my $upload_photo_form = 0; #Variable to check when user upload a photo 0=not 1=true |
|
| |
|
| require Exporter; |
require Exporter; |
| |
|
| our @ISA = qw (Exporter); |
our @ISA = qw (Exporter); |
|
Line 196 sub get_server_timezone {
|
Line 198 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 212 sub get_server_loncaparev {
|
Line 237 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=¤t_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; |
| |
} |
| |
} |
| |
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 ($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 { |
} else { |
| my $loncaparev = &reply('serverloncaparev',$lonhost); |
my $requested = &freeze_escape(\%whatneeded); |
| return &do_cache_new('serverloncaparev',$lonhost,$loncaparev,$cachetime); |
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 |
|
Line 553 sub appenv {
|
Line 683 sub appenv {
|
| # ----------------------------------------------------- Delete from Environment |
# ----------------------------------------------------- Delete from Environment |
| |
|
| sub delenv { |
sub delenv { |
| my ($delthis,$regexp) = @_; |
my ($delthis,$regexp,$roles) = @_; |
| if (($delthis=~/user\.role/) || ($delthis=~/user\.priv/)) { |
if (($delthis=~/^user\.role/) || ($delthis=~/^user\.priv/)) { |
| &logthis("<font color=\"blue\">WARNING: ". |
my $refused = 1; |
| "Attempt to delete from environment ".$delthis); |
if (ref($roles) eq 'ARRAY') { |
| return 'error'; |
my ($type,$role) = ($delthis =~ /^user\.(role|priv)\.([^.]+)\./); |
| |
if (grep(/^\Q$role\E$/,@{$roles})) { |
| |
$refused = 0; |
| |
} |
| |
} |
| |
if ($refused) { |
| |
&logthis("<font color=\"blue\">WARNING: ". |
| |
"Attempt to delete from environment ".$delthis); |
| |
return 'error'; |
| |
} |
| } |
} |
| my $opened = open(my $env_file,'+<',$env{'user.environment'}); |
my $opened = open(my $env_file,'+<',$env{'user.environment'}); |
| if ($opened |
if ($opened |
|
Line 666 sub userload {
|
Line 805 sub userload {
|
| return $userloadpercent; |
return $userloadpercent; |
| } |
} |
| |
|
| # ------------------------------------------ Fight off request when overloaded |
|
| |
|
| sub overloaderror { |
|
| my ($r,$checkserver)=@_; |
|
| unless ($checkserver) { $checkserver=$perlvar{'lonHostID'}; } |
|
| my $loadavg; |
|
| if ($checkserver eq $perlvar{'lonHostID'}) { |
|
| open(my $loadfile,'/proc/loadavg'); |
|
| $loadavg=<$loadfile>; |
|
| $loadavg =~ s/\s.*//g; |
|
| $loadavg = 100*$loadavg/$perlvar{'lonLoadLim'}; |
|
| close($loadfile); |
|
| } else { |
|
| $loadavg=&reply('load',$checkserver); |
|
| } |
|
| my $overload=$loadavg-100; |
|
| if ($overload>0) { |
|
| $r->err_headers_out->{'Retry-After'}=$overload; |
|
| $r->log_error('Overload of '.$overload.' on '.$checkserver); |
|
| return 413; |
|
| } |
|
| return ''; |
|
| } |
|
| |
|
| # ------------------------------ Find server with least workload from spare.tab |
# ------------------------------ Find server with least workload from spare.tab |
| |
|
| sub spareserver { |
sub spareserver { |
| 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 718 sub spareserver {
|
Line 854 sub spareserver {
|
| if ($protocol{$spare_server} eq 'https') { |
if ($protocol{$spare_server} eq 'https') { |
| $protocol = $protocol{$spare_server}; |
$protocol = $protocol{$spare_server}; |
| } |
} |
| $spare_server = $protocol.'://'.&hostname($spare_server); |
if (defined($spare_server)) { |
| |
my $hostname = &hostname($spare_server); |
| |
if (defined($hostname)) { |
| |
$spare_server = $protocol.'://'.$hostname; |
| |
} |
| |
} |
| } |
} |
| return $spare_server; |
return $spare_server; |
| } |
} |
|
Line 730 sub compare_server_load {
|
Line 871 sub compare_server_load {
|
| my $userloadans = &reply('userload',$try_server); |
my $userloadans = &reply('userload',$try_server); |
| |
|
| if ($loadans !~ /\d/ && $userloadans !~ /\d/) { |
if ($loadans !~ /\d/ && $userloadans !~ /\d/) { |
| 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 756 sub compare_server_load {
|
Line 897 sub compare_server_load {
|
| # --------------------------- ask offload servers if user already has a session |
# --------------------------- ask offload servers if user already has a session |
| sub find_existing_session { |
sub find_existing_session { |
| my ($udom,$uname) = @_; |
my ($udom,$uname) = @_; |
| foreach my $try_server (@{ $spareid{'primary'} }, |
my $spareshash = &this_host_spares($udom); |
| @{ $spareid{'default'} }) { |
if (ref($spareshash) eq 'HASH') { |
| return $try_server if (&has_user_session($try_server, $udom, $uname)); |
if (ref($spareshash->{'primary'}) eq 'ARRAY') { |
| |
foreach my $try_server (@{ $spareshash->{'primary'} }) { |
| |
return $try_server if (&has_user_session($try_server, $udom, $uname)); |
| |
} |
| |
} |
| |
if (ref($spareshash->{'default'}) eq 'ARRAY') { |
| |
foreach my $try_server (@{ $spareshash->{'default'} }) { |
| |
return $try_server if (&has_user_session($try_server, $udom, $uname)); |
| |
} |
| |
} |
| } |
} |
| return; |
return; |
| } |
} |
|
Line 773 sub has_user_session {
|
Line 923 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 { |
| my ($uname,$udom,$currentpass,$newpass,$server,$context)=@_; |
my ($uname,$udom,$currentpass,$newpass,$server,$context)=@_; |
| $currentpass = &escape($currentpass); |
$currentpass = &escape($currentpass); |
| $newpass = &escape($newpass); |
$newpass = &escape($newpass); |
| my $answer = reply("encrypt:passwd:$udom:$uname:$currentpass:$newpass:$context", |
my $lonhost = $perlvar{'lonHostID'}; |
| |
my $answer = reply("encrypt:passwd:$udom:$uname:$currentpass:$newpass:$context:$lonhost", |
| $server); |
$server); |
| if (! $answer) { |
if (! $answer) { |
| &logthis("No reply on password change request to $server ". |
&logthis("No reply on password change request to $server ". |
|
Line 804 sub changepass {
|
Line 992 sub changepass {
|
| } elsif ($answer =~ "^refused") { |
} elsif ($answer =~ "^refused") { |
| &logthis("$server refused to change $uname in $udom password because ". |
&logthis("$server refused to change $uname in $udom password because ". |
| "it was sent an unencrypted request to change the password."); |
"it was sent an unencrypted request to change the password."); |
| |
} elsif ($answer =~ "invalid_client") { |
| |
&logthis("$server refused to change $uname in $udom password because ". |
| |
"it was a reset by e-mail originating from an invalid server."); |
| } |
} |
| return $answer; |
return $answer; |
| } |
} |
|
Line 827 sub queryauthenticate {
|
Line 1018 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 850 sub authenticate {
|
Line 1041 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 868 sub authenticate {
|
Line 1059 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 ($dom_in_use,$lonhost_in_use,$result); |
| |
my @hosts = ¤t_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 = 60*60*24; |
| |
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 = 60*60*24; |
| |
|
| |
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 = ¤t_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 953 sub idput {
|
Line 1522 sub idput {
|
| } |
} |
| } |
} |
| |
|
| # ------------------------------------------- get items from domain db files |
# ------------------------------dump from db file owned by domainconfig user |
| |
sub dump_dom { |
| |
my ($namespace,$udom,$regexp,$range)=@_; |
| |
if (!$udom) { |
| |
$udom=$env{'user.domain'}; |
| |
} |
| |
my %returnhash; |
| |
if ($udom) { |
| |
my $uname = &get_domainconfiguser($udom); |
| |
%returnhash = &dump($namespace,$udom,$uname,$regexp,$range); |
| |
} |
| |
return %returnhash; |
| |
} |
| |
|
| |
# ------------------------------------------ get items from domain db files |
| |
|
| sub get_dom { |
sub get_dom { |
| my ($namespace,$storearr,$udom,$uhome)=@_; |
my ($namespace,$storearr,$udom,$uhome)=@_; |
|
Line 1027 sub put_dom {
|
Line 1610 sub put_dom {
|
| } |
} |
| } |
} |
| |
|
| |
# --------------------- newput for items in db file owned by domainconfig user |
| |
sub newput_dom { |
| |
my ($namespace,$storehash,$udom) = @_; |
| |
my $result; |
| |
if (!$udom) { |
| |
$udom=$env{'user.domain'}; |
| |
} |
| |
if ($udom) { |
| |
my $uname = &get_domainconfiguser($udom); |
| |
$result = &newput($namespace,$storehash,$udom,$uname); |
| |
} |
| |
return $result; |
| |
} |
| |
|
| |
# --------------------- delete for items in db file owned by domainconfig user |
| |
sub del_dom { |
| |
my ($namespace,$storearr,$udom)=@_; |
| |
if (ref($storearr) eq 'ARRAY') { |
| |
if (!$udom) { |
| |
$udom=$env{'user.domain'}; |
| |
} |
| |
if ($udom) { |
| |
my $uname = &get_domainconfiguser($udom); |
| |
return &del($namespace,$storearr,$udom,$uname); |
| |
} |
| |
} |
| |
} |
| |
|
| |
# ----------------------------------construct domainconfig user for a domain |
| |
sub get_domainconfiguser { |
| |
my ($udom) = @_; |
| |
return $udom.'-domainconfig'; |
| |
} |
| |
|
| sub retrieve_inst_usertypes { |
sub retrieve_inst_usertypes { |
| my ($udom) = @_; |
my ($udom) = @_; |
| my (%returnhash,@order); |
my (%returnhash,@order); |
|
Line 1295 sub get_domain_defaults {
|
Line 1912 sub get_domain_defaults {
|
| my %domdefaults; |
my %domdefaults; |
| my %domconfig = |
my %domconfig = |
| &Apache::lonnet::get_dom('configuration',['defaults','quotas', |
&Apache::lonnet::get_dom('configuration',['defaults','quotas', |
| 'requestcourses','inststatus'],$domain); |
'requestcourses','inststatus', |
| |
'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 1321 sub get_domain_defaults {
|
Line 1939 sub get_domain_defaults {
|
| } |
} |
| } |
} |
| if (ref($domconfig{'requestcourses'}) eq 'HASH') { |
if (ref($domconfig{'requestcourses'}) eq 'HASH') { |
| foreach my $item ('official','unofficial') { |
foreach my $item ('official','unofficial','community') { |
| $domdefaults{$item} = $domconfig{'requestcourses'}{$item}; |
$domdefaults{$item} = $domconfig{'requestcourses'}{$item}; |
| } |
} |
| } |
} |
|
Line 1330 sub get_domain_defaults {
|
Line 1948 sub get_domain_defaults {
|
| $domdefaults{$item} = $domconfig{'inststatus'}{$item}; |
$domdefaults{$item} = $domconfig{'inststatus'}{$item}; |
| } |
} |
| } |
} |
| |
if (ref($domconfig{'coursedefaults'}) eq 'HASH') { |
| |
foreach my $item ('canuse_pdfforms') { |
| |
$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 1515 sub getsection {
|
Line 2146 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 1581 sub is_cached_new {
|
Line 2213 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 1660 sub userenvironment {
|
Line 2292 sub userenvironment {
|
| } |
} |
| $items=~s/\&$//; |
$items=~s/\&$//; |
| my %returnhash=(); |
my %returnhash=(); |
| my @answer=split(/\&/, |
my $uhome = &homeserver($unam,$udom); |
| &reply('get:'.$udom.':'.$unam.':environment:'.$items, |
unless ($uhome eq 'no_host') { |
| &homeserver($unam,$udom))); |
my @answer=split(/\&/, |
| my $i; |
&reply('get:'.$udom.':'.$unam.':environment:'.$items,$uhome)); |
| for ($i=0;$i<=$#what;$i++) { |
if ($#answer==0 && $answer[0] =~ /^(con_lost|error:|no_such_host)/i) { |
| $returnhash{$what[$i]}=&unescape($answer[$i]); |
return %returnhash; |
| |
} |
| |
my $i; |
| |
for ($i=0;$i<=$#what;$i++) { |
| |
$returnhash{$what[$i]}=&unescape($answer[$i]); |
| |
} |
| } |
} |
| return %returnhash; |
return %returnhash; |
| } |
} |
|
Line 1742 sub getversion {
|
Line 2379 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 1861 sub ssi_body {
|
Line 2507 sub ssi_body {
|
| if ($filelink=~/^https?\:/) { |
if ($filelink=~/^https?\:/) { |
| ($output,$response)=&externalssi($filelink); |
($output,$response)=&externalssi($filelink); |
| } else { |
} else { |
| |
$filelink .= $filelink=~/\?/ ? '&' : '?'; |
| |
$filelink .= 'inhibitmenu=yes'; |
| ($output,$response)=&ssi($filelink,%form); |
($output,$response)=&ssi($filelink,%form); |
| } |
} |
| $output=~s|//(\s*<!--)? BEGIN LON-CAPA Internal.+?// END LON-CAPA Internal\s*(-->)?\s||gs; |
$output=~s|//(\s*<!--)? BEGIN LON-CAPA Internal.+?// END LON-CAPA Internal\s*(-->)?\s||gs; |
|
Line 1904 sub ssi {
|
Line 2552 sub ssi {
|
| &Apache::lonenc::check_encrypt(\$fn); |
&Apache::lonenc::check_encrypt(\$fn); |
| if (%form) { |
if (%form) { |
| $request=new HTTP::Request('POST',&absolute_url().$fn); |
$request=new HTTP::Request('POST',&absolute_url().$fn); |
| $request->content(join('&',map { &escape($_).'='.&escape($form{$_}) } keys %form)); |
$request->content(join('&',map { &escape($_).'='.&escape($form{$_}) } keys(%form))); |
| } else { |
} else { |
| $request=new HTTP::Request('GET',&absolute_url().$fn); |
$request=new HTTP::Request('GET',&absolute_url().$fn); |
| } |
} |
|
Line 1949 sub allowuploaded {
|
Line 2597 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 1975 sub allowuploaded {
|
Line 2625 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 2002 sub process_coursefile {
|
Line 2653 sub process_coursefile {
|
| print $fh $env{'form.'.$source}; |
print $fh $env{'form.'.$source}; |
| close($fh); |
close($fh); |
| if ($parser eq 'parse') { |
if ($parser eq 'parse') { |
| my $parse_result = &extract_embedded_items($filepath.'/'.$fname,$allfiles,$codebase); |
my $mm = new File::MMagic; |
| unless ($parse_result eq 'ok') { |
my $type = $mm->checktype_filename($filepath.'/'.$fname); |
| &logthis('Failed to parse '.$filepath.'/'.$fname.' for embedded media: '.$parse_result); |
if ($type eq 'text/html') { |
| |
my $parse_result = &extract_embedded_items($filepath.'/'.$fname,$allfiles,$codebase); |
| |
unless ($parse_result eq 'ok') { |
| |
&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 2081 sub clean_filename {
|
Line 2739 sub clean_filename {
|
| $fname=~s/\.(\d+)(?=\.)/_$1/g; |
$fname=~s/\.(\d+)(?=\.)/_$1/g; |
| return $fname; |
return $fname; |
| } |
} |
| #This Function check if a Image max 400px width and height 500px. If not then scale the image down |
# This Function checks if an Image's dimensions exceed either $resizewidth (width) |
| |
# or $resizeheight (height) - both pixels. If so, the image is scaled to produce an |
| |
# image with the same aspect ratio as the original, but with dimensions which do |
| |
# not exceed $resizewidth and $resizeheight. |
| |
|
| sub resizeImage { |
sub resizeImage { |
| my($img_url) = @_; |
my ($img_path,$resizewidth,$resizeheight) = @_; |
| my $ima = Image::Magick->new; |
my $ima = Image::Magick->new; |
| $ima->Read($img_url); |
my $resized; |
| if($ima->Get('width') > 400) |
if (-e $img_path) { |
| { |
$ima->Read($img_path); |
| my $factor = $ima->Get('width')/400; |
if (($resizewidth =~ /^\d+$/) && ($resizeheight > 0)) { |
| $ima->Scale( width=>400, height=>$ima->Get('height')/$factor ); |
my $width = $ima->Get('width'); |
| } |
my $height = $ima->Get('height'); |
| if($ima->Get('height') > 500) |
if ($width > $resizewidth) { |
| { |
my $factor = $width/$resizewidth; |
| my $factor = $ima->Get('height')/500; |
my $newheight = $height/$factor; |
| $ima->Scale( width=>$ima->Get('width')/$factor, height=>500); |
$ima->Scale(width=>$resizewidth,height=>$newheight); |
| } |
$resized = 1; |
| |
} |
| $ima->Write($img_url); |
} |
| } |
if (($resizeheight =~ /^\d+$/) && ($resizeheight > 0)) { |
| |
my $width = $ima->Get('width'); |
| #Wrapper function for userphotoupload |
my $height = $ima->Get('height'); |
| sub userphotoupload |
if ($height > $resizeheight) { |
| { |
my $factor = $height/$resizeheight; |
| my($formname,$subdir) = @_; |
my $newwidth = $width/$factor; |
| $upload_photo_form = 1; |
$ima->Scale(width=>$newwidth,height=>$resizeheight); |
| return &userfileupload($formname,undef,$subdir); |
$resized = 1; |
| |
} |
| |
} |
| |
if ($resized) { |
| |
$ima->Write($img_path); |
| |
} |
| |
} |
| |
return; |
| } |
} |
| |
|
| # --------------- 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 2121 sub userphotoupload
|
Line 2794 sub userphotoupload
|
| # $dsetudom - domain for permanaent storage of uploaded file |
# $dsetudom - domain for permanaent storage of uploaded file |
| # $thumbwidth - width (pixels) of thumbnail to make for uploaded image |
# $thumbwidth - width (pixels) of thumbnail to make for uploaded image |
| # $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 |
| |
# $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)=@_; |
$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 2164 sub userfileupload {
|
Line 2861 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,$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; |
| my $docudom=$destudom; |
my $docudom=$destudom; |
| return &finishuserfileupload($docuname,$docudom,$formname,$fname, |
return &finishuserfileupload($docuname,$docudom,$formname,$fname, |
| $parser,$allfiles,$codebase, |
$parser,$allfiles,$codebase, |
| $thumbwidth,$thumbheight); |
$thumbwidth,$thumbheight, |
| |
$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 2201 sub userfileupload {
|
Line 2903 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,$context,$mimetype); |
| } |
} |
| } |
} |
| |
|
| sub finishuserfileupload { |
sub finishuserfileupload { |
| my ($docuname,$docudom,$formname,$fname,$parser,$allfiles,$codebase, |
my ($docuname,$docudom,$formname,$fname,$parser,$allfiles,$codebase, |
| $thumbwidth,$thumbheight) = @_; |
$thumbwidth,$thumbheight,$resizewidth,$resizeheight,$context,$mimetype) = @_; |
| my $path=$docudom.'/'.$docuname.'/'; |
my $path=$docudom.'/'.$docuname.'/'; |
| my $filepath=$perlvar{'lonDocRoot'}; |
my $filepath=$perlvar{'lonDocRoot'}; |
| |
|
|
Line 2233 sub finishuserfileupload {
|
Line 2936 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'; |
| } |
} |
| close(FH); |
close(FH); |
| if($upload_photo_form==1) |
if ($resizewidth && $resizeheight) { |
| { |
my $mm = new File::MMagic; |
| resizeImage($filepath.'/'.$file); |
my $mime_type = $mm->checktype_filename($filepath.'/'.$file); |
| $upload_photo_form = 0; |
if ($mime_type =~ m{^image/}) { |
| |
&resizeImage($filepath.'/'.$file,$resizewidth,$resizeheight); |
| |
} |
| } |
} |
| } |
} |
| if ($parser eq 'parse') { |
if ($parser eq 'parse') { |
| my $parse_result = &extract_embedded_items($filepath.'/'.$file,$allfiles, |
my $mm = new File::MMagic; |
| $codebase); |
my $type = $mm->checktype_filename($filepath.'/'.$file); |
| unless ($parse_result eq 'ok') { |
if ($type eq 'text/html') { |
| &logthis('Failed to parse '.$filepath.$file. |
my $parse_result = &extract_embedded_items($filepath.'/'.$file, |
| ' for embedded media: '.$parse_result); |
$allfiles,$codebase); |
| |
unless ($parse_result eq 'ok') { |
| |
&logthis('Failed to parse '.$filepath.$file. |
| |
' for embedded media: '.$parse_result); |
| |
} |
| |
} |
| |
if (ref($mimetype)) { |
| |
$$mimetype = $type; |
| } |
} |
| } |
} |
| if (($thumbwidth =~ /^\d+$/) && ($thumbheight =~ /^\d+$/)) { |
if (($thumbwidth =~ /^\d+$/) && ($thumbheight =~ /^\d+$/)) { |
|
Line 2554 sub flushcourselogs {
|
Line 3282 sub flushcourselogs {
|
| # Reverse lookup of domain roles (dc, ad, li, sc, au) |
# Reverse lookup of domain roles (dc, ad, li, sc, au) |
| # |
# |
| my %domrolebuffer = (); |
my %domrolebuffer = (); |
| foreach my $entry (keys %domainrolehash) { |
foreach my $entry (keys(%domainrolehash)) { |
| my ($role,$uname,$udom,$runame,$rudom,$rsec)=split(/:/,$entry); |
my ($role,$uname,$udom,$runame,$rudom,$rsec)=split(/:/,$entry); |
| if ($domrolebuffer{$rudom}) { |
if ($domrolebuffer{$rudom}) { |
| $domrolebuffer{$rudom}.='&'.&escape($entry). |
$domrolebuffer{$rudom}.='&'.&escape($entry). |
|
Line 2659 sub userrolelog {
|
Line 3387 sub userrolelog {
|
| if (($trole=~/^ca/) || ($trole=~/^aa/) || |
if (($trole=~/^ca/) || ($trole=~/^aa/) || |
| ($trole=~/^in/) || ($trole=~/^cc/) || |
($trole=~/^in/) || ($trole=~/^cc/) || |
| ($trole=~/^ep/) || ($trole=~/^cr/) || |
($trole=~/^ep/) || ($trole=~/^cr/) || |
| ($trole=~/^ta/)) { |
($trole=~/^ta/) || ($trole=~/^co/)) { |
| my (undef,$rudom,$runame,$rsec)=split(/\//,$area); |
my (undef,$rudom,$runame,$rsec)=split(/\//,$area); |
| $userrolehash |
$userrolehash |
| {$trole.':'.$username.':'.$domain.':'.$runame.':'.$rudom.':'.$rsec} |
{$trole.':'.$username.':'.$domain.':'.$runame.':'.$rudom.':'.$rsec} |
|
Line 2668 sub userrolelog {
|
Line 3396 sub userrolelog {
|
| if (($env{'request.role'} =~ /dc\./) && |
if (($env{'request.role'} =~ /dc\./) && |
| (($trole=~/^au/) || ($trole=~/^in/) || |
(($trole=~/^au/) || ($trole=~/^in/) || |
| ($trole=~/^cc/) || ($trole=~/^ep/) || |
($trole=~/^cc/) || ($trole=~/^ep/) || |
| ($trole=~/^cr/) || ($trole=~/^ta/))) { |
($trole=~/^cr/) || ($trole=~/^ta/) || |
| |
($trole=~/^co/))) { |
| $userrolehash |
$userrolehash |
| {$trole.':'.$username.':'.$domain.':'.$env{'user.name'}.':'.$env{'user.domain'}.':'} |
{$trole.':'.$username.':'.$domain.':'.$env{'user.name'}.':'.$env{'user.domain'}.':'} |
| =$tend.':'.$tstart; |
=$tend.':'.$tstart; |
|
Line 2689 sub courserolelog {
|
Line 3418 sub courserolelog {
|
| if (($trole eq 'cc') || ($trole eq 'in') || |
if (($trole eq 'cc') || ($trole eq 'in') || |
| ($trole eq 'ep') || ($trole eq 'ad') || |
($trole eq 'ep') || ($trole eq 'ad') || |
| ($trole eq 'ta') || ($trole eq 'st') || |
($trole eq 'ta') || ($trole eq 'st') || |
| ($trole=~/^cr/) || ($trole eq 'gr')) { |
($trole=~/^cr/) || ($trole eq 'gr') || |
| |
($trole eq 'co')) { |
| if ($area =~ m-^/($match_domain)/($match_courseid)/?([^/]*)-) { |
if ($area =~ m-^/($match_domain)/($match_courseid)/?([^/]*)-) { |
| my $cdom = $1; |
my $cdom = $1; |
| my $cnum = $2; |
my $cnum = $2; |
|
Line 2735 sub get_course_adv_roles {
|
Line 3465 sub get_course_adv_roles {
|
| &dump('nohist_userroles',$coursehash{'domain'},$coursehash{'num'}); |
&dump('nohist_userroles',$coursehash{'domain'},$coursehash{'num'}); |
| my $now=time; |
my $now=time; |
| my %privileged; |
my %privileged; |
| foreach my $entry (keys %dumphash) { |
foreach my $entry (keys(%dumphash)) { |
| my ($tend,$tstart)=split(/\:/,$dumphash{$entry}); |
my ($tend,$tstart)=split(/\:/,$dumphash{$entry}); |
| if (($tstart) && ($tstart<0)) { next; } |
if (($tstart) && ($tstart<0)) { next; } |
| if (($tend) && ($tend<$now)) { next; } |
if (($tend) && ($tend<$now)) { next; } |
|
Line 2783 sub get_my_roles {
|
Line 3513 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 2844 sub get_my_roles {
|
Line 3575 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 2923 sub getannounce {
|
Line 3658 sub getannounce {
|
| |
|
| sub courseidput { |
sub courseidput { |
| my ($domain,$storehash,$coursehome,$caller) = @_; |
my ($domain,$storehash,$coursehome,$caller) = @_; |
| |
return unless (ref($storehash) eq 'HASH'); |
| my $outcome; |
my $outcome; |
| if ($caller eq 'timeonly') { |
if ($caller eq 'timeonly') { |
| my $cids = ''; |
my $cids = ''; |
|
Line 2961 sub courseidput {
|
Line 3697 sub courseidput {
|
| sub courseiddump { |
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)=@_; |
$selfenrollonly,$catfilter,$showhidden,$caller,$cloner,$cc_clone, |
| |
$cloneonly,$createdbefore,$createdafter,$creationcontext,$domcloner)=@_; |
| my $as_hash = 1; |
my $as_hash = 1; |
| my %returnhash; |
my %returnhash; |
| if (!$domfilter) { $domfilter=''; } |
if (!$domfilter) { $domfilter=''; } |
|
Line 2980 sub courseiddump {
|
Line 3717 sub courseiddump {
|
| ':'.&escape($coursefilter).':'.&escape($typefilter). |
':'.&escape($coursefilter).':'.&escape($typefilter). |
| ':'.&escape($regexp_ok).':'.$as_hash.':'. |
':'.&escape($regexp_ok).':'.$as_hash.':'. |
| &escape($selfenrollonly).':'.&escape($catfilter).':'. |
&escape($selfenrollonly).':'.&escape($catfilter).':'. |
| $showhidden.':'.$caller,$tryserver); |
$showhidden.':'.$caller.':'.&escape($cloner).':'. |
| |
&escape($cc_clone).':'.$cloneonly.':'. |
| |
&escape($createdbefore).':'.&escape($createdafter).':'. |
| |
&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 2995 sub courseiddump {
|
Line 3736 sub courseiddump {
|
| for (my $i=0; $i<@responses; $i++) { |
for (my $i=0; $i<@responses; $i++) { |
| $returnhash{$key}{$items[$i]} = &unescape($responses[$i]); |
$returnhash{$key}{$items[$i]} = &unescape($responses[$i]); |
| } |
} |
| } |
} |
| } |
} |
| } |
} |
| } |
} |
|
Line 3003 sub courseiddump {
|
Line 3744 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 3035 sub dcmaildump {
|
Line 3819 sub dcmaildump {
|
| |
|
| sub get_domain_roles { |
sub get_domain_roles { |
| my ($dom,$roles,$startdate,$enddate)=@_; |
my ($dom,$roles,$startdate,$enddate)=@_; |
| if (undef($startdate) || $startdate eq '') { |
if ((!defined($startdate)) || ($startdate eq '')) { |
| $startdate = '.'; |
$startdate = '.'; |
| } |
} |
| if (undef($enddate) || $enddate eq '') { |
if ((!defined($enddate)) || ($enddate eq '')) { |
| $enddate = '.'; |
$enddate = '.'; |
| } |
} |
| my $rolelist; |
my $rolelist; |
|
Line 3063 sub get_domain_roles {
|
Line 3847 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 3099 sub set_first_access {
|
Line 3883 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 3288 sub hashref2str {
|
Line 3987 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 3440 sub tmpreset {
|
Line 4139 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', |
| &GDBM_WRCREAT(),0640)) { |
&GDBM_WRCREAT(),0640)) { |
| foreach my $key (keys %hash) { |
foreach my $key (keys(%hash)) { |
| if ($key=~ /:$symb/) { |
if ($key=~ /:$symb/) { |
| delete($hash{$key}); |
delete($hash{$key}); |
| } |
} |
|
Line 3479 sub tmpstore {
|
Line 4178 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 3525 sub tmprestore {
|
Line 4224 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 3662 sub restore {
|
Line 4361 sub restore {
|
| } |
} |
| |
|
| # ---------------------------------------------------------- Course Description |
# ---------------------------------------------------------- Course Description |
| |
# |
| |
# |
| |
|
| sub coursedescription { |
sub coursedescription { |
| my ($courseid,$args)=@_; |
my ($courseid,$args)=@_; |
|
Line 3691 sub coursedescription {
|
Line 4392 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 3699 sub coursedescription {
|
Line 4401 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 3709 sub coursedescription {
|
Line 4415 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 3722 sub coursedescription {
|
Line 4428 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 { |
| my ($username,$domain)=@_; |
my ($username,$domain)=@_; |
| my $rolesdump=&reply("dump:$domain:$username:roles", |
my $rolesdump=&reply("dump:$domain:$username:roles", |
| &homeserver($username,$domain)); |
&homeserver($username,$domain)); |
| if (($rolesdump eq 'con_lost') || ($rolesdump eq '')) { return 0; } |
if (($rolesdump eq 'con_lost') || ($rolesdump eq '') || |
| |
($rolesdump =~ /^error:/)) { |
| |
return 0; |
| |
} |
| my $now=time; |
my $now=time; |
| if ($rolesdump ne '') { |
if ($rolesdump ne '') { |
| foreach my $entry (split(/&/,$rolesdump)) { |
foreach my $entry (split(/&/,$rolesdump)) { |
|
Line 3756 sub privileged {
|
Line 4503 sub privileged {
|
| |
|
| sub rolesinit { |
sub rolesinit { |
| my ($domain,$username,$authhost)=@_; |
my ($domain,$username,$authhost)=@_; |
| my %userroles; |
my $now=time; |
| my $rolesdump=reply("dump:$domain:$username:roles",$authhost); |
my %userroles = ('user.login.time' => $now); |
| if (($rolesdump eq 'con_lost') || ($rolesdump eq '')) { return \%userroles; } |
my $extra = &freeze_escape({'skipcheck' => 1}); |
| |
my $rolesdump=reply("dump:$domain:$username:roles:.::$extra",$authhost); |
| |
if (($rolesdump eq 'con_lost') || ($rolesdump eq '') || |
| |
($rolesdump =~ /^error:/)) { |
| |
return \%userroles; |
| |
} |
| my %allroles=(); |
my %allroles=(); |
| my %allgroups=(); |
my %allgroups=(); |
| my $now=time; |
|
| %userroles = ('user.login.time' => $now); |
|
| my $group_privs; |
|
| |
|
| if ($rolesdump ne '') { |
if ($rolesdump ne '') { |
| foreach my $entry (split(/&/,$rolesdump)) { |
foreach my $entry (split(/&/,$rolesdump)) { |
|
Line 3780 sub rolesinit {
|
Line 4529 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 3828 sub custom_roleprivs {
|
Line 4578 sub custom_roleprivs {
|
| if (($rdummy ne 'con_lost') && ($roledef ne '')) { |
if (($rdummy ne 'con_lost') && ($roledef ne '')) { |
| my ($syspriv,$dompriv,$coursepriv)=split(/\_/,$roledef); |
my ($syspriv,$dompriv,$coursepriv)=split(/\_/,$roledef); |
| if (defined($syspriv)) { |
if (defined($syspriv)) { |
| |
if ($trest =~ /^$match_community$/) { |
| |
$syspriv =~ s/bre\&S//; |
| |
} |
| $$allroles{'cm./'}.=':'.$syspriv; |
$$allroles{'cm./'}.=':'.$syspriv; |
| $$allroles{$spec.'./'}.=':'.$syspriv; |
$$allroles{$spec.'./'}.=':'.$syspriv; |
| } |
} |
|
Line 3876 sub standard_roleprivs {
|
Line 4629 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) { |
| foreach my $role (keys %{$allroles}) { |
my @groupkeys; |
| my ($trole,$area,$sec,$extendedarea); |
foreach my $role (keys(%{$allroles})) { |
| if ($role =~ m-^(\w+|cr/$match_domain/$match_username/\w+)\.(/$match_domain/$match_courseid)(/?\w*)\.-) { |
push(@groupkeys,$role); |
| $trole = $1; |
} |
| $area = $2; |
if (ref($groups_roles) eq 'HASH') { |
| $sec = $3; |
foreach my $key (keys(%{$groups_roles})) { |
| $extendedarea = $area.$sec; |
unless (grep(/^\Q$key\E$/,@groupkeys)) { |
| if (exists($$allgroups{$area})) { |
push(@groupkeys,$key); |
| 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 3916 sub set_userprivs {
|
Line 4682 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 3925 sub set_userprivs {
|
Line 4691 sub set_userprivs {
|
| } |
} |
| |
|
| sub role_status { |
sub role_status { |
| my ($rolekey,$then,$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 3934 sub role_status {
|
Line 4700 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) { $$tstatus='will'; } |
if ($$tstart<$now) { |
| |
if ($$tstart && $$tstart>$refresh) { |
| |
if (($$where ne '') && ($$role ne '')) { |
| |
my (%allroles,%allgroups,$group_privs, |
| |
%groups_roles,@rolecodes); |
| |
my %userroles = ( |
| |
'user.role.'.$$role.'.'.$$where => $$tstart.'.'.$$tend |
| |
); |
| |
@rolecodes = ('cm'); |
| |
my $spec=$$role.'.'.$$where; |
| |
my ($tdummy,$tdomain,$trest)=split(/\//,$$where); |
| |
if ($$role =~ /^cr\//) { |
| |
&custom_roleprivs(\%allroles,$$role,$tdomain,$trest,$spec,$$where); |
| |
push(@rolecodes,'cr'); |
| |
} elsif ($$role eq 'gr') { |
| |
push(@rolecodes,$$role); |
| |
my %rolehash = &get('roles',[$$where.'_'.$$role],$env{'user.domain'}, |
| |
$env{'user.name'}); |
| |
my ($trole) = split('_',$rolehash{$$where.'_'.$$role},2); |
| |
(undef,my $group_privs) = split(/\//,$trole); |
| |
$group_privs = &unescape($group_privs); |
| |
&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 { |
| |
push(@rolecodes,$$role); |
| |
&standard_roleprivs(\%allroles,$$role,$tdomain,$spec,$trest,$$where); |
| |
} |
| |
my ($author,$adv)= &set_userprivs(\%userroles,\%allroles,\%allgroups,\%groups_roles); |
| |
&appenv(\%userroles,\@rolecodes); |
| |
&log($env{'user.domain'},$env{'user.name'},$env{'user.home'},"Role ".$role); |
| |
} |
| |
} |
| |
$$tstatus = 'is'; |
| |
} |
| } |
} |
| 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 3949 sub role_status {
|
Line 4751 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,$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,$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 3975 sub set_adhoc_privileges {
|
Line 4835 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 4031 sub del {
|
Line 4893 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 4040 sub dump {
|
Line 4902 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 4334 sub tmpget {
|
Line 5199 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 4445 sub get_portfolio_access {
|
Line 5310 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 4585 sub is_portfolio_file {
|
Line 5450 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 4594 sub usertools_access {
|
Line 5459 sub usertools_access {
|
| %tools = ( |
%tools = ( |
| official => 1, |
official => 1, |
| unofficial => 1, |
unofficial => 1, |
| |
community => 1, |
| ); |
); |
| } else { |
} else { |
| %tools = ( |
%tools = ( |
|
Line 4626 sub usertools_access {
|
Line 5492 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); |
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 4640 sub usertools_access {
|
Line 5511 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 4692 sub usertools_access {
|
Line 5572 sub usertools_access {
|
| } |
} |
| } |
} |
| |
|
| |
sub is_course_owner { |
| |
my ($cdom,$cnum,$udom,$uname) = @_; |
| |
if (($udom eq '') || ($uname eq '')) { |
| |
$udom = $env{'user.domain'}; |
| |
$uname = $env{'user.name'}; |
| |
} |
| |
unless (($udom eq '') || ($uname eq '')) { |
| |
if (exists($env{'course.'.$cdom.'_'.$cnum.'.internal.courseowner'})) { |
| |
if ($env{'course.'.$cdom.'_'.$cnum.'.internal.courseowner'} eq $uname.':'.$udom) { |
| |
return 1; |
| |
} else { |
| |
my %courseinfo = &Apache::lonnet::coursedescription($cdom.'/'.$cnum); |
| |
if ($courseinfo{'internal.courseowner'} eq $uname.':'.$udom) { |
| |
return 1; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
return; |
| |
} |
| |
|
| 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'})) { |
| |
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 4710 sub is_advanced_user {
|
Line 5620 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 4724 sub is_advanced_user {
|
Line 5637 sub is_advanced_user {
|
| } |
} |
| } |
} |
| } |
} |
| |
if (wantarray) { |
| |
return ($is_adv,$is_author); |
| |
} |
| return $is_adv; |
return $is_adv; |
| } |
} |
| |
|
| |
sub check_can_request { |
| |
my ($dom,$can_request,$request_domains) = @_; |
| |
my $canreq = 0; |
| |
my ($types,$typename) = &Apache::loncommon::course_types(); |
| |
my @options = ('approval','validate','autolimit'); |
| |
my $optregex = join('|',@options); |
| |
if ((ref($can_request) eq 'HASH') && (ref($types) eq 'ARRAY')) { |
| |
foreach my $type (@{$types}) { |
| |
if (&usertools_access($env{'user.name'}, |
| |
$env{'user.domain'}, |
| |
$type,undef,'requestcourses')) { |
| |
$canreq ++; |
| |
if (ref($request_domains) eq 'HASH') { |
| |
push(@{$request_domains->{$type}},$env{'user.domain'}); |
| |
} |
| |
if ($dom eq $env{'user.domain'}) { |
| |
$can_request->{$type} = 1; |
| |
} |
| |
} |
| |
if ($env{'environment.reqcrsotherdom.'.$type} ne '') { |
| |
my @curr = split(',',$env{'environment.reqcrsotherdom.'.$type}); |
| |
if (@curr > 0) { |
| |
foreach my $item (@curr) { |
| |
if (ref($request_domains) eq 'HASH') { |
| |
my ($otherdom) = ($item =~ /^($match_domain):($optregex)(=?\d*)$/); |
| |
if ($otherdom ne '') { |
| |
if (ref($request_domains->{$type}) eq 'ARRAY') { |
| |
unless (grep(/^\Q$otherdom\E$/,@{$request_domains->{$type}})) { |
| |
push(@{$request_domains->{$type}},$otherdom); |
| |
} |
| |
} else { |
| |
push(@{$request_domains->{$type}},$otherdom); |
| |
} |
| |
} |
| |
} |
| |
} |
| |
unless($dom eq $env{'user.domain'}) { |
| |
$canreq ++; |
| |
if (grep(/^\Q$dom\E:($optregex)(=?\d*)$/,@curr)) { |
| |
$can_request->{$type} = 1; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
return $canreq; |
| |
} |
| |
|
| # ---------------------------------------------- Custom access rule evaluation |
# ---------------------------------------------- Custom access rule evaluation |
| |
|
| sub customaccess { |
sub customaccess { |
|
Line 4881 sub allowed {
|
Line 5846 sub allowed {
|
| my $statecond=0; |
my $statecond=0; |
| my $courseprivid=''; |
my $courseprivid=''; |
| |
|
| |
my $ownaccess; |
| |
# Community Coordinator or Assistant Co-author browsing resource space. |
| |
if (($priv eq 'bro') && ($env{'user.author'})) { |
| |
if ($uri eq '') { |
| |
$ownaccess = 1; |
| |
} else { |
| |
if (($env{'user.domain'} ne '') && ($env{'user.name'} ne '')) { |
| |
my $udom = $env{'user.domain'}; |
| |
my $uname = $env{'user.name'}; |
| |
if ($uri =~ m{^\Q$udom\E/?$}) { |
| |
$ownaccess = 1; |
| |
} elsif ($uri =~ m{^\Q$udom\E/\Q$uname\E/?}) { |
| |
unless ($uri =~ m{\.\./}) { |
| |
$ownaccess = 1; |
| |
} |
| |
} elsif (($udom ne 'public') && ($uname ne 'public')) { |
| |
my $now = time; |
| |
if ($uri =~ m{^([^/]+)/?$}) { |
| |
my $adom = $1; |
| |
foreach my $key (keys(%env)) { |
| |
if ($key =~ m{^user\.role\.(ca|aa)/\Q$adom\E}) { |
| |
my ($start,$end) = split('.',$env{$key}); |
| |
if (($now >= $start) && (!$end || $end < $now)) { |
| |
$ownaccess = 1; |
| |
last; |
| |
} |
| |
} |
| |
} |
| |
} elsif ($uri =~ m{^([^/]+)/([^/]+)/?}) { |
| |
my $adom = $1; |
| |
my $aname = $2; |
| |
foreach my $role ('ca','aa') { |
| |
if ($env{"user.role.$role./$adom/$aname"}) { |
| |
my ($start,$end) = |
| |
split('.',$env{"user.role.$role./$adom/$aname"}); |
| |
if (($now >= $start) && (!$end || $end < $now)) { |
| |
$ownaccess = 1; |
| |
last; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
|
| # Course |
# Course |
| |
|
| if ($env{'user.priv.'.$env{'request.role'}.'./'}=~/\Q$priv\E\&([^\:]*)/) { |
if ($env{'user.priv.'.$env{'request.role'}.'./'}=~/\Q$priv\E\&([^\:]*)/) { |
| $thisallowed.=$1; |
unless (($priv eq 'bro') && (!$ownaccess)) { |
| |
$thisallowed.=$1; |
| |
} |
| } |
} |
| |
|
| # Domain |
# Domain |
| |
|
| if ($env{'user.priv.'.$env{'request.role'}.'./'.(split(/\//,$uri))[0].'/'} |
if ($env{'user.priv.'.$env{'request.role'}.'./'.(split(/\//,$uri))[0].'/'} |
| =~/\Q$priv\E\&([^\:]*)/) { |
=~/\Q$priv\E\&([^\:]*)/) { |
| $thisallowed.=$1; |
unless (($priv eq 'bro') && (!$ownaccess)) { |
| |
$thisallowed.=$1; |
| |
} |
| |
} |
| |
|
| |
# 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 |
|
Line 4901 sub allowed {
|
Line 5926 sub allowed {
|
| |
|
| if ($env{'user.priv.'.$env{'request.role'}.'.'.$courseuri} |
if ($env{'user.priv.'.$env{'request.role'}.'.'.$courseuri} |
| =~/\Q$priv\E\&([^\:]*)/) { |
=~/\Q$priv\E\&([^\:]*)/) { |
| $thisallowed.=$1; |
unless (($priv eq 'bro') && (!$ownaccess)) { |
| |
$thisallowed.=$1; |
| |
} |
| } |
} |
| |
|
| # URI is an uploaded document for this course, default permissions don't matter |
# URI is an uploaded document for this course, default permissions don't matter |
|
Line 5041 sub allowed {
|
Line 6068 sub allowed {
|
| |
|
| my $envkey; |
my $envkey; |
| if ($thisallowed=~/L/) { |
if ($thisallowed=~/L/) { |
| foreach $envkey (keys %env) { |
foreach $envkey (keys(%env)) { |
| if ($envkey=~/^user\.role\.(st|ta)\.([^\.]*)/) { |
if ($envkey=~/^user\.role\.(st|ta)\.([^\.]*)/) { |
| my $courseid=$2; |
my $courseid=$2; |
| my $roleid=$1.'.'.$2; |
my $roleid=$1.'.'.$2; |
|
Line 5107 sub allowed {
|
Line 6134 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 5117 sub allowed {
|
Line 6144 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 5131 sub allowed {
|
Line 6158 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 5162 sub allowed {
|
Line 6189 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 5314 sub update_allusers_table {
|
Line 6361 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 5332 sub fetch_enrollment_query {
|
Line 6378 sub fetch_enrollment_query {
|
| } |
} |
| my $host=&hostname($homeserver); |
my $host=&hostname($homeserver); |
| my $cmd = ''; |
my $cmd = ''; |
| foreach my $affiliate (keys %{$affiliatesref}) { |
foreach my $affiliate (keys(%{$affiliatesref})) { |
| $cmd .= $affiliate.'='.join(",",@{$$affiliatesref{$affiliate}}).'%%'; |
$cmd .= $affiliate.'='.join(",",@{$$affiliatesref{$affiliate}}).'%%'; |
| } |
} |
| $cmd =~ s/%%$//; |
$cmd =~ s/%%$//; |
|
Line 5359 sub fetch_enrollment_query {
|
Line 6405 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 5389 sub fetch_enrollment_query {
|
Line 6435 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 5465 sub auto_run {
|
Line 6511 sub auto_run {
|
| |
|
| sub auto_get_sections { |
sub auto_get_sections { |
| my ($cnum,$cdom,$inst_coursecode) = @_; |
my ($cnum,$cdom,$inst_coursecode) = @_; |
| my $homeserver = &homeserver($cnum,$cdom); |
my $homeserver; |
| my @secs = (); |
if (($cdom =~ /^$match_domain$/) && ($cnum =~ /^$match_courseid$/)) { |
| my $response=&unescape(&reply('autogetsections:'.$inst_coursecode.':'.$cdom,$homeserver)); |
$homeserver = &homeserver($cnum,$cdom); |
| unless ($response eq 'refused') { |
} |
| @secs = split(/:/,$response); |
if (!defined($homeserver)) { |
| |
if ($cdom =~ /^$match_domain$/) { |
| |
$homeserver = &domain($cdom,'primary'); |
| |
} |
| |
} |
| |
my @secs; |
| |
if (defined($homeserver)) { |
| |
my $response=&unescape(&reply('autogetsections:'.$inst_coursecode.':'.$cdom,$homeserver)); |
| |
unless ($response eq 'refused') { |
| |
@secs = split(/:/,$response); |
| |
} |
| } |
} |
| return @secs; |
return @secs; |
| } |
} |
| |
|
| 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 5488 sub auto_validate_courseID {
|
Line 6544 sub auto_validate_courseID {
|
| return $response; |
return $response; |
| } |
} |
| |
|
| |
sub auto_validate_instcode { |
| |
my ($cnum,$cdom,$instcode,$owner) = @_; |
| |
my ($homeserver,$response); |
| |
if (($cdom =~ /^$match_domain$/) && ($cnum =~ /^$match_courseid$/)) { |
| |
$homeserver = &homeserver($cnum,$cdom); |
| |
} |
| |
if (!defined($homeserver)) { |
| |
if ($cdom =~ /^$match_domain$/) { |
| |
$homeserver = &domain($cdom,'primary'); |
| |
} |
| |
} |
| |
$response=&unescape(&reply('autovalidateinstcode:'.$cdom.':'. |
| |
&escape($instcode).':'.&escape($owner),$homeserver)); |
| |
my ($outcome,$description) = map { &unescape($_); } split('&',$response,2); |
| |
return ($outcome,$description); |
| |
} |
| |
|
| sub auto_create_password { |
sub auto_create_password { |
| my ($cnum,$cdom,$authparam,$udom) = @_; |
my ($cnum,$cdom,$authparam,$udom) = @_; |
| my ($homeserver,$response); |
my ($homeserver,$response); |
|
Line 5602 sub auto_instcode_format {
|
Line 6675 sub auto_instcode_format {
|
| push(@homeservers,$tryserver); |
push(@homeservers,$tryserver); |
| } |
} |
| } |
} |
| |
} elsif ($caller eq 'requests') { |
| |
if ($codedom =~ /^$match_domain$/) { |
| |
my $chome = &domain($codedom,'primary'); |
| |
unless ($chome eq 'no_host') { |
| |
push(@homeservers,$chome); |
| |
} |
| |
} |
| } else { |
} else { |
| push(@homeservers,&homeserver($caller,$codedom)); |
push(@homeservers,&homeserver($caller,$codedom)); |
| } |
} |
|
Line 5659 sub auto_instcode_defaults {
|
Line 6739 sub auto_instcode_defaults {
|
| } |
} |
| |
|
| return $response; |
return $response; |
| } |
} |
| |
|
| |
sub auto_possible_instcodes { |
| |
my ($domain,$codetitles,$cat_titles,$cat_orders,$code_order) = @_; |
| |
unless ((ref($codetitles) eq 'ARRAY') && (ref($cat_titles) eq 'HASH') && |
| |
(ref($cat_orders) eq 'HASH') && (ref($code_order) eq 'ARRAY')) { |
| |
return; |
| |
} |
| |
my (@homeservers,$uhome); |
| |
if (defined(&domain($domain,'primary'))) { |
| |
$uhome=&domain($domain,'primary'); |
| |
push(@homeservers,&domain($domain,'primary')); |
| |
} else { |
| |
my %servers = &get_servers($domain,'library'); |
| |
foreach my $tryserver (keys(%servers)) { |
| |
if (!grep(/^\Q$tryserver\E$/,@homeservers)) { |
| |
push(@homeservers,$tryserver); |
| |
} |
| |
} |
| |
} |
| |
my $response; |
| |
foreach my $server (@homeservers) { |
| |
$response=&reply('autopossibleinstcodes:'.$domain,$server); |
| |
next if ($response =~ /(con_lost|error|no_such_host|refused)/); |
| |
my ($codetitlestr,$codeorderstr,$cat_title,$cat_order) = |
| |
split(':',$response); |
| |
@{$codetitles} = map { &unescape($_); } (split('&',$codetitlestr)); |
| |
@{$code_order} = map { &unescape($_); } (split('&',$codeorderstr)); |
| |
foreach my $item (split('&',$cat_title)) { |
| |
my ($name,$value)=split('=',$item); |
| |
$cat_titles->{&unescape($name)}=&thaw_unescape($value); |
| |
} |
| |
foreach my $item (split('&',$cat_order)) { |
| |
my ($name,$value)=split('=',$item); |
| |
$cat_orders->{&unescape($name)}=&thaw_unescape($value); |
| |
} |
| |
return 'ok'; |
| |
} |
| |
return $response; |
| |
} |
| |
|
| |
sub auto_courserequest_checks { |
| |
my ($dom) = @_; |
| |
my ($homeserver,%validations); |
| |
if ($dom =~ /^$match_domain$/) { |
| |
$homeserver = &domain($dom,'primary'); |
| |
} |
| |
unless ($homeserver eq 'no_host') { |
| |
my $response=&reply('autocrsreqchecks:'.$dom,$homeserver); |
| |
unless ($response =~ /(con_lost|error|no_such_host|refused)/) { |
| |
my @items = split(/&/,$response); |
| |
foreach my $item (@items) { |
| |
my ($key,$value) = split('=',$item); |
| |
$validations{&unescape($key)} = &thaw_unescape($value); |
| |
} |
| |
} |
| |
} |
| |
return %validations; |
| |
} |
| |
|
| |
sub auto_courserequest_validation { |
| |
my ($dom,$owner,$crstype,$inststatuslist,$instcode,$instseclist) = @_; |
| |
my ($homeserver,$response); |
| |
if ($dom =~ /^$match_domain$/) { |
| |
$homeserver = &domain($dom,'primary'); |
| |
} |
| |
unless ($homeserver eq 'no_host') { |
| |
|
| |
$response=&unescape(&reply('autocrsreqvalidation:'.$dom.':'.&escape($owner). |
| |
':'.&escape($crstype).':'.&escape($inststatuslist). |
| |
':'.&escape($instcode).':'.&escape($instseclist), |
| |
$homeserver)); |
| |
} |
| |
return $response; |
| |
} |
| |
|
| sub auto_validate_class_sec { |
sub auto_validate_class_sec { |
| my ($cdom,$cnum,$owners,$inst_class) = @_; |
my ($cdom,$cnum,$owners,$inst_class) = @_; |
|
Line 5770 sub get_users_groups {
|
Line 6924 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 5813 sub devalidate_getgroups_cache {
|
Line 6968 sub devalidate_getgroups_cache {
|
| |
|
| sub plaintext { |
sub plaintext { |
| my ($short,$type,$cid,$forcedefault) = @_; |
my ($short,$type,$cid,$forcedefault) = @_; |
| if ($short =~ /^cr/) { |
if ($short =~ m{^cr/}) { |
| return (split('/',$short))[-1]; |
return (split('/',$short))[-1]; |
| } |
} |
| if (!defined($cid)) { |
if (!defined($cid)) { |
| $cid = $env{'request.course.id'}; |
$cid = $env{'request.course.id'}; |
| } |
} |
| if (defined($cid) && ($env{'course.'.$cid.'.'.$short.'.plaintext'} ne '')) { |
|
| unless ($forcedefault) { |
|
| my $roletext = $env{'course.'.$cid.'.'.$short.'.plaintext'}; |
|
| &Apache::lonlocal::mt_escape(\$roletext); |
|
| return &Apache::lonlocal::mt($roletext); |
|
| } |
|
| } |
|
| my %rolenames = ( |
my %rolenames = ( |
| Course => 'std', |
Course => 'std', |
| Group => 'alt1', |
Community => 'alt1', |
| ); |
); |
| if (defined($type) && |
if ($cid ne '') { |
| defined($rolenames{$type}) && |
if ($env{'course.'.$cid.'.'.$short.'.plaintext'} ne '') { |
| defined($prp{$short}{$rolenames{$type}})) { |
unless ($forcedefault) { |
| |
my $roletext = $env{'course.'.$cid.'.'.$short.'.plaintext'}; |
| |
&Apache::lonlocal::mt_escape(\$roletext); |
| |
return &Apache::lonlocal::mt($roletext); |
| |
} |
| |
} |
| |
} |
| |
if ((defined($type)) && (defined($rolenames{$type})) && |
| |
(defined($rolenames{$type})) && |
| |
(defined($prp{$short}{$rolenames{$type}}))) { |
| return &Apache::lonlocal::mt($prp{$short}{$rolenames{$type}}); |
return &Apache::lonlocal::mt($prp{$short}{$rolenames{$type}}); |
| } else { |
} elsif ($cid ne '') { |
| return &Apache::lonlocal::mt($prp{$short}{'std'}); |
my $crstype = $env{'course.'.$cid.'.type'}; |
| |
if (($crstype ne '') && (defined($rolenames{$crstype})) && |
| |
(defined($prp{$short}{$rolenames{$crstype}}))) { |
| |
return &Apache::lonlocal::mt($prp{$short}{$rolenames{$crstype}}); |
| |
} |
| } |
} |
| |
return &Apache::lonlocal::mt($prp{$short}{'std'}); |
| } |
} |
| |
|
| # ----------------------------------------------------------------- Assign Role |
# ----------------------------------------------------------------- Assign Role |
|
Line 5849 sub assignrole {
|
Line 7011 sub assignrole {
|
| my $cwosec=$url; |
my $cwosec=$url; |
| $cwosec=~s/^\/($match_domain)\/($match_courseid)\/.*/$1\/$2/; |
$cwosec=~s/^\/($match_domain)\/($match_courseid)\/.*/$1\/$2/; |
| unless (&allowed('ccr',$cwosec)) { |
unless (&allowed('ccr',$cwosec)) { |
| &logthis('Refused custom assignrole: '. |
my $refused = 1; |
| $udom.' '.$uname.' '.$url.' '.$role.' '.$end.' '.$start.' by '. |
if ($context eq 'requestcourses') { |
| $env{'user.name'}.' at '.$env{'user.domain'}); |
if (($env{'user.name'} ne '') && ($env{'user.domain'} ne '')) { |
| return 'refused'; |
if ($role =~ m{^cr/($match_domain)/($match_username)/([^/]+)$}) { |
| |
if (($1 eq $env{'user.domain'}) && ($2 eq $env{'user.name'})) { |
| |
my ($cdom,$cnum) = ($cwosec =~ m{^/?($match_domain)/($match_courseid)$}); |
| |
my %crsenv = &userenvironment($cdom,$cnum,('internal.courseowner')); |
| |
if ($crsenv{'internal.courseowner'} eq |
| |
$env{'user.name'}.':'.$env{'user.domain'}) { |
| |
$refused = ''; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
if ($refused) { |
| |
&logthis('Refused custom assignrole: '. |
| |
$udom.' '.$uname.' '.$url.' '.$role.' '.$end.' '.$start. |
| |
' by '.$env{'user.name'}.' at '.$env{'user.domain'}); |
| |
return 'refused'; |
| |
} |
| } |
} |
| $mrole='cr'; |
$mrole='cr'; |
| } elsif ($role =~ /^gr\//) { |
} elsif ($role =~ /^gr\//) { |
|
Line 5878 sub assignrole {
|
Line 7057 sub assignrole {
|
| $refused = 1; |
$refused = 1; |
| } |
} |
| if ($refused) { |
if ($refused) { |
| if (($selfenroll == 1) && ($role eq 'st') && ($udom eq $env{'user.domain'}) && ($uname eq $env{'user.name'})) { |
my ($cdom,$cnum) = ($cwosec =~ m{^/?($match_domain)/($match_courseid)$}); |
| |
if (!$selfenroll && $context eq 'course') { |
| |
my %crsenv; |
| |
if ($role eq 'cc' || $role eq 'co') { |
| |
%crsenv = &userenvironment($cdom,$cnum,('internal.courseowner')); |
| |
if (($role eq 'cc') && ($cnum !~ /^$match_community$/)) { |
| |
if ($env{'request.role'} eq 'cc./'.$cdom.'/'.$cnum) { |
| |
if ($crsenv{'internal.courseowner'} eq |
| |
$env{'user.name'}.':'.$env{'user.domain'}) { |
| |
$refused = ''; |
| |
} |
| |
} |
| |
} elsif (($role eq 'co') && ($cnum =~ /^$match_community$/)) { |
| |
if ($env{'request.role'} eq 'co./'.$cdom.'/'.$cnum) { |
| |
if ($crsenv{'internal.courseowner'} eq |
| |
$env{'user.name'}.':'.$env{'user.domain'}) { |
| |
$refused = ''; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} elsif (($selfenroll == 1) && ($role eq 'st') && ($udom eq $env{'user.domain'}) && ($uname eq $env{'user.name'})) { |
| $refused = ''; |
$refused = ''; |
| } else { |
} elsif ($context eq 'requestcourses') { |
| |
my @possroles = ('st','ta','ep','in','cc','co'); |
| |
if ((grep(/^\Q$role\E$/,@possroles)) && ($env{'user.name'} ne '' && $env{'user.domain'} ne '')) { |
| |
my $wrongcc; |
| |
if ($cnum =~ /^$match_community$/) { |
| |
$wrongcc = 1 if ($role eq 'cc'); |
| |
} else { |
| |
$wrongcc = 1 if ($role eq 'co'); |
| |
} |
| |
unless ($wrongcc) { |
| |
my %crsenv = &userenvironment($cdom,$cnum,('internal.courseowner')); |
| |
if ($crsenv{'internal.courseowner'} eq |
| |
$env{'user.name'}.':'.$env{'user.domain'}) { |
| |
$refused = ''; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
if ($refused) { |
| &logthis('Refused assignrole: '.$udom.' '.$uname.' '.$url. |
&logthis('Refused assignrole: '.$udom.' '.$uname.' '.$url. |
| ' '.$role.' '.$end.' '.$start.' by '. |
' '.$role.' '.$end.' '.$start.' by '. |
| $env{'user.name'}.' at '.$env{'user.domain'}); |
$env{'user.name'}.' at '.$env{'user.domain'}); |
| 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 5927 sub assignrole {
|
Line 7152 sub assignrole {
|
| &Apache::longroup::group_changes($udom,$uname,$url,$role,$origend, |
&Apache::longroup::group_changes($udom,$uname,$url,$role,$origend, |
| $origstart,$selfenroll,$context); |
$origstart,$selfenroll,$context); |
| } |
} |
| |
if ($role eq 'cc') { |
| |
&autoupdate_coowners($url,$end,$start,$uname,$udom); |
| |
} |
| } |
} |
| return $answer; |
return $answer; |
| } |
} |
| |
|
| |
sub autoupdate_coowners { |
| |
my ($url,$end,$start,$uname,$udom) = @_; |
| |
my ($cdom,$cnum) = ($url =~ m{^/($match_domain)/($match_courseid)}); |
| |
if (($cdom ne '') && ($cnum ne '')) { |
| |
my $now = time; |
| |
my %domdesign = &Apache::loncommon::get_domainconf($cdom); |
| |
if ($domdesign{$cdom.'.autoassign.co-owners'}) { |
| |
my %coursehash = &coursedescription($cdom.'_'.$cnum); |
| |
my $instcode = $coursehash{'internal.coursecode'}; |
| |
if ($instcode ne '') { |
| |
if (($start && $start <= $now) && ($end == 0) || ($end > $now)) { |
| |
unless ($coursehash{'internal.courseowner'} eq $uname.':'.$udom) { |
| |
my ($delcoowners,@newcoowners,$putresult,$delresult,$coowners); |
| |
my ($result,$desc) = &auto_validate_instcode($cnum,$cdom,$instcode,$uname.':'.$udom); |
| |
if ($result eq 'valid') { |
| |
if ($coursehash{'internal.co-owners'}) { |
| |
foreach my $coowner (split(',',$coursehash{'internal.co-owners'})) { |
| |
push(@newcoowners,$coowner); |
| |
} |
| |
unless (grep(/^\Q$uname\E:\Q$udom\E$/,@newcoowners)) { |
| |
push(@newcoowners,$uname.':'.$udom); |
| |
} |
| |
@newcoowners = sort(@newcoowners); |
| |
} else { |
| |
push(@newcoowners,$uname.':'.$udom); |
| |
} |
| |
} else { |
| |
if ($coursehash{'internal.co-owners'}) { |
| |
foreach my $coowner (split(',',$coursehash{'internal.co-owners'})) { |
| |
unless ($coowner eq $uname.':'.$udom) { |
| |
push(@newcoowners,$coowner); |
| |
} |
| |
} |
| |
unless (@newcoowners > 0) { |
| |
$delcoowners = 1; |
| |
$coowners = ''; |
| |
} |
| |
} |
| |
} |
| |
if (@newcoowners || $delcoowners) { |
| |
&store_coowners($cdom,$cnum,$coursehash{'home'}, |
| |
$delcoowners,@newcoowners); |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
|
| |
sub store_coowners { |
| |
my ($cdom,$cnum,$chome,$delcoowners,@newcoowners) = @_; |
| |
my $cid = $cdom.'_'.$cnum; |
| |
my ($coowners,$delresult,$putresult); |
| |
if (@newcoowners) { |
| |
$coowners = join(',',@newcoowners); |
| |
my %coownershash = ( |
| |
'internal.co-owners' => $coowners, |
| |
); |
| |
$putresult = &put('environment',\%coownershash,$cdom,$cnum); |
| |
if ($putresult eq 'ok') { |
| |
if ($env{'course.'.$cid.'.num'} eq $cnum) { |
| |
&appenv({'course.'.$cid.'.internal.co-owners' => $coowners}); |
| |
} |
| |
} |
| |
} |
| |
if ($delcoowners) { |
| |
$delresult = &Apache::lonnet::del('environment',['internal.co-owners'],$cdom,$cnum); |
| |
if ($delresult eq 'ok') { |
| |
if ($env{'course.'.$cid.'.internal.co-owners'}) { |
| |
&Apache::lonnet::delenv('course.'.$cid.'.internal.co-owners'); |
| |
} |
| |
} |
| |
} |
| |
if (($putresult eq 'ok') || ($delresult eq 'ok')) { |
| |
my %crsinfo = |
| |
&Apache::lonnet::courseiddump($cdom,'.',1,'.','.',$cnum,undef,undef,'.'); |
| |
if (ref($crsinfo{$cid}) eq 'HASH') { |
| |
$crsinfo{$cid}{'co-owners'} = \@newcoowners; |
| |
my $cidput = &Apache::lonnet::courseidput($cdom,\%crsinfo,$chome,'notime'); |
| |
} |
| |
} |
| |
} |
| |
|
| # -------------------------------------------------- Modify user authentication |
# -------------------------------------------------- Modify user authentication |
| # Overrides without validation |
# Overrides without validation |
| |
|
|
Line 5963 sub modifyuser {
|
Line 7275 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 6026 sub modifyuser {
|
Line 7348 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 6060 sub modifyuser {
|
Line 7407 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 6204 sub writecoursepref {
|
Line 7573 sub writecoursepref {
|
| |
|
| sub createcourse { |
sub createcourse { |
| my ($udom,$description,$url,$course_server,$nonstandard,$inst_code, |
my ($udom,$description,$url,$course_server,$nonstandard,$inst_code, |
| $course_owner,$crstype)=@_; |
$course_owner,$crstype,$cnum,$context,$category)=@_; |
| $url=&declutter($url); |
$url=&declutter($url); |
| my $cid=''; |
my $cid=''; |
| unless (&allowed('ccc',$udom)) { |
if ($context eq 'requestcourses') { |
| |
my $can_create = 0; |
| |
my ($ownername,$ownerdom) = split(':',$course_owner); |
| |
if ($udom eq $ownerdom) { |
| |
if (&usertools_access($ownername,$ownerdom,$category,undef, |
| |
$context)) { |
| |
$can_create = 1; |
| |
} |
| |
} else { |
| |
my %userenv = &userenvironment($ownerdom,$ownername,'reqcrsotherdom.'. |
| |
$category); |
| |
if ($userenv{'reqcrsotherdom.'.$category} ne '') { |
| |
my @curr = split(',',$userenv{'reqcrsotherdom.'.$category}); |
| |
if (@curr > 0) { |
| |
my @options = qw(approval validate autolimit); |
| |
my $optregex = join('|',@options); |
| |
if (grep(/^\Q$udom\E:($optregex)(=?\d*)$/,@curr)) { |
| |
$can_create = 1; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
if ($can_create) { |
| |
unless ($ownername eq $env{'user.name'} && $ownerdom eq $env{'user.domain'}) { |
| |
unless (&allowed('ccc',$udom)) { |
| |
return 'refused'; |
| |
} |
| |
} |
| |
} else { |
| |
return 'refused'; |
| |
} |
| |
} elsif (!&allowed('ccc',$udom)) { |
| return 'refused'; |
return 'refused'; |
| } |
} |
| # ------------------------------------------------------------------- Create ID |
# --------------------------------------------------------------- Get Unique ID |
| my $uname=int(1+rand(9)). |
my $uname; |
| ('a'..'z','A'..'Z','0'..'9')[int(rand(62))]. |
if ($cnum =~ /^$match_courseid$/) { |
| substr($$.time,0,5).unpack("H8",pack("I32",time)). |
my $chome=&homeserver($cnum,$udom,'true'); |
| unpack("H2",pack("I32",int(rand(255)))).$perlvar{'lonHostID'}; |
if (($chome eq '') || ($chome eq 'no_host')) { |
| # ----------------------------------------------- Make sure that does not exist |
$uname = $cnum; |
| my $uhome=&homeserver($uname,$udom,'true'); |
} else { |
| unless (($uhome eq '') || ($uhome eq 'no_host')) { |
$uname = &generate_coursenum($udom,$crstype); |
| $uname=substr($$.time,0,5).unpack("H8",pack("I32",time)). |
} |
| unpack("H2",pack("I32",int(rand(255)))).$perlvar{'lonHostID'}; |
} else { |
| $uhome=&homeserver($uname,$udom,'true'); |
$uname = &generate_coursenum($udom,$crstype); |
| unless (($uhome eq '') || ($uhome eq 'no_host')) { |
} |
| return 'error: unable to generate unique course-ID'; |
return $uname if ($uname =~ /^error/); |
| } |
# -------------------------------------------------- Check supplied server name |
| } |
if (!defined($course_server)) { |
| # ------------------------------------------------ Check supplied server name |
if (defined(&domain($udom,'primary'))) { |
| $course_server = $env{'user.homeserver'} if (! defined($course_server)); |
$course_server = &domain($udom,'primary'); |
| if (! &is_library($course_server)) { |
} else { |
| return 'error:bad server name '.$course_server; |
$course_server = $env{'user.home'}; |
| |
} |
| |
} |
| |
my %host_servers = |
| |
&Apache::lonnet::get_servers($udom,'library'); |
| |
unless ($host_servers{$course_server}) { |
| |
return 'error: invalid home server for course: '.$course_server; |
| } |
} |
| # ------------------------------------------------------------- Make the course |
# ------------------------------------------------------------- Make the course |
| my $reply=&reply('encrypt:makeuser:'.$udom.':'.$uname.':none::', |
my $reply=&reply('encrypt:makeuser:'.$udom.':'.$uname.':none::', |
| $course_server); |
$course_server); |
| unless ($reply eq 'ok') { return 'error: '.$reply; } |
unless ($reply eq 'ok') { return 'error: '.$reply; } |
| $uhome=&homeserver($uname,$udom,'true'); |
my $uhome=&homeserver($uname,$udom,'true'); |
| if (($uhome eq '') || ($uhome eq 'no_host')) { |
if (($uhome eq '') || ($uhome eq 'no_host')) { |
| return 'error: no such course'; |
return 'error: no such course'; |
| } |
} |
| # ----------------------------------------------------------------- Course made |
# ----------------------------------------------------------------- Course made |
| # log existence |
# log existence |
| |
my $now = time; |
| my $newcourse = { |
my $newcourse = { |
| $udom.'_'.$uname => { |
$udom.'_'.$uname => { |
| description => $description, |
description => $description, |
| inst_code => $inst_code, |
inst_code => $inst_code, |
| owner => $course_owner, |
owner => $course_owner, |
| type => $crstype, |
type => $crstype, |
| |
creator => $env{'user.name'}.':'. |
| |
$env{'user.domain'}, |
| |
created => $now, |
| |
context => $context, |
| }, |
}, |
| }; |
}; |
| &courseidput($udom,$newcourse,$uhome,'notime'); |
&courseidput($udom,$newcourse,$uhome,'notime'); |
|
Line 6270 ENDINITMAP
|
Line 7681 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; |
| } |
} |
| |
|
| |
# ------------------------------------------------------------------- Create ID |
| |
sub generate_coursenum { |
| |
my ($udom,$crstype) = @_; |
| |
my $domdesc = &domain($udom); |
| |
return 'error: invalid domain' if ($domdesc eq ''); |
| |
my $first; |
| |
if ($crstype eq 'Community') { |
| |
$first = '0'; |
| |
} else { |
| |
$first = int(1+rand(9)); |
| |
} |
| |
my $uname=$first. |
| |
('a'..'z','A'..'Z','0'..'9')[int(rand(62))]. |
| |
substr($$.time,0,5).unpack("H8",pack("I32",time)). |
| |
unpack("H2",pack("I32",int(rand(255)))).$perlvar{'lonHostID'}; |
| |
# ----------------------------------------------- Make sure that does not exist |
| |
my $uhome=&homeserver($uname,$udom,'true'); |
| |
unless (($uhome eq '') || ($uhome eq 'no_host')) { |
| |
if ($crstype eq 'Community') { |
| |
$first = '0'; |
| |
} else { |
| |
$first = int(1+rand(9)); |
| |
} |
| |
$uname=$first. |
| |
('a'..'z','A'..'Z','0'..'9')[int(rand(62))]. |
| |
substr($$.time,0,5).unpack("H8",pack("I32",time)). |
| |
unpack("H2",pack("I32",int(rand(255)))).$perlvar{'lonHostID'}; |
| |
$uhome=&homeserver($uname,$udom,'true'); |
| |
unless (($uhome eq '') || ($uhome eq 'no_host')) { |
| |
return 'error: unable to generate unique course-ID'; |
| |
} |
| |
} |
| |
return $uname; |
| |
} |
| |
|
| sub is_course { |
sub is_course { |
| my ($cdom,$cnum) = @_; |
my ($cdom,$cnum) = @_; |
| my %courses = &courseiddump($cdom,'.',1,'.','.',$cnum,undef, |
my %courses = &courseiddump($cdom,'.',1,'.','.',$cnum,undef, |
|
Line 6285 sub is_course {
|
Line 7736 sub is_course {
|
| return 0; |
return 0; |
| } |
} |
| |
|
| |
sub store_userdata { |
| |
my ($storehash,$datakey,$namespace,$udom,$uname) = @_; |
| |
my $result; |
| |
if ($datakey ne '') { |
| |
if (ref($storehash) eq 'HASH') { |
| |
if ($udom eq '' || $uname eq '') { |
| |
$udom = $env{'user.domain'}; |
| |
$uname = $env{'user.name'}; |
| |
} |
| |
my $uhome=&homeserver($uname,$udom); |
| |
if (($uhome eq '') || ($uhome eq 'no_host')) { |
| |
$result = 'error: no_host'; |
| |
} else { |
| |
$storehash->{'ip'} = $ENV{'REMOTE_ADDR'}; |
| |
$storehash->{'host'} = $perlvar{'lonHostID'}; |
| |
|
| |
my $namevalue=''; |
| |
foreach my $key (keys(%{$storehash})) { |
| |
$namevalue.=&escape($key).'='.&freeze_escape($$storehash{$key}).'&'; |
| |
} |
| |
$namevalue=~s/\&$//; |
| |
$result = &reply("store:$udom:$uname:$namespace:$datakey:". |
| |
$namevalue,$uhome); |
| |
} |
| |
} else { |
| |
$result = 'error: data to store was not a hash reference'; |
| |
} |
| |
} else { |
| |
$result= 'error: invalid requestkey'; |
| |
} |
| |
return $result; |
| |
} |
| |
|
| # ---------------------------------------------------------- Assign Custom Role |
# ---------------------------------------------------------- Assign Custom Role |
| |
|
| sub assigncustomrole { |
sub assigncustomrole { |
|
Line 6327 sub diskusage {
|
Line 7811 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 6339 sub is_locked {
|
Line 7823 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 6390 sub save_selected_files {
|
Line 7879 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 6400 sub files_in_path {
|
Line 7889 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 6422 sub files_not_in_path {
|
Line 7911 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 6770 sub dirlist {
|
Line 8259 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 6808 sub dirlist {
|
Line 8304 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 6846 sub GetFileTimestamp {
|
Line 8341 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 6882 sub stat_file {
|
Line 8379 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 7489 sub add_prefix_and_part {
|
Line 8989 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 7496 sub metadata {
|
Line 8997 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 =~ /^priv/ || $uri=~/home\/httpd\/html\/priv/) |
| && &Apache::lonxml::get_state('target') =~ /^(|meta)$/) { |
&& &Apache::lonxml::get_state('target') =~ /^(|meta)$/) { |
| return undef; |
return undef; |
| } |
} |
|
Line 7515 sub metadata {
|
Line 9016 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 7532 sub metadata {
|
Line 9037 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, |
| ('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 7598 sub metadata {
|
Line 9104 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 7626 sub metadata {
|
Line 9160 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 7702 sub metadata {
|
Line 9243 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 7774 sub devalidate_title_cache {
|
Line 9331 sub devalidate_title_cache {
|
| &devalidate_cache_new('title',$key); |
&devalidate_cache_new('title',$key); |
| } |
} |
| |
|
| |
# ------------------------------------------------- Get the title of a course |
| |
|
| |
sub current_course_title { |
| |
return $env{ 'course.' . $env{'request.course.id'} . '.description' }; |
| |
} |
| # ------------------------------------------------- Get the title of a resource |
# ------------------------------------------------- Get the title of a resource |
| |
|
| sub gettitle { |
sub gettitle { |
|
Line 7840 sub symblist {
|
Line 9402 sub symblist {
|
| if (($env{'request.course.fn'}) && (%newhash)) { |
if (($env{'request.course.fn'}) && (%newhash)) { |
| if (tie(%hash,'GDBM_File',$env{'request.course.fn'}.'_symb.db', |
if (tie(%hash,'GDBM_File',$env{'request.course.fn'}.'_symb.db', |
| &GDBM_WRCREAT(),0640)) { |
&GDBM_WRCREAT(),0640)) { |
| foreach my $url (keys %newhash) { |
foreach my $url (keys(%newhash)) { |
| next if ($url eq 'last_known' |
next if ($url eq 'last_known' |
| && $env{'form.no_update_last_known'}); |
&& $env{'form.no_update_last_known'}); |
| $hash{declutter($url)}=&encode_symb($mapname, |
$hash{declutter($url)}=&encode_symb($mapname, |
|
Line 7877 sub symbverify {
|
Line 9439 sub symbverify {
|
| |
|
| if (tie(%bighash,'GDBM_File',$env{'request.course.fn'}.'.db', |
if (tie(%bighash,'GDBM_File',$env{'request.course.fn'}.'.db', |
| &GDBM_READER(),0640)) { |
&GDBM_READER(),0640)) { |
| |
if (($thisurl =~ m{^/adm/wrapper/ext/}) || ($thisurl =~ m{^ext/})) { |
| |
$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) |
| foreach my $id (split(/\,/,$ids)) { |
foreach my $id (split(/\,/,$ids)) { |
| my ($mapid,$resid)=split(/\./,$id); |
my ($mapid,$resid)=split(/\./,$id); |
| |
if ($thisfn =~ m{^/adm/wrapper/ext/}) { |
| |
$symb =~ s/\?.+$//; |
| |
} |
| if ( |
if ( |
| &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 8164 sub getCODE {
|
Line 9734 sub getCODE {
|
| } |
} |
| return undef; |
return undef; |
| } |
} |
| |
# |
| |
# Determines the random seed for a specific context: |
| |
# |
| |
# parameters: |
| |
# symb - in course context the symb for the seed. |
| |
# course_id - The course id of the form domain_coursenum. |
| |
# domain - Domain for the user. |
| |
# course - Course for the user. |
| |
# cenv - environment of the course. |
| |
# |
| |
# NOTE: |
| |
# All parameters are picked out of the environment if missing |
| |
# or not defined. |
| |
# If a symb cannot be determined the current time is used instead. |
| |
# |
| |
# For a given well defined symb, courside, domain, username, |
| |
# and course environment, the seed is reproducible. |
| |
# |
| sub rndseed { |
sub rndseed { |
| my ($symb,$courseid,$domain,$username)=@_; |
my ($symb,$courseid,$domain,$username, $cenv)=@_; |
| my ($wsymb,$wcourseid,$wdomain,$wusername)=&whichuser(); |
my ($wsymb,$wcourseid,$wdomain,$wusername)=&whichuser(); |
| if (!defined($symb)) { |
if (!defined($symb)) { |
| unless ($symb=$wsymb) { return time; } |
unless ($symb=$wsymb) { return time; } |
|
Line 8174 sub rndseed {
|
Line 9761 sub rndseed {
|
| if (!$courseid) { $courseid=$wcourseid; } |
if (!$courseid) { $courseid=$wcourseid; } |
| if (!$domain) { $domain=$wdomain; } |
if (!$domain) { $domain=$wdomain; } |
| if (!$username) { $username=$wusername } |
if (!$username) { $username=$wusername } |
| my $which=&get_rand_alg(); |
|
| |
my $which; |
| |
if (defined($cenv->{'rndseed'})) { |
| |
$which = $cenv->{'rndseed'}; |
| |
} else { |
| |
$which =&get_rand_alg($courseid); |
| |
} |
| |
|
| if (defined(&getCODE())) { |
if (defined(&getCODE())) { |
| |
|
| if ($which eq '64bit5') { |
if ($which eq '64bit5') { |
| return &rndseed_CODE_64bit5($symb,$courseid,$domain,$username); |
return &rndseed_CODE_64bit5($symb,$courseid,$domain,$username); |
| } elsif ($which eq '64bit4') { |
} elsif ($which eq '64bit4') { |
|
Line 8630 sub filelocation {
|
Line 10224 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 8646 sub filelocation {
|
Line 10234 sub filelocation {
|
| my @ids=¤t_machine_ids(); |
my @ids=¤t_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 8655 sub filelocation {
|
Line 10243 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 = '/home/httpd/html/'.$space.$file; |
| } |
} |
| } |
} |
| $location=~s://+:/:g; # remove duplicate / |
$location=~s://+:/:g; # remove duplicate / |
|
Line 8684 sub hreflocation {
|
Line 10273 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; |
|
Line 8696 sub hreflocation {
|
Line 10283 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 8761 sub declutter {
|
Line 10352 sub declutter {
|
| $thisfn=~s|^adm/wrapper/||; |
$thisfn=~s|^adm/wrapper/||; |
| $thisfn=~s|^adm/coursedocs/showdoc/||; |
$thisfn=~s|^adm/coursedocs/showdoc/||; |
| $thisfn=~s/^res\///; |
$thisfn=~s/^res\///; |
| $thisfn=~s/\?.+$//; |
unless (($thisfn =~ /^ext/) || ($thisfn =~ /\.(page|sequence)___\d+___ext/)) { |
| |
$thisfn=~s/\?.+$//; |
| |
} |
| return $thisfn; |
return $thisfn; |
| } |
} |
| |
|
|
Line 8773 sub clutter {
|
Line 10366 sub clutter {
|
| || $thisfn =~ m{^/adm/(includes|pages)} ) { |
|| $thisfn =~ m{^/adm/(includes|pages)} ) { |
| $thisfn='/res'.$thisfn; |
$thisfn='/res'.$thisfn; |
| } |
} |
| if ($thisfn !~m|/adm|) { |
if ($thisfn !~m|^/adm|) { |
| if ($thisfn =~ m|/ext/|) { |
if ($thisfn =~ m|^/ext/|) { |
| $thisfn='/adm/wrapper'.$thisfn; |
$thisfn='/adm/wrapper'.$thisfn; |
| } else { |
} else { |
| my ($ext) = ($thisfn =~ /\.(\w+)$/); |
my ($ext) = ($thisfn =~ /\.(\w+)$/); |
|
Line 8882 sub get_dns {
|
Line 10475 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 8965 sub get_dns {
|
Line 10559 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 8988 sub get_dns {
|
Line 10589 sub get_dns {
|
| } else { |
} else { |
| $protocol{$id} = 'http'; |
$protocol{$id} = 'http'; |
| } |
} |
| |
if (defined($intdom)) { |
| |
$internetdom{$id} = $intdom; |
| |
} |
| } |
} |
| } |
} |
| } |
} |
|
Line 9049 sub get_dns {
|
Line 10653 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 9072 sub get_dns {
|
Line 10682 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 9086 sub get_dns {
|
Line 10701 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 9203 sub get_dns {
|
Line 10833 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,12*60*60); |
| |
} |
| |
|
| |
} |
| |
|
| |
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 9280 BEGIN {
|
Line 10944 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; |
| |
} |
| |
} |
| |
} |
| |
} |
| |
} |
| |
|
| |
# ---------------------------------------------------------- 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 9510 authentication scheme
|
Line 11237 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 9587 and course level
|
Line 11319 and course level
|
| |
|
| plaintext($short,$type,$cid,$forcedefault) : return value in %prp hash |
plaintext($short,$type,$cid,$forcedefault) : return value in %prp hash |
| (rolesplain.tab); plain text explanation of a user role term. |
(rolesplain.tab); plain text explanation of a user role term. |
| $type is Course (default) or Group. |
$type is Course (default) or Community. |
| If $forcedefault evaluates to true, text returned will be default |
If $forcedefault evaluates to true, text returned will be default |
| text for $type. Otherwise, if this is a course, the text returned |
text for $type. Otherwise, if this is a course, the text returned |
| will be a custom name for the role (if defined in the course's |
will be a custom name for the role (if defined in the course's |
|
Line 9634 modifyuserauth($udom,$uname,$umode,$upas
|
Line 11366 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 9764 revokecustomrole($udom,$uname,$url,$role
|
Line 11503 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 9797 database) for a course
|
Line 11557 database) for a course
|
| |
|
| =item * |
=item * |
| |
|
| createcourse($udom,$description,$url) : make/modify course |
createcourse($udom,$description,$url,$course_server,$nonstandard,$inst_code,$course_owner,$crstype,$cnum) : make course |
| |
|
| |
=item * |
| |
|
| |
generate_coursenum($udom,$crstype) : get a unique (unused) course number in domain $udom for course type $crstype (Course or Community). |
| |
|
| =back |
=back |
| |
|
|
Line 10095 or lonTabs/domain.tab.
|
Line 11859 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 10157 splitting on '&', supports elements that
|
Line 11996 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 10177 logperm() : append a permanent message t
|
Line 12017 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 10250 userfileupload(): main rotine for puttin
|
Line 12091 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 10273 returns: the new clean filename
|
Line 12116 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 * |
| |
|
![[BACK]](/icons/back.gif){kind=icon}
Return to lonnet.pm CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / loncom / lonnet / perl