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