2 Unix SMB/CIFS implementation.
6 Copyright (C) Gerald Carter 2006
7 Copyright (C) Guenther Deschner 2007-2008
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.
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.
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/>.
24 #include "libsmb/dsgetdcname.h"
25 #include "libsmb/namequery.h"
26 #include "libads/sitename_cache.h"
27 #include "../librpc/gen_ndr/ndr_netlogon.h"
28 #include "libads/cldap.h"
29 #include "../lib/addns/dnsquery.h"
30 #include "libsmb/clidgram.h"
31 #include "lib/gencache.h"
34 #define DSGETDCNAME_CACHE_TTL 60*15
36 struct ip_service_name {
37 struct sockaddr_storage ss;
41 static NTSTATUS make_dc_info_from_cldap_reply(
44 const struct sockaddr_storage *ss,
45 struct NETLOGON_SAM_LOGON_RESPONSE_EX *r,
46 struct netr_DsRGetDCNameInfo **info);
48 /****************************************************************
49 ****************************************************************/
51 static void debug_dsdcinfo_flags(int lvl, uint32_t flags)
53 DEBUG(lvl,("debug_dsdcinfo_flags: 0x%08x\n\t", flags));
55 if (flags & DS_FORCE_REDISCOVERY)
56 DEBUGADD(lvl,("DS_FORCE_REDISCOVERY "));
57 if (flags & 0x000000002)
58 DEBUGADD(lvl,("0x00000002 "));
59 if (flags & 0x000000004)
60 DEBUGADD(lvl,("0x00000004 "));
61 if (flags & 0x000000008)
62 DEBUGADD(lvl,("0x00000008 "));
63 if (flags & DS_DIRECTORY_SERVICE_REQUIRED)
64 DEBUGADD(lvl,("DS_DIRECTORY_SERVICE_REQUIRED "));
65 if (flags & DS_DIRECTORY_SERVICE_PREFERRED)
66 DEBUGADD(lvl,("DS_DIRECTORY_SERVICE_PREFERRED "));
67 if (flags & DS_GC_SERVER_REQUIRED)
68 DEBUGADD(lvl,("DS_GC_SERVER_REQUIRED "));
69 if (flags & DS_PDC_REQUIRED)
70 DEBUGADD(lvl,("DS_PDC_REQUIRED "));
71 if (flags & DS_BACKGROUND_ONLY)
72 DEBUGADD(lvl,("DS_BACKGROUND_ONLY "));
73 if (flags & DS_IP_REQUIRED)
74 DEBUGADD(lvl,("DS_IP_REQUIRED "));
75 if (flags & DS_KDC_REQUIRED)
76 DEBUGADD(lvl,("DS_KDC_REQUIRED "));
77 if (flags & DS_TIMESERV_REQUIRED)
78 DEBUGADD(lvl,("DS_TIMESERV_REQUIRED "));
79 if (flags & DS_WRITABLE_REQUIRED)
80 DEBUGADD(lvl,("DS_WRITABLE_REQUIRED "));
81 if (flags & DS_GOOD_TIMESERV_PREFERRED)
82 DEBUGADD(lvl,("DS_GOOD_TIMESERV_PREFERRED "));
83 if (flags & DS_AVOID_SELF)
84 DEBUGADD(lvl,("DS_AVOID_SELF "));
85 if (flags & DS_ONLY_LDAP_NEEDED)
86 DEBUGADD(lvl,("DS_ONLY_LDAP_NEEDED "));
87 if (flags & DS_IS_FLAT_NAME)
88 DEBUGADD(lvl,("DS_IS_FLAT_NAME "));
89 if (flags & DS_IS_DNS_NAME)
90 DEBUGADD(lvl,("DS_IS_DNS_NAME "));
91 if (flags & 0x00040000)
92 DEBUGADD(lvl,("0x00040000 "));
93 if (flags & 0x00080000)
94 DEBUGADD(lvl,("0x00080000 "));
95 if (flags & 0x00100000)
96 DEBUGADD(lvl,("0x00100000 "));
97 if (flags & 0x00200000)
98 DEBUGADD(lvl,("0x00200000 "));
99 if (flags & 0x00400000)
100 DEBUGADD(lvl,("0x00400000 "));
101 if (flags & 0x00800000)
102 DEBUGADD(lvl,("0x00800000 "));
103 if (flags & 0x01000000)
104 DEBUGADD(lvl,("0x01000000 "));
105 if (flags & 0x02000000)
106 DEBUGADD(lvl,("0x02000000 "));
107 if (flags & 0x04000000)
108 DEBUGADD(lvl,("0x04000000 "));
109 if (flags & 0x08000000)
110 DEBUGADD(lvl,("0x08000000 "));
111 if (flags & 0x10000000)
112 DEBUGADD(lvl,("0x10000000 "));
113 if (flags & 0x20000000)
114 DEBUGADD(lvl,("0x20000000 "));
115 if (flags & DS_RETURN_DNS_NAME)
116 DEBUGADD(lvl,("DS_RETURN_DNS_NAME "));
117 if (flags & DS_RETURN_FLAT_NAME)
118 DEBUGADD(lvl,("DS_RETURN_FLAT_NAME "));
120 DEBUGADD(lvl,("\n"));
123 /****************************************************************
124 ****************************************************************/
126 static char *dsgetdcname_cache_key(TALLOC_CTX *mem_ctx, const char *domain)
132 return talloc_asprintf_strupper_m(mem_ctx, "DSGETDCNAME/DOMAIN/%s",
136 /****************************************************************
137 ****************************************************************/
139 static NTSTATUS dsgetdcname_cache_delete(TALLOC_CTX *mem_ctx,
140 const char *domain_name)
144 key = dsgetdcname_cache_key(mem_ctx, domain_name);
146 return NT_STATUS_NO_MEMORY;
149 if (!gencache_del(key)) {
150 return NT_STATUS_UNSUCCESSFUL;
156 /****************************************************************
157 ****************************************************************/
159 static NTSTATUS dsgetdcname_cache_store(TALLOC_CTX *mem_ctx,
160 const char *domain_name,
167 key = dsgetdcname_cache_key(mem_ctx, domain_name);
169 return NT_STATUS_NO_MEMORY;
172 expire_time = time(NULL) + DSGETDCNAME_CACHE_TTL;
174 ret = gencache_set_data_blob(key, blob, expire_time);
176 return ret ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
179 /****************************************************************
180 ****************************************************************/
182 static NTSTATUS store_cldap_reply(TALLOC_CTX *mem_ctx,
184 struct sockaddr_storage *ss,
186 struct NETLOGON_SAM_LOGON_RESPONSE_EX *r)
189 enum ndr_err_code ndr_err;
191 char addr[INET6_ADDRSTRLEN];
193 print_sockaddr(addr, sizeof(addr), ss);
196 r->sockaddr_size = 0x10; /* the w32 winsock addr size */
197 r->sockaddr.sockaddr_family = 2; /* AF_INET */
198 r->sockaddr.pdc_ip = talloc_strdup(mem_ctx, addr);
200 ndr_err = ndr_push_struct_blob(&blob, mem_ctx, r,
201 (ndr_push_flags_fn_t)ndr_push_NETLOGON_SAM_LOGON_RESPONSE_EX);
202 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
203 return ndr_map_error2ntstatus(ndr_err);
206 if (r->domain_name) {
207 status = dsgetdcname_cache_store(mem_ctx, r->domain_name,
209 if (!NT_STATUS_IS_OK(status)) {
212 if (r->client_site) {
213 sitename_store(r->domain_name, r->client_site);
217 status = dsgetdcname_cache_store(mem_ctx, r->dns_domain, blob);
218 if (!NT_STATUS_IS_OK(status)) {
221 if (r->client_site) {
222 sitename_store(r->dns_domain, r->client_site);
226 status = NT_STATUS_OK;
229 data_blob_free(&blob);
234 /****************************************************************
235 ****************************************************************/
237 static uint32_t get_cldap_reply_server_flags(struct netlogon_samlogon_response *r,
240 switch (nt_version & 0x0000001f) {
250 return r->data.nt5.server_type;
255 return r->data.nt5_ex.server_type;
264 return r->data.nt5_ex.server_type;
274 return r->data.nt5_ex.server_type;
278 return r->data.nt5_ex.server_type;
284 /****************************************************************
285 ****************************************************************/
287 static NTSTATUS dsgetdcname_cache_fetch(TALLOC_CTX *mem_ctx,
288 const char *domain_name,
289 const struct GUID *domain_guid,
291 struct netr_DsRGetDCNameInfo **info_p)
295 enum ndr_err_code ndr_err;
296 struct netr_DsRGetDCNameInfo *info;
297 struct NETLOGON_SAM_LOGON_RESPONSE_EX r;
300 key = dsgetdcname_cache_key(mem_ctx, domain_name);
302 return NT_STATUS_NO_MEMORY;
305 if (!gencache_get_data_blob(key, NULL, &blob, NULL, NULL)) {
306 return NT_STATUS_NOT_FOUND;
309 info = talloc_zero(mem_ctx, struct netr_DsRGetDCNameInfo);
311 data_blob_free(&blob);
312 return NT_STATUS_NO_MEMORY;
315 ndr_err = ndr_pull_struct_blob(&blob, mem_ctx, &r,
316 (ndr_pull_flags_fn_t)ndr_pull_NETLOGON_SAM_LOGON_RESPONSE_EX);
318 data_blob_free(&blob);
319 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
320 dsgetdcname_cache_delete(mem_ctx, domain_name);
321 return ndr_map_error2ntstatus(ndr_err);
324 status = make_dc_info_from_cldap_reply(mem_ctx, flags, NULL,
326 if (!NT_STATUS_IS_OK(status)) {
330 if (DEBUGLEVEL >= 10) {
331 NDR_PRINT_DEBUG(netr_DsRGetDCNameInfo, info);
335 if (!check_cldap_reply_required_flags(info->dc_flags, flags)) {
336 DEBUG(10,("invalid flags\n"));
337 return NT_STATUS_INVALID_PARAMETER;
340 if ((flags & DS_IP_REQUIRED) &&
341 (info->dc_address_type != DS_ADDRESS_TYPE_INET)) {
342 return NT_STATUS_INVALID_PARAMETER_MIX;
350 /****************************************************************
351 ****************************************************************/
353 static NTSTATUS dsgetdcname_cached(TALLOC_CTX *mem_ctx,
354 struct messaging_context *msg_ctx,
355 const char *domain_name,
356 const struct GUID *domain_guid,
358 const char *site_name,
359 struct netr_DsRGetDCNameInfo **info)
363 status = dsgetdcname_cache_fetch(mem_ctx, domain_name, domain_guid,
365 if (!NT_STATUS_IS_OK(status)
366 && !NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
367 DEBUG(10,("dsgetdcname_cached: cache fetch failed with: %s\n",
369 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
372 if (flags & DS_BACKGROUND_ONLY) {
376 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
377 struct netr_DsRGetDCNameInfo *dc_info;
379 status = dsgetdcname(mem_ctx, msg_ctx, domain_name,
380 domain_guid, site_name,
381 flags | DS_FORCE_REDISCOVERY,
384 if (!NT_STATUS_IS_OK(status)) {
394 /****************************************************************
395 ****************************************************************/
397 static bool check_allowed_required_flags(uint32_t flags,
398 const char *site_name)
400 uint32_t return_type = flags & (DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME);
401 uint32_t offered_type = flags & (DS_IS_FLAT_NAME|DS_IS_DNS_NAME);
402 uint32_t query_type = flags & (DS_BACKGROUND_ONLY|DS_FORCE_REDISCOVERY);
404 /* FIXME: check for DSGETDC_VALID_FLAGS and check for excluse bits
405 * (DS_PDC_REQUIRED, DS_KDC_REQUIRED, DS_GC_SERVER_REQUIRED) */
407 debug_dsdcinfo_flags(10, flags);
409 if ((flags & DS_TRY_NEXTCLOSEST_SITE) && site_name) {
413 if (return_type == (DS_RETURN_FLAT_NAME|DS_RETURN_DNS_NAME)) {
417 if (offered_type == (DS_IS_DNS_NAME|DS_IS_FLAT_NAME)) {
421 if (query_type == (DS_BACKGROUND_ONLY|DS_FORCE_REDISCOVERY)) {
426 if ((flags & DS_RETURN_DNS_NAME) && (!(flags & DS_IP_REQUIRED))) {
427 printf("gd: here5 \n");
434 /****************************************************************
435 ****************************************************************/
437 static NTSTATUS discover_dc_netbios(TALLOC_CTX *mem_ctx,
438 const char *domain_name,
440 struct ip_service_name **returned_dclist,
444 enum nbt_name_type name_type = NBT_NAME_LOGON;
445 struct ip_service *iplist;
447 struct ip_service_name *dclist = NULL;
449 static const char *resolve_order[] = { "lmhosts", "wins", "bcast", NULL };
451 *returned_dclist = NULL;
454 if (flags & DS_PDC_REQUIRED) {
455 name_type = NBT_NAME_PDC;
458 status = internal_resolve_name(domain_name, name_type, NULL,
461 if (!NT_STATUS_IS_OK(status)) {
462 DEBUG(10,("discover_dc_netbios: failed to find DC\n"));
466 dclist = talloc_zero_array(mem_ctx, struct ip_service_name, count);
469 return NT_STATUS_NO_MEMORY;
472 for (i=0; i<count; i++) {
474 char addr[INET6_ADDRSTRLEN];
475 struct ip_service_name *r = &dclist[i];
477 print_sockaddr(addr, sizeof(addr),
480 r->ss = iplist[i].ss;
481 r->hostname = talloc_strdup(mem_ctx, addr);
484 return NT_STATUS_NO_MEMORY;
489 *returned_dclist = dclist;
490 *returned_count = count;
496 /****************************************************************
497 ****************************************************************/
499 static NTSTATUS discover_dc_dns(TALLOC_CTX *mem_ctx,
500 const char *domain_name,
501 const struct GUID *domain_guid,
503 const char *site_name,
504 struct ip_service_name **returned_dclist,
510 struct dns_rr_srv *dcs = NULL;
513 struct ip_service_name *dclist = NULL;
516 if (flags & DS_PDC_REQUIRED) {
517 status = ads_dns_query_pdc(mem_ctx,
521 } else if (flags & DS_GC_SERVER_REQUIRED) {
522 status = ads_dns_query_gcs(mem_ctx,
527 } else if (flags & DS_KDC_REQUIRED) {
528 status = ads_dns_query_kdcs(mem_ctx,
533 } else if (flags & DS_DIRECTORY_SERVICE_REQUIRED) {
534 status = ads_dns_query_dcs(mem_ctx,
539 } else if (domain_guid) {
540 struct GUID_txt_buf buf;
541 GUID_buf_string(domain_guid, &buf);
543 status = ads_dns_query_dcs_guid(mem_ctx,
549 status = ads_dns_query_dcs(mem_ctx,
556 if (!NT_STATUS_IS_OK(status)) {
561 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
564 for (i=0;i<numdcs;i++) {
565 numaddrs += MAX(dcs[i].num_ips,1);
568 dclist = talloc_zero_array(mem_ctx,
569 struct ip_service_name,
572 return NT_STATUS_NO_MEMORY;
575 /* now unroll the list of IP addresses */
581 while ((i < numdcs) && (count < numaddrs)) {
583 struct ip_service_name *r = &dclist[count];
585 r->hostname = dcs[i].hostname;
587 /* If we don't have an IP list for a name, lookup it up */
590 interpret_string_addr_prefer_ipv4(&r->ss,
595 /* use the IP addresses from the SRV response */
597 if (j >= dcs[i].num_ips) {
603 r->ss = dcs[i].ss_s[j];
607 /* make sure it is a valid IP. I considered checking the
608 * negative connection cache, but this is the wrong place for
609 * it. Maybe only as a hack. After think about it, if all of
610 * the IP addresses returned from DNS are dead, what hope does a
611 * netbios name lookup have? The standard reason for falling
612 * back to netbios lookups is that our DNS server doesn't know
613 * anything about the DC's -- jerry */
615 if (!is_zero_addr(&r->ss)) {
621 *returned_dclist = dclist;
622 *return_count = count;
628 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
631 /****************************************************************
632 ****************************************************************/
634 static NTSTATUS make_domain_controller_info(TALLOC_CTX *mem_ctx,
636 const char *dc_address,
637 uint32_t dc_address_type,
638 const struct GUID *domain_guid,
639 const char *domain_name,
640 const char *forest_name,
642 const char *dc_site_name,
643 const char *client_site_name,
644 struct netr_DsRGetDCNameInfo **info_out)
646 struct netr_DsRGetDCNameInfo *info;
648 info = talloc_zero(mem_ctx, struct netr_DsRGetDCNameInfo);
649 NT_STATUS_HAVE_NO_MEMORY(info);
652 info->dc_unc = talloc_strdup(mem_ctx, dc_unc);
653 NT_STATUS_HAVE_NO_MEMORY(info->dc_unc);
657 if (!(dc_address[0] == '\\' && dc_address[1] == '\\')) {
658 info->dc_address = talloc_asprintf(mem_ctx, "\\\\%s",
661 info->dc_address = talloc_strdup(mem_ctx, dc_address);
663 NT_STATUS_HAVE_NO_MEMORY(info->dc_address);
666 info->dc_address_type = dc_address_type;
669 info->domain_guid = *domain_guid;
673 info->domain_name = talloc_strdup(mem_ctx, domain_name);
674 NT_STATUS_HAVE_NO_MEMORY(info->domain_name);
677 if (forest_name && *forest_name) {
678 info->forest_name = talloc_strdup(mem_ctx, forest_name);
679 NT_STATUS_HAVE_NO_MEMORY(info->forest_name);
680 flags |= DS_DNS_FOREST_ROOT;
683 info->dc_flags = flags;
686 info->dc_site_name = talloc_strdup(mem_ctx, dc_site_name);
687 NT_STATUS_HAVE_NO_MEMORY(info->dc_site_name);
690 if (client_site_name) {
691 info->client_site_name = talloc_strdup(mem_ctx,
693 NT_STATUS_HAVE_NO_MEMORY(info->client_site_name);
701 /****************************************************************
702 ****************************************************************/
704 static void map_dc_and_domain_names(uint32_t flags,
706 const char *domain_name,
707 const char *dns_dc_name,
708 const char *dns_domain_name,
710 const char **hostname_p,
711 const char **domain_p)
713 switch (flags & 0xf0000000) {
714 case DS_RETURN_FLAT_NAME:
715 if (dc_name && domain_name &&
716 *dc_name && *domain_name) {
717 *hostname_p = dc_name;
718 *domain_p = domain_name;
723 case DS_RETURN_DNS_NAME:
725 if (dns_dc_name && dns_domain_name &&
726 *dns_dc_name && *dns_domain_name) {
727 *hostname_p = dns_dc_name;
728 *domain_p = dns_domain_name;
729 *dc_flags |= DS_DNS_DOMAIN | DS_DNS_CONTROLLER;
732 if (dc_name && domain_name &&
733 *dc_name && *domain_name) {
734 *hostname_p = dc_name;
735 *domain_p = domain_name;
741 /****************************************************************
742 ****************************************************************/
744 static NTSTATUS make_dc_info_from_cldap_reply(
747 const struct sockaddr_storage *ss,
748 struct NETLOGON_SAM_LOGON_RESPONSE_EX *r,
749 struct netr_DsRGetDCNameInfo **info)
751 const char *dc_hostname = NULL;
752 const char *dc_domain_name = NULL;
753 const char *dc_address = NULL;
754 const char *dc_forest = NULL;
755 uint32_t dc_address_type = 0;
756 uint32_t dc_flags = 0;
757 struct GUID *dc_domain_guid = NULL;
758 const char *dc_server_site = NULL;
759 const char *dc_client_site = NULL;
761 char addr[INET6_ADDRSTRLEN];
764 print_sockaddr(addr, sizeof(addr), ss);
766 dc_address_type = DS_ADDRESS_TYPE_INET;
768 if (r->sockaddr.pdc_ip) {
769 dc_address = r->sockaddr.pdc_ip;
770 dc_address_type = DS_ADDRESS_TYPE_INET;
772 dc_address = r->pdc_name;
773 dc_address_type = DS_ADDRESS_TYPE_NETBIOS;
777 map_dc_and_domain_names(flags,
786 dc_flags |= r->server_type;
787 dc_forest = r->forest;
788 dc_domain_guid = &r->domain_uuid;
789 dc_server_site = r->server_site;
790 dc_client_site = r->client_site;
792 return make_domain_controller_info(mem_ctx,
805 /****************************************************************
806 ****************************************************************/
808 static uint32_t map_ds_flags_to_nt_version(uint32_t flags)
810 uint32_t nt_version = 0;
812 if (flags & DS_PDC_REQUIRED) {
813 nt_version |= NETLOGON_NT_VERSION_PDC;
816 if (flags & DS_GC_SERVER_REQUIRED) {
817 nt_version |= NETLOGON_NT_VERSION_GC;
820 if (flags & DS_TRY_NEXTCLOSEST_SITE) {
821 nt_version |= NETLOGON_NT_VERSION_WITH_CLOSEST_SITE;
824 if (flags & DS_IP_REQUIRED) {
825 nt_version |= NETLOGON_NT_VERSION_IP;
831 /****************************************************************
832 ****************************************************************/
834 static NTSTATUS process_dc_dns(TALLOC_CTX *mem_ctx,
835 const char *domain_name,
837 struct ip_service_name *dclist,
839 struct netr_DsRGetDCNameInfo **info)
842 bool valid_dc = false;
843 struct netlogon_samlogon_response *r = NULL;
844 uint32_t nt_version = NETLOGON_NT_VERSION_5 |
845 NETLOGON_NT_VERSION_5EX;
846 uint32_t ret_flags = 0;
849 nt_version |= map_ds_flags_to_nt_version(flags);
851 for (i=0; i<num_dcs; i++) {
853 char addr[INET6_ADDRSTRLEN];
854 print_sockaddr(addr, sizeof(addr), &dclist[i].ss);
856 DEBUG(10,("LDAP ping to %s (%s)\n", dclist[i].hostname, addr));
858 if (ads_cldap_netlogon(mem_ctx, &dclist[i].ss,
863 nt_version = r->ntver;
864 ret_flags = get_cldap_reply_server_flags(r, nt_version);
866 if (check_cldap_reply_required_flags(ret_flags, flags)) {
876 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
879 status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
880 &r->data.nt5_ex, info);
881 if (NT_STATUS_IS_OK(status)) {
882 return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
883 nt_version, &r->data.nt5_ex);
889 /****************************************************************
890 ****************************************************************/
892 /****************************************************************
893 ****************************************************************/
895 static NTSTATUS process_dc_netbios(TALLOC_CTX *mem_ctx,
896 struct messaging_context *msg_ctx,
897 const char *domain_name,
899 struct ip_service_name *dclist,
901 struct netr_DsRGetDCNameInfo **info)
903 struct sockaddr_storage ss;
904 struct ip_service ip_list;
905 enum nbt_name_type name_type = NBT_NAME_LOGON;
908 const char *dc_name = NULL;
910 struct netlogon_samlogon_response *r = NULL;
911 bool store_cache = false;
912 uint32_t nt_version = NETLOGON_NT_VERSION_1 |
913 NETLOGON_NT_VERSION_5 |
914 NETLOGON_NT_VERSION_5EX_WITH_IP;
915 size_t len = strlen(lp_netbios_name());
916 char my_acct_name[len+2];
918 if (msg_ctx == NULL) {
919 return NT_STATUS_INVALID_PARAMETER;
922 if (flags & DS_PDC_REQUIRED) {
923 name_type = NBT_NAME_PDC;
926 nt_version |= map_ds_flags_to_nt_version(flags);
928 snprintf(my_acct_name,
929 sizeof(my_acct_name),
933 DEBUG(10,("process_dc_netbios\n"));
935 for (i=0; i<num_dcs; i++) {
938 generate_random_buffer((uint8_t *)&val, 2);
940 ip_list.ss = dclist[i].ss;
943 if (!interpret_string_addr_prefer_ipv4(&ss, dclist[i].hostname, AI_NUMERICHOST)) {
944 return NT_STATUS_UNSUCCESSFUL;
947 status = nbt_getdc(msg_ctx, 10, &dclist[i].ss, domain_name,
948 NULL, my_acct_name, ACB_WSTRUST, nt_version,
949 mem_ctx, &nt_version, &dc_name, &r);
950 if (NT_STATUS_IS_OK(status)) {
952 namecache_store(dc_name, NBT_NAME_SERVER, 1, &ip_list);
956 if (name_status_find(domain_name,
962 struct NETLOGON_SAM_LOGON_RESPONSE_NT40 logon1;
964 r = talloc_zero(mem_ctx, struct netlogon_samlogon_response);
965 NT_STATUS_HAVE_NO_MEMORY(r);
969 nt_version = NETLOGON_NT_VERSION_1;
971 logon1.nt_version = nt_version;
972 logon1.pdc_name = tmp_dc_name;
973 logon1.domain_name = talloc_strdup_upper(mem_ctx, domain_name);
974 NT_STATUS_HAVE_NO_MEMORY(logon1.domain_name);
976 r->data.nt4 = logon1;
977 r->ntver = nt_version;
979 map_netlogon_samlogon_response(r);
981 namecache_store(tmp_dc_name, NBT_NAME_SERVER, 1, &ip_list);
987 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
991 status = make_dc_info_from_cldap_reply(mem_ctx, flags, &dclist[i].ss,
992 &r->data.nt5_ex, info);
993 if (NT_STATUS_IS_OK(status) && store_cache) {
994 return store_cldap_reply(mem_ctx, flags, &dclist[i].ss,
995 nt_version, &r->data.nt5_ex);
1001 /****************************************************************
1002 ****************************************************************/
1004 static NTSTATUS dsgetdcname_rediscover(TALLOC_CTX *mem_ctx,
1005 struct messaging_context *msg_ctx,
1006 const char *domain_name,
1007 const struct GUID *domain_guid,
1009 const char *site_name,
1010 struct netr_DsRGetDCNameInfo **info)
1013 struct ip_service_name *dclist = NULL;
1016 DEBUG(10,("dsgetdcname_rediscover\n"));
1018 if (flags & DS_IS_FLAT_NAME) {
1020 if (lp_disable_netbios()) {
1021 return NT_STATUS_NOT_SUPPORTED;
1024 status = discover_dc_netbios(mem_ctx, domain_name, flags,
1026 NT_STATUS_NOT_OK_RETURN(status);
1028 return process_dc_netbios(mem_ctx, msg_ctx, domain_name, flags,
1029 dclist, num_dcs, info);
1032 if (flags & DS_IS_DNS_NAME) {
1034 status = discover_dc_dns(mem_ctx, domain_name, domain_guid,
1035 flags, site_name, &dclist, &num_dcs);
1036 NT_STATUS_NOT_OK_RETURN(status);
1038 return process_dc_dns(mem_ctx, domain_name, flags,
1039 dclist, num_dcs, info);
1042 status = discover_dc_dns(mem_ctx, domain_name, domain_guid, flags,
1043 site_name, &dclist, &num_dcs);
1045 if (NT_STATUS_IS_OK(status) && num_dcs != 0) {
1047 status = process_dc_dns(mem_ctx, domain_name, flags, dclist,
1049 if (NT_STATUS_IS_OK(status)) {
1054 if (lp_disable_netbios()) {
1055 return NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND;
1058 status = discover_dc_netbios(mem_ctx, domain_name, flags, &dclist,
1060 NT_STATUS_NOT_OK_RETURN(status);
1062 return process_dc_netbios(mem_ctx, msg_ctx, domain_name, flags, dclist,
1066 static bool is_closest_site(struct netr_DsRGetDCNameInfo *info)
1068 if (info->dc_flags & DS_SERVER_CLOSEST) {
1072 if (!info->client_site_name) {
1076 if (!info->dc_site_name) {
1080 if (strcmp(info->client_site_name, info->dc_site_name) == 0) {
1087 /********************************************************************
1088 Internal dsgetdcname.
1089 ********************************************************************/
1091 static NTSTATUS dsgetdcname_internal(TALLOC_CTX *mem_ctx,
1092 struct messaging_context *msg_ctx,
1093 const char *domain_name,
1094 const struct GUID *domain_guid,
1095 const char *site_name,
1097 struct netr_DsRGetDCNameInfo **info)
1100 struct netr_DsRGetDCNameInfo *myinfo = NULL;
1102 struct netr_DsRGetDCNameInfo *first_info = NULL;
1104 DEBUG(10,("dsgetdcname_internal: domain_name: %s, "
1105 "domain_guid: %s, site_name: %s, flags: 0x%08x\n",
1107 domain_guid ? GUID_string(mem_ctx, domain_guid) : "(null)",
1108 site_name ? site_name : "(null)", flags));
1112 if (!check_allowed_required_flags(flags, site_name)) {
1113 DEBUG(0,("invalid flags specified\n"));
1114 return NT_STATUS_INVALID_PARAMETER;
1117 if (flags & DS_FORCE_REDISCOVERY) {
1121 status = dsgetdcname_cached(mem_ctx, msg_ctx, domain_name, domain_guid,
1122 flags, site_name, &myinfo);
1123 if (NT_STATUS_IS_OK(status)) {
1127 if (flags & DS_BACKGROUND_ONLY) {
1132 status = dsgetdcname_rediscover(mem_ctx, msg_ctx, domain_name,
1133 domain_guid, flags, site_name,
1137 if (!NT_STATUS_IS_OK(status)) {
1140 return NT_STATUS_OK;
1146 TALLOC_FREE(first_info);
1147 } else if (!is_closest_site(myinfo)) {
1149 first_info = myinfo;
1150 /* TODO: may use the next_closest_site here */
1151 site_name = myinfo->client_site_name;
1156 return NT_STATUS_OK;
1159 /********************************************************************
1162 This will be the only public function here.
1163 ********************************************************************/
1165 NTSTATUS dsgetdcname(TALLOC_CTX *mem_ctx,
1166 struct messaging_context *msg_ctx,
1167 const char *domain_name,
1168 const struct GUID *domain_guid,
1169 const char *site_name,
1171 struct netr_DsRGetDCNameInfo **info)
1174 const char *query_site = NULL;
1175 char *ptr_to_free = NULL;
1176 bool retry_query_with_null = false;
1178 if ((site_name == NULL) || (site_name[0] == '\0')) {
1179 ptr_to_free = sitename_fetch(mem_ctx, domain_name);
1180 if (ptr_to_free != NULL) {
1181 retry_query_with_null = true;
1183 query_site = ptr_to_free;
1185 query_site = site_name;
1188 status = dsgetdcname_internal(mem_ctx,
1196 TALLOC_FREE(ptr_to_free);
1198 if (!NT_STATUS_EQUAL(status, NT_STATUS_DOMAIN_CONTROLLER_NOT_FOUND)) {
1202 /* Should we try again with site_name == NULL ? */
1203 if (retry_query_with_null) {
1204 status = dsgetdcname_internal(mem_ctx,