[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.250 and 1.338

version 1.250, 2002/07/04 15:47:18 version 1.338, 2003/03/14 02:26:12
Line 47 Line 47
 # 09/01 Guy Albertelli  # 09/01 Guy Albertelli
 # 09/01,10/01,11/01 Gerd Kortemeyer  # 09/01,10/01,11/01 Gerd Kortemeyer
 # YEAR=2001  # YEAR=2001
 # 02/27/01 Scott Harrison  
 # 3/2 Gerd Kortemeyer  # 3/2 Gerd Kortemeyer
 # 3/15,3/19 Scott Harrison  
 # 3/19,3/20 Gerd Kortemeyer  # 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/26,5/28 Gerd Kortemeyer
 # 5/30 H. K. Ng  # 5/30 H. K. Ng
 # 6/1 Gerd Kortemeyer  # 6/1 Gerd Kortemeyer
 # July Guy Albertelli  # July Guy Albertelli
 # 8/4,8/7,8/8,8/9,8/11,8/16,8/17,8/18,8/20,8/23,9/20,9/21,9/26,  # 8/4,8/7,8/8,8/9,8/11,8/16,8/17,8/18,8/20,8/23,9/20,9/21,9/26,
 # 10/2 Gerd Kortemeyer  # 10/2 Gerd Kortemeyer
 # 10/5,10/10,11/13,11/15 Scott Harrison  
 # 11/17,11/20,11/22,11/29 Gerd Kortemeyer  # 11/17,11/20,11/22,11/29 Gerd Kortemeyer
 # 12/5 Matthew Hall  # 12/5 Matthew Hall
 # 12/5 Guy Albertelli  # 12/5 Guy Albertelli
 # 12/6,12/7,12/12 Gerd Kortemeyer  # 12/6,12/7,12/12 Gerd Kortemeyer
 # 12/18 Scott Harrison  
 # 12/21,12/22,12/27,12/28 Gerd Kortemeyer  # 12/21,12/22,12/27,12/28 Gerd Kortemeyer
 # YEAR=2002  # YEAR=2002
 # 1/4,2/4,2/7 Gerd Kortemeyer  # 1/4,2/4,2/7 Gerd Kortemeyer
Line 77  use Apache::File; Line 72  use Apache::File;
 use LWP::UserAgent();  use LWP::UserAgent();
 use HTTP::Headers;  use HTTP::Headers;
 use vars   use vars 
 qw(%perlvar %hostname %homecache %badServerCache %hostip %spareid %hostdom   qw(%perlvar %hostname %homecache %badServerCache %hostip %iphost %spareid %hostdom 
    %libserv %pr %prp %metacache %packagetab      %libserv %pr %prp %metacache %packagetab %titlecache 
    %courselogs %accesshash $processmarker $dumpcount      %courselogs %accesshash $processmarker $dumpcount 
    %coursedombuf %coursehombuf %courseresdatacache %domaindescription);     %coursedombuf %coursehombuf %courseresdatacache 
      %domaindescription %domain_auth_def %domain_auth_arg_def $tmpdir);
 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::LCParser;  use HTML::LCParser;
 use Fcntl qw(:flock);  use Fcntl qw(:flock);
   use Apache::loncoursedata;
   
 my $readit;  my $readit;
   
 # --------------------------------------------------------------------- Logging  # --------------------------------------------------------------------- Logging
Line 140  sub reply { Line 138  sub reply {
     unless (defined($hostname{$server})) { return 'no_such_host'; }      unless (defined($hostname{$server})) { return 'no_such_host'; }
     my $answer=subreply($cmd,$server);      my $answer=subreply($cmd,$server);
     if ($answer eq 'con_lost') {      if ($answer eq 'con_lost') {
        #sleep 5;           #sleep 5; 
        #$answer=subreply($cmd,$server);          #$answer=subreply($cmd,$server);
        #if ($answer eq 'con_lost') {          #if ($answer eq 'con_lost') {
  #   &logthis("Second attempt con_lost on $server");   #   &logthis("Second attempt con_lost on $server");
         #   my $peerfile="$perlvar{'lonSockDir'}/$server";          #   my $peerfile="$perlvar{'lonSockDir'}/$server";
         #   my $client=IO::Socket::UNIX->new(Peer    =>"$peerfile",          #   my $client=IO::Socket::UNIX->new(Peer    =>"$peerfile",
Line 213  sub critical { Line 211  sub critical {
             $middlename=substr($middlename,0,16);              $middlename=substr($middlename,0,16);
             $middlename=~s/\W//g;              $middlename=~s/\W//g;
             my $dfilename=              my $dfilename=
              "$perlvar{'lonSockDir'}/delayed/$now.$middlename.$server";        "$perlvar{'lonSockDir'}/delayed/$now.$dumpcount.$$.$middlename.$server";
               $dumpcount++;
             {              {
              my $dfh;               my $dfh;
              if ($dfh=Apache::File->new(">$dfilename")) {               if ($dfh=Apache::File->new(">$dfilename")) {
Line 348  sub delenv { Line 347  sub delenv {
     return 'ok';      return 'ok';
 }  }
   
   # ------------------------------------------ Fight off request when overloaded
   
   sub overloaderror {
       my ($r,$checkserver)=@_;
       unless ($checkserver) { $checkserver=$perlvar{'lonHostID'}; }
       my $loadavg;
       if ($checkserver eq $perlvar{'lonHostID'}) {
          my $loadfile=Apache::File->new('/proc/loadavg');
          $loadavg=<$loadfile>;
          $loadavg =~ s/\s.*//g;
          $loadavg = 100*$loadavg/$perlvar{'lonLoadLim'};
       } else {
          $loadavg=&reply('load',$checkserver);
       }
       my $overload=$loadavg-100;
       if ($overload>0) {
    $r->err_headers_out->{'Retry-After'}=$overload;
           $r->log_error('Overload of '.$overload.' on '.$checkserver);
           return 413;
       }    
       return '';
   }
   
 # ------------------------------ Find server with least workload from spare.tab  # ------------------------------ Find server with least workload from spare.tab
   
 sub spareserver {  sub spareserver {
       my $loadpercent = shift;
     my $tryserver;      my $tryserver;
     my $spareserver='';      my $spareserver='';
     my $lowestserver=100;      my $lowestserver=$loadpercent; 
     foreach $tryserver (keys %spareid) {      foreach $tryserver (keys %spareid) {
        my $answer=reply('load',$tryserver);         my $answer=reply('load',$tryserver);
        if (($answer =~ /\d/) && ($answer<$lowestserver)) {         if (($answer =~ /\d/) && ($answer<$lowestserver)) {
Line 567  sub idput { Line 590  sub idput {
   
 # ------------------------------------- Find the section of student in a course  # ------------------------------------- Find the section of student in a course
   
   sub getsection {
       my ($udom,$unam,$courseid)=@_;
       $courseid=~s/\_/\//g;
       $courseid=~s/^(\w)/\/$1/;
       my %Pending; 
       my %Expired;
       #
       # Each role can either have not started yet (pending), be active, 
       #    or have expired.
       #
       # If there is an active role, we are done.
       #
       # If there is more than one role which has not started yet, 
       #     choose the one which will start sooner
       # If there is one role which has not started yet, return it.
       #
       # If there is more than one expired role, choose the one which ended last.
       # If there is a role which has expired, return it.
       #
       foreach (split(/\&/,&reply('dump:'.$udom.':'.$unam.':roles',
                           &homeserver($unam,$udom)))) {
           my ($key,$value)=split(/\=/,$_);
           $key=&unescape($key);
           next if ($key !~/^$courseid(?:\/)*(\w+)*\_st$/);
           my $section=$1;
           if ($key eq $courseid.'_st') { $section=''; }
           my ($dummy,$end,$start)=split(/\_/,&unescape($value));
           my $now=time;
           if (defined($end) && ($now > $end)) {
               $Expired{$end}=$section;
               next;
           }
           if (defined($start) && ($now < $start)) {
               $Pending{$start}=$section;
               next;
           }
           return $section;
       }
       #
       # Presumedly there will be few matching roles from the above
       # loop and the sorting time will be negligible.
       if (scalar(keys(%Pending))) {
           my ($time) = sort {$a <=> $b} keys(%Pending);
           return $Pending{$time};
       } 
       if (scalar(keys(%Expired))) {
           my @sorted = sort {$a <=> $b} keys(%Expired);
           my $time = pop(@sorted);
           return $Expired{$time};
       }
       return '-1';
   }
   
 sub usection {  sub usection {
     my ($udom,$unam,$courseid)=@_;      my ($udom,$unam,$courseid)=@_;
     $courseid=~s/\_/\//g;      $courseid=~s/\_/\//g;
Line 608  sub userenvironment { Line 684  sub userenvironment {
     return %returnhash;      return %returnhash;
 }  }
   
   # -------------------------------------------------------------------- New chat
   
   sub chatsend {
       my ($newentry,$anon)=@_;
       my $cnum=$ENV{'course.'.$ENV{'request.course.id'}.'.num'};
       my $cdom=$ENV{'course.'.$ENV{'request.course.id'}.'.domain'};
       my $chome=$ENV{'course.'.$ENV{'request.course.id'}.'.home'};
       &reply('chatsend:'.$cdom.':'.$cnum.':'.
      &escape($ENV{'user.domain'}.':'.$ENV{'user.name'}.':'.$anon.':'.
      &escape($newentry)),$chome);
   }
   
   # ------------------------------------------ Find current version of a resource
   
   sub getversion {
       my $fname=&clutter(shift);
       unless ($fname=~/^\/res\//) { return -1; }
       return &currentversion(&filelocation('',$fname));
   }
   
   sub currentversion {
       my $fname=shift;
       my $author=$fname;
       $author=~s/\/home\/httpd\/html\/res\/([^\/]*)\/([^\/]*).*/$1\/$2/;
       my ($udom,$uname)=split(/\//,$author);
       my $home=homeserver($uname,$udom);
       if ($home eq 'no_host') { 
           return -1; 
       }
       my $answer=reply("currentversion:$fname",$home);
       if (($answer eq 'con_lost') || ($answer eq 'rejected')) {
    return -1;
       }
       return $answer;
   }
   
 # ----------------------------- Subscribe to a resource, return URL if possible  # ----------------------------- Subscribe to a resource, return URL if possible
   
 sub subscribe {  sub subscribe {
     my $fname=shift;      my $fname=shift;
       if ($fname=~/\/(aboutme|syllabus|bulletinboard|smppg)$/) { return ''; }
     my $author=$fname;      my $author=$fname;
     $author=~s/\/home\/httpd\/html\/res\/([^\/]*)\/([^\/]*).*/$1\/$2/;      $author=~s/\/home\/httpd\/html\/res\/([^\/]*)\/([^\/]*).*/$1\/$2/;
     my ($udom,$uname)=split(/\//,$author);      my ($udom,$uname)=split(/\//,$author);
     my $home=homeserver($uname,$udom);      my $home=homeserver($uname,$udom);
     if (($home eq 'no_host') || ($home eq $perlvar{'lonHostID'})) {       if ($home eq 'no_host') {
         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')) {      if (($answer eq 'con_lost') || ($answer eq 'rejected')) {
Line 647  sub repcopy { Line 760  sub repcopy {
     } elsif ($remoteurl eq 'directory') {      } elsif ($remoteurl eq 'directory') {
            return OK;             return OK;
     } else {      } else {
           my $author=$filename;
           $author=~s/\/home\/httpd\/html\/res\/([^\/]*)\/([^\/]*).*/$1\/$2/;
           my ($udom,$uname)=split(/\//,$author);
           my $home=homeserver($uname,$udom);
           unless ($home eq $perlvar{'lonHostID'}) {
            my @parts=split(/\//,$filename);             my @parts=split(/\//,$filename);
            my $path="/$parts[1]/$parts[2]/$parts[3]/$parts[4]";             my $path="/$parts[1]/$parts[2]/$parts[3]/$parts[4]";
            if ($path ne "$perlvar{'lonDocRoot'}/res") {             if ($path ne "$perlvar{'lonDocRoot'}/res") {
Line 682  sub repcopy { Line 800  sub repcopy {
                rename($transname,$filename);                 rename($transname,$filename);
                return OK;                 return OK;
            }             }
          }
     }      }
 }  }
   
   # ------------------------------------------------ Get server side include body
   sub ssi_body {
       my $filelink=shift;
       my $output=($filelink=~/^http\:/?&externalssi($filelink):
                                        &ssi($filelink));
       $output=~s/^.*\<body[^\>]*\>//si;
       $output=~s/\<\/body\s*\>.*$//si;
       $output=~
               s/\/\/ BEGIN LON\-CAPA Internal.+\/\/ END LON\-CAPA Internal\s//gs;
       return $output;
   }
   
 # --------------------------------------------------------- Server Side Include  # --------------------------------------------------------- Server Side Include
   
 sub ssi {  sub ssi {
Line 708  sub ssi { Line 839  sub ssi {
     return $response->content;      return $response->content;
 }  }
   
   sub externalssi {
       my ($url)=@_;
       my $ua=new LWP::UserAgent;
       my $request=new HTTP::Request('GET',$url);
       my $response=$ua->request($request);
       return $response->content;
   }
   
   # ------- Add a token to a remote URI's query string to vouch for access rights
   
   sub tokenwrapper {
       my $uri=shift;
       $uri=~s/^http\:\/\/([^\/]+)//;
       $uri=~s/^\///;
       $ENV{'user.environment'}=~/\/([^\/]+)\.id/;
       my $token=$1;
       if ($uri=~/^uploaded\/([^\/]+)\/([^\/]+)\/([^\/]+)(\?\.*)*$/) {
    &appenv('userfile.'.$1.'/'.$2.'/'.$3 => $ENV{'request.course.id'});
           return 'http://'.$hostname{ &homeserver($2,$1)}.'/'.$uri.
                  (($uri=~/\?/)?'&':'?').'token='.$token.
                                  '&tokenissued='.$perlvar{'lonHostID'};
       } else {
    return '/adm/notfound.html';
       }
   }
       
   # --------------- Take an uploaded file and put it into the userfiles directory
   # input: name of form element, coursedoc=1 means this is for the course
   # output: url of file in userspace
   
   sub userfileupload {
       my ($formname,$coursedoc)=@_;
       my $fname=$ENV{'form.'.$formname.'.filename'};
   # Replace Windows backslashes by forward slashes
       $fname=~s/\\/\//g;
   # Get rid of everything but the actual filename
       $fname=~s/^.*\/([^\/]+)$/$1/;
   # Replace spaces by underscores
       $fname=~s/\s+/\_/g;
   # Replace all other weird characters by nothing
       $fname=~s/[^\w\.\-]//g;
   # See if there is anything left
       unless ($fname) { return 'error: no uploaded file'; }
       chop($ENV{'form.'.$formname});
   # Create the directory if not present
       my $docuname='';
       my $docudom='';
       my $docuhome='';
       if ($coursedoc) {
    $docuname=$ENV{'course.'.$ENV{'request.course.id'}.'.num'};
    $docudom=$ENV{'course.'.$ENV{'request.course.id'}.'.domain'};
    $docuhome=$ENV{'course.'.$ENV{'request.course.id'}.'.home'};
       } else {
           $docuname=$ENV{'user.name'};
           $docudom=$ENV{'user.domain'};
           $docuhome=$ENV{'user.home'};
       }
       return 
           &finishuserfileupload($docuname,$docudom,$docuhome,$formname,$fname);
   }
   
   sub finishuserfileupload {
       my ($docuname,$docudom,$docuhome,$formname,$fname)=@_;
       my $path=$docudom.'/'.$docuname.'/';
       my $filepath=$perlvar{'lonDocRoot'};
       my @parts=split(/\//,$filepath.'/userfiles/'.$path);
       my $count;
       for ($count=4;$count<=$#parts;$count++) {
           $filepath.="/$parts[$count]";
           if ((-e $filepath)!=1) {
       mkdir($filepath,0777);
           }
       }
   # Save the file
       {
          my $fh=Apache::File->new('>'.$filepath.'/'.$fname);
          print $fh $ENV{'form.'.$formname};
       }
   # Notify homeserver to grep it
   #
       
       my $fetchresult= 
    &reply('fetchuserfile:'.$docudom.'/'.$docuname.'/'.$fname,$docuhome);
       if ($fetchresult eq 'ok') {
   #
   # Return the URL to it
           return '/uploaded/'.$path.$fname;
       } else {
           &logthis('Failed to transfer '.$docudom.'/'.$docuname.'/'.$fname.
            ' to host '.$docuhome.': '.$fetchresult);
           return '/adm/notfound.html';
       }    
   }
   
 # ------------------------------------------------------------------------- Log  # ------------------------------------------------------------------------- Log
   
 sub log {  sub log {
Line 739  sub flushcourselogs { Line 964  sub flushcourselogs {
         my $entry=$_;          my $entry=$_;
         $entry=~/\_\_\_(\w+)\/(\w+)\/(.*)\_\_\_(\w+)$/;          $entry=~/\_\_\_(\w+)\/(\w+)\/(.*)\_\_\_(\w+)$/;
         my %temphash=($entry => $accesshash{$entry});          my %temphash=($entry => $accesshash{$entry});
         if (&Apache::lonnet::put('resevaldata',\%temphash,$1,$2) eq 'ok') {          if (&Apache::lonnet::put('nohist_resevaldata',\%temphash,$1,$2) eq 'ok') {
     delete $accesshash{$entry};      delete $accesshash{$entry};
         }          }
     }      }
Line 784  sub countacc { Line 1009  sub countacc {
     my $url=&declutter(shift);      my $url=&declutter(shift);
     unless ($ENV{'request.course.id'}) { return ''; }      unless ($ENV{'request.course.id'}) { return ''; }
     $accesshash{$ENV{'request.course.id'}.'___'.$url.'___course'}=1;      $accesshash{$ENV{'request.course.id'}.'___'.$url.'___course'}=1;
     my $key=$processmarker.'_'.$dumpcount.'___'.$url.'___count';      my $key=$$.$processmarker.'_'.$dumpcount.'___'.$url.'___count';
     if (defined($accesshash{$key})) {      if (defined($accesshash{$key})) {
  $accesshash{$key}++;   $accesshash{$key}++;
     } else {      } else {
Line 899  sub expirespread { Line 1124  sub expirespread {
 # ----------------------------------------------------- Devalidate Spreadsheets  # ----------------------------------------------------- Devalidate Spreadsheets
   
 sub devalidate {  sub devalidate {
     my $symb=shift;      my ($symb,$uname,$udom)=@_;
     my $cid=$ENV{'request.course.id'};       my $cid=$ENV{'request.course.id'}; 
     if ($cid) {      if ($cid) {
  my $key=$ENV{'user.name'}.':'.$ENV{'user.domain'}.':';  # delete the stored spreadsheets for
   # - the student level sheet of this user in course's homespace
   # - the assessment level sheet for this resource 
   #   for this user in user's homespace
    my $key=$uname.':'.$udom.':';
         my $status=          my $status=
     &del('nohist_calculatedsheet',      &del('nohist_calculatedsheets',
  [$key.'studentcalc'],   [$key.'studentcalc'],
  $ENV{'course.'.$cid.'.domain'},   $ENV{'course.'.$cid.'.domain'},
  $ENV{'course.'.$cid.'.num'})   $ENV{'course.'.$cid.'.num'})
Line 913  sub devalidate { Line 1142  sub devalidate {
  [$key.'assesscalc:'.$symb]);   [$key.'assesscalc:'.$symb]);
         unless ($status eq 'ok ok') {          unless ($status eq 'ok ok') {
            &logthis('Could not devalidate spreadsheet '.             &logthis('Could not devalidate spreadsheet '.
                     $ENV{'user.name'}.' at '.$ENV{'user.domain'}.' for '.                      $uname.' at '.$udom.' for '.
     $symb.': '.$status);      $symb.': '.$status);
         }          }
     }      }
 }  }
   
   sub get_scalar {
       my ($string,$end) = @_;
       my $value;
       if ($$string =~ s/^([^&]*?)($end)/$2/) {
    $value = $1;
       } elsif ($$string =~ s/^([^&]*?)&//) {
    $value = $1;
       }
       return &unescape($value);
   }
   
   sub array2str {
     my (@array) = @_;
     my $result=&arrayref2str(\@array);
     $result=~s/^__ARRAY_REF__//;
     $result=~s/__END_ARRAY_REF__$//;
     return $result;
   }
   
 sub arrayref2str {  sub arrayref2str {
   my ($arrayref) = @_;    my ($arrayref) = @_;
   my $result='_ARRAY_REF__';    my $result='__ARRAY_REF__';
   foreach my $elem (@$arrayref) {    foreach my $elem (@$arrayref) {
     if (ref($elem) eq 'ARRAY') {      if(ref($elem) eq 'ARRAY') {
       $result.=&escape(&arrayref2str($elem)).'&';        $result.=&arrayref2str($elem).'&';
     } elsif (ref($elem) eq 'HASH') {      } elsif(ref($elem) eq 'HASH') {
       $result.=&escape(&hashref2str($elem)).'&';        $result.=&hashref2str($elem).'&';
     } elsif (ref($elem)) {      } elsif(ref($elem)) {
       &logthis("Got a ref of ".(ref($elem))." skipping.");        #print("Got a ref of ".(ref($elem))." skipping.");
     } else {      } else {
       $result.=&escape($elem).'&';        $result.=&escape($elem).'&';
     }      }
   }    }
   $result=~s/\&$//;    $result=~s/\&$//;
     $result .= '__END_ARRAY_REF__';
   return $result;    return $result;
 }  }
   
 sub hash2str {  sub hash2str {
   my (%hash) = @_;    my (%hash) = @_;
   my $result=&hashref2str(\%hash);    my $result=&hashref2str(\%hash);
   $result=~s/^_HASH_REF__//;    $result=~s/^__HASH_REF__//;
     $result=~s/__END_HASH_REF__$//;
   return $result;    return $result;
 }  }
   
 sub hashref2str {  sub hashref2str {
   my ($hashref)=@_;    my ($hashref)=@_;
   my $result='_HASH_REF__';    my $result='__HASH_REF__';
   foreach (keys(%$hashref)) {    foreach (keys(%$hashref)) {
     if (ref($_) eq 'ARRAY') {      if (ref($_) eq 'ARRAY') {
       $result.=&escape(&arrayref2str($_)).'=';        $result.=&arrayref2str($_).'=';
     } elsif (ref($_) eq 'HASH') {      } elsif (ref($_) eq 'HASH') {
       $result.=&escape(&hashref2str($_)).'=';        $result.=&hashref2str($_).'=';
     } elsif (ref($_)) {      } elsif (ref($_)) {
       &logthis("Got a ref of ".(ref($_))." skipping.");        $result.='=';
         #print("Got a ref of ".(ref($_))." skipping.");
     } else {      } else {
       $result.=&escape($_).'=';   if ($_) {$result.=&escape($_).'=';} else { last; }
     }      }
   
     if (ref($$hashref{$_}) eq 'ARRAY') {      if(ref($hashref->{$_}) eq 'ARRAY') {
       $result.=&escape(&arrayref2str($$hashref{$_})).'&';        $result.=&arrayref2str($hashref->{$_}).'&';
     } elsif (ref($$hashref{$_}) eq 'HASH') {      } elsif(ref($hashref->{$_}) eq 'HASH') {
       $result.=&escape(&hashref2str($$hashref{$_})).'&';        $result.=&hashref2str($hashref->{$_}).'&';
     } elsif (ref($$hashref{$_})) {      } elsif(ref($hashref->{$_})) {
       &logthis("Got a ref of ".(ref($$hashref{$_}))." skipping.");         $result.='&';
         #print("Got a ref of ".(ref($hashref->{$_}))." skipping.");
     } else {      } else {
       $result.=&escape($$hashref{$_}).'&';        $result.=&escape($hashref->{$_}).'&';
     }      }
   }    }
   $result=~s/\&$//;    $result=~s/\&$//;
     $result .= '__END_HASH_REF__';
   return $result;    return $result;
 }  }
   
 sub str2hash {  sub str2hash {
       my ($string)=@_;
       my ($hash)=&str2hashref('__HASH_REF__'.$string.'__END_HASH_REF__');
       return %$hash;
   }
   
   sub str2hashref {
   my ($string) = @_;    my ($string) = @_;
   my %returnhash;  
   foreach (split(/\&/,$string)) {    my %hash;
     my ($name,$value)=split(/\=/,$_);  
     $name=&unescape($name);    if($string !~ /^__HASH_REF__/) {
     $value=&unescape($value);        if (! ($string eq '' || !defined($string))) {
     if ($value =~ /^_HASH_REF__/) {    $hash{'error'}='Not hash reference';
       $value =~ s/^_HASH_REF__//;        }
       my %hash=&str2hash($value);        return (\%hash, $string);
       $value=\%hash;    }
     } elsif ($value =~ /^_ARRAY_REF__/) {  
       $value =~ s/^_ARRAY_REF__//;    $string =~ s/^__HASH_REF__//;
       my @array=&str2array($value);  
       $value=\@array;    while($string !~ /^__END_HASH_REF__/) {
     }        #key
     $returnhash{$name}=$value;        my $key='';
         if($string =~ /^__HASH_REF__/) {
             ($key, $string)=&str2hashref($string);
             if(defined($key->{'error'})) {
                 $hash{'error'}='Bad data';
                 return (\%hash, $string);
             }
         } elsif($string =~ /^__ARRAY_REF__/) {
             ($key, $string)=&str2arrayref($string);
             if($key->[0] eq 'Array reference error') {
                 $hash{'error'}='Bad data';
                 return (\%hash, $string);
             }
         } else {
             $string =~ s/^(.*?)=//;
     $key=&unescape($1);
         }
         $string =~ s/^=//;
   
         #value
         my $value='';
         if($string =~ /^__HASH_REF__/) {
             ($value, $string)=&str2hashref($string);
             if(defined($value->{'error'})) {
                 $hash{'error'}='Bad data';
                 return (\%hash, $string);
             }
         } elsif($string =~ /^__ARRAY_REF__/) {
             ($value, $string)=&str2arrayref($string);
             if($value->[0] eq 'Array reference error') {
                 $hash{'error'}='Bad data';
                 return (\%hash, $string);
             }
         } else {
     $value=&get_scalar(\$string,'__END_HASH_REF__');
         }
         $string =~ s/^&//;
   
         $hash{$key}=$value;
   }    }
   return (%returnhash);  
     $string =~ s/^__END_HASH_REF__//;
   
     return (\%hash, $string);
 }  }
   
 sub str2array {  sub str2array {
       my ($string)=@_;
       my ($array)=&str2arrayref('__ARRAY_REF__'.$string.'__END_ARRAY_REF__');
       return @$array;
   }
   
   sub str2arrayref {
   my ($string) = @_;    my ($string) = @_;
   my @returnarray;    my @array;
   foreach my $value (split(/\&/,$string)) {  
     $value=&unescape($value);    if($string !~ /^__ARRAY_REF__/) {
     if ($value =~ /^_HASH_REF__/) {        if (! ($string eq '' || !defined($string))) {
       $value =~ s/^_HASH_REF__//;    $array[0]='Array reference error';
       my %hash=&str2hash($value);        }
       $value=\%hash;        return (\@array, $string);
     } elsif ($value =~ /^_ARRAY_REF__/) {  
       $value =~ s/^_ARRAY_REF__//;  
       my @array=&str2array($value);  
       $value=\@array;  
     }  
     push(@returnarray,$value);  
   }    }
   return (@returnarray);  
     $string =~ s/^__ARRAY_REF__//;
   
     while($string !~ /^__END_ARRAY_REF__/) {
         my $value='';
         if($string =~ /^__HASH_REF__/) {
             ($value, $string)=&str2hashref($string);
             if(defined($value->{'error'})) {
                 $array[0] ='Array reference error';
                 return (\@array, $string);
             }
         } elsif($string =~ /^__ARRAY_REF__/) {
             ($value, $string)=&str2arrayref($string);
             if($value->[0] eq 'Array reference error') {
                 $array[0] ='Array reference error';
                 return (\@array, $string);
             }
         } else {
     $value=&get_scalar(\$string,'__END_ARRAY_REF__');
         }
         $string =~ s/^&//;
   
         push(@array, $value);
     }
   
     $string =~ s/^__END_ARRAY_REF__//;
   
     return (\@array, $string);
 }  }
   
 # -------------------------------------------------------------------Temp Store  # -------------------------------------------------------------------Temp Store
Line 1033  sub tmpreset { Line 1360  sub tmpreset {
   my %hash;    my %hash;
   if (tie(%hash,'GDBM_File',    if (tie(%hash,'GDBM_File',
   $path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',    $path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',
   &GDBM_WRCREAT,0640)) {    &GDBM_WRCREAT(),0640)) {
     foreach my $key (keys %hash) {      foreach my $key (keys %hash) {
       if ($key=~ /:$symb/) {        if ($key=~ /:$symb/) {
  delete($hash{$key});   delete($hash{$key});
Line 1069  sub tmpstore { Line 1396  sub tmpstore {
   my $path=$perlvar{'lonDaemons'}.'/tmp';    my $path=$perlvar{'lonDaemons'}.'/tmp';
   if (tie(%hash,'GDBM_File',    if (tie(%hash,'GDBM_File',
   $path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',    $path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',
   &GDBM_WRCREAT,0640)) {    &GDBM_WRCREAT(),0640)) {
     $hash{"version:$symb"}++;      $hash{"version:$symb"}++;
     my $version=$hash{"version:$symb"};      my $version=$hash{"version:$symb"};
     my $allkeys='';       my $allkeys=''; 
Line 1113  sub tmprestore { Line 1440  sub tmprestore {
   my $path=$perlvar{'lonDaemons'}.'/tmp';    my $path=$perlvar{'lonDaemons'}.'/tmp';
   if (tie(%hash,'GDBM_File',    if (tie(%hash,'GDBM_File',
   $path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',    $path.'/tmpstore_'.$stuname.'_'.$domain.'_'.$namespace.'.db',
   &GDBM_READER,0640)) {    &GDBM_READER(),0640)) {
     my $version=$hash{"version:$symb"};      my $version=$hash{"version:$symb"};
     $returnhash{'version'}=$version;      $returnhash{'version'}=$version;
     my $scope;      my $scope;
Line 1147  sub store { Line 1474  sub store {
     $symb=&symbclean($symb);      $symb=&symbclean($symb);
     if (!$symb) { unless ($symb=&symbread()) { return ''; } }      if (!$symb) { unless ($symb=&symbread()) { return ''; } }
   
     &devalidate($symb);      if (!$domain) { $domain=$ENV{'user.domain'}; }
       if (!$stuname) { $stuname=$ENV{'user.name'}; }
   
       &devalidate($symb,$stuname,$domain);
   
     $symb=escape($symb);      $symb=escape($symb);
     if (!$namespace) {       if (!$namespace) { 
Line 1155  sub store { Line 1485  sub store {
           return '';             return ''; 
        }          } 
     }      }
     if (!$domain) { $domain=$ENV{'user.domain'}; }  
     if (!$stuname) { $stuname=$ENV{'user.name'}; }  
     if (!$home) { $home=$ENV{'user.home'}; }      if (!$home) { $home=$ENV{'user.home'}; }
     my $namevalue='';      my $namevalue='';
     foreach (keys %$storehash) {      foreach (keys %$storehash) {
Line 1178  sub cstore { Line 1506  sub cstore {
     $symb=&symbclean($symb);      $symb=&symbclean($symb);
     if (!$symb) { unless ($symb=&symbread()) { return ''; } }      if (!$symb) { unless ($symb=&symbread()) { return ''; } }
   
     &devalidate($symb);      if (!$domain) { $domain=$ENV{'user.domain'}; }
       if (!$stuname) { $stuname=$ENV{'user.name'}; }
   
       &devalidate($symb,$stuname,$domain);
   
     $symb=escape($symb);      $symb=escape($symb);
     if (!$namespace) {       if (!$namespace) { 
Line 1186  sub cstore { Line 1517  sub cstore {
           return '';             return ''; 
        }          } 
     }      }
     if (!$domain) { $domain=$ENV{'user.domain'}; }  
     if (!$stuname) { $stuname=$ENV{'user.name'}; }  
     if (!$home) { $home=$ENV{'user.home'}; }      if (!$home) { $home=$ENV{'user.home'}; }
   
     my $namevalue='';      my $namevalue='';
Line 1245  sub coursedescription { Line 1574  sub coursedescription {
     $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);
       my $normalid=$cdomain.'_'.$cnum;
       # need to always cache even if we get errors otherwise we keep 
       # trying and trying and trying to get the course description.
       my %envhash=();
       my %returnhash=();
       $envhash{'course.'.$normalid.'.last_cache'}=time;
     if ($chome ne 'no_host') {      if ($chome ne 'no_host') {
        my %returnhash=&dump('environment',$cdomain,$cnum);         %returnhash=&dump('environment',$cdomain,$cnum);
        if (!exists($returnhash{'con_lost'})) {         if (!exists($returnhash{'con_lost'})) {
            my $normalid=$cdomain.'_'.$cnum;  
            my %envhash=();  
            $returnhash{'home'}= $chome;             $returnhash{'home'}= $chome;
    $returnhash{'domain'} = $cdomain;     $returnhash{'domain'} = $cdomain;
    $returnhash{'num'} = $cnum;     $returnhash{'num'} = $cnum;
            while (my ($name,$value) = each %returnhash) {             while (my ($name,$value) = each %returnhash) {
                $envhash{'course.'.$normalid.'.'.$name}=$value;                 $envhash{'course.'.$normalid.'.'.$name}=$value;
            }             }
            $returnhash{'url'}='/res/'.declutter($returnhash{'url'});             $returnhash{'url'}=&clutter($returnhash{'url'});
            $returnhash{'fn'}=$perlvar{'lonDaemons'}.'/tmp/'.             $returnhash{'fn'}=$perlvar{'lonDaemons'}.'/tmp/'.
        $ENV{'user.name'}.'_'.$cdomain.'_'.$cnum;         $ENV{'user.name'}.'_'.$cdomain.'_'.$cnum;
            $envhash{'course.'.$normalid.'.last_cache'}=time;  
            $envhash{'course.'.$normalid.'.home'}=$chome;             $envhash{'course.'.$normalid.'.home'}=$chome;
            $envhash{'course.'.$normalid.'.domain'}=$cdomain;             $envhash{'course.'.$normalid.'.domain'}=$cdomain;
            $envhash{'course.'.$normalid.'.num'}=$cnum;             $envhash{'course.'.$normalid.'.num'}=$cnum;
            &appenv(%envhash);  
            return %returnhash;  
        }         }
     }      }
     return ();      &appenv(%envhash);
       return %returnhash;
 }  }
   
 # -------------------------------------------------------- Get user privileges  # -------------------------------------------------------- Get user privileges
Line 1384  sub get { Line 1715  sub get {
   
    my $rep=&reply("get:$udomain:$uname:$namespace:$items",$uhome);     my $rep=&reply("get:$udomain:$uname:$namespace:$items",$uhome);
    my @pairs=split(/\&/,$rep);     my @pairs=split(/\&/,$rep);
      if ( $#pairs==0 && $pairs[0] =~ /^(con_lost|error|no_such_host)/i) {
        return @pairs;
      }
    my %returnhash=();     my %returnhash=();
    my $i=0;     my $i=0;
    foreach (@$storearr) {     foreach (@$storearr) {
Line 1431  sub dump { Line 1765  sub dump {
    return %returnhash;     return %returnhash;
 }  }
   
   # --------------------------------------------------------------- currentdump
   sub currentdump {
      my ($courseid,$sdom,$sname)=@_;
      $courseid = $ENV{'request.course.id'} if (! defined($courseid));
      $sdom     = $ENV{'user.domain'}       if (! defined($sdom));
      $sname    = $ENV{'user.name'}         if (! defined($sname));
      my $uhome = &homeserver($sname,$sdom);
      my $rep=reply('currentdump:'.$sdom.':'.$sname.':'.$courseid,$uhome);
      return if ($rep =~ /^(error:|no_such_host)/);
      #
      my %returnhash=();
      #
      if ($rep eq "unknown_cmd") { 
          # an old lond will not know currentdump
          # Do a dump and make it look like a currentdump
          my @tmp = &dump($courseid,$sdom,$sname,'.');
          return if ($tmp[0] =~ /^(error:|no_such_host)/);
          my %hash = @tmp;
          @tmp=();
          # Code ripped from lond, essentially.  The only difference
          # here is the unescaping done by lonnet::dump().  Conceivably
          # we might run in to problems with parameter names =~ /^v\./
          while (my ($key,$value) = each(%hash)) {
              my ($v,$symb,$param) = split(/:/,$key);
              next if ($v eq 'version' || $symb eq 'keys');
              next if (exists($returnhash{$symb}) &&
                       exists($returnhash{$symb}->{$param}) &&
                       $returnhash{$symb}->{'v.'.$param} > $v);
              $returnhash{$symb}->{$param}=$value;
              $returnhash{$symb}->{'v.'.$param}=$v;
          }
          #
          # Remove all of the keys in the hashes which keep track of
          # the version of the parameter.
          while (my ($symb,$param_hash) = each(%returnhash)) {
              # use a foreach because we are going to delete from the hash.
              foreach my $key (keys(%$param_hash)) {
                  delete($param_hash->{$key}) if ($key =~ /^v\./);
              }
          }
      } else {
          my @pairs=split(/\&/,$rep);
          foreach (@pairs) {
              my ($key,$value)=split(/=/,$_);
              my ($symb,$param) = split(/:/,$key);
              $returnhash{&unescape($symb)}->{&unescape($param)} = 
                                                             &unescape($value);
          }
      }
      return %returnhash;
   }
   
 # --------------------------------------------------------------- put interface  # --------------------------------------------------------------- put interface
   
 sub put {  sub put {
Line 1502  sub allowed { Line 1888  sub allowed {
   
     if ($priv eq 'bre') {      if ($priv eq 'bre') {
         my $copyright=&metadata($uri,'copyright');          my $copyright=&metadata($uri,'copyright');
  if ($copyright eq 'public') { return 'F'; }   if (($copyright eq 'public') && (!$ENV{'request.course.id'})) { 
              return 'F'; 
           }
         if ($copyright eq 'priv') {          if ($copyright eq 'priv') {
             $uri=~/([^\/]+)\/([^\/]+)\//;              $uri=~/([^\/]+)\/([^\/]+)\//;
     unless (($ENV{'user.name'} eq $2) && ($ENV{'user.domain'} eq $1)) {      unless (($ENV{'user.name'} eq $2) && ($ENV{'user.domain'} eq $1)) {
Line 1516  sub allowed { Line 1904  sub allowed {
  return '';   return '';
             }              }
         }          }
           if ($ENV{'request.role'}=~ /li\.\//) {
               # Library role, so allow browsing of resources in this domain.
               return 'F';
           }
       }
       # Domain coordinator is trying to create a course
       if (($priv eq 'ccc') && ($ENV{'request.role'} =~ /^dc\./)) {
           # uri is the requested domain in this case.
           # comparison to 'request.role.domain' shows if the user has selected
           # a role of dc for the domain in question. 
           return 'F' if ($uri eq $ENV{'request.role.domain'});
     }      }
   
     my $thisallowed='';      my $thisallowed='';
Line 1545  sub allowed { Line 1944  sub allowed {
        $thisallowed.=$1;         $thisallowed.=$1;
     }      }
   
   # URI is an uploaded document for this course
   
       if (($priv eq 'bre') && 
           ($uri=~/^uploaded\/$ENV{'course.'.$ENV{'request.course.id'}.'.domain'}\/$ENV{'course.'.$ENV{'request.course.id'}.'.num'}/)) {
           return 'F';
       }
 # Full access at system, domain or course-wide level? Exit.  # Full access at system, domain or course-wide level? Exit.
   
     if ($thisallowed=~/F/) {      if ($thisallowed=~/F/) {
Line 1763  sub is_on_map { Line 2168  sub is_on_map {
     my @uriparts=split(/\//,$uri);      my @uriparts=split(/\//,$uri);
     my $filename=$uriparts[$#uriparts];      my $filename=$uriparts[$#uriparts];
     my $pathname=$uri;      my $pathname=$uri;
     $pathname=~s/\/$filename$//;      $pathname=~s|/\Q$filename\E$||;
       $pathname=~s/^adm\/wrapper\///;    
       #Trying to find the conditional for the file
     my $match=($ENV{'acc.res.'.$ENV{'request.course.id'}.'.'.$pathname}=~      my $match=($ENV{'acc.res.'.$ENV{'request.course.id'}.'.'.$pathname}=~
        /\&$filename\:([\d\|]+)\&/);         /\&\Q$filename\E\:([\d\|]+)\&/);
     if ($match) {      if ($match) {
        return (1,$1);   return (1,$1);
    } else {      } else {
        return (0,0);   return (0,0);
    }      }
 }  }
   
 # ----------------------------------------------------------------- Define Role  # ----------------------------------------------------------------- Define Role
Line 1947  sub modifyuserauth { Line 2354  sub modifyuserauth {
     my $uhome=&homeserver($uname,$udom);      my $uhome=&homeserver($uname,$udom);
     unless (&allowed('mau',$udom)) { return 'refused'; }      unless (&allowed('mau',$udom)) { return 'refused'; }
     &logthis('Call to modify user authentication '.$udom.', '.$uname.', '.      &logthis('Call to modify user authentication '.$udom.', '.$uname.', '.
              $umode.' by '.$ENV{'user.name'}.' at '.$ENV{'user.domain'});                 $umode.' by '.$ENV{'user.name'}.' at '.$ENV{'user.domain'}.
                ' in domain '.$ENV{'request.role.domain'});  
     my $reply=&reply('encrypt:changeuserauth:'.$udom.':'.$uname.':'.$umode.':'.      my $reply=&reply('encrypt:changeuserauth:'.$udom.':'.$uname.':'.$umode.':'.
      &escape($upass),$uhome);       &escape($upass),$uhome);
     &log($ENV{'user.domain'},$ENV{'user.name'},$ENV{'user.home'},      &log($ENV{'user.domain'},$ENV{'user.name'},$ENV{'user.home'},
Line 1978  sub modifyuser { Line 2386  sub modifyuser {
      $last.', '.$gene.'(forceid: '.$forceid.')'.       $last.', '.$gene.'(forceid: '.$forceid.')'.
              (defined($desiredhome) ? ' desiredhome = '.$desiredhome :               (defined($desiredhome) ? ' desiredhome = '.$desiredhome :
                                      ' desiredhome not specified').                                        ' desiredhome not specified'). 
              ' by '.$ENV{'user.name'}.' at '.$ENV{'user.domain'});               ' by '.$ENV{'user.name'}.' at '.$ENV{'user.domain'}.
                ' in domain '.$ENV{'request.role.domain'});
     my $uhome=&homeserver($uname,$udom,'true');      my $uhome=&homeserver($uname,$udom,'true');
 # ----------------------------------------------------------------- Create User  # ----------------------------------------------------------------- Create User
     if (($uhome eq 'no_host') && ($umode) && ($upass)) {      if (($uhome eq 'no_host') && ($umode) && ($upass)) {
Line 2028  sub modifyuser { Line 2437  sub modifyuser {
        }         }
     }      }
 # -------------------------------------------------------------- Add names, etc  # -------------------------------------------------------------- Add names, etc
     my %names=&get('environment',      my @tmp=&get('environment',
    ['firstname','middlename','lastname','generation'],     ['firstname','middlename','lastname','generation'],
    $udom,$uname);     $udom,$uname);
     if ($names{'firstname'} =~ m/^error:.*/) { %names=(); }      my %names;
       if ($tmp[0] =~ m/^error:.*/) { 
           %names=(); 
       } else {
           %names = @tmp;
       }
     if ($first)  { $names{'firstname'}  = $first; }      if ($first)  { $names{'firstname'}  = $first; }
     if ($middle) { $names{'middlename'} = $middle; }      if ($middle) { $names{'middlename'} = $middle; }
     if ($last)   { $names{'lastname'}   = $last; }      if ($last)   { $names{'lastname'}   = $last; }
Line 2059  sub modifystudent { Line 2473  sub modifystudent {
  ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$forceid,   ($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$forceid,
          $desiredhome);           $desiredhome);
     unless ($reply eq 'ok') { return $reply; }      unless ($reply eq 'ok') { return $reply; }
       # This will cause &modify_student_enrollment to get the uid from the
       # students environment
       $uid = undef if (!$forceid);
       $reply = &modify_student_enrollment($udom,$uname,$uid,$first,$middle,
                                           $last,$gene,$usec,$end,$start);
       return $reply;
   }
   
   sub modify_student_enrollment {
       my ($udom,$uname,$uid,$first,$middle,$last,$gene,$usec,$end,$start) = @_;
       # Get the course id from the environment
       my $cid='';
       unless ($cid=$ENV{'request.course.id'}) {
    return 'not_in_class';
       }
       # Make sure the user exists
     my $uhome=&homeserver($uname,$udom);      my $uhome=&homeserver($uname,$udom);
     if (($uhome eq '') || ($uhome eq 'no_host')) {       if (($uhome eq '') || ($uhome eq 'no_host')) { 
  return 'error: no such user';   return 'error: no such user';
     }      }
 # -------------------------------------------------- Add student to course list      #
     $reply=critical('put:'.$ENV{'course.'.$cid.'.domain'}.':'.      # Get student data if we were not given enough information
       if (!defined($first)  || $first  eq '' || 
           !defined($last)   || $last   eq '' || 
           !defined($uid)    || $uid    eq '' || 
           !defined($middle) || $middle eq '' || 
           !defined($gene)   || $gene   eq '') {
           # They did not supply us with enough data to enroll the student, so
           # we need to pick up more information.
           my %tmp = &get('environment',
                          ['firstname','middlename','lastname', 'generation','id']
                          ,$udom,$uname);
   
           foreach (keys(%tmp)) {
               &logthis("key $_ = ".$tmp{$_});
           }
           $first  = $tmp{'firstname'}  if (!defined($first)  || $first  eq '');
           $middle = $tmp{'middlename'} if (!defined($middle) || $middle eq '');
           $last   = $tmp{'lastname'}   if (!defined($last)   || $last eq '');
           $gene   = $tmp{'generation'} if (!defined($gene)   || $gene eq '');
           $uid    = $tmp{'id'}         if (!defined($uid)    || $uid  eq '');
       }
       my $fullname = &Apache::loncoursedata::ProcessFullName($last,$gene,
                                                              $first,$middle);
       my $reply=critical('put:'.$ENV{'course.'.$cid.'.domain'}.':'.
               $ENV{'course.'.$cid.'.num'}.':classlist:'.                $ENV{'course.'.$cid.'.num'}.':classlist:'.
                       &escape($uname.':'.$udom).'='.                        &escape($uname.':'.$udom).'='.
                       &escape($end.':'.$start),                        &escape(join(':',$end,$start,$uid,$usec,$fullname)),
               $ENV{'course.'.$cid.'.home'});                $ENV{'course.'.$cid.'.home'});
     unless (($reply eq 'ok') || ($reply eq 'delayed')) {      unless (($reply eq 'ok') || ($reply eq 'delayed')) {
  return 'error: '.$reply;   return 'error: '.$reply;
     }      }
 # ---------------------------------------------------- Add student role to user      # Add student role to user
     my $uurl='/'.$cid;      my $uurl='/'.$cid;
     $uurl=~s/\_/\//g;      $uurl=~s/\_/\//g;
     if ($usec) {      if ($usec) {
Line 2103  sub writecoursepref { Line 2556  sub writecoursepref {
 # ---------------------------------------------------------- Make/modify course  # ---------------------------------------------------------- Make/modify course
   
 sub createcourse {  sub createcourse {
     my ($udom,$description,$url)=@_;      my ($udom,$description,$url,$course_server,$nonstandard)=@_;
     $url=&declutter($url);      $url=&declutter($url);
     my $cid='';      my $cid='';
     unless (&allowed('ccc',$ENV{'user.domain'})) {      unless (&allowed('ccc',$udom)) {
         return 'refused';  
     }  
     unless ($udom eq $ENV{'user.domain'}) {  
         return 'refused';          return 'refused';
     }      }
 # ------------------------------------------------------------------- Create ID  # ------------------------------------------------------------------- Create ID
Line 2125  sub createcourse { Line 2575  sub createcourse {
            return 'error: unable to generate unique course-ID';             return 'error: unable to generate unique course-ID';
        }          } 
    }     }
   # ------------------------------------------------ Check supplied server name
       $course_server = $ENV{'user.homeserver'} if (! defined($course_server));
       if (! exists($libserv{$course_server})) {
           return 'error:bad server name '.$course_server;
       }
 # ------------------------------------------------------------- Make the course  # ------------------------------------------------------------- Make the course
     my $reply=&reply('encrypt:makeuser:'.$udom.':'.$uname.':none::',      my $reply=&reply('encrypt:makeuser:'.$udom.':'.$uname.':none::',
                       $ENV{'user.home'});                        $course_server);
     unless ($reply eq 'ok') { return 'error: '.$reply; }      unless ($reply eq 'ok') { return 'error: '.$reply; }
     $uhome=&homeserver($uname,$udom,'true');      $uhome=&homeserver($uname,$udom,'true');
     if (($uhome eq '') || ($uhome eq 'no_host')) {       if (($uhome eq '') || ($uhome eq 'no_host')) { 
  return 'error: no such course';   return 'error: no such course';
     }      }
   # ----------------------------------------------------------------- Course made
       my $topurl=$url;
       unless ($nonstandard) {
   # ------------------------------------------ For standard courses, make top url
           my $mapurl=&clutter($url);
           if ($mapurl eq '/res/') { $mapurl=''; }
           $ENV{'form.initmap'}=(<<ENDINITMAP);
   <map>
   <resource id="1" type="start"></resource>
   <resource id="2" src="$mapurl"></resource>
   <resource id="3" type="finish"></resource>
   <link index="1" from="1" to="2"></link>
   <link index="2" from="2" to="3"></link>
   </map>
   ENDINITMAP
           $topurl=&declutter(
           &finishuserfileupload($uname,$udom,$uhome,'initmap','default.sequence')
                             );
       }
   # ----------------------------------------------------------- Write preferences
     &writecoursepref($udom.'_'.$uname,      &writecoursepref($udom.'_'.$uname,
                      ('description' => $description,                       ('description' => $description,
                       'url'         => $url));                        'url'         => $topurl));
     return '/'.$udom.'/'.$uname;      return '/'.$udom.'/'.$uname;
 }  }
   
Line 2166  sub revokecustomrole { Line 2641  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);
       }
   }
   
   # --------------------------------------------- GetFileTimestamp
   # This function utilizes dirlist and returns the date stamp for
   # when it was last modified.  It will also return an error of -1
   # if an error occurs
   
   sub GetFileTimestamp {
       my ($studentDomain,$studentName,$filename,$root)=@_;
       $studentDomain=~s/\W//g;
       $studentName=~s/\W//g;
       my $subdir=$studentName.'__';
       $subdir =~ s/(.)(.)(.).*/$1\/$2\/$3/;
       my $proname="$studentDomain/$subdir/$studentName";
       $proname .= '/'.$filename;
       my @dir = &Apache::lonnet::dirlist($proname, $studentDomain, $studentName,
                                          $root);
       my $fileStat = $dir[0];
       my @stats = split('&', $fileStat);
       if($stats[0] ne 'empty' && $stats[0] ne 'no_such_dir') {
           return $stats[9];
       } else {
           return -1;
       }
 }  }
   
 # -------------------------------------------------------- Value of a Condition  # -------------------------------------------------------- Value of a Condition
Line 2265  sub condval { Line 2787  sub condval {
     return $result;      return $result;
 }  }
   
   # ---------------------------------------------------- Devalidate courseresdata
   
   sub devalidatecourseresdata {
       my ($coursenum,$coursedomain)=@_;
       my $hashid=$coursenum.':'.$coursedomain;
       delete $courseresdatacache{$hashid.'.time'};
   }
   
 # --------------------------------------------------- Course Resourcedata Query  # --------------------------------------------------- Course Resourcedata Query
   
 sub courseresdata {  sub courseresdata {
Line 2278  sub courseresdata { Line 2808  sub courseresdata {
  if (time-$courseresdatacache{$hashid.'.time'}>300) { $dodump=1; }   if (time-$courseresdatacache{$hashid.'.time'}>300) { $dodump=1; }
     }      }
     if ($dodump) {      if ($dodump) {
  my $coursehom=&homeserver($coursenum,$coursedomain);   my %dumpreply=&dump('resourcedata',$coursedomain,$coursenum);
  if ($coursehom) {   my ($tmp) = keys(%dumpreply);
     my $dumpreply=&reply('dump:'.$coursedomain.':'.$coursenum.   if ($tmp !~ /^(con_lost|error|no_such_host)/i) {
  ':resourcedata:.',$coursehom);      $courseresdatacache{$hashid.'.time'}=time;
     if ($dumpreply!~/^error\:/) {      $courseresdatacache{$hashid}=\%dumpreply;
  $courseresdatacache{$hashid.'.time'}=time;   } elsif ($tmp =~ /^(con_lost|no_such_host)/) {
  $courseresdatacache{$hashid}=$dumpreply;      return $tmp;
     }  
  }   }
     }      }
     my @pairs=split(/\&/,$courseresdatacache{$hashid});      foreach my $item (@which) {
     my %returnhash=();   if (defined($courseresdatacache{$hashid}->{$item})) {
     foreach (@pairs) {      return $courseresdatacache{$hashid}->{$item};
  my ($key,$value)=split(/=/,$_);   }
  $returnhash{unescape($key)}=unescape($value);  
     }  
     my $item;  
     foreach $item (@which) {  
  if ($returnhash{$item}) { return $returnhash{$item}; }  
     }      }
     return '';      return undef;
 }  }
   
 # --------------------------------------------------------- Value of a Variable  # --------------------------------------------------------- Value of a Variable
   
 sub EXT {  sub EXT {
     my ($varname,$symbparm,$udom,$uname)=@_;      my ($varname,$symbparm,$udom,$uname,)=@_;
   
     unless ($varname) { return ''; }      unless ($varname) { return ''; }
   
     #get real user name/domain, courseid and symb      #get real user name/domain, courseid and symb
     my $courseid;      my $courseid;
     if (!($uname && $udom)) {      if (!($uname && $udom)) {
Line 2316  sub EXT { Line 2839  sub EXT {
     } else {      } else {
  $courseid=$ENV{'request.course.id'};   $courseid=$ENV{'request.course.id'};
     }      }
   
     my ($realm,$space,$qualifier,@therest)=split(/\./,$varname);      my ($realm,$space,$qualifier,@therest)=split(/\./,$varname);
     my $rest;      my $rest;
     if ($therest[0]) {      if (defined($therest[0])) {
        $rest=join('.',@therest);         $rest=join('.',@therest);
     } else {      } else {
        $rest='';         $rest='';
     }      }
   
     my $qualifierrest=$qualifier;      my $qualifierrest=$qualifier;
     if ($rest) { $qualifierrest.='.'.$rest; }      if ($rest) { $qualifierrest.='.'.$rest; }
     my $spacequalifierrest=$space;      my $spacequalifierrest=$space;
Line 2331  sub EXT { Line 2854  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(undef,undef,$udom,$uname);      if (defined($Apache::lonhomework::parsing_a_problem)) {
             return $restored{$qualifierrest};   return $Apache::lonhomework::history{$qualifierrest};
       } else {
    my %restored=&restore($symbparm,$courseid,$udom,$uname);
    return $restored{$qualifierrest};
       }
 # ----------------------------------------------------------------- user.access  # ----------------------------------------------------------------- user.access
         } elsif ($space eq 'access') {          } elsif ($space eq 'access') {
     # FIXME - not supporting calls for a specific user      # FIXME - not supporting calls for a specific user
Line 2367  sub EXT { Line 2894  sub EXT {
             return $uname;              return $uname;
 # ---------------------------------------------------- Any other user namespace  # ---------------------------------------------------- Any other user namespace
         } else {          } else {
             my $item=($rest)?$qualifier.'.'.$rest:$qualifier;              my %reply=&get($space,[$qualifierrest],$udom,$uname);
             my %reply=&get($space,[$item]);              return $reply{$qualifierrest};
             return $reply{$item};  
         }          }
     } elsif ($realm eq 'query') {      } elsif ($realm eq 'query') {
 # ---------------------------------------------- pull stuff out of query string  # ---------------------------------------------- pull stuff out of query string
Line 2403  sub EXT { Line 2929  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 2417  sub EXT { Line 2943  sub EXT {
     my $courselevelm=$courseid.'.'.$mapparm;      my $courselevelm=$courseid.'.'.$mapparm;
   
 # ----------------------------------------------------------- first, check user  # ----------------------------------------------------------- first, check user
     my %resourcedata=&get('resourcedata',      #most student don't have any data set, check if there is some data
   [$courselevelr,$courselevelm,$courselevel],              #every thirty minutes
  $udom,$uname);      if (!
     if (($resourcedata{$courselevelr}!~/^error\:/) &&   (exists($ENV{'cache.studentresdata'})
  ($resourcedata{$courselevelr}!~/^con_lost/)) {      && (($ENV{'cache.studentresdata'}+1800) > time))) {
    my %resourcedata=&get('resourcedata',
  if ($resourcedata{$courselevelr}) {        [$courselevelr,$courselevelm,$courselevel],
     return $resourcedata{$courselevelr}; }        $udom,$uname);
  if ($resourcedata{$courselevelm}) {   my ($tmp)=keys(%resourcedata);
     return $resourcedata{$courselevelm}; }   if (($tmp!~/^error\:/) && ($tmp!~/^con_lost/)) {
  if ($resourcedata{$courselevel}) {      if ($resourcedata{$courselevelr}) {
     return $resourcedata{$courselevel}; }   return $resourcedata{$courselevelr}; }
     } else {      if ($resourcedata{$courselevelm}) {
  if ($resourcedata{$courselevelr}!~/No such file/) {   return $resourcedata{$courselevelm}; }
     &logthis("<font color=blue>WARNING:".      if ($resourcedata{$courselevel}) {
      " Trying to get resource data for ".   return $resourcedata{$courselevel}; }
      $uname." at ".$udom.": ".   } else {
      $resourcedata{$courselevelr}."</font>");      if ($tmp!~/No such file/) {
    &logthis("<font color=blue>WARNING:".
    " Trying to get resource data for ".
    $uname." at ".$udom.": ".
    $tmp."</font>");
       } elsif ($tmp=~/error:No such file/) {
    $ENV{'cache.studentresdata'}=time;
    &appenv(('cache.studentresdata'=>
    $ENV{'cache.studentresdata'}));
       } elsif ($tmp =~ /^(con_lost|no_such_host)/) {
    return $tmp;
       }
  }   }
     }      }
   
Line 2445  sub EXT { Line 2982  sub EXT {
   ($seclevelr,$seclevelm,$seclevel,    ($seclevelr,$seclevelm,$seclevel,
    $courselevelr,$courselevelm,     $courselevelr,$courselevelm,
    $courselevel));     $courselevel));
     if ($coursereply) { return $coursereply; }      if (defined($coursereply)) { return $coursereply; }
   
 # ------------------------------------------------------ third, check map parms  # ------------------------------------------------------ third, check map parms
     my %parmhash=();      my %parmhash=();
     my $thisparm='';      my $thisparm='';
     if (tie(%parmhash,'GDBM_File',      if (tie(%parmhash,'GDBM_File',
     $ENV{'request.course.fn'}.'_parms.db',      $ENV{'request.course.fn'}.'_parms.db',
     &GDBM_READER,0640)) {      &GDBM_READER(),0640)) {
  $thisparm=$parmhash{$symbparm};   $thisparm=$parmhash{$symbparm};
  untie(%parmhash);   untie(%parmhash);
     }      }
Line 2461  sub EXT { Line 2998  sub EXT {
 # --------------------------------------------- last, look in resource metadata  # --------------------------------------------- last, look in resource metadata
   
  $spacequalifierrest=~s/\./\_/;   $spacequalifierrest=~s/\./\_/;
  my $metadata=&metadata($ENV{'request.filename'},$spacequalifierrest);   my $filename;
  if ($metadata) { return $metadata; }   if (!$symbparm) { $symbparm=&symbread(); }
  $metadata=&metadata($ENV{'request.filename'},   if ($symbparm) {
     'parameter_'.$spacequalifierrest);      $filename=(split(/\_\_\_/,$symbparm))[2];
  if ($metadata) { return $metadata; }   } else {
       $filename=$ENV{'request.filename'};
    }
    my $metadata=&metadata($filename,$spacequalifierrest);
    if (defined($metadata)) { return $metadata; }
    $metadata=&metadata($filename,'parameter_'.$spacequalifierrest);
    if (defined($metadata)) { return $metadata; }
   
 # ------------------------------------------------------------------ Cascade up  # ------------------------------------------------------------------ Cascade up
  unless ($space eq '0') {   unless ($space eq '0') {
     my ($part,$id)=split(/\_/,$space);      my @parts=split(/_/,$space);
     if ($id) {      my $id=pop(@parts);
  my $partgeneral=&EXT('resource.'.$part.'.'.$qualifierrest,      my $part=join('_',@parts);
      $symbparm,$udom,$uname);      if ($part eq '') { $part='0'; }
  if ($partgeneral) { return $partgeneral; }      my $partgeneral=&EXT('resource.'.$part.'.'.$qualifierrest,
     } else {   $symbparm,$udom,$uname);
  my $resourcegeneral=&EXT('resource.0.'.$qualifierrest,      if (defined($partgeneral)) { return $partgeneral; }
  $symbparm,$udom,$uname);  
  if ($resourcegeneral) { return $resourcegeneral; }  
     }  
  }   }
   
 # ---------------------------------------------------- Any other user namespace  # ---------------------------------------------------- Any other user namespace
Line 2500  sub EXT { Line 3040  sub EXT {
     return '';      return '';
 }  }
   
   sub add_prefix_and_part {
       my ($prefix,$part)=@_;
       my $keyroot;
       if (defined($prefix) && $prefix !~ /^__/) {
    # prefix that has a part already
    $keyroot=$prefix;
       } elsif (defined($prefix)) {
    # prefix that is missing a part
    if (defined($part)) { $keyroot='_'.$part.substr($prefix,1); }
       } else {
    # no prefix at all
    if (defined($part)) { $keyroot='_'.$part; }
       }
       return $keyroot;
   }
   
 # ---------------------------------------------------------------- Get metadata  # ---------------------------------------------------------------- Get metadata
   
 sub metadata {  sub metadata {
     my ($uri,$what,$liburi,$prefix,$depthcount)=@_;      my ($uri,$what,$liburi,$prefix,$depthcount)=@_;
   
     $uri=&declutter($uri);      $uri=&declutter($uri);
       # if it is a non metadata possible uri return quickly
       if (($uri eq '') || (($uri =~ m|^/*adm/|) && ($uri !~ m|^adm/includes|)) ||
           ($uri =~ m|/$|) || ($uri =~ m|/.meta$|)) {
    return '';
       }
     my $filename=$uri;      my $filename=$uri;
     $uri=~s/\.meta$//;      $uri=~s/\.meta$//;
 #  #
Line 2513  sub metadata { Line 3074  sub metadata {
 # Look at timestamp of caching  # Look at timestamp of caching
 # Everything is cached by the main uri, libraries are never directly cached  # Everything is cached by the main uri, libraries are never directly cached
 #  #
     unless (abs($metacache{$uri.':cachedtimestamp'}-time)<600) {      unless (abs($metacache{$uri.':cachedtimestamp'}-time)<600 && !defined($liburi)) {
 #  #
 # Is this a recursive call for a library?  # Is this a recursive call for a library?
 #  #
Line 2523  sub metadata { Line 3084  sub metadata {
         }          }
         my %metathesekeys=();          my %metathesekeys=();
         unless ($filename=~/\.meta$/) { $filename.='.meta'; }          unless ($filename=~/\.meta$/) { $filename.='.meta'; }
  my $metastring=&getfile($perlvar{'lonDocRoot'}.'/res/'.$filename);   my $metastring=&getfile(&filelocation('',&clutter($filename)));
         my $parser=HTML::LCParser->new(\$metastring);          my $parser=HTML::LCParser->new(\$metastring);
         my $token;          my $token;
         undef %metathesekeys;          undef %metathesekeys;
Line 2534  sub metadata { Line 3095  sub metadata {
 # This is a package - get package info  # This is a package - get package info
 #  #
       my $package=$token->[2]->{'package'};        my $package=$token->[2]->{'package'};
       my $keyroot='';        my $keyroot=&add_prefix_and_part($prefix,$token->[2]->{'part'});
               if ($prefix) {  
   $keyroot.='_'.$prefix;  
               } else {  
                 if (defined($token->[2]->{'part'})) {   
                    $keyroot.='_'.$token->[2]->{'part'};   
         }  
       }  
               if (defined($token->[2]->{'id'})) {                 if (defined($token->[2]->{'id'})) { 
                  $keyroot.='_'.$token->[2]->{'id'};                    $keyroot.='_'.$token->[2]->{'id'}; 
       }        }
Line 2562  sub metadata { Line 3116  sub metadata {
                       my $unikey='parameter'.$keyroot.'_'.$name;                        my $unikey='parameter'.$keyroot.'_'.$name;
                       $metathesekeys{$unikey}=1;                        $metathesekeys{$unikey}=1;
                       $metacache{$uri.':'.$unikey.'.part'}=$part;                        $metacache{$uri.':'.$unikey.'.part'}=$part;
                       unless                         unless (defined($metacache{$uri.':'.$unikey.'.'.$subp})) {
                        (defined($metacache{$uri.':'.$unikey.'.'.$subp})) {    $metacache{$uri.':'.$unikey.'.'.$subp}=$value;
                          $metacache{$uri.':'.$unikey.'.'.$subp}=$value;        }
         if (defined($metacache{$uri.':'.$unikey.'.default'})) {
     $metacache{$uri.':'.$unikey}=
        $metacache{$uri.':'.$unikey.'.default'}
       }        }
                   }                    }
               }                }
Line 2579  sub metadata { Line 3136  sub metadata {
               } else {                } else {
                  $unikey=$entry;                   $unikey=$entry;
       }        }
               if ($prefix) {        $unikey.=&add_prefix_and_part($prefix,$token->[2]->{'part'});
   $unikey.=$prefix;  
               } else {  
                 if (defined($token->[2]->{'part'})) {   
                    $unikey.='_'.$token->[2]->{'part'};   
         }  
       }  
               if (defined($token->[2]->{'id'})) {                 if (defined($token->[2]->{'id'})) { 
                  $unikey.='_'.$token->[2]->{'id'};                    $unikey.='_'.$token->[2]->{'id'}; 
       }        }
Line 2594  sub metadata { Line 3146  sub metadata {
 #  #
 # Importing a library here  # Importing a library here
 #                  #                
  if (defined($depthcount)) { $depthcount++; } else   
                                            { $depthcount=0; }  
                  if ($depthcount<20) {                   if ($depthcount<20) {
      foreach (split(/\,/,&metadata($uri,'keys',       my $location=$parser->get_text('/import');
                                   $parser->get_text('/import'),$unikey,       my $dir=$filename;
                                   $depthcount))) {       $dir=~s|[^/]*$||;
        $location=&filelocation($dir,$location);
        foreach (sort(split(/\,/,&metadata($uri,'keys',
    $location,$unikey,
    $depthcount+1)))) {
                          $metathesekeys{$_}=1;                           $metathesekeys{$_}=1;
      }       }
  }   }
Line 2612  sub metadata { Line 3166  sub metadata {
               foreach (@{$token->[3]}) {                foreach (@{$token->[3]}) {
   $metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};    $metacache{$uri.':'.$unikey.'.'.$_}=$token->[2]->{$_};
               }                }
               unless (        my $internaltext=&HTML::Entities::decode($parser->get_text('/'.$entry));
                  $metacache{$uri.':'.$unikey}=&HTML::Entities::decode($parser->get_text('/'.$entry))        my $default=$metacache{$uri.':'.$unikey.'.default'};
       ) { $metacache{$uri.':'.$unikey}=        if ( $internaltext =~ /^\s*$/ && $default !~ /^\s*$/) {
       $metacache{$uri.':'.$unikey.'.default'};    # only ws inside the tag, and not in default, so use default
       }                    # as value
     $metacache{$uri.':'.$unikey}=$default;
         } else {
     # either something interesting inside the tag or default
                     # uninteresting
     $metacache{$uri.':'.$unikey}=$internaltext;
         }
 # end of not-a-package not-a-library import  # end of not-a-package not-a-library import
    }     }
 # end of not-a-package start tag  # end of not-a-package start tag
Line 2624  sub metadata { Line 3184  sub metadata {
 # the next is the end of "start tag"  # the next is the end of "start tag"
  }   }
        }         }
        $metacache{$uri.':keys'}=join(',',keys %metathesekeys);  # are there custom rights to evaluate
    if ($metacache{$uri.':copyright'} eq 'custom') {
           
       #
       # Importing a rights file here
       #                
                    unless ($depthcount) {
        my $location=$metacache{$uri.':customdistributionfile'};
        my $dir=$filename;
        $dir=~s|[^/]*$||;
        $location=&filelocation($dir,$location);
        foreach (sort(split(/\,/,&metadata($uri,'keys',
    $location,'_rights',
    $depthcount+1)))) {
                            $metathesekeys{$_}=1;
        }
    }
        }
      $metacache{$uri.':keys'}=join(',',keys %metathesekeys);
    &metadata_generate_part0(\%metathesekeys,\%metacache,$uri);
          $metacache{$uri.':allpossiblekeys'}=join(',',keys %metathesekeys);
        $metacache{$uri.':cachedtimestamp'}=time;         $metacache{$uri.':cachedtimestamp'}=time;
 # this is the end of "was not already recently cached  # this is the end of "was not already recently cached
     }      }
     return $metacache{$uri.':'.$what};      return $metacache{$uri.':'.$what};
 }  }
   
   sub metadata_generate_part0 {
       my ($metadata,$metacache,$uri) = @_;
       my %allnames;
       foreach my $metakey (sort keys %$metadata) {
    if ($metakey=~/^parameter\_(.*)/) {
     my $part=$$metacache{$uri.':'.$metakey.'.part'};
     my $name=$$metacache{$uri.':'.$metakey.'.name'};
     if (! exists($$metadata{'parameter_0_'.$name})) {
       $allnames{$name}=$part;
     }
    }
       }
       foreach my $name (keys(%allnames)) {
         $$metadata{"parameter_0_$name"}=1;
         my $key="$uri:parameter_0_$name";
         $$metacache{"$key.part"}='0';
         $$metacache{"$key.name"}=$name;
         $$metacache{"$key.type"}=$$metacache{$uri.':parameter_'.
      $allnames{$name}.'_'.$name.
      '.type'};
         my $olddis=$$metacache{$uri.':parameter_'.$allnames{$name}.'_'.$name.
        '.display'};
         my $expr='\\[Part: '.$allnames{$name}.'\\]';
         $olddis=~s/$expr/\[Part: 0\]/;
         $$metacache{"$key.display"}=$olddis;
       }
   }
   
   # ------------------------------------------------- Get the title of a resource
   
   sub gettitle {
       my $urlsymb=shift;
       my $symb=&symbread($urlsymb);
       unless ($symb) {
    unless ($urlsymb) { $urlsymb=$ENV{'request.filename'}; }
           return &metadata($urlsymb,'title'); 
       }
       if ($titlecache{$symb}) { return $titlecache{$symb}; }
       my ($map,$resid,$url)=split(/\_\_\_/,$symb);
       my $title='';
       my %bighash;
       if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',
                               &GDBM_READER(),0640)) {
           my $mapid=$bighash{'map_pc_'.&clutter($map)};
           $title=$bighash{'title_'.$mapid.'.'.$resid};
           untie %bighash;
       }
       if ($title) {
           $titlecache{$symb}=$title;
           return $title;
       } else {
    return &metadata($urlsymb,'title');
       }
   }
       
 # ------------------------------------------------- Update symbolic store links  # ------------------------------------------------- Update symbolic store links
   
 sub symblist {  sub symblist {
Line 2639  sub symblist { Line 3274  sub symblist {
     my %hash;      my %hash;
     if (($ENV{'request.course.fn'}) && (%newhash)) {      if (($ENV{'request.course.fn'}) && (%newhash)) {
         if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',          if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',
                       &GDBM_WRCREAT,0640)) {                        &GDBM_WRCREAT(),0640)) {
     foreach (keys %newhash) {      foreach (keys %newhash) {
                 $hash{declutter($_)}=$mapname.'___'.$newhash{$_};                  $hash{declutter($_)}=$mapname.'___'.$newhash{$_};
             }              }
Line 2667  sub symbverify { Line 3302  sub symbverify {
     my %bighash;      my %bighash;
     my $okay=0;      my $okay=0;
     if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',      if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',
                             &GDBM_READER,0640)) {                              &GDBM_READER(),0640)) {
         my $ids=$bighash{'ids_/res/'.$thisfn};          my $ids=$bighash{'ids_'.&clutter($thisfn)};
         unless ($ids) {           unless ($ids) { 
            $ids=$bighash{'ids_/'.$thisfn};             $ids=$bighash{'ids_/'.$thisfn};
         }          }
Line 2721  sub symbread { Line 3356  sub symbread {
     my $syval='';      my $syval='';
     if (($ENV{'request.course.fn'}) && ($thisfn)) {      if (($ENV{'request.course.fn'}) && ($thisfn)) {
         if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',          if (tie(%hash,'GDBM_File',$ENV{'request.course.fn'}.'_symb.db',
                       &GDBM_READER,0640)) {                        &GDBM_READER(),0640)) {
     $syval=$hash{$thisfn};      $syval=$hash{$thisfn};
             untie(%hash);              untie(%hash);
         }          }
Line 2737  sub symbread { Line 3372  sub symbread {
         } else {          } else {
 # ------------------------------------------------------- Was not in symb table  # ------------------------------------------------------- Was not in symb table
            if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',             if (tie(%bighash,'GDBM_File',$ENV{'request.course.fn'}.'.db',
                             &GDBM_READER,0640)) {                              &GDBM_READER(),0640)) {
 # ---------------------------------------------- Get ID(s) for current resource  # ---------------------------------------------- Get ID(s) for current resource
               my $ids=$bighash{'ids_/res/'.$thisfn};                my $ids=$bighash{'ids_'.&clutter($thisfn)};
               unless ($ids) {                 unless ($ids) { 
                  $ids=$bighash{'ids_/'.$thisfn};                   $ids=$bighash{'ids_/'.$thisfn};
               }                }
Line 2839  sub ireceipt { Line 3474  sub ireceipt {
 }  }
   
 sub receipt {  sub receipt {
     return &ireceipt($ENV{'user.name'},$ENV{'user.domain'},    my ($symb,$courseid,$domain,$name) = &Apache::lonxml::whichuser();
                      $ENV{'request.course.id'},&symbread());    return &ireceipt($name,$domain,$courseid,$symb);
 }  }
     
 # ------------------------------------------------------------ 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 {
   my $file=shift;   my $file=shift;
    if ($file=~/^\/*uploaded\//) { # user file
       my $ua=new LWP::UserAgent;
       my $request=new HTTP::Request('GET',&tokenwrapper($file));
       my $response=$ua->request($request);
       if ($response->is_success()) {
          return $response->content;
       } else { 
          return -1; 
       }
    } else { # normal file from res space
   &repcopy($file);    &repcopy($file);
   if (! -e $file ) { return -1; };    if (! -e $file ) { return -1; };
   my $fh=Apache::File->new($file);    my $fh=Apache::File->new($file);
   my $a='';    my $a='';
   while (<$fh>) { $a .=$_; }    while (<$fh>) { $a .=$_; }
   return $a    return $a;
    }
 }  }
   
 sub filelocation {  sub filelocation {
Line 2862  sub filelocation { Line 3508  sub filelocation {
   if ($file=~m:^/~:) { # is a contruction space reference    if ($file=~m:^/~:) { # is a contruction space reference
     $location = $file;      $location = $file;
     $location =~ s:/~(.*?)/(.*):/home/$1/public_html/$2:;      $location =~ s:/~(.*?)/(.*):/home/$1/public_html/$2:;
     } elsif ($file=~/^\/*uploaded/) { # is an uploaded file
       $location=$file;
   } else {    } else {
     $file=~s/^$perlvar{'lonDocRoot'}//;      $file=~s/^$perlvar{'lonDocRoot'}//;
     $file=~s:^/*res::;      $file=~s:^/*res::;
Line 2899  sub declutter { Line 3547  sub declutter {
     return $thisfn;      return $thisfn;
 }  }
   
   # ------------------------------------------------------------- Clutter up URLs
   
   sub clutter {
       my $thisfn='/'.&declutter(shift);
       unless ($thisfn=~/^\/(uploaded|adm|userfiles|ext|raw|priv)\//) { 
          $thisfn='/res'.$thisfn; 
       }
       return $thisfn;
   }
   
 # -------------------------------------------------------- Escape Special Chars  # -------------------------------------------------------- Escape Special Chars
   
 sub escape {  sub escape {
Line 2949  BEGIN { Line 3607  BEGIN {
     }      }
 }  }
   
   # ------------------------------------------------------------ Read domain file
   {
       my $fh=Apache::File->new($Apache::lonnet::perlvar{'lonTabDir'}.
                               '/domain.tab');
       %domaindescription = ();
       %domain_auth_def = ();
       %domain_auth_arg_def = ();
       if ($fh) {
          while (<$fh>) {
              next if /^\#/;
              chomp;
              my ($domain, $domain_description, $def_auth, $def_auth_arg)
                  = split(/:/,$_,4);
              $domain_auth_def{$domain}=$def_auth;
              $domain_auth_arg_def{$domain}=$def_auth_arg;
              $domaindescription{$domain}=$domain_description;
   #          &logthis("Domain.tab: $domain, $domain_auth_def{$domain}, $domain_auth_arg_def{$domain},$domaindescription{$domain}");
   #          &logthis("Domain.tab: $domain ".$domaindescription{$domain} );
          }
       }
   }
   
   
 # ------------------------------------------------------------- Read hosts file  # ------------------------------------------------------------- Read hosts file
 {  {
     my $config=Apache::File->new("$perlvar{'lonTabDir'}/hosts.tab");      my $config=Apache::File->new("$perlvar{'lonTabDir'}/hosts.tab");
   
     while (my $configline=<$config>) {      while (my $configline=<$config>) {
          next if ($configline =~ /^(\#|\s*$)/);
        chomp($configline);         chomp($configline);
        my ($id,$domain,$role,$name,$ip,$domdescr)=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 ($domdescr) {   $hostip{$id}=$ip;
    $domaindescription{$domain}=$domdescr;   $iphost{$ip}=$id;
    if ($role eq 'library') { $libserv{$id}=$name; }
          } else {
    if ($configline) {
      &logthis("Skipping hosts.tab line -$configline-");
    }
        }         }
        if ($role eq 'library') { $libserv{$id}=$name; }  
     }      }
 }  }
   
Line 2972  BEGIN { Line 3658  BEGIN {
   
     while (my $configline=<$config>) {      while (my $configline=<$config>) {
        chomp($configline);         chomp($configline);
        if (($configline) && ($configline ne $perlvar{'lonHostID'})) {         if ($configline) {
           $spareid{$configline}=1;            $spareid{$configline}=1;
        }         }
     }      }
Line 3018  BEGIN { Line 3704  BEGIN {
     }      }
 }  }
   
   # ------------- set up temporary directory
   {
       $tmpdir = $perlvar{'lonDaemons'}.'/tmp/';
   
   }
   
 %metacache=();  %metacache=();
   
 $processmarker=$$.'_'.time.'_'.$perlvar{'lonHostID'};  $processmarker='_'.time.'_'.$perlvar{'lonHostID'};
 $dumpcount=0;  $dumpcount=0;
   
 &logtouch();  &logtouch();
Line 3236  modify user Line 3928  modify user
   
 =item *  =item *
   
 modifystudent($udom,$uname,$uid,$umode,$upass,$first,$middle,$last,$gene,$usec,$end,$start) : modify student  modifystudent
   
   modify a students enrollment and identification information.
   The course id is resolved based on the current users environment.  
   This means the envoking user must be a course coordinator or otherwise
   associated with a course.
   
   This call is essentially a wrapper for lonnet::modifyuser and
   lonnet::modify_student_enrollment
   
   Inputs: 
   
   =over 4
   
   =item B<$udom> Students loncapa domain
   
   =item B<$uname> Students loncapa login name
   
   =item B<$uid> Students id/student number
   
   =item B<$umode> Students authentication mode
   
   =item B<$upass> Students password
   
   =item B<$first> Students first name
   
   =item B<$middle> Students middle name
   
   =item B<$last> Students last name
   
   =item B<$gene> Students generation
   
   =item B<$usec> Students section in course
   
   =item B<$end> Unix time of the roles expiration
   
   =item B<$start> Unix time of the roles start date
   
   =item B<$forceid> If defined, allow $uid to be changed
   
   =item B<$desiredhome> server to use as home server for student
   
   =back
   
   =item *
   
   modify_student_enrollment
   
   Change a students enrollment status in a class.  The environment variable
   'role.request.course' must be defined for this function to proceed.
   
   Inputs:
   
   =over 4
   
   =item $udom, students domain
   
   =item $uname, students name
   
   =item $uid, students user id
   
   =item $first, students first name
   
   =item $middle
   
   =item $last
   
   =item $gene
   
   =item $usec
   
   =item $end
   
   =item $start
   
   =back
   
   
 =item *  =item *
   
Removed from v.1.250  
changed lines
  Added in v.1.338

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