source/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 #ifdef USE_SMBPASS_DB
  23
  24 static int pw_file_lock_depth = 0;
  25 extern int DEBUGLEVEL;
  26
  27 static char s_readbuf[1024];
  28
  29 /***************************************************************
  30  Start to enumerate the smbpasswd list. Returns a void pointer
  31  to ensure no modification outside this module.
  32 ****************************************************************/
  33
  34 static void *startsmbfilepwent(BOOL update)
  35 {
  36         return startfilepwent(lp_smb_passwd_file(), s_readbuf, sizeof(s_readbuf),
  37                               &pw_file_lock_depth, update);
  38 }
  39
  40 /***************************************************************
  41  End enumeration of the smbpasswd list.
  42 ****************************************************************/
  43
  44 static void endsmbfilepwent(void *vp)
  45 {
  46         endfilepwent(vp, &pw_file_lock_depth);
  47 }
  48
  49 /*************************************************************************
  50  Return the current position in the smbpasswd list as an SMB_BIG_UINT.
  51  This must be treated as an opaque token.
  52 *************************************************************************/
  53
  54 static SMB_BIG_UINT getsmbfilepwpos(void *vp)
  55 {
  56         return getfilepwpos(vp);
  57 }
  58
  59 /*************************************************************************
  60  Set the current position in the smbpasswd list from an SMB_BIG_UINT.
  61  This must be treated as an opaque token.
  62 *************************************************************************/
  63
  64 static BOOL setsmbfilepwpos(void *vp, SMB_BIG_UINT tok)
  65 {
  66         return setfilepwpos(vp, tok);
  67 }
  68
  69 /*************************************************************************
  70  Routine to return the next entry in the smbpasswd list.
  71
  72  this function is non-static as it is called (exclusively and only)
  73  from getsamfile21pwent().
  74  *************************************************************************/
  75 struct smb_passwd *getsmbfilepwent(void *vp)
  76 {
  77         /* Static buffers we will return. */
  78         static struct smb_passwd pw_buf;
  79         static pstring  unix_name;
  80         static unsigned char smbpwd[16];
  81         static unsigned char smbntpwd[16];
  82         char            linebuf[256];
  83         char  *p;
  84         int            uidval;
  85         size_t            linebuf_len;
  86
  87         if (vp == NULL)
  88         {
  89                 DEBUG(0,("getsmbfilepwent: Bad password file pointer.\n"));
  90                 return NULL;
  91         }
  92
  93         pwdb_init_smb(&pw_buf);
  94
  95         pw_buf.acct_ctrl = ACB_NORMAL;
  96
  97         /*
  98          * Scan the file, a line at a time.
  99          */
 100         while ((linebuf_len = getfileline(vp, linebuf, sizeof(linebuf))) > 0)
 101         {
 102                 /*
 103                  * The line we have should be of the form :-
 104                  *
 105                  * username:uid:32hex bytes:[Account type]:LCT-12345678....other flags presently
 106                  * ignored....
 107                  *
 108                  * or,
 109                  *
 110                  * username:uid:32hex bytes:32hex bytes:[Account type]:LCT-12345678....ignored....
 111                  *
 112                  * if Windows NT compatible passwords are also present.
 113                  * [Account type] is an ascii encoding of the type of account.
 114                  * LCT-(8 hex digits) is the time_t value of the last change time.
 115                  */
 116
 117                 /*
 118                  * As 256 is shorter than a pstring we don't need to check
 119                  * length here - if this ever changes....
 120                  */
 121                 p = strncpyn(unix_name, linebuf, sizeof(unix_name), ':');
 122
 123                 /* Go past ':' */
 124                 p++;
 125
 126                 /* Get smb uid. */
 127
 128                 p = Atoic( p, &uidval, ":");
 129
 130                 pw_buf.unix_name = unix_name;
 131                 pw_buf.unix_uid = uidval;
 132
 133                 /*
 134                  * Now get the password value - this should be 32 hex digits
 135                  * which are the ascii representations of a 16 byte string.
 136                  * Get two at a time and put them into the password.
 137                  */
 138
 139                 /* Skip the ':' */
 140                 p++;
 141
 142                 if (linebuf_len < (PTR_DIFF(p, linebuf) + 33))
 143                 {
 144                         DEBUG(0, ("getsmbfilepwent: malformed password entry (passwd too short)\n"));
 145                         continue;
 146                 }
 147
 148                 if (p[32] != ':')
 149                 {
 150                         DEBUG(0, ("getsmbfilepwent: malformed password entry (no terminating :)\n"));
 151                         continue;
 152                 }
 153
 154                 if (!strncasecmp( p, "NO PASSWORD", 11))
 155                 {
 156                         pw_buf.smb_passwd = NULL;
 157                         pw_buf.acct_ctrl |= ACB_PWNOTREQ;
 158                 }
 159                 else
 160                 {
 161                         if (!pwdb_gethexpwd(p, (char *)smbpwd, NULL))
 162                         {
 163                                 DEBUG(0, ("getsmbfilepwent: Malformed Lanman password entry (non hex chars)\n"));
 164                                 continue;
 165                         }
 166                         pw_buf.smb_passwd = smbpwd;
 167                 }
 168
 169                 /*
 170                  * Now check if the NT compatible password is
 171                  * available.
 172                  */
 173                 pw_buf.smb_nt_passwd = NULL;
 174
 175                 /* Move to the first character of the line after the lanman password. */
 176                 p += 33;
 177                 if ((linebuf_len >= (PTR_DIFF(p, linebuf) + 33)) && (p[32] == ':'))
 178                 {
 179                         if (*p != '*' && *p != 'X')
 180                         {
 181                                 if(pwdb_gethexpwd(p,(char *)smbntpwd, NULL))
 182                                 {
 183                                         pw_buf.smb_nt_passwd = smbntpwd;
 184                                 }
 185                         }
 186                         /* Move to the first character of the line after the NT password. */
 187                         p += 33;
 188                 }
 189
 190                 DEBUG(5,("getsmbfilepwent: returning passwd entry for unix user %s, unix uid %d\n",
 191                           unix_name, uidval));
 192
 193                 if (*p == '[')
 194                 {
 195                         pw_buf.acct_ctrl = pwdb_decode_acct_ctrl((char*)p);
 196
 197                         /* Must have some account type set. */
 198                         if (pw_buf.acct_ctrl == 0)
 199                         {
 200                                 pw_buf.acct_ctrl = ACB_NORMAL;
 201                         }
 202
 203                         /* Now try and get the last change time. */
 204                         while (*p != ']' && *p != ':')
 205                         {
 206                                 p++;
 207                         }
 208                         if (*p == ']')
 209                         {
 210                                 p++;
 211                         }
 212                         if (*p == ':')
 213                         {
 214                                 p++;
 215                                 pw_buf.pass_last_set_time = pwdb_get_last_set_time(p);
 216                         }
 217                 }
 218                 else
 219                 {
 220                         /* 'Old' style file. Fake up based on user name. */
 221                         /*
 222                          * Currently trust accounts are kept in the same
 223                          * password file as 'normal accounts'. If this changes
 224                          * we will have to fix this code. JRA.
 225                          */
 226                         if (pw_buf.unix_name[strlen(pw_buf.unix_name) - 1] == '$')
 227                         {
 228                                 pw_buf.acct_ctrl &= ~ACB_NORMAL;
 229                                 pw_buf.acct_ctrl |= ACB_WSTRUST;
 230                         }
 231                 }
 232
 233                 if (*p == '*' || *p == 'X')
 234                 {
 235                         /* Password deliberately invalid - end here. */
 236                         DEBUG(10, ("getsmbfilepwent: entry invalidated for unix user %s\n", unix_name));
 237                         pw_buf.smb_nt_passwd = NULL;
 238                         pw_buf.smb_passwd = NULL;
 239                         pw_buf.acct_ctrl |= ACB_DISABLED;
 240                 }
 241
 242                 DEBUG(6,("unixuser:%s uid:%d acb:%x\n",
 243                           pw_buf.unix_name, pw_buf.unix_uid, pw_buf.acct_ctrl));
 244
 245                 return &pw_buf;
 246         }
 247
 248         DEBUG(5,("getsmbfilepwent: end of file reached.\n"));
 249         return NULL;
 250 }
 251
 252 /************************************************************************
 253  Routine to add an entry to the smbpasswd file.
 254 *************************************************************************/
 255
 256 static BOOL add_smbfilepwd_entry(struct smb_passwd *newpwd)
 257 {
 258   char *pfile = lp_smb_passwd_file();
 259   struct smb_passwd *pwd = NULL;
 260   FILE *fp = NULL;
 261
 262   int i;
 263   int wr_len;
 264
 265   int fd;
 266   int new_entry_length;
 267   char *new_entry;
 268   SMB_OFF_T offpos;
 269   char *p;
 270
 271   /* Open the smbpassword file - for update. */
 272   fp = startsmbfilepwent(True);
 273
 274   if (fp == NULL) {
 275     DEBUG(0, ("add_smbfilepwd_entry: unable to open file.\n"));
 276     return False;
 277   }
 278
 279   /*
 280    * Scan the file, a line at a time and check if the name matches.
 281    */
 282
 283   while ((pwd = getsmbfilepwent(fp)) != NULL) {
 284     if (strequal(newpwd->unix_name, pwd->unix_name)) {
 285       DEBUG(0, ("add_smbfilepwd_entry: entry with unix name %s already exists\n", pwd->unix_name));
 286       endsmbfilepwent(fp);
 287       return False;
 288     }
 289   }
 290
 291   /* Ok - entry doesn't exist. We can add it */
 292
 293   /* Create a new smb passwd entry and set it to the given password. */
 294   /*
 295    * The add user write needs to be atomic - so get the fd from
 296    * the fp and do a raw write() call.
 297    */
 298   fd = fileno(fp);
 299
 300   if((offpos = sys_lseek(fd, 0, SEEK_END)) == -1) {
 301     DEBUG(0, ("add_smbfilepwd_entry(sys_lseek): Failed to add entry for user %s to file %s. \
 302 Error was %s\n", newpwd->unix_name, pfile, strerror(errno)));
 303     endsmbfilepwent(fp);
 304     return False;
 305   }
 306
 307   new_entry_length = strlen(newpwd->unix_name) + 1 + 15 + 1 + 32 + 1 + 32 + 1 + NEW_PW_FORMAT_SPACE_PADDED_LEN + 1 + 13 + 2;
 308
 309   if((new_entry = (char *)malloc( new_entry_length )) == NULL) {
 310     DEBUG(0, ("add_smbfilepwd_entry(malloc): Failed to add entry for user %s to file %s. \
 311 Error was %s\n", newpwd->unix_name, pfile, strerror(errno)));
 312     endsmbfilepwent(fp);
 313     return False;
 314   }
 315
 316   slprintf(new_entry, new_entry_length - 1, "%s:%u:", newpwd->unix_name, (unsigned)newpwd->unix_uid);
 317   p = &new_entry[strlen(new_entry)];
 318
 319   if(newpwd->smb_passwd != NULL) {
 320     for( i = 0; i < 16; i++) {
 321       slprintf((char *)&p[i*2], new_entry_length - (p - new_entry) - 1, "%02X", newpwd->smb_passwd[i]);
 322     }
 323   } else {
 324     i=0;
 325     if(newpwd->acct_ctrl & ACB_PWNOTREQ)
 326       safe_strcpy((char *)p, "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX", new_entry_length - 1 - (p - new_entry));
 327     else
 328       safe_strcpy((char *)p, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", new_entry_length - 1 - (p - new_entry));
 329   }
 330
 331   p += 32;
 332
 333   *p++ = ':';
 334
 335   if(newpwd->smb_nt_passwd != NULL) {
 336     for( i = 0; i < 16; i++) {
 337       slprintf((char *)&p[i*2], new_entry_length - 1 - (p - new_entry), "%02X", newpwd->smb_nt_passwd[i]);
 338     }
 339   } else {
 340     if(newpwd->acct_ctrl & ACB_PWNOTREQ)
 341       safe_strcpy((char *)p, "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX", new_entry_length - 1 - (p - new_entry));
 342     else
 343       safe_strcpy((char *)p, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", new_entry_length - 1 - (p - new_entry));
 344   }
 345
 346   p += 32;
 347
 348   *p++ = ':';
 349
 350   /* Add the account encoding and the last change time. */
 351   slprintf((char *)p, new_entry_length - 1 - (p - new_entry),  "%s:LCT-%08X:\n",
 352            pwdb_encode_acct_ctrl(newpwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN), (uint32)time(NULL));
 353
 354 #ifdef DEBUG_PASSWORD
 355   DEBUG(100, ("add_smbfilepwd_entry(%d): new_entry_len %d entry_len %d made line |%s|",
 356                              fd, new_entry_length, strlen(new_entry), new_entry));
 357 #endif
 358
 359   if ((wr_len = write(fd, new_entry, strlen(new_entry))) != strlen(new_entry)) {
 360     DEBUG(0, ("add_smbfilepwd_entry(write): %d Failed to add entry for user %s to file %s. \
 361 Error was %s\n", wr_len, newpwd->unix_name, pfile, strerror(errno)));
 362
 363     /* Remove the entry we just wrote. */
 364     if(sys_ftruncate(fd, offpos) == -1) {
 365       DEBUG(0, ("add_smbfilepwd_entry: ERROR failed to ftruncate file %s. \
 366 Error was %s. Password file may be corrupt ! Please examine by hand !\n",
 367              newpwd->unix_name, strerror(errno)));
 368     }
 369
 370     endsmbfilepwent(fp);
 371     free(new_entry);
 372     return False;
 373   }
 374
 375   free(new_entry);
 376   endsmbfilepwent(fp);
 377   return True;
 378 }
 379
 380 /************************************************************************
 381  Routine to search the smbpasswd file for an entry matching the username.
 382  and then modify its password entry. We can't use the startsmbpwent()/
 383  getsmbpwent()/endsmbpwent() interfaces here as we depend on looking
 384  in the actual file to decide how much room we have to write data.
 385  override = False, normal
 386  override = True, override XXXXXXXX'd out password or NO PASS
 387 ************************************************************************/
 388
 389 static BOOL mod_smbfilepwd_entry(struct smb_passwd* pwd, BOOL override)
 390 {
 391   /* Static buffers we will return. */
 392   static pstring  unix_name;
 393
 394   char            linebuf[256];
 395   char            readbuf[1024];
 396   unsigned char   c;
 397   fstring         ascii_p16;
 398   fstring         encode_bits;
 399   unsigned char  *p = NULL;
 400   size_t            linebuf_len = 0;
 401   FILE           *fp;
 402   int             lockfd;
 403   char           *pfile = lp_smb_passwd_file();
 404   BOOL found_entry = False;
 405   BOOL got_pass_last_set_time = False;
 406
 407   SMB_OFF_T pwd_seekpos = 0;
 408
 409   int i;
 410   int wr_len;
 411   int fd;
 412
 413 #ifdef DEBUG_PASSWORD
 414         DEBUG(100,("mod_smbfilepwd_entry: password entries\n"));
 415         if (pwd->smb_passwd != NULL)
 416         {
 417                 dump_data(100, pwd->smb_passwd, 16);
 418         }
 419         if (pwd->smb_nt_passwd != NULL)
 420         {
 421                 dump_data(100, pwd->smb_nt_passwd, 16);
 422         }
 423 #endif
 424   if (!*pfile) {
 425     DEBUG(0, ("No SMB password file set\n"));
 426     return False;
 427   }
 428   DEBUG(10, ("mod_smbfilepwd_entry: opening file %s\n", pfile));
 429
 430   fp = sys_fopen(pfile, "r+");
 431
 432   if (fp == NULL) {
 433     DEBUG(0, ("mod_smbfilepwd_entry: unable to open file %s\n", pfile));
 434     return False;
 435   }
 436   /* Set a buffer to do more efficient reads */
 437   setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
 438
 439   lockfd = fileno(fp);
 440
 441   if (!file_lock(lockfd, F_WRLCK, 5, &pw_file_lock_depth)) {
 442     DEBUG(0, ("mod_smbfilepwd_entry: unable to lock file %s\n", pfile));
 443     fclose(fp);
 444     return False;
 445   }
 446
 447   /* Make sure it is only rw by the owner */
 448   chmod(pfile, 0600);
 449
 450   /* We have a write lock on the file. */
 451   /*
 452    * Scan the file, a line at a time and check if the name matches.
 453    */
 454   while (!feof(fp)) {
 455     pwd_seekpos = sys_ftell(fp);
 456
 457     linebuf[0] = '\0';
 458
 459     fgets(linebuf, sizeof(linebuf), fp);
 460     if (ferror(fp)) {
 461       file_unlock(lockfd, &pw_file_lock_depth);
 462       fclose(fp);
 463       return False;
 464     }
 465
 466     /*
 467      * Check if the string is terminated with a newline - if not
 468      * then we must keep reading and discard until we get one.
 469      */
 470     linebuf_len = strlen(linebuf);
 471     if (linebuf[linebuf_len - 1] != '\n') {
 472       c = '\0';
 473       while (!ferror(fp) && !feof(fp)) {
 474         c = fgetc(fp);
 475         if (c == '\n') {
 476           break;
 477         }
 478       }
 479     } else {
 480       linebuf[linebuf_len - 1] = '\0';
 481     }
 482
 483 #ifdef DEBUG_PASSWORD
 484     DEBUG(100, ("mod_smbfilepwd_entry: got line |%s|\n", linebuf));
 485 #endif
 486
 487     if ((linebuf[0] == 0) && feof(fp)) {
 488       DEBUG(4, ("mod_smbfilepwd_entry: end of file reached\n"));
 489       break;
 490     }
 491
 492     /*
 493      * The line we have should be of the form :-
 494      *
 495      * username:uid:[32hex bytes]:....other flags presently
 496      * ignored....
 497      *
 498      * or,
 499      *
 500      * username:uid:[32hex bytes]:[32hex bytes]:[attributes]:LCT-XXXXXXXX:...ignored.
 501      *
 502      * if Windows NT compatible passwords are also present.
 503      */
 504
 505     if (linebuf[0] == '#' || linebuf[0] == '\0') {
 506       DEBUG(6, ("mod_smbfilepwd_entry: skipping comment or blank line\n"));
 507       continue;
 508     }
 509
 510     p = (unsigned char *) strchr(linebuf, ':');
 511
 512     if (p == NULL) {
 513       DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no :)\n"));
 514       continue;
 515     }
 516
 517     /*
 518      * As 256 is shorter than a pstring we don't need to check
 519      * length here - if this ever changes....
 520      */
 521     strncpy(unix_name, linebuf, PTR_DIFF(p, linebuf));
 522     unix_name[PTR_DIFF(p, linebuf)] = '\0';
 523     if (strequal(unix_name, pwd->unix_name)) {
 524       found_entry = True;
 525       break;
 526     }
 527   }
 528
 529   if (!found_entry) {
 530     file_unlock(lockfd, &pw_file_lock_depth);
 531     fclose(fp);
 532     return False;
 533   }
 534
 535   DEBUG(6, ("mod_smbfilepwd_entry: entry exists\n"));
 536
 537   /* User name matches - get uid and password */
 538   p++;          /* Go past ':' */
 539
 540   if (!isdigit(*p)) {
 541     DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (uid not number)\n"));
 542     file_unlock(lockfd, &pw_file_lock_depth);
 543     fclose(fp);
 544     return False;
 545   }
 546
 547   while (*p && isdigit(*p))
 548     p++;
 549   if (*p != ':') {
 550     DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no : after uid)\n"));
 551     file_unlock(lockfd, &pw_file_lock_depth);
 552     fclose(fp);
 553     return False;
 554   }
 555
 556   /*
 557    * Now get the password value - this should be 32 hex digits
 558    * which are the ascii representations of a 16 byte string.
 559    * Get two at a time and put them into the password.
 560    */
 561   p++;
 562
 563   /* Record exact password position */
 564   pwd_seekpos += PTR_DIFF(p, linebuf);
 565
 566   if (!override && (*p == '*' || *p == 'X')) {
 567     /* Password deliberately invalid - end here. */
 568     DEBUG(10, ("mod_smbfilepwd_entry: entry invalidated for unix user %s\n", unix_name));
 569     file_unlock(lockfd, &pw_file_lock_depth);
 570     fclose(fp);
 571     return False;
 572   }
 573
 574   if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
 575     DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (passwd too short)\n"));
 576     file_unlock(lockfd,&pw_file_lock_depth);
 577     fclose(fp);
 578     return (False);
 579   }
 580
 581   if (p[32] != ':') {
 582     DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no terminating :)\n"));
 583     file_unlock(lockfd,&pw_file_lock_depth);
 584     fclose(fp);
 585     return False;
 586   }
 587
 588   if (!override && (*p == '*' || *p == 'X')) {
 589     file_unlock(lockfd,&pw_file_lock_depth);
 590     fclose(fp);
 591     return False;
 592   }
 593
 594   /* Now check if the NT compatible password is
 595      available. */
 596   p += 33; /* Move to the first character of the line after
 597               the lanman password. */
 598   if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
 599     DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (passwd too short)\n"));
 600     file_unlock(lockfd,&pw_file_lock_depth);
 601     fclose(fp);
 602     return (False);
 603   }
 604
 605   if (p[32] != ':') {
 606     DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no terminating :)\n"));
 607     file_unlock(lockfd,&pw_file_lock_depth);
 608     fclose(fp);
 609     return False;
 610   }
 611
 612   /*
 613    * Now check if the account info and the password last
 614    * change time is available.
 615    */
 616   p += 33; /* Move to the first character of the line after
 617               the NT password. */
 618
 619   /*
 620    * If both NT and lanman passwords are provided - reset password
 621    * not required flag.
 622    */
 623
 624   if(pwd->smb_passwd != NULL || pwd->smb_nt_passwd != NULL) {
 625     /* Reqiure password in the future (should ACB_DISABLED also be reset?) */
 626     pwd->acct_ctrl &= ~(ACB_PWNOTREQ);
 627   }
 628
 629   if (*p == '[') {
 630
 631     i = 0;
 632     encode_bits[i++] = *p++;
 633     while((linebuf_len > PTR_DIFF(p, linebuf)) && (*p != ']'))
 634       encode_bits[i++] = *p++;
 635
 636     encode_bits[i++] = ']';
 637     encode_bits[i++] = '\0';
 638
 639     if(i == NEW_PW_FORMAT_SPACE_PADDED_LEN) {
 640       /*
 641        * We are using a new format, space padded
 642        * acct ctrl field. Encode the given acct ctrl
 643        * bits into it.
 644        */
 645       fstrcpy(encode_bits, pwdb_encode_acct_ctrl(pwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN));
 646     } else {
 647       /*
 648        * If using the old format and the ACB_DISABLED or
 649        * ACB_PWNOTREQ are set then set the lanman and NT passwords to NULL
 650        * here as we have no space to encode the change.
 651        */
 652       if(pwd->acct_ctrl & (ACB_DISABLED|ACB_PWNOTREQ)) {
 653         pwd->smb_passwd = NULL;
 654         pwd->smb_nt_passwd = NULL;
 655       }
 656     }
 657
 658     /* Go past the ']' */
 659     if(linebuf_len > PTR_DIFF(p, linebuf))
 660       p++;
 661
 662     if((linebuf_len > PTR_DIFF(p, linebuf)) && (*p == ':')) {
 663       p++;
 664
 665       /* We should be pointing at the LCT entry. */
 666       if((linebuf_len > (PTR_DIFF(p, linebuf) + 13)) && (StrnCaseCmp((char *)p, "LCT-", 4) == 0)) {
 667
 668         p += 4;
 669         for(i = 0; i < 8; i++) {
 670           if(p[i] == '\0' || !isxdigit(p[i]))
 671             break;
 672         }
 673         if(i == 8) {
 674           /*
 675            * p points at 8 characters of hex digits -
 676            * read into a time_t as the seconds since
 677            * 1970 that the password was last changed.
 678            */
 679           got_pass_last_set_time = True;
 680         } /* i == 8 */
 681       } /* *p && StrnCaseCmp() */
 682     } /* p == ':' */
 683   } /* p == '[' */
 684
 685   /* Entry is correctly formed. */
 686
 687   /* Create the 32 byte representation of the new p16 */
 688   if(pwd->smb_passwd != NULL) {
 689     for (i = 0; i < 16; i++) {
 690       slprintf(&ascii_p16[i*2], sizeof(fstring) - 1, "%02X", (uchar) pwd->smb_passwd[i]);
 691     }
 692   } else {
 693     if(pwd->acct_ctrl & ACB_PWNOTREQ)
 694       fstrcpy(ascii_p16, "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX");
 695     else
 696       fstrcpy(ascii_p16, "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
 697   }
 698
 699   /* Add on the NT md4 hash */
 700   ascii_p16[32] = ':';
 701   wr_len = 66;
 702   if (pwd->smb_nt_passwd != NULL) {
 703     for (i = 0; i < 16; i++) {
 704       slprintf(&ascii_p16[(i*2)+33], sizeof(fstring) - 1, "%02X", (uchar) pwd->smb_nt_passwd[i]);
 705     }
 706   } else {
 707     if(pwd->acct_ctrl & ACB_PWNOTREQ)
 708       fstrcpy(&ascii_p16[33], "NO PASSWORDXXXXXXXXXXXXXXXXXXXXX");
 709     else
 710       fstrcpy(&ascii_p16[33], "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
 711   }
 712   ascii_p16[65] = ':';
 713   ascii_p16[66] = '\0'; /* null-terminate the string so that strlen works */
 714
 715   /* Add on the account info bits and the time of last
 716      password change. */
 717
 718   pwd->pass_last_set_time = time(NULL);
 719
 720   if(got_pass_last_set_time) {
 721     slprintf(&ascii_p16[strlen(ascii_p16)],
 722              sizeof(ascii_p16)-(strlen(ascii_p16)+1),
 723              "%s:LCT-%08X:",
 724                      encode_bits, (uint32)pwd->pass_last_set_time );
 725     wr_len = strlen(ascii_p16);
 726   }
 727
 728 #ifdef DEBUG_PASSWORD
 729   DEBUG(100,("mod_smbfilepwd_entry: "));
 730   dump_data(100, ascii_p16, wr_len);
 731 #endif
 732
 733   if(wr_len > sizeof(linebuf)) {
 734     DEBUG(0, ("mod_smbfilepwd_entry: line to write (%d) is too long.\n", wr_len+1));
 735     file_unlock(lockfd,&pw_file_lock_depth);
 736     fclose(fp);
 737     return (False);
 738   }
 739
 740   /*
 741    * Do an atomic write into the file at the position defined by
 742    * seekpos.
 743    */
 744
 745   /* The mod user write needs to be atomic - so get the fd from
 746      the fp and do a raw write() call.
 747    */
 748
 749   fd = fileno(fp);
 750
 751   if (sys_lseek(fd, pwd_seekpos - 1, SEEK_SET) != pwd_seekpos - 1) {
 752     DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
 753     file_unlock(lockfd,&pw_file_lock_depth);
 754     fclose(fp);
 755     return False;
 756   }
 757
 758   /* Sanity check - ensure the areas we are writing are framed by ':' */
 759   if (read(fd, linebuf, wr_len+1) != wr_len+1) {
 760     DEBUG(0, ("mod_smbfilepwd_entry: read fail on file %s.\n", pfile));
 761     file_unlock(lockfd,&pw_file_lock_depth);
 762     fclose(fp);
 763     return False;
 764   }
 765
 766   if ((linebuf[0] != ':') || (linebuf[wr_len] != ':'))  {
 767     DEBUG(0, ("mod_smbfilepwd_entry: check on passwd file %s failed.\n", pfile));
 768     file_unlock(lockfd,&pw_file_lock_depth);
 769     fclose(fp);
 770     return False;
 771   }
 772
 773   if (sys_lseek(fd, pwd_seekpos, SEEK_SET) != pwd_seekpos) {
 774     DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
 775     file_unlock(lockfd,&pw_file_lock_depth);
 776     fclose(fp);
 777     return False;
 778   }
 779
 780   if (write(fd, ascii_p16, wr_len) != wr_len) {
 781     DEBUG(0, ("mod_smbfilepwd_entry: write failed in passwd file %s\n", pfile));
 782     file_unlock(lockfd,&pw_file_lock_depth);
 783     fclose(fp);
 784     return False;
 785   }
 786
 787   file_unlock(lockfd,&pw_file_lock_depth);
 788   fclose(fp);
 789   return True;
 790 }
 791
 792 static struct smb_passdb_ops file_ops = {
 793   startsmbfilepwent,
 794   endsmbfilepwent,
 795   getsmbfilepwpos,
 796   setsmbfilepwpos,
 797   iterate_getsmbpwnam,          /* In passdb.c */
 798   iterate_getsmbpwuid,          /* In passdb.c */
 799   getsmbfilepwent,
 800   add_smbfilepwd_entry,
 801   mod_smbfilepwd_entry
 802 };
 803
 804 struct smb_passdb_ops *file_initialise_password_db(void)
 805 {
 806   return &file_ops;
 807 }
 808
 809 #else
 810  /* Do *NOT* make this function static. It breaks the compile on gcc. JRA */
 811  void smbpass_dummy_function(void) { } /* stop some compilers complaining */
 812 #endif /* USE_SMBPASS_DB */