source/passdb/pdb_tdb.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * SMB parameters and setup
   4  * Copyright (C) Andrew Tridgell   1992-1998
   5  * Copyright (C) Simo Sorce        2000-2003
   6  * Copyright (C) Gerald Carter     2000
   7  * Copyright (C) Jeremy Allison    2001
   8  * Copyright (C) Andrew Bartlett   2002
   9  * Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2005
  10  *
  11  * This program is free software; you can redistribute it and/or modify it under
  12  * the terms of the GNU General Public License as published by the Free
  13  * Software Foundation; either version 2 of the License, or (at your option)
  14  * any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful, but WITHOUT
  17  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  19  * more details.
  20  *
  21  * You should have received a copy of the GNU General Public License along with
  22  * this program; if not, write to the Free Software Foundation, Inc., 675
  23  * Mass Ave, Cambridge, MA 02139, USA.
  24  */
  25
  26 #include "includes.h"
  27
  28 #if 0 /* when made a module use this */
  29
  30 static int tdbsam_debug_level = DBGC_ALL;
  31 #undef DBGC_CLASS
  32 #define DBGC_CLASS tdbsam_debug_level
  33
  34 #else
  35
  36 #undef DBGC_CLASS
  37 #define DBGC_CLASS DBGC_PASSDB
  38
  39 #endif
  40
  41 #define TDBSAM_VERSION  2       /* Most recent TDBSAM version */
  42 #define TDBSAM_VERSION_STRING   "INFO/version"
  43 #define PASSDB_FILE_NAME        "passdb.tdb"
  44 #define USERPREFIX              "USER_"
  45 #define RIDPREFIX               "RID_"
  46 #define PRIVPREFIX              "PRIV_"
  47 #define tdbsamver_t     int32
  48
  49 struct tdbsam_privates {
  50         TDB_CONTEXT     *passwd_tdb;
  51
  52         /* retrive-once info */
  53         const char *tdbsam_location;
  54 };
  55
  56 struct pwent_list {
  57         struct pwent_list *prev, *next;
  58         TDB_DATA key;
  59 };
  60 static struct pwent_list *tdbsam_pwent_list;
  61
  62
  63 /**
  64  * Convert old TDBSAM to the latest version.
  65  * @param pdb_tdb A pointer to the opened TDBSAM file which must be converted.
  66  *                This file must be opened with read/write access.
  67  * @param from Current version of the TDBSAM file.
  68  * @return True if the conversion has been successful, false otherwise.
  69  **/
  70
  71 static BOOL tdbsam_convert(TDB_CONTEXT *pdb_tdb, tdbsamver_t from)
  72 {
  73         const char * vstring = TDBSAM_VERSION_STRING;
  74         SAM_ACCOUNT *user = NULL;
  75         const char *prefix = USERPREFIX;
  76         TDB_DATA        data, key, old_key;
  77         uint8           *buf = NULL;
  78         BOOL            ret;
  79
  80         if (pdb_tdb == NULL) {
  81                 DEBUG(0,("tdbsam_convert: Bad TDB Context pointer.\n"));
  82                 return False;
  83         }
  84
  85         /* handle a Samba upgrade */
  86         tdb_lock_bystring(pdb_tdb, vstring, 0);
  87
  88         if (!NT_STATUS_IS_OK(pdb_init_sam(&user))) {
  89                 DEBUG(0,("tdbsam_convert: cannot initialized a SAM_ACCOUNT.\n"));
  90                 return False;
  91         }
  92
  93         /* Enumerate all records and convert them */
  94         key = tdb_firstkey(pdb_tdb);
  95
  96         while (key.dptr) {
  97
  98                 /* skip all non-USER entries (eg. RIDs) */
  99                 while ((key.dsize != 0) && (strncmp(key.dptr, prefix, strlen (prefix)))) {
 100                         old_key = key;
 101                         /* increment to next in line */
 102                         key = tdb_nextkey(pdb_tdb, key);
 103                         SAFE_FREE(old_key.dptr);
 104                 }
 105
 106                 if (key.dptr) {
 107
 108                         /* read from tdbsam */
 109                         data = tdb_fetch(pdb_tdb, key);
 110                         if (!data.dptr) {
 111                                 DEBUG(0,("tdbsam_convert: database entry not found: %s.\n",key.dptr));
 112                                 return False;
 113                         }
 114
 115                         if (!NT_STATUS_IS_OK(pdb_reset_sam(user))) {
 116                                 DEBUG(0,("tdbsam_convert: cannot reset SAM_ACCOUNT.\n"));
 117                                 SAFE_FREE(data.dptr);
 118                                 return False;
 119                         }
 120
 121                         /* unpack the buffer from the former format */
 122                         DEBUG(10,("tdbsam_convert: Try unpacking a record with (key:%s) (version:%d)\n", key.dptr, from));
 123                         switch (from) {
 124                                 case 0:
 125                                         ret = init_sam_from_buffer_v0(user, (uint8 *)data.dptr, data.dsize);
 126                                         break;
 127                                 case 1:
 128                                         ret = init_sam_from_buffer_v1(user, (uint8 *)data.dptr, data.dsize);
 129                                         break;
 130                                 case 2:
 131                                         ret = init_sam_from_buffer_v2(user, (uint8 *)data.dptr, data.dsize);
 132                                         break;
 133                                 default:
 134                                         /* unknown tdbsam version */
 135                                         ret = False;
 136                         }
 137                         if (!ret) {
 138                                 DEBUG(0,("tdbsam_convert: Bad SAM_ACCOUNT entry returned from TDB (key:%s) (version:%d)\n", key.dptr, from));
 139                                 SAFE_FREE(data.dptr);
 140                                 return False;
 141                         }
 142
 143                         /* We're finished with the old data. */
 144                         SAFE_FREE(data.dptr);
 145
 146                         /* pack from the buffer into the new format */
 147                         DEBUG(10,("tdbsam_convert: Try packing a record (key:%s) (version:%d)\n", key.dptr, from));
 148                         if ((data.dsize=init_buffer_from_sam (&buf, user, False)) == -1) {
 149                                 DEBUG(0,("tdbsam_convert: cannot pack the SAM_ACCOUNT into the new format\n"));
 150                                 SAFE_FREE(data.dptr);
 151                                 return False;
 152                         }
 153                         data.dptr = (char *)buf;
 154
 155                         /* Store the buffer inside the TDBSAM */
 156                         if (tdb_store(pdb_tdb, key, data, TDB_MODIFY) != TDB_SUCCESS) {
 157                                 DEBUG(0,("tdbsam_convert: cannot store the SAM_ACCOUNT (key:%s) in new format\n",key.dptr));
 158                                 SAFE_FREE(data.dptr);
 159                                 return False;
 160                         }
 161
 162                         SAFE_FREE(data.dptr);
 163
 164                         /* increment to next in line */
 165                         old_key = key;
 166                         key = tdb_nextkey(pdb_tdb, key);
 167                         SAFE_FREE(old_key.dptr);
 168                 }
 169
 170         }
 171
 172         pdb_free_sam(&user);
 173
 174         /* upgrade finished */
 175         tdb_store_int32(pdb_tdb, vstring, TDBSAM_VERSION);
 176         tdb_unlock_bystring(pdb_tdb, vstring);
 177
 178         return(True);
 179 }
 180
 181 /**
 182  * Open the TDB passwd database, check version and convert it if needed.
 183  * @param name filename of the tdbsam file.
 184  * @param open_flags file access mode.
 185  * @return a TDB_CONTEXT handle on the tdbsam file.
 186  **/
 187
 188 static TDB_CONTEXT * tdbsam_tdbopen (const char *name, int open_flags)
 189 {
 190         TDB_CONTEXT     *pdb_tdb;
 191         tdbsamver_t     version;
 192
 193         /* Try to open tdb passwd */
 194         if (!(pdb_tdb = tdb_open_log(name, 0, TDB_DEFAULT,
 195                                      open_flags, 0600))) {
 196                 DEBUG(0, ("Unable to open/create TDB passwd\n"));
 197                 return NULL;
 198         }
 199
 200         /* Check the version */
 201         version = (tdbsamver_t) tdb_fetch_int32(pdb_tdb,
 202                                                 TDBSAM_VERSION_STRING);
 203         if (version == -1)
 204                 version = 0;    /* Version not found, assume version 0 */
 205
 206         /* Compare the version */
 207         if (version > TDBSAM_VERSION) {
 208                 /* Version more recent than the latest known */
 209                 DEBUG(0, ("TDBSAM version unknown: %d\n", version));
 210                 tdb_close(pdb_tdb);
 211                 pdb_tdb = NULL;
 212         }
 213         else if (version < TDBSAM_VERSION) {
 214                 /* Older version, must be converted */
 215                 DEBUG(1, ("TDBSAM version too old (%d), trying to convert it.\n", version));
 216
 217                 /* Reopen the pdb file with read-write access if needed */
 218                 if (!(open_flags & O_RDWR)) {
 219                         DEBUG(10, ("tdbsam_tdbopen: TDB file opened with read only access, reopen it with read-write access.\n"));
 220                         tdb_close(pdb_tdb);
 221                         pdb_tdb = tdb_open_log(name, 0, TDB_DEFAULT, (open_flags & 07777770) | O_RDWR, 0600);
 222                 }
 223
 224                 /* Convert */
 225                 if (!tdbsam_convert(pdb_tdb, version)){
 226                         DEBUG(0, ("tdbsam_tdbopen: Error when trying to convert tdbsam: %s\n",name));
 227                         tdb_close(pdb_tdb);
 228                         pdb_tdb = NULL;
 229                 } else {
 230                         DEBUG(1, ("TDBSAM converted successfully.\n"));
 231                 }
 232
 233                 /* Reopen the pdb file as it must be */
 234                 if (!(open_flags & O_RDWR)) {
 235                         tdb_close(pdb_tdb);
 236                         pdb_tdb = tdb_open_log(name, 0, TDB_DEFAULT, open_flags, 0600);
 237                 }
 238         }
 239
 240         return pdb_tdb;
 241 }
 242
 243 /*****************************************************************************
 244  Utility functions to close the tdb sam database
 245  ****************************************************************************/
 246
 247 static void tdbsam_tdbclose ( struct tdbsam_privates *state )
 248 {
 249         if ( !state )
 250                 return;
 251
 252         if ( state->passwd_tdb ) {
 253                 tdb_close( state->passwd_tdb );
 254                 state->passwd_tdb = NULL;
 255         }
 256
 257         return;
 258
 259 }
 260
 261 /****************************************************************************
 262  creates a list of user keys
 263 ****************************************************************************/
 264
 265 static int tdbsam_traverse_setpwent(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
 266 {
 267         const char *prefix = USERPREFIX;
 268         int  prefixlen = strlen (prefix);
 269         struct pwent_list *ptr;
 270
 271         if ( strncmp(key.dptr, prefix, prefixlen) == 0 ) {
 272                 if ( !(ptr=SMB_MALLOC_P(struct pwent_list)) ) {
 273                         DEBUG(0,("tdbsam_traverse_setpwent: Failed to malloc new entry for list\n"));
 274
 275                         /* just return 0 and let the traversal continue */
 276                         return 0;
 277                 }
 278                 ZERO_STRUCTP(ptr);
 279
 280                 /* save a copy of the key */
 281
 282                 ptr->key.dptr = memdup( key.dptr, key.dsize );
 283                 ptr->key.dsize = key.dsize;
 284
 285                 DLIST_ADD( tdbsam_pwent_list, ptr );
 286
 287         }
 288
 289
 290         return 0;
 291 }
 292
 293 /***************************************************************
 294  Open the TDB passwd database for SAM account enumeration.
 295  Save a list of user keys for iteration.
 296 ****************************************************************/
 297
 298 static NTSTATUS tdbsam_setsampwent(struct pdb_methods *my_methods, BOOL update, uint16 acb_mask)
 299 {
 300         uint32 flags = update ? (O_RDWR|O_CREAT) : O_RDONLY;
 301
 302         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 303
 304         if ( !(tdb_state->passwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, flags )) )
 305                 return NT_STATUS_UNSUCCESSFUL;
 306
 307         tdb_traverse( tdb_state->passwd_tdb, tdbsam_traverse_setpwent, NULL );
 308
 309         return NT_STATUS_OK;
 310 }
 311
 312
 313 /***************************************************************
 314  End enumeration of the TDB passwd list.
 315 ****************************************************************/
 316
 317 static void tdbsam_endsampwent(struct pdb_methods *my_methods)
 318 {
 319         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 320         struct pwent_list *ptr, *ptr_next;
 321
 322         tdbsam_tdbclose( tdb_state );
 323
 324         /* clear out any remaining entries in the list */
 325
 326         for ( ptr=tdbsam_pwent_list; ptr; ptr = ptr_next ) {
 327                 ptr_next = ptr->next;
 328                 DLIST_REMOVE( tdbsam_pwent_list, ptr );
 329                 SAFE_FREE( ptr->key.dptr);
 330                 SAFE_FREE( ptr );
 331         }
 332
 333         DEBUG(7, ("endtdbpwent: closed sam database.\n"));
 334 }
 335
 336 /*****************************************************************
 337  Get one SAM_ACCOUNT from the TDB (next in line)
 338 *****************************************************************/
 339
 340 static NTSTATUS tdbsam_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *user)
 341 {
 342         NTSTATUS                nt_status = NT_STATUS_UNSUCCESSFUL;
 343         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 344         TDB_DATA                data;
 345         struct pwent_list       *pkey;
 346
 347         if ( !user ) {
 348                 DEBUG(0,("tdbsam_getsampwent: SAM_ACCOUNT is NULL.\n"));
 349                 return nt_status;
 350         }
 351
 352         if ( !tdbsam_pwent_list ) {
 353                 DEBUG(4,("tdbsam_getsampwent: end of list\n"));
 354                 tdbsam_tdbclose( tdb_state );
 355                 return nt_status;
 356         }
 357
 358         if ( !tdb_state->passwd_tdb ) {
 359                 if ( !(tdb_state->passwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDONLY)) )
 360                         return nt_status;
 361         }
 362
 363         /* pull the next entry */
 364
 365         pkey = tdbsam_pwent_list;
 366         DLIST_REMOVE( tdbsam_pwent_list, pkey );
 367
 368         data = tdb_fetch(tdb_state->passwd_tdb, pkey->key);
 369
 370         SAFE_FREE( pkey->key.dptr);
 371         SAFE_FREE( pkey);
 372
 373         if (!data.dptr) {
 374                 DEBUG(5,("pdb_getsampwent: database entry not found.  Was the user deleted?\n"));
 375                 return nt_status;
 376         }
 377
 378         if (!init_sam_from_buffer(user, (unsigned char *)data.dptr, data.dsize)) {
 379                 DEBUG(0,("pdb_getsampwent: Bad SAM_ACCOUNT entry returned from TDB!\n"));
 380         }
 381
 382         SAFE_FREE( data.dptr );
 383
 384
 385         return NT_STATUS_OK;
 386 }
 387
 388 /******************************************************************
 389  Lookup a name in the SAM TDB
 390 ******************************************************************/
 391
 392 static NTSTATUS tdbsam_getsampwnam (struct pdb_methods *my_methods, SAM_ACCOUNT *user, const char *sname)
 393 {
 394         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 395         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 396         TDB_CONTEXT     *pwd_tdb;
 397         TDB_DATA        data, key;
 398         fstring         keystr;
 399         fstring         name;
 400
 401         if ( !user ) {
 402                 DEBUG(0,("pdb_getsampwnam: SAM_ACCOUNT is NULL.\n"));
 403                 return nt_status;
 404         }
 405
 406         /* Data is stored in all lower-case */
 407         fstrcpy(name, sname);
 408         strlower_m(name);
 409
 410         /* set search key */
 411         slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
 412         key.dptr = keystr;
 413         key.dsize = strlen(keystr) + 1;
 414
 415         /* open the accounts TDB */
 416         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDONLY))) {
 417
 418                 if (errno == ENOENT) {
 419                         /*
 420                          * TDB file doesn't exist, so try to create new one. This is useful to avoid
 421                          * confusing error msg when adding user account first time
 422                          */
 423                         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_CREAT ))) {
 424                                 DEBUG(0, ("pdb_getsampwnam: TDB passwd (%s) did not exist. File successfully created.\n",
 425                                           tdb_state->tdbsam_location));
 426                         } else {
 427                                 DEBUG(0, ("pdb_getsampwnam: TDB passwd (%s) does not exist. Couldn't create new one. Error was: %s\n",
 428                                           tdb_state->tdbsam_location, strerror(errno)));
 429                         }
 430
 431                         /* requested user isn't there anyway */
 432                         nt_status = NT_STATUS_NO_SUCH_USER;
 433                         return nt_status;
 434                 }
 435                 DEBUG(0, ("pdb_getsampwnam: Unable to open TDB passwd (%s)!\n", tdb_state->tdbsam_location));
 436                 return nt_status;
 437         }
 438
 439         /* get the record */
 440         data = tdb_fetch(pwd_tdb, key);
 441         if (!data.dptr) {
 442                 DEBUG(5,("pdb_getsampwnam (TDB): error fetching database.\n"));
 443                 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 444                 DEBUGADD(5, (" Key: %s\n", keystr));
 445                 tdb_close(pwd_tdb);
 446                 return nt_status;
 447         }
 448
 449         /* unpack the buffer */
 450         if (!init_sam_from_buffer(user, (unsigned char *)data.dptr, data.dsize)) {
 451                 DEBUG(0,("pdb_getsampwent: Bad SAM_ACCOUNT entry returned from TDB!\n"));
 452                 SAFE_FREE(data.dptr);
 453                 tdb_close(pwd_tdb);
 454                 return nt_status;
 455         }
 456         SAFE_FREE(data.dptr);
 457
 458         /* no further use for database, close it now */
 459         tdb_close(pwd_tdb);
 460
 461         return NT_STATUS_OK;
 462 }
 463
 464 /***************************************************************************
 465  Search by rid
 466  **************************************************************************/
 467
 468 static NTSTATUS tdbsam_getsampwrid (struct pdb_methods *my_methods, SAM_ACCOUNT *user, uint32 rid)
 469 {
 470         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 471         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 472         TDB_CONTEXT             *pwd_tdb;
 473         TDB_DATA                data, key;
 474         fstring                 keystr;
 475         fstring                 name;
 476
 477         if (user==NULL) {
 478                 DEBUG(0,("pdb_getsampwrid: SAM_ACCOUNT is NULL.\n"));
 479                 return nt_status;
 480         }
 481
 482         /* set search key */
 483         slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, rid);
 484         key.dptr = keystr;
 485         key.dsize = strlen (keystr) + 1;
 486
 487         /* open the accounts TDB */
 488         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDONLY))) {
 489                 DEBUG(0, ("pdb_getsampwrid: Unable to open TDB rid database!\n"));
 490                 return nt_status;
 491         }
 492
 493         /* get the record */
 494         data = tdb_fetch (pwd_tdb, key);
 495         if (!data.dptr) {
 496                 DEBUG(5,("pdb_getsampwrid (TDB): error looking up RID %d by key %s.\n", rid, keystr));
 497                 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 498                 tdb_close (pwd_tdb);
 499                 return nt_status;
 500         }
 501
 502
 503         fstrcpy(name, data.dptr);
 504         SAFE_FREE(data.dptr);
 505
 506         tdb_close (pwd_tdb);
 507
 508         return tdbsam_getsampwnam (my_methods, user, name);
 509 }
 510
 511 static NTSTATUS tdbsam_getsampwsid(struct pdb_methods *my_methods, SAM_ACCOUNT * user, const DOM_SID *sid)
 512 {
 513         uint32 rid;
 514         if (!sid_peek_check_rid(get_global_sam_sid(), sid, &rid))
 515                 return NT_STATUS_UNSUCCESSFUL;
 516         return tdbsam_getsampwrid(my_methods, user, rid);
 517 }
 518
 519 static BOOL tdb_delete_samacct_only(TDB_CONTEXT *pwd_tdb,
 520                                     struct pdb_methods *my_methods,
 521                                     SAM_ACCOUNT *sam_pass)
 522 {
 523         TDB_DATA        key;
 524         fstring         keystr;
 525         fstring         name;
 526
 527         fstrcpy(name, pdb_get_username(sam_pass));
 528         strlower_m(name);
 529
 530         /* set the search key */
 531         slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
 532         key.dptr = keystr;
 533         key.dsize = strlen (keystr) + 1;
 534
 535         /* it's outaa here!  8^) */
 536         if (tdb_delete(pwd_tdb, key) != TDB_SUCCESS) {
 537                 DEBUG(5, ("Error deleting entry from tdb passwd database!\n"));
 538                 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 539                 tdb_close(pwd_tdb);
 540                 return False;
 541         }
 542         return True;
 543 }
 544
 545 /***************************************************************************
 546  Delete a SAM_ACCOUNT
 547 ****************************************************************************/
 548
 549 static NTSTATUS tdbsam_delete_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT *sam_pass)
 550 {
 551         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 552         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 553         TDB_CONTEXT     *pwd_tdb;
 554         TDB_DATA        key;
 555         fstring         keystr;
 556         uint32          rid;
 557         fstring         name;
 558
 559         fstrcpy(name, pdb_get_username(sam_pass));
 560         strlower_m(name);
 561
 562         /* open the TDB */
 563         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDWR))) {
 564                 DEBUG(0, ("Unable to open TDB passwd!"));
 565                 return nt_status;
 566         }
 567
 568         /* set the search key */
 569         slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
 570         key.dptr = keystr;
 571         key.dsize = strlen (keystr) + 1;
 572
 573         rid = pdb_get_user_rid(sam_pass);
 574
 575         /* it's outaa here!  8^) */
 576         if (tdb_delete(pwd_tdb, key) != TDB_SUCCESS) {
 577                 DEBUG(5, ("Error deleting entry from tdb passwd database!\n"));
 578                 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 579                 tdb_close(pwd_tdb);
 580                 return nt_status;
 581         }
 582
 583         /* delete also the RID key */
 584
 585         /* set the search key */
 586         slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, rid);
 587         key.dptr = keystr;
 588         key.dsize = strlen (keystr) + 1;
 589
 590         /* it's outaa here!  8^) */
 591         if (tdb_delete(pwd_tdb, key) != TDB_SUCCESS) {
 592                 DEBUG(5, ("Error deleting entry from tdb rid database!\n"));
 593                 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 594                 tdb_close(pwd_tdb);
 595                 return nt_status;
 596         }
 597
 598         tdb_close(pwd_tdb);
 599
 600         return NT_STATUS_OK;
 601 }
 602
 603
 604 /***************************************************************************
 605  Update the TDB SAM account record only
 606 ****************************************************************************/
 607 static BOOL tdb_update_samacct_only(TDB_CONTEXT *pwd_tdb,
 608                                     struct pdb_methods *my_methods,
 609                                     SAM_ACCOUNT* newpwd, int flag)
 610 {
 611         TDB_DATA        key, data;
 612         uint8           *buf = NULL;
 613         fstring         keystr;
 614         fstring         name;
 615         BOOL            ret = True;
 616
 617         /* copy the SAM_ACCOUNT struct into a BYTE buffer for storage */
 618         if ((data.dsize=init_buffer_from_sam (&buf, newpwd, False)) == -1) {
 619                 DEBUG(0,("tdb_update_sam: ERROR - Unable to copy SAM_ACCOUNT info BYTE buffer!\n"));
 620                 ret = False;
 621                 goto done;
 622         }
 623         data.dptr = (char *)buf;
 624
 625         fstrcpy(name, pdb_get_username(newpwd));
 626         strlower_m(name);
 627
 628         DEBUG(5, ("Storing %saccount %s with RID %d\n",
 629                   flag == TDB_INSERT ? "(new) " : "", name,
 630                   pdb_get_user_rid(newpwd)));
 631
 632         /* setup the USER index key */
 633         slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
 634         key.dptr = keystr;
 635         key.dsize = strlen(keystr) + 1;
 636
 637         /* add the account */
 638         if (tdb_store(pwd_tdb, key, data, flag) != TDB_SUCCESS) {
 639                 DEBUG(0, ("Unable to modify passwd TDB!"));
 640                 DEBUGADD(0, (" Error: %s", tdb_errorstr(pwd_tdb)));
 641                 DEBUGADD(0, (" occured while storing the main record (%s)\n",
 642                              keystr));
 643                 ret = False;
 644                 goto done;
 645         }
 646
 647 done:
 648         /* cleanup */
 649         SAFE_FREE(buf);
 650
 651         return (ret);
 652 }
 653
 654 /***************************************************************************
 655  Update the TDB SAM RID record only
 656 ****************************************************************************/
 657 static BOOL tdb_update_ridrec_only(TDB_CONTEXT *pwd_tdb,
 658                                    struct pdb_methods *my_methods,
 659                                    SAM_ACCOUNT* newpwd, int flag)
 660 {
 661         TDB_DATA        key, data;
 662         fstring         keystr;
 663         fstring         name;
 664
 665         fstrcpy(name, pdb_get_username(newpwd));
 666         strlower_m(name);
 667
 668         /* setup RID data */
 669         data.dsize = strlen(name) + 1;
 670         data.dptr = name;
 671
 672         /* setup the RID index key */
 673         slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX,
 674                  pdb_get_user_rid(newpwd));
 675         key.dptr = keystr;
 676         key.dsize = strlen (keystr) + 1;
 677
 678         /* add the reference */
 679         if (tdb_store(pwd_tdb, key, data, flag) != TDB_SUCCESS) {
 680                 DEBUG(0, ("Unable to modify TDB passwd !"));
 681                 DEBUGADD(0, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 682                 DEBUGADD(0, (" occured while storing the RID index (%s)\n", keystr));
 683                 return False;
 684         }
 685
 686         return True;
 687
 688 }
 689
 690 /***************************************************************************
 691  Update the TDB SAM
 692 ****************************************************************************/
 693
 694 static BOOL tdb_update_sam(struct pdb_methods *my_methods, SAM_ACCOUNT* newpwd, int flag)
 695 {
 696         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 697         TDB_CONTEXT     *pwd_tdb = NULL;
 698         BOOL            ret = True;
 699         uint32          user_rid;
 700
 701         /* invalidate the existing TDB iterator if it is open */
 702
 703         if (tdb_state->passwd_tdb) {
 704                 tdb_close(tdb_state->passwd_tdb);
 705                 tdb_state->passwd_tdb = NULL;
 706         }
 707
 708         /* open the account TDB passwd*/
 709
 710         pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDWR | O_CREAT);
 711
 712         if (!pwd_tdb) {
 713                 DEBUG(0, ("tdb_update_sam: Unable to open TDB passwd (%s)!\n",
 714                         tdb_state->tdbsam_location));
 715                 return False;
 716         }
 717
 718         if (!pdb_get_group_rid(newpwd)) {
 719                 DEBUG (0,("tdb_update_sam: Failing to store a SAM_ACCOUNT for [%s] without a primary group RID\n",
 720                         pdb_get_username(newpwd)));
 721                 ret = False;
 722                 goto done;
 723         }
 724
 725         if ( !(user_rid = pdb_get_user_rid(newpwd)) ) {
 726                 DEBUG(0,("tdb_update_sam: SAM_ACCOUNT (%s) with no RID!\n", pdb_get_username(newpwd)));
 727                 ret = False;
 728                 goto done;
 729         }
 730
 731         if (!tdb_update_samacct_only(pwd_tdb, my_methods, newpwd, flag) ||
 732             !tdb_update_ridrec_only(pwd_tdb, my_methods, newpwd, flag)) {
 733                 ret = False;
 734                 goto done;
 735         }
 736
 737 done:
 738         /* cleanup */
 739         tdb_close (pwd_tdb);
 740
 741         return (ret);
 742 }
 743
 744 /***************************************************************************
 745  Modifies an existing SAM_ACCOUNT
 746 ****************************************************************************/
 747
 748 static NTSTATUS tdbsam_update_sam_account (struct pdb_methods *my_methods, SAM_ACCOUNT *newpwd)
 749 {
 750         if (tdb_update_sam(my_methods, newpwd, TDB_MODIFY))
 751                 return NT_STATUS_OK;
 752         else
 753                 return NT_STATUS_UNSUCCESSFUL;
 754 }
 755
 756 /***************************************************************************
 757  Adds an existing SAM_ACCOUNT
 758 ****************************************************************************/
 759
 760 static NTSTATUS tdbsam_add_sam_account (struct pdb_methods *my_methods, SAM_ACCOUNT *newpwd)
 761 {
 762         if (tdb_update_sam(my_methods, newpwd, TDB_INSERT))
 763                 return NT_STATUS_OK;
 764         else
 765                 return NT_STATUS_UNSUCCESSFUL;
 766 }
 767
 768 /***************************************************************************
 769  Renames a SAM_ACCOUNT
 770  - check for the posix user/rename user script
 771  - Add and lock the new user record
 772  - rename the posix user
 773  - rewrite the rid->username record
 774  - delete the old user
 775  - unlock the new user record
 776 ***************************************************************************/
 777 static NTSTATUS tdbsam_rename_sam_account(struct pdb_methods *my_methods,
 778                                           SAM_ACCOUNT *old_acct,
 779                                           const char *newname)
 780 {
 781         struct tdbsam_privates *tdb_state =
 782                 (struct tdbsam_privates *)my_methods->private_data;
 783         SAM_ACCOUNT *new_acct = NULL;
 784         pstring rename_script;
 785         TDB_CONTEXT     *pwd_tdb = NULL;
 786         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 787         BOOL interim_account = False;
 788
 789         if (!*(lp_renameuser_script()))
 790                 goto done;
 791
 792         if (!pdb_copy_sam_account(old_acct, &new_acct) ||
 793             !pdb_set_username(new_acct, newname, PDB_CHANGED))
 794                 goto done;
 795
 796         /* invalidate the existing TDB iterator if it is open */
 797
 798         if (tdb_state->passwd_tdb) {
 799                 tdb_close(tdb_state->passwd_tdb);
 800                 tdb_state->passwd_tdb = NULL;
 801         }
 802
 803         /* open the account TDB passwd */
 804
 805         pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDWR | O_CREAT);
 806
 807         if (!pwd_tdb) {
 808                 DEBUG(0, ("tdb_update_sam: Unable to open TDB passwd (%s)!\n",
 809                         tdb_state->tdbsam_location));
 810                 goto done;
 811         }
 812
 813         /* add the new account and lock it */
 814         if (!tdb_update_samacct_only(pwd_tdb, my_methods, new_acct,
 815                                      TDB_INSERT))
 816                 goto done;
 817         interim_account = True;
 818
 819         if (tdb_lock_bystring(pwd_tdb, newname, 30) == -1) {
 820                 goto done;
 821         }
 822
 823         /* rename the posix user */
 824         pstrcpy(rename_script, lp_renameuser_script());
 825
 826         if (*rename_script) {
 827                 int rename_ret;
 828
 829                 pstring_sub(rename_script, "%unew", newname);
 830                 pstring_sub(rename_script, "%uold",
 831                             pdb_get_username(old_acct));
 832                 rename_ret = smbrun(rename_script, NULL);
 833
 834                 DEBUG(rename_ret ? 0 : 3,("Running the command `%s' gave %d\n", rename_script, rename_ret));
 835
 836                 if (rename_ret)
 837                         goto done;
 838         } else {
 839                 goto done;
 840         }
 841
 842         /* rewrite the rid->username record */
 843         if (!tdb_update_ridrec_only(pwd_tdb, my_methods, new_acct, TDB_MODIFY))
 844                 goto done;
 845         interim_account = False;
 846         tdb_unlock_bystring(pwd_tdb, newname);
 847
 848         tdb_delete_samacct_only(pwd_tdb, my_methods, old_acct);
 849
 850         ret = NT_STATUS_OK;
 851
 852
 853 done:
 854         /* cleanup */
 855         if (interim_account) {
 856                 tdb_unlock_bystring(pwd_tdb, newname);
 857                 tdb_delete_samacct_only(pwd_tdb, my_methods, new_acct);
 858         }
 859         if (pwd_tdb)
 860                 tdb_close (pwd_tdb);
 861         if (new_acct)
 862                 pdb_free_sam(&new_acct);
 863
 864         return (ret);
 865 }
 866
 867 static void free_private_data(void **vp)
 868 {
 869         struct tdbsam_privates **tdb_state = (struct tdbsam_privates **)vp;
 870         tdbsam_tdbclose(*tdb_state);
 871         *tdb_state = NULL;
 872
 873         /* No need to free any further, as it is talloc()ed */
 874 }
 875
 876
 877
 878
 879 /**
 880  * Init tdbsam backend
 881  *
 882  * @param pdb_context initialised passdb context
 883  * @param pdb_method backend methods structure to be filled with function pointers
 884  * @param location the backend tdb file location
 885  *
 886  * @return nt_status code
 887  **/
 888
 889 static NTSTATUS pdb_init_tdbsam(PDB_CONTEXT *pdb_context, PDB_METHODS **pdb_method, const char *location)
 890 {
 891         NTSTATUS nt_status;
 892         struct tdbsam_privates *tdb_state;
 893
 894         if (!NT_STATUS_IS_OK(nt_status = make_pdb_methods(pdb_context->mem_ctx, pdb_method))) {
 895                 return nt_status;
 896         }
 897
 898         (*pdb_method)->name = "tdbsam";
 899
 900         (*pdb_method)->setsampwent = tdbsam_setsampwent;
 901         (*pdb_method)->endsampwent = tdbsam_endsampwent;
 902         (*pdb_method)->getsampwent = tdbsam_getsampwent;
 903         (*pdb_method)->getsampwnam = tdbsam_getsampwnam;
 904         (*pdb_method)->getsampwsid = tdbsam_getsampwsid;
 905         (*pdb_method)->add_sam_account = tdbsam_add_sam_account;
 906         (*pdb_method)->update_sam_account = tdbsam_update_sam_account;
 907         (*pdb_method)->delete_sam_account = tdbsam_delete_sam_account;
 908         (*pdb_method)->rename_sam_account = tdbsam_rename_sam_account;
 909
 910         tdb_state = TALLOC_ZERO_P(pdb_context->mem_ctx, struct tdbsam_privates);
 911
 912         if (!tdb_state) {
 913                 DEBUG(0, ("talloc() failed for tdbsam private_data!\n"));
 914                 return NT_STATUS_NO_MEMORY;
 915         }
 916
 917         if (location) {
 918                 tdb_state->tdbsam_location = talloc_strdup(pdb_context->mem_ctx, location);
 919         } else {
 920                 pstring tdbfile;
 921                 get_private_directory(tdbfile);
 922                 pstrcat(tdbfile, "/");
 923                 pstrcat(tdbfile, PASSDB_FILE_NAME);
 924                 tdb_state->tdbsam_location = talloc_strdup(pdb_context->mem_ctx, tdbfile);
 925         }
 926
 927         (*pdb_method)->private_data = tdb_state;
 928
 929         (*pdb_method)->free_private_data = free_private_data;
 930
 931         return NT_STATUS_OK;
 932 }
 933
 934 NTSTATUS pdb_tdbsam_init(void)
 935 {
 936         return smb_register_passdb(PASSDB_INTERFACE_VERSION, "tdbsam", pdb_init_tdbsam);
 937 }