Adding the same changes to HEAD as were added to BRANCH_1_9_18.
[samba.git] / source3 / passdb / smbpass.c
1 /*
2  * Unix SMB/Netbios implementation. Version 1.9. SMB parameters and setup
3  * Copyright (C) Andrew Tridgell 1992-1998 Modified by Jeremy Allison 1995.
4  * 
5  * This program is free software; you can redistribute it and/or modify it under
6  * the terms of the GNU General Public License as published by the Free
7  * Software Foundation; either version 2 of the License, or (at your option)
8  * any later version.
9  * 
10  * This program is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  * 
15  * You should have received a copy of the GNU General Public License along with
16  * this program; if not, write to the Free Software Foundation, Inc., 675
17  * Mass Ave, Cambridge, MA 02139, USA.
18  */
19
20 #include "includes.h"
21
22 extern int DEBUGLEVEL;
23
24 static int gotalarm;
25 static char s_readbuf[16 * 1024];
26
27 /***************************************************************
28  Signal function to tell us we timed out.
29 ****************************************************************/
30
31 static void gotalarm_sig()
32 {
33   gotalarm = 1;
34 }
35
36 /***************************************************************
37  Lock or unlock a fd for a known lock type. Abandon after waitsecs 
38  seconds.
39 ****************************************************************/
40
41 static int do_pw_lock(int fd, int waitsecs, int type)
42 {
43   struct flock    lock;
44   int             ret;
45
46   gotalarm = 0;
47   signal(SIGALRM, SIGNAL_CAST gotalarm_sig);
48
49   lock.l_type = type;
50   lock.l_whence = SEEK_SET;
51   lock.l_start = 0;
52   lock.l_len = 1;
53   lock.l_pid = 0;
54
55   alarm(5);
56   ret = fcntl(fd, F_SETLKW, &lock);
57   alarm(0);
58   signal(SIGALRM, SIGNAL_CAST SIG_DFL);
59
60   if (gotalarm) {
61     DEBUG(0, ("do_pw_lock: failed to %s SMB passwd file.\n",
62                 type == F_UNLCK ? "unlock" : "lock"));
63     return -1;
64   }
65   return ret;
66 }
67
68 /***************************************************************
69  Lock an fd. Abandon after waitsecs seconds.
70 ****************************************************************/
71
72 int pw_file_lock(int fd, int type, int secs)
73 {
74   if (fd < 0)
75     return (-1);
76   if (do_pw_lock(fd, secs, type)) {
77     return -1;
78   }
79   return fd;
80 }
81
82 /***************************************************************
83  Unlock an fd. Abandon after waitsecs seconds.
84 ****************************************************************/
85
86 int pw_file_unlock(int fd)
87 {
88  return do_pw_lock(fd, 5, F_UNLCK);
89 }
90
91 /***************************************************************
92  Open the smbpasswd file - get ready to enumerate it.
93 ****************************************************************/
94
95 FILE *startsmbpwent(BOOL update)
96 {
97   FILE *fp = NULL;
98   char *pfile = lp_smb_passwd_file();
99
100   if (!*pfile) {
101     DEBUG(0, ("startsmbpwent: No SMB password file set\n"));
102     return (NULL);
103   }
104   DEBUG(10, ("startsmbpwent: opening file %s\n", pfile));
105
106   fp = fopen(pfile, update ? "r+b" : "rb");
107
108   if (fp == NULL) {
109     DEBUG(0, ("startsmbpwent: unable to open file %s\n", pfile));
110     return NULL;
111   }
112
113   /* Set a 16k buffer to do more efficient reads */
114   setvbuf(fp, s_readbuf, _IOFBF, sizeof(s_readbuf));
115
116   if ((pw_file_lock(fileno(fp), F_RDLCK | (update ? F_WRLCK : 0), 5)) < 0) {
117     DEBUG(0, ("startsmbpwent: unable to lock file %s\n", pfile));
118     fclose(fp);
119     return NULL;
120   }
121
122   /* Make sure it is only rw by the owner */
123   chmod(pfile, 0600);
124
125   /* We have a lock on the file. */
126   return fp;
127 }
128
129 /***************************************************************
130  Close the smbpasswd file - end enumeration.
131 ****************************************************************/
132
133 void endsmbpwent(FILE *fp)
134 {
135   pw_file_unlock(fileno(fp));
136   fclose(fp);
137   DEBUG(7, ("endsmbpwent: closed password file.\n"));
138 }
139
140 /*************************************************************
141  Routine to get the next 32 hex characters and turn them
142  into a 16 byte array.
143 **************************************************************/
144
145 static int gethexpwd(char *p, char *pwd)
146 {
147   int i;
148   unsigned char   lonybble, hinybble;
149   char           *hexchars = "0123456789ABCDEF";
150   char           *p1, *p2;
151
152   for (i = 0; i < 32; i += 2) {
153     hinybble = toupper(p[i]);
154     lonybble = toupper(p[i + 1]);
155  
156     p1 = strchr(hexchars, hinybble);
157     p2 = strchr(hexchars, lonybble);
158     if (!p1 || !p2)
159       return (False);
160     hinybble = PTR_DIFF(p1, hexchars);
161     lonybble = PTR_DIFF(p2, hexchars);
162  
163     pwd[i / 2] = (hinybble << 4) | lonybble;
164   }
165   return (True);
166 }
167
168 /*************************************************************************
169  Routine to return the next entry in the smbpasswd file.
170  *************************************************************************/
171
172 struct smb_passwd *getsmbpwent(FILE *fp)
173 {
174   /* Static buffers we will return. */
175   static struct smb_passwd pw_buf;
176   static pstring  user_name;
177   static unsigned char smbpwd[16];
178   static unsigned char smbntpwd[16];
179   char            linebuf[256];
180   unsigned char   c;
181   unsigned char  *p;
182   long            uidval;
183   long            linebuf_len;
184
185   if(fp == NULL) {
186     DEBUG(0,("getsmbpwent: Bad password file pointer.\n"));
187     return NULL;
188   }
189
190   /*
191    * Scan the file, a line at a time and check if the name matches.
192    */
193   while (!feof(fp)) {
194     linebuf[0] = '\0';
195
196     fgets(linebuf, 256, fp);
197     if (ferror(fp)) {
198       return NULL;
199     }
200
201     /*
202      * Check if the string is terminated with a newline - if not
203      * then we must keep reading and discard until we get one.
204      */
205     linebuf_len = strlen(linebuf);
206     if (linebuf[linebuf_len - 1] != '\n') {
207       c = '\0';
208       while (!ferror(fp) && !feof(fp)) {
209         c = fgetc(fp);
210         if (c == '\n')
211           break;
212       }
213     } else
214       linebuf[linebuf_len - 1] = '\0';
215
216 #ifdef DEBUG_PASSWORD
217     DEBUG(100, ("getsmbpwent: got line |%s|\n", linebuf));
218 #endif
219     if ((linebuf[0] == 0) && feof(fp)) {
220       DEBUG(4, ("getsmbpwent: end of file reached\n"));
221       break;
222     }
223     /*
224      * The line we have should be of the form :-
225      * 
226      * username:uid:[32hex bytes]:....other flags presently
227      * ignored....
228      * 
229      * or,
230      *
231      * username:uid:[32hex bytes]:[32hex bytes]:....ignored....
232      *
233      * if Windows NT compatible passwords are also present.
234      */
235
236     if (linebuf[0] == '#' || linebuf[0] == '\0') {
237       DEBUG(6, ("getsmbpwent: skipping comment or blank line\n"));
238       continue;
239     }
240     p = (unsigned char *) strchr(linebuf, ':');
241     if (p == NULL) {
242       DEBUG(0, ("getsmbpwent: malformed password entry (no :)\n"));
243       continue;
244     }
245     /*
246      * As 256 is shorter than a pstring we don't need to check
247      * length here - if this ever changes....
248      */
249     strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
250     user_name[PTR_DIFF(p, linebuf)] = '\0';
251
252     /* Get smb uid. */
253
254     p++;                /* Go past ':' */
255     if (!isdigit(*p)) {
256       DEBUG(0, ("getsmbpwent: malformed password entry (uid not number)\n"));
257       continue;
258     }
259
260     uidval = atoi((char *) p);
261
262     while (*p && isdigit(*p))
263       p++;
264
265     if (*p != ':') {
266       DEBUG(0, ("getsmbpwent: malformed password entry (no : after uid)\n"));
267       continue;
268     }
269
270     pw_buf.smb_name = user_name;
271     pw_buf.smb_userid = uidval;
272
273     /*
274      * Now get the password value - this should be 32 hex digits
275      * which are the ascii representations of a 16 byte string.
276      * Get two at a time and put them into the password.
277      */
278
279     /* Skip the ':' */
280     p++;
281
282     if (*p == '*' || *p == 'X') {
283       /* Password deliberately invalid - end here. */
284       DEBUG(10, ("getsmbpwent: entry invalidated for user %s\n", user_name));
285       pw_buf.smb_nt_passwd = NULL;
286       pw_buf.smb_passwd = NULL;
287       pw_buf.acct_ctrl |= ACB_DISABLED;
288       return &pw_buf;
289     }
290
291     if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
292       DEBUG(0, ("getsmbpwent: malformed password entry (passwd too short)\n"));
293       continue;
294     }
295
296     if (p[32] != ':') {
297       DEBUG(0, ("getsmbpwent: malformed password entry (no terminating :)\n"));
298       continue;
299     }
300
301     if (!strncasecmp((char *) p, "NO PASSWORD", 11)) {
302       pw_buf.smb_passwd = NULL;
303       pw_buf.acct_ctrl |= ACB_PWNOTREQ;
304     } else {
305       if (!gethexpwd((char *)p, (char *)smbpwd)) {
306         DEBUG(0, ("getsmbpwent: Malformed Lanman password entry (non hex chars)\n"));
307         continue;
308       }
309       pw_buf.smb_passwd = smbpwd;
310     }
311
312     /* 
313      * Now check if the NT compatible password is
314      * available.
315      */
316     pw_buf.smb_nt_passwd = NULL;
317
318     p += 33; /* Move to the first character of the line after
319                 the lanman password. */
320     if ((linebuf_len >= (PTR_DIFF(p, linebuf) + 33)) && (p[32] == ':')) {
321       if (*p != '*' && *p != 'X') {
322         if(gethexpwd((char *)p,(char *)smbntpwd))
323           pw_buf.smb_nt_passwd = smbntpwd;
324       }
325       p += 33; /* Move to the first character of the line after
326                   the NT password. */
327     }
328
329     DEBUG(5, ("getsmbpwent: returning passwd entry for user %s, uid %d\n",
330                           user_name, uidval));
331
332     /*
333      * Check if the account type bits have been encoded after the
334      * NT password (in the form [NDHTUWSLXI]).
335      */
336
337     if (*p == '[') {
338       BOOL finished = False;
339
340       pw_buf.acct_ctrl = 0;
341
342       for(p++;*p && !finished; p++) {
343         switch (*p) {
344           case 'N':
345             /* 'N'o password. */
346             pw_buf.acct_ctrl |= ACB_PWNOTREQ;
347             break;
348           case 'D':
349             /* 'D'isabled. */
350             pw_buf.acct_ctrl |= ACB_DISABLED;
351             break;
352           case 'H':
353             /* 'H'omedir required. */
354             pw_buf.acct_ctrl |= ACB_HOMDIRREQ;
355             break;
356           case 'T':
357             /* 'T'emp account. */
358             pw_buf.acct_ctrl |= ACB_TEMPDUP;
359             break;
360           case 'U':
361             /* 'U'ser account (normal). */
362             pw_buf.acct_ctrl |= ACB_NORMAL;
363             break;
364           case 'M':
365             /* 'M'NS logon user account. What is this ? */
366             pw_buf.acct_ctrl |= ACB_MNS;
367             break;
368           case 'W':
369             /* 'W'orkstation account. */
370             pw_buf.acct_ctrl |= ACB_WSTRUST;
371             break;
372           case 'S':
373             /* 'S'erver account. */
374             pw_buf.acct_ctrl |= ACB_SVRTRUST;
375             break;
376           case 'L':
377             /* 'L'ocked account. */
378             pw_buf.acct_ctrl |= ACB_AUTOLOCK;
379             break;
380           case 'X':
381             /* No 'X'piry. */
382             pw_buf.acct_ctrl |= ACB_PWNOEXP;
383             break;
384           case 'I':
385             /* 'I'nterdomain trust account. */
386             pw_buf.acct_ctrl |= ACB_DOMTRUST;
387             break;
388
389           case ':':
390           case '\n':
391           case '\0': 
392           case ']':
393           default:
394             finished = True;
395         }
396       }
397
398       /* Must have some account type set. */
399       if(pw_buf.acct_ctrl == 0)
400         pw_buf.acct_ctrl = ACB_NORMAL;
401
402     } else {
403       /* 'Old' style file. Fake up based on user name. */
404       /*
405        * Currently machine accounts are kept in the same
406        * password file as 'normal accounts'. If this changes
407        * we will have to fix this code. JRA.
408        */
409       if(pw_buf.smb_name[strlen(pw_buf.smb_name) - 1] == '$')
410         pw_buf.acct_ctrl = ACB_WSTRUST;
411       else
412         pw_buf.acct_ctrl = ACB_NORMAL;
413     }
414
415     return &pw_buf;
416   }
417
418   DEBUG(5,("getsmbpwent: end of file reached.\n"));
419   return NULL;
420 }
421
422 /*************************************************************************
423  Routine to search the smbpasswd file for an entry matching the username
424  or user id.  if the name is NULL, then the smb_uid is used instead.
425  *************************************************************************/
426
427 struct smb_passwd *get_smbpwd_entry(char *name, int smb_userid)
428 {
429   struct smb_passwd *pwd = NULL;
430   FILE *fp = NULL;
431
432   if (name != NULL) {
433     DEBUG(10, ("get_smbpwd_entry: search by name: %s\n", name));
434   } else {
435     DEBUG(10, ("get_smbpwd_entry: search by smb_userid: %x\n", smb_userid));
436   }
437
438   /* Open the smbpassword file - not for update. */
439   fp = startsmbpwent(False);
440
441   if (fp == NULL) {
442     DEBUG(0, ("get_smbpwd_entry: unable to open password file.\n"));
443     return NULL;
444   }
445
446   /*
447    * Scan the file, a line at a time and check if the name 
448    * or uid matches.
449    */
450
451   while ((pwd = getsmbpwent(fp)) != NULL) {
452     if (name != NULL) {
453       /* Search is by user name */
454       if (!strequal(pwd->smb_name, name))
455         continue;
456       DEBUG(10, ("get_smbpwd_entry: found by name: %s\n", name));
457       break;
458     } else {
459       /* Search is by user id */
460       if (pwd->smb_userid != smb_userid)
461         continue;
462       DEBUG(10, ("get_smbpwd_entry: found by smb_userid: %x\n", smb_userid));
463       break;
464     }
465   }
466
467   endsmbpwent(fp);
468   return pwd;
469 }
470
471 /************************************************************************
472  Routine to add an entry to the smbpasswd file.
473 *************************************************************************/
474
475 BOOL add_smbpwd_entry(struct smb_passwd *newpwd)
476 {
477   char *pfile = lp_smb_passwd_file();
478   struct smb_passwd *pwd = NULL;
479   FILE *fp = NULL;
480
481   int i;
482   int wr_len;
483
484   int fd;
485   int new_entry_length;
486   char *new_entry;
487   long offpos;
488   unsigned char *p;
489
490   /* Open the smbpassword file - for update. */
491   fp = startsmbpwent(True);
492
493   if (fp == NULL) {
494     DEBUG(0, ("add_smbpwd_entry: unable to open file.\n"));
495     return False;
496   }
497
498   /*
499    * Scan the file, a line at a time and check if the name matches.
500    */
501
502   while ((pwd = getsmbpwent(fp)) != NULL) {
503     if (strequal(newpwd->smb_name, pwd->smb_name)) {
504       DEBUG(0, ("add_smbpwd_entry: entry with name %s already exists\n", pwd->smb_name));
505       endsmbpwent(fp);
506       return False;
507     }
508   }
509
510   /* Ok - entry doesn't exist. We can add it */
511
512   /* Create a new smb passwd entry and set it to the given password. */
513   /* 
514    * The add user write needs to be atomic - so get the fd from 
515    * the fp and do a raw write() call.
516    */
517   fd = fileno(fp);
518
519   if((offpos = lseek(fd, 0, SEEK_END)) == -1) {
520     DEBUG(0, ("add_smbpwd_entry(lseek): Failed to add entry for user %s to file %s. \
521 Error was %s\n", pwd->smb_name, pfile, strerror(errno)));
522     endsmbpwent(fp);
523     return False;
524   }
525
526   new_entry_length = strlen(pwd->smb_name) + 1 + 15 + 1 + 32 + 1 + 32 + 1 + 2;
527
528   if((new_entry = (char *)malloc( new_entry_length )) == NULL) {
529     DEBUG(0, ("add_smbpwd_entry(malloc): Failed to add entry for user %s to file %s. \
530 Error was %s\n", pwd->smb_name, pfile, strerror(errno)));
531     endsmbpwent(fp);
532     return False;
533   }
534
535   sprintf(new_entry, "%s:%u:", pwd->smb_name, (unsigned)pwd->smb_userid);
536   p = (unsigned char *)&new_entry[strlen(new_entry)];
537
538   for( i = 0; i < 16; i++) {
539     sprintf((char *)&p[i*2], "%02X", pwd->smb_passwd[i]);
540   }
541
542   p += 32;
543
544   *p++ = ':';
545
546   for( i = 0; i < 16; i++) {
547     sprintf((char *)&p[i*2], "%02X", pwd->smb_nt_passwd[i]);
548   }
549   p += 32;
550
551   *p++ = ':';
552   sprintf((char *)p,"\n");
553
554 #ifdef DEBUG_PASSWORD
555   DEBUG(100, ("add_smbpwd_entry(%d): new_entry_len %d entry_len %d made line |%s|\n", 
556                              fd, new_entry_length, strlen(new_entry), new_entry));
557 #endif
558
559   if ((wr_len = write(fd, new_entry, strlen(new_entry))) != strlen(new_entry)) {
560     DEBUG(0, ("add_smbpwd_entry(write): %d Failed to add entry for user %s to file %s. \
561 Error was %s\n", wr_len, pwd->smb_name, pfile, strerror(errno)));
562
563     /* Remove the entry we just wrote. */
564     if(ftruncate(fd, offpos) == -1) {
565       DEBUG(0, ("add_smbpwd_entry: ERROR failed to ftruncate file %s. \
566 Error was %s. Password file may be corrupt ! Please examine by hand !\n", 
567              pwd->smb_name, strerror(errno)));
568     }
569
570     endsmbpwent(fp);
571     return False;
572   }
573
574   endsmbpwent(fp);
575   return True;
576 }
577
578 /************************************************************************
579  Routine to search the smbpasswd file for an entry matching the username.
580  and then modify its password entry. We can't use the startsmbpwent()/
581  getsmbpwent()/endsmbpwent() interfaces here as we depend on looking
582  in the actual file to decide how much room we have to write data.
583 ************************************************************************/
584
585 BOOL mod_smbpwd_entry(struct smb_passwd* pwd)
586 {
587   /* Static buffers we will return. */
588   static pstring  user_name;
589
590   char            linebuf[256];
591   char            readbuf[16 * 1024];
592   unsigned char   c;
593   char            ascii_p16[66];
594   unsigned char  *p = NULL;
595   long            linebuf_len = 0;
596   FILE           *fp;
597   int             lockfd;
598   char           *pfile = lp_smb_passwd_file();
599   BOOL found_entry = False;
600
601   long pwd_seekpos = 0;
602
603   int i;
604   int wr_len;
605   int fd;
606
607   if (!*pfile) {
608     DEBUG(0, ("No SMB password file set\n"));
609     return False;
610   }
611   DEBUG(10, ("mod_smbpwd_entry: opening file %s\n", pfile));
612
613   fp = fopen(pfile, "r+");
614
615   if (fp == NULL) {
616     DEBUG(0, ("mod_smbpwd_entry: unable to open file %s\n", pfile));
617     return False;
618   }
619   /* Set a 16k buffer to do more efficient reads */
620   setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
621
622   if ((lockfd = pw_file_lock(fileno(fp), F_RDLCK | F_WRLCK, 5)) < 0) {
623     DEBUG(0, ("mod_smbpwd_entry: unable to lock file %s\n", pfile));
624     fclose(fp);
625     return False;
626   }
627
628   /* Make sure it is only rw by the owner */
629   chmod(pfile, 0600);
630
631   /* We have a write lock on the file. */
632   /*
633    * Scan the file, a line at a time and check if the name matches.
634    */
635   while (!feof(fp)) {
636     pwd_seekpos = ftell(fp);
637
638     linebuf[0] = '\0';
639
640     fgets(linebuf, 256, fp);
641     if (ferror(fp)) {
642       fclose(fp);
643       pw_file_unlock(lockfd);
644       return False;
645     }
646
647     /*
648      * Check if the string is terminated with a newline - if not
649      * then we must keep reading and discard until we get one.
650      */
651     linebuf_len = strlen(linebuf);
652     if (linebuf[linebuf_len - 1] != '\n') {
653       c = '\0';
654       while (!ferror(fp) && !feof(fp)) {
655         c = fgetc(fp);
656         if (c == '\n') {
657           break;
658         }
659       }
660     } else {
661       linebuf[linebuf_len - 1] = '\0';
662     }
663
664 #ifdef DEBUG_PASSWORD
665     DEBUG(100, ("mod_smbpwd_entry: got line |%s|\n", linebuf));
666 #endif
667
668     if ((linebuf[0] == 0) && feof(fp)) {
669       DEBUG(4, ("mod_smbpwd_entry: end of file reached\n"));
670       break;
671     }
672
673     /*
674      * The line we have should be of the form :-
675      * 
676      * username:uid:[32hex bytes]:....other flags presently
677      * ignored....
678      * 
679      * or,
680      *
681      * username:uid:[32hex bytes]:[32hex bytes]:....ignored....
682      *
683      * if Windows NT compatible passwords are also present.
684      */
685
686     if (linebuf[0] == '#' || linebuf[0] == '\0') {
687       DEBUG(6, ("mod_smbpwd_entry: skipping comment or blank line\n"));
688       continue;
689     }
690
691     p = (unsigned char *) strchr(linebuf, ':');
692
693     if (p == NULL) {
694       DEBUG(0, ("mod_smbpwd_entry: malformed password entry (no :)\n"));
695       continue;
696     }
697
698     /*
699      * As 256 is shorter than a pstring we don't need to check
700      * length here - if this ever changes....
701      */
702     strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
703     user_name[PTR_DIFF(p, linebuf)] = '\0';
704     if (strequal(user_name, pwd->smb_name)) {
705       found_entry = True;
706       break;
707     }
708   }
709
710   if (!found_entry) return False;
711
712   DEBUG(6, ("mod_smbpwd_entry: entry exists\n"));
713
714   /* User name matches - get uid and password */
715   p++;          /* Go past ':' */
716
717   if (!isdigit(*p)) {
718     DEBUG(0, ("mod_smbpwd_entry: malformed password entry (uid not number)\n"));
719     fclose(fp);
720     pw_file_unlock(lockfd);
721     return False;
722   }
723
724   while (*p && isdigit(*p))
725     p++;
726   if (*p != ':') {
727     DEBUG(0, ("mod_smbpwd_entry: malformed password entry (no : after uid)\n"));
728     fclose(fp);
729     pw_file_unlock(lockfd);
730     return False;
731   }
732
733   /*
734    * Now get the password value - this should be 32 hex digits
735    * which are the ascii representations of a 16 byte string.
736    * Get two at a time and put them into the password.
737    */
738   p++;
739
740   /* Record exact password position */
741   pwd_seekpos += PTR_DIFF(p, linebuf);
742
743   if (*p == '*' || *p == 'X') {
744     /* Password deliberately invalid - end here. */
745     DEBUG(10, ("get_smbpwd_entry: entry invalidated for user %s\n", user_name));
746     fclose(fp);
747     pw_file_unlock(lockfd);
748     return False;
749   }
750
751   if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
752     DEBUG(0, ("mod_smbpwd_entry: malformed password entry (passwd too short)\n"));
753     fclose(fp);
754     pw_file_unlock(lockfd);
755     return (False);
756   }
757
758   if (p[32] != ':') {
759     DEBUG(0, ("mod_smbpwd_entry: malformed password entry (no terminating :)\n"));
760     fclose(fp);
761     pw_file_unlock(lockfd);
762     return False;
763   }
764
765   if (*p == '*' || *p == 'X') {
766     fclose(fp);
767     pw_file_unlock(lockfd);
768     return False;
769   }
770
771   /* Now check if the NT compatible password is
772      available. */
773   p += 33; /* Move to the first character of the line after
774               the lanman password. */
775   if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
776     DEBUG(0, ("mod_smbpwd_entry: malformed password entry (passwd too short)\n"));
777     fclose(fp);
778     pw_file_unlock(lockfd);
779     return (False);
780   }
781
782   if (p[32] != ':') {
783     DEBUG(0, ("mod_smbpwd_entry: malformed password entry (no terminating :)\n"));
784     fclose(fp);
785     pw_file_unlock(lockfd);
786     return False;
787   }
788
789   /* Entry is correctly formed. */
790
791   /*
792    * Do an atomic write into the file at the position defined by
793    * seekpos.
794    */
795
796   /* The mod user write needs to be atomic - so get the fd from 
797      the fp and do a raw write() call.
798    */
799
800   fd = fileno(fp);
801
802   if (lseek(fd, pwd_seekpos - 1, SEEK_SET) != pwd_seekpos - 1) {
803     DEBUG(0, ("mod_smbpwd_entry: seek fail on file %s.\n", pfile));
804     fclose(fp);
805     pw_file_unlock(lockfd);
806     return False;
807   }
808
809   /* Sanity check - ensure the character is a ':' */
810   if (read(fd, &c, 1) != 1) {
811     DEBUG(0, ("mod_smbpwd_entry: read fail on file %s.\n", pfile));
812     fclose(fp);
813     pw_file_unlock(lockfd);
814     return False;
815   }
816
817   if (c != ':') {
818     DEBUG(0, ("mod_smbpwd_entry: check on passwd file %s failed.\n", pfile));
819     fclose(fp);
820     pw_file_unlock(lockfd);
821     return False;
822   }
823  
824   /* Create the 32 byte representation of the new p16 */
825   for (i = 0; i < 16; i++) {
826     sprintf(&ascii_p16[i*2], "%02X", (uchar) pwd->smb_passwd[i]);
827   }
828
829   /* Add on the NT md4 hash */
830   ascii_p16[32] = ':';
831   wr_len = 65;
832   if (pwd->smb_nt_passwd != NULL) {
833     for (i = 0; i < 16; i++) {
834       sprintf(&ascii_p16[(i*2)+33], "%02X", (uchar) pwd->smb_nt_passwd[i]);
835     }
836   } else {
837     /* No NT hash - write out an 'invalid' string. */
838     strcpy(&ascii_p16[33], "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
839   }
840
841 #ifdef DEBUG_PASSWORD
842   DEBUG(100,("mod_smbpwd_entry: "));
843   dump_data(100, ascii_p16, wr_len);
844 #endif
845
846   if (write(fd, ascii_p16, wr_len) != wr_len) {
847     DEBUG(0, ("mod_smbpwd_entry: write failed in passwd file %s\n", pfile));
848     fclose(fp);
849     pw_file_unlock(lockfd);
850     return False;
851   }
852
853   fclose(fp);
854   pw_file_unlock(lockfd);
855   return True;
856 }