Return to lchtmldir CVS log

Up to [LON-CAPA] / loncom

Latent support for saving full directory tree permission/ownerships
in the form of a script that can be run to restore.  This would be used
when changing a file system authenticated user to internally authenticated
in order to support rolling their directory ownership/permissions back.

    1: #!/usr/bin/perl
    2: 
    3: # The Learning Online Network with CAPA
    4: #
    5: # Copyright Michigan State University Board of Trustees
    6: #
    7: # This file is part of the LearningOnline Network with CAPA (LON-CAPA).
    8: #
    9: # LON-CAPA is free software; you can redistribute it and/or modify
   10: # it under the terms of the GNU General Public License as published by
   11: # the Free Software Foundation; either version 2 of the License, or
   12: # (at your option) any later version.
   13: #
   14: # LON-CAPA is distributed in the hope that it will be useful,
   15: # but WITHOUT ANY WARRANTY; without even the implied warranty of
   16: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   17: # GNU General Public License for more details.
   18: #
   19: # You should have received a copy of the GNU General Public License
   20: # along with LON-CAPA; if not, write to the Free Software
   21: # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   22: #
   23: # /home/httpd/html/adm/gpl.txt
   24: #
   25: # http://www.lon-capa.org/
   26: #
   27: #  lchtmldir - LONC-CAPA setuid script to:
   28: #              o If necessary, add a public_html directory 
   29: #                to the specified user home directory.
   30: #              o Set the permissions according to the authentication type.
   31: #
   32: #  Motivations:
   33: #     Originally, account creation would create a public_html
   34: #     directory for unix authorized people only.  It is possible to have
   35: #     Kerberos, internal and locally authorized 'users' which may be authors
   36: #     and hence need a properly owned an protected public_html directory
   37: #     to serve as their construction space.
   38: #
   39: #  Author:
   40: #    Ron Fox
   41: #    NSCL
   42: #    Michigan State University8
   43: #    East Lansing, MI 48824-1321
   44: 
   45: #   General flow of control:
   46: #   1. Validate process state (must be run as www).
   47: #   2. Validate parameters:  Need two parameters:
   48: #         o Homedir  - Home diretory of user 
   49: #         o Username - Name of the user.
   50: #         o AuthMode - Authentication mode, can be:
   51: #                      - unix
   52: #                      - internal
   53: #                      - krb4
   54: #                      - localauth
   55: #  3. Untaint the usename and home directory
   56: #
   57: #  4. As root if necessary, create $Homedir/public_html
   58: #  5. Set ownership/permissions according to authentication mode (AuthMode)
   59: #       - unix - ~owner:www/2775
   60: #       - krb4 - ~owner:www/2775
   61: #       - internal - www:www/2775
   62: #       - local    - www:www/2775
   63: #
   64: 
   65: #
   66: #   Take a few precautions to be sure that we're not vulnerable to trojan
   67: #   horses and other fine issues:
   68: #
   69: use strict; 
   70: use Fcntl qw(:mode);
   71: use DirHandle;
   72: 
   73: 
   74: $ENV{'PATH'} = '/bin:/usr/bin:/usr/local/sbin:/home/httpd/perl';
   75: delete @ENV{qw{IFS CDPATH ENV BASH_ENV}};
   76: 
   77: my $DEBUG = 0;                         # .nonzero -> Debug printing enabled.
   78: my $path_sep = "/";		# Unix like operating systems.
   79: 
   80: 
   81: # If the UID of the running process is not www exit with error.
   82: 
   83: if ($DEBUG) {
   84:     print("Checking uid...\n");
   85: }
   86: my $wwwid = getpwnam('www');
   87: &DisableRoot;
   88: if($wwwid != $>) {
   89:     if ($DEBUG) {
   90: 	print("User ID incorrect.  This program must be run as user 'www'\n");
   91:     }
   92:     exit 1;			# Exit with error status.
   93: }
   94: 
   95: # There must be three 'command line' parameters.  The first
   96: # is the home directory of the user.
   97: # The second is the name of the user.  This is only referenced
   98: # in code branches dealing with unix mode authentication.
   99: # The last is the authentication mode which must be one of unix, internal
  100: # krb4 or localauth.
  101: #   If there is an error in the argument count or countents, we exit with an
  102: # error.
  103: 
  104: if ($DEBUG) {
  105:     print("Checking parameters: \n");
  106: }
  107: if(@ARGV != 3) {
  108:     if($DEBUG) {
  109: 	print("Error: lchtmldir need 3 parameters \n");
  110:     }
  111:     exit 2;
  112: }
  113: my ($dir,$username,$authentication) = @ARGV;
  114: 
  115: if($DEBUG) {
  116:     print ("Directory = $dir \n");
  117:     print ("User      = $username \n");
  118:     print ("Authmode  = $authentication \n");
  119: 
  120: }
  121: 
  122: if( $authentication ne "unix:"     &&
  123:     $authentication ne "internal:" &&
  124:     $authentication !~ /^krb(4|5):(.*)/ &&
  125:     $authentication ne "localauth:") {
  126:     if($DEBUG) {
  127: 	print("Invalid authentication parameter: ".$authentication."\n");
  128: 	print("Should be one of: unix, internal, krb4, localauth\n");
  129:     }
  130:     exit 3;
  131: }
  132: 
  133: # Untaint the username.
  134: 
  135: my $match = $username =~ /^(\w+)$/;
  136: my $patt  = $1;
  137:  
  138: if($DEBUG) {
  139:    print("Username word match flag = ".$match."\n");
  140:     print("Match value = ".$patt."\n");
  141: }
  142: 
  143: my $safeuser = $patt;
  144: if($DEBUG) {
  145:     print("Save username = $safeuser \n");
  146: }
  147: if(($username ne $safeuser) or ($safeuser!~/^[A-za-z]/)) {
  148:     if($DEBUG) {
  149: 	print("User name $username had illegal characters\n");
  150:     }
  151:     exit 4;
  152: }
  153: 
  154: #untaint the base directory require that the dir contain only 
  155: # alphas, / numbers or underscores, and end in /$safeuser
  156: 
  157: $dir =~ /(^([\w\/]+))/;
  158: 
  159: my $dirtry1 = $1;
  160: 
  161: $dir =~ /$\/$safeuser/;
  162: my $dirtry2 = $1;
  163: 
  164: if(($dirtry1 ne $dir) or ($dirtry2 ne $dir)) {
  165:     if ($DEBUG) {
  166: 	print("Directory $dir is not a valid home for $safeuser\n");
  167:     }
  168:     exit 5;
  169: }
  170: 
  171: 
  172: # As root, create the directory.
  173: 
  174: my $homedir = $dirtry1;
  175: my $fulldir = $homedir."/public_html";
  176: 
  177: if($DEBUG) {
  178:     print("Full directory path is: $fulldir \n");
  179: }
  180: if(!( -e $dirtry1)) {
  181:     if($DEBUG) {
  182: 	print("User's home directory $dirtry1 does not exist\n");
  183:     }
  184:     if ($authentication eq "unix:") {
  185:         exit 6;
  186:     }
  187: }
  188: &EnableRoot;
  189: 
  190: &System("/bin/mkdir -p $fulldir")   unless (-e $fulldir);
  191:     unless(-e $fulldir."/index.html") {
  192: 	open OUT,">".$fulldir."/index.html";
  193: 	print OUT<<END;
  194: 	<html>
  195: 	<head>
  196: 	<title>$safeuser</title>
  197:         </head>
  198:         <body bgcolor="#ccffdd">
  199:         <h1>$safeuser Construction Space</h1>
  200:           <h2>
  201:             The Learning<i>Online</i> Network with Computer-Assisted Personalized Approach
  202:           </h2>
  203:           <p>
  204: This is your construction space within LON-CAPA, where you would construct resources which are meant to be
  205: used across courses and institutions.
  206:           </p>
  207:           <p>
  208: Material within this area can only be seen and edited by $safeuser and designated co-authors. To make
  209: it available to students and other instructors, the material needs to be published.
  210:           </p>
  211:         </body>
  212:        </html>
  213: END
  214:     close OUT;
  215:     }
  216: 
  217: &System("/bin/chmod  02775  $fulldir");
  218: &System("/bin/chmod  0775  $fulldir"."/index.html");
  219: 
  220: 
  221: # Based on the authentiation mode, set the ownership of the directory.
  222: 
  223: if($authentication eq "unix:") {	# Unix mode authentication...
  224:     &System("/bin/chown -R   $safeuser".":".$safeuser." ".$fulldir);
  225:     &JoinGroup($safeuser);
  226: } else {
  227:     # Internal, Kerberos, and Local authentication are for users
  228:     # who do not have unix accounts on the system.  Therefore we
  229:     # will give ownership of their public_html directories to www:www
  230:     # If the user is an internal auth user, the rest of the directory tree
  231:     # gets owned by root.  This chown is needed in case what's really happening
  232:     # is that a file system user is being demoted to internal user...
  233: 
  234:     if($authentication eq "internal:") {
  235: 	&System("/bin/chown -R root:root ".$homedir);
  236:     }
  237:     &System("/bin/chown -R www:www  ".$fulldir);
  238: }
  239: &DisableRoot;
  240: 
  241: exit 0;
  242: 
  243: #----------------------------------------------------------------------
  244: #
  245: #  Local utility procedures.
  246: #  These include:
  247: #     EnableRoot - Start running as root.
  248: #     DisableRoot- Stop running as root.
  249: #     JoinGroup  - Join www to the specified group.
  250: 
  251: # Turn on as root:
  252: 
  253: sub EnableRoot {
  254:     if ($wwwid==$>) {
  255: 	($<,$>)=($>,$<);
  256: 	($(,$))=($),$();
  257:     }
  258:     else {
  259: 	# root capability is already enabled
  260:     }
  261:     if($DEBUG) {
  262: 	print("Enable Root - id =  $> $<\n");
  263:     }
  264:     return $>;  
  265: }
  266: 
  267: sub DisableRoot {
  268:     if ($wwwid==$<) {
  269: 	($<,$>)=($>,$<);
  270: 	($(,$))=($),$();
  271:     }
  272:     else {
  273: 	# root capability is already disabled
  274:     }
  275:     if($DEBUG) {
  276: 	print("Disable root: id = ".$>."\n");
  277:     }
  278: }
  279: 
  280: sub JoinGroup {
  281:     my $usergroup = shift;
  282: 
  283:     my $groups = `/usr/bin/groups www`;
  284:     # untaint
  285:     my ($safegroups)=($groups=~/:\s+([\s\w]+)/);
  286:     $groups=$safegroups;
  287:     chomp $groups; $groups=~s/^\S+\s+\:\s+//;
  288:     my @grouplist=split(/\s+/,$groups);
  289:     my @ugrouplist=grep {!/www|$usergroup/} @grouplist;
  290:     my $gl=join(',',(@ugrouplist,$usergroup));
  291:     if (&System('/usr/sbin/usermod','-G',$gl,'www')) {
  292: 	if($DEBUG) {
  293: 	    print "Error. Could not make www a member of the group ".
  294: 		"\"$usergroup\".\n";
  295: 	}
  296: 	exit 6;
  297:     }
  298:     
  299: }
  300: 
  301: 
  302: 
  303: sub System {
  304:     my ($command,@args) = @_;
  305:     if($DEBUG) {
  306: 	print("system: $command with args ".join(' ',@args)."\n");
  307:     }
  308:     system($command,@args);
  309: }
  310: 
  311: 
  312: 
  313: 
  314: 
  315: #
  316: #   This file contains code to recursively process
  317: #   a Directory.  This is a bit more powerful
  318: #   than File::Find in that we pass the full
  319: #   stat info to the processing function.
  320: #     For each file in the specified directory subtree, 
  321: #   The user's Code reference is invoked for all files, regular and otherwise
  322: #   except:
  323: #      ., ..
  324: #
  325: #  Parameters:
  326: #     code_ref    - Code reference, invoked for each file in the tree.
  327: #                   as follows:  CodeRef(directory, name, statinfo)
  328: #                   directory the path to the directory holding the file.
  329: #                   name      the name of the file within Directory.
  330: #                   statinfo  a reference to the stat of the file.
  331: #     start_dir   - The starting point of the directory walk.
  332: #
  333: # NOTE:
  334: #   Yes, we could have just used File::Find, but since we have to get the
  335: #   stat anyway, this is actually simpler, as File::Find would have gotten
  336: #   the stat to figure out the file type and then we would have gotten it
  337: #   again.
  338: #
  339: 
  340: sub process_tree {
  341:     my ($code_ref, $start_dir)  = @_;
  342: 
  343:     my $dir = new DirHandle $start_dir; 
  344:     if (!defined($dir)) {
  345:         print "Failed to  open dirhandle: $start_dir\n";
  346:     }
  347: 
  348:     # Now iterate through this level of the tree:
  349: 
  350:     while (defined (my $name = $dir->read)) {
  351: 	next if $name =~/^\.\.?$/;       # Skip ., .. (see cookbook pg 319)
  352: 	
  353: 	my $full_name   = $start_dir.$path_sep.$name; # Full filename path.
  354: 	my @stat_info  = lstat($full_name);
  355: 	my $mode       = $stat_info[2];
  356: 	my $type       = $mode & 0170000; #  File type.
  357: 
  358: 	# Unless the file type is a symlink, call the user code:
  359: 
  360: 	unless ($type == S_IFLNK) {
  361: 	    &$code_ref($start_dir, $name, \@stat_info);
  362: 	}
  363: 
  364: 	# If the entry is a directory, we need to recurse:
  365: 
  366: 
  367: 	if (($type ==  S_IFDIR) != 0) {
  368: 	    &process_tree($code_ref, $full_name);
  369: 	}
  370:     }
  371: 
  372: }
  373: #
  374: #  Simple test of process_tree:
  375: #
  376: sub write_script {
  377:     my ($dir, $name, $statinfo) = @_;
  378: 
  379:     my $fullname = $dir.$path_sep.$name;
  380: 
  381:     #  We're going to '' the name, but we need to deal with embedded
  382:     #  ' characters.  Using " is much worse as we'd then have to
  383:     #  escape all the shell escapes too.  This way all we need
  384:     #  to do is replace ' with '\''
  385: 
  386:     $fullname =~ s/\'/\'\\\'\'/g;
  387: 
  388:     my $perms    = $statinfo->[2] & 0777; # Just permissions.
  389:     printf CHMODSCRIPT "chmod 0%o '%s'\n", $perms, $fullname;
  390:     printf CHMODSCRIPT "chown %d:%d '%s'\n", $statinfo->[4], $statinfo->[5], 
  391:                                          $fullname
  392: 
  393: 
  394: }
  395: 
  396: 
  397: 
  398: