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
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20 */
  21
  22 #include "includes.h"
  23
  24 #undef DBGC_CLASS
  25 #define DBGC_CLASS DBGC_PASSDB
  26
  27 static struct pdb_init_function_entry *backends = NULL;
  28
  29 static void lazy_initialize_passdb(void)
  30 {
  31         static BOOL initialized = False;
  32         if(initialized)return;
  33         static_init_pdb;
  34         initialized = True;
  35 }
  36
  37 static struct pdb_init_function_entry *pdb_find_backend_entry(const char *name);
  38
  39 /*******************************************************************
  40  Clean up uninitialised passwords.  The only way to tell
  41  that these values are not 'real' is that they do not
  42  have a valid last set time.  Instead, the value is fixed at 0.
  43  Therefore we use that as the key for 'is this a valid password'.
  44  However, it is perfectly valid to have a 'default' last change
  45  time, such LDAP with a missing attribute would produce.
  46 ********************************************************************/
  47
  48 static void pdb_force_pw_initialization(SAM_ACCOUNT *pass)
  49 {
  50         const char *lm_pwd, *nt_pwd;
  51
  52         /* only reset a password if the last set time has been
  53            explicitly been set to zero.  A default last set time
  54            is ignored */
  55
  56         if ( (pdb_get_init_flags(pass, PDB_PASSLASTSET) != PDB_DEFAULT)
  57                 && (pdb_get_pass_last_set_time(pass) == 0) )
  58         {
  59
  60                 if (pdb_get_init_flags(pass, PDB_LMPASSWD) != PDB_DEFAULT)
  61                 {
  62                         lm_pwd = pdb_get_lanman_passwd(pass);
  63                         if (lm_pwd)
  64                                 pdb_set_lanman_passwd(pass, NULL, PDB_CHANGED);
  65                 }
  66                 if (pdb_get_init_flags(pass, PDB_NTPASSWD) != PDB_DEFAULT)
  67                 {
  68                         nt_pwd = pdb_get_nt_passwd(pass);
  69                         if (nt_pwd)
  70                                 pdb_set_nt_passwd(pass, NULL, PDB_CHANGED);
  71                 }
  72         }
  73
  74         return;
  75 }
  76
  77 NTSTATUS smb_register_passdb(int version, const char *name, pdb_init_function init)
  78 {
  79         struct pdb_init_function_entry *entry = backends;
  80
  81         if(version != PASSDB_INTERFACE_VERSION) {
  82                 DEBUG(0,("Can't register passdb backend!\n"
  83                          "You tried to register a passdb module with PASSDB_INTERFACE_VERSION %d, "
  84                          "while this version of samba uses version %d\n",
  85                          version,PASSDB_INTERFACE_VERSION));
  86                 return NT_STATUS_OBJECT_TYPE_MISMATCH;
  87         }
  88
  89         if (!name || !init) {
  90                 return NT_STATUS_INVALID_PARAMETER;
  91         }
  92
  93         DEBUG(5,("Attempting to register passdb backend %s\n", name));
  94
  95         /* Check for duplicates */
  96         if (pdb_find_backend_entry(name)) {
  97                 DEBUG(0,("There already is a passdb backend registered with the name %s!\n", name));
  98                 return NT_STATUS_OBJECT_NAME_COLLISION;
  99         }
 100
 101         entry = smb_xmalloc(sizeof(struct pdb_init_function_entry));
 102         entry->name = smb_xstrdup(name);
 103         entry->init = init;
 104
 105         DLIST_ADD(backends, entry);
 106         DEBUG(5,("Successfully added passdb backend '%s'\n", name));
 107         return NT_STATUS_OK;
 108 }
 109
 110 static struct pdb_init_function_entry *pdb_find_backend_entry(const char *name)
 111 {
 112         struct pdb_init_function_entry *entry = backends;
 113
 114         while(entry) {
 115                 if (strcmp(entry->name, name)==0) return entry;
 116                 entry = entry->next;
 117         }
 118
 119         return NULL;
 120 }
 121
 122 static NTSTATUS context_setsampwent(struct pdb_context *context, BOOL update)
 123 {
 124         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 125
 126         if (!context) {
 127                 DEBUG(0, ("invalid pdb_context specified!\n"));
 128                 return ret;
 129         }
 130
 131         context->pwent_methods = context->pdb_methods;
 132
 133         if (!context->pwent_methods) {
 134                 /* No passdbs at all */
 135                 return ret;
 136         }
 137
 138         while (NT_STATUS_IS_ERR(ret = context->pwent_methods->setsampwent(context->pwent_methods, update))) {
 139                 context->pwent_methods = context->pwent_methods->next;
 140                 if (context->pwent_methods == NULL)
 141                         return NT_STATUS_UNSUCCESSFUL;
 142         }
 143         return ret;
 144 }
 145
 146 static void context_endsampwent(struct pdb_context *context)
 147 {
 148         if ((!context)){
 149                 DEBUG(0, ("invalid pdb_context specified!\n"));
 150                 return;
 151         }
 152
 153         if (context->pwent_methods && context->pwent_methods->endsampwent)
 154                 context->pwent_methods->endsampwent(context->pwent_methods);
 155
 156         /* So we won't get strange data when calling getsampwent now */
 157         context->pwent_methods = NULL;
 158 }
 159
 160 static NTSTATUS context_getsampwent(struct pdb_context *context, SAM_ACCOUNT *user)
 161 {
 162         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 163
 164         if ((!context) || (!context->pwent_methods)) {
 165                 DEBUG(0, ("invalid pdb_context specified!\n"));
 166                 return ret;
 167         }
 168         /* Loop until we find something useful */
 169         while (NT_STATUS_IS_ERR(ret = context->pwent_methods->getsampwent(context->pwent_methods, user))) {
 170
 171                 context->pwent_methods->endsampwent(context->pwent_methods);
 172
 173                 context->pwent_methods = context->pwent_methods->next;
 174
 175                 /* All methods are checked now. There are no more entries */
 176                 if (context->pwent_methods == NULL)
 177                         return ret;
 178
 179                 context->pwent_methods->setsampwent(context->pwent_methods, False);
 180         }
 181         user->methods = context->pwent_methods;
 182         pdb_force_pw_initialization(user);
 183         return ret;
 184 }
 185
 186 static NTSTATUS context_getsampwnam(struct pdb_context *context, SAM_ACCOUNT *sam_acct, const char *username)
 187 {
 188         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 189
 190         struct pdb_methods *curmethods;
 191         if ((!context)) {
 192                 DEBUG(0, ("invalid pdb_context specified!\n"));
 193                 return ret;
 194         }
 195         curmethods = context->pdb_methods;
 196         while (curmethods){
 197                 if (NT_STATUS_IS_OK(ret = curmethods->getsampwnam(curmethods, sam_acct, username))) {
 198                         pdb_force_pw_initialization(sam_acct);
 199                         sam_acct->methods = curmethods;
 200                         return ret;
 201                 }
 202                 curmethods = curmethods->next;
 203         }
 204
 205         return ret;
 206 }
 207
 208 static NTSTATUS context_getsampwsid(struct pdb_context *context, SAM_ACCOUNT *sam_acct, const DOM_SID *sid)
 209 {
 210         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 211
 212         struct pdb_methods *curmethods;
 213         if ((!context)) {
 214                 DEBUG(0, ("invalid pdb_context specified!\n"));
 215                 return ret;
 216         }
 217
 218         curmethods = context->pdb_methods;
 219
 220         while (curmethods){
 221                 if (NT_STATUS_IS_OK(ret = curmethods->getsampwsid(curmethods, sam_acct, sid))) {
 222                         pdb_force_pw_initialization(sam_acct);
 223                         sam_acct->methods = curmethods;
 224                         return ret;
 225                 }
 226                 curmethods = curmethods->next;
 227         }
 228
 229         return ret;
 230 }
 231
 232 static NTSTATUS context_add_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
 233 {
 234         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 235         const char *lm_pw, *nt_pw;
 236         uint16 acb_flags;
 237
 238         if ((!context) || (!context->pdb_methods)) {
 239                 DEBUG(0, ("invalid pdb_context specified!\n"));
 240                 return ret;
 241         }
 242
 243         /* disable acccounts with no passwords (that has not
 244            been allowed by the  ACB_PWNOTREQ bit */
 245
 246         lm_pw = pdb_get_lanman_passwd( sam_acct );
 247         nt_pw = pdb_get_nt_passwd( sam_acct );
 248         acb_flags = pdb_get_acct_ctrl( sam_acct );
 249         if ( !lm_pw && !nt_pw && !(acb_flags&ACB_PWNOTREQ) ) {
 250                 acb_flags |= ACB_DISABLED;
 251                 pdb_set_acct_ctrl( sam_acct, acb_flags, PDB_CHANGED );
 252         }
 253
 254         /** @todo  This is where a 're-read on add' should be done */
 255         /* We now add a new account to the first database listed.
 256          * Should we? */
 257
 258         return context->pdb_methods->add_sam_account(context->pdb_methods, sam_acct);
 259 }
 260
 261 static NTSTATUS context_update_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
 262 {
 263         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 264         const char *lm_pw, *nt_pw;
 265         uint16 acb_flags;
 266
 267         if (!context) {
 268                 DEBUG(0, ("invalid pdb_context specified!\n"));
 269                 return ret;
 270         }
 271
 272         if (!sam_acct || !sam_acct->methods){
 273                 DEBUG(0, ("invalid sam_acct specified\n"));
 274                 return ret;
 275         }
 276
 277         /* disable acccounts with no passwords (that has not
 278            been allowed by the  ACB_PWNOTREQ bit */
 279
 280         lm_pw = pdb_get_lanman_passwd( sam_acct );
 281         nt_pw = pdb_get_nt_passwd( sam_acct );
 282         acb_flags = pdb_get_acct_ctrl( sam_acct );
 283         if ( !lm_pw && !nt_pw && !(acb_flags&ACB_PWNOTREQ) ) {
 284                 acb_flags |= ACB_DISABLED;
 285                 pdb_set_acct_ctrl( sam_acct, acb_flags, PDB_CHANGED );
 286         }
 287
 288         /** @todo  This is where a 're-read on update' should be done */
 289
 290         return sam_acct->methods->update_sam_account(sam_acct->methods, sam_acct);
 291 }
 292
 293 static NTSTATUS context_delete_sam_account(struct pdb_context *context, SAM_ACCOUNT *sam_acct)
 294 {
 295         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 296
 297         struct pdb_methods *pdb_selected;
 298         if (!context) {
 299                 DEBUG(0, ("invalid pdb_context specified!\n"));
 300                 return ret;
 301         }
 302
 303         if (!sam_acct->methods){
 304                 pdb_selected = context->pdb_methods;
 305                 /* There's no passdb backend specified for this account.
 306                  * Try to delete it in every passdb available
 307                  * Needed to delete accounts in smbpasswd that are not
 308                  * in /etc/passwd.
 309                  */
 310                 while (pdb_selected){
 311                         if (NT_STATUS_IS_OK(ret = pdb_selected->delete_sam_account(pdb_selected, sam_acct))) {
 312                                 return ret;
 313                         }
 314                         pdb_selected = pdb_selected->next;
 315                 }
 316                 return ret;
 317         }
 318
 319         if (!sam_acct->methods->delete_sam_account){
 320                 DEBUG(0,("invalid sam_acct->methods->delete_sam_account\n"));
 321                 return ret;
 322         }
 323
 324         return sam_acct->methods->delete_sam_account(sam_acct->methods, sam_acct);
 325 }
 326
 327 static NTSTATUS context_getgrsid(struct pdb_context *context,
 328                                  GROUP_MAP *map, DOM_SID sid)
 329 {
 330         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 331
 332         struct pdb_methods *curmethods;
 333         if ((!context)) {
 334                 DEBUG(0, ("invalid pdb_context specified!\n"));
 335                 return ret;
 336         }
 337         curmethods = context->pdb_methods;
 338         while (curmethods){
 339                 ret = curmethods->getgrsid(curmethods, map, sid);
 340                 if (NT_STATUS_IS_OK(ret)) {
 341                         map->methods = curmethods;
 342                         return ret;
 343                 }
 344                 curmethods = curmethods->next;
 345         }
 346
 347         return ret;
 348 }
 349
 350 static NTSTATUS context_getgrgid(struct pdb_context *context,
 351                                  GROUP_MAP *map, gid_t gid)
 352 {
 353         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 354
 355         struct pdb_methods *curmethods;
 356         if ((!context)) {
 357                 DEBUG(0, ("invalid pdb_context specified!\n"));
 358                 return ret;
 359         }
 360         curmethods = context->pdb_methods;
 361         while (curmethods){
 362                 ret = curmethods->getgrgid(curmethods, map, gid);
 363                 if (NT_STATUS_IS_OK(ret)) {
 364                         map->methods = curmethods;
 365                         return ret;
 366                 }
 367                 curmethods = curmethods->next;
 368         }
 369
 370         return ret;
 371 }
 372
 373 static NTSTATUS context_getgrnam(struct pdb_context *context,
 374                                  GROUP_MAP *map, const char *name)
 375 {
 376         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 377
 378         struct pdb_methods *curmethods;
 379         if ((!context)) {
 380                 DEBUG(0, ("invalid pdb_context specified!\n"));
 381                 return ret;
 382         }
 383         curmethods = context->pdb_methods;
 384         while (curmethods){
 385                 ret = curmethods->getgrnam(curmethods, map, name);
 386                 if (NT_STATUS_IS_OK(ret)) {
 387                         map->methods = curmethods;
 388                         return ret;
 389                 }
 390                 curmethods = curmethods->next;
 391         }
 392
 393         return ret;
 394 }
 395
 396 static NTSTATUS context_add_group_mapping_entry(struct pdb_context *context,
 397                                                 GROUP_MAP *map)
 398 {
 399         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 400
 401         if ((!context) || (!context->pdb_methods)) {
 402                 DEBUG(0, ("invalid pdb_context specified!\n"));
 403                 return ret;
 404         }
 405
 406         return context->pdb_methods->add_group_mapping_entry(context->pdb_methods,
 407                                                              map);
 408 }
 409
 410 static NTSTATUS context_update_group_mapping_entry(struct pdb_context *context,
 411                                                    GROUP_MAP *map)
 412 {
 413         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 414
 415         if ((!context) || (!context->pdb_methods)) {
 416                 DEBUG(0, ("invalid pdb_context specified!\n"));
 417                 return ret;
 418         }
 419
 420         return context->
 421                 pdb_methods->update_group_mapping_entry(context->pdb_methods, map);
 422 }
 423
 424 static NTSTATUS context_delete_group_mapping_entry(struct pdb_context *context,
 425                                                    DOM_SID sid)
 426 {
 427         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 428
 429         if ((!context) || (!context->pdb_methods)) {
 430                 DEBUG(0, ("invalid pdb_context specified!\n"));
 431                 return ret;
 432         }
 433
 434         return context->
 435                 pdb_methods->delete_group_mapping_entry(context->pdb_methods, sid);
 436 }
 437
 438 static NTSTATUS context_enum_group_mapping(struct pdb_context *context,
 439                                            enum SID_NAME_USE sid_name_use,
 440                                            GROUP_MAP **rmap, int *num_entries,
 441                                            BOOL unix_only)
 442 {
 443         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 444
 445         if ((!context) || (!context->pdb_methods)) {
 446                 DEBUG(0, ("invalid pdb_context specified!\n"));
 447                 return ret;
 448         }
 449
 450         return context->pdb_methods->enum_group_mapping(context->pdb_methods,
 451                                                         sid_name_use, rmap,
 452                                                         num_entries, unix_only);
 453 }
 454
 455 static NTSTATUS context_find_alias(struct pdb_context *context,
 456                                    const char *name, DOM_SID *sid)
 457 {
 458         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 459
 460         if ((!context) || (!context->pdb_methods)) {
 461                 DEBUG(0, ("invalid pdb_context specified!\n"));
 462                 return ret;
 463         }
 464
 465         return context->pdb_methods->find_alias(context->pdb_methods,
 466                                                 name, sid);
 467 }
 468
 469 static NTSTATUS context_create_alias(struct pdb_context *context,
 470                                      const char *name, uint32 *rid)
 471 {
 472         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 473
 474         if ((!context) || (!context->pdb_methods)) {
 475                 DEBUG(0, ("invalid pdb_context specified!\n"));
 476                 return ret;
 477         }
 478
 479         return context->pdb_methods->create_alias(context->pdb_methods,
 480                                                   name, rid);
 481 }
 482
 483 static NTSTATUS context_delete_alias(struct pdb_context *context,
 484                                      const DOM_SID *sid)
 485 {
 486         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 487
 488         if ((!context) || (!context->pdb_methods)) {
 489                 DEBUG(0, ("invalid pdb_context specified!\n"));
 490                 return ret;
 491         }
 492
 493         return context->pdb_methods->delete_alias(context->pdb_methods, sid);
 494 }
 495
 496 static NTSTATUS context_enum_aliases(struct pdb_context *context,
 497                                      const DOM_SID *sid,
 498                                      uint32 start_idx, uint32 max_entries,
 499                                      uint32 *num_aliases,
 500                                      struct acct_info **info)
 501 {
 502         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 503
 504         if ((!context) || (!context->pdb_methods)) {
 505                 DEBUG(0, ("invalid pdb_context specified!\n"));
 506                 return ret;
 507         }
 508
 509         return context->pdb_methods->enum_aliases(context->pdb_methods,
 510                                                   sid, start_idx, max_entries,
 511                                                   num_aliases, info);
 512 }
 513
 514 static NTSTATUS context_get_aliasinfo(struct pdb_context *context,
 515                                       const DOM_SID *sid,
 516                                       struct acct_info *info)
 517 {
 518         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 519
 520         if ((!context) || (!context->pdb_methods)) {
 521                 DEBUG(0, ("invalid pdb_context specified!\n"));
 522                 return ret;
 523         }
 524
 525         return context->pdb_methods->get_aliasinfo(context->pdb_methods,
 526                                                    sid, info);
 527 }
 528
 529 static NTSTATUS context_set_aliasinfo(struct pdb_context *context,
 530                                       const DOM_SID *sid,
 531                                       struct acct_info *info)
 532 {
 533         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 534
 535         if ((!context) || (!context->pdb_methods)) {
 536                 DEBUG(0, ("invalid pdb_context specified!\n"));
 537                 return ret;
 538         }
 539
 540         return context->pdb_methods->set_aliasinfo(context->pdb_methods,
 541                                                    sid, info);
 542 }
 543
 544 static NTSTATUS context_add_aliasmem(struct pdb_context *context,
 545                                      const DOM_SID *alias,
 546                                      const DOM_SID *member)
 547 {
 548         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 549
 550         if ((!context) || (!context->pdb_methods)) {
 551                 DEBUG(0, ("invalid pdb_context specified!\n"));
 552                 return ret;
 553         }
 554
 555         return context->pdb_methods->add_aliasmem(context->pdb_methods,
 556                                                   alias, member);
 557 }
 558
 559 static NTSTATUS context_del_aliasmem(struct pdb_context *context,
 560                                      const DOM_SID *alias,
 561                                      const DOM_SID *member)
 562 {
 563         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 564
 565         if ((!context) || (!context->pdb_methods)) {
 566                 DEBUG(0, ("invalid pdb_context specified!\n"));
 567                 return ret;
 568         }
 569
 570         return context->pdb_methods->del_aliasmem(context->pdb_methods,
 571                                                   alias, member);
 572 }
 573
 574 static NTSTATUS context_enum_aliasmem(struct pdb_context *context,
 575                                       const DOM_SID *alias, DOM_SID **members,
 576                                       int *num)
 577 {
 578         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 579
 580         if ((!context) || (!context->pdb_methods)) {
 581                 DEBUG(0, ("invalid pdb_context specified!\n"));
 582                 return ret;
 583         }
 584
 585         return context->pdb_methods->enum_aliasmem(context->pdb_methods,
 586                                                    alias, members, num);
 587 }
 588
 589 static NTSTATUS context_enum_alias_memberships(struct pdb_context *context,
 590                                                const DOM_SID *sid,
 591                                                DOM_SID **aliases, int *num)
 592 {
 593         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 594
 595         if ((!context) || (!context->pdb_methods)) {
 596                 DEBUG(0, ("invalid pdb_context specified!\n"));
 597                 return ret;
 598         }
 599
 600         return context->pdb_methods->
 601                 enum_alias_memberships(context->pdb_methods, sid, aliases,
 602                                        num);
 603 }
 604
 605 /******************************************************************
 606   Free and cleanup a pdb context, any associated data and anything
 607   that the attached modules might have associated.
 608  *******************************************************************/
 609
 610 static void free_pdb_context(struct pdb_context **context)
 611 {
 612         struct pdb_methods *pdb_selected = (*context)->pdb_methods;
 613
 614         while (pdb_selected){
 615                 if(pdb_selected->free_private_data)
 616                         pdb_selected->free_private_data(&(pdb_selected->private_data));
 617                 pdb_selected = pdb_selected->next;
 618         }
 619
 620         talloc_destroy((*context)->mem_ctx);
 621         *context = NULL;
 622 }
 623
 624 /******************************************************************
 625   Make a pdb_methods from scratch
 626  *******************************************************************/
 627
 628 static NTSTATUS make_pdb_methods_name(struct pdb_methods **methods, struct pdb_context *context, const char *selected)
 629 {
 630         char *module_name = smb_xstrdup(selected);
 631         char *module_location = NULL, *p;
 632         struct pdb_init_function_entry *entry;
 633         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 634
 635         lazy_initialize_passdb();
 636
 637         p = strchr(module_name, ':');
 638
 639         if (p) {
 640                 *p = 0;
 641                 module_location = p+1;
 642                 trim_char(module_location, ' ', ' ');
 643         }
 644
 645         trim_char(module_name, ' ', ' ');
 646
 647
 648         DEBUG(5,("Attempting to find an passdb backend to match %s (%s)\n", selected, module_name));
 649
 650         entry = pdb_find_backend_entry(module_name);
 651
 652         /* Try to find a module that contains this module */
 653         if (!entry) {
 654                 DEBUG(2,("No builtin backend found, trying to load plugin\n"));
 655                 if(NT_STATUS_IS_OK(smb_probe_module("pdb", module_name)) && !(entry = pdb_find_backend_entry(module_name))) {
 656                         DEBUG(0,("Plugin is available, but doesn't register passdb backend %s\n", module_name));
 657                         SAFE_FREE(module_name);
 658                         return NT_STATUS_UNSUCCESSFUL;
 659                 }
 660         }
 661
 662         /* No such backend found */
 663         if(!entry) {
 664                 DEBUG(0,("No builtin nor plugin backend for %s found\n", module_name));
 665                 SAFE_FREE(module_name);
 666                 return NT_STATUS_INVALID_PARAMETER;
 667         }
 668
 669         DEBUG(5,("Found pdb backend %s\n", module_name));
 670         nt_status = entry->init(context, methods, module_location);
 671         if (NT_STATUS_IS_OK(nt_status)) {
 672                 DEBUG(5,("pdb backend %s has a valid init\n", selected));
 673         } else {
 674                 DEBUG(0,("pdb backend %s did not correctly init (error was %s)\n", selected, nt_errstr(nt_status)));
 675         }
 676         SAFE_FREE(module_name);
 677         return nt_status;
 678 }
 679
 680 /******************************************************************
 681   Make a pdb_context from scratch.
 682  *******************************************************************/
 683
 684 static NTSTATUS make_pdb_context(struct pdb_context **context)
 685 {
 686         TALLOC_CTX *mem_ctx;
 687
 688         mem_ctx = talloc_init("pdb_context internal allocation context");
 689
 690         if (!mem_ctx) {
 691                 DEBUG(0, ("make_pdb_context: talloc init failed!\n"));
 692                 return NT_STATUS_NO_MEMORY;
 693         }
 694
 695         *context = talloc(mem_ctx, sizeof(**context));
 696         if (!*context) {
 697                 DEBUG(0, ("make_pdb_context: talloc failed!\n"));
 698                 return NT_STATUS_NO_MEMORY;
 699         }
 700
 701         ZERO_STRUCTP(*context);
 702
 703         (*context)->mem_ctx = mem_ctx;
 704
 705         (*context)->pdb_setsampwent = context_setsampwent;
 706         (*context)->pdb_endsampwent = context_endsampwent;
 707         (*context)->pdb_getsampwent = context_getsampwent;
 708         (*context)->pdb_getsampwnam = context_getsampwnam;
 709         (*context)->pdb_getsampwsid = context_getsampwsid;
 710         (*context)->pdb_add_sam_account = context_add_sam_account;
 711         (*context)->pdb_update_sam_account = context_update_sam_account;
 712         (*context)->pdb_delete_sam_account = context_delete_sam_account;
 713         (*context)->pdb_getgrsid = context_getgrsid;
 714         (*context)->pdb_getgrgid = context_getgrgid;
 715         (*context)->pdb_getgrnam = context_getgrnam;
 716         (*context)->pdb_add_group_mapping_entry = context_add_group_mapping_entry;
 717         (*context)->pdb_update_group_mapping_entry = context_update_group_mapping_entry;
 718         (*context)->pdb_delete_group_mapping_entry = context_delete_group_mapping_entry;
 719         (*context)->pdb_enum_group_mapping = context_enum_group_mapping;
 720
 721         (*context)->pdb_find_alias = context_find_alias;
 722         (*context)->pdb_create_alias = context_create_alias;
 723         (*context)->pdb_delete_alias = context_delete_alias;
 724         (*context)->pdb_enum_aliases = context_enum_aliases;
 725         (*context)->pdb_get_aliasinfo = context_get_aliasinfo;
 726         (*context)->pdb_set_aliasinfo = context_set_aliasinfo;
 727         (*context)->pdb_add_aliasmem = context_add_aliasmem;
 728         (*context)->pdb_del_aliasmem = context_del_aliasmem;
 729         (*context)->pdb_enum_aliasmem = context_enum_aliasmem;
 730         (*context)->pdb_enum_alias_memberships = context_enum_alias_memberships;
 731
 732         (*context)->free_fn = free_pdb_context;
 733
 734         return NT_STATUS_OK;
 735 }
 736
 737
 738 /******************************************************************
 739   Make a pdb_context, given an array of strings
 740  *******************************************************************/
 741
 742 NTSTATUS make_pdb_context_list(struct pdb_context **context, const char **selected)
 743 {
 744         int i = 0;
 745         struct pdb_methods *curmethods, *tmpmethods;
 746         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 747         BOOL have_guest = False;
 748
 749         if (!NT_STATUS_IS_OK(nt_status = make_pdb_context(context))) {
 750                 return nt_status;
 751         }
 752
 753         if (!selected) {
 754                 DEBUG(0, ("ERROR: empty passdb backend list!\n"));
 755                 return nt_status;
 756         }
 757
 758         while (selected[i]){
 759                 if (strcmp(selected[i], "guest") == 0) {
 760                         have_guest = True;
 761                 }
 762                 /* Try to initialise pdb */
 763                 DEBUG(5,("Trying to load: %s\n", selected[i]));
 764                 if (!NT_STATUS_IS_OK(nt_status = make_pdb_methods_name(&curmethods, *context, selected[i]))) {
 765                         DEBUG(1, ("Loading %s failed!\n", selected[i]));
 766                         free_pdb_context(context);
 767                         return nt_status;
 768                 }
 769                 curmethods->parent = *context;
 770                 DLIST_ADD_END((*context)->pdb_methods, curmethods, tmpmethods);
 771                 i++;
 772         }
 773
 774         if (have_guest)
 775                 return NT_STATUS_OK;
 776
 777         if ( (lp_guestaccount() == NULL) ||
 778              (*lp_guestaccount() == '\0') ) {
 779                 /* We explicitly don't want guest access. No idea what
 780                    else that breaks, but be it that way. */
 781                 return NT_STATUS_OK;
 782         }
 783
 784         if (!NT_STATUS_IS_OK(nt_status = make_pdb_methods_name(&curmethods,
 785                                                                *context,
 786                                                                "guest"))) {
 787                 DEBUG(1, ("Loading guest module failed!\n"));
 788                 free_pdb_context(context);
 789                 return nt_status;
 790         }
 791
 792         curmethods->parent = *context;
 793         DLIST_ADD_END((*context)->pdb_methods, curmethods, tmpmethods);
 794
 795         return NT_STATUS_OK;
 796 }
 797
 798 /******************************************************************
 799   Make a pdb_context, given a text string.
 800  *******************************************************************/
 801
 802 NTSTATUS make_pdb_context_string(struct pdb_context **context, const char *selected)
 803 {
 804         NTSTATUS ret;
 805         char **newsel = str_list_make(selected, NULL);
 806         ret = make_pdb_context_list(context, (const char **)newsel);
 807         str_list_free(&newsel);
 808         return ret;
 809 }
 810
 811 /******************************************************************
 812  Return an already initialised pdb_context, to facilitate backward
 813  compatibility (see functions below).
 814 *******************************************************************/
 815
 816 static struct pdb_context *pdb_get_static_context(BOOL reload)
 817 {
 818         static struct pdb_context *pdb_context = NULL;
 819
 820         if ((pdb_context) && (reload)) {
 821                 pdb_context->free_fn(&pdb_context);
 822                 if (!NT_STATUS_IS_OK(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
 823                         return NULL;
 824                 }
 825         }
 826
 827         if (!pdb_context) {
 828                 if (!NT_STATUS_IS_OK(make_pdb_context_list(&pdb_context, lp_passdb_backend()))) {
 829                         return NULL;
 830                 }
 831         }
 832
 833         return pdb_context;
 834 }
 835
 836 /******************************************************************
 837  Backward compatibility functions for the original passdb interface
 838 *******************************************************************/
 839
 840 BOOL pdb_setsampwent(BOOL update)
 841 {
 842         struct pdb_context *pdb_context = pdb_get_static_context(False);
 843
 844         if (!pdb_context) {
 845                 return False;
 846         }
 847
 848         return NT_STATUS_IS_OK(pdb_context->pdb_setsampwent(pdb_context, update));
 849 }
 850
 851 void pdb_endsampwent(void)
 852 {
 853         struct pdb_context *pdb_context = pdb_get_static_context(False);
 854
 855         if (!pdb_context) {
 856                 return;
 857         }
 858
 859         pdb_context->pdb_endsampwent(pdb_context);
 860 }
 861
 862 BOOL pdb_getsampwent(SAM_ACCOUNT *user)
 863 {
 864         struct pdb_context *pdb_context = pdb_get_static_context(False);
 865
 866         if (!pdb_context) {
 867                 return False;
 868         }
 869
 870         return NT_STATUS_IS_OK(pdb_context->pdb_getsampwent(pdb_context, user));
 871 }
 872
 873 BOOL pdb_getsampwnam(SAM_ACCOUNT *sam_acct, const char *username)
 874 {
 875         struct pdb_context *pdb_context = pdb_get_static_context(False);
 876
 877         if (!pdb_context) {
 878                 return False;
 879         }
 880
 881         return NT_STATUS_IS_OK(pdb_context->pdb_getsampwnam(pdb_context, sam_acct, username));
 882 }
 883
 884 BOOL pdb_getsampwsid(SAM_ACCOUNT *sam_acct, const DOM_SID *sid)
 885 {
 886         struct pdb_context *pdb_context = pdb_get_static_context(False);
 887
 888         if (!pdb_context) {
 889                 return False;
 890         }
 891
 892         return NT_STATUS_IS_OK(pdb_context->pdb_getsampwsid(pdb_context, sam_acct, sid));
 893 }
 894
 895 BOOL pdb_add_sam_account(SAM_ACCOUNT *sam_acct)
 896 {
 897         struct pdb_context *pdb_context = pdb_get_static_context(False);
 898
 899         if (!pdb_context) {
 900                 return False;
 901         }
 902
 903         return NT_STATUS_IS_OK(pdb_context->pdb_add_sam_account(pdb_context, sam_acct));
 904 }
 905
 906 BOOL pdb_update_sam_account(SAM_ACCOUNT *sam_acct)
 907 {
 908         struct pdb_context *pdb_context = pdb_get_static_context(False);
 909
 910         if (!pdb_context) {
 911                 return False;
 912         }
 913
 914         return NT_STATUS_IS_OK(pdb_context->pdb_update_sam_account(pdb_context, sam_acct));
 915 }
 916
 917 BOOL pdb_delete_sam_account(SAM_ACCOUNT *sam_acct)
 918 {
 919         struct pdb_context *pdb_context = pdb_get_static_context(False);
 920
 921         if (!pdb_context) {
 922                 return False;
 923         }
 924
 925         return NT_STATUS_IS_OK(pdb_context->pdb_delete_sam_account(pdb_context, sam_acct));
 926 }
 927
 928 BOOL pdb_getgrsid(GROUP_MAP *map, DOM_SID sid)
 929 {
 930         struct pdb_context *pdb_context = pdb_get_static_context(False);
 931
 932         if (!pdb_context) {
 933                 return False;
 934         }
 935
 936         return NT_STATUS_IS_OK(pdb_context->
 937                                pdb_getgrsid(pdb_context, map, sid));
 938 }
 939
 940 BOOL pdb_getgrgid(GROUP_MAP *map, gid_t gid)
 941 {
 942         struct pdb_context *pdb_context = pdb_get_static_context(False);
 943
 944         if (!pdb_context) {
 945                 return False;
 946         }
 947
 948         return NT_STATUS_IS_OK(pdb_context->
 949                                pdb_getgrgid(pdb_context, map, gid));
 950 }
 951
 952 BOOL pdb_getgrnam(GROUP_MAP *map, const char *name)
 953 {
 954         struct pdb_context *pdb_context = pdb_get_static_context(False);
 955
 956         if (!pdb_context) {
 957                 return False;
 958         }
 959
 960         return NT_STATUS_IS_OK(pdb_context->
 961                                pdb_getgrnam(pdb_context, map, name));
 962 }
 963
 964 BOOL pdb_add_group_mapping_entry(GROUP_MAP *map)
 965 {
 966         struct pdb_context *pdb_context = pdb_get_static_context(False);
 967
 968         if (!pdb_context) {
 969                 return False;
 970         }
 971
 972         return NT_STATUS_IS_OK(pdb_context->
 973                                pdb_add_group_mapping_entry(pdb_context, map));
 974 }
 975
 976 BOOL pdb_update_group_mapping_entry(GROUP_MAP *map)
 977 {
 978         struct pdb_context *pdb_context = pdb_get_static_context(False);
 979
 980         if (!pdb_context) {
 981                 return False;
 982         }
 983
 984         return NT_STATUS_IS_OK(pdb_context->
 985                                pdb_update_group_mapping_entry(pdb_context, map));
 986 }
 987
 988 BOOL pdb_delete_group_mapping_entry(DOM_SID sid)
 989 {
 990         struct pdb_context *pdb_context = pdb_get_static_context(False);
 991
 992         if (!pdb_context) {
 993                 return False;
 994         }
 995
 996         return NT_STATUS_IS_OK(pdb_context->
 997                                pdb_delete_group_mapping_entry(pdb_context, sid));
 998 }
 999
1000 BOOL pdb_enum_group_mapping(enum SID_NAME_USE sid_name_use, GROUP_MAP **rmap,
1001                             int *num_entries, BOOL unix_only)
1002 {
1003         struct pdb_context *pdb_context = pdb_get_static_context(False);
1004
1005         if (!pdb_context) {
1006                 return False;
1007         }
1008
1009         return NT_STATUS_IS_OK(pdb_context->
1010                                pdb_enum_group_mapping(pdb_context, sid_name_use,
1011                                                       rmap, num_entries, unix_only));
1012 }
1013
1014 BOOL pdb_find_alias(const char *name, DOM_SID *sid)
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_find_alias(pdb_context,
1023                                                              name, sid));
1024 }
1025
1026 NTSTATUS pdb_create_alias(const char *name, uint32 *rid)
1027 {
1028         struct pdb_context *pdb_context = pdb_get_static_context(False);
1029
1030         if (!pdb_context) {
1031                 return NT_STATUS_NOT_IMPLEMENTED;
1032         }
1033
1034         return pdb_context->pdb_create_alias(pdb_context, name, rid);
1035 }
1036
1037 BOOL pdb_delete_alias(const DOM_SID *sid)
1038 {
1039         struct pdb_context *pdb_context = pdb_get_static_context(False);
1040
1041         if (!pdb_context) {
1042                 return False;
1043         }
1044
1045         return NT_STATUS_IS_OK(pdb_context->pdb_delete_alias(pdb_context,
1046                                                              sid));
1047
1048 }
1049
1050 BOOL pdb_enum_aliases(const DOM_SID *sid, uint32 start_idx, uint32 max_entries,
1051                       uint32 *num_aliases, struct acct_info **info)
1052 {
1053         struct pdb_context *pdb_context = pdb_get_static_context(False);
1054
1055         if (!pdb_context) {
1056                 return False;
1057         }
1058
1059         return NT_STATUS_IS_OK(pdb_context->pdb_enum_aliases(pdb_context, sid,
1060                                                              start_idx,
1061                                                              max_entries,
1062                                                              num_aliases,
1063                                                              info));
1064 }
1065
1066 BOOL pdb_get_aliasinfo(const DOM_SID *sid, struct acct_info *info)
1067 {
1068         struct pdb_context *pdb_context = pdb_get_static_context(False);
1069
1070         if (!pdb_context) {
1071                 return False;
1072         }
1073
1074         return NT_STATUS_IS_OK(pdb_context->pdb_get_aliasinfo(pdb_context, sid,
1075                                                               info));
1076 }
1077
1078 BOOL pdb_set_aliasinfo(const DOM_SID *sid, struct acct_info *info)
1079 {
1080         struct pdb_context *pdb_context = pdb_get_static_context(False);
1081
1082         if (!pdb_context) {
1083                 return False;
1084         }
1085
1086         return NT_STATUS_IS_OK(pdb_context->pdb_set_aliasinfo(pdb_context, sid,
1087                                                               info));
1088 }
1089
1090 BOOL pdb_add_aliasmem(const DOM_SID *alias, const DOM_SID *member)
1091 {
1092         struct pdb_context *pdb_context = pdb_get_static_context(False);
1093
1094         if (!pdb_context) {
1095                 return False;
1096         }
1097
1098         return NT_STATUS_IS_OK(pdb_context->
1099                                pdb_add_aliasmem(pdb_context, alias, member));
1100 }
1101
1102 BOOL pdb_del_aliasmem(const DOM_SID *alias, const DOM_SID *member)
1103 {
1104         struct pdb_context *pdb_context = pdb_get_static_context(False);
1105
1106         if (!pdb_context) {
1107                 return False;
1108         }
1109
1110         return NT_STATUS_IS_OK(pdb_context->
1111                                pdb_del_aliasmem(pdb_context, alias, member));
1112 }
1113
1114 BOOL pdb_enum_aliasmem(const DOM_SID *alias,
1115                        DOM_SID **members, int *num_members)
1116 {
1117         struct pdb_context *pdb_context = pdb_get_static_context(False);
1118
1119         if (!pdb_context) {
1120                 return False;
1121         }
1122
1123         return NT_STATUS_IS_OK(pdb_context->
1124                                pdb_enum_aliasmem(pdb_context, alias,
1125                                                  members, num_members));
1126 }
1127
1128 BOOL pdb_enum_alias_memberships(const DOM_SID *sid,
1129                                 DOM_SID **aliases, int *num)
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_enum_alias_memberships(pdb_context, sid,
1139                                                           aliases, num));
1140 }
1141
1142 /***************************************************************
1143   Initialize the static context (at smbd startup etc).
1144
1145   If uninitialised, context will auto-init on first use.
1146  ***************************************************************/
1147
1148 BOOL initialize_password_db(BOOL reload)
1149 {
1150         return (pdb_get_static_context(reload) != NULL);
1151 }
1152
1153
1154 /***************************************************************************
1155   Default implementations of some functions.
1156  ****************************************************************************/
1157
1158 static NTSTATUS pdb_default_getsampwnam (struct pdb_methods *methods, SAM_ACCOUNT *user, const char *sname)
1159 {
1160         return NT_STATUS_NO_SUCH_USER;
1161 }
1162
1163 static NTSTATUS pdb_default_getsampwsid(struct pdb_methods *my_methods, SAM_ACCOUNT * user, const DOM_SID *sid)
1164 {
1165         return NT_STATUS_NO_SUCH_USER;
1166 }
1167
1168 static NTSTATUS pdb_default_add_sam_account (struct pdb_methods *methods, SAM_ACCOUNT *newpwd)
1169 {
1170         DEBUG(0,("this backend (%s) should not be listed as the first passdb backend! You can't add users to it.\n", methods->name));
1171         return NT_STATUS_NOT_IMPLEMENTED;
1172 }
1173
1174 static NTSTATUS pdb_default_update_sam_account (struct pdb_methods *methods, SAM_ACCOUNT *newpwd)
1175 {
1176         return NT_STATUS_NOT_IMPLEMENTED;
1177 }
1178
1179 static NTSTATUS pdb_default_delete_sam_account (struct pdb_methods *methods, SAM_ACCOUNT *pwd)
1180 {
1181         return NT_STATUS_NOT_IMPLEMENTED;
1182 }
1183
1184 static NTSTATUS pdb_default_setsampwent(struct pdb_methods *methods, BOOL update)
1185 {
1186         return NT_STATUS_NOT_IMPLEMENTED;
1187 }
1188
1189 static NTSTATUS pdb_default_getsampwent(struct pdb_methods *methods, SAM_ACCOUNT *user)
1190 {
1191         return NT_STATUS_NOT_IMPLEMENTED;
1192 }
1193
1194 static void pdb_default_endsampwent(struct pdb_methods *methods)
1195 {
1196         return; /* NT_STATUS_NOT_IMPLEMENTED; */
1197 }
1198
1199 NTSTATUS make_pdb_methods(TALLOC_CTX *mem_ctx, PDB_METHODS **methods)
1200 {
1201         *methods = talloc(mem_ctx, sizeof(struct pdb_methods));
1202
1203         if (!*methods) {
1204                 return NT_STATUS_NO_MEMORY;
1205         }
1206
1207         ZERO_STRUCTP(*methods);
1208
1209         (*methods)->setsampwent = pdb_default_setsampwent;
1210         (*methods)->endsampwent = pdb_default_endsampwent;
1211         (*methods)->getsampwent = pdb_default_getsampwent;
1212         (*methods)->getsampwnam = pdb_default_getsampwnam;
1213         (*methods)->getsampwsid = pdb_default_getsampwsid;
1214         (*methods)->add_sam_account = pdb_default_add_sam_account;
1215         (*methods)->update_sam_account = pdb_default_update_sam_account;
1216         (*methods)->delete_sam_account = pdb_default_delete_sam_account;
1217
1218         (*methods)->getgrsid = pdb_default_getgrsid;
1219         (*methods)->getgrgid = pdb_default_getgrgid;
1220         (*methods)->getgrnam = pdb_default_getgrnam;
1221         (*methods)->add_group_mapping_entry = pdb_default_add_group_mapping_entry;
1222         (*methods)->update_group_mapping_entry = pdb_default_update_group_mapping_entry;
1223         (*methods)->delete_group_mapping_entry = pdb_default_delete_group_mapping_entry;
1224         (*methods)->enum_group_mapping = pdb_default_enum_group_mapping;
1225         (*methods)->find_alias = pdb_default_find_alias;
1226         (*methods)->create_alias = pdb_default_create_alias;
1227         (*methods)->delete_alias = pdb_default_delete_alias;
1228         (*methods)->enum_aliases = pdb_default_enum_aliases;
1229         (*methods)->get_aliasinfo = pdb_default_get_aliasinfo;
1230         (*methods)->set_aliasinfo = pdb_default_set_aliasinfo;
1231         (*methods)->add_aliasmem = pdb_default_add_aliasmem;
1232         (*methods)->del_aliasmem = pdb_default_del_aliasmem;
1233         (*methods)->enum_aliasmem = pdb_default_enum_aliasmem;
1234         (*methods)->enum_alias_memberships = pdb_default_alias_memberships;
1235
1236         return NT_STATUS_OK;
1237 }