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