[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.235 and 1.255

version 1.235, 2002/05/29 14:10:28 version 1.255, 2002/07/30 19:57:40
Line 80  use vars Line 80  use vars
 qw(%perlvar %hostname %homecache %badServerCache %hostip %spareid %hostdom   qw(%perlvar %hostname %homecache %badServerCache %hostip %spareid %hostdom 
    %libserv %pr %prp %metacache %packagetab      %libserv %pr %prp %metacache %packagetab 
    %courselogs %accesshash $processmarker $dumpcount      %courselogs %accesshash $processmarker $dumpcount 
    %coursedombuf %coursehombuf %courseresdatacache);     %coursedombuf %coursehombuf %courseresdatacache %domaindescription);
 use IO::Socket;  use IO::Socket;
 use GDBM_File;  use GDBM_File;
 use Apache::Constants qw(:common :http);  use Apache::Constants qw(:common :http);
Line 708  sub ssi { Line 708  sub ssi {
     return $response->content;      return $response->content;
 }  }
   
   # ------- Add a token to a remote URI's query string to vouch for access rights
   
   sub tokenwrapper {
       my $uri=shift;
       my $token=&reply('tmpput:'.&escape($uri),$perlvar{'lonHostID'});
       return $uri.(($uri=~/\?/)?'&':'?').
    'token='.$token.'&server='.$perlvar{'lonHostID'};
   }
       
   
 # ------------------------------------------------------------------------- Log  # ------------------------------------------------------------------------- Log
   
 sub log {  sub log {
Line 1501  sub allowed { Line 1511  sub allowed {
 # Free bre to public access  # Free bre to public access
   
     if ($priv eq 'bre') {      if ($priv eq 'bre') {
  if (&metadata($uri,'copyright') eq 'public') { return 'F'; }          my $copyright=&metadata($uri,'copyright');
    if ($copyright eq 'public') { return 'F'; }
           if ($copyright eq 'priv') {
               $uri=~/([^\/]+)\/([^\/]+)\//;
       unless (($ENV{'user.name'} eq $2) && ($ENV{'user.domain'} eq $1)) {
    return '';
               }
           }
           if ($copyright eq 'domain') {
               $uri=~/([^\/]+)\/([^\/]+)\//;
       unless (($ENV{'user.domain'} eq $1) ||
                    ($ENV{'course.'.$ENV{'request.course.id'}.'.domain'} eq $1)) {
    return '';
               }
           }
     }      }
   
     my $thisallowed='';      my $thisallowed='';
Line 1645  sub allowed { Line 1669  sub allowed {
                 || ($ENV{$prefix.'res.'.$uri.'.lock.sections'} eq 'all')) {                  || ($ENV{$prefix.'res.'.$uri.'.lock.sections'} eq 'all')) {
    if ($ENV{$prefix.'res.'.$uri.'.lock.expire'}>time) {     if ($ENV{$prefix.'res.'.$uri.'.lock.expire'}>time) {
                        &log($ENV{'user.domain'},$ENV{'user.name'},                         &log($ENV{'user.domain'},$ENV{'user.name'},
                             $ENV{'user.host'},                              $ENV{'user.home'},
                             'Locked by res: '.$priv.' for '.$uri.' due to '.                              'Locked by res: '.$priv.' for '.$uri.' due to '.
                             $cdom.'/'.$cnum.'/'.$csec.' expire '.                              $cdom.'/'.$cnum.'/'.$csec.' expire '.
                             $ENV{$prefix.'priv.'.$priv.'.lock.expire'});                              $ENV{$prefix.'priv.'.$priv.'.lock.expire'});
Line 1656  sub allowed { Line 1680  sub allowed {
                 || ($ENV{$prefix.'priv.'.$priv.'.lock.sections'} eq 'all')) {                  || ($ENV{$prefix.'priv.'.$priv.'.lock.sections'} eq 'all')) {
    if ($ENV{'priv.'.$priv.'.lock.expire'}>time) {     if ($ENV{'priv.'.$priv.'.lock.expire'}>time) {
                        &log($ENV{'user.domain'},$ENV{'user.name'},                         &log($ENV{'user.domain'},$ENV{'user.name'},
                             $ENV{'user.host'},                              $ENV{'user.home'},
                             'Locked by priv: '.$priv.' for '.$uri.' due to '.                              'Locked by priv: '.$priv.' for '.$uri.' due to '.
                             $cdom.'/'.$cnum.'/'.$csec.' expire '.                              $cdom.'/'.$cnum.'/'.$csec.' expire '.
                             $ENV{$prefix.'priv.'.$priv.'.lock.expire'});                              $ENV{$prefix.'priv.'.$priv.'.lock.expire'});
Line 1684  sub allowed { Line 1708  sub allowed {
   
    if ($thisallowed=~/C/) {     if ($thisallowed=~/C/) {
        my $rolecode=(split(/\./,$ENV{'request.role'}))[0];         my $rolecode=(split(/\./,$ENV{'request.role'}))[0];
          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'}
    =~/$rolecode/) {     =~/$rolecode/) {
            &log($ENV{'user.domain'},$ENV{'user.name'},$ENV{'user.host'},             &log($ENV{'user.domain'},$ENV{'user.name'},$ENV{'user.host'},
Line 1691  sub allowed { Line 1716  sub allowed {
                 $ENV{'request.course.id'});                  $ENV{'request.course.id'});
            return '';             return '';
        }         }
   
          if ($ENV{'course.'.$ENV{'request.course.id'}.'.'.$priv.'.users.denied'}
      =~/$unamedom/) {
              &log($ENV{'user.domain'},$ENV{'user.name'},$ENV{'user.host'},
                   'Denied by user: '.$priv.' for '.$uri.' as '.$unamedom.' in '.
                   $ENV{'request.course.id'});
              return '';
          }
    }     }
   
 # Resource preferences  # Resource preferences
Line 1714  sub allowed { Line 1747  sub allowed {
        }         }
    }     }
   
 # Restricted by state?  # Restricted by state or randomout?
   
    if ($thisallowed=~/X/) {     if ($thisallowed=~/X/) {
         if ($ENV{'acc.randomout'}) {
            my $symb=&symbread($uri,1);
            if (($symb) && ($ENV{'acc.randomout'}=~/\&$symb\&/)) { 
               return ''; 
            }
         }
       if (&condval($statecond)) {        if (&condval($statecond)) {
  return '2';   return '2';
       } else {        } else {
Line 1789  sub definerole { Line 1828  sub definerole {
 # ---------------- Make a metadata query against the network of library servers  # ---------------- Make a metadata query against the network of library servers
   
 sub metadata_query {  sub metadata_query {
     my ($query,$custom,$customshow)=@_;      my ($query,$custom,$customshow,$server_array)=@_;
     my %rhash;      my %rhash;
     for my $server (keys %libserv) {      my @server_list = (defined($server_array) ? @$server_array
                                                 : keys(%libserv) );
       for my $server (@server_list) {
  unless ($custom or $customshow) {   unless ($custom or $customshow) {
     my $reply=&reply("querysend:".&escape($query),$server);      my $reply=&reply("querysend:".&escape($query),$server);
     $rhash{$server}=$reply;      $rhash{$server}=$reply;
Line 1806  sub metadata_query { Line 1847  sub metadata_query {
     return \%rhash;      return \%rhash;
 }  }
   
   # ----------------------------------------- Send log queries and wait for reply
   
   sub log_query {
       my ($uname,$udom,$query,%filters)=@_;
       my $uhome=&homeserver($uname,$udom);
       if ($uhome eq 'no_host') { return 'error: no_host'; }
       my $uhost=$hostname{$uhome};
       my $command=&escape(join(':',map{$_.'='.$filters{$_}} keys %filters));
       my $queryid=&reply("querysend:".$query.':'.$udom.':'.$uname.':'.$command,
                          $uhome);
       unless ($queryid=~/^$uhost\_/) { return 'error: '.$queryid; }
       return get_query_reply($queryid);
   }
   
   sub get_query_reply {
       my $queryid=shift;
       my $replyfile=$perlvar{'lonDaemons'}.'/tmp/'.$queryid;
       my $reply='';
       for (1..100) {
    sleep 2;
           if (-e $replyfile.'.end') {
       if (my $fh=Apache::File->new($replyfile)) {
                  $reply.=<$fh>;
                  $fh->close;
      } else { return 'error: reply_file_error'; }
              return &unescape($reply);
    }
       }
       return 'timeout:'.$queryid;
   }
   
   sub courselog_query {
   #
   # possible filters:
   # url: url or symb
   # username
   # domain
   # action: view, submit, grade
   # start: timestamp
   # end: timestamp
   #
       my (%filters)=@_;
       unless ($ENV{'request.course.id'}) { return 'no_course'; }
       if ($filters{'url'}) {
    $filters{'url'}=&symbclean(&declutter($filters{'url'}));
           $filters{'url'}=~s/\.(\w+)$/(\\.\\d+)*\\.$1/;
           $filters{'url'}=~s/\.(\w+)\_\_\_/(\\.\\d+)*\\.$1/;
       }
       my $cname=$ENV{'course.'.$ENV{'request.course.id'}.'.num'};
       my $cdom=$ENV{'course.'.$ENV{'request.course.id'}.'.domain'};
       return &log_query($cname,$cdom,'courselog',%filters);
   }
   
   sub userlog_query {
       my ($uname,$udom,%filters)=@_;
       return &log_query($uname,$udom,'userlog',%filters);
   }
   
 # ------------------------------------------------------------------ Plain Text  # ------------------------------------------------------------------ Plain Text
   
 sub plaintext {  sub plaintext {
Line 2077  sub revokecustomrole { Line 2176  sub revokecustomrole {
 # ------------------------------------------------------------ Directory lister  # ------------------------------------------------------------ Directory lister
   
 sub dirlist {  sub dirlist {
     my $uri=shift;      my ($uri,$userdomain,$username,$alternateDirectoryRoot)=@_;
   
     $uri=~s/^\///;      $uri=~s/^\///;
     $uri=~s/\/$//;      $uri=~s/\/$//;
     my ($res,$udom,$uname,@rest)=split(/\//,$uri);      my ($udom, $uname);
     if ($udom) {      (undef,$udom,$uname)=split(/\//,$uri);
      if ($uname) {      if(defined($userdomain)) {
        my $listing=reply('ls:'.$perlvar{'lonDocRoot'}.'/'.$uri,          $udom = $userdomain;
                       homeserver($uname,$udom));      }
        return split(/:/,$listing);      if(defined($username)) {
      } else {          $uname = $username;
        my $tryserver;      }
        my %allusers=();  
        foreach $tryserver (keys %libserv) {      my $dirRoot = $perlvar{'lonDocRoot'};
   if ($hostdom{$tryserver} eq $udom) {      if(defined($alternateDirectoryRoot)) {
              my $listing=reply('ls:'.$perlvar{'lonDocRoot'}.'/res/'.$udom,          $dirRoot = $alternateDirectoryRoot;
        $tryserver);          $dirRoot =~ s/\/$//;
              if (($listing ne 'no_such_dir') && ($listing ne 'empty')      }
               && ($listing ne 'con_lost')) {  
                 foreach (split(/:/,$listing)) {      if($udom) {
                   my ($entry,@stat)=split(/&/,$_);          if($uname) {
                   $allusers{$entry}=1;              my $listing=reply('ls:'.$dirRoot.'/'.$uri,
                                 homeserver($uname,$udom));
               return split(/:/,$listing);
           } elsif(!defined($alternateDirectoryRoot)) {
               my $tryserver;
               my %allusers=();
               foreach $tryserver (keys %libserv) {
                   if($hostdom{$tryserver} eq $udom) {
                       my $listing=reply('ls:'.$perlvar{'lonDocRoot'}.'/res/'.
                                         $udom, $tryserver);
                       if (($listing ne 'no_such_dir') && ($listing ne 'empty')
                           && ($listing ne 'con_lost')) {
                           foreach (split(/:/,$listing)) {
                               my ($entry,@stat)=split(/&/,$_);
                               $allusers{$entry}=1;
                           }
                       }
                 }                  }
              }              }
   }              my $alluserstr='';
        }              foreach (sort keys %allusers) {
        my $alluserstr='';                  $alluserstr.=$_.'&user:';
        foreach (sort keys %allusers) {              }
            $alluserstr.=$_.'&user:';              $alluserstr=~s/:$//;
        }              return split(/:/,$alluserstr);
        $alluserstr=~s/:$//;          } else {
        return split(/:/,$alluserstr);              my @emptyResults = ();
      }               push(@emptyResults, 'missing user name');
    } else {              return split(':',@emptyResults);
        my $tryserver;          }
        my %alldom=();      } elsif(!defined($alternateDirectoryRoot)) {
        foreach $tryserver (keys %libserv) {          my $tryserver;
    $alldom{$hostdom{$tryserver}}=1;          my %alldom=();
        }          foreach $tryserver (keys %libserv) {
        my $alldomstr='';              $alldom{$hostdom{$tryserver}}=1;
        foreach (sort keys %alldom) {          }
           $alldomstr.=$perlvar{'lonDocRoot'}.'/res/'.$_.'&domain:';          my $alldomstr='';
        }          foreach (sort keys %alldom) {
        $alldomstr=~s/:$//;              $alldomstr.=$perlvar{'lonDocRoot'}.'/res/'.$_.'&domain:';
        return split(/:/,$alldomstr);                 }
    }          $alldomstr=~s/:$//;
           return split(/:/,$alldomstr);       
       } else {
           my @emptyResults = ();
           push(@emptyResults, 'missing domain');
           return split(':',@emptyResults);
       }
 }  }
   
 # -------------------------------------------------------- Value of a Condition  # -------------------------------------------------------- Value of a Condition
Line 2182  sub courseresdata { Line 2304  sub courseresdata {
     my ($coursenum,$coursedomain,@which)=@_;      my ($coursenum,$coursedomain,@which)=@_;
     my $coursehom=&homeserver($coursenum,$coursedomain);      my $coursehom=&homeserver($coursenum,$coursedomain);
     my $hashid=$coursenum.':'.$coursedomain;      my $hashid=$coursenum.':'.$coursedomain;
     unless (defined($courseresdatacache{$hashid.'.time'})) {      my $dodump=0;
  unless (time-$courseresdatacache{$hashid.'.time'}<300) {      if (!defined($courseresdatacache{$hashid.'.time'})) {
            my $coursehom=&homeserver($coursenum,$coursedomain);   $dodump=1;
            if ($coursehom) {      } else {
               my $dumpreply=&reply('dump:'.$coursedomain.':'.$coursenum.   if (time-$courseresdatacache{$hashid.'.time'}>300) { $dodump=1; }
      ':resourcedata:.',$coursehom);  
       unless ($dumpreply=~/^error\:/) {  
          $courseresdatacache{$hashid.'.time'}=time;  
                  $courseresdatacache{$hashid}=$dumpreply;  
      }  
   }  
        }  
     }      }
    my @pairs=split(/\&/,$courseresdatacache{$hashid});      if ($dodump) {
    my %returnhash=();   my %dumpreply=&dump('resourcedata',$coursedomain,$coursenum);
    foreach (@pairs) {   my ($tmp) = keys(%dumpreply);
       my ($key,$value)=split(/=/,$_);   if ($tmp !~ /^(con_lost|error|no_such_host)/i) {
       $returnhash{unescape($key)}=unescape($value);      $courseresdatacache{$hashid.'.time'}=time;
    }      $courseresdatacache{$hashid}=\%dumpreply;
     my $item;   }
    foreach $item (@which) {      }
        if ($returnhash{$item}) { return $returnhash{$item}; }      foreach my $item (@which) {
    }   if ($courseresdatacache{$hashid}->{$item}) {
    return '';      return $courseresdatacache{$hashid}->{$item};
    }
       }
       return '';
 }  }
   
 # --------------------------------------------------------- Value of a Variable  # --------------------------------------------------------- Value of a Variable
Line 2278  sub EXT { Line 2396  sub EXT {
             my %reply=&get($space,[$item]);              my %reply=&get($space,[$item]);
             return $reply{$item};              return $reply{$item};
         }          }
     } elsif ($realm eq 'request') {      } elsif ($realm eq 'query') {
   # ---------------------------------------------- pull stuff out of query string
           &Apache::loncommon::get_unprocessed_cgi($ENV{'QUERY_STRING'},[$space]);
    return $ENV{'form.'.$space}; 
      } elsif ($realm eq 'request') {
 # ------------------------------------------------------------- request.browser  # ------------------------------------------------------------- request.browser
         if ($space eq 'browser') {          if ($space eq 'browser') {
     return $ENV{'browser.'.$qualifier};      return $ENV{'browser.'.$qualifier};
Line 2306  sub EXT { Line 2428  sub EXT {
     my $section;      my $section;
     if (($ENV{'user.name'} eq $uname) &&      if (($ENV{'user.name'} eq $uname) &&
  ($ENV{'user.domain'} eq $udom)) {   ($ENV{'user.domain'} eq $udom)) {
  $section={'request.course.sec'};   $section=$ENV{'request.course.sec'};
     } else {      } else {
  $section=&usection($udom,$uname,$courseid);   $section=&usection($udom,$uname,$courseid);
     }      }
Line 2608  sub symbclean { Line 2730  sub symbclean {
 # ------------------------------------------------------ Return symb list entry  # ------------------------------------------------------ Return symb list entry
   
 sub symbread {  sub symbread {
     my $thisfn=shift;      my ($thisfn,$donotrecurse)=@_;
   # no filename provided? try from environment
     unless ($thisfn) {      unless ($thisfn) {
         if ($ENV{'request.symb'}) { return &symbclean($ENV{'request.symb'}); }          if ($ENV{'request.symb'}) { return &symbclean($ENV{'request.symb'}); }
  $thisfn=$ENV{'request.filename'};   $thisfn=$ENV{'request.filename'};
     }      }
   # is that filename actually a symb? Verify, clean, and return
       if ($thisfn=~/\_\_\_\d+\_\_\_(.*)$/) {
    if (&symbverify($thisfn,$1)) { return &symbclean($thisfn); }
       }
     $thisfn=declutter($thisfn);      $thisfn=declutter($thisfn);
     my %hash;      my %hash;
     my %bighash;      my %bighash;
Line 2641  sub symbread { Line 2768  sub symbread {
               unless ($ids) {                 unless ($ids) { 
                  $ids=$bighash{'ids_/'.$thisfn};                   $ids=$bighash{'ids_/'.$thisfn};
               }                }
                 unless ($ids) {
   # alias?
     $ids=$bighash{'mapalias_'.$thisfn};
                 }
               if ($ids) {                if ($ids) {
 # ------------------------------------------------------------------- Has ID(s)  # ------------------------------------------------------------------- Has ID(s)
                  my @possibilities=split(/\,/,$ids);                   my @possibilities=split(/\,/,$ids);
Line 2648  sub symbread { Line 2779  sub symbread {
 # ----------------------------------------------- There is only one possibility  # ----------------------------------------------- There is only one possibility
      my ($mapid,$resid)=split(/\./,$ids);       my ($mapid,$resid)=split(/\./,$ids);
                      $syval=declutter($bighash{'map_id_'.$mapid}).'___'.$resid;                       $syval=declutter($bighash{'map_id_'.$mapid}).'___'.$resid;
                  } else {                   } elsif (!$donotrecurse) {
 # ------------------------------------------ There is more than one possibility  # ------------------------------------------ There is more than one possibility
                      my $realpossible=0;                       my $realpossible=0;
                      foreach (@possibilities) {                       foreach (@possibilities) {
Line 2663  sub symbread { Line 2794  sub symbread {
  }   }
                      }                       }
      if ($realpossible!=1) { $syval=''; }       if ($realpossible!=1) { $syval=''; }
                    } else {
                        $syval='';
                  }                   }
       }        }
               untie(%bighash)                untie(%bighash)
Line 2847  BEGIN { Line 2980  BEGIN {
   
     while (my $configline=<$config>) {      while (my $configline=<$config>) {
        chomp($configline);         chomp($configline);
        my ($id,$domain,$role,$name,$ip)=split(/:/,$configline);         my ($id,$domain,$role,$name,$ip,$domdescr)=split(/:/,$configline);
        $hostname{$id}=$name;         if ($id && $domain && $role && $name && $ip) {
        $hostdom{$id}=$domain;   $hostname{$id}=$name;
        $hostip{$id}=$ip;   $hostdom{$id}=$domain;
        if ($role eq 'library') { $libserv{$id}=$name; }   $hostip{$id}=$ip;
    if ($domdescr) { $domaindescription{$domain}=$domdescr; }
    if ($role eq 'library') { $libserv{$id}=$name; }
          } else {
    if ($configline) {
      &logthis("Skipping hosts.tab line -$configline-");
    }
          }
     }      }
 }  }
   
Line 2921  $readit=1; Line 3061  $readit=1;
 1;  1;
 __END__  __END__
   
   =pod
   
 =head1 NAME  =head1 NAME
   
 Apache::lonnet - TCP networking package  Apache::lonnet - Subroutines to ask questions about things in the network.
   
 =head1 SYNOPSIS  =head1 SYNOPSIS
   
 Invoked by other LON-CAPA modules.  Invoked by other LON-CAPA modules, when they need to talk to or about objects in the network.
   
  &Apache::lonnet::SUBROUTINENAME(ARGUMENTS);   &Apache::lonnet::SUBROUTINENAME(ARGUMENTS);
   
   Common parameters:
   
   =over 4
   
   =item *
   
   $uname : an internal username (if $cname expecting a course Id specifically)
   
   =item *
   
   $udom : a domain (if $cdom expecting a course's domain specifically)
   
   =item *
   
   $symb : a resource instance identifier
   
   =item *
   
   $namespace : the name of a .db file that contains the data needed or
   being set.
   
   =back
   
 =head1 INTRODUCTION  =head1 INTRODUCTION
   
 This module provides subroutines which interact with the  This module provides subroutines which interact with the
 lonc/lond (TCP) network layer of LON-CAPA.  lonc/lond (TCP) network layer of LON-CAPA. And Can be used to ask about 
   - classes
   - users 
   - resources
   
   For many of these objects you can also use this to store data about
   them or modify them in various ways.
   
 This is part of the LearningOnline Network with CAPA project  This is part of the LearningOnline Network with CAPA project
 described at http://www.lon-capa.org.  described at http://www.lon-capa.org.
   
 =head1 HANDLER SUBROUTINE  =head1 RETURN MESSAGES
   
 There is no handler routine for this module.  
   
 =head1 OTHER SUBROUTINES  
   
 =over 4  =over 4
   
 =item *  =item *
   
 logtouch() : make sure the logfile, lonnet.log, exists  con_lost : unable to contact remote host
   
 =item *  =item *
   
 logthis() : append message to lonnet.log  con_delayed : unable to contact remote host, message will be delivered
   when the connection is brought back up
   
 =item *  =item *
   
 logperm() : append a permanent message to lonnet.perm.log  con_failed : unable to contact remote host and unable to save message
   for later delivery
   
 =item *  =item *
   
 subreply() : non-critical communication, called by &reply  error: : an error a occured, a description of the error follows the :
   
 =item *  =item *
   
 reply() : makes two attempts to pass message; logs refusals and rejections  no_such_host : unable to fund a host associated with the user/domain
   that was requested
   
 =item *  =back
   
 reconlonc() : tries to reconnect lonc client processes.  =head1 PUBLIC SUBROUTINES
   
 =item *  =head2 Session Environment Functions
   
 critical() : passes a critical message to another server; if cannot get  =over 4
 through then place message in connection buffer  
   
 =item *  =item *
   
 appenv(%hash) : read in current user environment, append new environment  appenv(%hash) : the value of %hash is written to the user envirnoment
 values to make new user environment  file, and will be restored for each access this user makes during this
   session, also modifies the %ENV for the current process
   
 =item *  =item *
   
 delenv($varname) : read in current user environment, remove all values  delenv($regexp) : removes all items from the session environment file that matches the regular expression in $regexp. The values are also delted from the current processes %ENV.
 beginning with $varname, write new user environment (note: flock is used  
 to prevent conflicting shared read/writes with file)  
   
 =item *  =back
   
 spareserver() : find server with least workload from spare.tab  =head2 User Information
   
   =over 4
   
 =item *  =item *
   
Line 2999  authentication scheme Line 3169  authentication scheme
 =item *  =item *
   
 authenticate($uname,$upass,$udom) : try to authenticate user from domain's lib  authenticate($uname,$upass,$udom) : try to authenticate user from domain's lib
 servers (first use the current one)  servers (first use the current one), $upass should be the users password
   
 =item *  =item *
   
 homeserver($uname,$udom) : find the homebase for a user from domain's lib  homeserver($uname,$udom) : find the server which has the user's
 servers  directory and files (there must be only one), this caches the answer,
   and also caches if there is a borken connection.
   
 =item *  =item *
   
 idget($udom,@ids) : find the usernames behind a list of IDs (returns hash:  idget($udom,@ids) : find the usernames behind a list of IDs (IDs are a
   unique resource in a domain, there must be only 1 ID per username, and
   only 1 username per ID in a specific domain) (returns hash:
 id=>name,id=>name)  id=>name,id=>name)
   
 =item *  =item *
Line 3022  idput($udom,%ids) : store away a list of Line 3195  idput($udom,%ids) : store away a list of
   
 =item *  =item *
   
 usection($domain,$user,$courseid) : output of section name/number or '' for  rolesinit($udom,$username,$authhost) : get user privileges
 "not in course" and '-1' for "no section"  
   
 =item *  =item *
   
 userenvironment($domain,$user,$what) : puts out any environment parameter   usection($udom,$uname,$cname) : finds the section of student in the
 for a user  course $cname, return section name/number or '' for "not in course"
   and '-1' for "no section"
   
 =item *  =item *
   
 subscribe($fname) : subscribe to a resource, return URL if possible  userenvironment($udom,$uname,@what) : gets the values of the keys
   passed in @what from the requested user's environment, returns a hash
   
   =back
   
   =head2 User Roles
   
   =over 4
   
 =item *  =item *
   
 repcopy($filename) : replicate file  allowed($priv,$uri) : check for a user privilege; returns codes for allowed
   actions
    F: full access
    U,I,K: authentication modes (cxx only)
    '': forbidden
    1: user needs to choose course
    2: browse allowed
   
 =item *  =item *
   
 ssi($url,%hash) : server side include, does a complete request cycle on url to  definerole($rolename,$sysrole,$domrole,$courole) : define role; define a custom
 localhost, posts hash  role rolename set privileges in format of lonTabs/roles.tab for system, domain,
   and course level
   
 =item *  =item *
   
 log($domain,$name,$home,$message) : write to permanent log for user; use  plaintext($short) : return value in %prp hash (rolesplain.tab); plain text
 critical subroutine  explanation of a user role term
   
   =back
   
   =head2 User Modification
   
   =over 4
   
 =item *  =item *
   
 flushcourselogs() : flush (save) buffer logs and access logs  assignrole($udom,$uname,$url,$role,$end,$start) : assign role; give a role to a
   user for the level given by URL.  Optional start and end dates (leave empty
   string or zero for "no date")
   
 =item *  =item *
   
 courselog($what) : save message for course in hash  changepass($uname,$udom,$currentpass,$newpass,$server) : attempts to
   change a users, password, possible return values are: ok,
   pwchange_failure, non_authorized, auth_mode_error, unknown_user,
   refused
   
 =item *  =item *
   
 courseacclog($what) : save message for course using &courselog().  Perform  modifyuserauth($udom,$uname,$umode,$upass) : modify user authentication
 special processing for specific resource types (problems, exams, quizzes, etc).  
   
 =item *  =item *
   
 countacc($url) : count the number of accesses to a given URL  modifyuser($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene) : 
   modify user
   
 =item *  =item *
   
 sub checkout($symb,$tuname,$tudom,$tcrsid) : check out an item  modifystudent($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec,$end,$start) : modify student
   
 =item *  =item *
   
 sub checkin($token) : check in an item  assigncustomrole($udom,$uname,$url,$rdom,$rnam,$rolename,$end,$start) : assign
   custom role; give a custom role to a user for the level given by URL.  Specify
   name and domain of role author, and role name
   
 =item *  =item *
   
 sub expirespread($uname,$udom,$stype,$usymb) : set expire date for spreadsheet  revokerole($udom,$uname,$url,$role) : revoke a role for url
   
 =item *  =item *
   
 devalidate($symb) : devalidate spreadsheets  revokecustomrole($udom,$uname,$url,$role) : revoke a custom role
   
   =back
   
   =head2 Course Infomation
   
   =over 4
   
 =item *  =item *
   
 hash2str(%hash) : convert a hash into a string complete with escaping and '='  coursedescription($courseid) : course description
 and '&' separators, supports elements that are arrayrefs and hashrefs  
   
 =item *  =item *
   
 hashref2str($hashref) : convert a hashref into a string complete with  courseresdata($coursenum,$coursedomain,@which) : request for current
 escaping and '=' and '&' separators, supports elements that are  parameter setting for a specific course, @what should be a list of
 arrayrefs and hashrefs  parameters to ask about. This routine caches answers for 5 minutes.
   
   =back
   
   =head2 Course Modification
   
   =over 4
   
 =item *  =item *
   
 arrayref2str($arrayref) : convert an arrayref into a string complete  writecoursepref($courseid,%prefs) : write preferences (environment
 with escaping and '&' separators, supports elements that are arrayrefs  database) for a course
 and hashrefs  
   
 =item *  =item *
   
 str2hash($string) : convert string to hash using unescaping and  createcourse($udom,$description,$url) : make/modify course
 splitting on '=' and '&', supports elements that are arrayrefs and  
 hashrefs  =back
   
   =head2 Resource Subroutines
   
   =over 4
   
 =item *  =item *
   
 str2array($string) : convert string to hash using unescaping and  subscribe($fname) : subscribe to a resource, returns URL if possible (probably should use repcopy instead)
 splitting on '&', supports elements that are arrayrefs and hashrefs  
   
 =item *  =item *
   
 tmpreset($symb,$namespace,$domain,$stuname) : temporary storage  repcopy($filename) : subscribes to the requested file, and attempts to
   replicate from the owning library server, Might return
   HTTP_SERVICE_UNAVAILABLE, HTTP_NOT_FOUND, FORBIDDEN, OK, or
   HTTP_BAD_REQUEST, also attempts to grab the metadata for the
   resource. Expects the local filesystem pathname
   (/home/httpd/html/res/....)
   
   =back
   
   =head2 Resource Information
   
   =over 4
   
 =item *  =item *
   
 tmprestore($symb,$namespace,$domain,$stuname) : temporary restore  EXT($varname,$symb,$udom,$uname) : evaluates and returns the value of
   a vairety of different possible values, $varname should be a request
   string, and the other parameters can be used to specify who and what
   one is asking about.
   
   Possible values for $varname are environment.lastname (or other item
   from the envirnment hash), user.name (or someother aspect about the
   user), resource.0.maxtries (or some other part and parameter of a
   resource)
   
 =item *  =item *
   
 store($storehash,$symb,$namespace,$domain,$stuname) : stores hash permanently  directcondval($number) : get current value of a condition; reads from a state
 for this url; hashref needs to be given and should be a \%hashname; the  string
 remaining args aren't required and if they aren't passed or are '' they will  
 be derived from the ENV  
   
 =item *  =item *
   
 cstore($storehash,$symb,$namespace,$domain,$stuname) : same as store but  condval($condidx) : value of condition index based on state
 uses critical subroutine  
   
 =item *  =item *
   
 restore($symb,$namespace,$domain,$stuname) : returns hash for this symb;  metadata($uri,$what,$liburi,$prefix,$depthcount) : request a
 all args are optional  resource's metadata, $what should be either a specific key, or either
   'keys' (to get a list of possible keys) or 'packages' to get a list of
   packages that this resource currently uses, the last 3 arguments are only used internally for recursive metadata.
   
   this function automatically caches all requests
   
 =item *  =item *
   
 coursedescription($courseid) : course description  metadata_query($query,$custom,$customshow) : make a metadata query against the
   network of library servers; returns file handle of where SQL and regex results
   will be stored for query
   
 =item *  =item *
   
 rolesinit($domain,$username,$authhost) : get user privileges  symbread($filename) : return symbolic list entry (filename argument optional);
   returns the data handle
   
 =item *  =item *
   
 get($namespace,$storearr,$udomain,$uname) : returns hash with keys from array  symbverify($symb,$thisfn) : verifies that $symb actually exists and is
 reference filled in from namesp ($udomain and $uname are optional)  a possible symb for the URL in $thisfn, returns a 1 on success, 0 on
   failure, user must be in a course, as it assumes the existance of the
   course initi hash, and uses $ENV('request.course.id'}
   
   
 =item *  =item *
   
 del($namespace,$storearr,$udomain,$uname) : deletes keys out of array from  symbclean($symb) : removes versions numbers from a symb, returns the
 namesp ($udomain and $uname are optional)  cleaned symb
   
 =item *  =item *
   
 dump($namespace,$udomain,$uname,$regexp) :   is_on_map($uri) : checks if the $uri is somewhere on the current
 dumps the complete (or key matching regexp) namespace into a hash  course map, user must be in a course for it to work.
 ($udomain, $uname and $regexp are optional)  
   
 =item *  =item *
   
 put($namespace,$storehash,$udomain,$uname) : stores hash in namesp  numval($salt) : return random seed value (addend for rndseed)
 ($udomain and $uname are optional)  
   
 =item *  =item *
   
 cput($namespace,$storehash,$udomain,$uname) : critical put  rndseed($symb,$courseid,$udom,$uname) : create a random sum; returns
 ($udomain and $uname are optional)  a random seed, all arguments are optional, if they aren't sent it uses the
   environment to derive them. Note: if symb isn't sent and it can't get one
   from &symbread it will use the current time as its return value
   
 =item *  =item *
   
 eget($namespace,$storearr,$udomain,$uname) : returns hash with keys from array  ireceipt($funame,$fudom,$fucourseid,$fusymb) : return unique,
 reference filled in from namesp (encrypts the return communication)  unfakeable, receipt
 ($udomain and $uname are optional)  
   
 =item *  =item *
   
 allowed($priv,$uri) : check for a user privilege; returns codes for allowed  receipt() : API to ireceipt working off of ENV values; given out to users
 actions  
  F: full access  
  U,I,K: authentication modes (cxx only)  
  '': forbidden  
  1: user needs to choose course  
  2: browse allowed  
   
 =item *  =item *
   
 definerole($rolename,$sysrole,$domrole,$courole) : define role; define a custom  countacc($url) : count the number of accesses to a given URL
 role rolename set privileges in format of lonTabs/roles.tab for system, domain,  
 and course level  
   
 =item *  =item *
   
 metadata_query($query,$custom,$customshow) : make a metadata query against the  checkout($symb,$tuname,$tudom,$tcrsid) :  creates a record of a user having looked at an item, most likely printed out or otherwise using a resource
 network of library servers; returns file handle of where SQL and regex results  
 will be stored for query  
   
 =item *  =item *
   
 plaintext($short) : return value in %prp hash (rolesplain.tab); plain text  checkin($token) : updates that a resource has beeen returned (a hard copy version for instance) and returns the data that $token was Checkout with ($symb, $tuname, $tudom, and $tcrsid)
 explanation of a user role term  
   
 =item *  =item *
   
 assignrole($udom,$uname,$url,$role,$end,$start) : assign role; give a role to a  expirespread($uname,$udom,$stype,$usymb) : set expire date for spreadsheet
 user for the level given by URL.  Optional start and end dates (leave empty  
 string or zero for "no date")  
   
 =item *  =item *
   
 modifyuserauth($udom,$uname,$umode,$upass) : modify user authentication  devalidate($symb) : devalidate temporary spreadsheet calculations,
   forcing spreadsheet to reevaluate the resource scores next time.
   
   =back
   
   =head2 Storing/Retreiving Data
   
   =over 4
   
 =item *  =item *
   
 modifyuser($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene) :   store($storehash,$symb,$namespace,$udom,$uname) : stores hash permanently
 modify user  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
   
 =item *  =item *
   
 modifystudent($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec,  cstore($storehash,$symb,$namespace,$udom,$uname) : same as store but
 $end,$start) : modify student  uses critical subroutine
   
 =item *  =item *
   
 writecoursepref($courseid,%prefs) : write preferences for a course  restore($symb,$namespace,$udom,$uname) : returns hash for this symb;
   all args are optional
   
 =item *  =item *
   
 createcourse($udom,$description,$url) : make/modify course  tmpstore($storehash,$symb,$namespace,$udom,$uname) : storage that
   works very similar to store/cstore, but all data is stored in a
   temporary location and can be reset using tmpreset, $storehash should
   be a hash reference, returns nothing on success
   
 =item *  =item *
   
 assigncustomrole($udom,$uname,$url,$rdom,$rnam,$rolename,$end,$start) : assign  tmprestore($symb,$namespace,$udom,$uname) : storage that works very
 custom role; give a custom role to a user for the level given by URL.  Specify  similar to restore, but all data is stored in a temporary location and
 name and domain of role author, and role name  can be reset using tmpreset. Returns a hash of values on success,
   error string otherwise.
   
 =item *  =item *
   
 revokerole($udom,$uname,$url,$role) : revoke a role for url  tmpreset($symb,$namespace,$udom,$uname) : temporary storage reset,
   deltes all keys for $symb form the temporary storage hash.
   
 =item *  =item *
   
 revokecustomrole($udom,$uname,$url,$role) : revoke a custom role  get($namespace,$storearr,$udom,$uname) : returns hash with keys from array
   reference filled in from namesp ($udom and $uname are optional)
   
   =item *
   
   del($namespace,$storearr,$udom,$uname) : deletes keys out of array from
   namesp ($udom and $uname are optional)
   
   =item *
   
   dump($namespace,$udom,$uname,$regexp) : 
   dumps the complete (or key matching regexp) namespace into a hash
   ($udom, $uname and $regexp are optional)
   
   =item *
   
   put($namespace,$storehash,$udom,$uname) : stores hash in namesp
   ($udom and $uname are optional)
   
   =item *
   
   cput($namespace,$storehash,$udom,$uname) : critical put
   ($udom and $uname are optional)
   
   =item *
   
   eget($namespace,$storearr,$udom,$uname) : returns hash with keys from array
   reference filled in from namesp (encrypts the return communication)
   ($udom and $uname are optional)
   
   =item *
   
   log($udom,$name,$home,$message) : write to permanent log for user; use
   critical subroutine
   
   =back
   
   =head2 Network Status Functions
   
   =over 4
   
 =item *  =item *
   
Line 3249  dirlist($uri) : return directory list ba Line 3528  dirlist($uri) : return directory list ba
   
 =item *  =item *
   
 directcondval($number) : get current value of a condition; reads from a state  spareserver() : find server with least workload from spare.tab
 string  
   =back
   
   =head2 Apache Request
   
   =over 4
   
 =item *  =item *
   
 condval($condidx) : value of condition index based on state  ssi($url,%hash) : server side include, does a complete request cycle on url to
   localhost, posts hash
   
   =back
   
   =head2 Data to String to Data
   
   =over 4
   
 =item *  =item *
   
 EXT($varname,$symbparm) : value of a variable  hash2str(%hash) : convert a hash into a string complete with escaping and '='
   and '&' separators, supports elements that are arrayrefs and hashrefs
   
 =item *  =item *
   
 metadata($uri,$what,$liburi,$prefix,$depthcount) : get metadata; returns the  hashref2str($hashref) : convert a hashref into a string complete with
 metadata entry for a file; entry='keys', returns a comma separated list of keys  escaping and '=' and '&' separators, supports elements that are
   arrayrefs and hashrefs
   
 =item *  =item *
   
 symblist($mapname,%newhash) : update symbolic storage links  arrayref2str($arrayref) : convert an arrayref into a string complete
   with escaping and '&' separators, supports elements that are arrayrefs
   and hashrefs
   
 =item *  =item *
   
 symbread($filename) : return symbolic list entry (filename argument optional);  str2hash($string) : convert string to hash using unescaping and
 returns the data handle  splitting on '=' and '&', supports elements that are arrayrefs and
   hashrefs
   
 =item *  =item *
   
 numval($salt) : return random seed value (addend for rndseed)  str2array($string) : convert string to hash using unescaping and
   splitting on '&', supports elements that are arrayrefs and hashrefs
   
   =back
   
   =head2 Logging Routines
   
   =over 4
   
   These routines allow one to make log messages in the lonnet.log and
   lonnet.perm logfiles.
   
 =item *  =item *
   
 rndseed($symb,$courseid,$domain,$username) : create a random sum; returns  logtouch() : make sure the logfile, lonnet.log, exists
 a random seed, all arguments are optional, if they aren't sent it uses the  
 environment to derive them. Note: if symb isn't sent and it can't get one  
 from &symbread it will use the current time as its return value  
   
 =item *  =item *
   
 ireceipt($funame,$fudom,$fucourseid,$fusymb) : return unique,  logthis() : append message to the normal lonnet.log file, it gets
 unfakeable, receipt  preiodically rolled over and deleted.
   
 =item *  =item *
   
 receipt() : API to ireceipt working off of ENV values; given out to users  logperm() : append a permanent message to lonnet.perm.log, this log
   file never gets deleted by any automated portion of the system, only
   messages of critical importance should go in here.
   
   =back
   
   =head2 General File Helper Routines
   
   =over 4
   
 =item *  =item *
   
 getfile($file) : serves up a file, returns the contents of a file or -1;  getfile($file) : returns the entire contents of a file or -1; it
 replicates and subscribes to the file  properly subscribes to and replicates the file if neccessary.
   
 =item *  =item *
   
 filelocation($dir,$file) : returns file system location of a file based on URI;  filelocation($dir,$file) : returns file system location of a file
 meant to be "fairly clean" absolute reference, $dir is a directory that relative $file lookups are to looked in ($dir of /a/dir and a file of ../bob will become /a/bob)  based on URI; meant to be "fairly clean" absolute reference, $dir is a
   directory that relative $file lookups are to looked in ($dir of /a/dir
   and a file of ../bob will become /a/bob)
   
 =item *  =item *
   
Line 3313  filelocation except for hrefs Line 3626  filelocation except for hrefs
   
 declutter() : declutters URLs (remove docroot, beginning slashes, 'res' etc)  declutter() : declutters URLs (remove docroot, beginning slashes, 'res' etc)
   
   =back
   
   =head2 HTTP Helper Routines
   
   =over 4
   
 =item *  =item *
   
 escape() : unpack non-word characters into CGI-compatible hex codes  escape() : unpack non-word characters into CGI-compatible hex codes
Line 3321  escape() : unpack non-word characters in Line 3640  escape() : unpack non-word characters in
   
 unescape() : pack CGI-compatible hex codes into actual non-word ASCII character  unescape() : pack CGI-compatible hex codes into actual non-word ASCII character
   
   =back
   
   =head1 PRIVATE SUBROUTINES
   
   =head2 Underlying communication routines (Shouldn't call)
   
   =over 4
   
   =item *
   
   subreply() : tries to pass a message to lonc, returns con_lost if incapable
   
   =item *
   
   reply() : uses subreply to send a message to remote machine, logs all failures
   
   =item *
   
   critical() : passes a critical message to another server; if cannot
   get through then place message in connection buffer directory and
   returns con_delayed, if incapable of saving message, returns
   con_failed
   
   =item *
   
   reconlonc() : tries to reconnect lonc client processes.
   
   =back
   
   =head2 Resource Access Logging
   
   =over 4
   
   =item *
   
   flushcourselogs() : flush (save) buffer logs and access logs
   
   =item *
   
   courselog($what) : save message for course in hash
   
   =item *
   
   courseacclog($what) : save message for course using &courselog().  Perform
   special processing for specific resource types (problems, exams, quizzes, etc).
   
 =item *  =item *
   
 goodbye() : flush course logs and log shutting down; it is called in srm.conf  goodbye() : flush course logs and log shutting down; it is called in srm.conf
Line 3328  as a PerlChildExitHandler Line 3693  as a PerlChildExitHandler
   
 =back  =back
   
   =head2 Other
   
   =over 4
   
   =item *
   
   symblist($mapname,%newhash) : update symbolic storage links
   
   =back
   
 =cut  =cut
Removed from v.1.235  
changed lines
  Added in v.1.255

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