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