source/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 <jmcd@us.ibm.com> 2002
   7    Copyright (C) Guenther Deschner 2005
   8    Copyright (C) Gerald Carter 2006
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22 */
  23
  24 #include "includes.h"
  25
  26 #ifdef HAVE_LDAP
  27
  28 /**
  29  * @file ldap.c
  30  * @brief basic ldap client-side routines for ads server communications
  31  *
  32  * The routines contained here should do the necessary ldap calls for
  33  * ads setups.
  34  *
  35  * Important note: attribute names passed into ads_ routines must
  36  * already be in UTF-8 format.  We do not convert them because in almost
  37  * all cases, they are just ascii (which is represented with the same
  38  * codepoints in UTF-8).  This may have to change at some point
  39  **/
  40
  41
  42 #define LDAP_SERVER_TREE_DELETE_OID     "1.2.840.113556.1.4.805"
  43
  44 static SIG_ATOMIC_T gotalarm;
  45
  46 /***************************************************************
  47  Signal function to tell us we timed out.
  48 ****************************************************************/
  49
  50 static void gotalarm_sig(void)
  51 {
  52         gotalarm = 1;
  53 }
  54
  55  LDAP *ldap_open_with_timeout(const char *server, int port, unsigned int to)
  56 {
  57         LDAP *ldp = NULL;
  58
  59         /* Setup timeout */
  60         gotalarm = 0;
  61         CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
  62         alarm(to);
  63         /* End setup timeout. */
  64
  65         ldp = ldap_open(server, port);
  66
  67         if (ldp == NULL) {
  68                 DEBUG(2,("Could not open LDAP connection to %s:%d: %s\n",
  69                          server, port, strerror(errno)));
  70         }
  71
  72         /* Teardown timeout. */
  73         CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
  74         alarm(0);
  75
  76         return ldp;
  77 }
  78
  79 static int ldap_search_with_timeout(LDAP *ld,
  80                                     LDAP_CONST char *base,
  81                                     int scope,
  82                                     LDAP_CONST char *filter,
  83                                     char **attrs,
  84                                     int attrsonly,
  85                                     LDAPControl **sctrls,
  86                                     LDAPControl **cctrls,
  87                                     int sizelimit,
  88                                     LDAPMessage **res )
  89 {
  90         struct timeval timeout;
  91         int result;
  92
  93         /* Setup timeout for the ldap_search_ext_s call - local and remote. */
  94         timeout.tv_sec = lp_ldap_timeout();
  95         timeout.tv_usec = 0;
  96
  97         /* Setup alarm timeout.... Do we need both of these ? JRA. */
  98         gotalarm = 0;
  99         CatchSignal(SIGALRM, SIGNAL_CAST gotalarm_sig);
 100         alarm(lp_ldap_timeout());
 101         /* End setup timeout. */
 102
 103         result = ldap_search_ext_s(ld, base, scope, filter, attrs,
 104                                    attrsonly, sctrls, cctrls, &timeout,
 105                                    sizelimit, res);
 106
 107         /* Teardown timeout. */
 108         CatchSignal(SIGALRM, SIGNAL_CAST SIG_IGN);
 109         alarm(0);
 110
 111         if (gotalarm != 0)
 112                 return LDAP_TIMELIMIT_EXCEEDED;
 113
 114         return result;
 115 }
 116
 117 /**********************************************
 118  Do client and server sitename match ?
 119 **********************************************/
 120
 121 BOOL ads_sitename_match(ADS_STRUCT *ads)
 122 {
 123         if (ads->config.server_site_name == NULL &&
 124             ads->config.client_site_name == NULL ) {
 125                 DEBUG(10,("ads_sitename_match: both null\n"));
 126                 return True;
 127         }
 128         if (ads->config.server_site_name &&
 129             ads->config.client_site_name &&
 130             strequal(ads->config.server_site_name,
 131                      ads->config.client_site_name)) {
 132                 DEBUG(10,("ads_sitename_match: name %s match\n", ads->config.server_site_name));
 133                 return True;
 134         }
 135         DEBUG(10,("ads_sitename_match: no match between server: %s and client: %s\n",
 136                 ads->config.server_site_name ? ads->config.server_site_name : "NULL",
 137                 ads->config.client_site_name ? ads->config.client_site_name : "NULL"));
 138         return False;
 139 }
 140
 141 /**********************************************
 142  Is this the closest DC ?
 143 **********************************************/
 144
 145 BOOL ads_closest_dc(ADS_STRUCT *ads)
 146 {
 147         if (ads->config.flags & ADS_CLOSEST) {
 148                 DEBUG(10,("ads_closest_dc: ADS_CLOSEST flag set\n"));
 149                 return True;
 150         }
 151
 152         /* not sure if this can ever happen */
 153         if (ads_sitename_match(ads)) {
 154                 DEBUG(10,("ads_closest_dc: ADS_CLOSEST flag not set but sites match\n"));
 155                 return True;
 156         }
 157
 158         DEBUG(10,("ads_closest_dc: %s is not the closest DC\n",
 159                 ads->config.ldap_server_name));
 160
 161         return False;
 162 }
 163
 164
 165 /*
 166   try a connection to a given ldap server, returning True and setting the servers IP
 167   in the ads struct if successful
 168  */
 169 BOOL ads_try_connect(ADS_STRUCT *ads, const char *server )
 170 {
 171         char *srv;
 172         struct cldap_netlogon_reply cldap_reply;
 173
 174         if (!server || !*server) {
 175                 return False;
 176         }
 177
 178         DEBUG(5,("ads_try_connect: sending CLDAP request to %s (realm: %s)\n",
 179                 server, ads->server.realm));
 180
 181         /* this copes with inet_ntoa brokenness */
 182
 183         srv = SMB_STRDUP(server);
 184
 185         ZERO_STRUCT( cldap_reply );
 186
 187         if ( !ads_cldap_netlogon( srv, ads->server.realm, &cldap_reply ) ) {
 188                 DEBUG(3,("ads_try_connect: CLDAP request %s failed.\n", srv));
 189                 SAFE_FREE( srv );
 190                 return False;
 191         }
 192
 193         /* Check the CLDAP reply flags */
 194
 195         if ( !(cldap_reply.flags & ADS_LDAP) ) {
 196                 DEBUG(1,("ads_try_connect: %s's CLDAP reply says it is not an LDAP server!\n",
 197                         srv));
 198                 SAFE_FREE( srv );
 199                 return False;
 200         }
 201
 202         /* Fill in the ads->config values */
 203
 204         SAFE_FREE(ads->config.realm);
 205         SAFE_FREE(ads->config.bind_path);
 206         SAFE_FREE(ads->config.ldap_server_name);
 207         SAFE_FREE(ads->config.server_site_name);
 208         SAFE_FREE(ads->config.client_site_name);
 209         SAFE_FREE(ads->server.workgroup);
 210
 211         ads->config.flags              = cldap_reply.flags;
 212         ads->config.ldap_server_name   = SMB_STRDUP(cldap_reply.hostname);
 213         strupper_m(cldap_reply.domain);
 214         ads->config.realm              = SMB_STRDUP(cldap_reply.domain);
 215         ads->config.bind_path          = ads_build_dn(ads->config.realm);
 216         if (*cldap_reply.server_site_name) {
 217                 ads->config.server_site_name =
 218                         SMB_STRDUP(cldap_reply.server_site_name);
 219         }
 220         if (*cldap_reply.client_site_name) {
 221                 ads->config.client_site_name =
 222                         SMB_STRDUP(cldap_reply.client_site_name);
 223         }
 224
 225         ads->server.workgroup          = SMB_STRDUP(cldap_reply.netbios_domain);
 226
 227         ads->ldap_port = LDAP_PORT;
 228         ads->ldap_ip = *interpret_addr2(srv);
 229         SAFE_FREE(srv);
 230
 231         /* Store our site name. */
 232         sitename_store( cldap_reply.domain, cldap_reply.client_site_name );
 233
 234         return True;
 235 }
 236
 237 /**********************************************************************
 238  Try to find an AD dc using our internal name resolution routines
 239  Try the realm first and then then workgroup name if netbios is not
 240  disabled
 241 **********************************************************************/
 242
 243 static NTSTATUS ads_find_dc(ADS_STRUCT *ads)
 244 {
 245         const char *c_realm;
 246         int count, i=0;
 247         struct ip_service *ip_list;
 248         pstring realm;
 249         BOOL got_realm = False;
 250         BOOL use_own_domain = False;
 251         char *sitename;
 252         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
 253
 254         /* if the realm and workgroup are both empty, assume they are ours */
 255
 256         /* realm */
 257         c_realm = ads->server.realm;
 258
 259         if ( !c_realm || !*c_realm ) {
 260                 /* special case where no realm and no workgroup means our own */
 261                 if ( !ads->server.workgroup || !*ads->server.workgroup ) {
 262                         use_own_domain = True;
 263                         c_realm = lp_realm();
 264                 }
 265         }
 266
 267         if (c_realm && *c_realm)
 268                 got_realm = True;
 269
 270         /* we need to try once with the realm name and fallback to the
 271            netbios domain name if we fail (if netbios has not been disabled */
 272
 273         if ( !got_realm && !lp_disable_netbios() ) {
 274                 c_realm = ads->server.workgroup;
 275                 if (!c_realm || !*c_realm) {
 276                         if ( use_own_domain )
 277                                 c_realm = lp_workgroup();
 278                 }
 279
 280                 if ( !c_realm || !*c_realm ) {
 281                         DEBUG(0,("ads_find_dc: no realm or workgroup!  Don't know what to do\n"));
 282                         return NT_STATUS_INVALID_PARAMETER; /* rather need MISSING_PARAMETER ... */
 283                 }
 284         }
 285
 286         pstrcpy( realm, c_realm );
 287
 288         sitename = sitename_fetch(realm);
 289
 290  again:
 291
 292         DEBUG(6,("ads_find_dc: looking for %s '%s'\n",
 293                 (got_realm ? "realm" : "domain"), realm));
 294
 295         status = get_sorted_dc_list(realm, sitename, &ip_list, &count, got_realm);
 296         if (!NT_STATUS_IS_OK(status)) {
 297                 /* fall back to netbios if we can */
 298                 if ( got_realm && !lp_disable_netbios() ) {
 299                         got_realm = False;
 300                         goto again;
 301                 }
 302
 303                 SAFE_FREE(sitename);
 304                 return status;
 305         }
 306
 307         /* if we fail this loop, then giveup since all the IP addresses returned were dead */
 308         for ( i=0; i<count; i++ ) {
 309                 fstring server;
 310
 311                 fstrcpy( server, inet_ntoa(ip_list[i].ip) );
 312
 313                 if ( !NT_STATUS_IS_OK(check_negative_conn_cache(realm, server)) )
 314                         continue;
 315
 316                 if (!got_realm) {
 317                         /* realm in this case is a workgroup name. We need
 318                            to ignore any IP addresses in the negative connection
 319                            cache that match ip addresses returned in the ad realm
 320                            case. It sucks that I have to reproduce the logic above... */
 321                         c_realm = ads->server.realm;
 322                         if ( !c_realm || !*c_realm ) {
 323                                 if ( !ads->server.workgroup || !*ads->server.workgroup ) {
 324                                         c_realm = lp_realm();
 325                                 }
 326                         }
 327                         if (c_realm && *c_realm &&
 328                                         !NT_STATUS_IS_OK(check_negative_conn_cache(c_realm, server))) {
 329                                 /* Ensure we add the workgroup name for this
 330                                    IP address as negative too. */
 331                                 add_failed_connection_entry( realm, server, NT_STATUS_UNSUCCESSFUL );
 332                                 continue;
 333                         }
 334                 }
 335
 336                 if ( ads_try_connect(ads, server) ) {
 337                         SAFE_FREE(ip_list);
 338                         SAFE_FREE(sitename);
 339                         return NT_STATUS_OK;
 340                 }
 341
 342                 /* keep track of failures */
 343                 add_failed_connection_entry( realm, server, NT_STATUS_UNSUCCESSFUL );
 344         }
 345
 346         SAFE_FREE(ip_list);
 347
 348         /* In case we failed to contact one of our closest DC on our site we
 349          * need to try to find another DC, retry with a site-less SRV DNS query
 350          * - Guenther */
 351
 352         if (sitename) {
 353                 DEBUG(1,("ads_find_dc: failed to find a valid DC on our site (%s), "
 354                                 "trying to find another DC\n", sitename));
 355                 SAFE_FREE(sitename);
 356                 namecache_delete(realm, 0x1C);
 357                 goto again;
 358         }
 359
 360         return NT_STATUS_NO_LOGON_SERVERS;
 361 }
 362
 363
 364 /**
 365  * Connect to the LDAP server
 366  * @param ads Pointer to an existing ADS_STRUCT
 367  * @return status of connection
 368  **/
 369 ADS_STATUS ads_connect(ADS_STRUCT *ads)
 370 {
 371         int version = LDAP_VERSION3;
 372         ADS_STATUS status;
 373         NTSTATUS ntstatus;
 374
 375         ads->last_attempt = time(NULL);
 376         ads->ld = NULL;
 377
 378         /* try with a user specified server */
 379
 380         if (ads->server.ldap_server &&
 381             ads_try_connect(ads, ads->server.ldap_server)) {
 382                 goto got_connection;
 383         }
 384
 385         ntstatus = ads_find_dc(ads);
 386         if (NT_STATUS_IS_OK(ntstatus)) {
 387                 goto got_connection;
 388         }
 389
 390         return ADS_ERROR_NT(ntstatus);
 391
 392 got_connection:
 393         DEBUG(3,("Connected to LDAP server %s\n", inet_ntoa(ads->ldap_ip)));
 394
 395         if (!ads->auth.user_name) {
 396                 /* Must use the userPrincipalName value here or sAMAccountName
 397                    and not servicePrincipalName; found by Guenther Deschner */
 398
 399                 asprintf(&ads->auth.user_name, "%s$", global_myname() );
 400         }
 401
 402         if (!ads->auth.realm) {
 403                 ads->auth.realm = SMB_STRDUP(ads->config.realm);
 404         }
 405
 406         if (!ads->auth.kdc_server) {
 407                 ads->auth.kdc_server = SMB_STRDUP(inet_ntoa(ads->ldap_ip));
 408         }
 409
 410 #if KRB5_DNS_HACK
 411         /* this is a really nasty hack to avoid ADS DNS problems. It needs a patch
 412            to MIT kerberos to work (tridge) */
 413         {
 414                 char *env;
 415                 asprintf(&env, "KRB5_KDC_ADDRESS_%s", ads->config.realm);
 416                 setenv(env, ads->auth.kdc_server, 1);
 417                 free(env);
 418         }
 419 #endif
 420
 421         /* If the caller() requested no LDAP bind, then we are done */
 422
 423         if (ads->auth.flags & ADS_AUTH_NO_BIND) {
 424                 return ADS_SUCCESS;
 425         }
 426
 427         /* Otherwise setup the TCP LDAP session */
 428
 429         if ( (ads->ld = ldap_open_with_timeout(ads->config.ldap_server_name,
 430                 LDAP_PORT, lp_ldap_timeout())) == NULL )
 431         {
 432                 return ADS_ERROR(LDAP_OPERATIONS_ERROR);
 433         }
 434
 435         /* cache the successful connection for workgroup and realm */
 436         if (ads_closest_dc(ads)) {
 437                 saf_store( ads->server.workgroup, inet_ntoa(ads->ldap_ip));
 438                 saf_store( ads->server.realm, inet_ntoa(ads->ldap_ip));
 439         }
 440
 441         ldap_set_option(ads->ld, LDAP_OPT_PROTOCOL_VERSION, &version);
 442
 443         status = ADS_ERROR(smb_ldap_start_tls(ads->ld, version));
 444         if (!ADS_ERR_OK(status)) {
 445                 return status;
 446         }
 447
 448         /* fill in the current time and offsets */
 449
 450         status = ads_current_time( ads );
 451         if ( !ADS_ERR_OK(status) ) {
 452                 return status;
 453         }
 454
 455         /* Now do the bind */
 456
 457         if (ads->auth.flags & ADS_AUTH_ANON_BIND) {
 458                 return ADS_ERROR(ldap_simple_bind_s( ads->ld, NULL, NULL));
 459         }
 460
 461         if (ads->auth.flags & ADS_AUTH_SIMPLE_BIND) {
 462                 return ADS_ERROR(ldap_simple_bind_s( ads->ld, ads->auth.user_name, ads->auth.password));
 463         }
 464
 465         return ads_sasl_bind(ads);
 466 }
 467
 468 /*
 469   Duplicate a struct berval into talloc'ed memory
 470  */
 471 static struct berval *dup_berval(TALLOC_CTX *ctx, const struct berval *in_val)
 472 {
 473         struct berval *value;
 474
 475         if (!in_val) return NULL;
 476
 477         value = TALLOC_ZERO_P(ctx, struct berval);
 478         if (value == NULL)
 479                 return NULL;
 480         if (in_val->bv_len == 0) return value;
 481
 482         value->bv_len = in_val->bv_len;
 483         value->bv_val = (char *)TALLOC_MEMDUP(ctx, in_val->bv_val,
 484                                               in_val->bv_len);
 485         return value;
 486 }
 487
 488 /*
 489   Make a values list out of an array of (struct berval *)
 490  */
 491 static struct berval **ads_dup_values(TALLOC_CTX *ctx,
 492                                       const struct berval **in_vals)
 493 {
 494         struct berval **values;
 495         int i;
 496
 497         if (!in_vals) return NULL;
 498         for (i=0; in_vals[i]; i++)
 499                 ; /* count values */
 500         values = TALLOC_ZERO_ARRAY(ctx, struct berval *, i+1);
 501         if (!values) return NULL;
 502
 503         for (i=0; in_vals[i]; i++) {
 504                 values[i] = dup_berval(ctx, in_vals[i]);
 505         }
 506         return values;
 507 }
 508
 509 /*
 510   UTF8-encode a values list out of an array of (char *)
 511  */
 512 static char **ads_push_strvals(TALLOC_CTX *ctx, const char **in_vals)
 513 {
 514         char **values;
 515         int i;
 516
 517         if (!in_vals) return NULL;
 518         for (i=0; in_vals[i]; i++)
 519                 ; /* count values */
 520         values = TALLOC_ZERO_ARRAY(ctx, char *, i+1);
 521         if (!values) return NULL;
 522
 523         for (i=0; in_vals[i]; i++) {
 524                 push_utf8_talloc(ctx, &values[i], in_vals[i]);
 525         }
 526         return values;
 527 }
 528
 529 /*
 530   Pull a (char *) array out of a UTF8-encoded values list
 531  */
 532 static char **ads_pull_strvals(TALLOC_CTX *ctx, const char **in_vals)
 533 {
 534         char **values;
 535         int i;
 536
 537         if (!in_vals) return NULL;
 538         for (i=0; in_vals[i]; i++)
 539                 ; /* count values */
 540         values = TALLOC_ZERO_ARRAY(ctx, char *, i+1);
 541         if (!values) return NULL;
 542
 543         for (i=0; in_vals[i]; i++) {
 544                 pull_utf8_talloc(ctx, &values[i], in_vals[i]);
 545         }
 546         return values;
 547 }
 548
 549 /**
 550  * Do a search with paged results.  cookie must be null on the first
 551  *  call, and then returned on each subsequent call.  It will be null
 552  *  again when the entire search is complete
 553  * @param ads connection to ads server
 554  * @param bind_path Base dn for the search
 555  * @param scope Scope of search (LDAP_SCOPE_BASE | LDAP_SCOPE_ONE | LDAP_SCOPE_SUBTREE)
 556  * @param expr Search expression - specified in local charset
 557  * @param attrs Attributes to retrieve - specified in utf8 or ascii
 558  * @param res ** which will contain results - free res* with ads_msgfree()
 559  * @param count Number of entries retrieved on this page
 560  * @param cookie The paged results cookie to be returned on subsequent calls
 561  * @return status of search
 562  **/
 563 static ADS_STATUS ads_do_paged_search_args(ADS_STRUCT *ads,
 564                                            const char *bind_path,
 565                                            int scope, const char *expr,
 566                                            const char **attrs, void *args,
 567                                            LDAPMessage **res,
 568                                            int *count, struct berval **cookie)
 569 {
 570         int rc, i, version;
 571         char *utf8_expr, *utf8_path, **search_attrs;
 572         LDAPControl PagedResults, NoReferrals, ExternalCtrl, *controls[4], **rcontrols;
 573         BerElement *cookie_be = NULL;
 574         struct berval *cookie_bv= NULL;
 575         BerElement *ext_be = NULL;
 576         struct berval *ext_bv= NULL;
 577
 578         TALLOC_CTX *ctx;
 579         ads_control *external_control = (ads_control *) args;
 580
 581         *res = NULL;
 582
 583         if (!(ctx = talloc_init("ads_do_paged_search_args")))
 584                 return ADS_ERROR(LDAP_NO_MEMORY);
 585
 586         /* 0 means the conversion worked but the result was empty
 587            so we only fail if it's -1.  In any case, it always
 588            at least nulls out the dest */
 589         if ((push_utf8_talloc(ctx, &utf8_expr, expr) == (size_t)-1) ||
 590             (push_utf8_talloc(ctx, &utf8_path, bind_path) == (size_t)-1)) {
 591                 rc = LDAP_NO_MEMORY;
 592                 goto done;
 593         }
 594
 595         if (!attrs || !(*attrs))
 596                 search_attrs = NULL;
 597         else {
 598                 /* This would be the utf8-encoded version...*/
 599                 /* if (!(search_attrs = ads_push_strvals(ctx, attrs))) */
 600                 if (!(str_list_copy(&search_attrs, attrs))) {
 601                         rc = LDAP_NO_MEMORY;
 602                         goto done;
 603                 }
 604         }
 605
 606         /* Paged results only available on ldap v3 or later */
 607         ldap_get_option(ads->ld, LDAP_OPT_PROTOCOL_VERSION, &version);
 608         if (version < LDAP_VERSION3) {
 609                 rc =  LDAP_NOT_SUPPORTED;
 610                 goto done;
 611         }
 612
 613         cookie_be = ber_alloc_t(LBER_USE_DER);
 614         if (*cookie) {
 615                 ber_printf(cookie_be, "{iO}", (ber_int_t) 1000, *cookie);
 616                 ber_bvfree(*cookie); /* don't need it from last time */
 617                 *cookie = NULL;
 618         } else {
 619                 ber_printf(cookie_be, "{io}", (ber_int_t) 1000, "", 0);
 620         }
 621         ber_flatten(cookie_be, &cookie_bv);
 622         PagedResults.ldctl_oid = CONST_DISCARD(char *, ADS_PAGE_CTL_OID);
 623         PagedResults.ldctl_iscritical = (char) 1;
 624         PagedResults.ldctl_value.bv_len = cookie_bv->bv_len;
 625         PagedResults.ldctl_value.bv_val = cookie_bv->bv_val;
 626
 627         NoReferrals.ldctl_oid = CONST_DISCARD(char *, ADS_NO_REFERRALS_OID);
 628         NoReferrals.ldctl_iscritical = (char) 0;
 629         NoReferrals.ldctl_value.bv_len = 0;
 630         NoReferrals.ldctl_value.bv_val = CONST_DISCARD(char *, "");
 631
 632         if (external_control &&
 633             (strequal(external_control->control, ADS_EXTENDED_DN_OID) ||
 634              strequal(external_control->control, ADS_SD_FLAGS_OID))) {
 635
 636                 ExternalCtrl.ldctl_oid = CONST_DISCARD(char *, external_control->control);
 637                 ExternalCtrl.ldctl_iscritical = (char) external_control->critical;
 638
 639                 /* win2k does not accept a ldctl_value beeing passed in */
 640
 641                 if (external_control->val != 0) {
 642
 643                         if ((ext_be = ber_alloc_t(LBER_USE_DER)) == NULL ) {
 644                                 rc = LDAP_NO_MEMORY;
 645                                 goto done;
 646                         }
 647
 648                         if ((ber_printf(ext_be, "{i}", (ber_int_t) external_control->val)) == -1) {
 649                                 rc = LDAP_NO_MEMORY;
 650                                 goto done;
 651                         }
 652                         if ((ber_flatten(ext_be, &ext_bv)) == -1) {
 653                                 rc = LDAP_NO_MEMORY;
 654                                 goto done;
 655                         }
 656
 657                         ExternalCtrl.ldctl_value.bv_len = ext_bv->bv_len;
 658                         ExternalCtrl.ldctl_value.bv_val = ext_bv->bv_val;
 659
 660                 } else {
 661                         ExternalCtrl.ldctl_value.bv_len = 0;
 662                         ExternalCtrl.ldctl_value.bv_val = NULL;
 663                 }
 664
 665                 controls[0] = &NoReferrals;
 666                 controls[1] = &PagedResults;
 667                 controls[2] = &ExternalCtrl;
 668                 controls[3] = NULL;
 669
 670         } else {
 671                 controls[0] = &NoReferrals;
 672                 controls[1] = &PagedResults;
 673                 controls[2] = NULL;
 674         }
 675
 676         /* we need to disable referrals as the openldap libs don't
 677            handle them and paged results at the same time.  Using them
 678            together results in the result record containing the server
 679            page control being removed from the result list (tridge/jmcd)
 680
 681            leaving this in despite the control that says don't generate
 682            referrals, in case the server doesn't support it (jmcd)
 683         */
 684         ldap_set_option(ads->ld, LDAP_OPT_REFERRALS, LDAP_OPT_OFF);
 685
 686         rc = ldap_search_with_timeout(ads->ld, utf8_path, scope, utf8_expr,
 687                                       search_attrs, 0, controls,
 688                                       NULL, LDAP_NO_LIMIT,
 689                                       (LDAPMessage **)res);
 690
 691         ber_free(cookie_be, 1);
 692         ber_bvfree(cookie_bv);
 693
 694         if (rc) {
 695                 DEBUG(3,("ads_do_paged_search_args: ldap_search_with_timeout(%s) -> %s\n", expr,
 696                          ldap_err2string(rc)));
 697                 goto done;
 698         }
 699
 700         rc = ldap_parse_result(ads->ld, *res, NULL, NULL, NULL,
 701                                         NULL, &rcontrols,  0);
 702
 703         if (!rcontrols) {
 704                 goto done;
 705         }
 706
 707         for (i=0; rcontrols[i]; i++) {
 708                 if (strcmp(ADS_PAGE_CTL_OID, rcontrols[i]->ldctl_oid) == 0) {
 709                         cookie_be = ber_init(&rcontrols[i]->ldctl_value);
 710                         ber_scanf(cookie_be,"{iO}", (ber_int_t *) count,
 711                                   &cookie_bv);
 712                         /* the berval is the cookie, but must be freed when
 713                            it is all done */
 714                         if (cookie_bv->bv_len) /* still more to do */
 715                                 *cookie=ber_bvdup(cookie_bv);
 716                         else
 717                                 *cookie=NULL;
 718                         ber_bvfree(cookie_bv);
 719                         ber_free(cookie_be, 1);
 720                         break;
 721                 }
 722         }
 723         ldap_controls_free(rcontrols);
 724
 725 done:
 726         talloc_destroy(ctx);
 727
 728         if (ext_be) {
 729                 ber_free(ext_be, 1);
 730         }
 731
 732         if (ext_bv) {
 733                 ber_bvfree(ext_bv);
 734         }
 735
 736         /* if/when we decide to utf8-encode attrs, take out this next line */
 737         str_list_free(&search_attrs);
 738
 739         return ADS_ERROR(rc);
 740 }
 741
 742 static ADS_STATUS ads_do_paged_search(ADS_STRUCT *ads, const char *bind_path,
 743                                       int scope, const char *expr,
 744                                       const char **attrs, LDAPMessage **res,
 745                                       int *count, struct berval **cookie)
 746 {
 747         return ads_do_paged_search_args(ads, bind_path, scope, expr, attrs, NULL, res, count, cookie);
 748 }
 749
 750
 751 /**
 752  * Get all results for a search.  This uses ads_do_paged_search() to return
 753  * all entries in a large search.
 754  * @param ads connection to ads server
 755  * @param bind_path Base dn for the search
 756  * @param scope Scope of search (LDAP_SCOPE_BASE | LDAP_SCOPE_ONE | LDAP_SCOPE_SUBTREE)
 757  * @param expr Search expression
 758  * @param attrs Attributes to retrieve
 759  * @param res ** which will contain results - free res* with ads_msgfree()
 760  * @return status of search
 761  **/
 762  ADS_STATUS ads_do_search_all_args(ADS_STRUCT *ads, const char *bind_path,
 763                                    int scope, const char *expr,
 764                                    const char **attrs, void *args,
 765                                    LDAPMessage **res)
 766 {
 767         struct berval *cookie = NULL;
 768         int count = 0;
 769         ADS_STATUS status;
 770
 771         *res = NULL;
 772         status = ads_do_paged_search_args(ads, bind_path, scope, expr, attrs, args, res,
 773                                      &count, &cookie);
 774
 775         if (!ADS_ERR_OK(status))
 776                 return status;
 777
 778 #ifdef HAVE_LDAP_ADD_RESULT_ENTRY
 779         while (cookie) {
 780                 LDAPMessage *res2 = NULL;
 781                 ADS_STATUS status2;
 782                 LDAPMessage *msg, *next;
 783
 784                 status2 = ads_do_paged_search_args(ads, bind_path, scope, expr,
 785                                               attrs, args, &res2, &count, &cookie);
 786
 787                 if (!ADS_ERR_OK(status2)) break;
 788
 789                 /* this relies on the way that ldap_add_result_entry() works internally. I hope
 790                    that this works on all ldap libs, but I have only tested with openldap */
 791                 for (msg = ads_first_entry(ads, res2); msg; msg = next) {
 792                         next = ads_next_entry(ads, msg);
 793                         ldap_add_result_entry((LDAPMessage **)res, msg);
 794                 }
 795                 /* note that we do not free res2, as the memory is now
 796                    part of the main returned list */
 797         }
 798 #else
 799         DEBUG(0, ("no ldap_add_result_entry() support in LDAP libs!\n"));
 800         status = ADS_ERROR_NT(NT_STATUS_UNSUCCESSFUL);
 801 #endif
 802
 803         return status;
 804 }
 805
 806  ADS_STATUS ads_do_search_all(ADS_STRUCT *ads, const char *bind_path,
 807                               int scope, const char *expr,
 808                               const char **attrs, LDAPMessage **res)
 809 {
 810         return ads_do_search_all_args(ads, bind_path, scope, expr, attrs, NULL, res);
 811 }
 812
 813  ADS_STATUS ads_do_search_all_sd_flags(ADS_STRUCT *ads, const char *bind_path,
 814                                        int scope, const char *expr,
 815                                        const char **attrs, uint32 sd_flags,
 816                                        LDAPMessage **res)
 817 {
 818         ads_control args;
 819
 820         args.control = ADS_SD_FLAGS_OID;
 821         args.val = sd_flags;
 822         args.critical = True;
 823
 824         return ads_do_search_all_args(ads, bind_path, scope, expr, attrs, &args, res);
 825 }
 826
 827
 828 /**
 829  * Run a function on all results for a search.  Uses ads_do_paged_search() and
 830  *  runs the function as each page is returned, using ads_process_results()
 831  * @param ads connection to ads server
 832  * @param bind_path Base dn for the search
 833  * @param scope Scope of search (LDAP_SCOPE_BASE | LDAP_SCOPE_ONE | LDAP_SCOPE_SUBTREE)
 834  * @param expr Search expression - specified in local charset
 835  * @param attrs Attributes to retrieve - specified in UTF-8 or ascii
 836  * @param fn Function which takes attr name, values list, and data_area
 837  * @param data_area Pointer which is passed to function on each call
 838  * @return status of search
 839  **/
 840 ADS_STATUS ads_do_search_all_fn(ADS_STRUCT *ads, const char *bind_path,
 841                                 int scope, const char *expr, const char **attrs,
 842                                 BOOL(*fn)(char *, void **, void *),
 843                                 void *data_area)
 844 {
 845         struct berval *cookie = NULL;
 846         int count = 0;
 847         ADS_STATUS status;
 848         LDAPMessage *res;
 849
 850         status = ads_do_paged_search(ads, bind_path, scope, expr, attrs, &res,
 851                                      &count, &cookie);
 852
 853         if (!ADS_ERR_OK(status)) return status;
 854
 855         ads_process_results(ads, res, fn, data_area);
 856         ads_msgfree(ads, res);
 857
 858         while (cookie) {
 859                 status = ads_do_paged_search(ads, bind_path, scope, expr, attrs,
 860                                              &res, &count, &cookie);
 861
 862                 if (!ADS_ERR_OK(status)) break;
 863
 864                 ads_process_results(ads, res, fn, data_area);
 865                 ads_msgfree(ads, res);
 866         }
 867
 868         return status;
 869 }
 870
 871 /**
 872  * Do a search with a timeout.
 873  * @param ads connection to ads server
 874  * @param bind_path Base dn for the search
 875  * @param scope Scope of search (LDAP_SCOPE_BASE | LDAP_SCOPE_ONE | LDAP_SCOPE_SUBTREE)
 876  * @param expr Search expression
 877  * @param attrs Attributes to retrieve
 878  * @param res ** which will contain results - free res* with ads_msgfree()
 879  * @return status of search
 880  **/
 881  ADS_STATUS ads_do_search(ADS_STRUCT *ads, const char *bind_path, int scope,
 882                           const char *expr,
 883                           const char **attrs, LDAPMessage **res)
 884 {
 885         int rc;
 886         char *utf8_expr, *utf8_path, **search_attrs = NULL;
 887         TALLOC_CTX *ctx;
 888
 889         *res = NULL;
 890         if (!(ctx = talloc_init("ads_do_search"))) {
 891                 DEBUG(1,("ads_do_search: talloc_init() failed!"));
 892                 return ADS_ERROR(LDAP_NO_MEMORY);
 893         }
 894
 895         /* 0 means the conversion worked but the result was empty
 896            so we only fail if it's negative.  In any case, it always
 897            at least nulls out the dest */
 898         if ((push_utf8_talloc(ctx, &utf8_expr, expr) == (size_t)-1) ||
 899             (push_utf8_talloc(ctx, &utf8_path, bind_path) == (size_t)-1)) {
 900                 DEBUG(1,("ads_do_search: push_utf8_talloc() failed!"));
 901                 rc = LDAP_NO_MEMORY;
 902                 goto done;
 903         }
 904
 905         if (!attrs || !(*attrs))
 906                 search_attrs = NULL;
 907         else {
 908                 /* This would be the utf8-encoded version...*/
 909                 /* if (!(search_attrs = ads_push_strvals(ctx, attrs)))  */
 910                 if (!(str_list_copy(&search_attrs, attrs)))
 911                 {
 912                         DEBUG(1,("ads_do_search: str_list_copy() failed!"));
 913                         rc = LDAP_NO_MEMORY;
 914                         goto done;
 915                 }
 916         }
 917
 918         /* see the note in ads_do_paged_search - we *must* disable referrals */
 919         ldap_set_option(ads->ld, LDAP_OPT_REFERRALS, LDAP_OPT_OFF);
 920
 921         rc = ldap_search_with_timeout(ads->ld, utf8_path, scope, utf8_expr,
 922                                       search_attrs, 0, NULL, NULL,
 923                                       LDAP_NO_LIMIT,
 924                                       (LDAPMessage **)res);
 925
 926         if (rc == LDAP_SIZELIMIT_EXCEEDED) {
 927                 DEBUG(3,("Warning! sizelimit exceeded in ldap. Truncating.\n"));
 928                 rc = 0;
 929         }
 930
 931  done:
 932         talloc_destroy(ctx);
 933         /* if/when we decide to utf8-encode attrs, take out this next line */
 934         str_list_free(&search_attrs);
 935         return ADS_ERROR(rc);
 936 }
 937 /**
 938  * Do a general ADS search
 939  * @param ads connection to ads server
 940  * @param res ** which will contain results - free res* with ads_msgfree()
 941  * @param expr Search expression
 942  * @param attrs Attributes to retrieve
 943  * @return status of search
 944  **/
 945  ADS_STATUS ads_search(ADS_STRUCT *ads, LDAPMessage **res,
 946                        const char *expr, const char **attrs)
 947 {
 948         return ads_do_search(ads, ads->config.bind_path, LDAP_SCOPE_SUBTREE,
 949                              expr, attrs, res);
 950 }
 951
 952 /**
 953  * Do a search on a specific DistinguishedName
 954  * @param ads connection to ads server
 955  * @param res ** which will contain results - free res* with ads_msgfree()
 956  * @param dn DistinguishName to search
 957  * @param attrs Attributes to retrieve
 958  * @return status of search
 959  **/
 960  ADS_STATUS ads_search_dn(ADS_STRUCT *ads, LDAPMessage **res,
 961                           const char *dn, const char **attrs)
 962 {
 963         return ads_do_search(ads, dn, LDAP_SCOPE_BASE, "(objectclass=*)",
 964                              attrs, res);
 965 }
 966
 967 /**
 968  * Free up memory from a ads_search
 969  * @param ads connection to ads server
 970  * @param msg Search results to free
 971  **/
 972  void ads_msgfree(ADS_STRUCT *ads, LDAPMessage *msg)
 973 {
 974         if (!msg) return;
 975         ldap_msgfree(msg);
 976 }
 977
 978 /**
 979  * Free up memory from various ads requests
 980  * @param ads connection to ads server
 981  * @param mem Area to free
 982  **/
 983 void ads_memfree(ADS_STRUCT *ads, void *mem)
 984 {
 985         SAFE_FREE(mem);
 986 }
 987
 988 /**
 989  * Get a dn from search results
 990  * @param ads connection to ads server
 991  * @param msg Search result
 992  * @return dn string
 993  **/
 994  char *ads_get_dn(ADS_STRUCT *ads, LDAPMessage *msg)
 995 {
 996         char *utf8_dn, *unix_dn;
 997
 998         utf8_dn = ldap_get_dn(ads->ld, msg);
 999
1000         if (!utf8_dn) {
1001                 DEBUG (5, ("ads_get_dn: ldap_get_dn failed\n"));
1002                 return NULL;
1003         }
1004
1005         if (pull_utf8_allocate(&unix_dn, utf8_dn) == (size_t)-1) {
1006                 DEBUG(0,("ads_get_dn: string conversion failure utf8 [%s]\n",
1007                         utf8_dn ));
1008                 return NULL;
1009         }
1010         ldap_memfree(utf8_dn);
1011         return unix_dn;
1012 }
1013
1014 /**
1015  * Get the parent from a dn
1016  * @param dn the dn to return the parent from
1017  * @return parent dn string
1018  **/
1019 char *ads_parent_dn(const char *dn)
1020 {
1021         char *p;
1022
1023         if (dn == NULL) {
1024                 return NULL;
1025         }
1026
1027         p = strchr(dn, ',');
1028
1029         if (p == NULL) {
1030                 return NULL;
1031         }
1032
1033         return p+1;
1034 }
1035
1036 /**
1037  * Find a machine account given a hostname
1038  * @param ads connection to ads server
1039  * @param res ** which will contain results - free res* with ads_msgfree()
1040  * @param host Hostname to search for
1041  * @return status of search
1042  **/
1043  ADS_STATUS ads_find_machine_acct(ADS_STRUCT *ads, LDAPMessage **res,
1044                                   const char *machine)
1045 {
1046         ADS_STATUS status;
1047         char *expr;
1048         const char *attrs[] = {"*", "nTSecurityDescriptor", NULL};
1049
1050         *res = NULL;
1051
1052         /* the easiest way to find a machine account anywhere in the tree
1053            is to look for hostname$ */
1054         if (asprintf(&expr, "(samAccountName=%s$)", machine) == -1) {
1055                 DEBUG(1, ("asprintf failed!\n"));
1056                 return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
1057         }
1058
1059         status = ads_search(ads, res, expr, attrs);
1060         SAFE_FREE(expr);
1061         return status;
1062 }
1063
1064 /**
1065  * Initialize a list of mods to be used in a modify request
1066  * @param ctx An initialized TALLOC_CTX
1067  * @return allocated ADS_MODLIST
1068  **/
1069 ADS_MODLIST ads_init_mods(TALLOC_CTX *ctx)
1070 {
1071 #define ADS_MODLIST_ALLOC_SIZE 10
1072         LDAPMod **mods;
1073
1074         if ((mods = TALLOC_ZERO_ARRAY(ctx, LDAPMod *, ADS_MODLIST_ALLOC_SIZE + 1)))
1075                 /* -1 is safety to make sure we don't go over the end.
1076                    need to reset it to NULL before doing ldap modify */
1077                 mods[ADS_MODLIST_ALLOC_SIZE] = (LDAPMod *) -1;
1078
1079         return (ADS_MODLIST)mods;
1080 }
1081
1082
1083 /*
1084   add an attribute to the list, with values list already constructed
1085 */
1086 static ADS_STATUS ads_modlist_add(TALLOC_CTX *ctx, ADS_MODLIST *mods,
1087                                   int mod_op, const char *name,
1088                                   const void *_invals)
1089 {
1090         const void **invals = (const void **)_invals;
1091         int curmod;
1092         LDAPMod **modlist = (LDAPMod **) *mods;
1093         struct berval **ber_values = NULL;
1094         char **char_values = NULL;
1095
1096         if (!invals) {
1097                 mod_op = LDAP_MOD_DELETE;
1098         } else {
1099                 if (mod_op & LDAP_MOD_BVALUES)
1100                         ber_values = ads_dup_values(ctx,
1101                                                 (const struct berval **)invals);
1102                 else
1103                         char_values = ads_push_strvals(ctx,
1104                                                   (const char **) invals);
1105         }
1106
1107         /* find the first empty slot */
1108         for (curmod=0; modlist[curmod] && modlist[curmod] != (LDAPMod *) -1;
1109              curmod++);
1110         if (modlist[curmod] == (LDAPMod *) -1) {
1111                 if (!(modlist = TALLOC_REALLOC_ARRAY(ctx, modlist, LDAPMod *,
1112                                 curmod+ADS_MODLIST_ALLOC_SIZE+1)))
1113                         return ADS_ERROR(LDAP_NO_MEMORY);
1114                 memset(&modlist[curmod], 0,
1115                        ADS_MODLIST_ALLOC_SIZE*sizeof(LDAPMod *));
1116                 modlist[curmod+ADS_MODLIST_ALLOC_SIZE] = (LDAPMod *) -1;
1117                 *mods = (ADS_MODLIST)modlist;
1118         }
1119
1120         if (!(modlist[curmod] = TALLOC_ZERO_P(ctx, LDAPMod)))
1121                 return ADS_ERROR(LDAP_NO_MEMORY);
1122         modlist[curmod]->mod_type = talloc_strdup(ctx, name);
1123         if (mod_op & LDAP_MOD_BVALUES) {
1124                 modlist[curmod]->mod_bvalues = ber_values;
1125         } else if (mod_op & LDAP_MOD_DELETE) {
1126                 modlist[curmod]->mod_values = NULL;
1127         } else {
1128                 modlist[curmod]->mod_values = char_values;
1129         }
1130
1131         modlist[curmod]->mod_op = mod_op;
1132         return ADS_ERROR(LDAP_SUCCESS);
1133 }
1134
1135 /**
1136  * Add a single string value to a mod list
1137  * @param ctx An initialized TALLOC_CTX
1138  * @param mods An initialized ADS_MODLIST
1139  * @param name The attribute name to add
1140  * @param val The value to add - NULL means DELETE
1141  * @return ADS STATUS indicating success of add
1142  **/
1143 ADS_STATUS ads_mod_str(TALLOC_CTX *ctx, ADS_MODLIST *mods,
1144                        const char *name, const char *val)
1145 {
1146         const char *values[2];
1147
1148         values[0] = val;
1149         values[1] = NULL;
1150
1151         if (!val)
1152                 return ads_modlist_add(ctx, mods, LDAP_MOD_DELETE, name, NULL);
1153         return ads_modlist_add(ctx, mods, LDAP_MOD_REPLACE, name, values);
1154 }
1155
1156 /**
1157  * Add an array of string values to a mod list
1158  * @param ctx An initialized TALLOC_CTX
1159  * @param mods An initialized ADS_MODLIST
1160  * @param name The attribute name to add
1161  * @param vals The array of string values to add - NULL means DELETE
1162  * @return ADS STATUS indicating success of add
1163  **/
1164 ADS_STATUS ads_mod_strlist(TALLOC_CTX *ctx, ADS_MODLIST *mods,
1165                            const char *name, const char **vals)
1166 {
1167         if (!vals)
1168                 return ads_modlist_add(ctx, mods, LDAP_MOD_DELETE, name, NULL);
1169         return ads_modlist_add(ctx, mods, LDAP_MOD_REPLACE,
1170                                name, (const void **) vals);
1171 }
1172
1173 #if 0
1174 /**
1175  * Add a single ber-encoded value to a mod list
1176  * @param ctx An initialized TALLOC_CTX
1177  * @param mods An initialized ADS_MODLIST
1178  * @param name The attribute name to add
1179  * @param val The value to add - NULL means DELETE
1180  * @return ADS STATUS indicating success of add
1181  **/
1182 static ADS_STATUS ads_mod_ber(TALLOC_CTX *ctx, ADS_MODLIST *mods,
1183                               const char *name, const struct berval *val)
1184 {
1185         const struct berval *values[2];
1186
1187         values[0] = val;
1188         values[1] = NULL;
1189         if (!val)
1190                 return ads_modlist_add(ctx, mods, LDAP_MOD_DELETE, name, NULL);
1191         return ads_modlist_add(ctx, mods, LDAP_MOD_REPLACE|LDAP_MOD_BVALUES,
1192                                name, (const void **) values);
1193 }
1194 #endif
1195
1196 /**
1197  * Perform an ldap modify
1198  * @param ads connection to ads server
1199  * @param mod_dn DistinguishedName to modify
1200  * @param mods list of modifications to perform
1201  * @return status of modify
1202  **/
1203 ADS_STATUS ads_gen_mod(ADS_STRUCT *ads, const char *mod_dn, ADS_MODLIST mods)
1204 {
1205         int ret,i;
1206         char *utf8_dn = NULL;
1207         /*
1208            this control is needed to modify that contains a currently
1209            non-existent attribute (but allowable for the object) to run
1210         */
1211         LDAPControl PermitModify = {
1212                 CONST_DISCARD(char *, ADS_PERMIT_MODIFY_OID),
1213                 {0, NULL},
1214                 (char) 1};
1215         LDAPControl *controls[2];
1216
1217         controls[0] = &PermitModify;
1218         controls[1] = NULL;
1219
1220         if (push_utf8_allocate(&utf8_dn, mod_dn) == -1) {
1221                 return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
1222         }
1223
1224         /* find the end of the list, marked by NULL or -1 */
1225         for(i=0;(mods[i]!=0)&&(mods[i]!=(LDAPMod *) -1);i++);
1226         /* make sure the end of the list is NULL */
1227         mods[i] = NULL;
1228         ret = ldap_modify_ext_s(ads->ld, utf8_dn,
1229                                 (LDAPMod **) mods, controls, NULL);
1230         SAFE_FREE(utf8_dn);
1231         return ADS_ERROR(ret);
1232 }
1233
1234 /**
1235  * Perform an ldap add
1236  * @param ads connection to ads server
1237  * @param new_dn DistinguishedName to add
1238  * @param mods list of attributes and values for DN
1239  * @return status of add
1240  **/
1241 ADS_STATUS ads_gen_add(ADS_STRUCT *ads, const char *new_dn, ADS_MODLIST mods)
1242 {
1243         int ret, i;
1244         char *utf8_dn = NULL;
1245
1246         if (push_utf8_allocate(&utf8_dn, new_dn) == -1) {
1247                 DEBUG(1, ("ads_gen_add: push_utf8_allocate failed!"));
1248                 return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
1249         }
1250
1251         /* find the end of the list, marked by NULL or -1 */
1252         for(i=0;(mods[i]!=0)&&(mods[i]!=(LDAPMod *) -1);i++);
1253         /* make sure the end of the list is NULL */
1254         mods[i] = NULL;
1255
1256         ret = ldap_add_s(ads->ld, utf8_dn, (LDAPMod**)mods);
1257         SAFE_FREE(utf8_dn);
1258         return ADS_ERROR(ret);
1259 }
1260
1261 /**
1262  * Delete a DistinguishedName
1263  * @param ads connection to ads server
1264  * @param new_dn DistinguishedName to delete
1265  * @return status of delete
1266  **/
1267 ADS_STATUS ads_del_dn(ADS_STRUCT *ads, char *del_dn)
1268 {
1269         int ret;
1270         char *utf8_dn = NULL;
1271         if (push_utf8_allocate(&utf8_dn, del_dn) == -1) {
1272                 DEBUG(1, ("ads_del_dn: push_utf8_allocate failed!"));
1273                 return ADS_ERROR_NT(NT_STATUS_NO_MEMORY);
1274         }
1275
1276         ret = ldap_delete_s(ads->ld, utf8_dn);
1277         SAFE_FREE(utf8_dn);
1278         return ADS_ERROR(ret);
1279 }
1280
1281 /**
1282  * Build an org unit string
1283  *  if org unit is Computers or blank then assume a container, otherwise
1284  *  assume a / separated list of organisational units.
1285  * jmcd: '\' is now used for escapes so certain chars can be in the ou (e.g. #)
1286  * @param ads connection to ads server
1287  * @param org_unit Organizational unit
1288  * @return org unit string - caller must free
1289  **/
1290 char *ads_ou_string(ADS_STRUCT *ads, const char *org_unit)
1291 {
1292         char *ret = NULL;
1293
1294         if (!org_unit || !*org_unit) {
1295
1296                 ret = ads_default_ou_string(ads, WELL_KNOWN_GUID_COMPUTERS);
1297
1298                 /* samba4 might not yet respond to a wellknownobject-query */
1299                 return ret ? ret : SMB_STRDUP("cn=Computers");
1300         }
1301
1302         if (strequal(org_unit, "Computers")) {
1303                 return SMB_STRDUP("cn=Computers");
1304         }
1305
1306         /* jmcd: removed "\\" from the separation chars, because it is
1307            needed as an escape for chars like '#' which are valid in an
1308            OU name */
1309         return ads_build_path(org_unit, "/", "ou=", 1);
1310 }
1311
1312 /**
1313  * Get a org unit string for a well-known GUID
1314  * @param ads connection to ads server
1315  * @param wknguid Well known GUID
1316  * @return org unit string - caller must free
1317  **/
1318 char *ads_default_ou_string(ADS_STRUCT *ads, const char *wknguid)
1319 {
1320         ADS_STATUS status;
1321         LDAPMessage *res = NULL;
1322         char *base, *wkn_dn = NULL, *ret = NULL, **wkn_dn_exp = NULL,
1323                 **bind_dn_exp = NULL;
1324         const char *attrs[] = {"distinguishedName", NULL};
1325         int new_ln, wkn_ln, bind_ln, i;
1326
1327         if (wknguid == NULL) {
1328                 return NULL;
1329         }
1330
1331         if (asprintf(&base, "<WKGUID=%s,%s>", wknguid, ads->config.bind_path ) == -1) {
1332                 DEBUG(1, ("asprintf failed!\n"));
1333                 return NULL;
1334         }
1335
1336         status = ads_search_dn(ads, &res, base, attrs);
1337         if (!ADS_ERR_OK(status)) {
1338                 DEBUG(1,("Failed while searching for: %s\n", base));
1339                 goto out;
1340         }
1341
1342         if (ads_count_replies(ads, res) != 1) {
1343                 goto out;
1344         }
1345
1346         /* substitute the bind-path from the well-known-guid-search result */
1347         wkn_dn = ads_get_dn(ads, res);
1348         if (!wkn_dn) {
1349                 goto out;
1350         }
1351
1352         wkn_dn_exp = ldap_explode_dn(wkn_dn, 0);
1353         if (!wkn_dn_exp) {
1354                 goto out;
1355         }
1356
1357         bind_dn_exp = ldap_explode_dn(ads->config.bind_path, 0);
1358         if (!bind_dn_exp) {
1359                 goto out;
1360         }
1361
1362         for (wkn_ln=0; wkn_dn_exp[wkn_ln]; wkn_ln++)
1363                 ;
1364         for (bind_ln=0; bind_dn_exp[bind_ln]; bind_ln++)
1365                 ;
1366
1367         new_ln = wkn_ln - bind_ln;
1368
1369         ret = SMB_STRDUP(wkn_dn_exp[0]);
1370         if (!ret) {
1371                 goto out;
1372         }
1373
1374         for (i=1; i < new_ln; i++) {
1375                 char *s = NULL;
1376
1377                 if (asprintf(&s, "%s,%s", ret, wkn_dn_exp[i]) == -1) {
1378                         SAFE_FREE(ret);
1379                         goto out;
1380                 }
1381
1382                 SAFE_FREE(ret);
1383                 ret = SMB_STRDUP(s);
1384                 free(s);
1385                 if (!ret) {
1386                         goto out;
1387                 }
1388         }
1389
1390  out:
1391         SAFE_FREE(base);
1392         ads_msgfree(ads, res);
1393         ads_memfree(ads, wkn_dn);
1394         if (wkn_dn_exp) {
1395                 ldap_value_free(wkn_dn_exp);
1396         }
1397         if (bind_dn_exp) {
1398                 ldap_value_free(bind_dn_exp);
1399         }
1400
1401         return ret;
1402 }
1403
1404 /**
1405  * Adds (appends) an item to an attribute array, rather then
1406  * replacing the whole list
1407  * @param ctx An initialized TALLOC_CTX
1408  * @param mods An initialized ADS_MODLIST
1409  * @param name name of the ldap attribute to append to
1410  * @param vals an array of values to add
1411  * @return status of addition
1412  **/
1413
1414 ADS_STATUS ads_add_strlist(TALLOC_CTX *ctx, ADS_MODLIST *mods,
1415                                 const char *name, const char **vals)
1416 {
1417         return ads_modlist_add(ctx, mods, LDAP_MOD_ADD, name,
1418                                (const void *) vals);
1419 }
1420
1421 /**
1422  * Determines the computer account's current KVNO via an LDAP lookup
1423  * @param ads An initialized ADS_STRUCT
1424  * @param machine_name the NetBIOS name of the computer, which is used to identify the computer account.
1425  * @return the kvno for the computer account, or -1 in case of a failure.
1426  **/
1427
1428 uint32 ads_get_kvno(ADS_STRUCT *ads, const char *machine_name)
1429 {
1430         LDAPMessage *res = NULL;
1431         uint32 kvno = (uint32)-1;      /* -1 indicates a failure */
1432         char *filter;
1433         const char *attrs[] = {"msDS-KeyVersionNumber", NULL};
1434         char *dn_string = NULL;
1435         ADS_STATUS ret = ADS_ERROR(LDAP_SUCCESS);
1436
1437         DEBUG(5,("ads_get_kvno: Searching for host %s\n", machine_name));
1438         if (asprintf(&filter, "(samAccountName=%s$)", machine_name) == -1) {
1439                 return kvno;
1440         }
1441         ret = ads_search(ads, &res, filter, attrs);
1442         SAFE_FREE(filter);
1443         if (!ADS_ERR_OK(ret) && ads_count_replies(ads, res)) {
1444                 DEBUG(1,("ads_get_kvno: Computer Account For %s not found.\n", machine_name));
1445                 ads_msgfree(ads, res);
1446                 return kvno;
1447         }
1448
1449         dn_string = ads_get_dn(ads, res);
1450         if (!dn_string) {
1451                 DEBUG(0,("ads_get_kvno: out of memory.\n"));
1452                 ads_msgfree(ads, res);
1453                 return kvno;
1454         }
1455         DEBUG(5,("ads_get_kvno: Using: %s\n", dn_string));
1456         ads_memfree(ads, dn_string);
1457
1458         /* ---------------------------------------------------------
1459          * 0 is returned as a default KVNO from this point on...
1460          * This is done because Windows 2000 does not support key
1461          * version numbers.  Chances are that a failure in the next
1462          * step is simply due to Windows 2000 being used for a
1463          * domain controller. */
1464         kvno = 0;
1465
1466         if (!ads_pull_uint32(ads, res, "msDS-KeyVersionNumber", &kvno)) {
1467                 DEBUG(3,("ads_get_kvno: Error Determining KVNO!\n"));
1468                 DEBUG(3,("ads_get_kvno: Windows 2000 does not support KVNO's, so this may be normal.\n"));
1469                 ads_msgfree(ads, res);
1470                 return kvno;
1471         }
1472
1473         /* Success */
1474         DEBUG(5,("ads_get_kvno: Looked Up KVNO of: %d\n", kvno));
1475         ads_msgfree(ads, res);
1476         return kvno;
1477 }
1478
1479 /**
1480  * This clears out all registered spn's for a given hostname
1481  * @param ads An initilaized ADS_STRUCT
1482  * @param machine_name the NetBIOS name of the computer.
1483  * @return 0 upon success, non-zero otherwise.
1484  **/
1485
1486 ADS_STATUS ads_clear_service_principal_names(ADS_STRUCT *ads, const char *machine_name)
1487 {
1488         TALLOC_CTX *ctx;
1489         LDAPMessage *res = NULL;
1490         ADS_MODLIST mods;
1491         const char *servicePrincipalName[1] = {NULL};
1492         ADS_STATUS ret = ADS_ERROR(LDAP_SUCCESS);
1493         char *dn_string = NULL;
1494
1495         ret = ads_find_machine_acct(ads, &res, machine_name);
1496         if (!ADS_ERR_OK(ret) || ads_count_replies(ads, res) != 1) {
1497                 DEBUG(5,("ads_clear_service_principal_names: WARNING: Host Account for %s not found... skipping operation.\n", machine_name));
1498                 DEBUG(5,("ads_clear_service_principal_names: WARNING: Service Principals for %s have NOT been cleared.\n", machine_name));
1499                 ads_msgfree(ads, res);
1500                 return ADS_ERROR(LDAP_NO_SUCH_OBJECT);
1501         }
1502
1503         DEBUG(5,("ads_clear_service_principal_names: Host account for %s found\n", machine_name));
1504         ctx = talloc_init("ads_clear_service_principal_names");
1505         if (!ctx) {
1506                 ads_msgfree(ads, res);
1507                 return ADS_ERROR(LDAP_NO_MEMORY);
1508         }
1509
1510         if (!(mods = ads_init_mods(ctx))) {
1511                 talloc_destroy(ctx);
1512                 ads_msgfree(ads, res);
1513                 return ADS_ERROR(LDAP_NO_MEMORY);
1514         }
1515         ret = ads_mod_strlist(ctx, &mods, "servicePrincipalName", servicePrincipalName);
1516         if (!ADS_ERR_OK(ret)) {
1517                 DEBUG(1,("ads_clear_service_principal_names: Error creating strlist.\n"));
1518                 ads_msgfree(ads, res);
1519                 talloc_destroy(ctx);
1520                 return ret;
1521         }
1522         dn_string = ads_get_dn(ads, res);
1523         if (!dn_string) {
1524                 talloc_destroy(ctx);
1525                 ads_msgfree(ads, res);
1526                 return ADS_ERROR(LDAP_NO_MEMORY);
1527         }
1528         ret = ads_gen_mod(ads, dn_string, mods);
1529         ads_memfree(ads,dn_string);
1530         if (!ADS_ERR_OK(ret)) {
1531                 DEBUG(1,("ads_clear_service_principal_names: Error: Updating Service Principals for machine %s in LDAP\n",
1532                         machine_name));
1533                 ads_msgfree(ads, res);
1534                 talloc_destroy(ctx);
1535                 return ret;
1536         }
1537
1538         ads_msgfree(ads, res);
1539         talloc_destroy(ctx);
1540         return ret;
1541 }
1542
1543 /**
1544  * This adds a service principal name to an existing computer account
1545  * (found by hostname) in AD.
1546  * @param ads An initialized ADS_STRUCT
1547  * @param machine_name the NetBIOS name of the computer, which is used to identify the computer account.
1548  * @param my_fqdn The fully qualified DNS name of the machine
1549  * @param spn A string of the service principal to add, i.e. 'host'
1550  * @return 0 upon sucess, or non-zero if a failure occurs
1551  **/
1552
1553 ADS_STATUS ads_add_service_principal_name(ADS_STRUCT *ads, const char *machine_name,
1554                                           const char *my_fqdn, const char *spn)
1555 {
1556         ADS_STATUS ret;
1557         TALLOC_CTX *ctx;
1558         LDAPMessage *res = NULL;
1559         char *psp1, *psp2;
1560         ADS_MODLIST mods;
1561         char *dn_string = NULL;
1562         const char *servicePrincipalName[3] = {NULL, NULL, NULL};
1563
1564         ret = ads_find_machine_acct(ads, &res, machine_name);
1565         if (!ADS_ERR_OK(ret) || ads_count_replies(ads, res) != 1) {
1566                 DEBUG(1,("ads_add_service_principal_name: WARNING: Host Account for %s not found... skipping operation.\n",
1567                         machine_name));
1568                 DEBUG(1,("ads_add_service_principal_name: WARNING: Service Principal '%s/%s@%s' has NOT been added.\n",
1569                         spn, machine_name, ads->config.realm));
1570                 ads_msgfree(ads, res);
1571                 return ADS_ERROR(LDAP_NO_SUCH_OBJECT);
1572         }
1573
1574         DEBUG(1,("ads_add_service_principal_name: Host account for %s found\n", machine_name));
1575         if (!(ctx = talloc_init("ads_add_service_principal_name"))) {
1576                 ads_msgfree(ads, res);
1577                 return ADS_ERROR(LDAP_NO_MEMORY);
1578         }
1579
1580         /* add short name spn */
1581
1582         if ( (psp1 = talloc_asprintf(ctx, "%s/%s", spn, machine_name)) == NULL ) {
1583                 talloc_destroy(ctx);
1584                 ads_msgfree(ads, res);
1585                 return ADS_ERROR(LDAP_NO_MEMORY);
1586         }
1587         strupper_m(psp1);
1588         strlower_m(&psp1[strlen(spn)]);
1589         servicePrincipalName[0] = psp1;
1590
1591         DEBUG(5,("ads_add_service_principal_name: INFO: Adding %s to host %s\n",
1592                 psp1, machine_name));
1593
1594
1595         /* add fully qualified spn */
1596
1597         if ( (psp2 = talloc_asprintf(ctx, "%s/%s", spn, my_fqdn)) == NULL ) {
1598                 ret = ADS_ERROR(LDAP_NO_MEMORY);
1599                 goto out;
1600         }
1601         strupper_m(psp2);
1602         strlower_m(&psp2[strlen(spn)]);
1603         servicePrincipalName[1] = psp2;
1604
1605         DEBUG(5,("ads_add_service_principal_name: INFO: Adding %s to host %s\n",
1606                 psp2, machine_name));
1607
1608         if ( (mods = ads_init_mods(ctx)) == NULL ) {
1609                 ret = ADS_ERROR(LDAP_NO_MEMORY);
1610                 goto out;
1611         }
1612
1613         ret = ads_add_strlist(ctx, &mods, "servicePrincipalName", servicePrincipalName);
1614         if (!ADS_ERR_OK(ret)) {
1615                 DEBUG(1,("ads_add_service_principal_name: Error: Updating Service Principals in LDAP\n"));
1616                 goto out;
1617         }
1618
1619         if ( (dn_string = ads_get_dn(ads, res)) == NULL ) {
1620                 ret = ADS_ERROR(LDAP_NO_MEMORY);
1621                 goto out;
1622         }
1623
1624         ret = ads_gen_mod(ads, dn_string, mods);
1625         ads_memfree(ads,dn_string);
1626         if (!ADS_ERR_OK(ret)) {
1627                 DEBUG(1,("ads_add_service_principal_name: Error: Updating Service Principals in LDAP\n"));
1628                 goto out;
1629         }
1630
1631  out:
1632         TALLOC_FREE( ctx );
1633         ads_msgfree(ads, res);
1634         return ret;
1635 }
1636
1637 /**
1638  * adds a machine account to the ADS server
1639  * @param ads An intialized ADS_STRUCT
1640  * @param machine_name - the NetBIOS machine name of this account.
1641  * @param account_type A number indicating the type of account to create
1642  * @param org_unit The LDAP path in which to place this account
1643  * @return 0 upon success, or non-zero otherwise
1644 **/
1645
1646 ADS_STATUS ads_create_machine_acct(ADS_STRUCT *ads, const char *machine_name,
1647                                    const char *org_unit)
1648 {
1649         ADS_STATUS ret;
1650         char *samAccountName, *controlstr;
1651         TALLOC_CTX *ctx;
1652         ADS_MODLIST mods;
1653         char *machine_escaped = NULL;
1654         char *new_dn;
1655         const char *objectClass[] = {"top", "person", "organizationalPerson",
1656                                      "user", "computer", NULL};
1657         LDAPMessage *res = NULL;
1658         uint32 acct_control = ( UF_WORKSTATION_TRUST_ACCOUNT |\
1659                                 UF_DONT_EXPIRE_PASSWD |\
1660                                 UF_ACCOUNTDISABLE );
1661
1662         if (!(ctx = talloc_init("ads_add_machine_acct")))
1663                 return ADS_ERROR(LDAP_NO_MEMORY);
1664
1665         ret = ADS_ERROR(LDAP_NO_MEMORY);
1666
1667         machine_escaped = escape_rdn_val_string_alloc(machine_name);
1668         if (!machine_escaped) {
1669                 goto done;
1670         }
1671
1672         new_dn = talloc_asprintf(ctx, "cn=%s,%s", machine_escaped, org_unit);
1673         samAccountName = talloc_asprintf(ctx, "%s$", machine_name);
1674
1675         if ( !new_dn || !samAccountName ) {
1676                 goto done;
1677         }
1678
1679 #ifndef ENCTYPE_ARCFOUR_HMAC
1680         acct_control |= UF_USE_DES_KEY_ONLY;
1681 #endif
1682
1683         if (!(controlstr = talloc_asprintf(ctx, "%u", acct_control))) {
1684                 goto done;
1685         }
1686
1687         if (!(mods = ads_init_mods(ctx))) {
1688                 goto done;
1689         }
1690
1691         ads_mod_str(ctx, &mods, "cn", machine_name);
1692         ads_mod_str(ctx, &mods, "sAMAccountName", samAccountName);
1693         ads_mod_strlist(ctx, &mods, "objectClass", objectClass);
1694         ads_mod_str(ctx, &mods, "userAccountControl", controlstr);
1695
1696         ret = ads_gen_add(ads, new_dn, mods);
1697
1698 done:
1699         SAFE_FREE(machine_escaped);
1700         ads_msgfree(ads, res);
1701         talloc_destroy(ctx);
1702
1703         return ret;
1704 }
1705
1706 /**
1707  * move a machine account to another OU on the ADS server
1708  * @param ads - An intialized ADS_STRUCT
1709  * @param machine_name - the NetBIOS machine name of this account.
1710  * @param org_unit - The LDAP path in which to place this account
1711  * @param moved - whether we moved the machine account (optional)
1712  * @return 0 upon success, or non-zero otherwise
1713 **/
1714
1715 ADS_STATUS ads_move_machine_acct(ADS_STRUCT *ads, const char *machine_name,
1716                                  const char *org_unit, BOOL *moved)
1717 {
1718         ADS_STATUS rc;
1719         int ldap_status;
1720         LDAPMessage *res = NULL;
1721         char *filter = NULL;
1722         char *computer_dn = NULL;
1723         char *parent_dn;
1724         char *computer_rdn = NULL;
1725         BOOL need_move = False;
1726
1727         if (asprintf(&filter, "(samAccountName=%s$)", machine_name) == -1) {
1728                 rc = ADS_ERROR(LDAP_NO_MEMORY);
1729                 goto done;
1730         }
1731
1732         /* Find pre-existing machine */
1733         rc = ads_search(ads, &res, filter, NULL);
1734         if (!ADS_ERR_OK(rc)) {
1735                 goto done;
1736         }
1737
1738         computer_dn = ads_get_dn(ads, res);
1739         if (!computer_dn) {
1740                 rc = ADS_ERROR(LDAP_NO_MEMORY);
1741                 goto done;
1742         }
1743
1744         parent_dn = ads_parent_dn(computer_dn);
1745         if (strequal(parent_dn, org_unit)) {
1746                 goto done;
1747         }
1748
1749         need_move = True;
1750
1751         if (asprintf(&computer_rdn, "CN=%s", machine_name) == -1) {
1752                 rc = ADS_ERROR(LDAP_NO_MEMORY);
1753                 goto done;
1754         }
1755
1756         ldap_status = ldap_rename_s(ads->ld, computer_dn, computer_rdn,
1757                                     org_unit, 1, NULL, NULL);
1758         rc = ADS_ERROR(ldap_status);
1759
1760 done:
1761         ads_msgfree(ads, res);
1762         SAFE_FREE(filter);
1763         SAFE_FREE(computer_dn);
1764         SAFE_FREE(computer_rdn);
1765
1766         if (!ADS_ERR_OK(rc)) {
1767                 need_move = False;
1768         }
1769
1770         if (moved) {
1771                 *moved = need_move;
1772         }
1773
1774         return rc;
1775 }
1776
1777 /*
1778   dump a binary result from ldap
1779 */
1780 static void dump_binary(const char *field, struct berval **values)
1781 {
1782         int i, j;
1783         for (i=0; values[i]; i++) {
1784                 printf("%s: ", field);
1785                 for (j=0; j<values[i]->bv_len; j++) {
1786                         printf("%02X", (unsigned char)values[i]->bv_val[j]);
1787                 }
1788                 printf("\n");
1789         }
1790 }
1791
1792 static void dump_guid(const char *field, struct berval **values)
1793 {
1794         int i;
1795         UUID_FLAT guid;
1796         for (i=0; values[i]; i++) {
1797                 memcpy(guid.info, values[i]->bv_val, sizeof(guid.info));
1798                 printf("%s: %s\n", field,
1799                        smb_uuid_string_static(smb_uuid_unpack_static(guid)));
1800         }
1801 }
1802
1803 /*
1804   dump a sid result from ldap
1805 */
1806 static void dump_sid(const char *field, struct berval **values)
1807 {
1808         int i;
1809         for (i=0; values[i]; i++) {
1810                 DOM_SID sid;
1811                 sid_parse(values[i]->bv_val, values[i]->bv_len, &sid);
1812                 printf("%s: %s\n", field, sid_string_static(&sid));
1813         }
1814 }
1815
1816 /*
1817   dump ntSecurityDescriptor
1818 */
1819 static void dump_sd(const char *filed, struct berval **values)
1820 {
1821         prs_struct ps;
1822
1823         SEC_DESC   *psd = 0;
1824         TALLOC_CTX *ctx = 0;
1825
1826         if (!(ctx = talloc_init("sec_io_desc")))
1827                 return;
1828
1829         /* prepare data */
1830         prs_init(&ps, values[0]->bv_len, ctx, UNMARSHALL);
1831         prs_copy_data_in(&ps, values[0]->bv_val, values[0]->bv_len);
1832         prs_set_offset(&ps,0);
1833
1834         /* parse secdesc */
1835         if (!sec_io_desc("sd", &psd, &ps, 1)) {
1836                 prs_mem_free(&ps);
1837                 talloc_destroy(ctx);
1838                 return;
1839         }
1840         if (psd) ads_disp_sd(psd);
1841
1842         prs_mem_free(&ps);
1843         talloc_destroy(ctx);
1844 }
1845
1846 /*
1847   dump a string result from ldap
1848 */
1849 static void dump_string(const char *field, char **values)
1850 {
1851         int i;
1852         for (i=0; values[i]; i++) {
1853                 printf("%s: %s\n", field, values[i]);
1854         }
1855 }
1856
1857 /*
1858   dump a field from LDAP on stdout
1859   used for debugging
1860 */
1861
1862 static BOOL ads_dump_field(char *field, void **values, void *data_area)
1863 {
1864         const struct {
1865                 const char *name;
1866                 BOOL string;
1867                 void (*handler)(const char *, struct berval **);
1868         } handlers[] = {
1869                 {"objectGUID", False, dump_guid},
1870                 {"netbootGUID", False, dump_guid},
1871                 {"nTSecurityDescriptor", False, dump_sd},
1872                 {"dnsRecord", False, dump_binary},
1873                 {"objectSid", False, dump_sid},
1874                 {"tokenGroups", False, dump_sid},
1875                 {"tokenGroupsNoGCAcceptable", False, dump_sid},
1876                 {"tokengroupsGlobalandUniversal", False, dump_sid},
1877                 {"mS-DS-CreatorSID", False, dump_sid},
1878                 {NULL, True, NULL}
1879         };
1880         int i;
1881
1882         if (!field) { /* must be end of an entry */
1883                 printf("\n");
1884                 return False;
1885         }
1886
1887         for (i=0; handlers[i].name; i++) {
1888                 if (StrCaseCmp(handlers[i].name, field) == 0) {
1889                         if (!values) /* first time, indicate string or not */
1890                                 return handlers[i].string;
1891                         handlers[i].handler(field, (struct berval **) values);
1892                         break;
1893                 }
1894         }
1895         if (!handlers[i].name) {
1896                 if (!values) /* first time, indicate string conversion */
1897                         return True;
1898                 dump_string(field, (char **)values);
1899         }
1900         return False;
1901 }
1902
1903 /**
1904  * Dump a result from LDAP on stdout
1905  *  used for debugging
1906  * @param ads connection to ads server
1907  * @param res Results to dump
1908  **/
1909
1910  void ads_dump(ADS_STRUCT *ads, LDAPMessage *res)
1911 {
1912         ads_process_results(ads, res, ads_dump_field, NULL);
1913 }
1914
1915 /**
1916  * Walk through results, calling a function for each entry found.
1917  *  The function receives a field name, a berval * array of values,
1918  *  and a data area passed through from the start.  The function is
1919  *  called once with null for field and values at the end of each
1920  *  entry.
1921  * @param ads connection to ads server
1922  * @param res Results to process
1923  * @param fn Function for processing each result
1924  * @param data_area user-defined area to pass to function
1925  **/
1926  void ads_process_results(ADS_STRUCT *ads, LDAPMessage *res,
1927                           BOOL(*fn)(char *, void **, void *),
1928                           void *data_area)
1929 {
1930         LDAPMessage *msg;
1931         TALLOC_CTX *ctx;
1932
1933         if (!(ctx = talloc_init("ads_process_results")))
1934                 return;
1935
1936         for (msg = ads_first_entry(ads, res); msg;
1937              msg = ads_next_entry(ads, msg)) {
1938                 char *utf8_field;
1939                 BerElement *b;
1940
1941                 for (utf8_field=ldap_first_attribute(ads->ld,
1942                                                      (LDAPMessage *)msg,&b);
1943                      utf8_field;
1944                      utf8_field=ldap_next_attribute(ads->ld,
1945                                                     (LDAPMessage *)msg,b)) {
1946                         struct berval **ber_vals;
1947                         char **str_vals, **utf8_vals;
1948                         char *field;
1949                         BOOL string;
1950
1951                         pull_utf8_talloc(ctx, &field, utf8_field);
1952                         string = fn(field, NULL, data_area);
1953
1954                         if (string) {
1955                                 utf8_vals = ldap_get_values(ads->ld,
1956                                                  (LDAPMessage *)msg, field);
1957                                 str_vals = ads_pull_strvals(ctx,
1958                                                   (const char **) utf8_vals);
1959                                 fn(field, (void **) str_vals, data_area);
1960                                 ldap_value_free(utf8_vals);
1961                         } else {
1962                                 ber_vals = ldap_get_values_len(ads->ld,
1963                                                  (LDAPMessage *)msg, field);
1964                                 fn(field, (void **) ber_vals, data_area);
1965
1966                                 ldap_value_free_len(ber_vals);
1967                         }
1968                         ldap_memfree(utf8_field);
1969                 }
1970                 ber_free(b, 0);
1971                 talloc_free_children(ctx);
1972                 fn(NULL, NULL, data_area); /* completed an entry */
1973
1974         }
1975         talloc_destroy(ctx);
1976 }
1977
1978 /**
1979  * count how many replies are in a LDAPMessage
1980  * @param ads connection to ads server
1981  * @param res Results to count
1982  * @return number of replies
1983  **/
1984 int ads_count_replies(ADS_STRUCT *ads, void *res)
1985 {
1986         return ldap_count_entries(ads->ld, (LDAPMessage *)res);
1987 }
1988
1989 /**
1990  * pull the first entry from a ADS result
1991  * @param ads connection to ads server
1992  * @param res Results of search
1993  * @return first entry from result
1994  **/
1995  LDAPMessage *ads_first_entry(ADS_STRUCT *ads, LDAPMessage *res)
1996 {
1997         return ldap_first_entry(ads->ld, res);
1998 }
1999
2000 /**
2001  * pull the next entry from a ADS result
2002  * @param ads connection to ads server
2003  * @param res Results of search
2004  * @return next entry from result
2005  **/
2006  LDAPMessage *ads_next_entry(ADS_STRUCT *ads, LDAPMessage *res)
2007 {
2008         return ldap_next_entry(ads->ld, res);
2009 }
2010
2011 /**
2012  * pull a single string from a ADS result
2013  * @param ads connection to ads server
2014  * @param mem_ctx TALLOC_CTX to use for allocating result string
2015  * @param msg Results of search
2016  * @param field Attribute to retrieve
2017  * @return Result string in talloc context
2018  **/
2019  char *ads_pull_string(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx, LDAPMessage *msg,
2020                        const char *field)
2021 {
2022         char **values;
2023         char *ret = NULL;
2024         char *ux_string;
2025         size_t rc;
2026
2027         values = ldap_get_values(ads->ld, msg, field);
2028         if (!values)
2029                 return NULL;
2030
2031         if (values[0]) {
2032                 rc = pull_utf8_talloc(mem_ctx, &ux_string,
2033                                       values[0]);
2034                 if (rc != (size_t)-1)
2035                         ret = ux_string;
2036
2037         }
2038         ldap_value_free(values);
2039         return ret;
2040 }
2041
2042 /**
2043  * pull an array of strings from a ADS result
2044  * @param ads connection to ads server
2045  * @param mem_ctx TALLOC_CTX to use for allocating result string
2046  * @param msg Results of search
2047  * @param field Attribute to retrieve
2048  * @return Result strings in talloc context
2049  **/
2050  char **ads_pull_strings(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx,
2051                          LDAPMessage *msg, const char *field,
2052                          size_t *num_values)
2053 {
2054         char **values;
2055         char **ret = NULL;
2056         int i;
2057
2058         values = ldap_get_values(ads->ld, msg, field);
2059         if (!values)
2060                 return NULL;
2061
2062         *num_values = ldap_count_values(values);
2063
2064         ret = TALLOC_ARRAY(mem_ctx, char *, *num_values + 1);
2065         if (!ret) {
2066                 ldap_value_free(values);
2067                 return NULL;
2068         }
2069
2070         for (i=0;i<*num_values;i++) {
2071                 if (pull_utf8_talloc(mem_ctx, &ret[i], values[i]) == -1) {
2072                         ldap_value_free(values);
2073                         return NULL;
2074                 }
2075         }
2076         ret[i] = NULL;
2077
2078         ldap_value_free(values);
2079         return ret;
2080 }
2081
2082 /**
2083  * pull an array of strings from a ADS result
2084  *  (handle large multivalue attributes with range retrieval)
2085  * @param ads connection to ads server
2086  * @param mem_ctx TALLOC_CTX to use for allocating result string
2087  * @param msg Results of search
2088  * @param field Attribute to retrieve
2089  * @param current_strings strings returned by a previous call to this function
2090  * @param next_attribute The next query should ask for this attribute
2091  * @param num_values How many values did we get this time?
2092  * @param more_values Are there more values to get?
2093  * @return Result strings in talloc context
2094  **/
2095  char **ads_pull_strings_range(ADS_STRUCT *ads,
2096                                TALLOC_CTX *mem_ctx,
2097                                LDAPMessage *msg, const char *field,
2098                                char **current_strings,
2099                                const char **next_attribute,
2100                                size_t *num_strings,
2101                                BOOL *more_strings)
2102 {
2103         char *attr;
2104         char *expected_range_attrib, *range_attr;
2105         BerElement *ptr = NULL;
2106         char **strings;
2107         char **new_strings;
2108         size_t num_new_strings;
2109         unsigned long int range_start;
2110         unsigned long int range_end;
2111
2112         /* we might have been given the whole lot anyway */
2113         if ((strings = ads_pull_strings(ads, mem_ctx, msg, field, num_strings))) {
2114                 *more_strings = False;
2115                 return strings;
2116         }
2117
2118         expected_range_attrib = talloc_asprintf(mem_ctx, "%s;Range=", field);
2119
2120         /* look for Range result */
2121         for (attr = ldap_first_attribute(ads->ld, (LDAPMessage *)msg, &ptr);
2122              attr;
2123              attr = ldap_next_attribute(ads->ld, (LDAPMessage *)msg, ptr)) {
2124                 /* we ignore the fact that this is utf8, as all attributes are ascii... */
2125                 if (strnequal(attr, expected_range_attrib, strlen(expected_range_attrib))) {
2126                         range_attr = attr;
2127                         break;
2128                 }
2129                 ldap_memfree(attr);
2130         }
2131         if (!attr) {
2132                 ber_free(ptr, 0);
2133                 /* nothing here - this field is just empty */
2134                 *more_strings = False;
2135                 return NULL;
2136         }
2137
2138         if (sscanf(&range_attr[strlen(expected_range_attrib)], "%lu-%lu",
2139                    &range_start, &range_end) == 2) {
2140                 *more_strings = True;
2141         } else {
2142                 if (sscanf(&range_attr[strlen(expected_range_attrib)], "%lu-*",
2143                            &range_start) == 1) {
2144                         *more_strings = False;
2145                 } else {
2146                         DEBUG(1, ("ads_pull_strings_range:  Cannot parse Range attriubte (%s)\n",
2147                                   range_attr));
2148                         ldap_memfree(range_attr);
2149                         *more_strings = False;
2150                         return NULL;
2151                 }
2152         }
2153
2154         if ((*num_strings) != range_start) {
2155                 DEBUG(1, ("ads_pull_strings_range: Range attribute (%s) doesn't start at %u, but at %lu"
2156                           " - aborting range retreival\n",
2157                           range_attr, (unsigned int)(*num_strings) + 1, range_start));
2158                 ldap_memfree(range_attr);
2159                 *more_strings = False;
2160                 return NULL;
2161         }
2162
2163         new_strings = ads_pull_strings(ads, mem_ctx, msg, range_attr, &num_new_strings);
2164
2165         if (*more_strings && ((*num_strings + num_new_strings) != (range_end + 1))) {
2166                 DEBUG(1, ("ads_pull_strings_range: Range attribute (%s) tells us we have %lu "
2167                           "strings in this bunch, but we only got %lu - aborting range retreival\n",
2168                           range_attr, (unsigned long int)range_end - range_start + 1,
2169                           (unsigned long int)num_new_strings));
2170                 ldap_memfree(range_attr);
2171                 *more_strings = False;
2172                 return NULL;
2173         }
2174
2175         strings = TALLOC_REALLOC_ARRAY(mem_ctx, current_strings, char *,
2176                                  *num_strings + num_new_strings);
2177
2178         if (strings == NULL) {
2179                 ldap_memfree(range_attr);
2180                 *more_strings = False;
2181                 return NULL;
2182         }
2183
2184         if (new_strings && num_new_strings) {
2185                 memcpy(&strings[*num_strings], new_strings,
2186                        sizeof(*new_strings) * num_new_strings);
2187         }
2188
2189         (*num_strings) += num_new_strings;
2190
2191         if (*more_strings) {
2192                 *next_attribute = talloc_asprintf(mem_ctx,
2193                                                   "%s;range=%d-*",
2194                                                   field,
2195                                                   (int)*num_strings);
2196
2197                 if (!*next_attribute) {
2198                         DEBUG(1, ("talloc_asprintf for next attribute failed!\n"));
2199                         ldap_memfree(range_attr);
2200                         *more_strings = False;
2201                         return NULL;
2202                 }
2203         }
2204
2205         ldap_memfree(range_attr);
2206
2207         return strings;
2208 }
2209
2210 /**
2211  * pull a single uint32 from a ADS result
2212  * @param ads connection to ads server
2213  * @param msg Results of search
2214  * @param field Attribute to retrieve
2215  * @param v Pointer to int to store result
2216  * @return boolean inidicating success
2217 */
2218  BOOL ads_pull_uint32(ADS_STRUCT *ads, LDAPMessage *msg, const char *field,
2219                       uint32 *v)
2220 {
2221         char **values;
2222
2223         values = ldap_get_values(ads->ld, msg, field);
2224         if (!values)
2225                 return False;
2226         if (!values[0]) {
2227                 ldap_value_free(values);
2228                 return False;
2229         }
2230
2231         *v = atoi(values[0]);
2232         ldap_value_free(values);
2233         return True;
2234 }
2235
2236 /**
2237  * pull a single objectGUID from an ADS result
2238  * @param ads connection to ADS server
2239  * @param msg results of search
2240  * @param guid 37-byte area to receive text guid
2241  * @return boolean indicating success
2242  **/
2243  BOOL ads_pull_guid(ADS_STRUCT *ads, LDAPMessage *msg, struct GUID *guid)
2244 {
2245         char **values;
2246         UUID_FLAT flat_guid;
2247
2248         values = ldap_get_values(ads->ld, msg, "objectGUID");
2249         if (!values)
2250                 return False;
2251
2252         if (values[0]) {
2253                 memcpy(&flat_guid.info, values[0], sizeof(UUID_FLAT));
2254                 smb_uuid_unpack(flat_guid, guid);
2255                 ldap_value_free(values);
2256                 return True;
2257         }
2258         ldap_value_free(values);
2259         return False;
2260
2261 }
2262
2263
2264 /**
2265  * pull a single DOM_SID from a ADS result
2266  * @param ads connection to ads server
2267  * @param msg Results of search
2268  * @param field Attribute to retrieve
2269  * @param sid Pointer to sid to store result
2270  * @return boolean inidicating success
2271 */
2272  BOOL ads_pull_sid(ADS_STRUCT *ads, LDAPMessage *msg, const char *field,
2273                    DOM_SID *sid)
2274 {
2275         struct berval **values;
2276         BOOL ret = False;
2277
2278         values = ldap_get_values_len(ads->ld, msg, field);
2279
2280         if (!values)
2281                 return False;
2282
2283         if (values[0])
2284                 ret = sid_parse(values[0]->bv_val, values[0]->bv_len, sid);
2285
2286         ldap_value_free_len(values);
2287         return ret;
2288 }
2289
2290 /**
2291  * pull an array of DOM_SIDs from a ADS result
2292  * @param ads connection to ads server
2293  * @param mem_ctx TALLOC_CTX for allocating sid array
2294  * @param msg Results of search
2295  * @param field Attribute to retrieve
2296  * @param sids pointer to sid array to allocate
2297  * @return the count of SIDs pulled
2298  **/
2299  int ads_pull_sids(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx,
2300                    LDAPMessage *msg, const char *field, DOM_SID **sids)
2301 {
2302         struct berval **values;
2303         BOOL ret;
2304         int count, i;
2305
2306         values = ldap_get_values_len(ads->ld, msg, field);
2307
2308         if (!values)
2309                 return 0;
2310
2311         for (i=0; values[i]; i++)
2312                 /* nop */ ;
2313
2314         if (i) {
2315                 (*sids) = TALLOC_ARRAY(mem_ctx, DOM_SID, i);
2316                 if (!(*sids)) {
2317                         ldap_value_free_len(values);
2318                         return 0;
2319                 }
2320         } else {
2321                 (*sids) = NULL;
2322         }
2323
2324         count = 0;
2325         for (i=0; values[i]; i++) {
2326                 ret = sid_parse(values[i]->bv_val, values[i]->bv_len, &(*sids)[count]);
2327                 if (ret) {
2328                         fstring sid;
2329                         DEBUG(10, ("pulling SID: %s\n", sid_to_string(sid, &(*sids)[count])));
2330                         count++;
2331                 }
2332         }
2333
2334         ldap_value_free_len(values);
2335         return count;
2336 }
2337
2338 /**
2339  * pull a SEC_DESC from a ADS result
2340  * @param ads connection to ads server
2341  * @param mem_ctx TALLOC_CTX for allocating sid array
2342  * @param msg Results of search
2343  * @param field Attribute to retrieve
2344  * @param sd Pointer to *SEC_DESC to store result (talloc()ed)
2345  * @return boolean inidicating success
2346 */
2347  BOOL ads_pull_sd(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx,
2348                   LDAPMessage *msg, const char *field, SEC_DESC **sd)
2349 {
2350         struct berval **values;
2351         BOOL ret = False;
2352
2353         values = ldap_get_values_len(ads->ld, msg, field);
2354
2355         if (!values) return False;
2356
2357         if (values[0]) {
2358                 prs_struct ps;
2359                 prs_init(&ps, values[0]->bv_len, mem_ctx, UNMARSHALL);
2360                 prs_copy_data_in(&ps, values[0]->bv_val, values[0]->bv_len);
2361                 prs_set_offset(&ps,0);
2362
2363                 ret = sec_io_desc("sd", sd, &ps, 1);
2364                 prs_mem_free(&ps);
2365         }
2366
2367         ldap_value_free_len(values);
2368         return ret;
2369 }
2370
2371 /*
2372  * in order to support usernames longer than 21 characters we need to
2373  * use both the sAMAccountName and the userPrincipalName attributes
2374  * It seems that not all users have the userPrincipalName attribute set
2375  *
2376  * @param ads connection to ads server
2377  * @param mem_ctx TALLOC_CTX for allocating sid array
2378  * @param msg Results of search
2379  * @return the username
2380  */
2381  char *ads_pull_username(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx,
2382                          LDAPMessage *msg)
2383 {
2384 #if 0   /* JERRY */
2385         char *ret, *p;
2386
2387         /* lookup_name() only works on the sAMAccountName to
2388            returning the username portion of userPrincipalName
2389            breaks winbindd_getpwnam() */
2390
2391         ret = ads_pull_string(ads, mem_ctx, msg, "userPrincipalName");
2392         if (ret && (p = strchr_m(ret, '@'))) {
2393                 *p = 0;
2394                 return ret;
2395         }
2396 #endif
2397         return ads_pull_string(ads, mem_ctx, msg, "sAMAccountName");
2398 }
2399
2400
2401 /**
2402  * find the update serial number - this is the core of the ldap cache
2403  * @param ads connection to ads server
2404  * @param ads connection to ADS server
2405  * @param usn Pointer to retrieved update serial number
2406  * @return status of search
2407  **/
2408 ADS_STATUS ads_USN(ADS_STRUCT *ads, uint32 *usn)
2409 {
2410         const char *attrs[] = {"highestCommittedUSN", NULL};
2411         ADS_STATUS status;
2412         LDAPMessage *res;
2413
2414         status = ads_do_search_retry(ads, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
2415         if (!ADS_ERR_OK(status))
2416                 return status;
2417
2418         if (ads_count_replies(ads, res) != 1) {
2419                 ads_msgfree(ads, res);
2420                 return ADS_ERROR(LDAP_NO_RESULTS_RETURNED);
2421         }
2422
2423         if (!ads_pull_uint32(ads, res, "highestCommittedUSN", usn)) {
2424                 ads_msgfree(ads, res);
2425                 return ADS_ERROR(LDAP_NO_SUCH_ATTRIBUTE);
2426         }
2427
2428         ads_msgfree(ads, res);
2429         return ADS_SUCCESS;
2430 }
2431
2432 /* parse a ADS timestring - typical string is
2433    '20020917091222.0Z0' which means 09:12.22 17th September
2434    2002, timezone 0 */
2435 static time_t ads_parse_time(const char *str)
2436 {
2437         struct tm tm;
2438
2439         ZERO_STRUCT(tm);
2440
2441         if (sscanf(str, "%4d%2d%2d%2d%2d%2d",
2442                    &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
2443                    &tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {
2444                 return 0;
2445         }
2446         tm.tm_year -= 1900;
2447         tm.tm_mon -= 1;
2448
2449         return timegm(&tm);
2450 }
2451
2452 /********************************************************************
2453 ********************************************************************/
2454
2455 ADS_STATUS ads_current_time(ADS_STRUCT *ads)
2456 {
2457         const char *attrs[] = {"currentTime", NULL};
2458         ADS_STATUS status;
2459         LDAPMessage *res;
2460         char *timestr;
2461         TALLOC_CTX *ctx;
2462         ADS_STRUCT *ads_s = ads;
2463
2464         if (!(ctx = talloc_init("ads_current_time"))) {
2465                 return ADS_ERROR(LDAP_NO_MEMORY);
2466         }
2467
2468         /* establish a new ldap tcp session if necessary */
2469
2470         if ( !ads->ld ) {
2471                 if ( (ads_s = ads_init( ads->server.realm, ads->server.workgroup,
2472                         ads->server.ldap_server )) == NULL )
2473                 {
2474                         goto done;
2475                 }
2476                 ads_s->auth.flags = ADS_AUTH_ANON_BIND;
2477                 status = ads_connect( ads_s );
2478                 if ( !ADS_ERR_OK(status))
2479                         goto done;
2480         }
2481
2482         status = ads_do_search(ads_s, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
2483         if (!ADS_ERR_OK(status)) {
2484                 goto done;
2485         }
2486
2487         timestr = ads_pull_string(ads_s, ctx, res, "currentTime");
2488         if (!timestr) {
2489                 ads_msgfree(ads_s, res);
2490                 status = ADS_ERROR(LDAP_NO_RESULTS_RETURNED);
2491                 goto done;
2492         }
2493
2494         /* but save the time and offset in the original ADS_STRUCT */
2495
2496         ads->config.current_time = ads_parse_time(timestr);
2497
2498         if (ads->config.current_time != 0) {
2499                 ads->auth.time_offset = ads->config.current_time - time(NULL);
2500                 DEBUG(4,("time offset is %d seconds\n", ads->auth.time_offset));
2501         }
2502
2503         ads_msgfree(ads, res);
2504
2505         status = ADS_SUCCESS;
2506
2507 done:
2508         /* free any temporary ads connections */
2509         if ( ads_s != ads ) {
2510                 ads_destroy( &ads_s );
2511         }
2512         talloc_destroy(ctx);
2513
2514         return status;
2515 }
2516
2517 /********************************************************************
2518 ********************************************************************/
2519
2520 ADS_STATUS ads_domain_func_level(ADS_STRUCT *ads, uint32 *val)
2521 {
2522         const char *attrs[] = {"domainFunctionality", NULL};
2523         ADS_STATUS status;
2524         LDAPMessage *res;
2525         ADS_STRUCT *ads_s = ads;
2526
2527         *val = DS_DOMAIN_FUNCTION_2000;
2528
2529         /* establish a new ldap tcp session if necessary */
2530
2531         if ( !ads->ld ) {
2532                 if ( (ads_s = ads_init( ads->server.realm, ads->server.workgroup,
2533                         ads->server.ldap_server )) == NULL )
2534                 {
2535                         goto done;
2536                 }
2537                 ads_s->auth.flags = ADS_AUTH_ANON_BIND;
2538                 status = ads_connect( ads_s );
2539                 if ( !ADS_ERR_OK(status))
2540                         goto done;
2541         }
2542
2543         /* If the attribute does not exist assume it is a Windows 2000
2544            functional domain */
2545
2546         status = ads_do_search(ads_s, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
2547         if (!ADS_ERR_OK(status)) {
2548                 if ( status.err.rc == LDAP_NO_SUCH_ATTRIBUTE ) {
2549                         status = ADS_SUCCESS;
2550                 }
2551                 goto done;
2552         }
2553
2554         if ( !ads_pull_uint32(ads_s, res, "domainFunctionality", val) ) {
2555                 DEBUG(5,("ads_domain_func_level: Failed to pull the domainFunctionality attribute.\n"));
2556         }
2557         DEBUG(3,("ads_domain_func_level: %d\n", *val));
2558
2559
2560         ads_msgfree(ads, res);
2561
2562 done:
2563         /* free any temporary ads connections */
2564         if ( ads_s != ads ) {
2565                 ads_destroy( &ads_s );
2566         }
2567
2568         return status;
2569 }
2570
2571 /**
2572  * find the domain sid for our domain
2573  * @param ads connection to ads server
2574  * @param sid Pointer to domain sid
2575  * @return status of search
2576  **/
2577 ADS_STATUS ads_domain_sid(ADS_STRUCT *ads, DOM_SID *sid)
2578 {
2579         const char *attrs[] = {"objectSid", NULL};
2580         LDAPMessage *res;
2581         ADS_STATUS rc;
2582
2583         rc = ads_do_search_retry(ads, ads->config.bind_path, LDAP_SCOPE_BASE, "(objectclass=*)",
2584                            attrs, &res);
2585         if (!ADS_ERR_OK(rc)) return rc;
2586         if (!ads_pull_sid(ads, res, "objectSid", sid)) {
2587                 ads_msgfree(ads, res);
2588                 return ADS_ERROR_SYSTEM(ENOENT);
2589         }
2590         ads_msgfree(ads, res);
2591
2592         return ADS_SUCCESS;
2593 }
2594
2595 /**
2596  * find our site name
2597  * @param ads connection to ads server
2598  * @param mem_ctx Pointer to talloc context
2599  * @param site_name Pointer to the sitename
2600  * @return status of search
2601  **/
2602 ADS_STATUS ads_site_dn(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx, const char **site_name)
2603 {
2604         ADS_STATUS status;
2605         LDAPMessage *res;
2606         const char *dn, *service_name;
2607         const char *attrs[] = { "dsServiceName", NULL };
2608
2609         status = ads_do_search(ads, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
2610         if (!ADS_ERR_OK(status)) {
2611                 return status;
2612         }
2613
2614         service_name = ads_pull_string(ads, mem_ctx, res, "dsServiceName");
2615         if (service_name == NULL) {
2616                 ads_msgfree(ads, res);
2617                 return ADS_ERROR(LDAP_NO_RESULTS_RETURNED);
2618         }
2619
2620         ads_msgfree(ads, res);
2621
2622         /* go up three levels */
2623         dn = ads_parent_dn(ads_parent_dn(ads_parent_dn(service_name)));
2624         if (dn == NULL) {
2625                 return ADS_ERROR(LDAP_NO_MEMORY);
2626         }
2627
2628         *site_name = talloc_strdup(mem_ctx, dn);
2629         if (*site_name == NULL) {
2630                 return ADS_ERROR(LDAP_NO_MEMORY);
2631         }
2632
2633         return status;
2634         /*
2635         dsServiceName: CN=NTDS Settings,CN=W2K3DC,CN=Servers,CN=Default-First-Site-Name,CN=Sites,CN=Configuration,DC=ber,DC=suse,DC=de
2636         */
2637 }
2638
2639 /**
2640  * find the site dn where a machine resides
2641  * @param ads connection to ads server
2642  * @param mem_ctx Pointer to talloc context
2643  * @param computer_name name of the machine
2644  * @param site_name Pointer to the sitename
2645  * @return status of search
2646  **/
2647 ADS_STATUS ads_site_dn_for_machine(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx, const char *computer_name, const char **site_dn)
2648 {
2649         ADS_STATUS status;
2650         LDAPMessage *res;
2651         const char *parent, *config_context, *filter;
2652         const char *attrs[] = { "configurationNamingContext", NULL };
2653         char *dn;
2654
2655         /* shortcut a query */
2656         if (strequal(computer_name, ads->config.ldap_server_name)) {
2657                 return ads_site_dn(ads, mem_ctx, site_dn);
2658         }
2659
2660         status = ads_do_search(ads, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
2661         if (!ADS_ERR_OK(status)) {
2662                 return status;
2663         }
2664
2665         config_context = ads_pull_string(ads, mem_ctx, res, "configurationNamingContext");
2666         if (config_context == NULL) {
2667                 ads_msgfree(ads, res);
2668                 return ADS_ERROR(LDAP_NO_MEMORY);
2669         }
2670
2671         filter = talloc_asprintf(mem_ctx, "(cn=%s)", computer_name);
2672         if (filter == NULL) {
2673                 ads_msgfree(ads, res);
2674                 return ADS_ERROR(LDAP_NO_MEMORY);
2675         }
2676
2677         ads_msgfree(ads, res);
2678
2679         status = ads_do_search(ads, config_context, LDAP_SCOPE_SUBTREE, filter, NULL, &res);
2680         if (!ADS_ERR_OK(status)) {
2681                 return status;
2682         }
2683
2684         if (ads_count_replies(ads, res) != 1) {
2685                 ads_msgfree(ads, res);
2686                 return ADS_ERROR(LDAP_NO_SUCH_OBJECT);
2687         }
2688
2689         dn = ads_get_dn(ads, res);
2690         if (dn == NULL) {
2691                 ads_msgfree(ads, res);
2692                 return ADS_ERROR(LDAP_NO_MEMORY);
2693         }
2694
2695         /* go up three levels */
2696         parent = ads_parent_dn(ads_parent_dn(ads_parent_dn(dn)));
2697         if (parent == NULL) {
2698                 ads_msgfree(ads, res);
2699                 ads_memfree(ads, dn);
2700                 return ADS_ERROR(LDAP_NO_MEMORY);
2701         }
2702
2703         *site_dn = talloc_strdup(mem_ctx, parent);
2704         if (*site_dn == NULL) {
2705                 ads_msgfree(ads, res);
2706                 ads_memfree(ads, dn);
2707                 ADS_ERROR(LDAP_NO_MEMORY);
2708         }
2709
2710         ads_memfree(ads, dn);
2711         ads_msgfree(ads, res);
2712
2713         return status;
2714 }
2715
2716 /**
2717  * get the upn suffixes for a domain
2718  * @param ads connection to ads server
2719  * @param mem_ctx Pointer to talloc context
2720  * @param suffixes Pointer to an array of suffixes
2721  * @param num_suffixes Pointer to the number of suffixes
2722  * @return status of search
2723  **/
2724 ADS_STATUS ads_upn_suffixes(ADS_STRUCT *ads, TALLOC_CTX *mem_ctx, char ***suffixes, size_t *num_suffixes)
2725 {
2726         ADS_STATUS status;
2727         LDAPMessage *res;
2728         const char *config_context, *base;
2729         const char *attrs[] = { "configurationNamingContext", NULL };
2730         const char *attrs2[] = { "uPNSuffixes", NULL };
2731
2732         status = ads_do_search(ads, "", LDAP_SCOPE_BASE, "(objectclass=*)", attrs, &res);
2733         if (!ADS_ERR_OK(status)) {
2734                 return status;
2735         }
2736
2737         config_context = ads_pull_string(ads, mem_ctx, res, "configurationNamingContext");
2738         if (config_context == NULL) {
2739                 ads_msgfree(ads, res);
2740                 return ADS_ERROR(LDAP_NO_MEMORY);
2741         }
2742
2743         ads_msgfree(ads, res);
2744
2745         base = talloc_asprintf(mem_ctx, "cn=Partitions,%s", config_context);
2746         if (base == NULL) {
2747                 return ADS_ERROR(LDAP_NO_MEMORY);
2748         }
2749
2750         status = ads_search_dn(ads, &res, base, attrs2);
2751         if (!ADS_ERR_OK(status)) {
2752                 return status;
2753         }
2754
2755         if (ads_count_replies(ads, res) != 1) {
2756                 return ADS_ERROR(LDAP_NO_SUCH_OBJECT);
2757         }
2758
2759         (*suffixes) = ads_pull_strings(ads, mem_ctx, res, "uPNSuffixes", num_suffixes);
2760         if ((*suffixes) == NULL) {
2761                 ads_msgfree(ads, res);
2762                 return ADS_ERROR(LDAP_NO_MEMORY);
2763         }
2764
2765         ads_msgfree(ads, res);
2766
2767         return status;
2768 }
2769
2770 /**
2771  * pull a DOM_SID from an extended dn string
2772  * @param mem_ctx TALLOC_CTX
2773  * @param extended_dn string
2774  * @param flags string type of extended_dn
2775  * @param sid pointer to a DOM_SID
2776  * @return boolean inidicating success
2777  **/
2778 BOOL ads_get_sid_from_extended_dn(TALLOC_CTX *mem_ctx,
2779                                   const char *extended_dn,
2780                                   enum ads_extended_dn_flags flags,
2781                                   DOM_SID *sid)
2782 {
2783         char *p, *q, *dn;
2784
2785         if (!extended_dn) {
2786                 return False;
2787         }
2788
2789         /* otherwise extended_dn gets stripped off */
2790         if ((dn = talloc_strdup(mem_ctx, extended_dn)) == NULL) {
2791                 return False;
2792         }
2793         /*
2794          * ADS_EXTENDED_DN_HEX_STRING:
2795          * <GUID=238e1963cb390f4bb032ba0105525a29>;<SID=010500000000000515000000bb68c8fd6b61b427572eb04556040000>;CN=gd,OU=berlin,OU=suse,DC=ber,DC=suse,DC=de
2796          *
2797          * ADS_EXTENDED_DN_STRING (only with w2k3):
2798         <GUID=63198e23-39cb-4b0f-b032-ba0105525a29>;<SID=S-1-5-21-4257769659-666132843-1169174103-1110>;CN=gd,OU=berlin,OU=suse,DC=ber,DC=suse,DC=de
2799          */
2800
2801         p = strchr(dn, ';');
2802         if (!p) {
2803                 return False;
2804         }
2805
2806         if (strncmp(p, ";<SID=", strlen(";<SID=")) != 0) {
2807                 return False;
2808         }
2809
2810         p += strlen(";<SID=");
2811
2812         q = strchr(p, '>');
2813         if (!q) {
2814                 return False;
2815         }
2816
2817         *q = '\0';
2818
2819         DEBUG(100,("ads_get_sid_from_extended_dn: sid string is %s\n", p));
2820
2821         switch (flags) {
2822
2823         case ADS_EXTENDED_DN_STRING:
2824                 if (!string_to_sid(sid, p)) {
2825                         return False;
2826                 }
2827                 break;
2828         case ADS_EXTENDED_DN_HEX_STRING: {
2829                 pstring buf;
2830                 size_t buf_len;
2831
2832                 buf_len = strhex_to_str(buf, strlen(p), p);
2833                 if (buf_len == 0) {
2834                         return False;
2835                 }
2836
2837                 if (!sid_parse(buf, buf_len, sid)) {
2838                         DEBUG(10,("failed to parse sid\n"));
2839                         return False;
2840                 }
2841                 break;
2842                 }
2843         default:
2844                 DEBUG(10,("unknown extended dn format\n"));
2845                 return False;
2846         }
2847
2848         return True;
2849 }
2850
2851 /**
2852  * pull an array of DOM_SIDs from a ADS result
2853  * @param ads connection to ads server
2854  * @param mem_ctx TALLOC_CTX for allocating sid array
2855  * @param msg Results of search
2856  * @param field Attribute to retrieve
2857  * @param flags string type of extended_dn
2858  * @param sids pointer to sid array to allocate
2859  * @return the count of SIDs pulled
2860  **/
2861  int ads_pull_sids_from_extendeddn(ADS_STRUCT *ads,
2862                                    TALLOC_CTX *mem_ctx,
2863                                    LDAPMessage *msg,
2864                                    const char *field,
2865                                    enum ads_extended_dn_flags flags,
2866                                    DOM_SID **sids)
2867 {
2868         int i;
2869         size_t dn_count;
2870         char **dn_strings;
2871
2872         if ((dn_strings = ads_pull_strings(ads, mem_ctx, msg, field,
2873                                            &dn_count)) == NULL) {
2874                 return 0;
2875         }
2876
2877         (*sids) = TALLOC_ZERO_ARRAY(mem_ctx, DOM_SID, dn_count + 1);
2878         if (!(*sids)) {
2879                 TALLOC_FREE(dn_strings);
2880                 return 0;
2881         }
2882
2883         for (i=0; i<dn_count; i++) {
2884
2885                 if (!ads_get_sid_from_extended_dn(mem_ctx, dn_strings[i],
2886                                                   flags, &(*sids)[i])) {
2887                         TALLOC_FREE(*sids);
2888                         TALLOC_FREE(dn_strings);
2889                         return 0;
2890                 }
2891         }
2892
2893         TALLOC_FREE(dn_strings);
2894
2895         return dn_count;
2896 }
2897
2898 /********************************************************************
2899 ********************************************************************/
2900
2901 char* ads_get_dnshostname( ADS_STRUCT *ads, TALLOC_CTX *ctx, const char *machine_name )
2902 {
2903         LDAPMessage *res = NULL;
2904         ADS_STATUS status;
2905         int count = 0;
2906         char *name = NULL;
2907
2908         status = ads_find_machine_acct(ads, &res, global_myname());
2909         if (!ADS_ERR_OK(status)) {
2910                 DEBUG(0,("ads_get_dnshostname: Failed to find account for %s\n",
2911                         global_myname()));
2912                 goto out;
2913         }
2914
2915         if ( (count = ads_count_replies(ads, res)) != 1 ) {
2916                 DEBUG(1,("ads_get_dnshostname: %d entries returned!\n", count));
2917                 goto out;
2918         }
2919
2920         if ( (name = ads_pull_string(ads, ctx, res, "dNSHostName")) == NULL ) {
2921                 DEBUG(0,("ads_get_dnshostname: No dNSHostName attribute!\n"));
2922         }
2923
2924 out:
2925         ads_msgfree(ads, res);
2926
2927         return name;
2928 }
2929
2930 /********************************************************************
2931 ********************************************************************/
2932
2933 char* ads_get_upn( ADS_STRUCT *ads, TALLOC_CTX *ctx, const char *machine_name )
2934 {
2935         LDAPMessage *res = NULL;
2936         ADS_STATUS status;
2937         int count = 0;
2938         char *name = NULL;
2939
2940         status = ads_find_machine_acct(ads, &res, global_myname());
2941         if (!ADS_ERR_OK(status)) {
2942                 DEBUG(0,("ads_get_upn: Failed to find account for %s\n",
2943                         global_myname()));
2944                 goto out;
2945         }
2946
2947         if ( (count = ads_count_replies(ads, res)) != 1 ) {
2948                 DEBUG(1,("ads_get_upn: %d entries returned!\n", count));
2949                 goto out;
2950         }
2951
2952         if ( (name = ads_pull_string(ads, ctx, res, "userPrincipalName")) == NULL ) {
2953                 DEBUG(2,("ads_get_upn: No userPrincipalName attribute!\n"));
2954         }
2955
2956 out:
2957         ads_msgfree(ads, res);
2958
2959         return name;
2960 }
2961
2962 /********************************************************************
2963 ********************************************************************/
2964
2965 char* ads_get_samaccountname( ADS_STRUCT *ads, TALLOC_CTX *ctx, const char *machine_name )
2966 {
2967         LDAPMessage *res = NULL;
2968         ADS_STATUS status;
2969         int count = 0;
2970         char *name = NULL;
2971
2972         status = ads_find_machine_acct(ads, &res, global_myname());
2973         if (!ADS_ERR_OK(status)) {
2974                 DEBUG(0,("ads_get_dnshostname: Failed to find account for %s\n",
2975                         global_myname()));
2976                 goto out;
2977         }
2978
2979         if ( (count = ads_count_replies(ads, res)) != 1 ) {
2980                 DEBUG(1,("ads_get_dnshostname: %d entries returned!\n", count));
2981                 goto out;
2982         }
2983
2984         if ( (name = ads_pull_string(ads, ctx, res, "sAMAccountName")) == NULL ) {
2985                 DEBUG(0,("ads_get_dnshostname: No sAMAccountName attribute!\n"));
2986         }
2987
2988 out:
2989         ads_msgfree(ads, res);
2990
2991         return name;
2992 }
2993
2994 #if 0
2995
2996    SAVED CODE - we used to join via ldap - remember how we did this. JRA.
2997
2998 /**
2999  * Join a machine to a realm
3000  *  Creates the machine account and sets the machine password
3001  * @param ads connection to ads server
3002  * @param machine name of host to add
3003  * @param org_unit Organizational unit to place machine in
3004  * @return status of join
3005  **/
3006 ADS_STATUS ads_join_realm(ADS_STRUCT *ads, const char *machine_name,
3007                         uint32 account_type, const char *org_unit)
3008 {
3009         ADS_STATUS status;
3010         LDAPMessage *res = NULL;
3011         char *machine;
3012
3013         /* machine name must be lowercase */
3014         machine = SMB_STRDUP(machine_name);
3015         strlower_m(machine);
3016
3017         /*
3018         status = ads_find_machine_acct(ads, (void **)&res, machine);
3019         if (ADS_ERR_OK(status) && ads_count_replies(ads, res) == 1) {
3020                 DEBUG(0, ("Host account for %s already exists - deleting old account\n", machine));
3021                 status = ads_leave_realm(ads, machine);
3022                 if (!ADS_ERR_OK(status)) {
3023                         DEBUG(0, ("Failed to delete host '%s' from the '%s' realm.\n",
3024                                 machine, ads->config.realm));
3025                         return status;
3026                 }
3027         }
3028         */
3029         status = ads_add_machine_acct(ads, machine, account_type, org_unit);
3030         if (!ADS_ERR_OK(status)) {
3031                 DEBUG(0, ("ads_join_realm: ads_add_machine_acct failed (%s): %s\n", machine, ads_errstr(status)));
3032                 SAFE_FREE(machine);
3033                 return status;
3034         }
3035
3036         status = ads_find_machine_acct(ads, (void **)(void *)&res, machine);
3037         if (!ADS_ERR_OK(status)) {
3038                 DEBUG(0, ("ads_join_realm: Host account test failed for machine %s\n", machine));
3039                 SAFE_FREE(machine);
3040                 return status;
3041         }
3042
3043         SAFE_FREE(machine);
3044         ads_msgfree(ads, res);
3045
3046         return status;
3047 }
3048 #endif
3049
3050 /**
3051  * Delete a machine from the realm
3052  * @param ads connection to ads server
3053  * @param hostname Machine to remove
3054  * @return status of delete
3055  **/
3056 ADS_STATUS ads_leave_realm(ADS_STRUCT *ads, const char *hostname)
3057 {
3058         ADS_STATUS status;
3059         void *msg;
3060         LDAPMessage *res;
3061         char *hostnameDN, *host;
3062         int rc;
3063         LDAPControl ldap_control;
3064         LDAPControl  * pldap_control[2] = {NULL, NULL};
3065
3066         pldap_control[0] = &ldap_control;
3067         memset(&ldap_control, 0, sizeof(LDAPControl));
3068         ldap_control.ldctl_oid = (char *)LDAP_SERVER_TREE_DELETE_OID;
3069
3070         /* hostname must be lowercase */
3071         host = SMB_STRDUP(hostname);
3072         strlower_m(host);
3073
3074         status = ads_find_machine_acct(ads, &res, host);
3075         if (!ADS_ERR_OK(status)) {
3076                 DEBUG(0, ("Host account for %s does not exist.\n", host));
3077                 SAFE_FREE(host);
3078                 return status;
3079         }
3080
3081         msg = ads_first_entry(ads, res);
3082         if (!msg) {
3083                 SAFE_FREE(host);
3084                 return ADS_ERROR_SYSTEM(ENOENT);
3085         }
3086
3087         hostnameDN = ads_get_dn(ads, (LDAPMessage *)msg);
3088
3089         rc = ldap_delete_ext_s(ads->ld, hostnameDN, pldap_control, NULL);
3090         if (rc) {
3091                 DEBUG(3,("ldap_delete_ext_s failed with error code %d\n", rc));
3092         }else {
3093                 DEBUG(3,("ldap_delete_ext_s succeeded with error code %d\n", rc));
3094         }
3095
3096         if (rc != LDAP_SUCCESS) {
3097                 const char *attrs[] = { "cn", NULL };
3098                 LDAPMessage *msg_sub;
3099
3100                 /* we only search with scope ONE, we do not expect any further
3101                  * objects to be created deeper */
3102
3103                 status = ads_do_search_retry(ads, hostnameDN,
3104                                              LDAP_SCOPE_ONELEVEL,
3105                                              "(objectclass=*)", attrs, &res);
3106
3107                 if (!ADS_ERR_OK(status)) {
3108                         SAFE_FREE(host);
3109                         ads_memfree(ads, hostnameDN);
3110                         return status;
3111                 }
3112
3113                 for (msg_sub = ads_first_entry(ads, res); msg_sub;
3114                         msg_sub = ads_next_entry(ads, msg_sub)) {
3115
3116                         char *dn = NULL;
3117
3118                         if ((dn = ads_get_dn(ads, msg_sub)) == NULL) {
3119                                 SAFE_FREE(host);
3120                                 ads_memfree(ads, hostnameDN);
3121                                 return ADS_ERROR(LDAP_NO_MEMORY);
3122                         }
3123
3124                         status = ads_del_dn(ads, dn);
3125                         if (!ADS_ERR_OK(status)) {
3126                                 DEBUG(3,("failed to delete dn %s: %s\n", dn, ads_errstr(status)));
3127                                 SAFE_FREE(host);
3128                                 ads_memfree(ads, dn);
3129                                 ads_memfree(ads, hostnameDN);
3130                                 return status;
3131                         }
3132
3133                         ads_memfree(ads, dn);
3134                 }
3135
3136                 /* there should be no subordinate objects anymore */
3137                 status = ads_do_search_retry(ads, hostnameDN,
3138                                              LDAP_SCOPE_ONELEVEL,
3139                                              "(objectclass=*)", attrs, &res);
3140
3141                 if (!ADS_ERR_OK(status) || ( (ads_count_replies(ads, res)) > 0 ) ) {
3142                         SAFE_FREE(host);
3143                         ads_memfree(ads, hostnameDN);
3144                         return status;
3145                 }
3146
3147                 /* delete hostnameDN now */
3148                 status = ads_del_dn(ads, hostnameDN);
3149                 if (!ADS_ERR_OK(status)) {
3150                         SAFE_FREE(host);
3151                         DEBUG(3,("failed to delete dn %s: %s\n", hostnameDN, ads_errstr(status)));
3152                         ads_memfree(ads, hostnameDN);
3153                         return status;
3154                 }
3155         }
3156
3157         ads_memfree(ads, hostnameDN);
3158
3159         status = ads_find_machine_acct(ads, &res, host);
3160         if (ADS_ERR_OK(status) && ads_count_replies(ads, res) == 1) {
3161                 DEBUG(3, ("Failed to remove host account.\n"));
3162                 SAFE_FREE(host);
3163                 return status;
3164         }
3165
3166         SAFE_FREE(host);
3167         return status;
3168 }
3169
3170 /**
3171  * pull all token-sids from an LDAP dn
3172  * @param ads connection to ads server
3173  * @param mem_ctx TALLOC_CTX for allocating sid array
3174  * @param dn of LDAP object
3175  * @param user_sid pointer to DOM_SID (objectSid)
3176  * @param primary_group_sid pointer to DOM_SID (self composed)
3177  * @param sids pointer to sid array to allocate
3178  * @param num_sids counter of SIDs pulled
3179  * @return status of token query
3180  **/
3181  ADS_STATUS ads_get_tokensids(ADS_STRUCT *ads,
3182                               TALLOC_CTX *mem_ctx,
3183                               const char *dn,
3184                               DOM_SID *user_sid,
3185                               DOM_SID *primary_group_sid,
3186                               DOM_SID **sids,
3187                               size_t *num_sids)
3188 {
3189         ADS_STATUS status;
3190         LDAPMessage *res = NULL;
3191         int count = 0;
3192         size_t tmp_num_sids;
3193         DOM_SID *tmp_sids;
3194         DOM_SID tmp_user_sid;
3195         DOM_SID tmp_primary_group_sid;
3196         uint32 pgid;
3197         const char *attrs[] = {
3198                 "objectSid",
3199                 "tokenGroups",
3200                 "primaryGroupID",
3201                 NULL
3202         };
3203
3204         status = ads_search_retry_dn(ads, &res, dn, attrs);
3205         if (!ADS_ERR_OK(status)) {
3206                 return status;
3207         }
3208
3209         count = ads_count_replies(ads, res);
3210         if (count != 1) {
3211                 ads_msgfree(ads, res);
3212                 return ADS_ERROR_LDAP(LDAP_NO_SUCH_OBJECT);
3213         }
3214
3215         if (!ads_pull_sid(ads, res, "objectSid", &tmp_user_sid)) {
3216                 ads_msgfree(ads, res);
3217                 return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
3218         }
3219
3220         if (!ads_pull_uint32(ads, res, "primaryGroupID", &pgid)) {
3221                 ads_msgfree(ads, res);
3222                 return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
3223         }
3224
3225         {
3226                 /* hack to compose the primary group sid without knowing the
3227                  * domsid */
3228
3229                 DOM_SID domsid;
3230                 uint32 dummy_rid;
3231
3232                 sid_copy(&domsid, &tmp_user_sid);
3233
3234                 if (!sid_split_rid(&domsid, &dummy_rid)) {
3235                         ads_msgfree(ads, res);
3236                         return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
3237                 }
3238
3239                 if (!sid_compose(&tmp_primary_group_sid, &domsid, pgid)) {
3240                         ads_msgfree(ads, res);
3241                         return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
3242                 }
3243         }
3244
3245         tmp_num_sids = ads_pull_sids(ads, mem_ctx, res, "tokenGroups", &tmp_sids);
3246
3247         if (tmp_num_sids == 0 || !tmp_sids) {
3248                 ads_msgfree(ads, res);
3249                 return ADS_ERROR_LDAP(LDAP_NO_MEMORY);
3250         }
3251
3252         if (num_sids) {
3253                 *num_sids = tmp_num_sids;
3254         }
3255
3256         if (sids) {
3257                 *sids = tmp_sids;
3258         }
3259
3260         if (user_sid) {
3261                 *user_sid = tmp_user_sid;
3262         }
3263
3264         if (primary_group_sid) {
3265                 *primary_group_sid = tmp_primary_group_sid;
3266         }
3267
3268         DEBUG(10,("ads_get_tokensids: returned %d sids\n", (int)tmp_num_sids + 2));
3269
3270         ads_msgfree(ads, res);
3271         return ADS_ERROR_LDAP(LDAP_SUCCESS);
3272 }
3273
3274 ADS_STATUS ads_find_samaccount(ADS_STRUCT *ads,
3275                                TALLOC_CTX *mem_ctx,
3276                                const char *samaccountname,
3277                                uint32 *uac_ret,
3278                                const char **dn_ret)
3279 {
3280         ADS_STATUS status;
3281         const char *attrs[] = { "userAccountControl", NULL };
3282         const char *filter;
3283         LDAPMessage *res = NULL;
3284         char *dn = NULL;
3285         uint32 uac = 0;
3286
3287         filter = talloc_asprintf(mem_ctx, "(&(objectclass=user)(sAMAccountName=%s))",
3288                 samaccountname);
3289         if (filter == NULL) {
3290                 goto out;
3291         }
3292
3293         status = ads_do_search_all(ads, ads->config.bind_path,
3294                                    LDAP_SCOPE_SUBTREE,
3295                                    filter, attrs, &res);
3296
3297         if (!ADS_ERR_OK(status)) {
3298                 goto out;
3299         }
3300
3301         if (ads_count_replies(ads, res) != 1) {
3302                 printf("no result\n");
3303                 goto out;
3304         }
3305
3306         dn = ads_get_dn(ads, res);
3307         if (dn == NULL) {
3308                 status = ADS_ERROR(LDAP_NO_MEMORY);
3309                 goto out;
3310         }
3311
3312         if (!ads_pull_uint32(ads, res, "userAccountControl", &uac)) {
3313                 status = ADS_ERROR(LDAP_NO_SUCH_ATTRIBUTE);
3314                 goto out;
3315         }
3316
3317         if (uac_ret) {
3318                 *uac_ret = uac;
3319         }
3320
3321         if (dn_ret) {
3322                 *dn_ret = talloc_strdup(mem_ctx, dn);
3323                 if (!*dn_ret) {
3324                         status = ADS_ERROR(LDAP_NO_MEMORY);
3325                         goto out;
3326                 }
3327         }
3328  out:
3329         ads_memfree(ads, dn);
3330         ads_msgfree(ads, res);
3331
3332         return status;
3333 }
3334 #endif