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
  11    This program is free software; you can redistribute it and/or modify
  12    it under the terms of the GNU General Public License as published by
  13    the Free Software Foundation; either version 3 of the License, or
  14    (at your option) any later version.
  15
  16    This program is distributed in the hope that it will be useful,
  17    but WITHOUT ANY WARRANTY; without even the implied warranty of
  18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19    GNU General Public License for more details.
  20
  21    You should have received a copy of the GNU General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 #include "includes.h"
  26 #include "winbindd.h"
  27
  28 #undef DBGC_CLASS
  29 #define DBGC_CLASS DBGC_IDMAP
  30
  31 #include <lber.h>
  32 #include <ldap.h>
  33
  34 #include "smbldap.h"
  35
  36 static char *idmap_fetch_secret(const char *backend, bool alloc,
  37                                 const char *domain, const char *identity)
  38 {
  39         char *tmp, *ret;
  40         int r;
  41
  42         if (alloc) {
  43                 r = asprintf(&tmp, "IDMAP_ALLOC_%s", backend);
  44         } else {
  45                 r = asprintf(&tmp, "IDMAP_%s_%s", backend, domain);
  46         }
  47
  48         if (r < 0)
  49                 return NULL;
  50
  51         strupper_m(tmp); /* make sure the key is case insensitive */
  52         ret = secrets_fetch_generic(tmp, identity);
  53
  54         SAFE_FREE(tmp);
  55
  56         return ret;
  57 }
  58
  59 struct idmap_ldap_context {
  60         struct smbldap_state *smbldap_state;
  61         char *url;
  62         char *suffix;
  63         char *user_dn;
  64         uint32_t filter_low_id, filter_high_id;         /* Filter range */
  65         bool anon;
  66 };
  67
  68 struct idmap_ldap_alloc_context {
  69         struct smbldap_state *smbldap_state;
  70         char *url;
  71         char *suffix;
  72         char *user_dn;
  73         uid_t low_uid, high_uid;      /* Range of uids */
  74         gid_t low_gid, high_gid;      /* Range of gids */
  75
  76 };
  77
  78 #define CHECK_ALLOC_DONE(mem) do { \
  79         if (!mem) { \
  80                 DEBUG(0, ("Out of memory!\n")); \
  81                 ret = NT_STATUS_NO_MEMORY; \
  82                 goto done; \
  83         } } while (0)
  84
  85 /**********************************************************************
  86  IDMAP ALLOC TDB BACKEND
  87 **********************************************************************/
  88
  89 static struct idmap_ldap_alloc_context *idmap_alloc_ldap;
  90
  91 /*********************************************************************
  92  ********************************************************************/
  93
  94 static NTSTATUS get_credentials( TALLOC_CTX *mem_ctx,
  95                                  struct smbldap_state *ldap_state,
  96                                  const char *config_option,
  97                                  struct idmap_domain *dom,
  98                                  char **dn )
  99 {
 100         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 101         char *secret = NULL;
 102         const char *tmp = NULL;
 103         char *user_dn = NULL;
 104         bool anon = False;
 105
 106         /* assume anonymous if we don't have a specified user */
 107
 108         tmp = lp_parm_const_string(-1, config_option, "ldap_user_dn", NULL);
 109
 110         if ( tmp ) {
 111                 if (!dom) {
 112                         /* only the alloc backend can pass in a NULL dom */
 113                         secret = idmap_fetch_secret("ldap", True,
 114                                                     NULL, tmp);
 115                 } else {
 116                         secret = idmap_fetch_secret("ldap", False,
 117                                                     dom->name, tmp);
 118                 }
 119
 120                 if (!secret) {
 121                         DEBUG(0, ("get_credentials: Unable to fetch "
 122                                   "auth credentials for %s in %s\n",
 123                                   tmp, (dom==NULL)?"ALLOC":dom->name));
 124                         ret = NT_STATUS_ACCESS_DENIED;
 125                         goto done;
 126                 }
 127                 *dn = talloc_strdup(mem_ctx, tmp);
 128                 CHECK_ALLOC_DONE(*dn);
 129         } else {
 130                 if (!fetch_ldap_pw(&user_dn, &secret)) {
 131                         DEBUG(2, ("get_credentials: Failed to lookup ldap "
 132                                   "bind creds. Using anonymous connection.\n"));
 133                         anon = True;
 134                 } else {
 135                         *dn = talloc_strdup(mem_ctx, user_dn);
 136                         SAFE_FREE( user_dn );
 137                         CHECK_ALLOC_DONE(*dn);
 138                 }
 139         }
 140
 141         smbldap_set_creds(ldap_state, anon, *dn, secret);
 142         ret = NT_STATUS_OK;
 143
 144 done:
 145         SAFE_FREE(secret);
 146
 147         return ret;
 148 }
 149
 150
 151 /**********************************************************************
 152  Verify the sambaUnixIdPool entry in the directory.
 153 **********************************************************************/
 154
 155 static NTSTATUS verify_idpool(void)
 156 {
 157         NTSTATUS ret;
 158         TALLOC_CTX *ctx;
 159         LDAPMessage *result = NULL;
 160         LDAPMod **mods = NULL;
 161         const char **attr_list;
 162         char *filter;
 163         int count;
 164         int rc;
 165
 166         if ( ! idmap_alloc_ldap) {
 167                 return NT_STATUS_UNSUCCESSFUL;
 168         }
 169
 170         ctx = talloc_new(idmap_alloc_ldap);
 171         if ( ! ctx) {
 172                 DEBUG(0, ("Out of memory!\n"));
 173                 return NT_STATUS_NO_MEMORY;
 174         }
 175
 176         filter = talloc_asprintf(ctx, "(objectclass=%s)", LDAP_OBJ_IDPOOL);
 177         CHECK_ALLOC_DONE(filter);
 178
 179         attr_list = get_attr_list(ctx, idpool_attr_list);
 180         CHECK_ALLOC_DONE(attr_list);
 181
 182         rc = smbldap_search(idmap_alloc_ldap->smbldap_state,
 183                                 idmap_alloc_ldap->suffix,
 184                                 LDAP_SCOPE_SUBTREE,
 185                                 filter,
 186                                 attr_list,
 187                                 0,
 188                                 &result);
 189
 190         if (rc != LDAP_SUCCESS) {
 191                 DEBUG(1, ("Unable to verify the idpool, "
 192                           "cannot continue initialization!\n"));
 193                 return NT_STATUS_UNSUCCESSFUL;
 194         }
 195
 196         count = ldap_count_entries(idmap_alloc_ldap->smbldap_state->ldap_struct,
 197                                    result);
 198
 199         ldap_msgfree(result);
 200
 201         if ( count > 1 ) {
 202                 DEBUG(0,("Multiple entries returned from %s (base == %s)\n",
 203                         filter, idmap_alloc_ldap->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(ctx, "%lu",
 211                                 (unsigned long)idmap_alloc_ldap->low_uid);
 212                 gid_str = talloc_asprintf(ctx, "%lu",
 213                                 (unsigned long)idmap_alloc_ldap->low_gid);
 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(idmap_alloc_ldap->smbldap_state,
 227                                                 idmap_alloc_ldap->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(ctx);
 239         return ret;
 240 }
 241
 242 /*****************************************************************************
 243  Initialise idmap database.
 244 *****************************************************************************/
 245
 246 static NTSTATUS idmap_ldap_alloc_init(const char *params)
 247 {
 248         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 249         const char *tmp;
 250         uid_t low_uid = 0;
 251         uid_t high_uid = 0;
 252         gid_t low_gid = 0;
 253         gid_t high_gid = 0;
 254
 255         /* Only do init if we are online */
 256         if (idmap_is_offline()) {
 257                 return NT_STATUS_FILE_IS_OFFLINE;
 258         }
 259
 260         idmap_alloc_ldap = TALLOC_ZERO_P(NULL, struct idmap_ldap_alloc_context);
 261         CHECK_ALLOC_DONE( idmap_alloc_ldap );
 262
 263         /* load ranges */
 264
 265         if (!lp_idmap_uid(&low_uid, &high_uid)
 266             || !lp_idmap_gid(&low_gid, &high_gid)) {
 267                 DEBUG(1, ("idmap uid or idmap gid missing\n"));
 268                 ret = NT_STATUS_UNSUCCESSFUL;
 269                 goto done;
 270         }
 271
 272         idmap_alloc_ldap->low_uid = low_uid;
 273         idmap_alloc_ldap->high_uid = high_uid;
 274         idmap_alloc_ldap->low_gid = low_gid;
 275         idmap_alloc_ldap->high_gid= high_gid;
 276
 277         if (idmap_alloc_ldap->high_uid <= idmap_alloc_ldap->low_uid) {
 278                 DEBUG(1, ("idmap uid range invalid\n"));
 279                 DEBUGADD(1, ("idmap will be unable to map foreign SIDs\n"));
 280                 ret = NT_STATUS_UNSUCCESSFUL;
 281                 goto done;
 282         }
 283
 284         if (idmap_alloc_ldap->high_gid <= idmap_alloc_ldap->low_gid) {
 285                 DEBUG(1, ("idmap gid range invalid\n"));
 286                 DEBUGADD(1, ("idmap will be unable to map foreign SIDs\n"));
 287                 ret = NT_STATUS_UNSUCCESSFUL;
 288                 goto done;
 289         }
 290
 291         if (params && *params) {
 292                 /* assume location is the only parameter */
 293                 idmap_alloc_ldap->url = talloc_strdup(idmap_alloc_ldap, params);
 294         } else {
 295                 tmp = lp_parm_const_string(-1, "idmap alloc config",
 296                                            "ldap_url", NULL);
 297
 298                 if ( ! tmp) {
 299                         DEBUG(1, ("ERROR: missing idmap ldap url\n"));
 300                         ret = NT_STATUS_UNSUCCESSFUL;
 301                         goto done;
 302                 }
 303
 304                 idmap_alloc_ldap->url = talloc_strdup(idmap_alloc_ldap, tmp);
 305         }
 306         CHECK_ALLOC_DONE( idmap_alloc_ldap->url );
 307
 308         tmp = lp_parm_const_string(-1, "idmap alloc config",
 309                                    "ldap_base_dn", NULL);
 310         if ( ! tmp || ! *tmp) {
 311                 tmp = lp_ldap_idmap_suffix();
 312                 if ( ! tmp) {
 313                         DEBUG(1, ("ERROR: missing idmap ldap suffix\n"));
 314                         ret = NT_STATUS_UNSUCCESSFUL;
 315                         goto done;
 316                 }
 317         }
 318
 319         idmap_alloc_ldap->suffix = talloc_strdup(idmap_alloc_ldap, tmp);
 320         CHECK_ALLOC_DONE( idmap_alloc_ldap->suffix );
 321
 322         ret = smbldap_init(idmap_alloc_ldap, winbind_event_context(),
 323                            idmap_alloc_ldap->url,
 324                            &idmap_alloc_ldap->smbldap_state);
 325         if (!NT_STATUS_IS_OK(ret)) {
 326                 DEBUG(1, ("ERROR: smbldap_init (%s) failed!\n",
 327                           idmap_alloc_ldap->url));
 328                 goto done;
 329         }
 330
 331         ret = get_credentials( idmap_alloc_ldap,
 332                                idmap_alloc_ldap->smbldap_state,
 333                                "idmap alloc config", NULL,
 334                                &idmap_alloc_ldap->user_dn );
 335         if ( !NT_STATUS_IS_OK(ret) ) {
 336                 DEBUG(1,("idmap_ldap_alloc_init: Failed to get connection "
 337                          "credentials (%s)\n", nt_errstr(ret)));
 338                 goto done;
 339         }
 340
 341         /* see if the idmap suffix and sub entries exists */
 342
 343         ret = verify_idpool();
 344
 345  done:
 346         if ( !NT_STATUS_IS_OK( ret ) )
 347                 TALLOC_FREE( idmap_alloc_ldap );
 348
 349         return ret;
 350 }
 351
 352 /********************************
 353  Allocate a new uid or gid
 354 ********************************/
 355
 356 static NTSTATUS idmap_ldap_allocate_id(struct unixid *xid)
 357 {
 358         TALLOC_CTX *ctx;
 359         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 360         int rc = LDAP_SERVER_DOWN;
 361         int count = 0;
 362         LDAPMessage *result = NULL;
 363         LDAPMessage *entry = NULL;
 364         LDAPMod **mods = NULL;
 365         char *id_str;
 366         char *new_id_str;
 367         char *filter = NULL;
 368         const char *dn = NULL;
 369         const char **attr_list;
 370         const char *type;
 371
 372         /* Only do query if we are online */
 373         if (idmap_is_offline()) {
 374                 return NT_STATUS_FILE_IS_OFFLINE;
 375         }
 376
 377         if ( ! idmap_alloc_ldap) {
 378                 return NT_STATUS_UNSUCCESSFUL;
 379         }
 380
 381         ctx = talloc_new(idmap_alloc_ldap);
 382         if ( ! ctx) {
 383                 DEBUG(0, ("Out of memory!\n"));
 384                 return NT_STATUS_NO_MEMORY;
 385         }
 386
 387         /* get type */
 388         switch (xid->type) {
 389
 390         case ID_TYPE_UID:
 391                 type = get_attr_key2string(idpool_attr_list,
 392                                            LDAP_ATTR_UIDNUMBER);
 393                 break;
 394
 395         case ID_TYPE_GID:
 396                 type = get_attr_key2string(idpool_attr_list,
 397                                            LDAP_ATTR_GIDNUMBER);
 398                 break;
 399
 400         default:
 401                 DEBUG(2, ("Invalid ID type (0x%x)\n", xid->type));
 402                 return NT_STATUS_INVALID_PARAMETER;
 403         }
 404
 405         filter = talloc_asprintf(ctx, "(objectClass=%s)", LDAP_OBJ_IDPOOL);
 406         CHECK_ALLOC_DONE(filter);
 407
 408         attr_list = get_attr_list(ctx, idpool_attr_list);
 409         CHECK_ALLOC_DONE(attr_list);
 410
 411         DEBUG(10, ("Search of the id pool (filter: %s)\n", filter));
 412
 413         rc = smbldap_search(idmap_alloc_ldap->smbldap_state,
 414                                 idmap_alloc_ldap->suffix,
 415                                LDAP_SCOPE_SUBTREE, filter,
 416                                attr_list, 0, &result);
 417
 418         if (rc != LDAP_SUCCESS) {
 419                 DEBUG(0,("%s object not found\n", LDAP_OBJ_IDPOOL));
 420                 goto done;
 421         }
 422
 423         talloc_autofree_ldapmsg(ctx, result);
 424
 425         count = ldap_count_entries(idmap_alloc_ldap->smbldap_state->ldap_struct,
 426                                    result);
 427         if (count != 1) {
 428                 DEBUG(0,("Single %s object not found\n", LDAP_OBJ_IDPOOL));
 429                 goto done;
 430         }
 431
 432         entry = ldap_first_entry(idmap_alloc_ldap->smbldap_state->ldap_struct,
 433                                  result);
 434
 435         dn = smbldap_talloc_dn(ctx,
 436                                idmap_alloc_ldap->smbldap_state->ldap_struct,
 437                                entry);
 438         if ( ! dn) {
 439                 goto done;
 440         }
 441
 442         if ( ! (id_str = smbldap_talloc_single_attribute(idmap_alloc_ldap->smbldap_state->ldap_struct,
 443                                 entry, type, ctx))) {
 444                 DEBUG(0,("%s attribute not found\n", type));
 445                 goto done;
 446         }
 447         if ( ! id_str) {
 448                 DEBUG(0,("Out of memory\n"));
 449                 ret = NT_STATUS_NO_MEMORY;
 450                 goto done;
 451         }
 452
 453         xid->id = strtoul(id_str, NULL, 10);
 454
 455         /* make sure we still have room to grow */
 456
 457         switch (xid->type) {
 458         case ID_TYPE_UID:
 459                 if (xid->id > idmap_alloc_ldap->high_uid) {
 460                         DEBUG(0,("Cannot allocate uid above %lu!\n",
 461                                  (unsigned long)idmap_alloc_ldap->high_uid));
 462                         goto done;
 463                 }
 464                 break;
 465
 466         case ID_TYPE_GID:
 467                 if (xid->id > idmap_alloc_ldap->high_gid) {
 468                         DEBUG(0,("Cannot allocate gid above %lu!\n",
 469                                  (unsigned long)idmap_alloc_ldap->high_uid));
 470                         goto done;
 471                 }
 472                 break;
 473
 474         default:
 475                 /* impossible */
 476                 goto done;
 477         }
 478
 479         new_id_str = talloc_asprintf(ctx, "%lu", (unsigned long)xid->id + 1);
 480         if ( ! new_id_str) {
 481                 DEBUG(0,("Out of memory\n"));
 482                 ret = NT_STATUS_NO_MEMORY;
 483                 goto done;
 484         }
 485
 486         smbldap_set_mod(&mods, LDAP_MOD_DELETE, type, id_str);
 487         smbldap_set_mod(&mods, LDAP_MOD_ADD, type, new_id_str);
 488
 489         if (mods == NULL) {
 490                 DEBUG(0,("smbldap_set_mod() failed.\n"));
 491                 goto done;
 492         }
 493
 494         DEBUG(10, ("Try to atomically increment the id (%s -> %s)\n",
 495                    id_str, new_id_str));
 496
 497         rc = smbldap_modify(idmap_alloc_ldap->smbldap_state, dn, mods);
 498
 499         ldap_mods_free(mods, True);
 500
 501         if (rc != LDAP_SUCCESS) {
 502                 DEBUG(1,("Failed to allocate new %s. "
 503                          "smbldap_modify() failed.\n", type));
 504                 goto done;
 505         }
 506
 507         ret = NT_STATUS_OK;
 508
 509 done:
 510         talloc_free(ctx);
 511         return ret;
 512 }
 513
 514 /**********************************
 515  Get current highest id.
 516 **********************************/
 517
 518 static NTSTATUS idmap_ldap_get_hwm(struct unixid *xid)
 519 {
 520         TALLOC_CTX *memctx;
 521         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 522         int rc = LDAP_SERVER_DOWN;
 523         int count = 0;
 524         LDAPMessage *result = NULL;
 525         LDAPMessage *entry = NULL;
 526         char *id_str;
 527         char *filter = NULL;
 528         const char **attr_list;
 529         const char *type;
 530
 531         /* Only do query if we are online */
 532         if (idmap_is_offline()) {
 533                 return NT_STATUS_FILE_IS_OFFLINE;
 534         }
 535
 536         if ( ! idmap_alloc_ldap) {
 537                 return NT_STATUS_UNSUCCESSFUL;
 538         }
 539
 540         memctx = talloc_new(idmap_alloc_ldap);
 541         if ( ! memctx) {
 542                 DEBUG(0, ("Out of memory!\n"));
 543                 return NT_STATUS_NO_MEMORY;
 544         }
 545
 546         /* get type */
 547         switch (xid->type) {
 548
 549         case ID_TYPE_UID:
 550                 type = get_attr_key2string(idpool_attr_list,
 551                                            LDAP_ATTR_UIDNUMBER);
 552                 break;
 553
 554         case ID_TYPE_GID:
 555                 type = get_attr_key2string(idpool_attr_list,
 556                                            LDAP_ATTR_GIDNUMBER);
 557                 break;
 558
 559         default:
 560                 DEBUG(2, ("Invalid ID type (0x%x)\n", xid->type));
 561                 return NT_STATUS_INVALID_PARAMETER;
 562         }
 563
 564         filter = talloc_asprintf(memctx, "(objectClass=%s)", LDAP_OBJ_IDPOOL);
 565         CHECK_ALLOC_DONE(filter);
 566
 567         attr_list = get_attr_list(memctx, idpool_attr_list);
 568         CHECK_ALLOC_DONE(attr_list);
 569
 570         rc = smbldap_search(idmap_alloc_ldap->smbldap_state,
 571                                 idmap_alloc_ldap->suffix,
 572                                LDAP_SCOPE_SUBTREE, filter,
 573                                attr_list, 0, &result);
 574
 575         if (rc != LDAP_SUCCESS) {
 576                 DEBUG(0,("%s object not found\n", LDAP_OBJ_IDPOOL));
 577                 goto done;
 578         }
 579
 580         talloc_autofree_ldapmsg(memctx, result);
 581
 582         count = ldap_count_entries(idmap_alloc_ldap->smbldap_state->ldap_struct,
 583                                    result);
 584         if (count != 1) {
 585                 DEBUG(0,("Single %s object not found\n", LDAP_OBJ_IDPOOL));
 586                 goto done;
 587         }
 588
 589         entry = ldap_first_entry(idmap_alloc_ldap->smbldap_state->ldap_struct,
 590                                  result);
 591
 592         id_str = smbldap_talloc_single_attribute(idmap_alloc_ldap->smbldap_state->ldap_struct,
 593                         entry, type, memctx);
 594         if ( ! id_str) {
 595                 DEBUG(0,("%s attribute not found\n", type));
 596                 goto done;
 597         }
 598         if ( ! id_str) {
 599                 DEBUG(0,("Out of memory\n"));
 600                 ret = NT_STATUS_NO_MEMORY;
 601                 goto done;
 602         }
 603
 604         xid->id = strtoul(id_str, NULL, 10);
 605
 606         ret = NT_STATUS_OK;
 607 done:
 608         talloc_free(memctx);
 609         return ret;
 610 }
 611 /**********************************
 612  Set highest id.
 613 **********************************/
 614
 615 static NTSTATUS idmap_ldap_set_hwm(struct unixid *xid)
 616 {
 617         TALLOC_CTX *ctx;
 618         NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
 619         int rc = LDAP_SERVER_DOWN;
 620         int count = 0;
 621         LDAPMessage *result = NULL;
 622         LDAPMessage *entry = NULL;
 623         LDAPMod **mods = NULL;
 624         char *new_id_str;
 625         char *filter = NULL;
 626         const char *dn = NULL;
 627         const char **attr_list;
 628         const char *type;
 629
 630         /* Only do query if we are online */
 631         if (idmap_is_offline()) {
 632                 return NT_STATUS_FILE_IS_OFFLINE;
 633         }
 634
 635         if ( ! idmap_alloc_ldap) {
 636                 return NT_STATUS_UNSUCCESSFUL;
 637         }
 638
 639         ctx = talloc_new(idmap_alloc_ldap);
 640         if ( ! ctx) {
 641                 DEBUG(0, ("Out of memory!\n"));
 642                 return NT_STATUS_NO_MEMORY;
 643         }
 644
 645         /* get type */
 646         switch (xid->type) {
 647
 648         case ID_TYPE_UID:
 649                 type = get_attr_key2string(idpool_attr_list,
 650                                            LDAP_ATTR_UIDNUMBER);
 651                 break;
 652
 653         case ID_TYPE_GID:
 654                 type = get_attr_key2string(idpool_attr_list,
 655                                            LDAP_ATTR_GIDNUMBER);
 656                 break;
 657
 658         default:
 659                 DEBUG(2, ("Invalid ID type (0x%x)\n", xid->type));
 660                 return NT_STATUS_INVALID_PARAMETER;
 661         }
 662
 663         filter = talloc_asprintf(ctx, "(objectClass=%s)", LDAP_OBJ_IDPOOL);
 664         CHECK_ALLOC_DONE(filter);
 665
 666         attr_list = get_attr_list(ctx, idpool_attr_list);
 667         CHECK_ALLOC_DONE(attr_list);
 668
 669         rc = smbldap_search(idmap_alloc_ldap->smbldap_state,
 670                                 idmap_alloc_ldap->suffix,
 671                                LDAP_SCOPE_SUBTREE, filter,
 672                                attr_list, 0, &result);
 673
 674         if (rc != LDAP_SUCCESS) {
 675                 DEBUG(0,("%s object not found\n", LDAP_OBJ_IDPOOL));
 676                 goto done;
 677         }
 678
 679         talloc_autofree_ldapmsg(ctx, result);
 680
 681         count = ldap_count_entries(idmap_alloc_ldap->smbldap_state->ldap_struct,
 682                                    result);
 683         if (count != 1) {
 684                 DEBUG(0,("Single %s object not found\n", LDAP_OBJ_IDPOOL));
 685                 goto done;
 686         }
 687
 688         entry = ldap_first_entry(idmap_alloc_ldap->smbldap_state->ldap_struct,
 689                                  result);
 690
 691         dn = smbldap_talloc_dn(ctx,
 692                                 idmap_alloc_ldap->smbldap_state->ldap_struct,
 693                                 entry);
 694         if ( ! dn) {
 695                 goto done;
 696         }
 697
 698         new_id_str = talloc_asprintf(ctx, "%lu", (unsigned long)xid->id);
 699         if ( ! new_id_str) {
 700                 DEBUG(0,("Out of memory\n"));
 701                 ret = NT_STATUS_NO_MEMORY;
 702                 goto done;
 703         }
 704
 705         smbldap_set_mod(&mods, LDAP_MOD_REPLACE, type, new_id_str);
 706
 707         if (mods == NULL) {
 708                 DEBUG(0,("smbldap_set_mod() failed.\n"));
 709                 goto done;
 710         }
 711
 712         rc = smbldap_modify(idmap_alloc_ldap->smbldap_state, dn, mods);
 713
 714         ldap_mods_free(mods, True);
 715
 716         if (rc != LDAP_SUCCESS) {
 717                 DEBUG(1,("Failed to allocate new %s. "
 718                          "smbldap_modify() failed.\n", type));
 719                 goto done;
 720         }
 721
 722         ret = NT_STATUS_OK;
 723
 724 done:
 725         talloc_free(ctx);
 726         return ret;
 727 }
 728
 729 /**********************************
 730  Close idmap ldap alloc
 731 **********************************/
 732
 733 static NTSTATUS idmap_ldap_alloc_close(void)
 734 {
 735         if (idmap_alloc_ldap) {
 736                 smbldap_free_struct(&idmap_alloc_ldap->smbldap_state);
 737                 DEBUG(5,("The connection to the LDAP server was closed\n"));
 738                 /* maybe free the results here --metze */
 739                 TALLOC_FREE(idmap_alloc_ldap);
 740         }
 741         return NT_STATUS_OK;
 742 }
 743
 744
 745 /**********************************************************************
 746  IDMAP MAPPING LDAP BACKEND
 747 **********************************************************************/
 748
 749 static int idmap_ldap_close_destructor(struct idmap_ldap_context *ctx)
 750 {
 751         smbldap_free_struct(&ctx->smbldap_state);
 752         DEBUG(5,("The connection to the LDAP server was closed\n"));
 753         /* maybe free the results here --metze */
 754
 755         return 0;
 756 }
 757
 758 /********************************
 759  Initialise idmap database.
 760 ********************************/
 761
 762 static NTSTATUS idmap_ldap_db_init(struct idmap_domain *dom,
 763                                    const char *params)
 764 {
 765         NTSTATUS ret;
 766         struct idmap_ldap_context *ctx = NULL;
 767         char *config_option = NULL;
 768         const char *range = NULL;
 769         const char *tmp = NULL;
 770
 771         /* Only do init if we are online */
 772         if (idmap_is_offline()) {
 773                 return NT_STATUS_FILE_IS_OFFLINE;
 774         }
 775
 776         ctx = TALLOC_ZERO_P(dom, struct idmap_ldap_context);
 777         if ( ! ctx) {
 778                 DEBUG(0, ("Out of memory!\n"));
 779                 return NT_STATUS_NO_MEMORY;
 780         }
 781
 782         config_option = talloc_asprintf(ctx, "idmap config %s", dom->name);
 783         if ( ! config_option) {
 784                 DEBUG(0, ("Out of memory!\n"));
 785                 ret = NT_STATUS_NO_MEMORY;
 786                 goto done;
 787         }
 788
 789         /* load ranges */
 790         range = lp_parm_const_string(-1, config_option, "range", NULL);
 791         if (range && range[0]) {
 792                 if ((sscanf(range, "%u - %u", &ctx->filter_low_id,
 793                                                 &ctx->filter_high_id) != 2) ||
 794                     (ctx->filter_low_id > ctx->filter_high_id)) {
 795                         DEBUG(1, ("ERROR: invalid filter range [%s]", range));
 796                         ctx->filter_low_id = 0;
 797                         ctx->filter_high_id = 0;
 798                 }
 799         }
 800
 801         if (params != NULL) {
 802                 /* assume location is the only parameter */
 803                 ctx->url = talloc_strdup(ctx, params);
 804         } else {
 805                 tmp = lp_parm_const_string(-1, config_option, "ldap_url", NULL);
 806
 807                 if ( ! tmp) {
 808                         DEBUG(1, ("ERROR: missing idmap ldap url\n"));
 809                         ret = NT_STATUS_UNSUCCESSFUL;
 810                         goto done;
 811                 }
 812
 813                 ctx->url = talloc_strdup(ctx, tmp);
 814         }
 815         CHECK_ALLOC_DONE(ctx->url);
 816
 817         tmp = lp_parm_const_string(-1, config_option, "ldap_base_dn", NULL);
 818         if ( ! tmp || ! *tmp) {
 819                 tmp = lp_ldap_idmap_suffix();
 820                 if ( ! tmp) {
 821                         DEBUG(1, ("ERROR: missing idmap ldap suffix\n"));
 822                         ret = NT_STATUS_UNSUCCESSFUL;
 823                         goto done;
 824                 }
 825         }
 826
 827         ctx->suffix = talloc_strdup(ctx, tmp);
 828         CHECK_ALLOC_DONE(ctx->suffix);
 829
 830         ret = smbldap_init(ctx, winbind_event_context(), ctx->url,
 831                            &ctx->smbldap_state);
 832         if (!NT_STATUS_IS_OK(ret)) {
 833                 DEBUG(1, ("ERROR: smbldap_init (%s) failed!\n", ctx->url));
 834                 goto done;
 835         }
 836
 837         ret = get_credentials( ctx, ctx->smbldap_state, config_option,
 838                                dom, &ctx->user_dn );
 839         if ( !NT_STATUS_IS_OK(ret) ) {
 840                 DEBUG(1,("idmap_ldap_db_init: Failed to get connection "
 841                          "credentials (%s)\n", nt_errstr(ret)));
 842                 goto done;
 843         }
 844
 845         /* set the destructor on the context, so that resource are properly
 846            freed if the contexts is released */
 847
 848         talloc_set_destructor(ctx, idmap_ldap_close_destructor);
 849
 850         dom->private_data = ctx;
 851
 852         talloc_free(config_option);
 853         return NT_STATUS_OK;
 854
 855 /*failed */
 856 done:
 857         talloc_free(ctx);
 858         return ret;
 859 }
 860
 861 /* max number of ids requested per batch query */
 862 #define IDMAP_LDAP_MAX_IDS 30
 863
 864 /**********************************
 865  lookup a set of unix ids.
 866 **********************************/
 867
 868 /* this function searches up to IDMAP_LDAP_MAX_IDS entries
 869  * in maps for a match */
 870 static struct id_map *find_map_by_id(struct id_map **maps,
 871                                      enum id_type type,
 872                                      uint32_t id)
 873 {
 874         int i;
 875
 876         for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
 877                 if (maps[i] == NULL) { /* end of the run */
 878                         return NULL;
 879                 }
 880                 if ((maps[i]->xid.type == type) && (maps[i]->xid.id == id)) {
 881                         return maps[i];
 882                 }
 883         }
 884
 885         return NULL;
 886 }
 887
 888 static NTSTATUS idmap_ldap_unixids_to_sids(struct idmap_domain *dom,
 889                                            struct id_map **ids)
 890 {
 891         NTSTATUS ret;
 892         TALLOC_CTX *memctx;
 893         struct idmap_ldap_context *ctx;
 894         LDAPMessage *result = NULL;
 895         const char *uidNumber;
 896         const char *gidNumber;
 897         const char **attr_list;
 898         char *filter = NULL;
 899         bool multi = False;
 900         int idx = 0;
 901         int bidx = 0;
 902         int count;
 903         int rc;
 904         int i;
 905
 906         /* Only do query if we are online */
 907         if (idmap_is_offline()) {
 908                 return NT_STATUS_FILE_IS_OFFLINE;
 909         }
 910
 911         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
 912
 913         memctx = talloc_new(ctx);
 914         if ( ! memctx) {
 915                 DEBUG(0, ("Out of memory!\n"));
 916                 return NT_STATUS_NO_MEMORY;
 917         }
 918
 919         uidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_UIDNUMBER);
 920         gidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_GIDNUMBER);
 921
 922         attr_list = get_attr_list(memctx, sidmap_attr_list);
 923
 924         if ( ! ids[1]) {
 925                 /* if we are requested just one mapping use the simple filter */
 926
 927                 filter = talloc_asprintf(memctx, "(&(objectClass=%s)(%s=%lu))",
 928                                 LDAP_OBJ_IDMAP_ENTRY,
 929                                 (ids[0]->xid.type==ID_TYPE_UID)?uidNumber:gidNumber,
 930                                 (unsigned long)ids[0]->xid.id);
 931                 CHECK_ALLOC_DONE(filter);
 932                 DEBUG(10, ("Filter: [%s]\n", filter));
 933         } else {
 934                 /* multiple mappings */
 935                 multi = True;
 936         }
 937
 938         for (i = 0; ids[i]; i++) {
 939                 ids[i]->status = ID_UNKNOWN;
 940         }
 941
 942 again:
 943         if (multi) {
 944
 945                 talloc_free(filter);
 946                 filter = talloc_asprintf(memctx,
 947                                          "(&(objectClass=%s)(|",
 948                                          LDAP_OBJ_IDMAP_ENTRY);
 949                 CHECK_ALLOC_DONE(filter);
 950
 951                 bidx = idx;
 952                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
 953                         filter = talloc_asprintf_append_buffer(filter, "(%s=%lu)",
 954                                         (ids[idx]->xid.type==ID_TYPE_UID)?uidNumber:gidNumber,
 955                                         (unsigned long)ids[idx]->xid.id);
 956                         CHECK_ALLOC_DONE(filter);
 957                 }
 958                 filter = talloc_asprintf_append_buffer(filter, "))");
 959                 CHECK_ALLOC_DONE(filter);
 960                 DEBUG(10, ("Filter: [%s]\n", filter));
 961         } else {
 962                 bidx = 0;
 963                 idx = 1;
 964         }
 965
 966         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
 967                 filter, attr_list, 0, &result);
 968
 969         if (rc != LDAP_SUCCESS) {
 970                 DEBUG(3,("Failure looking up ids (%s)\n", ldap_err2string(rc)));
 971                 ret = NT_STATUS_UNSUCCESSFUL;
 972                 goto done;
 973         }
 974
 975         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
 976
 977         if (count == 0) {
 978                 DEBUG(10, ("NO SIDs found\n"));
 979         }
 980
 981         for (i = 0; i < count; i++) {
 982                 LDAPMessage *entry = NULL;
 983                 char *sidstr = NULL;
 984                 char *tmp = NULL;
 985                 enum id_type type;
 986                 struct id_map *map;
 987                 uint32_t id;
 988
 989                 if (i == 0) { /* first entry */
 990                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
 991                                                  result);
 992                 } else { /* following ones */
 993                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
 994                                                 entry);
 995                 }
 996                 if ( ! entry) {
 997                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
 998                                   "from results\n"));
 999                         break;
1000                 }
1001
1002                 /* first check if the SID is present */
1003                 sidstr = smbldap_talloc_single_attribute(
1004                                 ctx->smbldap_state->ldap_struct,
1005                                 entry, LDAP_ATTRIBUTE_SID, memctx);
1006                 if ( ! sidstr) { /* no sid, skip entry */
1007                         DEBUG(2, ("WARNING SID not found on entry\n"));
1008                         continue;
1009                 }
1010
1011                 /* now try to see if it is a uid, if not try with a gid
1012                  * (gid is more common, but in case both uidNumber and
1013                  * gidNumber are returned the SID is mapped to the uid
1014                  *not the gid) */
1015                 type = ID_TYPE_UID;
1016                 tmp = smbldap_talloc_single_attribute(
1017                                 ctx->smbldap_state->ldap_struct,
1018                                 entry, uidNumber, memctx);
1019                 if ( ! tmp) {
1020                         type = ID_TYPE_GID;
1021                         tmp = smbldap_talloc_single_attribute(
1022                                         ctx->smbldap_state->ldap_struct,
1023                                         entry, gidNumber, memctx);
1024                 }
1025                 if ( ! tmp) { /* wow very strange entry, how did it match ? */
1026                         DEBUG(5, ("Unprobable match on (%s), no uidNumber, "
1027                                   "nor gidNumber returned\n", sidstr));
1028                         TALLOC_FREE(sidstr);
1029                         continue;
1030                 }
1031
1032                 id = strtoul(tmp, NULL, 10);
1033                 if ((id == 0) ||
1034                     (ctx->filter_low_id && (id < ctx->filter_low_id)) ||
1035                     (ctx->filter_high_id && (id > ctx->filter_high_id))) {
1036                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
1037                                   "Filtered!\n", id,
1038                                   ctx->filter_low_id, ctx->filter_high_id));
1039                         TALLOC_FREE(sidstr);
1040                         TALLOC_FREE(tmp);
1041                         continue;
1042                 }
1043                 TALLOC_FREE(tmp);
1044
1045                 map = find_map_by_id(&ids[bidx], type, id);
1046                 if (!map) {
1047                         DEBUG(2, ("WARNING: couldn't match sid (%s) "
1048                                   "with requested ids\n", sidstr));
1049                         TALLOC_FREE(sidstr);
1050                         continue;
1051                 }
1052
1053                 if ( ! string_to_sid(map->sid, sidstr)) {
1054                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
1055                         TALLOC_FREE(sidstr);
1056                         continue;
1057                 }
1058                 TALLOC_FREE(sidstr);
1059
1060                 /* mapped */
1061                 map->status = ID_MAPPED;
1062
1063                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
1064                            (unsigned long)map->xid.id, map->xid.type));
1065         }
1066
1067         /* free the ldap results */
1068         if (result) {
1069                 ldap_msgfree(result);
1070                 result = NULL;
1071         }
1072
1073         if (multi && ids[idx]) { /* still some values to map */
1074                 goto again;
1075         }
1076
1077         ret = NT_STATUS_OK;
1078
1079         /* mark all unknwon/expired ones as unmapped */
1080         for (i = 0; ids[i]; i++) {
1081                 if (ids[i]->status != ID_MAPPED)
1082                         ids[i]->status = ID_UNMAPPED;
1083         }
1084
1085 done:
1086         talloc_free(memctx);
1087         return ret;
1088 }
1089
1090 /**********************************
1091  lookup a set of sids.
1092 **********************************/
1093
1094 /* this function searches up to IDMAP_LDAP_MAX_IDS entries
1095  * in maps for a match */
1096 static struct id_map *find_map_by_sid(struct id_map **maps, DOM_SID *sid)
1097 {
1098         int i;
1099
1100         for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
1101                 if (maps[i] == NULL) { /* end of the run */
1102                         return NULL;
1103                 }
1104                 if (sid_equal(maps[i]->sid, sid)) {
1105                         return maps[i];
1106                 }
1107         }
1108
1109         return NULL;
1110 }
1111
1112 static NTSTATUS idmap_ldap_sids_to_unixids(struct idmap_domain *dom,
1113                                            struct id_map **ids)
1114 {
1115         LDAPMessage *entry = NULL;
1116         NTSTATUS ret;
1117         TALLOC_CTX *memctx;
1118         struct idmap_ldap_context *ctx;
1119         LDAPMessage *result = NULL;
1120         const char *uidNumber;
1121         const char *gidNumber;
1122         const char **attr_list;
1123         char *filter = NULL;
1124         bool multi = False;
1125         int idx = 0;
1126         int bidx = 0;
1127         int count;
1128         int rc;
1129         int i;
1130
1131         /* Only do query if we are online */
1132         if (idmap_is_offline()) {
1133                 return NT_STATUS_FILE_IS_OFFLINE;
1134         }
1135
1136         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
1137
1138         memctx = talloc_new(ctx);
1139         if ( ! memctx) {
1140                 DEBUG(0, ("Out of memory!\n"));
1141                 return NT_STATUS_NO_MEMORY;
1142         }
1143
1144         uidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_UIDNUMBER);
1145         gidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_GIDNUMBER);
1146
1147         attr_list = get_attr_list(memctx, sidmap_attr_list);
1148
1149         if ( ! ids[1]) {
1150                 /* if we are requested just one mapping use the simple filter */
1151
1152                 filter = talloc_asprintf(memctx, "(&(objectClass=%s)(%s=%s))",
1153                                 LDAP_OBJ_IDMAP_ENTRY,
1154                                 LDAP_ATTRIBUTE_SID,
1155                                 sid_string_talloc(memctx, ids[0]->sid));
1156                 CHECK_ALLOC_DONE(filter);
1157                 DEBUG(10, ("Filter: [%s]\n", filter));
1158         } else {
1159                 /* multiple mappings */
1160                 multi = True;
1161         }
1162
1163         for (i = 0; ids[i]; i++) {
1164                 ids[i]->status = ID_UNKNOWN;
1165         }
1166
1167 again:
1168         if (multi) {
1169
1170                 TALLOC_FREE(filter);
1171                 filter = talloc_asprintf(memctx,
1172                                          "(&(objectClass=%s)(|",
1173                                          LDAP_OBJ_IDMAP_ENTRY);
1174                 CHECK_ALLOC_DONE(filter);
1175
1176                 bidx = idx;
1177                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
1178                         filter = talloc_asprintf_append_buffer(filter, "(%s=%s)",
1179                                         LDAP_ATTRIBUTE_SID,
1180                                         sid_string_talloc(memctx,
1181                                                           ids[idx]->sid));
1182                         CHECK_ALLOC_DONE(filter);
1183                 }
1184                 filter = talloc_asprintf_append_buffer(filter, "))");
1185                 CHECK_ALLOC_DONE(filter);
1186                 DEBUG(10, ("Filter: [%s]", filter));
1187         } else {
1188                 bidx = 0;
1189                 idx = 1;
1190         }
1191
1192         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
1193                 filter, attr_list, 0, &result);
1194
1195         if (rc != LDAP_SUCCESS) {
1196                 DEBUG(3,("Failure looking up sids (%s)\n",
1197                          ldap_err2string(rc)));
1198                 ret = NT_STATUS_UNSUCCESSFUL;
1199                 goto done;
1200         }
1201
1202         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
1203
1204         if (count == 0) {
1205                 DEBUG(10, ("NO SIDs found\n"));
1206         }
1207
1208         for (i = 0; i < count; i++) {
1209                 char *sidstr = NULL;
1210                 char *tmp = NULL;
1211                 enum id_type type;
1212                 struct id_map *map;
1213                 DOM_SID sid;
1214                 uint32_t id;
1215
1216                 if (i == 0) { /* first entry */
1217                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
1218                                                  result);
1219                 } else { /* following ones */
1220                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
1221                                                 entry);
1222                 }
1223                 if ( ! entry) {
1224                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
1225                                   "from results\n"));
1226                         break;
1227                 }
1228
1229                 /* first check if the SID is present */
1230                 sidstr = smbldap_talloc_single_attribute(
1231                                 ctx->smbldap_state->ldap_struct,
1232                                 entry, LDAP_ATTRIBUTE_SID, memctx);
1233                 if ( ! sidstr) { /* no sid ??, skip entry */
1234                         DEBUG(2, ("WARNING SID not found on entry\n"));
1235                         continue;
1236                 }
1237
1238                 if ( ! string_to_sid(&sid, sidstr)) {
1239                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
1240                         TALLOC_FREE(sidstr);
1241                         continue;
1242                 }
1243
1244                 map = find_map_by_sid(&ids[bidx], &sid);
1245                 if (!map) {
1246                         DEBUG(2, ("WARNING: couldn't find entry sid (%s) "
1247                                   "in ids", sidstr));
1248                         TALLOC_FREE(sidstr);
1249                         continue;
1250                 }
1251
1252                 TALLOC_FREE(sidstr);
1253
1254                 /* now try to see if it is a uid, if not try with a gid
1255                  * (gid is more common, but in case both uidNumber and
1256                  * gidNumber are returned the SID is mapped to the uid
1257                  * not the gid) */
1258                 type = ID_TYPE_UID;
1259                 tmp = smbldap_talloc_single_attribute(
1260                                 ctx->smbldap_state->ldap_struct,
1261                                 entry, uidNumber, memctx);
1262                 if ( ! tmp) {
1263                         type = ID_TYPE_GID;
1264                         tmp = smbldap_talloc_single_attribute(
1265                                         ctx->smbldap_state->ldap_struct,
1266                                         entry, gidNumber, memctx);
1267                 }
1268                 if ( ! tmp) { /* no ids ?? */
1269                         DEBUG(5, ("no uidNumber, "
1270                                   "nor gidNumber attributes found\n"));
1271                         continue;
1272                 }
1273
1274                 id = strtoul(tmp, NULL, 10);
1275                 if ((id == 0) ||
1276                     (ctx->filter_low_id && (id < ctx->filter_low_id)) ||
1277                     (ctx->filter_high_id && (id > ctx->filter_high_id))) {
1278                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
1279                                   "Filtered!\n", id,
1280                                   ctx->filter_low_id, ctx->filter_high_id));
1281                         TALLOC_FREE(tmp);
1282                         continue;
1283                 }
1284                 TALLOC_FREE(tmp);
1285
1286                 /* mapped */
1287                 map->xid.type = type;
1288                 map->xid.id = id;
1289                 map->status = ID_MAPPED;
1290
1291                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
1292                            (unsigned long)map->xid.id, map->xid.type));
1293         }
1294
1295         /* free the ldap results */
1296         if (result) {
1297                 ldap_msgfree(result);
1298                 result = NULL;
1299         }
1300
1301         if (multi && ids[idx]) { /* still some values to map */
1302                 goto again;
1303         }
1304
1305         ret = NT_STATUS_OK;
1306
1307         /* mark all unknwon/expired ones as unmapped */
1308         for (i = 0; ids[i]; i++) {
1309                 if (ids[i]->status != ID_MAPPED)
1310                         ids[i]->status = ID_UNMAPPED;
1311         }
1312
1313 done:
1314         talloc_free(memctx);
1315         return ret;
1316 }
1317
1318 /**********************************
1319  set a mapping.
1320 **********************************/
1321
1322 /* TODO: change this:  This function cannot be called to modify a mapping,
1323  * only set a new one */
1324
1325 static NTSTATUS idmap_ldap_set_mapping(struct idmap_domain *dom,
1326                                        const struct id_map *map)
1327 {
1328         NTSTATUS ret;
1329         TALLOC_CTX *memctx;
1330         struct idmap_ldap_context *ctx;
1331         LDAPMessage *entry = NULL;
1332         LDAPMod **mods = NULL;
1333         const char *type;
1334         char *id_str;
1335         char *sid;
1336         char *dn;
1337         int rc = -1;
1338
1339         /* Only do query if we are online */
1340         if (idmap_is_offline()) {
1341                 return NT_STATUS_FILE_IS_OFFLINE;
1342         }
1343
1344         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
1345
1346         switch(map->xid.type) {
1347         case ID_TYPE_UID:
1348                 type = get_attr_key2string(sidmap_attr_list,
1349                                            LDAP_ATTR_UIDNUMBER);
1350                 break;
1351
1352         case ID_TYPE_GID:
1353                 type = get_attr_key2string(sidmap_attr_list,
1354                                            LDAP_ATTR_GIDNUMBER);
1355                 break;
1356
1357         default:
1358                 return NT_STATUS_INVALID_PARAMETER;
1359         }
1360
1361         memctx = talloc_new(ctx);
1362         if ( ! memctx) {
1363                 DEBUG(0, ("Out of memory!\n"));
1364                 return NT_STATUS_NO_MEMORY;
1365         }
1366
1367         id_str = talloc_asprintf(memctx, "%lu", (unsigned long)map->xid.id);
1368         CHECK_ALLOC_DONE(id_str);
1369
1370         sid = talloc_strdup(memctx, sid_string_talloc(memctx, map->sid));
1371         CHECK_ALLOC_DONE(sid);
1372
1373         dn = talloc_asprintf(memctx, "%s=%s,%s",
1374                         get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
1375                         sid,
1376                         ctx->suffix);
1377         CHECK_ALLOC_DONE(dn);
1378
1379         smbldap_set_mod(&mods, LDAP_MOD_ADD,
1380                         "objectClass", LDAP_OBJ_IDMAP_ENTRY);
1381
1382         smbldap_make_mod(ctx->smbldap_state->ldap_struct,
1383                          entry, &mods, type, id_str);
1384
1385         smbldap_make_mod(ctx->smbldap_state->ldap_struct, entry, &mods,
1386                          get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
1387                          sid);
1388
1389         if ( ! mods) {
1390                 DEBUG(2, ("ERROR: No mods?\n"));
1391                 ret = NT_STATUS_UNSUCCESSFUL;
1392                 goto done;
1393         }
1394
1395         /* TODO: remove conflicting mappings! */
1396
1397         smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_SID_ENTRY);
1398
1399         DEBUG(10, ("Set DN %s (%s -> %s)\n", dn, sid, id_str));
1400
1401         rc = smbldap_add(ctx->smbldap_state, dn, mods);
1402         ldap_mods_free(mods, True);
1403
1404         if (rc != LDAP_SUCCESS) {
1405                 char *ld_error = NULL;
1406                 ldap_get_option(ctx->smbldap_state->ldap_struct,
1407                                 LDAP_OPT_ERROR_STRING, &ld_error);
1408                 DEBUG(0,("ldap_set_mapping_internals: Failed to add %s to %lu "
1409                          "mapping [%s]\n", sid,
1410                          (unsigned long)map->xid.id, type));
1411                 DEBUG(0, ("ldap_set_mapping_internals: Error was: %s (%s)\n",
1412                         ld_error ? ld_error : "(NULL)", ldap_err2string (rc)));
1413                 if (ld_error) {
1414                         ldap_memfree(ld_error);
1415                 }
1416                 ret = NT_STATUS_UNSUCCESSFUL;
1417                 goto done;
1418         }
1419
1420         DEBUG(10,("ldap_set_mapping: Successfully created mapping from %s to "
1421                   "%lu [%s]\n", sid, (unsigned long)map->xid.id, type));
1422
1423         ret = NT_STATUS_OK;
1424
1425 done:
1426         talloc_free(memctx);
1427         return ret;
1428 }
1429
1430 /**********************************
1431  Close the idmap ldap instance
1432 **********************************/
1433
1434 static NTSTATUS idmap_ldap_close(struct idmap_domain *dom)
1435 {
1436         struct idmap_ldap_context *ctx;
1437
1438         if (dom->private_data) {
1439                 ctx = talloc_get_type(dom->private_data,
1440                                       struct idmap_ldap_context);
1441
1442                 talloc_free(ctx);
1443                 dom->private_data = NULL;
1444         }
1445
1446         return NT_STATUS_OK;
1447 }
1448
1449 static struct idmap_methods idmap_ldap_methods = {
1450
1451         .init = idmap_ldap_db_init,
1452         .unixids_to_sids = idmap_ldap_unixids_to_sids,
1453         .sids_to_unixids = idmap_ldap_sids_to_unixids,
1454         .set_mapping = idmap_ldap_set_mapping,
1455         .close_fn = idmap_ldap_close
1456 };
1457
1458 static struct idmap_alloc_methods idmap_ldap_alloc_methods = {
1459
1460         .init = idmap_ldap_alloc_init,
1461         .allocate_id = idmap_ldap_allocate_id,
1462         .get_id_hwm = idmap_ldap_get_hwm,
1463         .set_id_hwm = idmap_ldap_set_hwm,
1464         .close_fn = idmap_ldap_alloc_close,
1465         /* .dump_data = TODO */
1466 };
1467
1468 static NTSTATUS idmap_alloc_ldap_init(void)
1469 {
1470         return smb_register_idmap_alloc(SMB_IDMAP_INTERFACE_VERSION, "ldap",
1471                                         &idmap_ldap_alloc_methods);
1472 }
1473
1474 NTSTATUS idmap_ldap_init(void);
1475 NTSTATUS idmap_ldap_init(void)
1476 {
1477         NTSTATUS ret;
1478
1479         /* FIXME: bad hack to actually register also the alloc_ldap module
1480          * without changining configure.in */
1481         ret = idmap_alloc_ldap_init();
1482         if (! NT_STATUS_IS_OK(ret)) {
1483                 return ret;
1484         }
1485         return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "ldap",
1486                                   &idmap_ldap_methods);
1487 }
1488