source3/passdb/pdb_interface.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Password and authentication handling
   4    Copyright (C) Andrew Bartlett                        2002
   5    Copyright (C) Jelmer Vernooij                        2002
   6    Copyright (C) Simo Sorce                             2003
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_PASSDB
  27
  28 static struct pdb_init_function_entry *backends = NULL;
  29
  30 static void lazy_initialize_passdb(void)
  31 {
  32         static BOOL initialized = False;
  33         if(initialized)return;
  34         static_init_pdb;
  35         initialized = True;
  36 }
  37
  38 static struct pdb_init_function_entry *pdb_find_backend_entry(const char *name);
  39
  40 /*******************************************************************
  41  Clean up uninitialised passwords.  The only way to tell
  42  that these values are not 'real' is that they do not
  43  have a valid last set time.  Instead, the value is fixed at 0.
  44  Therefore we use that as the key for 'is this a valid password'.
  45  However, it is perfectly valid to have a 'default' last change
  46  time, such LDAP with a missing attribute would produce.
  47 ********************************************************************/
  48
  49 static void pdb_force_pw_initialization(SAM_ACCOUNT *pass)
  50 {
  51         const uint8 *lm_pwd, *nt_pwd;
  52
  53         /* only reset a password if the last set time has been
  54            explicitly been set to zero.  A default last set time
  55            is ignored */
  56
  57         if ( (pdb_get_init_flags(pass, PDB_PASSLASTSET) != PDB_DEFAULT)
  58                 && (pdb_get_pass_last_set_time(pass) == 0) )
  59         {
  60
  61                 if (pdb_get_init_flags(pass, PDB_LMPASSWD) != PDB_DEFAULT)
  62                 {
  63                         lm_pwd = pdb_get_lanman_passwd(pass);
  64                         if (lm_pwd)
  65                                 pdb_set_lanman_passwd(pass, NULL, PDB_CHANGED);
  66                 }
  67                 if (pdb_get_init_flags(pass, PDB_NTPASSWD) != PDB_DEFAULT)
  68                 {
  69                         nt_pwd = pdb_get_nt_passwd(pass);
  70                         if (nt_pwd)
  71                                 pdb_set_nt_passwd(pass, NULL, PDB_CHANGED);
  72                 }
  73         }
  74
  75         return;
  76 }
  77
  78 NTSTATUS smb_register_passdb(int version, const char *name, pdb_init_function init)
  79 {
  80         struct pdb_init_function_entry *entry = backends;
  81
  82         if(version != PASSDB_INTERFACE_VERSION) {
  83                 DEBUG(0,("Can't register passdb backend!\n"
  84                          "You tried to register a passdb module with PASSDB_INTERFACE_VERSION %d, "
  85                          "while this version of samba uses version %d\n",
  86                          version,PASSDB_INTERFACE_VERSION));
  87                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
  88         }
  89
  90         if (!name || !init) {
  91                 return NT_STATUS_INVALID_PARAMETER;
  92         }
  93
  94         DEBUG(5,("Attempting to register passdb backend %s\n", name));
  95
  96         /* Check for duplicates */
  97         if (pdb_find_backend_entry(name)) {
  98                 DEBUG(0,("There already is a passdb backend registered with the name %s!\n", name));
  99                 return NT_STATUS_OBJECT_NAME_COLLISION;
 100         }
 101
 102         entry = SMB_XMALLOC_P(struct pdb_init_function_entry);
 103         entry->name = smb_xstrdup(name);
 104         entry->init = init;
 105
 106         DLIST_ADD(backends, entry);
 107         DEBUG(5,("Successfully added passdb backend '%s'\n", name));
 108         return NT_STATUS_OK;
 109 }
 110
 111 static struct pdb_init_function_entry *pdb_find_backend_entry(const char *name)
 112 {
 113         struct pdb_init_function_entry *entry = backends;
 114
 115         while(entry) {
 116                 if (strcmp(entry->name, name)==0) return entry;
 117                 entry = entry->next;
 118         }
 119
 120         return NULL;
 121 }
 122
 123 static NTSTATUS context_setsampwent(struct pdb_context *context, BOOL update, uint16 acb_mask)
 124 {
 125         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 126
 127         if (!context) {
 128                 DEBUG(0, ("invalid pdb_context specified!\n"));
 129                 return ret;
 130         }
 131
 132         context->pwent_methods = context->pdb_methods;
 133
 134         if (!context->pwent_methods) {
 135                 /* No passdbs at all */
 136                 return ret;
 137         }
 138
 139         while (NT_STATUS_IS_ERR(ret = context->pwent_methods->setsampwent(context->pwent_methods, update, acb_mask))) {
 140                 context->pwent_methods = context->pwent_methods->next;
 141                 if (context->pwent_methods == NULL)
 142                         return NT_STATUS_UNSUCCESSFUL;
 143         }
 144         return ret;
 145 }
 146
 147 static void context_endsampwent(struct pdb_context *context)
 148 {
 149         if ((!context)){
 150                 DEBUG(0, ("invalid pdb_context specified!\n"));
 151                 return;
 152         }
 153
 154         if (context->pwent_methods && context->pwent_methods->endsampwent)
 155                 context->pwent_methods->endsampwent(context->pwent_methods);
 156
 157         /* So we won't get strange data when calling getsampwent now */
 158         context->pwent_methods = NULL;
 159 }
 160
 161 static NTSTATUS context_getsampwent(struct pdb_context *context, SAM_ACCOUNT *user)
 162 {
 163         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 164
 165         if ((!context) || (!context->pwent_methods)) {
 166                 DEBUG(0, ("invalid pdb_context specified!\n"));
 167                 return ret;
 168         }
 169         /* Loop until we find something useful */
 170         while (NT_STATUS_IS_ERR(ret = context->pwent_methods->getsampwent(context->pwent_methods, user))) {
 171
 172                 context->pwent_methods->endsampwent(context->pwent_methods);
 173
 174                 context->pwent_methods = context->pwent_methods->next;
 175
 176                 /* All methods are checked now. There are no more entries */
 177                 if (context->pwent_methods == NULL)
 178                         return ret;
 179
 180                 context->pwent_methods->setsampwent(context->pwent_methods, False, 0);
 181         }
 182         user->methods = context->pwent_methods;
 183         pdb_force_pw_initialization(user);
 184         return ret;
 185 }
 186
 187 static NTSTATUS context_getsampwnam(struct pdb_context *context, SAM_ACCOUNT *sam_acct, const char *username)
 188 {
 189         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 190
 191         struct pdb_methods *curmethods;
 192         if ((!context)) {
 193                 DEBUG(0, ("invalid pdb_context specified!\n"));
 194                 return ret;
 195         }
 196         curmethods = context->pdb_methods;
 197         while (curmethods){
 198                 if (NT_STATUS_IS_OK(ret = curmethods->getsampwnam(curmethods, sam_acct, username))) {
 199                         pdb_force_pw_initialization(sam_acct);
 200                         sam_acct->methods = curmethods;
 201                         return ret;
 202                 }
 203                 curmethods = curmethods->next;
 204         }
 205
 206         return ret;
 207 }
 208
 209 static NTSTATUS context_getsampwsid(struct pdb_context *context, SAM_ACCOUNT *sam_acct, const DOM_SID *sid)
 210 {
 211         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 212
 213         struct pdb_methods *curmethods;
 214         if ((!context)) {
 215                 DEBUG(0, ("invalid pdb_context specified!\n"));
 216                 return ret;
 217         }
 218
 219         curmethods = context->pdb_methods;
 220
 221         while (curmethods){
 222                 if (NT_STATUS_IS_OK(ret = curmethods->getsampwsid(curmethods, sam_acct, sid))) {
 223                         pdb_force_pw_initialization(sam_acct);
 224                         sam_acct->methods = curmethods;
 225                         return ret;
 226                 }
 227                 curmethods = curmethods->next;
 228         }
 229
 230         return ret;
 231 }
 232
 233 static NTSTATUS context_add_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
 234 {
 235         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 236         const uint8 *lm_pw, *nt_pw;
 237         uint16 acb_flags;
 238
 239         if ((!context) || (!context->pdb_methods)) {
 240                 DEBUG(0, ("invalid pdb_context specified!\n"));
 241                 return ret;
 242         }
 243
 244         /* disable acccounts with no passwords (that has not
 245            been allowed by the  ACB_PWNOTREQ bit */
 246
 247         lm_pw = pdb_get_lanman_passwd( sam_acct );
 248         nt_pw = pdb_get_nt_passwd( sam_acct );
 249         acb_flags = pdb_get_acct_ctrl( sam_acct );
 250         if ( !lm_pw && !nt_pw && !(acb_flags&ACB_PWNOTREQ) ) {
 251                 acb_flags |= ACB_DISABLED;
 252                 pdb_set_acct_ctrl( sam_acct, acb_flags, PDB_CHANGED );
 253         }
 254
 255         /** @todo  This is where a 're-read on add' should be done */
 256         /* We now add a new account to the first database listed.
 257          * Should we? */
 258
 259         return context->pdb_methods->add_sam_account(context->pdb_methods, sam_acct);
 260 }
 261
 262 static NTSTATUS context_update_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
 263 {
 264         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 265         const uint8 *lm_pw, *nt_pw;
 266         uint16 acb_flags;
 267
 268         if (!context) {
 269                 DEBUG(0, ("invalid pdb_context specified!\n"));
 270                 return ret;
 271         }
 272
 273         if (!sam_acct || !sam_acct->methods){
 274                 DEBUG(0, ("invalid sam_acct specified\n"));
 275                 return ret;
 276         }
 277
 278         /* disable acccounts with no passwords (that has not
 279            been allowed by the  ACB_PWNOTREQ bit */
 280
 281         lm_pw = pdb_get_lanman_passwd( sam_acct );
 282         nt_pw = pdb_get_nt_passwd( sam_acct );
 283         acb_flags = pdb_get_acct_ctrl( sam_acct );
 284         if ( !lm_pw && !nt_pw && !(acb_flags&ACB_PWNOTREQ) ) {
 285                 acb_flags |= ACB_DISABLED;
 286                 pdb_set_acct_ctrl( sam_acct, acb_flags, PDB_CHANGED );
 287         }
 288
 289         /** @todo  This is where a 're-read on update' should be done */
 290
 291         return sam_acct->methods->update_sam_account(sam_acct->methods, sam_acct);
 292 }
 293
 294 static NTSTATUS context_delete_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
 295 {
 296         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 297
 298         struct pdb_methods *pdb_selected;
 299         if (!context) {
 300                 DEBUG(0, ("invalid pdb_context specified!\n"));
 301                 return ret;
 302         }
 303
 304         if (!sam_acct->methods){
 305                 pdb_selected = context->pdb_methods;
 306                 /* There's no passdb backend specified for this account.
 307                  * Try to delete it in every passdb available
 308                  * Needed to delete accounts in smbpasswd that are not
 309                  * in /etc/passwd.
 310                  */
 311                 while (pdb_selected){
 312                         if (NT_STATUS_IS_OK(ret = pdb_selected->delete_sam_account(pdb_selected, sam_acct))) {
 313                                 return ret;
 314                         }
 315                         pdb_selected = pdb_selected->next;
 316                 }
 317                 return ret;
 318         }
 319
 320         if (!sam_acct->methods->delete_sam_account){
 321                 DEBUG(0,("invalid sam_acct->methods->delete_sam_account\n"));
 322                 return ret;
 323         }
 324
 325         return sam_acct->methods->delete_sam_account(sam_acct->methods, sam_acct);
 326 }
 327
 328 static NTSTATUS context_update_login_attempts(struct pdb_context *context,
 329                                                 SAM_ACCOUNT *sam_acct, BOOL success)
 330 {
 331         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 332
 333         if (!context) {
 334                 DEBUG(0, ("invalid pdb_context specified!\n"));
 335                 return ret;
 336         }
 337
 338         if (!sam_acct || !sam_acct->methods){
 339                 DEBUG(0, ("invalid sam_acct specified\n"));
 340                 return ret;
 341         }
 342
 343         return sam_acct->methods->update_login_attempts(sam_acct->methods, sam_acct, success);
 344 }
 345
 346 static NTSTATUS context_getgrsid(struct pdb_context *context,
 347                                  GROUP_MAP *map, DOM_SID sid)
 348 {
 349         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 350
 351         struct pdb_methods *curmethods;
 352         if ((!context)) {
 353                 DEBUG(0, ("invalid pdb_context specified!\n"));
 354                 return ret;
 355         }
 356         curmethods = context->pdb_methods;
 357         while (curmethods){
 358                 ret = curmethods->getgrsid(curmethods, map, sid);
 359                 if (NT_STATUS_IS_OK(ret)) {
 360                         map->methods = curmethods;
 361                         return ret;
 362                 }
 363                 curmethods = curmethods->next;
 364         }
 365
 366         return ret;
 367 }
 368
 369 static NTSTATUS context_getgrgid(struct pdb_context *context,
 370                                  GROUP_MAP *map, gid_t gid)
 371 {
 372         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 373
 374         struct pdb_methods *curmethods;
 375         if ((!context)) {
 376                 DEBUG(0, ("invalid pdb_context specified!\n"));
 377                 return ret;
 378         }
 379         curmethods = context->pdb_methods;
 380         while (curmethods){
 381                 ret = curmethods->getgrgid(curmethods, map, gid);
 382                 if (NT_STATUS_IS_OK(ret)) {
 383                         map->methods = curmethods;
 384                         return ret;
 385                 }
 386                 curmethods = curmethods->next;
 387         }
 388
 389         return ret;
 390 }
 391
 392 static NTSTATUS context_getgrnam(struct pdb_context *context,
 393                                  GROUP_MAP *map, const char *name)
 394 {
 395         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 396
 397         struct pdb_methods *curmethods;
 398         if ((!context)) {
 399                 DEBUG(0, ("invalid pdb_context specified!\n"));
 400                 return ret;
 401         }
 402         curmethods = context->pdb_methods;
 403         while (curmethods){
 404                 ret = curmethods->getgrnam(curmethods, map, name);
 405                 if (NT_STATUS_IS_OK(ret)) {
 406                         map->methods = curmethods;
 407                         return ret;
 408                 }
 409                 curmethods = curmethods->next;
 410         }
 411
 412         return ret;
 413 }
 414
 415 static NTSTATUS context_add_group_mapping_entry(struct pdb_context *context,
 416                                                 GROUP_MAP *map)
 417 {
 418         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 419
 420         if ((!context) || (!context->pdb_methods)) {
 421                 DEBUG(0, ("invalid pdb_context specified!\n"));
 422                 return ret;
 423         }
 424
 425         return context->pdb_methods->add_group_mapping_entry(context->pdb_methods,
 426                                                              map);
 427 }
 428
 429 static NTSTATUS context_update_group_mapping_entry(struct pdb_context *context,
 430                                                    GROUP_MAP *map)
 431 {
 432         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 433
 434         if ((!context) || (!context->pdb_methods)) {
 435                 DEBUG(0, ("invalid pdb_context specified!\n"));
 436                 return ret;
 437         }
 438
 439         return context->
 440                 pdb_methods->update_group_mapping_entry(context->pdb_methods, map);
 441 }
 442
 443 static NTSTATUS context_delete_group_mapping_entry(struct pdb_context *context,
 444                                                    DOM_SID sid)
 445 {
 446         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 447
 448         if ((!context) || (!context->pdb_methods)) {
 449                 DEBUG(0, ("invalid pdb_context specified!\n"));
 450                 return ret;
 451         }
 452
 453         return context->
 454                 pdb_methods->delete_group_mapping_entry(context->pdb_methods, sid);
 455 }
 456
 457 static NTSTATUS context_enum_group_mapping(struct pdb_context *context,
 458                                            enum SID_NAME_USE sid_name_use,
 459                                            GROUP_MAP **rmap, int *num_entries,
 460                                            BOOL unix_only)
 461 {
 462         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 463
 464         if ((!context) || (!context->pdb_methods)) {
 465                 DEBUG(0, ("invalid pdb_context specified!\n"));
 466                 return ret;
 467         }
 468
 469         return context->pdb_methods->enum_group_mapping(context->pdb_methods,
 470                                                         sid_name_use, rmap,
 471                                                         num_entries, unix_only);
 472 }
 473
 474 static NTSTATUS context_enum_group_members(struct pdb_context *context,
 475                                            TALLOC_CTX *mem_ctx,
 476                                            const DOM_SID *group,
 477                                            uint32 **member_rids,
 478                                            int *num_members)
 479 {
 480         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 481
 482         if ((!context) || (!context->pdb_methods)) {
 483                 DEBUG(0, ("invalid pdb_context specified!\n"));
 484                 return ret;
 485         }
 486
 487         return context->pdb_methods->enum_group_members(context->pdb_methods,
 488                                                         mem_ctx, group,
 489                                                         member_rids,
 490                                                         num_members);
 491 }
 492
 493 static NTSTATUS context_enum_group_memberships(struct pdb_context *context,
 494                                                const char *username,
 495                                                gid_t primary_gid,
 496                                                DOM_SID **sids, gid_t **gids,
 497                                                int *num_groups)
 498 {
 499         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 500
 501         if ((!context) || (!context->pdb_methods)) {
 502                 DEBUG(0, ("invalid pdb_context specified!\n"));
 503                 return ret;
 504         }
 505
 506         return context->pdb_methods->
 507                 enum_group_memberships(context->pdb_methods, username,
 508                                        primary_gid, sids, gids, num_groups);
 509 }
 510
 511 static NTSTATUS context_find_alias(struct pdb_context *context,
 512                                    const char *name, DOM_SID *sid)
 513 {
 514         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 515
 516         if ((!context) || (!context->pdb_methods)) {
 517                 DEBUG(0, ("invalid pdb_context specified!\n"));
 518                 return ret;
 519         }
 520
 521         return context->pdb_methods->find_alias(context->pdb_methods,
 522                                                 name, sid);
 523 }
 524
 525 static NTSTATUS context_create_alias(struct pdb_context *context,
 526                                      const char *name, uint32 *rid)
 527 {
 528         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 529
 530         if ((!context) || (!context->pdb_methods)) {
 531                 DEBUG(0, ("invalid pdb_context specified!\n"));
 532                 return ret;
 533         }
 534
 535         return context->pdb_methods->create_alias(context->pdb_methods,
 536                                                   name, rid);
 537 }
 538
 539 static NTSTATUS context_delete_alias(struct pdb_context *context,
 540                                      const DOM_SID *sid)
 541 {
 542         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 543
 544         if ((!context) || (!context->pdb_methods)) {
 545                 DEBUG(0, ("invalid pdb_context specified!\n"));
 546                 return ret;
 547         }
 548
 549         return context->pdb_methods->delete_alias(context->pdb_methods, sid);
 550 }
 551
 552 static NTSTATUS context_get_aliasinfo(struct pdb_context *context,
 553                                       const DOM_SID *sid,
 554                                       struct acct_info *info)
 555 {
 556         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 557
 558         if ((!context) || (!context->pdb_methods)) {
 559                 DEBUG(0, ("invalid pdb_context specified!\n"));
 560                 return ret;
 561         }
 562
 563         return context->pdb_methods->get_aliasinfo(context->pdb_methods,
 564                                                    sid, info);
 565 }
 566
 567 static NTSTATUS context_set_aliasinfo(struct pdb_context *context,
 568                                       const DOM_SID *sid,
 569                                       struct acct_info *info)
 570 {
 571         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 572
 573         if ((!context) || (!context->pdb_methods)) {
 574                 DEBUG(0, ("invalid pdb_context specified!\n"));
 575                 return ret;
 576         }
 577
 578         return context->pdb_methods->set_aliasinfo(context->pdb_methods,
 579                                                    sid, info);
 580 }
 581
 582 static NTSTATUS context_add_aliasmem(struct pdb_context *context,
 583                                      const DOM_SID *alias,
 584                                      const DOM_SID *member)
 585 {
 586         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 587
 588         if ((!context) || (!context->pdb_methods)) {
 589                 DEBUG(0, ("invalid pdb_context specified!\n"));
 590                 return ret;
 591         }
 592
 593         return context->pdb_methods->add_aliasmem(context->pdb_methods,
 594                                                   alias, member);
 595 }
 596
 597 static NTSTATUS context_del_aliasmem(struct pdb_context *context,
 598                                      const DOM_SID *alias,
 599                                      const DOM_SID *member)
 600 {
 601         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 602
 603         if ((!context) || (!context->pdb_methods)) {
 604                 DEBUG(0, ("invalid pdb_context specified!\n"));
 605                 return ret;
 606         }
 607
 608         return context->pdb_methods->del_aliasmem(context->pdb_methods,
 609                                                   alias, member);
 610 }
 611
 612 static NTSTATUS context_enum_aliasmem(struct pdb_context *context,
 613                                       const DOM_SID *alias, DOM_SID **members,
 614                                       int *num)
 615 {
 616         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 617
 618         if ((!context) || (!context->pdb_methods)) {
 619                 DEBUG(0, ("invalid pdb_context specified!\n"));
 620                 return ret;
 621         }
 622
 623         return context->pdb_methods->enum_aliasmem(context->pdb_methods,
 624                                                    alias, members, num);
 625 }
 626
 627 static NTSTATUS context_enum_alias_memberships(struct pdb_context *context,
 628                                                TALLOC_CTX *mem_ctx,
 629                                                const DOM_SID *domain_sid,
 630                                                const DOM_SID *members,
 631                                                int num_members,
 632                                                uint32 **alias_rids,
 633                                                int *num_alias_rids)
 634 {
 635         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 636
 637         if ((!context) || (!context->pdb_methods)) {
 638                 DEBUG(0, ("invalid pdb_context specified!\n"));
 639                 return ret;
 640         }
 641
 642         return context->pdb_methods->
 643                 enum_alias_memberships(context->pdb_methods, mem_ctx,
 644                                        domain_sid, members, num_members,
 645                                        alias_rids, num_alias_rids);
 646 }
 647
 648 static NTSTATUS context_lookup_rids(struct pdb_context *context,
 649                                     TALLOC_CTX *mem_ctx,
 650                                     const DOM_SID *domain_sid,
 651                                     int num_rids,
 652                                     uint32 *rids,
 653                                     const char ***names,
 654                                     uint32 **attrs)
 655 {
 656         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 657
 658         if ((!context) || (!context->pdb_methods)) {
 659                 DEBUG(0, ("invalid pdb_context specified!\n"));
 660                 return ret;
 661         }
 662
 663         return context->pdb_methods->lookup_rids(context->pdb_methods,
 664                                                  mem_ctx, domain_sid, num_rids,
 665                                                  rids, names, attrs);
 666 }
 667
 668 static NTSTATUS context_get_account_policy(struct pdb_context *context,
 669                                            int policy_index, uint32 *value)
 670 {
 671         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 672
 673         if ((!context) || (!context->pdb_methods)) {
 674                 DEBUG(0, ("invalid pdb_context specified!\n"));
 675                 return ret;
 676         }
 677
 678         return context->pdb_methods->get_account_policy(context->pdb_methods,
 679                                                         policy_index, value);
 680 }
 681
 682 static NTSTATUS context_set_account_policy(struct pdb_context *context,
 683                                            int policy_index, uint32 value)
 684 {
 685         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 686
 687         if ((!context) || (!context->pdb_methods)) {
 688                 DEBUG(0, ("invalid pdb_context specified!\n"));
 689                 return ret;
 690         }
 691
 692         return context->pdb_methods->set_account_policy(context->pdb_methods,
 693                                                         policy_index, value);
 694 }
 695
 696 static NTSTATUS context_get_seq_num(struct pdb_context *context, time_t *seq_num)
 697 {
 698         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 699
 700         if ((!context) || (!context->pdb_methods)) {
 701                 DEBUG(0, ("invalid pdb_context specified!\n"));
 702                 return ret;
 703         }
 704
 705         return context->pdb_methods->get_seq_num(context->pdb_methods, seq_num);
 706 }
 707
 708 /******************************************************************
 709   Free and cleanup a pdb context, any associated data and anything
 710   that the attached modules might have associated.
 711  *******************************************************************/
 712
 713 static void free_pdb_context(struct pdb_context **context)
 714 {
 715         struct pdb_methods *pdb_selected = (*context)->pdb_methods;
 716
 717         while (pdb_selected){
 718                 if(pdb_selected->free_private_data)
 719                         pdb_selected->free_private_data(&(pdb_selected->private_data));
 720                 pdb_selected = pdb_selected->next;
 721         }
 722
 723         talloc_destroy((*context)->mem_ctx);
 724         *context = NULL;
 725 }
 726
 727 static BOOL context_search_users(struct pdb_context *context,
 728                                  struct pdb_search *search, uint16 acct_flags)
 729 {
 730         if ((!context) || (!context->pdb_methods)) {
 731                 DEBUG(0, ("invalid pdb_context specified!\n"));
 732                 return False;
 733         }
 734
 735         return context->pdb_methods->search_users(context->pdb_methods,
 736                                                   search, acct_flags);
 737 }
 738
 739 static BOOL context_search_groups(struct pdb_context *context,
 740                                   struct pdb_search *search)
 741 {
 742         if ((!context) || (!context->pdb_methods)) {
 743                 DEBUG(0, ("invalid pdb_context specified!\n"));
 744                 return False;
 745         }
 746
 747         return context->pdb_methods->search_groups(context->pdb_methods,
 748                                                    search);
 749 }
 750
 751 static BOOL context_search_aliases(struct pdb_context *context,
 752                                    struct pdb_search *search,
 753                                    const DOM_SID *sid)
 754 {
 755         if ((!context) || (!context->pdb_methods)) {
 756                 DEBUG(0, ("invalid pdb_context specified!\n"));
 757                 return False;
 758         }
 759
 760         return context->pdb_methods->search_aliases(context->pdb_methods,
 761                                                     search, sid);
 762 }
 763
 764 /******************************************************************
 765   Make a pdb_methods from scratch
 766  *******************************************************************/
 767
 768 static NTSTATUS make_pdb_methods_name(struct pdb_methods **methods, struct pdb_context *context, const char *selected)
 769 {
 770         char *module_name = smb_xstrdup(selected);
 771         char *module_location = NULL, *p;
 772         struct pdb_init_function_entry *entry;
 773         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 774
 775         lazy_initialize_passdb();
 776
 777         p = strchr(module_name, ':');
 778
 779         if (p) {
 780                 *p = 0;
 781                 module_location = p+1;
 782                 trim_char(module_location, ' ', ' ');
 783         }
 784
 785         trim_char(module_name, ' ', ' ');
 786
 787
 788         DEBUG(5,("Attempting to find an passdb backend to match %s (%s)\n", selected, module_name));
 789
 790         entry = pdb_find_backend_entry(module_name);
 791
 792         /* Try to find a module that contains this module */
 793         if (!entry) {
 794                 DEBUG(2,("No builtin backend found, trying to load plugin\n"));
 795                 if(NT_STATUS_IS_OK(smb_probe_module("pdb", module_name)) && !(entry = pdb_find_backend_entry(module_name))) {
 796                         DEBUG(0,("Plugin is available, but doesn't register passdb backend %s\n", module_name));
 797                         SAFE_FREE(module_name);
 798                         return NT_STATUS_UNSUCCESSFUL;
 799                 }
 800         }
 801
 802         /* No such backend found */
 803         if(!entry) {
 804                 DEBUG(0,("No builtin nor plugin backend for %s found\n", module_name));
 805                 SAFE_FREE(module_name);
 806                 return NT_STATUS_INVALID_PARAMETER;
 807         }
 808
 809         DEBUG(5,("Found pdb backend %s\n", module_name));
 810         nt_status = entry->init(context, methods, module_location);
 811         if (NT_STATUS_IS_OK(nt_status)) {
 812                 DEBUG(5,("pdb backend %s has a valid init\n", selected));
 813         } else {
 814                 DEBUG(0,("pdb backend %s did not correctly init (error was %s)\n", selected, nt_errstr(nt_status)));
 815         }
 816         SAFE_FREE(module_name);
 817         return nt_status;
 818 }
 819
 820 /******************************************************************
 821   Make a pdb_context from scratch.
 822  *******************************************************************/
 823
 824 static NTSTATUS make_pdb_context(struct pdb_context **context)
 825 {
 826         TALLOC_CTX *mem_ctx;
 827
 828         mem_ctx = talloc_init("pdb_context internal allocation context");
 829
 830         if (!mem_ctx) {
 831                 DEBUG(0, ("make_pdb_context: talloc init failed!\n"));
 832                 return NT_STATUS_NO_MEMORY;
 833         }
 834
 835         *context = TALLOC_P(mem_ctx, struct pdb_context);
 836         if (!*context) {
 837                 DEBUG(0, ("make_pdb_context: talloc failed!\n"));
 838                 return NT_STATUS_NO_MEMORY;
 839         }
 840
 841         ZERO_STRUCTP(*context);
 842
 843         (*context)->mem_ctx = mem_ctx;
 844
 845         (*context)->pdb_setsampwent = context_setsampwent;
 846         (*context)->pdb_endsampwent = context_endsampwent;
 847         (*context)->pdb_getsampwent = context_getsampwent;
 848         (*context)->pdb_getsampwnam = context_getsampwnam;
 849         (*context)->pdb_getsampwsid = context_getsampwsid;
 850         (*context)->pdb_add_sam_account = context_add_sam_account;
 851         (*context)->pdb_update_sam_account = context_update_sam_account;
 852         (*context)->pdb_delete_sam_account = context_delete_sam_account;
 853         (*context)->pdb_update_login_attempts = context_update_login_attempts;
 854         (*context)->pdb_getgrsid = context_getgrsid;
 855         (*context)->pdb_getgrgid = context_getgrgid;
 856         (*context)->pdb_getgrnam = context_getgrnam;
 857         (*context)->pdb_add_group_mapping_entry = context_add_group_mapping_entry;
 858         (*context)->pdb_update_group_mapping_entry = context_update_group_mapping_entry;
 859         (*context)->pdb_delete_group_mapping_entry = context_delete_group_mapping_entry;
 860         (*context)->pdb_enum_group_mapping = context_enum_group_mapping;
 861         (*context)->pdb_enum_group_members = context_enum_group_members;
 862         (*context)->pdb_enum_group_memberships = context_enum_group_memberships;
 863
 864         (*context)->pdb_find_alias = context_find_alias;
 865         (*context)->pdb_create_alias = context_create_alias;
 866         (*context)->pdb_delete_alias = context_delete_alias;
 867         (*context)->pdb_get_aliasinfo = context_get_aliasinfo;
 868         (*context)->pdb_set_aliasinfo = context_set_aliasinfo;
 869         (*context)->pdb_add_aliasmem = context_add_aliasmem;
 870         (*context)->pdb_del_aliasmem = context_del_aliasmem;
 871         (*context)->pdb_enum_aliasmem = context_enum_aliasmem;
 872         (*context)->pdb_enum_alias_memberships = context_enum_alias_memberships;
 873         (*context)->pdb_lookup_rids = context_lookup_rids;
 874
 875         (*context)->pdb_get_account_policy = context_get_account_policy;
 876         (*context)->pdb_set_account_policy = context_set_account_policy;
 877
 878         (*context)->pdb_get_seq_num = context_get_seq_num;
 879
 880         (*context)->pdb_search_users = context_search_users;
 881         (*context)->pdb_search_groups = context_search_groups;
 882         (*context)->pdb_search_aliases = context_search_aliases;
 883
 884         (*context)->free_fn = free_pdb_context;
 885
 886         return NT_STATUS_OK;
 887 }
 888
 889
 890 /******************************************************************
 891   Make a pdb_context, given an array of strings
 892  *******************************************************************/
 893
 894 NTSTATUS make_pdb_context_list(struct pdb_context **context, const char **selected)
 895 {
 896         int i = 0;
 897         struct pdb_methods *curmethods, *tmpmethods;
 898         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 899         BOOL have_guest = False;
 900
 901         if (!NT_STATUS_IS_OK(nt_status = make_pdb_context(context))) {
 902                 return nt_status;
 903         }
 904
 905         if (!selected) {
 906                 DEBUG(0, ("ERROR: empty passdb backend list!\n"));
 907                 return nt_status;
 908         }
 909
 910         while (selected[i]){
 911                 if (strcmp(selected[i], "guest") == 0) {
 912                         have_guest = True;
 913                 }
 914                 /* Try to initialise pdb */
 915                 DEBUG(5,("Trying to load: %s\n", selected[i]));
 916                 if (!NT_STATUS_IS_OK(nt_status = make_pdb_methods_name(&curmethods, *context, selected[i]))) {
 917                         DEBUG(1, ("Loading %s failed!\n", selected[i]));
 918                         free_pdb_context(context);
 919                         return nt_status;
 920                 }
 921                 curmethods->parent = *context;
 922                 DLIST_ADD_END((*context)->pdb_methods, curmethods, tmpmethods);
 923                 i++;
 924         }
 925
 926         if (have_guest)
 927                 return NT_STATUS_OK;
 928
 929         if ( (lp_guestaccount() == NULL) ||
 930              (*lp_guestaccount() == '\0') ) {
 931                 /* We explicitly don't want guest access. No idea what
 932                    else that breaks, but be it that way. */
 933                 return NT_STATUS_OK;
 934         }
 935
 936         if (!NT_STATUS_IS_OK(nt_status = make_pdb_methods_name(&curmethods,
 937                                                                *context,
 938                                                                "guest"))) {
 939                 DEBUG(1, ("Loading guest module failed!\n"));
 940                 free_pdb_context(context);
 941                 return nt_status;
 942         }
 943
 944         curmethods->parent = *context;
 945         DLIST_ADD_END((*context)->pdb_methods, curmethods, tmpmethods);
 946
 947         return NT_STATUS_OK;
 948 }
 949
 950 /******************************************************************
 951   Make a pdb_context, given a text string.
 952  *******************************************************************/
 953
 954 NTSTATUS make_pdb_context_string(struct pdb_context **context, const char *selected)
 955 {
 956         NTSTATUS ret;
 957         char **newsel = str_list_make(selected, NULL);
 958         ret = make_pdb_context_list(context, (const char **)newsel);
 959         str_list_free(&newsel);
 960         return ret;
 961 }
 962
 963 /******************************************************************
 964  Return an already initialised pdb_context, to facilitate backward
 965  compatibility (see functions below).
 966 *******************************************************************/
 967
 968 static struct pdb_context *pdb_get_static_context(BOOL reload)
 969 {
 970         static struct pdb_context *pdb_context = NULL;
 971
 972         if ((pdb_context) && (reload)) {
 973                 pdb_context->free_fn(&pdb_context);
 974                 if (!NT_STATUS_IS_OK(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
 975                         return NULL;
 976                 }
 977         }
 978
 979         if (!pdb_context) {
 980                 if (!NT_STATUS_IS_OK(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
 981                         return NULL;
 982                 }
 983         }
 984
 985         return pdb_context;
 986 }
 987
 988 /******************************************************************
 989  Backward compatibility functions for the original passdb interface
 990 *******************************************************************/
 991
 992 BOOL pdb_setsampwent(BOOL update, uint16 acb_mask)
 993 {
 994         struct pdb_context *pdb_context = pdb_get_static_context(False);
 995
 996         if (!pdb_context) {
 997                 return False;
 998         }
 999
1000         return NT_STATUS_IS_OK(pdb_context->pdb_setsampwent(pdb_context, update, acb_mask));
1001 }
1002
1003 void pdb_endsampwent(void)
1004 {
1005         struct pdb_context *pdb_context = pdb_get_static_context(False);
1006
1007         if (!pdb_context) {
1008                 return;
1009         }
1010
1011         pdb_context->pdb_endsampwent(pdb_context);
1012 }
1013
1014 BOOL pdb_getsampwent(SAM_ACCOUNT *user)
1015 {
1016         struct pdb_context *pdb_context = pdb_get_static_context(False);
1017
1018         if (!pdb_context) {
1019                 return False;
1020         }
1021
1022         return NT_STATUS_IS_OK(pdb_context->pdb_getsampwent(pdb_context, user));
1023 }
1024
1025 static SAM_ACCOUNT *sam_account_cache = NULL;
1026
1027 BOOL pdb_getsampwnam(SAM_ACCOUNT *sam_acct, const char *username)
1028 {
1029         struct pdb_context *pdb_context = pdb_get_static_context(False);
1030
1031         if (!pdb_context) {
1032                 return False;
1033         }
1034
1035         if (!NT_STATUS_IS_OK(pdb_context->pdb_getsampwnam(pdb_context,
1036                                                           sam_acct, username)))
1037                 return False;
1038
1039         if (sam_account_cache != NULL) {
1040                 pdb_free_sam(&sam_account_cache);
1041                 sam_account_cache = NULL;
1042         }
1043
1044         pdb_copy_sam_account(sam_acct, &sam_account_cache);
1045         return True;
1046 }
1047
1048 BOOL pdb_getsampwsid(SAM_ACCOUNT *sam_acct, const DOM_SID *sid)
1049 {
1050         struct pdb_context *pdb_context = pdb_get_static_context(False);
1051
1052         if (!pdb_context) {
1053                 return False;
1054         }
1055
1056         if ((sam_account_cache != NULL) &&
1057             (sid_equal(sid, pdb_get_user_sid(sam_account_cache))))
1058                 return pdb_copy_sam_account(sam_account_cache, &sam_acct);
1059
1060         return NT_STATUS_IS_OK(pdb_context->pdb_getsampwsid(pdb_context, sam_acct, sid));
1061 }
1062
1063 BOOL pdb_add_sam_account(SAM_ACCOUNT *sam_acct)
1064 {
1065         struct pdb_context *pdb_context = pdb_get_static_context(False);
1066
1067         if (!pdb_context) {
1068                 return False;
1069         }
1070
1071         return NT_STATUS_IS_OK(pdb_context->pdb_add_sam_account(pdb_context, sam_acct));
1072 }
1073
1074 BOOL pdb_update_sam_account(SAM_ACCOUNT *sam_acct)
1075 {
1076         struct pdb_context *pdb_context = pdb_get_static_context(False);
1077
1078         if (!pdb_context) {
1079                 return False;
1080         }
1081
1082         if (sam_account_cache != NULL) {
1083                 pdb_free_sam(&sam_account_cache);
1084                 sam_account_cache = NULL;
1085         }
1086
1087         return NT_STATUS_IS_OK(pdb_context->pdb_update_sam_account(pdb_context, sam_acct));
1088 }
1089
1090 BOOL pdb_delete_sam_account(SAM_ACCOUNT *sam_acct)
1091 {
1092         struct pdb_context *pdb_context = pdb_get_static_context(False);
1093
1094         if (!pdb_context) {
1095                 return False;
1096         }
1097
1098         if (sam_account_cache != NULL) {
1099                 pdb_free_sam(&sam_account_cache);
1100                 sam_account_cache = NULL;
1101         }
1102
1103         return NT_STATUS_IS_OK(pdb_context->pdb_delete_sam_account(pdb_context, sam_acct));
1104 }
1105
1106 NTSTATUS pdb_update_login_attempts(SAM_ACCOUNT *sam_acct, BOOL success)
1107 {
1108         struct pdb_context *pdb_context = pdb_get_static_context(False);
1109
1110         if (!pdb_context) {
1111                 return NT_STATUS_NOT_IMPLEMENTED;
1112         }
1113
1114         return pdb_context->pdb_update_login_attempts(pdb_context, sam_acct, success);
1115 }
1116
1117 BOOL pdb_getgrsid(GROUP_MAP *map, DOM_SID sid)
1118 {
1119         struct pdb_context *pdb_context = pdb_get_static_context(False);
1120
1121         if (!pdb_context) {
1122                 return False;
1123         }
1124
1125         return NT_STATUS_IS_OK(pdb_context->
1126                                pdb_getgrsid(pdb_context, map, sid));
1127 }
1128
1129 BOOL pdb_getgrgid(GROUP_MAP *map, gid_t gid)
1130 {
1131         struct pdb_context *pdb_context = pdb_get_static_context(False);
1132
1133         if (!pdb_context) {
1134                 return False;
1135         }
1136
1137         return NT_STATUS_IS_OK(pdb_context->
1138                                pdb_getgrgid(pdb_context, map, gid));
1139 }
1140
1141 BOOL pdb_getgrnam(GROUP_MAP *map, const char *name)
1142 {
1143         struct pdb_context *pdb_context = pdb_get_static_context(False);
1144
1145         if (!pdb_context) {
1146                 return False;
1147         }
1148
1149         return NT_STATUS_IS_OK(pdb_context->
1150                                pdb_getgrnam(pdb_context, map, name));
1151 }
1152
1153 BOOL pdb_add_group_mapping_entry(GROUP_MAP *map)
1154 {
1155         struct pdb_context *pdb_context = pdb_get_static_context(False);
1156
1157         if (!pdb_context) {
1158                 return False;
1159         }
1160
1161         return NT_STATUS_IS_OK(pdb_context->
1162                                pdb_add_group_mapping_entry(pdb_context, map));
1163 }
1164
1165 BOOL pdb_update_group_mapping_entry(GROUP_MAP *map)
1166 {
1167         struct pdb_context *pdb_context = pdb_get_static_context(False);
1168
1169         if (!pdb_context) {
1170                 return False;
1171         }
1172
1173         return NT_STATUS_IS_OK(pdb_context->
1174                                pdb_update_group_mapping_entry(pdb_context, map));
1175 }
1176
1177 BOOL pdb_delete_group_mapping_entry(DOM_SID sid)
1178 {
1179         struct pdb_context *pdb_context = pdb_get_static_context(False);
1180
1181         if (!pdb_context) {
1182                 return False;
1183         }
1184
1185         return NT_STATUS_IS_OK(pdb_context->
1186                                pdb_delete_group_mapping_entry(pdb_context, sid));
1187 }
1188
1189 BOOL pdb_enum_group_mapping(enum SID_NAME_USE sid_name_use, GROUP_MAP **rmap,
1190                             int *num_entries, BOOL unix_only)
1191 {
1192         struct pdb_context *pdb_context = pdb_get_static_context(False);
1193
1194         if (!pdb_context) {
1195                 return False;
1196         }
1197
1198         return NT_STATUS_IS_OK(pdb_context->
1199                                pdb_enum_group_mapping(pdb_context, sid_name_use,
1200                                                       rmap, num_entries, unix_only));
1201 }
1202
1203 NTSTATUS pdb_enum_group_members(TALLOC_CTX *mem_ctx,
1204                                 const DOM_SID *sid,
1205                                 uint32 **member_rids,
1206                                 int *num_members)
1207 {
1208         struct pdb_context *pdb_context = pdb_get_static_context(False);
1209
1210         if (!pdb_context) {
1211                 return NT_STATUS_UNSUCCESSFUL;
1212         }
1213
1214         return pdb_context->pdb_enum_group_members(pdb_context, mem_ctx, sid,
1215                                                    member_rids, num_members);
1216 }
1217
1218 NTSTATUS pdb_enum_group_memberships(const char *username, gid_t primary_gid,
1219                                     DOM_SID **sids, gid_t **gids,
1220                                     int *num_groups)
1221 {
1222         struct pdb_context *pdb_context = pdb_get_static_context(False);
1223
1224         if (!pdb_context) {
1225                 return NT_STATUS_UNSUCCESSFUL;
1226         }
1227
1228         return pdb_context->pdb_enum_group_memberships(pdb_context, username,
1229                                                        primary_gid, sids, gids,
1230                                                        num_groups);
1231 }
1232
1233 BOOL pdb_find_alias(const char *name, DOM_SID *sid)
1234 {
1235         struct pdb_context *pdb_context = pdb_get_static_context(False);
1236
1237         if (!pdb_context) {
1238                 return False;
1239         }
1240
1241         return NT_STATUS_IS_OK(pdb_context->pdb_find_alias(pdb_context,
1242                                                              name, sid));
1243 }
1244
1245 NTSTATUS pdb_create_alias(const char *name, uint32 *rid)
1246 {
1247         struct pdb_context *pdb_context = pdb_get_static_context(False);
1248
1249         if (!pdb_context) {
1250                 return NT_STATUS_NOT_IMPLEMENTED;
1251         }
1252
1253         return pdb_context->pdb_create_alias(pdb_context, name, rid);
1254 }
1255
1256 BOOL pdb_delete_alias(const DOM_SID *sid)
1257 {
1258         struct pdb_context *pdb_context = pdb_get_static_context(False);
1259
1260         if (!pdb_context) {
1261                 return False;
1262         }
1263
1264         return NT_STATUS_IS_OK(pdb_context->pdb_delete_alias(pdb_context,
1265                                                              sid));
1266
1267 }
1268
1269 BOOL pdb_get_aliasinfo(const DOM_SID *sid, struct acct_info *info)
1270 {
1271         struct pdb_context *pdb_context = pdb_get_static_context(False);
1272
1273         if (!pdb_context) {
1274                 return False;
1275         }
1276
1277         return NT_STATUS_IS_OK(pdb_context->pdb_get_aliasinfo(pdb_context, sid,
1278                                                               info));
1279 }
1280
1281 BOOL pdb_set_aliasinfo(const DOM_SID *sid, struct acct_info *info)
1282 {
1283         struct pdb_context *pdb_context = pdb_get_static_context(False);
1284
1285         if (!pdb_context) {
1286                 return False;
1287         }
1288
1289         return NT_STATUS_IS_OK(pdb_context->pdb_set_aliasinfo(pdb_context, sid,
1290                                                               info));
1291 }
1292
1293 BOOL pdb_add_aliasmem(const DOM_SID *alias, const DOM_SID *member)
1294 {
1295         struct pdb_context *pdb_context = pdb_get_static_context(False);
1296
1297         if (!pdb_context) {
1298                 return False;
1299         }
1300
1301         return NT_STATUS_IS_OK(pdb_context->
1302                                pdb_add_aliasmem(pdb_context, alias, member));
1303 }
1304
1305 BOOL pdb_del_aliasmem(const DOM_SID *alias, const DOM_SID *member)
1306 {
1307         struct pdb_context *pdb_context = pdb_get_static_context(False);
1308
1309         if (!pdb_context) {
1310                 return False;
1311         }
1312
1313         return NT_STATUS_IS_OK(pdb_context->
1314                                pdb_del_aliasmem(pdb_context, alias, member));
1315 }
1316
1317 BOOL pdb_enum_aliasmem(const DOM_SID *alias,
1318                        DOM_SID **members, int *num_members)
1319 {
1320         struct pdb_context *pdb_context = pdb_get_static_context(False);
1321
1322         if (!pdb_context) {
1323                 return False;
1324         }
1325
1326         return NT_STATUS_IS_OK(pdb_context->
1327                                pdb_enum_aliasmem(pdb_context, alias,
1328                                                  members, num_members));
1329 }
1330
1331 BOOL pdb_enum_alias_memberships(TALLOC_CTX *mem_ctx, const DOM_SID *domain_sid,
1332                                 const DOM_SID *members, int num_members,
1333                                 uint32 **alias_rids, int *num_alias_rids)
1334 {
1335         struct pdb_context *pdb_context = pdb_get_static_context(False);
1336
1337         if (!pdb_context) {
1338                 return False;
1339         }
1340
1341         return NT_STATUS_IS_OK(pdb_context->
1342                                pdb_enum_alias_memberships(pdb_context, mem_ctx,
1343                                                           domain_sid,
1344                                                           members, num_members,
1345                                                           alias_rids,
1346                                                           num_alias_rids));
1347 }
1348
1349 NTSTATUS pdb_lookup_rids(TALLOC_CTX *mem_ctx,
1350                          const DOM_SID *domain_sid,
1351                          int num_rids,
1352                          uint32 *rids,
1353                          const char ***names,
1354                          uint32 **attrs)
1355 {
1356         struct pdb_context *pdb_context = pdb_get_static_context(False);
1357
1358         if (!pdb_context) {
1359                 return NT_STATUS_NOT_IMPLEMENTED;
1360         }
1361
1362         return pdb_context->pdb_lookup_rids(pdb_context, mem_ctx, domain_sid,
1363                                             num_rids, rids, names, attrs);
1364 }
1365
1366 BOOL pdb_get_account_policy(int policy_index, uint32 *value)
1367 {
1368         struct pdb_context *pdb_context = pdb_get_static_context(False);
1369
1370         if (!pdb_context) {
1371                 return False;
1372         }
1373
1374         return NT_STATUS_IS_OK(pdb_context->
1375                                pdb_get_account_policy(pdb_context, policy_index, value));
1376 }
1377
1378 BOOL pdb_set_account_policy(int policy_index, uint32 value)
1379 {
1380         struct pdb_context *pdb_context = pdb_get_static_context(False);
1381
1382         if (!pdb_context) {
1383                 return False;
1384         }
1385
1386         return NT_STATUS_IS_OK(pdb_context->
1387                                pdb_set_account_policy(pdb_context, policy_index, value));
1388 }
1389
1390 BOOL pdb_get_seq_num(time_t *seq_num)
1391 {
1392         struct pdb_context *pdb_context = pdb_get_static_context(False);
1393
1394         if (!pdb_context) {
1395                 return False;
1396         }
1397
1398         return NT_STATUS_IS_OK(pdb_context->
1399                                pdb_get_seq_num(pdb_context, seq_num));
1400 }
1401 /***************************************************************
1402   Initialize the static context (at smbd startup etc).
1403
1404   If uninitialised, context will auto-init on first use.
1405  ***************************************************************/
1406
1407 BOOL initialize_password_db(BOOL reload)
1408 {
1409         return (pdb_get_static_context(reload) != NULL);
1410 }
1411
1412
1413 /***************************************************************************
1414   Default implementations of some functions.
1415  ****************************************************************************/
1416
1417 static NTSTATUS pdb_default_getsampwnam (struct pdb_methods *methods, SAM_ACCOUNT *user, const char *sname)
1418 {
1419         return NT_STATUS_NO_SUCH_USER;
1420 }
1421
1422 static NTSTATUS pdb_default_getsampwsid(struct pdb_methods *my_methods, SAM_ACCOUNT * user, const DOM_SID *sid)
1423 {
1424         return NT_STATUS_NO_SUCH_USER;
1425 }
1426
1427 static NTSTATUS pdb_default_add_sam_account (struct pdb_methods *methods, SAM_ACCOUNT *newpwd)
1428 {
1429         DEBUG(0,("this backend (%s) should not be listed as the first passdb backend! You can't add users to it.\n", methods->name));
1430         return NT_STATUS_NOT_IMPLEMENTED;
1431 }
1432
1433 static NTSTATUS pdb_default_update_sam_account (struct pdb_methods *methods, SAM_ACCOUNT *newpwd)
1434 {
1435         return NT_STATUS_NOT_IMPLEMENTED;
1436 }
1437
1438 static NTSTATUS pdb_default_delete_sam_account (struct pdb_methods *methods, SAM_ACCOUNT *pwd)
1439 {
1440         return NT_STATUS_NOT_IMPLEMENTED;
1441 }
1442
1443 static NTSTATUS pdb_default_update_login_attempts (struct pdb_methods *methods, SAM_ACCOUNT *newpwd, BOOL success)
1444 {
1445         return NT_STATUS_OK;
1446 }
1447
1448 static NTSTATUS pdb_default_setsampwent(struct pdb_methods *methods, BOOL update, uint16 acb_mask)
1449 {
1450         return NT_STATUS_NOT_IMPLEMENTED;
1451 }
1452
1453 static NTSTATUS pdb_default_getsampwent(struct pdb_methods *methods, SAM_ACCOUNT *user)
1454 {
1455         return NT_STATUS_NOT_IMPLEMENTED;
1456 }
1457
1458 static void pdb_default_endsampwent(struct pdb_methods *methods)
1459 {
1460         return; /* NT_STATUS_NOT_IMPLEMENTED; */
1461 }
1462
1463 static NTSTATUS pdb_default_get_account_policy(struct pdb_methods *methods, int policy_index, uint32 *value)
1464 {
1465         return account_policy_get(policy_index, value) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1466 }
1467
1468 static NTSTATUS pdb_default_set_account_policy(struct pdb_methods *methods, int policy_index, uint32 value)
1469 {
1470         return account_policy_set(policy_index, value) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1471 }
1472
1473 static NTSTATUS pdb_default_get_seq_num(struct pdb_methods *methods, time_t *seq_num)
1474 {
1475         *seq_num = time(NULL);
1476         return NT_STATUS_OK;
1477 }
1478
1479 static void add_uid_to_array_unique(TALLOC_CTX *mem_ctx,
1480                                     uid_t uid, uid_t **uids, int *num)
1481 {
1482         int i;
1483
1484         for (i=0; i<*num; i++) {
1485                 if ((*uids)[i] == uid)
1486                         return;
1487         }
1488
1489         *uids = TALLOC_REALLOC_ARRAY(mem_ctx, *uids, uid_t, *num+1);
1490
1491         if (*uids == NULL)
1492                 return;
1493
1494         (*uids)[*num] = uid;
1495         *num += 1;
1496 }
1497
1498 static BOOL get_memberuids(TALLOC_CTX *mem_ctx, gid_t gid, uid_t **uids,
1499                            int *num)
1500 {
1501         struct group *grp;
1502         char **gr;
1503         struct sys_pwent *userlist, *user;
1504
1505         *uids = NULL;
1506         *num = 0;
1507
1508         /* We only look at our own sam, so don't care about imported stuff */
1509
1510         winbind_off();
1511
1512         if ((grp = getgrgid(gid)) == NULL) {
1513                 winbind_on();
1514                 return False;
1515         }
1516
1517         /* Primary group members */
1518
1519         userlist = getpwent_list();
1520
1521         for (user = userlist; user != NULL; user = user->next) {
1522                 if (user->pw_gid != gid)
1523                         continue;
1524                 add_uid_to_array_unique(mem_ctx, user->pw_uid, uids, num);
1525         }
1526
1527         pwent_free(userlist);
1528
1529         /* Secondary group members */
1530
1531         for (gr = grp->gr_mem; (*gr != NULL) && ((*gr)[0] != '\0'); gr += 1) {
1532                 struct passwd *pw = getpwnam(*gr);
1533
1534                 if (pw == NULL)
1535                         continue;
1536                 add_uid_to_array_unique(mem_ctx, pw->pw_uid, uids, num);
1537         }
1538
1539         winbind_on();
1540
1541         return True;
1542 }
1543
1544 NTSTATUS pdb_default_enum_group_members(struct pdb_methods *methods,
1545                                         TALLOC_CTX *mem_ctx,
1546                                         const DOM_SID *group,
1547                                         uint32 **member_rids,
1548                                         int *num_members)
1549 {
1550         gid_t gid;
1551         uid_t *uids;
1552         int i, num_uids;
1553
1554         *member_rids = NULL;
1555         *num_members = 0;
1556
1557         if (!NT_STATUS_IS_OK(sid_to_gid(group, &gid)))
1558                 return NT_STATUS_NO_SUCH_GROUP;
1559
1560         if(!get_memberuids(mem_ctx, gid, &uids, &num_uids))
1561                 return NT_STATUS_NO_SUCH_GROUP;
1562
1563         if (num_uids == 0)
1564                 return NT_STATUS_OK;
1565
1566         *member_rids = TALLOC_ZERO_ARRAY(mem_ctx, uint32, num_uids);
1567
1568         for (i=0; i<num_uids; i++) {
1569                 DOM_SID sid;
1570
1571                 if (!NT_STATUS_IS_OK(uid_to_sid(&sid, uids[i]))) {
1572                         DEBUG(1, ("Could not map member uid to SID\n"));
1573                         continue;
1574                 }
1575
1576                 if (!sid_check_is_in_our_domain(&sid)) {
1577                         DEBUG(1, ("Inconsistent SAM -- group member uid not "
1578                                   "in our domain\n"));
1579                         continue;
1580                 }
1581
1582                 sid_peek_rid(&sid, &(*member_rids)[*num_members]);
1583                 *num_members += 1;
1584         }
1585
1586         return NT_STATUS_OK;
1587 }
1588
1589 NTSTATUS pdb_default_lookup_rids(struct pdb_methods *methods,
1590                                  TALLOC_CTX *mem_ctx,
1591                                  const DOM_SID *domain_sid,
1592                                  int num_rids,
1593                                  uint32 *rids,
1594                                  const char ***names,
1595                                  uint32 **attrs)
1596 {
1597         int i;
1598         NTSTATUS result;
1599         BOOL have_mapped = False;
1600         BOOL have_unmapped = False;
1601
1602         (*names) = TALLOC_ZERO_ARRAY(mem_ctx, const char *, num_rids);
1603         (*attrs) = TALLOC_ZERO_ARRAY(mem_ctx, uint32, num_rids);
1604
1605         if ((num_rids != 0) && (((*names) == NULL) || ((*attrs) == NULL)))
1606                 return NT_STATUS_NO_MEMORY;
1607
1608         if (!sid_equal(domain_sid, get_global_sam_sid())) {
1609                 /* TODO: Sooner or later we need to look up BUILTIN rids as
1610                  * well. -- vl */
1611                 goto done;
1612         }
1613
1614         for (i = 0; i < num_rids; i++) {
1615                 fstring tmpname;
1616                 fstring domname;
1617                 DOM_SID sid;
1618                 enum SID_NAME_USE type;
1619
1620                 (*attrs)[i] = SID_NAME_UNKNOWN;
1621
1622                 sid_copy(&sid, domain_sid);
1623                 sid_append_rid(&sid, rids[i]);
1624
1625                 if (lookup_sid(&sid, domname, tmpname, &type)) {
1626                         (*attrs)[i] = (uint32)type;
1627                         (*names)[i] = talloc_strdup(mem_ctx, tmpname);
1628                         if ((*names)[i] == NULL)
1629                                 return NT_STATUS_NO_MEMORY;
1630                         DEBUG(5,("lookup_rids: %s:%d\n", (*names)[i],
1631                                  (*attrs)[i]));
1632                         have_mapped = True;
1633                 } else {
1634                         have_unmapped = True;
1635                 }
1636         }
1637
1638  done:
1639
1640         result = NT_STATUS_NONE_MAPPED;
1641
1642         if (have_mapped)
1643                 result = have_unmapped ? STATUS_SOME_UNMAPPED : NT_STATUS_OK;
1644
1645         return result;
1646 }
1647
1648 static struct pdb_search *pdb_search_init(enum pdb_search_type type)
1649 {
1650         TALLOC_CTX *mem_ctx;
1651         struct pdb_search *result;
1652
1653         mem_ctx = talloc_init("pdb_search");
1654         if (mem_ctx == NULL) {
1655                 DEBUG(0, ("talloc_init failed\n"));
1656                 return NULL;
1657         }
1658
1659         result = TALLOC_P(mem_ctx, struct pdb_search);
1660         if (result == NULL) {
1661                 DEBUG(0, ("talloc failed\n"));
1662                 return NULL;
1663         }
1664
1665         result->mem_ctx = mem_ctx;
1666         result->type = type;
1667         result->cache = NULL;
1668         result->num_entries = 0;
1669         result->cache_size = 0;
1670         result->search_ended = False;
1671
1672         /* Segfault appropriately if not initialized */
1673         result->next_entry = NULL;
1674         result->search_end = NULL;
1675
1676         return result;
1677 }
1678
1679 static void fill_displayentry(TALLOC_CTX *mem_ctx, uint32 rid,
1680                               uint16 acct_flags,
1681                               const char *account_name,
1682                               const char *fullname,
1683                               const char *description,
1684                               struct samr_displayentry *entry)
1685 {
1686         entry->rid = rid;
1687         entry->acct_flags = acct_flags;
1688
1689         if (account_name != NULL)
1690                 entry->account_name = talloc_strdup(mem_ctx, account_name);
1691         else
1692                 entry->account_name = "";
1693
1694         if (fullname != NULL)
1695                 entry->fullname = talloc_strdup(mem_ctx, fullname);
1696         else
1697                 entry->fullname = "";
1698
1699         if (description != NULL)
1700                 entry->description = talloc_strdup(mem_ctx, description);
1701         else
1702                 entry->description = "";
1703 }
1704
1705 static BOOL user_search_in_progress = False;
1706 struct user_search {
1707         uint16 acct_flags;
1708 };
1709
1710 static BOOL next_entry_users(struct pdb_search *s,
1711                              struct samr_displayentry *entry)
1712 {
1713         struct user_search *state = s->private_data;
1714         SAM_ACCOUNT *user = NULL;
1715         NTSTATUS status;
1716
1717  next:
1718         status = pdb_init_sam(&user);
1719         if (!NT_STATUS_IS_OK(status)) {
1720                 DEBUG(0, ("Could not pdb_init_sam\n"));
1721                 return False;
1722         }
1723
1724         if (!pdb_getsampwent(user)) {
1725                 pdb_free_sam(&user);
1726                 return False;
1727         }
1728
1729         if ((state->acct_flags != 0) &&
1730             ((pdb_get_acct_ctrl(user) & state->acct_flags) == 0)) {
1731                 pdb_free_sam(&user);
1732                 goto next;
1733         }
1734
1735         fill_displayentry(s->mem_ctx, pdb_get_user_rid(user),
1736                           pdb_get_acct_ctrl(user), pdb_get_username(user),
1737                           pdb_get_fullname(user), pdb_get_acct_desc(user),
1738                           entry);
1739
1740         pdb_free_sam(&user);
1741         return True;
1742 }
1743
1744 static void search_end_users(struct pdb_search *search)
1745 {
1746         pdb_endsampwent();
1747         user_search_in_progress = False;
1748 }
1749
1750 static BOOL pdb_default_search_users(struct pdb_methods *methods,
1751                                      struct pdb_search *search,
1752                                      uint16 acct_flags)
1753 {
1754         struct user_search *state;
1755
1756         if (user_search_in_progress) {
1757                 DEBUG(1, ("user search in progress\n"));
1758                 return False;
1759         }
1760
1761         if (!pdb_setsampwent(False, acct_flags)) {
1762                 DEBUG(5, ("Could not start search\n"));
1763                 return False;
1764         }
1765
1766         user_search_in_progress = True;
1767
1768         state = TALLOC_P(search->mem_ctx, struct user_search);
1769         if (state == NULL) {
1770                 DEBUG(0, ("talloc failed\n"));
1771                 return False;
1772         }
1773
1774         state->acct_flags = acct_flags;
1775
1776         search->private_data = state;
1777         search->next_entry = next_entry_users;
1778         search->search_end = search_end_users;
1779         return True;
1780 }
1781
1782 struct group_search {
1783         GROUP_MAP *groups;
1784         int num_groups, current_group;
1785 };
1786
1787 static BOOL next_entry_groups(struct pdb_search *s,
1788                               struct samr_displayentry *entry)
1789 {
1790         struct group_search *state = s->private_data;
1791         uint32 rid;
1792         GROUP_MAP *map = &state->groups[state->current_group];
1793
1794         if (state->current_group == state->num_groups)
1795                 return False;
1796
1797         sid_peek_rid(&map->sid, &rid);
1798
1799         fill_displayentry(s->mem_ctx, rid, 0, map->nt_name, NULL, map->comment,
1800                           entry);
1801
1802         state->current_group += 1;
1803         return True;
1804 }
1805
1806 static void search_end_groups(struct pdb_search *search)
1807 {
1808         struct group_search *state = search->private_data;
1809         SAFE_FREE(state->groups);
1810 }
1811
1812 static BOOL pdb_search_grouptype(struct pdb_search *search,
1813                                  enum SID_NAME_USE type)
1814 {
1815         struct group_search *state;
1816
1817         state = TALLOC_P(search->mem_ctx, struct group_search);
1818         if (state == NULL) {
1819                 DEBUG(0, ("talloc failed\n"));
1820                 return False;
1821         }
1822
1823         if (!pdb_enum_group_mapping(type, &state->groups, &state->num_groups,
1824                                     True)) {
1825                 DEBUG(0, ("Could not enum groups\n"));
1826                 return False;
1827         }
1828
1829         state->current_group = 0;
1830         search->private_data = state;
1831         search->next_entry = next_entry_groups;
1832         search->search_end = search_end_groups;
1833         return True;
1834 }
1835
1836 static BOOL pdb_default_search_groups(struct pdb_methods *methods,
1837                                       struct pdb_search *search)
1838 {
1839         return pdb_search_grouptype(search, SID_NAME_DOM_GRP);
1840 }
1841
1842 static BOOL pdb_default_search_aliases(struct pdb_methods *methods,
1843                                        struct pdb_search *search,
1844                                        const DOM_SID *sid)
1845 {
1846
1847         if (sid_equal(sid, get_global_sam_sid()))
1848                 return pdb_search_grouptype(search, SID_NAME_ALIAS);
1849
1850         if (sid_equal(sid, &global_sid_Builtin))
1851                 return pdb_search_grouptype(search, SID_NAME_WKN_GRP);
1852
1853         DEBUG(3, ("unknown domain sid: %s\n", sid_string_static(sid)));
1854         return False;
1855 }
1856
1857 static struct samr_displayentry *pdb_search_getentry(struct pdb_search *search,
1858                                                      uint32 idx)
1859 {
1860         if (idx < search->num_entries)
1861                 return &search->cache[idx];
1862
1863         if (search->search_ended)
1864                 return NULL;
1865
1866         while (idx >= search->num_entries) {
1867                 struct samr_displayentry entry;
1868
1869                 if (!search->next_entry(search, &entry)) {
1870                         search->search_end(search);
1871                         search->search_ended = True;
1872                         break;
1873                 }
1874
1875                 ADD_TO_LARGE_ARRAY(search->mem_ctx, struct samr_displayentry,
1876                                    entry, &search->cache, &search->num_entries,
1877                                    &search->cache_size);
1878         }
1879
1880         return (search->num_entries > idx) ? &search->cache[idx] : NULL;
1881 }
1882
1883 struct pdb_search *pdb_search_users(uint16 acct_flags)
1884 {
1885         struct pdb_context *pdb_context = pdb_get_static_context(False);
1886         struct pdb_search *result;
1887
1888         if (pdb_context == NULL) return NULL;
1889
1890         result = pdb_search_init(PDB_USER_SEARCH);
1891         if (result == NULL) return NULL;
1892
1893         if (!pdb_context->pdb_search_users(pdb_context, result, acct_flags)) {
1894                 talloc_destroy(result->mem_ctx);
1895                 return NULL;
1896         }
1897         return result;
1898 }
1899
1900 struct pdb_search *pdb_search_groups(void)
1901 {
1902         struct pdb_context *pdb_context = pdb_get_static_context(False);
1903         struct pdb_search *result;
1904
1905         if (pdb_context == NULL) return NULL;
1906
1907         result = pdb_search_init(PDB_GROUP_SEARCH);
1908         if (result == NULL) return NULL;
1909
1910         if (!pdb_context->pdb_search_groups(pdb_context, result)) {
1911                 talloc_destroy(result->mem_ctx);
1912                 return NULL;
1913         }
1914         return result;
1915 }
1916
1917 struct pdb_search *pdb_search_aliases(const DOM_SID *sid)
1918 {
1919         struct pdb_context *pdb_context = pdb_get_static_context(False);
1920         struct pdb_search *result;
1921
1922         if (pdb_context == NULL) return NULL;
1923
1924         result = pdb_search_init(PDB_ALIAS_SEARCH);
1925         if (result == NULL) return NULL;
1926
1927         if (!pdb_context->pdb_search_aliases(pdb_context, result, sid)) {
1928                 talloc_destroy(result->mem_ctx);
1929                 return NULL;
1930         }
1931         return result;
1932 }
1933
1934 uint32 pdb_search_entries(struct pdb_search *search,
1935                           uint32 start_idx, uint32 max_entries,
1936                           struct samr_displayentry **result)
1937 {
1938         struct samr_displayentry *end_entry;
1939         uint32 end_idx = start_idx+max_entries-1;
1940
1941         /* The first entry needs to be searched after the last. Otherwise the
1942          * first entry might have moved due to a realloc during the search for
1943          * the last entry. */
1944
1945         end_entry = pdb_search_getentry(search, end_idx);
1946         *result = pdb_search_getentry(search, start_idx);
1947
1948         if (end_entry != NULL)
1949                 return max_entries;
1950
1951         if (start_idx >= search->num_entries)
1952                 return 0;
1953
1954         return search->num_entries - start_idx;
1955 }
1956
1957 void pdb_search_destroy(struct pdb_search *search)
1958 {
1959         if (search == NULL)
1960                 return;
1961
1962         if (!search->search_ended)
1963                 search->search_end(search);
1964
1965         talloc_destroy(search->mem_ctx);
1966 }
1967
1968 NTSTATUS make_pdb_methods(TALLOC_CTX *mem_ctx, PDB_METHODS **methods)
1969 {
1970         *methods = TALLOC_P(mem_ctx, struct pdb_methods);
1971
1972         if (!*methods) {
1973                 return NT_STATUS_NO_MEMORY;
1974         }
1975
1976         ZERO_STRUCTP(*methods);
1977
1978         (*methods)->setsampwent = pdb_default_setsampwent;
1979         (*methods)->endsampwent = pdb_default_endsampwent;
1980         (*methods)->getsampwent = pdb_default_getsampwent;
1981         (*methods)->getsampwnam = pdb_default_getsampwnam;
1982         (*methods)->getsampwsid = pdb_default_getsampwsid;
1983         (*methods)->add_sam_account = pdb_default_add_sam_account;
1984         (*methods)->update_sam_account = pdb_default_update_sam_account;
1985         (*methods)->delete_sam_account = pdb_default_delete_sam_account;
1986         (*methods)->update_login_attempts = pdb_default_update_login_attempts;
1987
1988         (*methods)->getgrsid = pdb_default_getgrsid;
1989         (*methods)->getgrgid = pdb_default_getgrgid;
1990         (*methods)->getgrnam = pdb_default_getgrnam;
1991         (*methods)->add_group_mapping_entry = pdb_default_add_group_mapping_entry;
1992         (*methods)->update_group_mapping_entry = pdb_default_update_group_mapping_entry;
1993         (*methods)->delete_group_mapping_entry = pdb_default_delete_group_mapping_entry;
1994         (*methods)->enum_group_mapping = pdb_default_enum_group_mapping;
1995         (*methods)->enum_group_members = pdb_default_enum_group_members;
1996         (*methods)->enum_group_memberships = pdb_default_enum_group_memberships;
1997         (*methods)->find_alias = pdb_default_find_alias;
1998         (*methods)->create_alias = pdb_default_create_alias;
1999         (*methods)->delete_alias = pdb_default_delete_alias;
2000         (*methods)->get_aliasinfo = pdb_default_get_aliasinfo;
2001         (*methods)->set_aliasinfo = pdb_default_set_aliasinfo;
2002         (*methods)->add_aliasmem = pdb_default_add_aliasmem;
2003         (*methods)->del_aliasmem = pdb_default_del_aliasmem;
2004         (*methods)->enum_aliasmem = pdb_default_enum_aliasmem;
2005         (*methods)->enum_alias_memberships = pdb_default_alias_memberships;
2006         (*methods)->lookup_rids = pdb_default_lookup_rids;
2007         (*methods)->get_account_policy = pdb_default_get_account_policy;
2008         (*methods)->set_account_policy = pdb_default_set_account_policy;
2009         (*methods)->get_seq_num = pdb_default_get_seq_num;
2010
2011         (*methods)->search_users = pdb_default_search_users;
2012         (*methods)->search_groups = pdb_default_search_groups;
2013         (*methods)->search_aliases = pdb_default_search_aliases;
2014
2015         return NT_STATUS_OK;
2016 }