?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3-selftest: introduce registry upgrade test
[Samba/bjacke.git] / dfs_server / dfs_server_ad.c
blob22d3263b03b5b4ed10e77581094b87b00c72e5cf
1 /*
2 Unix SMB/CIFS implementation.
3
4 Copyright Matthieu Patou <mat@matws.net> 2010-2011
5 Copyright Stefan Metzmacher 2011
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21 #include "includes.h"
22 #include "librpc/gen_ndr/dfsblobs.h"
23 #include "librpc/gen_ndr/ndr_dfsblobs.h"
24 #include "dsdb/samdb/samdb.h"
25 #include "auth/session.h"
26 #include "param/param.h"
27 #include "lib/tsocket/tsocket.h"
28 #include "dfs_server/dfs_server_ad.h"
29
30 #define MAX_DFS_RESPONSE 56*1024 /* 56 Kb */
31
32 /* A DC set is a group of DC, they might have been grouped together
33 because they belong to the same site, or to site with same cost ...
34 */
35 struct dc_set {
36 const char **names;
37 uint32_t count;
38 };
39
40 /*
41 fill a referral type structure
42 */
43 static NTSTATUS fill_normal_dfs_referraltype(TALLOC_CTX *mem_ctx,
44 struct dfs_referral_type *ref,
45 uint16_t version,
46 const char *dfs_path,
47 const char *server_path, int isfirstoffset)
48 {
49 ZERO_STRUCTP(ref);
50 switch (version) {
51 case 4:
52 version = 3;
53 # if 0
54 /* For the moment there is a bug with XP that don't seems to appriciate much
55 * level4 so we return just level 3 for everyone
56 */
57 ref->referral.v4.server_type = DFS_SERVER_NON_ROOT;
58 /* "normal" referral seems to always include the GUID */
59 ref->referral.v4.size = 34;
60
61 if (isfirstoffset) {
62 ref->referral.v4.entry_flags = DFS_HEADER_FLAG_TARGET_BCK;
63 }
64 ref->referral.v4.ttl = 900; /* As w2k8r2 */
65 ref->referral.v4.referrals.r1.DFS_path = talloc_strdup(mem_ctx, dfs_path);
66 if (ref->referral.v4.referrals.r1.DFS_path == NULL) {
67 return NT_STATUS_NO_MEMORY;
68 }
69 ref->referral.v4.referrals.r1.DFS_alt_path = talloc_strdup(mem_ctx, dfs_path);
70 if (ref->referral.v4.referrals.r1.DFS_alt_path == NULL) {
71 return NT_STATUS_NO_MEMORY;
72 }
73 ref->referral.v4.referrals.r1.netw_address = talloc_strdup(mem_ctx, server_path);
74 if (ref->referral.v4.referrals.r1.netw_address == NULL) {
75 return NT_STATUS_NO_MEMORY;
76 }
77 return NT_STATUS_OK;
78 #endif
79 case 3:
80 ref->version = version;
81 ref->referral.v3.server_type = DFS_SERVER_NON_ROOT;
82 /* "normal" referral seems to always include the GUID */
83 ref->referral.v3.size = 34;
84
85 ref->referral.v3.entry_flags = 0;
86 ref->referral.v3.ttl = 600; /* As w2k3 */
87 ref->referral.v3.referrals.r1.DFS_path = talloc_strdup(mem_ctx, dfs_path);
88 if (ref->referral.v3.referrals.r1.DFS_path == NULL) {
89 return NT_STATUS_NO_MEMORY;
90 }
91 ref->referral.v3.referrals.r1.DFS_alt_path = talloc_strdup(mem_ctx, dfs_path);
92 if (ref->referral.v3.referrals.r1.DFS_alt_path == NULL) {
93 return NT_STATUS_NO_MEMORY;
94 }
95 ref->referral.v3.referrals.r1.netw_address = talloc_strdup(mem_ctx, server_path);
96 if (ref->referral.v3.referrals.r1.netw_address == NULL) {
97 return NT_STATUS_NO_MEMORY;
98 }
99 return NT_STATUS_OK;
100 }
101 return NT_STATUS_INVALID_LEVEL;
102 }
103
104 /*
105 fill a domain refererral
106 */
107 static NTSTATUS fill_domain_dfs_referraltype(TALLOC_CTX *mem_ctx,
108 struct dfs_referral_type *ref,
109 uint16_t version,
110 const char *domain,
111 const char **names,
112 uint16_t numnames)
113 {
114 switch (version) {
115 case 3:
116 ZERO_STRUCTP(ref);
117 DEBUG(8, ("Called fill_domain_dfs_referraltype\n"));
118 ref->version = version;
119 ref->referral.v3.server_type = DFS_SERVER_NON_ROOT;
120 /*
121 * It's hard coded ... don't think it's a good way but the
122 * sizeof return not the correct values
123 *
124 * We have 18 if the GUID is not included 34 otherwise
125 */
126 if (numnames == 0) {
127 /* Windows return without the guid when returning domain list
128 */
129 ref->referral.v3.size = 18;
130 } else {
131 ref->referral.v3.size = 34;
132 }
133 ref->referral.v3.entry_flags = DFS_FLAG_REFERRAL_DOMAIN_RESP;
134 ref->referral.v3.ttl = 600; /* As w2k3 */
135 ref->referral.v3.referrals.r2.special_name = talloc_strdup(mem_ctx,
136 domain);
137 if (ref->referral.v3.referrals.r2.special_name == NULL) {
138 return NT_STATUS_NO_MEMORY;
139 }
140 ref->referral.v3.referrals.r2.nb_expanded_names = numnames;
141 /* Put the final terminator */
142 if (names) {
143 int i;
144 const char **names2 = talloc_array(mem_ctx, const char *,
145 numnames+1);
146 NT_STATUS_HAVE_NO_MEMORY(names2);
147 for (i = 0; i<numnames; i++) {
148 names2[i] = talloc_asprintf(names2, "\\%s", names[i]);
149 NT_STATUS_HAVE_NO_MEMORY(names2[i]);
150 }
151 names2[numnames] = NULL;
152 ref->referral.v3.referrals.r2.expanded_names = names2;
153 }
154 return NT_STATUS_OK;
155 }
156 return NT_STATUS_INVALID_LEVEL;
157 }
158
159 /*
160 get the DCs list within a site
161 */
162 static NTSTATUS get_dcs_insite(TALLOC_CTX *ctx, struct ldb_context *ldb,
163 struct ldb_dn *sitedn, struct dc_set *list,
164 bool dofqdn)
165 {
166 static const char *attrs[] = { "serverReference", NULL };
167 static const char *attrs2[] = { "dNSHostName", "sAMAccountName", NULL };
168 struct ldb_result *r;
169 unsigned int i;
170 int ret;
171 const char **dc_list;
172
173 ret = ldb_search(ldb, ctx, &r, sitedn, LDB_SCOPE_SUBTREE, attrs,
174 "(&(objectClass=server)(serverReference=*))");
175 if (ret != LDB_SUCCESS) {
176 DEBUG(2,(__location__ ": Failed to get list of servers - %s\n",
177 ldb_errstring(ldb)));
178 return NT_STATUS_INTERNAL_ERROR;
179 }
180
181 if (r->count == 0) {
182 /* none in this site */
183 talloc_free(r);
184 return NT_STATUS_OK;
185 }
186
187 /*
188 * need to search for all server object to know the size of the array.
189 * Search all the object of class server in this site
190 */
191 dc_list = talloc_array(r, const char *, r->count);
192 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(dc_list, r);
193
194 /* TODO put some random here in the order */
195 list->names = talloc_realloc(list, list->names, const char *, list->count + r->count);
196 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(list->names, r);
197
198 for (i = 0; i<r->count; i++) {
199 struct ldb_dn *dn;
200 struct ldb_result *r2;
201
202 dn = ldb_msg_find_attr_as_dn(ldb, ctx, r->msgs[i], "serverReference");
203 if (!dn) {
204 return NT_STATUS_INTERNAL_ERROR;
205 }
206
207 ret = ldb_search(ldb, r, &r2, dn, LDB_SCOPE_BASE, attrs2, "(objectClass=computer)");
208 if (ret != LDB_SUCCESS) {
209 DEBUG(2,(__location__ ": Search for computer on %s failed - %s\n",
210 ldb_dn_get_linearized(dn), ldb_errstring(ldb)));
211 return NT_STATUS_INTERNAL_ERROR;
212 }
213
214 if (dofqdn) {
215 const char *dns = ldb_msg_find_attr_as_string(r2->msgs[0], "dNSHostName", NULL);
216 if (dns == NULL) {
217 DEBUG(2,(__location__ ": dNSHostName missing on %s\n",
218 ldb_dn_get_linearized(dn)));
219 talloc_free(r);
220 return NT_STATUS_INTERNAL_ERROR;
221 }
222
223 list->names[list->count] = talloc_strdup(list->names, dns);
224 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(list->names[list->count], r);
225 } else {
226 char *tmp;
227 const char *acct = ldb_msg_find_attr_as_string(r2->msgs[0], "sAMAccountName", NULL);
228 if (acct == NULL) {
229 DEBUG(2,(__location__ ": sAMAccountName missing on %s\n",
230 ldb_dn_get_linearized(dn)));
231 talloc_free(r);
232 return NT_STATUS_INTERNAL_ERROR;
233 }
234
235 tmp = talloc_strdup(list->names, acct);
236 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(tmp, r);
237
238 /* Netbios name is also the sAMAccountName for
239 computer but without the final $ */
240 tmp[strlen(tmp) - 1] = '\0';
241 list->names[list->count] = tmp;
242 }
243 list->count++;
244 talloc_free(r2);
245 }
246
247 talloc_free(r);
248 return NT_STATUS_OK;
249 }
250
251
252 /*
253 get all DCs
254 */
255 static NTSTATUS get_dcs(TALLOC_CTX *ctx, struct ldb_context *ldb,
256 const char *searched_site, bool need_fqdn,
257 struct dc_set ***pset_list, uint32_t flags)
258 {
259 /*
260 * Flags will be used later to indicate things like least-expensive
261 * or same-site options
262 */
263 const char *attrs_none[] = { NULL };
264 const char *attrs3[] = { "name", NULL };
265 struct ldb_dn *configdn, *sitedn, *dn, *sitescontainerdn;
266 struct ldb_result *r;
267 struct dc_set **set_list = NULL;
268 uint32_t i;
269 int ret;
270 uint32_t current_pos = 0;
271 NTSTATUS status;
272 TALLOC_CTX *subctx = talloc_new(ctx);
273
274 *pset_list = set_list = NULL;
275
276 subctx = talloc_new(ctx);
277 NT_STATUS_HAVE_NO_MEMORY(subctx);
278
279 configdn = ldb_get_config_basedn(ldb);
280
281 /* Let's search for the Site container */
282 ret = ldb_search(ldb, subctx, &r, configdn, LDB_SCOPE_SUBTREE, attrs_none,
283 "(objectClass=sitesContainer)");
284 if (ret != LDB_SUCCESS) {
285 DEBUG(2,(__location__ ": Failed to find sitesContainer within %s - %s\n",
286 ldb_dn_get_linearized(configdn), ldb_errstring(ldb)));
287 talloc_free(subctx);
288 return NT_STATUS_INTERNAL_ERROR;
289 }
290 if (r->count > 1) {
291 DEBUG(2,(__location__ ": Expected 1 sitesContainer - found %u within %s\n",
292 r->count, ldb_dn_get_linearized(configdn)));
293 talloc_free(subctx);
294 return NT_STATUS_INTERNAL_ERROR;
295 }
296
297 sitescontainerdn = talloc_steal(subctx, r->msgs[0]->dn);
298 talloc_free(r);
299
300 /*
301 * TODO: Here we should have a more subtle handling
302 * for the case "same-site"
303 */
304 ret = ldb_search(ldb, subctx, &r, sitescontainerdn, LDB_SCOPE_SUBTREE,
305 attrs_none, "(objectClass=server)");
306 if (ret != LDB_SUCCESS) {
307 DEBUG(2,(__location__ ": Failed to find servers within %s - %s\n",
308 ldb_dn_get_linearized(sitescontainerdn), ldb_errstring(ldb)));
309 talloc_free(subctx);
310 return NT_STATUS_INTERNAL_ERROR;
311 }
312 talloc_free(r);
313
314 if (searched_site != NULL && searched_site[0] != '\0') {
315 ret = ldb_search(ldb, subctx, &r, configdn, LDB_SCOPE_SUBTREE,
316 attrs_none, "(&(name=%s)(objectClass=site))", searched_site);
317 if (ret != LDB_SUCCESS) {
318 talloc_free(subctx);
319 return NT_STATUS_FOOBAR;
320 } else if (r->count != 1) {
321 talloc_free(subctx);
322 return NT_STATUS_FOOBAR;
323 }
324
325 /* All of this was to get the DN of the searched_site */
326 sitedn = r->msgs[0]->dn;
327
328 set_list = talloc_realloc(subctx, set_list, struct dc_set *, current_pos+1);
329 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(set_list, subctx);
330
331 set_list[current_pos] = talloc(set_list, struct dc_set);
332 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(set_list[current_pos], subctx);
333
334 set_list[current_pos]->names = NULL;
335 set_list[current_pos]->count = 0;
336 status = get_dcs_insite(subctx, ldb, sitedn,
337 set_list[current_pos], need_fqdn);
338 if (!NT_STATUS_IS_OK(status)) {
339 DEBUG(2,(__location__ ": Failed to get DC from site %s - %s\n",
340 ldb_dn_get_linearized(sitedn), nt_errstr(status)));
341 talloc_free(subctx);
342 return status;
343 }
344 talloc_free(r);
345 current_pos++;
346 }
347
348 /* Let's find all the sites */
349 ret = ldb_search(ldb, subctx, &r, configdn, LDB_SCOPE_SUBTREE, attrs3, "(objectClass=site)");
350 if (ret != LDB_SUCCESS) {
351 DEBUG(2,(__location__ ": Failed to find any site containers in %s\n",
352 ldb_dn_get_linearized(configdn)));
353 talloc_free(subctx);
354 return NT_STATUS_INTERNAL_DB_CORRUPTION;
355 }
356
357 /*
358 * TODO:
359 * We should randomize the order in the main site,
360 * it's mostly needed for sysvol/netlogon referral.
361 * Depending of flag we either randomize order of the
362 * not "in the same site DCs"
363 * or we randomize by group of site that have the same cost
364 * In the long run we want to manipulate an array of site_set
365 * All the site in one set have the same cost (if least-expansive options is selected)
366 * and we will put all the dc related to 1 site set into 1 DCs set.
367 * Within a site set, site order has to be randomized
368 *
369 * But for the moment we just return the list of sites
370 */
371 if (r->count) {
372 /*
373 * We will realloc + 2 because we will need one additional place
374 * for element at current_pos + 1 for the NULL element
375 */
376 set_list = talloc_realloc(subctx, set_list, struct dc_set *,
377 current_pos+2);
378 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(set_list, subctx);
379
380 set_list[current_pos] = talloc(ctx, struct dc_set);
381 NT_STATUS_HAVE_NO_MEMORY_AND_FREE(set_list[current_pos], subctx);
382
383 set_list[current_pos]->names = NULL;
384 set_list[current_pos]->count = 0;
385
386 set_list[current_pos+1] = NULL;
387 }
388
389 for (i=0; i<r->count; i++) {
390 const char *site_name = ldb_msg_find_attr_as_string(r->msgs[i], "name", NULL);
391 if (site_name == NULL) {
392 DEBUG(2,(__location__ ": Failed to find name attribute in %s\n",
393 ldb_dn_get_linearized(r->msgs[i]->dn)));
394 talloc_free(subctx);
395 return NT_STATUS_INTERNAL_DB_CORRUPTION;
396 }
397
398 if (searched_site == NULL ||
399 strcmp(searched_site, site_name) != 0) {
400 DEBUG(2,(__location__ ": Site: %s %s\n",
401 searched_site, site_name));
402
403 /*
404 * Do all the site but the one of the client
405 * (because it has already been done ...)
406 */
407 dn = r->msgs[i]->dn;
408
409 status = get_dcs_insite(subctx, ldb, dn,
410 set_list[current_pos],
411 need_fqdn);
412 if (!NT_STATUS_IS_OK(status)) {
413 talloc_free(subctx);
414 return status;
415 }
416 }
417 }
418 current_pos++;
419 set_list[current_pos] = NULL;
420
421 *pset_list = talloc_move(ctx, &set_list);
422 talloc_free(subctx);
423 return NT_STATUS_OK;
424 }
425
426 static NTSTATUS dodomain_referral(struct loadparm_context *lp_ctx,
427 struct ldb_context *sam_ctx,
428 const struct tsocket_address *client,
429 struct dfs_GetDFSReferral *r)
430 {
431 /*
432 * TODO for the moment we just return the local domain
433 */
434 NTSTATUS status;
435 const char *dns_domain = lpcfg_dnsdomain(lp_ctx);
436 const char *netbios_domain = lpcfg_workgroup(lp_ctx);
437 struct dfs_referral_type *referrals;
438 const char *referral_str;
439 /* In the future this needs to be fetched from the ldb */
440 uint32_t found_domain = 2;
441
442 if (lpcfg_server_role(lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
443 DEBUG(10 ,("Received a domain referral request on a non DC\n"));
444 return NT_STATUS_INVALID_PARAMETER;
445 }
446
447 if (r->in.req.max_referral_level < 3) {
448 DEBUG(2,("invalid max_referral_level %u\n",
449 r->in.req.max_referral_level));
450 return NT_STATUS_UNSUCCESSFUL;
451 }
452
453 r->out.resp = talloc_zero(r, struct dfs_referral_resp);
454 if (r->out.resp == NULL) {
455 return NT_STATUS_NO_MEMORY;
456 }
457
458 r->out.resp->path_consumed = 0;
459 r->out.resp->header_flags = 0; /* Do like w2k3 */
460 r->out.resp->nb_referrals = found_domain; /* the fqdn one + the NT domain */
461
462 referrals = talloc_zero_array(r->out.resp,
463 struct dfs_referral_type,
464 r->out.resp->nb_referrals);
465 if (referrals == NULL) {
466 return NT_STATUS_NO_MEMORY;
467 }
468 r->out.resp->referral_entries = referrals;
469
470 referral_str = talloc_asprintf(r, "\\%s", netbios_domain);
471 if (referral_str == NULL) {
472 return NT_STATUS_NO_MEMORY;
473 }
474
475 status = fill_domain_dfs_referraltype(referrals,
476 &referrals[0], 3,
477 referral_str,
478 NULL, 0);
479 if (!NT_STATUS_IS_OK(status)) {
480 DEBUG(2,("%s: Unable to fill domain referral structure - %s\n",
481 __location__, nt_errstr(status)));
482 return status;
483 }
484
485 referral_str = talloc_asprintf(r, "\\%s", dns_domain);
486 if (referral_str == NULL) {
487 return NT_STATUS_NO_MEMORY;
488 }
489
490 status = fill_domain_dfs_referraltype(referrals,
491 &referrals[1], 3,
492 referral_str,
493 NULL, 0);
494 if (!NT_STATUS_IS_OK(status)) {
495 DEBUG(2,("%s: Unable to fill domain referral structure - %s\n",
496 __location__, nt_errstr(status)));
497 return status;
498 }
499
500 return NT_STATUS_OK;
501 }
502
503 /*
504 * Handle the logic for dfs referral request like
505 * \\dns_domain or \\netbios_domain.
506 */
507 static NTSTATUS dodc_referral(struct loadparm_context *lp_ctx,
508 struct ldb_context *sam_ctx,
509 const struct tsocket_address *client,
510 struct dfs_GetDFSReferral *r,
511 const char *domain_name)
512 {
513 NTSTATUS status;
514 const char *site_name = NULL; /* Name of the site where the client is */
515 bool need_fqdn = false;
516 unsigned int i;
517 const char **dc_list = NULL;
518 uint32_t num_dcs = 0;
519 struct dc_set **set;
520 char *client_str = NULL;
521 struct dfs_referral_type *referrals;
522 const char *referral_str;
523
524 if (lpcfg_server_role(lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
525 return NT_STATUS_INVALID_PARAMETER;
526 }
527
528 if (r->in.req.max_referral_level < 3) {
529 DEBUG(2,("invalid max_referral_level %u\n",
530 r->in.req.max_referral_level));
531 return NT_STATUS_UNSUCCESSFUL;
532 }
533
534 DEBUG(10, ("in this we have request for %s requested is %s\n",
535 domain_name, r->in.req.servername));
536
537 if (strchr(domain_name,'.')) {
538 need_fqdn = 1;
539 }
540
541 if (tsocket_address_is_inet(client, "ip")) {
542 client_str = tsocket_address_inet_addr_string(client, r);
543 if (client_str == NULL) {
544 return NT_STATUS_NO_MEMORY;
545 }
546 }
547
548 site_name = samdb_client_site_name(sam_ctx, r, client_str, NULL);
549
550 status = get_dcs(r, sam_ctx, site_name, need_fqdn, &set, 0);
551 if (!NT_STATUS_IS_OK(status)) {
552 DEBUG(3,("Unable to get list of DCs - %s\n",
553 nt_errstr(status)));
554 return status;
555 }
556
557 for(i=0; set[i]; i++) {
558 uint32_t j;
559
560 dc_list = talloc_realloc(r, dc_list, const char*,
561 num_dcs + set[i]->count + 1);
562 if (dc_list == NULL) {
563 return NT_STATUS_NO_MEMORY;
564 }
565
566 for(j=0; j<set[i]->count; j++) {
567 dc_list[num_dcs + j] = talloc_move(dc_list,
568 &set[i]->names[j]);
569 }
570 num_dcs = num_dcs + set[i]->count;
571 TALLOC_FREE(set[i]);
572 dc_list[num_dcs] = NULL;
573 }
574
575 r->out.resp = talloc_zero(r, struct dfs_referral_resp);
576 if (r->out.resp == NULL) {
577 return NT_STATUS_NO_MEMORY;
578 }
579
580 r->out.resp->path_consumed = 0;
581 r->out.resp->header_flags = 0; /* Do like w2k3 */
582 r->out.resp->nb_referrals = 1;
583
584 referrals = talloc_zero_array(r->out.resp,
585 struct dfs_referral_type,
586 r->out.resp->nb_referrals);
587 if (referrals == NULL) {
588 return NT_STATUS_NO_MEMORY;
589 }
590 r->out.resp->referral_entries = referrals;
591
592 if (r->in.req.servername[0] == '\\') {
593 referral_str = talloc_asprintf(referrals, "%s",
594 domain_name);
595 } else {
596 referral_str = talloc_asprintf(referrals, "\\%s",
597 domain_name);
598 }
599 if (referral_str == NULL) {
600 return NT_STATUS_NO_MEMORY;
601 }
602
603 status = fill_domain_dfs_referraltype(referrals,
604 &referrals[0], 3,
605 referral_str,
606 dc_list, num_dcs);
607 if (!NT_STATUS_IS_OK(status)) {
608 DEBUG(2,("%s: Unable to fill domain referral structure - %s\n",
609 __location__, nt_errstr(status)));
610 return status;
611 }
612
613 return NT_STATUS_OK;
614 }
615
616 /*
617 * Handle the logic for dfs referral request like
618 * \\domain\sysvol or \\domain\netlogon
619 */
620 static NTSTATUS dosysvol_referral(struct loadparm_context *lp_ctx,
621 struct ldb_context *sam_ctx,
622 const struct tsocket_address *client,
623 struct dfs_GetDFSReferral *r,
624 const char *domain_name,
625 const char *dfs_name)
626 {
627 const char *site_name = NULL; /* Name of the site where the client is */
628 bool need_fqdn = false;
629 unsigned int i, c = 0, nb_entries = 0;
630 struct dc_set **set;
631 char *client_str = NULL;
632 NTSTATUS status;
633 struct dfs_referral_type *referrals;
634
635 if (lpcfg_server_role(lp_ctx) != ROLE_DOMAIN_CONTROLLER) {
636 return NT_STATUS_INVALID_PARAMETER;
637 }
638
639 if (r->in.req.max_referral_level < 3) {
640 DEBUG(2,("invalid max_referral_level %u\n",
641 r->in.req.max_referral_level));
642 return NT_STATUS_UNSUCCESSFUL;
643 }
644
645 DEBUG(10, ("in this we have request for %s and share %s requested is %s\n",
646 domain_name, dfs_name, r->in.req.servername));
647
648 if (strchr(domain_name,'.')) {
649 need_fqdn = 1;
650 }
651
652 if (tsocket_address_is_inet(client, "ip")) {
653 client_str = tsocket_address_inet_addr_string(client, r);
654 if (client_str == NULL) {
655 return NT_STATUS_NO_MEMORY;
656 }
657 }
658
659 site_name = samdb_client_site_name(sam_ctx, r, client_str, NULL);
660
661 status = get_dcs(r, sam_ctx, site_name, need_fqdn, &set, 0);
662 if (!NT_STATUS_IS_OK(status)) {
663 DEBUG(3,("Unable to get list of DCs - %s\n",
664 nt_errstr(status)));
665 return status;
666 }
667
668 for(i=0; set[i]; i++) {
669 nb_entries = nb_entries + set[i]->count;
670 }
671
672 r->out.resp = talloc_zero(r, struct dfs_referral_resp);
673 if (r->out.resp == NULL) {
674 return NT_STATUS_NO_MEMORY;
675 }
676
677 /* The length is expected in bytes */
678 r->out.resp->path_consumed = strlen_m(r->in.req.servername) * 2;
679 /* Do like w2k3 and like in 3.3.5.3 of MS-DFSC*/
680 r->out.resp->header_flags = DFS_HEADER_FLAG_STORAGE_SVR;
681 r->out.resp->nb_referrals = nb_entries;
682
683 referrals = talloc_zero_array(r->out.resp,
684 struct dfs_referral_type,
685 r->out.resp->nb_referrals);
686 if (referrals == NULL) {
687 return NT_STATUS_NO_MEMORY;
688 }
689 r->out.resp->referral_entries = referrals;
690
691 c = 0;
692 for(i=0; set[i]; i++) {
693 uint32_t j;
694
695 for(j=0; j< set[i]->count; j++) {
696 struct dfs_referral_type *ref = &referrals[c];
697 const char *referral_str;
698
699 referral_str = talloc_asprintf(referrals, "\\%s\\%s",
700 set[i]->names[j], dfs_name);
701 if (referral_str == NULL) {
702 return NT_STATUS_NO_MEMORY;
703 }
704
705 DEBUG(8,("Doing a dfs referral for %s with this value "
706 "%s requested %s\n",
707 set[i]->names[j], referral_str,
708 r->in.req.servername));
709
710 status = fill_normal_dfs_referraltype(referrals, ref,
711 r->in.req.max_referral_level,
712 r->in.req.servername,
713 referral_str, c==0);
714
715
716 if (!NT_STATUS_IS_OK(status)) {
717 DEBUG(2,("%s: Unable to fill domain referral "
718 "structure - %s\n",
719 __location__, nt_errstr(status)));
720 return status;
721 }
722
723 c++;
724 }
725 }
726
727 return NT_STATUS_OK;
728 }
729
730 /*
731 trans2 getdfsreferral implementation
732 */
733 NTSTATUS dfs_server_ad_get_referrals(struct loadparm_context *lp_ctx,
734 struct ldb_context *sam_ctx,
735 const struct tsocket_address *client,
736 struct dfs_GetDFSReferral *r)
737 {
738 char *server_name = NULL;
739 char *dfs_name = NULL;
740 char *link_path = NULL;
741 const char *netbios_domain;
742 const char *dns_domain;
743 const char *netbios_name;
744 const char *dns_name;
745
746 if (!lpcfg_host_msdfs(lp_ctx)) {
747 return NT_STATUS_FS_DRIVER_REQUIRED;
748 }
749
750 if (r->in.req.servername == NULL) {
751 return NT_STATUS_INVALID_PARAMETER;
752 }
753
754 DEBUG(8, ("Requested DFS name: %s length: %u\n",
755 r->in.req.servername,
756 (unsigned int)strlen_m(r->in.req.servername)*2));
757
758 /*
759 * If the servername is "" then we are in a case of domain dfs
760 * and the client just searches for the list of local domain
761 * it is attached and also trusted ones.
762 */
763 if (strlen(r->in.req.servername) == 0) {
764 return dodomain_referral(lp_ctx, sam_ctx, client, r);
765 }
766
767 server_name = talloc_strdup(r, r->in.req.servername);
768 if (server_name == NULL) {
769 return NT_STATUS_NO_MEMORY;
770 }
771
772 while(*server_name && *server_name == '\\') {
773 server_name++;
774 }
775
776 dfs_name = strchr(server_name, '\\');
777 if (dfs_name != NULL) {
778 dfs_name[0] = '\0';
779 dfs_name++;
780
781 link_path = strchr(dfs_name, '\\');
782 if (link_path != NULL) {
783 link_path[0] = '\0';
784 link_path++;
785 }
786 }
787
788 if (link_path != NULL) {
789 /*
790 * If it is a DFS Link we do not
791 * handle it here.
792 */
793 return NT_STATUS_NOT_FOUND;
794 }
795
796 netbios_domain = lpcfg_workgroup(lp_ctx);
797 dns_domain = lpcfg_dnsdomain(lp_ctx);
798 netbios_name = lpcfg_netbios_name(lp_ctx);
799 dns_name = talloc_asprintf(r, "%s.%s", netbios_name, dns_domain);
800 if (dns_name == NULL) {
801 return NT_STATUS_NO_MEMORY;
802 }
803
804 if ((strcasecmp_m(server_name, netbios_name) == 0) ||
805 (strcasecmp_m(server_name, dns_name) == 0)) {
806 /*
807 * If it is not domain related do not
808 * handle it here.
809 */
810 return NT_STATUS_NOT_FOUND;
811
812 }
813
814 if ((strcasecmp_m(server_name, netbios_domain) != 0) &&
815 (strcasecmp_m(server_name, dns_domain) != 0)) {
816 /*
817 * Not a domain we handle.
818 */
819 return NT_STATUS_INVALID_PARAMETER;
820 }
821
822 /*
823 * Here we have filtered the thing the requested name don't contain our DNS name.
824 * So if the share == NULL or if share in ("sysvol", "netlogon")
825 * then we proceed. In the first case it will be a dc refereal in the second it will
826 * be just a sysvol/netlogon referral.
827 */
828 if (dfs_name == NULL) {
829 return dodc_referral(lp_ctx, sam_ctx,
830 client, r, server_name);
831 }
832
833 /*
834 * Here we have filtered the thing the requested name don't contain our DNS name.
835 * So if the share == NULL or if share in ("sysvol", "netlogon")
836 * then we proceed. In the first case it will be a dc refereal in the second it will
837 * be just a sysvol/netlogon referral.
838 */
839 if (strcasecmp(dfs_name, "sysvol") == 0 ||
840 strcasecmp(dfs_name, "netlogon") == 0) {
841 return dosysvol_referral(lp_ctx, sam_ctx, client, r,
842 server_name, dfs_name);
843 }
844
845 /* By default until all the case are handled */
846 return NT_STATUS_NOT_FOUND;
847 }
stuff from bjacke