[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.61 and 1.80

version 1.61, 2000/11/14 14:58:59 version 1.80, 2000/12/13 22:45:22
Line 45 Line 45
 # 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 farily 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
   # usection(domain,user,courseid) : output of section name/number or '' for
   #                                  "not in course" and '-1' for "no section"
   # userenvironment(domain,user,what) : puts out any environment parameter 
   #                                     for a user
   # idput(domain,hash) : writes IDs for users from hash (name=>id,name=>id)
   # idget(domain,array): returns hash with usernames (id=>name,id=>name) for
   #                      an array of IDs
   # idrget(domain,array): returns hash with IDs for usernames (name=>id,...) for
   #                       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 67 Line 79
 # 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 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 Gerd Kortemeyer
   
 package Apache::lonnet;  package Apache::lonnet;
   
Line 76  use Apache::File; Line 90  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;
   
 # --------------------------------------------------------------------- Logging  # --------------------------------------------------------------------- Logging
   
Line 122  sub reply { Line 137  sub reply {
     my ($cmd,$server)=@_;      my ($cmd,$server)=@_;
     my $answer=subreply($cmd,$server);      my $answer=subreply($cmd,$server);
     if ($answer eq 'con_lost') { $answer=subreply($cmd,$server); }      if ($answer eq 'con_lost') { $answer=subreply($cmd,$server); }
     if (($answer=~/^error:/) || ($answer=~/^refused/) ||       if (($answer=~/^refused/) || ($answer=~/^rejected/)) {
         ($answer=~/^rejected/)) {  
        &logthis("<font color=blue>WARNING:".         &logthis("<font color=blue>WARNING:".
                 " $cmd to $server returned $answer</font>");                  " $cmd to $server returned $answer</font>");
     }      }
Line 357  sub homeserver { Line 371  sub homeserver {
     return 'no_host';      return 'no_host';
 }  }
   
   # ------------------------------------- Find the usernames behind a list of IDs
   
   sub idget {
       my ($udom,@ids)=@_;
       my %returnhash=();
       
       my $tryserver;
       foreach $tryserver (keys %libserv) {
          if ($hostdom{$tryserver} eq $udom) {
     my $idlist=join('&',@ids);
             $idlist=~tr/A-Z/a-z/; 
     my $reply=&reply("idget:$udom:".$idlist,$tryserver);
             my @answer=();
             if (($reply ne 'con_lost') && ($reply!~/^error\:/)) {
         @answer=split(/\&/,$reply);
             }                    ;
             my $i;
             for ($i=0;$i<=$#ids;$i++) {
                 if ($answer[$i]) {
     $returnhash{$ids[$i]}=$answer[$i];
                 } 
             }
          }
       }    
       return %returnhash;
   }
   
   # ------------------------------------- Find the IDs behind a list of usernames
   
   sub idrget {
       my ($udom,@unames)=@_;
       my %returnhash=();
       map {
           $returnhash{$_}=(&userenvironment($udom,$_,'id'))[1];
       } @unames;
       return %returnhash;
   }
   
   # ------------------------------- Store away a list of names and associated IDs
   
   sub idput {
       my ($udom,%ids)=@_;
       my %servers=();
       map {
           my $uhom=&homeserver($_,$udom);
           if ($uhom ne 'no_host') {
               my $id=&escape($ids{$_});
               $id=~tr/A-Z/a-z/;
               my $unam=&escape($_);
       if ($servers{$uhom}) {
    $servers{$uhom}.='&'.$id.'='.$unam;
               } else {
                   $servers{$uhom}=$id.'='.$unam;
               }
               &critical('put:'.$udom.':'.$unam.':environment:id='.$id,$uhom);
           }
       } keys %ids;
       map {
           &critical('idput:'.$udom.':'.$servers{$_},$_);
       } keys %servers;
   }
   
   # ------------------------------------- Find the section of student in a course
   
   sub usection {
       my ($udom,$unam,$courseid)=@_;
       $courseid=~s/\_/\//g;
       $courseid=~s/^(\w)/\/$1/;
       map {
           my ($key,$value)=split(/\=/,$_);
           $key=&unescape($key);
           if ($key=~/^$courseid(?:\/)*(\w+)*\_st$/) {
               my $section=$1;
               if ($key eq $courseid.'_st') { $section=''; }
       my ($dummy,$end,$start)=split(/\_/,&unescape($value));
               my $now=time;
               my $notactive=0;
               if ($start) {
    if ($now<$start) { $notactive=1; }
               }
               if ($end) {
                   if ($now>$end) { $notactive=1; }
               } 
               unless ($notactive) { return $section; }
           }
       } split(/\&/,&reply('dump:'.$udom.':'.$unam.':roles',
                           &homeserver($unam,$udom)));
       return '-1';
   }
   
   # ------------------------------------- Read an entry from a user's environment
   
   sub userenvironment {
       my ($udom,$unam,@what)=@_;
       my %returnhash=();
       my @answer=split(/\&/,
                   &reply('get:'.$udom.':'.$unam.':environment:'.join('&',@what),
                         &homeserver($unam,$udom)));
       my $i;
       for ($i=0;$i<=$#what;$i++) {
    $returnhash{$what[$i]}=&unescape($answer[$i]);
       }
       return %returnhash;
   }
   
 # ----------------------------- Subscribe to a resource, return URL if possible  # ----------------------------- Subscribe to a resource, return URL if possible
   
 sub subscribe {  sub subscribe {
Line 369  sub subscribe { Line 488  sub subscribe {
         return 'not_found';           return 'not_found'; 
     }      }
     my $answer=reply("sub:$fname",$home);      my $answer=reply("sub:$fname",$home);
       if (($answer eq 'con_lost') || ($answer eq 'rejected')) {
    $answer.=' by '.$home;
       }
     return $answer;      return $answer;
 }  }
           
Line 380  sub repcopy { Line 502  sub repcopy {
     my $transname="$filename.in.transfer";      my $transname="$filename.in.transfer";
     if ((-e $filename) || (-e $transname)) { return OK; }      if ((-e $filename) || (-e $transname)) { return OK; }
     my $remoteurl=subscribe($filename);      my $remoteurl=subscribe($filename);
     if ($remoteurl eq 'con_lost') {      if ($remoteurl =~ /^con_lost by/) {
    &logthis("Subscribe returned con_lost: $filename");     &logthis("Subscribe returned $remoteurl: $filename");
            return HTTP_SERVICE_UNAVAILABLE;             return HTTP_SERVICE_UNAVAILABLE;
     } elsif ($remoteurl eq 'not_found') {      } elsif ($remoteurl eq 'not_found') {
    &logthis("Subscribe returned not_found: $filename");     &logthis("Subscribe returned not_found: $filename");
    return HTTP_NOT_FOUND;     return HTTP_NOT_FOUND;
     } elsif ($remoteurl eq 'rejected') {      } elsif ($remoteurl =~ /^rejected by/) {
    &logthis("Subscribe returned rejected: $filename");     &logthis("Subscribe returned $remoteurl: $filename");
            return FORBIDDEN;             return FORBIDDEN;
     } elsif ($remoteurl eq 'directory') {      } elsif ($remoteurl eq 'directory') {
            return OK;             return OK;
Line 511  sub restore { Line 633  sub restore {
  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 774  sub allowed { Line 899  sub allowed {
     }      }
   
 # Course: uri itself is a course  # Course: uri itself is a course
       my $courseuri=$uri;
     if ($ENV{'user.priv.'.$ENV{'request.role'}.'./'.$uri}      $courseuri=~s/\_(\d)/\/$1/;
       if ($ENV{'user.priv.'.$ENV{'request.role'}.'./'.$courseuri}
        =~/$priv\&([^\:]*)/) {         =~/$priv\&([^\:]*)/) {
        $thisallowed.=$1;         $thisallowed.=$1;
     }      }
Line 1028  sub fileembstyle { Line 1154  sub fileembstyle {
   
 # ------------------------------------------------------------ Description Text  # ------------------------------------------------------------ Description Text
   
 sub filedecription {  sub filedescription {
     my $ending=shift;      my $ending=shift;
     return $fd{$ending};      return $fd{$ending};
 }  }
Line 1061  sub assignrole { Line 1187  sub assignrole {
     return &reply($command,&homeserver($uname,$udom));      return &reply($command,&homeserver($uname,$udom));
 }  }
   
   # ----------------------------------------------------------------- Make a user
   
   
   sub makeuser {
       my ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene)=@_;
       &logthis('Call to make 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') {
           my $unhome='';
    if ($ENV{'course.'.$ENV{'request.course.id'}.'.domain'} eq $udom) {
       $unhome=$ENV{'course.'.$ENV{'request.course.id'}.'.home'};
    } elsif ($ENV{'user.domain'} eq $udom) {
               $unhome=$ENV{'user.home'};
           } else {
               my $tryserver;
               my $loadm=999999;
               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);
       unless ($efirst)  { $efirst  = &escape($first); }
       unless ($emiddle) { $emiddle = &escape($middle); }
       unless ($elast)   { $elast   = &escape($last); }
       unless ($egene)   { $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 making user '.$udom.', '.$uname.', '.$uid.', '.
                $umode.', '.$first.', '.$middle.', '.
        $last.', '.$gene.' by '.
                $ENV{'user.name'}.' at '.$ENV{'user.domain'});
       return 'ok'; 
   }
   
   # -------------------------------------------------------------- Make a student
   
   sub makestudent {
       my ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec)=@_;
       unless ($ENV{'request.course.id'}) {
    return 'not_in_class';
       }
   # --------------------------------------------------------------- Make the user
       my $reply=&makeuser
    ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene);
       unless ($reply eq 'ok') { return $reply; }
   # -------------------------------------------------- Add student to course list
   
   # ---------------------------------------------------- Add student role to user
   
   }
   
 # ---------------------------------------------------------- Assign Custom Role  # ---------------------------------------------------------- Assign Custom Role
   
 sub assigncustomrole {  sub assigncustomrole {
Line 1191  sub condval { Line 1413  sub condval {
   
 sub EXT {  sub EXT {
     my $varname=shift;      my $varname=shift;
       unless ($varname) { return ''; }
     my ($realm,$space,$qualifier,@therest)=split(/\./,$varname);      my ($realm,$space,$qualifier,@therest)=split(/\./,$varname);
     my $rest;      my $rest;
     if ($therest[0]) {      if ($therest[0]) {
Line 1255  sub EXT { Line 1478  sub EXT {
     } 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 $reslevel=         my $symbp=&symbread();
     $ENV{'request.course.id'}.'.'.&symbread().'.'.$spacequalifierrest;         my $mapp=(split(/\_\_\_/,$symbp))[0];
   
          my $symbparm=$symbp.'.'.$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=
               $ENV{'request.course.id'}.'.['.
    $ENV{'request.course.sec'}.'].'.$symbparm;
          my $seclevelm=
               $ENV{'request.course.id'}.'.['.
    $ENV{'request.course.sec'}.'].'.$mapparm;
   
        my $courselevel=         my $courselevel=
             $ENV{'request.course.id'}.'.'.$spacequalifierrest;              $ENV{'request.course.id'}.'.'.$spacequalifierrest;
          my $courselevelr=
               $ENV{'request.course.id'}.'.'.$symbparm;
          my $courselevelm=
               $ENV{'request.course.id'}.'.'.$mapparm;
   
   
 # ----------------------------------------------------------- first, check user  # ----------------------------------------------------------- first, check user
        my %resourcedata=get('resourcedata',($reslevel,$seclevel,$courselevel));        my %resourcedata=get('resourcedata',
        if ($resourcedata{$reslevel}) { return $resourcedata{$reslevel}; }                             ($courselevelr,$courselevelm,$courselevel));
        if ($resourcedata{$seclevel}) { return $resourcedata{$seclevel}; }        if ($resourcedata{$courselevelr}!~/^error\:/) {
   
          if ($resourcedata{$courselevelr}) { 
             return $resourcedata{$courselevelr}; }
          if ($resourcedata{$courselevelm}) { 
             return $resourcedata{$courselevelm}; }
        if ($resourcedata{$courselevel}) { return $resourcedata{$courselevel}; }         if ($resourcedata{$courselevel}) { return $resourcedata{$courselevel}; }
   
         }
 # -------------------------------------------------------- second, check course  # -------------------------------------------------------- second, check course
         my $section='';          my $section='';
         if ($ENV{'request.course.sec'}) {          if ($ENV{'request.course.sec'}) {
Line 1277  sub EXT { Line 1522  sub EXT {
         my $reply=&reply('get:'.          my $reply=&reply('get:'.
               $ENV{'course.'.$ENV{'request.course.id'}.$section.'.domain'}.':'.                $ENV{'course.'.$ENV{'request.course.id'}.$section.'.domain'}.':'.
               $ENV{'course.'.$ENV{'request.course.id'}.$section.'.num'}.                $ENV{'course.'.$ENV{'request.course.id'}.$section.'.num'}.
               ':resourcedata:'.        ':resourcedata:'.
               escape($reslevel).':'.escape($seclevel).':'.escape($courselevel),     &escape($seclevelr).'&'.&escape($seclevelm).'&'.&escape($seclevel).'&'.
      &escape($courselevelr).'&'.&escape($courselevelm).'&'.&escape($courselevel),
    $ENV{'course.'.$ENV{'request.course.id'}.$section.'.home'});     $ENV{'course.'.$ENV{'request.course.id'}.$section.'.home'});
         map {        if ($reply!~/^error\:/) {
            my ($name,$value)=split(/\=/,$_);    map {
            $resourcedata{unescape($name)}=unescape($value);          if ($_) { return &unescape($_); }
         } split(/\&/,$reply);            } split(/\&/,$reply);
        if ($resourcedata{$reslevel}) { return $resourcedata{$reslevel}; }        }
        if ($resourcedata{$seclevel}) { return $resourcedata{$seclevel}; }  
        if ($resourcedata{$courselevel}) { return $resourcedata{$courselevel}; }  
   
 # ------------------------------------------------------ third, check map parms  # ------------------------------------------------------ third, check map parms
                 my %parmhash=();
        if ($ENV{'resource.parms.'.$reslevel}) {         my $thisparm='';       
    return $ENV{'resource.parms.'.$reslevel};         if (tie(%parmhash,'GDBM_File',
             $ENV{'request.course.fn'}.'_parms.db',&GDBM_READER,0640)) {
              $thisparm=$parmhash{$symbparm};
      untie(%parmhash);
        }         }
          if ($thisparm) { return $thisparm; }
      }       }
             
 # --------------------------------------------- last, look in resource metadata  # --------------------------------------------- last, look in resource metadata
  my $uri=&declutter($ENV{'request.filename'});  
         my $filename=$perlvar{'lonDocRoot'}.'/res/'.$ENV.'.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
Line 1322  sub EXT { Line 1565  sub EXT {
     return '';      return '';
 }  }
   
 # ---------------------------------------- Append resource parms to environment  # ---------------------------------------------------------------- Get metadata
   
 sub appendparms {  sub metadata {
     my ($symb,$parms)=@_;      my ($uri,$what)=@_;
     my %storehash=();  
     my $prefix='resource.parms.'.$ENV{'request.course.id'}.'.'.$symb;      $uri=&declutter($uri);
     map {      my $filename=$uri;
  my ($typename,$value)=split(/\=/,$_);      $uri=~s/\.meta$//;
         my ($type,$name)=split(/\:/,$typename);      unless ($metacache{$uri.':keys'}) {
         $storehash{$prefix.'.'.unescape($name)}=unescape($value);          unless ($filename=~/\.meta$/) { $filename.='.meta'; }
  $storehash{$prefix.'.'.unescape($name).'.type'}=unescape($type);   my $metastring=&getfile($perlvar{'lonDocRoot'}.'/res/'.$filename);
     } split(/\&/,$parms);          my $parser=HTML::TokeParser->new(\$metastring);
     &appenv(%storehash);          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
Line 1389  sub symbread { Line 1659  sub symbread {
                             &GDBM_READER,0640)) {                              &GDBM_READER,0640)) {
 # ---------------------------------------------- Get ID(s) for current resource  # ---------------------------------------------- Get ID(s) for current resource
               my $ids=$bighash{'ids_/res/'.$thisfn};                my $ids=$bighash{'ids_/res/'.$thisfn};
                 unless ($ids) { 
                    $ids=$bighash{'ids_/'.$thisfn};
                 }
               if ($ids) {                if ($ids) {
 # ------------------------------------------------------------------- Has ID(s)  # ------------------------------------------------------------------- Has ID(s)
                  my @possibilities=split(/\,/,$ids);                   my @possibilities=split(/\,/,$ids);
Line 1416  sub symbread { Line 1689  sub symbread {
               untie(%bighash)                untie(%bighash)
            }              } 
         }          }
         if ($syval) { return $syval.'___'.$thisfn; }          if ($syval) {
              return $syval.'___'.$thisfn; 
           }
     }      }
     &appenv('request.ambiguous' => $thisfn);      &appenv('request.ambiguous' => $thisfn);
     return '';      return '';
Line 1451  sub rndseed { Line 1726  sub rndseed {
                .$symbchck);                 .$symbchck);
 }  }
   
   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 1597  if ($readit ne 'done') { Line 1893  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.61  
changed lines
  Added in v.1.80

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