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