home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / UUCPbb_2_1_src.lzh / UUCPBB21 / chown.c < prev    next >
Text File  |  1994-09-25  |  7KB  |  252 lines
  1. /*  chown.c  This program lets a user change ownership of a file or directory
  2.     Copyright (C) 1992  Bob Billson
  3.  
  4.     This file is part of the OS-9 UUCP package, UUCPbb.
  5.  
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 2 of the License, or
  9.     (at your option) any later version.
  10.  
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  15.  
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  
  20.     The author of UUCPbb, Bob Billson, can be contacted at:
  21.     bob@kc2wz.bubble.org  or  uunet!kc2wz!bob  or  by snail mail:
  22.     21 Bates Way, Westfield, NJ 07090
  23. */
  24.  
  25. /* A user who is not the superuser allowed only to ownership of files and/or
  26.    directories belonging to them TO that of another user.  They are NOT
  27.    allowed to change ownership another user's files and/or directories TO
  28.    their own.
  29.  
  30.     Usage:  chown <user_id | username>   <file [<file...>]>   */
  31.  
  32. #define MAIN
  33.  
  34. #include "uucp.h"
  35. #include <ctype.h>
  36. #include <direct.h>
  37. #include <modes.h>
  38. #include <password.h>
  39.  
  40. #define OK         0
  41. #define OPENERROR  1
  42. #define GFDERROR   2
  43. #define SFDERROR   3
  44. #define OWNERROR   4
  45.  
  46. QQ unsigned myuid; 
  47. unsigned getuserid();
  48.  
  49.  
  50. main (argc, argv)
  51. int argc;
  52. char **argv;
  53. {
  54.      unsigned uid;
  55.      register int i;
  56.      int result;
  57.  
  58.      if (argc < 3)
  59.           usage();
  60.  
  61.      myuid = getuid();
  62.  
  63.      /* get the user name or ID from the command line */
  64.  
  65.      if ((uid = getuserid (argv[1])) == ERROR)
  66.           exit (_errmsg (0, "chown: '%s' is not a valid user name or ID\n",
  67.                      argv[1]));
  68.  
  69.      /* process each file and/or directory on the command line */
  70.      for (i = 2; i < argc; ++i)
  71.        {
  72.           result = setnewowner (argv[i], uid);
  73.  
  74.           switch (result)
  75.             {
  76.                case OPENERROR:
  77.                     fprintf (stderr, "can't open %s...error %d\n",
  78.                               argv[i], errno);
  79.                     break;
  80.  
  81.                case OWNERROR:
  82.                     fprintf (stderr, "can't change ownership...you don't own '%s'\n",
  83.                              argv[i]);
  84.                     break;
  85.  
  86.                case GFDERROR:
  87.                     fprintf (stderr, "can't get file descriptor for %s...error %d\n",
  88.                                argv[i], errno);
  89.                     break;
  90.                     
  91.                case SFDERROR:
  92.                     fprintf (stderr, "can't update file descriptor for %s...error %d\n",
  93.                                argv[i], errno);
  94.                     break;
  95.  
  96.                case OK:
  97.                     break;
  98.  
  99.                default:
  100.                     fprintf (stderr, "can't change ownership of %s...error %d\n",
  101.                                 errno);
  102.                     break;
  103.             }
  104.        }
  105.      exit (0);
  106. }
  107.  
  108.  
  109.  
  110.  
  111. unsigned getuserid (user)
  112. char *user;
  113. {  
  114.      register PWENT *pwentry;
  115.      unsigned newuid;
  116.  
  117.      /* were we given a numerical uid? */
  118.      if (validnum (user))
  119.           return (atoi (user));
  120.  
  121.      /* Nope, must be username, get ID from password file.  Become superuser
  122.         so we can open password file. */
  123.  
  124.      asetuid (0);
  125.      pwentry = getpwnam (user);
  126.  
  127.      if (pwentry == ERROR)
  128.           fatal ("getuserid() cannot open password file");
  129.  
  130.      if (pwentry == NULL)
  131.        {
  132.           endpwent();
  133.           asetuid (myuid);
  134.           return (ERROR);
  135.        }
  136.  
  137.      newuid = (unsigned) atoi (pwentry->uid);
  138.      endpwent();
  139.      asetuid (myuid);
  140.      return (newuid);
  141. }
  142.  
  143.  
  144.  
  145.  
  146. /* Is 'string' numerical user ID or name? */
  147.  
  148. int validnum (string)
  149. char *string;
  150. {
  151.      register char *ptr;
  152.      int result = FALSE;                             /* assume a user name */
  153.  
  154.      ptr = string;
  155.  
  156.      if (isdigit (*ptr))
  157.        {
  158.           while (*ptr &&  isdigit (*ptr))
  159.                ++ptr;
  160.  
  161.           /* is this a numerical ID or user name? */
  162.           if (*ptr == '\0')
  163.                result = TRUE;          /* numerical ID */
  164.        }
  165.      return (result);
  166. }
  167.  
  168.  
  169.  
  170. /* Change the ownership of a file or directory.  Microware's chown() will not
  171.    allow directory ownership to be changed.  Therefore, we do it ourselves.
  172.    If the current user is *not* the superuser or the file/directories is not
  173.    theirs, the user won't be allowed to change ownership. 
  174.    Owners can change ownership TO another user, but not another user's
  175.    files/directories TO their own.  */
  176.  
  177. int setnewowner (file_or_dir, newowner)
  178. char *file_or_dir;
  179. unsigned newowner;
  180. {
  181.      struct fildes buffer;
  182.      register int path;
  183.  
  184.      if (((path = open (file_or_dir, S_IWRITE)) == ERROR)  &&
  185.           ((path = open (file_or_dir, S_IFDIR | S_IWRITE)) == ERROR))
  186.        {
  187.           return (OPENERROR);
  188.        }
  189.  
  190.      if (_gs_gfd (path, &buffer, sizeof (buffer)) == ERROR)
  191.        {
  192.           close (path);
  193.           return (GFDERROR);
  194.        }
  195.  
  196.      /* Does this file belong to me  or am I the superuser? */
  197.      if ((myuid != 0)  &&  (buffer.fd_own != myuid))
  198.        {
  199.           close (path);
  200.           return (OWNERROR);
  201.        }
  202.  
  203.      /* set the new owner ID to another user */
  204.      buffer.fd_own = newowner;
  205.  
  206.      /* become superuser so we can write the file descriptor */
  207.      asetuid (0);
  208.  
  209.      /* update the file descriptor */
  210.      if (_ss_pfd (path, &buffer) == ERROR)
  211.        {
  212.           close (path);
  213.           asetuid (myuid);
  214.           return (SFDERROR);
  215.        }
  216.  
  217.      /* back to our ID */
  218.      asetuid (myuid);
  219.      close (path);
  220.      return (OK);
  221. }
  222.  
  223.  
  224.  
  225. int usage()
  226. {
  227.      register char **ptr;
  228.      static char *use[] = {
  229.              "chown: change ownership of a file or directory to another user",
  230.              " ",
  231.              "Usage:  chown <username | ID>  <file | dir> [<file | dir>...]",
  232.              NULL
  233.           };
  234.  
  235.      for (ptr = use; *ptr != NULL; ++ptr)
  236.           fprintf (stderr, "%s\n", *ptr);
  237.  
  238.      fprintf (stderr, "\nv%s (%s) This is free software released under the GNU General Public\n",
  239.                       version, VERDATE);
  240.      fputs ("License.  Please send suggestions/bug reports to:  bob@kc2wz.bubble.org\n", stderr);
  241.      exit (0);
  242. }
  243.  
  244.  
  245.  
  246. int fatal (msg)
  247. char *msg;
  248. {
  249.      fprintf (stderr, "chown: %s...error %d\n", msg, errno);
  250.      exit (0);
  251. }
  252.