[BACK]Return to lonnet.pm CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom / lonnet / perl

Diff for /loncom/lonnet/perl/lonnet.pm between versions 1.1056.4.25 and 1.1072

version 1.1056.4.25, 2011/05/14 17:16:49 version 1.1072, 2010/07/06 18:36:56
Line 76  use HTTP::Date; Line 76  use HTTP::Date;
 use Image::Magick;  use Image::Magick;
   
 use vars qw(%perlvar %spareid %pr %prp $memcache %packagetab $tmpdir  use vars qw(%perlvar %spareid %pr %prp $memcache %packagetab $tmpdir
             $_64bit %env %protocol %loncaparevs %serverhomeIDs %needsrelease);              $_64bit %env %protocol);
   
 my (%badServerCache, $memcache, %courselogs, %accesshash, %domainrolehash,  my (%badServerCache, $memcache, %courselogs, %accesshash, %domainrolehash,
     %userrolehash, $processmarker, $dumpcount, %coursedombuf,      %userrolehash, $processmarker, $dumpcount, %coursedombuf,
Line 95  use Math::Random; Line 95  use Math::Random;
 use File::MMagic;  use File::MMagic;
 use LONCAPA qw(:DEFAULT :match);  use LONCAPA qw(:DEFAULT :match);
 use LONCAPA::Configuration;  use LONCAPA::Configuration;
 use File::Copy;  
   
 my $readit;  my $readit;
 my $max_connection_retries = 10;     # Or some such value.  my $max_connection_retries = 10;     # Or some such value.
Line 196  sub get_server_timezone { Line 195  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,$ignore_cache,$caller) = @_;      my ($dom,$lonhost) = @_;
     if (defined($lonhost)) {      if (defined($lonhost)) {
         if (!defined(&hostname($lonhost))) {          if (!defined(&hostname($lonhost))) {
             undef($lonhost);              undef($lonhost);
Line 235  sub get_server_loncaparev { Line 211  sub get_server_loncaparev {
         }          }
     }      }
     if (defined($lonhost)) {      if (defined($lonhost)) {
         my $cachetime = 12*3600;          my $cachetime = 24*3600;
         if (!$ignore_cache) {          my ($loncaparev,$cached)=&is_cached_new('serverloncaparev',$lonhost);
             my ($loncaparev,$cached)=&is_cached_new('serverloncaparev',$lonhost);  
             if (defined($cached)) {  
                 return $loncaparev;  
             }  
         }  
         my ($answer,$loncaparev);  
         my @ids=&current_machine_ids();  
         if (grep(/^\Q$lonhost\E$/,@ids)) {  
             $answer = $perlvar{'lonVersion'};  
             if ($answer =~ /^[\'\"]?([\w.\-]+)[\'\"]?$/) {  
                 $loncaparev = $1;  
             }  
         } else {  
             $answer = &reply('serverloncaparev',$lonhost);  
             if (($answer eq 'unknown_cmd') || ($answer eq 'con_lost')) {  
                 if ($caller eq 'loncron') {  
                     my $ua=new LWP::UserAgent;  
                     $ua->timeout(4);  
                     my $protocol = $protocol{$lonhost};  
                     $protocol = 'http' if ($protocol ne 'https');  
                     my $url = $protocol.'://'.&hostname($lonhost).'/adm/about.html';  
                     my $request=new HTTP::Request('GET',$url);  
                     my $response=$ua->request($request);  
                     unless ($response->is_error()) {  
                         my $content = $response->content;  
                         if ($content =~ /<p>VERSION\:\s*([\w.\-]+)<\/p>/) {  
                             $loncaparev = $1;  
                         }  
                     }  
                 } else {  
                     $loncaparev = $loncaparevs{$lonhost};  
                 }  
             } elsif ($answer =~ /^[\'\"]?([\w.\-]+)[\'\"]?$/) {  
                 $loncaparev = $1;  
             }  
         }  
         return &do_cache_new('serverloncaparev',$lonhost,$loncaparev,$cachetime);  
     }  
 }  
   
 sub get_server_homeID {  
     my ($hostname,$ignore_cache,$caller) = @_;  
     unless ($ignore_cache) {  
         my ($serverhomeID,$cached)=&is_cached_new('serverhomeID',$hostname);  
         if (defined($cached)) {          if (defined($cached)) {
             return $serverhomeID;              return $loncaparev;
         }          } else {
     }              my $loncaparev = &reply('serverloncaparev',$lonhost);
     my $cachetime = 12*3600;              return &do_cache_new('serverloncaparev',$lonhost,$loncaparev,$cachetime);
     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);  
 }  }
   
 # -------------------------------------------------- Non-critical communication  # -------------------------------------------------- Non-critical communication
Line 748  sub userload { Line 665  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,$udom) = @_;      my ($loadpercent,$userloadpercent,$want_server_name) = @_;
     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);      
     if (($udom ne '') && (&domain($udom) ne '')) {  
         my $uprimary_id = &Apache::lonnet::domain($udom,'primary');  
         $uint_dom = &Apache::lonnet::internet_dom($uprimary_id);  
         my %udomdefaults = &Apache::lonnet::get_domain_defaults($udom);  
         $remotesessions = $udomdefaults{'remotesessions'};  
     }  
     foreach my $try_server (@{ $spareid{'primary'} }) {      foreach my $try_server (@{ $spareid{'primary'} }) {
         if ($uint_dom) {  
             next unless (&spare_can_host($udom,$uint_dom,$remotesessions,  
                                          $try_server));  
         }  
  ($spare_server, $lowest_load) =   ($spare_server, $lowest_load) =
     &compare_server_load($try_server, $spare_server, $lowest_load);      &compare_server_load($try_server, $spare_server, $lowest_load);
     }      }
Line 800  sub spareserver { Line 683  sub spareserver {
   
     if (!$found_server) {      if (!$found_server) {
  foreach my $try_server (@{ $spareid{'default'} }) {   foreach my $try_server (@{ $spareid{'default'} }) {
             if ($uint_dom) {  
                 next unless (&spare_can_host($udom,$uint_dom,$remotesessions,  
                                              $try_server));  
             }  
     ($spare_server, $lowest_load) =      ($spare_server, $lowest_load) =
  &compare_server_load($try_server, $spare_server, $lowest_load);   &compare_server_load($try_server, $spare_server, $lowest_load);
  }   }
Line 816  sub spareserver { Line 695  sub spareserver {
         }          }
         if (defined($spare_server)) {          if (defined($spare_server)) {
             my $hostname = &hostname($spare_server);              my $hostname = &hostname($spare_server);
             if (defined($hostname)) {              if (defined($hostname)) {  
         $spare_server = $protocol.'://'.$hostname;          $spare_server = $protocol.'://'.$hostname;
             }              }
         }          }
Line 831  sub compare_server_load { Line 710  sub compare_server_load {
     my $userloadans = &reply('userload',$try_server);      my $userloadans = &reply('userload',$try_server);
   
     if ($loadans !~ /\d/ && $userloadans !~ /\d/) {      if ($loadans !~ /\d/ && $userloadans !~ /\d/) {
         return; #didn't get a number from the server   return; #didn't get a number from the server
     }      }
   
     my $load;      my $load;
Line 874  sub has_user_session { Line 753  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) = @_;  
     my %domconfhash = &Apache::loncommon::get_domainconf($udom);  
     my %servers = &get_servers($udom);  
     my $lowest_load = 30000;  
     my ($login_host,$hostname);  
     foreach my $lonhost (keys(%servers)) {  
         my $loginvia = $domconfhash{$udom.'.login.loginvia_'.$lonhost};  
         if ($loginvia eq '') {  
             ($login_host, $lowest_load) =  
             &compare_server_load($lonhost, $login_host, $lowest_load);  
         }  
     }  
     if ($login_host ne '') {  
         $hostname = $servers{$login_host};  
     }  
     return ($login_host,$hostname);  
 }  
   
 # --------------------------------------------- Try to change a user's password  # --------------------------------------------- Try to change a user's password
   
 sub changepass {  sub changepass {
Line 953  sub queryauthenticate { Line 811  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,$clientcancheckhost)=@_;      my ($uname,$upass,$udom,$checkdefauth)=@_;
     $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 976  sub authenticate { Line 834  sub authenticate {
     return 'no_host';      return 'no_host';
         }          }
     }      }
     my $answer=reply("encrypt:auth:$udom:$uname:$upass:$checkdefauth:$clientcancheckhost",$uhome);      my $answer=reply("encrypt:auth:$udom:$uname:$upass:$checkdefauth",$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 994  sub authenticate { Line 852  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') {  
             if (ref($hostedsessions->{'excludedomain'}) eq 'ARRAY') {  
                 if (grep(/^\Q$udom\E$/,@{$hostedsessions->{'excludedomain'}})) {  
                     $canhost = 0;  
                 } else {  
                     $canhost = 1;  
                 }  
             }  
             if (ref($hostedsessions->{'includedomain'}) eq 'ARRAY') {  
                 if (grep(/^\Q$udom\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;  
 }  
   
 # ---------------------- 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 1548  sub get_domain_defaults { Line 1328  sub get_domain_defaults {
     my %domconfig =      my %domconfig =
          &Apache::lonnet::get_dom('configuration',['defaults','quotas',           &Apache::lonnet::get_dom('configuration',['defaults','quotas',
                                   'requestcourses','inststatus',                                    'requestcourses','inststatus',
                                   'coursedefaults','usersessions'],$domain);                                    'coursedefaults'],$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 1588  sub get_domain_defaults { Line 1368  sub get_domain_defaults {
             $domdefaults{$item} = $domconfig{'coursedefaults'}{$item};              $domdefaults{$item} = $domconfig{'coursedefaults'}{$item};
         }          }
     }      }
     if (ref($domconfig{'usersessions'}) eq 'HASH') {  
         if (ref($domconfig{'usersessions'}{'remote'}) eq 'HASH') {  
             $domdefaults{'remotesessions'} = $domconfig{'usersessions'}{'remote'};  
         }  
         if (ref($domconfig{'usersessions'}{'hosted'}) eq 'HASH') {  
             $domdefaults{'hostedsessions'} = $domconfig{'usersessions'}{'hosted'};  
         }  
     }  
     &Apache::lonnet::do_cache_new('domdefaults',$domain,\%domdefaults,      &Apache::lonnet::do_cache_new('domdefaults',$domain,\%domdefaults,
                                   $cachetime);                                    $cachetime);
     return %domdefaults;      return %domdefaults;
Line 1781  sub getsection { Line 1553  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 $extra = &freeze_escape({'skipcheck' => 1});      my %roleshash = &dump('roles',$udom,$unam,$courseid);
     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 2223  sub allowuploaded { Line 1994  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 2251  sub allowuploaded { Line 2020  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 2280  sub process_coursefile { Line 2048  sub process_coursefile {
             close($fh);              close($fh);
             if ($parser eq 'parse') {              if ($parser eq 'parse') {
                 my $mm = new File::MMagic;                  my $mm = new File::MMagic;
                 my $type = $mm->checktype_filename($filepath.'/'.$fname);                  my $mime_type = $mm->checktype_filename($filepath.'/'.$fname);
                 if ($type eq 'text/html') {                  if ($mime_type eq 'text/html') {
                     my $parse_result = &extract_embedded_items($filepath.'/'.$fname,$allfiles,$codebase);                      my $parse_result = &extract_embedded_items($filepath.'/'.$fname,$allfiles,$codebase);
                     unless ($parse_result eq 'ok') {                      unless ($parse_result eq 'ok') {
                         &logthis('Failed to parse '.$filepath.'/'.$fname.' for embedded media: '.$parse_result);                          &logthis('Failed to parse '.$filepath.'/'.$fname.' for embedded media: '.$parse_result);
                     }                      }
                 }                  }
                 if (ref($mimetype)) {  
                     $$mimetype = $type;  
                 }  
             }              }
             $fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,              $fetchresult= &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$file,
                                  $home);                                   $home);
Line 2405  sub resizeImage { Line 2170  sub resizeImage {
   
 # --------------- Take an uploaded file and put it into the userfiles directory  # --------------- Take an uploaded file and put it into the userfiles directory
 # input: $formname - the contents of the file are in $env{"form.$formname"}  # input: $formname - the contents of the file are in $env{"form.$formname"}
 #                    the desired filename is in $env{"form.$formname.filename"}  #                    the desired filenam is in $env{"form.$formname.filename"}
 #        $context - possible values: coursedoc, existingfile, overwrite,   #        $coursedoc - if true up to the current course
 #                                    canceloverwrite, or ''.  #                     if false
 #                   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 2422  sub resizeImage { Line 2183  sub resizeImage {
 #        $thumbheight - height (pixels) of thumbnail to make for uploaded image  #        $thumbheight - height (pixels) of thumbnail to make for uploaded image
 #        $resizewidth - width (pixels) to which to resize uploaded image  #        $resizewidth - width (pixels) to which to resize uploaded image
 #        $resizeheight - height (pixels) to which to resize uploaded image  #        $resizeheight - height (pixels) to which to resize uploaded image
 #        $mimetype - reference to scalar to accommodate mime type determined  
 #                    from File::MMagic if $parser = parse.  
 #   # 
 # output: url of file in userspace, or error: <message>   # output: url of file in userspace, or error: <message> 
 #             or /adm/notfound.html if failure to upload occurse  #             or /adm/notfound.html if failure to upload occurse
   
 sub userfileupload {  sub userfileupload {
     my ($formname,$context,$subdir,$parser,$allfiles,$codebase,$destuname,      my ($formname,$coursedoc,$subdir,$parser,$allfiles,$codebase,$destuname,
         $destudom,$thumbwidth,$thumbheight,$resizewidth,$resizeheight,$mimetype)=@_;          $destudom,$thumbwidth,$thumbheight,$resizewidth,$resizeheight)=@_;
     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'; }
     # Files uploaded to help request form, or uploaded to "create course" page are handled differently      chop($env{'form.'.$formname});
     if ((($formname eq 'screenshot') && ($subdir eq 'helprequests')) ||      if (($formname eq 'screenshot') && ($subdir eq 'helprequests')) { #files uploaded to help request form are handled differently
         (($formname eq 'coursecreatorxml') && ($subdir eq 'batchupload')) ||  
          ($context eq 'existingfile') || ($context eq 'canceloverwrite')) {  
         my $now = time;          my $now = time;
         my $filepath;          my $filepath = 'tmp/helprequests/'.$now;
         if (($formname eq 'screenshot') && ($subdir eq 'helprequests')) {          my @parts=split(/\//,$filepath);
              $filepath = 'tmp/helprequests/'.$now;          my $fullpath = $perlvar{'lonDaemons'};
         } elsif (($formname eq 'coursecreatorxml') && ($subdir eq 'batchupload')) {          for (my $i=0;$i<@parts;$i++) {
              $filepath = 'tmp/addcourse/'.$destudom.'/web/'.$env{'user.name'}.              $fullpath .= '/'.$parts[$i];
                          '_'.$env{'user.domain'}.'/pending';              if ((-e $fullpath)!=1) {
         } elsif (($context eq 'existingfile') || ($context eq 'canceloverwrite')) {                  mkdir($fullpath,0777);
             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;  
             }              }
         }          }
         # Create the directory if not present          open(my $fh,'>'.$fullpath.'/'.$fname);
           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 2487  sub userfileupload { Line 2225  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);
         if ($context eq 'existingfile') {          return $fullpath.'/'.$fname;
             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 ($context eq 'coursedoc') {      if ($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);                                           $resizewidth,$resizeheight);
         } 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,$mimetype);         $allfiles,$codebase);
         }          }
     } elsif (defined($destuname)) {      } elsif (defined($destuname)) {
         my $docuname=$destuname;          my $docuname=$destuname;
Line 2519  sub userfileupload { Line 2253  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);                                       $resizewidth,$resizeheight);
           
     } else {      } else {
         my $docuname=$env{'user.name'};          my $docuname=$env{'user.name'};
         my $docudom=$env{'user.domain'};          my $docudom=$env{'user.domain'};
Line 2530  sub userfileupload { Line 2265  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);                                       $resizewidth,$resizeheight);
     }      }
 }  }
   
 sub finishuserfileupload {  sub finishuserfileupload {
     my ($docuname,$docudom,$formname,$fname,$parser,$allfiles,$codebase,      my ($docuname,$docudom,$formname,$fname,$parser,$allfiles,$codebase,
         $thumbwidth,$thumbheight,$resizewidth,$resizeheight,$context,$mimetype) = @_;          $thumbwidth,$thumbheight,$resizewidth,$resizeheight) = @_;
     my $path=$docudom.'/'.$docuname.'/';      my $path=$docudom.'/'.$docuname.'/';
     my $filepath=$perlvar{'lonDocRoot'};      my $filepath=$perlvar{'lonDocRoot'};
       
Line 2562  sub finishuserfileupload { Line 2297  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 ($context eq 'overwrite') {   if (!print FH ($env{'form.'.$formname})) {
             my $source =  $perlvar{'lonDaemons'}.'/tmp/overwrites/'.$docudom.'/'.$docuname.'/'.$fname;  
             my $target = $filepath.'/'.$file;  
             if (-e $source) {  
                 my @info = stat($source);  
                 if ($info[9] eq $env{'form.timestamp'}) {  
                     unless (&File::Copy::move($source,$target)) {  
                         &logthis('Failed to overwrite '.$filepath.'/'.$file);  
                         return "Moving from $source failed";  
                     }  
                 } else {  
                     return "Temporary file: $source had unexpected date/time for last modification";  
                 }  
             } else {  
                 return "Temporary file: $source missing";  
             }  
  } elsif (!print FH ($env{'form.'.$formname})) {  
     &logthis('Failed to write to '.$filepath.'/'.$file);      &logthis('Failed to write to '.$filepath.'/'.$file);
     print STDERR ('Failed to write to '.$filepath.'/'.$file."\n");      print STDERR ('Failed to write to '.$filepath.'/'.$file."\n");
     return '/adm/notfound.html';      return '/adm/notfound.html';
Line 2594  sub finishuserfileupload { Line 2313  sub finishuserfileupload {
     }      }
     if ($parser eq 'parse') {      if ($parser eq 'parse') {
         my $mm = new File::MMagic;          my $mm = new File::MMagic;
         my $type = $mm->checktype_filename($filepath.'/'.$file);          my $mime_type = $mm->checktype_filename($filepath.'/'.$file);
         if ($type eq 'text/html') {          if ($mime_type eq 'text/html') {
             my $parse_result = &extract_embedded_items($filepath.'/'.$file,              my $parse_result = &extract_embedded_items($filepath.'/'.$file,
                                                        $allfiles,$codebase);                                                         $allfiles,$codebase);
             unless ($parse_result eq 'ok') {              unless ($parse_result eq 'ok') {
Line 2603  sub finishuserfileupload { Line 2322  sub finishuserfileupload {
            ' for embedded media: '.$parse_result);              ' for embedded media: '.$parse_result); 
             }              }
         }          }
         if (ref($mimetype)) {  
             $$mimetype = $type;  
         }  
     }      }
     if (($thumbwidth =~ /^\d+$/) && ($thumbheight =~ /^\d+$/)) {      if (($thumbwidth =~ /^\d+$/) && ($thumbheight =~ /^\d+$/)) {
         my $input = $filepath.'/'.$file;          my $input = $filepath.'/'.$file;
Line 3140  sub get_my_roles { Line 2856  sub get_my_roles {
     unless (defined($udom)) { $udom=$env{'user.domain'}; }      unless (defined($udom)) { $udom=$env{'user.domain'}; }
     my (%dumphash,%nothide);      my (%dumphash,%nothide);
     if ($context eq 'userroles') {       if ($context eq 'userroles') { 
         my $extra = &freeze_escape({'skipcheck' => 1});          %dumphash = &dump('roles',$udom,$uname);
         %dumphash = &dump('roles',$udom,$uname,'.',undef,$extra);  
     } else {      } else {
         %dumphash=          %dumphash=
             &dump('nohist_userroles',$udom,$uname);              &dump('nohist_userroles',$udom,$uname);
Line 3469  sub get_domain_roles { Line 3184  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 3505  sub set_first_access { Line 3220  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 4128  sub coursedescription { Line 3758  sub coursedescription {
     return %returnhash;      return %returnhash;
 }  }
   
 sub update_released_required {  
     my ($needsrelease,$cdom,$cnum,$chome,$cid) = @_;  
     if ($cdom eq '' || $cnum eq '' || $chome eq '' || $cid eq '') {  
         $cid = $env{'request.course.id'};  
         $cdom = $env{'course.'.$cid.'.domain'};  
         $cnum = $env{'course.'.$cid.'.num'};  
         $chome = $env{'course.'.$cid.'.home'};  
     }  
     if ($needsrelease) {  
         my %curr_reqd_hash = &userenvironment($cdom,$cnum,'internal.releaserequired');  
         my $needsupdate;  
         if ($curr_reqd_hash{'internal.releaserequired'} eq '') {  
             $needsupdate = 1;  
         } else {  
             my ($currmajor,$currminor) = split(/\./,$curr_reqd_hash{'internal.releaserequired'});  
             my ($needsmajor,$needsminor) = split(/\./,$needsrelease);  
             if (($currmajor < $needsmajor) || ($currmajor == $needsmajor && $currminor < $needsminor)) {  
                 $needsupdate = 1;  
             }  
         }  
         if ($needsupdate) {  
             my %needshash = (  
                              'internal.releaserequired' => $needsrelease,  
                             );  
             my $putresult = &put('environment',\%needshash,$cdom,$cnum);  
             if ($putresult eq 'ok') {  
                 &appenv({'course.'.$cid.'.internal.releaserequired' => $needsrelease});  
                 my %crsinfo = &courseiddump($cdom,'.',1,'.','.',$cnum,undef,undef,'.');  
                 if (ref($crsinfo{$cid}) eq 'HASH') {  
                     $crsinfo{$cid}{'releaserequired'} = $needsrelease;  
                     &courseidput($cdom,\%crsinfo,$chome,'notime');  
                 }  
             }  
         }  
     }  
     return;  
 }  
   
 # -------------------------------------------------See if a user is privileged  # -------------------------------------------------See if a user is privileged
   
 sub privileged {  sub privileged {
Line 4205  sub rolesinit { Line 3797  sub rolesinit {
     my ($domain,$username,$authhost)=@_;      my ($domain,$username,$authhost)=@_;
     my $now=time;      my $now=time;
     my %userroles = ('user.login.time' => $now);      my %userroles = ('user.login.time' => $now);
     my $extra = &freeze_escape({'skipcheck' => 1});      my $rolesdump=reply("dump:$domain:$username:roles",$authhost);
     my $rolesdump=reply("dump:$domain:$username:roles:.::$extra",$authhost);  
     if (($rolesdump eq 'con_lost') || ($rolesdump eq '') ||       if (($rolesdump eq 'con_lost') || ($rolesdump eq '') || 
         ($rolesdump =~ /^error:/)) {          ($rolesdump =~ /^error:/)) { 
         return \%userroles;          return \%userroles;
     }      }
     my %allroles=();      my %allroles=();
Line 4334  sub set_userprivs { Line 3925  sub set_userprivs {
     my $adv=0;      my $adv=0;
     my %grouproles = ();      my %grouproles = ();
     if (keys(%{$allgroups}) > 0) {      if (keys(%{$allgroups}) > 0) {
         my @groupkeys;          my @groupkeys; 
         foreach my $role (keys(%{$allroles})) {          foreach my $role (keys(%{$allroles})) {
             push(@groupkeys,$role);              push(@groupkeys,$role);
         }          }
Line 4410  sub role_status { Line 4001  sub role_status {
                             my %userroles = (                              my %userroles = (
                                 'user.role.'.$$role.'.'.$$where => $$tstart.'.'.$$tend                                  'user.role.'.$$role.'.'.$$where => $$tstart.'.'.$$tend
                             );                              );
                             @rolecodes = ('cm');                              @rolecodes = ('cm'); 
                             my $spec=$$role.'.'.$$where;                              my $spec=$$role.'.'.$$where;
                             my ($tdummy,$tdomain,$trest)=split(/\//,$$where);                              my ($tdummy,$tdomain,$trest)=split(/\//,$$where);
                             if ($$role =~ /^cr\//) {                              if ($$role =~ /^cr\//) {
Line 4427  sub role_status { Line 4018  sub role_status {
                                 my %course_roles = &get_my_roles($env{'user.name'},$env{'user.domain'},'userroles',['active'],['cc','co','in','ta','ep','ad','st','cr'],[$tdomain],1);                                  my %course_roles = &get_my_roles($env{'user.name'},$env{'user.domain'},'userroles',['active'],['cc','co','in','ta','ep','ad','st','cr'],[$tdomain],1);
                                 if (keys(%course_roles) > 0) {                                  if (keys(%course_roles) > 0) {
                                     my ($tnum) = ($trest =~ /^($match_courseid)/);                                      my ($tnum) = ($trest =~ /^($match_courseid)/);
                                     if ($tdomain ne '' && $tnum ne '') {                                      if ($tdomain ne '' && $tnum ne '') { 
                                         foreach my $key (keys(%course_roles)) {                                          foreach my $key (keys(%course_roles)) {
                                             if ($key =~ /^\Q$tnum\E:\Q$tdomain\E:([^:]+):?([^:]*)/) {                                              if ($key =~ /^\Q$tnum\E:\Q$tdomain\E:([^:]+):?([^:]*)/) {
                                                 my $crsrole = $1;                                                  my $crsrole = $1;
Line 4475  sub role_status { Line 4066  sub role_status {
 }  }
   
 sub check_adhoc_privs {  sub check_adhoc_privs {
     my ($cdom,$cnum,$then,$refresh,$now,$checkrole,$caller) = @_;      my ($cdom,$cnum,$then,$refresh,$now,$checkrole) = @_;
     my $cckey = 'user.role.'.$checkrole.'./'.$cdom.'/'.$cnum;      my $cckey = 'user.role.'.$checkrole.'./'.$cdom.'/'.$cnum;
     if ($env{$cckey}) {      if ($env{$cckey}) {
         my ($role,$where,$trolecode,$tstart,$tend,$tremark,$tstatus,$tpstart,$tpend);          my ($role,$where,$trolecode,$tstart,$tend,$tremark,$tstatus,$tpstart,$tpend);
         &role_status($cckey,$then,$refresh,$now,\$role,\$where,\$trolecode,\$tstatus,\$tstart,\$tend);          &role_status($cckey,$then,$refresh,$now,\$role,\$where,\$trolecode,\$tstatus,\$tstart,\$tend);
         unless (($tstatus eq 'is') || ($tstatus eq 'will_not')) {          unless (($tstatus eq 'is') || ($tstatus eq 'will_not')) {
             &set_adhoc_privileges($cdom,$cnum,$checkrole,$caller);              &set_adhoc_privileges($cdom,$cnum,$checkrole);
         }          }
     } else {      } else {
         &set_adhoc_privileges($cdom,$cnum,$checkrole,$caller);          &set_adhoc_privileges($cdom,$cnum,$checkrole);
     }      }
 }  }
   
 sub set_adhoc_privileges {  sub set_adhoc_privileges {
 # role can be cc or ca  # role can be cc or ca
     my ($dcdom,$pickedcourse,$role,$caller) = @_;      my ($dcdom,$pickedcourse,$role) = @_;
     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 4500  sub set_adhoc_privileges { Line 4091  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);
     unless ($caller eq 'constructaccess' && $env{'request.course.id'}) {      &appenv( {'request.role'        => $spec,
         &appenv( {'request.role'        => $spec,                'request.role.domain' => $dcdom,
                   'request.role.domain' => $dcdom,                'request.course.sec'  => ''
                   'request.course.sec'  => ''               }
                  }             );
                );      my $tadv=0;
         my $tadv=0;      if (&allowed('adv') eq 'F') { $tadv=1; }
         if (&allowed('adv') eq 'F') { $tadv=1; }      &appenv({'request.role.adv'    => $tadv});
         &appenv({'request.role.adv'    => $tadv});  
     }  
 }  }
   
 # --------------------------------------------------------------- get interface  # --------------------------------------------------------------- get interface
Line 4558  sub del { Line 4147  sub del {
 # -------------------------------------------------------------- dump interface  # -------------------------------------------------------------- dump interface
   
 sub dump {  sub dump {
     my ($namespace,$udomain,$uname,$regexp,$range,$extra)=@_;      my ($namespace,$udomain,$uname,$regexp,$range)=@_;
     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 4567  sub dump { Line 4156  sub dump {
     } else {      } else {
  $regexp='.';   $regexp='.';
     }      }
     my $rep=&reply("dump:$udomain:$uname:$namespace:$regexp:$range:$extra",$uhome);      my $rep=&reply("dump:$udomain:$uname:$namespace:$regexp:$range",$uhome);
     my @pairs=split(/\&/,$rep);      my @pairs=split(/\&/,$rep);
     my %returnhash=();      my %returnhash=();
     foreach my $item (@pairs) {      foreach my $item (@pairs) {
Line 5112  sub is_portfolio_file { Line 4701  sub is_portfolio_file {
 }  }
   
 sub usertools_access {  sub usertools_access {
     my ($uname,$udom,$tool,$action,$context,$userenvref,$domdefref,$is_advref) = @_;      my ($uname,$udom,$tool,$action,$context) = @_;
     my ($access,%tools);      my ($access,%tools);
     if ($context eq '') {      if ($context eq '') {
         $context = 'tools';          $context = 'tools';
Line 5154  sub usertools_access { Line 4743  sub usertools_access {
         $toolstatus = $env{'environment.'.$context.'.'.$tool};          $toolstatus = $env{'environment.'.$context.'.'.$tool};
         $inststatus = $env{'environment.inststatus'};          $inststatus = $env{'environment.inststatus'};
     } else {      } else {
         if (ref($userenvref) eq 'HASH') {          my %userenv = &userenvironment($udom,$uname,$context.'.'.$tool,'inststatus');
             $toolstatus = $userenvref->{$context.'.'.$tool};          $toolstatus = $userenv{$context.'.'.$tool};
             $inststatus = $userenvref->{'inststatus'};          $inststatus = $userenv{'inststatus'};
         } else {  
             my %userenv = &userenvironment($udom,$uname,$context.'.'.$tool,'inststatus');  
             $toolstatus = $userenv{$context.'.'.$tool};  
             $inststatus = $userenv{'inststatus'};  
         }  
     }      }
   
     if ($toolstatus ne '') {      if ($toolstatus ne '') {
Line 5173  sub usertools_access { Line 4757  sub usertools_access {
         return $access;          return $access;
     }      }
   
     my ($is_adv,%domdef);      my $is_adv = &is_advanced_user($udom,$uname);
     if (ref($is_advref) eq 'HASH') {      my %domdef = &get_domain_defaults($udom);
         $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 5257  sub is_course_owner { Line 4832  sub is_course_owner {
   
 sub is_advanced_user {  sub is_advanced_user {
     my ($udom,$uname) = @_;      my ($udom,$uname) = @_;
     if ($udom ne '' && $uname ne '') {  
         if (($udom eq $env{'user.domain'}) && ($uname eq $env{'user.name'})) {  
             return $env{'user.adv'};  
         }  
     }  
     my %roleshash = &get_my_roles($uname,$udom,'userroles',undef,undef,undef,1);      my %roleshash = &get_my_roles($uname,$udom,'userroles',undef,undef,undef,1);
     my %allroles;      my %allroles;
     my $is_adv;      my $is_adv;
Line 5777  sub allowed { Line 5347  sub allowed {
        my $unamedom=$env{'user.name'}.':'.$env{'user.domain'};         my $unamedom=$env{'user.name'}.':'.$env{'user.domain'};
        if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.roles.denied'}         if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.roles.denied'}
    =~/\Q$rolecode\E/) {     =~/\Q$rolecode\E/) {
            if (($priv ne 'pch') && ($priv ne 'plc')) {     if ($priv ne 'pch') { 
        &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 5787  sub allowed { Line 5357  sub allowed {
   
        if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.users.denied'}         if ($env{'course.'.$env{'request.course.id'}.'.'.$priv.'.users.denied'}
    =~/\Q$unamedom\E/) {     =~/\Q$unamedom\E/) {
            if (($priv ne 'pch') && ($priv ne 'plc')) {     if ($priv ne 'pch') { 
        &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 5801  sub allowed { Line 5371  sub allowed {
    if ($thisallowed=~/R/) {     if ($thisallowed=~/R/) {
        my $rolecode=(split(/\./,$env{'request.role'}))[0];         my $rolecode=(split(/\./,$env{'request.role'}))[0];
        if (&metadata($uri,'roledeny')=~/\Q$rolecode\E/) {         if (&metadata($uri,'roledeny')=~/\Q$rolecode\E/) {
            if (($priv ne 'pch') && ($priv ne 'plc')) {     if ($priv ne 'pch') { 
        &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 5984  sub update_allusers_table { Line 5554  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);
     return;      my $reply = &get_query_reply($queryid);
       return $reply;
 }  }
   
 # ------- Request retrieval of institutional classlists for course(s)  # ------- Request retrieval of institutional classlists for course(s)
Line 6154  sub auto_get_sections { Line 5725  sub auto_get_sections {
 }  }
   
 sub auto_new_course {  sub auto_new_course {
     my ($cnum,$cdom,$inst_course_id,$owner,$coowners) = @_;      my ($cnum,$cdom,$inst_course_id,$owner) = @_;
     my $homeserver = &homeserver($cnum,$cdom);      my $homeserver = &homeserver($cnum,$cdom);
     my $response=&unescape(&reply('autonewcourse:'.$inst_course_id.':'.&escape($owner).':'.$cdom.':'.&escape($coowners),$homeserver));      my $response=&unescape(&reply('autonewcourse:'.$inst_course_id.':'.$owner.':'.$cdom,$homeserver));
     return $response;      return $response;
 }  }
   
Line 6547  sub get_users_groups { Line 6118  sub get_users_groups {
     } else {        } else {  
         $grouplist = '';          $grouplist = '';
         my $courseurl = &courseid_to_courseurl($courseid);          my $courseurl = &courseid_to_courseurl($courseid);
         my $extra = &freeze_escape({'skipcheck' => 1});          my %roleshash = &dump('roles',$udom,$uname,$courseurl);
         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 6902  sub modifyuser { Line 6472  sub modifyuser {
     }      }
     &logthis('Call to modify user '.$udom.', '.$uname.', '.$uid.', '.      &logthis('Call to modify user '.$udom.', '.$uname.', '.$uid.', '.
              $umode.', '.$first.', '.$middle.', '.               $umode.', '.$first.', '.$middle.', '.
              $last.', '.$gene.'(forceid: '.$forceid.'; candelete: '.$showcandelete.')'.       $last.', '.$gene.'(forceid: '.$forceid.'; candelete: '.$showcandelete.')'.
              (defined($desiredhome) ? ' desiredhome = '.$desiredhome :               (defined($desiredhome) ? ' desiredhome = '.$desiredhome :
                                      ' desiredhome not specified').                                        ' desiredhome not specified'). 
              ' by '.$env{'user.name'}.' at '.$env{'user.domain'}.               ' by '.$env{'user.name'}.' at '.$env{'user.domain'}.
              ' 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 6964  sub modifyuser { Line 6530  sub modifyuser {
    ['firstname','middlename','lastname','generation','id',     ['firstname','middlename','lastname','generation','id',
                     'permanentemail','inststatus'],                      'permanentemail','inststatus'],
    $udom,$uname);     $udom,$uname);
     my (%names,%oldnames);      my %names;
     if ($tmp[0] =~ m/^error:.*/) {       if ($tmp[0] =~ m/^error:.*/) { 
         %names=();           %names=(); 
     } else {      } else {
         %names = @tmp;          %names = @tmp;
         %oldnames = %names;  
     }      }
 #  #
 # If name, email and/or uid are blank (e.g., because an uploaded file  # If name, email and/or uid are blank (e.g., because an uploaded file
Line 7023  sub modifyuser { Line 6588  sub modifyuser {
             }              }
         }          }
     }      }
     my $logmsg = $udom.', '.$uname.', '.$uid.', '.      my $reply = &put('environment', \%names, $udom,$uname);
       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 7373  sub store_userdata { Line 6916  sub store_userdata {
                     $namevalue.=&escape($key).'='.&freeze_escape($$storehash{$key}).'&';                      $namevalue.=&escape($key).'='.&freeze_escape($$storehash{$key}).'&';
                 }                  }
                 $namevalue=~s/\&$//;                  $namevalue=~s/\&$//;
                 $result =  &reply("store:$udom:$uname:$namespace:$datakey:".                  $result =  &reply("store:$env{'user.domain'}:$env{'user.name'}:".
                                   $namevalue,$uhome);                                    "$namespace:$datakey:$namevalue",$uhome);
             }              }
         } else {          } else {
             $result = 'error: data to store was not a hash reference';               $result = 'error: data to store was not a hash reference'; 
Line 7427  sub diskusage { Line 6970  sub diskusage {
 }  }
   
 sub is_locked {  sub is_locked {
     my ($file_name, $domain, $user, $which) = @_;      my ($file_name, $domain, $user) = @_;
     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 7439  sub is_locked { Line 6982  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';
                if (ref($which) eq 'ARRAY') {                 last;
                    push(@{$which},$entry);  
                } else {  
                    last;  
                }  
            }             }
        }         }
     } else {      } else {
         $is_locked = 'false';          $is_locked = 'false';
     }      }
     return $is_locked;  
 }  }
   
 sub declutter_portfile {  sub declutter_portfile {
Line 8594  sub add_prefix_and_part { Line 8132  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 8601  sub metadata { Line 8140  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{^/*uploaded/.+\.sequence$}) || ($uri =~ m{^/*uploaded/$match_domain/$match_courseid/docs/})) {          ($uri =~ m|/$|) || ($uri =~ m|/.meta$|) ) {
  return undef;   return undef;
     }      }
     if (($uri =~ /^~/ || $uri =~ m{home/$match_username/public_html/})       if (($uri =~ /^~/ || $uri =~ m{home/$match_username/public_html/}) 
Line 8620  sub metadata { Line 8159  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 8703  sub metadata { Line 8246  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 8731  sub metadata { Line 8302  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 8806  sub metadata { Line 8385  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 8991  sub symbverify { Line 8586  sub symbverify {
         }          }
         my $ids=$bighash{'ids_'.&clutter($thisurl)};          my $ids=$bighash{'ids_'.&clutter($thisurl)};
         unless ($ids) {           unless ($ids) { 
            my $idkey = 'ids_'.($thisurl =~ m{^/}? '' : '/').$thisurl;             $ids=$bighash{'ids_/'.$thisurl};
            $ids=$bighash{$idkey};  
         }          }
         if ($ids) {          if ($ids) {
 # ------------------------------------------------------------------- Has ID(s)  # ------------------------------------------------------------------- Has ID(s)
Line 9005  sub symbverify { Line 8599  sub symbverify {
   &symbclean(&declutter($bighash{'map_id_'.$mapid}).'___'.$resid.'___'.$thisfn)    &symbclean(&declutter($bighash{'map_id_'.$mapid}).'___'.$resid.'___'.$thisfn)
    eq $symb) {      eq $symb) { 
    if (($env{'request.role.adv'}) ||     if (($env{'request.role.adv'}) ||
        ($bighash{'encrypted_'.$id} eq $env{'request.enc'}) ||         $bighash{'encrypted_'.$id} eq $env{'request.enc'}) {
        ($thisurl eq '/adm/navmaps')) {  
        $okay=1;          $okay=1; 
    }     }
        }         }
Line 10084  sub get_dns { Line 9677  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);
             chomp($configline);      next if ($configline =~ /^\^/);
             if ($configline =~ /^\^/) {      chomp($configline);
                 if ($configline =~ /^\^([\w.\-]+)/) {      my ($id,$domain,$role,$name,$protocol)=split(/:/,$configline);
                     $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 10114  sub get_dns { Line 9700  sub get_dns {
                 } else {                  } else {
                     $protocol{$id} = 'http';                      $protocol{$id} = 'http';
                 }                  }
                 if (defined($intdom)) {  
                     $internetdom{$id} = $intdom;  
                 }  
     }      }
  }   }
     }      }
Line 10179  sub get_dns { Line 9762  sub get_dns {
     }      }
   
     sub unique_library {      sub unique_library {
         #2x reverse removes all hostnames that appear more than once   #2x reverse removes all hostnames that appear more than once
         my %unique = reverse &all_library();          my %unique = reverse &all_library();
         return reverse %unique;          return reverse %unique;
     }      }
Line 10209  sub get_dns { Line 9792  sub get_dns {
   
     sub get_unique_servers {      sub get_unique_servers {
         my %unique = reverse &get_servers(@_);          my %unique = reverse &get_servers(@_);
         return reverse %unique;   return reverse %unique;
     }      }
   
     sub host_domain {      sub host_domain {
Line 10226  sub get_dns { Line 9809  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};  
     }  
 }  }
   
 {   { 
Line 10350  sub get_dns { Line 9926  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 10461  BEGIN { Line 10003  BEGIN {
     close($config);      close($config);
 }  }
   
 # ---------------------------------------------------------- Read loncaparev table  
 {  
     if (-e "$perlvar{'lonTabDir'}/loncaparevs.tab") {  
         if (open(my $config,"<$perlvar{'lonTabDir'}/loncaparevs.tab")) {  
             while (my $configline=<$config>) {  
                 chomp($configline);  
                 my ($hostid,$loncaparev)=split(/:/,$configline);  
                 $loncaparevs{$hostid}=$loncaparev;  
             }  
             close($config);  
         }  
     }  
 }  
   
 # ---------------------------------------------------------- Read serverhostID table  
 {  
     if (-e "$perlvar{'lonTabDir'}/serverhomeIDs.tab") {  
         if (open(my $config,"<$perlvar{'lonTabDir'}/serverhomeIDs.tab")) {  
             while (my $configline=<$config>) {  
                 chomp($configline);  
                 my ($name,$id)=split(/:/,$configline);  
                 $serverhomeIDs{$name}=$id;  
             }  
             close($config);  
         }  
     }  
 }  
   
 {  
     my $file = $Apache::lonnet::perlvar{'lonTabDir'}.'/releaseslist.xml';  
     if (-e $file) {  
         my $parser = HTML::LCParser->new($file);  
         while (my $token = $parser->get_token()) {  
             if ($token->[0] eq 'S') {  
                 my $item = $token->[1];  
                 my $name = $token->[2]{'name'};  
                 my $value = $token->[2]{'value'};  
                 if ($item ne '' && $name ne '' && $value ne '') {  
                     my $release = $parser->get_text();  
                     $release =~ s/(^\s*|\s*$ )//gx;  
                     $needsrelease{$item.':'.$name.':'.$value} = $release;  
                 }  
             }  
         }  
     }  
 }  
   
 # ------------- set up temporary directory  # ------------- set up temporary directory
 {  {
     $tmpdir = $perlvar{'lonDaemons'}.'/tmp/';      $tmpdir = $perlvar{'lonDaemons'}.'/tmp/';
Line 10738  authentication scheme Line 10233  authentication scheme
   
 =item *  =item *
 X<authenticate()>  X<authenticate()>
 B<authenticate($uname,$upass,$udom,$checkdefauth,$clientcancheckhost)>: try to  B<authenticate($uname,$upass,$udom)>: 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 11494  userfileupload(): main rotine for puttin Line 10984  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}
  context - if coursedoc, store the file in the course of the active role   coursedoc - if true, 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 11519  returns: the new clean filename Line 11007  returns: the new clean filename
   
 =item *  =item *
   
 finishuserfileupload(): routine that creates and sends the file to  finishuserfileupload(): routine that creaes 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 (including subdirectories) for the file    fname: filename (inculding 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 (or an error message if context    and /adm/notfound.html if unsuccessful
  was 'overwrite').  
   
   
 =item *  =item *
   
Removed from v.1.1056.4.25  
changed lines
  Added in v.1.1072

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