source3/libads/ldap.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    ads (active directory) utility library
   4    Copyright (C) Andrew Tridgell 2001
   5    Copyright (C) Remus Koos 2001
   6    Copyright (C) Jim McDonough 2002
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 #ifdef HAVE_ADS
  26
  27 /*
  28   connect to the LDAP server
  29 */
  30 ADS_STATUS ads_connect(ADS_STRUCT *ads)
  31 {
  32         int version = LDAP_VERSION3;
  33         int code;
  34         ADS_STATUS status;
  35
  36         ads->last_attempt = time(NULL);
  37
  38         ads->ld = ldap_open(ads->ldap_server, ads->ldap_port);
  39         if (!ads->ld) {
  40                 return ADS_ERROR_SYSTEM(errno);
  41         }
  42         status = ads_server_info(ads);
  43         if (!ADS_ERR_OK(status)) {
  44                 DEBUG(1,("Failed to get ldap server info\n"));
  45                 return status;
  46         }
  47
  48         ldap_set_option(ads->ld, LDAP_OPT_PROTOCOL_VERSION, &version);
  49
  50         if (ads->password) {
  51                 if ((code = ads_kinit_password(ads)))
  52                         return ADS_ERROR_KRB5(code);
  53         }
  54
  55         return ads_sasl_bind(ads);
  56 }
  57
  58 /*
  59   do a search with a timeout
  60 */
  61 ADS_STATUS ads_do_search(ADS_STRUCT *ads, const char *bind_path, int scope,
  62                          const char *exp,
  63                          const char **attrs, void **res)
  64 {
  65         struct timeval timeout;
  66         int rc;
  67
  68         timeout.tv_sec = ADS_SEARCH_TIMEOUT;
  69         timeout.tv_usec = 0;
  70         *res = NULL;
  71
  72         rc = ldap_search_ext_s(ads->ld,
  73                                bind_path, scope,
  74                                exp, (char **) attrs, 0, NULL, NULL,
  75                                &timeout, LDAP_NO_LIMIT, (LDAPMessage **)res);
  76         return ADS_ERROR(rc);
  77 }
  78 /*
  79   do a general ADS search
  80 */
  81 ADS_STATUS ads_search(ADS_STRUCT *ads, void **res,
  82                       const char *exp,
  83                       const char **attrs)
  84 {
  85         return ads_do_search(ads, ads->bind_path, LDAP_SCOPE_SUBTREE,
  86                              exp, attrs, res);
  87 }
  88
  89 /*
  90   do a search on a specific DistinguishedName
  91 */
  92 ADS_STATUS ads_search_dn(ADS_STRUCT *ads, void **res,
  93                          const char *dn,
  94                          const char **attrs)
  95 {
  96         return ads_do_search(ads, dn, LDAP_SCOPE_BASE, "(objectclass=*)", attrs, res);
  97 }
  98
  99 /*
 100   free up memory from a ads_search
 101 */
 102 void ads_msgfree(ADS_STRUCT *ads, void *msg)
 103 {
 104         if (!msg) return;
 105         ldap_msgfree(msg);
 106 }
 107
 108 /*
 109   free up memory from various ads requests
 110 */
 111 void ads_memfree(ADS_STRUCT *ads, void *mem)
 112 {
 113         if (!mem) return;
 114         ldap_memfree(mem);
 115 }
 116
 117 /*
 118   get a dn from search results
 119 */
 120 char *ads_get_dn(ADS_STRUCT *ads, void *res)
 121 {
 122         return ldap_get_dn(ads->ld, res);
 123 }
 124
 125 /*
 126   find a machine account given a hostname
 127 */
 128 ADS_STATUS ads_find_machine_acct(ADS_STRUCT *ads, void **res, const char *host)
 129 {
 130         ADS_STATUS status;
 131         char *exp;
 132         const char *attrs[] = {"*", "nTSecurityDescriptor", NULL};
 133
 134         /* the easiest way to find a machine account anywhere in the tree
 135            is to look for hostname$ */
 136         asprintf(&exp, "(samAccountName=%s$)", host);
 137         status = ads_search(ads, res, exp, attrs);
 138         free(exp);
 139         return status;
 140 }
 141
 142 /*
 143   duplicate an already-assembled list of values so that it can be
 144   freed as part of the standard msgfree call
 145 */
 146 static char **ads_dup_values(TALLOC_CTX *ctx, char **values)
 147 {
 148         char **newvals;
 149         int i;
 150 #define ADS_MAX_NUM_VALUES 32
 151
 152         for (i=0; values[i] && i<ADS_MAX_NUM_VALUES; i++);
 153         if (!(newvals = talloc_zero(ctx, (i+1)*sizeof(char *))))
 154                 return NULL;
 155         for (i=0; values[i] && i<ADS_MAX_NUM_VALUES; i++)
 156                 newvals[i] = values[i];
 157         newvals[i] = NULL;
 158         return newvals;
 159 }
 160
 161 /*
 162   initialize a list of mods
 163 */
 164
 165 ADS_MODLIST ads_init_mods(TALLOC_CTX *ctx)
 166 {
 167 #define ADS_MODLIST_ALLOC_SIZE 10
 168         LDAPMod **mods;
 169
 170         if ((mods = (LDAPMod **) talloc_zero(ctx, sizeof(LDAPMod *) *
 171                                              (ADS_MODLIST_ALLOC_SIZE + 1))))
 172                 /* -1 is safety to make sure we don't go over the end.
 173                    need to reset it to NULL before doing ldap modify */
 174                 mods[ADS_MODLIST_ALLOC_SIZE] = (LDAPMod *) -1;
 175
 176         return mods;
 177 }
 178
 179 /*
 180   add an attribute to the list, with values list already constructed
 181 */
 182 static ADS_STATUS ads_modlist_add(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 183                                   int mod_op, char *name, char **values)
 184 {
 185         int curmod;
 186         LDAPMod **modlist = (LDAPMod **) *mods;
 187
 188         /* find the first empty slot */
 189         for (curmod=0; modlist[curmod] && modlist[curmod] != (LDAPMod *) -1;
 190              curmod++);
 191         if (modlist[curmod] == (LDAPMod *) -1) {
 192                 if (!(modlist = talloc_realloc(ctx, modlist,
 193                         (curmod+ADS_MODLIST_ALLOC_SIZE+1)*sizeof(LDAPMod *))))
 194                         return ADS_ERROR(LDAP_NO_MEMORY);
 195                 memset(&modlist[curmod], 0,
 196                        ADS_MODLIST_ALLOC_SIZE*sizeof(LDAPMod *));
 197                 modlist[curmod+ADS_MODLIST_ALLOC_SIZE] = (LDAPMod *) -1;
 198                 *mods = modlist;
 199         }
 200
 201         if (!(modlist[curmod] = talloc_zero(ctx, sizeof(LDAPMod))))
 202                 return ADS_ERROR(LDAP_NO_MEMORY);
 203         modlist[curmod]->mod_type = name;
 204         if (mod_op & LDAP_MOD_BVALUES)
 205                 modlist[curmod]->mod_bvalues = (struct berval **) values;
 206         else
 207                 modlist[curmod]->mod_values = values;
 208         modlist[curmod]->mod_op = mod_op;
 209         return ADS_ERROR(LDAP_SUCCESS);
 210 }
 211
 212 ADS_STATUS ads_mod_add_list(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 213                             char *name, char **values)
 214 {
 215         char **newvals = ads_dup_values(ctx, values);
 216         if (newvals)
 217                 return ads_modlist_add(ctx, mods, LDAP_MOD_ADD, name, newvals);
 218         else
 219                 return ADS_ERROR(LDAP_NO_MEMORY);
 220 }
 221
 222 ADS_STATUS ads_mod_repl_list(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 223                              char *name, char **values)
 224 {
 225         char **newvals;
 226         if (values && *values) {
 227                 if (!(newvals = ads_dup_values(ctx, values)))
 228                         return ADS_ERROR(LDAP_NO_MEMORY);
 229                 else
 230                         return ads_modlist_add(ctx, mods, LDAP_MOD_REPLACE,
 231                                                 name, newvals);
 232         }
 233         else
 234                 return ads_modlist_add(ctx, mods, LDAP_MOD_DELETE, name, NULL);
 235 }
 236
 237 /*
 238   add an attribute to the list, with values list to be built from args
 239 */
 240 ADS_STATUS ads_mod_add_var(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 241                            int mod_op, char *name, ...)
 242 {
 243         va_list ap;
 244         int num_vals, i, do_op;
 245         char *value, **values;
 246
 247         /* count the number of values */
 248         va_start(ap, name);
 249         for (num_vals=0; va_arg(ap, char *); num_vals++);
 250         va_end(ap);
 251
 252         if (num_vals) {
 253                 if (!(values = talloc_zero(ctx, sizeof(char *)*(num_vals+1))))
 254                         return ADS_ERROR(LDAP_NO_MEMORY);
 255                 va_start(ap, name);
 256                 for (i=0; (value = (char *) va_arg(ap, char *)) &&
 257                              i < num_vals; i++)
 258                         values[i] = value;
 259                 va_end(ap);
 260                 values[i] = NULL;
 261                 do_op = mod_op;
 262         } else {
 263                 do_op = LDAP_MOD_DELETE;
 264                 values = NULL;
 265         }
 266         return ads_modlist_add(ctx, mods, do_op, name, values);
 267 }
 268
 269 ADS_STATUS ads_mod_add_ber(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 270                            int mod_op, char *name, ...)
 271 {
 272         va_list ap;
 273         int num_vals, i, do_op;
 274         char *value, **values;
 275
 276         /* count the number of values */
 277         va_start(ap, name);
 278         for (num_vals=0; va_arg(ap, struct berval *); num_vals++);
 279         va_end(ap);
 280
 281         if (num_vals) {
 282                 if (!(values = talloc_zero(ctx, sizeof(struct berval) *
 283                                            (num_vals + 1))))
 284                         return ADS_ERROR(LDAP_NO_MEMORY);
 285                 va_start(ap, name);
 286                 for (i=0; (value = (char *) va_arg(ap, char *)) &&
 287                              i < num_vals; i++)
 288                         values[i] = value;
 289                 va_end(ap);
 290                 values[i] = NULL;
 291                 do_op = mod_op;
 292         } else {
 293                 do_op = LDAP_MOD_DELETE;
 294                 values = NULL;
 295         }
 296         do_op |= LDAP_MOD_BVALUES;
 297         return ads_modlist_add(ctx, mods, do_op, name, values);
 298 }
 299
 300 ADS_STATUS ads_mod_repl(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 301                         char *name, char *val)
 302 {
 303         if (val)
 304                 return ads_mod_add_var(ctx, mods, LDAP_MOD_REPLACE,
 305                                        name, val, NULL);
 306         else
 307                 return ads_mod_add_var(ctx, mods, LDAP_MOD_DELETE, name, NULL);
 308 }
 309
 310 ADS_STATUS ads_mod_add(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 311                        char *name, char *val)
 312 {
 313         return ads_mod_add_var(ctx, mods, LDAP_MOD_ADD, name, val, NULL);
 314 }
 315
 316 ADS_STATUS ads_mod_add_len(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 317                            char *name, size_t size, char *val)
 318 {
 319         struct berval *bval = NULL;
 320
 321         if (!(bval = talloc_zero(ctx, sizeof(struct berval *))))
 322                 return ADS_ERROR(LDAP_NO_MEMORY);
 323         if (!(bval->bv_val = talloc_zero(ctx, sizeof(char *))))
 324                 return ADS_ERROR(LDAP_NO_MEMORY);
 325
 326         bval->bv_val = val;
 327         bval->bv_len = size;
 328         return ads_mod_add_ber(ctx, mods, LDAP_MOD_ADD, name, bval, NULL);
 329 }
 330
 331 ADS_STATUS ads_mod_repl_len(TALLOC_CTX *ctx, ADS_MODLIST *mods,
 332                            char *name, size_t size, char *val)
 333 {
 334         struct berval *bval = NULL;
 335
 336         if (!(bval = talloc_zero(ctx, sizeof(struct berval *))))
 337                 return ADS_ERROR(LDAP_NO_MEMORY);
 338
 339         if (!val)
 340                 return ads_mod_add_ber(ctx, mods, LDAP_MOD_DELETE, name, NULL);
 341         else {
 342                 if (!(bval->bv_val = talloc_zero(ctx, sizeof(char *))))
 343                         return ADS_ERROR(LDAP_NO_MEMORY);
 344                 bval->bv_val = val;
 345                 bval->bv_len = size;
 346                 return ads_mod_add_ber(ctx, mods, LDAP_MOD_ADD, name,
 347                                        bval, NULL);
 348         }
 349 }
 350
 351 ADS_STATUS ads_gen_mod(ADS_STRUCT *ads, const char *mod_dn, ADS_MODLIST mods)
 352 {
 353         int ret,i;
 354         /*
 355            this control is needed to modify that contains a currently
 356            non-existent attribute (but allowable for the object) to run
 357         */
 358         LDAPControl PermitModify = {
 359                 "1.2.840.113556.1.4.1413",
 360                 {0, NULL},
 361                 (char) 1};
 362         LDAPControl *controls[2] = {
 363                 &PermitModify,
 364                 NULL };
 365
 366         /* find the end of the list, marked by NULL or -1 */
 367         for(i=0;(mods[i]!=0)&&(mods[i]!=(LDAPMod *) -1);i++);
 368         /* make sure the end of the list is NULL */
 369         mods[i] = NULL;
 370         ret = ldap_modify_ext_s(ads->ld, mod_dn, (LDAPMod **) mods,
 371                                 controls, NULL);
 372         return ADS_ERROR(ret);
 373 }
 374
 375 ADS_STATUS ads_gen_add(ADS_STRUCT *ads, const char *new_dn, ADS_MODLIST mods)
 376 {
 377         int i;
 378
 379         /* find the end of the list, marked by NULL or -1 */
 380         for(i=0;(mods[i]!=0)&&(mods[i]!=(LDAPMod *) -1);i++);
 381         /* make sure the end of the list is NULL */
 382         mods[i] = NULL;
 383
 384         return ADS_ERROR(ldap_add_s(ads->ld, new_dn, mods));
 385 }
 386
 387 ADS_STATUS ads_del_dn(ADS_STRUCT *ads, char *del_dn)
 388 {
 389         return ADS_ERROR(ldap_delete(ads->ld, del_dn));
 390 }
 391
 392 /*
 393   build an org unit string
 394   if org unit is Computers or blank then assume a container, otherwise
 395   assume a \ separated list of organisational units
 396   caller must free
 397 */
 398 char *ads_ou_string(const char *org_unit)
 399 {
 400         if (!org_unit || !*org_unit || strcasecmp(org_unit, "Computers") == 0) {
 401                 return strdup("cn=Computers");
 402         }
 403
 404         return ads_build_path(org_unit, "\\/", "ou=", 1);
 405 }
 406
 407
 408
 409 /*
 410   add a machine account to the ADS server
 411 */
 412 static ADS_STATUS ads_add_machine_acct(ADS_STRUCT *ads, const char *hostname,
 413                                        const char *org_unit)
 414 {
 415         ADS_STATUS ret;
 416         char *host_spn, *host_upn, *new_dn, *samAccountName, *controlstr;
 417         char *ou_str;
 418         TALLOC_CTX *ctx;
 419         ADS_MODLIST mods;
 420
 421         if (!(ctx = talloc_init_named("machine_account")))
 422                 return ADS_ERROR(LDAP_NO_MEMORY);
 423
 424         ret = ADS_ERROR(LDAP_NO_MEMORY);
 425
 426         if (!(host_spn = talloc_asprintf(ctx, "HOST/%s", hostname)))
 427                 goto done;
 428         if (!(host_upn = talloc_asprintf(ctx, "%s@%s", host_spn, ads->realm)))
 429                 goto done;
 430         ou_str = ads_ou_string(org_unit);
 431         new_dn = talloc_asprintf(ctx, "cn=%s,%s,%s", hostname, ou_str,
 432                                  ads->bind_path);
 433         free(ou_str);
 434         if (!new_dn)
 435                 goto done;
 436
 437         if (!(samAccountName = talloc_asprintf(ctx, "%s$", hostname)))
 438                 goto done;
 439         if (!(controlstr = talloc_asprintf(ctx, "%u",
 440                    UF_DONT_EXPIRE_PASSWD | UF_WORKSTATION_TRUST_ACCOUNT |
 441                    UF_TRUSTED_FOR_DELEGATION | UF_USE_DES_KEY_ONLY)))
 442                 goto done;
 443
 444         if (!(mods = ads_init_mods(ctx)))
 445                 goto done;
 446
 447         ads_mod_add(ctx, &mods, "cn", hostname);
 448         ads_mod_add(ctx, &mods, "sAMAccountName", samAccountName);
 449         ads_mod_add_var(ctx, &mods, LDAP_MOD_ADD, "objectClass",
 450                         "top", "person", "organizationalPerson",
 451                         "user", "computer", NULL);
 452         ads_mod_add(ctx, &mods, "userPrincipalName", host_upn);
 453         ads_mod_add(ctx, &mods, "servicePrincipalName", host_spn);
 454         ads_mod_add(ctx, &mods, "dNSHostName", hostname);
 455         ads_mod_add(ctx, &mods, "userAccountControl", controlstr);
 456         ads_mod_add(ctx, &mods, "operatingSystem", "Samba");
 457         ads_mod_add(ctx, &mods, "operatingSystemVersion", VERSION);
 458
 459         ret = ads_gen_add(ads, new_dn, mods);
 460
 461 done:
 462         talloc_destroy(ctx);
 463         return ret;
 464 }
 465
 466 /*
 467   dump a binary result from ldap
 468 */
 469 static void dump_binary(const char *field, struct berval **values)
 470 {
 471         int i, j;
 472         for (i=0; values[i]; i++) {
 473                 printf("%s: ", field);
 474                 for (j=0; j<values[i]->bv_len; j++) {
 475                         printf("%02X", (unsigned char)values[i]->bv_val[j]);
 476                 }
 477                 printf("\n");
 478         }
 479 }
 480
 481 /*
 482   dump a sid result from ldap
 483 */
 484 static void dump_sid(const char *field, struct berval **values)
 485 {
 486         int i;
 487         for (i=0; values[i]; i++) {
 488                 DOM_SID sid;
 489                 sid_parse(values[i]->bv_val, values[i]->bv_len, &sid);
 490                 printf("%s: %s\n", field, sid_string_static(&sid));
 491         }
 492 }
 493
 494 /*
 495   dump a string result from ldap
 496 */
 497 static void dump_string(const char *field, struct berval **values)
 498 {
 499         int i;
 500         for (i=0; values[i]; i++) {
 501                 printf("%s: %s\n", field, values[i]->bv_val);
 502         }
 503 }
 504
 505 /*
 506   dump a record from LDAP on stdout
 507   used for debugging
 508 */
 509 void ads_dump(ADS_STRUCT *ads, void *res)
 510 {
 511         char *field;
 512         void *msg;
 513         BerElement *b;
 514         struct {
 515                 char *name;
 516                 void (*handler)(const char *, struct berval **);
 517         } handlers[] = {
 518                 {"objectGUID", dump_binary},
 519                 {"nTSecurityDescriptor", dump_binary},
 520                 {"objectSid", dump_sid},
 521                 {NULL, NULL}
 522         };
 523
 524         for (msg = ads_first_entry(ads, res); msg; msg = ads_next_entry(ads, msg)) {
 525                 for (field = ldap_first_attribute(ads->ld, (LDAPMessage *)msg, &b);
 526                      field;
 527                      field = ldap_next_attribute(ads->ld, (LDAPMessage *)msg, b)) {
 528                         struct berval **values;
 529                         int i;
 530
 531                         values = ldap_get_values_len(ads->ld, (LDAPMessage *)msg, field);
 532
 533                         for (i=0; handlers[i].name; i++) {
 534                                 if (StrCaseCmp(handlers[i].name, field) == 0) {
 535                                         handlers[i].handler(field, values);
 536                                         break;
 537                                 }
 538                         }
 539                         if (!handlers[i].name) {
 540                                 dump_string(field, values);
 541                         }
 542                         ldap_value_free_len(values);
 543                         ldap_memfree(field);
 544                 }
 545
 546                 ber_free(b, 1);
 547                 printf("\n");
 548         }
 549 }
 550
 551 /*
 552   count how many replies are in a LDAPMessage
 553 */
 554 int ads_count_replies(ADS_STRUCT *ads, void *res)
 555 {
 556         return ldap_count_entries(ads->ld, (LDAPMessage *)res);
 557 }
 558
 559 /*
 560   join a machine to a realm, creating the machine account
 561   and setting the machine password
 562 */
 563 ADS_STATUS ads_join_realm(ADS_STRUCT *ads, const char *hostname, const char *org_unit)
 564 {
 565         ADS_STATUS status;
 566         LDAPMessage *res;
 567         char *host;
 568
 569         /* hostname must be lowercase */
 570         host = strdup(hostname);
 571         strlower(host);
 572
 573         status = ads_find_machine_acct(ads, (void **)&res, host);
 574         if (ADS_ERR_OK(status) && ads_count_replies(ads, res) == 1) {
 575                 DEBUG(0, ("Host account for %s already exists - deleting for readd\n", host));
 576                 status = ads_leave_realm(ads, host);
 577                 if (!ADS_ERR_OK(status)) {
 578                         DEBUG(0, ("Failed to delete host '%s' from the '%s' realm.\n",
 579                                   host, ads->realm));
 580                         return status;
 581                 }
 582         }
 583
 584         status = ads_add_machine_acct(ads, host, org_unit);
 585         if (!ADS_ERR_OK(status)) {
 586                 DEBUG(0, ("ads_add_machine_acct: %s\n", ads_errstr(status)));
 587                 return status;
 588         }
 589
 590         status = ads_find_machine_acct(ads, (void **)&res, host);
 591         if (!ADS_ERR_OK(status)) {
 592                 DEBUG(0, ("Host account test failed\n"));
 593                 return status;
 594         }
 595
 596         free(host);
 597
 598         return status;
 599 }
 600
 601 /*
 602   delete a machine from the realm
 603 */
 604 ADS_STATUS ads_leave_realm(ADS_STRUCT *ads, const char *hostname)
 605 {
 606         ADS_STATUS status;
 607         void *res;
 608         char *hostnameDN, *host;
 609         int rc;
 610
 611         /* hostname must be lowercase */
 612         host = strdup(hostname);
 613         strlower(host);
 614
 615         status = ads_find_machine_acct(ads, &res, host);
 616         if (!ADS_ERR_OK(status)) {
 617             DEBUG(0, ("Host account for %s does not exist.\n", host));
 618             return status;
 619         }
 620
 621         hostnameDN = ads_get_dn(ads, (LDAPMessage *)res);
 622         rc = ldap_delete_s(ads->ld, hostnameDN);
 623         ads_memfree(ads, hostnameDN);
 624         if (rc != LDAP_SUCCESS) {
 625                 return ADS_ERROR(rc);
 626         }
 627
 628         status = ads_find_machine_acct(ads, &res, host);
 629         if (ADS_ERR_OK(status) && ads_count_replies(ads, res) == 1) {
 630                 DEBUG(0, ("Failed to remove host account.\n"));
 631                 return status;
 632         }
 633
 634         free(host);
 635
 636         return status;
 637 }
 638
 639
 640 ADS_STATUS ads_set_machine_password(ADS_STRUCT *ads,
 641                                     const char *hostname,
 642                                     const char *password)
 643 {
 644         ADS_STATUS status;
 645         char *host = strdup(hostname);
 646         char *principal;
 647
 648         strlower(host);
 649
 650         asprintf(&principal, "%s@%s", host, ads->realm);
 651
 652         status = krb5_set_password(ads->kdc_server, principal, password);
 653
 654         free(host);
 655         free(principal);
 656
 657         return status;
 658 }
 659
 660 /*
 661   pull the first entry from a ADS result
 662 */
 663 void *ads_first_entry(ADS_STRUCT *ads, void *res)
 664 {
 665         return (void *)ldap_first_entry(ads->ld, (LDAPMessage *)res);
 666 }
 667
 668 /*
 669   pull the next entry from a ADS result
 670 */
 671 void *ads_next_entry(ADS_STRUCT *ads, void *res)
 672 {
 673         return (void *)ldap_next_entry(ads->ld, (LDAPMessage *)res);
 674 }
 675
 676 /*
 677   pull a single string from a ADS result
 678 */
 679 char *ads_pull_string(ADS_STRUCT *ads,
 680                       TALLOC_CTX *mem_ctx, void *msg, const char *field)
 681 {
 682         char **values;
 683         char *ret = NULL;
 684
 685         values = ldap_get_values(ads->ld, msg, field);
 686         if (!values) return NULL;
 687
 688         if (values[0]) {
 689                 ret = talloc_strdup(mem_ctx, values[0]);
 690         }
 691         ldap_value_free(values);
 692         return ret;
 693 }
 694
 695 /*
 696   pull a single uint32 from a ADS result
 697 */
 698 BOOL ads_pull_uint32(ADS_STRUCT *ads,
 699                      void *msg, const char *field, uint32 *v)
 700 {
 701         char **values;
 702
 703         values = ldap_get_values(ads->ld, msg, field);
 704         if (!values) return False;
 705         if (!values[0]) {
 706                 ldap_value_free(values);
 707                 return False;
 708         }
 709
 710         *v = atoi(values[0]);
 711         ldap_value_free(values);
 712         return True;
 713 }
 714
 715 /*
 716   pull a single DOM_SID from a ADS result
 717 */
 718 BOOL ads_pull_sid(ADS_STRUCT *ads,
 719                   void *msg, const char *field, DOM_SID *sid)
 720 {
 721         struct berval **values;
 722         BOOL ret = False;
 723
 724         values = ldap_get_values_len(ads->ld, msg, field);
 725
 726         if (!values) return False;
 727
 728         if (values[0]) {
 729                 ret = sid_parse(values[0]->bv_val, values[0]->bv_len, sid);
 730         }
 731
 732         ldap_value_free_len(values);
 733         return ret;
 734 }
 735
 736 /*
 737   pull an array of DOM_SIDs from a ADS result
 738   return the count of SIDs pulled
 739 */
 740 int ads_pull_sids(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx,
 741                   void *msg, const char *field, DOM_SID **sids)
 742 {
 743         struct berval **values;
 744         BOOL ret;
 745         int count, i;
 746
 747         values = ldap_get_values_len(ads->ld, msg, field);
 748
 749         if (!values) return 0;
 750
 751         for (i=0; values[i]; i++) /* nop */ ;
 752
 753         (*sids) = talloc(mem_ctx, sizeof(DOM_SID) * i);
 754
 755         count = 0;
 756         for (i=0; values[i]; i++) {
 757                 ret = sid_parse(values[i]->bv_val, values[i]->bv_len, &(*sids)[count]);
 758                 if (ret) count++;
 759         }
 760
 761         ldap_value_free_len(values);
 762         return count;
 763 }
 764
 765
 766 /* find the update serial number - this is the core of the ldap cache */
 767 ADS_STATUS ads_USN(ADS_STRUCT *ads, uint32 *usn)
 768 {
 769         const char *attrs[] = {"highestCommittedUSN", NULL};
 770         ADS_STATUS status;
 771         void *res;
 772
 773         status = ads_do_search(ads, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
 774         if (!ADS_ERR_OK(status)) return status;
 775
 776         if (ads_count_replies(ads, res) != 1) {
 777                 return ADS_ERROR(LDAP_NO_RESULTS_RETURNED);
 778         }
 779
 780         ads_pull_uint32(ads, res, "highestCommittedUSN", usn);
 781         ads_msgfree(ads, res);
 782         return ADS_SUCCESS;
 783 }
 784
 785
 786 /* find the servers name and realm - this can be done before authentication
 787    The ldapServiceName field on w2k  looks like this:
 788      vnet3.home.samba.org:win2000-vnet3$@VNET3.HOME.SAMBA.ORG
 789 */
 790 ADS_STATUS ads_server_info(ADS_STRUCT *ads)
 791 {
 792         const char *attrs[] = {"ldapServiceName", NULL};
 793         ADS_STATUS status;
 794         void *res;
 795         char **values;
 796         char *p;
 797
 798         status = ads_do_search(ads, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
 799         if (!ADS_ERR_OK(status)) return status;
 800
 801         values = ldap_get_values(ads->ld, res, "ldapServiceName");
 802         if (!values || !values[0]) return ADS_ERROR(LDAP_NO_RESULTS_RETURNED);
 803
 804         p = strchr(values[0], ':');
 805         if (!p) {
 806                 ldap_value_free(values);
 807                 ldap_msgfree(res);
 808                 return ADS_ERROR(LDAP_DECODING_ERROR);
 809         }
 810
 811         SAFE_FREE(ads->ldap_server_name);
 812
 813         ads->ldap_server_name = strdup(p+1);
 814         p = strchr(ads->ldap_server_name, '$');
 815         if (!p || p[1] != '@') {
 816                 ldap_value_free(values);
 817                 ldap_msgfree(res);
 818                 SAFE_FREE(ads->ldap_server_name);
 819                 return ADS_ERROR(LDAP_DECODING_ERROR);
 820         }
 821
 822         *p = 0;
 823
 824         SAFE_FREE(ads->server_realm);
 825         SAFE_FREE(ads->bind_path);
 826
 827         ads->server_realm = strdup(p+2);
 828         ads->bind_path = ads_build_dn(ads->server_realm);
 829
 830         /* in case the realm isn't configured in smb.conf */
 831         if (!ads->realm || !ads->realm[0]) {
 832                 SAFE_FREE(ads->realm);
 833                 ads->realm = strdup(ads->server_realm);
 834         }
 835
 836         DEBUG(3,("got ldap server name %s@%s\n",
 837                  ads->ldap_server_name, ads->realm));
 838
 839         return ADS_SUCCESS;
 840 }
 841
 842
 843 /*
 844    find the list of trusted domains
 845 */
 846 ADS_STATUS ads_trusted_domains(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx,
 847                                int *num_trusts, char ***names, DOM_SID **sids)
 848 {
 849         const char *attrs[] = {"flatName", "securityIdentifier", NULL};
 850         ADS_STATUS status;
 851         void *res, *msg;
 852         int count, i;
 853
 854         *num_trusts = 0;
 855
 856         status = ads_search(ads, &res, "(objectcategory=trustedDomain)", attrs);
 857         if (!ADS_ERR_OK(status)) return status;
 858
 859         count = ads_count_replies(ads, res);
 860         if (count == 0) {
 861                 ads_msgfree(ads, res);
 862                 return ADS_ERROR(LDAP_NO_RESULTS_RETURNED);
 863         }
 864
 865         (*names) = talloc(mem_ctx, sizeof(char *) * count);
 866         (*sids) = talloc(mem_ctx, sizeof(DOM_SID) * count);
 867         if (! *names || ! *sids) return ADS_ERROR(LDAP_NO_MEMORY);
 868
 869         for (i=0, msg = ads_first_entry(ads, res); msg; msg = ads_next_entry(ads, msg)) {
 870                 (*names)[i] = ads_pull_string(ads, mem_ctx, msg, "flatName");
 871                 if (ads_pull_sid(ads, msg, "securityIdentifier", &(*sids)[i])) {
 872                         i++;
 873                 }
 874         }
 875
 876         ads_msgfree(ads, res);
 877
 878         *num_trusts = i;
 879
 880         return ADS_SUCCESS;
 881 }
 882
 883 /* find the domain sid for our domain */
 884 ADS_STATUS ads_domain_sid(ADS_STRUCT *ads, DOM_SID *sid)
 885 {
 886         const char *attrs[] = {"objectSid", NULL};
 887         void *res;
 888         ADS_STATUS rc;
 889
 890         rc = ads_do_search(ads, ads->bind_path, LDAP_SCOPE_BASE, "(objectclass=*)",
 891                            attrs, &res);
 892         if (!ADS_ERR_OK(rc)) return rc;
 893         if (!ads_pull_sid(ads, res, "objectSid", sid)) {
 894                 return ADS_ERROR_SYSTEM(ENOENT);
 895         }
 896         ads_msgfree(ads, res);
 897
 898         return ADS_SUCCESS;
 899 }
 900
 901 #endif