home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume25 / npasswd / part02 / pw_passwd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-19  |  9.2 KB  |  401 lines
  1.  
  2. /* --------------------------------------------------------------------  */
  3. /*                                                                       */
  4. /*                         Author: Clyde Hoover                          */
  5. /*                          Computation Center                           */
  6. /*                   The University of Texas at Austin                   */
  7. /*                          Austin, Texas 78712                          */
  8. /*                         clyde@emx.utexas.edu                          */
  9. /*                   uunet!cs.utexas.edu!ut-emx!clyde                    */
  10. /*                                                                       */
  11. /*This code may be distributed freely, provided this notice is retained. */
  12. /*                                                                       */
  13. /* --------------------------------------------------------------------  */
  14. /*
  15.  *    pw_passwd - Routines for dealing with password files.
  16.  *        Handles V7 / *.* BSD / Sys V format.
  17.  */
  18. #include <stdio.h>
  19. #include <sys/types.h>
  20. #include <sys/stat.h>
  21. #include <signal.h>
  22. #include <errno.h>
  23. #include <pwd.h>
  24. #include <fcntl.h>
  25.  
  26. #ifndef lint
  27. static char sccsid[] = "@(#)pw_passwd.c    1.9 1/24/91 (cc.utexas.edu)";
  28. #endif
  29.  
  30. #define    SLOP    128    /*  Size difference tolerated old <> new passwd file */
  31.  
  32. #ifdef    SYSV
  33. /*
  34.  *    System V password aging stuff
  35.  */
  36. #define    SEC_PER_WEEK    ((long )24 * 7 * 60 * 60)
  37.  
  38. extern long a64l();
  39. extern char *l64a();
  40.  
  41. static time_t    pwage = 0,
  42.         maxpwtime = 0,
  43.         minpwtime = 0,
  44.         now;
  45. #endif
  46.  
  47. typedef struct passwd    passwd;
  48. typedef    struct passwd    *passwdp;
  49.  
  50. static passwd    theUser,        /* The user to change */
  51.         Me;            /* The user who invoked command */
  52. static int    myuid,            /* Uid of program */
  53.         mytempfile = 0;        /* Does PASSWD_TEMP belong to me? */
  54.  
  55. /*
  56.  *    File names
  57.  */
  58. #ifndef    PASSWD_FILE
  59. #define    PASSWD_FILE    "/etc/passwd"
  60. #endif
  61.  
  62. #ifndef    PASSWD_SAVE
  63. #define    PASSWD_SAVE    "/etc/opasswd"
  64. #endif
  65.  
  66. #ifndef    PASSWD_TEMP
  67. #define    PASSWD_TEMP    "/etc/ptmp"
  68. #endif
  69.  
  70. #define    PASSWD_MODE    0644
  71.  
  72. #ifdef    DEBUG
  73. static char    *passwdtemp = "./etc_ptmp",
  74.         *passwdfile = "./etc_passwd",
  75.         *savefile = "./etc_opasswd";
  76. #else
  77. static char    *passwdtemp = PASSWD_TEMP,
  78.         *passwdfile = PASSWD_FILE,
  79.         *savefile = PASSWD_SAVE;
  80. #endif
  81.  
  82. extern int    errno;
  83.  
  84. char    *getlogin(),
  85.     *crypt();
  86.  
  87. /*
  88.  *    pw_initialize - set up
  89.  */
  90. pw_initialize()
  91. {
  92.     passwdp    me;    /* Temp */
  93.     char    *myname = getlogin();    /* Name of invoker */
  94.  
  95. #ifdef    DEBUG
  96.     setpwfile(passwdfile);
  97. #endif
  98.     myuid = getuid();
  99.     if (myname && *myname) {
  100.         if ((me = getpwnam(myname)) == NULL)
  101.             quit(1, "Cannot get user identification from name.\n");
  102.     } else {
  103.         if ((me = getpwuid(myuid)) == NULL)
  104.             quit(1, "Cannot get user identification from uid.\n");
  105.     }
  106.  
  107.     _cppasswd(me, &Me);
  108.     return(1);
  109. }
  110.  
  111. /*
  112.  *    pw_getuserbyname - get password 
  113.  *
  114.  *    Returns 1 if passwd info found for <name>
  115.  *        0 otherwise
  116.  */
  117. pw_getuserbyname(name, passwdb)
  118. char    *name,        /* User name */
  119.     *passwdb;    /* Where to stuff password */
  120. {
  121.     passwdp    p;    /* Temp */
  122.  
  123.     if ((p = getpwnam(name)) == NULL)
  124.         return(0);
  125.     _cppasswd(p, &theUser);
  126.     (void) strcpy(passwdb, p->pw_passwd);
  127.     return(1);
  128. }
  129.  
  130. /*
  131.  *    pw_permission - check password change permission
  132.  *
  133.  *    Returns 1 if password can be changed
  134.  *        0 if not
  135.  */
  136. pw_permission()
  137. {
  138.     if (strcmp(Me.pw_name, theUser.pw_name) && myuid)
  139.         return(0);
  140.  
  141.     /*
  142.      * Other checks can be put here to determine if the invoker should
  143.      * be allowed to change this password.
  144.      */
  145. #ifdef    SYSV
  146.     if (theUser.pw_age) {
  147.         pwage = a64l(theUser.pw_age);
  148.         maxpwtime = pwage & 077;
  149.         minpwtime = (pwage >> 6) & 077;
  150.         pwage >>= 12;
  151.         (void) time(&now);
  152.         now /= SEC_PER_WEEK;
  153.         if (pwage <= now) {
  154.             if (myuid && (now < (pwage + minpwtime))) {
  155.                 fprintf(stderr, 
  156.                      "Sorry: < %ld  weeks since last change\n",
  157.                      minpwtime);
  158.                 return(0);
  159.             }
  160.             if ((minpwtime > maxpwtime) && myuid) {
  161.                 fprintf(stderr,
  162.                     "You may not change this password.\n");
  163.                 return(0);
  164.             }
  165.         }
  166.     }
  167. #endif
  168.     return(1);
  169. }
  170.  
  171. /*
  172.  *    pw_compare - compare old and new passwords
  173.  *
  174.  *    Returns 1 if check = new, 0 if not
  175.  */
  176. pw_compare(current, check)
  177. char    *current,        /* Current pw (encrypted) */
  178.     *check;            /* check pw (plain) */
  179. {
  180.     if (!*current)
  181.         return(0);
  182.     return(!strcmp(current, crypt(check, current)));
  183. }
  184.  
  185. /*
  186.  *    pw_check - sanity check password.  Right now just calls
  187.  *        the password check program
  188.  *
  189.  *    Returns 1 if password is ok to use, 0 otherwise
  190.  */
  191. pw_check(newpw)
  192. char    *newpw;        /* New password (plain) */
  193. {
  194.     /* Put other administrative checks here */
  195.     return(checkpasswd(theUser.pw_uid, newpw));
  196. }
  197.  
  198. /*
  199.  *    pw_replace - replace password in passwd file 
  200.  */
  201. pw_replace(newpwd, curpwd)
  202. char    *newpwd,        /* New password (plain) */
  203.     *curpwd;        /* Old password (plain) */
  204. {
  205. #ifdef    SYSV
  206.     int    (*sigint)(),        /* Save SIGINT */
  207.         (*sigquit)();        /* Save SIGQUIT */
  208. #else
  209.     long    oldsigs,        /* Signal mask save */
  210.         blocksigs = sigmask(SIGINT) |    /* Signals to block */
  211.                 sigmask(SIGQUIT) |    /* while updating */
  212.                 sigmask(SIGTSTP);    /* password file */
  213. #endif
  214.     passwdp px;        /* Temp */
  215.     char    salt[4];    /* Encryption salt */
  216.     FILE    *tf;        /* File ptr to new passwd file */
  217.     int    fd;        /* File desc. to new passwd file */
  218.     struct stat    oldstat,    /* Stat of current passwd file */
  219.             newstat;    /* Stat of new passwd file */
  220.  
  221.     /*
  222.      * Prepare password entry 'theUser' for replacement
  223.      */
  224.     randomstring(salt, sizeof(salt));
  225.     theUser.pw_passwd = crypt(newpwd, salt);
  226. #ifdef    SYSV
  227.     /*
  228.      * Update password age field
  229.      */
  230.     if (theUser.pw_age) {
  231.         if (maxpwtime == 0)
  232.             *theUser.pw_age = '\0';
  233.         else {
  234.             now = time((time_t *)0) / SEC_PER_WEEK;
  235.             pwage = maxpwtime
  236.                 + (minpwtime << 6)
  237.                 + (now << 12);
  238.             theUser.pw_age = l64a(pwage);
  239.         }
  240.     }
  241. #endif
  242.     (void) umask(0);
  243.     (void) stat(passwdfile, &oldstat);
  244.     fd = open(passwdtemp, O_WRONLY|O_CREAT|O_EXCL, PASSWD_MODE);
  245.     if (fd < 0) {
  246.         if (errno == EEXIST)
  247.             quit(0, "Password file busy - try again.\n");
  248.         perror("Tempfile create");
  249.         quit(1, "Cannot create temp file.\n");
  250.     }
  251.     mytempfile = 1;
  252.     if ((tf = fdopen(fd, "w")) == NULL)
  253.         quit(1, "Cannot fdopen temp file.");
  254. #ifdef    SYSV
  255.     sigint = signal(SIGINT, SIG_IGN);
  256.     sigquit = signal(SIGQUIT, SIG_IGN);
  257. #else
  258.     oldsigs = sigblock(blocksigs);
  259. #endif
  260.     setpwent();
  261.     while ((px = getpwent()) != NULL) {
  262.         if (px->pw_name == 0 || px->pw_name[0] == 0) /* Sanity check */
  263.             continue;
  264.         if (strcmp(px->pw_name, theUser.pw_name) == 0)
  265.             px = &theUser;
  266.         (void) putpwent(px, tf);
  267.     }
  268.     endpwent();
  269.     (void) fflush(tf);
  270.     (void) fstat(fileno(tf), &newstat);
  271.     (void) fclose(tf);
  272.     /*
  273.      * Check if the new password file is complete.  Since the encrypted
  274.      * password is of a fixed length, the new file should be roughly
  275.      * the same size as the old one.
  276.      */
  277.     if (newstat.st_size < (oldstat.st_size - SLOP))
  278.         quit(1, "New password file appears to be incomplete - aborting.\n");
  279.  
  280.     if (rename(passwdfile, savefile) < 0) {
  281.         perror("Password file save");
  282.         unlink(passwdtemp);
  283.         quit(1, "Can't save password file");
  284.     }
  285.     if (rename(passwdtemp, passwdfile) < 0) {
  286.         perror("Password file replace");
  287.         (void) unlink(passwdtemp);
  288.         (void) link(savefile, passwdfile);
  289.         quit(1, "Can't replace password file");
  290.     }
  291. #ifdef    BSD4_3
  292.     updatedbm();
  293. #endif
  294. #ifdef    SYSV
  295.     (void) signal(SIGINT, sigint);
  296.     (void) signal(SIGQUIT, sigquit);
  297. #else
  298.     (void) sigsetmask(oldsigs);
  299. #endif
  300. }
  301.  
  302. /*
  303.  *    pw_cleanup - clean up after myself
  304.  */
  305. pw_cleanup(code)
  306. int    code;        /* 0 for normal, 1 for abort */ /*NOTUSED*/
  307. {
  308.     if (mytempfile)
  309.         (void) unlink(passwdtemp);
  310. }
  311.  
  312. /*
  313.  *    _newstr - copy string into new storage
  314.  */
  315. static char *
  316. _newstr(s)
  317. char    *s;        /* String to copy */
  318. {
  319.     register char    *t;    /* Temp */
  320.     char    *malloc();
  321.  
  322.     if (s == NULL)
  323.         return(0);
  324.     t = malloc(strlen(s) + 1);
  325.     if (t == NULL)
  326.         quit(1, "No memory.\n");
  327.     (void) strcpy(t, s);
  328.     return(t);
  329. }
  330.  
  331. /*
  332.  *    _cppasswd - copy a passwd structure
  333.  */
  334. static
  335. _cppasswd(f,t)
  336. passwdp    f,        /* From */
  337.     t;        /* To */
  338. {
  339.     *t = *f;
  340.     t->pw_name = _newstr(f->pw_name);
  341. #ifdef    SYSV
  342.     t->pw_age = _newstr(f->pw_age);
  343. #endif
  344.     t->pw_passwd = _newstr(f->pw_passwd);
  345.     t->pw_comment = _newstr(f->pw_comment);
  346.     t->pw_gecos = _newstr(f->pw_gecos);
  347.     t->pw_dir = _newstr(f->pw_dir);
  348.     t->pw_shell = _newstr(f->pw_shell);
  349. }
  350.  
  351. #ifdef    BSD4_3
  352. /*
  353.  *    Update the hashed password data base
  354.  */
  355. #include <ndbm.h>
  356.  
  357. #define    SCOPY(S) xp = (S); while (*cp++ = *xp++)
  358. #define    BCOPY(B) bcopy((char *)&(B), cp, sizeof(int)); cp += sizeof(int)
  359.  
  360. updatedbm()
  361. {
  362.     DBM    *pwd;        /* DBM data base passwd */
  363.     register char    *cp,    /* Data storage pointer */
  364.             *xp;    /* String copy pointer */
  365.     datum    key,        /* DBM key datum */
  366.         data;        /* DBM data store datum */
  367.     char    buf[512];    /* Data buffer */
  368.  
  369.     pwd = dbm_open(passwdfile, O_RDWR, 0);
  370.     if (pwd == 0)
  371.         return;
  372.     cp = buf;
  373.     /* Pack passwd entry in the form expected by the getpw* routines */
  374.     SCOPY(theUser.pw_name);
  375.     SCOPY(theUser.pw_passwd);
  376.     BCOPY(theUser.pw_uid);
  377.     BCOPY(theUser.pw_gid);
  378.     BCOPY(theUser.pw_quota);
  379.     SCOPY(theUser.pw_comment);
  380.     SCOPY(theUser.pw_gecos);
  381.     SCOPY(theUser.pw_dir);
  382.     SCOPY(theUser.pw_shell);
  383.  
  384.     data.dptr = buf;
  385.     data.dsize = cp - buf;
  386.     key.dptr = theUser.pw_name;
  387.     key.dsize = strlen(theUser.pw_name);
  388.     if (dbm_store(pwd, key, data, DBM_REPLACE) < 0) {
  389.         perror("dbm_store (name)");
  390.         quit(1, "Can't store passwd entry (name key).\n");
  391.     }
  392.     key.dptr = (char *)&theUser.pw_uid;
  393.     key.dsize = sizeof (int);
  394.     if (dbm_store(pwd, key, data, DBM_REPLACE) < 0) {
  395.         perror("dbm_store (uid)");
  396.         quit(1, "Can't store passwd entry (uid key).\n");
  397.     }
  398.     dbm_close(pwd);
  399. }
  400. #endif
  401.