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 *tmp = NULL;
 769
 770         /* Only do init if we are online */
 771         if (idmap_is_offline()) {
 772                 return NT_STATUS_FILE_IS_OFFLINE;
 773         }
 774
 775         ctx = TALLOC_ZERO_P(dom, struct idmap_ldap_context);
 776         if ( ! ctx) {
 777                 DEBUG(0, ("Out of memory!\n"));
 778                 return NT_STATUS_NO_MEMORY;
 779         }
 780
 781         if (strequal(dom->name, "*")) {
 782                 uid_t low_uid = 0;
 783                 uid_t high_uid = 0;
 784                 gid_t low_gid = 0;
 785                 gid_t high_gid = 0;
 786
 787                 ctx->filter_low_id = 0;
 788                 ctx->filter_high_id = 0;
 789
 790                 if (lp_idmap_uid(&low_uid, &high_uid)) {
 791                         ctx->filter_low_id = low_uid;
 792                         ctx->filter_high_id = high_uid;
 793                 } else {
 794                         DEBUG(3, ("Warning: 'idmap uid' not set!\n"));
 795                 }
 796
 797                 if (lp_idmap_gid(&low_gid, &high_gid)) {
 798                         if ((low_gid != low_uid) || (high_gid != high_uid)) {
 799                                 DEBUG(1, ("Warning: 'idmap uid' and 'idmap gid'"
 800                                       " ranges do not agree -- building "
 801                                       "intersection\n"));
 802                                 ctx->filter_low_id = MAX(ctx->filter_low_id,
 803                                                          low_gid);
 804                                 ctx->filter_high_id = MIN(ctx->filter_high_id,
 805                                                           high_gid);
 806                         }
 807                 } else {
 808                         DEBUG(3, ("Warning: 'idmap gid' not set!\n"));
 809                 }
 810         } else {
 811                 const char *range = NULL;
 812
 813                 config_option = talloc_asprintf(ctx, "idmap config %s", dom->name);
 814                 if ( ! config_option) {
 815                         DEBUG(0, ("Out of memory!\n"));
 816                         ret = NT_STATUS_NO_MEMORY;
 817                         goto done;
 818                 }
 819
 820                 /* load ranges */
 821                 range = lp_parm_const_string(-1, config_option, "range", NULL);
 822                 if (range && range[0]) {
 823                         if ((sscanf(range, "%u - %u", &ctx->filter_low_id,
 824                                                         &ctx->filter_high_id) != 2))
 825                         {
 826                                 DEBUG(1, ("ERROR: invalid filter range [%s]", range));
 827                                 ctx->filter_low_id = 0;
 828                                 ctx->filter_high_id = 0;
 829                         }
 830                 }
 831         }
 832
 833         if (ctx->filter_low_id > ctx->filter_high_id) {
 834                 DEBUG(1, ("ERROR: invalid filter range [%u-%u]",
 835                       ctx->filter_low_id, ctx->filter_high_id));
 836                 ctx->filter_low_id = 0;
 837                 ctx->filter_high_id = 0;
 838         }
 839
 840         if (params != NULL) {
 841                 /* assume location is the only parameter */
 842                 ctx->url = talloc_strdup(ctx, params);
 843         } else {
 844                 tmp = lp_parm_const_string(-1, config_option, "ldap_url", NULL);
 845
 846                 if ( ! tmp) {
 847                         DEBUG(1, ("ERROR: missing idmap ldap url\n"));
 848                         ret = NT_STATUS_UNSUCCESSFUL;
 849                         goto done;
 850                 }
 851
 852                 ctx->url = talloc_strdup(ctx, tmp);
 853         }
 854         CHECK_ALLOC_DONE(ctx->url);
 855
 856         tmp = lp_parm_const_string(-1, config_option, "ldap_base_dn", NULL);
 857         if ( ! tmp || ! *tmp) {
 858                 tmp = lp_ldap_idmap_suffix();
 859                 if ( ! tmp) {
 860                         DEBUG(1, ("ERROR: missing idmap ldap suffix\n"));
 861                         ret = NT_STATUS_UNSUCCESSFUL;
 862                         goto done;
 863                 }
 864         }
 865
 866         ctx->suffix = talloc_strdup(ctx, tmp);
 867         CHECK_ALLOC_DONE(ctx->suffix);
 868
 869         ret = smbldap_init(ctx, winbind_event_context(), ctx->url,
 870                            &ctx->smbldap_state);
 871         if (!NT_STATUS_IS_OK(ret)) {
 872                 DEBUG(1, ("ERROR: smbldap_init (%s) failed!\n", ctx->url));
 873                 goto done;
 874         }
 875
 876         ret = get_credentials( ctx, ctx->smbldap_state, config_option,
 877                                dom, &ctx->user_dn );
 878         if ( !NT_STATUS_IS_OK(ret) ) {
 879                 DEBUG(1,("idmap_ldap_db_init: Failed to get connection "
 880                          "credentials (%s)\n", nt_errstr(ret)));
 881                 goto done;
 882         }
 883
 884         /* set the destructor on the context, so that resource are properly
 885            freed if the contexts is released */
 886
 887         talloc_set_destructor(ctx, idmap_ldap_close_destructor);
 888
 889         dom->private_data = ctx;
 890
 891         talloc_free(config_option);
 892         return NT_STATUS_OK;
 893
 894 /*failed */
 895 done:
 896         talloc_free(ctx);
 897         return ret;
 898 }
 899
 900 /* max number of ids requested per batch query */
 901 #define IDMAP_LDAP_MAX_IDS 30
 902
 903 /**********************************
 904  lookup a set of unix ids.
 905 **********************************/
 906
 907 /* this function searches up to IDMAP_LDAP_MAX_IDS entries
 908  * in maps for a match */
 909 static struct id_map *find_map_by_id(struct id_map **maps,
 910                                      enum id_type type,
 911                                      uint32_t id)
 912 {
 913         int i;
 914
 915         for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
 916                 if (maps[i] == NULL) { /* end of the run */
 917                         return NULL;
 918                 }
 919                 if ((maps[i]->xid.type == type) && (maps[i]->xid.id == id)) {
 920                         return maps[i];
 921                 }
 922         }
 923
 924         return NULL;
 925 }
 926
 927 static NTSTATUS idmap_ldap_unixids_to_sids(struct idmap_domain *dom,
 928                                            struct id_map **ids)
 929 {
 930         NTSTATUS ret;
 931         TALLOC_CTX *memctx;
 932         struct idmap_ldap_context *ctx;
 933         LDAPMessage *result = NULL;
 934         LDAPMessage *entry = NULL;
 935         const char *uidNumber;
 936         const char *gidNumber;
 937         const char **attr_list;
 938         char *filter = NULL;
 939         bool multi = False;
 940         int idx = 0;
 941         int bidx = 0;
 942         int count;
 943         int rc;
 944         int i;
 945
 946         /* Only do query if we are online */
 947         if (idmap_is_offline()) {
 948                 return NT_STATUS_FILE_IS_OFFLINE;
 949         }
 950
 951         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
 952
 953         memctx = talloc_new(ctx);
 954         if ( ! memctx) {
 955                 DEBUG(0, ("Out of memory!\n"));
 956                 return NT_STATUS_NO_MEMORY;
 957         }
 958
 959         uidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_UIDNUMBER);
 960         gidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_GIDNUMBER);
 961
 962         attr_list = get_attr_list(memctx, sidmap_attr_list);
 963
 964         if ( ! ids[1]) {
 965                 /* if we are requested just one mapping use the simple filter */
 966
 967                 filter = talloc_asprintf(memctx, "(&(objectClass=%s)(%s=%lu))",
 968                                 LDAP_OBJ_IDMAP_ENTRY,
 969                                 (ids[0]->xid.type==ID_TYPE_UID)?uidNumber:gidNumber,
 970                                 (unsigned long)ids[0]->xid.id);
 971                 CHECK_ALLOC_DONE(filter);
 972                 DEBUG(10, ("Filter: [%s]\n", filter));
 973         } else {
 974                 /* multiple mappings */
 975                 multi = True;
 976         }
 977
 978         for (i = 0; ids[i]; i++) {
 979                 ids[i]->status = ID_UNKNOWN;
 980         }
 981
 982 again:
 983         if (multi) {
 984
 985                 talloc_free(filter);
 986                 filter = talloc_asprintf(memctx,
 987                                          "(&(objectClass=%s)(|",
 988                                          LDAP_OBJ_IDMAP_ENTRY);
 989                 CHECK_ALLOC_DONE(filter);
 990
 991                 bidx = idx;
 992                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
 993                         filter = talloc_asprintf_append_buffer(filter, "(%s=%lu)",
 994                                         (ids[idx]->xid.type==ID_TYPE_UID)?uidNumber:gidNumber,
 995                                         (unsigned long)ids[idx]->xid.id);
 996                         CHECK_ALLOC_DONE(filter);
 997                 }
 998                 filter = talloc_asprintf_append_buffer(filter, "))");
 999                 CHECK_ALLOC_DONE(filter);
1000                 DEBUG(10, ("Filter: [%s]\n", filter));
1001         } else {
1002                 bidx = 0;
1003                 idx = 1;
1004         }
1005
1006         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
1007                 filter, attr_list, 0, &result);
1008
1009         if (rc != LDAP_SUCCESS) {
1010                 DEBUG(3,("Failure looking up ids (%s)\n", ldap_err2string(rc)));
1011                 ret = NT_STATUS_UNSUCCESSFUL;
1012                 goto done;
1013         }
1014
1015         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
1016
1017         if (count == 0) {
1018                 DEBUG(10, ("NO SIDs found\n"));
1019         }
1020
1021         for (i = 0; i < count; i++) {
1022                 char *sidstr = NULL;
1023                 char *tmp = NULL;
1024                 enum id_type type;
1025                 struct id_map *map;
1026                 uint32_t id;
1027
1028                 if (i == 0) { /* first entry */
1029                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
1030                                                  result);
1031                 } else { /* following ones */
1032                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
1033                                                 entry);
1034                 }
1035                 if ( ! entry) {
1036                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
1037                                   "from results\n"));
1038                         break;
1039                 }
1040
1041                 /* first check if the SID is present */
1042                 sidstr = smbldap_talloc_single_attribute(
1043                                 ctx->smbldap_state->ldap_struct,
1044                                 entry, LDAP_ATTRIBUTE_SID, memctx);
1045                 if ( ! sidstr) { /* no sid, skip entry */
1046                         DEBUG(2, ("WARNING SID not found on entry\n"));
1047                         continue;
1048                 }
1049
1050                 /* now try to see if it is a uid, if not try with a gid
1051                  * (gid is more common, but in case both uidNumber and
1052                  * gidNumber are returned the SID is mapped to the uid
1053                  *not the gid) */
1054                 type = ID_TYPE_UID;
1055                 tmp = smbldap_talloc_single_attribute(
1056                                 ctx->smbldap_state->ldap_struct,
1057                                 entry, uidNumber, memctx);
1058                 if ( ! tmp) {
1059                         type = ID_TYPE_GID;
1060                         tmp = smbldap_talloc_single_attribute(
1061                                         ctx->smbldap_state->ldap_struct,
1062                                         entry, gidNumber, memctx);
1063                 }
1064                 if ( ! tmp) { /* wow very strange entry, how did it match ? */
1065                         DEBUG(5, ("Unprobable match on (%s), no uidNumber, "
1066                                   "nor gidNumber returned\n", sidstr));
1067                         TALLOC_FREE(sidstr);
1068                         continue;
1069                 }
1070
1071                 id = strtoul(tmp, NULL, 10);
1072                 if ((id == 0) ||
1073                     (ctx->filter_low_id && (id < ctx->filter_low_id)) ||
1074                     (ctx->filter_high_id && (id > ctx->filter_high_id))) {
1075                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
1076                                   "Filtered!\n", id,
1077                                   ctx->filter_low_id, ctx->filter_high_id));
1078                         TALLOC_FREE(sidstr);
1079                         TALLOC_FREE(tmp);
1080                         continue;
1081                 }
1082                 TALLOC_FREE(tmp);
1083
1084                 map = find_map_by_id(&ids[bidx], type, id);
1085                 if (!map) {
1086                         DEBUG(2, ("WARNING: couldn't match sid (%s) "
1087                                   "with requested ids\n", sidstr));
1088                         TALLOC_FREE(sidstr);
1089                         continue;
1090                 }
1091
1092                 if ( ! string_to_sid(map->sid, sidstr)) {
1093                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
1094                         TALLOC_FREE(sidstr);
1095                         continue;
1096                 }
1097
1098                 if (map->status == ID_MAPPED) {
1099                         DEBUG(1, ("WARNING: duplicate %s mapping in LDAP. "
1100                               "overwriting mapping %u -> %s with %u -> %s\n",
1101                               (type == ID_TYPE_UID) ? "UID" : "GID",
1102                               id, sid_string_dbg(map->sid), id, sidstr));
1103                 }
1104
1105                 TALLOC_FREE(sidstr);
1106
1107                 /* mapped */
1108                 map->status = ID_MAPPED;
1109
1110                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
1111                            (unsigned long)map->xid.id, map->xid.type));
1112         }
1113
1114         /* free the ldap results */
1115         if (result) {
1116                 ldap_msgfree(result);
1117                 result = NULL;
1118         }
1119
1120         if (multi && ids[idx]) { /* still some values to map */
1121                 goto again;
1122         }
1123
1124         ret = NT_STATUS_OK;
1125
1126         /* mark all unknwon/expired ones as unmapped */
1127         for (i = 0; ids[i]; i++) {
1128                 if (ids[i]->status != ID_MAPPED)
1129                         ids[i]->status = ID_UNMAPPED;
1130         }
1131
1132 done:
1133         talloc_free(memctx);
1134         return ret;
1135 }
1136
1137 /**********************************
1138  lookup a set of sids.
1139 **********************************/
1140
1141 /* this function searches up to IDMAP_LDAP_MAX_IDS entries
1142  * in maps for a match */
1143 static struct id_map *find_map_by_sid(struct id_map **maps, DOM_SID *sid)
1144 {
1145         int i;
1146
1147         for (i = 0; i < IDMAP_LDAP_MAX_IDS; i++) {
1148                 if (maps[i] == NULL) { /* end of the run */
1149                         return NULL;
1150                 }
1151                 if (sid_equal(maps[i]->sid, sid)) {
1152                         return maps[i];
1153                 }
1154         }
1155
1156         return NULL;
1157 }
1158
1159 static NTSTATUS idmap_ldap_sids_to_unixids(struct idmap_domain *dom,
1160                                            struct id_map **ids)
1161 {
1162         LDAPMessage *entry = NULL;
1163         NTSTATUS ret;
1164         TALLOC_CTX *memctx;
1165         struct idmap_ldap_context *ctx;
1166         LDAPMessage *result = NULL;
1167         const char *uidNumber;
1168         const char *gidNumber;
1169         const char **attr_list;
1170         char *filter = NULL;
1171         bool multi = False;
1172         int idx = 0;
1173         int bidx = 0;
1174         int count;
1175         int rc;
1176         int i;
1177
1178         /* Only do query if we are online */
1179         if (idmap_is_offline()) {
1180                 return NT_STATUS_FILE_IS_OFFLINE;
1181         }
1182
1183         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
1184
1185         memctx = talloc_new(ctx);
1186         if ( ! memctx) {
1187                 DEBUG(0, ("Out of memory!\n"));
1188                 return NT_STATUS_NO_MEMORY;
1189         }
1190
1191         uidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_UIDNUMBER);
1192         gidNumber = get_attr_key2string(idpool_attr_list, LDAP_ATTR_GIDNUMBER);
1193
1194         attr_list = get_attr_list(memctx, sidmap_attr_list);
1195
1196         if ( ! ids[1]) {
1197                 /* if we are requested just one mapping use the simple filter */
1198
1199                 filter = talloc_asprintf(memctx, "(&(objectClass=%s)(%s=%s))",
1200                                 LDAP_OBJ_IDMAP_ENTRY,
1201                                 LDAP_ATTRIBUTE_SID,
1202                                 sid_string_talloc(memctx, ids[0]->sid));
1203                 CHECK_ALLOC_DONE(filter);
1204                 DEBUG(10, ("Filter: [%s]\n", filter));
1205         } else {
1206                 /* multiple mappings */
1207                 multi = True;
1208         }
1209
1210         for (i = 0; ids[i]; i++) {
1211                 ids[i]->status = ID_UNKNOWN;
1212         }
1213
1214 again:
1215         if (multi) {
1216
1217                 TALLOC_FREE(filter);
1218                 filter = talloc_asprintf(memctx,
1219                                          "(&(objectClass=%s)(|",
1220                                          LDAP_OBJ_IDMAP_ENTRY);
1221                 CHECK_ALLOC_DONE(filter);
1222
1223                 bidx = idx;
1224                 for (i = 0; (i < IDMAP_LDAP_MAX_IDS) && ids[idx]; i++, idx++) {
1225                         filter = talloc_asprintf_append_buffer(filter, "(%s=%s)",
1226                                         LDAP_ATTRIBUTE_SID,
1227                                         sid_string_talloc(memctx,
1228                                                           ids[idx]->sid));
1229                         CHECK_ALLOC_DONE(filter);
1230                 }
1231                 filter = talloc_asprintf_append_buffer(filter, "))");
1232                 CHECK_ALLOC_DONE(filter);
1233                 DEBUG(10, ("Filter: [%s]", filter));
1234         } else {
1235                 bidx = 0;
1236                 idx = 1;
1237         }
1238
1239         rc = smbldap_search(ctx->smbldap_state, ctx->suffix, LDAP_SCOPE_SUBTREE,
1240                 filter, attr_list, 0, &result);
1241
1242         if (rc != LDAP_SUCCESS) {
1243                 DEBUG(3,("Failure looking up sids (%s)\n",
1244                          ldap_err2string(rc)));
1245                 ret = NT_STATUS_UNSUCCESSFUL;
1246                 goto done;
1247         }
1248
1249         count = ldap_count_entries(ctx->smbldap_state->ldap_struct, result);
1250
1251         if (count == 0) {
1252                 DEBUG(10, ("NO SIDs found\n"));
1253         }
1254
1255         for (i = 0; i < count; i++) {
1256                 char *sidstr = NULL;
1257                 char *tmp = NULL;
1258                 enum id_type type;
1259                 struct id_map *map;
1260                 DOM_SID sid;
1261                 uint32_t id;
1262
1263                 if (i == 0) { /* first entry */
1264                         entry = ldap_first_entry(ctx->smbldap_state->ldap_struct,
1265                                                  result);
1266                 } else { /* following ones */
1267                         entry = ldap_next_entry(ctx->smbldap_state->ldap_struct,
1268                                                 entry);
1269                 }
1270                 if ( ! entry) {
1271                         DEBUG(2, ("ERROR: Unable to fetch ldap entries "
1272                                   "from results\n"));
1273                         break;
1274                 }
1275
1276                 /* first check if the SID is present */
1277                 sidstr = smbldap_talloc_single_attribute(
1278                                 ctx->smbldap_state->ldap_struct,
1279                                 entry, LDAP_ATTRIBUTE_SID, memctx);
1280                 if ( ! sidstr) { /* no sid ??, skip entry */
1281                         DEBUG(2, ("WARNING SID not found on entry\n"));
1282                         continue;
1283                 }
1284
1285                 if ( ! string_to_sid(&sid, sidstr)) {
1286                         DEBUG(2, ("ERROR: Invalid SID on entry\n"));
1287                         TALLOC_FREE(sidstr);
1288                         continue;
1289                 }
1290
1291                 map = find_map_by_sid(&ids[bidx], &sid);
1292                 if (!map) {
1293                         DEBUG(2, ("WARNING: couldn't find entry sid (%s) "
1294                                   "in ids", sidstr));
1295                         TALLOC_FREE(sidstr);
1296                         continue;
1297                 }
1298
1299                 /* now try to see if it is a uid, if not try with a gid
1300                  * (gid is more common, but in case both uidNumber and
1301                  * gidNumber are returned the SID is mapped to the uid
1302                  * not the gid) */
1303                 type = ID_TYPE_UID;
1304                 tmp = smbldap_talloc_single_attribute(
1305                                 ctx->smbldap_state->ldap_struct,
1306                                 entry, uidNumber, memctx);
1307                 if ( ! tmp) {
1308                         type = ID_TYPE_GID;
1309                         tmp = smbldap_talloc_single_attribute(
1310                                         ctx->smbldap_state->ldap_struct,
1311                                         entry, gidNumber, memctx);
1312                 }
1313                 if ( ! tmp) { /* no ids ?? */
1314                         DEBUG(5, ("no uidNumber, "
1315                                   "nor gidNumber attributes found\n"));
1316                         TALLOC_FREE(sidstr);
1317                         continue;
1318                 }
1319
1320                 id = strtoul(tmp, NULL, 10);
1321                 if ((id == 0) ||
1322                     (ctx->filter_low_id && (id < ctx->filter_low_id)) ||
1323                     (ctx->filter_high_id && (id > ctx->filter_high_id))) {
1324                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). "
1325                                   "Filtered!\n", id,
1326                                   ctx->filter_low_id, ctx->filter_high_id));
1327                         TALLOC_FREE(sidstr);
1328                         TALLOC_FREE(tmp);
1329                         continue;
1330                 }
1331                 TALLOC_FREE(tmp);
1332
1333                 if (map->status == ID_MAPPED) {
1334                         DEBUG(1, ("WARNING: duplicate %s mapping in LDAP. "
1335                               "overwriting mapping %s -> %u with %s -> %u\n",
1336                               (type == ID_TYPE_UID) ? "UID" : "GID",
1337                               sidstr, map->xid.id, sidstr, id));
1338                 }
1339
1340                 TALLOC_FREE(sidstr);
1341
1342                 /* mapped */
1343                 map->xid.type = type;
1344                 map->xid.id = id;
1345                 map->status = ID_MAPPED;
1346
1347                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
1348                            (unsigned long)map->xid.id, map->xid.type));
1349         }
1350
1351         /* free the ldap results */
1352         if (result) {
1353                 ldap_msgfree(result);
1354                 result = NULL;
1355         }
1356
1357         if (multi && ids[idx]) { /* still some values to map */
1358                 goto again;
1359         }
1360
1361         ret = NT_STATUS_OK;
1362
1363         /* mark all unknwon/expired ones as unmapped */
1364         for (i = 0; ids[i]; i++) {
1365                 if (ids[i]->status != ID_MAPPED)
1366                         ids[i]->status = ID_UNMAPPED;
1367         }
1368
1369 done:
1370         talloc_free(memctx);
1371         return ret;
1372 }
1373
1374 /**********************************
1375  set a mapping.
1376 **********************************/
1377
1378 /* TODO: change this:  This function cannot be called to modify a mapping,
1379  * only set a new one */
1380
1381 static NTSTATUS idmap_ldap_set_mapping(struct idmap_domain *dom,
1382                                        const struct id_map *map)
1383 {
1384         NTSTATUS ret;
1385         TALLOC_CTX *memctx;
1386         struct idmap_ldap_context *ctx;
1387         LDAPMessage *entry = NULL;
1388         LDAPMod **mods = NULL;
1389         const char *type;
1390         char *id_str;
1391         char *sid;
1392         char *dn;
1393         int rc = -1;
1394
1395         /* Only do query if we are online */
1396         if (idmap_is_offline()) {
1397                 return NT_STATUS_FILE_IS_OFFLINE;
1398         }
1399
1400         ctx = talloc_get_type(dom->private_data, struct idmap_ldap_context);
1401
1402         switch(map->xid.type) {
1403         case ID_TYPE_UID:
1404                 type = get_attr_key2string(sidmap_attr_list,
1405                                            LDAP_ATTR_UIDNUMBER);
1406                 break;
1407
1408         case ID_TYPE_GID:
1409                 type = get_attr_key2string(sidmap_attr_list,
1410                                            LDAP_ATTR_GIDNUMBER);
1411                 break;
1412
1413         default:
1414                 return NT_STATUS_INVALID_PARAMETER;
1415         }
1416
1417         memctx = talloc_new(ctx);
1418         if ( ! memctx) {
1419                 DEBUG(0, ("Out of memory!\n"));
1420                 return NT_STATUS_NO_MEMORY;
1421         }
1422
1423         id_str = talloc_asprintf(memctx, "%lu", (unsigned long)map->xid.id);
1424         CHECK_ALLOC_DONE(id_str);
1425
1426         sid = talloc_strdup(memctx, sid_string_talloc(memctx, map->sid));
1427         CHECK_ALLOC_DONE(sid);
1428
1429         dn = talloc_asprintf(memctx, "%s=%s,%s",
1430                         get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
1431                         sid,
1432                         ctx->suffix);
1433         CHECK_ALLOC_DONE(dn);
1434
1435         smbldap_set_mod(&mods, LDAP_MOD_ADD,
1436                         "objectClass", LDAP_OBJ_IDMAP_ENTRY);
1437
1438         smbldap_make_mod(ctx->smbldap_state->ldap_struct,
1439                          entry, &mods, type, id_str);
1440
1441         smbldap_make_mod(ctx->smbldap_state->ldap_struct, entry, &mods,
1442                          get_attr_key2string(sidmap_attr_list, LDAP_ATTR_SID),
1443                          sid);
1444
1445         if ( ! mods) {
1446                 DEBUG(2, ("ERROR: No mods?\n"));
1447                 ret = NT_STATUS_UNSUCCESSFUL;
1448                 goto done;
1449         }
1450
1451         /* TODO: remove conflicting mappings! */
1452
1453         smbldap_set_mod(&mods, LDAP_MOD_ADD, "objectClass", LDAP_OBJ_SID_ENTRY);
1454
1455         DEBUG(10, ("Set DN %s (%s -> %s)\n", dn, sid, id_str));
1456
1457         rc = smbldap_add(ctx->smbldap_state, dn, mods);
1458         ldap_mods_free(mods, True);
1459
1460         if (rc != LDAP_SUCCESS) {
1461                 char *ld_error = NULL;
1462                 ldap_get_option(ctx->smbldap_state->ldap_struct,
1463                                 LDAP_OPT_ERROR_STRING, &ld_error);
1464                 DEBUG(0,("ldap_set_mapping_internals: Failed to add %s to %lu "
1465                          "mapping [%s]\n", sid,
1466                          (unsigned long)map->xid.id, type));
1467                 DEBUG(0, ("ldap_set_mapping_internals: Error was: %s (%s)\n",
1468                         ld_error ? ld_error : "(NULL)", ldap_err2string (rc)));
1469                 if (ld_error) {
1470                         ldap_memfree(ld_error);
1471                 }
1472                 ret = NT_STATUS_UNSUCCESSFUL;
1473                 goto done;
1474         }
1475
1476         DEBUG(10,("ldap_set_mapping: Successfully created mapping from %s to "
1477                   "%lu [%s]\n", sid, (unsigned long)map->xid.id, type));
1478
1479         ret = NT_STATUS_OK;
1480
1481 done:
1482         talloc_free(memctx);
1483         return ret;
1484 }
1485
1486 /**********************************
1487  Close the idmap ldap instance
1488 **********************************/
1489
1490 static NTSTATUS idmap_ldap_close(struct idmap_domain *dom)
1491 {
1492         struct idmap_ldap_context *ctx;
1493
1494         if (dom->private_data) {
1495                 ctx = talloc_get_type(dom->private_data,
1496                                       struct idmap_ldap_context);
1497
1498                 talloc_free(ctx);
1499                 dom->private_data = NULL;
1500         }
1501
1502         return NT_STATUS_OK;
1503 }
1504
1505 static struct idmap_methods idmap_ldap_methods = {
1506
1507         .init = idmap_ldap_db_init,
1508         .unixids_to_sids = idmap_ldap_unixids_to_sids,
1509         .sids_to_unixids = idmap_ldap_sids_to_unixids,
1510         .set_mapping = idmap_ldap_set_mapping,
1511         .close_fn = idmap_ldap_close
1512 };
1513
1514 static struct idmap_alloc_methods idmap_ldap_alloc_methods = {
1515
1516         .init = idmap_ldap_alloc_init,
1517         .allocate_id = idmap_ldap_allocate_id,
1518         .get_id_hwm = idmap_ldap_get_hwm,
1519         .set_id_hwm = idmap_ldap_set_hwm,
1520         .close_fn = idmap_ldap_alloc_close,
1521         /* .dump_data = TODO */
1522 };
1523
1524 static NTSTATUS idmap_alloc_ldap_init(void)
1525 {
1526         return smb_register_idmap_alloc(SMB_IDMAP_INTERFACE_VERSION, "ldap",
1527                                         &idmap_ldap_alloc_methods);
1528 }
1529
1530 NTSTATUS idmap_ldap_init(void);
1531 NTSTATUS idmap_ldap_init(void)
1532 {
1533         NTSTATUS ret;
1534
1535         /* FIXME: bad hack to actually register also the alloc_ldap module
1536          * without changining configure.in */
1537         ret = idmap_alloc_ldap_init();
1538         if (! NT_STATUS_IS_OK(ret)) {
1539                 return ret;
1540         }
1541         return smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION, "ldap",
1542                                   &idmap_ldap_methods);
1543 }
1544