source/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_enum_aliases(struct pdb_context *context,
 553                                      const DOM_SID *sid,
 554                                      uint32 start_idx, uint32 max_entries,
 555                                      uint32 *num_aliases,
 556                                      struct acct_info **info)
 557 {
 558         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 559
 560         if ((!context) || (!context->pdb_methods)) {
 561                 DEBUG(0, ("invalid pdb_context specified!\n"));
 562                 return ret;
 563         }
 564
 565         return context->pdb_methods->enum_aliases(context->pdb_methods,
 566                                                   sid, start_idx, max_entries,
 567                                                   num_aliases, info);
 568 }
 569
 570 static NTSTATUS context_get_aliasinfo(struct pdb_context *context,
 571                                       const DOM_SID *sid,
 572                                       struct acct_info *info)
 573 {
 574         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 575
 576         if ((!context) || (!context->pdb_methods)) {
 577                 DEBUG(0, ("invalid pdb_context specified!\n"));
 578                 return ret;
 579         }
 580
 581         return context->pdb_methods->get_aliasinfo(context->pdb_methods,
 582                                                    sid, info);
 583 }
 584
 585 static NTSTATUS context_set_aliasinfo(struct pdb_context *context,
 586                                       const DOM_SID *sid,
 587                                       struct acct_info *info)
 588 {
 589         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 590
 591         if ((!context) || (!context->pdb_methods)) {
 592                 DEBUG(0, ("invalid pdb_context specified!\n"));
 593                 return ret;
 594         }
 595
 596         return context->pdb_methods->set_aliasinfo(context->pdb_methods,
 597                                                    sid, info);
 598 }
 599
 600 static NTSTATUS context_add_aliasmem(struct pdb_context *context,
 601                                      const DOM_SID *alias,
 602                                      const DOM_SID *member)
 603 {
 604         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 605
 606         if ((!context) || (!context->pdb_methods)) {
 607                 DEBUG(0, ("invalid pdb_context specified!\n"));
 608                 return ret;
 609         }
 610
 611         return context->pdb_methods->add_aliasmem(context->pdb_methods,
 612                                                   alias, member);
 613 }
 614
 615 static NTSTATUS context_del_aliasmem(struct pdb_context *context,
 616                                      const DOM_SID *alias,
 617                                      const DOM_SID *member)
 618 {
 619         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 620
 621         if ((!context) || (!context->pdb_methods)) {
 622                 DEBUG(0, ("invalid pdb_context specified!\n"));
 623                 return ret;
 624         }
 625
 626         return context->pdb_methods->del_aliasmem(context->pdb_methods,
 627                                                   alias, member);
 628 }
 629
 630 static NTSTATUS context_enum_aliasmem(struct pdb_context *context,
 631                                       const DOM_SID *alias, DOM_SID **members,
 632                                       int *num)
 633 {
 634         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 635
 636         if ((!context) || (!context->pdb_methods)) {
 637                 DEBUG(0, ("invalid pdb_context specified!\n"));
 638                 return ret;
 639         }
 640
 641         return context->pdb_methods->enum_aliasmem(context->pdb_methods,
 642                                                    alias, members, num);
 643 }
 644
 645 static NTSTATUS context_enum_alias_memberships(struct pdb_context *context,
 646                                                const DOM_SID *members,
 647                                                int num_members,
 648                                                DOM_SID **aliases, int *num)
 649 {
 650         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 651
 652         if ((!context) || (!context->pdb_methods)) {
 653                 DEBUG(0, ("invalid pdb_context specified!\n"));
 654                 return ret;
 655         }
 656
 657         return context->pdb_methods->
 658                 enum_alias_memberships(context->pdb_methods, members,
 659                                        num_members, aliases, num);
 660 }
 661
 662 static NTSTATUS context_lookup_rids(struct pdb_context *context,
 663                                     TALLOC_CTX *mem_ctx,
 664                                     const DOM_SID *domain_sid,
 665                                     int num_rids,
 666                                     uint32 *rids,
 667                                     const char ***names,
 668                                     uint32 **attrs)
 669 {
 670         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 671
 672         if ((!context) || (!context->pdb_methods)) {
 673                 DEBUG(0, ("invalid pdb_context specified!\n"));
 674                 return ret;
 675         }
 676
 677         return context->pdb_methods->lookup_rids(context->pdb_methods,
 678                                                  mem_ctx, domain_sid, num_rids,
 679                                                  rids, names, attrs);
 680 }
 681
 682 /******************************************************************
 683   Free and cleanup a pdb context, any associated data and anything
 684   that the attached modules might have associated.
 685  *******************************************************************/
 686
 687 static void free_pdb_context(struct pdb_context **context)
 688 {
 689         struct pdb_methods *pdb_selected = (*context)->pdb_methods;
 690
 691         while (pdb_selected){
 692                 if(pdb_selected->free_private_data)
 693                         pdb_selected->free_private_data(&(pdb_selected->private_data));
 694                 pdb_selected = pdb_selected->next;
 695         }
 696
 697         talloc_destroy((*context)->mem_ctx);
 698         *context = NULL;
 699 }
 700
 701 /******************************************************************
 702   Make a pdb_methods from scratch
 703  *******************************************************************/
 704
 705 static NTSTATUS make_pdb_methods_name(struct pdb_methods **methods, struct pdb_context *context, const char *selected)
 706 {
 707         char *module_name = smb_xstrdup(selected);
 708         char *module_location = NULL, *p;
 709         struct pdb_init_function_entry *entry;
 710         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 711
 712         lazy_initialize_passdb();
 713
 714         p = strchr(module_name, ':');
 715
 716         if (p) {
 717                 *p = 0;
 718                 module_location = p+1;
 719                 trim_char(module_location, ' ', ' ');
 720         }
 721
 722         trim_char(module_name, ' ', ' ');
 723
 724
 725         DEBUG(5,("Attempting to find an passdb backend to match %s (%s)\n", selected, module_name));
 726
 727         entry = pdb_find_backend_entry(module_name);
 728
 729         /* Try to find a module that contains this module */
 730         if (!entry) {
 731                 DEBUG(2,("No builtin backend found, trying to load plugin\n"));
 732                 if(NT_STATUS_IS_OK(smb_probe_module("pdb", module_name)) && !(entry = pdb_find_backend_entry(module_name))) {
 733                         DEBUG(0,("Plugin is available, but doesn't register passdb backend %s\n", module_name));
 734                         SAFE_FREE(module_name);
 735                         return NT_STATUS_UNSUCCESSFUL;
 736                 }
 737         }
 738
 739         /* No such backend found */
 740         if(!entry) {
 741                 DEBUG(0,("No builtin nor plugin backend for %s found\n", module_name));
 742                 SAFE_FREE(module_name);
 743                 return NT_STATUS_INVALID_PARAMETER;
 744         }
 745
 746         DEBUG(5,("Found pdb backend %s\n", module_name));
 747         nt_status = entry->init(context, methods, module_location);
 748         if (NT_STATUS_IS_OK(nt_status)) {
 749                 DEBUG(5,("pdb backend %s has a valid init\n", selected));
 750         } else {
 751                 DEBUG(0,("pdb backend %s did not correctly init (error was %s)\n", selected, nt_errstr(nt_status)));
 752         }
 753         SAFE_FREE(module_name);
 754         return nt_status;
 755 }
 756
 757 /******************************************************************
 758   Make a pdb_context from scratch.
 759  *******************************************************************/
 760
 761 static NTSTATUS make_pdb_context(struct pdb_context **context)
 762 {
 763         TALLOC_CTX *mem_ctx;
 764
 765         mem_ctx = talloc_init("pdb_context internal allocation context");
 766
 767         if (!mem_ctx) {
 768                 DEBUG(0, ("make_pdb_context: talloc init failed!\n"));
 769                 return NT_STATUS_NO_MEMORY;
 770         }
 771
 772         *context = TALLOC_P(mem_ctx, struct pdb_context);
 773         if (!*context) {
 774                 DEBUG(0, ("make_pdb_context: talloc failed!\n"));
 775                 return NT_STATUS_NO_MEMORY;
 776         }
 777
 778         ZERO_STRUCTP(*context);
 779
 780         (*context)->mem_ctx = mem_ctx;
 781
 782         (*context)->pdb_setsampwent = context_setsampwent;
 783         (*context)->pdb_endsampwent = context_endsampwent;
 784         (*context)->pdb_getsampwent = context_getsampwent;
 785         (*context)->pdb_getsampwnam = context_getsampwnam;
 786         (*context)->pdb_getsampwsid = context_getsampwsid;
 787         (*context)->pdb_add_sam_account = context_add_sam_account;
 788         (*context)->pdb_update_sam_account = context_update_sam_account;
 789         (*context)->pdb_delete_sam_account = context_delete_sam_account;
 790         (*context)->pdb_update_login_attempts = context_update_login_attempts;
 791         (*context)->pdb_getgrsid = context_getgrsid;
 792         (*context)->pdb_getgrgid = context_getgrgid;
 793         (*context)->pdb_getgrnam = context_getgrnam;
 794         (*context)->pdb_add_group_mapping_entry = context_add_group_mapping_entry;
 795         (*context)->pdb_update_group_mapping_entry = context_update_group_mapping_entry;
 796         (*context)->pdb_delete_group_mapping_entry = context_delete_group_mapping_entry;
 797         (*context)->pdb_enum_group_mapping = context_enum_group_mapping;
 798         (*context)->pdb_enum_group_members = context_enum_group_members;
 799         (*context)->pdb_enum_group_memberships = context_enum_group_memberships;
 800
 801         (*context)->pdb_find_alias = context_find_alias;
 802         (*context)->pdb_create_alias = context_create_alias;
 803         (*context)->pdb_delete_alias = context_delete_alias;
 804         (*context)->pdb_enum_aliases = context_enum_aliases;
 805         (*context)->pdb_get_aliasinfo = context_get_aliasinfo;
 806         (*context)->pdb_set_aliasinfo = context_set_aliasinfo;
 807         (*context)->pdb_add_aliasmem = context_add_aliasmem;
 808         (*context)->pdb_del_aliasmem = context_del_aliasmem;
 809         (*context)->pdb_enum_aliasmem = context_enum_aliasmem;
 810         (*context)->pdb_enum_alias_memberships = context_enum_alias_memberships;
 811         (*context)->pdb_lookup_rids = context_lookup_rids;
 812
 813         (*context)->free_fn = free_pdb_context;
 814
 815         return NT_STATUS_OK;
 816 }
 817
 818
 819 /******************************************************************
 820   Make a pdb_context, given an array of strings
 821  *******************************************************************/
 822
 823 NTSTATUS make_pdb_context_list(struct pdb_context **context, const char **selected)
 824 {
 825         int i = 0;
 826         struct pdb_methods *curmethods, *tmpmethods;
 827         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 828         BOOL have_guest = False;
 829
 830         if (!NT_STATUS_IS_OK(nt_status = make_pdb_context(context))) {
 831                 return nt_status;
 832         }
 833
 834         if (!selected) {
 835                 DEBUG(0, ("ERROR: empty passdb backend list!\n"));
 836                 return nt_status;
 837         }
 838
 839         while (selected[i]){
 840                 if (strcmp(selected[i], "guest") == 0) {
 841                         have_guest = True;
 842                 }
 843                 /* Try to initialise pdb */
 844                 DEBUG(5,("Trying to load: %s\n", selected[i]));
 845                 if (!NT_STATUS_IS_OK(nt_status = make_pdb_methods_name(&curmethods, *context, selected[i]))) {
 846                         DEBUG(1, ("Loading %s failed!\n", selected[i]));
 847                         free_pdb_context(context);
 848                         return nt_status;
 849                 }
 850                 curmethods->parent = *context;
 851                 DLIST_ADD_END((*context)->pdb_methods, curmethods, tmpmethods);
 852                 i++;
 853         }
 854
 855         if (have_guest)
 856                 return NT_STATUS_OK;
 857
 858         if ( (lp_guestaccount() == NULL) ||
 859              (*lp_guestaccount() == '\0') ) {
 860                 /* We explicitly don't want guest access. No idea what
 861                    else that breaks, but be it that way. */
 862                 return NT_STATUS_OK;
 863         }
 864
 865         if (!NT_STATUS_IS_OK(nt_status = make_pdb_methods_name(&curmethods,
 866                                                                *context,
 867                                                                "guest"))) {
 868                 DEBUG(1, ("Loading guest module failed!\n"));
 869                 free_pdb_context(context);
 870                 return nt_status;
 871         }
 872
 873         curmethods->parent = *context;
 874         DLIST_ADD_END((*context)->pdb_methods, curmethods, tmpmethods);
 875
 876         return NT_STATUS_OK;
 877 }
 878
 879 /******************************************************************
 880   Make a pdb_context, given a text string.
 881  *******************************************************************/
 882
 883 NTSTATUS make_pdb_context_string(struct pdb_context **context, const char *selected)
 884 {
 885         NTSTATUS ret;
 886         char **newsel = str_list_make(selected, NULL);
 887         ret = make_pdb_context_list(context, (const char **)newsel);
 888         str_list_free(&newsel);
 889         return ret;
 890 }
 891
 892 /******************************************************************
 893  Return an already initialised pdb_context, to facilitate backward
 894  compatibility (see functions below).
 895 *******************************************************************/
 896
 897 static struct pdb_context *pdb_get_static_context(BOOL reload)
 898 {
 899         static struct pdb_context *pdb_context = NULL;
 900
 901         if ((pdb_context) && (reload)) {
 902                 pdb_context->free_fn(&pdb_context);
 903                 if (!NT_STATUS_IS_OK(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
 904                         return NULL;
 905                 }
 906         }
 907
 908         if (!pdb_context) {
 909                 if (!NT_STATUS_IS_OK(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
 910                         return NULL;
 911                 }
 912         }
 913
 914         return pdb_context;
 915 }
 916
 917 /******************************************************************
 918  Backward compatibility functions for the original passdb interface
 919 *******************************************************************/
 920
 921 BOOL pdb_setsampwent(BOOL update, uint16 acb_mask)
 922 {
 923         struct pdb_context *pdb_context = pdb_get_static_context(False);
 924
 925         if (!pdb_context) {
 926                 return False;
 927         }
 928
 929         return NT_STATUS_IS_OK(pdb_context->pdb_setsampwent(pdb_context, update, acb_mask));
 930 }
 931
 932 void pdb_endsampwent(void)
 933 {
 934         struct pdb_context *pdb_context = pdb_get_static_context(False);
 935
 936         if (!pdb_context) {
 937                 return;
 938         }
 939
 940         pdb_context->pdb_endsampwent(pdb_context);
 941 }
 942
 943 BOOL pdb_getsampwent(SAM_ACCOUNT *user)
 944 {
 945         struct pdb_context *pdb_context = pdb_get_static_context(False);
 946
 947         if (!pdb_context) {
 948                 return False;
 949         }
 950
 951         return NT_STATUS_IS_OK(pdb_context->pdb_getsampwent(pdb_context, user));
 952 }
 953
 954 static SAM_ACCOUNT *sam_account_cache = NULL;
 955
 956 BOOL pdb_getsampwnam(SAM_ACCOUNT *sam_acct, const char *username)
 957 {
 958         struct pdb_context *pdb_context = pdb_get_static_context(False);
 959
 960         if (!pdb_context) {
 961                 return False;
 962         }
 963
 964         if (!NT_STATUS_IS_OK(pdb_context->pdb_getsampwnam(pdb_context,
 965                                                           sam_acct, username)))
 966                 return False;
 967
 968         if (sam_account_cache != NULL) {
 969                 pdb_free_sam(&sam_account_cache);
 970                 sam_account_cache = NULL;
 971         }
 972
 973         pdb_copy_sam_account(sam_acct, &sam_account_cache);
 974         return True;
 975 }
 976
 977 BOOL pdb_getsampwsid(SAM_ACCOUNT *sam_acct, const DOM_SID *sid)
 978 {
 979         struct pdb_context *pdb_context = pdb_get_static_context(False);
 980
 981         if (!pdb_context) {
 982                 return False;
 983         }
 984
 985         if ((sam_account_cache != NULL) &&
 986             (sid_equal(sid, pdb_get_user_sid(sam_account_cache))))
 987                 return pdb_copy_sam_account(sam_account_cache, &sam_acct);
 988
 989         return NT_STATUS_IS_OK(pdb_context->pdb_getsampwsid(pdb_context, sam_acct, sid));
 990 }
 991
 992 BOOL pdb_add_sam_account(SAM_ACCOUNT *sam_acct)
 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_add_sam_account(pdb_context, sam_acct));
1001 }
1002
1003 BOOL pdb_update_sam_account(SAM_ACCOUNT *sam_acct)
1004 {
1005         struct pdb_context *pdb_context = pdb_get_static_context(False);
1006
1007         if (!pdb_context) {
1008                 return False;
1009         }
1010
1011         if (sam_account_cache != NULL) {
1012                 pdb_free_sam(&sam_account_cache);
1013                 sam_account_cache = NULL;
1014         }
1015
1016         return NT_STATUS_IS_OK(pdb_context->pdb_update_sam_account(pdb_context, sam_acct));
1017 }
1018
1019 BOOL pdb_delete_sam_account(SAM_ACCOUNT *sam_acct)
1020 {
1021         struct pdb_context *pdb_context = pdb_get_static_context(False);
1022
1023         if (!pdb_context) {
1024                 return False;
1025         }
1026
1027         if (sam_account_cache != NULL) {
1028                 pdb_free_sam(&sam_account_cache);
1029                 sam_account_cache = NULL;
1030         }
1031
1032         return NT_STATUS_IS_OK(pdb_context->pdb_delete_sam_account(pdb_context, sam_acct));
1033 }
1034
1035 NTSTATUS pdb_update_login_attempts(SAM_ACCOUNT *sam_acct, BOOL success)
1036 {
1037         struct pdb_context *pdb_context = pdb_get_static_context(False);
1038
1039         if (!pdb_context) {
1040                 return NT_STATUS_NOT_IMPLEMENTED;
1041         }
1042
1043         return pdb_context->pdb_update_login_attempts(pdb_context, sam_acct, success);
1044 }
1045
1046 BOOL pdb_getgrsid(GROUP_MAP *map, DOM_SID sid)
1047 {
1048         struct pdb_context *pdb_context = pdb_get_static_context(False);
1049
1050         if (!pdb_context) {
1051                 return False;
1052         }
1053
1054         return NT_STATUS_IS_OK(pdb_context->
1055                                pdb_getgrsid(pdb_context, map, sid));
1056 }
1057
1058 BOOL pdb_getgrgid(GROUP_MAP *map, gid_t gid)
1059 {
1060         struct pdb_context *pdb_context = pdb_get_static_context(False);
1061
1062         if (!pdb_context) {
1063                 return False;
1064         }
1065
1066         return NT_STATUS_IS_OK(pdb_context->
1067                                pdb_getgrgid(pdb_context, map, gid));
1068 }
1069
1070 BOOL pdb_getgrnam(GROUP_MAP *map, const char *name)
1071 {
1072         struct pdb_context *pdb_context = pdb_get_static_context(False);
1073
1074         if (!pdb_context) {
1075                 return False;
1076         }
1077
1078         return NT_STATUS_IS_OK(pdb_context->
1079                                pdb_getgrnam(pdb_context, map, name));
1080 }
1081
1082 BOOL pdb_add_group_mapping_entry(GROUP_MAP *map)
1083 {
1084         struct pdb_context *pdb_context = pdb_get_static_context(False);
1085
1086         if (!pdb_context) {
1087                 return False;
1088         }
1089
1090         return NT_STATUS_IS_OK(pdb_context->
1091                                pdb_add_group_mapping_entry(pdb_context, map));
1092 }
1093
1094 BOOL pdb_update_group_mapping_entry(GROUP_MAP *map)
1095 {
1096         struct pdb_context *pdb_context = pdb_get_static_context(False);
1097
1098         if (!pdb_context) {
1099                 return False;
1100         }
1101
1102         return NT_STATUS_IS_OK(pdb_context->
1103                                pdb_update_group_mapping_entry(pdb_context, map));
1104 }
1105
1106 BOOL pdb_delete_group_mapping_entry(DOM_SID sid)
1107 {
1108         struct pdb_context *pdb_context = pdb_get_static_context(False);
1109
1110         if (!pdb_context) {
1111                 return False;
1112         }
1113
1114         return NT_STATUS_IS_OK(pdb_context->
1115                                pdb_delete_group_mapping_entry(pdb_context, sid));
1116 }
1117
1118 BOOL pdb_enum_group_mapping(enum SID_NAME_USE sid_name_use, GROUP_MAP **rmap,
1119                             int *num_entries, BOOL unix_only)
1120 {
1121         struct pdb_context *pdb_context = pdb_get_static_context(False);
1122
1123         if (!pdb_context) {
1124                 return False;
1125         }
1126
1127         return NT_STATUS_IS_OK(pdb_context->
1128                                pdb_enum_group_mapping(pdb_context, sid_name_use,
1129                                                       rmap, num_entries, unix_only));
1130 }
1131
1132 NTSTATUS pdb_enum_group_members(TALLOC_CTX *mem_ctx,
1133                                 const DOM_SID *sid,
1134                                 uint32 **member_rids,
1135                                 int *num_members)
1136 {
1137         struct pdb_context *pdb_context = pdb_get_static_context(False);
1138
1139         if (!pdb_context) {
1140                 return NT_STATUS_UNSUCCESSFUL;
1141         }
1142
1143         return pdb_context->pdb_enum_group_members(pdb_context, mem_ctx, sid,
1144                                                    member_rids, num_members);
1145 }
1146
1147 NTSTATUS pdb_enum_group_memberships(const char *username, gid_t primary_gid,
1148                                     DOM_SID **sids, gid_t **gids,
1149                                     int *num_groups)
1150 {
1151         struct pdb_context *pdb_context = pdb_get_static_context(False);
1152
1153         if (!pdb_context) {
1154                 return NT_STATUS_UNSUCCESSFUL;
1155         }
1156
1157         return pdb_context->pdb_enum_group_memberships(pdb_context, username,
1158                                                        primary_gid, sids, gids,
1159                                                        num_groups);
1160 }
1161
1162 BOOL pdb_find_alias(const char *name, DOM_SID *sid)
1163 {
1164         struct pdb_context *pdb_context = pdb_get_static_context(False);
1165
1166         if (!pdb_context) {
1167                 return False;
1168         }
1169
1170         return NT_STATUS_IS_OK(pdb_context->pdb_find_alias(pdb_context,
1171                                                              name, sid));
1172 }
1173
1174 NTSTATUS pdb_create_alias(const char *name, uint32 *rid)
1175 {
1176         struct pdb_context *pdb_context = pdb_get_static_context(False);
1177
1178         if (!pdb_context) {
1179                 return NT_STATUS_NOT_IMPLEMENTED;
1180         }
1181
1182         return pdb_context->pdb_create_alias(pdb_context, name, rid);
1183 }
1184
1185 BOOL pdb_delete_alias(const DOM_SID *sid)
1186 {
1187         struct pdb_context *pdb_context = pdb_get_static_context(False);
1188
1189         if (!pdb_context) {
1190                 return False;
1191         }
1192
1193         return NT_STATUS_IS_OK(pdb_context->pdb_delete_alias(pdb_context,
1194                                                              sid));
1195
1196 }
1197
1198 BOOL pdb_enum_aliases(const DOM_SID *sid, uint32 start_idx, uint32 max_entries,
1199                       uint32 *num_aliases, struct acct_info **info)
1200 {
1201         struct pdb_context *pdb_context = pdb_get_static_context(False);
1202
1203         if (!pdb_context) {
1204                 return False;
1205         }
1206
1207         return NT_STATUS_IS_OK(pdb_context->pdb_enum_aliases(pdb_context, sid,
1208                                                              start_idx,
1209                                                              max_entries,
1210                                                              num_aliases,
1211                                                              info));
1212 }
1213
1214 BOOL pdb_get_aliasinfo(const DOM_SID *sid, struct acct_info *info)
1215 {
1216         struct pdb_context *pdb_context = pdb_get_static_context(False);
1217
1218         if (!pdb_context) {
1219                 return False;
1220         }
1221
1222         return NT_STATUS_IS_OK(pdb_context->pdb_get_aliasinfo(pdb_context, sid,
1223                                                               info));
1224 }
1225
1226 BOOL pdb_set_aliasinfo(const DOM_SID *sid, struct acct_info *info)
1227 {
1228         struct pdb_context *pdb_context = pdb_get_static_context(False);
1229
1230         if (!pdb_context) {
1231                 return False;
1232         }
1233
1234         return NT_STATUS_IS_OK(pdb_context->pdb_set_aliasinfo(pdb_context, sid,
1235                                                               info));
1236 }
1237
1238 BOOL pdb_add_aliasmem(const DOM_SID *alias, const DOM_SID *member)
1239 {
1240         struct pdb_context *pdb_context = pdb_get_static_context(False);
1241
1242         if (!pdb_context) {
1243                 return False;
1244         }
1245
1246         return NT_STATUS_IS_OK(pdb_context->
1247                                pdb_add_aliasmem(pdb_context, alias, member));
1248 }
1249
1250 BOOL pdb_del_aliasmem(const DOM_SID *alias, const DOM_SID *member)
1251 {
1252         struct pdb_context *pdb_context = pdb_get_static_context(False);
1253
1254         if (!pdb_context) {
1255                 return False;
1256         }
1257
1258         return NT_STATUS_IS_OK(pdb_context->
1259                                pdb_del_aliasmem(pdb_context, alias, member));
1260 }
1261
1262 BOOL pdb_enum_aliasmem(const DOM_SID *alias,
1263                        DOM_SID **members, int *num_members)
1264 {
1265         struct pdb_context *pdb_context = pdb_get_static_context(False);
1266
1267         if (!pdb_context) {
1268                 return False;
1269         }
1270
1271         return NT_STATUS_IS_OK(pdb_context->
1272                                pdb_enum_aliasmem(pdb_context, alias,
1273                                                  members, num_members));
1274 }
1275
1276 BOOL pdb_enum_alias_memberships(const DOM_SID *members, int num_members,
1277                                 DOM_SID **aliases, int *num)
1278 {
1279         struct pdb_context *pdb_context = pdb_get_static_context(False);
1280
1281         if (!pdb_context) {
1282                 return False;
1283         }
1284
1285         return NT_STATUS_IS_OK(pdb_context->
1286                                pdb_enum_alias_memberships(pdb_context, members,
1287                                                           num_members,
1288                                                           aliases, num));
1289 }
1290
1291 NTSTATUS pdb_lookup_rids(TALLOC_CTX *mem_ctx,
1292                          const DOM_SID *domain_sid,
1293                          int num_rids,
1294                          uint32 *rids,
1295                          const char ***names,
1296                          uint32 **attrs)
1297 {
1298         struct pdb_context *pdb_context = pdb_get_static_context(False);
1299
1300         if (!pdb_context) {
1301                 return NT_STATUS_NOT_IMPLEMENTED;
1302         }
1303
1304         return pdb_context->pdb_lookup_rids(pdb_context, mem_ctx, domain_sid,
1305                                             num_rids, rids, names, attrs);
1306 }
1307
1308 /***************************************************************
1309   Initialize the static context (at smbd startup etc).
1310
1311   If uninitialised, context will auto-init on first use.
1312  ***************************************************************/
1313
1314 BOOL initialize_password_db(BOOL reload)
1315 {
1316         return (pdb_get_static_context(reload) != NULL);
1317 }
1318
1319
1320 /***************************************************************************
1321   Default implementations of some functions.
1322  ****************************************************************************/
1323
1324 static NTSTATUS pdb_default_getsampwnam (struct pdb_methods *methods, SAM_ACCOUNT *user, const char *sname)
1325 {
1326         return NT_STATUS_NO_SUCH_USER;
1327 }
1328
1329 static NTSTATUS pdb_default_getsampwsid(struct pdb_methods *my_methods, SAM_ACCOUNT * user, const DOM_SID *sid)
1330 {
1331         return NT_STATUS_NO_SUCH_USER;
1332 }
1333
1334 static NTSTATUS pdb_default_add_sam_account (struct pdb_methods *methods, SAM_ACCOUNT *newpwd)
1335 {
1336         DEBUG(0,("this backend (%s) should not be listed as the first passdb backend! You can't add users to it.\n", methods->name));
1337         return NT_STATUS_NOT_IMPLEMENTED;
1338 }
1339
1340 static NTSTATUS pdb_default_update_sam_account (struct pdb_methods *methods, SAM_ACCOUNT *newpwd)
1341 {
1342         return NT_STATUS_NOT_IMPLEMENTED;
1343 }
1344
1345 static NTSTATUS pdb_default_delete_sam_account (struct pdb_methods *methods, SAM_ACCOUNT *pwd)
1346 {
1347         return NT_STATUS_NOT_IMPLEMENTED;
1348 }
1349
1350 static NTSTATUS pdb_default_update_login_attempts (struct pdb_methods *methods, SAM_ACCOUNT *newpwd, BOOL success)
1351 {
1352         return NT_STATUS_OK;
1353 }
1354
1355 static NTSTATUS pdb_default_setsampwent(struct pdb_methods *methods, BOOL update, uint16 acb_mask)
1356 {
1357         return NT_STATUS_NOT_IMPLEMENTED;
1358 }
1359
1360 static NTSTATUS pdb_default_getsampwent(struct pdb_methods *methods, SAM_ACCOUNT *user)
1361 {
1362         return NT_STATUS_NOT_IMPLEMENTED;
1363 }
1364
1365 static void pdb_default_endsampwent(struct pdb_methods *methods)
1366 {
1367         return; /* NT_STATUS_NOT_IMPLEMENTED; */
1368 }
1369
1370 static void add_uid_to_array_unique(TALLOC_CTX *mem_ctx,
1371                                     uid_t uid, uid_t **uids, int *num)
1372 {
1373         int i;
1374
1375         for (i=0; i<*num; i++) {
1376                 if ((*uids)[i] == uid)
1377                         return;
1378         }
1379
1380         *uids = TALLOC_REALLOC_ARRAY(mem_ctx, *uids, uid_t, *num+1);
1381
1382         if (*uids == NULL)
1383                 return;
1384
1385         (*uids)[*num] = uid;
1386         *num += 1;
1387 }
1388
1389 static BOOL get_memberuids(TALLOC_CTX *mem_ctx, gid_t gid, uid_t **uids,
1390                            int *num)
1391 {
1392         struct group *grp;
1393         char **gr;
1394         struct sys_pwent *userlist, *user;
1395
1396         *uids = NULL;
1397         *num = 0;
1398
1399         /* We only look at our own sam, so don't care about imported stuff */
1400
1401         winbind_off();
1402
1403         if ((grp = getgrgid(gid)) == NULL) {
1404                 winbind_on();
1405                 return False;
1406         }
1407
1408         /* Primary group members */
1409
1410         userlist = getpwent_list();
1411
1412         for (user = userlist; user != NULL; user = user->next) {
1413                 if (user->pw_gid != gid)
1414                         continue;
1415                 add_uid_to_array_unique(mem_ctx, user->pw_uid, uids, num);
1416         }
1417
1418         pwent_free(userlist);
1419
1420         /* Secondary group members */
1421
1422         for (gr = grp->gr_mem; (*gr != NULL) && ((*gr)[0] != '\0'); gr += 1) {
1423                 struct passwd *pw = getpwnam(*gr);
1424
1425                 if (pw == NULL)
1426                         continue;
1427                 add_uid_to_array_unique(mem_ctx, pw->pw_uid, uids, num);
1428         }
1429
1430         winbind_on();
1431
1432         return True;
1433 }
1434
1435 NTSTATUS pdb_default_enum_group_members(struct pdb_methods *methods,
1436                                         TALLOC_CTX *mem_ctx,
1437                                         const DOM_SID *group,
1438                                         uint32 **member_rids,
1439                                         int *num_members)
1440 {
1441         gid_t gid;
1442         uid_t *uids;
1443         int i, num_uids;
1444
1445         *member_rids = NULL;
1446         *num_members = 0;
1447
1448         if (!NT_STATUS_IS_OK(sid_to_gid(group, &gid)))
1449                 return NT_STATUS_NO_SUCH_GROUP;
1450
1451         if(!get_memberuids(mem_ctx, gid, &uids, &num_uids))
1452                 return NT_STATUS_NO_SUCH_GROUP;
1453
1454         if (num_uids == 0)
1455                 return NT_STATUS_OK;
1456
1457         *member_rids = TALLOC_ZERO_ARRAY(mem_ctx, uint32, num_uids);
1458
1459         for (i=0; i<num_uids; i++) {
1460                 DOM_SID sid;
1461
1462                 if (!NT_STATUS_IS_OK(uid_to_sid(&sid, uids[i]))) {
1463                         DEBUG(1, ("Could not map member uid to SID\n"));
1464                         continue;
1465                 }
1466
1467                 if (!sid_check_is_in_our_domain(&sid)) {
1468                         DEBUG(1, ("Inconsistent SAM -- group member uid not "
1469                                   "in our domain\n"));
1470                         continue;
1471                 }
1472
1473                 sid_peek_rid(&sid, &(*member_rids)[*num_members]);
1474                 *num_members += 1;
1475         }
1476
1477         return NT_STATUS_OK;
1478 }
1479
1480 NTSTATUS pdb_default_lookup_rids(struct pdb_methods *methods,
1481                                  TALLOC_CTX *mem_ctx,
1482                                  const DOM_SID *domain_sid,
1483                                  int num_rids,
1484                                  uint32 *rids,
1485                                  const char ***names,
1486                                  uint32 **attrs)
1487 {
1488         int i;
1489         NTSTATUS result;
1490         BOOL have_mapped = False;
1491         BOOL have_unmapped = False;
1492
1493         (*names) = TALLOC_ZERO_ARRAY(mem_ctx, const char *, num_rids);
1494         (*attrs) = TALLOC_ZERO_ARRAY(mem_ctx, uint32, num_rids);
1495
1496         if ((num_rids != 0) && (((*names) == NULL) || ((*attrs) == NULL)))
1497                 return NT_STATUS_NO_MEMORY;
1498
1499         if (!sid_equal(domain_sid, get_global_sam_sid())) {
1500                 /* TODO: Sooner or later we need to look up BUILTIN rids as
1501                  * well. -- vl */
1502                 goto done;
1503         }
1504
1505         for (i = 0; i < num_rids; i++) {
1506                 fstring tmpname;
1507                 fstring domname;
1508                 DOM_SID sid;
1509                 enum SID_NAME_USE type;
1510
1511                 (*attrs)[i] = SID_NAME_UNKNOWN;
1512
1513                 sid_copy(&sid, domain_sid);
1514                 sid_append_rid(&sid, rids[i]);
1515
1516                 if (lookup_sid(&sid, domname, tmpname, &type)) {
1517                         (*attrs)[i] = (uint32)type;
1518                         (*names)[i] = talloc_strdup(mem_ctx, tmpname);
1519                         if ((*names)[i] == NULL)
1520                                 return NT_STATUS_NO_MEMORY;
1521                         DEBUG(5,("lookup_rids: %s:%d\n", (*names)[i],
1522                                  (*attrs)[i]));
1523                         have_mapped = True;
1524                 } else {
1525                         have_unmapped = True;
1526                 }
1527         }
1528
1529  done:
1530
1531         result = NT_STATUS_NONE_MAPPED;
1532
1533         if (have_mapped)
1534                 result = have_unmapped ? STATUS_SOME_UNMAPPED : NT_STATUS_OK;
1535
1536         return result;
1537 }
1538
1539 NTSTATUS make_pdb_methods(TALLOC_CTX *mem_ctx, PDB_METHODS **methods)
1540 {
1541         *methods = TALLOC_P(mem_ctx, struct pdb_methods);
1542
1543         if (!*methods) {
1544                 return NT_STATUS_NO_MEMORY;
1545         }
1546
1547         ZERO_STRUCTP(*methods);
1548
1549         (*methods)->setsampwent = pdb_default_setsampwent;
1550         (*methods)->endsampwent = pdb_default_endsampwent;
1551         (*methods)->getsampwent = pdb_default_getsampwent;
1552         (*methods)->getsampwnam = pdb_default_getsampwnam;
1553         (*methods)->getsampwsid = pdb_default_getsampwsid;
1554         (*methods)->add_sam_account = pdb_default_add_sam_account;
1555         (*methods)->update_sam_account = pdb_default_update_sam_account;
1556         (*methods)->delete_sam_account = pdb_default_delete_sam_account;
1557         (*methods)->update_login_attempts = pdb_default_update_login_attempts;
1558
1559         (*methods)->getgrsid = pdb_default_getgrsid;
1560         (*methods)->getgrgid = pdb_default_getgrgid;
1561         (*methods)->getgrnam = pdb_default_getgrnam;
1562         (*methods)->add_group_mapping_entry = pdb_default_add_group_mapping_entry;
1563         (*methods)->update_group_mapping_entry = pdb_default_update_group_mapping_entry;
1564         (*methods)->delete_group_mapping_entry = pdb_default_delete_group_mapping_entry;
1565         (*methods)->enum_group_mapping = pdb_default_enum_group_mapping;
1566         (*methods)->enum_group_members = pdb_default_enum_group_members;
1567         (*methods)->enum_group_memberships = pdb_default_enum_group_memberships;
1568         (*methods)->find_alias = pdb_default_find_alias;
1569         (*methods)->create_alias = pdb_default_create_alias;
1570         (*methods)->delete_alias = pdb_default_delete_alias;
1571         (*methods)->enum_aliases = pdb_default_enum_aliases;
1572         (*methods)->get_aliasinfo = pdb_default_get_aliasinfo;
1573         (*methods)->set_aliasinfo = pdb_default_set_aliasinfo;
1574         (*methods)->add_aliasmem = pdb_default_add_aliasmem;
1575         (*methods)->del_aliasmem = pdb_default_del_aliasmem;
1576         (*methods)->enum_aliasmem = pdb_default_enum_aliasmem;
1577         (*methods)->enum_alias_memberships = pdb_default_alias_memberships;
1578         (*methods)->lookup_rids = pdb_default_lookup_rids;
1579
1580         return NT_STATUS_OK;
1581 }