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
  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 }