source3/libsmb/dsgetdcname.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    dsgetdcname
   5
   6    Copyright (C) Gerald Carter 2006
   7    Copyright (C) Guenther Deschner 2007-2008
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24
  25 #define DSGETDCNAME_FMT "DSGETDCNAME/DOMAIN/%s"
  26 /* 15 minutes */
  27 #define DSGETDCNAME_CACHE_TTL   60*15
  28
  29 struct ip_service_name {
  30         struct sockaddr_storage ss;
  31         unsigned port;
  32         const char *hostname;
  33 };
  34
  35 static NTSTATUS make_dc_info_from_cldap_reply(TALLOC_CTX *mem_ctx,
  36                                               uint32_t flags,
  37                                               struct sockaddr_storage *ss,
  38                                               struct netlogon_samlogon_response *r,
  39                                               struct netr_DsRGetDCNameInfo **info);
  40
  41 /****************************************************************
  42 ****************************************************************/
  43
  44 void debug_dsdcinfo_flags(int lvl, uint32_t flags)
  45 {
  46         DEBUG(lvl,("debug_dsdcinfo_flags: 0x%08x\n\t", flags));
  47
  48         if (flags & DS_FORCE_REDISCOVERY)
  49                 DEBUGADD(lvl,("DS_FORCE_REDISCOVERY "));
  50         if (flags & 0x000000002)
  51                 DEBUGADD(lvl,("0x00000002 "));
  52         if (flags & 0x000000004)
  53                 DEBUGADD(lvl,("0x00000004 "));
  54         if (flags & 0x000000008)
  55                 DEBUGADD(lvl,("0x00000008 "));
  56         if (flags & DS_DIRECTORY_SERVICE_REQUIRED)
  57                 DEBUGADD(lvl,("DS_DIRECTORY_SERVICE_REQUIRED "));
  58         if (flags & DS_DIRECTORY_SERVICE_PREFERRED)
  59                 DEBUGADD(lvl,("DS_DIRECTORY_SERVICE_PREFERRED "));
  60         if (flags & DS_GC_SERVER_REQUIRED)
  61                 DEBUGADD(lvl,("DS_GC_SERVER_REQUIRED "));
  62         if (flags & DS_PDC_REQUIRED)
  63                 DEBUGADD(lvl,("DS_PDC_REQUIRED "));
  64         if (flags & DS_BACKGROUND_ONLY)
  65                 DEBUGADD(lvl,("DS_BACKGROUND_ONLY "));
  66         if (flags & DS_IP_REQUIRED)
  67                 DEBUGADD(lvl,("DS_IP_REQUIRED "));
  68         if (flags & DS_KDC_REQUIRED)
  69                 DEBUGADD(lvl,("DS_KDC_REQUIRED "));
  70         if (flags & DS_TIMESERV_REQUIRED)
  71                 DEBUGADD(lvl,("DS_TIMESERV_REQUIRED "));
  72         if (flags & DS_WRITABLE_REQUIRED)
  73                 DEBUGADD(lvl,("DS_WRITABLE_REQUIRED "));
  74         if (flags & DS_GOOD_TIMESERV_PREFERRED)
  75                 DEBUGADD(lvl,("DS_GOOD_TIMESERV_PREFERRED "));
  76         if (flags & DS_AVOID_SELF)
  77                 DEBUGADD(lvl,("DS_AVOID_SELF "));
  78         if (flags & DS_ONLY_LDAP_NEEDED)
  79                 DEBUGADD(lvl,("DS_ONLY_LDAP_NEEDED "));
  80         if (flags & DS_IS_FLAT_NAME)
  81                 DEBUGADD(lvl,("DS_IS_FLAT_NAME "));
  82         if (flags & DS_IS_DNS_NAME)
  83                 DEBUGADD(lvl,("DS_IS_DNS_NAME "));
  84         if (flags & 0x00040000)
  85                 DEBUGADD(lvl,("0x00040000 "));
  86         if (flags & 0x00080000)
  87                 DEBUGADD(lvl,("0x00080000 "));
  88         if (flags & 0x00100000)
  89                 DEBUGADD(lvl,("0x00100000 "));
  90         if (flags & 0x00200000)
  91                 DEBUGADD(lvl,("0x00200000 "));
  92         if (flags & 0x00400000)
  93                 DEBUGADD(lvl,("0x00400000 "));
  94         if (flags & 0x00800000)
  95                 DEBUGADD(lvl,("0x00800000 "));
  96         if (flags & 0x01000000)
  97                 DEBUGADD(lvl,("0x01000000 "));
  98         if (flags & 0x02000000)
  99                 DEBUGADD(lvl,("0x02000000 "));
 100         if (flags & 0x04000000)
 101                 DEBUGADD(lvl,("0x04000000 "));
 102         if (flags & 0x08000000)
 103                 DEBUGADD(lvl,("0x08000000 "));
 104         if (flags & 0x10000000)
 105                 DEBUGADD(lvl,("0x10000000 "));
 106         if (flags & 0x20000000)
 107                 DEBUGADD(lvl,("0x20000000 "));
 108         if (flags & DS_RETURN_DNS_NAME)
 109                 DEBUGADD(lvl,("DS_RETURN_DNS_NAME "));
 110         if (flags & DS_RETURN_FLAT_NAME)
 111                 DEBUGADD(lvl,("DS_RETURN_FLAT_NAME "));
 112         if (flags)
 113                 DEBUGADD(lvl,("\n"));
 114 }
 115
 116 /****************************************************************
 117 ****************************************************************/
 118
 119 static char *dsgetdcname_cache_key(TALLOC_CTX *mem_ctx, const char *domain)
 120 {
 121         if (!domain) {
 122                 return NULL;
 123         }
 124
 125         return talloc_asprintf_strupper_m(mem_ctx, DSGETDCNAME_FMT, domain);
 126 }
 127
 128 /****************************************************************
 129 ****************************************************************/
 130
 131 static NTSTATUS dsgetdcname_cache_delete(TALLOC_CTX *mem_ctx,
 132                                         const char *domain_name)
 133 {
 134         char *key;
 135
 136         if (!gencache_init()) {
 137                 return NT_STATUS_INTERNAL_DB_ERROR;
 138         }
 139
 140         key = dsgetdcname_cache_key(mem_ctx, domain_name);
 141         if (!key) {
 142                 return NT_STATUS_NO_MEMORY;
 143         }
 144
 145         if (!gencache_del(key)) {
 146                 return NT_STATUS_UNSUCCESSFUL;
 147         }
 148
 149         return NT_STATUS_OK;
 150 }
 151
 152 /****************************************************************
 153 ****************************************************************/
 154
 155 static NTSTATUS dsgetdcname_cache_store(TALLOC_CTX *mem_ctx,
 156                                         const char *domain_name,
 157                                         const DATA_BLOB *blob)
 158 {
 159         time_t expire_time;
 160         char *key;
 161         bool ret = false;
 162
 163         if (!gencache_init()) {
 164                 return NT_STATUS_INTERNAL_DB_ERROR;
 165         }
 166
 167         key = dsgetdcname_cache_key(mem_ctx, domain_name);
 168         if (!key) {
 169                 return NT_STATUS_NO_MEMORY;
 170         }
 171
 172         expire_time = time(NULL) + DSGETDCNAME_CACHE_TTL;
 173
 174         if (gencache_lock_entry(key) != 0) {
 175                 return NT_STATUS_LOCK_NOT_GRANTED;
 176         }
 177
 178         ret = gencache_set_data_blob(key, blob, expire_time);
 179
 180         gencache_unlock_entry(key);
 181
 182         return ret ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 183 }
 184
 185 /****************************************************************
 186 ****************************************************************/
 187
 188 static NTSTATUS store_cldap_reply(TALLOC_CTX *mem_ctx,
 189                                   uint32_t flags,
 190                                   struct sockaddr_storage *ss,
 191                                   uint32_t nt_version,
 192                                   struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
 193 {
 194         DATA_BLOB blob;
 195         enum ndr_err_code ndr_err;
 196         NTSTATUS status;
 197         char addr[INET6_ADDRSTRLEN];
 198
 199        print_sockaddr(addr, sizeof(addr), ss);
 200
 201         /* FIXME */
 202         r->sockaddr_size = 0x10; /* the w32 winsock addr size */
 203         r->sockaddr.sa_family = 2; /* AF_INET */
 204         r->sockaddr.pdc_ip = talloc_strdup(mem_ctx, addr);
 205
 206         ndr_err = ndr_push_struct_blob(&blob, mem_ctx, NULL, r,
 207                        (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX);
 208         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 209                 return ndr_map_error2ntstatus(ndr_err);
 210         }
 211
 212         if (r->domain) {
 213                 status = dsgetdcname_cache_store(mem_ctx, r->domain, &blob);
 214                 if (!NT_STATUS_IS_OK(status)) {
 215                         goto done;
 216                 }
 217                 if (r->client_site) {
 218                         sitename_store(r->domain, r->client_site);
 219                 }
 220         }
 221         if (r->dns_domain) {
 222                 status = dsgetdcname_cache_store(mem_ctx, r->dns_domain, &blob);
 223                 if (!NT_STATUS_IS_OK(status)) {
 224                         goto done;
 225                 }
 226                 if (r->client_site) {
 227                         sitename_store(r->dns_domain, r->client_site);
 228                 }
 229         }
 230
 231  done:
 232         data_blob_free(&blob);
 233
 234         return status;
 235 }
 236
 237 /****************************************************************
 238 ****************************************************************/
 239
 240 static NTSTATUS dsgetdcname_cache_refresh(TALLOC_CTX *mem_ctx,
 241                                           struct messaging_context *msg_ctx,
 242                                           const char *domain_name,
 243                                           struct GUID *domain_guid,
 244                                           uint32_t flags,
 245                                           const char *site_name,
 246                                           struct netr_DsRGetDCNameInfo *info)
 247 {
 248         struct netr_DsRGetDCNameInfo *dc_info;
 249
 250         return dsgetdcname(mem_ctx,
 251                            msg_ctx,
 252                            domain_name,
 253                            domain_guid,
 254                            site_name,
 255                            flags | DS_FORCE_REDISCOVERY,
 256                            &dc_info);
 257 }
 258
 259 /****************************************************************
 260 ****************************************************************/
 261
 262 static uint32_t get_cldap_reply_server_flags(struct netlogon_samlogon_response *r,
 263                                              uint32_t nt_version)
 264 {
 265         switch (nt_version & 0x0000001f) {
 266                 case 0:
 267                 case 1:
 268                 case 16:
 269                 case 17:
 270                         return 0;
 271                 case 2:
 272                 case 3:
 273                 case 18:
 274                 case 19:
 275                         return r->nt5.server_type;
 276                 case 4:
 277                 case 5:
 278                 case 6:
 279                 case 7:
 280                         return r->nt5_ex.server_type;
 281                 case 8:
 282                 case 9:
 283                 case 10:
 284                 case 11:
 285                 case 12:
 286                 case 13:
 287                 case 14:
 288                 case 15:
 289                         return r->nt5_ex.server_type;
 290                 case 20:
 291                 case 21:
 292                 case 22:
 293                 case 23:
 294                 case 24:
 295                 case 25:
 296                 case 26:
 297                 case 27:
 298                 case 28:
 299                         return r->nt5_ex.server_type;
 300                 case 29:
 301                 case 30:
 302                 case 31:
 303                         return r->nt5_ex.server_type;
 304                 default:
 305                         return 0;
 306         }
 307 }
 308
 309 /****************************************************************
 310 ****************************************************************/
 311
 312 #define RETURN_ON_FALSE(x) if (!x) return false;
 313
 314 static bool check_cldap_reply_required_flags(uint32_t ret_flags,
 315                                              uint32_t req_flags)
 316 {
 317         if (ret_flags == 0) {
 318                 return true;
 319         }
 320
 321         if (req_flags & DS_PDC_REQUIRED)
 322                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_PDC);
 323
 324         if (req_flags & DS_GC_SERVER_REQUIRED)
 325                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_GC);
 326
 327         if (req_flags & DS_ONLY_LDAP_NEEDED)
 328                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_LDAP);
 329
 330         if ((req_flags & DS_DIRECTORY_SERVICE_REQUIRED) ||
 331             (req_flags & DS_DIRECTORY_SERVICE_PREFERRED))
 332                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_DS);
 333
 334         if (req_flags & DS_KDC_REQUIRED)
 335                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_KDC);
 336
 337         if (req_flags & DS_TIMESERV_REQUIRED)
 338                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_TIMESERV);
 339
 340         if (req_flags & DS_WRITABLE_REQUIRED)
 341                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_WRITABLE);
 342
 343         return true;
 344 }
 345
 346 /****************************************************************
 347 ****************************************************************/
 348
 349 static NTSTATUS dsgetdcname_cache_fetch(TALLOC_CTX *mem_ctx,
 350                                         const char *domain_name,
 351                                         struct GUID *domain_guid,
 352                                         uint32_t flags,
 353                                         const char *site_name,
 354                                         struct netr_DsRGetDCNameInfo **info_p,
 355                                         bool *expired)
 356 {
 357         char *key;
 358         DATA_BLOB blob;
 359         enum ndr_err_code ndr_err;
 360         struct netr_DsRGetDCNameInfo *info;
 361         struct netlogon_samlogon_response p;
 362         struct NETLOGON_SAM_LOGON_RESPONSE_EX r;
 363         NTSTATUS status;
 364
 365         if (!gencache_init()) {
 366                 return NT_STATUS_INTERNAL_DB_ERROR;
 367         }
 368
 369         key = dsgetdcname_cache_key(mem_ctx, domain_name);
 370         if (!key) {
 371                 return NT_STATUS_NO_MEMORY;
 372         }
 373
 374         if (!gencache_get_data_blob(key, &blob, expired)) {
 375                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 376         }
 377
 378         info = TALLOC_ZERO_P(mem_ctx, struct netr_DsRGetDCNameInfo);
 379         if (!info) {
 380                 return NT_STATUS_NO_MEMORY;
 381         }
 382
 383         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &r,
 384                       (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX);
 385
 386         data_blob_free(&blob);
 387         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 388                 dsgetdcname_cache_delete(mem_ctx, domain_name);
 389                 return ndr_map_error2ntstatus(ndr_err);
 390         }
 391
 392         p.nt5_ex = r;
 393
 394         status = make_dc_info_from_cldap_reply(mem_ctx, flags, NULL,
 395                                                &p, &info);
 396         if (!NT_STATUS_IS_OK(status)) {
 397                 return status;
 398         }
 399
 400         if (DEBUGLEVEL >= 10) {
 401                 NDR_PRINT_DEBUG(netr_DsRGetDCNameInfo, info);
 402         }
 403
 404         /* check flags */
 405         if (!check_cldap_reply_required_flags(info->dc_flags, flags)) {
 406                 DEBUG(10,("invalid flags\n"));
 407                 return NT_STATUS_INVALID_PARAMETER;
 408         }
 409
 410         if ((flags & DS_IP_REQUIRED) &&
 411             (info->dc_address_type != DS_ADDRESS_TYPE_INET)) {
 412                 return NT_STATUS_INVALID_PARAMETER_MIX;
 413         }
 414
 415         *info_p = info;
 416
 417         return NT_STATUS_OK;
 418 }
 419
 420 /****************************************************************
 421 ****************************************************************/
 422
 423 static NTSTATUS dsgetdcname_cached(TALLOC_CTX *mem_ctx,
 424                                    struct messaging_context *msg_ctx,
 425                                    const char *domain_name,
 426                                    struct GUID *domain_guid,
 427                                    uint32_t flags,
 428                                    const char *site_name,
 429                                    struct netr_DsRGetDCNameInfo **info)
 430 {
 431         NTSTATUS status;
 432         bool expired = false;
 433
 434         status = dsgetdcname_cache_fetch(mem_ctx, domain_name, domain_guid,
 435                                          flags, site_name, info, &expired);
 436         if (!NT_STATUS_IS_OK(status)) {
 437                 DEBUG(10,("dsgetdcname_cached: cache fetch failed with: %s\n",
 438                         nt_errstr(status)));
 439                 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
 440         }
 441
 442         if (flags & DS_BACKGROUND_ONLY) {
 443                 return status;
 444         }
 445
 446         if (expired) {
 447                 status = dsgetdcname_cache_refresh(mem_ctx, msg_ctx,
 448                                                    domain_name,
 449                                                    domain_guid, flags,
 450                                                    site_name, *info);
 451                 if (!NT_STATUS_IS_OK(status)) {
 452                         return status;
 453                 }
 454         }
 455
 456         return status;
 457 }
 458
 459 /****************************************************************
 460 ****************************************************************/
 461
 462 static bool check_allowed_required_flags(uint32_t flags,
 463                                          const char *site_name)
 464 {
 465         uint32_t return_type = flags & (DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME);
 466         uint32_t offered_type = flags & (DS_IS_FLAT_NAME|DS_IS_DNS_NAME);
 467         uint32_t query_type = flags & (DS_BACKGROUND_ONLY|DS_FORCE_REDISCOVERY);
 468
 469         /* FIXME: check for DSGETDC_VALID_FLAGS and check for excluse bits
 470          * (DS_PDC_REQUIRED, DS_KDC_REQUIRED, DS_GC_SERVER_REQUIRED) */
 471
 472         debug_dsdcinfo_flags(10, flags);
 473
 474         if ((flags & DS_TRY_NEXTCLOSEST_SITE) && site_name) {
 475                 return false;
 476         }
 477
 478         if (return_type == (DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME)) {
 479                 return false;
 480         }
 481
 482         if (offered_type == (DS_IS_DNS_NAME|DS_IS_FLAT_NAME)) {
 483                 return false;
 484         }
 485
 486         if (query_type == (DS_BACKGROUND_ONLY|DS_FORCE_REDISCOVERY)) {
 487                 return false;
 488         }
 489
 490 #if 0
 491         if ((flags & DS_RETURN_DNS_NAME) && (!(flags & DS_IP_REQUIRED))) {
 492                 printf("gd: here5 \n");
 493                 return false;
 494         }
 495 #endif
 496         return true;
 497 }
 498
 499 /****************************************************************
 500 ****************************************************************/
 501
 502 static NTSTATUS discover_dc_netbios(TALLOC_CTX *mem_ctx,
 503                                     const char *domain_name,
 504                                     uint32_t flags,
 505                                     struct ip_service_name **returned_dclist,
 506                                     int *returned_count)
 507 {
 508         NTSTATUS status;
 509         enum nbt_name_type name_type = NBT_NAME_LOGON;
 510         struct ip_service *iplist;
 511         int i;
 512         struct ip_service_name *dclist = NULL;
 513         int count;
 514
 515         *returned_dclist = NULL;
 516         *returned_count = 0;
 517
 518         if (lp_disable_netbios()) {
 519                 return NT_STATUS_NOT_SUPPORTED;
 520         }
 521
 522         if (flags & DS_PDC_REQUIRED) {
 523                 name_type = NBT_NAME_PDC;
 524         }
 525
 526         status = internal_resolve_name(domain_name, name_type, NULL,
 527                                        &iplist, &count,
 528                                        "lmhosts wins bcast");
 529         if (!NT_STATUS_IS_OK(status)) {
 530                 DEBUG(10,("discover_dc_netbios: failed to find DC\n"));
 531                 return status;
 532         }
 533
 534         dclist = TALLOC_ZERO_ARRAY(mem_ctx, struct ip_service_name, count);
 535         if (!dclist) {
 536                 return NT_STATUS_NO_MEMORY;
 537         }
 538
 539         for (i=0; i<count; i++) {
 540
 541                 char addr[INET6_ADDRSTRLEN];
 542                 struct ip_service_name *r = &dclist[i];
 543
 544                 print_sockaddr(addr, sizeof(addr),
 545                                &iplist[i].ss);
 546
 547                 r->ss   = iplist[i].ss;
 548                 r->port = iplist[i].port;
 549                 r->hostname = talloc_strdup(mem_ctx, addr);
 550                 if (!r->hostname) {
 551                         return NT_STATUS_NO_MEMORY;
 552                 }
 553
 554         }
 555
 556         *returned_dclist = dclist;
 557         *returned_count = count;
 558
 559         return NT_STATUS_OK;
 560 }
 561
 562 /****************************************************************
 563 ****************************************************************/
 564
 565 static NTSTATUS discover_dc_dns(TALLOC_CTX *mem_ctx,
 566                                 const char *domain_name,
 567                                 struct GUID *domain_guid,
 568                                 uint32_t flags,
 569                                 const char *site_name,
 570                                 struct ip_service_name **returned_dclist,
 571                                 int *return_count)
 572 {
 573         int i, j;
 574         NTSTATUS status;
 575         struct dns_rr_srv *dcs = NULL;
 576         int numdcs = 0;
 577         int numaddrs = 0;
 578         struct ip_service_name *dclist = NULL;
 579         int count = 0;
 580
 581         if (flags & DS_PDC_REQUIRED) {
 582                 status = ads_dns_query_pdc(mem_ctx, domain_name,
 583                                            &dcs, &numdcs);
 584         } else if (flags & DS_GC_SERVER_REQUIRED) {
 585                 status = ads_dns_query_gcs(mem_ctx, domain_name, site_name,
 586                                            &dcs, &numdcs);
 587         } else if (flags & DS_KDC_REQUIRED) {
 588                 status = ads_dns_query_kdcs(mem_ctx, domain_name, site_name,
 589                                             &dcs, &numdcs);
 590         } else if (flags & DS_DIRECTORY_SERVICE_REQUIRED) {
 591                 status = ads_dns_query_dcs(mem_ctx, domain_name, site_name,
 592                                            &dcs, &numdcs);
 593         } else if (domain_guid) {
 594                 status = ads_dns_query_dcs_guid(mem_ctx, domain_name,
 595                                                 domain_guid, &dcs, &numdcs);
 596         } else {
 597                 status = ads_dns_query_dcs(mem_ctx, domain_name, site_name,
 598                                            &dcs, &numdcs);
 599         }
 600
 601         if (!NT_STATUS_IS_OK(status)) {
 602                 return status;
 603         }
 604
 605         if (numdcs == 0) {
 606                 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
 607         }
 608
 609         for (i=0;i<numdcs;i++) {
 610                 numaddrs += MAX(dcs[i].num_ips,1);
 611         }
 612
 613         dclist = TALLOC_ZERO_ARRAY(mem_ctx,
 614                                    struct ip_service_name,
 615                                    numaddrs);
 616         if (!dclist) {
 617                 return NT_STATUS_NO_MEMORY;
 618         }
 619
 620         /* now unroll the list of IP addresses */
 621
 622         *return_count = 0;
 623         i = 0;
 624         j = 0;
 625
 626         while ((i < numdcs) && (count < numaddrs)) {
 627
 628                 struct ip_service_name *r = &dclist[count];
 629
 630                 r->port = dcs[count].port;
 631                 r->hostname = dcs[count].hostname;
 632
 633                 /* If we don't have an IP list for a name, lookup it up */
 634
 635                 if (!dcs[i].ss_s) {
 636                         interpret_string_addr(&r->ss, dcs[i].hostname, 0);
 637                         i++;
 638                         j = 0;
 639                 } else {
 640                         /* use the IP addresses from the SRV sresponse */
 641
 642                         if (j >= dcs[i].num_ips) {
 643                                 i++;
 644                                 j = 0;
 645                                 continue;
 646                         }
 647
 648                         r->ss = dcs[i].ss_s[j];
 649                         j++;
 650                 }
 651
 652                 /* make sure it is a valid IP.  I considered checking the
 653                  * negative connection cache, but this is the wrong place for
 654                  * it.  Maybe only as a hac.  After think about it, if all of
 655                  * the IP addresses retuend from DNS are dead, what hope does a
 656                  * netbios name lookup have?  The standard reason for falling
 657                  * back to netbios lookups is that our DNS server doesn't know
 658                  * anything about the DC's   -- jerry */
 659
 660                 if (!is_zero_addr(&r->ss)) {
 661                         count++;
 662                         continue;
 663                 }
 664         }
 665
 666         *returned_dclist = dclist;
 667         *return_count = count;
 668
 669         if (count > 0) {
 670                 return NT_STATUS_OK;
 671         }
 672
 673         return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
 674 }
 675
 676 /****************************************************************
 677 ****************************************************************/
 678
 679 static NTSTATUS make_domain_controller_info(TALLOC_CTX *mem_ctx,
 680                                             const char *dc_unc,
 681                                             const char *dc_address,
 682                                             uint32_t dc_address_type,
 683                                             const struct GUID *domain_guid,
 684                                             const char *domain_name,
 685                                             const char *forest_name,
 686                                             uint32_t flags,
 687                                             const char *dc_site_name,
 688                                             const char *client_site_name,
 689                                             struct netr_DsRGetDCNameInfo **info_out)
 690 {
 691         struct netr_DsRGetDCNameInfo *info;
 692
 693         info = TALLOC_ZERO_P(mem_ctx, struct netr_DsRGetDCNameInfo);
 694         NT_STATUS_HAVE_NO_MEMORY(info);
 695
 696         if (dc_unc) {
 697                 info->dc_unc = talloc_strdup(mem_ctx, dc_unc);
 698                 NT_STATUS_HAVE_NO_MEMORY(info->dc_unc);
 699         }
 700
 701         if (dc_address) {
 702                 if (!(dc_address[0] == '\\' && dc_address[1] == '\\')) {
 703                         info->dc_address = talloc_asprintf(mem_ctx, "\\\\%s",
 704                                                            dc_address);
 705                 } else {
 706                         info->dc_address = talloc_strdup(mem_ctx, dc_address);
 707                 }
 708                 NT_STATUS_HAVE_NO_MEMORY(info->dc_address);
 709         }
 710
 711         info->dc_address_type = dc_address_type;
 712
 713         if (domain_guid) {
 714                 info->domain_guid = *domain_guid;
 715         }
 716
 717         if (domain_name) {
 718                 info->domain_name = talloc_strdup(mem_ctx, domain_name);
 719                 NT_STATUS_HAVE_NO_MEMORY(info->domain_name);
 720         }
 721
 722         if (forest_name && *forest_name) {
 723                 info->forest_name = talloc_strdup(mem_ctx, forest_name);
 724                 NT_STATUS_HAVE_NO_MEMORY(info->forest_name);
 725                 flags |= DS_DNS_FOREST;
 726         }
 727
 728         info->dc_flags = flags;
 729
 730         if (dc_site_name) {
 731                 info->dc_site_name = talloc_strdup(mem_ctx, dc_site_name);
 732                 NT_STATUS_HAVE_NO_MEMORY(info->dc_site_name);
 733         }
 734
 735         if (client_site_name) {
 736                 info->client_site_name = talloc_strdup(mem_ctx,
 737                                                        client_site_name);
 738                 NT_STATUS_HAVE_NO_MEMORY(info->client_site_name);
 739         }
 740
 741         *info_out = info;
 742
 743         return NT_STATUS_OK;
 744 }
 745
 746 /****************************************************************
 747 ****************************************************************/
 748
 749 static void map_dc_and_domain_names(uint32_t flags,
 750                                     const char *dc_name,
 751                                     const char *domain_name,
 752                                     const char *dns_dc_name,
 753                                     const char *dns_domain_name,
 754                                     uint32_t *dc_flags,
 755                                     const char **hostname_p,
 756                                     const char **domain_p)
 757 {
 758         switch (flags & 0xf0000000) {
 759                 case DS_RETURN_FLAT_NAME:
 760                         if (dc_name && domain_name &&
 761                             *dc_name && *domain_name) {
 762                                 *hostname_p = dc_name;
 763                                 *domain_p = domain_name;
 764                                 break;
 765                         }
 766                 case DS_RETURN_DNS_NAME:
 767                 default:
 768                         if (dns_dc_name && dns_domain_name &&
 769                             *dns_dc_name && *dns_domain_name) {
 770                                 *hostname_p = dns_dc_name;
 771                                 *domain_p = dns_domain_name;
 772                                 *dc_flags |= DS_DNS_DOMAIN | DS_DNS_CONTROLLER;
 773                                 break;
 774                         }
 775                         if (dc_name && domain_name &&
 776                             *dc_name && *domain_name) {
 777                                 *hostname_p = dc_name;
 778                                 *domain_p = domain_name;
 779                                 break;
 780                         }
 781         }
 782 }
 783
 784 /****************************************************************
 785 ****************************************************************/
 786
 787 static NTSTATUS make_dc_info_from_cldap_reply(TALLOC_CTX *mem_ctx,
 788                                               uint32_t flags,
 789                                               struct sockaddr_storage *ss,
 790                                               struct netlogon_samlogon_response *r,
 791                                               struct netr_DsRGetDCNameInfo **info)
 792 {
 793         const char *dc_hostname = NULL;
 794         const char *dc_domain_name = NULL;
 795         const char *dc_address = NULL;
 796         const char *dc_forest = NULL;
 797         uint32_t dc_address_type = 0;
 798         uint32_t dc_flags = 0;
 799         struct GUID *dc_domain_guid = NULL;
 800         const char *dc_server_site = NULL;
 801         const char *dc_client_site = NULL;
 802
 803         char addr[INET6_ADDRSTRLEN];
 804
 805         if (ss) {
 806                 print_sockaddr(addr, sizeof(addr), ss);
 807                 dc_address = addr;
 808                 dc_address_type = DS_ADDRESS_TYPE_INET;
 809         }
 810
 811         switch (r->ntver & 0x0000001f) {
 812                 case 0:
 813                 case 1:
 814                 case 16:
 815                 case 17:
 816                         if (!ss) {
 817                                 dc_address      = r->nt4.server;
 818                                 dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
 819                         }
 820
 821                         map_dc_and_domain_names(flags,
 822                                                 r->nt4.server,
 823                                                 r->nt4.domain,
 824                                                 NULL,
 825                                                 NULL,
 826                                                 &dc_flags,
 827                                                 &dc_hostname,
 828                                                 &dc_domain_name);
 829
 830                         if (flags & DS_PDC_REQUIRED) {
 831                                 dc_flags = NBT_SERVER_WRITABLE | NBT_SERVER_PDC;
 832                         }
 833                         break;
 834                 case 2:
 835                 case 3:
 836                 case 18:
 837                 case 19:
 838                         if (!ss) {
 839                                 dc_address      = r->nt5.pdc_ip;
 840                                 dc_address_type = DS_ADDRESS_TYPE_INET;
 841                         }
 842
 843                         map_dc_and_domain_names(flags,
 844                                                 r->nt5.pdc_name,
 845                                                 r->nt5.domain_name,
 846                                                 r->nt5.pdc_dns_name,
 847                                                 r->nt5.dns_domain,
 848                                                 &dc_flags,
 849                                                 &dc_hostname,
 850                                                 &dc_domain_name);
 851
 852                         dc_flags        |= r->nt5.server_type;
 853                         dc_forest       = r->nt5.forest;
 854                         dc_domain_guid  = &r->nt5.domain_uuid;
 855
 856                         break;
 857                 case 4:
 858                 case 5:
 859                 case 6:
 860                 case 7:
 861                         if (!ss) {
 862                                 dc_address      = r->nt5_ex.pdc_name;
 863                                 dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
 864                         }
 865
 866                         map_dc_and_domain_names(flags,
 867                                                 r->nt5_ex.pdc_name,
 868                                                 r->nt5_ex.domain,
 869                                                 r->nt5_ex.pdc_dns_name,
 870                                                 r->nt5_ex.dns_domain,
 871                                                 &dc_flags,
 872                                                 &dc_hostname,
 873                                                 &dc_domain_name);
 874
 875                         dc_flags        |= r->nt5_ex.server_type;
 876                         dc_forest       = r->nt5_ex.forest;
 877                         dc_domain_guid  = &r->nt5_ex.domain_uuid;
 878                         dc_server_site  = r->nt5_ex.server_site;
 879                         dc_client_site  = r->nt5_ex.client_site;
 880
 881                         break;
 882                 case 8:
 883                 case 9:
 884                 case 10:
 885                 case 11:
 886                 case 12:
 887                 case 13:
 888                 case 14:
 889                 case 15:
 890                         if (!ss) {
 891                                 dc_address      = r->nt5_ex.sockaddr.pdc_ip;
 892                                 dc_address_type = DS_ADDRESS_TYPE_INET;
 893                         }
 894
 895                         map_dc_and_domain_names(flags,
 896                                                 r->nt5_ex.pdc_name,
 897                                                 r->nt5_ex.domain,
 898                                                 r->nt5_ex.pdc_dns_name,
 899                                                 r->nt5_ex.dns_domain,
 900                                                 &dc_flags,
 901                                                 &dc_hostname,
 902                                                 &dc_domain_name);
 903
 904                         dc_flags        |= r->nt5_ex.server_type;
 905                         dc_forest       = r->nt5_ex.forest;
 906                         dc_domain_guid  = &r->nt5_ex.domain_uuid;
 907                         dc_server_site  = r->nt5_ex.server_site;
 908                         dc_client_site  = r->nt5_ex.client_site;
 909
 910                         break;
 911                 case 20:
 912                 case 21:
 913                 case 22:
 914                 case 23:
 915                 case 24:
 916                 case 25:
 917                 case 26:
 918                 case 27:
 919                 case 28:
 920                         if (!ss) {
 921                                 dc_address      = r->nt5_ex.pdc_name;
 922                                 dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
 923                         }
 924
 925                         map_dc_and_domain_names(flags,
 926                                                 r->nt5_ex.pdc_name,
 927                                                 r->nt5_ex.domain,
 928                                                 r->nt5_ex.pdc_dns_name,
 929                                                 r->nt5_ex.dns_domain,
 930                                                 &dc_flags,
 931                                                 &dc_hostname,
 932                                                 &dc_domain_name);
 933
 934                         dc_flags        |= r->nt5_ex.server_type;
 935                         dc_forest       = r->nt5_ex.forest;
 936                         dc_domain_guid  = &r->nt5_ex.domain_uuid;
 937                         dc_server_site  = r->nt5_ex.server_site;
 938                         dc_client_site  = r->nt5_ex.client_site;
 939
 940                         break;
 941                 case 29:
 942                 case 30:
 943                 case 31:
 944                         if (!ss) {
 945                                 dc_address      = r->nt5_ex.sockaddr.pdc_ip;
 946                                 dc_address_type = DS_ADDRESS_TYPE_INET;
 947                         }
 948
 949                         map_dc_and_domain_names(flags,
 950                                                 r->nt5_ex.pdc_name,
 951                                                 r->nt5_ex.domain,
 952                                                 r->nt5_ex.pdc_dns_name,
 953                                                 r->nt5_ex.dns_domain,
 954                                                 &dc_flags,
 955                                                 &dc_hostname,
 956                                                 &dc_domain_name);
 957
 958                         dc_flags        |= r->nt5_ex.server_type;
 959                         dc_forest       = r->nt5_ex.forest;
 960                         dc_domain_guid  = &r->nt5_ex.domain_uuid;
 961                         dc_server_site  = r->nt5_ex.server_site;
 962                         dc_client_site  = r->nt5_ex.client_site;
 963
 964                         break;
 965                 default:
 966                         return NT_STATUS_INVALID_PARAMETER;
 967         }
 968
 969         return make_domain_controller_info(mem_ctx,
 970                                            dc_hostname,
 971                                            dc_address,
 972                                            dc_address_type,
 973                                            dc_domain_guid,
 974                                            dc_domain_name,
 975                                            dc_forest,
 976                                            dc_flags,
 977                                            dc_server_site,
 978                                            dc_client_site,
 979                                            info);
 980 }
 981
 982 /****************************************************************
 983 ****************************************************************/
 984
 985 static uint32_t map_ds_flags_to_nt_version(uint32_t flags)
 986 {
 987         uint32_t nt_version = 0;
 988
 989         if (flags & DS_PDC_REQUIRED) {
 990                 nt_version |= NETLOGON_NT_VERSION_PDC;
 991         }
 992
 993         if (flags & DS_GC_SERVER_REQUIRED) {
 994                 nt_version |= NETLOGON_NT_VERSION_GC;
 995         }
 996
 997         if (flags & DS_TRY_NEXTCLOSEST_SITE) {
 998                 nt_version |= NETLOGON_NT_VERSION_WITH_CLOSEST_SITE;
 999         }
1000
1001         if (flags & DS_IP_REQUIRED) {
1002                 nt_version |= NETLOGON_NT_VERSION_IP;
1003         }
1004
1005         return nt_version;
1006 }
1007
1008 /****************************************************************
1009 ****************************************************************/
1010
1011 static NTSTATUS process_dc_dns(TALLOC_CTX *mem_ctx,
1012                                const char *domain_name,
1013                                uint32_t flags,
1014                                struct ip_service_name *dclist,
1015                                int num_dcs,
1016                                struct netr_DsRGetDCNameInfo **info)
1017 {
1018         int i = 0;
1019         bool valid_dc = false;
1020         struct netlogon_samlogon_response *r = NULL;
1021         uint32_t nt_version = NETLOGON_NT_VERSION_5 |
1022                               NETLOGON_NT_VERSION_5EX;
1023         uint32_t ret_flags = 0;
1024         NTSTATUS status;
1025
1026         nt_version |= map_ds_flags_to_nt_version(flags);
1027
1028         for (i=0; i<num_dcs; i++) {
1029
1030                 DEBUG(10,("LDAP ping to %s\n", dclist[i].hostname));
1031
1032                 if (ads_cldap_netlogon(mem_ctx, dclist[i].hostname,
1033                                         domain_name,
1034                                         nt_version,
1035                                         &r))
1036                 {
1037                         nt_version = r->ntver;
1038                         ret_flags = get_cldap_reply_server_flags(r, nt_version);
1039
1040                         if (check_cldap_reply_required_flags(ret_flags, flags)) {
1041                                 valid_dc = true;
1042                                 break;
1043                         }
1044                 }
1045
1046                 continue;
1047         }
1048
1049         if (!valid_dc) {
1050                 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1051         }
1052
1053         status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
1054                                                r, info);
1055         if (NT_STATUS_IS_OK(status)) {
1056                 return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
1057                                          nt_version, &r->nt5_ex);
1058         }
1059
1060         return status;
1061 }
1062
1063 /****************************************************************
1064 ****************************************************************/
1065
1066 static struct event_context *ev_context(void)
1067 {
1068         static struct event_context *ctx;
1069
1070         if (!ctx && !(ctx = event_context_init(NULL))) {
1071                 smb_panic("Could not init event context");
1072         }
1073         return ctx;
1074 }
1075
1076 /****************************************************************
1077 ****************************************************************/
1078
1079 static struct messaging_context *msg_context(TALLOC_CTX *mem_ctx)
1080 {
1081         static struct messaging_context *ctx;
1082
1083         if (!ctx && !(ctx = messaging_init(mem_ctx, server_id_self(),
1084                                            ev_context()))) {
1085                 smb_panic("Could not init messaging context");
1086         }
1087         return ctx;
1088 }
1089
1090 /****************************************************************
1091 ****************************************************************/
1092
1093 static NTSTATUS process_dc_netbios(TALLOC_CTX *mem_ctx,
1094                                    struct messaging_context *msg_ctx,
1095                                    const char *domain_name,
1096                                    uint32_t flags,
1097                                    struct ip_service_name *dclist,
1098                                    int num_dcs,
1099                                    struct netr_DsRGetDCNameInfo **info)
1100 {
1101         struct sockaddr_storage ss;
1102         struct ip_service ip_list;
1103         enum nbt_name_type name_type = NBT_NAME_LOGON;
1104         NTSTATUS status;
1105         int i;
1106         const char *dc_name = NULL;
1107         fstring tmp_dc_name;
1108         struct netlogon_samlogon_response *r = NULL;
1109         bool store_cache = false;
1110         uint32_t nt_version = NETLOGON_NT_VERSION_1 |
1111                               NETLOGON_NT_VERSION_5 |
1112                               NETLOGON_NT_VERSION_5EX_WITH_IP;
1113
1114         if (!msg_ctx) {
1115                 msg_ctx = msg_context(mem_ctx);
1116         }
1117
1118         if (flags & DS_PDC_REQUIRED) {
1119                 name_type = NBT_NAME_PDC;
1120         }
1121
1122         nt_version |= map_ds_flags_to_nt_version(flags);
1123
1124         DEBUG(10,("process_dc_netbios\n"));
1125
1126         for (i=0; i<num_dcs; i++) {
1127
1128                 ip_list.ss = dclist[i].ss;
1129                 ip_list.port = 0;
1130
1131                 if (!interpret_string_addr(&ss, dclist[i].hostname, AI_NUMERICHOST)) {
1132                         return NT_STATUS_UNSUCCESSFUL;
1133                 }
1134
1135                 if (send_getdc_request(mem_ctx, msg_ctx,
1136                                        &dclist[i].ss, domain_name,
1137                                        NULL, nt_version))
1138                 {
1139                         int k;
1140                         smb_msleep(300);
1141                         for (k=0; k<5; k++) {
1142                                 if (receive_getdc_response(mem_ctx,
1143                                                            &dclist[i].ss,
1144                                                            domain_name,
1145                                                            &nt_version,
1146                                                            &dc_name,
1147                                                            &r)) {
1148                                         store_cache = true;
1149                                         namecache_store(dc_name, NBT_NAME_SERVER, 1, &ip_list);
1150                                         goto make_reply;
1151                                 }
1152                                 smb_msleep(1500);
1153                         }
1154                 }
1155
1156                 if (name_status_find(domain_name,
1157                                      name_type,
1158                                      NBT_NAME_SERVER,
1159                                      &dclist[i].ss,
1160                                      tmp_dc_name))
1161                 {
1162                         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 logon1;
1163
1164                         r = TALLOC_ZERO_P(mem_ctx, struct netlogon_samlogon_response);
1165                         NT_STATUS_HAVE_NO_MEMORY(r);
1166
1167                         ZERO_STRUCT(logon1);
1168
1169                         nt_version = NETLOGON_NT_VERSION_1;
1170
1171                         logon1.nt_version = nt_version;
1172                         logon1.server = tmp_dc_name;
1173                         logon1.domain = talloc_strdup_upper(mem_ctx, domain_name);
1174                         NT_STATUS_HAVE_NO_MEMORY(logon1.domain);
1175
1176                         r->nt4 = logon1;
1177                         r->ntver = nt_version;
1178
1179                         namecache_store(tmp_dc_name, NBT_NAME_SERVER, 1, &ip_list);
1180
1181                         goto make_reply;
1182                 }
1183         }
1184
1185         return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1186
1187  make_reply:
1188
1189         status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
1190                                                r, info);
1191         if (NT_STATUS_IS_OK(status) && store_cache) {
1192                 return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
1193                                          nt_version, &r->nt5_ex);
1194         }
1195
1196         return status;
1197 }
1198
1199 /****************************************************************
1200 ****************************************************************/
1201
1202 static NTSTATUS dsgetdcname_rediscover(TALLOC_CTX *mem_ctx,
1203                                        struct messaging_context *msg_ctx,
1204                                        const char *domain_name,
1205                                        struct GUID *domain_guid,
1206                                        uint32_t flags,
1207                                        const char *site_name,
1208                                        struct netr_DsRGetDCNameInfo **info)
1209 {
1210         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1211         struct ip_service_name *dclist = NULL;
1212         int num_dcs;
1213
1214         DEBUG(10,("dsgetdcname_rediscover\n"));
1215
1216         if (flags & DS_IS_FLAT_NAME) {
1217
1218                 status = discover_dc_netbios(mem_ctx, domain_name, flags,
1219                                              &dclist, &num_dcs);
1220                 NT_STATUS_NOT_OK_RETURN(status);
1221
1222                 return process_dc_netbios(mem_ctx, msg_ctx, domain_name, flags,
1223                                           dclist, num_dcs, info);
1224         }
1225
1226         if (flags & DS_IS_DNS_NAME) {
1227
1228                 status = discover_dc_dns(mem_ctx, domain_name, domain_guid,
1229                                          flags, site_name, &dclist, &num_dcs);
1230                 NT_STATUS_NOT_OK_RETURN(status);
1231
1232                 return process_dc_dns(mem_ctx, domain_name, flags,
1233                                       dclist, num_dcs, info);
1234         }
1235
1236         status = discover_dc_dns(mem_ctx, domain_name, domain_guid, flags,
1237                                  site_name, &dclist, &num_dcs);
1238
1239         if (NT_STATUS_IS_OK(status) && num_dcs != 0) {
1240
1241                 status = process_dc_dns(mem_ctx, domain_name, flags, dclist,
1242                                         num_dcs, info);
1243                 if (NT_STATUS_IS_OK(status)) {
1244                         return status;
1245                 }
1246         }
1247
1248         status = discover_dc_netbios(mem_ctx, domain_name, flags, &dclist,
1249                                      &num_dcs);
1250         NT_STATUS_NOT_OK_RETURN(status);
1251
1252         return process_dc_netbios(mem_ctx, msg_ctx, domain_name, flags, dclist,
1253                                   num_dcs, info);
1254 }
1255
1256 /********************************************************************
1257  dsgetdcname.
1258
1259  This will be the only public function here.
1260 ********************************************************************/
1261
1262 NTSTATUS dsgetdcname(TALLOC_CTX *mem_ctx,
1263                      struct messaging_context *msg_ctx,
1264                      const char *domain_name,
1265                      struct GUID *domain_guid,
1266                      const char *site_name,
1267                      uint32_t flags,
1268                      struct netr_DsRGetDCNameInfo **info)
1269 {
1270         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1271         struct netr_DsRGetDCNameInfo *myinfo = NULL;
1272         char *query_site = NULL;
1273
1274         DEBUG(10,("dsgetdcname: domain_name: %s, "
1275                   "domain_guid: %s, site_name: %s, flags: 0x%08x\n",
1276                   domain_name,
1277                   domain_guid ? GUID_string(mem_ctx, domain_guid) : "(null)",
1278                   site_name, flags));
1279
1280         *info = NULL;
1281
1282         if (!check_allowed_required_flags(flags, site_name)) {
1283                 DEBUG(0,("invalid flags specified\n"));
1284                 return NT_STATUS_INVALID_PARAMETER;
1285         }
1286
1287         if (!site_name) {
1288                 query_site = sitename_fetch(domain_name);
1289         } else {
1290                 query_site = SMB_STRDUP(site_name);
1291         }
1292
1293         if (flags & DS_FORCE_REDISCOVERY) {
1294                 goto rediscover;
1295         }
1296
1297         status = dsgetdcname_cached(mem_ctx, msg_ctx, domain_name, domain_guid,
1298                                     flags, query_site, &myinfo);
1299         if (NT_STATUS_IS_OK(status)) {
1300                 *info = myinfo;
1301                 goto done;
1302         }
1303
1304         if (flags & DS_BACKGROUND_ONLY) {
1305                 goto done;
1306         }
1307
1308  rediscover:
1309         status = dsgetdcname_rediscover(mem_ctx, msg_ctx, domain_name,
1310                                         domain_guid, flags, query_site,
1311                                         &myinfo);
1312
1313         if (NT_STATUS_IS_OK(status)) {
1314                 *info = myinfo;
1315         }
1316
1317  done:
1318         SAFE_FREE(query_site);
1319
1320         return status;
1321 }