[BACK]Return to lond CVS log [TXT] [DIR] Up to [LON-CAPA] / loncom

Diff for /loncom/lond between versions 1.212 and 1.250

version 1.212, 2004/07/27 10:25:07 version 1.250, 2004/09/07 14:28:30
Line 50  use File::Copy; Line 50  use File::Copy;
 use LONCAPA::ConfigFileEdit;  use LONCAPA::ConfigFileEdit;
 use LONCAPA::lonlocal;  use LONCAPA::lonlocal;
 use LONCAPA::lonssl;  use LONCAPA::lonssl;
   use Fcntl qw(:flock);
   
 my $DEBUG = 0;       # Non zero to enable debug log entries.  my $DEBUG = 0;       # Non zero to enable debug log entries.
   
Line 58  my $lastlog=''; Line 59  my $lastlog='';
   
 my $VERSION='$Revision$'; #' stupid emacs  my $VERSION='$Revision$'; #' stupid emacs
 my $remoteVERSION;  my $remoteVERSION;
 my $currenthostid;  my $currenthostid="default";
 my $currentdomainid;  my $currentdomainid;
   
 my $client;  my $client;
Line 121  my @passwderrors = ("ok", Line 122  my @passwderrors = ("ok",
    "lcpasswd Cannot set new passwd.",     "lcpasswd Cannot set new passwd.",
    "lcpasswd Username has invalid characters",     "lcpasswd Username has invalid characters",
    "lcpasswd Invalid characters in password",     "lcpasswd Invalid characters in password",
     "11", "12",     "lcpasswd User already exists", 
     "lcpasswd Password mismatch");                     "lcpasswd Something went wrong with user addition.",
       "lcpasswd Password mismatch",
       "lcpasswd Error filename is invalid");
   
   
 #  The array below are lcuseradd error strings.:  #  The array below are lcuseradd error strings.:
Line 159  sub ResetStatistics { Line 162  sub ResetStatistics {
     $Failures     = 0;      $Failures     = 0;
 }  }
   
   
   
 #------------------------------------------------------------------------  #------------------------------------------------------------------------
 #  #
 #   LocalConnection  #   LocalConnection
Line 191  sub LocalConnection { Line 192  sub LocalConnection {
  ."$clientdns ne $thisserver </font>");   ."$clientdns ne $thisserver </font>");
  close $Socket;   close $Socket;
  return undef;   return undef;
     }       }  else {
     else {  
  chomp($initcmd); # Get rid of \n in filename.   chomp($initcmd); # Get rid of \n in filename.
  my ($init, $type, $name) = split(/:/, $initcmd);   my ($init, $type, $name) = split(/:/, $initcmd);
  Debug(" Init command: $init $type $name ");   Debug(" Init command: $init $type $name ");
Line 323  sub InsecureConnection { Line 323  sub InsecureConnection {
     $answer    =~s/\W//g;      $answer    =~s/\W//g;
     if($challenge eq $answer) {      if($challenge eq $answer) {
  return 1;   return 1;
     }       } else {
     else {  
  logthis("<font color='blue'>WARNING client did not respond to challenge</font>");   logthis("<font color='blue'>WARNING client did not respond to challenge</font>");
  &status("No challenge reqply");   &status("No challenge reqply");
  return 0;   return 0;
Line 371  sub isClient { Line 370  sub isClient {
 #                     - This allows dynamic changes to the manager table  #                     - This allows dynamic changes to the manager table
 #                       without the need to signal to the lond.  #                       without the need to signal to the lond.
 #  #
   
 sub ReadManagerTable {  sub ReadManagerTable {
   
     #   Clean out the old table first..      #   Clean out the old table first..
Line 653  sub PushFile { Line 651  sub PushFile {
  &logthis('<font color="red"> Pushfile: unable to install '   &logthis('<font color="red"> Pushfile: unable to install '
  .$tablefile." $! </font>");   .$tablefile." $! </font>");
  return "error:$!";   return "error:$!";
     }      } else {
     else {  
  &logthis('<font color="green"> Installed new '.$tablefile   &logthis('<font color="green"> Installed new '.$tablefile
  ."</font>");   ."</font>");
   
Line 1032  sub tie_user_hash { Line 1029  sub tie_user_hash {
     }      }
           
 }  }
 #---------------------------------------------------------------  
   #--------------------- Request Handlers --------------------------------------------
 #  #
 #   Getting, decoding and dispatching requests:  #   By convention each request handler registers itself prior to the sub 
   #   declaration:
 #  #
   
   #++
 #  #
 #   Get a Request:  #  Handles ping requests.
 #   Gets a Request message from the client.  The transaction  #  Parameters:
 #   is defined as a 'line' of text.  We remove the new line  #      $cmd    - the actual keyword that invoked us.
 #   from the text line.    #      $tail   - the tail of the request that invoked us.
 #     #      $replyfd- File descriptor connected to the client
 sub get_request {  #  Implicit Inputs:
     my $input = <$client>;  #      $currenthostid - Global variable that carries the name of the host we are
     chomp($input);  #                       known as.
   #  Returns:
   #      1       - Ok to continue processing.
   #      0       - Program should exit.
   #  Side effects:
   #      Reply information is sent to the client.
   
   sub ping_handler {
       my ($cmd, $tail, $client) = @_;
       Debug("$cmd $tail $client .. $currenthostid:");
      
       Reply( $client,"$currenthostid\n","$cmd:$tail");
      
       return 1;
   }
   &register_handler("ping", \&ping_handler, 0, 1, 1);       # Ping unencoded, client or manager.
   
     Debug("get_request: Request = $input\n");  #++
   #
   # Handles pong requests.  Pong replies with our current host id, and
   #                         the results of a ping sent to us via our lonc.
   #
   # Parameters:
   #      $cmd    - the actual keyword that invoked us.
   #      $tail   - the tail of the request that invoked us.
   #      $replyfd- File descriptor connected to the client
   #  Implicit Inputs:
   #      $currenthostid - Global variable that carries the name of the host we are
   #                       connected to.
   #  Returns:
   #      1       - Ok to continue processing.
   #      0       - Program should exit.
   #  Side effects:
   #      Reply information is sent to the client.
   
     &status('Processing '.$clientname.':'.$input);  sub pong_handler {
       my ($cmd, $tail, $replyfd) = @_;
   
     return $input;      my $reply=&reply("ping",$clientname);
       &Reply( $replyfd, "$currenthostid:$reply\n", "$cmd:$tail"); 
       return 1;
 }  }
 #---------------------------------------------------------------  &register_handler("pong", \&pong_handler, 0, 1, 1);       # Pong unencoded, client or manager
   
   #++
   #      Called to establish an encrypted session key with the remote client.
   #      Note that with secure lond, in most cases this function is never
   #      invoked.  Instead, the secure session key is established either
   #      via a local file that's locked down tight and only lives for a short
   #      time, or via an ssl tunnel...and is generated from a bunch-o-random
   #      bits from /dev/urandom, rather than the predictable pattern used by
   #      by this sub.  This sub is only used in the old-style insecure
   #      key negotiation.
   # Parameters:
   #      $cmd    - the actual keyword that invoked us.
   #      $tail   - the tail of the request that invoked us.
   #      $replyfd- File descriptor connected to the client
   #  Implicit Inputs:
   #      $currenthostid - Global variable that carries the name of the host
   #                       known as.
   #      $clientname    - Global variable that carries the name of the hsot we're connected to.
   #  Returns:
   #      1       - Ok to continue processing.
   #      0       - Program should exit.
   #  Implicit Outputs:
   #      Reply information is sent to the client.
   #      $cipher is set with a reference to a new IDEA encryption object.
   #
   sub establish_key_handler {
       my ($cmd, $tail, $replyfd) = @_;
   
       my $buildkey=time.$$.int(rand 100000);
       $buildkey=~tr/1-6/A-F/;
       $buildkey=int(rand 100000).$buildkey.int(rand 100000);
       my $key=$currenthostid.$clientname;
       $key=~tr/a-z/A-Z/;
       $key=~tr/G-P/0-9/;
       $key=~tr/Q-Z/0-9/;
       $key=$key.$buildkey.$key.$buildkey.$key.$buildkey;
       $key=substr($key,0,32);
       my $cipherkey=pack("H32",$key);
       $cipher=new IDEA $cipherkey;
       &Reply($replyfd, "$buildkey\n", "$cmd:$tail"); 
      
       return 1;
   
   }
   &register_handler("ekey", \&establish_key_handler, 0, 1,1);
   
   
   #     Handler for the load command.  Returns the current system load average
   #     to the requestor.
 #  #
 #  Process a request.  This sub should shrink as each action  # Parameters:
 #  gets farmed out into a separat sub that is registered   #      $cmd    - the actual keyword that invoked us.
 #  with the dispatch hash.    #      $tail   - the tail of the request that invoked us.
   #      $replyfd- File descriptor connected to the client
   #  Implicit Inputs:
   #      $currenthostid - Global variable that carries the name of the host
   #                       known as.
   #      $clientname    - Global variable that carries the name of the hsot we're connected to.
   #  Returns:
   #      1       - Ok to continue processing.
   #      0       - Program should exit.
   #  Side effects:
   #      Reply information is sent to the client.
   sub load_handler {
       my ($cmd, $tail, $replyfd) = @_;
   
      # Get the load average from /proc/loadavg and calculate it as a percentage of
      # the allowed load limit as set by the perl global variable lonLoadLim
   
       my $loadavg;
       my $loadfile=IO::File->new('/proc/loadavg');
      
       $loadavg=<$loadfile>;
       $loadavg =~ s/\s.*//g;                      # Extract the first field only.
      
       my $loadpercent=100*$loadavg/$perlvar{'lonLoadLim'};
   
       &Reply( $replyfd, "$loadpercent\n", "$cmd:$tail");
      
       return 1;
   }
   register_handler("load", \&load_handler, 0, 1, 0);
   
   #
   #   Process the userload request.  This sub returns to the client the current
   #  user load average.  It can be invoked either by clients or managers.
 #  #
 # Parameters:  # Parameters:
 #    user_input   - The request received from the client (lonc).  #      $cmd    - the actual keyword that invoked us.
 # Returns:  #      $tail   - the tail of the request that invoked us.
 #    true to keep processing, false if caller should exit.  #      $replyfd- File descriptor connected to the client
   #  Implicit Inputs:
   #      $currenthostid - Global variable that carries the name of the host
   #                       known as.
   #      $clientname    - Global variable that carries the name of the hsot we're connected to.
   #  Returns:
   #      1       - Ok to continue processing.
   #      0       - Program should exit
   # Implicit inputs:
   #     whatever the userload() function requires.
   #  Implicit outputs:
   #     the reply is written to the client.
 #  #
 sub process_request {  sub user_load_handler {
     my ($userinput) = @_;      # Easier for now to break style than to      my ($cmd, $tail, $replyfd) = @_;
                                 # fix all the userinput -> user_input.  
     my $wasenc    = 0; # True if request was encrypted.      my $userloadpercent=&userload();
 # ------------------------------------------------------------ See if encrypted      &Reply($replyfd, "$userloadpercent\n", "$cmd:$tail");
     if ($userinput =~ /^enc/) {  
  $userinput = decipher($userinput);  
  $wasenc=1;  
  if(!$userinput) { # Cipher not defined.  
     &Failure($client, "error: Encrypted data without negotated key");  
     return 0;  
  }  
     }  
     Debug("process_request: $userinput\n");  
           
 # ------------------------------------------------------------- Normal commands      return 1;
 # ------------------------------------------------------------------------ ping  }
     if ($userinput =~ /^ping/) { # client only  register_handler("userload", \&user_load_handler, 0, 1, 0);
  if(isClient) {  
     print $client "$currenthostid\n";  #   Process a request for the authorization type of a user:
  } else {  #   (userauth).
     Reply($client, "refused\n", $userinput);  
  }  
 # ------------------------------------------------------------------------ pong  
     }elsif ($userinput =~ /^pong/) { # client only  
  if(isClient) {  
     my $reply=&reply("ping",$clientname);  
     print $client "$currenthostid:$reply\n";   
  } else {  
     Reply($client, "refused\n", $userinput);  
  }  
 # ------------------------------------------------------------------------ ekey  
     } elsif ($userinput =~ /^ekey/) { # ok for both clients & mgrs  
  my $buildkey=time.$$.int(rand 100000);  
  $buildkey=~tr/1-6/A-F/;  
  $buildkey=int(rand 100000).$buildkey.int(rand 100000);  
  my $key=$currenthostid.$clientname;  
  $key=~tr/a-z/A-Z/;  
  $key=~tr/G-P/0-9/;  
  $key=~tr/Q-Z/0-9/;  
  $key=$key.$buildkey.$key.$buildkey.$key.$buildkey;  
  $key=substr($key,0,32);  
  my $cipherkey=pack("H32",$key);  
  $cipher=new IDEA $cipherkey;  
  print $client "$buildkey\n";   
 # ------------------------------------------------------------------------ load  
     } elsif ($userinput =~ /^load/) { # client only  
  if (isClient) {  
     my $loadavg;  
     {  
  my $loadfile=IO::File->new('/proc/loadavg');  
  $loadavg=<$loadfile>;  
     }  
     $loadavg =~ s/\s.*//g;  
     my $loadpercent=100*$loadavg/$perlvar{'lonLoadLim'};  
     print $client "$loadpercent\n";  
  } else {  
     Reply($client, "refused\n", $userinput);  
       
  }  
 # -------------------------------------------------------------------- userload  
     } elsif ($userinput =~ /^userload/) { # client only  
  if(isClient) {  
     my $userloadpercent=&userload();  
     print $client "$userloadpercent\n";  
  } else {  
     Reply($client, "refused\n", $userinput);  
       
  }  
 #  #
 #        Transactions requiring encryption:  # Parameters:
   #      $cmd    - the actual keyword that invoked us.
   #      $tail   - the tail of the request that invoked us.
   #      $replyfd- File descriptor connected to the client
   #  Returns:
   #      1       - Ok to continue processing.
   #      0       - Program should exit
   # Implicit outputs:
   #    The user authorization type is written to the client.
 #  #
 # ----------------------------------------------------------------- currentauth  sub user_authorization_type {
     } elsif ($userinput =~ /^currentauth/) {      my ($cmd, $tail, $replyfd) = @_;
  if (($wasenc==1)  && isClient) { # Encoded & client only.     
     my ($cmd,$udom,$uname)=split(/:/,$userinput);      my $userinput = "$cmd:$tail";
     my $result = GetAuthType($udom, $uname);     
     if($result eq "nouser") {      #  Pull the domain and username out of the command tail.
  print $client "unknown_user\n";      # and call get_auth_type to determine the authentication type.
     }     
     else {      my ($udom,$uname)=split(/:/,$tail);
  print $client "$result\n";      my $result = &get_auth_type($udom, $uname);
     }      if($result eq "nouser") {
  } else {   &Failure( $replyfd, "unknown_user\n", $userinput);
     Reply($client, "refused\n", $userinput);      } else {
        #
  }   # We only want to pass the second field from get_auth_type
 #--------------------------------------------------------------------- pushfile   # for ^krb.. otherwise we'll be handing out the encrypted
     } elsif($userinput =~ /^pushfile/) { # encoded & manager.   # password for internals e.g.
  if(($wasenc == 1) && isManager) {   #
     my $cert = GetCertificate($userinput);   my ($type,$otherinfo) = split(/:/,$result);
     if(ValidManager($cert)) {   if($type =~ /^krb/) {
  my $reply = PushFile($userinput);      $type = $result;
  print $client "$reply\n";  
     } else {  
  print $client "refused\n";  
     }   
  } else {  
     Reply($client, "refused\n", $userinput);  
       
  }  
 #--------------------------------------------------------------------- reinit  
     } elsif($userinput =~ /^reinit/) { # Encoded and manager  
  if (($wasenc == 1) && isManager) {  
     my $cert = GetCertificate($userinput);  
     if(ValidManager($cert)) {  
  chomp($userinput);  
  my $reply = ReinitProcess($userinput);  
  print $client  "$reply\n";  
     } else {  
  print $client "refused\n";  
     }  
  } else {  
     Reply($client, "refused\n", $userinput);  
  }  
 #------------------------------------------------------------------------- edit  
     } elsif ($userinput =~ /^edit/) {    # encoded and manager:  
  if(($wasenc ==1) && (isManager)) {  
     my $cert = GetCertificate($userinput);  
     if(ValidManager($cert)) {  
  my($command, $filetype, $script) = split(/:/, $userinput);  
  if (($filetype eq "hosts") || ($filetype eq "domain")) {  
     if($script ne "") {  
  Reply($client, EditFile($userinput));  
     } else {  
  Reply($client,"refused\n",$userinput);  
     }  
  } else {  
     Reply($client,"refused\n",$userinput);  
  }  
             } else {  
  Reply($client,"refused\n",$userinput);  
             }  
  } else {  
     Reply($client,"refused\n",$userinput);  
  }   }
 # ------------------------------------------------------------------------ auth   &Reply( $replyfd, "$type:\n", $userinput);
     } elsif ($userinput =~ /^auth/) { # Encoded and client only.      }
  if (($wasenc==1) && isClient) {    
     my ($cmd,$udom,$uname,$upass)=split(/:/,$userinput);      return 1;
     chomp($upass);  }
     $upass=unescape($upass);  &register_handler("currentauth", \&user_authorization_type, 1, 1, 0);
     my $proname=propath($udom,$uname);  
     my $passfilename="$proname/passwd";  #   Process a request by a manager to push a hosts or domain table 
     if (-e $passfilename) {  #   to us.  We pick apart the command and pass it on to the subs
  my $pf = IO::File->new($passfilename);  #   that already exist to do this.
  my $realpasswd=<$pf>;  #
  chomp($realpasswd);  # Parameters:
  my ($howpwd,$contentpwd)=split(/:/,$realpasswd);  #      $cmd    - the actual keyword that invoked us.
  my $pwdcorrect=0;  #      $tail   - the tail of the request that invoked us.
  if ($howpwd eq 'internal') {  #      $client - File descriptor connected to the client
     &Debug("Internal auth");  #  Returns:
     $pwdcorrect=  #      1       - Ok to continue processing.
  (crypt($upass,$contentpwd) eq $contentpwd);  #      0       - Program should exit
  } elsif ($howpwd eq 'unix') {  # Implicit Output:
     &Debug("Unix auth");  #    a reply is written to the client.
     if((getpwnam($uname))[1] eq "") { #no such user!  
  $pwdcorrect = 0;  sub push_file_handler {
     } else {      my ($cmd, $tail, $client) = @_;
  $contentpwd=(getpwnam($uname))[1];  
  my $pwauth_path="/usr/local/sbin/pwauth";      my $userinput = "$cmd:$tail";
  unless ($contentpwd eq 'x') {  
     $pwdcorrect=      # At this time we only know that the IP of our partner is a valid manager
  (crypt($upass,$contentpwd) eq       # the code below is a hook to do further authentication (e.g. to resolve
  $contentpwd);      # spoofing).
  }  
       my $cert = &GetCertificate($userinput);
  elsif (-e $pwauth_path) {      if(&ValidManager($cert)) { 
     open PWAUTH, "|$pwauth_path" or  
  die "Cannot invoke authentication";   # Now presumably we have the bona fides of both the peer host and the
     print PWAUTH "$uname\n$upass\n";   # process making the request.
     close PWAUTH;        
     $pwdcorrect=!$?;   my $reply = &PushFile($userinput);
  }   &Reply($client, "$reply\n", $userinput);
     }  
  } elsif ($howpwd eq 'krb4') {      } else {
     my $null=pack("C",0);   &Failure( $client, "refused\n", $userinput);
     unless ($upass=~/$null/) {      } 
  my $krb4_error = &Authen::Krb4::get_pw_in_tkt      return 1;
     ($uname,"",$contentpwd,'krbtgt',  }
      $contentpwd,1,$upass);  &register_handler("pushfile", \&push_file_handler, 1, 0, 1);
  if (!$krb4_error) {  
     $pwdcorrect = 1;  #
  } else {   #   du  - list the disk usuage of a directory recursively. 
     $pwdcorrect=0;   #    
     # log error if it is not a bad password  #   note: stolen code from the ls file handler
     if ($krb4_error != 62) {  #   under construction by Rick Banghart 
  &logthis('krb4:'.$uname.','.  #    .
  &Authen::Krb4::get_err_txt($Authen::Krb4::error));  # Parameters:
     }  #    $cmd        - The command that dispatched us (du).
   #    $ududir     - The directory path to list... I'm not sure what this
   #                  is relative as things like ls:. return e.g.
   #                  no_such_dir.
   #    $client     - Socket open on the client.
   # Returns:
   #     1 - indicating that the daemon should not disconnect.
   # Side Effects:
   #   The reply is written to  $client.
   #
   
   sub du_handler {
       my ($cmd, $ududir, $client) = @_;
       if ($ududir=~/\.\./ || $ududir!~m|^/home/httpd/|) {
    &Failure($client,"refused\n","$cmd:$ududir");
    return 1;
       }
       #  Since $ududir could have some nasties in it,
       #  we will require that ududir is a valid
       #  directory.  Just in case someone tries to
       #  slip us a  line like .;(cd /home/httpd rm -rf*)
       #  etc.
       #
       if (-d $ududir) {
    #  And as Shakespeare would say to make
    #  assurance double sure, quote the $ududir
    #  This is in case someone manages to first
    #  e.g. fabricate a valid directory with a ';'
    #  in it.  Quoting the dir will help
    #  keep $ududir completely interpreted as a 
    #  directory.
    # 
    my $duout = `du -ks "$ududir" 2>/dev/null`;
    $duout=~s/[^\d]//g; #preserve only the numbers
    &Reply($client,"$duout\n","$cmd:$ududir");
       } else {
    &Failure($client, "bad_directory:$ududir","$cmd:$ududir"); 
       }
       return 1;
   }
   &register_handler("du", \&du_handler, 0, 1, 0);
   
   
   #
   #   ls  - list the contents of a directory.  For each file in the
   #    selected directory the filename followed by the full output of
   #    the stat function is returned.  The returned info for each
   #    file are separated by ':'.  The stat fields are separated by &'s.
   # Parameters:
   #    $cmd        - The command that dispatched us (ls).
   #    $ulsdir     - The directory path to list... I'm not sure what this
   #                  is relative as things like ls:. return e.g.
   #                  no_such_dir.
   #    $client     - Socket open on the client.
   # Returns:
   #     1 - indicating that the daemon should not disconnect.
   # Side Effects:
   #   The reply is written to  $client.
   #
   sub ls_handler {
       my ($cmd, $ulsdir, $client) = @_;
   
       my $userinput = "$cmd:$ulsdir";
   
       my $obs;
       my $rights;
       my $ulsout='';
       my $ulsfn;
       if (-e $ulsdir) {
    if(-d $ulsdir) {
       if (opendir(LSDIR,$ulsdir)) {
    while ($ulsfn=readdir(LSDIR)) {
       undef $obs, $rights; 
       my @ulsstats=stat($ulsdir.'/'.$ulsfn);
       #We do some obsolete checking here
       if(-e $ulsdir.'/'.$ulsfn.".meta") { 
    open(FILE, $ulsdir.'/'.$ulsfn.".meta");
    my @obsolete=<FILE>;
    foreach my $obsolete (@obsolete) {
       if($obsolete =~ m|(<obsolete>)(on)|) { $obs = 1; } 
       if($obsolete =~ m|(<copyright>)(default)|) { $rights = 1; }
  }   }
     }      }
  } elsif ($howpwd eq 'krb5') {      $ulsout.=$ulsfn.'&'.join('&',@ulsstats);
     my $null=pack("C",0);      if($obs eq '1') { $ulsout.="&1"; }
     unless ($upass=~/$null/) {      else { $ulsout.="&0"; }
  my $krbclient=&Authen::Krb5::parse_name($uname.'@'.$contentpwd);      if($rights eq '1') { $ulsout.="&1:"; }
  my $krbservice="krbtgt/".$contentpwd."\@".$contentpwd;      else { $ulsout.="&0:"; }
  my $krbserver=&Authen::Krb5::parse_name($krbservice);  
  my $credentials=&Authen::Krb5::cc_default();  
  $credentials->initialize($krbclient);  
  my $krbreturn =   
     &Authen::Krb5::get_in_tkt_with_password(  
     $krbclient,$krbserver,$upass,$credentials);  
 #  unless ($krbreturn) {  
 #      &logthis("Krb5 Error: ".  
 #       &Authen::Krb5::error());  
 #  }  
  $pwdcorrect = ($krbreturn == 1);  
     } else { $pwdcorrect=0; }  
  } elsif ($howpwd eq 'localauth') {  
     $pwdcorrect=&localauth::localauth($uname,$upass,  
       $contentpwd);  
  }   }
  if ($pwdcorrect) {   closedir(LSDIR);
     print $client "authorized\n";  
  } else {  
     print $client "non_authorized\n";  
  }    
     } else {  
  print $client "unknown_user\n";  
     }      }
  } else {   } else {
     Reply($client, "refused\n", $userinput);      my @ulsstats=stat($ulsdir);
           $ulsout.=$ulsfn.'&'.join('&',@ulsstats).':';
  }   }
 # ---------------------------------------------------------------------- passwd      } else {
     } elsif ($userinput =~ /^passwd/) { # encoded and client   $ulsout='no_such_dir';
  if (($wasenc==1) && isClient) {      }
     my       if ($ulsout eq '') { $ulsout='empty'; }
  ($cmd,$udom,$uname,$upass,$npass)=split(/:/,$userinput);      &Reply($client, "$ulsout\n", $userinput); # This supports debug logging.
     chomp($npass);      
     $upass=&unescape($upass);      return 1;
     $npass=&unescape($npass);  
     &Debug("Trying to change password for $uname");  }
     my $proname=propath($udom,$uname);  &register_handler("ls", \&ls_handler, 0, 1, 0);
     my $passfilename="$proname/passwd";  
     if (-e $passfilename) {  
  my $realpasswd;  
  { my $pf = IO::File->new($passfilename);  
   $realpasswd=<$pf>; }  #   Process a reinit request.  Reinit requests that either
  chomp($realpasswd);  #   lonc or lond be reinitialized so that an updated 
  my ($howpwd,$contentpwd)=split(/:/,$realpasswd);  #   host.tab or domain.tab can be processed.
  if ($howpwd eq 'internal') {  #
     &Debug("internal auth");  # Parameters:
     if (crypt($upass,$contentpwd) eq $contentpwd) {  #      $cmd    - the actual keyword that invoked us.
  my $salt=time;  #      $tail   - the tail of the request that invoked us.
  $salt=substr($salt,6,2);  #      $client - File descriptor connected to the client
  my $ncpass=crypt($npass,$salt);  #  Returns:
  {  #      1       - Ok to continue processing.
     my $pf;  #      0       - Program should exit
     if ($pf = IO::File->new(">$passfilename")) {  #  Implicit output:
  print $pf "internal:$ncpass\n";  #     a reply is sent to the client.
  &logthis("Result of password change for $uname: pwchange_success");  #
  print $client "ok\n";  sub reinit_process_handler {
     } else {      my ($cmd, $tail, $client) = @_;
  &logthis("Unable to open $uname passwd to change password");     
  print $client "non_authorized\n";      my $userinput = "$cmd:$tail";
     }     
  }                   my $cert = &GetCertificate($userinput);
       if(&ValidManager($cert)) {
     } else {   chomp($userinput);
  print $client "non_authorized\n";   my $reply = &ReinitProcess($userinput);
     }   &Reply( $client,  "$reply\n", $userinput);
  } elsif ($howpwd eq 'unix') {      } else {
     # Unix means we have to access /etc/password   &Failure( $client, "refused\n", $userinput);
     # one way or another.      }
     # First: Make sure the current password is      return 1;
     #        correct  }
     &Debug("auth is unix");  
     $contentpwd=(getpwnam($uname))[1];  &register_handler("reinit", \&reinit_process_handler, 1, 0, 1);
     my $pwdcorrect = "0";  
     my $pwauth_path="/usr/local/sbin/pwauth";  #  Process the editing script for a table edit operation.
     unless ($contentpwd eq 'x') {  #  the editing operation must be encrypted and requested by
  $pwdcorrect=  #  a manager host.
     (crypt($upass,$contentpwd) eq $contentpwd);  #
     } elsif (-e $pwauth_path) {  # Parameters:
  open PWAUTH, "|$pwauth_path" or  #      $cmd    - the actual keyword that invoked us.
     die "Cannot invoke authentication";  #      $tail   - the tail of the request that invoked us.
  print PWAUTH "$uname\n$upass\n";  #      $client - File descriptor connected to the client
  close PWAUTH;  #  Returns:
  &Debug("exited pwauth with $? ($uname,$upass) ");  #      1       - Ok to continue processing.
  $pwdcorrect=($? == 0);  #      0       - Program should exit
     }  #  Implicit output:
     if ($pwdcorrect) {  #     a reply is sent to the client.
  my $execdir=$perlvar{'lonDaemons'};  #
  &Debug("Opening lcpasswd pipeline");  sub edit_table_handler {
  my $pf = IO::File->new("|$execdir/lcpasswd > $perlvar{'lonDaemons'}/logs/lcpasswd.log");      my ($command, $tail, $client) = @_;
  print $pf "$uname\n$npass\n$npass\n";     
  close $pf;      my $userinput = "$command:$tail";
  my $err = $?;  
  my $result = ($err>0 ? 'pwchange_failure'       my $cert = &GetCertificate($userinput);
       : 'ok');      if(&ValidManager($cert)) {
  &logthis("Result of password change for $uname: ".   my($filetype, $script) = split(/:/, $tail);
  &lcpasswdstrerror($?));   if (($filetype eq "hosts") || 
  print $client "$result\n";      ($filetype eq "domain")) {
     } else {      if($script ne "") {
  print $client "non_authorized\n";   &Reply($client,              # BUGBUG - EditFile
     }        &EditFile($userinput), #   could fail.
  } else {        $userinput);
     print $client "auth_mode_error\n";  
  }    
     } else {      } else {
  print $client "unknown_user\n";   &Failure($client,"refused\n",$userinput);
     }      }
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client,"refused\n",$userinput);
       
  }   }
 # -------------------------------------------------------------------- makeuser      } else {
     } elsif ($userinput =~ /^makeuser/) { # encoded and client.   &Failure($client,"refused\n",$userinput);
  &Debug("Make user received");      }
  my $oldumask=umask(0077);      return 1;
  if (($wasenc==1) && isClient) {  }
     my   register_handler("edit", \&edit_table_handler, 1, 0, 1);
  ($cmd,$udom,$uname,$umode,$npass)=split(/:/,$userinput);  
     &Debug("cmd =".$cmd." $udom =".$udom.  
    " uname=".$uname);  #
     chomp($npass);  #   Authenticate a user against the LonCAPA authentication
     $npass=&unescape($npass);  #   database.  Note that there are several authentication
     my $proname=propath($udom,$uname);  #   possibilities:
     my $passfilename="$proname/passwd";  #   - unix     - The user can be authenticated against the unix
     &Debug("Password file created will be:".  #                password file.
    $passfilename);  #   - internal - The user can be authenticated against a purely 
     if (-e $passfilename) {  #                internal per user password file.
  print $client "already_exists\n";  #   - kerberos - The user can be authenticated against either a kerb4 or kerb5
     } elsif ($udom ne $currentdomainid) {  #                ticket granting authority.
  print $client "not_right_domain\n";  #   - user     - The person tailoring LonCAPA can supply a user authentication
   #                mechanism that is per system.
   #
   # Parameters:
   #    $cmd      - The command that got us here.
   #    $tail     - Tail of the command (remaining parameters).
   #    $client   - File descriptor connected to client.
   # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   # Implicit inputs:
   #    The authentication systems describe above have their own forms of implicit
   #    input into the authentication process that are described above.
   #
   sub authenticate_handler {
       my ($cmd, $tail, $client) = @_;
   
       
       #  Regenerate the full input line 
       
       my $userinput  = $cmd.":".$tail;
       
       #  udom    - User's domain.
       #  uname   - Username.
       #  upass   - User's password.
       
       my ($udom,$uname,$upass)=split(/:/,$tail);
       &Debug(" Authenticate domain = $udom, user = $uname, password = $upass");
       chomp($upass);
       $upass=&unescape($upass);
   
       my $pwdcorrect = &validate_user($udom, $uname, $upass);
       if($pwdcorrect) {
    &Reply( $client, "authorized\n", $userinput);
    #
    #  Bad credentials: Failed to authorize
    #
       } else {
    &Failure( $client, "non_authorized\n", $userinput);
       }
   
       return 1;
   }
   
   register_handler("auth", \&authenticate_handler, 1, 1, 0);
   
   #
   #   Change a user's password.  Note that this function is complicated by
   #   the fact that a user may be authenticated in more than one way:
   #   At present, we are not able to change the password for all types of
   #   authentication methods.  Only for:
   #      unix    - unix password or shadow passoword style authentication.
   #      local   - Locally written authentication mechanism.
   #   For now, kerb4 and kerb5 password changes are not supported and result
   #   in an error.
   # FUTURE WORK:
   #    Support kerberos passwd changes?
   # Parameters:
   #    $cmd      - The command that got us here.
   #    $tail     - Tail of the command (remaining parameters).
   #    $client   - File descriptor connected to client.
   # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   # Implicit inputs:
   #    The authentication systems describe above have their own forms of implicit
   #    input into the authentication process that are described above.
   sub change_password_handler {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput = $cmd.":".$tail;           # Reconstruct client's string.
   
       #
       #  udom  - user's domain.
       #  uname - Username.
       #  upass - Current password.
       #  npass - New password.
      
       my ($udom,$uname,$upass,$npass)=split(/:/,$tail);
   
       $upass=&unescape($upass);
       $npass=&unescape($npass);
       &Debug("Trying to change password for $uname");
   
       # First require that the user can be authenticated with their
       # old password:
   
       my $validated = &validate_user($udom, $uname, $upass);
       if($validated) {
    my $realpasswd  = &get_auth_type($udom, $uname); # Defined since authd.
   
    my ($howpwd,$contentpwd)=split(/:/,$realpasswd);
    if ($howpwd eq 'internal') {
       &Debug("internal auth");
       my $salt=time;
       $salt=substr($salt,6,2);
       my $ncpass=crypt($npass,$salt);
       if(&rewrite_password_file($udom, $uname, "internal:$ncpass")) {
    &logthis("Result of password change for "
    ."$uname: pwchange_success");
    &Reply($client, "ok\n", $userinput);
     } else {      } else {
  my @fpparts=split(/\//,$proname);   &logthis("Unable to open $uname passwd "               
  my $fpnow=$fpparts[0].'/'.$fpparts[1].'/'.$fpparts[2];   ."to change password");
  my $fperror='';   &Failure( $client, "non_authorized\n",$userinput);
  for (my $i=3;$i<=$#fpparts;$i++) {      }
     $fpnow.='/'.$fpparts[$i];    } elsif ($howpwd eq 'unix') {
     unless (-e $fpnow) {      # Unix means we have to access /etc/password
  unless (mkdir($fpnow,0777)) {      &Debug("auth is unix");
     $fperror="error: ".($!+0)      my $execdir=$perlvar{'lonDaemons'};
  ." mkdir failed while attempting "      &Debug("Opening lcpasswd pipeline");
  ."makeuser";      my $pf = IO::File->new("|$execdir/lcpasswd > "
  }     ."$perlvar{'lonDaemons'}"
      ."/logs/lcpasswd.log");
       print $pf "$uname\n$npass\n$npass\n";
       close $pf;
       my $err = $?;
       my $result = ($err>0 ? 'pwchange_failure' : 'ok');
       &logthis("Result of password change for $uname: ".
        &lcpasswdstrerror($?));
       &Reply($client, "$result\n", $userinput);
    } else {
       # this just means that the current password mode is not
       # one we know how to change (e.g the kerberos auth modes or
       # locally written auth handler).
       #
       &Failure( $client, "auth_mode_error\n", $userinput);
    }  
   
       } else {
    &Failure( $client, "non_authorized\n", $userinput);
       }
   
       return 1;
   }
   register_handler("passwd", \&change_password_handler, 1, 1, 0);
   
   
   #
   #   Create a new user.  User in this case means a lon-capa user.
   #   The user must either already exist in some authentication realm
   #   like kerberos or the /etc/passwd.  If not, a user completely local to
   #   this loncapa system is created.
   #
   # Parameters:
   #    $cmd      - The command that got us here.
   #    $tail     - Tail of the command (remaining parameters).
   #    $client   - File descriptor connected to client.
   # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   # Implicit inputs:
   #    The authentication systems describe above have their own forms of implicit
   #    input into the authentication process that are described above.
   sub add_user_handler {
   
       my ($cmd, $tail, $client) = @_;
   
   
       my ($udom,$uname,$umode,$npass)=split(/:/,$tail);
       my $userinput = $cmd.":".$tail; # Reconstruct the full request line.
   
       &Debug("cmd =".$cmd." $udom =".$udom." uname=".$uname);
   
   
       if($udom eq $currentdomainid) { # Reject new users for other domains...
   
    my $oldumask=umask(0077);
    chomp($npass);
    $npass=&unescape($npass);
    my $passfilename  = &password_path($udom, $uname);
    &Debug("Password file created will be:".$passfilename);
    if (-e $passfilename) {
       &Failure( $client, "already_exists\n", $userinput);
    } else {
       my @fpparts=split(/\//,$passfilename);
       my $fpnow=$fpparts[0].'/'.$fpparts[1].'/'.$fpparts[2];
       my $fperror='';
       for (my $i=3;$i<= ($#fpparts-1);$i++) {
    $fpnow.='/'.$fpparts[$i]; 
    unless (-e $fpnow) {
       &logthis("mkdir $fpnow");
       unless (mkdir($fpnow,0777)) {
    $fperror="error: ".($!+0)." mkdir failed while attempting "
       ."makeuser";
     }      }
  }   }
  unless ($fperror) {  
     my $result=&make_passwd_file($uname, $umode,$npass,  
  $passfilename);  
     print $client $result;  
  } else {  
     print $client "$fperror\n";  
  }  
     }      }
  } else {      unless ($fperror) {
     Reply($client, "refused\n", $userinput);   my $result=&make_passwd_file($uname, $umode,$npass, $passfilename);
        &Reply($client, $result, $userinput);     #BUGBUG - could be fail
  }  
  umask($oldumask);  
 # -------------------------------------------------------------- changeuserauth  
     } elsif ($userinput =~ /^changeuserauth/) { # encoded & client  
  &Debug("Changing authorization");  
  if (($wasenc==1) && isClient) {  
     my   
  ($cmd,$udom,$uname,$umode,$npass)=split(/:/,$userinput);  
     chomp($npass);  
     &Debug("cmd = ".$cmd." domain= ".$udom.  
    "uname =".$uname." umode= ".$umode);  
     $npass=&unescape($npass);  
     my $proname=&propath($udom,$uname);  
     my $passfilename="$proname/passwd";  
     if ($udom ne $currentdomainid) {  
  print $client "not_right_domain\n";  
     } else {      } else {
  my $result=&make_passwd_file($uname, $umode,$npass,   &Failure($client, "$fperror\n", $userinput);
      $passfilename);  
  print $client $result;  
     }      }
  } else {  
     Reply($client, "refused\n", $userinput);  
       
  }   }
 # ------------------------------------------------------------------------ home   umask($oldumask);
     } elsif ($userinput =~ /^home/) { # client clear or encoded      }  else {
  if(isClient) {   &Failure($client, "not_right_domain\n",
     my ($cmd,$udom,$uname)=split(/:/,$userinput);   $userinput); # Even if we are multihomed.
     chomp($uname);      
     my $proname=propath($udom,$uname);      }
     if (-e $proname) {      return 1;
  print $client "found\n";  
     } else {  }
  print $client "not_found\n";  &register_handler("makeuser", \&add_user_handler, 1, 1, 0);
     }  
  } else {  #
     Reply($client, "refused\n", $userinput);  #   Change the authentication method of a user.  Note that this may
       #   also implicitly change the user's password if, for example, the user is
   #   joining an existing authentication realm.  Known authentication realms at
   #   this time are:
   #    internal   - Purely internal password file (only loncapa knows this user)
   #    local      - Institutionally written authentication module.
   #    unix       - Unix user (/etc/passwd with or without /etc/shadow).
   #    kerb4      - kerberos version 4
   #    kerb5      - kerberos version 5
   #
   # Parameters:
   #    $cmd      - The command that got us here.
   #    $tail     - Tail of the command (remaining parameters).
   #    $client   - File descriptor connected to client.
   # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   # Implicit inputs:
   #    The authentication systems describe above have their own forms of implicit
   #    input into the authentication process that are described above.
   #
   sub change_authentication_handler {
   
       my ($cmd, $tail, $client) = @_;
      
       my $userinput  = "$cmd:$tail";              # Reconstruct user input.
   
       my ($udom,$uname,$umode,$npass)=split(/:/,$tail);
       &Debug("cmd = ".$cmd." domain= ".$udom."uname =".$uname." umode= ".$umode);
       if ($udom ne $currentdomainid) {
    &Failure( $client, "not_right_domain\n", $client);
       } else {
   
    chomp($npass);
   
    $npass=&unescape($npass);
    my $passfilename = &password_path($udom, $uname);
    if ($passfilename) { # Not allowed to create a new user!!
       my $result=&make_passwd_file($uname, $umode,$npass,$passfilename);
       &Reply($client, $result, $userinput);
    } else {       
       &Failure($client, "non_authorized", $userinput); # Fail the user now.
  }   }
 # ---------------------------------------------------------------------- update      }
     } elsif ($userinput =~ /^update/) { # client clear or encoded.      return 1;
  if(isClient) {  }
     my ($cmd,$fname)=split(/:/,$userinput);  &register_handler("changeuserauth", \&change_authentication_handler, 1,1, 0);
     my $ownership=ishome($fname);  
     if ($ownership eq 'not_owner') {  #
  if (-e $fname) {  #   Determines if this is the home server for a user.  The home server
     my ($dev,$ino,$mode,$nlink,  #   for a user will have his/her lon-capa passwd file.  Therefore all we need
  $uid,$gid,$rdev,$size,  #   to do is determine if this file exists.
  $atime,$mtime,$ctime,  #
  $blksize,$blocks)=stat($fname);  # Parameters:
     my $now=time;  #    $cmd      - The command that got us here.
     my $since=$now-$atime;  #    $tail     - Tail of the command (remaining parameters).
     if ($since>$perlvar{'lonExpire'}) {  #    $client   - File descriptor connected to client.
  my $reply=  # Returns
     &reply("unsub:$fname","$clientname");  #     0        - Requested to exit, caller should shut down.
     unlink("$fname");  #     1        - Continue processing.
     } else {  # Implicit inputs:
  my $transname="$fname.in.transfer";  #    The authentication systems describe above have their own forms of implicit
  my $remoteurl=  #    input into the authentication process that are described above.
     &reply("sub:$fname","$clientname");  #
  my $response;  sub is_home_handler {
  {      my ($cmd, $tail, $client) = @_;
     my $ua=new LWP::UserAgent;     
     my $request=new HTTP::Request('GET',"$remoteurl");      my $userinput  = "$cmd:$tail";
     $response=$ua->request($request,$transname);     
  }      my ($udom,$uname)=split(/:/,$tail);
  if ($response->is_error()) {      chomp($uname);
     unlink($transname);      my $passfile = &password_filename($udom, $uname);
     my $message=$response->status_line;      if($passfile) {
     &logthis(   &Reply( $client, "found\n", $userinput);
      "LWP GET: $message for $fname ($remoteurl)");      } else {
  } else {   &Failure($client, "not_found\n", $userinput);
     if ($remoteurl!~/\.meta$/) {      }
  my $ua=new LWP::UserAgent;      return 1;
  my $mrequest=  }
     new HTTP::Request('GET',$remoteurl.'.meta');  &register_handler("home", \&is_home_handler, 0,1,0);
  my $mresponse=  
     $ua->request($mrequest,$fname.'.meta');  #
  if ($mresponse->is_error()) {  #   Process an update request for a resource?? I think what's going on here is
     unlink($fname.'.meta');  #   that a resource has been modified that we hold a subscription to.
  }  #   If the resource is not local, then we must update, or at least invalidate our
     }  #   cached copy of the resource. 
     rename($transname,$fname);  #   FUTURE WORK:
  }  #      I need to look at this logic carefully.  My druthers would be to follow
     }  #      typical caching logic, and simple invalidate the cache, drop any subscription
     print $client "ok\n";  #      an let the next fetch start the ball rolling again... however that may
  } else {  #      actually be more difficult than it looks given the complex web of
     print $client "not_found\n";  #      proxy servers.
  }  # Parameters:
   #    $cmd      - The command that got us here.
   #    $tail     - Tail of the command (remaining parameters).
   #    $client   - File descriptor connected to client.
   # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   # Implicit inputs:
   #    The authentication systems describe above have their own forms of implicit
   #    input into the authentication process that are described above.
   #
   sub update_resource_handler {
   
       my ($cmd, $tail, $client) = @_;
      
       my $userinput = "$cmd:$tail";
      
       my $fname= $tail; # This allows interactive testing
   
   
       my $ownership=ishome($fname);
       if ($ownership eq 'not_owner') {
    if (-e $fname) {
       my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
    $atime,$mtime,$ctime,$blksize,$blocks)=stat($fname);
       my $now=time;
       my $since=$now-$atime;
       if ($since>$perlvar{'lonExpire'}) {
    my $reply=&reply("unsub:$fname","$clientname");
    unlink("$fname");
     } else {      } else {
  print $client "rejected\n";   my $transname="$fname.in.transfer";
     }   my $remoteurl=&reply("sub:$fname","$clientname");
  } else {  
     Reply($client, "refused\n", $userinput);  
       
  }  
 # -------------------------------------- fetch a user file from a remote server  
     } elsif ($userinput =~ /^fetchuserfile/) { # Client clear or enc.  
  if(isClient) {  
     my ($cmd,$fname)=split(/:/,$userinput);  
     my ($udom,$uname,$ufile) = ($fname =~ m|^([^/]+)/([^/]+)/(.+)$|);  
     my $udir=propath($udom,$uname).'/userfiles';  
     unless (-e $udir) { mkdir($udir,0770); }  
     if (-e $udir) {  
  $ufile=~s/^[\.\~]+//;  
  my $path = $udir;  
  if ($ufile =~m|(.+)/([^/]+)$|) {  
     my @parts=split('/',$1);  
     foreach my $part (@parts) {  
  $path .= '/'.$part;  
  if ((-e $path)!=1) {  
     mkdir($path,0770);  
  }  
     }  
  }  
  my $destname=$udir.'/'.$ufile;  
  my $transname=$udir.'/'.$ufile.'.in.transit';  
  my $remoteurl='http://'.$clientip.'/userfiles/'.$fname;  
  my $response;   my $response;
    alarm(120);
  {   {
     my $ua=new LWP::UserAgent;      my $ua=new LWP::UserAgent;
     my $request=new HTTP::Request('GET',"$remoteurl");      my $request=new HTTP::Request('GET',"$remoteurl");
     $response=$ua->request($request,$transname);      $response=$ua->request($request,$transname);
  }   }
    alarm(0);
  if ($response->is_error()) {   if ($response->is_error()) {
     unlink($transname);      unlink($transname);
     my $message=$response->status_line;      my $message=$response->status_line;
     &logthis("LWP GET: $message for $fname ($remoteurl)");      &logthis("LWP GET: $message for $fname ($remoteurl)");
     print $client "failed\n";  
  } else {   } else {
     if (!rename($transname,$destname)) {      if ($remoteurl!~/\.meta$/) {
  &logthis("Unable to move $transname to $destname");   alarm(120);
  unlink($transname);   {
  print $client "failed\n";      my $ua=new LWP::UserAgent;
     } else {      my $mrequest=new HTTP::Request('GET',$remoteurl.'.meta');
  print $client "ok\n";      my $mresponse=$ua->request($mrequest,$fname.'.meta');
     }      if ($mresponse->is_error()) {
  }   unlink($fname.'.meta');
     } else {      }
  print $client "not_home\n";  
     }  
  } else {  
     Reply($client, "refused\n", $userinput);  
  }  
 # --------------------------------------------------------- remove a user file   
     } elsif ($userinput =~ /^removeuserfile/) { # Client clear or enc.  
  if(isClient) {  
     my ($cmd,$fname)=split(/:/,$userinput);  
     my ($udom,$uname,$ufile) = ($fname =~ m|^([^/]+)/([^/]+)/(.+)$|);  
     &logthis("$udom - $uname - $ufile");  
     if ($ufile =~m|/\.\./|) {  
  # any files paths with /../ in them refuse   
  # to deal with  
  print $client "refused\n";  
     } else {  
  my $udir=propath($udom,$uname);  
  if (-e $udir) {  
     my $file=$udir.'/userfiles/'.$ufile;  
     if (-e $file) {  
  unlink($file);  
  if (-e $file) {  
     print $client "failed\n";  
  } else {  
     print $client "ok\n";  
  }   }
     } else {   alarm(0);
  print $client "not_found\n";  
     }      }
  } else {      rename($transname,$fname);
     print $client "not_home\n";  
  }   }
     }      }
       &Reply( $client, "ok\n", $userinput);
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "not_found\n", $userinput);
  }   }
 # ------------------------------------------ authenticate access to a user file      } else {
     } elsif ($userinput =~ /^tokenauthuserfile/) { # Client only   &Failure($client, "rejected\n", $userinput);
  if(isClient) {      }
     my ($cmd,$fname,$session)=split(/:/,$userinput);      return 1;
     chomp($session);  }
     my $reply='non_auth';  &register_handler("update", \&update_resource_handler, 0 ,1, 0);
     if (open(ENVIN,$perlvar{'lonIDsDir'}.'/'.  
      $session.'.id')) {  #
  while (my $line=<ENVIN>) {  #   Fetch a user file from a remote server to the user's home directory
     if ($line=~ m|userfile\.\Q$fname\E\=|) { $reply='ok'; }  #   userfiles subdir.
     }  # Parameters:
  close(ENVIN);  #    $cmd      - The command that got us here.
  print $client $reply."\n";  #    $tail     - Tail of the command (remaining parameters).
     } else {  #    $client   - File descriptor connected to client.
  print $client "invalid_token\n";  # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   #
   sub fetch_user_file_handler {
   
       my ($cmd, $tail, $client) = @_;
   
       my $userinput = "$cmd:$tail";
       my $fname           = $tail;
       my ($udom,$uname,$ufile) = ($fname =~ m|^([^/]+)/([^/]+)/(.+)$|);
       my $udir=&propath($udom,$uname).'/userfiles';
       unless (-e $udir) {
    mkdir($udir,0770); 
       }
       Debug("fetch user file for $fname");
       if (-e $udir) {
    $ufile=~s/^[\.\~]+//;
   
    # IF necessary, create the path right down to the file.
    # Note that any regular files in the way of this path are
    # wiped out to deal with some earlier folly of mine.
   
    my $path = $udir;
    if ($ufile =~m|(.+)/([^/]+)$|) {
       my @parts=split('/',$1);
       foreach my $part (@parts) {
    $path .= '/'.$part;
    if( -f $path) {
       unlink($path);
    }
    if ((-e $path)!=1) {
       mkdir($path,0770);
    }
     }      }
  } else {  
     Reply($client, "refused\n", $userinput);  
       
  }   }
 # ----------------------------------------------------------------- unsubscribe  
     } elsif ($userinput =~ /^unsub/) {  
  if(isClient) {   my $destname=$udir.'/'.$ufile;
     my ($cmd,$fname)=split(/:/,$userinput);   my $transname=$udir.'/'.$ufile.'.in.transit';
     if (-e $fname) {   my $remoteurl='http://'.$clientip.'/userfiles/'.$fname;
  print $client &unsub($fname,$clientip);   my $response;
    Debug("Remote URL : $remoteurl Transfername $transname Destname: $destname");
    alarm(120);
    {
       my $ua=new LWP::UserAgent;
       my $request=new HTTP::Request('GET',"$remoteurl");
       $response=$ua->request($request,$transname);
    }
    alarm(0);
    if ($response->is_error()) {
       unlink($transname);
       my $message=$response->status_line;
       &logthis("LWP GET: $message for $fname ($remoteurl)");
       &Failure($client, "failed\n", $userinput);
    } else {
       Debug("Renaming $transname to $destname");
       if (!rename($transname,$destname)) {
    &logthis("Unable to move $transname to $destname");
    unlink($transname);
    &Failure($client, "failed\n", $userinput);
     } else {      } else {
  print $client "not_found\n";   &Reply($client, "ok\n", $userinput);
     }      }
  } else {   }   
     Reply($client, "refused\n", $userinput);      } else {
        &Failure($client, "not_home\n", $userinput);
  }      }
 # ------------------------------------------------------------------- subscribe      return 1;
     } elsif ($userinput =~ /^sub/) {  }
  if(isClient) {  &register_handler("fetchuserfile", \&fetch_user_file_handler, 0, 1, 0);
     print $client &subscribe($userinput,$clientip);  
  } else {  #
     Reply($client, "refused\n", $userinput);  #   Remove a file from a user's home directory userfiles subdirectory.
       # Parameters:
  }  #    cmd   - the Lond request keyword that got us here.
 # ------------------------------------------------------------- current version  #    tail  - the part of the command past the keyword.
     } elsif ($userinput =~ /^currentversion/) {  #    client- File descriptor connected with the client.
  if(isClient) {  #
     my ($cmd,$fname)=split(/:/,$userinput);  # Returns:
     print $client &currentversion($fname)."\n";  #    1    - Continue processing.
  } else {  
     Reply($client, "refused\n", $userinput);  sub remove_user_file_handler {
           my ($cmd, $tail, $client) = @_;
  }  
 # ------------------------------------------------------------------------- log      my ($fname) = split(/:/, $tail); # Get rid of any tailing :'s lonc may have sent.
     } elsif ($userinput =~ /^log/) {  
  if(isClient) {      my ($udom,$uname,$ufile) = ($fname =~ m|^([^/]+)/([^/]+)/(.+)$|);
     my ($cmd,$udom,$uname,$what)=split(/:/,$userinput);      if ($ufile =~m|/\.\./|) {
     chomp($what);   # any files paths with /../ in them refuse 
     my $proname=propath($udom,$uname);   # to deal with
     my $now=time;   &Failure($client, "refused\n", "$cmd:$tail");
     {      } else {
  my $hfh;   my $udir = &propath($udom,$uname);
  if ($hfh=IO::File->new(">>$proname/activity.log")) {    if (-e $udir) {
     print $hfh "$now:$clientname:$what\n";      my $file=$udir.'/userfiles/'.$ufile;
     print $client "ok\n";       if (-e $file) {
  } else {          if (-f $file){
     print $client "error: ".($!+0)      unlink($file);
  ." IO::File->new Failed "   } elsif(-d $file) {
  ."while attempting log\n";      rmdir($file);
  }   }
     }   if (-e $file) {
  } else {      &Failure($client, "failed\n", "$cmd:$tail");
     Reply($client, "refused\n", $userinput);  
       
  }  
 # ------------------------------------------------------------------------- put  
     } elsif ($userinput =~ /^put/) {  
  if(isClient) {  
     my ($cmd,$udom,$uname,$namespace,$what)  
  =split(/:/,$userinput,5);  
     $namespace=~s/\//\_/g;  
     $namespace=~s/\W//g;  
     if ($namespace ne 'roles') {  
  chomp($what);  
  my $proname=propath($udom,$uname);  
  my $now=time;  
  my @pairs=split(/\&/,$what);  
  my %hash;  
  if (tie(%hash,'GDBM_File',  
  "$proname/$namespace.db",  
  &GDBM_WRCREAT(),0640)) {  
     unless ($namespace=~/^nohist\_/) {  
  my $hfh;  
  if ($hfh=IO::File->new(">>$proname/$namespace.hist")) { print $hfh "P:$now:$what\n"; }  
     }  
       
     foreach my $pair (@pairs) {  
  my ($key,$value)=split(/=/,$pair);  
  $hash{$key}=$value;  
     }  
     if (untie(%hash)) {  
  print $client "ok\n";  
     } else {  
  print $client "error: ".($!+0)  
     ." untie(GDBM) failed ".  
     "while attempting put\n";  
     }  
  } else {   } else {
     print $client "error: ".($!)      &Reply($client, "ok\n", "$cmd:$tail");
  ." tie(GDBM) Failed ".  
  "while attempting put\n";  
  }   }
     } else {      } else {
  print $client "refused\n";   &Failure($client, "not_found\n", "$cmd:$tail");
     }      }
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "not_home\n", "$cmd:$tail");
       
  }   }
 # ------------------------------------------------------------------- inc      }
     } elsif ($userinput =~ /^inc:/) {      return 1;
  if(isClient) {  }
     my ($cmd,$udom,$uname,$namespace,$what)  &register_handler("removeuserfile", \&remove_user_file_handler, 0,1,0);
  =split(/:/,$userinput);  
     $namespace=~s/\//\_/g;  #
     $namespace=~s/\W//g;  #   make a directory in a user's home directory userfiles subdirectory.
     if ($namespace ne 'roles') {  # Parameters:
  chomp($what);  #    cmd   - the Lond request keyword that got us here.
  my $proname=propath($udom,$uname);  #    tail  - the part of the command past the keyword.
  my $now=time;  #    client- File descriptor connected with the client.
  my @pairs=split(/\&/,$what);  #
  my %hash;  # Returns:
  if (tie(%hash,'GDBM_File',  #    1    - Continue processing.
  "$proname/$namespace.db",  
  &GDBM_WRCREAT(),0640)) {  sub mkdir_user_file_handler {
     unless ($namespace=~/^nohist\_/) {      my ($cmd, $tail, $client) = @_;
  my $hfh;  
  if ($hfh=IO::File->new(">>$proname/$namespace.hist")) { print $hfh "P:$now:$what\n"; }      my ($dir) = split(/:/, $tail); # Get rid of any tailing :'s lonc may have sent.
     }      $dir=&unescape($dir);
     foreach my $pair (@pairs) {      my ($udom,$uname,$ufile) = ($dir =~ m|^([^/]+)/([^/]+)/(.+)$|);
  my ($key,$value)=split(/=/,$pair);      if ($ufile =~m|/\.\./|) {
  # We could check that we have a number...   # any files paths with /../ in them refuse 
  if (! defined($value) || $value eq '') {   # to deal with
     $value = 1;   &Failure($client, "refused\n", "$cmd:$tail");
  }      } else {
  $hash{$key}+=$value;   my $udir = &propath($udom,$uname);
     }   if (-e $udir) {
     if (untie(%hash)) {      my $newdir=$udir.'/userfiles/'.$ufile;
  print $client "ok\n";      if (!-e $newdir) {
     } else {   mkdir($newdir);
  print $client "error: ".($!+0)   if (!-e $newdir) {
     ." untie(GDBM) failed ".      &Failure($client, "failed\n", "$cmd:$tail");
     "while attempting inc\n";  
     }  
  } else {   } else {
     print $client "error: ".($!)      &Reply($client, "ok\n", "$cmd:$tail");
  ." tie(GDBM) Failed ".  
  "while attempting inc\n";  
  }   }
     } else {      } else {
  print $client "refused\n";   &Failure($client, "not_found\n", "$cmd:$tail");
     }      }
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "not_home\n", "$cmd:$tail");
       
  }   }
 # -------------------------------------------------------------------- rolesput      }
     } elsif ($userinput =~ /^rolesput/) {      return 1;
  if(isClient) {  }
     &Debug("rolesput");  &register_handler("mkdiruserfile", \&mkdir_user_file_handler, 0,1,0);
     if ($wasenc==1) {  
  my ($cmd,$exedom,$exeuser,$udom,$uname,$what)  #
     =split(/:/,$userinput);  #   rename a file in a user's home directory userfiles subdirectory.
  &Debug("cmd = ".$cmd." exedom= ".$exedom.  # Parameters:
        "user = ".$exeuser." udom=".$udom.  #    cmd   - the Lond request keyword that got us here.
        "what = ".$what);  #    tail  - the part of the command past the keyword.
  my $namespace='roles';  #    client- File descriptor connected with the client.
  chomp($what);  #
  my $proname=propath($udom,$uname);  # Returns:
  my $now=time;  #    1    - Continue processing.
  my @pairs=split(/\&/,$what);  
  my %hash;  sub rename_user_file_handler {
  if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {      my ($cmd, $tail, $client) = @_;
     {  
  my $hfh;      my ($udom,$uname,$old,$new) = split(/:/, $tail);
  if ($hfh=IO::File->new(">>$proname/$namespace.hist")) {       $old=&unescape($old);
     print $hfh "P:$now:$exedom:$exeuser:$what\n";      $new=&unescape($new);
  }      if ($new =~m|/\.\./| || $old =~m|/\.\./|) {
     }   # any files paths with /../ in them refuse to deal with
        &Failure($client, "refused\n", "$cmd:$tail");
     foreach my $pair (@pairs) {      } else {
  my ($key,$value)=split(/=/,$pair);   my $udir = &propath($udom,$uname);
  &ManagePermissions($key, $udom, $uname,   if (-e $udir) {
    &GetAuthType( $udom,       my $oldfile=$udir.'/userfiles/'.$old;
  $uname));      my $newfile=$udir.'/userfiles/'.$new;
  $hash{$key}=$value;      if (-e $newfile) {
     }   &Failure($client, "exists\n", "$cmd:$tail");
     if (untie(%hash)) {      } elsif (! -e $oldfile) {
  print $client "ok\n";   &Failure($client, "not_found\n", "$cmd:$tail");
     } else {  
  print $client "error: ".($!+0)  
     ." untie(GDBM) Failed ".  
     "while attempting rolesput\n";  
     }  
  } else {  
     print $client "error: ".($!+0)  
  ." tie(GDBM) Failed ".  
  "while attempting rolesput\n";  
     }  
     } else {      } else {
  print $client "refused\n";   if (!rename($oldfile,$newfile)) {
     }      &Failure($client, "failed\n", "$cmd:$tail");
  } else {  
     Reply($client, "refused\n", $userinput);  
       
  }  
 # -------------------------------------------------------------------- rolesdel  
     } elsif ($userinput =~ /^rolesdel/) {  
  if(isClient) {  
     &Debug("rolesdel");  
     if ($wasenc==1) {  
  my ($cmd,$exedom,$exeuser,$udom,$uname,$what)  
     =split(/:/,$userinput);  
  &Debug("cmd = ".$cmd." exedom= ".$exedom.  
        "user = ".$exeuser." udom=".$udom.  
        "what = ".$what);  
  my $namespace='roles';  
  chomp($what);  
  my $proname=propath($udom,$uname);  
  my $now=time;  
  my @rolekeys=split(/\&/,$what);  
  my %hash;  
  if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {  
     {  
  my $hfh;  
  if ($hfh=IO::File->new(">>$proname/$namespace.hist")) {   
     print $hfh "D:$now:$exedom:$exeuser:$what\n";  
  }  
     }  
     foreach my $key (@rolekeys) {  
  delete $hash{$key};  
     }  
     if (untie(%hash)) {  
  print $client "ok\n";  
     } else {  
  print $client "error: ".($!+0)  
     ." untie(GDBM) Failed ".  
     "while attempting rolesdel\n";  
     }  
  } else {   } else {
     print $client "error: ".($!+0)      &Reply($client, "ok\n", "$cmd:$tail");
  ." tie(GDBM) Failed ".  
  "while attempting rolesdel\n";  
  }   }
     } else {  
  print $client "refused\n";  
     }      }
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "not_home\n", "$cmd:$tail");
       
  }   }
 # ------------------------------------------------------------------------- get      }
     } elsif ($userinput =~ /^get/) {      return 1;
  if(isClient) {  }
     my ($cmd,$udom,$uname,$namespace,$what)  &register_handler("renameuserfile", \&rename_user_file_handler, 0,1,0);
  =split(/:/,$userinput);  
     $namespace=~s/\//\_/g;  
     $namespace=~s/\W//g;  #
     chomp($what);  #  Authenticate access to a user file by checking the user's 
     my @queries=split(/\&/,$what);  #  session token(?)
     my $proname=propath($udom,$uname);  #
     my $qresult='';  # Parameters:
     my %hash;  #   cmd      - The request keyword that dispatched to tus.
     if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {  #   tail     - The tail of the request (colon separated parameters).
  for (my $i=0;$i<=$#queries;$i++) {  #   client   - Filehandle open on the client.
     $qresult.="$hash{$queries[$i]}&";  # Return:
  }  #    1.
  if (untie(%hash)) {  
     $qresult=~s/\&$//;  sub token_auth_user_file_handler {
     print $client "$qresult\n";      my ($cmd, $tail, $client) = @_;
  } else {  
     print $client "error: ".($!+0)      my ($fname, $session) = split(/:/, $tail);
  ." untie(GDBM) Failed ".      
  "while attempting get\n";      chomp($session);
  }      my $reply='non_auth';
     } else {      if (open(ENVIN,$perlvar{'lonIDsDir'}.'/'.
  if ($!+0 == 2) {       $session.'.id')) {
     print $client "error:No such file or ".   while (my $line=<ENVIN>) {
  "GDBM reported bad block error\n";      if ($line=~ m|userfile\.\Q$fname\E\=|) { $reply='ok'; }
  } else {  
     print $client "error: ".($!+0)  
  ." tie(GDBM) Failed ".  
  "while attempting get\n";  
  }  
     }  
  } else {  
     Reply($client, "refused\n", $userinput);  
       
  }   }
 # ------------------------------------------------------------------------ eget   close(ENVIN);
     } elsif ($userinput =~ /^eget/) {   &Reply($client, $reply);
  if (isClient) {      } else {
     my ($cmd,$udom,$uname,$namespace,$what)   &Failure($client, "invalid_token\n", "$cmd:$tail");
  =split(/:/,$userinput);      }
     $namespace=~s/\//\_/g;      return 1;
     $namespace=~s/\W//g;  
     chomp($what);  }
     my @queries=split(/\&/,$what);  
     my $proname=propath($udom,$uname);  &register_handler("tokenauthuserfile", \&token_auth_user_file_handler, 0,1,0);
     my $qresult='';  
     my %hash;  
     if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {  #
  for (my $i=0;$i<=$#queries;$i++) {  #   Unsubscribe from a resource.
     $qresult.="$hash{$queries[$i]}&";  #
  }  # Parameters:
  if (untie(%hash)) {  #    $cmd      - The command that got us here.
     $qresult=~s/\&$//;  #    $tail     - Tail of the command (remaining parameters).
     if ($cipher) {  #    $client   - File descriptor connected to client.
  my $cmdlength=length($qresult);  # Returns
  $qresult.="         ";  #     0        - Requested to exit, caller should shut down.
  my $encqresult='';  #     1        - Continue processing.
  for   #
     (my $encidx=0;$encidx<=$cmdlength;$encidx+=8) {  sub unsubscribe_handler {
  $encqresult.=      my ($cmd, $tail, $client) = @_;
     unpack("H16",  
    $cipher->encrypt(substr($qresult,$encidx,8)));      my $userinput= "$cmd:$tail";
     }      
  print $client "enc:$cmdlength:$encqresult\n";      my ($fname) = split(/:/,$tail); # Split in case there's extrs.
     } else {  
  print $client "error:no_key\n";      &Debug("Unsubscribing $fname");
     }      if (-e $fname) {
  } else {   &Debug("Exists");
     print $client "error: ".($!+0)   &Reply($client, &unsub($fname,$clientip), $userinput);
  ." untie(GDBM) Failed ".      } else {
  "while attempting eget\n";   &Failure($client, "not_found\n", $userinput);
  }      }
       return 1;
   }
   &register_handler("unsub", \&unsubscribe_handler, 0, 1, 0);
   #   Subscribe to a resource
   #
   # Parameters:
   #    $cmd      - The command that got us here.
   #    $tail     - Tail of the command (remaining parameters).
   #    $client   - File descriptor connected to client.
   # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   #
   sub subscribe_handler {
       my ($cmd, $tail, $client)= @_;
   
       my $userinput  = "$cmd:$tail";
   
       &Reply( $client, &subscribe($userinput,$clientip), $userinput);
   
       return 1;
   }
   &register_handler("sub", \&subscribe_handler, 0, 1, 0);
   
   #
   #   Determine the version of a resource (?) Or is it return
   #   the top version of the resource?  Not yet clear from the
   #   code in currentversion.
   #
   # Parameters:
   #    $cmd      - The command that got us here.
   #    $tail     - Tail of the command (remaining parameters).
   #    $client   - File descriptor connected to client.
   # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   #
   sub current_version_handler {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput= "$cmd:$tail";
      
       my $fname   = $tail;
       &Reply( $client, &currentversion($fname)."\n", $userinput);
       return 1;
   
   }
   &register_handler("currentversion", \&current_version_handler, 0, 1, 0);
   
   #  Make an entry in a user's activity log.
   #
   # Parameters:
   #    $cmd      - The command that got us here.
   #    $tail     - Tail of the command (remaining parameters).
   #    $client   - File descriptor connected to client.
   # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   #
   sub activity_log_handler {
       my ($cmd, $tail, $client) = @_;
   
   
       my $userinput= "$cmd:$tail";
   
       my ($udom,$uname,$what)=split(/:/,$tail);
       chomp($what);
       my $proname=&propath($udom,$uname);
       my $now=time;
       my $hfh;
       if ($hfh=IO::File->new(">>$proname/activity.log")) { 
    print $hfh "$now:$clientname:$what\n";
    &Reply( $client, "ok\n", $userinput); 
       } else {
    &Failure($client, "error: ".($!+0)." IO::File->new Failed "
    ."while attempting log\n", 
    $userinput);
       }
   
       return 1;
   }
   register_handler("log", \&activity_log_handler, 0, 1, 0);
   
   #
   #   Put a namespace entry in a user profile hash.
   #   My druthers would be for this to be an encrypted interaction too.
   #   anything that might be an inadvertent covert channel about either
   #   user authentication or user personal information....
   #
   # Parameters:
   #    $cmd      - The command that got us here.
   #    $tail     - Tail of the command (remaining parameters).
   #    $client   - File descriptor connected to client.
   # Returns
   #     0        - Requested to exit, caller should shut down.
   #     1        - Continue processing.
   #
   sub put_user_profile_entry {
       my ($cmd, $tail, $client)  = @_;
   
       my $userinput = "$cmd:$tail";
       
       my ($udom,$uname,$namespace,$what) =split(/:/,$tail,4);
       if ($namespace ne 'roles') {
    chomp($what);
    my $hashref = &tie_user_hash($udom, $uname, $namespace,
     &GDBM_WRCREAT(),"P",$what);
    if($hashref) {
       my @pairs=split(/\&/,$what);
       foreach my $pair (@pairs) {
    my ($key,$value)=split(/=/,$pair);
    $hashref->{$key}=$value;
       }
       if (untie(%$hashref)) {
    &Reply( $client, "ok\n", $userinput);
     } else {      } else {
  print $client "error: ".($!+0)   &Failure($client, "error: ".($!+0)." untie(GDBM) failed ".
     ." tie(GDBM) Failed ".   "while attempting put\n", 
     "while attempting eget\n";   $userinput);
     }      }
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure( $client, "error: ".($!)." tie(GDBM) Failed ".
            "while attempting put\n", $userinput);
  }   }
 # ------------------------------------------------------------------------- del      } else {
     } elsif ($userinput =~ /^del/) {          &Failure( $client, "refused\n", $userinput);
  if(isClient) {      }
     my ($cmd,$udom,$uname,$namespace,$what)      
  =split(/:/,$userinput);      return 1;
     $namespace=~s/\//\_/g;  }
     $namespace=~s/\W//g;  &register_handler("put", \&put_user_profile_entry, 0, 1, 0);
     chomp($what);  
     my $proname=propath($udom,$uname);  # 
     my $now=time;  #   Increment a profile entry in the user history file.
     my @keys=split(/\&/,$what);  #   The history contains keyword value pairs.  In this case,
     my %hash;  #   The value itself is a pair of numbers.  The first, the current value
     if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {  #   the second an increment that this function applies to the current
  unless ($namespace=~/^nohist\_/) {  #   value.
     my $hfh;  #
     if ($hfh=IO::File->new(">>$proname/$namespace.hist")) { print $hfh "D:$now:$what\n"; }  # Parameters:
  }  #    $cmd      - The command that got us here.
  foreach my $key (@keys) {  #    $tail     - Tail of the command (remaining parameters).
     delete($hash{$key});  #    $client   - File descriptor connected to client.
  }  # Returns
  if (untie(%hash)) {  #     0        - Requested to exit, caller should shut down.
     print $client "ok\n";  #     1        - Continue processing.
  } else {  #
     print $client "error: ".($!+0)  sub increment_user_value_handler {
  ." untie(GDBM) Failed ".      my ($cmd, $tail, $client) = @_;
  "while attempting del\n";      
       my $userinput   = "$cmd:$tail";
       
       my ($udom,$uname,$namespace,$what) =split(/:/,$tail);
       if ($namespace ne 'roles') {
           chomp($what);
    my $hashref = &tie_user_hash($udom, $uname,
        $namespace, &GDBM_WRCREAT(),
        "P",$what);
    if ($hashref) {
       my @pairs=split(/\&/,$what);
       foreach my $pair (@pairs) {
    my ($key,$value)=split(/=/,$pair);
    # We could check that we have a number...
    if (! defined($value) || $value eq '') {
       $value = 1;
  }   }
    $hashref->{$key}+=$value;
       }
       if (untie(%$hashref)) {
    &Reply( $client, "ok\n", $userinput);
     } else {      } else {
  print $client "error: ".($!+0)   &Failure($client, "error: ".($!+0)." untie(GDBM) failed ".
     ." tie(GDBM) Failed ".   "while attempting inc\n", $userinput);
     "while attempting del\n";  
     }      }
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "error: ".($!+0)." tie(GDBM) Failed ".
            "while attempting inc\n", $userinput);
  }   }
 # ------------------------------------------------------------------------ keys      } else {
     } elsif ($userinput =~ /^keys/) {   &Failure($client, "refused\n", $userinput);
  if(isClient) {      }
     my ($cmd,$udom,$uname,$namespace)      
  =split(/:/,$userinput);      return 1;
     $namespace=~s/\//\_/g;  }
     $namespace=~s/\W//g;  &register_handler("inc", \&increment_user_value_handler, 0, 1, 0);
     my $proname=propath($udom,$uname);  
     my $qresult='';  
     my %hash;  #
     if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {  #   Put a new role for a user.  Roles are LonCAPA's packaging of permissions.
  foreach my $key (keys %hash) {  #   Each 'role' a user has implies a set of permissions.  Adding a new role
     $qresult.="$key&";  #   for a person grants the permissions packaged with that role
  }  #   to that user when the role is selected.
  if (untie(%hash)) {  #
     $qresult=~s/\&$//;  # Parameters:
     print $client "$qresult\n";  #    $cmd       - The command string (rolesput).
  } else {  #    $tail      - The remainder of the request line.  For rolesput this
     print $client "error: ".($!+0)  #                 consists of a colon separated list that contains:
  ." untie(GDBM) Failed ".  #                 The domain and user that is granting the role (logged).
  "while attempting keys\n";  #                 The domain and user that is getting the role.
  }  #                 The roles being granted as a set of & separated pairs.
     } else {  #                 each pair a key value pair.
  print $client "error: ".($!+0)  #    $client    - File descriptor connected to the client.
     ." tie(GDBM) Failed ".  # Returns:
     "while attempting keys\n";  #     0         - If the daemon should exit
     }  #     1         - To continue processing.
   #
   #
   sub roles_put_handler {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput  = "$cmd:$tail";
   
       my ( $exedom, $exeuser, $udom, $uname,  $what) = split(/:/,$tail);
       
   
       my $namespace='roles';
       chomp($what);
       my $hashref = &tie_user_hash($udom, $uname, $namespace,
    &GDBM_WRCREAT(), "P",
    "$exedom:$exeuser:$what");
       #
       #  Log the attempt to set a role.  The {}'s here ensure that the file 
       #  handle is open for the minimal amount of time.  Since the flush
       #  is done on close this improves the chances the log will be an un-
       #  corrupted ordered thing.
       if ($hashref) {
    my @pairs=split(/\&/,$what);
    foreach my $pair (@pairs) {
       my ($key,$value)=split(/=/,$pair);
       &manage_permissions($key, $udom, $uname,
          &get_auth_type( $udom, $uname));
       $hashref->{$key}=$value;
    }
    if (untie($hashref)) {
       &Reply($client, "ok\n", $userinput);
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure( $client, "error: ".($!+0)." untie(GDBM) Failed ".
            "while attempting rolesput\n", $userinput);
  }   }
 # ----------------------------------------------------------------- dumpcurrent      } else {
     } elsif ($userinput =~ /^currentdump/) {   &Failure( $client, "error: ".($!+0)." tie(GDBM) Failed ".
  if (isClient) {   "while attempting rolesput\n", $userinput);
     my ($cmd,$udom,$uname,$namespace)      }
  =split(/:/,$userinput);      return 1;
     $namespace=~s/\//\_/g;  }
     $namespace=~s/\W//g;  &register_handler("rolesput", \&roles_put_handler, 1,1,0);  # Encoded client only.
     my $qresult='';  
     my $proname=propath($udom,$uname);  #
     my %hash;  #   Deletes (removes) a role for a user.   This is equivalent to removing
     if (tie(%hash,'GDBM_File',  #  a permissions package associated with the role from the user's profile.
     "$proname/$namespace.db",  #
     &GDBM_READER(),0640)) {  # Parameters:
     # Structure of %data:  #     $cmd                 - The command (rolesdel)
  # $data{$symb}->{$parameter}=$value;  #     $tail                - The remainder of the request line. This consists
  # $data{$symb}->{'v.'.$parameter}=$version;  #                             of:
  # since $parameter will be unescaped, we do not  #                             The domain and user requesting the change (logged)
  # have to worry about silly parameter names...  #                             The domain and user being changed.
  my %data = ();  #                             The roles being revoked.  These are shipped to us
  while (my ($key,$value) = each(%hash)) {  #                             as a bunch of & separated role name keywords.
     my ($v,$symb,$param) = split(/:/,$key);  #     $client              - The file handle open on the client.
     next if ($v eq 'version' || $symb eq 'keys');  # Returns:
     next if (exists($data{$symb}) &&   #     1                    - Continue processing
      exists($data{$symb}->{$param}) &&  #     0                    - Exit.
      $data{$symb}->{'v.'.$param} > $v);  #
     $data{$symb}->{$param}=$value;  sub roles_delete_handler {
     $data{$symb}->{'v.'.$param}=$v;      my ($cmd, $tail, $client)  = @_;
  }  
  if (untie(%hash)) {      my $userinput    = "$cmd:$tail";
     while (my ($symb,$param_hash) = each(%data)) {     
  while(my ($param,$value) = each (%$param_hash)){      my ($exedom,$exeuser,$udom,$uname,$what)=split(/:/,$tail);
     next if ($param =~ /^v\./);      &Debug("cmd = ".$cmd." exedom= ".$exedom."user = ".$exeuser." udom=".$udom.
     $qresult.=$symb.':'.$param.'='.$value.'&';     "what = ".$what);
  }      my $namespace='roles';
     }      chomp($what);
     chop($qresult);      my $hashref = &tie_user_hash($udom, $uname, $namespace,
     print $client "$qresult\n";   &GDBM_WRCREAT(), "D",
  } else {   "$exedom:$exeuser:$what");
     print $client "error: ".($!+0)      
  ." untie(GDBM) Failed ".      if ($hashref) {
  "while attempting currentdump\n";   my @rolekeys=split(/\&/,$what);
  }  
     } else {   foreach my $key (@rolekeys) {
  print $client "error: ".($!+0)      delete $hashref->{$key};
     ." tie(GDBM) Failed ".   }
     "while attempting currentdump\n";   if (untie(%$hashref)) {
     }      &Reply($client, "ok\n", $userinput);
  } else {  
     Reply($client, "refused\n", $userinput);  
  }  
 # ------------------------------------------------------------------------ dump  
     } elsif ($userinput =~ /^dump/) {  
  if(isClient) {  
     my ($cmd,$udom,$uname,$namespace,$regexp)  
  =split(/:/,$userinput);  
     $namespace=~s/\//\_/g;  
     $namespace=~s/\W//g;  
     if (defined($regexp)) {  
  $regexp=&unescape($regexp);  
     } else {  
  $regexp='.';  
     }  
     my $qresult='';  
     my $proname=propath($udom,$uname);  
     my %hash;  
     if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {  
  while (my ($key,$value) = each(%hash)) {  
     if ($regexp eq '.') {  
  $qresult.=$key.'='.$value.'&';  
     } else {  
  my $unescapeKey = &unescape($key);  
  if (eval('$unescapeKey=~/$regexp/')) {  
     $qresult.="$key=$value&";  
  }  
     }  
  }  
  if (untie(%hash)) {  
     chop($qresult);  
     print $client "$qresult\n";  
  } else {  
     print $client "error: ".($!+0)  
  ." untie(GDBM) Failed ".  
  "while attempting dump\n";  
  }  
     } else {  
  print $client "error: ".($!+0)  
     ." tie(GDBM) Failed ".  
     "while attempting dump\n";  
     }  
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure( $client, "error: ".($!+0)." untie(GDBM) Failed ".
            "while attempting rolesdel\n", $userinput);
  }   }
 # ----------------------------------------------------------------------- store      } else {
     } elsif ($userinput =~ /^store/) {          &Failure( $client, "error: ".($!+0)." tie(GDBM) Failed ".
  if(isClient) {   "while attempting rolesdel\n", $userinput);
     my ($cmd,$udom,$uname,$namespace,$rid,$what)      }
  =split(/:/,$userinput);      
     $namespace=~s/\//\_/g;      return 1;
     $namespace=~s/\W//g;  }
     if ($namespace ne 'roles') {  &register_handler("rolesdel", \&roles_delete_handler, 1,1, 0); # Encoded client only
  chomp($what);  
  my $proname=propath($udom,$uname);  # Unencrypted get from a user's profile database.  See 
  my $now=time;  # GetProfileEntryEncrypted for a version that does end-to-end encryption.
  my @pairs=split(/\&/,$what);  # This function retrieves a keyed item from a specific named database in the
  my %hash;  # user's directory.
  if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_WRCREAT(),0640)) {  #
     unless ($namespace=~/^nohist\_/) {  # Parameters:
  my $hfh;  #   $cmd             - Command request keyword (get).
  if ($hfh=IO::File->new(">>$proname/$namespace.hist")) {  #   $tail            - Tail of the command.  This is a colon separated list
     print $hfh "P:$now:$rid:$what\n";  #                      consisting of the domain and username that uniquely
  }  #                      identifies the profile,
     }  #                      The 'namespace' which selects the gdbm file to 
     my @previouskeys=split(/&/,$hash{"keys:$rid"});  #                      do the lookup in, 
     my $key;  #                      & separated list of keys to lookup.  Note that
     $hash{"version:$rid"}++;  #                      the values are returned as an & separated list too.
     my $version=$hash{"version:$rid"};  #   $client          - File descriptor open on the client.
     my $allkeys='';   # Returns:
     foreach my $pair (@pairs) {  #   1       - Continue processing.
  my ($key,$value)=split(/=/,$pair);  #   0       - Exit.
  $allkeys.=$key.':';  #
  $hash{"$version:$rid:$key"}=$value;  sub get_profile_entry {
     }      my ($cmd, $tail, $client) = @_;
     $hash{"$version:$rid:timestamp"}=$now;  
     $allkeys.='timestamp';      my $userinput= "$cmd:$tail";
     $hash{"$version:keys:$rid"}=$allkeys;     
     if (untie(%hash)) {      my ($udom,$uname,$namespace,$what) = split(/:/,$tail);
  print $client "ok\n";      chomp($what);
     } else {      my $hashref = &tie_user_hash($udom, $uname, $namespace,
  print $client "error: ".($!+0)   &GDBM_READER());
     ." untie(GDBM) Failed ".      if ($hashref) {
     "while attempting store\n";          my @queries=split(/\&/,$what);
  }          my $qresult='';
  } else {  
     print $client "error: ".($!+0)   for (my $i=0;$i<=$#queries;$i++) {
  ." tie(GDBM) Failed ".      $qresult.="$hashref->{$queries[$i]}&";    # Presumably failure gives empty string.
  "while attempting store\n";   }
  }   $qresult=~s/\&$//;              # Remove trailing & from last lookup.
     } else {   if (untie(%$hashref)) {
  print $client "refused\n";      &Reply($client, "$qresult\n", $userinput);
     }  
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "error: ".($!+0)." untie(GDBM) Failed ".
           "while attempting get\n", $userinput);
  }   }
 # --------------------------------------------------------------------- restore      } else {
     } elsif ($userinput =~ /^restore/) {   if ($!+0 == 2) {               # +0 coerces errno -> number 2 is ENOENT
  if(isClient) {      &Failure($client, "error:No such file or ".
     my ($cmd,$udom,$uname,$namespace,$rid)      "GDBM reported bad block error\n", $userinput);
  =split(/:/,$userinput);   } else {                        # Some other undifferentiated err.
     $namespace=~s/\//\_/g;      &Failure($client, "error: ".($!+0)." tie(GDBM) Failed ".
     $namespace=~s/\W//g;      "while attempting get\n", $userinput);
     chomp($rid);   }
     my $proname=propath($udom,$uname);      }
     my $qresult='';      return 1;
     my %hash;  }
     if (tie(%hash,'GDBM_File',"$proname/$namespace.db",&GDBM_READER(),0640)) {  &register_handler("get", \&get_profile_entry, 0,1,0);
  my $version=$hash{"version:$rid"};  
  $qresult.="version=$version&";  #
  my $scope;  #  Process the encrypted get request.  Note that the request is sent
  for ($scope=1;$scope<=$version;$scope++) {  #  in clear, but the reply is encrypted.  This is a small covert channel:
     my $vkeys=$hash{"$scope:keys:$rid"};  #  information about the sensitive keys is given to the snooper.  Just not
     my @keys=split(/:/,$vkeys);  #  information about the values of the sensitive key.  Hmm if I wanted to
     my $key;  #  know these I'd snoop for the egets. Get the profile item names from them
     $qresult.="$scope:keys=$vkeys&";  #  and then issue a get for them since there's no enforcement of the
     foreach $key (@keys) {  #  requirement of an encrypted get for particular profile items.  If I
  $qresult.="$scope:$key=".$hash{"$scope:$rid:$key"}."&";  #  were re-doing this, I'd force the request to be encrypted as well as the
     }                                    #  reply.  I'd also just enforce encrypted transactions for all gets since
  }  #  that would prevent any covert channel snooping.
  if (untie(%hash)) {  #
     $qresult=~s/\&$//;  #  Parameters:
     print $client "$qresult\n";  #     $cmd               - Command keyword of request (eget).
  } else {  #     $tail              - Tail of the command.  See GetProfileEntry #                          for more information about this.
     print $client "error: ".($!+0)  #     $client            - File open on the client.
  ." untie(GDBM) Failed ".  #  Returns:
  "while attempting restore\n";  #     1      - Continue processing
   #     0      - server should exit.
   sub get_profile_entry_encrypted {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput = "$cmd:$tail";
      
       my ($cmd,$udom,$uname,$namespace,$what) = split(/:/,$userinput);
       chomp($what);
       my $hashref = &tie_user_hash($udom, $uname, $namespace,
    &GDBM_READER());
       if ($hashref) {
           my @queries=split(/\&/,$what);
           my $qresult='';
    for (my $i=0;$i<=$#queries;$i++) {
       $qresult.="$hashref->{$queries[$i]}&";
    }
    if (untie(%$hashref)) {
       $qresult=~s/\&$//;
       if ($cipher) {
    my $cmdlength=length($qresult);
    $qresult.="         ";
    my $encqresult='';
    for(my $encidx=0;$encidx<=$cmdlength;$encidx+=8) {
       $encqresult.= unpack("H16", 
    $cipher->encrypt(substr($qresult,
    $encidx,
    8)));
  }   }
    &Reply( $client, "enc:$cmdlength:$encqresult\n", $userinput);
     } else {      } else {
  print $client "error: ".($!+0)   &Failure( $client, "error:no_key\n", $userinput);
     ." tie(GDBM) Failed ".  
     "while attempting restore\n";  
     }      }
  } else  {  
     Reply($client, "refused\n", $userinput);  
       
  }  
 # -------------------------------------------------------------------- chatsend  
     } elsif ($userinput =~ /^chatsend/) {  
  if(isClient) {  
     my ($cmd,$cdom,$cnum,$newpost)=split(/\:/,$userinput);  
     &chatadd($cdom,$cnum,$newpost);  
     print $client "ok\n";  
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "error: ".($!+0)." untie(GDBM) Failed ".
           "while attempting eget\n", $userinput);
  }   }
 # -------------------------------------------------------------------- chatretr      } else {
     } elsif ($userinput =~ /^chatretr/) {   &Failure($client, "error: ".($!+0)." tie(GDBM) Failed ".
  if(isClient) {   "while attempting eget\n", $userinput);
     my       }
  ($cmd,$cdom,$cnum,$udom,$uname)=split(/\:/,$userinput);      
     my $reply='';      return 1;
     foreach (&getchat($cdom,$cnum,$udom,$uname)) {  }
  $reply.=&escape($_).':';  &register_handler("eget", \&GetProfileEntryEncrypted, 0, 1, 0);
     }  #
     $reply=~s/\:$//;  #   Deletes a key in a user profile database.
     print $client $reply."\n";  #   
  } else {  #   Parameters:
     Reply($client, "refused\n", $userinput);  #       $cmd                  - Command keyword (del).
       #       $tail                 - Command tail.  IN this case a colon
   #                               separated list containing:
   #                               The domain and user that identifies uniquely
   #                               the identity of the user.
   #                               The profile namespace (name of the profile
   #                               database file).
   #                               & separated list of keywords to delete.
   #       $client              - File open on client socket.
   # Returns:
   #     1   - Continue processing
   #     0   - Exit server.
   #
   #
   
   sub delete_profile_entry {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput = "cmd:$tail";
   
       my ($udom,$uname,$namespace,$what) = split(/:/,$tail);
       chomp($what);
       my $hashref = &tie_user_hash($udom, $uname, $namespace,
    &GDBM_WRCREAT(),
    "D",$what);
       if ($hashref) {
           my @keys=split(/\&/,$what);
    foreach my $key (@keys) {
       delete($hashref->{$key});
  }   }
 # ------------------------------------------------------------------- querysend   if (untie(%$hashref)) {
     } elsif ($userinput =~ /^querysend/) {      &Reply($client, "ok\n", $userinput);
  if (isClient) {  
     my ($cmd,$query,  
  $arg1,$arg2,$arg3)=split(/\:/,$userinput);  
     $query=~s/\n*$//g;  
     print $client "".  
  sqlreply("$clientname\&$query".  
  "\&$arg1"."\&$arg2"."\&$arg3")."\n";  
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "error: ".($!+0)." untie(GDBM) Failed ".
           "while attempting del\n", $userinput);
  }   }
 # ------------------------------------------------------------------ queryreply      } else {
     } elsif ($userinput =~ /^queryreply/) {   &Failure( $client, "error: ".($!+0)." tie(GDBM) Failed ".
  if(isClient) {   "while attempting del\n", $userinput);
     my ($cmd,$id,$reply)=split(/:/,$userinput);       }
     my $store;      return 1;
     my $execdir=$perlvar{'lonDaemons'};  }
     if ($store=IO::File->new(">$execdir/tmp/$id")) {  &register_handler("del", \&delete_profile_entry, 0, 1, 0);
  $reply=~s/\&/\n/g;  #
  print $store $reply;  #  List the set of keys that are defined in a profile database file.
  close $store;  #  A successful reply from this will contain an & separated list of
  my $store2=IO::File->new(">$execdir/tmp/$id.end");  #  the keys. 
  print $store2 "done\n";  # Parameters:
  close $store2;  #     $cmd              - Command request (keys).
  print $client "ok\n";  #     $tail             - Remainder of the request, a colon separated
     }  #                         list containing domain/user that identifies the
     else {  #                         user being queried, and the database namespace
  print $client "error: ".($!+0)  #                         (database filename essentially).
     ." IO::File->new Failed ".  #     $client           - File open on the client.
     "while attempting queryreply\n";  #  Returns:
     }  #    1    - Continue processing.
   #    0    - Exit the server.
   #
   sub get_profile_keys {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput = "$cmd:$tail";
   
       my ($udom,$uname,$namespace)=split(/:/,$tail);
       my $qresult='';
       my $hashref = &tie_user_hash($udom, $uname, $namespace,
     &GDBM_READER());
       if ($hashref) {
    foreach my $key (keys %$hashref) {
       $qresult.="$key&";
    }
    if (untie(%$hashref)) {
       $qresult=~s/\&$//;
       &Reply($client, "$qresult\n", $userinput);
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "error: ".($!+0)." untie(GDBM) Failed ".
           "while attempting keys\n", $userinput);
  }   }
 # ----------------------------------------------------------------- courseidput      } else {
     } elsif ($userinput =~ /^courseidput/) {   &Failure( $client, "error: ".($!+0)." tie(GDBM) Failed ".
  if(isClient) {   "while attempting keys\n", $userinput);
     my ($cmd,$udom,$what)=split(/:/,$userinput);      }
     chomp($what);     
  $udom=~s/\W//g;      return 1;
     my $proname=  }
  "$perlvar{'lonUsersDir'}/$udom/nohist_courseids";  &register_handler("keys", \&get_profile_keys, 0, 1, 0);
     my $now=time;  
     my @pairs=split(/\&/,$what);  #
     my %hash;  #   Dump the contents of a user profile database.
     if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_WRCREAT(),0640)) {  #   Note that this constitutes a very large covert channel too since
  foreach my $pair (@pairs) {  #   the dump will return sensitive information that is not encrypted.
     my ($key,$descr,$inst_code)=split(/=/,$pair);  #   The naive security assumption is that the session negotiation ensures
     $hash{$key}=$descr.':'.$inst_code.':'.$now;  #   our client is trusted and I don't believe that's assured at present.
  }  #   Sure want badly to go to ssl or tls.  Of course if my peer isn't really
  if (untie(%hash)) {  #   a LonCAPA node they could have negotiated an encryption key too so >sigh<.
     print $client "ok\n";  # 
  } else {  #  Parameters:
     print $client "error: ".($!+0)  #     $cmd           - The command request keyword (currentdump).
  ." untie(GDBM) Failed ".  #     $tail          - Remainder of the request, consisting of a colon
  "while attempting courseidput\n";  #                      separated list that has the domain/username and
   #                      the namespace to dump (database file).
   #     $client        - file open on the remote client.
   # Returns:
   #     1    - Continue processing.
   #     0    - Exit the server.
   #
   sub dump_profile_database {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput = "$cmd:$tail";
      
       my ($udom,$uname,$namespace) = split(/:/,$tail);
       my $hashref = &tie_user_hash($udom, $uname, $namespace,
    &GDBM_READER());
       if ($hashref) {
    # Structure of %data:
    # $data{$symb}->{$parameter}=$value;
    # $data{$symb}->{'v.'.$parameter}=$version;
    # since $parameter will be unescaped, we do not
     # have to worry about silly parameter names...
   
           my $qresult='';
    my %data = ();                     # A hash of anonymous hashes..
    while (my ($key,$value) = each(%$hashref)) {
       my ($v,$symb,$param) = split(/:/,$key);
       next if ($v eq 'version' || $symb eq 'keys');
       next if (exists($data{$symb}) && 
        exists($data{$symb}->{$param}) &&
        $data{$symb}->{'v.'.$param} > $v);
       $data{$symb}->{$param}=$value;
       $data{$symb}->{'v.'.$param}=$v;
    }
    if (untie(%$hashref)) {
       while (my ($symb,$param_hash) = each(%data)) {
    while(my ($param,$value) = each (%$param_hash)){
       next if ($param =~ /^v\./);       # Ignore versions...
       #
       #   Just dump the symb=value pairs separated by &
       #
       $qresult.=$symb.':'.$param.'='.$value.'&';
  }   }
     } else {  
  print $client "error: ".($!+0)  
     ." tie(GDBM) Failed ".  
     "while attempting courseidput\n";  
     }      }
       chop($qresult);
       &Reply($client , "$qresult\n", $userinput);
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure( $client, "error: ".($!+0)." untie(GDBM) Failed ".
            "while attempting currentdump\n", $userinput);
  }   }
 # ---------------------------------------------------------------- courseiddump      } else {
     } elsif ($userinput =~ /^courseiddump/) {   &Failure($client, "error: ".($!+0)." tie(GDBM) Failed ".
  if(isClient) {   "while attempting currentdump\n", $userinput);
     my ($cmd,$udom,$since,$description)      }
  =split(/:/,$userinput);  
     if (defined($description)) {      return 1;
  $description=&unescape($description);  }
   &register_handler("currentdump", \&dump_profile_database, 0, 1, 0);
   
   #
   #   Dump a profile database with an optional regular expression
   #   to match against the keys.  In this dump, no effort is made
   #   to separate symb from version information. Presumably the
   #   databases that are dumped by this command are of a different
   #   structure.  Need to look at this and improve the documentation of
   #   both this and the currentdump handler.
   # Parameters:
   #    $cmd                     - The command keyword.
   #    $tail                    - All of the characters after the $cmd:
   #                               These are expected to be a colon
   #                               separated list containing:
   #                               domain/user - identifying the user.
   #                               namespace   - identifying the database.
   #                               regexp      - optional regular expression
   #                                             that is matched against
   #                                             database keywords to do
   #                                             selective dumps.
   #   $client                   - Channel open on the client.
   # Returns:
   #    1    - Continue processing.
   # Side effects:
   #    response is written to $client.
   #
   sub dump_with_regexp {
       my ($cmd, $tail, $client) = @_;
   
   
       my $userinput = "$cmd:$tail";
   
       my ($udom,$uname,$namespace,$regexp)=split(/:/,$tail);
       if (defined($regexp)) {
    $regexp=&unescape($regexp);
       } else {
    $regexp='.';
       }
       my $hashref = &tie_user_hash($udom, $uname, $namespace,
    &GDBM_READER());
       if ($hashref) {
           my $qresult='';
    while (my ($key,$value) = each(%$hashref)) {
       if ($regexp eq '.') {
    $qresult.=$key.'='.$value.'&';
     } else {      } else {
  $description='.';   my $unescapeKey = &unescape($key);
     }   if (eval('$unescapeKey=~/$regexp/')) {
     unless (defined($since)) { $since=0; }      $qresult.="$key=$value&";
     my $qresult='';  
     my $proname=  
  "$perlvar{'lonUsersDir'}/$udom/nohist_courseids";  
     my %hash;  
     if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_READER(),0640)) {  
  while (my ($key,$value) = each(%hash)) {  
     my ($descr,$lasttime,$inst_code);  
     if ($value =~ m/^([^\:]*):([^\:]*):(\d+)$/) {  
  ($descr,$inst_code,$lasttime)=($1,$2,$3);  
     } else {  
  ($descr,$lasttime) = split(/\:/,$value);  
     }  
     if ($lasttime<$since) { next; }  
     if ($description eq '.') {  
  $qresult.=$key.'='.$descr.':'.$inst_code.'&';  
     } else {  
  my $unescapeVal = &unescape($descr);  
  if (eval('$unescapeVal=~/\Q$description\E/i')) {  
     $qresult.=$key.'='.$descr.':'.$inst_code.'&';  
  }  
     }  
  }   }
  if (untie(%hash)) {  
     chop($qresult);  
     print $client "$qresult\n";  
  } else {  
     print $client "error: ".($!+0)  
  ." untie(GDBM) Failed ".  
  "while attempting courseiddump\n";  
  }  
     } else {  
  print $client "error: ".($!+0)  
     ." tie(GDBM) Failed ".  
     "while attempting courseiddump\n";  
     }      }
  } else {  
     Reply($client, "refused\n", $userinput);  
       
  }   }
 # ----------------------------------------------------------------------- idput   if (untie(%$hashref)) {
     } elsif ($userinput =~ /^idput/) {      chop($qresult);
  if(isClient) {      &Reply($client, "$qresult\n", $userinput);
     my ($cmd,$udom,$what)=split(/:/,$userinput);  
     chomp($what);  
     $udom=~s/\W//g;  
     my $proname="$perlvar{'lonUsersDir'}/$udom/ids";  
     my $now=time;  
     my @pairs=split(/\&/,$what);  
     my %hash;  
     if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_WRCREAT(),0640)) {  
  {  
     my $hfh;  
     if ($hfh=IO::File->new(">>$proname.hist")) {  
  print $hfh "P:$now:$what\n";  
     }  
  }  
  foreach my $pair (@pairs) {  
     my ($key,$value)=split(/=/,$pair);  
     $hash{$key}=$value;  
  }  
  if (untie(%hash)) {  
     print $client "ok\n";  
  } else {  
     print $client "error: ".($!+0)  
  ." untie(GDBM) Failed ".  
  "while attempting idput\n";  
  }  
     } else {  
  print $client "error: ".($!+0)  
     ." tie(GDBM) Failed ".  
     "while attempting idput\n";  
     }  
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure( $client, "error: ".($!+0)." untie(GDBM) Failed ".
            "while attempting dump\n", $userinput);
  }   }
 # ----------------------------------------------------------------------- idget      } else {
     } elsif ($userinput =~ /^idget/) {   &Failure($client, "error: ".($!+0)." tie(GDBM) Failed ".
  if(isClient) {   "while attempting dump\n", $userinput);
     my ($cmd,$udom,$what)=split(/:/,$userinput);      }
     chomp($what);  
     $udom=~s/\W//g;      return 1;
     my $proname="$perlvar{'lonUsersDir'}/$udom/ids";  }
     my @queries=split(/\&/,$what);  
     my $qresult='';  &register_handler("dump", \&dump_with_regexp, 0, 1, 0);
     my %hash;  
     if (tie(%hash,'GDBM_File',"$proname.db",&GDBM_READER(),0640)) {  #  Store a set of key=value pairs associated with a versioned name.
  for (my $i=0;$i<=$#queries;$i++) {  #
     $qresult.="$hash{$queries[$i]}&";  #  Parameters:
  }  #    $cmd                - Request command keyword.
  if (untie(%hash)) {  #    $tail               - Tail of the request.  This is a colon
     $qresult=~s/\&$//;  #                          separated list containing:
     print $client "$qresult\n";  #                          domain/user - User and authentication domain.
  } else {  #                          namespace   - Name of the database being modified
     print $client "error: ".($!+0)  #                          rid         - Resource keyword to modify.
  ." untie(GDBM) Failed ".  #                          what        - new value associated with rid.
  "while attempting idget\n";  #
  }  #    $client             - Socket open on the client.
   #
   #
   #  Returns:
   #      1 (keep on processing).
   #  Side-Effects:
   #    Writes to the client
   sub store_handler {
       my ($cmd, $tail, $client) = @_;
    
       my $userinput = "$cmd:$tail";
   
       my ($udom,$uname,$namespace,$rid,$what) =split(/:/,$tail);
       if ($namespace ne 'roles') {
   
    chomp($what);
    my @pairs=split(/\&/,$what);
    my $hashref  = &tie_user_hash($udom, $uname, $namespace,
          &GDBM_WRCREAT(), "P",
          "$rid:$what");
    if ($hashref) {
       my $now = time;
       my @previouskeys=split(/&/,$hashref->{"keys:$rid"});
       my $key;
       $hashref->{"version:$rid"}++;
       my $version=$hashref->{"version:$rid"};
       my $allkeys=''; 
       foreach my $pair (@pairs) {
    my ($key,$value)=split(/=/,$pair);
    $allkeys.=$key.':';
    $hashref->{"$version:$rid:$key"}=$value;
       }
       $hashref->{"$version:$rid:timestamp"}=$now;
       $allkeys.='timestamp';
       $hashref->{"$version:keys:$rid"}=$allkeys;
       if (untie($hashref)) {
    &Reply($client, "ok\n", $userinput);
     } else {      } else {
  print $client "error: ".($!+0)   &Failure($client, "error: ".($!+0)." untie(GDBM) Failed ".
     ." tie(GDBM) Failed ".   "while attempting store\n", $userinput);
     "while attempting idget\n";  
     }      }
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure( $client, "error: ".($!+0)." tie(GDBM) Failed ".
            "while attempting store\n", $userinput);
  }   }
 # ---------------------------------------------------------------------- tmpput      } else {
     } elsif ($userinput =~ /^tmpput/) {   &Failure($client, "refused\n", $userinput);
  if(isClient) {      }
     my ($cmd,$what)=split(/:/,$userinput);  
     my $store;      return 1;
     $tmpsnum++;  }
     my $id=$$.'_'.$clientip.'_'.$tmpsnum;  &register_handler("store", \&store_handler, 0, 1, 0);
     $id=~s/\W/\_/g;  #
     $what=~s/\n//g;  #  Dump out all versions of a resource that has key=value pairs associated
     my $execdir=$perlvar{'lonDaemons'};  # with it for each version.  These resources are built up via the store
     if ($store=IO::File->new(">$execdir/tmp/$id.tmp")) {  # command.
  print $store $what;  #
  close $store;  #  Parameters:
  print $client "$id\n";  #     $cmd               - Command keyword.
     }  #     $tail              - Remainder of the request which consists of:
     else {  #                          domain/user   - User and auth. domain.
  print $client "error: ".($!+0)  #                          namespace     - name of resource database.
     ."IO::File->new Failed ".  #                          rid           - Resource id.
     "while attempting tmpput\n";  #    $client             - socket open on the client.
     }  #
   # Returns:
   #      1  indicating the caller should not yet exit.
   # Side-effects:
   #   Writes a reply to the client.
   #   The reply is a string of the following shape:
   #   version=current&version:keys=k1:k2...&1:k1=v1&1:k2=v2...
   #    Where the 1 above represents version 1.
   #    this continues for all pairs of keys in all versions.
   #
   #
   #    
   #
   sub restore_handler {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput = "$cmd:$tail"; # Only used for logging purposes.
   
       my ($cmd,$udom,$uname,$namespace,$rid) = split(/:/,$userinput);
       $namespace=~s/\//\_/g;
       $namespace=~s/\W//g;
       chomp($rid);
       my $proname=&propath($udom,$uname);
       my $qresult='';
       my %hash;
       if (tie(%hash,'GDBM_File',"$proname/$namespace.db",
       &GDBM_READER(),0640)) {
    my $version=$hash{"version:$rid"};
    $qresult.="version=$version&";
    my $scope;
    for ($scope=1;$scope<=$version;$scope++) {
       my $vkeys=$hash{"$scope:keys:$rid"};
       my @keys=split(/:/,$vkeys);
       my $key;
       $qresult.="$scope:keys=$vkeys&";
       foreach $key (@keys) {
    $qresult.="$scope:$key=".$hash{"$scope:$rid:$key"}."&";
       }                                  
    }
    if (untie(%hash)) {
       $qresult=~s/\&$//;
       &Reply( $client, "$qresult\n", $userinput);
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "error: ".($!+0)." untie(GDBM) Failed ".
           "while attempting restore\n", $userinput);
  }   }
       } else {
 # ---------------------------------------------------------------------- tmpget   &Failure($client, "error: ".($!+0)." tie(GDBM) Failed ".
     } elsif ($userinput =~ /^tmpget/) {   "while attempting restore\n", $userinput);
  if(isClient) {      }
     my ($cmd,$id)=split(/:/,$userinput);    
     chomp($id);      return 1;
     $id=~s/\W/\_/g;  
     my $store;  
     my $execdir=$perlvar{'lonDaemons'};  }
     if ($store=IO::File->new("$execdir/tmp/$id.tmp")) {  &register_handler("restore", \&restore_handler, 0,1,0);
  my $reply=<$store>;  
     print $client "$reply\n";  #
  close $store;  #   Add a chat message to to a discussion board.
     }  #
     else {  # Parameters:
  print $client "error: ".($!+0)  #    $cmd                - Request keyword.
     ."IO::File->new Failed ".  #    $tail               - Tail of the command. A colon separated list
     "while attempting tmpget\n";  #                          containing:
     }  #                          cdom    - Domain on which the chat board lives
  } else {  #                          cnum    - Identifier of the discussion group.
     Reply($client, "refused\n", $userinput);  #                          post    - Body of the posting.
       #   $client              - Socket open on the client.
   # Returns:
   #   1    - Indicating caller should keep on processing.
   #
   # Side-effects:
   #   writes a reply to the client.
   #
   #
   sub send_chat_handler {
       my ($cmd, $tail, $client) = @_;
   
       
       my $userinput = "$cmd:$tail";
   
       my ($cdom,$cnum,$newpost)=split(/\:/,$tail);
       &chat_add($cdom,$cnum,$newpost);
       &Reply($client, "ok\n", $userinput);
   
       return 1;
   }
   &register_handler("chatsend", \&send_chat_handler, 0, 1, 0);
   #
   #   Retrieve the set of chat messagss from a discussion board.
   #
   #  Parameters:
   #    $cmd             - Command keyword that initiated the request.
   #    $tail            - Remainder of the request after the command
   #                       keyword.  In this case a colon separated list of
   #                       chat domain    - Which discussion board.
   #                       chat id        - Discussion thread(?)
   #                       domain/user    - Authentication domain and username
   #                                        of the requesting person.
   #   $client           - Socket open on the client program.
   # Returns:
   #    1     - continue processing
   # Side effects:
   #    Response is written to the client.
   #
   sub retrieve_chat_handler {
       my ($cmd, $tail, $client) = @_;
   
   
       my $userinput = "$cmd:$tail";
   
       my ($cdom,$cnum,$udom,$uname)=split(/\:/,$tail);
       my $reply='';
       foreach (&get_chat($cdom,$cnum,$udom,$uname)) {
    $reply.=&escape($_).':';
       }
       $reply=~s/\:$//;
       &Reply($client, $reply."\n", $userinput);
   
   
       return 1;
   }
   &register_handler("chatretr", \&retrieve_chat_handler, 0, 1, 0);
   
   #
   #  Initiate a query of an sql database.  SQL query repsonses get put in
   #  a file for later retrieval.  This prevents sql query results from
   #  bottlenecking the system.  Note that with loncnew, perhaps this is
   #  less of an issue since multiple outstanding requests can be concurrently
   #  serviced.
   #
   #  Parameters:
   #     $cmd       - COmmand keyword that initiated the request.
   #     $tail      - Remainder of the command after the keyword.
   #                  For this function, this consists of a query and
   #                  3 arguments that are self-documentingly labelled
   #                  in the original arg1, arg2, arg3.
   #     $client    - Socket open on the client.
   # Return:
   #    1   - Indicating processing should continue.
   # Side-effects:
   #    a reply is written to $client.
   #
   sub send_query_handler {
       my ($cmd, $tail, $client) = @_;
   
   
       my $userinput = "$cmd:$tail";
   
       my ($query,$arg1,$arg2,$arg3)=split(/\:/,$tail);
       $query=~s/\n*$//g;
       &Reply($client, "". &sql_reply("$clientname\&$query".
    "\&$arg1"."\&$arg2"."\&$arg3")."\n",
     $userinput);
       
       return 1;
   }
   &register_handler("querysend", \&send_query_handler, 0, 1, 0);
   
   #
   #   Add a reply to an sql query.  SQL queries are done asyncrhonously.
   #   The query is submitted via a "querysend" transaction.
   #   There it is passed on to the lonsql daemon, queued and issued to
   #   mysql.
   #     This transaction is invoked when the sql transaction is complete
   #   it stores the query results in flie and indicates query completion.
   #   presumably local software then fetches this response... I'm guessing
   #   the sequence is: lonc does a querysend, we ask lonsql to do it.
   #   lonsql on completion of the query interacts with the lond of our
   #   client to do a query reply storing two files:
   #    - id     - The results of the query.
   #    - id.end - Indicating the transaction completed. 
   #    NOTE: id is a unique id assigned to the query and querysend time.
   # Parameters:
   #    $cmd        - Command keyword that initiated this request.
   #    $tail       - Remainder of the tail.  In this case that's a colon
   #                  separated list containing the query Id and the 
   #                  results of the query.
   #    $client     - Socket open on the client.
   # Return:
   #    1           - Indicating that we should continue processing.
   # Side effects:
   #    ok written to the client.
   #
   sub reply_query_handler {
       my ($cmd, $tail, $client) = @_;
   
   
       my $userinput = "$cmd:$tail";
   
       my ($cmd,$id,$reply)=split(/:/,$userinput); 
       my $store;
       my $execdir=$perlvar{'lonDaemons'};
       if ($store=IO::File->new(">$execdir/tmp/$id")) {
    $reply=~s/\&/\n/g;
    print $store $reply;
    close $store;
    my $store2=IO::File->new(">$execdir/tmp/$id.end");
    print $store2 "done\n";
    close $store2;
    &Reply($client, "ok\n", $userinput);
       } else {
    &Failure($client, "error: ".($!+0)
    ." IO::File->new Failed ".
    "while attempting queryreply\n", $userinput);
       }
    
   
       return 1;
   }
   &register_handler("queryreply", \&reply_query_handler, 0, 1, 0);
   
   #
   #  Process the courseidput request.  Not quite sure what this means
   #  at the system level sense.  It appears a gdbm file in the 
   #  /home/httpd/lonUsers/$domain/nohist_courseids is tied and
   #  a set of entries made in that database.
   #
   # Parameters:
   #   $cmd      - The command keyword that initiated this request.
   #   $tail     - Tail of the command.  In this case consists of a colon
   #               separated list contaning the domain to apply this to and
   #               an ampersand separated list of keyword=value pairs.
   #   $client   - Socket open on the client.
   # Returns:
   #   1    - indicating that processing should continue
   #
   # Side effects:
   #   reply is written to the client.
   #
   sub put_course_id_handler {
       my ($cmd, $tail, $client) = @_;
   
   
       my $userinput = "$cmd:$tail";
   
       my ($udom, $what) = split(/:/, $tail);
       chomp($what);
       my $now=time;
       my @pairs=split(/\&/,$what);
   
       my $hashref = &tie_domain_hash($udom, "nohist_courseids", &GDBM_WRCREAT());
       if ($hashref) {
    foreach my $pair (@pairs) {
       my ($key,$value)=split(/=/,$pair);
       $hashref->{$key}=$value.':'.$now;
    }
    if (untie(%$hashref)) {
       &Reply($client, "ok\n", $userinput);
    } else {
       &Failure( $client, "error: ".($!+0)
        ." untie(GDBM) Failed ".
        "while attempting courseidput\n", $userinput);
  }   }
 # ---------------------------------------------------------------------- tmpdel      } else {
     } elsif ($userinput =~ /^tmpdel/) {   &Failure( $client, "error: ".($!+0)
  if(isClient) {   ." tie(GDBM) Failed ".
     my ($cmd,$id)=split(/:/,$userinput);   "while attempting courseidput\n", $userinput);
     chomp($id);      }
     $id=~s/\W/\_/g;  
     my $execdir=$perlvar{'lonDaemons'};      return 1;
     if (unlink("$execdir/tmp/$id.tmp")) {  }
  print $client "ok\n";  &register_handler("courseidput", \&put_course_id_handler, 0, 1, 0);
   
   #  Retrieves the value of a course id resource keyword pattern
   #  defined since a starting date.  Both the starting date and the
   #  keyword pattern are optional.  If the starting date is not supplied it
   #  is treated as the beginning of time.  If the pattern is not found,
   #  it is treatred as "." matching everything.
   #
   #  Parameters:
   #     $cmd     - Command keyword that resulted in us being dispatched.
   #     $tail    - The remainder of the command that, in this case, consists
   #                of a colon separated list of:
   #                 domain   - The domain in which the course database is 
   #                            defined.
   #                 since    - Optional parameter describing the minimum
   #                            time of definition(?) of the resources that
   #                            will match the dump.
   #                 description - regular expression that is used to filter
   #                            the dump.  Only keywords matching this regexp
   #                            will be used.
   #     $client  - The socket open on the client.
   # Returns:
   #    1     - Continue processing.
   # Side Effects:
   #   a reply is written to $client.
   sub dump_course_id_handler {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput = "$cmd:$tail";
   
       my ($udom,$since,$description) =split(/:/,$tail);
       if (defined($description)) {
    $description=&unescape($description);
       } else {
    $description='.';
       }
       unless (defined($since)) { $since=0; }
       my $qresult='';
       my $hashref = &tie_domain_hash($udom, "nohist_courseids", &GDBM_WRCREAT());
       if ($hashref) {
    while (my ($key,$value) = each(%$hashref)) {
       my ($descr,$lasttime,$inst_code);
       if ($value =~ m/^([^\:]*):([^\:]*):(\d+)$/) {
    ($descr,$inst_code,$lasttime)=($1,$2,$3);
     } else {      } else {
  print $client "error: ".($!+0)   ($descr,$lasttime) = split(/\:/,$value);
     ."Unlink tmp Failed ".  
     "while attempting tmpdel\n";  
     }      }
  } else {      if ($lasttime<$since) { next; }
     Reply($client, "refused\n", $userinput);      if ($description eq '.') {
        $qresult.=$key.'='.$descr.':'.$inst_code.'&';
  }  
 # ----------------------------------------- portfolio directory list (portls)  
     } elsif ($userinput =~ /^portls/) {  
  if(isClient) {  
     my ($cmd,$uname,$udom)=split(/:/,$userinput);  
     my $udir=propath($udom,$uname).'/userfiles/portfolio';  
     my $dirLine='';  
     my $dirContents='';  
     if (opendir(LSDIR,$udir.'/')){  
  while ($dirLine = readdir(LSDIR)){  
     $dirContents = $dirContents.$dirLine.'<br />';  
  }  
     } else {      } else {
  $dirContents = "No directory found\n";   my $unescapeVal = &unescape($descr);
    if (eval('$unescapeVal=~/\Q$description\E/i')) {
       $qresult.=$key.'='.$descr.':'.$inst_code.'&';
    }
     }      }
     print $client $dirContents."\n";   }
    if (untie(%$hashref)) {
       chop($qresult);
       &Reply($client, "$qresult\n", $userinput);
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "error: ".($!+0)." untie(GDBM) Failed ".
       "while attempting courseiddump\n", $userinput);
  }   }
 # -------------------------------------------------------------------------- ls      } else {
     } elsif ($userinput =~ /^ls/) {   &Failure($client, "error: ".($!+0)." tie(GDBM) Failed ".
  if(isClient) {   "while attempting courseiddump\n", $userinput);
     my $obs;      }
     my $rights;  
     my ($cmd,$ulsdir)=split(/:/,$userinput);  
     my $ulsout='';      return 1;
     my $ulsfn;  }
     if (-e $ulsdir) {  &register_handler("courseiddump", \&dump_course_id_handler, 0, 1, 0);
  if(-d $ulsdir) {  
     if (opendir(LSDIR,$ulsdir)) {  #
  while ($ulsfn=readdir(LSDIR)) {  #  Puts an id to a domains id database. 
     undef $obs, $rights;   #
     my @ulsstats=stat($ulsdir.'/'.$ulsfn);  #  Parameters:
     #We do some obsolete checking here  #   $cmd     - The command that triggered us.
     if(-e $ulsdir.'/'.$ulsfn.".meta") {   #   $tail    - Remainder of the request other than the command. This is a 
  open(FILE, $ulsdir.'/'.$ulsfn.".meta");  #              colon separated list containing:
  my @obsolete=<FILE>;  #              $domain  - The domain for which we are writing the id.
  foreach my $obsolete (@obsolete) {  #              $pairs  - The id info to write... this is and & separated list
     if($obsolete =~ m|(<obsolete>)(on)|) { $obs = 1; }   #                        of keyword=value.
     if($obsolete =~ m|(<copyright>)(default)|) { $rights = 1; }  #   $client  - Socket open on the client.
  }  #  Returns:
     }  #    1   - Continue processing.
     $ulsout.=$ulsfn.'&'.join('&',@ulsstats);  #  Side effects:
     if($obs eq '1') { $ulsout.="&1"; }  #     reply is written to $client.
     else { $ulsout.="&0"; }  #
     if($rights eq '1') { $ulsout.="&1:"; }  sub put_id_handler {
     else { $ulsout.="&0:"; }      my ($cmd,$tail,$client) = @_;
  }  
  closedir(LSDIR);  
     }      my $userinput = "$cmd:$tail";
  } else {  
     my @ulsstats=stat($ulsdir);      my ($udom,$what)=split(/:/,$tail);
     $ulsout.=$ulsfn.'&'.join('&',@ulsstats).':';      chomp($what);
  }      my @pairs=split(/\&/,$what);
     } else {      my $hashref = &tie_domain_hash($udom, "ids", &GDBM_WRCREAT(),
  $ulsout='no_such_dir';     "P", $what);
     }      if ($hashref) {
     if ($ulsout eq '') { $ulsout='empty'; }   foreach my $pair (@pairs) {
     print $client "$ulsout\n";      my ($key,$value)=split(/=/,$pair);
       $hashref->{$key}=$value;
    }
    if (untie(%$hashref)) {
       &Reply($client, "ok\n", $userinput);
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure($client, "error: ".($!+0)." untie(GDBM) Failed ".
            "while attempting idput\n", $userinput);
  }   }
 # ----------------------------------------------------------------- setannounce      } else {
     } elsif ($userinput =~ /^setannounce/) {   &Failure( $client, "error: ".($!+0)." tie(GDBM) Failed ".
  if (isClient) {    "while attempting idput\n", $userinput);
     my ($cmd,$announcement)=split(/:/,$userinput);      }
     chomp($announcement);  
     $announcement=&unescape($announcement);      return 1;
     if (my $store=IO::File->new('>'.$perlvar{'lonDocRoot'}.  }
  '/announcement.txt')) {  
  print $store $announcement;  &register_handler("idput", \&put_id_handler, 0, 1, 0);
  close $store;  #
  print $client "ok\n";  #  Retrieves a set of id values from the id database.
     } else {  #  Returns an & separated list of results, one for each requested id to the
  print $client "error: ".($!+0)."\n";  #  client.
     }  #
   # Parameters:
   #   $cmd       - Command keyword that caused us to be dispatched.
   #   $tail      - Tail of the command.  Consists of a colon separated:
   #               domain - the domain whose id table we dump
   #               ids      Consists of an & separated list of
   #                        id keywords whose values will be fetched.
   #                        nonexisting keywords will have an empty value.
   #   $client    - Socket open on the client.
   #
   # Returns:
   #    1 - indicating processing should continue.
   # Side effects:
   #   An & separated list of results is written to $client.
   #
   sub get_id_handler {
       my ($cmd, $tail, $client) = @_;
   
       
       my $userinput = "$client:$tail";
       
       my ($udom,$what)=split(/:/,$tail);
       chomp($what);
       my @queries=split(/\&/,$what);
       my $qresult='';
       my $hashref = &tie_domain_hash($udom, "ids", &GDBM_READER());
       if ($hashref) {
    for (my $i=0;$i<=$#queries;$i++) {
       $qresult.="$hashref->{$queries[$i]}&";
    }
    if (untie(%$hashref)) {
       $qresult=~s/\&$//;
       &Reply($client, "$qresult\n", $userinput);
  } else {   } else {
     Reply($client, "refused\n", $userinput);      &Failure( $client, "error: ".($!+0)." untie(GDBM) Failed ".
             "while attempting idget\n",$userinput);
  }   }
 # ------------------------------------------------------------------ Hanging up      } else {
     } elsif (($userinput =~ /^exit/) ||   &Failure($client, "error: ".($!+0)." tie(GDBM) Failed ".
      ($userinput =~ /^init/)) { # no restrictions.   "while attempting idget\n",$userinput);
  &logthis(      }
  "Client $clientip ($clientname) hanging up: $userinput");      
  print $client "bye\n";      return 1;
  $client->shutdown(2);        # shutdown the socket forcibly.  }
  $client->close();  
  return 0;  register_handler("idget", \&get_id_handler, 0, 1, 0);
   
 # ---------------------------------- set current host/domain  #
     } elsif ($userinput =~ /^sethost:/) {  #  Process the tmpput command I'm not sure what this does.. Seems to
  if (isClient) {  #  create a file in the lonDaemons/tmp directory of the form $id.tmp
     print $client &sethost($userinput)."\n";  # where Id is the client's ip concatenated with a sequence number.
   # The file will contain some value that is passed in.  Is this e.g.
   # a login token?
   #
   # Parameters:
   #    $cmd     - The command that got us dispatched.
   #    $tail    - The remainder of the request following $cmd:
   #               In this case this will be the contents of the file.
   #    $client  - Socket connected to the client.
   # Returns:
   #    1 indicating processing can continue.
   # Side effects:
   #   A file is created in the local filesystem.
   #   A reply is sent to the client.
   sub tmp_put_handler {
       my ($cmd, $what, $client) = @_;
   
       my $userinput = "$cmd:$what"; # Reconstruct for logging.
   
   
       my $store;
       $tmpsnum++;
       my $id=$$.'_'.$clientip.'_'.$tmpsnum;
       $id=~s/\W/\_/g;
       $what=~s/\n//g;
       my $execdir=$perlvar{'lonDaemons'};
       if ($store=IO::File->new(">$execdir/tmp/$id.tmp")) {
    print $store $what;
    close $store;
    &Reply($client, "$id\n", $userinput);
       } else {
    &Failure( $client, "error: ".($!+0)."IO::File->new Failed ".
     "while attempting tmpput\n", $userinput);
       }
       return 1;
     
   }
   &register_handler("tmpput", \&tmp_put_handler, 0, 1, 0);
   #   Processes the tmpget command.  This command returns the contents
   #  of a temporary resource file(?) created via tmpput.
   #
   # Paramters:
   #    $cmd      - Command that got us dispatched.
   #    $id       - Tail of the command, contain the id of the resource
   #                we want to fetch.
   #    $client   - socket open on the client.
   # Return:
   #    1         - Inidcating processing can continue.
   # Side effects:
   #   A reply is sent to the client.
   
   #
   sub tmp_get_handler {
       my ($cmd, $id, $client) = @_;
   
       my $userinput = "$cmd:$id"; 
       
   
       $id=~s/\W/\_/g;
       my $store;
       my $execdir=$perlvar{'lonDaemons'};
       if ($store=IO::File->new("$execdir/tmp/$id.tmp")) {
    my $reply=<$store>;
    &Reply( $client, "$reply\n", $userinput);
    close $store;
       } else {
    &Failure( $client, "error: ".($!+0)."IO::File->new Failed ".
     "while attempting tmpget\n", $userinput);
       }
   
       return 1;
   }
   &register_handler("tmpget", \&tmp_get_handler, 0, 1, 0);
   #
   #  Process the tmpdel command.  This command deletes a temp resource
   #  created by the tmpput command.
   #
   # Parameters:
   #   $cmd      - Command that got us here.
   #   $id       - Id of the temporary resource created.
   #   $client   - socket open on the client process.
   #
   # Returns:
   #   1     - Indicating processing should continue.
   # Side Effects:
   #   A file is deleted
   #   A reply is sent to the client.
   sub tmp_del_handler {
       my ($cmd, $id, $client) = @_;
       
       my $userinput= "$cmd:$id";
       
       chomp($id);
       $id=~s/\W/\_/g;
       my $execdir=$perlvar{'lonDaemons'};
       if (unlink("$execdir/tmp/$id.tmp")) {
    &Reply($client, "ok\n", $userinput);
       } else {
    &Failure( $client, "error: ".($!+0)."Unlink tmp Failed ".
     "while attempting tmpdel\n", $userinput);
       }
       
       return 1;
   
   }
   &register_handler("tmpdel", \&tmp_del_handler, 0, 1, 0);
   #
   #   Processes the setannounce command.  This command
   #   creates a file named announce.txt in the top directory of
   #   the documentn root and sets its contents.  The announce.txt file is
   #   printed in its entirety at the LonCAPA login page.  Note:
   #   once the announcement.txt fileis created it cannot be deleted.
   #   However, setting the contents of the file to empty removes the
   #   announcement from the login page of loncapa so who cares.
   #
   # Parameters:
   #    $cmd          - The command that got us dispatched.
   #    $announcement - The text of the announcement.
   #    $client       - Socket open on the client process.
   # Retunrns:
   #   1             - Indicating request processing should continue
   # Side Effects:
   #   The file {DocRoot}/announcement.txt is created.
   #   A reply is sent to $client.
   #
   sub set_announce_handler {
       my ($cmd, $announcement, $client) = @_;
     
       my $userinput    = "$cmd:$announcement";
   
       chomp($announcement);
       $announcement=&unescape($announcement);
       if (my $store=IO::File->new('>'.$perlvar{'lonDocRoot'}.
    '/announcement.txt')) {
    print $store $announcement;
    close $store;
    &Reply($client, "ok\n", $userinput);
       } else {
    &Failure($client, "error: ".($!+0)."\n", $userinput);
       }
   
       return 1;
   }
   &register_handler("setannounce", \&set_announce_handler, 0, 1, 0);
   #
   #  Return the version of the daemon.  This can be used to determine
   #  the compatibility of cross version installations or, alternatively to
   #  simply know who's out of date and who isn't.  Note that the version
   #  is returned concatenated with the tail.
   # Parameters:
   #   $cmd        - the request that dispatched to us.
   #   $tail       - Tail of the request (client's version?).
   #   $client     - Socket open on the client.
   #Returns:
   #   1 - continue processing requests.
   # Side Effects:
   #   Replies with version to $client.
   sub get_version_handler {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput  = $cmd.$tail;
       
       &Reply($client, &version($userinput)."\n", $userinput);
   
   
       return 1;
   }
   &register_handler("version", \&get_version_handler, 0, 1, 0);
   #  Set the current host and domain.  This is used to support
   #  multihomed systems.  Each IP of the system, or even separate daemons
   #  on the same IP can be treated as handling a separate lonCAPA virtual
   #  machine.  This command selects the virtual lonCAPA.  The client always
   #  knows the right one since it is lonc and it is selecting the domain/system
   #  from the hosts.tab file.
   # Parameters:
   #    $cmd      - Command that dispatched us.
   #    $tail     - Tail of the command (domain/host requested).
   #    $socket   - Socket open on the client.
   #
   # Returns:
   #     1   - Indicates the program should continue to process requests.
   # Side-effects:
   #     The default domain/system context is modified for this daemon.
   #     a reply is sent to the client.
   #
   sub set_virtual_host_handler {
       my ($cmd, $tail, $socket) = @_;
     
       my $userinput  ="$cmd:$tail";
   
       &Reply($client, &sethost($userinput)."\n", $userinput);
   
   
       return 1;
   }
   &register_handler("sethost", \&set_virtual_host_handler, 0, 1, 0);
   
   #  Process a request to exit:
   #   - "bye" is sent to the client.
   #   - The client socket is shutdown and closed.
   #   - We indicate to the caller that we should exit.
   # Formal Parameters:
   #   $cmd                - The command that got us here.
   #   $tail               - Tail of the command (empty).
   #   $client             - Socket open on the tail.
   # Returns:
   #   0      - Indicating the program should exit!!
   #
   sub exit_handler {
       my ($cmd, $tail, $client) = @_;
   
       my $userinput = "$cmd:$tail";
   
       &logthis("Client $clientip ($clientname) hanging up: $userinput");
       &Reply($client, "bye\n", $userinput);
       $client->shutdown(2);        # shutdown the socket forcibly.
       $client->close();
   
       return 0;
   }
   &register_handler("exit", \&exit_handler, 0,1,1);
   &register_handler("init", \&exit_handler, 0,1,1);
   &register_handler("quit", \&exit_handler, 0,1,1);
   
   #  Determine if auto-enrollment is enabled.
   #  Note that the original had what I believe to be a defect.
   #  The original returned 0 if the requestor was not a registerd client.
   #  It should return "refused".
   # Formal Parameters:
   #   $cmd       - The command that invoked us.
   #   $tail      - The tail of the command (Extra command parameters.
   #   $client    - The socket open on the client that issued the request.
   # Returns:
   #    1         - Indicating processing should continue.
   #
   sub enrollment_enabled_handler {
       my ($cmd, $tail, $client) = @_;
       my $userinput = $cmd.":".$tail; # For logging purposes.
   
       
       my $cdom = split(/:/, $tail);   # Domain we're asking about.
       my $outcome  = &localenroll::run($cdom);
       &Reply($client, "$outcome\n", $userinput);
   
       return 1;
   }
   &register_handler("autorun", \&enrollment_enabled_handler, 0, 1, 0);
   
   #   Get the official sections for which auto-enrollment is possible.
   #   Since the admin people won't know about 'unofficial sections' 
   #   we cannot auto-enroll on them.
   # Formal Parameters:
   #    $cmd     - The command request that got us dispatched here.
   #    $tail    - The remainder of the request.  In our case this
   #               will be split into:
   #               $coursecode   - The course name from the admin point of view.
   #               $cdom         - The course's domain(?).
   #    $client  - Socket open on the client.
   # Returns:
   #    1    - Indiciting processing should continue.
   #
   sub get_sections_handler {
       my ($cmd, $tail, $client) = @_;
       my $userinput = "$cmd:$tail";
   
       my ($coursecode, $cdom) = split(/:/, $tail);
       my @secs = &localenroll::get_sections($coursecode,$cdom);
       my $seclist = &escape(join(':',@secs));
   
       &Reply($client, "$seclist\n", $userinput);
       
   
       return 1;
   }
   &register_handler("autogetsections", \&get_sections_handler, 0, 1, 0);
   
   #   Validate the owner of a new course section.  
   #
   # Formal Parameters:
   #   $cmd      - Command that got us dispatched.
   #   $tail     - the remainder of the command.  For us this consists of a
   #               colon separated string containing:
   #                  $inst    - Course Id from the institutions point of view.
   #                  $owner   - Proposed owner of the course.
   #                  $cdom    - Domain of the course (from the institutions
   #                             point of view?)..
   #   $client   - Socket open on the client.
   #
   # Returns:
   #   1        - Processing should continue.
   #
   sub validate_course_owner_handler {
       my ($cmd, $tail, $client)  = @_;
       my $userinput = "$cmd:$tail";
       my ($inst_course_id, $owner, $cdom) = split(/:/, $tail);
   
       my $outcome = &localenroll::new_course($inst_course_id,$owner,$cdom);
       &Reply($client, "$outcome\n", $userinput);
   
   
   
       return 1;
   }
   &register_handler("autonewcourse", \&validate_course_owner_handler, 0, 1, 0);
   #
   #   Validate a course section in the official schedule of classes
   #   from the institutions point of view (part of autoenrollment).
   #
   # Formal Parameters:
   #   $cmd          - The command request that got us dispatched.
   #   $tail         - The tail of the command.  In this case,
   #                   this is a colon separated set of words that will be split
   #                   into:
   #                        $inst_course_id - The course/section id from the
   #                                          institutions point of view.
   #                        $cdom           - The domain from the institutions
   #                                          point of view.
   #   $client       - Socket open on the client.
   # Returns:
   #    1           - Indicating processing should continue.
   #
   sub validate_course_section_handler {
       my ($cmd, $tail, $client) = @_;
       my $userinput = "$cmd:$tail";
       my ($inst_course_id, $cdom) = split(/:/, $tail);
   
       my $outcome=&localenroll::validate_courseID($inst_course_id,$cdom);
       &Reply($client, "$outcome\n", $userinput);
   
   
       return 1;
   }
   &register_handler("autovalidatecourse", \&validate_course_section_handler, 0, 1, 0);
   
   #
   #   Create a password for a new auto-enrollment user.
   #   I think/guess, this password allows access to the institutions 
   #   AIS class list server/services.  Stuart can correct this comment
   #   when he finds out how wrong I am.
   #
   # Formal Parameters:
   #    $cmd     - The command request that got us dispatched.
   #    $tail    - The tail of the command.   In this case this is a colon separated
   #               set of words that will be split into:
   #               $authparam - An authentication parameter (username??).
   #               $cdom      - The domain of the course from the institution's
   #                            point of view.
   #    $client  - The socket open on the client.
   # Returns:
   #    1 - continue processing.
   #
   sub create_auto_enroll_password_handler {
       my ($cmd, $tail, $client) = @_;
       my $userinput = "$cmd:$tail";
   
       my ($authparam, $cdom) = split(/:/, $userinput);
   
       my ($create_passwd,$authchk);
       ($authparam,
        $create_passwd,
        $authchk) = &localenroll::create_password($authparam,$cdom);
   
       &Reply($client, &escape($authparam.':'.$create_passwd.':'.$authchk)."\n",
      $userinput);
   
   
       return 1;
   }
   &register_handler("autocreatepassword", \&create_auto_enroll_password_handler, 
     0, 1, 0);
   
   #   Retrieve and remove temporary files created by/during autoenrollment.
   #
   # Formal Parameters:
   #    $cmd      - The command that got us dispatched.
   #    $tail     - The tail of the command.  In our case this is a colon 
   #                separated list that will be split into:
   #                $filename - The name of the file to remove.
   #                            The filename is given as a path relative to
   #                            the LonCAPA temp file directory.
   #    $client   - Socket open on the client.
   #
   # Returns:
   #   1     - Continue processing.
   
   sub retrieve_auto_file_handler {
       my ($cmd, $tail, $client)    = @_;
       my $userinput                = "cmd:$tail";
   
       my ($filename)   = split(/:/, $tail);
   
       my $source = $perlvar{'lonDaemons'}.'/tmp/'.$filename;
       if ( (-e $source) && ($filename ne '') ) {
    my $reply = '';
    if (open(my $fh,$source)) {
       while (<$fh>) {
    chomp($_);
    $_ =~ s/^\s+//g;
    $_ =~ s/\s+$//g;
    $reply .= $_;
       }
       close($fh);
       &Reply($client, &escape($reply)."\n", $userinput);
   
   #   Does this have to be uncommented??!?  (RF).
   #
   #                                unlink($source);
  } else {   } else {
     print $client "refused\n";      &Failure($client, "error\n", $userinput);
  }   }
 #---------------------------------- request file (?) version.      } else {
     } elsif ($userinput =~/^version:/) {   &Failure($client, "error\n", $userinput);
  if (isClient) {      }
     print $client &version($userinput)."\n";      
   
       return 1;
   }
   &register_handler("autoretrieve", \&retrieve_auto_file_handler, 0,1,0);
   
   #
   #   Read and retrieve institutional code format (for support form).
   # Formal Parameters:
   #    $cmd        - Command that dispatched us.
   #    $tail       - Tail of the command.  In this case it conatins 
   #                  the course domain and the coursename.
   #    $client     - Socket open on the client.
   # Returns:
   #    1     - Continue processing.
   #
   sub get_institutional_code_format_handler {
       my ($cmd, $tail, $client)   = @_;
       my $userinput               = "$cmd:$tail";
   
       my $reply;
       my($cdom,$course) = split(/:/,$tail);
       my @pairs = split/\&/,$course;
       my %instcodes = ();
       my %codes = ();
       my @codetitles = ();
       my %cat_titles = ();
       my %cat_order = ();
       foreach (@pairs) {
    my ($key,$value) = split/=/,$_;
    $instcodes{&unescape($key)} = &unescape($value);
       }
       my $formatreply = &localenroll::instcode_format($cdom,
       \%instcodes,
       \%codes,
       \@codetitles,
       \%cat_titles,
       \%cat_order);
       if ($formatreply eq 'ok') {
    my $codes_str = &hash2str(%codes);
    my $codetitles_str = &array2str(@codetitles);
    my $cat_titles_str = &hash2str(%cat_titles);
    my $cat_order_str = &hash2str(%cat_order);
    &Reply($client,
          $codes_str.':'.$codetitles_str.':'.$cat_titles_str.':'
          .$cat_order_str."\n",
          $userinput);
       } else {
    # this else branch added by RF since if not ok, lonc will
    # hang waiting on reply until timeout.
    #
    &Reply($client, "format_error\n", $userinput);
       }
       
       return 1;
   }
   
   &register_handler("autoinstcodeformat", \&get_institutional_code_format_handler,
     0,1,0);
   
   #
   #
   #
   #
   #
   #---------------------------------------------------------------
   #
   #   Getting, decoding and dispatching requests:
   #
   
   #
   #   Get a Request:
   #   Gets a Request message from the client.  The transaction
   #   is defined as a 'line' of text.  We remove the new line
   #   from the text line.  
   #
   sub get_request {
       my $input = <$client>;
       chomp($input);
   
       &Debug("get_request: Request = $input\n");
   
       &status('Processing '.$clientname.':'.$input);
   
       return $input;
   }
   #---------------------------------------------------------------
   #
   #  Process a request.  This sub should shrink as each action
   #  gets farmed out into a separat sub that is registered 
   #  with the dispatch hash.  
   #
   # Parameters:
   #    user_input   - The request received from the client (lonc).
   # Returns:
   #    true to keep processing, false if caller should exit.
   #
   sub process_request {
       my ($userinput) = @_;      # Easier for now to break style than to
                                   # fix all the userinput -> user_input.
       my $wasenc    = 0; # True if request was encrypted.
   # ------------------------------------------------------------ See if encrypted
       if ($userinput =~ /^enc/) {
    $userinput = decipher($userinput);
    $wasenc=1;
    if(!$userinput) { # Cipher not defined.
       &Failure($client, "error: Encrypted data without negotated key");
       return 0;
    }
       }
       Debug("process_request: $userinput\n");
       
       #  
       #   The 'correct way' to add a command to lond is now to
       #   write a sub to execute it and Add it to the command dispatch
       #   hash via a call to register_handler..  The comments to that
       #   sub should give you enough to go on to show how to do this
       #   along with the examples that are building up as this code
       #   is getting refactored.   Until all branches of the
       #   if/elseif monster below have been factored out into
       #   separate procesor subs, if the dispatch hash is missing
       #   the command keyword, we will fall through to the remainder
       #   of the if/else chain below in order to keep this thing in 
       #   working order throughout the transmogrification.
   
       my ($command, $tail) = split(/:/, $userinput, 2);
       chomp($command);
       chomp($tail);
       $tail =~ s/(\r)//; # This helps people debugging with e.g. telnet.
       $command =~ s/(\r)//; # And this too for parameterless commands.
       if(!$tail) {
    $tail =""; # defined but blank.
       }
   
       &Debug("Command received: $command, encoded = $wasenc");
   
       if(defined $Dispatcher{$command}) {
   
    my $dispatch_info = $Dispatcher{$command};
    my $handler       = $$dispatch_info[0];
    my $need_encode   = $$dispatch_info[1];
    my $client_types  = $$dispatch_info[2];
    Debug("Matched dispatch hash: mustencode: $need_encode "
         ."ClientType $client_types");
         
    #  Validate the request:
         
    my $ok = 1;
    my $requesterprivs = 0;
    if(&isClient()) {
       $requesterprivs |= $CLIENT_OK;
    }
    if(&isManager()) {
       $requesterprivs |= $MANAGER_OK;
    }
    if($need_encode && (!$wasenc)) {
       Debug("Must encode but wasn't: $need_encode $wasenc");
       $ok = 0;
    }
    if(($client_types & $requesterprivs) == 0) {
       Debug("Client not privileged to do this operation");
       $ok = 0;
    }
   
    if($ok) {
       Debug("Dispatching to handler $command $tail");
       my $keep_going = &$handler($command, $tail, $client);
       return $keep_going;
  } else {   } else {
     print $client "refused\n";      Debug("Refusing to dispatch because client did not match requirements");
       Failure($client, "refused\n", $userinput);
       return 1;
  }   }
   
       }    
   
   #------------------- Commands not yet in spearate handlers. --------------
   
 #------------------------------- is auto-enrollment enabled?  #------------------------------- is auto-enrollment enabled?
     } elsif ($userinput =~/^autorun:/) {      if ($userinput =~/^autorun/) {
  if (isClient) {   if (isClient) {
     my ($cmd,$cdom) = split(/:/,$userinput);      my ($cmd,$cdom) = split(/:/,$userinput);
     my $outcome = &localenroll::run($cdom);      my $outcome = &localenroll::run($cdom);
Line 2578  sub process_request { Line 3881  sub process_request {
     print $client "0\n";      print $client "0\n";
  }   }
 #------------------------------- get official sections (for auto-enrollment).  #------------------------------- get official sections (for auto-enrollment).
     } elsif ($userinput =~/^autogetsections:/) {      } elsif ($userinput =~/^autogetsections/) {
  if (isClient) {   if (isClient) {
     my ($cmd,$coursecode,$cdom)=split(/:/,$userinput);      my ($cmd,$coursecode,$cdom)=split(/:/,$userinput);
     my @secs = &localenroll::get_sections($coursecode,$cdom);      my @secs = &localenroll::get_sections($coursecode,$cdom);
Line 2588  sub process_request { Line 3891  sub process_request {
     print $client "refused\n";      print $client "refused\n";
  }   }
 #----------------------- validate owner of new course section (for auto-enrollment).  #----------------------- validate owner of new course section (for auto-enrollment).
     } elsif ($userinput =~/^autonewcourse:/) {      } elsif ($userinput =~/^autonewcourse/) {
  if (isClient) {   if (isClient) {
     my ($cmd,$inst_course_id,$owner,$cdom)=split(/:/,$userinput);      my ($cmd,$inst_course_id,$owner,$cdom)=split(/:/,$userinput);
     my $outcome = &localenroll::new_course($inst_course_id,$owner,$cdom);      my $outcome = &localenroll::new_course($inst_course_id,$owner,$cdom);
Line 2597  sub process_request { Line 3900  sub process_request {
     print $client "refused\n";      print $client "refused\n";
  }   }
 #-------------- validate course section in schedule of classes (for auto-enrollment).  #-------------- validate course section in schedule of classes (for auto-enrollment).
     } elsif ($userinput =~/^autovalidatecourse:/) {      } elsif ($userinput =~/^autovalidatecourse/) {
  if (isClient) {   if (isClient) {
     my ($cmd,$inst_course_id,$cdom)=split(/:/,$userinput);      my ($cmd,$inst_course_id,$cdom)=split(/:/,$userinput);
     my $outcome=&localenroll::validate_courseID($inst_course_id,$cdom);      my $outcome=&localenroll::validate_courseID($inst_course_id,$cdom);
Line 2606  sub process_request { Line 3909  sub process_request {
     print $client "refused\n";      print $client "refused\n";
  }   }
 #--------------------------- create password for new user (for auto-enrollment).  #--------------------------- create password for new user (for auto-enrollment).
     } elsif ($userinput =~/^autocreatepassword:/) {      } elsif ($userinput =~/^autocreatepassword/) {
  if (isClient) {   if (isClient) {
     my ($cmd,$authparam,$cdom)=split(/:/,$userinput);      my ($cmd,$authparam,$cdom)=split(/:/,$userinput);
     my ($create_passwd,$authchk);      my ($create_passwd,$authchk);
Line 2616  sub process_request { Line 3919  sub process_request {
     print $client "refused\n";      print $client "refused\n";
  }   }
 #---------------------------  read and remove temporary files (for auto-enrollment).  #---------------------------  read and remove temporary files (for auto-enrollment).
     } elsif ($userinput =~/^autoretrieve:/) {      } elsif ($userinput =~/^autoretrieve/) {
  if (isClient) {   if (isClient) {
     my ($cmd,$filename) = split(/:/,$userinput);      my ($cmd,$filename) = split(/:/,$userinput);
     my $source = $perlvar{'lonDaemons'}.'/tmp/'.$filename;      my $source = $perlvar{'lonDaemons'}.'/tmp/'.$filename;
Line 2641  sub process_request { Line 3944  sub process_request {
  } else {   } else {
     print $client "refused\n";      print $client "refused\n";
  }   }
 #---------------------  read and retrieve institutional code format (for support form).  #---------------------  read and retrieve institutional code format 
     } elsif ($userinput =~/^autoinstcodeformat:/) {  #                          (for support form).
       } elsif ($userinput =~/^autoinstcodeformat/) {
  if (isClient) {   if (isClient) {
     my $reply;      my $reply;
     my($cmd,$cdom,$course) = split(/:/,$userinput);      my($cmd,$cdom,$course) = split(/:/,$userinput);
Line 2754  sub register_handler { Line 4058  sub register_handler {
         
     $Dispatcher{$request_name} = \@entry;      $Dispatcher{$request_name} = \@entry;
         
      
 }  }
   
   
Line 2801  sub catchexception { Line 4104  sub catchexception {
     $server->close();      $server->close();
     die($error);      die($error);
 }  }
   
 sub timeout {  sub timeout {
     &status("Handling Timeout");      &status("Handling Timeout");
     &logthis("<font color='red'>CRITICAL: TIME OUT ".$$."</font>");      &logthis("<font color='red'>CRITICAL: TIME OUT ".$$."</font>");
Line 2809  sub timeout { Line 4111  sub timeout {
 }  }
 # -------------------------------- Set signal handlers to record abnormal exits  # -------------------------------- Set signal handlers to record abnormal exits
   
   
 $SIG{'QUIT'}=\&catchexception;  $SIG{'QUIT'}=\&catchexception;
 $SIG{__DIE__}=\&catchexception;  $SIG{__DIE__}=\&catchexception;
   
Line 3009  sub checkchildren { Line 4312  sub checkchildren {
     &logthis('Going to check on the children');      &logthis('Going to check on the children');
     my $docdir=$perlvar{'lonDocRoot'};      my $docdir=$perlvar{'lonDocRoot'};
     foreach (sort keys %children) {      foreach (sort keys %children) {
  sleep 1;   #sleep 1;
         unless (kill 'USR1' => $_) {          unless (kill 'USR1' => $_) {
     &logthis ('Child '.$_.' is dead');      &logthis ('Child '.$_.' is dead');
             &logstatus($$.' is dead');              &logstatus($$.' is dead');
       delete($children{$_});
         }           } 
     }      }
     sleep 5;      sleep 5;
Line 3031  sub checkchildren { Line 4335  sub checkchildren {
     #my $result=`echo 'Killed lond process $_.' | mailto $emailto -s '$subj' > /dev/null`;      #my $result=`echo 'Killed lond process $_.' | mailto $emailto -s '$subj' > /dev/null`;
     #$execdir=$perlvar{'lonDaemons'};      #$execdir=$perlvar{'lonDaemons'};
     #$result=`/bin/cp $execdir/logs/lond.log $execdir/logs/lond.log.$_`;      #$result=`/bin/cp $execdir/logs/lond.log $execdir/logs/lond.log.$_`;
       delete($children{$_});
     alarm(0);      alarm(0);
   }    }
         }          }
Line 3038  sub checkchildren { Line 4343  sub checkchildren {
     $SIG{ALRM} = 'DEFAULT';      $SIG{ALRM} = 'DEFAULT';
     $SIG{__DIE__} = \&catchexception;      $SIG{__DIE__} = \&catchexception;
     &status("Finished checking children");      &status("Finished checking children");
       &logthis('Finished Checking children');
 }  }
   
 # --------------------------------------------------------------------- Logging  # --------------------------------------------------------------------- Logging
Line 3069  sub Debug { Line 4375  sub Debug {
 #     request - Original request from client.  #     request - Original request from client.
 #  #
 sub Reply {  sub Reply {
     alarm(120);  
     my $fd      = shift;  
     my $reply   = shift;  
     my $request = shift;  
   
     my ($fd, $reply, $request) = @_;      my ($fd, $reply, $request) = @_;
     print $fd $reply;      print $fd $reply;
     Debug("Request was $request  Reply was $reply");      Debug("Request was $request  Reply was $reply");
   
     $Transactions++;      $Transactions++;
     alarm(0);  
   
   
 }  }
Line 3114  sub logstatus { Line 4414  sub logstatus {
     &status("Doing logging");      &status("Doing logging");
     my $docdir=$perlvar{'lonDocRoot'};      my $docdir=$perlvar{'lonDocRoot'};
     {      {
     my $fh=IO::File->new(">>$docdir/lon-status/londstatus.txt");  
     print $fh $$."\t".$clientname."\t".$currenthostid."\t"  
  .$status."\t".$lastlog."\t $keymode\n";  
     $fh->close();  
     }  
     &status("Finished londstatus.txt");  
     {  
  my $fh=IO::File->new(">$docdir/lon-status/londchld/$$.txt");   my $fh=IO::File->new(">$docdir/lon-status/londchld/$$.txt");
         print $fh $status."\n".$lastlog."\n".time."\n$keymode";          print $fh $status."\n".$lastlog."\n".time."\n$keymode";
         $fh->close();          $fh->close();
     }      }
       &status("Finished $$.txt");
       {
    open(LOG,">>$docdir/lon-status/londstatus.txt");
    flock(LOG,LOCK_EX);
    print LOG $$."\t".$clientname."\t".$currenthostid."\t"
       .$status."\t".$lastlog."\t $keymode\n";
    flock(DB,LOCK_UN);
    close(LOG);
       }
     &status("Finished logging");      &status("Finished logging");
 }  }
   
Line 3226  sub reply { Line 4528  sub reply {
   
 # -------------------------------------------------------------- Talk to lonsql  # -------------------------------------------------------------- Talk to lonsql
   
 sub sqlreply {  sub sql_reply {
     my ($cmd)=@_;      my ($cmd)=@_;
     my $answer=subsqlreply($cmd);      my $answer=&sub_sql_reply($cmd);
     if ($answer eq 'con_lost') { $answer=subsqlreply($cmd); }      if ($answer eq 'con_lost') { $answer=&sub_sql_reply($cmd); }
     return $answer;      return $answer;
 }  }
   
 sub subsqlreply {  sub sub_sql_reply {
     my ($cmd)=@_;      my ($cmd)=@_;
     my $unixsock="mysqlsock";      my $unixsock="mysqlsock";
     my $peerfile="$perlvar{'lonSockDir'}/$unixsock";      my $peerfile="$perlvar{'lonSockDir'}/$unixsock";
Line 3439  sub make_new_child { Line 4741  sub make_new_child {
  $inittype = ""; # This forces insecure attempt.   $inittype = ""; # This forces insecure attempt.
  &logthis("<font color=\"blue\"> Certificates not "   &logthis("<font color=\"blue\"> Certificates not "
  ."installed -- trying insecure auth</font>");   ."installed -- trying insecure auth</font>");
     }      } else { # SSL certificates are in place so
     else { # SSL certificates are in place so  
     } # Leave the inittype alone.      } # Leave the inittype alone.
  }   }
   
Line 3563  sub make_new_child { Line 4864  sub make_new_child {
 #    user      - Name of the user for which the role is being put.  #    user      - Name of the user for which the role is being put.
 #    authtype  - The authentication type associated with the user.  #    authtype  - The authentication type associated with the user.
 #  #
 sub ManagePermissions  sub manage_permissions
 {  {
   
     my ($request, $domain, $user, $authtype) = @_;      my ($request, $domain, $user, $authtype) = @_;
Line 3576  sub ManagePermissions Line 4877  sub ManagePermissions
  system("$execdir/lchtmldir $userhome $user $authtype");   system("$execdir/lchtmldir $userhome $user $authtype");
     }      }
 }  }
   
   
   #
   #  Return the full path of a user password file, whether it exists or not.
   # Parameters:
   #   domain     - Domain in which the password file lives.
   #   user       - name of the user.
   # Returns:
   #    Full passwd path:
   #
   sub password_path {
       my ($domain, $user) = @_;
   
   
       my $path   = &propath($domain, $user);
       $path  .= "/passwd";
   
       return $path;
   }
   
   #   Password Filename
   #   Returns the path to a passwd file given domain and user... only if
   #  it exists.
   # Parameters:
   #   domain    - Domain in which to search.
   #   user      - username.
   # Returns:
   #   - If the password file exists returns its path.
   #   - If the password file does not exist, returns undefined.
   #
   sub password_filename {
       my ($domain, $user) = @_;
   
       Debug ("PasswordFilename called: dom = $domain user = $user");
   
       my $path  = &password_path($domain, $user);
       Debug("PasswordFilename got path: $path");
       if(-e $path) {
    return $path;
       } else {
    return undef;
       }
   }
   
   #
   #   Rewrite the contents of the user's passwd file.
   #  Parameters:
   #    domain    - domain of the user.
   #    name      - User's name.
   #    contents  - New contents of the file.
   # Returns:
   #   0    - Failed.
   #   1    - Success.
   #
   sub rewrite_password_file {
       my ($domain, $user, $contents) = @_;
   
       my $file = &password_filename($domain, $user);
       if (defined $file) {
    my $pf = IO::File->new(">$file");
    if($pf) {
       print $pf "$contents\n";
       return 1;
    } else {
       return 0;
    }
       } else {
    return 0;
       }
   
   }
   
 #  #
 #   GetAuthType - Determines the authorization type of a user in a domain.  #   get_auth_type - Determines the authorization type of a user in a domain.
   
 #     Returns the authorization type or nouser if there is no such user.  #     Returns the authorization type or nouser if there is no such user.
 #  #
 sub GetAuthType   sub get_auth_type 
 {  {
   
     my ($domain, $user)  = @_;      my ($domain, $user)  = @_;
   
     Debug("GetAuthType( $domain, $user ) \n");      Debug("get_auth_type( $domain, $user ) \n");
     my $proname    = &propath($domain, $user);       my $proname    = &propath($domain, $user); 
     my $passwdfile = "$proname/passwd";      my $passwdfile = "$proname/passwd";
     if( -e $passwdfile ) {      if( -e $passwdfile ) {
Line 3602  sub GetAuthType Line 4975  sub GetAuthType
  }   }
   
  return "$authtype:$availinfo";   return "$authtype:$availinfo";
     }      } else {
     else {  
  Debug("Returning nouser");   Debug("Returning nouser");
  return "nouser";   return "nouser";
     }      }
 }  }
   
   #
   #  Validate a user given their domain, name and password.  This utility
   #  function is used by both  AuthenticateHandler and ChangePasswordHandler
   #  to validate the login credentials of a user.
   # Parameters:
   #    $domain    - The domain being logged into (this is required due to
   #                 the capability for multihomed systems.
   #    $user      - The name of the user being validated.
   #    $password  - The user's propoposed password.
   #
   # Returns:
   #     1        - The domain,user,pasword triplet corresponds to a valid
   #                user.
   #     0        - The domain,user,password triplet is not a valid user.
   #
   sub validate_user {
       my ($domain, $user, $password) = @_;
   
   
       # Why negative ~pi you may well ask?  Well this function is about
       # authentication, and therefore very important to get right.
       # I've initialized the flag that determines whether or not I've 
       # validated correctly to a value it's not supposed to get.
       # At the end of this function. I'll ensure that it's not still that
       # value so we don't just wind up returning some accidental value
       # as a result of executing an unforseen code path that
       # did not set $validated.  At the end of valid execution paths,
       # validated shoule be 1 for success or 0 for failuer.
   
       my $validated = -3.14159;
   
       #  How we authenticate is determined by the type of authentication
       #  the user has been assigned.  If the authentication type is
       #  "nouser", the user does not exist so we will return 0.
   
       my $contents = &get_auth_type($domain, $user);
       my ($howpwd, $contentpwd) = split(/:/, $contents);
   
       my $null = pack("C",0); # Used by kerberos auth types.
   
       if ($howpwd ne 'nouser') {
   
    if($howpwd eq "internal") { # Encrypted is in local password file.
       $validated = (crypt($password, $contentpwd) eq $contentpwd);
    }
    elsif ($howpwd eq "unix") { # User is a normal unix user.
       $contentpwd = (getpwnam($user))[1];
       if($contentpwd) {
    if($contentpwd eq 'x') { # Shadow password file...
       my $pwauth_path = "/usr/local/sbin/pwauth";
       open PWAUTH,  "|$pwauth_path" or
    die "Cannot invoke authentication";
       print PWAUTH "$user\n$password\n";
       close PWAUTH;
       $validated = ! $?;
   
    } else {         # Passwords in /etc/passwd. 
       $validated = (crypt($password,
    $contentpwd) eq $contentpwd);
    }
       } else {
    $validated = 0;
       }
    }
    elsif ($howpwd eq "krb4") { # user is in kerberos 4 auth. domain.
       if(! ($password =~ /$null/) ) {
    my $k4error = &Authen::Krb4::get_pw_in_tkt($user,
      "",
      $contentpwd,,
      'krbtgt',
      $contentpwd,
      1,
      $password);
    if(!$k4error) {
       $validated = 1;
    } else {
       $validated = 0;
       &logthis('krb4: '.$user.', '.$contentpwd.', '.
        &Authen::Krb4::get_err_txt($Authen::Krb4::error));
    }
       } else {
    $validated = 0; # Password has a match with null.
       }
    } elsif ($howpwd eq "krb5") { # User is in kerberos 5 auth. domain.
       if(!($password =~ /$null/)) { # Null password not allowed.
    my $krbclient = &Authen::Krb5::parse_name($user.'@'
     .$contentpwd);
    my $krbservice = "krbtgt/".$contentpwd."\@".$contentpwd;
    my $krbserver  = &Authen::Krb5::parse_name($krbservice);
    my $credentials= &Authen::Krb5::cc_default();
    $credentials->initialize($krbclient);
    my $krbreturn  = &Authen::KRb5::get_in_tkt_with_password($krbclient,
    $krbserver,
    $password,
    $credentials);
    $validated = ($krbreturn == 1);
       } else {
    $validated = 0;
       }
    } elsif ($howpwd eq "localauth") { 
       #  Authenticate via installation specific authentcation method:
       $validated = &localauth::localauth($user, 
          $password, 
          $contentpwd);
    } else { # Unrecognized auth is also bad.
       $validated = 0;
    }
       } else {
    $validated = 0;
       }
       #
       #  $validated has the correct stat of the authentication:
       #
   
       unless ($validated != -3.14159) {
    #  I >really really< want to know if this happens.
    #  since it indicates that user authentication is badly
    #  broken in some code path.
           #
    die "ValidateUser - failed to set the value of validated $domain, $user $password";
       }
       return $validated;
   }
   
   
 sub addline {  sub addline {
     my ($fname,$hostid,$ip,$newline)=@_;      my ($fname,$hostid,$ip,$newline)=@_;
     my $contents;      my $contents;
Line 3629  sub addline { Line 5126  sub addline {
     return $found;      return $found;
 }  }
   
 sub getchat {  sub get_chat {
     my ($cdom,$cname,$udom,$uname)=@_;      my ($cdom,$cname,$udom,$uname)=@_;
     my %hash;      my %hash;
     my $proname=&propath($cdom,$cname);      my $proname=&propath($cdom,$cname);
Line 3654  sub getchat { Line 5151  sub getchat {
     return (@participants,@entries);      return (@participants,@entries);
 }  }
   
 sub chatadd {  sub chat_add {
     my ($cdom,$cname,$newchat)=@_;      my ($cdom,$cname,$newchat)=@_;
     my %hash;      my %hash;
     my $proname=&propath($cdom,$cname);      my $proname=&propath($cdom,$cname);
Line 3854  sub make_passwd_file { Line 5351  sub make_passwd_file {
  return "no_priv_account_error\n";   return "no_priv_account_error\n";
     }      }
   
     my $execpath="$perlvar{'lonDaemons'}/"."lcuseradd";      my $execpath       ="$perlvar{'lonDaemons'}/"."lcuseradd";
   
       my $lc_error_file  = $execdir."/tmp/lcuseradd".$$.".status";
     {      {
  &Debug("Executing external: ".$execpath);   &Debug("Executing external: ".$execpath);
  &Debug("user  = ".$uname.", Password =". $npass);   &Debug("user  = ".$uname.", Password =". $npass);
Line 3862  sub make_passwd_file { Line 5361  sub make_passwd_file {
  print $se "$uname\n";   print $se "$uname\n";
  print $se "$npass\n";   print $se "$npass\n";
  print $se "$npass\n";   print $se "$npass\n";
    print $se "$lc_error_file\n"; # Status -> unique file.
     }      }
     my $useraddok = $?;      my $error = IO::File->new("< $lc_error_file");
       my $useraddok = <$error>;
       $error->close;
       unlink($lc_error_file);
   
       chomp $useraddok;
   
     if($useraddok > 0) {      if($useraddok > 0) {
  &logthis("Failed lcuseradd: ".&lcuseraddstrerror($useraddok));   my $error_text = &lcuseraddstrerror($useraddok);
    &logthis("Failed lcuseradd: $error_text");
    $result = "lcuseradd_failed:$error_text\n";
       }  else {
    my $pf = IO::File->new(">$passfilename");
    print $pf "unix:\n";
     }      }
     my $pf = IO::File->new(">$passfilename");  
     print $pf "unix:\n";  
  }   }
     } elsif ($umode eq 'none') {      } elsif ($umode eq 'none') {
  {   {
     my $pf = IO::File->new(">$passfilename");      my $pf = IO::File->new("> $passfilename");
     print $pf "none:\n";      print $pf "none:\n";
  }   }
     } else {      } else {
Line 4201  Place in B<logs/lond.log> Line 5710  Place in B<logs/lond.log>
   
 stores hash in namespace  stores hash in namespace
   
 =item rolesput  =item rolesputy
   
 put a role into a user's environment  put a role into a user's environment
   
Removed from v.1.212  
changed lines
  Added in v.1.250

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