home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 July & August / Pcwk78a98.iso / Wtestowe / Clico / UNIX / SAMBA / SOURCE / SAMBA.TAR / samba-1.9.17 / source / smbpass.c < prev    next >
C/C++ Source or Header  |  1997-07-18  |  7KB  |  300 lines
  1. #ifdef SMB_PASSWD
  2. /*
  3.  * Unix SMB/Netbios implementation. Version 1.9. SMB parameters and setup
  4.  * Copyright (C) Andrew Tridgell 1992-1997 Modified by Jeremy Allison 1995.
  5.  * 
  6.  * This program is free software; you can redistribute it and/or modify it under
  7.  * the terms of the GNU General Public License as published by the Free
  8.  * Software Foundation; either version 2 of the License, or (at your option)
  9.  * any later version.
  10.  * 
  11.  * This program is distributed in the hope that it will be useful, but WITHOUT
  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14.  * more details.
  15.  * 
  16.  * You should have received a copy of the GNU General Public License along with
  17.  * this program; if not, write to the Free Software Foundation, Inc., 675
  18.  * Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20.  
  21. #include "includes.h"
  22.  
  23. extern int      DEBUGLEVEL;
  24.  
  25. int             gotalarm;
  26.  
  27. void 
  28. gotalarm_sig()
  29. {
  30.     gotalarm = 1;
  31. }
  32.  
  33. int 
  34. do_pw_lock(int fd, int waitsecs, int type)
  35. {
  36.     struct flock    lock;
  37.     int             ret;
  38.  
  39.     gotalarm = 0;
  40.     signal(SIGALRM, SIGNAL_CAST gotalarm_sig);
  41.  
  42.     lock.l_type = type;
  43.     lock.l_whence = SEEK_SET;
  44.     lock.l_start = 0;
  45.     lock.l_len = 1;
  46.     lock.l_pid = 0;
  47.  
  48.     alarm(5);
  49.     ret = fcntl(fd, F_SETLKW, &lock);
  50.     alarm(0);
  51.     signal(SIGALRM, SIGNAL_CAST SIG_DFL);
  52.  
  53.     if (gotalarm) {
  54.         DEBUG(0, ("do_pw_lock: failed to %s SMB passwd file.\n",
  55.               type == F_UNLCK ? "unlock" : "lock"));
  56.         return -1;
  57.     }
  58.     return ret;
  59. }
  60.  
  61. int pw_file_lock(char *name, int type, int secs)
  62. {
  63.     int fd = open(name, O_RDWR | O_CREAT, 0600);
  64.     if (fd < 0)
  65.         return (-1);
  66.     if (do_pw_lock(fd, secs, type)) {
  67.         close(fd);
  68.         return -1;
  69.     }
  70.     return fd;
  71. }
  72.  
  73. int pw_file_unlock(int fd)
  74. {
  75.     do_pw_lock(fd, 5, F_UNLCK);
  76.     return close(fd);
  77. }
  78.  
  79. /*
  80.  * Routine to get the next 32 hex characters and turn them
  81.  * into a 16 byte array.
  82.  */
  83.  
  84. static int gethexpwd(char *p, char *pwd)
  85. {
  86.     int i;
  87.     unsigned char   lonybble, hinybble;
  88.     char           *hexchars = "0123456789ABCDEF";
  89.     char           *p1, *p2;
  90.  
  91.     for (i = 0; i < 32; i += 2) {
  92.         hinybble = toupper(p[i]);
  93.         lonybble = toupper(p[i + 1]);
  94.  
  95.         p1 = strchr(hexchars, hinybble);
  96.         p2 = strchr(hexchars, lonybble);
  97.         if (!p1 || !p2)
  98.             return (False);
  99.         hinybble = PTR_DIFF(p1, hexchars);
  100.         lonybble = PTR_DIFF(p2, hexchars);
  101.  
  102.         pwd[i / 2] = (hinybble << 4) | lonybble;
  103.     }
  104.     return (True);
  105. }
  106.  
  107. /*
  108.  * Routine to search the smbpasswd file for an entry matching the username.
  109.  */
  110. struct smb_passwd *get_smbpwnam(char *name)
  111. {
  112.     /* Static buffers we will return. */
  113.     static struct smb_passwd pw_buf;
  114.     static pstring  user_name;
  115.     static unsigned char smbpwd[16];
  116.     static unsigned char smbntpwd[16];
  117.     char            linebuf[256];
  118.     char            readbuf[16 * 1024];
  119.     unsigned char   c;
  120.     unsigned char  *p;
  121.     long            uidval;
  122.     long            linebuf_len;
  123.     FILE           *fp;
  124.     int             lockfd;
  125.     char           *pfile = lp_smb_passwd_file();
  126.  
  127.     if (!*pfile) {
  128.         DEBUG(0, ("No SMB password file set\n"));
  129.         return (NULL);
  130.     }
  131.     DEBUG(10, ("get_smbpwnam: opening file %s\n", pfile));
  132.  
  133.     fp = fopen(pfile, "r");
  134.  
  135.     if (fp == NULL) {
  136.         DEBUG(0, ("get_smbpwnam: unable to open file %s\n", pfile));
  137.         return NULL;
  138.     }
  139.     /* Set a 16k buffer to do more efficient reads */
  140.     setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
  141.  
  142.     if ((lockfd = pw_file_lock(pfile, F_RDLCK, 5)) < 0) {
  143.         DEBUG(0, ("get_smbpwnam: unable to lock file %s\n", pfile));
  144.         fclose(fp);
  145.         return NULL;
  146.     }
  147.     /* make sure it is only rw by the owner */
  148.     chmod(pfile, 0600);
  149.  
  150.     /* We have a read lock on the file. */
  151.     /*
  152.      * Scan the file, a line at a time and check if the name matches.
  153.      */
  154.     while (!feof(fp)) {
  155.         linebuf[0] = '\0';
  156.  
  157.         fgets(linebuf, 256, fp);
  158.         if (ferror(fp)) {
  159.             fclose(fp);
  160.             pw_file_unlock(lockfd);
  161.             return NULL;
  162.         }
  163.         /*
  164.          * Check if the string is terminated with a newline - if not
  165.          * then we must keep reading and discard until we get one.
  166.          */
  167.         linebuf_len = strlen(linebuf);
  168.         if (linebuf[linebuf_len - 1] != '\n') {
  169.             c = '\0';
  170.             while (!ferror(fp) && !feof(fp)) {
  171.                 c = fgetc(fp);
  172.                 if (c == '\n')
  173.                     break;
  174.             }
  175.         } else
  176.             linebuf[linebuf_len - 1] = '\0';
  177.  
  178. #ifdef DEBUG_PASSWORD
  179.         DEBUG(100, ("get_smbpwnam: got line |%s|\n", linebuf));
  180. #endif
  181.         if ((linebuf[0] == 0) && feof(fp)) {
  182.             DEBUG(4, ("get_smbpwnam: end of file reached\n"));
  183.             break;
  184.         }
  185.         /*
  186.          * The line we have should be of the form :-
  187.          * 
  188.          * username:uid:[32hex bytes]:....other flags presently
  189.          * ignored....
  190.          * 
  191.          * or,
  192.          *
  193.          * username:uid:[32hex bytes]:[32hex bytes]:....ignored....
  194.          *
  195.          * if Windows NT compatible passwords are also present.
  196.          */
  197.  
  198.         if (linebuf[0] == '#' || linebuf[0] == '\0') {
  199.             DEBUG(6, ("get_smbpwnam: skipping comment or blank line\n"));
  200.             continue;
  201.         }
  202.         p = (unsigned char *) strchr(linebuf, ':');
  203.         if (p == NULL) {
  204.             DEBUG(0, ("get_smbpwnam: malformed password entry (no :)\n"));
  205.             continue;
  206.         }
  207.         /*
  208.          * As 256 is shorter than a pstring we don't need to check
  209.          * length here - if this ever changes....
  210.          */
  211.         strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
  212.         user_name[PTR_DIFF(p, linebuf)] = '\0';
  213.         if (!strequal(user_name, name))
  214.             continue;
  215.  
  216.         /* User name matches - get uid and password */
  217.         p++;        /* Go past ':' */
  218.         if (!isdigit(*p)) {
  219.             DEBUG(0, ("get_smbpwnam: malformed password entry (uid not number)\n"));
  220.             fclose(fp);
  221.             pw_file_unlock(lockfd);
  222.             return NULL;
  223.         }
  224.         uidval = atoi((char *) p);
  225.         while (*p && isdigit(*p))
  226.             p++;
  227.         if (*p != ':') {
  228.             DEBUG(0, ("get_smbpwnam: malformed password entry (no : after uid)\n"));
  229.             fclose(fp);
  230.             pw_file_unlock(lockfd);
  231.             return NULL;
  232.         }
  233.         /*
  234.          * Now get the password value - this should be 32 hex digits
  235.          * which are the ascii representations of a 16 byte string.
  236.          * Get two at a time and put them into the password.
  237.          */
  238.         p++;
  239.         if (*p == '*' || *p == 'X') {
  240.             /* Password deliberately invalid - end here. */
  241.             DEBUG(10, ("get_smbpwnam: entry invalidated for user %s\n", user_name));
  242.             fclose(fp);
  243.             pw_file_unlock(lockfd);
  244.             return NULL;
  245.         }
  246.         if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
  247.             DEBUG(0, ("get_smbpwnam: malformed password entry (passwd too short)\n"));
  248.             fclose(fp);
  249.             pw_file_unlock(lockfd);
  250.             return (False);
  251.         }
  252.         if (p[32] != ':') {
  253.             DEBUG(0, ("get_smbpwnam: malformed password entry (no terminating :)\n"));
  254.             fclose(fp);
  255.             pw_file_unlock(lockfd);
  256.             return NULL;
  257.         }
  258.         if (!strncasecmp((char *) p, "NO PASSWORD", 11)) {
  259.             pw_buf.smb_passwd = NULL;
  260.         } else {
  261.             if(!gethexpwd((char *)p,(char *)smbpwd)) {
  262.                 DEBUG(0, ("Malformed Lanman password entry (non hex chars)\n"));
  263.                 fclose(fp);
  264.                 pw_file_unlock(lockfd);
  265.                 return NULL;
  266.             }
  267.             pw_buf.smb_passwd = smbpwd;
  268.         }
  269.         pw_buf.smb_name = user_name;
  270.         pw_buf.smb_userid = uidval;
  271.         pw_buf.smb_nt_passwd = NULL;
  272.  
  273.         /* Now check if the NT compatible password is
  274.             available. */
  275.         p += 33; /* Move to the first character of the line after
  276.                     the lanman password. */
  277.         if ((linebuf_len >= (PTR_DIFF(p, linebuf) + 33)) && (p[32] == ':')) {
  278.             if (*p != '*' && *p != 'X') {
  279.                 if(gethexpwd((char *)p,(char *)smbntpwd))
  280.                     pw_buf.smb_nt_passwd = smbntpwd;
  281.             }
  282.         }
  283.  
  284.         fclose(fp);
  285.         pw_file_unlock(lockfd);
  286.         DEBUG(5, ("get_smbpwname: returning passwd entry for user %s, uid %d\n",
  287.               user_name, uidval));
  288.         return &pw_buf;
  289.     }
  290.  
  291.     fclose(fp);
  292.     pw_file_unlock(lockfd);
  293.     return NULL;
  294. }
  295. #else
  296.  void smbpass_dummy(void)
  297. {
  298. }                /* To avoid compiler complaints */
  299. #endif
  300.