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_SAM_LOGON_RESPONSE_EX *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.sockaddr_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         status = NT_STATUS_OK;
 232
 233  done:
 234         data_blob_free(&blob);
 235
 236         return status;
 237 }
 238
 239 /****************************************************************
 240 ****************************************************************/
 241
 242 static NTSTATUS dsgetdcname_cache_refresh(TALLOC_CTX *mem_ctx,
 243                                           struct messaging_context *msg_ctx,
 244                                           const char *domain_name,
 245                                           struct GUID *domain_guid,
 246                                           uint32_t flags,
 247                                           const char *site_name,
 248                                           struct netr_DsRGetDCNameInfo *info)
 249 {
 250         struct netr_DsRGetDCNameInfo *dc_info;
 251
 252         return dsgetdcname(mem_ctx,
 253                            msg_ctx,
 254                            domain_name,
 255                            domain_guid,
 256                            site_name,
 257                            flags | DS_FORCE_REDISCOVERY,
 258                            &dc_info);
 259 }
 260
 261 /****************************************************************
 262 ****************************************************************/
 263
 264 static uint32_t get_cldap_reply_server_flags(struct netlogon_samlogon_response *r,
 265                                              uint32_t nt_version)
 266 {
 267         switch (nt_version & 0x0000001f) {
 268                 case 0:
 269                 case 1:
 270                 case 16:
 271                 case 17:
 272                         return 0;
 273                 case 2:
 274                 case 3:
 275                 case 18:
 276                 case 19:
 277                         return r->data.nt5.server_type;
 278                 case 4:
 279                 case 5:
 280                 case 6:
 281                 case 7:
 282                         return r->data.nt5_ex.server_type;
 283                 case 8:
 284                 case 9:
 285                 case 10:
 286                 case 11:
 287                 case 12:
 288                 case 13:
 289                 case 14:
 290                 case 15:
 291                         return r->data.nt5_ex.server_type;
 292                 case 20:
 293                 case 21:
 294                 case 22:
 295                 case 23:
 296                 case 24:
 297                 case 25:
 298                 case 26:
 299                 case 27:
 300                 case 28:
 301                         return r->data.nt5_ex.server_type;
 302                 case 29:
 303                 case 30:
 304                 case 31:
 305                         return r->data.nt5_ex.server_type;
 306                 default:
 307                         return 0;
 308         }
 309 }
 310
 311 /****************************************************************
 312 ****************************************************************/
 313
 314 #define RETURN_ON_FALSE(x) if (!x) return false;
 315
 316 static bool check_cldap_reply_required_flags(uint32_t ret_flags,
 317                                              uint32_t req_flags)
 318 {
 319         if (ret_flags == 0) {
 320                 return true;
 321         }
 322
 323         if (req_flags & DS_PDC_REQUIRED)
 324                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_PDC);
 325
 326         if (req_flags & DS_GC_SERVER_REQUIRED)
 327                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_GC);
 328
 329         if (req_flags & DS_ONLY_LDAP_NEEDED)
 330                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_LDAP);
 331
 332         if ((req_flags & DS_DIRECTORY_SERVICE_REQUIRED) ||
 333             (req_flags & DS_DIRECTORY_SERVICE_PREFERRED))
 334                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_DS);
 335
 336         if (req_flags & DS_KDC_REQUIRED)
 337                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_KDC);
 338
 339         if (req_flags & DS_TIMESERV_REQUIRED)
 340                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_TIMESERV);
 341
 342         if (req_flags & DS_WRITABLE_REQUIRED)
 343                 RETURN_ON_FALSE(ret_flags & NBT_SERVER_WRITABLE);
 344
 345         return true;
 346 }
 347
 348 /****************************************************************
 349 ****************************************************************/
 350
 351 static NTSTATUS dsgetdcname_cache_fetch(TALLOC_CTX *mem_ctx,
 352                                         const char *domain_name,
 353                                         struct GUID *domain_guid,
 354                                         uint32_t flags,
 355                                         const char *site_name,
 356                                         struct netr_DsRGetDCNameInfo **info_p,
 357                                         bool *expired)
 358 {
 359         char *key;
 360         DATA_BLOB blob;
 361         enum ndr_err_code ndr_err;
 362         struct netr_DsRGetDCNameInfo *info;
 363         struct NETLOGON_SAM_LOGON_RESPONSE_EX r;
 364         NTSTATUS status;
 365
 366         if (!gencache_init()) {
 367                 return NT_STATUS_INTERNAL_DB_ERROR;
 368         }
 369
 370         key = dsgetdcname_cache_key(mem_ctx, domain_name);
 371         if (!key) {
 372                 return NT_STATUS_NO_MEMORY;
 373         }
 374
 375         if (!gencache_get_data_blob(key, &blob, expired)) {
 376                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
 377         }
 378
 379         info = TALLOC_ZERO_P(mem_ctx, struct netr_DsRGetDCNameInfo);
 380         if (!info) {
 381                 return NT_STATUS_NO_MEMORY;
 382         }
 383
 384         ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, NULL, &r,
 385                       (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX);
 386
 387         data_blob_free(&blob);
 388         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 389                 dsgetdcname_cache_delete(mem_ctx, domain_name);
 390                 return ndr_map_error2ntstatus(ndr_err);
 391         }
 392
 393         status = make_dc_info_from_cldap_reply(mem_ctx, flags, NULL,
 394                                                &r, &info);
 395         if (!NT_STATUS_IS_OK(status)) {
 396                 return status;
 397         }
 398
 399         if (DEBUGLEVEL >= 10) {
 400                 NDR_PRINT_DEBUG(netr_DsRGetDCNameInfo, info);
 401         }
 402
 403         /* check flags */
 404         if (!check_cldap_reply_required_flags(info->dc_flags, flags)) {
 405                 DEBUG(10,("invalid flags\n"));
 406                 return NT_STATUS_INVALID_PARAMETER;
 407         }
 408
 409         if ((flags & DS_IP_REQUIRED) &&
 410             (info->dc_address_type != DS_ADDRESS_TYPE_INET)) {
 411                 return NT_STATUS_INVALID_PARAMETER_MIX;
 412         }
 413
 414         *info_p = info;
 415
 416         return NT_STATUS_OK;
 417 }
 418
 419 /****************************************************************
 420 ****************************************************************/
 421
 422 static NTSTATUS dsgetdcname_cached(TALLOC_CTX *mem_ctx,
 423                                    struct messaging_context *msg_ctx,
 424                                    const char *domain_name,
 425                                    struct GUID *domain_guid,
 426                                    uint32_t flags,
 427                                    const char *site_name,
 428                                    struct netr_DsRGetDCNameInfo **info)
 429 {
 430         NTSTATUS status;
 431         bool expired = false;
 432
 433         status = dsgetdcname_cache_fetch(mem_ctx, domain_name, domain_guid,
 434                                          flags, site_name, info, &expired);
 435         if (!NT_STATUS_IS_OK(status)) {
 436                 DEBUG(10,("dsgetdcname_cached: cache fetch failed with: %s\n",
 437                         nt_errstr(status)));
 438                 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
 439         }
 440
 441         if (flags & DS_BACKGROUND_ONLY) {
 442                 return status;
 443         }
 444
 445         if (expired) {
 446                 status = dsgetdcname_cache_refresh(mem_ctx, msg_ctx,
 447                                                    domain_name,
 448                                                    domain_guid, flags,
 449                                                    site_name, *info);
 450                 if (!NT_STATUS_IS_OK(status)) {
 451                         return status;
 452                 }
 453         }
 454
 455         return status;
 456 }
 457
 458 /****************************************************************
 459 ****************************************************************/
 460
 461 static bool check_allowed_required_flags(uint32_t flags,
 462                                          const char *site_name)
 463 {
 464         uint32_t return_type = flags & (DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME);
 465         uint32_t offered_type = flags & (DS_IS_FLAT_NAME|DS_IS_DNS_NAME);
 466         uint32_t query_type = flags & (DS_BACKGROUND_ONLY|DS_FORCE_REDISCOVERY);
 467
 468         /* FIXME: check for DSGETDC_VALID_FLAGS and check for excluse bits
 469          * (DS_PDC_REQUIRED, DS_KDC_REQUIRED, DS_GC_SERVER_REQUIRED) */
 470
 471         debug_dsdcinfo_flags(10, flags);
 472
 473         if ((flags & DS_TRY_NEXTCLOSEST_SITE) && site_name) {
 474                 return false;
 475         }
 476
 477         if (return_type == (DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME)) {
 478                 return false;
 479         }
 480
 481         if (offered_type == (DS_IS_DNS_NAME|DS_IS_FLAT_NAME)) {
 482                 return false;
 483         }
 484
 485         if (query_type == (DS_BACKGROUND_ONLY|DS_FORCE_REDISCOVERY)) {
 486                 return false;
 487         }
 488
 489 #if 0
 490         if ((flags & DS_RETURN_DNS_NAME) && (!(flags & DS_IP_REQUIRED))) {
 491                 printf("gd: here5 \n");
 492                 return false;
 493         }
 494 #endif
 495         return true;
 496 }
 497
 498 /****************************************************************
 499 ****************************************************************/
 500
 501 static NTSTATUS discover_dc_netbios(TALLOC_CTX *mem_ctx,
 502                                     const char *domain_name,
 503                                     uint32_t flags,
 504                                     struct ip_service_name **returned_dclist,
 505                                     int *returned_count)
 506 {
 507         NTSTATUS status;
 508         enum nbt_name_type name_type = NBT_NAME_LOGON;
 509         struct ip_service *iplist;
 510         int i;
 511         struct ip_service_name *dclist = NULL;
 512         int count;
 513
 514         *returned_dclist = NULL;
 515         *returned_count = 0;
 516
 517         if (lp_disable_netbios()) {
 518                 return NT_STATUS_NOT_SUPPORTED;
 519         }
 520
 521         if (flags & DS_PDC_REQUIRED) {
 522                 name_type = NBT_NAME_PDC;
 523         }
 524
 525         status = internal_resolve_name(domain_name, name_type, NULL,
 526                                        &iplist, &count,
 527                                        "lmhosts wins bcast");
 528         if (!NT_STATUS_IS_OK(status)) {
 529                 DEBUG(10,("discover_dc_netbios: failed to find DC\n"));
 530                 return status;
 531         }
 532
 533         dclist = TALLOC_ZERO_ARRAY(mem_ctx, struct ip_service_name, count);
 534         if (!dclist) {
 535                 return NT_STATUS_NO_MEMORY;
 536         }
 537
 538         for (i=0; i<count; i++) {
 539
 540                 char addr[INET6_ADDRSTRLEN];
 541                 struct ip_service_name *r = &dclist[i];
 542
 543                 print_sockaddr(addr, sizeof(addr),
 544                                &iplist[i].ss);
 545
 546                 r->ss   = iplist[i].ss;
 547                 r->port = iplist[i].port;
 548                 r->hostname = talloc_strdup(mem_ctx, addr);
 549                 if (!r->hostname) {
 550                         return NT_STATUS_NO_MEMORY;
 551                 }
 552
 553         }
 554
 555         *returned_dclist = dclist;
 556         *returned_count = count;
 557
 558         return NT_STATUS_OK;
 559 }
 560
 561 /****************************************************************
 562 ****************************************************************/
 563
 564 static NTSTATUS discover_dc_dns(TALLOC_CTX *mem_ctx,
 565                                 const char *domain_name,
 566                                 struct GUID *domain_guid,
 567                                 uint32_t flags,
 568                                 const char *site_name,
 569                                 struct ip_service_name **returned_dclist,
 570                                 int *return_count)
 571 {
 572         int i, j;
 573         NTSTATUS status;
 574         struct dns_rr_srv *dcs = NULL;
 575         int numdcs = 0;
 576         int numaddrs = 0;
 577         struct ip_service_name *dclist = NULL;
 578         int count = 0;
 579
 580         if (flags & DS_PDC_REQUIRED) {
 581                 status = ads_dns_query_pdc(mem_ctx, domain_name,
 582                                            &dcs, &numdcs);
 583         } else if (flags & DS_GC_SERVER_REQUIRED) {
 584                 status = ads_dns_query_gcs(mem_ctx, domain_name, site_name,
 585                                            &dcs, &numdcs);
 586         } else if (flags & DS_KDC_REQUIRED) {
 587                 status = ads_dns_query_kdcs(mem_ctx, domain_name, site_name,
 588                                             &dcs, &numdcs);
 589         } else if (flags & DS_DIRECTORY_SERVICE_REQUIRED) {
 590                 status = ads_dns_query_dcs(mem_ctx, domain_name, site_name,
 591                                            &dcs, &numdcs);
 592         } else if (domain_guid) {
 593                 status = ads_dns_query_dcs_guid(mem_ctx, domain_name,
 594                                                 domain_guid, &dcs, &numdcs);
 595         } else {
 596                 status = ads_dns_query_dcs(mem_ctx, domain_name, site_name,
 597                                            &dcs, &numdcs);
 598         }
 599
 600         if (!NT_STATUS_IS_OK(status)) {
 601                 return status;
 602         }
 603
 604         if (numdcs == 0) {
 605                 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
 606         }
 607
 608         for (i=0;i<numdcs;i++) {
 609                 numaddrs += MAX(dcs[i].num_ips,1);
 610         }
 611
 612         dclist = TALLOC_ZERO_ARRAY(mem_ctx,
 613                                    struct ip_service_name,
 614                                    numaddrs);
 615         if (!dclist) {
 616                 return NT_STATUS_NO_MEMORY;
 617         }
 618
 619         /* now unroll the list of IP addresses */
 620
 621         *return_count = 0;
 622         i = 0;
 623         j = 0;
 624
 625         while ((i < numdcs) && (count < numaddrs)) {
 626
 627                 struct ip_service_name *r = &dclist[count];
 628
 629                 r->port = dcs[count].port;
 630                 r->hostname = dcs[count].hostname;
 631
 632                 /* If we don't have an IP list for a name, lookup it up */
 633
 634                 if (!dcs[i].ss_s) {
 635                         interpret_string_addr(&r->ss, dcs[i].hostname, 0);
 636                         i++;
 637                         j = 0;
 638                 } else {
 639                         /* use the IP addresses from the SRV sresponse */
 640
 641                         if (j >= dcs[i].num_ips) {
 642                                 i++;
 643                                 j = 0;
 644                                 continue;
 645                         }
 646
 647                         r->ss = dcs[i].ss_s[j];
 648                         j++;
 649                 }
 650
 651                 /* make sure it is a valid IP.  I considered checking the
 652                  * negative connection cache, but this is the wrong place for
 653                  * it.  Maybe only as a hac.  After think about it, if all of
 654                  * the IP addresses retuend from DNS are dead, what hope does a
 655                  * netbios name lookup have?  The standard reason for falling
 656                  * back to netbios lookups is that our DNS server doesn't know
 657                  * anything about the DC's   -- jerry */
 658
 659                 if (!is_zero_addr((struct sockaddr *)&r->ss)) {
 660                         count++;
 661                         continue;
 662                 }
 663         }
 664
 665         *returned_dclist = dclist;
 666         *return_count = count;
 667
 668         if (count > 0) {
 669                 return NT_STATUS_OK;
 670         }
 671
 672         return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
 673 }
 674
 675 /****************************************************************
 676 ****************************************************************/
 677
 678 static NTSTATUS make_domain_controller_info(TALLOC_CTX *mem_ctx,
 679                                             const char *dc_unc,
 680                                             const char *dc_address,
 681                                             uint32_t dc_address_type,
 682                                             const struct GUID *domain_guid,
 683                                             const char *domain_name,
 684                                             const char *forest_name,
 685                                             uint32_t flags,
 686                                             const char *dc_site_name,
 687                                             const char *client_site_name,
 688                                             struct netr_DsRGetDCNameInfo **info_out)
 689 {
 690         struct netr_DsRGetDCNameInfo *info;
 691
 692         info = TALLOC_ZERO_P(mem_ctx, struct netr_DsRGetDCNameInfo);
 693         NT_STATUS_HAVE_NO_MEMORY(info);
 694
 695         if (dc_unc) {
 696                 info->dc_unc = talloc_strdup(mem_ctx, dc_unc);
 697                 NT_STATUS_HAVE_NO_MEMORY(info->dc_unc);
 698         }
 699
 700         if (dc_address) {
 701                 if (!(dc_address[0] == '\\' && dc_address[1] == '\\')) {
 702                         info->dc_address = talloc_asprintf(mem_ctx, "\\\\%s",
 703                                                            dc_address);
 704                 } else {
 705                         info->dc_address = talloc_strdup(mem_ctx, dc_address);
 706                 }
 707                 NT_STATUS_HAVE_NO_MEMORY(info->dc_address);
 708         }
 709
 710         info->dc_address_type = dc_address_type;
 711
 712         if (domain_guid) {
 713                 info->domain_guid = *domain_guid;
 714         }
 715
 716         if (domain_name) {
 717                 info->domain_name = talloc_strdup(mem_ctx, domain_name);
 718                 NT_STATUS_HAVE_NO_MEMORY(info->domain_name);
 719         }
 720
 721         if (forest_name && *forest_name) {
 722                 info->forest_name = talloc_strdup(mem_ctx, forest_name);
 723                 NT_STATUS_HAVE_NO_MEMORY(info->forest_name);
 724                 flags |= DS_DNS_FOREST;
 725         }
 726
 727         info->dc_flags = flags;
 728
 729         if (dc_site_name) {
 730                 info->dc_site_name = talloc_strdup(mem_ctx, dc_site_name);
 731                 NT_STATUS_HAVE_NO_MEMORY(info->dc_site_name);
 732         }
 733
 734         if (client_site_name) {
 735                 info->client_site_name = talloc_strdup(mem_ctx,
 736                                                        client_site_name);
 737                 NT_STATUS_HAVE_NO_MEMORY(info->client_site_name);
 738         }
 739
 740         *info_out = info;
 741
 742         return NT_STATUS_OK;
 743 }
 744
 745 /****************************************************************
 746 ****************************************************************/
 747
 748 static void map_dc_and_domain_names(uint32_t flags,
 749                                     const char *dc_name,
 750                                     const char *domain_name,
 751                                     const char *dns_dc_name,
 752                                     const char *dns_domain_name,
 753                                     uint32_t *dc_flags,
 754                                     const char **hostname_p,
 755                                     const char **domain_p)
 756 {
 757         switch (flags & 0xf0000000) {
 758                 case DS_RETURN_FLAT_NAME:
 759                         if (dc_name && domain_name &&
 760                             *dc_name && *domain_name) {
 761                                 *hostname_p = dc_name;
 762                                 *domain_p = domain_name;
 763                                 break;
 764                         }
 765                 case DS_RETURN_DNS_NAME:
 766                 default:
 767                         if (dns_dc_name && dns_domain_name &&
 768                             *dns_dc_name && *dns_domain_name) {
 769                                 *hostname_p = dns_dc_name;
 770                                 *domain_p = dns_domain_name;
 771                                 *dc_flags |= DS_DNS_DOMAIN | DS_DNS_CONTROLLER;
 772                                 break;
 773                         }
 774                         if (dc_name && domain_name &&
 775                             *dc_name && *domain_name) {
 776                                 *hostname_p = dc_name;
 777                                 *domain_p = domain_name;
 778                                 break;
 779                         }
 780         }
 781 }
 782
 783 /****************************************************************
 784 ****************************************************************/
 785
 786 static NTSTATUS make_dc_info_from_cldap_reply(TALLOC_CTX *mem_ctx,
 787                                               uint32_t flags,
 788                                               struct sockaddr_storage *ss,
 789                                               struct NETLOGON_SAM_LOGON_RESPONSE_EX *r,
 790                                               struct netr_DsRGetDCNameInfo **info)
 791 {
 792         const char *dc_hostname = NULL;
 793         const char *dc_domain_name = NULL;
 794         const char *dc_address = NULL;
 795         const char *dc_forest = NULL;
 796         uint32_t dc_address_type = 0;
 797         uint32_t dc_flags = 0;
 798         struct GUID *dc_domain_guid = NULL;
 799         const char *dc_server_site = NULL;
 800         const char *dc_client_site = NULL;
 801
 802         char addr[INET6_ADDRSTRLEN];
 803
 804         if (ss) {
 805                 print_sockaddr(addr, sizeof(addr), ss);
 806                 dc_address = addr;
 807                 dc_address_type = DS_ADDRESS_TYPE_INET;
 808         }
 809
 810         if (!ss && r->sockaddr.pdc_ip) {
 811                 dc_address      = r->sockaddr.pdc_ip;
 812                 dc_address_type = DS_ADDRESS_TYPE_INET;
 813         } else {
 814                 dc_address      = r->pdc_name;
 815                 dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
 816         }
 817
 818         map_dc_and_domain_names(flags,
 819                                 r->pdc_name,
 820                                 r->domain,
 821                                 r->pdc_dns_name,
 822                                 r->dns_domain,
 823                                 &dc_flags,
 824                                 &dc_hostname,
 825                                 &dc_domain_name);
 826
 827         dc_flags        |= r->server_type;
 828         dc_forest       = r->forest;
 829         dc_domain_guid  = &r->domain_uuid;
 830         dc_server_site  = r->server_site;
 831         dc_client_site  = r->client_site;
 832
 833         return make_domain_controller_info(mem_ctx,
 834                                            dc_hostname,
 835                                            dc_address,
 836                                            dc_address_type,
 837                                            dc_domain_guid,
 838                                            dc_domain_name,
 839                                            dc_forest,
 840                                            dc_flags,
 841                                            dc_server_site,
 842                                            dc_client_site,
 843                                            info);
 844 }
 845
 846 /****************************************************************
 847 ****************************************************************/
 848
 849 static uint32_t map_ds_flags_to_nt_version(uint32_t flags)
 850 {
 851         uint32_t nt_version = 0;
 852
 853         if (flags & DS_PDC_REQUIRED) {
 854                 nt_version |= NETLOGON_NT_VERSION_PDC;
 855         }
 856
 857         if (flags & DS_GC_SERVER_REQUIRED) {
 858                 nt_version |= NETLOGON_NT_VERSION_GC;
 859         }
 860
 861         if (flags & DS_TRY_NEXTCLOSEST_SITE) {
 862                 nt_version |= NETLOGON_NT_VERSION_WITH_CLOSEST_SITE;
 863         }
 864
 865         if (flags & DS_IP_REQUIRED) {
 866                 nt_version |= NETLOGON_NT_VERSION_IP;
 867         }
 868
 869         return nt_version;
 870 }
 871
 872 /****************************************************************
 873 ****************************************************************/
 874
 875 static NTSTATUS process_dc_dns(TALLOC_CTX *mem_ctx,
 876                                const char *domain_name,
 877                                uint32_t flags,
 878                                struct ip_service_name *dclist,
 879                                int num_dcs,
 880                                struct netr_DsRGetDCNameInfo **info)
 881 {
 882         int i = 0;
 883         bool valid_dc = false;
 884         struct netlogon_samlogon_response *r = NULL;
 885         uint32_t nt_version = NETLOGON_NT_VERSION_5 |
 886                               NETLOGON_NT_VERSION_5EX;
 887         uint32_t ret_flags = 0;
 888         NTSTATUS status;
 889
 890         nt_version |= map_ds_flags_to_nt_version(flags);
 891
 892         for (i=0; i<num_dcs; i++) {
 893
 894                 DEBUG(10,("LDAP ping to %s\n", dclist[i].hostname));
 895
 896                 if (ads_cldap_netlogon(mem_ctx, dclist[i].hostname,
 897                                         domain_name,
 898                                         nt_version,
 899                                         &r))
 900                 {
 901                         nt_version = r->ntver;
 902                         ret_flags = get_cldap_reply_server_flags(r, nt_version);
 903
 904                         if (check_cldap_reply_required_flags(ret_flags, flags)) {
 905                                 valid_dc = true;
 906                                 break;
 907                         }
 908                 }
 909
 910                 continue;
 911         }
 912
 913         if (!valid_dc) {
 914                 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
 915         }
 916
 917         status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
 918                                                &r->data.nt5_ex, info);
 919         if (NT_STATUS_IS_OK(status)) {
 920                 return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
 921                                          nt_version, &r->data.nt5_ex);
 922         }
 923
 924         return status;
 925 }
 926
 927 /****************************************************************
 928 ****************************************************************/
 929
 930 static struct event_context *ev_context(void)
 931 {
 932         static struct event_context *ctx;
 933
 934         if (!ctx && !(ctx = event_context_init(NULL))) {
 935                 smb_panic("Could not init event context");
 936         }
 937         return ctx;
 938 }
 939
 940 /****************************************************************
 941 ****************************************************************/
 942
 943 static struct messaging_context *msg_context(TALLOC_CTX *mem_ctx)
 944 {
 945         static struct messaging_context *ctx;
 946
 947         if (!ctx && !(ctx = messaging_init(mem_ctx, server_id_self(),
 948                                            ev_context()))) {
 949                 smb_panic("Could not init messaging context");
 950         }
 951         return ctx;
 952 }
 953
 954 /****************************************************************
 955 ****************************************************************/
 956
 957 static NTSTATUS process_dc_netbios(TALLOC_CTX *mem_ctx,
 958                                    struct messaging_context *msg_ctx,
 959                                    const char *domain_name,
 960                                    uint32_t flags,
 961                                    struct ip_service_name *dclist,
 962                                    int num_dcs,
 963                                    struct netr_DsRGetDCNameInfo **info)
 964 {
 965         struct sockaddr_storage ss;
 966         struct ip_service ip_list;
 967         enum nbt_name_type name_type = NBT_NAME_LOGON;
 968         NTSTATUS status;
 969         int i;
 970         const char *dc_name = NULL;
 971         fstring tmp_dc_name;
 972         struct netlogon_samlogon_response *r = NULL;
 973         bool store_cache = false;
 974         uint32_t nt_version = NETLOGON_NT_VERSION_1 |
 975                               NETLOGON_NT_VERSION_5 |
 976                               NETLOGON_NT_VERSION_5EX_WITH_IP;
 977
 978         if (!msg_ctx) {
 979                 msg_ctx = msg_context(mem_ctx);
 980         }
 981
 982         if (flags & DS_PDC_REQUIRED) {
 983                 name_type = NBT_NAME_PDC;
 984         }
 985
 986         nt_version |= map_ds_flags_to_nt_version(flags);
 987
 988         DEBUG(10,("process_dc_netbios\n"));
 989
 990         for (i=0; i<num_dcs; i++) {
 991
 992                 ip_list.ss = dclist[i].ss;
 993                 ip_list.port = 0;
 994
 995                 if (!interpret_string_addr(&ss, dclist[i].hostname, AI_NUMERICHOST)) {
 996                         return NT_STATUS_UNSUCCESSFUL;
 997                 }
 998
 999                 if (send_getdc_request(mem_ctx, msg_ctx,
1000                                        &dclist[i].ss, domain_name,
1001                                        NULL, nt_version))
1002                 {
1003                         int k;
1004                         smb_msleep(300);
1005                         for (k=0; k<5; k++) {
1006                                 if (receive_getdc_response(mem_ctx,
1007                                                            &dclist[i].ss,
1008                                                            domain_name,
1009                                                            &nt_version,
1010                                                            &dc_name,
1011                                                            &r)) {
1012                                         store_cache = true;
1013                                         namecache_store(dc_name, NBT_NAME_SERVER, 1, &ip_list);
1014                                         goto make_reply;
1015                                 }
1016                                 smb_msleep(1500);
1017                         }
1018                 }
1019
1020                 if (name_status_find(domain_name,
1021                                      name_type,
1022                                      NBT_NAME_SERVER,
1023                                      &dclist[i].ss,
1024                                      tmp_dc_name))
1025                 {
1026                         struct NETLOGON_SAM_LOGON_RESPONSE_NT40 logon1;
1027
1028                         r = TALLOC_ZERO_P(mem_ctx, struct netlogon_samlogon_response);
1029                         NT_STATUS_HAVE_NO_MEMORY(r);
1030
1031                         ZERO_STRUCT(logon1);
1032
1033                         nt_version = NETLOGON_NT_VERSION_1;
1034
1035                         logon1.nt_version = nt_version;
1036                         logon1.server = tmp_dc_name;
1037                         logon1.domain = talloc_strdup_upper(mem_ctx, domain_name);
1038                         NT_STATUS_HAVE_NO_MEMORY(logon1.domain);
1039
1040                         r->data.nt4 = logon1;
1041                         r->ntver = nt_version;
1042
1043                         map_netlogon_samlogon_response(r);
1044
1045                         namecache_store(tmp_dc_name, NBT_NAME_SERVER, 1, &ip_list);
1046
1047                         goto make_reply;
1048                 }
1049         }
1050
1051         return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1052
1053  make_reply:
1054
1055         status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
1056                                                &r->data.nt5_ex, info);
1057         if (NT_STATUS_IS_OK(status) && store_cache) {
1058                 return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
1059                                          nt_version, &r->data.nt5_ex);
1060         }
1061
1062         return status;
1063 }
1064
1065 /****************************************************************
1066 ****************************************************************/
1067
1068 static NTSTATUS dsgetdcname_rediscover(TALLOC_CTX *mem_ctx,
1069                                        struct messaging_context *msg_ctx,
1070                                        const char *domain_name,
1071                                        struct GUID *domain_guid,
1072                                        uint32_t flags,
1073                                        const char *site_name,
1074                                        struct netr_DsRGetDCNameInfo **info)
1075 {
1076         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1077         struct ip_service_name *dclist = NULL;
1078         int num_dcs;
1079
1080         DEBUG(10,("dsgetdcname_rediscover\n"));
1081
1082         if (flags & DS_IS_FLAT_NAME) {
1083
1084                 status = discover_dc_netbios(mem_ctx, domain_name, flags,
1085                                              &dclist, &num_dcs);
1086                 NT_STATUS_NOT_OK_RETURN(status);
1087
1088                 return process_dc_netbios(mem_ctx, msg_ctx, domain_name, flags,
1089                                           dclist, num_dcs, info);
1090         }
1091
1092         if (flags & DS_IS_DNS_NAME) {
1093
1094                 status = discover_dc_dns(mem_ctx, domain_name, domain_guid,
1095                                          flags, site_name, &dclist, &num_dcs);
1096                 NT_STATUS_NOT_OK_RETURN(status);
1097
1098                 return process_dc_dns(mem_ctx, domain_name, flags,
1099                                       dclist, num_dcs, info);
1100         }
1101
1102         status = discover_dc_dns(mem_ctx, domain_name, domain_guid, flags,
1103                                  site_name, &dclist, &num_dcs);
1104
1105         if (NT_STATUS_IS_OK(status) && num_dcs != 0) {
1106
1107                 status = process_dc_dns(mem_ctx, domain_name, flags, dclist,
1108                                         num_dcs, info);
1109                 if (NT_STATUS_IS_OK(status)) {
1110                         return status;
1111                 }
1112         }
1113
1114         status = discover_dc_netbios(mem_ctx, domain_name, flags, &dclist,
1115                                      &num_dcs);
1116         NT_STATUS_NOT_OK_RETURN(status);
1117
1118         return process_dc_netbios(mem_ctx, msg_ctx, domain_name, flags, dclist,
1119                                   num_dcs, info);
1120 }
1121
1122 static bool is_closest_site(struct netr_DsRGetDCNameInfo *info)
1123 {
1124         if (info->dc_flags & DS_SERVER_CLOSEST) {
1125                 return true;
1126         }
1127
1128         if (!info->client_site_name) {
1129                 return true;
1130         }
1131
1132         if (!info->dc_site_name) {
1133                 return false;
1134         }
1135
1136         if (strcmp(info->client_site_name, info->dc_site_name) == 0) {
1137                 return true;
1138         }
1139
1140         return false;
1141 }
1142
1143 /********************************************************************
1144  dsgetdcname.
1145
1146  This will be the only public function here.
1147 ********************************************************************/
1148
1149 NTSTATUS dsgetdcname(TALLOC_CTX *mem_ctx,
1150                      struct messaging_context *msg_ctx,
1151                      const char *domain_name,
1152                      struct GUID *domain_guid,
1153                      const char *site_name,
1154                      uint32_t flags,
1155                      struct netr_DsRGetDCNameInfo **info)
1156 {
1157         NTSTATUS status = NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1158         struct netr_DsRGetDCNameInfo *myinfo = NULL;
1159         char *query_site = NULL;
1160         bool first = true;
1161         struct netr_DsRGetDCNameInfo *first_info = NULL;
1162
1163         DEBUG(10,("dsgetdcname: domain_name: %s, "
1164                   "domain_guid: %s, site_name: %s, flags: 0x%08x\n",
1165                   domain_name,
1166                   domain_guid ? GUID_string(mem_ctx, domain_guid) : "(null)",
1167                   site_name, flags));
1168
1169         *info = NULL;
1170
1171         if (!check_allowed_required_flags(flags, site_name)) {
1172                 DEBUG(0,("invalid flags specified\n"));
1173                 return NT_STATUS_INVALID_PARAMETER;
1174         }
1175
1176         if (!site_name) {
1177                 query_site = sitename_fetch(domain_name);
1178         } else {
1179                 query_site = SMB_STRDUP(site_name);
1180         }
1181
1182         if (flags & DS_FORCE_REDISCOVERY) {
1183                 goto rediscover;
1184         }
1185
1186         status = dsgetdcname_cached(mem_ctx, msg_ctx, domain_name, domain_guid,
1187                                     flags, query_site, &myinfo);
1188         if (NT_STATUS_IS_OK(status)) {
1189                 goto done;
1190         }
1191
1192         if (flags & DS_BACKGROUND_ONLY) {
1193                 goto done;
1194         }
1195
1196  rediscover:
1197         status = dsgetdcname_rediscover(mem_ctx, msg_ctx, domain_name,
1198                                         domain_guid, flags, query_site,
1199                                         &myinfo);
1200
1201  done:
1202         SAFE_FREE(query_site);
1203
1204         if (!NT_STATUS_IS_OK(status)) {
1205                 if (!first) {
1206                         *info = first_info;
1207                         return NT_STATUS_OK;
1208                 }
1209                 return status;
1210         }
1211
1212         if (!first) {
1213                 TALLOC_FREE(first_info);
1214         } else if (!is_closest_site(myinfo)) {
1215                 first = false;
1216                 first_info = myinfo;
1217                 /* TODO: may use the next_closest_site here */
1218                 query_site = SMB_STRDUP(myinfo->client_site_name);
1219                 goto rediscover;
1220         }
1221
1222         *info = myinfo;
1223         return NT_STATUS_OK;
1224 }