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 again:
 939         if (multi) {
 940
 941                 talloc_free(filter);
 942                 filter = talloc_asprintf(memctx,
 943                                          "(&(objectClass=%s)(|",
 944                                          LDAP_OBJ_IDMAP_ENTRY);
 945                 CHECK_ALLOC_DONE(filter);
 946
 947                 bidx = idx;
 948                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
 949                         filter = talloc_asprintf_append_buffer(filter, "(%s=%lu)",
 950                                         (ids[idx]->xid.type==ID_TYPE_UID)?uidNumber:gidNumber,
 951                                         (unsigned long)ids[idx]->xid.id);
 952                         CHECK_ALLOC_DONE(filter);
 953                 }
 954                 filter = talloc_asprintf_append_buffer(filter, "))");
 955                 CHECK_ALLOC_DONE(filter);
 956                 DEBUG(10, ("Filter: [%s]\n", filter));
 957         } else {
 958                 bidx = 0;
 959                 idx = 1;
 960         }
 961
 962         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
 963                 filter, attr_list, 0, &result);
 964
 965         if (rc != LDAP_SUCCESS) {
 966                 DEBUG(3,("Failure looking up ids (%s)\n", ldap_err2string(rc)));
 967                 ret = NT_STATUS_UNSUCCESSFUL;
 968                 goto done;
 969         }
 970
 971         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
 972
 973         if (count == 0) {
 974                 DEBUG(10, ("NO SIDs found\n"));
 975         }
 976
 977         for (i = 0; i < count; i++) {
 978                 LDAPMessage *entry = NULL;
 979                 char *sidstr = NULL;
 980                 char *tmp = NULL;
 981                 enum id_type type;
 982                 struct id_map *map;
 983                 uint32_t id;
 984
 985                 if (i == 0) { /* first entry */
 986                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
 987                                                  result);
 988                 } else { /* following ones */
 989                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
 990                                                 entry);
 991                 }
 992                 if ( ! entry) {
 993                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
 994                                   "from results\n"));
 995                         break;
 996                 }
 997
 998                 /* first check if the SID is present */
 999                 sidstr = smbldap_talloc_single_attribute(
1000                                 ctx->smbldap_state->ldap_struct,
1001                                 entry, LDAP_ATTRIBUTE_SID, memctx);
1002                 if ( ! sidstr) { /* no sid, skip entry */
1003                         DEBUG(2, ("WARNING SID not found on entry\n"));
1004                         continue;
1005                 }
1006
1007                 /* now try to see if it is a uid, if not try with a gid
1008                  * (gid is more common, but in case both uidNumber and
1009                  * gidNumber are returned the SID is mapped to the uid
1010                  *not the gid) */
1011                 type = ID_TYPE_UID;
1012                 tmp = smbldap_talloc_single_attribute(
1013                                 ctx->smbldap_state->ldap_struct,
1014                                 entry, uidNumber, memctx);
1015                 if ( ! tmp) {
1016                         type = ID_TYPE_GID;
1017                         tmp = smbldap_talloc_single_attribute(
1018                                         ctx->smbldap_state->ldap_struct,
1019                                         entry, gidNumber, memctx);
1020                 }
1021                 if ( ! tmp) { /* wow very strange entry, how did it match ? */
1022                         DEBUG(5, ("Unprobable match on (%s), no uidNumber, "
1023                                   "nor gidNumber returned\n", sidstr));
1024                         TALLOC_FREE(sidstr);
1025                         continue;
1026                 }
1027
1028                 id = strtoul(tmp, NULL, 10);
1029                 if ((id == 0) ||
1030                     (ctx->filter_low_id && (id < ctx->filter_low_id)) ||
1031                     (ctx->filter_high_id && (id > ctx->filter_high_id))) {
1032                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
1033                                   "Filtered!\n", id,
1034                                   ctx->filter_low_id, ctx->filter_high_id));
1035                         TALLOC_FREE(sidstr);
1036                         TALLOC_FREE(tmp);
1037                         continue;
1038                 }
1039                 TALLOC_FREE(tmp);
1040
1041                 map = find_map_by_id(&ids[bidx], type, id);
1042                 if (!map) {
1043                         DEBUG(2, ("WARNING: couldn't match sid (%s) "
1044                                   "with requested ids\n", sidstr));
1045                         TALLOC_FREE(sidstr);
1046                         continue;
1047                 }
1048
1049                 if ( ! string_to_sid(map->sid, sidstr)) {
1050                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
1051                         TALLOC_FREE(sidstr);
1052                         continue;
1053                 }
1054                 TALLOC_FREE(sidstr);
1055
1056                 /* mapped */
1057                 map->status = ID_MAPPED;
1058
1059                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
1060                            (unsigned long)map->xid.id, map->xid.type));
1061         }
1062
1063         /* free the ldap results */
1064         if (result) {
1065                 ldap_msgfree(result);
1066                 result = NULL;
1067         }
1068
1069         if (multi && ids[idx]) { /* still some values to map */
1070                 goto again;
1071         }
1072
1073         ret = NT_STATUS_OK;
1074
1075         /* mark all unknwon/expired ones as unmapped */
1076         for (i = 0; ids[i]; i++) {
1077                 if (ids[i]->status != ID_MAPPED)
1078                         ids[i]->status = ID_UNMAPPED;
1079         }
1080
1081 done:
1082         talloc_free(memctx);
1083         return ret;
1084 }
1085
1086 /**********************************
1087  lookup a set of sids.
1088 **********************************/
1089
1090 /* this function searches up to IDMAP_LDAP_MAX_IDS entries
1091  * in maps for a match */
1092 static struct id_map *find_map_by_sid(struct id_map **maps, DOM_SID *sid)
1093 {
1094         int i;
1095
1096         for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
1097                 if (maps[i] == NULL) { /* end of the run */
1098                         return NULL;
1099                 }
1100                 if (sid_equal(maps[i]->sid, sid)) {
1101                         return maps[i];
1102                 }
1103         }
1104
1105         return NULL;
1106 }
1107
1108 static NTSTATUS idmap_ldap_sids_to_unixids(struct idmap_domain *dom,
1109                                            struct id_map **ids)
1110 {
1111         LDAPMessage *entry = NULL;
1112         NTSTATUS ret;
1113         TALLOC_CTX *memctx;
1114         struct idmap_ldap_context *ctx;
1115         LDAPMessage *result = NULL;
1116         const char *uidNumber;
1117         const char *gidNumber;
1118         const char **attr_list;
1119         char *filter = NULL;
1120         bool multi = False;
1121         int idx = 0;
1122         int bidx = 0;
1123         int count;
1124         int rc;
1125         int i;
1126
1127         /* Only do query if we are online */
1128         if (idmap_is_offline()) {
1129                 return NT_STATUS_FILE_IS_OFFLINE;
1130         }
1131
1132         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
1133
1134         memctx = talloc_new(ctx);
1135         if ( ! memctx) {
1136                 DEBUG(0, ("Out of memory!\n"));
1137                 return NT_STATUS_NO_MEMORY;
1138         }
1139
1140         uidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_UIDNUMBER);
1141         gidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_GIDNUMBER);
1142
1143         attr_list = get_attr_list(memctx, sidmap_attr_list);
1144
1145         if ( ! ids[1]) {
1146                 /* if we are requested just one mapping use the simple filter */
1147
1148                 filter = talloc_asprintf(memctx, "(&(objectClass=%s)(%s=%s))",
1149                                 LDAP_OBJ_IDMAP_ENTRY,
1150                                 LDAP_ATTRIBUTE_SID,
1151                                 sid_string_talloc(memctx, ids[0]->sid));
1152                 CHECK_ALLOC_DONE(filter);
1153                 DEBUG(10, ("Filter: [%s]\n", filter));
1154         } else {
1155                 /* multiple mappings */
1156                 multi = True;
1157         }
1158
1159 again:
1160         if (multi) {
1161
1162                 TALLOC_FREE(filter);
1163                 filter = talloc_asprintf(memctx,
1164                                          "(&(objectClass=%s)(|",
1165                                          LDAP_OBJ_IDMAP_ENTRY);
1166                 CHECK_ALLOC_DONE(filter);
1167
1168                 bidx = idx;
1169                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
1170                         filter = talloc_asprintf_append_buffer(filter, "(%s=%s)",
1171                                         LDAP_ATTRIBUTE_SID,
1172                                         sid_string_talloc(memctx,
1173                                                           ids[idx]->sid));
1174                         CHECK_ALLOC_DONE(filter);
1175                 }
1176                 filter = talloc_asprintf_append_buffer(filter, "))");
1177                 CHECK_ALLOC_DONE(filter);
1178                 DEBUG(10, ("Filter: [%s]", filter));
1179         } else {
1180                 bidx = 0;
1181                 idx = 1;
1182         }
1183
1184         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
1185                 filter, attr_list, 0, &result);
1186
1187         if (rc != LDAP_SUCCESS) {
1188                 DEBUG(3,("Failure looking up sids (%s)\n",
1189                          ldap_err2string(rc)));
1190                 ret = NT_STATUS_UNSUCCESSFUL;
1191                 goto done;
1192         }
1193
1194         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
1195
1196         if (count == 0) {
1197                 DEBUG(10, ("NO SIDs found\n"));
1198         }
1199
1200         for (i = 0; i < count; i++) {
1201                 char *sidstr = NULL;
1202                 char *tmp = NULL;
1203                 enum id_type type;
1204                 struct id_map *map;
1205                 DOM_SID sid;
1206                 uint32_t id;
1207
1208                 if (i == 0) { /* first entry */
1209                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
1210                                                  result);
1211                 } else { /* following ones */
1212                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
1213                                                 entry);
1214                 }
1215                 if ( ! entry) {
1216                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
1217                                   "from results\n"));
1218                         break;
1219                 }
1220
1221                 /* first check if the SID is present */
1222                 sidstr = smbldap_talloc_single_attribute(
1223                                 ctx->smbldap_state->ldap_struct,
1224                                 entry, LDAP_ATTRIBUTE_SID, memctx);
1225                 if ( ! sidstr) { /* no sid ??, skip entry */
1226                         DEBUG(2, ("WARNING SID not found on entry\n"));
1227                         continue;
1228                 }
1229
1230                 if ( ! string_to_sid(&sid, sidstr)) {
1231                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
1232                         TALLOC_FREE(sidstr);
1233                         continue;
1234                 }
1235
1236                 map = find_map_by_sid(&ids[bidx], &sid);
1237                 if (!map) {
1238                         DEBUG(2, ("WARNING: couldn't find entry sid (%s) "
1239                                   "in ids", sidstr));
1240                         TALLOC_FREE(sidstr);
1241                         continue;
1242                 }
1243
1244                 TALLOC_FREE(sidstr);
1245
1246                 /* now try to see if it is a uid, if not try with a gid
1247                  * (gid is more common, but in case both uidNumber and
1248                  * gidNumber are returned the SID is mapped to the uid
1249                  * not the gid) */
1250                 type = ID_TYPE_UID;
1251                 tmp = smbldap_talloc_single_attribute(
1252                                 ctx->smbldap_state->ldap_struct,
1253                                 entry, uidNumber, memctx);
1254                 if ( ! tmp) {
1255                         type = ID_TYPE_GID;
1256                         tmp = smbldap_talloc_single_attribute(
1257                                         ctx->smbldap_state->ldap_struct,
1258                                         entry, gidNumber, memctx);
1259                 }
1260                 if ( ! tmp) { /* no ids ?? */
1261                         DEBUG(5, ("no uidNumber, "
1262                                   "nor gidNumber attributes found\n"));
1263                         continue;
1264                 }
1265
1266                 id = strtoul(tmp, NULL, 10);
1267                 if ((id == 0) ||
1268                     (ctx->filter_low_id && (id < ctx->filter_low_id)) ||
1269                     (ctx->filter_high_id && (id > ctx->filter_high_id))) {
1270                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
1271                                   "Filtered!\n", id,
1272                                   ctx->filter_low_id, ctx->filter_high_id));
1273                         TALLOC_FREE(tmp);
1274                         continue;
1275                 }
1276                 TALLOC_FREE(tmp);
1277
1278                 /* mapped */
1279                 map->xid.type = type;
1280                 map->xid.id = id;
1281                 map->status = ID_MAPPED;
1282
1283                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
1284                            (unsigned long)map->xid.id, map->xid.type));
1285         }
1286
1287         /* free the ldap results */
1288         if (result) {
1289                 ldap_msgfree(result);
1290                 result = NULL;
1291         }
1292
1293         if (multi && ids[idx]) { /* still some values to map */
1294                 goto again;
1295         }
1296
1297         ret = NT_STATUS_OK;
1298
1299         /* mark all unknwon/expired ones as unmapped */
1300         for (i = 0; ids[i]; i++) {
1301                 if (ids[i]->status != ID_MAPPED)
1302                         ids[i]->status = ID_UNMAPPED;
1303         }
1304
1305 done:
1306         talloc_free(memctx);
1307         return ret;
1308 }
1309
1310 /**********************************
1311  set a mapping.
1312 **********************************/
1313
1314 /* TODO: change this:  This function cannot be called to modify a mapping,
1315  * only set a new one */
1316
1317 static NTSTATUS idmap_ldap_set_mapping(struct idmap_domain *dom,
1318                                        const struct id_map *map)
1319 {
1320         NTSTATUS ret;
1321         TALLOC_CTX *memctx;
1322         struct idmap_ldap_context *ctx;
1323         LDAPMessage *entry = NULL;
1324         LDAPMod **mods = NULL;
1325         const char *type;
1326         char *id_str;
1327         char *sid;
1328         char *dn;
1329         int rc = -1;
1330
1331         /* Only do query if we are online */
1332         if (idmap_is_offline()) {
1333                 return NT_STATUS_FILE_IS_OFFLINE;
1334         }
1335
1336         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
1337
1338         switch(map->xid.type) {
1339         case ID_TYPE_UID:
1340                 type = get_attr_key2string(sidmap_attr_list,
1341                                            LDAP_ATTR_UIDNUMBER);
1342                 break;
1343
1344         case ID_TYPE_GID:
1345                 type = get_attr_key2string(sidmap_attr_list,
1346                                            LDAP_ATTR_GIDNUMBER);
1347                 break;
1348
1349         default:
1350                 return NT_STATUS_INVALID_PARAMETER;
1351         }
1352
1353         memctx = talloc_new(ctx);
1354         if ( ! memctx) {
1355                 DEBUG(0, ("Out of memory!\n"));
1356                 return NT_STATUS_NO_MEMORY;
1357         }
1358
1359         id_str = talloc_asprintf(memctx, "%lu", (unsigned long)map->xid.id);
1360         CHECK_ALLOC_DONE(id_str);
1361
1362         sid = talloc_strdup(memctx, sid_string_talloc(memctx, map->sid));
1363         CHECK_ALLOC_DONE(sid);
1364
1365         dn = talloc_asprintf(memctx, "%s=%s,%s",
1366                         get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
1367                         sid,
1368                         ctx->suffix);
1369         CHECK_ALLOC_DONE(dn);
1370
1371         smbldap_set_mod(&mods, LDAP_MOD_ADD,
1372                         "objectClass", LDAP_OBJ_IDMAP_ENTRY);
1373
1374         smbldap_make_mod(ctx->smbldap_state->ldap_struct,
1375                          entry, &mods, type, id_str);
1376
1377         smbldap_make_mod(ctx->smbldap_state->ldap_struct, entry, &mods,
1378                          get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
1379                          sid);
1380
1381         if ( ! mods) {
1382                 DEBUG(2, ("ERROR: No mods?\n"));
1383                 ret = NT_STATUS_UNSUCCESSFUL;
1384                 goto done;
1385         }
1386
1387         /* TODO: remove conflicting mappings! */
1388
1389         smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_SID_ENTRY);
1390
1391         DEBUG(10, ("Set DN %s (%s -> %s)\n", dn, sid, id_str));
1392
1393         rc = smbldap_add(ctx->smbldap_state, dn, mods);
1394         ldap_mods_free(mods, True);
1395
1396         if (rc != LDAP_SUCCESS) {
1397                 char *ld_error = NULL;
1398                 ldap_get_option(ctx->smbldap_state->ldap_struct,
1399                                 LDAP_OPT_ERROR_STRING, &ld_error);
1400                 DEBUG(0,("ldap_set_mapping_internals: Failed to add %s to %lu "
1401                          "mapping [%s]\n", sid,
1402                          (unsigned long)map->xid.id, type));
1403                 DEBUG(0, ("ldap_set_mapping_internals: Error was: %s (%s)\n",
1404                         ld_error ? ld_error : "(NULL)", ldap_err2string (rc)));
1405                 if (ld_error) {
1406                         ldap_memfree(ld_error);
1407                 }
1408                 ret = NT_STATUS_UNSUCCESSFUL;
1409                 goto done;
1410         }
1411
1412         DEBUG(10,("ldap_set_mapping: Successfully created mapping from %s to "
1413                   "%lu [%s]\n", sid, (unsigned long)map->xid.id, type));
1414
1415         ret = NT_STATUS_OK;
1416
1417 done:
1418         talloc_free(memctx);
1419         return ret;
1420 }
1421
1422 /**********************************
1423  Close the idmap ldap instance
1424 **********************************/
1425
1426 static NTSTATUS idmap_ldap_close(struct idmap_domain *dom)
1427 {
1428         struct idmap_ldap_context *ctx;
1429
1430         if (dom->private_data) {
1431                 ctx = talloc_get_type(dom->private_data,
1432                                       struct idmap_ldap_context);
1433
1434                 talloc_free(ctx);
1435                 dom->private_data = NULL;
1436         }
1437
1438         return NT_STATUS_OK;
1439 }
1440
1441 static struct idmap_methods idmap_ldap_methods = {
1442
1443         .init = idmap_ldap_db_init,
1444         .unixids_to_sids = idmap_ldap_unixids_to_sids,
1445         .sids_to_unixids = idmap_ldap_sids_to_unixids,
1446         .set_mapping = idmap_ldap_set_mapping,
1447         .close_fn = idmap_ldap_close
1448 };
1449
1450 static struct idmap_alloc_methods idmap_ldap_alloc_methods = {
1451
1452         .init = idmap_ldap_alloc_init,
1453         .allocate_id = idmap_ldap_allocate_id,
1454         .get_id_hwm = idmap_ldap_get_hwm,
1455         .set_id_hwm = idmap_ldap_set_hwm,
1456         .close_fn = idmap_ldap_alloc_close,
1457         /* .dump_data = TODO */
1458 };
1459
1460 static NTSTATUS idmap_alloc_ldap_init(void)
1461 {
1462         return smb_register_idmap_alloc(SMB_IDMAP_INTERFACE_VERSION, "ldap",
1463                                         &idmap_ldap_alloc_methods);
1464 }
1465
1466 NTSTATUS idmap_ldap_init(void);
1467 NTSTATUS idmap_ldap_init(void)
1468 {
1469         NTSTATUS ret;
1470
1471         /* FIXME: bad hack to actually register also the alloc_ldap module
1472          * without changining configure.in */
1473         ret = idmap_alloc_ldap_init();
1474         if (! NT_STATUS_IS_OK(ret)) {
1475                 return ret;
1476         }
1477         return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "ldap",
1478                                   &idmap_ldap_methods);
1479 }
1480