source3/winbindd/idmap_ldap.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    idmap LDAP backend
   5
   6    Copyright (C) Tim Potter             2000
   7    Copyright (C) Jim McDonough <jmcd@us.ibm.com>        2003
   8    Copyright (C) Gerald Carter          2003
   9    Copyright (C) Simo Sorce             2003-2007
  10    Copyright (C) Michael Adam           2010
  11
  12    This program is free software; you can redistribute it and/or modify
  13    it under the terms of the GNU General Public License as published by
  14    the Free Software Foundation; either version 3 of the License, or
  15    (at your option) any later version.
  16
  17    This program is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24 */
  25
  26 #include "includes.h"
  27 #include "winbindd.h"
  28 #include "secrets.h"
  29 #include "idmap.h"
  30 #include "idmap_rw.h"
  31 #include "../libcli/security/security.h"
  32
  33 #undef DBGC_CLASS
  34 #define DBGC_CLASS DBGC_IDMAP
  35
  36 #include <lber.h>
  37 #include <ldap.h>
  38
  39 #include "smbldap.h"
  40
  41 static char *idmap_fetch_secret(const char *backend, bool alloc,
  42                                 const char *domain, const char *identity)
  43 {
  44         char *tmp, *ret;
  45         int r;
  46
  47         if (alloc) {
  48                 r = asprintf(&tmp, "IDMAP_ALLOC_%s", backend);
  49         } else {
  50                 r = asprintf(&tmp, "IDMAP_%s_%s", backend, domain);
  51         }
  52
  53         if (r < 0)
  54                 return NULL;
  55
  56         strupper_m(tmp); /* make sure the key is case insensitive */
  57         ret = secrets_fetch_generic(tmp, identity);
  58
  59         SAFE_FREE(tmp);
  60
  61         return ret;
  62 }
  63
  64 struct idmap_ldap_alloc_context {
  65         struct smbldap_state *smbldap_state;
  66         char *url;
  67         char *suffix;
  68         char *user_dn;
  69 };
  70
  71 struct idmap_ldap_context {
  72         struct smbldap_state *smbldap_state;
  73         char *url;
  74         char *suffix;
  75         char *user_dn;
  76         bool anon;
  77         struct idmap_ldap_alloc_context *alloc;
  78         struct idmap_rw_ops *rw_ops;
  79 };
  80
  81 #define CHECK_ALLOC_DONE(mem) do { \
  82         if (!mem) { \
  83                 DEBUG(0, ("Out of memory!\n")); \
  84                 ret = NT_STATUS_NO_MEMORY; \
  85                 goto done; \
  86         } } while (0)
  87
  88 /**********************************************************************
  89  IDMAP ALLOC TDB BACKEND
  90 **********************************************************************/
  91
  92 /*********************************************************************
  93  ********************************************************************/
  94
  95 static NTSTATUS get_credentials( TALLOC_CTX *mem_ctx,
  96                                  struct smbldap_state *ldap_state,
  97                                  const char *config_option,
  98                                  struct idmap_domain *dom,
  99                                  char **dn )
 100 {
 101         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 102         char *secret = NULL;
 103         const char *tmp = NULL;
 104         char *user_dn = NULL;
 105         bool anon = False;
 106
 107         /* assume anonymous if we don't have a specified user */
 108
 109         tmp = lp_parm_const_string(-1, config_option, "ldap_user_dn", NULL);
 110
 111         if ( tmp ) {
 112                 if (!dom) {
 113                         /* only the alloc backend can pass in a NULL dom */
 114                         secret = idmap_fetch_secret("ldap", True,
 115                                                     NULL, tmp);
 116                 } else {
 117                         secret = idmap_fetch_secret("ldap", False,
 118                                                     dom->name, tmp);
 119                 }
 120
 121                 if (!secret) {
 122                         DEBUG(0, ("get_credentials: Unable to fetch "
 123                                   "auth credentials for %s in %s\n",
 124                                   tmp, (dom==NULL)?"ALLOC":dom->name));
 125                         ret = NT_STATUS_ACCESS_DENIED;
 126                         goto done;
 127                 }
 128                 *dn = talloc_strdup(mem_ctx, tmp);
 129                 CHECK_ALLOC_DONE(*dn);
 130         } else {
 131                 if (!fetch_ldap_pw(&user_dn, &secret)) {
 132                         DEBUG(2, ("get_credentials: Failed to lookup ldap "
 133                                   "bind creds. Using anonymous connection.\n"));
 134                         anon = True;
 135                         *dn = NULL;
 136                 } else {
 137                         *dn = talloc_strdup(mem_ctx, user_dn);
 138                         SAFE_FREE( user_dn );
 139                         CHECK_ALLOC_DONE(*dn);
 140                 }
 141         }
 142
 143         smbldap_set_creds(ldap_state, anon, *dn, secret);
 144         ret = NT_STATUS_OK;
 145
 146 done:
 147         SAFE_FREE(secret);
 148
 149         return ret;
 150 }
 151
 152
 153 /**********************************************************************
 154  Verify the sambaUnixIdPool entry in the directory.
 155 **********************************************************************/
 156
 157 static NTSTATUS verify_idpool(struct idmap_domain *dom)
 158 {
 159         NTSTATUS ret;
 160         TALLOC_CTX *mem_ctx;
 161         LDAPMessage *result = NULL;
 162         LDAPMod **mods = NULL;
 163         const char **attr_list;
 164         char *filter;
 165         int count;
 166         int rc;
 167         struct idmap_ldap_context *ctx;
 168
 169         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
 170
 171         mem_ctx = talloc_new(ctx);
 172         if (mem_ctx == NULL) {
 173                 DEBUG(0, ("Out of memory!\n"));
 174                 return NT_STATUS_NO_MEMORY;
 175         }
 176
 177         filter = talloc_asprintf(mem_ctx, "(objectclass=%s)", LDAP_OBJ_IDPOOL);
 178         CHECK_ALLOC_DONE(filter);
 179
 180         attr_list = get_attr_list(mem_ctx, idpool_attr_list);
 181         CHECK_ALLOC_DONE(attr_list);
 182
 183         rc = smbldap_search(ctx->smbldap_state,
 184                                 ctx->suffix,
 185                                 LDAP_SCOPE_SUBTREE,
 186                                 filter,
 187                                 attr_list,
 188                                 0,
 189                                 &result);
 190
 191         if (rc != LDAP_SUCCESS) {
 192                 DEBUG(1, ("Unable to verify the idpool, "
 193                           "cannot continue initialization!\n"));
 194                 return NT_STATUS_UNSUCCESSFUL;
 195         }
 196
 197         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
 198
 199         ldap_msgfree(result);
 200
 201         if ( count > 1 ) {
 202                 DEBUG(0,("Multiple entries returned from %s (base == %s)\n",
 203                         filter, ctx->suffix));
 204                 ret = NT_STATUS_UNSUCCESSFUL;
 205                 goto done;
 206         }
 207         else if (count == 0) {
 208                 char *uid_str, *gid_str;
 209
 210                 uid_str = talloc_asprintf(mem_ctx, "%lu",
 211                                 (unsigned long)dom->low_id);
 212                 gid_str = talloc_asprintf(mem_ctx, "%lu",
 213                                 (unsigned long)dom->low_id);
 214
 215                 smbldap_set_mod(&mods, LDAP_MOD_ADD,
 216                                 "objectClass", LDAP_OBJ_IDPOOL);
 217                 smbldap_set_mod(&mods, LDAP_MOD_ADD,
 218                                 get_attr_key2string(idpool_attr_list,
 219                                                     LDAP_ATTR_UIDNUMBER),
 220                                 uid_str);
 221                 smbldap_set_mod(&mods, LDAP_MOD_ADD,
 222                                 get_attr_key2string(idpool_attr_list,
 223                                                     LDAP_ATTR_GIDNUMBER),
 224                                 gid_str);
 225                 if (mods) {
 226                         rc = smbldap_modify(ctx->smbldap_state,
 227                                                 ctx->suffix,
 228                                                 mods);
 229                         ldap_mods_free(mods, True);
 230                 } else {
 231                         ret = NT_STATUS_UNSUCCESSFUL;
 232                         goto done;
 233                 }
 234         }
 235
 236         ret = (rc == LDAP_SUCCESS)?NT_STATUS_OK:NT_STATUS_UNSUCCESSFUL;
 237 done:
 238         talloc_free(mem_ctx);
 239         return ret;
 240 }
 241
 242 /********************************
 243  Allocate a new uid or gid
 244 ********************************/
 245
 246 static NTSTATUS idmap_ldap_allocate_id(struct idmap_domain *dom,
 247                                        struct unixid *xid)
 248 {
 249         TALLOC_CTX *mem_ctx;
 250         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 251         int rc = LDAP_SERVER_DOWN;
 252         int count = 0;
 253         LDAPMessage *result = NULL;
 254         LDAPMessage *entry = NULL;
 255         LDAPMod **mods = NULL;
 256         char *id_str;
 257         char *new_id_str;
 258         char *filter = NULL;
 259         const char *dn = NULL;
 260         const char **attr_list;
 261         const char *type;
 262         struct idmap_ldap_context *ctx;
 263
 264         /* Only do query if we are online */
 265         if (idmap_is_offline()) {
 266                 return NT_STATUS_FILE_IS_OFFLINE;
 267         }
 268
 269         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
 270
 271         mem_ctx = talloc_new(ctx);
 272         if (!mem_ctx) {
 273                 DEBUG(0, ("Out of memory!\n"));
 274                 return NT_STATUS_NO_MEMORY;
 275         }
 276
 277         /* get type */
 278         switch (xid->type) {
 279
 280         case ID_TYPE_UID:
 281                 type = get_attr_key2string(idpool_attr_list,
 282                                            LDAP_ATTR_UIDNUMBER);
 283                 break;
 284
 285         case ID_TYPE_GID:
 286                 type = get_attr_key2string(idpool_attr_list,
 287                                            LDAP_ATTR_GIDNUMBER);
 288                 break;
 289
 290         default:
 291                 DEBUG(2, ("Invalid ID type (0x%x)\n", xid->type));
 292                 return NT_STATUS_INVALID_PARAMETER;
 293         }
 294
 295         filter = talloc_asprintf(mem_ctx, "(objectClass=%s)", LDAP_OBJ_IDPOOL);
 296         CHECK_ALLOC_DONE(filter);
 297
 298         attr_list = get_attr_list(mem_ctx, idpool_attr_list);
 299         CHECK_ALLOC_DONE(attr_list);
 300
 301         DEBUG(10, ("Search of the id pool (filter: %s)\n", filter));
 302
 303         rc = smbldap_search(ctx->smbldap_state,
 304                            ctx->suffix,
 305                            LDAP_SCOPE_SUBTREE, filter,
 306                            attr_list, 0, &result);
 307
 308         if (rc != LDAP_SUCCESS) {
 309                 DEBUG(0,("%s object not found\n", LDAP_OBJ_IDPOOL));
 310                 goto done;
 311         }
 312
 313         talloc_autofree_ldapmsg(mem_ctx, result);
 314
 315         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
 316         if (count != 1) {
 317                 DEBUG(0,("Single %s object not found\n", LDAP_OBJ_IDPOOL));
 318                 goto done;
 319         }
 320
 321         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct, result);
 322
 323         dn = smbldap_talloc_dn(mem_ctx,
 324                                ctx->smbldap_state->ldap_struct,
 325                                entry);
 326         if ( ! dn) {
 327                 goto done;
 328         }
 329
 330         id_str = smbldap_talloc_single_attribute(
 331                                 ctx->smbldap_state->ldap_struct,
 332                                 entry, type, mem_ctx);
 333         if (id_str == NULL) {
 334                 DEBUG(0,("%s attribute not found\n", type));
 335                 ret = NT_STATUS_UNSUCCESSFUL;
 336                 goto done;
 337         }
 338
 339         xid->id = strtoul(id_str, NULL, 10);
 340
 341         /* make sure we still have room to grow */
 342
 343         switch (xid->type) {
 344         case ID_TYPE_UID:
 345                 if (xid->id > dom->high_id) {
 346                         DEBUG(0,("Cannot allocate uid above %lu!\n",
 347                                  (unsigned long)dom->high_id));
 348                         goto done;
 349                 }
 350                 break;
 351
 352         case ID_TYPE_GID:
 353                 if (xid->id > dom->high_id) {
 354                         DEBUG(0,("Cannot allocate gid above %lu!\n",
 355                                  (unsigned long)dom->high_id));
 356                         goto done;
 357                 }
 358                 break;
 359
 360         default:
 361                 /* impossible */
 362                 goto done;
 363         }
 364
 365         new_id_str = talloc_asprintf(mem_ctx, "%lu", (unsigned long)xid->id + 1);
 366         if ( ! new_id_str) {
 367                 DEBUG(0,("Out of memory\n"));
 368                 ret = NT_STATUS_NO_MEMORY;
 369                 goto done;
 370         }
 371
 372         smbldap_set_mod(&mods, LDAP_MOD_DELETE, type, id_str);
 373         smbldap_set_mod(&mods, LDAP_MOD_ADD, type, new_id_str);
 374
 375         if (mods == NULL) {
 376                 DEBUG(0,("smbldap_set_mod() failed.\n"));
 377                 goto done;
 378         }
 379
 380         DEBUG(10, ("Try to atomically increment the id (%s -> %s)\n",
 381                    id_str, new_id_str));
 382
 383         rc = smbldap_modify(ctx->smbldap_state, dn, mods);
 384
 385         ldap_mods_free(mods, True);
 386
 387         if (rc != LDAP_SUCCESS) {
 388                 DEBUG(1,("Failed to allocate new %s. "
 389                          "smbldap_modify() failed.\n", type));
 390                 goto done;
 391         }
 392
 393         ret = NT_STATUS_OK;
 394
 395 done:
 396         talloc_free(mem_ctx);
 397         return ret;
 398 }
 399
 400 /**
 401  * Allocate a new unix-ID.
 402  * For now this is for the default idmap domain only.
 403  * Should be extended later on.
 404  */
 405 static NTSTATUS idmap_ldap_get_new_id(struct idmap_domain *dom,
 406                                       struct unixid *id)
 407 {
 408         NTSTATUS ret;
 409
 410         if (!strequal(dom->name, "*")) {
 411                 DEBUG(3, ("idmap_ldap_get_new_id: "
 412                           "Refusing allocation of a new unixid for domain'%s'. "
 413                           "Currently only supported for the default "
 414                           "domain \"*\".\n",
 415                            dom->name));
 416                 return NT_STATUS_NOT_IMPLEMENTED;
 417         }
 418
 419         ret = idmap_ldap_allocate_id(dom, id);
 420
 421         return ret;
 422 }
 423
 424
 425 /**********************************************************************
 426  IDMAP MAPPING LDAP BACKEND
 427 **********************************************************************/
 428
 429 static int idmap_ldap_close_destructor(struct idmap_ldap_context *ctx)
 430 {
 431         smbldap_free_struct(&ctx->smbldap_state);
 432         DEBUG(5,("The connection to the LDAP server was closed\n"));
 433         /* maybe free the results here --metze */
 434
 435         return 0;
 436 }
 437
 438 /********************************
 439  Initialise idmap database.
 440 ********************************/
 441
 442 static NTSTATUS idmap_ldap_set_mapping(struct idmap_domain *dom,
 443                                        const struct id_map *map);
 444
 445 static NTSTATUS idmap_ldap_db_init(struct idmap_domain *dom,
 446                                    const char *params)
 447 {
 448         NTSTATUS ret;
 449         struct idmap_ldap_context *ctx = NULL;
 450         char *config_option = NULL;
 451         const char *tmp = NULL;
 452
 453         /* Only do init if we are online */
 454         if (idmap_is_offline()) {
 455                 return NT_STATUS_FILE_IS_OFFLINE;
 456         }
 457
 458         ctx = TALLOC_ZERO_P(dom, struct idmap_ldap_context);
 459         if ( ! ctx) {
 460                 DEBUG(0, ("Out of memory!\n"));
 461                 return NT_STATUS_NO_MEMORY;
 462         }
 463
 464         if (strequal(dom->name, "*")) {
 465                 /* more specific configuration can go here */
 466         } else {
 467                 config_option = talloc_asprintf(ctx, "idmap config %s", dom->name);
 468                 if ( ! config_option) {
 469                         DEBUG(0, ("Out of memory!\n"));
 470                         ret = NT_STATUS_NO_MEMORY;
 471                         goto done;
 472                 }
 473         }
 474
 475         if (params != NULL) {
 476                 /* assume location is the only parameter */
 477                 ctx->url = talloc_strdup(ctx, params);
 478         } else {
 479                 tmp = lp_parm_const_string(-1, config_option, "ldap_url", NULL);
 480
 481                 if ( ! tmp) {
 482                         DEBUG(1, ("ERROR: missing idmap ldap url\n"));
 483                         ret = NT_STATUS_UNSUCCESSFUL;
 484                         goto done;
 485                 }
 486
 487                 ctx->url = talloc_strdup(ctx, tmp);
 488         }
 489         CHECK_ALLOC_DONE(ctx->url);
 490
 491         trim_char(ctx->url, '\"', '\"');
 492
 493         tmp = lp_parm_const_string(-1, config_option, "ldap_base_dn", NULL);
 494         if ( ! tmp || ! *tmp) {
 495                 tmp = lp_ldap_idmap_suffix();
 496                 if ( ! tmp) {
 497                         DEBUG(1, ("ERROR: missing idmap ldap suffix\n"));
 498                         ret = NT_STATUS_UNSUCCESSFUL;
 499                         goto done;
 500                 }
 501         }
 502
 503         ctx->suffix = talloc_strdup(ctx, tmp);
 504         CHECK_ALLOC_DONE(ctx->suffix);
 505
 506         ctx->rw_ops = talloc_zero(ctx, struct idmap_rw_ops);
 507         CHECK_ALLOC_DONE(ctx->rw_ops);
 508
 509         ctx->rw_ops->get_new_id = idmap_ldap_get_new_id;
 510         ctx->rw_ops->set_mapping = idmap_ldap_set_mapping;
 511
 512         ret = smbldap_init(ctx, winbind_event_context(), ctx->url,
 513                            &ctx->smbldap_state);
 514         if (!NT_STATUS_IS_OK(ret)) {
 515                 DEBUG(1, ("ERROR: smbldap_init (%s) failed!\n", ctx->url));
 516                 goto done;
 517         }
 518
 519         ret = get_credentials( ctx, ctx->smbldap_state, config_option,
 520                                dom, &ctx->user_dn );
 521         if ( !NT_STATUS_IS_OK(ret) ) {
 522                 DEBUG(1,("idmap_ldap_db_init: Failed to get connection "
 523                          "credentials (%s)\n", nt_errstr(ret)));
 524                 goto done;
 525         }
 526
 527         /* set the destructor on the context, so that resource are properly
 528            freed if the contexts is released */
 529
 530         talloc_set_destructor(ctx, idmap_ldap_close_destructor);
 531
 532         dom->private_data = ctx;
 533
 534         ret = verify_idpool(dom);
 535         if (!NT_STATUS_IS_OK(ret)) {
 536                 DEBUG(1, ("idmap_ldap_db_init: failed to verify ID pool (%s)\n",
 537                          nt_errstr(ret)));
 538                 goto done;
 539         }
 540
 541         talloc_free(config_option);
 542         return NT_STATUS_OK;
 543
 544 /*failed */
 545 done:
 546         talloc_free(ctx);
 547         return ret;
 548 }
 549
 550 /**
 551  * set a mapping.
 552  */
 553
 554 /* TODO: change this:  This function cannot be called to modify a mapping,
 555  * only set a new one */
 556
 557 static NTSTATUS idmap_ldap_set_mapping(struct idmap_domain *dom,
 558                                        const struct id_map *map)
 559 {
 560         NTSTATUS ret;
 561         TALLOC_CTX *memctx;
 562         struct idmap_ldap_context *ctx;
 563         LDAPMessage *entry = NULL;
 564         LDAPMod **mods = NULL;
 565         const char *type;
 566         char *id_str;
 567         char *sid;
 568         char *dn;
 569         int rc = -1;
 570
 571         /* Only do query if we are online */
 572         if (idmap_is_offline()) {
 573                 return NT_STATUS_FILE_IS_OFFLINE;
 574         }
 575
 576         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
 577
 578         switch(map->xid.type) {
 579         case ID_TYPE_UID:
 580                 type = get_attr_key2string(sidmap_attr_list,
 581                                            LDAP_ATTR_UIDNUMBER);
 582                 break;
 583
 584         case ID_TYPE_GID:
 585                 type = get_attr_key2string(sidmap_attr_list,
 586                                            LDAP_ATTR_GIDNUMBER);
 587                 break;
 588
 589         default:
 590                 return NT_STATUS_INVALID_PARAMETER;
 591         }
 592
 593         memctx = talloc_new(ctx);
 594         if ( ! memctx) {
 595                 DEBUG(0, ("Out of memory!\n"));
 596                 return NT_STATUS_NO_MEMORY;
 597         }
 598
 599         id_str = talloc_asprintf(memctx, "%lu", (unsigned long)map->xid.id);
 600         CHECK_ALLOC_DONE(id_str);
 601
 602         sid = talloc_strdup(memctx, sid_string_talloc(memctx, map->sid));
 603         CHECK_ALLOC_DONE(sid);
 604
 605         dn = talloc_asprintf(memctx, "%s=%s,%s",
 606                         get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
 607                         sid,
 608                         ctx->suffix);
 609         CHECK_ALLOC_DONE(dn);
 610
 611         smbldap_set_mod(&mods, LDAP_MOD_ADD,
 612                         "objectClass", LDAP_OBJ_IDMAP_ENTRY);
 613
 614         smbldap_make_mod(ctx->smbldap_state->ldap_struct,
 615                          entry, &mods, type, id_str);
 616
 617         smbldap_make_mod(ctx->smbldap_state->ldap_struct, entry, &mods,
 618                          get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
 619                          sid);
 620
 621         if ( ! mods) {
 622                 DEBUG(2, ("ERROR: No mods?\n"));
 623                 ret = NT_STATUS_UNSUCCESSFUL;
 624                 goto done;
 625         }
 626
 627         /* TODO: remove conflicting mappings! */
 628
 629         smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_SID_ENTRY);
 630
 631         DEBUG(10, ("Set DN %s (%s -> %s)\n", dn, sid, id_str));
 632
 633         rc = smbldap_add(ctx->smbldap_state, dn, mods);
 634         ldap_mods_free(mods, True);
 635
 636         if (rc != LDAP_SUCCESS) {
 637                 char *ld_error = NULL;
 638                 ldap_get_option(ctx->smbldap_state->ldap_struct,
 639                                 LDAP_OPT_ERROR_STRING, &ld_error);
 640                 DEBUG(0,("ldap_set_mapping_internals: Failed to add %s to %lu "
 641                          "mapping [%s]\n", sid,
 642                          (unsigned long)map->xid.id, type));
 643                 DEBUG(0, ("ldap_set_mapping_internals: Error was: %s (%s)\n",
 644                         ld_error ? ld_error : "(NULL)", ldap_err2string (rc)));
 645                 if (ld_error) {
 646                         ldap_memfree(ld_error);
 647                 }
 648                 ret = NT_STATUS_UNSUCCESSFUL;
 649                 goto done;
 650         }
 651
 652         DEBUG(10,("ldap_set_mapping: Successfully created mapping from %s to "
 653                   "%lu [%s]\n", sid, (unsigned long)map->xid.id, type));
 654
 655         ret = NT_STATUS_OK;
 656
 657 done:
 658         talloc_free(memctx);
 659         return ret;
 660 }
 661
 662 /**
 663  * Create a new mapping for an unmapped SID, also allocating a new ID.
 664  * If possible, this should be run inside a transaction to make the
 665  * action atomic.
 666  */
 667 static NTSTATUS idmap_ldap_new_mapping(struct idmap_domain *dom, struct id_map *map)
 668 {
 669         NTSTATUS ret;
 670         struct idmap_ldap_context *ctx;
 671
 672         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
 673
 674         ret = idmap_rw_new_mapping(dom, ctx->rw_ops, map);
 675
 676         return ret;
 677 }
 678
 679
 680 /* max number of ids requested per batch query */
 681 #define IDMAP_LDAP_MAX_IDS 30
 682
 683 /**********************************
 684  lookup a set of unix ids.
 685 **********************************/
 686
 687 /* this function searches up to IDMAP_LDAP_MAX_IDS entries
 688  * in maps for a match */
 689 static struct id_map *find_map_by_id(struct id_map **maps,
 690                                      enum id_type type,
 691                                      uint32_t id)
 692 {
 693         int i;
 694
 695         for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
 696                 if (maps[i] == NULL) { /* end of the run */
 697                         return NULL;
 698                 }
 699                 if ((maps[i]->xid.type == type) && (maps[i]->xid.id == id)) {
 700                         return maps[i];
 701                 }
 702         }
 703
 704         return NULL;
 705 }
 706
 707 static NTSTATUS idmap_ldap_unixids_to_sids(struct idmap_domain *dom,
 708                                            struct id_map **ids)
 709 {
 710         NTSTATUS ret;
 711         TALLOC_CTX *memctx;
 712         struct idmap_ldap_context *ctx;
 713         LDAPMessage *result = NULL;
 714         LDAPMessage *entry = NULL;
 715         const char *uidNumber;
 716         const char *gidNumber;
 717         const char **attr_list;
 718         char *filter = NULL;
 719         bool multi = False;
 720         int idx = 0;
 721         int bidx = 0;
 722         int count;
 723         int rc;
 724         int i;
 725
 726         /* Only do query if we are online */
 727         if (idmap_is_offline()) {
 728                 return NT_STATUS_FILE_IS_OFFLINE;
 729         }
 730
 731         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
 732
 733         memctx = talloc_new(ctx);
 734         if ( ! memctx) {
 735                 DEBUG(0, ("Out of memory!\n"));
 736                 return NT_STATUS_NO_MEMORY;
 737         }
 738
 739         uidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_UIDNUMBER);
 740         gidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_GIDNUMBER);
 741
 742         attr_list = get_attr_list(memctx, sidmap_attr_list);
 743
 744         if ( ! ids[1]) {
 745                 /* if we are requested just one mapping use the simple filter */
 746
 747                 filter = talloc_asprintf(memctx, "(&(objectClass=%s)(%s=%lu))",
 748                                 LDAP_OBJ_IDMAP_ENTRY,
 749                                 (ids[0]->xid.type==ID_TYPE_UID)?uidNumber:gidNumber,
 750                                 (unsigned long)ids[0]->xid.id);
 751                 CHECK_ALLOC_DONE(filter);
 752                 DEBUG(10, ("Filter: [%s]\n", filter));
 753         } else {
 754                 /* multiple mappings */
 755                 multi = True;
 756         }
 757
 758         for (i = 0; ids[i]; i++) {
 759                 ids[i]->status = ID_UNKNOWN;
 760         }
 761
 762 again:
 763         if (multi) {
 764
 765                 talloc_free(filter);
 766                 filter = talloc_asprintf(memctx,
 767                                          "(&(objectClass=%s)(|",
 768                                          LDAP_OBJ_IDMAP_ENTRY);
 769                 CHECK_ALLOC_DONE(filter);
 770
 771                 bidx = idx;
 772                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
 773                         filter = talloc_asprintf_append_buffer(filter, "(%s=%lu)",
 774                                         (ids[idx]->xid.type==ID_TYPE_UID)?uidNumber:gidNumber,
 775                                         (unsigned long)ids[idx]->xid.id);
 776                         CHECK_ALLOC_DONE(filter);
 777                 }
 778                 filter = talloc_asprintf_append_buffer(filter, "))");
 779                 CHECK_ALLOC_DONE(filter);
 780                 DEBUG(10, ("Filter: [%s]\n", filter));
 781         } else {
 782                 bidx = 0;
 783                 idx = 1;
 784         }
 785
 786         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
 787                 filter, attr_list, 0, &result);
 788
 789         if (rc != LDAP_SUCCESS) {
 790                 DEBUG(3,("Failure looking up ids (%s)\n", ldap_err2string(rc)));
 791                 ret = NT_STATUS_UNSUCCESSFUL;
 792                 goto done;
 793         }
 794
 795         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
 796
 797         if (count == 0) {
 798                 DEBUG(10, ("NO SIDs found\n"));
 799         }
 800
 801         for (i = 0; i < count; i++) {
 802                 char *sidstr = NULL;
 803                 char *tmp = NULL;
 804                 enum id_type type;
 805                 struct id_map *map;
 806                 uint32_t id;
 807
 808                 if (i == 0) { /* first entry */
 809                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
 810                                                  result);
 811                 } else { /* following ones */
 812                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
 813                                                 entry);
 814                 }
 815                 if ( ! entry) {
 816                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
 817                                   "from results\n"));
 818                         break;
 819                 }
 820
 821                 /* first check if the SID is present */
 822                 sidstr = smbldap_talloc_single_attribute(
 823                                 ctx->smbldap_state->ldap_struct,
 824                                 entry, LDAP_ATTRIBUTE_SID, memctx);
 825                 if ( ! sidstr) { /* no sid, skip entry */
 826                         DEBUG(2, ("WARNING SID not found on entry\n"));
 827                         continue;
 828                 }
 829
 830                 /* now try to see if it is a uid, if not try with a gid
 831                  * (gid is more common, but in case both uidNumber and
 832                  * gidNumber are returned the SID is mapped to the uid
 833                  *not the gid) */
 834                 type = ID_TYPE_UID;
 835                 tmp = smbldap_talloc_single_attribute(
 836                                 ctx->smbldap_state->ldap_struct,
 837                                 entry, uidNumber, memctx);
 838                 if ( ! tmp) {
 839                         type = ID_TYPE_GID;
 840                         tmp = smbldap_talloc_single_attribute(
 841                                         ctx->smbldap_state->ldap_struct,
 842                                         entry, gidNumber, memctx);
 843                 }
 844                 if ( ! tmp) { /* wow very strange entry, how did it match ? */
 845                         DEBUG(5, ("Unprobable match on (%s), no uidNumber, "
 846                                   "nor gidNumber returned\n", sidstr));
 847                         TALLOC_FREE(sidstr);
 848                         continue;
 849                 }
 850
 851                 id = strtoul(tmp, NULL, 10);
 852                 if (!idmap_unix_id_is_in_range(id, dom)) {
 853                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
 854                                   "Filtered!\n", id,
 855                                   dom->low_id, dom->high_id));
 856                         TALLOC_FREE(sidstr);
 857                         TALLOC_FREE(tmp);
 858                         continue;
 859                 }
 860                 TALLOC_FREE(tmp);
 861
 862                 map = find_map_by_id(&ids[bidx], type, id);
 863                 if (!map) {
 864                         DEBUG(2, ("WARNING: couldn't match sid (%s) "
 865                                   "with requested ids\n", sidstr));
 866                         TALLOC_FREE(sidstr);
 867                         continue;
 868                 }
 869
 870                 if ( ! string_to_sid(map->sid, sidstr)) {
 871                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
 872                         TALLOC_FREE(sidstr);
 873                         continue;
 874                 }
 875
 876                 if (map->status == ID_MAPPED) {
 877                         DEBUG(1, ("WARNING: duplicate %s mapping in LDAP. "
 878                               "overwriting mapping %u -> %s with %u -> %s\n",
 879                               (type == ID_TYPE_UID) ? "UID" : "GID",
 880                               id, sid_string_dbg(map->sid), id, sidstr));
 881                 }
 882
 883                 TALLOC_FREE(sidstr);
 884
 885                 /* mapped */
 886                 map->status = ID_MAPPED;
 887
 888                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
 889                            (unsigned long)map->xid.id, map->xid.type));
 890         }
 891
 892         /* free the ldap results */
 893         if (result) {
 894                 ldap_msgfree(result);
 895                 result = NULL;
 896         }
 897
 898         if (multi && ids[idx]) { /* still some values to map */
 899                 goto again;
 900         }
 901
 902         ret = NT_STATUS_OK;
 903
 904         /* mark all unknwon/expired ones as unmapped */
 905         for (i = 0; ids[i]; i++) {
 906                 if (ids[i]->status != ID_MAPPED)
 907                         ids[i]->status = ID_UNMAPPED;
 908         }
 909
 910 done:
 911         talloc_free(memctx);
 912         return ret;
 913 }
 914
 915 /**********************************
 916  lookup a set of sids.
 917 **********************************/
 918
 919 /* this function searches up to IDMAP_LDAP_MAX_IDS entries
 920  * in maps for a match */
 921 static struct id_map *find_map_by_sid(struct id_map **maps, struct dom_sid *sid)
 922 {
 923         int i;
 924
 925         for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
 926                 if (maps[i] == NULL) { /* end of the run */
 927                         return NULL;
 928                 }
 929                 if (dom_sid_equal(maps[i]->sid, sid)) {
 930                         return maps[i];
 931                 }
 932         }
 933
 934         return NULL;
 935 }
 936
 937 static NTSTATUS idmap_ldap_sids_to_unixids(struct idmap_domain *dom,
 938                                            struct id_map **ids)
 939 {
 940         LDAPMessage *entry = NULL;
 941         NTSTATUS ret;
 942         TALLOC_CTX *memctx;
 943         struct idmap_ldap_context *ctx;
 944         LDAPMessage *result = NULL;
 945         const char *uidNumber;
 946         const char *gidNumber;
 947         const char **attr_list;
 948         char *filter = NULL;
 949         bool multi = False;
 950         int idx = 0;
 951         int bidx = 0;
 952         int count;
 953         int rc;
 954         int i;
 955
 956         /* Only do query if we are online */
 957         if (idmap_is_offline()) {
 958                 return NT_STATUS_FILE_IS_OFFLINE;
 959         }
 960
 961         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
 962
 963         memctx = talloc_new(ctx);
 964         if ( ! memctx) {
 965                 DEBUG(0, ("Out of memory!\n"));
 966                 return NT_STATUS_NO_MEMORY;
 967         }
 968
 969         uidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_UIDNUMBER);
 970         gidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_GIDNUMBER);
 971
 972         attr_list = get_attr_list(memctx, sidmap_attr_list);
 973
 974         if ( ! ids[1]) {
 975                 /* if we are requested just one mapping use the simple filter */
 976
 977                 filter = talloc_asprintf(memctx, "(&(objectClass=%s)(%s=%s))",
 978                                 LDAP_OBJ_IDMAP_ENTRY,
 979                                 LDAP_ATTRIBUTE_SID,
 980                                 sid_string_talloc(memctx, ids[0]->sid));
 981                 CHECK_ALLOC_DONE(filter);
 982                 DEBUG(10, ("Filter: [%s]\n", filter));
 983         } else {
 984                 /* multiple mappings */
 985                 multi = True;
 986         }
 987
 988         for (i = 0; ids[i]; i++) {
 989                 ids[i]->status = ID_UNKNOWN;
 990         }
 991
 992 again:
 993         if (multi) {
 994
 995                 TALLOC_FREE(filter);
 996                 filter = talloc_asprintf(memctx,
 997                                          "(&(objectClass=%s)(|",
 998                                          LDAP_OBJ_IDMAP_ENTRY);
 999                 CHECK_ALLOC_DONE(filter);
1000
1001                 bidx = idx;
1002                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
1003                         filter = talloc_asprintf_append_buffer(filter, "(%s=%s)",
1004                                         LDAP_ATTRIBUTE_SID,
1005                                         sid_string_talloc(memctx,
1006                                                           ids[idx]->sid));
1007                         CHECK_ALLOC_DONE(filter);
1008                 }
1009                 filter = talloc_asprintf_append_buffer(filter, "))");
1010                 CHECK_ALLOC_DONE(filter);
1011                 DEBUG(10, ("Filter: [%s]", filter));
1012         } else {
1013                 bidx = 0;
1014                 idx = 1;
1015         }
1016
1017         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
1018                 filter, attr_list, 0, &result);
1019
1020         if (rc != LDAP_SUCCESS) {
1021                 DEBUG(3,("Failure looking up sids (%s)\n",
1022                          ldap_err2string(rc)));
1023                 ret = NT_STATUS_UNSUCCESSFUL;
1024                 goto done;
1025         }
1026
1027         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
1028
1029         if (count == 0) {
1030                 DEBUG(10, ("NO SIDs found\n"));
1031         }
1032
1033         for (i = 0; i < count; i++) {
1034                 char *sidstr = NULL;
1035                 char *tmp = NULL;
1036                 enum id_type type;
1037                 struct id_map *map;
1038                 struct dom_sid sid;
1039                 uint32_t id;
1040
1041                 if (i == 0) { /* first entry */
1042                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
1043                                                  result);
1044                 } else { /* following ones */
1045                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
1046                                                 entry);
1047                 }
1048                 if ( ! entry) {
1049                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
1050                                   "from results\n"));
1051                         break;
1052                 }
1053
1054                 /* first check if the SID is present */
1055                 sidstr = smbldap_talloc_single_attribute(
1056                                 ctx->smbldap_state->ldap_struct,
1057                                 entry, LDAP_ATTRIBUTE_SID, memctx);
1058                 if ( ! sidstr) { /* no sid ??, skip entry */
1059                         DEBUG(2, ("WARNING SID not found on entry\n"));
1060                         continue;
1061                 }
1062
1063                 if ( ! string_to_sid(&sid, sidstr)) {
1064                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
1065                         TALLOC_FREE(sidstr);
1066                         continue;
1067                 }
1068
1069                 map = find_map_by_sid(&ids[bidx], &sid);
1070                 if (!map) {
1071                         DEBUG(2, ("WARNING: couldn't find entry sid (%s) "
1072                                   "in ids", sidstr));
1073                         TALLOC_FREE(sidstr);
1074                         continue;
1075                 }
1076
1077                 /* now try to see if it is a uid, if not try with a gid
1078                  * (gid is more common, but in case both uidNumber and
1079                  * gidNumber are returned the SID is mapped to the uid
1080                  * not the gid) */
1081                 type = ID_TYPE_UID;
1082                 tmp = smbldap_talloc_single_attribute(
1083                                 ctx->smbldap_state->ldap_struct,
1084                                 entry, uidNumber, memctx);
1085                 if ( ! tmp) {
1086                         type = ID_TYPE_GID;
1087                         tmp = smbldap_talloc_single_attribute(
1088                                         ctx->smbldap_state->ldap_struct,
1089                                         entry, gidNumber, memctx);
1090                 }
1091                 if ( ! tmp) { /* no ids ?? */
1092                         DEBUG(5, ("no uidNumber, "
1093                                   "nor gidNumber attributes found\n"));
1094                         TALLOC_FREE(sidstr);
1095                         continue;
1096                 }
1097
1098                 id = strtoul(tmp, NULL, 10);
1099                 if (!idmap_unix_id_is_in_range(id, dom)) {
1100                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
1101                                   "Filtered!\n", id,
1102                                   dom->low_id, dom->high_id));
1103                         TALLOC_FREE(sidstr);
1104                         TALLOC_FREE(tmp);
1105                         continue;
1106                 }
1107                 TALLOC_FREE(tmp);
1108
1109                 if (map->status == ID_MAPPED) {
1110                         DEBUG(1, ("WARNING: duplicate %s mapping in LDAP. "
1111                               "overwriting mapping %s -> %u with %s -> %u\n",
1112                               (type == ID_TYPE_UID) ? "UID" : "GID",
1113                               sidstr, map->xid.id, sidstr, id));
1114                 }
1115
1116                 TALLOC_FREE(sidstr);
1117
1118                 /* mapped */
1119                 map->xid.type = type;
1120                 map->xid.id = id;
1121                 map->status = ID_MAPPED;
1122
1123                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
1124                            (unsigned long)map->xid.id, map->xid.type));
1125         }
1126
1127         /* free the ldap results */
1128         if (result) {
1129                 ldap_msgfree(result);
1130                 result = NULL;
1131         }
1132
1133         if (multi && ids[idx]) { /* still some values to map */
1134                 goto again;
1135         }
1136
1137         /*
1138          *  try to create new mappings for unmapped sids
1139          */
1140         for (i = 0; ids[i]; i++) {
1141                 if (ids[i]->status != ID_MAPPED) {
1142                         ids[i]->status = ID_UNMAPPED;
1143                         if (ids[i]->sid != NULL) {
1144                                 ret = idmap_ldap_new_mapping(dom, ids[i]);
1145                                 if (!NT_STATUS_IS_OK(ret)) {
1146                                         goto done;
1147                                 }
1148                         }
1149                 }
1150         }
1151
1152         ret = NT_STATUS_OK;
1153
1154 done:
1155         talloc_free(memctx);
1156         return ret;
1157 }
1158
1159 /**********************************
1160  Close the idmap ldap instance
1161 **********************************/
1162
1163 static NTSTATUS idmap_ldap_close(struct idmap_domain *dom)
1164 {
1165         struct idmap_ldap_context *ctx;
1166
1167         if (dom->private_data) {
1168                 ctx = talloc_get_type(dom->private_data,
1169                                       struct idmap_ldap_context);
1170
1171                 talloc_free(ctx);
1172                 dom->private_data = NULL;
1173         }
1174
1175         return NT_STATUS_OK;
1176 }
1177
1178 static struct idmap_methods idmap_ldap_methods = {
1179
1180         .init = idmap_ldap_db_init,
1181         .unixids_to_sids = idmap_ldap_unixids_to_sids,
1182         .sids_to_unixids = idmap_ldap_sids_to_unixids,
1183         .allocate_id = idmap_ldap_get_new_id,
1184         .close_fn = idmap_ldap_close
1185 };
1186
1187 NTSTATUS idmap_ldap_init(void);
1188 NTSTATUS idmap_ldap_init(void)
1189 {
1190         return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "ldap",
1191                                   &idmap_ldap_methods);
1192 }
1193