[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.70 and 1.132

version 1.70, 2000/11/25 19:56:04 version 1.132, 2001/07/26 20:44:42
Line 3 Line 3
 #  #
 # Functions for use by content handlers:  # Functions for use by content handlers:
 #  #
   # metadata_query(sql-query-string,custom-metadata-regex) : 
   #                                    returns file handle of where sql and
   #                                    regex results will be stored for query
 # plaintext(short)   : plain text explanation of short term  # plaintext(short)   : plain text explanation of short term
 # fileembstyle(ext)  : embed style in page for file extension  # fileembstyle(ext)  : embed style in page for file extension
 # filedescription(ext) : descriptor text for file extension  # filedescription(ext) : descriptor text for file extension
Line 13 Line 16
 #                      1: user needs to choose course  #                      1: user needs to choose course
 #                      2: browse allowed  #                      2: browse allowed
 # definerole(rolename,sys,dom,cou) : define a custom role rolename  # definerole(rolename,sys,dom,cou) : define a custom role rolename
 #                      set priviledges in format of lonTabs/roles.tab for  #                      set privileges in format of lonTabs/roles.tab for
 #                      system, domain and course level,   #                      system, domain and course level, 
 # assignrole(udom,uname,url,role,end,start) : give a role to a user for the  # assignrole(udom,uname,url,role,end,start) : give a role to a user for the
 #                      level given by url. Optional start and end dates  #                      level given by url. Optional start and end dates
Line 25 Line 28
 # revokecustomrole (udom,uname,url,rdom,rnam,rolename) : Revoke a custom role  # revokecustomrole (udom,uname,url,rdom,rnam,rolename) : Revoke a custom role
 # appenv(hash)       : adds hash to session environment  # appenv(hash)       : adds hash to session environment
 # delenv(varname)    : deletes all environment entries starting with varname  # delenv(varname)    : deletes all environment entries starting with varname
 # store(hash)        : stores hash permanently for this url  # store(hashref,symb,courseid,udom,uname)
 # cstore(hash)       : critical store  #                    : stores hash permanently for this url
 # restore            : returns hash for this url  #                      hashref needs to be given, and should be a \%hashname
   #                      the remaining args aren't required and if they aren't
   #                      passed or are '' they will be derived from the ENV
   # cstore(hashref,symb,courseid,udom,uname)
   #                    : same as store but uses the critical interface to 
   #                      guarentee a store
   # restore(symb,courseid,udom,uname)
   #                    : returns hash for this symb, all args are optional
   #                      if they aren't given they will be derived from the 
   #                      current enviroment
 # eget(namesp,array) : returns hash with keys from array filled in from namesp  # eget(namesp,array) : returns hash with keys from array filled in from namesp
 # get(namesp,array)  : returns hash with keys from array filled in from namesp  # get(namesp,arrayref,udom,uname)
   #                    : returns hash with keys from array  reference filled
   #                      in from namesp
   #                           if supplied uses udom as the domain and uname
   #                           as the username for the dump (supply a courseid
   #                           for the uname if you want a course database)
   #                           if not supplied it uses %ENV to get the values
 # del(namesp,array)  : deletes keys out of array from namesp  # del(namesp,array)  : deletes keys out of array from namesp
 # put(namesp,hash)   : stores hash in namesp  # put(namesp,hash)   : stores hash in namesp
 # cput(namesp,hash)  : critical put  # cput(namesp,hash)  : critical put
 # dump(namesp)       : dumps the complete namespace into a hash  # dump(namesp,udom,uname) : dumps the complete namespace into a hash
   #                           if supplied uses udom as the domain and uname
   #                           as the username for the dump (supply a courseid
   #                           for the uname if you want a course database)
   #                           if not supplied it uses %ENV to get the values
 # ssi(url,hash)      : does a complete request cycle on url to localhost, posts  # ssi(url,hash)      : does a complete request cycle on url to localhost, posts
 #                      hash  #                      hash
 # coursedescription(id) : returns and caches course description for id  # coursedescription(id) : returns and caches course description for id
Line 45 Line 67
 # EXT(name)          : value of a variable  # EXT(name)          : value of a variable
 # symblist(map,hash) : Updates symbolic storage links  # symblist(map,hash) : Updates symbolic storage links
 # symbread([filename]) : returns the data handle (filename optional)  # symbread([filename]) : returns the data handle (filename optional)
 # rndseed()          : returns a random seed    # rndseed()          : returns a random seed 
   # receipt()          : returns a receipt to be given out to users 
 # getfile(filename)  : returns the contents of filename, or a -1 if it can't  # getfile(filename)  : returns the contents of filename, or a -1 if it can't
 #                      be found, replicates and subscribes to the file  #                      be found, replicates and subscribes to the file
 # filelocation(dir,file) : returns a farily clean absolute reference to file   # filelocation(dir,file) : returns a fairly clean absolute reference to file 
 #                          from the directory dir  #                          from the directory dir
 # hreflocation(dir,file) : same as filelocation, but for hrefs  # hreflocation(dir,file) : same as filelocation, but for hrefs
 # log(domain,user,home,msg) : write to permanent log for user  # log(domain,user,home,msg) : write to permanent log for user
Line 61 Line 84
 #                      an array of IDs  #                      an array of IDs
 # idrget(domain,array): returns hash with IDs for usernames (name=>id,...) for  # idrget(domain,array): returns hash with IDs for usernames (name=>id,...) for
 #                       an array of names  #                       an array of names
   # metadata(file,entry): returns the metadata entry for a file. entry='keys'
   #                       returns a comma separated list of keys
 #  #
 # 6/1/99,6/2,6/10,6/11,6/12,6/14,6/26,6/28,6/29,6/30,  # 6/1/99,6/2,6/10,6/11,6/12,6/14,6/26,6/28,6/29,6/30,
 # 7/1,7/2,7/9,7/10,7/12,7/14,7/15,7/19,  # 7/1,7/2,7/9,7/10,7/12,7/14,7/15,7/19,
Line 76 Line 101
 # 10/04 Gerd Kortemeyer  # 10/04 Gerd Kortemeyer
 # 10/04 Guy Albertelli  # 10/04 Guy Albertelli
 # 10/06,10/09,10/10,10/11,10/14,10/20,10/23,10/25,10/26,10/27,10/28,10/29,   # 10/06,10/09,10/10,10/11,10/14,10/20,10/23,10/25,10/26,10/27,10/28,10/29, 
 # 10/30,10/31,11/2,11/14,11/15,11/16,11/20,11/21,11/22,11/25 Gerd Kortemeyer  # 10/30,10/31,
   # 11/2,11/14,11/15,11/16,11/20,11/21,11/22,11/25,11/27,
   # 12/02,12/12,12/13,12/14,12/28,12/29 Gerd Kortemeyer
   # 05/01/01 Guy Albertelli
   # 05/01,06/01,09/01 Gerd Kortemeyer
   # 09/01 Guy Albertelli
   # 09/01,10/01,11/01 Gerd Kortemeyer
   # 02/27/01 Scott Harrison
   # 3/2 Gerd Kortemeyer
   # 3/15,3/19 Scott Harrison
   # 3/19,3/20 Gerd Kortemeyer
   # 3/22,3/27,4/2,4/16,4/17 Scott Harrison
   # 5/26,5/28 Gerd Kortemeyer
   # 5/30 H. K. Ng
   # 6/1 Gerd Kortemeyer
   #
   
 package Apache::lonnet;  package Apache::lonnet;
   
Line 85  use Apache::File; Line 125  use Apache::File;
 use LWP::UserAgent();  use LWP::UserAgent();
 use HTTP::Headers;  use HTTP::Headers;
 use vars   use vars 
 qw(%perlvar %hostname %homecache %spareid %hostdom %libserv %pr %prp %fe %fd $readit);  qw(%perlvar %hostname %homecache %spareid %hostdom %libserv %pr %prp %fe %fd $readit %metacache);
 use IO::Socket;  use IO::Socket;
 use GDBM_File;  use GDBM_File;
 use Apache::Constants qw(:common :http);  use Apache::Constants qw(:common :http);
   use HTML::TokeParser;
   use Fcntl qw(:flock);
   
 # --------------------------------------------------------------------- Logging  # --------------------------------------------------------------------- Logging
   
Line 171  sub reconlonc { Line 213  sub reconlonc {
   
 sub critical {  sub critical {
     my ($cmd,$server)=@_;      my ($cmd,$server)=@_;
       unless ($hostname{$server}) {
           &logthis("<font color=blue>WARNING:".
                  " Critical message to unknown server ($server)</font>");
           return 'no_such_host';
       }
     my $answer=reply($cmd,$server);      my $answer=reply($cmd,$server);
     if ($answer eq 'con_lost') {      if ($answer eq 'con_lost') {
         my $pingreply=reply('ping',$server);          my $pingreply=reply('ping',$server);
Line 229  sub appenv { Line 276  sub appenv {
             $ENV{$_}=$newenv{$_};              $ENV{$_}=$newenv{$_};
         }          }
     } keys %newenv;      } keys %newenv;
   
       my $lockfh;
       unless ($lockfh=Apache::File->new("$ENV{'user.environment'}")) {
          return 'error: '.$!;
       }
       unless (flock($lockfh,LOCK_EX)) {
            &logthis("<font color=blue>WARNING: ".
                     'Could not obtain exclusive lock in appenv: '.$!);
            $lockfh->close();
            return 'error: '.$!;
       }
   
     my @oldenv;      my @oldenv;
     {      {
      my $fh;       my $fh;
      unless ($fh=Apache::File->new("$ENV{'user.environment'}")) {       unless ($fh=Apache::File->new("$ENV{'user.environment'}")) {
  return 'error';   return 'error: '.$!;
      }       }
      @oldenv=<$fh>;       @oldenv=<$fh>;
        $fh->close();
     }      }
     for (my $i=0; $i<=$#oldenv; $i++) {      for (my $i=0; $i<=$#oldenv; $i++) {
         chomp($oldenv[$i]);          chomp($oldenv[$i]);
Line 255  sub appenv { Line 315  sub appenv {
      foreach $newname (keys %newenv) {       foreach $newname (keys %newenv) {
  print $fh "$newname=$newenv{$newname}\n";   print $fh "$newname=$newenv{$newname}\n";
      }       }
        $fh->close();
     }      }
   
       $lockfh->close();
     return 'ok';      return 'ok';
 }  }
 # ----------------------------------------------------- Delete from Environment  # ----------------------------------------------------- Delete from Environment
Line 274  sub delenv { Line 337  sub delenv {
      unless ($fh=Apache::File->new("$ENV{'user.environment'}")) {       unless ($fh=Apache::File->new("$ENV{'user.environment'}")) {
  return 'error';   return 'error';
      }       }
        unless (flock($fh,LOCK_SH)) {
            &logthis("<font color=blue>WARNING: ".
                     'Could not obtain shared lock in delenv: '.$!);
            $fh->close();
            return 'error: '.$!;
        }
      @oldenv=<$fh>;       @oldenv=<$fh>;
        $fh->close();
     }      }
     {      {
      my $fh;       my $fh;
      unless ($fh=Apache::File->new(">$ENV{'user.environment'}")) {       unless ($fh=Apache::File->new(">$ENV{'user.environment'}")) {
  return 'error';   return 'error';
      }       }
        unless (flock($fh,LOCK_EX)) {
            &logthis("<font color=blue>WARNING: ".
                     'Could not obtain exclusive lock in delenv: '.$!);
            $fh->close();
            return 'error: '.$!;
        }
      map {       map {
  unless ($_=~/^$delthis/) { print $fh $_; }   unless ($_=~/^$delthis/) { print $fh $_; }
      } @oldenv;       } @oldenv;
        $fh->close();
     }      }
     return 'ok';      return 'ok';
 }  }
Line 378  sub idget { Line 455  sub idget {
           $idlist=~tr/A-Z/a-z/;             $idlist=~tr/A-Z/a-z/; 
   my $reply=&reply("idget:$udom:".$idlist,$tryserver);    my $reply=&reply("idget:$udom:".$idlist,$tryserver);
           my @answer=();            my @answer=();
           if ($reply ne 'con_lost') {            if (($reply ne 'con_lost') && ($reply!~/^error\:/)) {
       @answer=split(/\&/,$reply);        @answer=split(/\&/,$reply);
           }                    ;            }                    ;
           my $i;            my $i;
Line 576  sub log { Line 653  sub log {
     return critical("log:$dom:$nam:$what",$hom);      return critical("log:$dom:$nam:$what",$hom);
 }  }
   
   # --------------------------------------------- Set Expire Date for Spreadsheet
   
   sub expirespread {
       my ($uname,$udom,$stype,$usymb)=@_;
       my $cid=$ENV{'request.course.id'}; 
       if ($cid) {
          my $now=time;
          my $key=$uname.':'.$udom.':'.$stype.':'.$usymb;
          return &reply('put:'.$ENV{'course.'.$cid.'.domain'}.':'.
                               $ENV{'course.'.$cid.'.num'}.
               ':nohist_expirationdates:'.
                               &escape($key).'='.$now,
                               $ENV{'course.'.$cid.'.home'})
       }
       return 'ok';
   }
   
   # ----------------------------------------------------- Devalidate Spreadsheets
   
   sub devalidate {
       my $symb=shift;
       my $cid=$ENV{'request.course.id'}; 
       if ($cid) {
    my $key=$ENV{'user.name'}.':'.$ENV{'user.domain'}.':';
           my $status=
             &reply('del:'.$ENV{'course.'.$cid.'.domain'}.':'.
                           $ENV{'course.'.$cid.'.num'}.
                   ':nohist_calculatedsheets:'.
                           &escape($key.'studentcalc:'),
                           $ENV{'course.'.$cid.'.home'})
             .' '.
             &reply('del:'.$ENV{'user.domain'}.':'.
                           $ENV{'user.name'}.
           ':nohist_calculatedsheets_'.$cid.':'.
                           &escape($key.'assesscalc:'.$symb),
                           $ENV{'user.home'});
           unless ($status eq 'ok ok') {
              &logthis('Could not devalidate spreadsheet '.
                       $ENV{'user.name'}.' at '.$ENV{'user.domain'}.' for '.
       $symb.': '.$status);
           } 
       }
   }
   
 # ----------------------------------------------------------------------- Store  # ----------------------------------------------------------------------- Store
   
 sub store {  sub store {
     my %storehash=@_;      my ($storehash,$symb,$namespace,$domain,$stuname) = @_;
     my $symb;      my $home='';
     unless ($symb=escape(&symbread())) { return ''; }  
     my $namespace;      if ($stuname) {
     unless ($namespace=$ENV{'request.course.id'}) { return ''; }   $home=&homeserver($stuname,$domain);
       }
   
       if (!$symb) { unless ($symb=&symbread()) { return ''; } }
   
       &devalidate($symb);
   
       $symb=escape($symb);
       if (!$namespace) { unless ($namespace=$ENV{'request.course.id'}) { return ''; } }
       if (!$domain) { $domain=$ENV{'user.domain'}; }
       if (!$stuname) { $stuname=$ENV{'user.name'}; }
       if (!$home) { $home=$ENV{'user.home'}; }
     my $namevalue='';      my $namevalue='';
     map {      map {
         $namevalue.=escape($_).'='.escape($storehash{$_}).'&';          $namevalue.=escape($_).'='.escape($$storehash{$_}).'&';
     } keys %storehash;      } keys %$storehash;
     $namevalue=~s/\&$//;      $namevalue=~s/\&$//;
     return reply(      return reply("store:$domain:$stuname:$namespace:$symb:$namevalue","$home");
      "store:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$symb:$namevalue",  
  "$ENV{'user.home'}");  
 }  }
   
 # -------------------------------------------------------------- Critical Store  # -------------------------------------------------------------- Critical Store
   
 sub cstore {  sub cstore {
     my %storehash=@_;      my ($storehash,$symb,$namespace,$domain,$stuname) = @_;
     my $symb;      my $home='';
     unless ($symb=escape(&symbread())) { return ''; }  
     my $namespace;      if ($stuname) {
     unless ($namespace=$ENV{'request.course.id'}) { return ''; }   $home=&homeserver($stuname,$domain);
       }
   
       if (!$symb) { unless ($symb=&symbread()) { return ''; } }
   
       &devalidate($symb);
   
       $symb=escape($symb);
       if (!$namespace) { unless ($namespace=$ENV{'request.course.id'}) { return ''; } }
       if (!$domain) { $domain=$ENV{'user.domain'}; }
       if (!$stuname) { $stuname=$ENV{'user.name'}; }
       if (!$home) { $home=$ENV{'user.home'}; }
   
     my $namevalue='';      my $namevalue='';
     map {      map {
         $namevalue.=escape($_).'='.escape($storehash{$_}).'&';          $namevalue.=escape($_).'='.escape($$storehash{$_}).'&';
     } keys %storehash;      } keys %$storehash;
     $namevalue=~s/\&$//;      $namevalue=~s/\&$//;
     return critical(      return critical("store:$domain:$stuname:$namespace:$symb:$namevalue","$home");
      "store:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$symb:$namevalue",  
  "$ENV{'user.home'}");  
 }  }
   
 # --------------------------------------------------------------------- Restore  # --------------------------------------------------------------------- Restore
   
 sub restore {  sub restore {
     my $symb;      my ($symb,$namespace,$domain,$stuname) = @_;
     unless ($symb=escape(&symbread())) { return ''; }      my $home='';
     my $namespace;  
     unless ($namespace=$ENV{'request.course.id'}) { return ''; }      if ($stuname) {
     my $answer=reply(   $home=&homeserver($stuname,$domain);
               "restore:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$symb",      }
               "$ENV{'user.home'}");  
       if (!$symb) {
         unless ($symb=escape(&symbread())) { return ''; }
       } else {
         $symb=&escape($symb);
       }
       if (!$namespace) { unless ($namespace=$ENV{'request.course.id'}) { return ''; } }
       if (!$domain) { $domain=$ENV{'user.domain'}; }
       if (!$stuname) { $stuname=$ENV{'user.name'}; }
       if (!$home) { $home=$ENV{'user.home'}; }
       my $answer=&reply("restore:$domain:$stuname:$namespace:$symb","$home");
   
     my %returnhash=();      my %returnhash=();
     map {      map {
  my ($name,$value)=split(/\=/,$_);   my ($name,$value)=split(/\=/,$_);
         $returnhash{&unescape($name)}=&unescape($value);          $returnhash{&unescape($name)}=&unescape($value);
     } split(/\&/,$answer);      } split(/\&/,$answer);
     map {      my $version;
         $returnhash{$_}=$returnhash{$returnhash{'version'}.':'.$_};      for ($version=1;$version<=$returnhash{'version'};$version++) {
     } split(/\:/,$returnhash{$returnhash{'version'}.':keys'});         map {
             $returnhash{$_}=$returnhash{$version.':'.$_};
          } split(/\:/,$returnhash{$version.':keys'});
       }
     return %returnhash;      return %returnhash;
 }  }
   
Line 640  sub coursedescription { Line 794  sub coursedescription {
     $courseid=~s/^\///;      $courseid=~s/^\///;
     $courseid=~s/\_/\//g;      $courseid=~s/\_/\//g;
     my ($cdomain,$cnum)=split(/\//,$courseid);      my ($cdomain,$cnum)=split(/\//,$courseid);
     my $chome=homeserver($cnum,$cdomain);      my $chome=&homeserver($cnum,$cdomain);
     if ($chome ne 'no_host') {      if ($chome ne 'no_host') {
        my $rep=reply("dump:$cdomain:$cnum:environment",$chome);         my %returnhash=&dump('environment',$cdomain,$cnum);
        if ($rep ne 'con_lost') {         if (!exists($returnhash{'con_lost'})) {
            my $normalid=$courseid;             my $normalid=$cdomain.'_'.$cnum;
            $normalid=~s/\//\_/g;  
            my %envhash=();             my %envhash=();
            my %returnhash=('home'   => $chome,              $returnhash{'home'}= $chome;
                            'domain' => $cdomain,     $returnhash{'domain'} = $cdomain;
                            'num'    => $cnum);     $returnhash{'num'} = $cnum;
            map {             while (my ($name,$value) = each %returnhash) {
                my ($name,$value)=split(/\=/,$_);  
                $name=&unescape($name);  
                $value=&unescape($value);  
                $returnhash{$name}=$value;  
                $envhash{'course.'.$normalid.'.'.$name}=$value;                 $envhash{'course.'.$normalid.'.'.$name}=$value;
            } split(/\&/,$rep);             }
            $returnhash{'url'}='/res/'.declutter($returnhash{'url'});             $returnhash{'url'}='/res/'.declutter($returnhash{'url'});
            $returnhash{'fn'}=$perlvar{'lonDaemons'}.'/tmp/'.             $returnhash{'fn'}=$perlvar{'lonDaemons'}.'/tmp/'.
        $ENV{'user.name'}.'_'.$cdomain.'_'.$cnum;         $ENV{'user.name'}.'_'.$cdomain.'_'.$cnum;
Line 671  sub coursedescription { Line 820  sub coursedescription {
     return ();      return ();
 }  }
   
 # -------------------------------------------------------- Get user priviledges  # -------------------------------------------------------- Get user privileges
   
 sub rolesinit {  sub rolesinit {
     my ($domain,$username,$authhost)=@_;      my ($domain,$username,$authhost)=@_;
Line 741  sub rolesinit { Line 890  sub rolesinit {
             }              }
           }             } 
         } split(/&/,$rolesdump);          } split(/&/,$rolesdump);
           my $adv=0;
           my $author=0;
         map {          map {
             %thesepriv=();              %thesepriv=();
               if ($_!~/^st/) { $adv=1; }
               if (($_=~/^au/) || ($_=~/^ca/)) { $author=1; }
             map {              map {
                 if ($_ ne '') {                  if ($_ ne '') {
     my ($priviledge,$restrictions)=split(/&/,$_);      my ($privilege,$restrictions)=split(/&/,$_);
                     if ($restrictions eq '') {                      if ($restrictions eq '') {
  $thesepriv{$priviledge}='F';   $thesepriv{$privilege}='F';
                     } else {                      } else {
                         if ($thesepriv{$priviledge} ne 'F') {                          if ($thesepriv{$privilege} ne 'F') {
     $thesepriv{$priviledge}.=$restrictions;      $thesepriv{$privilege}.=$restrictions;
                         }                          }
                     }                      }
                 }                  }
Line 759  sub rolesinit { Line 912  sub rolesinit {
             map { $thesestr.=':'.$_.'&'.$thesepriv{$_}; } keys %thesepriv;              map { $thesestr.=':'.$_.'&'.$thesepriv{$_}; } keys %thesepriv;
             $userroles.='user.priv.'.$_.'='.$thesestr."\n";              $userroles.='user.priv.'.$_.'='.$thesestr."\n";
         } keys %allroles;                      } keys %allroles;            
           $userroles.='user.adv='.$adv."\n".
               'user.author='.$author."\n";
           $ENV{'user.adv'}=$adv;
     }      }
     return $userroles;        return $userroles;  
 }  }
Line 766  sub rolesinit { Line 922  sub rolesinit {
 # --------------------------------------------------------------- get interface  # --------------------------------------------------------------- get interface
   
 sub get {  sub get {
    my ($namespace,@storearr)=@_;     my ($namespace,$storearr,$udomain,$uname)=@_;
    my $items='';     my $items='';
    map {     map {
        $items.=escape($_).'&';         $items.=escape($_).'&';
    } @storearr;     } @$storearr;
    $items=~s/\&$//;     $items=~s/\&$//;
  my $rep=reply("get:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace:$items",     if (!$udomain) { $udomain=$ENV{'user.domain'}; }
                  $ENV{'user.home'});     if (!$uname) { $uname=$ENV{'user.name'}; }
      my $uhome=&homeserver($uname,$udomain);
   
      my $rep=reply("get:$udomain:$uname:$namespace:$items",$uhome);
    my @pairs=split(/\&/,$rep);     my @pairs=split(/\&/,$rep);
    my %returnhash=();     my %returnhash=();
    my $i=0;     my $i=0;
    map {     map {
       $returnhash{$_}=unescape($pairs[$i]);        $returnhash{$_}=unescape($pairs[$i]);
       $i++;        $i++;
    } @storearr;     } @$storearr;
    return %returnhash;     return %returnhash;
 }  }
   
Line 800  sub del { Line 959  sub del {
 # -------------------------------------------------------------- dump interface  # -------------------------------------------------------------- dump interface
   
 sub dump {  sub dump {
    my $namespace=shift;     my ($namespace,$udomain,$uname)=@_;
    my $rep=reply("dump:$ENV{'user.domain'}:$ENV{'user.name'}:$namespace",     if (!$udomain) { $udomain=$ENV{'user.domain'}; }
                 $ENV{'user.home'});     if (!$uname) { $uname=$ENV{'user.name'}; }
      my $uhome=&homeserver($uname,$udomain);
      my $rep=reply("dump:$udomain:$uname:$namespace",$uhome);
    my @pairs=split(/\&/,$rep);     my @pairs=split(/\&/,$rep);
    my %returnhash=();     my %returnhash=();
    map {     map {
Line 860  sub eget { Line 1021  sub eget {
    return %returnhash;     return %returnhash;
 }  }
   
 # ------------------------------------------------- Check for a user priviledge  # ------------------------------------------------- Check for a user privilege
   
 sub allowed {  sub allowed {
     my ($priv,$uri)=@_;      my ($priv,$uri)=@_;
Line 892  sub allowed { Line 1053  sub allowed {
 # Course: uri itself is a course  # Course: uri itself is a course
     my $courseuri=$uri;      my $courseuri=$uri;
     $courseuri=~s/\_(\d)/\/$1/;      $courseuri=~s/\_(\d)/\/$1/;
     if ($ENV{'user.priv.'.$ENV{'request.role'}.'./'.$courseuri}      $courseuri=~s/^([^\/])/\/$1/;
   
       if ($ENV{'user.priv.'.$ENV{'request.role'}.'.'.$courseuri}
        =~/$priv\&([^\:]*)/) {         =~/$priv\&([^\:]*)/) {
        $thisallowed.=$1;         $thisallowed.=$1;
     }      }
Line 909  sub allowed { Line 1072  sub allowed {
  return $thisallowed;   return $thisallowed;
     }      }
 #  #
 # Gathered so far: system, domain and course wide priviledges  # Gathered so far: system, domain and course wide privileges
 #  #
 # Course: See if uri or referer is an individual resource that is part of   # Course: See if uri or referer is an individual resource that is part of 
 # the course  # the course
Line 934  sub allowed { Line 1097  sub allowed {
                $checkreferer=0;                 $checkreferer=0;
            }             }
        }         }
          
        if (($ENV{'HTTP_REFERER'}) && ($checkreferer)) {         if (($ENV{'HTTP_REFERER'}) && ($checkreferer)) {
   my $refuri=$ENV{'HTTP_REFERER'};    my $refuri=$ENV{'HTTP_REFERER'};
           $refuri=~s/^http\:\/\/$ENV{'request.host'}//i;            $refuri=~s/^http\:\/\/$ENV{'request.host'}//i;
Line 960  sub allowed { Line 1123  sub allowed {
    }     }
   
 #  #
 # Gathered now: all priviledges that could apply, and condition number  # Gathered now: all privileges that could apply, and condition number
 #   # 
 #  #
 # Full or no access?  # Full or no access?
Line 992  sub allowed { Line 1155  sub allowed {
            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;
                  $courseid=~s/^\///;
                my $expiretime=600;                 my $expiretime=600;
                if ($ENV{'request.role'} eq $roleid) {                 if ($ENV{'request.role'} eq $roleid) {
   $expiretime=120;    $expiretime=120;
Line 1129  sub definerole { Line 1293  sub definerole {
   }    }
 }  }
   
   # ---------------- Make a metadata query against the network of library servers
   
   sub metadata_query {
       my ($query,$custom,$customshow)=@_;
       # need to put in a library server loop here and return a hash
       my %rhash;
       for my $server (keys %libserv) {
    unless ($custom or $customshow) {
       my $reply=&reply("querysend:".&escape($query),$server);
       $rhash{$server}=$reply;
    }
    else {
       my $reply=&reply("querysend:".&escape($query).':'.
        &escape($custom).':'.&escape($customshow),
        $server);
       $rhash{$server}=$reply;
    }
       }
       return \%rhash;
   }
   
 # ------------------------------------------------------------------ Plain Text  # ------------------------------------------------------------------ Plain Text
   
 sub plaintext {  sub plaintext {
Line 1145  sub fileembstyle { Line 1330  sub fileembstyle {
   
 # ------------------------------------------------------------ Description Text  # ------------------------------------------------------------ Description Text
   
 sub filedecription {  sub filedescription {
     my $ending=shift;      my $ending=shift;
     return $fd{$ending};      return $fd{$ending};
 }  }
Line 1155  sub filedecription { Line 1340  sub filedecription {
 sub assignrole {  sub assignrole {
     my ($udom,$uname,$url,$role,$end,$start)=@_;      my ($udom,$uname,$url,$role,$end,$start)=@_;
     my $mrole;      my $mrole;
     $url=declutter($url);  
     if ($role =~ /^cr\//) {      if ($role =~ /^cr\//) {
         unless ($url=~/\.course$/) { return 'invalid'; }   unless (&allowed('ccr',$url)) {
  unless (allowed('ccr',$url)) { return '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';
     } else {      } else {
         unless (($url=~/\.course$/) || ($url=~/\/$/)) { return 'invalid'; }          my $cwosec=$url;
         unless (allowed('c'+$role)) { return 'refused'; }          $cwosec=~s/^\/(\w+)\/(\w+)\/.*/$1\/$2/;
           unless (&allowed('c'.$role,$cwosec)) { 
              &logthis('Refused assignrole: '.
                $udom.' '.$uname.' '.$url.' '.$role.' '.$end.' '.$start.' by '.
       $ENV{'user.name'}.' at '.$ENV{'user.domain'});
              return 'refused'; 
           }
         $mrole=$role;          $mrole=$role;
     }      }
     my $command="encrypt:rolesput:$ENV{'user.domain'}:$ENV{'user.name'}:".      my $command="encrypt:rolesput:$ENV{'user.domain'}:$ENV{'user.name'}:".
                 "$udom:$uname:$url".'_'."$mrole=$role";                  "$udom:$uname:$url".'_'."$mrole=$role";
     if ($end) { $command.='_$end'; }      if ($end) { $command.='_'.$end; }
     if ($start) {      if ($start) {
  if ($end) {    if ($end) { 
            $command.='_$start';              $command.='_'.$start; 
         } else {          } else {
            $command.='_0_$start';             $command.='_0_'.$start;
         }          }
     }      }
     return &reply($command,&homeserver($uname,$udom));      return &reply($command,&homeserver($uname,$udom));
 }  }
   
   # --------------------------------------------------------------- Modify a user
   
   
   sub modifyuser {
       my ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene)=@_;
       &logthis('Call to modify user '.$udom.', '.$uname.', '.$uid.', '.
                $umode.', '.$first.', '.$middle.', '.
        $last.', '.$gene.' by '.
                $ENV{'user.name'}.' at '.$ENV{'user.domain'});  
       my $uhome=&homeserver($uname,$udom);
   # ----------------------------------------------------------------- Create User
       if (($uhome eq 'no_host') && ($umode) && ($upass)) {
           my $unhome='';
    if ($ENV{'course.'.$ENV{'request.course.id'}.'.domain'} eq $udom) {
       $unhome=$ENV{'course.'.$ENV{'request.course.id'}.'.home'};
           } else {
               my $tryserver;
               my $loadm=10000000;
               foreach $tryserver (keys %libserv) {
          if ($hostdom{$tryserver} eq $udom) {
                     my $answer=reply('load',$tryserver);
                     if (($answer=~/\d+/) && ($answer<$loadm)) {
         $loadm=$answer;
                         $unhome=$tryserver;
                     }
          }
       }
           }
           if (($unhome eq '') || ($unhome eq 'no_host')) {
       return 'error: find home';
           }
           my $reply=&reply('encrypt:makeuser:'.$udom.':'.$uname.':'.$umode.':'.
                            &escape($upass),$unhome);
    unless ($reply eq 'ok') {
               return 'error: '.$reply;
           }   
           $uhome=&homeserver($uname,$udom);
           if (($uhome eq '') || ($uhome eq 'no_host') || ($uhome ne $unhome)) {
       return 'error: verify home';
           }
       }
   # ---------------------------------------------------------------------- Add ID
       if ($uid) {
          $uid=~tr/A-Z/a-z/;
          my %uidhash=&idrget($udom,$uname);
          if (($uidhash{$uname}) && ($uidhash{$uname}!~/error\:/)) {
     unless ($uid eq $uidhash{$uname}) {
         return 'error: mismatch '.$uidhash{$uname}.' versus '.$uid;
             }
          } else {
     &idput($udom,($uname => $uid));
          }
       }
   # -------------------------------------------------------------- Add names, etc
       my $names=&reply('get:'.$udom.':'.$uname.
                        ':environment:firstname&middlename&lastname&generation',
                        $uhome);
       my ($efirst,$emiddle,$elast,$egene)=split(/\&/,$names);
       if ($first)  { $efirst  = &escape($first); }
       if ($middle) { $emiddle = &escape($middle); }
       if ($last)   { $elast   = &escape($last); }
       if ($gene)   { $egene   = &escape($gene); }
       my $reply=&reply('put:'.$udom.':'.$uname.
              ':environment:firstname='.$efirst.
                         '&middlename='.$emiddle.
                           '&lastname='.$elast.
                         '&generation='.$egene,$uhome);
       if ($reply ne 'ok') {
    return 'error: '.$reply;
       }
       &logthis('Success modifying user '.$udom.', '.$uname.', '.$uid.', '.
                $umode.', '.$first.', '.$middle.', '.
        $last.', '.$gene.' by '.
                $ENV{'user.name'}.' at '.$ENV{'user.domain'});
       return 'ok'; 
   }
   
   # -------------------------------------------------------------- Modify student
   
   sub modifystudent {
       my ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec,
           $end,$start)=@_;
       my $cid='';
       unless ($cid=$ENV{'request.course.id'}) {
    return 'not_in_class';
       }
   # --------------------------------------------------------------- Make the user
       my $reply=&modifyuser
    ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene);
       unless ($reply eq 'ok') { return $reply; }
       my $uhome=&homeserver($uname,$udom);
       if (($uhome eq '') || ($uhome eq 'no_host')) { 
    return 'error: no such user';
       }
   # -------------------------------------------------- Add student to course list
       my $reply=critical('put:'.$ENV{'course.'.$cid.'.domain'}.':'.
                 $ENV{'course.'.$cid.'.num'}.':classlist:'.
                         &escape($uname.':'.$udom).'='.
                         &escape($end.':'.$start),
                 $ENV{'course.'.$cid.'.home'});
       unless (($reply eq 'ok') || ($reply eq 'delayed')) {
    return 'error: '.$reply;
       }
   # ---------------------------------------------------- Add student role to user
       my $uurl='/'.$cid;
       $uurl=~s/\_/\//g;
       if ($usec) {
    $uurl.='/'.$usec;
       }
       return &assignrole($udom,$uname,$uurl,'st',$end,$start);
   }
   
   # ------------------------------------------------- Write to course preferences
   
   sub writecoursepref {
       my ($courseid,%prefs)=@_;
       $courseid=~s/^\///;
       $courseid=~s/\_/\//g;
       my ($cdomain,$cnum)=split(/\//,$courseid);
       my $chome=homeserver($cnum,$cdomain);
       if (($chome eq '') || ($chome eq 'no_host')) { 
    return 'error: no such course';
       }
       my $cstring='';
       map {
    $cstring.=escape($_).'='.escape($prefs{$_}).'&';
       } keys %prefs;
       $cstring=~s/\&$//;
       return reply('put:'.$cdomain.':'.$cnum.':environment:'.$cstring,$chome);
   }
   
   # ---------------------------------------------------------- Make/modify course
   
   sub createcourse {
       my ($udom,$description,$url)=@_;
       $url=&declutter($url);
       my $cid='';
       unless (&allowed('ccc',$ENV{'user.domain'})) {
           return 'refused';
       }
       unless ($udom eq $ENV{'user.domain'}) {
           return 'refused';
       }
   # ------------------------------------------------------------------- Create ID
      my $uname=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);
      unless (($uhome eq '') || ($uhome eq 'no_host')) {
          $uname=substr($$.time,0,5).unpack("H8",pack("I32",time)).
           unpack("H2",pack("I32",int(rand(255)))).$perlvar{'lonHostID'};
          $uhome=&homeserver($uname,$udom);       
          unless (($uhome eq '') || ($uhome eq 'no_host')) {
              return 'error: unable to generate unique course-ID';
          } 
      }
   # ------------------------------------------------------------- Make the course
       my $reply=&reply('encrypt:makeuser:'.$udom.':'.$uname.':none::',
                         $ENV{'user.home'});
       unless ($reply eq 'ok') { return 'error: '.$reply; }
       my $uhome=&homeserver($uname,$udom);
       if (($uhome eq '') || ($uhome eq 'no_host')) { 
    return 'error: no such course';
       }
       &writecoursepref($udom.'_'.$uname,
                        ('description' => $description,
                         'url'         => $url));
       return '/'.$udom.'/'.$uname;
   }
   
 # ---------------------------------------------------------- Assign Custom Role  # ---------------------------------------------------------- Assign Custom Role
   
 sub assigncustomrole {  sub assigncustomrole {
Line 1323  sub EXT { Line 1687  sub EXT {
     if ($realm eq 'user') {      if ($realm eq 'user') {
 # --------------------------------------------------------------- user.resource  # --------------------------------------------------------------- user.resource
  if ($space eq 'resource') {   if ($space eq 'resource') {
     my %restored=&restore;      my %restored=&restore();
             return $restored{$qualifierrest};              return $restored{$qualifierrest};
 # ----------------------------------------------------------------- user.access  # ----------------------------------------------------------------- user.access
         } elsif ($space eq 'access') {          } elsif ($space eq 'access') {
Line 1351  sub EXT { Line 1715  sub EXT {
 # ---------------------------------------------------- Any other user namespace  # ---------------------------------------------------- Any other user namespace
         } else {          } else {
             my $item=($rest)?$qualifier.'.'.$rest:$qualifier;              my $item=($rest)?$qualifier.'.'.$rest:$qualifier;
             my %reply=&get($space,$item);              my %reply=&get($space,[$item]);
             return $reply{$item};              return $reply{$item};
         }          }
     } elsif ($realm eq 'request') {      } elsif ($realm eq 'request') {
Line 1364  sub EXT { Line 1728  sub EXT {
         }          }
     } elsif ($realm eq 'course') {      } elsif ($realm eq 'course') {
 # ---------------------------------------------------------- course.description  # ---------------------------------------------------------- course.description
         my $section='';          return $ENV{'course.'.$ENV{'request.course.id'}.'.'.
         if ($ENV{'request.course.sec'}) {  
     $section='_'.$ENV{'request.course.sec'};  
         }  
         return $ENV{'course.'.$ENV{'request.course.id'}.$section.'.'.  
                               $spacequalifierrest};                                $spacequalifierrest};
     } elsif ($realm eq 'resource') {      } elsif ($realm eq 'resource') {
       if ($ENV{'request.course.id'}) {         if ($ENV{'request.course.id'}) {
 # ----------------------------------------------------- Cascading lookup scheme  # ----------------------------------------------------- Cascading lookup scheme
        my $symbp=&symbread();           my $symbp=&symbread();
        my $mapp=(split(/\_\_\_/,$symbp))[0];           my $mapp=(split(/\_\_\_/,$symbp))[0];
   
        my $symbparm=$symbp.'.'.$spacequalifierrest;           my $symbparm=$symbp.'.'.$spacequalifierrest;
        my $mapparm=$mapp.'___(all).'.$spacequalifierrest;           my $mapparm=$mapp.'___(all).'.$spacequalifierrest;
   
        my $seclevel=           my $seclevel=
             $ENV{'request.course.id'}.'.['.              $ENV{'request.course.id'}.'.['.
  $ENV{'request.course.sec'}.'].'.$spacequalifierrest;   $ENV{'request.course.sec'}.'].'.$spacequalifierrest;
        my $seclevelr=           my $seclevelr=
             $ENV{'request.course.id'}.'.['.              $ENV{'request.course.id'}.'.['.
  $ENV{'request.course.sec'}.'].'.$symbparm;   $ENV{'request.course.sec'}.'].'.$symbparm;
        my $seclevelm=           my $seclevelm=
             $ENV{'request.course.id'}.'.['.              $ENV{'request.course.id'}.'.['.
  $ENV{'request.course.sec'}.'].'.$mapparm;   $ENV{'request.course.sec'}.'].'.$mapparm;
   
        my $courselevel=           my $courselevel=
             $ENV{'request.course.id'}.'.'.$spacequalifierrest;              $ENV{'request.course.id'}.'.'.$spacequalifierrest;
        my $courselevelr=           my $courselevelr=
             $ENV{'request.course.id'}.'.'.$symbparm;              $ENV{'request.course.id'}.'.'.$symbparm;
        my $courselevelm=           my $courselevelm=
             $ENV{'request.course.id'}.'.'.$mapparm;              $ENV{'request.course.id'}.'.'.$mapparm;
   
   
 # ----------------------------------------------------------- first, check user  # ----------------------------------------------------------- first, check user
       my %resourcedata=get('resourcedata',           my %resourcedata=get('resourcedata',
                            ($courselevelr,$courselevelm,$courselevel));                             [$courselevelr,$courselevelm,$courselevel]);
       if ($resourcedata{$courselevelr}!~/^error\:/) {           if (($resourcedata{$courselevelr}!~/^error\:/) &&
                ($resourcedata{$courselevelr}!~/^con_lost/)) {
        if ($resourcedata{$courselevelr}) {   
           return $resourcedata{$courselevelr}; }           if ($resourcedata{$courselevelr}) { 
        if ($resourcedata{$courselevelm}) {               return $resourcedata{$courselevelr}; }
           return $resourcedata{$courselevelm}; }           if ($resourcedata{$courselevelm}) { 
        if ($resourcedata{$courselevel}) { return $resourcedata{$courselevel}; }              return $resourcedata{$courselevelm}; }
            if ($resourcedata{$courselevel}) { return $resourcedata{$courselevel}; }
   
         } else {
     if ($resourcedata{$courselevelr}!~/No such file/) {
       &logthis("<font color=blue>WARNING:".
      " Trying to get resource data for ".$ENV{'user.name'}." at "
                      .$ENV{'user.domain'}.": ".$resourcedata{$courselevelr}.
                    "</font>");
     }
       }        }
   
 # -------------------------------------------------------- second, check course  # -------------------------------------------------------- second, check course
         my $section='';  
         if ($ENV{'request.course.sec'}) {  
     $section='_'.$ENV{'request.course.sec'};  
         }  
         my $reply=&reply('get:'.          my $reply=&reply('get:'.
               $ENV{'course.'.$ENV{'request.course.id'}.$section.'.domain'}.':'.                $ENV{'course.'.$ENV{'request.course.id'}.'.domain'}.':'.
               $ENV{'course.'.$ENV{'request.course.id'}.$section.'.num'}.                $ENV{'course.'.$ENV{'request.course.id'}.'.num'}.
               ':resourcedata:'.        ':resourcedata:'.
  escape($seclevelr).':'.escape($seclevelm).':'.escape($seclevel).':'.     &escape($seclevelr).'&'.&escape($seclevelm).'&'.&escape($seclevel).'&'.
  escape($courselevelr).':'.escape($courselevelm).':'.escape($courselevel),     &escape($courselevelr).'&'.&escape($courselevelm).'&'.&escape($courselevel),
    $ENV{'course.'.$ENV{'request.course.id'}.$section.'.home'});     $ENV{'course.'.$ENV{'request.course.id'}.'.home'});
       if ($reply!~/^error\:/) {        if ($reply!~/^error\:/) {
         map {    map {
            my ($name,$value)=split(/\=/,$_);        if ($_) { return &unescape($_); }
            $resourcedata{unescape($name)}=unescape($value);              } split(/\&/,$reply);
         } split(/\&/,$reply);        }
         if (($reply=~/^con_lost/) || ($reply=~/^error\:/)) {
        if ($resourcedata{$seclevelr}) { return $resourcedata{$seclevelr}; }    &logthis("<font color=blue>WARNING:".
        if ($resourcedata{$seclevelm}) { return $resourcedata{$seclevelm}; }                    " Getting ".$reply." asking for ".$varname." for ".
        if ($resourcedata{$seclevel}) { return $resourcedata{$seclevel}; }                  $ENV{'course.'.$ENV{'request.course.id'}.'.num'}.
                   ' at '.
        if ($resourcedata{$courselevelr}) {                   $ENV{'course.'.$ENV{'request.course.id'}.'.domain'}.
           return $resourcedata{$courselevelr}; }                  ' from '.
        if ($resourcedata{$courselevelm}) {                   $ENV{'course.'.$ENV{'request.course.id'}.'.home'}.
           return $resourcedata{$courselevelm}; }                   "</font>");
        if ($resourcedata{$courselevel}) { return $resourcedata{$courselevel}; }  
   
       }        }
   
 # ------------------------------------------------------ third, check map parms  # ------------------------------------------------------ third, check map parms
        my %parmhash=();         my %parmhash=();
        my $thisparm='';                my $thisparm='';       
Line 1451  sub EXT { Line 1813  sub EXT {
      }       }
             
 # --------------------------------------------- last, look in resource metadata  # --------------------------------------------- last, look in resource metadata
  my $uri=&declutter($ENV{'request.filename'});  
         my $filename=$perlvar{'lonDocRoot'}.'/res/'.$uri.'.meta';        $spacequalifierrest=~s/\./\_/;
         if (-e $filename) {        my $metadata=&metadata($ENV{'request.filename'},$spacequalifierrest);
             my @content;        if ($metadata) { return $metadata; }
             {        $metadata=&metadata($ENV{'request.filename'},
              my $fh=Apache::File->new($filename);                                           'parameter_'.$spacequalifierrest);
              @content=<$fh>;        if ($metadata) { return $metadata; }
             }  
             if (join('',@content)=~  
                  /\<$space[^\>]*\>([^\<]*)\<\/$space\>/) {  
         return $1;  
      }  
         }  
 # ---------------------------------------------------- Any other user namespace  # ---------------------------------------------------- Any other user namespace
     } elsif ($realm eq 'environment') {      } elsif ($realm eq 'environment') {
 # ----------------------------------------------------------------- environment  # ----------------------------------------------------------------- environment
         return $ENV{$spacequalifierrest};          return $ENV{'environment.'.$spacequalifierrest};
     } elsif ($realm eq 'system') {      } elsif ($realm eq 'system') {
 # ----------------------------------------------------------------- system.time  # ----------------------------------------------------------------- system.time
  if ($space eq 'time') {   if ($space eq 'time') {
Line 1477  sub EXT { Line 1834  sub EXT {
     return '';      return '';
 }  }
   
   # ---------------------------------------------------------------- Get metadata
   
   sub metadata {
       my ($uri,$what)=@_;
   
       $uri=&declutter($uri);
       my $filename=$uri;
       $uri=~s/\.meta$//;
       unless ($metacache{$uri.':keys'}) {
           unless ($filename=~/\.meta$/) { $filename.='.meta'; }
    my $metastring=&getfile($perlvar{'lonDocRoot'}.'/res/'.$filename);
           my $parser=HTML::TokeParser->new(\$metastring);
           my $token;
           while ($token=$parser->get_token) {
              if ($token->[0] eq 'S') {
         my $entry=$token->[1];
                 my $unikey=$entry;
                 if (defined($token->[2]->{'part'})) { 
                    $unikey.='_'.$token->[2]->{'part'}; 
         }
                 if (defined($token->[2]->{'name'})) { 
                    $unikey.='_'.$token->[2]->{'name'}; 
         }
                 if ($metacache{$uri.':keys'}) {
                    $metacache{$uri.':keys'}.=','.$unikey;
                 } else {
                    $metacache{$uri.':keys'}=$unikey;
         }
                 map {
     $metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};
                 } @{$token->[3]};
                 unless (
                    $metacache{$uri.':'.$unikey}=$parser->get_text('/'.$entry)
         ) { $metacache{$uri.':'.$unikey}=
         $metacache{$uri.':'.$unikey.'.default'};
         }
             }
          }
       }
       return $metacache{$uri.':'.$what};
   }
   
 # ------------------------------------------------- Update symbolic store links  # ------------------------------------------------- Update symbolic store links
   
 sub symblist {  sub symblist {
Line 1584  sub numval { Line 1983  sub numval {
 sub rndseed {  sub rndseed {
     my $symb;      my $symb;
     unless ($symb=&symbread()) { return time; }      unless ($symb=&symbread()) { return time; }
     my $symbchck=unpack("%32C*",$symb);      { 
     my $symbseed=numval($symb)%$symbchck;        use integer;
     my $namechck=unpack("%32C*",$ENV{'user.name'});        my $symbchck=unpack("%32C*",$symb) << 27;
     my $nameseed=numval($ENV{'user.name'})%$namechck;        my $symbseed=numval($symb) << 22;
     return int( $symbseed        my $namechck=unpack("%32C*",$ENV{'user.name'}) << 17;
        .$nameseed        my $nameseed=numval($ENV{'user.name'}) << 12;
                .unpack("%32C*",$ENV{'user.domain'})        my $domainseed=unpack("%32C*",$ENV{'user.domain'}) << 7;
                .unpack("%32C*",$ENV{'request.course.id'})        my $courseseed=unpack("%32C*",$ENV{'request.course.id'});
                .$namechck        my $num=$symbseed+$nameseed+$domainseed+$courseseed+$namechck+$symbchck;
                .$symbchck);        #uncommenting these lines can break things!
         #&Apache::lonxml::debug("$symbseed:$nameseed;$domainseed|$courseseed;$namechck:$symbchck");
         #&Apache::lonxml::debug("rndseed :$num:$symb");
         return $num;
       }
 }  }
   
   sub ireceipt {
       my ($funame,$fudom,$fucourseid,$fusymb)=@_;
       my $cuname=unpack("%32C*",$funame);
       my $cudom=unpack("%32C*",$fudom);
       my $cucourseid=unpack("%32C*",$fucourseid);
       my $cusymb=unpack("%32C*",$fusymb);
       my $cunique=unpack("%32C*",$perlvar{'lonReceipt'});
       return unpack("%32C*",$perlvar{'lonHostID'}).'-'.
              ($cunique%$cuname+
               $cunique%$cudom+
               $cusymb%$cuname+
               $cusymb%$cudom+
               $cucourseid%$cuname+
               $cucourseid%$cudom);
   }
   
   sub receipt {
       return &ireceipt($ENV{'user.name'},$ENV{'user.domain'},
                        $ENV{'request.course.id'},&symbread());
   }
     
 # ------------------------------------------------------------ Serves up a file  # ------------------------------------------------------------ Serves up a file
 # returns either the contents of the file or a -1  # returns either the contents of the file or a -1
 sub getfile {  sub getfile {
Line 1742  if ($readit ne 'done') { Line 2166  if ($readit ne 'done') {
     }      }
 }  }
   
   %metacache=();
   
 $readit='done';  $readit='done';
 &logthis('<font color=yellow>INFO: Read configuration</font>');  &logthis('<font color=yellow>INFO: Read configuration</font>');
Removed from v.1.70  
changed lines
  Added in v.1.132

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