source3/passdb/pdb_smbpasswd.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * SMB parameters and setup
   4  * Copyright (C) Andrew Tridgell       1992-1998
   5  * Modified by Jeremy Allison          1995.
   6  * Modified by Gerald (Jerry) Carter   2000-2001,2003
   7  * Modified by Andrew Bartlett         2002.
   8  *
   9  * This program is free software; you can redistribute it and/or modify it under
  10  * the terms of the GNU General Public License as published by the Free
  11  * Software Foundation; either version 3 of the License, or (at your option)
  12  * any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful, but WITHOUT
  15  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17  * more details.
  18  *
  19  * You should have received a copy of the GNU General Public License along with
  20  * this program; if not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "includes.h"
  24 #include "passdb.h"
  25 #include "system/passwd.h"
  26 #include "system/filesys.h"
  27 #include "../librpc/gen_ndr/samr.h"
  28 #include "../libcli/security/security.h"
  29
  30 #undef DBGC_CLASS
  31 #define DBGC_CLASS DBGC_PASSDB
  32
  33 /*
  34    smb_passwd is analogous to sam_passwd used everywhere
  35    else.  However, smb_passwd is limited to the information
  36    stored by an smbpasswd entry
  37  */
  38
  39 struct smb_passwd
  40 {
  41         uint32 smb_userid;        /* this is actually the unix uid_t */
  42         const char *smb_name;     /* username string */
  43
  44         const unsigned char *smb_passwd;    /* Null if no password */
  45         const unsigned char *smb_nt_passwd; /* Null if no password */
  46
  47         uint16_t acct_ctrl;             /* account info (ACB_xxxx bit-mask) */
  48         time_t pass_last_set_time;    /* password last set time */
  49 };
  50
  51 struct smbpasswd_privates
  52 {
  53         /* used for maintain locks on the smbpasswd file */
  54         int     pw_file_lock_depth;
  55
  56         /* Global File pointer */
  57         FILE    *pw_file;
  58
  59         /* formerly static variables */
  60         struct smb_passwd pw_buf;
  61         fstring user_name;
  62         unsigned char smbpwd[16];
  63         unsigned char smbntpwd[16];
  64
  65         /* retrive-once info */
  66         const char *smbpasswd_file;
  67 };
  68
  69 enum pwf_access_type { PWF_READ, PWF_UPDATE, PWF_CREATE };
  70
  71 static SIG_ATOMIC_T gotalarm;
  72
  73 /***************************************************************
  74  Signal function to tell us we timed out.
  75 ****************************************************************/
  76
  77 static void gotalarm_sig(int signum)
  78 {
  79         gotalarm = 1;
  80 }
  81
  82 /***************************************************************
  83  Lock or unlock a fd for a known lock type. Abandon after waitsecs
  84  seconds.
  85 ****************************************************************/
  86
  87 static bool do_file_lock(int fd, int waitsecs, int type)
  88 {
  89         SMB_STRUCT_FLOCK lock;
  90         int             ret;
  91         void (*oldsig_handler)(int);
  92
  93         gotalarm = 0;
  94         oldsig_handler = CatchSignal(SIGALRM, gotalarm_sig);
  95
  96         lock.l_type = type;
  97         lock.l_whence = SEEK_SET;
  98         lock.l_start = 0;
  99         lock.l_len = 1;
 100         lock.l_pid = 0;
 101
 102         alarm(waitsecs);
 103         /* Note we must *NOT* use sys_fcntl here ! JRA */
 104         ret = fcntl(fd, SMB_F_SETLKW, &lock);
 105         alarm(0);
 106         CatchSignal(SIGALRM, oldsig_handler);
 107
 108         if (gotalarm && ret == -1) {
 109                 DEBUG(0, ("do_file_lock: failed to %s file.\n",
 110                         type == F_UNLCK ? "unlock" : "lock"));
 111                 return False;
 112         }
 113
 114         return (ret == 0);
 115 }
 116
 117 /***************************************************************
 118  Lock an fd. Abandon after waitsecs seconds.
 119 ****************************************************************/
 120
 121 static bool pw_file_lock(int fd, int type, int secs, int *plock_depth)
 122 {
 123         if (fd < 0) {
 124                 return False;
 125         }
 126
 127         if(*plock_depth == 0) {
 128                 if (!do_file_lock(fd, secs, type)) {
 129                         DEBUG(10,("pw_file_lock: locking file failed, error = %s.\n",
 130                                 strerror(errno)));
 131                         return False;
 132                 }
 133         }
 134
 135         (*plock_depth)++;
 136
 137         return True;
 138 }
 139
 140 /***************************************************************
 141  Unlock an fd. Abandon after waitsecs seconds.
 142 ****************************************************************/
 143
 144 static bool pw_file_unlock(int fd, int *plock_depth)
 145 {
 146         bool ret=True;
 147
 148         if (fd == 0 || *plock_depth == 0) {
 149                 return True;
 150         }
 151
 152         if(*plock_depth == 1) {
 153                 ret = do_file_lock(fd, 5, F_UNLCK);
 154         }
 155
 156         if (*plock_depth > 0) {
 157                 (*plock_depth)--;
 158         }
 159
 160         if(!ret) {
 161                 DEBUG(10,("pw_file_unlock: unlocking file failed, error = %s.\n",
 162                         strerror(errno)));
 163         }
 164         return ret;
 165 }
 166
 167 /**************************************************************
 168  Intialize a smb_passwd struct
 169  *************************************************************/
 170
 171 static void pdb_init_smb(struct smb_passwd *user)
 172 {
 173         if (user == NULL)
 174                 return;
 175         ZERO_STRUCTP (user);
 176
 177         user->pass_last_set_time = (time_t)0;
 178 }
 179
 180 /***************************************************************
 181  Internal fn to enumerate the smbpasswd list. Returns a void pointer
 182  to ensure no modification outside this module. Checks for atomic
 183  rename of smbpasswd file on update or create once the lock has
 184  been granted to prevent race conditions. JRA.
 185 ****************************************************************/
 186
 187 static FILE *startsmbfilepwent(const char *pfile, enum pwf_access_type type, int *lock_depth)
 188 {
 189         FILE *fp = NULL;
 190         const char *open_mode = NULL;
 191         int race_loop = 0;
 192         int lock_type = F_RDLCK;
 193
 194         if (!*pfile) {
 195                 DEBUG(0, ("startsmbfilepwent: No SMB password file set\n"));
 196                 return (NULL);
 197         }
 198
 199         switch(type) {
 200                 case PWF_READ:
 201                         open_mode = "rb";
 202                         lock_type = F_RDLCK;
 203                         break;
 204                 case PWF_UPDATE:
 205                         open_mode = "r+b";
 206                         lock_type = F_WRLCK;
 207                         break;
 208                 case PWF_CREATE:
 209                         /*
 210                          * Ensure atomic file creation.
 211                          */
 212                         {
 213                                 int i, fd = -1;
 214
 215                                 for(i = 0; i < 5; i++) {
 216                                         if((fd = sys_open(pfile, O_CREAT|O_TRUNC|O_EXCL|O_RDWR, 0600))!=-1) {
 217                                                 break;
 218                                         }
 219                                         sys_usleep(200); /* Spin, spin... */
 220                                 }
 221                                 if(fd == -1) {
 222                                         DEBUG(0,("startsmbfilepwent_internal: too many race conditions \
 223 creating file %s\n", pfile));
 224                                         return NULL;
 225                                 }
 226                                 close(fd);
 227                                 open_mode = "r+b";
 228                                 lock_type = F_WRLCK;
 229                                 break;
 230                         }
 231                 default:
 232                         DEBUG(10, ("Invalid open mode: %d\n", type));
 233                         return NULL;
 234         }
 235
 236         for(race_loop = 0; race_loop < 5; race_loop++) {
 237                 DEBUG(10, ("startsmbfilepwent_internal: opening file %s\n", pfile));
 238
 239                 if((fp = sys_fopen(pfile, open_mode)) == NULL) {
 240
 241                         /*
 242                          * If smbpasswd file doesn't exist, then create new one. This helps to avoid
 243                          * confusing error msg when adding user account first time.
 244                          */
 245                         if (errno == ENOENT) {
 246                                 if ((fp = sys_fopen(pfile, "a+")) != NULL) {
 247                                         DEBUG(0, ("startsmbfilepwent_internal: file %s did not \
 248 exist. File successfully created.\n", pfile));
 249                                 } else {
 250                                         DEBUG(0, ("startsmbfilepwent_internal: file %s did not \
 251 exist. Couldn't create new one. Error was: %s",
 252                                         pfile, strerror(errno)));
 253                                         return NULL;
 254                                 }
 255                         } else {
 256                                 DEBUG(0, ("startsmbfilepwent_internal: unable to open file %s. \
 257 Error was: %s\n", pfile, strerror(errno)));
 258                                 return NULL;
 259                         }
 260                 }
 261
 262                 if (!pw_file_lock(fileno(fp), lock_type, 5, lock_depth)) {
 263                         DEBUG(0, ("startsmbfilepwent_internal: unable to lock file %s. \
 264 Error was %s\n", pfile, strerror(errno) ));
 265                         fclose(fp);
 266                         return NULL;
 267                 }
 268
 269                 /*
 270                  * Only check for replacement races on update or create.
 271                  * For read we don't mind if the data is one record out of date.
 272                  */
 273
 274                 if(type == PWF_READ) {
 275                         break;
 276                 } else {
 277                         SMB_STRUCT_STAT sbuf1, sbuf2;
 278
 279                         /*
 280                          * Avoid the potential race condition between the open and the lock
 281                          * by doing a stat on the filename and an fstat on the fd. If the
 282                          * two inodes differ then someone did a rename between the open and
 283                          * the lock. Back off and try the open again. Only do this 5 times to
 284                          * prevent infinate loops. JRA.
 285                          */
 286
 287                         if (sys_stat(pfile, &sbuf1, false) != 0) {
 288                                 DEBUG(0, ("startsmbfilepwent_internal: unable to stat file %s. \
 289 Error was %s\n", pfile, strerror(errno)));
 290                                 pw_file_unlock(fileno(fp), lock_depth);
 291                                 fclose(fp);
 292                                 return NULL;
 293                         }
 294
 295                         if (sys_fstat(fileno(fp), &sbuf2, false) != 0) {
 296                                 DEBUG(0, ("startsmbfilepwent_internal: unable to fstat file %s. \
 297 Error was %s\n", pfile, strerror(errno)));
 298                                 pw_file_unlock(fileno(fp), lock_depth);
 299                                 fclose(fp);
 300                                 return NULL;
 301                         }
 302
 303                         if( sbuf1.st_ex_ino == sbuf2.st_ex_ino) {
 304                                 /* No race. */
 305                                 break;
 306                         }
 307
 308                         /*
 309                          * Race occurred - back off and try again...
 310                          */
 311
 312                         pw_file_unlock(fileno(fp), lock_depth);
 313                         fclose(fp);
 314                 }
 315         }
 316
 317         if(race_loop == 5) {
 318                 DEBUG(0, ("startsmbfilepwent_internal: too many race conditions opening file %s\n", pfile));
 319                 return NULL;
 320         }
 321
 322         /* Set a buffer to do more efficient reads */
 323         setvbuf(fp, (char *)NULL, _IOFBF, 1024);
 324
 325         /* Make sure it is only rw by the owner */
 326 #ifdef HAVE_FCHMOD
 327         if(fchmod(fileno(fp), S_IRUSR|S_IWUSR) == -1) {
 328 #else
 329         if(chmod(pfile, S_IRUSR|S_IWUSR) == -1) {
 330 #endif
 331                 DEBUG(0, ("startsmbfilepwent_internal: failed to set 0600 permissions on password file %s. \
 332 Error was %s\n.", pfile, strerror(errno) ));
 333                 pw_file_unlock(fileno(fp), lock_depth);
 334                 fclose(fp);
 335                 return NULL;
 336         }
 337
 338         /* We have a lock on the file. */
 339         return fp;
 340 }
 341
 342 /***************************************************************
 343  End enumeration of the smbpasswd list.
 344 ****************************************************************/
 345
 346 static void endsmbfilepwent(FILE *fp, int *lock_depth)
 347 {
 348         if (!fp) {
 349                 return;
 350         }
 351
 352         pw_file_unlock(fileno(fp), lock_depth);
 353         fclose(fp);
 354         DEBUG(7, ("endsmbfilepwent_internal: closed password file.\n"));
 355 }
 356
 357 /*************************************************************************
 358  Routine to return the next entry in the smbpasswd list.
 359  *************************************************************************/
 360
 361 static struct smb_passwd *getsmbfilepwent(struct smbpasswd_privates *smbpasswd_state, FILE *fp)
 362 {
 363         /* Static buffers we will return. */
 364         struct smb_passwd *pw_buf = &smbpasswd_state->pw_buf;
 365         char  *user_name = smbpasswd_state->user_name;
 366         unsigned char *smbpwd = smbpasswd_state->smbpwd;
 367         unsigned char *smbntpwd = smbpasswd_state->smbntpwd;
 368         char linebuf[256];
 369         int c;
 370         unsigned char *p;
 371         long uidval;
 372         size_t linebuf_len;
 373         char *status;
 374
 375         if(fp == NULL) {
 376                 DEBUG(0,("getsmbfilepwent: Bad password file pointer.\n"));
 377                 return NULL;
 378         }
 379
 380         pdb_init_smb(pw_buf);
 381         pw_buf->acct_ctrl = ACB_NORMAL;
 382
 383         /*
 384          * Scan the file, a line at a time and check if the name matches.
 385          */
 386         status = linebuf;
 387         while (status && !feof(fp)) {
 388                 linebuf[0] = '\0';
 389
 390                 status = fgets(linebuf, 256, fp);
 391                 if (status == NULL && ferror(fp)) {
 392                         return NULL;
 393                 }
 394
 395                 /*
 396                  * Check if the string is terminated with a newline - if not
 397                  * then we must keep reading and discard until we get one.
 398                  */
 399                 if ((linebuf_len = strlen(linebuf)) == 0) {
 400                         continue;
 401                 }
 402
 403                 if (linebuf[linebuf_len - 1] != '\n') {
 404                         c = '\0';
 405                         while (!ferror(fp) && !feof(fp)) {
 406                                 c = fgetc(fp);
 407                                 if (c == '\n') {
 408                                         break;
 409                                 }
 410                         }
 411                 } else {
 412                         linebuf[linebuf_len - 1] = '\0';
 413                 }
 414
 415 #ifdef DEBUG_PASSWORD
 416                 DEBUG(100, ("getsmbfilepwent: got line |%s|\n", linebuf));
 417 #endif
 418                 if ((linebuf[0] == 0) && feof(fp)) {
 419                         DEBUG(4, ("getsmbfilepwent: end of file reached\n"));
 420                         break;
 421                 }
 422
 423                 /*
 424                  * The line we have should be of the form :-
 425                  *
 426                  * username:uid:32hex bytes:[Account type]:LCT-12345678....other flags presently
 427                  * ignored....
 428                  *
 429                  * or,
 430                  *
 431                  * username:uid:32hex bytes:32hex bytes:[Account type]:LCT-12345678....ignored....
 432                  *
 433                  * if Windows NT compatible passwords are also present.
 434                  * [Account type] is an ascii encoding of the type of account.
 435                  * LCT-(8 hex digits) is the time_t value of the last change time.
 436                  */
 437
 438                 if (linebuf[0] == '#' || linebuf[0] == '\0') {
 439                         DEBUG(6, ("getsmbfilepwent: skipping comment or blank line\n"));
 440                         continue;
 441                 }
 442                 p = (unsigned char *) strchr_m(linebuf, ':');
 443                 if (p == NULL) {
 444                         DEBUG(0, ("getsmbfilepwent: malformed password entry (no :)\n"));
 445                         continue;
 446                 }
 447
 448                 strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
 449                 user_name[PTR_DIFF(p, linebuf)] = '\0';
 450
 451                 /* Get smb uid. */
 452
 453                 p++; /* Go past ':' */
 454
 455                 if(*p == '-') {
 456                         DEBUG(0, ("getsmbfilepwent: user name %s has a negative uid.\n", user_name));
 457                         continue;
 458                 }
 459
 460                 if (!isdigit(*p)) {
 461                         DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (uid not number)\n",
 462                                 user_name));
 463                         continue;
 464                 }
 465
 466                 uidval = atoi((char *) p);
 467
 468                 while (*p && isdigit(*p)) {
 469                         p++;
 470                 }
 471
 472                 if (*p != ':') {
 473                         DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (no : after uid)\n",
 474                                 user_name));
 475                         continue;
 476                 }
 477
 478                 pw_buf->smb_name = user_name;
 479                 pw_buf->smb_userid = uidval;
 480
 481                 /*
 482                  * Now get the password value - this should be 32 hex digits
 483                  * which are the ascii representations of a 16 byte string.
 484                  * Get two at a time and put them into the password.
 485                  */
 486
 487                 /* Skip the ':' */
 488                 p++;
 489
 490                 if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
 491                         DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (passwd too short)\n",
 492                                 user_name ));
 493                         continue;
 494                 }
 495
 496                 if (p[32] != ':') {
 497                         DEBUG(0, ("getsmbfilepwent: malformed password entry for user %s (no terminating :)\n",
 498                                 user_name));
 499                         continue;
 500                 }
 501
 502                 if (strnequal((char *) p, "NO PASSWORD", 11)) {
 503                         pw_buf->smb_passwd = NULL;
 504                         pw_buf->acct_ctrl |= ACB_PWNOTREQ;
 505                 } else {
 506                         if (*p == '*' || *p == 'X') {
 507                                 /* NULL LM password */
 508                                 pw_buf->smb_passwd = NULL;
 509                                 DEBUG(10, ("getsmbfilepwent: LM password for user %s invalidated\n", user_name));
 510                         } else if (pdb_gethexpwd((char *)p, smbpwd)) {
 511                                 pw_buf->smb_passwd = smbpwd;
 512                         } else {
 513                                 pw_buf->smb_passwd = NULL;
 514                                 DEBUG(0, ("getsmbfilepwent: Malformed Lanman password entry for user %s \
 515 (non hex chars)\n", user_name));
 516                         }
 517                 }
 518
 519                 /*
 520                  * Now check if the NT compatible password is
 521                  * available.
 522                  */
 523                 pw_buf->smb_nt_passwd = NULL;
 524                 p += 33; /* Move to the first character of the line after the lanman password. */
 525                 if ((linebuf_len >= (PTR_DIFF(p, linebuf) + 33)) && (p[32] == ':')) {
 526                         if (*p != '*' && *p != 'X') {
 527                                 if(pdb_gethexpwd((char *)p,smbntpwd)) {
 528                                         pw_buf->smb_nt_passwd = smbntpwd;
 529                                 }
 530                         }
 531                         p += 33; /* Move to the first character of the line after the NT password. */
 532                 }
 533
 534                 DEBUG(5,("getsmbfilepwent: returning passwd entry for user %s, uid %ld\n",
 535                         user_name, uidval));
 536
 537                 if (*p == '[') {
 538                         unsigned char *end_p = (unsigned char *)strchr_m((char *)p, ']');
 539                         pw_buf->acct_ctrl = pdb_decode_acct_ctrl((char*)p);
 540
 541                         /* Must have some account type set. */
 542                         if(pw_buf->acct_ctrl == 0) {
 543                                 pw_buf->acct_ctrl = ACB_NORMAL;
 544                         }
 545
 546                         /* Now try and get the last change time. */
 547                         if(end_p) {
 548                                 p = end_p + 1;
 549                         }
 550                         if(*p == ':') {
 551                                 p++;
 552                                 if(*p && (strncasecmp_m((char *)p, "LCT-", 4)==0)) {
 553                                         int i;
 554                                         p += 4;
 555                                         for(i = 0; i < 8; i++) {
 556                                                 if(p[i] == '\0' || !isxdigit(p[i])) {
 557                                                         break;
 558                                                 }
 559                                         }
 560                                         if(i == 8) {
 561                                                 /*
 562                                                  * p points at 8 characters of hex digits -
 563                                                  * read into a time_t as the seconds since
 564                                                  * 1970 that the password was last changed.
 565                                                  */
 566                                                 pw_buf->pass_last_set_time = (time_t)strtol((char *)p, NULL, 16);
 567                                         }
 568                                 }
 569                         }
 570                 } else {
 571                         /* 'Old' style file. Fake up based on user name. */
 572                         /*
 573                          * Currently trust accounts are kept in the same
 574                          * password file as 'normal accounts'. If this changes
 575                          * we will have to fix this code. JRA.
 576                          */
 577                         if(pw_buf->smb_name[strlen(pw_buf->smb_name) - 1] == '$') {
 578                                 pw_buf->acct_ctrl &= ~ACB_NORMAL;
 579                                 pw_buf->acct_ctrl |= ACB_WSTRUST;
 580                         }
 581                 }
 582
 583                 return pw_buf;
 584         }
 585
 586         DEBUG(5,("getsmbfilepwent: end of file reached.\n"));
 587         return NULL;
 588 }
 589
 590 /************************************************************************
 591  Create a new smbpasswd entry - malloced space returned.
 592 *************************************************************************/
 593
 594 static char *format_new_smbpasswd_entry(const struct smb_passwd *newpwd)
 595 {
 596         int new_entry_length;
 597         char *new_entry;
 598         char *p;
 599
 600         new_entry_length = strlen(newpwd->smb_name) + 1 + 15 + 1 + 32 + 1 + 32 + 1 +
 601                                 NEW_PW_FORMAT_SPACE_PADDED_LEN + 1 + 13 + 2;
 602
 603         if((new_entry = (char *)SMB_MALLOC( new_entry_length )) == NULL) {
 604                 DEBUG(0, ("format_new_smbpasswd_entry: Malloc failed adding entry for user %s.\n",
 605                         newpwd->smb_name ));
 606                 return NULL;
 607         }
 608
 609         slprintf(new_entry, new_entry_length - 1, "%s:%u:", newpwd->smb_name, (unsigned)newpwd->smb_userid);
 610
 611         p = new_entry+strlen(new_entry);
 612         pdb_sethexpwd(p, newpwd->smb_passwd, newpwd->acct_ctrl);
 613         p+=strlen(p);
 614         *p = ':';
 615         p++;
 616
 617         pdb_sethexpwd(p, newpwd->smb_nt_passwd, newpwd->acct_ctrl);
 618         p+=strlen(p);
 619         *p = ':';
 620         p++;
 621
 622         /* Add the account encoding and the last change time. */
 623         slprintf((char *)p, new_entry_length - 1 - (p - new_entry),  "%s:LCT-%08X:\n",
 624                 pdb_encode_acct_ctrl(newpwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN),
 625                 (uint32_t)newpwd->pass_last_set_time);
 626
 627         return new_entry;
 628 }
 629
 630 /************************************************************************
 631  Routine to add an entry to the smbpasswd file.
 632 *************************************************************************/
 633
 634 static NTSTATUS add_smbfilepwd_entry(struct smbpasswd_privates *smbpasswd_state,
 635                                      struct smb_passwd *newpwd)
 636 {
 637         const char *pfile = smbpasswd_state->smbpasswd_file;
 638         struct smb_passwd *pwd = NULL;
 639         FILE *fp = NULL;
 640         int wr_len;
 641         int fd;
 642         size_t new_entry_length;
 643         char *new_entry;
 644         SMB_OFF_T offpos;
 645
 646         /* Open the smbpassword file - for update. */
 647         fp = startsmbfilepwent(pfile, PWF_UPDATE, &smbpasswd_state->pw_file_lock_depth);
 648
 649         if (fp == NULL && errno == ENOENT) {
 650                 /* Try again - create. */
 651                 fp = startsmbfilepwent(pfile, PWF_CREATE, &smbpasswd_state->pw_file_lock_depth);
 652         }
 653
 654         if (fp == NULL) {
 655                 DEBUG(0, ("add_smbfilepwd_entry: unable to open file.\n"));
 656                 return map_nt_error_from_unix(errno);
 657         }
 658
 659         /*
 660          * Scan the file, a line at a time and check if the name matches.
 661          */
 662
 663         while ((pwd = getsmbfilepwent(smbpasswd_state, fp)) != NULL) {
 664                 if (strequal(newpwd->smb_name, pwd->smb_name)) {
 665                         DEBUG(0, ("add_smbfilepwd_entry: entry with name %s already exists\n", pwd->smb_name));
 666                         endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
 667                         return NT_STATUS_USER_EXISTS;
 668                 }
 669         }
 670
 671         /* Ok - entry doesn't exist. We can add it */
 672
 673         /* Create a new smb passwd entry and set it to the given password. */
 674         /*
 675          * The add user write needs to be atomic - so get the fd from
 676          * the fp and do a raw write() call.
 677          */
 678         fd = fileno(fp);
 679
 680         if((offpos = sys_lseek(fd, 0, SEEK_END)) == -1) {
 681                 NTSTATUS result = map_nt_error_from_unix(errno);
 682                 DEBUG(0, ("add_smbfilepwd_entry(sys_lseek): Failed to add entry for user %s to file %s. \
 683 Error was %s\n", newpwd->smb_name, pfile, strerror(errno)));
 684                 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
 685                 return result;
 686         }
 687
 688         if((new_entry = format_new_smbpasswd_entry(newpwd)) == NULL) {
 689                 DEBUG(0, ("add_smbfilepwd_entry(malloc): Failed to add entry for user %s to file %s. \
 690 Error was %s\n", newpwd->smb_name, pfile, strerror(errno)));
 691                 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
 692                 return NT_STATUS_NO_MEMORY;
 693         }
 694
 695         new_entry_length = strlen(new_entry);
 696
 697 #ifdef DEBUG_PASSWORD
 698         DEBUG(100, ("add_smbfilepwd_entry(%d): new_entry_len %d made line |%s|",
 699                         fd, (int)new_entry_length, new_entry));
 700 #endif
 701
 702         if ((wr_len = write(fd, new_entry, new_entry_length)) != new_entry_length) {
 703                 NTSTATUS result = map_nt_error_from_unix(errno);
 704                 DEBUG(0, ("add_smbfilepwd_entry(write): %d Failed to add entry for user %s to file %s. \
 705 Error was %s\n", wr_len, newpwd->smb_name, pfile, strerror(errno)));
 706
 707                 /* Remove the entry we just wrote. */
 708                 if(sys_ftruncate(fd, offpos) == -1) {
 709                         DEBUG(0, ("add_smbfilepwd_entry: ERROR failed to ftruncate file %s. \
 710 Error was %s. Password file may be corrupt ! Please examine by hand !\n",
 711                                 newpwd->smb_name, strerror(errno)));
 712                 }
 713
 714                 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
 715                 free(new_entry);
 716                 return result;
 717         }
 718
 719         free(new_entry);
 720         endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
 721         return NT_STATUS_OK;
 722 }
 723
 724 /************************************************************************
 725  Routine to search the smbpasswd file for an entry matching the username.
 726  and then modify its password entry. We can't use the startsmbpwent()/
 727  getsmbpwent()/endsmbpwent() interfaces here as we depend on looking
 728  in the actual file to decide how much room we have to write data.
 729  override = False, normal
 730  override = True, override XXXXXXXX'd out password or NO PASS
 731 ************************************************************************/
 732
 733 static bool mod_smbfilepwd_entry(struct smbpasswd_privates *smbpasswd_state, const struct smb_passwd* pwd)
 734 {
 735         /* Static buffers we will return. */
 736         fstring user_name;
 737
 738         char *status;
 739         char linebuf[256];
 740         char readbuf[1024];
 741         int c;
 742         fstring ascii_p16;
 743         fstring encode_bits;
 744         unsigned char *p = NULL;
 745         size_t linebuf_len = 0;
 746         FILE *fp;
 747         int lockfd;
 748         const char *pfile = smbpasswd_state->smbpasswd_file;
 749         bool found_entry = False;
 750         bool got_pass_last_set_time = False;
 751
 752         SMB_OFF_T pwd_seekpos = 0;
 753
 754         int i;
 755         int wr_len;
 756         int fd;
 757
 758         if (!*pfile) {
 759                 DEBUG(0, ("No SMB password file set\n"));
 760                 return False;
 761         }
 762         DEBUG(10, ("mod_smbfilepwd_entry: opening file %s\n", pfile));
 763
 764         fp = sys_fopen(pfile, "r+");
 765
 766         if (fp == NULL) {
 767                 DEBUG(0, ("mod_smbfilepwd_entry: unable to open file %s\n", pfile));
 768                 return False;
 769         }
 770         /* Set a buffer to do more efficient reads */
 771         setvbuf(fp, readbuf, _IOFBF, sizeof(readbuf));
 772
 773         lockfd = fileno(fp);
 774
 775         if (!pw_file_lock(lockfd, F_WRLCK, 5, &smbpasswd_state->pw_file_lock_depth)) {
 776                 DEBUG(0, ("mod_smbfilepwd_entry: unable to lock file %s\n", pfile));
 777                 fclose(fp);
 778                 return False;
 779         }
 780
 781         /* Make sure it is only rw by the owner */
 782         chmod(pfile, 0600);
 783
 784         /* We have a write lock on the file. */
 785         /*
 786          * Scan the file, a line at a time and check if the name matches.
 787          */
 788         status = linebuf;
 789         while (status && !feof(fp)) {
 790                 pwd_seekpos = sys_ftell(fp);
 791
 792                 linebuf[0] = '\0';
 793
 794                 status = fgets(linebuf, sizeof(linebuf), fp);
 795                 if (status == NULL && ferror(fp)) {
 796                         pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
 797                         fclose(fp);
 798                         return False;
 799                 }
 800
 801                 /*
 802                  * Check if the string is terminated with a newline - if not
 803                  * then we must keep reading and discard until we get one.
 804                  */
 805                 linebuf_len = strlen(linebuf);
 806                 if (linebuf[linebuf_len - 1] != '\n') {
 807                         c = '\0';
 808                         while (!ferror(fp) && !feof(fp)) {
 809                                 c = fgetc(fp);
 810                                 if (c == '\n') {
 811                                         break;
 812                                 }
 813                         }
 814                 } else {
 815                         linebuf[linebuf_len - 1] = '\0';
 816                 }
 817
 818 #ifdef DEBUG_PASSWORD
 819                 DEBUG(100, ("mod_smbfilepwd_entry: got line |%s|\n", linebuf));
 820 #endif
 821
 822                 if ((linebuf[0] == 0) && feof(fp)) {
 823                         DEBUG(4, ("mod_smbfilepwd_entry: end of file reached\n"));
 824                         break;
 825                 }
 826
 827                 /*
 828                  * The line we have should be of the form :-
 829                  *
 830                  * username:uid:[32hex bytes]:....other flags presently
 831                  * ignored....
 832                  *
 833                  * or,
 834                  *
 835                  * username:uid:[32hex bytes]:[32hex bytes]:[attributes]:LCT-XXXXXXXX:...ignored.
 836                  *
 837                  * if Windows NT compatible passwords are also present.
 838                  */
 839
 840                 if (linebuf[0] == '#' || linebuf[0] == '\0') {
 841                         DEBUG(6, ("mod_smbfilepwd_entry: skipping comment or blank line\n"));
 842                         continue;
 843                 }
 844
 845                 p = (unsigned char *) strchr_m(linebuf, ':');
 846
 847                 if (p == NULL) {
 848                         DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry (no :)\n"));
 849                         continue;
 850                 }
 851
 852                 strncpy(user_name, linebuf, PTR_DIFF(p, linebuf));
 853                 user_name[PTR_DIFF(p, linebuf)] = '\0';
 854                 if (strequal(user_name, pwd->smb_name)) {
 855                         found_entry = True;
 856                         break;
 857                 }
 858         }
 859
 860         if (!found_entry) {
 861                 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
 862                 fclose(fp);
 863
 864                 DEBUG(2, ("Cannot update entry for user %s, as they don't exist in the smbpasswd file!\n",
 865                         pwd->smb_name));
 866                 return False;
 867         }
 868
 869         DEBUG(6, ("mod_smbfilepwd_entry: entry exists for user %s\n", pwd->smb_name));
 870
 871         /* User name matches - get uid and password */
 872         p++; /* Go past ':' */
 873
 874         if (!isdigit(*p)) {
 875                 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (uid not number)\n",
 876                         pwd->smb_name));
 877                 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
 878                 fclose(fp);
 879                 return False;
 880         }
 881
 882         while (*p && isdigit(*p)) {
 883                 p++;
 884         }
 885         if (*p != ':') {
 886                 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no : after uid)\n",
 887                         pwd->smb_name));
 888                 pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
 889                 fclose(fp);
 890                 return False;
 891         }
 892
 893         /*
 894          * Now get the password value - this should be 32 hex digits
 895          * which are the ascii representations of a 16 byte string.
 896          * Get two at a time and put them into the password.
 897          */
 898         p++;
 899
 900         /* Record exact password position */
 901         pwd_seekpos += PTR_DIFF(p, linebuf);
 902
 903         if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
 904                 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (passwd too short)\n",
 905                         pwd->smb_name));
 906                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
 907                 fclose(fp);
 908                 return (False);
 909         }
 910
 911         if (p[32] != ':') {
 912                 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no terminating :)\n",
 913                         pwd->smb_name));
 914                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
 915                 fclose(fp);
 916                 return False;
 917         }
 918
 919         /* Now check if the NT compatible password is available. */
 920         p += 33; /* Move to the first character of the line after the lanman password. */
 921         if (linebuf_len < (PTR_DIFF(p, linebuf) + 33)) {
 922                 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (passwd too short)\n",
 923                         pwd->smb_name));
 924                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
 925                 fclose(fp);
 926                 return (False);
 927         }
 928
 929         if (p[32] != ':') {
 930                 DEBUG(0, ("mod_smbfilepwd_entry: malformed password entry for user %s (no terminating :)\n",
 931                         pwd->smb_name));
 932                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
 933                 fclose(fp);
 934                 return False;
 935         }
 936
 937         /*
 938          * Now check if the account info and the password last
 939          * change time is available.
 940          */
 941         p += 33; /* Move to the first character of the line after the NT password. */
 942
 943         if (*p == '[') {
 944                 i = 0;
 945                 encode_bits[i++] = *p++;
 946                 while((linebuf_len > PTR_DIFF(p, linebuf)) && (*p != ']')) {
 947                         encode_bits[i++] = *p++;
 948                 }
 949
 950                 encode_bits[i++] = ']';
 951                 encode_bits[i++] = '\0';
 952
 953                 if(i == NEW_PW_FORMAT_SPACE_PADDED_LEN) {
 954                         /*
 955                          * We are using a new format, space padded
 956                          * acct ctrl field. Encode the given acct ctrl
 957                          * bits into it.
 958                          */
 959                         fstrcpy(encode_bits, pdb_encode_acct_ctrl(pwd->acct_ctrl, NEW_PW_FORMAT_SPACE_PADDED_LEN));
 960                 } else {
 961                         DEBUG(0,("mod_smbfilepwd_entry:  Using old smbpasswd format for user %s. \
 962 This is no longer supported.!\n", pwd->smb_name));
 963                         DEBUG(0,("mod_smbfilepwd_entry:  No changes made, failing.!\n"));
 964                         pw_file_unlock(lockfd, &smbpasswd_state->pw_file_lock_depth);
 965                         fclose(fp);
 966                         return False;
 967                 }
 968
 969                 /* Go past the ']' */
 970                 if(linebuf_len > PTR_DIFF(p, linebuf)) {
 971                         p++;
 972                 }
 973
 974                 if((linebuf_len > PTR_DIFF(p, linebuf)) && (*p == ':')) {
 975                         p++;
 976
 977                         /* We should be pointing at the LCT entry. */
 978                         if((linebuf_len > (PTR_DIFF(p, linebuf) + 13)) && (strncasecmp_m((char *)p, "LCT-", 4) == 0)) {
 979                                 p += 4;
 980                                 for(i = 0; i < 8; i++) {
 981                                         if(p[i] == '\0' || !isxdigit(p[i])) {
 982                                                 break;
 983                                         }
 984                                 }
 985                                 if(i == 8) {
 986                                         /*
 987                                          * p points at 8 characters of hex digits -
 988                                          * read into a time_t as the seconds since
 989                                          * 1970 that the password was last changed.
 990                                          */
 991                                         got_pass_last_set_time = True;
 992                                 } /* i == 8 */
 993                         } /* *p && strncasecmp_m() */
 994                 } /* p == ':' */
 995         } /* p == '[' */
 996
 997         /* Entry is correctly formed. */
 998
 999         /* Create the 32 byte representation of the new p16 */
1000         pdb_sethexpwd(ascii_p16, pwd->smb_passwd, pwd->acct_ctrl);
1001
1002         /* Add on the NT md4 hash */
1003         ascii_p16[32] = ':';
1004         wr_len = 66;
1005         pdb_sethexpwd(ascii_p16+33, pwd->smb_nt_passwd, pwd->acct_ctrl);
1006         ascii_p16[65] = ':';
1007         ascii_p16[66] = '\0'; /* null-terminate the string so that strlen works */
1008
1009         /* Add on the account info bits and the time of last password change. */
1010         if(got_pass_last_set_time) {
1011                 slprintf(&ascii_p16[strlen(ascii_p16)],
1012                         sizeof(ascii_p16)-(strlen(ascii_p16)+1),
1013                         "%s:LCT-%08X:",
1014                         encode_bits, (uint32_t)pwd->pass_last_set_time );
1015                 wr_len = strlen(ascii_p16);
1016         }
1017
1018 #ifdef DEBUG_PASSWORD
1019         DEBUG(100,("mod_smbfilepwd_entry: "));
1020         dump_data(100, (uint8 *)ascii_p16, wr_len);
1021 #endif
1022
1023         if(wr_len > sizeof(linebuf)) {
1024                 DEBUG(0, ("mod_smbfilepwd_entry: line to write (%d) is too long.\n", wr_len+1));
1025                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1026                 fclose(fp);
1027                 return (False);
1028         }
1029
1030         /*
1031          * Do an atomic write into the file at the position defined by
1032          * seekpos.
1033          */
1034
1035         /* The mod user write needs to be atomic - so get the fd from
1036                 the fp and do a raw write() call.
1037          */
1038
1039         fd = fileno(fp);
1040
1041         if (sys_lseek(fd, pwd_seekpos - 1, SEEK_SET) != pwd_seekpos - 1) {
1042                 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
1043                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1044                 fclose(fp);
1045                 return False;
1046         }
1047
1048         /* Sanity check - ensure the areas we are writing are framed by ':' */
1049         if (read(fd, linebuf, wr_len+1) != wr_len+1) {
1050                 DEBUG(0, ("mod_smbfilepwd_entry: read fail on file %s.\n", pfile));
1051                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1052                 fclose(fp);
1053                 return False;
1054         }
1055
1056         if ((linebuf[0] != ':') || (linebuf[wr_len] != ':'))    {
1057                 DEBUG(0, ("mod_smbfilepwd_entry: check on passwd file %s failed.\n", pfile));
1058                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1059                 fclose(fp);
1060                 return False;
1061         }
1062
1063         if (sys_lseek(fd, pwd_seekpos, SEEK_SET) != pwd_seekpos) {
1064                 DEBUG(0, ("mod_smbfilepwd_entry: seek fail on file %s.\n", pfile));
1065                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1066                 fclose(fp);
1067                 return False;
1068         }
1069
1070         if (write(fd, ascii_p16, wr_len) != wr_len) {
1071                 DEBUG(0, ("mod_smbfilepwd_entry: write failed in passwd file %s\n", pfile));
1072                 pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1073                 fclose(fp);
1074                 return False;
1075         }
1076
1077         pw_file_unlock(lockfd,&smbpasswd_state->pw_file_lock_depth);
1078         fclose(fp);
1079         return True;
1080 }
1081
1082 /************************************************************************
1083  Routine to delete an entry in the smbpasswd file by name.
1084 *************************************************************************/
1085
1086 static bool del_smbfilepwd_entry(struct smbpasswd_privates *smbpasswd_state, const char *name)
1087 {
1088         const char *pfile = smbpasswd_state->smbpasswd_file;
1089         char *pfile2 = NULL;
1090         struct smb_passwd *pwd = NULL;
1091         FILE *fp = NULL;
1092         FILE *fp_write = NULL;
1093         int pfile2_lockdepth = 0;
1094
1095         pfile2 = talloc_asprintf(talloc_tos(),
1096                         "%s.%u",
1097                         pfile, (unsigned)sys_getpid());
1098         if (!pfile2) {
1099                 return false;
1100         }
1101
1102         /*
1103          * Open the smbpassword file - for update. It needs to be update
1104          * as we need any other processes to wait until we have replaced
1105          * it.
1106          */
1107
1108         if((fp = startsmbfilepwent(pfile, PWF_UPDATE, &smbpasswd_state->pw_file_lock_depth)) == NULL) {
1109                 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
1110                 return False;
1111         }
1112
1113         /*
1114          * Create the replacement password file.
1115          */
1116         if((fp_write = startsmbfilepwent(pfile2, PWF_CREATE, &pfile2_lockdepth)) == NULL) {
1117                 DEBUG(0, ("del_smbfilepwd_entry: unable to open file %s.\n", pfile));
1118                 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1119                 return False;
1120         }
1121
1122         /*
1123          * Scan the file, a line at a time and check if the name matches.
1124          */
1125
1126         while ((pwd = getsmbfilepwent(smbpasswd_state, fp)) != NULL) {
1127                 char *new_entry;
1128                 size_t new_entry_length;
1129
1130                 if (strequal(name, pwd->smb_name)) {
1131                         DEBUG(10, ("del_smbfilepwd_entry: found entry with "
1132                                    "name %s - deleting it.\n", name));
1133                         continue;
1134                 }
1135
1136                 /*
1137                  * We need to copy the entry out into the second file.
1138                  */
1139
1140                 if((new_entry = format_new_smbpasswd_entry(pwd)) == NULL) {
1141                         DEBUG(0, ("del_smbfilepwd_entry(malloc): Failed to copy entry for user %s to file %s. \
1142 Error was %s\n", pwd->smb_name, pfile2, strerror(errno)));
1143                         unlink(pfile2);
1144                         endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1145                         endsmbfilepwent(fp_write, &pfile2_lockdepth);
1146                         return False;
1147                 }
1148
1149                 new_entry_length = strlen(new_entry);
1150
1151                 if(fwrite(new_entry, 1, new_entry_length, fp_write) != new_entry_length) {
1152                         DEBUG(0, ("del_smbfilepwd_entry(write): Failed to copy entry for user %s to file %s. \
1153 Error was %s\n", pwd->smb_name, pfile2, strerror(errno)));
1154                         unlink(pfile2);
1155                         endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1156                         endsmbfilepwent(fp_write, &pfile2_lockdepth);
1157                         free(new_entry);
1158                         return False;
1159                 }
1160
1161                 free(new_entry);
1162         }
1163
1164         /*
1165          * Ensure pfile2 is flushed before rename.
1166          */
1167
1168         if(fflush(fp_write) != 0) {
1169                 DEBUG(0, ("del_smbfilepwd_entry: Failed to flush file %s. Error was %s\n", pfile2, strerror(errno)));
1170                 endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1171                 endsmbfilepwent(fp_write,&pfile2_lockdepth);
1172                 return False;
1173         }
1174
1175         /*
1176          * Do an atomic rename - then release the locks.
1177          */
1178
1179         if(rename(pfile2,pfile) != 0) {
1180                 unlink(pfile2);
1181         }
1182
1183         endsmbfilepwent(fp, &smbpasswd_state->pw_file_lock_depth);
1184         endsmbfilepwent(fp_write,&pfile2_lockdepth);
1185         return True;
1186 }
1187
1188 /*********************************************************************
1189  Create a smb_passwd struct from a struct samu.
1190  We will not allocate any new memory.  The smb_passwd struct
1191  should only stay around as long as the struct samu does.
1192  ********************************************************************/
1193
1194 static bool build_smb_pass (struct smb_passwd *smb_pw, const struct samu *sampass)
1195 {
1196         uint32_t rid;
1197
1198         if (sampass == NULL)
1199                 return False;
1200         ZERO_STRUCTP(smb_pw);
1201
1202         if (!IS_SAM_DEFAULT(sampass, PDB_USERSID)) {
1203                 rid = pdb_get_user_rid(sampass);
1204
1205                 /* If the user specified a RID, make sure its able to be both stored and retreived */
1206                 if (rid == DOMAIN_RID_GUEST) {
1207                         struct passwd *passwd = Get_Pwnam_alloc(NULL, lp_guestaccount());
1208                         if (!passwd) {
1209                                 DEBUG(0, ("Could not find guest account via Get_Pwnam_alloc()! (%s)\n", lp_guestaccount()));
1210                                 return False;
1211                         }
1212                         smb_pw->smb_userid=passwd->pw_uid;
1213                         TALLOC_FREE(passwd);
1214                 } else if (algorithmic_pdb_rid_is_user(rid)) {
1215                         smb_pw->smb_userid=algorithmic_pdb_user_rid_to_uid(rid);
1216                 } else {
1217                         DEBUG(0,("build_sam_pass: Failing attempt to store user with non-uid based user RID. \n"));
1218                         return False;
1219                 }
1220         }
1221
1222         smb_pw->smb_name=(const char*)pdb_get_username(sampass);
1223
1224         smb_pw->smb_passwd=pdb_get_lanman_passwd(sampass);
1225         smb_pw->smb_nt_passwd=pdb_get_nt_passwd(sampass);
1226
1227         smb_pw->acct_ctrl=pdb_get_acct_ctrl(sampass);
1228         smb_pw->pass_last_set_time=pdb_get_pass_last_set_time(sampass);
1229
1230         return True;
1231 }
1232
1233 /*********************************************************************
1234  Create a struct samu from a smb_passwd struct
1235  ********************************************************************/
1236
1237 static bool build_sam_account(struct smbpasswd_privates *smbpasswd_state,
1238                               struct samu *sam_pass, const struct smb_passwd *pw_buf)
1239 {
1240         struct passwd *pwfile;
1241
1242         if ( !sam_pass ) {
1243                 DEBUG(5,("build_sam_account: struct samu is NULL\n"));
1244                 return False;
1245         }
1246
1247         /* verify the user account exists */
1248
1249         if ( !(pwfile = Get_Pwnam_alloc(NULL, pw_buf->smb_name )) ) {
1250                 DEBUG(0,("build_sam_account: smbpasswd database is corrupt!  username %s with uid "
1251                 "%u is not in unix passwd database!\n", pw_buf->smb_name, pw_buf->smb_userid));
1252                         return False;
1253         }
1254
1255         if ( !NT_STATUS_IS_OK( samu_set_unix(sam_pass, pwfile )) )
1256                 return False;
1257
1258         TALLOC_FREE(pwfile);
1259
1260         /* set remaining fields */
1261
1262         if (!pdb_set_nt_passwd (sam_pass, pw_buf->smb_nt_passwd, PDB_SET))
1263                 return False;
1264         if (!pdb_set_lanman_passwd (sam_pass, pw_buf->smb_passwd, PDB_SET))
1265                 return False;
1266         pdb_set_acct_ctrl (sam_pass, pw_buf->acct_ctrl, PDB_SET);
1267         pdb_set_pass_last_set_time (sam_pass, pw_buf->pass_last_set_time, PDB_SET);
1268         pdb_set_pass_can_change_time (sam_pass, pw_buf->pass_last_set_time, PDB_SET);
1269
1270         return True;
1271 }
1272
1273 /*****************************************************************
1274  Functions to be implemented by the new passdb API
1275  ****************************************************************/
1276
1277 /****************************************************************
1278  Search smbpasswd file by iterating over the entries.  Do not
1279  call getpwnam() for unix account information until we have found
1280  the correct entry
1281  ***************************************************************/
1282
1283 static NTSTATUS smbpasswd_getsampwnam(struct pdb_methods *my_methods,
1284                                   struct samu *sam_acct, const char *username)
1285 {
1286         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1287         struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1288         struct smb_passwd *smb_pw;
1289         FILE *fp = NULL;
1290
1291         DEBUG(10, ("getsampwnam (smbpasswd): search by name: %s\n", username));
1292
1293         /* startsmbfilepwent() is used here as we don't want to lookup
1294            the UNIX account in the local system password file until
1295            we have a match.  */
1296         fp = startsmbfilepwent(smbpasswd_state->smbpasswd_file, PWF_READ, &(smbpasswd_state->pw_file_lock_depth));
1297
1298         if (fp == NULL) {
1299                 DEBUG(0, ("Unable to open passdb database.\n"));
1300                 return nt_status;
1301         }
1302
1303         while ( ((smb_pw=getsmbfilepwent(smbpasswd_state, fp)) != NULL)&& (!strequal(smb_pw->smb_name, username)) )
1304                 /* do nothing....another loop */ ;
1305
1306         endsmbfilepwent(fp, &(smbpasswd_state->pw_file_lock_depth));
1307
1308
1309         /* did we locate the username in smbpasswd  */
1310         if (smb_pw == NULL)
1311                 return nt_status;
1312
1313         DEBUG(10, ("getsampwnam (smbpasswd): found by name: %s\n", smb_pw->smb_name));
1314
1315         if (!sam_acct) {
1316                 DEBUG(10,("getsampwnam (smbpasswd): struct samu is NULL\n"));
1317                 return nt_status;
1318         }
1319
1320         /* now build the struct samu */
1321         if (!build_sam_account(smbpasswd_state, sam_acct, smb_pw))
1322                 return nt_status;
1323
1324         /* success */
1325         return NT_STATUS_OK;
1326 }
1327
1328 static NTSTATUS smbpasswd_getsampwsid(struct pdb_methods *my_methods, struct samu *sam_acct, const struct dom_sid *sid)
1329 {
1330         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
1331         struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1332         struct smb_passwd *smb_pw;
1333         FILE *fp = NULL;
1334         uint32_t rid;
1335
1336         DEBUG(10, ("smbpasswd_getsampwrid: search by sid: %s\n",
1337                    sid_string_dbg(sid)));
1338
1339         if (!sid_peek_check_rid(get_global_sam_sid(), sid, &rid))
1340                 return NT_STATUS_UNSUCCESSFUL;
1341
1342         /* More special case 'guest account' hacks... */
1343         if (rid == DOMAIN_RID_GUEST) {
1344                 const char *guest_account = lp_guestaccount();
1345                 if (!(guest_account && *guest_account)) {
1346                         DEBUG(1, ("Guest account not specfied!\n"));
1347                         return nt_status;
1348                 }
1349                 return smbpasswd_getsampwnam(my_methods, sam_acct, guest_account);
1350         }
1351
1352         /* Open the sam password file - not for update. */
1353         fp = startsmbfilepwent(smbpasswd_state->smbpasswd_file, PWF_READ, &(smbpasswd_state->pw_file_lock_depth));
1354
1355         if (fp == NULL) {
1356                 DEBUG(0, ("Unable to open passdb database.\n"));
1357                 return nt_status;
1358         }
1359
1360         while ( ((smb_pw=getsmbfilepwent(smbpasswd_state, fp)) != NULL) && (algorithmic_pdb_uid_to_user_rid(smb_pw->smb_userid) != rid) )
1361                 /* do nothing */ ;
1362
1363         endsmbfilepwent(fp, &(smbpasswd_state->pw_file_lock_depth));
1364
1365
1366         /* did we locate the username in smbpasswd  */
1367         if (smb_pw == NULL)
1368                 return nt_status;
1369
1370         DEBUG(10, ("getsampwrid (smbpasswd): found by name: %s\n", smb_pw->smb_name));
1371
1372         if (!sam_acct) {
1373                 DEBUG(10,("getsampwrid: (smbpasswd) struct samu is NULL\n"));
1374                 return nt_status;
1375         }
1376
1377         /* now build the struct samu */
1378         if (!build_sam_account (smbpasswd_state, sam_acct, smb_pw))
1379                 return nt_status;
1380
1381         /* build_sam_account might change the SID on us, if the name was for the guest account */
1382         if (NT_STATUS_IS_OK(nt_status) && !dom_sid_equal(pdb_get_user_sid(sam_acct), sid)) {
1383                 DEBUG(1, ("looking for user with sid %s instead returned %s "
1384                           "for account %s!?!\n", sid_string_dbg(sid),
1385                           sid_string_dbg(pdb_get_user_sid(sam_acct)),
1386                           pdb_get_username(sam_acct)));
1387                 return NT_STATUS_NO_SUCH_USER;
1388         }
1389
1390         /* success */
1391         return NT_STATUS_OK;
1392 }
1393
1394 static NTSTATUS smbpasswd_add_sam_account(struct pdb_methods *my_methods, struct samu *sampass)
1395 {
1396         struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1397         struct smb_passwd smb_pw;
1398
1399         /* convert the struct samu */
1400         if (!build_smb_pass(&smb_pw, sampass)) {
1401                 return NT_STATUS_UNSUCCESSFUL;
1402         }
1403
1404         /* add the entry */
1405         return add_smbfilepwd_entry(smbpasswd_state, &smb_pw);
1406 }
1407
1408 static NTSTATUS smbpasswd_update_sam_account(struct pdb_methods *my_methods, struct samu *sampass)
1409 {
1410         struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1411         struct smb_passwd smb_pw;
1412
1413         /* convert the struct samu */
1414         if (!build_smb_pass(&smb_pw, sampass)) {
1415                 DEBUG(0, ("smbpasswd_update_sam_account: build_smb_pass failed!\n"));
1416                 return NT_STATUS_UNSUCCESSFUL;
1417         }
1418
1419         /* update the entry */
1420         if(!mod_smbfilepwd_entry(smbpasswd_state, &smb_pw)) {
1421                 DEBUG(0, ("smbpasswd_update_sam_account: mod_smbfilepwd_entry failed!\n"));
1422                 return NT_STATUS_UNSUCCESSFUL;
1423         }
1424
1425         return NT_STATUS_OK;
1426 }
1427
1428 static NTSTATUS smbpasswd_delete_sam_account (struct pdb_methods *my_methods, struct samu *sampass)
1429 {
1430         struct smbpasswd_privates *smbpasswd_state = (struct smbpasswd_privates*)my_methods->private_data;
1431
1432         const char *username = pdb_get_username(sampass);
1433
1434         if (del_smbfilepwd_entry(smbpasswd_state, username))
1435                 return NT_STATUS_OK;
1436
1437         return NT_STATUS_UNSUCCESSFUL;
1438 }
1439
1440 static NTSTATUS smbpasswd_rename_sam_account (struct pdb_methods *my_methods,
1441                                               struct samu *old_acct,
1442                                               const char *newname)
1443 {
1444         char *rename_script = NULL;
1445         struct samu *new_acct = NULL;
1446         bool interim_account = False;
1447         TALLOC_CTX *ctx = talloc_tos();
1448         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
1449
1450         if (!*(lp_renameuser_script()))
1451                 goto done;
1452
1453         if ( !(new_acct = samu_new( NULL )) ) {
1454                 return NT_STATUS_NO_MEMORY;
1455         }
1456
1457         if ( !pdb_copy_sam_account( new_acct, old_acct )
1458                 || !pdb_set_username(new_acct, newname, PDB_CHANGED))
1459         {
1460                 goto done;
1461         }
1462
1463         ret = smbpasswd_add_sam_account(my_methods, new_acct);
1464         if (!NT_STATUS_IS_OK(ret))
1465                 goto done;
1466
1467         interim_account = True;
1468
1469         /* rename the posix user */
1470         rename_script = talloc_strdup(ctx,
1471                                 lp_renameuser_script());
1472         if (!rename_script) {
1473                 ret = NT_STATUS_NO_MEMORY;
1474                 goto done;
1475         }
1476
1477         if (*rename_script) {
1478                 int rename_ret;
1479
1480                 rename_script = talloc_string_sub2(ctx,
1481                                         rename_script,
1482                                         "%unew",
1483                                         newname,
1484                                         true,
1485                                         false,
1486                                         true);
1487                 if (!rename_script) {
1488                         ret = NT_STATUS_NO_MEMORY;
1489                         goto done;
1490                 }
1491                 rename_script = talloc_string_sub2(ctx,
1492                                         rename_script,
1493                                         "%uold",
1494                                         pdb_get_username(old_acct),
1495                                         true,
1496                                         false,
1497                                         true);
1498                 if (!rename_script) {
1499                         ret = NT_STATUS_NO_MEMORY;
1500                         goto done;
1501                 }
1502
1503                 rename_ret = smbrun(rename_script, NULL);
1504
1505                 DEBUG(rename_ret ? 0 : 3,("Running the command `%s' gave %d\n", rename_script, rename_ret));
1506
1507                 if (rename_ret == 0) {
1508                         smb_nscd_flush_user_cache();
1509                 }
1510
1511                 if (rename_ret)
1512                         goto done;
1513         } else {
1514                 goto done;
1515         }
1516
1517         smbpasswd_delete_sam_account(my_methods, old_acct);
1518         interim_account = False;
1519
1520 done:
1521         /* cleanup */
1522         if (interim_account)
1523                 smbpasswd_delete_sam_account(my_methods, new_acct);
1524
1525         if (new_acct)
1526                 TALLOC_FREE(new_acct);
1527
1528         return (ret);
1529 }
1530
1531 static uint32_t smbpasswd_capabilities(struct pdb_methods *methods)
1532 {
1533         return 0;
1534 }
1535
1536 static void free_private_data(void **vp)
1537 {
1538         struct smbpasswd_privates **privates = (struct smbpasswd_privates**)vp;
1539
1540         endsmbfilepwent((*privates)->pw_file, &((*privates)->pw_file_lock_depth));
1541
1542         *privates = NULL;
1543         /* No need to free any further, as it is talloc()ed */
1544 }
1545
1546 struct smbpasswd_search_state {
1547         uint32_t acct_flags;
1548
1549         struct samr_displayentry *entries;
1550         uint32_t num_entries;
1551         ssize_t array_size;
1552         uint32_t current;
1553 };
1554
1555 static void smbpasswd_search_end(struct pdb_search *search)
1556 {
1557         struct smbpasswd_search_state *state = talloc_get_type_abort(
1558                 search->private_data, struct smbpasswd_search_state);
1559         TALLOC_FREE(state);
1560 }
1561
1562 static bool smbpasswd_search_next_entry(struct pdb_search *search,
1563                                         struct samr_displayentry *entry)
1564 {
1565         struct smbpasswd_search_state *state = talloc_get_type_abort(
1566                 search->private_data, struct smbpasswd_search_state);
1567
1568         if (state->current == state->num_entries) {
1569                 return false;
1570         }
1571
1572         entry->idx = state->entries[state->current].idx;
1573         entry->rid = state->entries[state->current].rid;
1574         entry->acct_flags = state->entries[state->current].acct_flags;
1575
1576         entry->account_name = talloc_strdup(
1577                 search, state->entries[state->current].account_name);
1578         entry->fullname = talloc_strdup(
1579                 search, state->entries[state->current].fullname);
1580         entry->description = talloc_strdup(
1581                 search, state->entries[state->current].description);
1582
1583         if ((entry->account_name == NULL) || (entry->fullname == NULL)
1584             || (entry->description == NULL)) {
1585                 DEBUG(0, ("talloc_strdup failed\n"));
1586                 return false;
1587         }
1588
1589         state->current += 1;
1590         return true;
1591 }
1592
1593 static bool smbpasswd_search_users(struct pdb_methods *methods,
1594                                    struct pdb_search *search,
1595                                    uint32_t acct_flags)
1596 {
1597         struct smbpasswd_privates *smbpasswd_state =
1598                 (struct smbpasswd_privates*)methods->private_data;
1599
1600         struct smbpasswd_search_state *search_state;
1601         struct smb_passwd *pwd;
1602         FILE *fp;
1603
1604         search_state = talloc_zero(search, struct smbpasswd_search_state);
1605         if (search_state == NULL) {
1606                 DEBUG(0, ("talloc failed\n"));
1607                 return false;
1608         }
1609         search_state->acct_flags = acct_flags;
1610
1611         fp = startsmbfilepwent(smbpasswd_state->smbpasswd_file, PWF_READ,
1612                                &smbpasswd_state->pw_file_lock_depth);
1613
1614         if (fp == NULL) {
1615                 DEBUG(10, ("Unable to open smbpasswd file.\n"));
1616                 TALLOC_FREE(search_state);
1617                 return false;
1618         }
1619
1620         while ((pwd = getsmbfilepwent(smbpasswd_state, fp)) != NULL) {
1621                 struct samr_displayentry entry;
1622                 struct samu *user;
1623
1624                 if ((acct_flags != 0)
1625                     && ((acct_flags & pwd->acct_ctrl) == 0)) {
1626                         continue;
1627                 }
1628
1629                 user = samu_new(talloc_tos());
1630                 if (user == NULL) {
1631                         DEBUG(0, ("samu_new failed\n"));
1632                         break;
1633                 }
1634
1635                 if (!build_sam_account(smbpasswd_state, user, pwd)) {
1636                         /* Already got debug msgs... */
1637                         break;
1638                 }
1639
1640                 ZERO_STRUCT(entry);
1641
1642                 entry.acct_flags = pdb_get_acct_ctrl(user);
1643                 sid_peek_rid(pdb_get_user_sid(user), &entry.rid);
1644                 entry.account_name = talloc_strdup(
1645                         search_state, pdb_get_username(user));
1646                 entry.fullname = talloc_strdup(
1647                         search_state, pdb_get_fullname(user));
1648                 entry.description = talloc_strdup(
1649                         search_state, pdb_get_acct_desc(user));
1650
1651                 TALLOC_FREE(user);
1652
1653                 if ((entry.account_name == NULL) || (entry.fullname == NULL)
1654                     || (entry.description == NULL)) {
1655                         DEBUG(0, ("talloc_strdup failed\n"));
1656                         break;
1657                 }
1658
1659                 ADD_TO_LARGE_ARRAY(search_state, struct samr_displayentry,
1660                                    entry, &search_state->entries,
1661                                    &search_state->num_entries,
1662                                    &search_state->array_size);
1663         }
1664
1665         endsmbfilepwent(fp, &(smbpasswd_state->pw_file_lock_depth));
1666
1667         search->private_data = search_state;
1668         search->next_entry = smbpasswd_search_next_entry;
1669         search->search_end = smbpasswd_search_end;
1670
1671         return true;
1672 }
1673
1674 static NTSTATUS pdb_init_smbpasswd( struct pdb_methods **pdb_method, const char *location )
1675 {
1676         NTSTATUS nt_status;
1677         struct smbpasswd_privates *privates;
1678
1679         if ( !NT_STATUS_IS_OK(nt_status = make_pdb_method( pdb_method )) ) {
1680                 return nt_status;
1681         }
1682
1683         (*pdb_method)->name = "smbpasswd";
1684
1685         (*pdb_method)->getsampwnam = smbpasswd_getsampwnam;
1686         (*pdb_method)->getsampwsid = smbpasswd_getsampwsid;
1687         (*pdb_method)->add_sam_account = smbpasswd_add_sam_account;
1688         (*pdb_method)->update_sam_account = smbpasswd_update_sam_account;
1689         (*pdb_method)->delete_sam_account = smbpasswd_delete_sam_account;
1690         (*pdb_method)->rename_sam_account = smbpasswd_rename_sam_account;
1691         (*pdb_method)->search_users = smbpasswd_search_users;
1692
1693         (*pdb_method)->capabilities = smbpasswd_capabilities;
1694
1695         /* Setup private data and free function */
1696
1697         if ( !(privates = talloc_zero( *pdb_method, struct smbpasswd_privates )) ) {
1698                 DEBUG(0, ("talloc() failed for smbpasswd private_data!\n"));
1699                 return NT_STATUS_NO_MEMORY;
1700         }
1701
1702         /* Store some config details */
1703
1704         if (location) {
1705                 privates->smbpasswd_file = talloc_strdup(*pdb_method, location);
1706         } else {
1707                 privates->smbpasswd_file = talloc_strdup(*pdb_method, lp_smb_passwd_file());
1708         }
1709
1710         if (!privates->smbpasswd_file) {
1711                 DEBUG(0, ("talloc_strdp() failed for storing smbpasswd location!\n"));
1712                 return NT_STATUS_NO_MEMORY;
1713         }
1714
1715         (*pdb_method)->private_data = privates;
1716
1717         (*pdb_method)->free_private_data = free_private_data;
1718
1719         return NT_STATUS_OK;
1720 }
1721
1722 NTSTATUS pdb_smbpasswd_init(void)
1723 {
1724         return smb_register_passdb(PASSDB_INTERFACE_VERSION, "smbpasswd", pdb_init_smbpasswd);
1725 }