source/smbd/msdfs.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 3.0
   4    MSDFS services for Samba
   5    Copyright (C) Shirish Kalele 2000
   6    Copyright (C) Jeremy Allison 2007
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 */
  22
  23 #define DBGC_CLASS DBGC_MSDFS
  24 #include "includes.h"
  25
  26 extern uint32 global_client_caps;
  27
  28 /**********************************************************************
  29  Parse a DFS pathname of the form \hostname\service\reqpath
  30  into the dfs_path structure.
  31  If POSIX pathnames is true, the pathname may also be of the
  32  form /hostname/service/reqpath.
  33  We cope with either here.
  34
  35  Unfortunately, due to broken clients who might set the
  36  SVAL(inbuf,smb_flg2) & FLAGS2_DFS_PATHNAMES bit and then
  37  send a local path, we have to cope with that too....
  38
  39  If conn != NULL then ensure the provided service is
  40  the one pointed to by the connection.
  41
  42  This version does everything using pointers within one copy of the
  43  pathname string, talloced on the struct dfs_path pointer (which
  44  must be talloced). This may be too clever to live....
  45  JRA.
  46 **********************************************************************/
  47
  48 static NTSTATUS parse_dfs_path(connection_struct *conn,
  49                                 const char *pathname,
  50                                 bool allow_wcards,
  51                                 struct dfs_path *pdp, /* MUST BE TALLOCED */
  52                                 bool *ppath_contains_wcard)
  53 {
  54         char *pathname_local;
  55         char *p,*temp;
  56         char *servicename;
  57         char *eos_ptr;
  58         NTSTATUS status = NT_STATUS_OK;
  59         char sepchar;
  60
  61         ZERO_STRUCTP(pdp);
  62
  63         /*
  64          * This is the only talloc we should need to do
  65          * on the struct dfs_path. All the pointers inside
  66          * it should point to offsets within this string.
  67          */
  68
  69         pathname_local = talloc_strdup(pdp, pathname);
  70         if (!pathname_local) {
  71                 return NT_STATUS_NO_MEMORY;
  72         }
  73         /* Get a pointer to the terminating '\0' */
  74         eos_ptr = &pathname_local[strlen(pathname_local)];
  75         p = temp = pathname_local;
  76
  77         pdp->posix_path = (lp_posix_pathnames() && *pathname == '/');
  78
  79         sepchar = pdp->posix_path ? '/' : '\\';
  80
  81         if (*pathname != sepchar) {
  82                 DEBUG(10,("parse_dfs_path: path %s doesn't start with %c\n",
  83                         pathname, sepchar ));
  84                 /*
  85                  * Possibly client sent a local path by mistake.
  86                  * Try and convert to a local path.
  87                  */
  88
  89                 pdp->hostname = eos_ptr; /* "" */
  90                 pdp->servicename = eos_ptr; /* "" */
  91
  92                 /* We've got no info about separators. */
  93                 pdp->posix_path = lp_posix_pathnames();
  94                 p = temp;
  95                 DEBUG(10,("parse_dfs_path: trying to convert %s to a "
  96                         "local path\n",
  97                         temp));
  98                 goto local_path;
  99         }
 100
 101         /*
 102          * Safe to use on talloc'ed string as it only shrinks.
 103          * It also doesn't affect the eos_ptr.
 104          */
 105         trim_char(temp,sepchar,sepchar);
 106
 107         DEBUG(10,("parse_dfs_path: temp = |%s| after trimming %c's\n",
 108                 temp, sepchar));
 109
 110         /* Now tokenize. */
 111         /* Parse out hostname. */
 112         p = strchr_m(temp,sepchar);
 113         if(p == NULL) {
 114                 DEBUG(10,("parse_dfs_path: can't parse hostname from path %s\n",
 115                         temp));
 116                 /*
 117                  * Possibly client sent a local path by mistake.
 118                  * Try and convert to a local path.
 119                  */
 120
 121                 pdp->hostname = eos_ptr; /* "" */
 122                 pdp->servicename = eos_ptr; /* "" */
 123
 124                 p = temp;
 125                 DEBUG(10,("parse_dfs_path: trying to convert %s "
 126                         "to a local path\n",
 127                         temp));
 128                 goto local_path;
 129         }
 130         *p = '\0';
 131         pdp->hostname = temp;
 132
 133         DEBUG(10,("parse_dfs_path: hostname: %s\n",pdp->hostname));
 134
 135         /* Parse out servicename. */
 136         servicename = p+1;
 137         p = strchr_m(servicename,sepchar);
 138         if (p) {
 139                 *p = '\0';
 140         }
 141
 142         /* Is this really our servicename ? */
 143         if (conn && !( strequal(servicename, lp_servicename(SNUM(conn)))
 144                         || (strequal(servicename, HOMES_NAME)
 145                         && strequal(lp_servicename(SNUM(conn)),
 146                                 get_current_username()) )) ) {
 147                 DEBUG(10,("parse_dfs_path: %s is not our servicename\n",
 148                         servicename));
 149
 150                 /*
 151                  * Possibly client sent a local path by mistake.
 152                  * Try and convert to a local path.
 153                  */
 154
 155                 pdp->hostname = eos_ptr; /* "" */
 156                 pdp->servicename = eos_ptr; /* "" */
 157
 158                 /* Repair the path - replace the sepchar's
 159                    we nulled out */
 160                 servicename--;
 161                 *servicename = sepchar;
 162                 if (p) {
 163                         *p = sepchar;
 164                 }
 165
 166                 p = temp;
 167                 DEBUG(10,("parse_dfs_path: trying to convert %s "
 168                         "to a local path\n",
 169                         temp));
 170                 goto local_path;
 171         }
 172
 173         pdp->servicename = servicename;
 174
 175         DEBUG(10,("parse_dfs_path: servicename: %s\n",pdp->servicename));
 176
 177         if(p == NULL) {
 178                 /* Client sent self referral \server\share. */
 179                 pdp->reqpath = eos_ptr; /* "" */
 180                 return NT_STATUS_OK;
 181         }
 182
 183         p++;
 184
 185   local_path:
 186
 187         *ppath_contains_wcard = False;
 188
 189         pdp->reqpath = p;
 190
 191         /* Rest is reqpath. */
 192         if (pdp->posix_path) {
 193                 status = check_path_syntax_posix(pdp->reqpath);
 194         } else {
 195                 if (allow_wcards) {
 196                         status = check_path_syntax_wcard(pdp->reqpath,
 197                                         ppath_contains_wcard);
 198                 } else {
 199                         status = check_path_syntax(pdp->reqpath);
 200                 }
 201         }
 202
 203         if (!NT_STATUS_IS_OK(status)) {
 204                 DEBUG(10,("parse_dfs_path: '%s' failed with %s\n",
 205                         p, nt_errstr(status) ));
 206                 return status;
 207         }
 208
 209         DEBUG(10,("parse_dfs_path: rest of the path: %s\n",pdp->reqpath));
 210         return NT_STATUS_OK;
 211 }
 212
 213 /********************************************************
 214  Fake up a connection struct for the VFS layer.
 215  Note this CHANGES CWD !!!! JRA.
 216 *********************************************************/
 217
 218 static NTSTATUS create_conn_struct(TALLOC_CTX *ctx,
 219                                 connection_struct *conn,
 220                                 int snum,
 221                                 const char *path)
 222 {
 223         char *connpath;
 224
 225         ZERO_STRUCTP(conn);
 226
 227         connpath = talloc_strdup(ctx, path);
 228         if (!connpath) {
 229                 return NT_STATUS_NO_MEMORY;
 230         }
 231         connpath = talloc_string_sub(ctx,
 232                                 connpath,
 233                                 "%S",
 234                                 lp_servicename(snum));
 235         if (!connpath) {
 236                 return NT_STATUS_NO_MEMORY;
 237         }
 238
 239         /* needed for smbd_vfs_init() */
 240
 241         if ((conn->mem_ctx=talloc_init("connection_struct")) == NULL) {
 242                 DEBUG(0,("talloc_init(connection_struct) failed!\n"));
 243                 return NT_STATUS_NO_MEMORY;
 244         }
 245
 246         if (!(conn->params = TALLOC_ZERO_P(conn->mem_ctx,
 247                                         struct share_params))) {
 248                 DEBUG(0, ("TALLOC failed\n"));
 249                 return NT_STATUS_NO_MEMORY;
 250         }
 251
 252         conn->params->service = snum;
 253
 254         set_conn_connectpath(conn, connpath);
 255
 256         if (!smbd_vfs_init(conn)) {
 257                 NTSTATUS status = map_nt_error_from_unix(errno);
 258                 DEBUG(0,("create_conn_struct: smbd_vfs_init failed.\n"));
 259                 conn_free_internal(conn);
 260                 return status;
 261         }
 262
 263         conn->fs_capabilities = SMB_VFS_FS_CAPABILITIES(conn);
 264
 265         /*
 266          * Windows seems to insist on doing trans2getdfsreferral() calls on
 267          * the IPC$ share as the anonymous user. If we try to chdir as that
 268          * user we will fail.... WTF ? JRA.
 269          */
 270
 271         if (vfs_ChDir(conn,conn->connectpath) != 0) {
 272                 NTSTATUS status = map_nt_error_from_unix(errno);
 273                 DEBUG(3,("create_conn_struct: Can't ChDir to new conn path %s. "
 274                         "Error was %s\n",
 275                         conn->connectpath, strerror(errno) ));
 276                 conn_free_internal(conn);
 277                 return status;
 278         }
 279
 280         return NT_STATUS_OK;
 281 }
 282
 283 /**********************************************************************
 284  Parse the contents of a symlink to verify if it is an msdfs referral
 285  A valid referral is of the form:
 286
 287  msdfs:server1\share1,server2\share2
 288  msdfs:server1\share1\pathname,server2\share2\pathname
 289  msdfs:server1/share1,server2/share2
 290  msdfs:server1/share1/pathname,server2/share2/pathname.
 291
 292  Note that the alternate paths returned here must be of the canonicalized
 293  form:
 294
 295  \server\share or
 296  \server\share\path\to\file,
 297
 298  even in posix path mode. This is because we have no knowledge if the
 299  server we're referring to understands posix paths.
 300  **********************************************************************/
 301
 302 static bool parse_msdfs_symlink(TALLOC_CTX *ctx,
 303                                 const char *target,
 304                                 struct referral **preflist,
 305                                 int *refcount)
 306 {
 307         char *temp = NULL;
 308         char *prot;
 309         char **alt_path = NULL;
 310         int count = 0, i;
 311         struct referral *reflist;
 312         char *saveptr;
 313
 314         temp = talloc_strdup(ctx, target);
 315         if (!temp) {
 316                 return False;
 317         }
 318         prot = strtok_r(temp, ":", &saveptr);
 319         if (!prot) {
 320                 DEBUG(0,("parse_msdfs_symlink: invalid path !\n"));
 321                 return False;
 322         }
 323
 324         alt_path = TALLOC_ARRAY(ctx, char *, MAX_REFERRAL_COUNT);
 325         if (!alt_path) {
 326                 return False;
 327         }
 328
 329         /* parse out the alternate paths */
 330         while((count<MAX_REFERRAL_COUNT) &&
 331               ((alt_path[count] = strtok_r(NULL, ",", &saveptr)) != NULL)) {
 332                 count++;
 333         }
 334
 335         DEBUG(10,("parse_msdfs_symlink: count=%d\n", count));
 336
 337         if (count) {
 338                 reflist = *preflist = TALLOC_ZERO_ARRAY(ctx,
 339                                 struct referral, count);
 340                 if(reflist == NULL) {
 341                         TALLOC_FREE(alt_path);
 342                         return False;
 343                 }
 344         } else {
 345                 reflist = *preflist = NULL;
 346         }
 347
 348         for(i=0;i<count;i++) {
 349                 char *p;
 350
 351                 /* Canonicalize link target.
 352                  * Replace all /'s in the path by a \ */
 353                 string_replace(alt_path[i], '/', '\\');
 354
 355                 /* Remove leading '\\'s */
 356                 p = alt_path[i];
 357                 while (*p && (*p == '\\')) {
 358                         p++;
 359                 }
 360
 361                 reflist[i].alternate_path = talloc_asprintf(ctx,
 362                                 "\\%s",
 363                                 p);
 364                 if (!reflist[i].alternate_path) {
 365                         return False;
 366                 }
 367
 368                 reflist[i].proximity = 0;
 369                 reflist[i].ttl = REFERRAL_TTL;
 370                 DEBUG(10, ("parse_msdfs_symlink: Created alt path: %s\n",
 371                                         reflist[i].alternate_path));
 372         }
 373
 374         *refcount = count;
 375
 376         TALLOC_FREE(alt_path);
 377         return True;
 378 }
 379
 380 /**********************************************************************
 381  Returns true if the unix path is a valid msdfs symlink and also
 382  returns the target string from inside the link.
 383 **********************************************************************/
 384
 385 static bool is_msdfs_link_internal(TALLOC_CTX *ctx,
 386                         connection_struct *conn,
 387                         const char *path,
 388                         char **pp_link_target,
 389                         SMB_STRUCT_STAT *sbufp)
 390 {
 391         SMB_STRUCT_STAT st;
 392         int referral_len = 0;
 393         char link_target_buf[7];
 394         size_t bufsize = 0;
 395         char *link_target = NULL;
 396
 397         if (pp_link_target) {
 398                 bufsize = 1024;
 399                 link_target = TALLOC_ARRAY(ctx, char, bufsize);
 400                 if (!link_target) {
 401                         return False;
 402                 }
 403                 *pp_link_target = link_target;
 404         } else {
 405                 bufsize = sizeof(link_target_buf);
 406                 link_target = link_target_buf;
 407         }
 408
 409         if (sbufp == NULL) {
 410                 sbufp = &st;
 411         }
 412
 413         if (SMB_VFS_LSTAT(conn, path, sbufp) != 0) {
 414                 DEBUG(5,("is_msdfs_link_read_target: %s does not exist.\n",
 415                         path));
 416                 goto err;
 417         }
 418
 419         if (!S_ISLNK(sbufp->st_mode)) {
 420                 DEBUG(5,("is_msdfs_link_read_target: %s is not a link.\n",
 421                                         path));
 422                 goto err;
 423         }
 424
 425         referral_len = SMB_VFS_READLINK(conn, path, link_target, bufsize - 1);
 426         if (referral_len == -1) {
 427                 DEBUG(0,("is_msdfs_link_read_target: Error reading "
 428                         "msdfs link %s: %s\n",
 429                         path, strerror(errno)));
 430                 goto err;
 431         }
 432         link_target[referral_len] = '\0';
 433
 434         DEBUG(5,("is_msdfs_link_internal: %s -> %s\n",path,
 435                                 link_target));
 436
 437         if (!strnequal(link_target, "msdfs:", 6)) {
 438                 goto err;
 439         }
 440         return True;
 441
 442   err:
 443
 444         if (link_target != link_target_buf) {
 445                 TALLOC_FREE(link_target);
 446         }
 447         return False;
 448 }
 449
 450 /**********************************************************************
 451  Returns true if the unix path is a valid msdfs symlink.
 452 **********************************************************************/
 453
 454 bool is_msdfs_link(connection_struct *conn,
 455                 const char *path,
 456                 SMB_STRUCT_STAT *sbufp)
 457 {
 458         return is_msdfs_link_internal(talloc_tos(),
 459                                         conn,
 460                                         path,
 461                                         NULL,
 462                                         sbufp);
 463 }
 464
 465 /*****************************************************************
 466  Used by other functions to decide if a dfs path is remote,
 467  and to get the list of referred locations for that remote path.
 468
 469  search_flag: For findfirsts, dfs links themselves are not
 470  redirected, but paths beyond the links are. For normal smb calls,
 471  even dfs links need to be redirected.
 472
 473  consumedcntp: how much of the dfs path is being redirected. the client
 474  should try the remaining path on the redirected server.
 475
 476  If this returns NT_STATUS_PATH_NOT_COVERED the contents of the msdfs
 477  link redirect are in targetpath.
 478 *****************************************************************/
 479
 480 static NTSTATUS dfs_path_lookup(TALLOC_CTX *ctx,
 481                 connection_struct *conn,
 482                 const char *dfspath, /* Incoming complete dfs path */
 483                 const struct dfs_path *pdp, /* Parsed out
 484                                                server+share+extrapath. */
 485                 bool search_flag, /* Called from a findfirst ? */
 486                 int *consumedcntp,
 487                 char **pp_targetpath)
 488 {
 489         char *p = NULL;
 490         char *q = NULL;
 491         SMB_STRUCT_STAT sbuf;
 492         NTSTATUS status;
 493         char *localpath = NULL;
 494         char *canon_dfspath = NULL; /* Canonicalized dfs path. (only '/'
 495                                   components). */
 496
 497         DEBUG(10,("dfs_path_lookup: Conn path = %s reqpath = %s\n",
 498                 conn->connectpath, pdp->reqpath));
 499
 500         /*
 501          * Note the unix path conversion here we're doing we can
 502          * throw away. We're looking for a symlink for a dfs
 503          * resolution, if we don't find it we'll do another
 504          * unix_convert later in the codepath.
 505          * If we needed to remember what we'd resolved in
 506          * dp->reqpath (as the original code did) we'd
 507          * copy (localhost, dp->reqpath) on any code
 508          * path below that returns True - but I don't
 509          * think this is needed. JRA.
 510          */
 511
 512         status = unix_convert(ctx, conn, pdp->reqpath, search_flag, &localpath,
 513                         NULL, &sbuf);
 514         if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status,
 515                                         NT_STATUS_OBJECT_PATH_NOT_FOUND)) {
 516                 return status;
 517         }
 518
 519         /* Optimization - check if we can redirect the whole path. */
 520
 521         if (is_msdfs_link_internal(ctx, conn, localpath, pp_targetpath, NULL)) {
 522                 if (search_flag) {
 523                         DEBUG(6,("dfs_path_lookup (FindFirst) No redirection "
 524                                  "for dfs link %s.\n", dfspath));
 525                         return NT_STATUS_OK;
 526                 }
 527
 528                 DEBUG(6,("dfs_path_lookup: %s resolves to a "
 529                         "valid dfs link %s.\n", dfspath,
 530                         pp_targetpath ? *pp_targetpath : ""));
 531
 532                 if (consumedcntp) {
 533                         *consumedcntp = strlen(dfspath);
 534                 }
 535                 return NT_STATUS_PATH_NOT_COVERED;
 536         }
 537
 538         /* Prepare to test only for '/' components in the given path,
 539          * so if a Windows path replace all '\\' characters with '/'.
 540          * For a POSIX DFS path we know all separators are already '/'. */
 541
 542         canon_dfspath = talloc_strdup(ctx, dfspath);
 543         if (!canon_dfspath) {
 544                 return NT_STATUS_NO_MEMORY;
 545         }
 546         if (!pdp->posix_path) {
 547                 string_replace(canon_dfspath, '\\', '/');
 548         }
 549
 550         /*
 551          * localpath comes out of unix_convert, so it has
 552          * no trailing backslash. Make sure that canon_dfspath hasn't either.
 553          * Fix for bug #4860 from Jan Martin <Jan.Martin@rwedea.com>.
 554          */
 555
 556         trim_char(canon_dfspath,0,'/');
 557
 558         /*
 559          * Redirect if any component in the path is a link.
 560          * We do this by walking backwards through the
 561          * local path, chopping off the last component
 562          * in both the local path and the canonicalized
 563          * DFS path. If we hit a DFS link then we're done.
 564          */
 565
 566         p = strrchr_m(localpath, '/');
 567         if (consumedcntp) {
 568                 q = strrchr_m(canon_dfspath, '/');
 569         }
 570
 571         while (p) {
 572                 *p = '\0';
 573                 if (q) {
 574                         *q = '\0';
 575                 }
 576
 577                 if (is_msdfs_link_internal(ctx, conn,
 578                                         localpath, pp_targetpath, NULL)) {
 579                         DEBUG(4, ("dfs_path_lookup: Redirecting %s because "
 580                                 "parent %s is dfs link\n", dfspath, localpath));
 581
 582                         if (consumedcntp) {
 583                                 *consumedcntp = strlen(canon_dfspath);
 584                                 DEBUG(10, ("dfs_path_lookup: Path consumed: %s "
 585                                         "(%d)\n",
 586                                         canon_dfspath,
 587                                         *consumedcntp));
 588                         }
 589
 590                         return NT_STATUS_PATH_NOT_COVERED;
 591                 }
 592
 593                 /* Step back on the filesystem. */
 594                 p = strrchr_m(localpath, '/');
 595
 596                 if (consumedcntp) {
 597                         /* And in the canonicalized dfs path. */
 598                         q = strrchr_m(canon_dfspath, '/');
 599                 }
 600         }
 601
 602         return NT_STATUS_OK;
 603 }
 604
 605 /*****************************************************************
 606  Decides if a dfs pathname should be redirected or not.
 607  If not, the pathname is converted to a tcon-relative local unix path
 608
 609  search_wcard_flag: this flag performs 2 functions both related
 610  to searches.  See resolve_dfs_path() and parse_dfs_path_XX()
 611  for details.
 612
 613  This function can return NT_STATUS_OK, meaning use the returned path as-is
 614  (mapped into a local path).
 615  or NT_STATUS_NOT_COVERED meaning return a DFS redirect, or
 616  any other NT_STATUS error which is a genuine error to be
 617  returned to the client.
 618 *****************************************************************/
 619
 620 static NTSTATUS dfs_redirect(TALLOC_CTX *ctx,
 621                         connection_struct *conn,
 622                         const char *path_in,
 623                         bool search_wcard_flag,
 624                         char **pp_path_out,
 625                         bool *ppath_contains_wcard)
 626 {
 627         NTSTATUS status;
 628         struct dfs_path *pdp = TALLOC_P(ctx, struct dfs_path);
 629
 630         if (!pdp) {
 631                 return NT_STATUS_NO_MEMORY;
 632         }
 633
 634         status = parse_dfs_path(conn, path_in, search_wcard_flag, pdp,
 635                         ppath_contains_wcard);
 636         if (!NT_STATUS_IS_OK(status)) {
 637                 TALLOC_FREE(pdp);
 638                 return status;
 639         }
 640
 641         if (pdp->reqpath[0] == '\0') {
 642                 TALLOC_FREE(pdp);
 643                 *pp_path_out = talloc_strdup(ctx, "");
 644                 if (!*pp_path_out) {
 645                         return NT_STATUS_NO_MEMORY;
 646                 }
 647                 DEBUG(5,("dfs_redirect: self-referral.\n"));
 648                 return NT_STATUS_OK;
 649         }
 650
 651         /* If dfs pathname for a non-dfs share, convert to tcon-relative
 652            path and return OK */
 653
 654         if (!lp_msdfs_root(SNUM(conn))) {
 655                 *pp_path_out = talloc_strdup(ctx, pdp->reqpath);
 656                 TALLOC_FREE(pdp);
 657                 if (!*pp_path_out) {
 658                         return NT_STATUS_NO_MEMORY;
 659                 }
 660                 return NT_STATUS_OK;
 661         }
 662
 663         /* If it looked like a local path (zero hostname/servicename)
 664          * just treat as a tcon-relative path. */
 665
 666         if (pdp->hostname[0] == '\0' && pdp->servicename[0] == '\0') {
 667                 *pp_path_out = talloc_strdup(ctx, pdp->reqpath);
 668                 TALLOC_FREE(pdp);
 669                 if (!*pp_path_out) {
 670                         return NT_STATUS_NO_MEMORY;
 671                 }
 672                 return NT_STATUS_OK;
 673         }
 674
 675         status = dfs_path_lookup(ctx, conn, path_in, pdp,
 676                         search_wcard_flag, NULL, NULL);
 677         if (!NT_STATUS_IS_OK(status)) {
 678                 if (NT_STATUS_EQUAL(status, NT_STATUS_PATH_NOT_COVERED)) {
 679                         DEBUG(3,("dfs_redirect: Redirecting %s\n", path_in));
 680                 } else {
 681                         DEBUG(10,("dfs_redirect: dfs_path_lookup "
 682                                 "failed for %s with %s\n",
 683                                 path_in, nt_errstr(status) ));
 684                 }
 685                 return status;
 686         }
 687
 688         DEBUG(3,("dfs_redirect: Not redirecting %s.\n", path_in));
 689
 690         /* Form non-dfs tcon-relative path */
 691         *pp_path_out = talloc_strdup(ctx, pdp->reqpath);
 692         TALLOC_FREE(pdp);
 693         if (!*pp_path_out) {
 694                 return NT_STATUS_NO_MEMORY;
 695         }
 696
 697         DEBUG(3,("dfs_redirect: Path %s converted to non-dfs path %s\n",
 698                                 path_in,
 699                                 *pp_path_out));
 700
 701         return NT_STATUS_OK;
 702 }
 703
 704 /**********************************************************************
 705  Return a self referral.
 706 **********************************************************************/
 707
 708 static NTSTATUS self_ref(TALLOC_CTX *ctx,
 709                         const char *dfs_path,
 710                         struct junction_map *jucn,
 711                         int *consumedcntp,
 712                         bool *self_referralp)
 713 {
 714         struct referral *ref;
 715
 716         *self_referralp = True;
 717
 718         jucn->referral_count = 1;
 719         if((ref = TALLOC_ZERO_P(ctx, struct referral)) == NULL) {
 720                 return NT_STATUS_NO_MEMORY;
 721         }
 722
 723         ref->alternate_path = talloc_strdup(ctx, dfs_path);
 724         if (!ref->alternate_path) {
 725                 return NT_STATUS_NO_MEMORY;
 726         }
 727         ref->proximity = 0;
 728         ref->ttl = REFERRAL_TTL;
 729         jucn->referral_list = ref;
 730         *consumedcntp = strlen(dfs_path);
 731         return NT_STATUS_OK;
 732 }
 733
 734 /**********************************************************************
 735  Gets valid referrals for a dfs path and fills up the
 736  junction_map structure.
 737 **********************************************************************/
 738
 739 NTSTATUS get_referred_path(TALLOC_CTX *ctx,
 740                         const char *dfs_path,
 741                         struct junction_map *jucn,
 742                         int *consumedcntp,
 743                         bool *self_referralp)
 744 {
 745         struct connection_struct conns;
 746         struct connection_struct *conn = &conns;
 747         char *targetpath = NULL;
 748         int snum;
 749         NTSTATUS status = NT_STATUS_NOT_FOUND;
 750         bool dummy;
 751         struct dfs_path *pdp = TALLOC_P(ctx, struct dfs_path);
 752
 753         if (!pdp) {
 754                 return NT_STATUS_NO_MEMORY;
 755         }
 756
 757         ZERO_STRUCT(conns);
 758         *self_referralp = False;
 759
 760         status = parse_dfs_path(NULL, dfs_path, False, pdp, &dummy);
 761         if (!NT_STATUS_IS_OK(status)) {
 762                 return status;
 763         }
 764
 765         jucn->service_name = talloc_strdup(ctx, pdp->servicename);
 766         jucn->volume_name = talloc_strdup(ctx, pdp->reqpath);
 767         if (!jucn->service_name || !jucn->volume_name) {
 768                 TALLOC_FREE(pdp);
 769                 return NT_STATUS_NO_MEMORY;
 770         }
 771
 772         /* Verify the share is a dfs root */
 773         snum = lp_servicenumber(jucn->service_name);
 774         if(snum < 0) {
 775                 fstring service_name;
 776                 fstrcpy(service_name, jucn->service_name);
 777                 if ((snum = find_service(service_name)) < 0) {
 778                         return NT_STATUS_NOT_FOUND;
 779                 }
 780                 TALLOC_FREE(jucn->service_name);
 781                 jucn->service_name = talloc_strdup(ctx, service_name);
 782                 if (!jucn->service_name) {
 783                         TALLOC_FREE(pdp);
 784                         return NT_STATUS_NO_MEMORY;
 785                 }
 786         }
 787
 788         if (!lp_msdfs_root(snum) && (*lp_msdfs_proxy(snum) == '\0')) {
 789                 DEBUG(3,("get_referred_path: |%s| in dfs path %s is not "
 790                         "a dfs root.\n",
 791                         pdp->servicename, dfs_path));
 792                 TALLOC_FREE(pdp);
 793                 return NT_STATUS_NOT_FOUND;
 794         }
 795
 796         /*
 797          * Self referrals are tested with a anonymous IPC connection and
 798          * a GET_DFS_REFERRAL call to \\server\share. (which means
 799          * dp.reqpath[0] points to an empty string). create_conn_struct cd's
 800          * into the directory and will fail if it cannot (as the anonymous
 801          * user). Cope with this.
 802          */
 803
 804         if (pdp->reqpath[0] == '\0') {
 805                 char *tmp;
 806                 struct referral *ref;
 807
 808                 if (*lp_msdfs_proxy(snum) == '\0') {
 809                         TALLOC_FREE(pdp);
 810                         return self_ref(ctx,
 811                                         dfs_path,
 812                                         jucn,
 813                                         consumedcntp,
 814                                         self_referralp);
 815                 }
 816
 817                 /*
 818                  * It's an msdfs proxy share. Redirect to
 819                  * the configured target share.
 820                  */
 821
 822                 jucn->referral_count = 1;
 823                 if ((ref = TALLOC_ZERO_P(ctx, struct referral)) == NULL) {
 824                         TALLOC_FREE(pdp);
 825                         return NT_STATUS_NO_MEMORY;
 826                 }
 827
 828                 if (!(tmp = talloc_strdup(ctx, lp_msdfs_proxy(snum)))) {
 829                         TALLOC_FREE(pdp);
 830                         return NT_STATUS_NO_MEMORY;
 831                 }
 832
 833                 trim_string(tmp, "\\", 0);
 834
 835                 ref->alternate_path = talloc_asprintf(ctx, "\\%s", tmp);
 836                 TALLOC_FREE(tmp);
 837
 838                 if (!ref->alternate_path) {
 839                         TALLOC_FREE(pdp);
 840                         return NT_STATUS_NO_MEMORY;
 841                 }
 842
 843                 if (pdp->reqpath[0] != '\0') {
 844                         ref->alternate_path = talloc_asprintf_append(
 845                                         ref->alternate_path,
 846                                         "%s",
 847                                         pdp->reqpath);
 848                         if (!ref->alternate_path) {
 849                                 TALLOC_FREE(pdp);
 850                                 return NT_STATUS_NO_MEMORY;
 851                         }
 852                 }
 853                 ref->proximity = 0;
 854                 ref->ttl = REFERRAL_TTL;
 855                 jucn->referral_list = ref;
 856                 *consumedcntp = strlen(dfs_path);
 857                 TALLOC_FREE(pdp);
 858                 return NT_STATUS_OK;
 859         }
 860
 861         status = create_conn_struct(ctx, conn, snum, lp_pathname(snum));
 862         if (!NT_STATUS_IS_OK(status)) {
 863                 TALLOC_FREE(pdp);
 864                 return status;
 865         }
 866
 867         /* If this is a DFS path dfs_lookup should return
 868          * NT_STATUS_PATH_NOT_COVERED. */
 869
 870         status = dfs_path_lookup(ctx, conn, dfs_path, pdp,
 871                         False, consumedcntp, &targetpath);
 872
 873         if (!NT_STATUS_EQUAL(status, NT_STATUS_PATH_NOT_COVERED)) {
 874                 DEBUG(3,("get_referred_path: No valid referrals for path %s\n",
 875                         dfs_path));
 876                 conn_free_internal(conn);
 877                 TALLOC_FREE(pdp);
 878                 return status;
 879         }
 880
 881         /* We know this is a valid dfs link. Parse the targetpath. */
 882         if (!parse_msdfs_symlink(ctx, targetpath,
 883                                 &jucn->referral_list,
 884                                 &jucn->referral_count)) {
 885                 DEBUG(3,("get_referred_path: failed to parse symlink "
 886                         "target %s\n", targetpath ));
 887                 conn_free_internal(conn);
 888                 TALLOC_FREE(pdp);
 889                 return NT_STATUS_NOT_FOUND;
 890         }
 891
 892         conn_free_internal(conn);
 893         TALLOC_FREE(pdp);
 894         return NT_STATUS_OK;
 895 }
 896
 897 static int setup_ver2_dfs_referral(const char *pathname,
 898                                 char **ppdata,
 899                                 struct junction_map *junction,
 900                                 bool self_referral)
 901 {
 902         char* pdata = *ppdata;
 903
 904         smb_ucs2_t *uni_requestedpath = NULL;
 905         int uni_reqpathoffset1,uni_reqpathoffset2;
 906         int uni_curroffset;
 907         int requestedpathlen=0;
 908         int offset;
 909         int reply_size = 0;
 910         int i=0;
 911
 912         DEBUG(10,("Setting up version2 referral\nRequested path:\n"));
 913
 914         requestedpathlen = rpcstr_push_talloc(talloc_tos(),
 915                                         &uni_requestedpath, pathname);
 916         if (uni_requestedpath == NULL || requestedpathlen == 0) {
 917                 return -1;
 918         }
 919
 920         if (DEBUGLVL(10)) {
 921                 dump_data(0, (unsigned char *)uni_requestedpath,
 922                         requestedpathlen);
 923         }
 924
 925         DEBUG(10,("ref count = %u\n",junction->referral_count));
 926
 927         uni_reqpathoffset1 = REFERRAL_HEADER_SIZE +
 928                         VERSION2_REFERRAL_SIZE * junction->referral_count;
 929
 930         uni_reqpathoffset2 = uni_reqpathoffset1 + requestedpathlen;
 931
 932         uni_curroffset = uni_reqpathoffset2 + requestedpathlen;
 933
 934         reply_size = REFERRAL_HEADER_SIZE +
 935                         VERSION2_REFERRAL_SIZE*junction->referral_count +
 936                         2 * requestedpathlen;
 937         DEBUG(10,("reply_size: %u\n",reply_size));
 938
 939         /* add up the unicode lengths of all the referral paths */
 940         for(i=0;i<junction->referral_count;i++) {
 941                 DEBUG(10,("referral %u : %s\n",
 942                         i,
 943                         junction->referral_list[i].alternate_path));
 944                 reply_size +=
 945                         (strlen(junction->referral_list[i].alternate_path)+1)*2;
 946         }
 947
 948         DEBUG(10,("reply_size = %u\n",reply_size));
 949         /* add the unexplained 0x16 bytes */
 950         reply_size += 0x16;
 951
 952         pdata = (char *)SMB_REALLOC(pdata,reply_size);
 953         if(pdata == NULL) {
 954                 DEBUG(0,("Realloc failed!\n"));
 955                 return -1;
 956         }
 957         *ppdata = pdata;
 958
 959         /* copy in the dfs requested paths.. required for offset calculations */
 960         memcpy(pdata+uni_reqpathoffset1,uni_requestedpath,requestedpathlen);
 961         memcpy(pdata+uni_reqpathoffset2,uni_requestedpath,requestedpathlen);
 962
 963         /* create the header */
 964         SSVAL(pdata,0,requestedpathlen - 2); /* UCS2 of path consumed minus
 965                                                 2 byte null */
 966         /* number of referral in this pkt */
 967         SSVAL(pdata,2,junction->referral_count);
 968         if(self_referral) {
 969                 SIVAL(pdata,4,DFSREF_REFERRAL_SERVER | DFSREF_STORAGE_SERVER);
 970         } else {
 971                 SIVAL(pdata,4,DFSREF_STORAGE_SERVER);
 972         }
 973
 974         offset = 8;
 975         /* add the referral elements */
 976         for(i=0;i<junction->referral_count;i++) {
 977                 struct referral* ref = &junction->referral_list[i];
 978                 int unilen;
 979
 980                 SSVAL(pdata,offset,2); /* version 2 */
 981                 SSVAL(pdata,offset+2,VERSION2_REFERRAL_SIZE);
 982                 if(self_referral) {
 983                         SSVAL(pdata,offset+4,1);
 984                 } else {
 985                         SSVAL(pdata,offset+4,0);
 986                 }
 987
 988                 /* ref_flags :use path_consumed bytes? */
 989                 SSVAL(pdata,offset+6,0);
 990                 SIVAL(pdata,offset+8,ref->proximity);
 991                 SIVAL(pdata,offset+12,ref->ttl);
 992
 993                 SSVAL(pdata,offset+16,uni_reqpathoffset1-offset);
 994                 SSVAL(pdata,offset+18,uni_reqpathoffset2-offset);
 995                 /* copy referred path into current offset */
 996                 unilen = rpcstr_push(pdata+uni_curroffset,
 997                                         ref->alternate_path,
 998                                         reply_size - uni_curroffset,
 999                                         STR_UNICODE);
1000
1001                 SSVAL(pdata,offset+20,uni_curroffset-offset);
1002
1003                 uni_curroffset += unilen;
1004                 offset += VERSION2_REFERRAL_SIZE;
1005         }
1006         /* add in the unexplained 22 (0x16) bytes at the end */
1007         memset(pdata+uni_curroffset,'\0',0x16);
1008         return reply_size;
1009 }
1010
1011 static int setup_ver3_dfs_referral(const char *pathname,
1012                                 char **ppdata,
1013                                 struct junction_map *junction,
1014                                 bool self_referral)
1015 {
1016         char *pdata = *ppdata;
1017
1018         smb_ucs2_t *uni_reqpath = NULL;
1019         int uni_reqpathoffset1, uni_reqpathoffset2;
1020         int uni_curroffset;
1021         int reply_size = 0;
1022
1023         int reqpathlen = 0;
1024         int offset,i=0;
1025
1026         DEBUG(10,("setting up version3 referral\n"));
1027
1028         reqpathlen = rpcstr_push_talloc(talloc_tos(), &uni_reqpath, pathname);
1029         if (uni_reqpath == NULL || reqpathlen == 0) {
1030                 return -1;
1031         }
1032
1033         if (DEBUGLVL(10)) {
1034                 dump_data(0, (unsigned char *)uni_reqpath,
1035                         reqpathlen);
1036         }
1037
1038         uni_reqpathoffset1 = REFERRAL_HEADER_SIZE +
1039                         VERSION3_REFERRAL_SIZE * junction->referral_count;
1040         uni_reqpathoffset2 = uni_reqpathoffset1 + reqpathlen;
1041         reply_size = uni_curroffset = uni_reqpathoffset2 + reqpathlen;
1042
1043         for(i=0;i<junction->referral_count;i++) {
1044                 DEBUG(10,("referral %u : %s\n",
1045                         i,
1046                         junction->referral_list[i].alternate_path));
1047                 reply_size +=
1048                         (strlen(junction->referral_list[i].alternate_path)+1)*2;
1049         }
1050
1051         pdata = (char *)SMB_REALLOC(pdata,reply_size);
1052         if(pdata == NULL) {
1053                 DEBUG(0,("version3 referral setup:"
1054                         "malloc failed for Realloc!\n"));
1055                 return -1;
1056         }
1057         *ppdata = pdata;
1058
1059         /* create the header */
1060         SSVAL(pdata,0,reqpathlen - 2); /* UCS2 of path consumed minus
1061                                           2 byte null */
1062         SSVAL(pdata,2,junction->referral_count); /* number of referral */
1063         if(self_referral) {
1064                 SIVAL(pdata,4,DFSREF_REFERRAL_SERVER | DFSREF_STORAGE_SERVER);
1065         } else {
1066                 SIVAL(pdata,4,DFSREF_STORAGE_SERVER);
1067         }
1068
1069         /* copy in the reqpaths */
1070         memcpy(pdata+uni_reqpathoffset1,uni_reqpath,reqpathlen);
1071         memcpy(pdata+uni_reqpathoffset2,uni_reqpath,reqpathlen);
1072
1073         offset = 8;
1074         for(i=0;i<junction->referral_count;i++) {
1075                 struct referral* ref = &(junction->referral_list[i]);
1076                 int unilen;
1077
1078                 SSVAL(pdata,offset,3); /* version 3 */
1079                 SSVAL(pdata,offset+2,VERSION3_REFERRAL_SIZE);
1080                 if(self_referral) {
1081                         SSVAL(pdata,offset+4,1);
1082                 } else {
1083                         SSVAL(pdata,offset+4,0);
1084                 }
1085
1086                 /* ref_flags :use path_consumed bytes? */
1087                 SSVAL(pdata,offset+6,0);
1088                 SIVAL(pdata,offset+8,ref->ttl);
1089
1090                 SSVAL(pdata,offset+12,uni_reqpathoffset1-offset);
1091                 SSVAL(pdata,offset+14,uni_reqpathoffset2-offset);
1092                 /* copy referred path into current offset */
1093                 unilen = rpcstr_push(pdata+uni_curroffset,ref->alternate_path,
1094                                         reply_size - uni_curroffset,
1095                                         STR_UNICODE | STR_TERMINATE);
1096                 SSVAL(pdata,offset+16,uni_curroffset-offset);
1097                 /* copy 0x10 bytes of 00's in the ServiceSite GUID */
1098                 memset(pdata+offset+18,'\0',16);
1099
1100                 uni_curroffset += unilen;
1101                 offset += VERSION3_REFERRAL_SIZE;
1102         }
1103         return reply_size;
1104 }
1105
1106 /******************************************************************
1107  Set up the DFS referral for the dfs pathname. This call returns
1108  the amount of the path covered by this server, and where the
1109  client should be redirected to. This is the meat of the
1110  TRANS2_GET_DFS_REFERRAL call.
1111 ******************************************************************/
1112
1113 int setup_dfs_referral(connection_struct *orig_conn,
1114                         const char *dfs_path,
1115                         int max_referral_level,
1116                         char **ppdata, NTSTATUS *pstatus)
1117 {
1118         struct junction_map *junction = NULL;
1119         int consumedcnt = 0;
1120         bool self_referral = False;
1121         int reply_size = 0;
1122         char *pathnamep = NULL;
1123         char *local_dfs_path = NULL;
1124         TALLOC_CTX *ctx;
1125
1126         if (!(ctx=talloc_init("setup_dfs_referral"))) {
1127                 *pstatus = NT_STATUS_NO_MEMORY;
1128                 return -1;
1129         }
1130
1131         /* get the junction entry */
1132         if (!dfs_path) {
1133                 talloc_destroy(ctx);
1134                 *pstatus = NT_STATUS_NOT_FOUND;
1135                 return -1;
1136         }
1137
1138         /*
1139          * Trim pathname sent by client so it begins with only one backslash.
1140          * Two backslashes confuse some dfs clients
1141          */
1142
1143         local_dfs_path = talloc_strdup(ctx,dfs_path);
1144         if (!local_dfs_path) {
1145                 *pstatus = NT_STATUS_NO_MEMORY;
1146                 talloc_destroy(ctx);
1147                 return -1;
1148         }
1149         pathnamep = local_dfs_path;
1150         while (IS_DIRECTORY_SEP(pathnamep[0]) &&
1151                         IS_DIRECTORY_SEP(pathnamep[1])) {
1152                 pathnamep++;
1153         }
1154
1155         junction = TALLOC_ZERO_P(ctx, struct junction_map);
1156         if (!junction) {
1157                 *pstatus = NT_STATUS_NO_MEMORY;
1158                 talloc_destroy(ctx);
1159                 return -1;
1160         }
1161
1162         /* The following call can change cwd. */
1163         *pstatus = get_referred_path(ctx, pathnamep, junction,
1164                         &consumedcnt, &self_referral);
1165         if (!NT_STATUS_IS_OK(*pstatus)) {
1166                 vfs_ChDir(orig_conn,orig_conn->connectpath);
1167                 talloc_destroy(ctx);
1168                 return -1;
1169         }
1170         vfs_ChDir(orig_conn,orig_conn->connectpath);
1171
1172         if (!self_referral) {
1173                 pathnamep[consumedcnt] = '\0';
1174
1175                 if( DEBUGLVL( 3 ) ) {
1176                         int i=0;
1177                         dbgtext("setup_dfs_referral: Path %s to "
1178                                 "alternate path(s):",
1179                                 pathnamep);
1180                         for(i=0;i<junction->referral_count;i++)
1181                                 dbgtext(" %s",
1182                                 junction->referral_list[i].alternate_path);
1183                         dbgtext(".\n");
1184                 }
1185         }
1186
1187         /* create the referral depeding on version */
1188         DEBUG(10,("max_referral_level :%d\n",max_referral_level));
1189
1190         if (max_referral_level < 2) {
1191                 max_referral_level = 2;
1192         }
1193         if (max_referral_level > 3) {
1194                 max_referral_level = 3;
1195         }
1196
1197         switch(max_referral_level) {
1198         case 2:
1199                 reply_size = setup_ver2_dfs_referral(pathnamep,
1200                                         ppdata, junction,
1201                                         self_referral);
1202                 break;
1203         case 3:
1204                 reply_size = setup_ver3_dfs_referral(pathnamep, ppdata,
1205                                         junction, self_referral);
1206                 break;
1207         default:
1208                 DEBUG(0,("setup_dfs_referral: Invalid dfs referral "
1209                         "version: %d\n",
1210                         max_referral_level));
1211                 talloc_destroy(ctx);
1212                 *pstatus = NT_STATUS_INVALID_LEVEL;
1213                 return -1;
1214         }
1215
1216         if (DEBUGLVL(10)) {
1217                 DEBUGADD(0,("DFS Referral pdata:\n"));
1218                 dump_data(0,(uint8 *)*ppdata,reply_size);
1219         }
1220
1221         talloc_destroy(ctx);
1222         *pstatus = NT_STATUS_OK;
1223         return reply_size;
1224 }
1225
1226 /**********************************************************************
1227  The following functions are called by the NETDFS RPC pipe functions
1228  **********************************************************************/
1229
1230 /*********************************************************************
1231  Creates a junction structure from a DFS pathname
1232 **********************************************************************/
1233
1234 bool create_junction(TALLOC_CTX *ctx,
1235                 const char *dfs_path,
1236                 struct junction_map *jucn)
1237 {
1238         int snum;
1239         bool dummy;
1240         struct dfs_path *pdp = TALLOC_P(ctx,struct dfs_path);
1241         NTSTATUS status;
1242
1243         if (!pdp) {
1244                 return False;
1245         }
1246         status = parse_dfs_path(NULL, dfs_path, False, pdp, &dummy);
1247         if (!NT_STATUS_IS_OK(status)) {
1248                 return False;
1249         }
1250
1251         /* check if path is dfs : validate first token */
1252         if (!is_myname_or_ipaddr(pdp->hostname)) {
1253                 DEBUG(4,("create_junction: Invalid hostname %s "
1254                         "in dfs path %s\n",
1255                         pdp->hostname, dfs_path));
1256                 TALLOC_FREE(pdp);
1257                 return False;
1258         }
1259
1260         /* Check for a non-DFS share */
1261         snum = lp_servicenumber(pdp->servicename);
1262
1263         if(snum < 0 || !lp_msdfs_root(snum)) {
1264                 DEBUG(4,("create_junction: %s is not an msdfs root.\n",
1265                         pdp->servicename));
1266                 TALLOC_FREE(pdp);
1267                 return False;
1268         }
1269
1270         jucn->service_name = talloc_strdup(ctx, pdp->servicename);
1271         jucn->volume_name = talloc_strdup(ctx, pdp->reqpath);
1272         jucn->comment = talloc_strdup(ctx, lp_comment(snum));
1273
1274         TALLOC_FREE(pdp);
1275         if (!jucn->service_name || !jucn->volume_name || ! jucn->comment) {
1276                 return False;
1277         }
1278         return True;
1279 }
1280
1281 /**********************************************************************
1282  Forms a valid Unix pathname from the junction
1283  **********************************************************************/
1284
1285 static bool junction_to_local_path(const struct junction_map *jucn,
1286                                 char **pp_path_out,
1287                                 connection_struct *conn_out)
1288 {
1289         int snum;
1290
1291         snum = lp_servicenumber(jucn->service_name);
1292         if(snum < 0) {
1293                 return False;
1294         }
1295         if (!NT_STATUS_IS_OK(create_conn_struct(talloc_tos(),
1296                                         conn_out, snum,
1297                                         lp_pathname(snum)))) {
1298                 return False;
1299         }
1300
1301         *pp_path_out = talloc_asprintf(conn_out->mem_ctx,
1302                         "%s/%s",
1303                         lp_pathname(snum),
1304                         jucn->volume_name);
1305         if (!*pp_path_out) {
1306                 return False;
1307         }
1308         return True;
1309 }
1310
1311 bool create_msdfs_link(const struct junction_map *jucn)
1312 {
1313         char *path = NULL;
1314         char *msdfs_link = NULL;
1315         connection_struct conns;
1316         connection_struct *conn = &conns;
1317         int i=0;
1318         bool insert_comma = False;
1319         bool ret = False;
1320
1321         ZERO_STRUCT(conns);
1322
1323         if(!junction_to_local_path(jucn, &path, conn)) {
1324                 return False;
1325         }
1326
1327         /* Form the msdfs_link contents */
1328         msdfs_link = talloc_strdup(conn->mem_ctx, "msdfs:");
1329         if (!msdfs_link) {
1330                 goto out;
1331         }
1332         for(i=0; i<jucn->referral_count; i++) {
1333                 char *refpath = jucn->referral_list[i].alternate_path;
1334
1335                 /* Alternate paths always use Windows separators. */
1336                 trim_char(refpath, '\\', '\\');
1337                 if(*refpath == '\0') {
1338                         if (i == 0) {
1339                                 insert_comma = False;
1340                         }
1341                         continue;
1342                 }
1343                 if (i > 0 && insert_comma) {
1344                         msdfs_link = talloc_asprintf_append_buffer(msdfs_link,
1345                                         ",%s",
1346                                         refpath);
1347                 } else {
1348                         msdfs_link = talloc_asprintf_append_buffer(msdfs_link,
1349                                         "%s",
1350                                         refpath);
1351                 }
1352
1353                 if (!msdfs_link) {
1354                         goto out;
1355                 }
1356                 if (!insert_comma) {
1357                         insert_comma = True;
1358                 }
1359         }
1360
1361         DEBUG(5,("create_msdfs_link: Creating new msdfs link: %s -> %s\n",
1362                 path, msdfs_link));
1363
1364         if(SMB_VFS_SYMLINK(conn, msdfs_link, path) < 0) {
1365                 if (errno == EEXIST) {
1366                         if(SMB_VFS_UNLINK(conn,path)!=0) {
1367                                 goto out;
1368                         }
1369                 }
1370                 if (SMB_VFS_SYMLINK(conn, msdfs_link, path) < 0) {
1371                         DEBUG(1,("create_msdfs_link: symlink failed "
1372                                  "%s -> %s\nError: %s\n",
1373                                  path, msdfs_link, strerror(errno)));
1374                         goto out;
1375                 }
1376         }
1377
1378         ret = True;
1379
1380 out:
1381
1382         conn_free_internal(conn);
1383         return ret;
1384 }
1385
1386 bool remove_msdfs_link(const struct junction_map *jucn)
1387 {
1388         char *path = NULL;
1389         connection_struct conns;
1390         connection_struct *conn = &conns;
1391         bool ret = False;
1392
1393         ZERO_STRUCT(conns);
1394
1395         if( junction_to_local_path(jucn, &path, conn) ) {
1396                 if( SMB_VFS_UNLINK(conn, path) == 0 ) {
1397                         ret = True;
1398                 }
1399         }
1400
1401         conn_free_internal(conn);
1402         return ret;
1403 }
1404
1405 /*********************************************************************
1406  Return the number of DFS links at the root of this share.
1407 *********************************************************************/
1408
1409 static int count_dfs_links(TALLOC_CTX *ctx, int snum)
1410 {
1411         size_t cnt = 0;
1412         SMB_STRUCT_DIR *dirp = NULL;
1413         char *dname = NULL;
1414         const char *connect_path = lp_pathname(snum);
1415         const char *msdfs_proxy = lp_msdfs_proxy(snum);
1416         connection_struct conn;
1417
1418         ZERO_STRUCT(conn);
1419
1420         if(*connect_path == '\0') {
1421                 return 0;
1422         }
1423
1424         /*
1425          * Fake up a connection struct for the VFS layer.
1426          */
1427
1428         if (!NT_STATUS_IS_OK(create_conn_struct(talloc_tos(),
1429                                         &conn, snum, connect_path))) {
1430                 return 0;
1431         }
1432
1433         /* Count a link for the msdfs root - convention */
1434         cnt = 1;
1435
1436         /* No more links if this is an msdfs proxy. */
1437         if (*msdfs_proxy != '\0') {
1438                 goto out;
1439         }
1440
1441         /* Now enumerate all dfs links */
1442         dirp = SMB_VFS_OPENDIR(&conn, ".", NULL, 0);
1443         if(!dirp) {
1444                 goto out;
1445         }
1446
1447         while ((dname = vfs_readdirname(&conn, dirp)) != NULL) {
1448                 if (is_msdfs_link(&conn,
1449                                 dname,
1450                                 NULL)) {
1451                         cnt++;
1452                 }
1453         }
1454
1455         SMB_VFS_CLOSEDIR(&conn,dirp);
1456
1457 out:
1458
1459         conn_free_internal(&conn);
1460         return cnt;
1461 }
1462
1463 /*********************************************************************
1464 *********************************************************************/
1465
1466 static int form_junctions(TALLOC_CTX *ctx,
1467                                 int snum,
1468                                 struct junction_map *jucn,
1469                                 size_t jn_remain)
1470 {
1471         size_t cnt = 0;
1472         SMB_STRUCT_DIR *dirp = NULL;
1473         char *dname = NULL;
1474         const char *connect_path = lp_pathname(snum);
1475         char *service_name = lp_servicename(snum);
1476         const char *msdfs_proxy = lp_msdfs_proxy(snum);
1477         connection_struct conn;
1478         struct referral *ref = NULL;
1479
1480         ZERO_STRUCT(conn);
1481
1482         if (jn_remain == 0) {
1483                 return 0;
1484         }
1485
1486         if(*connect_path == '\0') {
1487                 return 0;
1488         }
1489
1490         /*
1491          * Fake up a connection struct for the VFS layer.
1492          */
1493
1494         if (!NT_STATUS_IS_OK(create_conn_struct(ctx, &conn, snum, connect_path))) {
1495                 return 0;
1496         }
1497
1498         /* form a junction for the msdfs root - convention
1499            DO NOT REMOVE THIS: NT clients will not work with us
1500            if this is not present
1501         */
1502         jucn[cnt].service_name = talloc_strdup(ctx,service_name);
1503         jucn[cnt].volume_name = talloc_strdup(ctx, "");
1504         if (!jucn[cnt].service_name || !jucn[cnt].volume_name) {
1505                 goto out;
1506         }
1507         jucn[cnt].comment = "";
1508         jucn[cnt].referral_count = 1;
1509
1510         ref = jucn[cnt].referral_list = TALLOC_ZERO_P(ctx, struct referral);
1511         if (jucn[cnt].referral_list == NULL) {
1512                 goto out;
1513         }
1514
1515         ref->proximity = 0;
1516         ref->ttl = REFERRAL_TTL;
1517         if (*msdfs_proxy != '\0') {
1518                 ref->alternate_path = talloc_strdup(ctx,
1519                                                 msdfs_proxy);
1520         } else {
1521                 ref->alternate_path = talloc_asprintf(ctx,
1522                         "\\\\%s\\%s",
1523                         get_local_machine_name(),
1524                         service_name);
1525         }
1526
1527         if (!ref->alternate_path) {
1528                 goto out;
1529         }
1530         cnt++;
1531
1532         /* Don't enumerate if we're an msdfs proxy. */
1533         if (*msdfs_proxy != '\0') {
1534                 goto out;
1535         }
1536
1537         /* Now enumerate all dfs links */
1538         dirp = SMB_VFS_OPENDIR(&conn, ".", NULL, 0);
1539         if(!dirp) {
1540                 goto out;
1541         }
1542
1543         while ((dname = vfs_readdirname(&conn, dirp)) != NULL) {
1544                 char *link_target = NULL;
1545                 if (cnt >= jn_remain) {
1546                         DEBUG(2, ("form_junctions: ran out of MSDFS "
1547                                 "junction slots"));
1548                         goto out;
1549                 }
1550                 if (is_msdfs_link_internal(ctx,
1551                                         &conn,
1552                                         dname, &link_target,
1553                                         NULL)) {
1554                         if (parse_msdfs_symlink(ctx,
1555                                         link_target,
1556                                         &jucn[cnt].referral_list,
1557                                         &jucn[cnt].referral_count)) {
1558
1559                                 jucn[cnt].service_name = talloc_strdup(ctx,
1560                                                                 service_name);
1561                                 jucn[cnt].volume_name = talloc_strdup(ctx,
1562                                                                 dname);
1563                                 if (!jucn[cnt].service_name ||
1564                                                 !jucn[cnt].volume_name) {
1565                                         goto out;
1566                                 }
1567                                 jucn[cnt].comment = "";
1568                                 cnt++;
1569                         }
1570                         TALLOC_FREE(link_target);
1571                 }
1572         }
1573
1574 out:
1575
1576         if (dirp) {
1577                 SMB_VFS_CLOSEDIR(&conn,dirp);
1578         }
1579
1580         conn_free_internal(&conn);
1581         return cnt;
1582 }
1583
1584 struct junction_map *enum_msdfs_links(TALLOC_CTX *ctx, size_t *p_num_jn)
1585 {
1586         struct junction_map *jn = NULL;
1587         int i=0;
1588         size_t jn_count = 0;
1589         int sharecount = 0;
1590
1591         *p_num_jn = 0;
1592         if(!lp_host_msdfs()) {
1593                 return NULL;
1594         }
1595
1596         /* Ensure all the usershares are loaded. */
1597         become_root();
1598         load_registry_shares();
1599         sharecount = load_usershare_shares();
1600         unbecome_root();
1601
1602         for(i=0;i < sharecount;i++) {
1603                 if(lp_msdfs_root(i)) {
1604                         jn_count += count_dfs_links(ctx, i);
1605                 }
1606         }
1607         if (jn_count == 0) {
1608                 return NULL;
1609         }
1610         jn = TALLOC_ARRAY(ctx,  struct junction_map, jn_count);
1611         if (!jn) {
1612                 return NULL;
1613         }
1614         for(i=0; i < sharecount; i++) {
1615                 if (*p_num_jn >= jn_count) {
1616                         break;
1617                 }
1618                 if(lp_msdfs_root(i)) {
1619                         *p_num_jn += form_junctions(ctx, i,
1620                                         &jn[*p_num_jn],
1621                                         jn_count - *p_num_jn);
1622                 }
1623         }
1624         return jn;
1625 }
1626
1627 /******************************************************************************
1628  Core function to resolve a dfs pathname.
1629 ******************************************************************************/
1630
1631 NTSTATUS resolve_dfspath(TALLOC_CTX *ctx,
1632                         connection_struct *conn,
1633                         bool dfs_pathnames,
1634                         const char *name_in,
1635                         char **pp_name_out)
1636 {
1637         NTSTATUS status = NT_STATUS_OK;
1638         bool dummy;
1639         if (dfs_pathnames) {
1640                 status = dfs_redirect(ctx,
1641                                         conn,
1642                                         name_in,
1643                                         False,
1644                                         pp_name_out,
1645                                         &dummy);
1646         } else {
1647                 /*
1648                  * Cheat and just return a copy of the in ptr.
1649                  * Once srvstr_get_path() uses talloc it'll
1650                  * be a talloced ptr anyway.
1651                  */
1652                 *pp_name_out = CONST_DISCARD(char *,name_in);
1653         }
1654         return status;
1655 }
1656
1657 /******************************************************************************
1658  Core function to resolve a dfs pathname possibly containing a wildcard.
1659  This function is identical to the above except for the bool param to
1660  dfs_redirect but I need this to be separate so it's really clear when
1661  we're allowing wildcards and when we're not. JRA.
1662 ******************************************************************************/
1663
1664 NTSTATUS resolve_dfspath_wcard(TALLOC_CTX *ctx,
1665                                 connection_struct *conn,
1666                                 bool dfs_pathnames,
1667                                 const char *name_in,
1668                                 char **pp_name_out,
1669                                 bool *ppath_contains_wcard)
1670 {
1671         NTSTATUS status = NT_STATUS_OK;
1672         if (dfs_pathnames) {
1673                 status = dfs_redirect(ctx,
1674                                         conn,
1675                                         name_in,
1676                                         True,
1677                                         pp_name_out,
1678                                         ppath_contains_wcard);
1679         } else {
1680                 /*
1681                  * Cheat and just return a copy of the in ptr.
1682                  * Once srvstr_get_path() uses talloc it'll
1683                  * be a talloced ptr anyway.
1684                  */
1685                 *pp_name_out = CONST_DISCARD(char *,name_in);
1686         }
1687         return status;
1688 }