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