source3/winbindd/idmap_ad.c

   1 /*
   2  *  idmap_ad: map between Active Directory and RFC 2307 or "Services for Unix" (SFU) Accounts
   3  *
   4  * Unix SMB/CIFS implementation.
   5  *
   6  * Winbind ADS backend functions
   7  *
   8  * Copyright (C) Andrew Tridgell 2001
   9  * Copyright (C) Andrew Bartlett <abartlet@samba.org> 2003
  10  * Copyright (C) Gerald (Jerry) Carter 2004-2007
  11  * Copyright (C) Luke Howard 2001-2004
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 3 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  25  */
  26
  27 #include "includes.h"
  28
  29 #undef DBGC_CLASS
  30 #define DBGC_CLASS DBGC_IDMAP
  31
  32 #define WINBIND_CCACHE_NAME "MEMORY:winbind_ccache"
  33
  34 #define IDMAP_AD_MAX_IDS 30
  35 #define CHECK_ALLOC_DONE(mem) do { \
  36      if (!mem) { \
  37            DEBUG(0, ("Out of memory!\n")); \
  38            ret = NT_STATUS_NO_MEMORY; \
  39            goto done; \
  40       } \
  41 } while (0)
  42
  43 struct idmap_ad_context {
  44         uint32_t filter_low_id;
  45         uint32_t filter_high_id;
  46 };
  47
  48 NTSTATUS init_module(void);
  49
  50 static ADS_STRUCT *ad_idmap_ads = NULL;
  51 static struct posix_schema *ad_schema = NULL;
  52 static enum wb_posix_mapping ad_map_type = WB_POSIX_MAP_UNKNOWN;
  53
  54 /************************************************************************
  55  ***********************************************************************/
  56
  57 static ADS_STRUCT *ad_idmap_cached_connection_internal(void)
  58 {
  59         ADS_STRUCT *ads;
  60         ADS_STATUS status;
  61         bool local = False;
  62         fstring dc_name;
  63         struct sockaddr_storage dc_ip;
  64
  65         if (ad_idmap_ads != NULL) {
  66
  67                 time_t expire;
  68                 time_t now = time(NULL);
  69
  70                 ads = ad_idmap_ads;
  71
  72                 expire = MIN(ads->auth.tgt_expire, ads->auth.tgs_expire);
  73
  74                 /* check for a valid structure */
  75                 DEBUG(7, ("Current tickets expire in %d seconds (at %d, time is now %d)\n",
  76                           (uint32)expire-(uint32)now, (uint32) expire, (uint32) now));
  77
  78                 if ( ads->config.realm && (expire > time(NULL))) {
  79                         return ads;
  80                 } else {
  81                         /* we own this ADS_STRUCT so make sure it goes away */
  82                         DEBUG(7,("Deleting expired krb5 credential cache\n"));
  83                         ads->is_mine = True;
  84                         ads_destroy( &ads );
  85                         ads_kdestroy(WINBIND_CCACHE_NAME);
  86                         ad_idmap_ads = NULL;
  87                         TALLOC_FREE( ad_schema );
  88                 }
  89         }
  90
  91         if (!local) {
  92                 /* we don't want this to affect the users ccache */
  93                 setenv("KRB5CCNAME", WINBIND_CCACHE_NAME, 1);
  94         }
  95
  96         if ( (ads = ads_init(lp_realm(), lp_workgroup(), NULL)) == NULL ) {
  97                 DEBUG(1,("ads_init failed\n"));
  98                 return NULL;
  99         }
 100
 101         /* the machine acct password might have change - fetch it every time */
 102         SAFE_FREE(ads->auth.password);
 103         ads->auth.password = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
 104
 105         SAFE_FREE(ads->auth.realm);
 106         ads->auth.realm = SMB_STRDUP(lp_realm());
 107
 108         /* setup server affinity */
 109
 110         get_dc_name( NULL, ads->auth.realm, dc_name, &dc_ip );
 111
 112         status = ads_connect(ads);
 113         if (!ADS_ERR_OK(status)) {
 114                 DEBUG(1, ("ad_idmap_init: failed to connect to AD\n"));
 115                 ads_destroy(&ads);
 116                 return NULL;
 117         }
 118
 119         ads->is_mine = False;
 120
 121         ad_idmap_ads = ads;
 122
 123         return ads;
 124 }
 125
 126 /************************************************************************
 127  ***********************************************************************/
 128
 129 static ADS_STRUCT *ad_idmap_cached_connection(void)
 130 {
 131         ADS_STRUCT *ads = ad_idmap_cached_connection_internal();
 132
 133         if ( !ads )
 134                 return NULL;
 135
 136         /* if we have a valid ADS_STRUCT and the schema model is
 137            defined, then we can return here. */
 138
 139         if ( ad_schema )
 140                 return ads;
 141
 142         /* Otherwise, set the schema model */
 143
 144         if ( (ad_map_type ==  WB_POSIX_MAP_SFU) ||
 145              (ad_map_type ==  WB_POSIX_MAP_SFU20) ||
 146              (ad_map_type ==  WB_POSIX_MAP_RFC2307) )
 147         {
 148                 ADS_STATUS schema_status;
 149
 150                 schema_status = ads_check_posix_schema_mapping( NULL, ads, ad_map_type, &ad_schema);
 151                 if ( !ADS_ERR_OK(schema_status) ) {
 152                         DEBUG(2,("ad_idmap_cached_connection: Failed to obtain schema details!\n"));
 153                         return NULL;
 154                 }
 155         }
 156
 157         return ads;
 158 }
 159
 160 /************************************************************************
 161  ***********************************************************************/
 162
 163 static NTSTATUS idmap_ad_initialize(struct idmap_domain *dom,
 164                                     const char *params)
 165 {
 166         struct idmap_ad_context *ctx;
 167         char *config_option;
 168         const char *range = NULL;
 169         const char *schema_mode = NULL;
 170
 171         if ( (ctx = TALLOC_ZERO_P(dom, struct idmap_ad_context)) == NULL ) {
 172                 DEBUG(0, ("Out of memory!\n"));
 173                 return NT_STATUS_NO_MEMORY;
 174         }
 175
 176         if ( (config_option = talloc_asprintf(ctx, "idmap config %s", dom->name)) == NULL ) {
 177                 DEBUG(0, ("Out of memory!\n"));
 178                 talloc_free(ctx);
 179                 return NT_STATUS_NO_MEMORY;
 180         }
 181
 182         /* load ranges */
 183         range = lp_parm_const_string(-1, config_option, "range", NULL);
 184         if (range && range[0]) {
 185                 if ((sscanf(range, "%u - %u", &ctx->filter_low_id, &ctx->filter_high_id) != 2) ||
 186                     (ctx->filter_low_id > ctx->filter_high_id)) {
 187                         DEBUG(1, ("ERROR: invalid filter range [%s]", range));
 188                         ctx->filter_low_id = 0;
 189                         ctx->filter_high_id = 0;
 190                 }
 191         }
 192
 193         /* schema mode */
 194         if ( ad_map_type == WB_POSIX_MAP_UNKNOWN )
 195                 ad_map_type = WB_POSIX_MAP_RFC2307;
 196         schema_mode = lp_parm_const_string(-1, config_option, "schema_mode", NULL);
 197         if ( schema_mode && schema_mode[0] ) {
 198                 if ( strequal(schema_mode, "sfu") )
 199                         ad_map_type = WB_POSIX_MAP_SFU;
 200                 else if ( strequal(schema_mode, "sfu20" ) )
 201                         ad_map_type = WB_POSIX_MAP_SFU20;
 202                 else if ( strequal(schema_mode, "rfc2307" ) )
 203                         ad_map_type = WB_POSIX_MAP_RFC2307;
 204                 else
 205                         DEBUG(0,("idmap_ad_initialize: Unknown schema_mode (%s)\n",
 206                                  schema_mode));
 207         }
 208
 209         dom->private_data = ctx;
 210
 211         talloc_free(config_option);
 212
 213         return NT_STATUS_OK;
 214 }
 215
 216 /************************************************************************
 217  Search up to IDMAP_AD_MAX_IDS entries in maps for a match.
 218  ***********************************************************************/
 219
 220 static struct id_map *find_map_by_id(struct id_map **maps, enum id_type type, uint32_t id)
 221 {
 222         int i;
 223
 224         for (i = 0; maps[i] && i<IDMAP_AD_MAX_IDS; i++) {
 225                 if ((maps[i]->xid.type == type) && (maps[i]->xid.id == id)) {
 226                         return maps[i];
 227                 }
 228         }
 229
 230         return NULL;
 231 }
 232
 233 /************************************************************************
 234  Search up to IDMAP_AD_MAX_IDS entries in maps for a match
 235  ***********************************************************************/
 236
 237 static struct id_map *find_map_by_sid(struct id_map **maps, DOM_SID *sid)
 238 {
 239         int i;
 240
 241         for (i = 0; maps[i] && i<IDMAP_AD_MAX_IDS; i++) {
 242                 if (sid_equal(maps[i]->sid, sid)) {
 243                         return maps[i];
 244                 }
 245         }
 246
 247         return NULL;
 248 }
 249
 250 /************************************************************************
 251  ***********************************************************************/
 252
 253 static NTSTATUS idmap_ad_unixids_to_sids(struct idmap_domain *dom, struct id_map **ids)
 254 {
 255         NTSTATUS ret;
 256         TALLOC_CTX *memctx;
 257         struct idmap_ad_context *ctx;
 258         ADS_STATUS rc;
 259         ADS_STRUCT *ads;
 260         const char *attrs[] = { "sAMAccountType",
 261                                 "objectSid",
 262                                 NULL, /* uidnumber */
 263                                 NULL, /* gidnumber */
 264                                 NULL };
 265         LDAPMessage *res = NULL;
 266         LDAPMessage *entry = NULL;
 267         char *filter = NULL;
 268         int idx = 0;
 269         int bidx = 0;
 270         int count;
 271         int i;
 272         char *u_filter = NULL;
 273         char *g_filter = NULL;
 274
 275         /* Only do query if we are online */
 276         if (idmap_is_offline()) {
 277                 return NT_STATUS_FILE_IS_OFFLINE;
 278         }
 279
 280         ctx = talloc_get_type(dom->private_data, struct idmap_ad_context);
 281
 282         if ( (memctx = talloc_new(ctx)) == NULL ) {
 283                 DEBUG(0, ("Out of memory!\n"));
 284                 return NT_STATUS_NO_MEMORY;
 285         }
 286
 287         if ( (ads = ad_idmap_cached_connection()) == NULL ) {
 288                 DEBUG(1, ("ADS uninitialized\n"));
 289                 ret = NT_STATUS_UNSUCCESSFUL;
 290                 goto done;
 291         }
 292
 293         attrs[2] = ad_schema->posix_uidnumber_attr;
 294         attrs[3] = ad_schema->posix_gidnumber_attr;
 295
 296 again:
 297         bidx = idx;
 298         for (i = 0; (i < IDMAP_AD_MAX_IDS) && ids[idx]; i++, idx++) {
 299                 switch (ids[idx]->xid.type) {
 300                 case ID_TYPE_UID:
 301                         if ( ! u_filter) {
 302                                 u_filter = talloc_asprintf(memctx, "(&(|"
 303                                                            "(sAMAccountType=%d)"
 304                                                            "(sAMAccountType=%d)"
 305                                                            "(sAMAccountType=%d))(|",
 306                                                            ATYPE_NORMAL_ACCOUNT,
 307                                                            ATYPE_WORKSTATION_TRUST,
 308                                                            ATYPE_INTERDOMAIN_TRUST);
 309                         }
 310                         u_filter = talloc_asprintf_append_buffer(u_filter, "(%s=%lu)",
 311                                                           ad_schema->posix_uidnumber_attr,
 312                                                           (unsigned long)ids[idx]->xid.id);
 313                         CHECK_ALLOC_DONE(u_filter);
 314                         break;
 315
 316                 case ID_TYPE_GID:
 317                         if ( ! g_filter) {
 318                                 g_filter = talloc_asprintf(memctx, "(&(|"
 319                                                            "(sAMAccountType=%d)"
 320                                                            "(sAMAccountType=%d))(|",
 321                                                            ATYPE_SECURITY_GLOBAL_GROUP,
 322                                                            ATYPE_SECURITY_LOCAL_GROUP);
 323                         }
 324                         g_filter = talloc_asprintf_append_buffer(g_filter, "(%s=%lu)",
 325                                                           ad_schema->posix_gidnumber_attr,
 326                                                           (unsigned long)ids[idx]->xid.id);
 327                         CHECK_ALLOC_DONE(g_filter);
 328                         break;
 329
 330                 default:
 331                         DEBUG(3, ("Error: mapping requested but Unknown ID type\n"));
 332                         ids[idx]->status = ID_UNKNOWN;
 333                         continue;
 334                 }
 335         }
 336         filter = talloc_asprintf(memctx, "(|");
 337         CHECK_ALLOC_DONE(filter);
 338         if ( u_filter) {
 339                 filter = talloc_asprintf_append_buffer(filter, "%s))", u_filter);
 340                 CHECK_ALLOC_DONE(filter);
 341                         TALLOC_FREE(u_filter);
 342         }
 343         if ( g_filter) {
 344                 filter = talloc_asprintf_append_buffer(filter, "%s))", g_filter);
 345                 CHECK_ALLOC_DONE(filter);
 346                 TALLOC_FREE(g_filter);
 347         }
 348         filter = talloc_asprintf_append_buffer(filter, ")");
 349         CHECK_ALLOC_DONE(filter);
 350
 351         rc = ads_search_retry(ads, &res, filter, attrs);
 352         if (!ADS_ERR_OK(rc)) {
 353                 DEBUG(1, ("ERROR: ads search returned: %s\n", ads_errstr(rc)));
 354                 ret = NT_STATUS_UNSUCCESSFUL;
 355                 goto done;
 356         }
 357
 358         if ( (count = ads_count_replies(ads, res)) == 0 ) {
 359                 DEBUG(10, ("No IDs found\n"));
 360         }
 361
 362         entry = res;
 363         for (i = 0; (i < count) && entry; i++) {
 364                 DOM_SID sid;
 365                 enum id_type type;
 366                 struct id_map *map;
 367                 uint32_t id;
 368                 uint32_t atype;
 369
 370                 if (i == 0) { /* first entry */
 371                         entry = ads_first_entry(ads, entry);
 372                 } else { /* following ones */
 373                         entry = ads_next_entry(ads, entry);
 374                 }
 375
 376                 if ( !entry ) {
 377                         DEBUG(2, ("ERROR: Unable to fetch ldap entries from results\n"));
 378                         break;
 379                 }
 380
 381                 /* first check if the SID is present */
 382                 if (!ads_pull_sid(ads, entry, "objectSid", &sid)) {
 383                         DEBUG(2, ("Could not retrieve SID from entry\n"));
 384                         continue;
 385                 }
 386
 387                 /* get type */
 388                 if (!ads_pull_uint32(ads, entry, "sAMAccountType", &atype)) {
 389                         DEBUG(1, ("could not get SAM account type\n"));
 390                         continue;
 391                 }
 392
 393                 switch (atype & 0xF0000000) {
 394                 case ATYPE_SECURITY_GLOBAL_GROUP:
 395                 case ATYPE_SECURITY_LOCAL_GROUP:
 396                         type = ID_TYPE_GID;
 397                         break;
 398                 case ATYPE_NORMAL_ACCOUNT:
 399                 case ATYPE_WORKSTATION_TRUST:
 400                 case ATYPE_INTERDOMAIN_TRUST:
 401                         type = ID_TYPE_UID;
 402                         break;
 403                 default:
 404                         DEBUG(1, ("unrecognized SAM account type %08x\n", atype));
 405                         continue;
 406                 }
 407
 408                 if (!ads_pull_uint32(ads, entry, (type==ID_TYPE_UID) ?
 409                                                  ad_schema->posix_uidnumber_attr :
 410                                                  ad_schema->posix_gidnumber_attr,
 411                                      &id))
 412                 {
 413                         DEBUG(1, ("Could not get unix ID\n"));
 414                         continue;
 415                 }
 416
 417                 if ((id == 0) ||
 418                     (ctx->filter_low_id && (id < ctx->filter_low_id)) ||
 419                     (ctx->filter_high_id && (id > ctx->filter_high_id))) {
 420                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). Filtered!\n",
 421                                 id, ctx->filter_low_id, ctx->filter_high_id));
 422                         continue;
 423                 }
 424
 425                 map = find_map_by_id(&ids[bidx], type, id);
 426                 if (!map) {
 427                         DEBUG(2, ("WARNING: couldn't match result with requested ID\n"));
 428                         continue;
 429                 }
 430
 431                 sid_copy(map->sid, &sid);
 432
 433                 /* mapped */
 434                 map->status = ID_MAPPED;
 435
 436                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
 437                            (unsigned long)map->xid.id,
 438                            map->xid.type));
 439         }
 440
 441         if (res) {
 442                 ads_msgfree(ads, res);
 443         }
 444
 445         if (ids[idx]) { /* still some values to map */
 446                 goto again;
 447         }
 448
 449         ret = NT_STATUS_OK;
 450
 451         /* mark all unknown/expired ones as unmapped */
 452         for (i = 0; ids[i]; i++) {
 453                 if (ids[i]->status != ID_MAPPED)
 454                         ids[i]->status = ID_UNMAPPED;
 455         }
 456
 457 done:
 458         talloc_free(memctx);
 459         return ret;
 460 }
 461
 462 /************************************************************************
 463  ***********************************************************************/
 464
 465 static NTSTATUS idmap_ad_sids_to_unixids(struct idmap_domain *dom, struct id_map **ids)
 466 {
 467         NTSTATUS ret;
 468         TALLOC_CTX *memctx;
 469         struct idmap_ad_context *ctx;
 470         ADS_STATUS rc;
 471         ADS_STRUCT *ads;
 472         const char *attrs[] = { "sAMAccountType",
 473                                 "objectSid",
 474                                 NULL, /* attr_uidnumber */
 475                                 NULL, /* attr_gidnumber */
 476                                 NULL };
 477         LDAPMessage *res = NULL;
 478         LDAPMessage *entry = NULL;
 479         char *filter = NULL;
 480         int idx = 0;
 481         int bidx = 0;
 482         int count;
 483         int i;
 484         char *sidstr;
 485
 486         /* Only do query if we are online */
 487         if (idmap_is_offline()) {
 488                 return NT_STATUS_FILE_IS_OFFLINE;
 489         }
 490
 491         ctx = talloc_get_type(dom->private_data, struct idmap_ad_context);
 492
 493         if ( (memctx = talloc_new(ctx)) == NULL ) {
 494                 DEBUG(0, ("Out of memory!\n"));
 495                 return NT_STATUS_NO_MEMORY;
 496         }
 497
 498         if ( (ads = ad_idmap_cached_connection()) == NULL ) {
 499                 DEBUG(1, ("ADS uninitialized\n"));
 500                 ret = NT_STATUS_UNSUCCESSFUL;
 501                 goto done;
 502         }
 503
 504         attrs[2] = ad_schema->posix_uidnumber_attr;
 505         attrs[3] = ad_schema->posix_gidnumber_attr;
 506
 507 again:
 508         filter = talloc_asprintf(memctx, "(&(|"
 509                                  "(sAMAccountType=%d)(sAMAccountType=%d)(sAMAccountType=%d)" /* user account types */
 510                                  "(sAMAccountType=%d)(sAMAccountType=%d)" /* group account types */
 511                                  ")(|",
 512                                  ATYPE_NORMAL_ACCOUNT, ATYPE_WORKSTATION_TRUST, ATYPE_INTERDOMAIN_TRUST,
 513                                  ATYPE_SECURITY_GLOBAL_GROUP, ATYPE_SECURITY_LOCAL_GROUP);
 514
 515         CHECK_ALLOC_DONE(filter);
 516
 517         bidx = idx;
 518         for (i = 0; (i < IDMAP_AD_MAX_IDS) && ids[idx]; i++, idx++) {
 519
 520                 ids[idx]->status = ID_UNKNOWN;
 521
 522                 sidstr = sid_binstring(ids[idx]->sid);
 523                 filter = talloc_asprintf_append_buffer(filter, "(objectSid=%s)", sidstr);
 524
 525                 free(sidstr);
 526                 CHECK_ALLOC_DONE(filter);
 527         }
 528         filter = talloc_asprintf_append_buffer(filter, "))");
 529         CHECK_ALLOC_DONE(filter);
 530         DEBUG(10, ("Filter: [%s]\n", filter));
 531
 532         rc = ads_search_retry(ads, &res, filter, attrs);
 533         if (!ADS_ERR_OK(rc)) {
 534                 DEBUG(1, ("ERROR: ads search returned: %s\n", ads_errstr(rc)));
 535                 ret = NT_STATUS_UNSUCCESSFUL;
 536                 goto done;
 537         }
 538
 539         if ( (count = ads_count_replies(ads, res)) == 0 ) {
 540                 DEBUG(10, ("No IDs found\n"));
 541         }
 542
 543         entry = res;
 544         for (i = 0; (i < count) && entry; i++) {
 545                 DOM_SID sid;
 546                 enum id_type type;
 547                 struct id_map *map;
 548                 uint32_t id;
 549                 uint32_t atype;
 550
 551                 if (i == 0) { /* first entry */
 552                         entry = ads_first_entry(ads, entry);
 553                 } else { /* following ones */
 554                         entry = ads_next_entry(ads, entry);
 555                 }
 556
 557                 if ( !entry ) {
 558                         DEBUG(2, ("ERROR: Unable to fetch ldap entries from results\n"));
 559                         break;
 560                 }
 561
 562                 /* first check if the SID is present */
 563                 if (!ads_pull_sid(ads, entry, "objectSid", &sid)) {
 564                         DEBUG(2, ("Could not retrieve SID from entry\n"));
 565                         continue;
 566                 }
 567
 568                 map = find_map_by_sid(&ids[bidx], &sid);
 569                 if (!map) {
 570                         DEBUG(2, ("WARNING: couldn't match result with requested SID\n"));
 571                         continue;
 572                 }
 573
 574                 /* get type */
 575                 if (!ads_pull_uint32(ads, entry, "sAMAccountType", &atype)) {
 576                         DEBUG(1, ("could not get SAM account type\n"));
 577                         continue;
 578                 }
 579
 580                 switch (atype & 0xF0000000) {
 581                 case ATYPE_SECURITY_GLOBAL_GROUP:
 582                 case ATYPE_SECURITY_LOCAL_GROUP:
 583                         type = ID_TYPE_GID;
 584                         break;
 585                 case ATYPE_NORMAL_ACCOUNT:
 586                 case ATYPE_WORKSTATION_TRUST:
 587                 case ATYPE_INTERDOMAIN_TRUST:
 588                         type = ID_TYPE_UID;
 589                         break;
 590                 default:
 591                         DEBUG(1, ("unrecognized SAM account type %08x\n", atype));
 592                         continue;
 593                 }
 594
 595                 if (!ads_pull_uint32(ads, entry, (type==ID_TYPE_UID) ?
 596                                                  ad_schema->posix_uidnumber_attr :
 597                                                  ad_schema->posix_gidnumber_attr,
 598                                      &id))
 599                 {
 600                         DEBUG(1, ("Could not get unix ID\n"));
 601                         continue;
 602                 }
 603                 if ((id == 0) ||
 604                     (ctx->filter_low_id && (id < ctx->filter_low_id)) ||
 605                     (ctx->filter_high_id && (id > ctx->filter_high_id))) {
 606                         DEBUG(5, ("Requested id (%u) out of range (%u - %u). Filtered!\n",
 607                                 id, ctx->filter_low_id, ctx->filter_high_id));
 608                         continue;
 609                 }
 610
 611                 /* mapped */
 612                 map->xid.type = type;
 613                 map->xid.id = id;
 614                 map->status = ID_MAPPED;
 615
 616                 DEBUG(10, ("Mapped %s -> %lu (%d)\n", sid_string_dbg(map->sid),
 617                            (unsigned long)map->xid.id,
 618                            map->xid.type));
 619         }
 620
 621         if (res) {
 622                 ads_msgfree(ads, res);
 623         }
 624
 625         if (ids[idx]) { /* still some values to map */
 626                 goto again;
 627         }
 628
 629         ret = NT_STATUS_OK;
 630
 631         /* mark all unknwoni/expired ones as unmapped */
 632         for (i = 0; ids[i]; i++) {
 633                 if (ids[i]->status != ID_MAPPED)
 634                         ids[i]->status = ID_UNMAPPED;
 635         }
 636
 637 done:
 638         talloc_free(memctx);
 639         return ret;
 640 }
 641
 642 /************************************************************************
 643  ***********************************************************************/
 644
 645 static NTSTATUS idmap_ad_close(struct idmap_domain *dom)
 646 {
 647         ADS_STRUCT *ads = ad_idmap_ads;
 648
 649         if (ads != NULL) {
 650                 /* we own this ADS_STRUCT so make sure it goes away */
 651                 ads->is_mine = True;
 652                 ads_destroy( &ads );
 653                 ad_idmap_ads = NULL;
 654         }
 655
 656         TALLOC_FREE( ad_schema );
 657
 658         return NT_STATUS_OK;
 659 }
 660
 661 /*
 662  * nss_info_{sfu,sfu20,rfc2307}
 663  */
 664
 665 /************************************************************************
 666  Initialize the {sfu,sfu20,rfc2307} state
 667  ***********************************************************************/
 668
 669 static NTSTATUS nss_sfu_init( struct nss_domain_entry *e )
 670 {
 671         /* Sanity check if we have previously been called with a
 672            different schema model */
 673
 674         if ( (ad_map_type != WB_POSIX_MAP_UNKNOWN) &&
 675              (ad_map_type != WB_POSIX_MAP_SFU) )
 676         {
 677                 DEBUG(0,("nss_sfu_init: Posix Map type has already been set.  "
 678                          "Mixed schema models not supported!\n"));
 679                 return NT_STATUS_NOT_SUPPORTED;
 680         }
 681
 682         ad_map_type = WB_POSIX_MAP_SFU;
 683
 684         return NT_STATUS_OK;
 685 }
 686
 687 static NTSTATUS nss_sfu20_init( struct nss_domain_entry *e )
 688 {
 689         /* Sanity check if we have previously been called with a
 690            different schema model */
 691
 692         if ( (ad_map_type != WB_POSIX_MAP_UNKNOWN) &&
 693              (ad_map_type != WB_POSIX_MAP_SFU20) )
 694         {
 695                 DEBUG(0,("nss_sfu20_init: Posix Map type has already been set.  "
 696                          "Mixed schema models not supported!\n"));
 697                 return NT_STATUS_NOT_SUPPORTED;
 698         }
 699
 700         ad_map_type = WB_POSIX_MAP_SFU20;
 701
 702         return NT_STATUS_OK;
 703 }
 704
 705 static NTSTATUS nss_rfc2307_init( struct nss_domain_entry *e )
 706 {
 707         /* Sanity check if we have previously been called with a
 708            different schema model */
 709
 710         if ( (ad_map_type != WB_POSIX_MAP_UNKNOWN) &&
 711              (ad_map_type != WB_POSIX_MAP_RFC2307) )
 712         {
 713                 DEBUG(0,("nss_rfc2307_init: Posix Map type has already been set.  "
 714                          "Mixed schema models not supported!\n"));
 715                 return NT_STATUS_NOT_SUPPORTED;
 716         }
 717
 718         ad_map_type = WB_POSIX_MAP_RFC2307;
 719
 720         return NT_STATUS_OK;
 721 }
 722
 723
 724 /************************************************************************
 725  ***********************************************************************/
 726 static NTSTATUS nss_ad_get_info( struct nss_domain_entry *e,
 727                                   const DOM_SID *sid,
 728                                   TALLOC_CTX *ctx,
 729                                   ADS_STRUCT *ads,
 730                                   LDAPMessage *msg,
 731                                   char **homedir,
 732                                   char **shell,
 733                                   char **gecos,
 734                                   uint32 *gid )
 735 {
 736         ADS_STRUCT *ads_internal = NULL;
 737         const char *attrs[] = {NULL, /* attr_homedir */
 738                                NULL, /* attr_shell */
 739                                NULL, /* attr_gecos */
 740                                NULL, /* attr_gidnumber */
 741                                NULL };
 742         char *filter = NULL;
 743         LDAPMessage *msg_internal = NULL;
 744         ADS_STATUS ads_status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
 745         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 746         char *sidstr = NULL;
 747
 748         /* Only do query if we are online */
 749         if (idmap_is_offline()) {
 750                 return NT_STATUS_FILE_IS_OFFLINE;
 751         }
 752
 753         /* We are assuming that the internal ADS_STRUCT is for the
 754            same forest as the incoming *ads pointer */
 755
 756         ads_internal = ad_idmap_cached_connection();
 757
 758         if ( !ads_internal || !ad_schema ) {
 759                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 760         }
 761
 762         if (!sid || !homedir || !shell || !gecos) {
 763                 return NT_STATUS_INVALID_PARAMETER;
 764         }
 765
 766         /* See if we can use the ADS connection struct swe were given */
 767
 768         if (ads) {
 769                 *homedir = ads_pull_string( ads, ctx, msg, ad_schema->posix_homedir_attr );
 770                 *shell   = ads_pull_string( ads, ctx, msg, ad_schema->posix_shell_attr );
 771                 *gecos   = ads_pull_string( ads, ctx, msg, ad_schema->posix_gecos_attr );
 772
 773                 if (gid) {
 774                         if ( !ads_pull_uint32(ads, msg, ad_schema->posix_gidnumber_attr, gid ) )
 775                                 *gid = (uint32)-1;
 776                 }
 777
 778                 nt_status = NT_STATUS_OK;
 779                 goto done;
 780         }
 781
 782         /* Have to do our own query */
 783
 784         attrs[0] = ad_schema->posix_homedir_attr;
 785         attrs[1] = ad_schema->posix_shell_attr;
 786         attrs[2] = ad_schema->posix_gecos_attr;
 787         attrs[3] = ad_schema->posix_gidnumber_attr;
 788
 789         sidstr = sid_binstring(sid);
 790         filter = talloc_asprintf(ctx, "(objectSid=%s)", sidstr);
 791         SAFE_FREE(sidstr);
 792
 793         if (!filter) {
 794                 nt_status = NT_STATUS_NO_MEMORY;
 795                 goto done;
 796         }
 797
 798         ads_status = ads_search_retry(ads_internal, &msg_internal, filter, attrs);
 799         if (!ADS_ERR_OK(ads_status)) {
 800                 nt_status = ads_ntstatus(ads_status);
 801                 goto done;
 802         }
 803
 804         *homedir = ads_pull_string(ads_internal, ctx, msg_internal, ad_schema->posix_homedir_attr);
 805         *shell   = ads_pull_string(ads_internal, ctx, msg_internal, ad_schema->posix_shell_attr);
 806         *gecos   = ads_pull_string(ads_internal, ctx, msg_internal, ad_schema->posix_gecos_attr);
 807
 808         if (gid) {
 809                 if (!ads_pull_uint32(ads_internal, msg_internal, ad_schema->posix_gidnumber_attr, gid))
 810                         *gid = (uint32)-1;
 811         }
 812
 813         nt_status = NT_STATUS_OK;
 814
 815 done:
 816         if (msg_internal) {
 817                 ads_msgfree(ads_internal, msg_internal);
 818         }
 819
 820         return nt_status;
 821 }
 822
 823 /**********************************************************************
 824  *********************************************************************/
 825
 826 static NTSTATUS nss_ad_map_to_alias(TALLOC_CTX *mem_ctx,
 827                                     const char *domain,
 828                                     const char *name,
 829                                     char **alias)
 830 {
 831         ADS_STRUCT *ads_internal = NULL;
 832         const char *attrs[] = {NULL, /* attr_uid */
 833                                NULL };
 834         char *filter = NULL;
 835         LDAPMessage *msg = NULL;
 836         ADS_STATUS ads_status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
 837         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 838
 839         /* Check incoming parameters */
 840
 841         if ( !domain || !name || !*alias) {
 842                 nt_status = NT_STATUS_INVALID_PARAMETER;
 843                 goto done;
 844         }
 845
 846         /* Only do query if we are online */
 847
 848         if (idmap_is_offline()) {
 849                 nt_status = NT_STATUS_FILE_IS_OFFLINE;
 850                 goto done;
 851         }
 852
 853         ads_internal = ad_idmap_cached_connection();
 854
 855         if (!ads_internal || !ad_schema) {
 856                 nt_status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
 857                 goto done;
 858         }
 859
 860         attrs[0] = ad_schema->posix_uid_attr;
 861
 862         filter = talloc_asprintf(mem_ctx,
 863                                  "(sAMAccountName=%s)",
 864                                  name);
 865         if (!filter) {
 866                 nt_status = NT_STATUS_NO_MEMORY;
 867                 goto done;
 868         }
 869
 870         ads_status = ads_search_retry(ads_internal, &msg, filter, attrs);
 871         if (!ADS_ERR_OK(ads_status)) {
 872                 nt_status = ads_ntstatus(ads_status);
 873                 goto done;
 874         }
 875
 876         *alias = ads_pull_string(ads_internal, mem_ctx, msg, ad_schema->posix_uid_attr );
 877
 878         if (!*alias) {
 879                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 880         }
 881
 882         nt_status = NT_STATUS_OK;
 883
 884 done:
 885         if (filter) {
 886                 talloc_destroy(filter);
 887         }
 888         if (msg) {
 889                 ads_msgfree(ads_internal, msg);
 890         }
 891
 892         return nt_status;
 893 }
 894
 895 /**********************************************************************
 896  *********************************************************************/
 897
 898 static NTSTATUS nss_ad_map_from_alias( TALLOC_CTX *mem_ctx,
 899                                              const char *domain,
 900                                              const char *alias,
 901                                              char **name )
 902 {
 903         ADS_STRUCT *ads_internal = NULL;
 904         const char *attrs[] = {"sAMAccountName",
 905                                NULL };
 906         char *filter = NULL;
 907         LDAPMessage *msg = NULL;
 908         ADS_STATUS ads_status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
 909         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
 910         char *username;
 911
 912         /* Check incoming parameters */
 913
 914         if ( !alias || !name) {
 915                 nt_status = NT_STATUS_INVALID_PARAMETER;
 916                 goto done;
 917         }
 918
 919         /* Only do query if we are online */
 920
 921         if (idmap_is_offline()) {
 922                 nt_status = NT_STATUS_FILE_IS_OFFLINE;
 923                 goto done;
 924         }
 925
 926         ads_internal = ad_idmap_cached_connection();
 927
 928         if (!ads_internal || !ad_schema) {
 929                 nt_status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
 930                 goto done;
 931         }
 932
 933         filter = talloc_asprintf(mem_ctx,
 934                                  "(%s=%s)",
 935                                  ad_schema->posix_uid_attr,
 936                                  alias);
 937         if (!filter) {
 938                 nt_status = NT_STATUS_NO_MEMORY;
 939                 goto done;
 940         }
 941
 942         ads_status = ads_search_retry(ads_internal, &msg, filter, attrs);
 943         if (!ADS_ERR_OK(ads_status)) {
 944                 nt_status = ads_ntstatus(ads_status);
 945                 goto done;
 946         }
 947
 948         username = ads_pull_string(ads_internal, mem_ctx, msg,
 949                                    "sAMAccountName");
 950         if (!username) {
 951                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 952         }
 953
 954         *name = talloc_asprintf(mem_ctx, "%s\\%s",
 955                                 lp_workgroup(),
 956                                 username);
 957         if (!*name) {
 958                 nt_status = NT_STATUS_NO_MEMORY;
 959                 goto done;
 960         }
 961
 962         nt_status = NT_STATUS_OK;
 963
 964 done:
 965         if (filter) {
 966                 talloc_destroy(filter);
 967         }
 968         if (msg) {
 969                 ads_msgfree(ads_internal, msg);
 970         }
 971
 972         return nt_status;
 973 }
 974
 975
 976 /************************************************************************
 977  ***********************************************************************/
 978
 979 static NTSTATUS nss_ad_close( void )
 980 {
 981         /* nothing to do.  All memory is free()'d by the idmap close_fn() */
 982
 983         return NT_STATUS_OK;
 984 }
 985
 986 /************************************************************************
 987  Function dispatch tables for the idmap and nss plugins
 988  ***********************************************************************/
 989
 990 static struct idmap_methods ad_methods = {
 991         .init            = idmap_ad_initialize,
 992         .unixids_to_sids = idmap_ad_unixids_to_sids,
 993         .sids_to_unixids = idmap_ad_sids_to_unixids,
 994         .close_fn        = idmap_ad_close
 995 };
 996
 997 /* The SFU and RFC2307 NSS plugins share everything but the init
 998    function which sets the intended schema model to use */
 999
1000 static struct nss_info_methods nss_rfc2307_methods = {
1001         .init           = nss_rfc2307_init,
1002         .get_nss_info   = nss_ad_get_info,
1003         .map_to_alias   = nss_ad_map_to_alias,
1004         .map_from_alias = nss_ad_map_from_alias,
1005         .close_fn       = nss_ad_close
1006 };
1007
1008 static struct nss_info_methods nss_sfu_methods = {
1009         .init           = nss_sfu_init,
1010         .get_nss_info   = nss_ad_get_info,
1011         .map_to_alias   = nss_ad_map_to_alias,
1012         .map_from_alias = nss_ad_map_from_alias,
1013         .close_fn       = nss_ad_close
1014 };
1015
1016 static struct nss_info_methods nss_sfu20_methods = {
1017         .init           = nss_sfu20_init,
1018         .get_nss_info   = nss_ad_get_info,
1019         .map_to_alias   = nss_ad_map_to_alias,
1020         .map_from_alias = nss_ad_map_from_alias,
1021         .close_fn       = nss_ad_close
1022 };
1023
1024
1025
1026 /************************************************************************
1027  Initialize the plugins
1028  ***********************************************************************/
1029
1030 NTSTATUS idmap_ad_init(void)
1031 {
1032         static NTSTATUS status_idmap_ad = NT_STATUS_UNSUCCESSFUL;
1033         static NTSTATUS status_nss_rfc2307 = NT_STATUS_UNSUCCESSFUL;
1034         static NTSTATUS status_nss_sfu = NT_STATUS_UNSUCCESSFUL;
1035         static NTSTATUS status_nss_sfu20 = NT_STATUS_UNSUCCESSFUL;
1036
1037         /* Always register the AD method first in order to get the
1038            idmap_domain interface called */
1039
1040         if ( !NT_STATUS_IS_OK(status_idmap_ad) ) {
1041                 status_idmap_ad = smb_register_idmap(SMB_IDMAP_INTERFACE_VERSION,
1042                                                      "ad", &ad_methods);
1043                 if ( !NT_STATUS_IS_OK(status_idmap_ad) )
1044                         return status_idmap_ad;
1045         }
1046
1047         if ( !NT_STATUS_IS_OK( status_nss_rfc2307 ) ) {
1048                 status_nss_rfc2307 = smb_register_idmap_nss(SMB_NSS_INFO_INTERFACE_VERSION,
1049                                                             "rfc2307",  &nss_rfc2307_methods );
1050                 if ( !NT_STATUS_IS_OK(status_nss_rfc2307) )
1051                         return status_nss_rfc2307;
1052         }
1053
1054         if ( !NT_STATUS_IS_OK( status_nss_sfu ) ) {
1055                 status_nss_sfu = smb_register_idmap_nss(SMB_NSS_INFO_INTERFACE_VERSION,
1056                                                         "sfu",  &nss_sfu_methods );
1057                 if ( !NT_STATUS_IS_OK(status_nss_sfu) )
1058                         return status_nss_sfu;
1059         }
1060
1061         if ( !NT_STATUS_IS_OK( status_nss_sfu20 ) ) {
1062                 status_nss_sfu20 = smb_register_idmap_nss(SMB_NSS_INFO_INTERFACE_VERSION,
1063                                                         "sfu20",  &nss_sfu20_methods );
1064                 if ( !NT_STATUS_IS_OK(status_nss_sfu20) )
1065                         return status_nss_sfu20;
1066         }
1067
1068         return NT_STATUS_OK;
1069 }
1070