source3/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-2002
   6  * Copyright (C) Gerald Carter     2000
   7  * Copyright (C) Jeremy Allison    2001
   8  * Copyright (C) Andrew Bartlett   2002
   9  *
  10  * This program is free software; you can redistribute it and/or modify it under
  11  * the terms of the GNU General Public License as published by the Free
  12  * Software Foundation; either version 2 of the License, or (at your option)
  13  * any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful, but WITHOUT
  16  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  18  * more details.
  19  *
  20  * You should have received a copy of the GNU General Public License along with
  21  * this program; if not, write to the Free Software Foundation, Inc., 675
  22  * Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 #include "includes.h"
  26
  27 #if 0 /* when made a module use this */
  28
  29 static int tdbsam_debug_level = DBGC_ALL;
  30 #undef DBGC_CLASS
  31 #define DBGC_CLASS tdbsam_debug_level
  32
  33 #else
  34
  35 #undef DBGC_CLASS
  36 #define DBGC_CLASS DBGC_PASSDB
  37
  38 #endif
  39
  40 #define TDBSAM_VERSION  1       /* Most recent TDBSAM version */
  41 #define TDBSAM_VERSION_STRING   "INFO/version"
  42 #define PASSDB_FILE_NAME        "passdb.tdb"
  43 #define USERPREFIX              "USER_"
  44 #define RIDPREFIX               "RID_"
  45 #define PRIVPREFIX              "PRIV_"
  46 #define tdbsamver_t     int32
  47
  48 struct tdbsam_privates {
  49         TDB_CONTEXT     *passwd_tdb;
  50
  51         /* retrive-once info */
  52         const char *tdbsam_location;
  53 };
  54
  55 struct pwent_list {
  56         struct pwent_list *prev, *next;
  57         TDB_DATA key;
  58 };
  59 static struct pwent_list *tdbsam_pwent_list;
  60
  61
  62 /**
  63  * Convert old TDBSAM to the latest version.
  64  * @param pdb_tdb A pointer to the opened TDBSAM file which must be converted.
  65  *                This file must be opened with read/write access.
  66  * @param from Current version of the TDBSAM file.
  67  * @return True if the conversion has been successful, false otherwise.
  68  **/
  69
  70 static BOOL tdbsam_convert(TDB_CONTEXT *pdb_tdb, tdbsamver_t from)
  71 {
  72         const char * vstring = TDBSAM_VERSION_STRING;
  73         SAM_ACCOUNT *user = NULL;
  74         const char *prefix = USERPREFIX;
  75         TDB_DATA        data, key, old_key;
  76         uint8           *buf = NULL;
  77         BOOL            ret;
  78
  79         if (pdb_tdb == NULL) {
  80                 DEBUG(0,("tdbsam_convert: Bad TDB Context pointer.\n"));
  81                 return False;
  82         }
  83
  84         /* handle a Samba upgrade */
  85         tdb_lock_bystring(pdb_tdb, vstring, 0);
  86
  87         if (!NT_STATUS_IS_OK(pdb_init_sam(&user))) {
  88                 DEBUG(0,("tdbsam_convert: cannot initialized a SAM_ACCOUNT.\n"));
  89                 return False;
  90         }
  91
  92         /* Enumerate all records and convert them */
  93         key = tdb_firstkey(pdb_tdb);
  94
  95         while (key.dptr) {
  96
  97                 /* skip all non-USER entries (eg. RIDs) */
  98                 while ((key.dsize != 0) && (strncmp(key.dptr, prefix, strlen (prefix)))) {
  99                         old_key = key;
 100                         /* increment to next in line */
 101                         key = tdb_nextkey(pdb_tdb, key);
 102                         SAFE_FREE(old_key.dptr);
 103                 }
 104
 105                 if (key.dptr) {
 106
 107                         /* read from tdbsam */
 108                         data = tdb_fetch(pdb_tdb, key);
 109                         if (!data.dptr) {
 110                                 DEBUG(0,("tdbsam_convert: database entry not found: %s.\n",key.dptr));
 111                                 return False;
 112                         }
 113
 114                         if (!NT_STATUS_IS_OK(pdb_reset_sam(user))) {
 115                                 DEBUG(0,("tdbsam_convert: cannot reset SAM_ACCOUNT.\n"));
 116                                 SAFE_FREE(data.dptr);
 117                                 return False;
 118                         }
 119
 120                         /* unpack the buffer from the former format */
 121                         DEBUG(10,("tdbsam_convert: Try unpacking a record with (key:%s) (version:%d)\n", key.dptr, from));
 122                         switch (from) {
 123                                 case 0:
 124                                         ret = init_sam_from_buffer_v0(user, (uint8 *)data.dptr, data.dsize);
 125                                         break;
 126                                 case 1:
 127                                         ret = init_sam_from_buffer_v1(user, (uint8 *)data.dptr, data.dsize);
 128                                         break;
 129                                 default:
 130                                         /* unknown tdbsam version */
 131                                         ret = False;
 132                         }
 133                         if (!ret) {
 134                                 DEBUG(0,("tdbsam_convert: Bad SAM_ACCOUNT entry returned from TDB (key:%s) (version:%d)\n", key.dptr, from));
 135                                 SAFE_FREE(data.dptr);
 136                                 return False;
 137                         }
 138
 139                         /* pack from the buffer into the new format */
 140                         DEBUG(10,("tdbsam_convert: Try packing a record (key:%s) (version:%d)\n", key.dptr, from));
 141                         if ((data.dsize=init_buffer_from_sam (&buf, user, False)) == -1) {
 142                                 DEBUG(0,("tdbsam_convert: cannot pack the SAM_ACCOUNT into the new format\n"));
 143                                 SAFE_FREE(data.dptr);
 144                                 return False;
 145                         }
 146                         data.dptr = (char *)buf;
 147
 148                         /* Store the buffer inside the TDBSAM */
 149                         if (tdb_store(pdb_tdb, key, data, TDB_MODIFY) != TDB_SUCCESS) {
 150                                 DEBUG(0,("tdbsam_convert: cannot store the SAM_ACCOUNT (key:%s) in new format\n",key.dptr));
 151                                 SAFE_FREE(data.dptr);
 152                                 return False;
 153                         }
 154
 155                         SAFE_FREE(data.dptr);
 156
 157                         /* increment to next in line */
 158                         old_key = key;
 159                         key = tdb_nextkey(pdb_tdb, key);
 160                         SAFE_FREE(old_key.dptr);
 161                 }
 162
 163         }
 164
 165         pdb_free_sam(&user);
 166
 167         /* upgrade finished */
 168         tdb_store_int32(pdb_tdb, vstring, TDBSAM_VERSION);
 169         tdb_unlock_bystring(pdb_tdb, vstring);
 170
 171         return(True);
 172 }
 173
 174 /**
 175  * Open the TDB passwd database, check version and convert it if needed.
 176  * @param name filename of the tdbsam file.
 177  * @param open_flags file access mode.
 178  * @return a TDB_CONTEXT handle on the tdbsam file.
 179  **/
 180
 181 static TDB_CONTEXT * tdbsam_tdbopen (const char *name, int open_flags)
 182 {
 183         TDB_CONTEXT     *pdb_tdb;
 184         tdbsamver_t     version;
 185
 186         /* Try to open tdb passwd */
 187         if (!(pdb_tdb = tdb_open_log(name, 0, TDB_DEFAULT,
 188                                      open_flags, 0600))) {
 189                 DEBUG(0, ("Unable to open/create TDB passwd\n"));
 190                 return NULL;
 191         }
 192
 193         /* Check the version */
 194         version = (tdbsamver_t) tdb_fetch_int32(pdb_tdb,
 195                                                 TDBSAM_VERSION_STRING);
 196         if (version == -1)
 197                 version = 0;    /* Version not found, assume version 0 */
 198
 199         /* Compare the version */
 200         if (version > TDBSAM_VERSION) {
 201                 /* Version more recent than the latest known */
 202                 DEBUG(0, ("TDBSAM version unknown: %d\n", version));
 203                 tdb_close(pdb_tdb);
 204                 pdb_tdb = NULL;
 205         }
 206         else if (version < TDBSAM_VERSION) {
 207                 /* Older version, must be converted */
 208                 DEBUG(1, ("TDBSAM version too old (%d), trying to convert it.\n", version));
 209
 210                 /* Reopen the pdb file with read-write access if needed */
 211                 if (!(open_flags & O_RDWR)) {
 212                         DEBUG(10, ("tdbsam_tdbopen: TDB file opened with read only access, reopen it with read-write access.\n"));
 213                         tdb_close(pdb_tdb);
 214                         pdb_tdb = tdb_open_log(name, 0, TDB_DEFAULT, (open_flags & 07777770) | O_RDWR, 0600);
 215                 }
 216
 217                 /* Convert */
 218                 if (!tdbsam_convert(pdb_tdb, version)){
 219                         DEBUG(0, ("tdbsam_tdbopen: Error when trying to convert tdbsam: %s\n",name));
 220                         tdb_close(pdb_tdb);
 221                         pdb_tdb = NULL;
 222                 } else {
 223                         DEBUG(1, ("TDBSAM converted successfully.\n"));
 224                 }
 225
 226                 /* Reopen the pdb file as it must be */
 227                 if (!(open_flags & O_RDWR)) {
 228                         tdb_close(pdb_tdb);
 229                         pdb_tdb = tdb_open_log(name, 0, TDB_DEFAULT, open_flags, 0600);
 230                 }
 231         }
 232
 233         return pdb_tdb;
 234 }
 235
 236 /*****************************************************************************
 237  Utility functions to close the tdb sam database
 238  ****************************************************************************/
 239
 240 static void tdbsam_tdbclose ( struct tdbsam_privates *state )
 241 {
 242         if ( !state )
 243                 return;
 244
 245         if ( state->passwd_tdb ) {
 246                 tdb_close( state->passwd_tdb );
 247                 state->passwd_tdb = NULL;
 248         }
 249
 250         return;
 251
 252 }
 253
 254 /****************************************************************************
 255  creates a list of user keys
 256 ****************************************************************************/
 257
 258 static int tdbsam_traverse_setpwent(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
 259 {
 260         const char *prefix = USERPREFIX;
 261         int  prefixlen = strlen (prefix);
 262         struct pwent_list *ptr;
 263
 264         if ( strncmp(key.dptr, prefix, prefixlen) == 0 ) {
 265                 if ( !(ptr=(struct pwent_list*)malloc(sizeof(struct pwent_list))) ) {
 266                         DEBUG(0,("tdbsam_traverse_setpwent: Failed to malloc new entry for list\n"));
 267
 268                         /* just return 0 and let the traversal continue */
 269                         return 0;
 270                 }
 271                 ZERO_STRUCTP(ptr);
 272
 273                 /* save a copy of the key */
 274
 275                 ptr->key.dptr = memdup( key.dptr, key.dsize );
 276                 ptr->key.dsize = key.dsize;
 277
 278                 DLIST_ADD( tdbsam_pwent_list, ptr );
 279
 280         }
 281
 282
 283         return 0;
 284 }
 285
 286 /***************************************************************
 287  Open the TDB passwd database for SAM account enumeration.
 288  Save a list of user keys for iteration.
 289 ****************************************************************/
 290
 291 static NTSTATUS tdbsam_setsampwent(struct pdb_methods *my_methods, BOOL update)
 292 {
 293         uint32 flags = update ? (O_RDWR|O_CREAT) : O_RDONLY;
 294
 295         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 296
 297         if ( !(tdb_state->passwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, flags )) )
 298                 return NT_STATUS_UNSUCCESSFUL;
 299
 300         tdb_traverse( tdb_state->passwd_tdb, tdbsam_traverse_setpwent, NULL );
 301
 302         return NT_STATUS_OK;
 303 }
 304
 305
 306 /***************************************************************
 307  End enumeration of the TDB passwd list.
 308 ****************************************************************/
 309
 310 static void tdbsam_endsampwent(struct pdb_methods *my_methods)
 311 {
 312         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 313         struct pwent_list *ptr, *ptr_next;
 314
 315         tdbsam_tdbclose( tdb_state );
 316
 317         /* clear out any remaining entries in the list */
 318
 319         for ( ptr=tdbsam_pwent_list; ptr; ptr = ptr_next ) {
 320                 ptr_next = ptr->next;
 321                 DLIST_REMOVE( tdbsam_pwent_list, ptr );
 322                 SAFE_FREE( ptr->key.dptr);
 323                 SAFE_FREE( ptr );
 324         }
 325
 326         DEBUG(7, ("endtdbpwent: closed sam database.\n"));
 327 }
 328
 329 /*****************************************************************
 330  Get one SAM_ACCOUNT from the TDB (next in line)
 331 *****************************************************************/
 332
 333 static NTSTATUS tdbsam_getsampwent(struct pdb_methods *my_methods, SAM_ACCOUNT *user)
 334 {
 335         NTSTATUS                nt_status = NT_STATUS_UNSUCCESSFUL;
 336         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 337         TDB_DATA                data;
 338         struct pwent_list       *pkey;
 339
 340         if ( !user ) {
 341                 DEBUG(0,("tdbsam_getsampwent: SAM_ACCOUNT is NULL.\n"));
 342                 return nt_status;
 343         }
 344
 345         if ( !tdbsam_pwent_list ) {
 346                 DEBUG(4,("tdbsam_getsampwent: end of list\n"));
 347                 tdbsam_tdbclose( tdb_state );
 348                 return nt_status;
 349         }
 350
 351         if ( !tdb_state->passwd_tdb ) {
 352                 if ( !(tdb_state->passwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDONLY)) )
 353                         return nt_status;
 354         }
 355
 356         /* pull the next entry */
 357
 358         pkey = tdbsam_pwent_list;
 359         DLIST_REMOVE( tdbsam_pwent_list, pkey );
 360
 361         data = tdb_fetch(tdb_state->passwd_tdb, pkey->key);
 362
 363         SAFE_FREE( pkey->key.dptr);
 364         SAFE_FREE( pkey);
 365
 366         if (!data.dptr) {
 367                 DEBUG(5,("pdb_getsampwent: database entry not found.  Was the user deleted?\n"));
 368                 return nt_status;
 369         }
 370
 371         if (!init_sam_from_buffer(user, (unsigned char *)data.dptr, data.dsize)) {
 372                 DEBUG(0,("pdb_getsampwent: Bad SAM_ACCOUNT entry returned from TDB!\n"));
 373         }
 374
 375         SAFE_FREE( data.dptr );
 376
 377
 378         return NT_STATUS_OK;
 379 }
 380
 381 /******************************************************************
 382  Lookup a name in the SAM TDB
 383 ******************************************************************/
 384
 385 static NTSTATUS tdbsam_getsampwnam (struct pdb_methods *my_methods, SAM_ACCOUNT *user, const char *sname)
 386 {
 387         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 388         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 389         TDB_CONTEXT     *pwd_tdb;
 390         TDB_DATA        data, key;
 391         fstring         keystr;
 392         fstring         name;
 393
 394         if ( !user ) {
 395                 DEBUG(0,("pdb_getsampwnam: SAM_ACCOUNT is NULL.\n"));
 396                 return nt_status;
 397         }
 398
 399         /* Data is stored in all lower-case */
 400         fstrcpy(name, sname);
 401         strlower_m(name);
 402
 403         /* set search key */
 404         slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
 405         key.dptr = keystr;
 406         key.dsize = strlen(keystr) + 1;
 407
 408         /* open the accounts TDB */
 409         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDONLY))) {
 410
 411                 if (errno == ENOENT) {
 412                         /*
 413                          * TDB file doesn't exist, so try to create new one. This is useful to avoid
 414                          * confusing error msg when adding user account first time
 415                          */
 416                         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_CREAT ))) {
 417                                 DEBUG(0, ("pdb_getsampwnam: TDB passwd (%s) did not exist. File successfully created.\n",
 418                                           tdb_state->tdbsam_location));
 419                         } else {
 420                                 DEBUG(0, ("pdb_getsampwnam: TDB passwd (%s) does not exist. Couldn't create new one. Error was: %s\n",
 421                                           tdb_state->tdbsam_location, strerror(errno)));
 422                         }
 423
 424                         /* requested user isn't there anyway */
 425                         nt_status = NT_STATUS_NO_SUCH_USER;
 426                         return nt_status;
 427                 }
 428                 DEBUG(0, ("pdb_getsampwnam: Unable to open TDB passwd (%s)!\n", tdb_state->tdbsam_location));
 429                 return nt_status;
 430         }
 431
 432         /* get the record */
 433         data = tdb_fetch(pwd_tdb, key);
 434         if (!data.dptr) {
 435                 DEBUG(5,("pdb_getsampwnam (TDB): error fetching database.\n"));
 436                 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 437                 DEBUGADD(5, (" Key: %s\n", keystr));
 438                 tdb_close(pwd_tdb);
 439                 return nt_status;
 440         }
 441
 442         /* unpack the buffer */
 443         if (!init_sam_from_buffer(user, (unsigned char *)data.dptr, data.dsize)) {
 444                 DEBUG(0,("pdb_getsampwent: Bad SAM_ACCOUNT entry returned from TDB!\n"));
 445                 SAFE_FREE(data.dptr);
 446                 tdb_close(pwd_tdb);
 447                 return nt_status;
 448         }
 449         SAFE_FREE(data.dptr);
 450
 451         /* no further use for database, close it now */
 452         tdb_close(pwd_tdb);
 453
 454         return NT_STATUS_OK;
 455 }
 456
 457 /***************************************************************************
 458  Search by rid
 459  **************************************************************************/
 460
 461 static NTSTATUS tdbsam_getsampwrid (struct pdb_methods *my_methods, SAM_ACCOUNT *user, uint32 rid)
 462 {
 463         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 464         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 465         TDB_CONTEXT             *pwd_tdb;
 466         TDB_DATA                data, key;
 467         fstring                 keystr;
 468         fstring                 name;
 469
 470         if (user==NULL) {
 471                 DEBUG(0,("pdb_getsampwrid: SAM_ACCOUNT is NULL.\n"));
 472                 return nt_status;
 473         }
 474
 475         /* set search key */
 476         slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, rid);
 477         key.dptr = keystr;
 478         key.dsize = strlen (keystr) + 1;
 479
 480         /* open the accounts TDB */
 481         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDONLY))) {
 482                 DEBUG(0, ("pdb_getsampwrid: Unable to open TDB rid database!\n"));
 483                 return nt_status;
 484         }
 485
 486         /* get the record */
 487         data = tdb_fetch (pwd_tdb, key);
 488         if (!data.dptr) {
 489                 DEBUG(5,("pdb_getsampwrid (TDB): error looking up RID %d by key %s.\n", rid, keystr));
 490                 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 491                 tdb_close (pwd_tdb);
 492                 return nt_status;
 493         }
 494
 495
 496         fstrcpy(name, data.dptr);
 497         SAFE_FREE(data.dptr);
 498
 499         tdb_close (pwd_tdb);
 500
 501         return tdbsam_getsampwnam (my_methods, user, name);
 502 }
 503
 504 static NTSTATUS tdbsam_getsampwsid(struct pdb_methods *my_methods, SAM_ACCOUNT * user, const DOM_SID *sid)
 505 {
 506         uint32 rid;
 507         if (!sid_peek_check_rid(get_global_sam_sid(), sid, &rid))
 508                 return NT_STATUS_UNSUCCESSFUL;
 509         return tdbsam_getsampwrid(my_methods, user, rid);
 510 }
 511
 512 /***************************************************************************
 513  Delete a SAM_ACCOUNT
 514 ****************************************************************************/
 515
 516 static NTSTATUS tdbsam_delete_sam_account(struct pdb_methods *my_methods, SAM_ACCOUNT *sam_pass)
 517 {
 518         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 519         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 520         TDB_CONTEXT     *pwd_tdb;
 521         TDB_DATA        key;
 522         fstring         keystr;
 523         uint32          rid;
 524         fstring         name;
 525
 526         fstrcpy(name, pdb_get_username(sam_pass));
 527         strlower_m(name);
 528
 529         /* open the TDB */
 530         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDWR))) {
 531                 DEBUG(0, ("Unable to open TDB passwd!"));
 532                 return nt_status;
 533         }
 534
 535         /* set the search key */
 536         slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
 537         key.dptr = keystr;
 538         key.dsize = strlen (keystr) + 1;
 539
 540         rid = pdb_get_user_rid(sam_pass);
 541
 542         /* it's outaa here!  8^) */
 543         if (tdb_delete(pwd_tdb, key) != TDB_SUCCESS) {
 544                 DEBUG(5, ("Error deleting entry from tdb passwd database!\n"));
 545                 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 546                 tdb_close(pwd_tdb);
 547                 return nt_status;
 548         }
 549
 550         /* delete also the RID key */
 551
 552         /* set the search key */
 553         slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, rid);
 554         key.dptr = keystr;
 555         key.dsize = strlen (keystr) + 1;
 556
 557         /* it's outaa here!  8^) */
 558         if (tdb_delete(pwd_tdb, key) != TDB_SUCCESS) {
 559                 DEBUG(5, ("Error deleting entry from tdb rid database!\n"));
 560                 DEBUGADD(5, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 561                 tdb_close(pwd_tdb);
 562                 return nt_status;
 563         }
 564
 565         tdb_close(pwd_tdb);
 566
 567         return NT_STATUS_OK;
 568 }
 569
 570 /***************************************************************************
 571  Update the TDB SAM
 572 ****************************************************************************/
 573
 574 static BOOL tdb_update_sam(struct pdb_methods *my_methods, SAM_ACCOUNT* newpwd, int flag)
 575 {
 576         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 577         TDB_CONTEXT     *pwd_tdb = NULL;
 578         TDB_DATA        key, data;
 579         uint8           *buf = NULL;
 580         fstring         keystr;
 581         fstring         name;
 582         BOOL            ret = True;
 583         uint32          user_rid;
 584
 585         /* invalidate the existing TDB iterator if it is open */
 586
 587         if (tdb_state->passwd_tdb) {
 588                 tdb_close(tdb_state->passwd_tdb);
 589                 tdb_state->passwd_tdb = NULL;
 590         }
 591
 592         /* open the account TDB passwd*/
 593
 594         pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDWR | O_CREAT);
 595
 596         if (!pwd_tdb) {
 597                 DEBUG(0, ("tdb_update_sam: Unable to open TDB passwd (%s)!\n",
 598                         tdb_state->tdbsam_location));
 599                 return False;
 600         }
 601
 602         if (!pdb_get_group_rid(newpwd)) {
 603                 DEBUG (0,("tdb_update_sam: Failing to store a SAM_ACCOUNT for [%s] without a primary group RID\n",
 604                         pdb_get_username(newpwd)));
 605                 ret = False;
 606                 goto done;
 607         }
 608
 609         if ( !(user_rid = pdb_get_user_rid(newpwd)) ) {
 610                 DEBUG(0,("tdb_update_sam: SAM_ACCOUNT (%s) with no RID!\n", pdb_get_username(newpwd)));
 611                 ret = False;
 612                 goto done;
 613         }
 614
 615         /* copy the SAM_ACCOUNT struct into a BYTE buffer for storage */
 616         if ((data.dsize=init_buffer_from_sam (&buf, newpwd, False)) == -1) {
 617                 DEBUG(0,("tdb_update_sam: ERROR - Unable to copy SAM_ACCOUNT info BYTE buffer!\n"));
 618                 ret = False;
 619                 goto done;
 620         }
 621         data.dptr = (char *)buf;
 622
 623         fstrcpy(name, pdb_get_username(newpwd));
 624         strlower_m(name);
 625
 626         DEBUG(5, ("Storing %saccount %s with RID %d\n", flag == TDB_INSERT ? "(new) " : "", name, user_rid));
 627
 628         /* setup the USER index key */
 629         slprintf(keystr, sizeof(keystr)-1, "%s%s", USERPREFIX, name);
 630         key.dptr = keystr;
 631         key.dsize = strlen(keystr) + 1;
 632
 633         /* add the account */
 634         if (tdb_store(pwd_tdb, key, data, flag) != TDB_SUCCESS) {
 635                 DEBUG(0, ("Unable to modify passwd TDB!"));
 636                 DEBUGADD(0, (" Error: %s", tdb_errorstr(pwd_tdb)));
 637                 DEBUGADD(0, (" occured while storing the main record (%s)\n", keystr));
 638                 ret = False;
 639                 goto done;
 640         }
 641
 642         /* setup RID data */
 643         data.dsize = strlen(name) + 1;
 644         data.dptr = name;
 645
 646         /* setup the RID index key */
 647         slprintf(keystr, sizeof(keystr)-1, "%s%.8x", RIDPREFIX, user_rid);
 648         key.dptr = keystr;
 649         key.dsize = strlen (keystr) + 1;
 650
 651         /* add the reference */
 652         if (tdb_store(pwd_tdb, key, data, flag) != TDB_SUCCESS) {
 653                 DEBUG(0, ("Unable to modify TDB passwd !"));
 654                 DEBUGADD(0, (" Error: %s\n", tdb_errorstr(pwd_tdb)));
 655                 DEBUGADD(0, (" occured while storing the RID index (%s)\n", keystr));
 656                 ret = False;
 657                 goto done;
 658         }
 659
 660 done:
 661         /* cleanup */
 662         tdb_close (pwd_tdb);
 663         SAFE_FREE(buf);
 664
 665         return (ret);
 666 }
 667
 668 /***************************************************************************
 669  Modifies an existing SAM_ACCOUNT
 670 ****************************************************************************/
 671
 672 static NTSTATUS tdbsam_update_sam_account (struct pdb_methods *my_methods, SAM_ACCOUNT *newpwd)
 673 {
 674         if (tdb_update_sam(my_methods, newpwd, TDB_MODIFY))
 675                 return NT_STATUS_OK;
 676         else
 677                 return NT_STATUS_UNSUCCESSFUL;
 678 }
 679
 680 /***************************************************************************
 681  Adds an existing SAM_ACCOUNT
 682 ****************************************************************************/
 683
 684 static NTSTATUS tdbsam_add_sam_account (struct pdb_methods *my_methods, SAM_ACCOUNT *newpwd)
 685 {
 686         if (tdb_update_sam(my_methods, newpwd, TDB_INSERT))
 687                 return NT_STATUS_OK;
 688         else
 689                 return NT_STATUS_UNSUCCESSFUL;
 690 }
 691
 692 static void free_private_data(void **vp)
 693 {
 694         struct tdbsam_privates **tdb_state = (struct tdbsam_privates **)vp;
 695         tdbsam_tdbclose(*tdb_state);
 696         *tdb_state = NULL;
 697
 698         /* No need to free any further, as it is talloc()ed */
 699 }
 700
 701 /**
 702  * Start enumerating through trust passwords (machine and
 703  * interdomain nt/ads)
 704  *
 705  * @param methods methods belonging in pdb context (module)
 706  * @param trust trust password structure
 707  *
 708  * @return nt status of performed operation
 709  **/
 710
 711 static NTSTATUS tdbsam_gettrustpwent(struct pdb_methods *methods, SAM_TRUST_PASSWD *trust)
 712 {
 713         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 714         struct trust_passwd_data t;
 715         TALLOC_CTX *mem_ctx;
 716
 717         TRUSTDOM **trustdom;
 718         static int enum_ctx;
 719         int num_domains = 0;
 720         unsigned int max_domains = 1;
 721         char *dom_name, *dom_pass;
 722
 723         smb_ucs2_t *uni_dom_name;
 724         uint8 mach_pass[16];
 725         uint32 sec_chan;
 726
 727         if (!methods) return NT_STATUS_UNSUCCESSFUL;
 728
 729         /*
 730          * NT domain trust passwords
 731          */
 732
 733         /* rewind enumeration when passed NULL pointer as a trust */
 734         if (!trust) {
 735                 enum_ctx = 0;
 736                 return NT_STATUS_OK;
 737         }
 738
 739         mem_ctx = talloc_init("tdbsam_gettrustpwent: trust password enumeration");
 740
 741         /* fetch next trusted domain (one at a time) and its full information */
 742         nt_status = secrets_get_trusted_domains(mem_ctx, &enum_ctx, max_domains, &num_domains,
 743                                                 &trustdom);
 744         if (num_domains) {
 745                 pull_ucs2_talloc(mem_ctx, &dom_name, trustdom[0]->name);
 746                 if (secrets_fetch_trusted_domain_password(dom_name, &dom_pass, &t.domain_sid,
 747                                                           &t.mod_time)) {
 748
 749                         t.uni_name_len = strnlen_w(trustdom[0]->name, 32);
 750                         strncpy_w(t.uni_name, trustdom[0]->name, t.uni_name_len);
 751                         safe_strcpy(t.pass, dom_pass, FSTRING_LEN - 1);
 752                         t.flags = PASS_DOMAIN_TRUST_NT;
 753
 754                         SAFE_FREE(dom_pass);
 755                         talloc_destroy(mem_ctx);
 756                         trust->private = t;
 757                         return nt_status;
 758                 } else {
 759                         talloc_destroy(mem_ctx);
 760                         return NT_STATUS_UNSUCCESSFUL;
 761                 }
 762         }
 763
 764         /*
 765          * NT machine trust password
 766          */
 767
 768         if (secrets_lock_trust_account_password(lp_workgroup(), True)) {
 769                 sec_chan = get_default_sec_channel();
 770                 if (secrets_fetch_trust_account_password(lp_workgroup(), mach_pass, &t.mod_time,
 771                                                          &sec_chan)) {
 772
 773                         t.uni_name_len = strlen(lp_workgroup());
 774                         push_ucs2_talloc(mem_ctx, &uni_dom_name, lp_workgroup());
 775                         strncpy_w(t.uni_name, uni_dom_name, t.uni_name_len);
 776                         safe_strcpy(t.pass, mach_pass, FSTRING_LEN - 1);
 777                         t.flags = PASS_MACHINE_TRUST_NT;
 778                         if (!secrets_fetch_domain_sid(lp_workgroup(), &t.domain_sid)) {
 779                                 talloc_destroy(mem_ctx);
 780                                 return NT_STATUS_UNSUCCESSFUL;
 781                         }
 782
 783                         talloc_destroy(mem_ctx);
 784                         trust->private = t;
 785                         return NT_STATUS_OK;
 786                 }
 787                 secrets_lock_trust_account_password(lp_workgroup(), False);
 788         } else {
 789                 talloc_destroy(mem_ctx);
 790                 return NT_STATUS_UNSUCCESSFUL;
 791         }
 792
 793         /*
 794          * ADS machine trust password (TODO)
 795          */
 796
 797         talloc_destroy(mem_ctx);
 798         return nt_status;
 799 }
 800
 801 /**
 802  * Get trust password by trusted party sid
 803  *
 804  * @param methods methods belonging to pdb context (module)
 805  * @param trust trust password structure
 806  * @param sid trusted party sid
 807  *
 808  * @return nt status of performed operation
 809  **/
 810
 811 static NTSTATUS tdbsam_gettrustpwsid(struct pdb_methods *methods, SAM_TRUST_PASSWD *trust,
 812                                      const DOM_SID *sid)
 813 {
 814         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 815         return nt_status;
 816 }
 817
 818
 819 /**
 820  * Add new trust password.
 821  *
 822  * @param methods methods belonging in pdb context (module)
 823  * @param trust trust password structure
 824  *
 825  * @return nt status of performed operation
 826  **/
 827
 828 static NTSTATUS tdbsam_add_trust_passwd(struct pdb_methods *methods, const SAM_TRUST_PASSWD *trust)
 829 {
 830         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 831         BOOL status = False;
 832         TALLOC_CTX *mem_ctx;
 833
 834         char* domain = NULL;
 835         struct trust_passwd_data t = trust->private;
 836         uint32 sec_chan;
 837
 838         mem_ctx = talloc_init("tdbsam_add_trust_passwd: storing new trust password");
 839
 840         /* convert unicode name to char* (used to form the key) */
 841         pull_ucs2_talloc(mem_ctx, &domain, t.uni_name);
 842
 843         /* add nt machine trust password */
 844         if (t.flags & (PASS_MACHINE_TRUST_NT | PASS_SERVER_TRUST_NT)) {
 845                 sec_chan = (t.flags & PASS_MACHINE_TRUST_NT) ? SEC_CHAN_WKSTA : SEC_CHAN_BDC;
 846                 status = secrets_store_machine_password(t.pass, domain, sec_chan);
 847                 if (status)
 848                         status = secrets_store_domain_sid(domain, &t.domain_sid);
 849
 850                 nt_status = status ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 851
 852         /* add nt domain trust password */
 853         } else if (t.flags & PASS_DOMAIN_TRUST_NT) {
 854                 status = secrets_store_trusted_domain_password(domain, t.uni_name, t.uni_name_len,
 855                                                                t.pass, t.domain_sid);
 856                 nt_status = status ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 857
 858         /* add ads machine trust password (TODO) */
 859         } else if (t.flags & PASS_MACHINE_TRUST_ADS) {
 860         }
 861
 862         talloc_destroy(mem_ctx);
 863         return nt_status;
 864 }
 865
 866
 867 /**
 868  * Update trust password.
 869  *
 870  * @param methods methods belonging in pdb context (module)
 871  * @param trust trust password structure
 872  *
 873  * @return nt status of performed operation
 874  **/
 875
 876 static NTSTATUS tdbsam_update_trust_passwd(struct pdb_methods *methods, const SAM_TRUST_PASSWD* trust)
 877 {
 878         NTSTATUS nt_status = NT_STATUS_NOT_IMPLEMENTED;
 879         return nt_status;
 880 }
 881
 882
 883 /**
 884  * Delete trust password.
 885  *
 886  * @param methods methods belonging in pdb context (module)
 887  * @param trust trust password structure
 888  *
 889  * @return nt status of performed operation
 890  **/
 891
 892 static NTSTATUS tdbsam_delete_trust_passwd(struct pdb_methods *methods, const SAM_TRUST_PASSWD* trust)
 893 {
 894         NTSTATUS nt_status = NT_STATUS_NOT_IMPLEMENTED;
 895         return nt_status;
 896 }
 897
 898
 899 /***************************************************************************
 900  Add sid to privilege
 901 ****************************************************************************/
 902
 903 static NTSTATUS tdbsam_add_sid_to_privilege(struct pdb_methods *my_methods, const char *priv_name, const DOM_SID *sid)
 904 {
 905         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
 906         TDB_CONTEXT     *pwd_tdb = NULL;
 907         TDB_DATA        key, data;
 908         fstring         keystr;
 909         fstring         name;
 910         NTSTATUS        ret = NT_STATUS_UNSUCCESSFUL;
 911         fstring         sid_str;
 912         char            *sid_list = NULL, *s = NULL;
 913         size_t          str_size;
 914         int             flag;
 915
 916         /* invalidate the existing TDB iterator if it is open */
 917
 918         if (tdb_state->passwd_tdb) {
 919                 tdb_close(tdb_state->passwd_tdb);
 920                 tdb_state->passwd_tdb = NULL;
 921         }
 922
 923         /* open the account TDB passwd*/
 924
 925         pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDWR | O_CREAT);
 926
 927         if (!pwd_tdb) {
 928                 DEBUG(0, ("tdb_add_sid_to_privilege: Unable to open TDB passwd (%s)!\n",
 929                         tdb_state->tdbsam_location));
 930                 return NT_STATUS_UNSUCCESSFUL;
 931         }
 932
 933         /* setup the PRIV index key */
 934         fstrcpy(name, priv_name);
 935         strlower_m(name);
 936
 937         slprintf(keystr, sizeof(keystr)-1, "%s%s", PRIVPREFIX, name);
 938         key.dptr = keystr;
 939         key.dsize = strlen(keystr) + 1;
 940
 941         /* check if the privilege already exist in the database */
 942
 943         /* get the record */
 944         data = tdb_fetch (pwd_tdb, key);
 945
 946         if (data.dptr) {
 947                 /* check the list is not empty */
 948                 if (*(data.dptr)) {
 949                         sid_list = strdup(data.dptr);
 950                         if (!sid_list) {
 951                                 DEBUG(0, ("tdbsam_add_sid_to_privilege: Out of Memory!\n"));
 952                                 goto done;
 953                         }
 954                 }
 955                 SAFE_FREE(data.dptr);
 956
 957                 flag = TDB_MODIFY;
 958         } else {
 959                 /* if privilege does not exist create one */
 960                 flag = TDB_INSERT;
 961         }
 962
 963         /* add the given sid */
 964         sid_to_string(sid_str, sid);
 965
 966         if (sid_list) {
 967                 str_size = strlen(sid_list) + strlen(sid_str) + 2;
 968                 s = realloc(sid_list, str_size);
 969                 if (!s) {
 970                         DEBUG(0, ("tdbsam_add_sid_to_privilege: Out of Memory!\n"));
 971                         ret = NT_STATUS_NO_MEMORY;
 972                         goto done;
 973                 }
 974                 sid_list = s;
 975                 s = &sid_list[strlen(sid_list)];
 976                 snprintf(s, strlen(sid_str) + 2, ",%s", sid_str);
 977
 978         } else {
 979                 sid_list = strdup(sid_str);
 980                 if (!sid_list) {
 981                         DEBUG(0, ("tdbsam_add_sid_to_privilege: Out of Memory!\n"));
 982                         ret = NT_STATUS_NO_MEMORY;
 983                         goto done;
 984                 }
 985
 986         }
 987
 988         /* copy the PRIVILEGE struct into a BYTE buffer for storage */
 989         data.dsize = strlen(sid_list) + 1;
 990         data.dptr = sid_list;
 991
 992         /* add the account */
 993         if (tdb_store(pwd_tdb, key, data, flag) != TDB_SUCCESS) {
 994                 DEBUG(0, ("Unable to modify passwd TDB!"));
 995                 DEBUGADD(0, (" Error: %s", tdb_errorstr(pwd_tdb)));
 996                 DEBUGADD(0, (" occured while storing the main record (%s)\n", keystr));
 997                 goto done;
 998         }
 999
1000         ret = NT_STATUS_OK;
1001
1002 done:
1003         /* cleanup */
1004         tdb_close (pwd_tdb);
1005         SAFE_FREE(sid_list);
1006
1007         return (ret);
1008 }
1009
1010 /***************************************************************************
1011  Reomve sid to privilege
1012 ****************************************************************************/
1013
1014 static NTSTATUS tdbsam_remove_sid_from_privilege(struct pdb_methods *my_methods, const char *priv_name, const DOM_SID *sid)
1015 {
1016         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
1017         TDB_CONTEXT     *pwd_tdb = NULL;
1018         TDB_DATA        key, data;
1019         fstring         keystr;
1020         fstring         name;
1021         NTSTATUS        ret = NT_STATUS_UNSUCCESSFUL;
1022         fstring         sid_str;
1023         char            *sid_list = NULL, *s = NULL;
1024
1025         /* invalidate the existing TDB iterator if it is open */
1026
1027         if (tdb_state->passwd_tdb) {
1028                 tdb_close(tdb_state->passwd_tdb);
1029                 tdb_state->passwd_tdb = NULL;
1030         }
1031
1032         /* open the account TDB passwd*/
1033
1034         pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDWR | O_CREAT);
1035
1036         if (!pwd_tdb) {
1037                 DEBUG(0, ("tdbsam_remove_sid_from_privilege: Unable to open TDB passwd (%s)!\n",
1038                         tdb_state->tdbsam_location));
1039                 return NT_STATUS_UNSUCCESSFUL;
1040         }
1041
1042         /* setup the PRIV index key */
1043         fstrcpy(name, priv_name);
1044         strlower_m(name);
1045
1046         slprintf(keystr, sizeof(keystr)-1, "%s%s", PRIVPREFIX, name);
1047         key.dptr = keystr;
1048         key.dsize = strlen(keystr) + 1;
1049
1050         /* check if the privilege already exist in the database */
1051
1052         /* get the record */
1053         data = tdb_fetch (pwd_tdb, key);
1054
1055         /* if privilege does not exist, just leave */
1056         if (!data.dptr) {
1057                 ret = NT_STATUS_OK;
1058                 goto done;
1059         }
1060
1061         if (data.dptr) {
1062                 sid_list = strdup(data.dptr);
1063                 if (!sid_list) {
1064                         DEBUG(0, ("tdbsam_remove_sid_from_privilege: Out of Memory!\n"));
1065                         goto done;
1066                 }
1067                 SAFE_FREE(data.dptr);
1068         }
1069
1070         /* remove the given sid */
1071         sid_to_string(sid_str, sid);
1072
1073         s = strstr(sid_list, sid_str);
1074         if (s) {
1075                 char *p;
1076                 p = strstr(s, ",");
1077                 if (p) {
1078                         size_t l = strlen(sid_list) + 1 - (s - sid_list);
1079                         memmove(s, ++p, l);
1080                 } else {
1081                         if (s != sid_list)
1082                                 s--;
1083                         *s = '\0';
1084                 }
1085         } else {
1086                 /* sid not found */
1087                 ret = NT_STATUS_UNSUCCESSFUL;
1088                 goto done;
1089         }
1090
1091         /* copy the PRIVILEGE struct into a BYTE buffer for storage */
1092         data.dsize = strlen(sid_list) + 1;
1093         data.dptr = sid_list;
1094
1095         /* add the account */
1096         if (tdb_store(pwd_tdb, key, data, TDB_MODIFY) != TDB_SUCCESS) {
1097                 DEBUG(0, ("Unable to modify passwd TDB!"));
1098                 DEBUGADD(0, (" Error: %s", tdb_errorstr(pwd_tdb)));
1099                 DEBUGADD(0, (" occured while storing the main record (%s)\n", keystr));
1100                 goto done;
1101         }
1102
1103         ret = NT_STATUS_OK;
1104
1105 done:
1106         /* cleanup */
1107         tdb_close (pwd_tdb);
1108         SAFE_FREE(sid_list);
1109
1110         return (ret);
1111 }
1112
1113 /***************************************************************************
1114  get the privilege list for the given token
1115 ****************************************************************************/
1116
1117 struct priv_traverse {
1118         char **sid_list;
1119         PRIVILEGE_SET *privset;
1120 };
1121
1122 static int tdbsam_traverse_privilege(TDB_CONTEXT *t, TDB_DATA key, TDB_DATA data, void *state)
1123 {
1124         struct priv_traverse *pt = (struct priv_traverse *)state;
1125         int  prefixlen = strlen(PRIVPREFIX);
1126
1127         if (strncmp(key.dptr, PRIVPREFIX, prefixlen) == 0) {
1128
1129                 /* add to privilege_set if any of the sid in the token
1130                  * is contained in the privilege */
1131                 int i;
1132
1133                 for(i=0; pt->sid_list[i] != NULL; i++) {
1134                         char *c, *s;
1135                         int len;
1136
1137                         s = data.dptr;
1138                         while (c = strchr(s, ',')) {
1139                                 len = MAX((c - s), strlen(pt->sid_list[i]));
1140                                 if (strncmp(s, pt->sid_list[i], len) == 0) {
1141                                         DEBUG(10, ("sid [%s] found in users sid list\n", pt->sid_list[i]));
1142                                         DEBUG(10, ("adding privilege [%s] to the users privilege list\n", &(key.dptr[prefixlen])));
1143                                         add_privilege_by_name(pt->privset, &(key.dptr[prefixlen]));
1144                                         return 0;
1145                                 }
1146                                 s = c + 1;
1147                         }
1148                         len = MAX(strlen(s), strlen(pt->sid_list[i]));
1149                         if (strncmp(s, pt->sid_list[i], len) == 0) {
1150                                 DEBUG(10, ("sid [%s] found in users sid list\n", pt->sid_list[i]));
1151                                 DEBUG(10, ("adding privilege [%s] to the users privilege list\n", &(key.dptr[prefixlen])));
1152                                 add_privilege_by_name(pt->privset, &(key.dptr[prefixlen]));
1153                                 return 0;
1154                         }
1155                 }
1156         }
1157
1158         return 0;
1159 }
1160
1161 static NTSTATUS tdbsam_get_privilege_set(struct pdb_methods *my_methods, NT_USER_TOKEN *token, PRIVILEGE_SET *privset)
1162 {
1163         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
1164         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
1165         TDB_CONTEXT     *pwd_tdb = NULL;
1166         struct priv_traverse pt;
1167         fstring sid_str;
1168         char **sid_list;
1169         int i;
1170
1171         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDONLY )))
1172                 return NT_STATUS_UNSUCCESSFUL;
1173
1174         sid_list = (char **)malloc(sizeof(char *) * (token->num_sids + 1));
1175         for (i = 0; i < token->num_sids; i++) {
1176                 sid_to_string(sid_str, &token->user_sids[i]);
1177                 sid_list[i] = strdup(sid_str);
1178                 if ( ! sid_list[i]) {
1179                         ret = NT_STATUS_NO_MEMORY;
1180                         goto done;
1181                 }
1182         }
1183         sid_list[i] = NULL;
1184
1185         pt.sid_list = sid_list;
1186         pt.privset = privset;
1187         tdb_traverse(pwd_tdb, tdbsam_traverse_privilege, &pt);
1188
1189         ret = NT_STATUS_OK;
1190
1191 done:
1192         i = 0;
1193         while (sid_list[i]) {
1194                 free(sid_list[i]);
1195                 i++;
1196         }
1197         free(sid_list);
1198
1199         tdb_close(pwd_tdb);
1200
1201         return ret;
1202 }
1203
1204 static NTSTATUS tdbsam_get_privilege_entry(struct pdb_methods *my_methods, const char *privname, char **sid_list)
1205 {
1206         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
1207         TDB_CONTEXT     *pwd_tdb = NULL;
1208         TDB_DATA key, data;
1209         fstring name;
1210         fstring keystr;
1211
1212         struct tdbsam_privates *tdb_state = (struct tdbsam_privates *)my_methods->private_data;
1213
1214         if (!(pwd_tdb = tdbsam_tdbopen(tdb_state->tdbsam_location, O_RDONLY)))
1215                 return ret;
1216
1217         /* setup the PRIV index key */
1218         fstrcpy(name, privname);
1219         strlower_m(name);
1220
1221         slprintf(keystr, sizeof(keystr)-1, "%s%s", PRIVPREFIX, name);
1222         key.dptr = keystr;
1223         key.dsize = strlen(keystr) + 1;
1224
1225         data = tdb_fetch(pwd_tdb, key);
1226         if (!data.dptr)
1227                 goto done;
1228
1229         *sid_list = strdup(data.dptr);
1230         SAFE_FREE(data.dptr);
1231
1232         if (!*sid_list)
1233                 goto done;
1234
1235         ret = NT_STATUS_OK;
1236 done:
1237         tdb_close(pwd_tdb);
1238         return ret;
1239 }
1240
1241
1242
1243
1244
1245
1246
1247 static NTSTATUS pdb_init_tdbsam(PDB_CONTEXT *pdb_context, PDB_METHODS **pdb_method, const char *location)
1248 {
1249         NTSTATUS nt_status;
1250         struct tdbsam_privates *tdb_state;
1251
1252         if (!NT_STATUS_IS_OK(nt_status = make_pdb_methods(pdb_context->mem_ctx, pdb_method))) {
1253                 return nt_status;
1254         }
1255
1256         (*pdb_method)->name = "tdbsam";
1257
1258         (*pdb_method)->setsampwent = tdbsam_setsampwent;
1259         (*pdb_method)->endsampwent = tdbsam_endsampwent;
1260         (*pdb_method)->getsampwent = tdbsam_getsampwent;
1261         (*pdb_method)->getsampwnam = tdbsam_getsampwnam;
1262         (*pdb_method)->getsampwsid = tdbsam_getsampwsid;
1263         (*pdb_method)->add_sam_account = tdbsam_add_sam_account;
1264         (*pdb_method)->update_sam_account = tdbsam_update_sam_account;
1265         (*pdb_method)->delete_sam_account = tdbsam_delete_sam_account;
1266         (*pdb_method)->gettrustpwent = tdbsam_gettrustpwent;
1267         (*pdb_method)->gettrustpwsid = tdbsam_gettrustpwsid;
1268         (*pdb_method)->add_trust_passwd = tdbsam_add_trust_passwd;
1269         (*pdb_method)->update_trust_passwd = tdbsam_update_trust_passwd;
1270         (*pdb_method)->delete_trust_passwd = tdbsam_delete_trust_passwd;
1271         (*pdb_method)->add_sid_to_privilege = tdbsam_add_sid_to_privilege;
1272         (*pdb_method)->remove_sid_from_privilege = tdbsam_remove_sid_from_privilege;
1273         (*pdb_method)->get_privilege_set = tdbsam_get_privilege_set;
1274         (*pdb_method)->get_privilege_entry = tdbsam_get_privilege_entry;
1275
1276         tdb_state = talloc_zero(pdb_context->mem_ctx, sizeof(struct tdbsam_privates));
1277
1278         if (!tdb_state) {
1279                 DEBUG(0, ("talloc() failed for tdbsam private_data!\n"));
1280                 return NT_STATUS_NO_MEMORY;
1281         }
1282
1283         if (location) {
1284                 tdb_state->tdbsam_location = talloc_strdup(pdb_context->mem_ctx, location);
1285         } else {
1286                 pstring tdbfile;
1287                 get_private_directory(tdbfile);
1288                 pstrcat(tdbfile, "/");
1289                 pstrcat(tdbfile, PASSDB_FILE_NAME);
1290                 tdb_state->tdbsam_location = talloc_strdup(pdb_context->mem_ctx, tdbfile);
1291         }
1292
1293         (*pdb_method)->private_data = tdb_state;
1294
1295         (*pdb_method)->free_private_data = free_private_data;
1296
1297         return NT_STATUS_OK;
1298 }
1299
1300 NTSTATUS pdb_tdbsam_init(void)
1301 {
1302         return smb_register_passdb(PASSDB_INTERFACE_VERSION, "tdbsam", pdb_init_tdbsam);
1303 }