source: branches/samba-3.2.x/source/libsmb/dsgetdcname.c@ 285

Last change on this file since 285 was 233, checked in by Herwig Bauernfeind, 16 years ago

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