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