source3/modules/vfs_streams_depot.c

   1 /*
   2  * Store streams in a separate subdirectory
   3  *
   4  * Copyright (C) Volker Lendecke, 2007
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "includes.h"
  21 #include "smbd/smbd.h"
  22 #include "system/filesys.h"
  23
  24 #undef DBGC_CLASS
  25 #define DBGC_CLASS DBGC_VFS
  26
  27 /*
  28  * Excerpt from a mail from tridge:
  29  *
  30  * Volker, what I'm thinking of is this:
  31  * /mount-point/.streams/XX/YY/aaaa.bbbb/namedstream1
  32  * /mount-point/.streams/XX/YY/aaaa.bbbb/namedstream2
  33  *
  34  * where XX/YY is a 2 level hash based on the fsid/inode. "aaaa.bbbb"
  35  * is the fsid/inode. "namedstreamX" is a file named after the stream
  36  * name.
  37  */
  38
  39 static uint32_t hash_fn(DATA_BLOB key)
  40 {
  41         uint32_t value; /* Used to compute the hash value.  */
  42         uint32_t i;     /* Used to cycle through random values. */
  43
  44         /* Set the initial value from the key size. */
  45         for (value = 0x238F13AF * key.length, i=0; i < key.length; i++)
  46                 value = (value + (key.data[i] << (i*5 % 24)));
  47
  48         return (1103515243 * value + 12345);
  49 }
  50
  51 /*
  52  * With the hashing scheme based on the inode we need to protect against
  53  * streams showing up on files with re-used inodes. This can happen if we
  54  * create a stream directory from within Samba, and a local process or NFS
  55  * client deletes the file without deleting the streams directory. When the
  56  * inode is re-used and the stream directory is still around, the streams in
  57  * there would be show up as belonging to the new file.
  58  *
  59  * There are several workarounds for this, probably the easiest one is on
  60  * systems which have a true birthtime stat element: When the file has a later
  61  * birthtime than the streams directory, then we have to recreate the
  62  * directory.
  63  *
  64  * The other workaround is to somehow mark the file as generated by Samba with
  65  * something that a NFS client would not do. The closest one is a special
  66  * xattr value being set. On systems which do not support xattrs, it might be
  67  * an option to put in a special ACL entry for a non-existing group.
  68  */
  69
  70 static bool file_is_valid(vfs_handle_struct *handle,
  71                         const struct smb_filename *smb_fname)
  72 {
  73         char buf;
  74         NTSTATUS status;
  75         struct smb_filename *pathref = NULL;
  76         int ret;
  77
  78         DEBUG(10, ("file_is_valid (%s) called\n", smb_fname->base_name));
  79
  80         status = synthetic_pathref(talloc_tos(),
  81                                 handle->conn->cwd_fsp,
  82                                 smb_fname->base_name,
  83                                 NULL,
  84                                 NULL,
  85                                 smb_fname->twrp,
  86                                 smb_fname->flags,
  87                                 &pathref);
  88         if (!NT_STATUS_IS_OK(status)) {
  89                 return false;
  90         }
  91         ret = SMB_VFS_FGETXATTR(pathref->fsp,
  92                                 SAMBA_XATTR_MARKER,
  93                                 &buf,
  94                                 sizeof(buf));
  95         if (ret != sizeof(buf)) {
  96                 int saved_errno = errno;
  97                 DBG_DEBUG("FGETXATTR failed: %s\n", strerror(saved_errno));
  98                 TALLOC_FREE(pathref);
  99                 errno = saved_errno;
 100                 return false;
 101         }
 102
 103         TALLOC_FREE(pathref);
 104
 105         if (buf != '1') {
 106                 DEBUG(10, ("got wrong buffer content: '%c'\n", buf));
 107                 return false;
 108         }
 109
 110         return true;
 111 }
 112
 113 static bool mark_file_valid(vfs_handle_struct *handle,
 114                                 const struct smb_filename *smb_fname)
 115 {
 116         char buf = '1';
 117         int ret;
 118
 119         DEBUG(10, ("marking file %s as valid\n", smb_fname->base_name));
 120
 121         ret = SMB_VFS_FSETXATTR(smb_fname->fsp, SAMBA_XATTR_MARKER,
 122                                     &buf, sizeof(buf), 0);
 123
 124         if (ret == -1) {
 125                 DEBUG(10, ("SETXATTR failed: %s\n", strerror(errno)));
 126                 return false;
 127         }
 128
 129         return true;
 130 }
 131
 132 /*
 133  * Return the root of the stream directory. Can be
 134  * external to the share definition but by default
 135  * is "handle->conn->connectpath/.streams".
 136  *
 137  * Note that this is an *absolute* path, starting
 138  * with '/', so the dirfsp being used in the
 139  * calls below isn't looked at.
 140  */
 141
 142 static char *stream_rootdir(vfs_handle_struct *handle,
 143                             TALLOC_CTX *ctx)
 144 {
 145         const struct loadparm_substitution *lp_sub =
 146                 loadparm_s3_global_substitution();
 147         char *tmp;
 148
 149         tmp = talloc_asprintf(ctx,
 150                               "%s/.streams",
 151                               handle->conn->connectpath);
 152         if (tmp == NULL) {
 153                 errno = ENOMEM;
 154                 return NULL;
 155         }
 156
 157         return lp_parm_substituted_string(ctx,
 158                                           lp_sub,
 159                                           SNUM(handle->conn),
 160                                           "streams_depot",
 161                                           "directory",
 162                                           tmp);
 163 }
 164
 165 /**
 166  * Given an smb_filename, determine the stream directory using the file's
 167  * base_name.
 168  */
 169 static char *stream_dir(vfs_handle_struct *handle,
 170                         const struct smb_filename *smb_fname,
 171                         const SMB_STRUCT_STAT *base_sbuf, bool create_it)
 172 {
 173         uint32_t hash;
 174         struct smb_filename *smb_fname_hash = NULL;
 175         char *result = NULL;
 176         SMB_STRUCT_STAT base_sbuf_tmp;
 177         char *tmp = NULL;
 178         uint8_t first, second;
 179         char *id_hex;
 180         struct file_id id;
 181         uint8_t id_buf[16];
 182         bool check_valid;
 183         char *rootdir = NULL;
 184         struct smb_filename *rootdir_fname = NULL;
 185         struct smb_filename *tmp_fname = NULL;
 186         struct smb_filename *tmpref = NULL;
 187         const struct smb_filename *pathref = NULL;
 188         int ret;
 189
 190         check_valid = lp_parm_bool(SNUM(handle->conn),
 191                       "streams_depot", "check_valid", true);
 192
 193         rootdir = stream_rootdir(handle,
 194                                  talloc_tos());
 195         if (rootdir == NULL) {
 196                 errno = ENOMEM;
 197                 goto fail;
 198         }
 199
 200         rootdir_fname = synthetic_smb_fname(talloc_tos(),
 201                                         rootdir,
 202                                         NULL,
 203                                         NULL,
 204                                         smb_fname->twrp,
 205                                         smb_fname->flags);
 206         if (rootdir_fname == NULL) {
 207                 errno = ENOMEM;
 208                 goto fail;
 209         }
 210
 211         /* Stat the base file if it hasn't already been done. */
 212         if (base_sbuf == NULL) {
 213                 struct smb_filename *smb_fname_base;
 214
 215                 smb_fname_base = synthetic_smb_fname(
 216                                         talloc_tos(),
 217                                         smb_fname->base_name,
 218                                         NULL,
 219                                         NULL,
 220                                         smb_fname->twrp,
 221                                         smb_fname->flags);
 222                 if (smb_fname_base == NULL) {
 223                         errno = ENOMEM;
 224                         goto fail;
 225                 }
 226                 if (SMB_VFS_NEXT_STAT(handle, smb_fname_base) == -1) {
 227                         TALLOC_FREE(smb_fname_base);
 228                         goto fail;
 229                 }
 230                 base_sbuf_tmp = smb_fname_base->st;
 231                 TALLOC_FREE(smb_fname_base);
 232         } else {
 233                 base_sbuf_tmp = *base_sbuf;
 234         }
 235
 236         id = SMB_VFS_FILE_ID_CREATE(handle->conn, &base_sbuf_tmp);
 237
 238         push_file_id_16((char *)id_buf, &id);
 239
 240         hash = hash_fn(data_blob_const(id_buf, sizeof(id_buf)));
 241
 242         first = hash & 0xff;
 243         second = (hash >> 8) & 0xff;
 244
 245         id_hex = hex_encode_talloc(talloc_tos(), id_buf, sizeof(id_buf));
 246
 247         if (id_hex == NULL) {
 248                 errno = ENOMEM;
 249                 goto fail;
 250         }
 251
 252         result = talloc_asprintf(talloc_tos(), "%s/%2.2X/%2.2X/%s", rootdir,
 253                                  first, second, id_hex);
 254
 255         TALLOC_FREE(id_hex);
 256
 257         if (result == NULL) {
 258                 errno = ENOMEM;
 259                 return NULL;
 260         }
 261
 262         smb_fname_hash = synthetic_smb_fname(talloc_tos(),
 263                                         result,
 264                                         NULL,
 265                                         NULL,
 266                                         smb_fname->twrp,
 267                                         smb_fname->flags);
 268         if (smb_fname_hash == NULL) {
 269                 errno = ENOMEM;
 270                 goto fail;
 271         }
 272
 273         if (SMB_VFS_NEXT_STAT(handle, smb_fname_hash) == 0) {
 274                 struct smb_filename *smb_fname_new = NULL;
 275                 char *newname;
 276                 bool delete_lost;
 277
 278                 if (!S_ISDIR(smb_fname_hash->st.st_ex_mode)) {
 279                         errno = EINVAL;
 280                         goto fail;
 281                 }
 282
 283                 if (!check_valid ||
 284                     file_is_valid(handle, smb_fname)) {
 285                         return result;
 286                 }
 287
 288                 /*
 289                  * Someone has recreated a file under an existing inode
 290                  * without deleting the streams directory.
 291                  * Move it away or remove if streams_depot:delete_lost is set.
 292                  */
 293
 294         again:
 295                 delete_lost = lp_parm_bool(SNUM(handle->conn), "streams_depot",
 296                                            "delete_lost", false);
 297
 298                 if (delete_lost) {
 299                         DEBUG(3, ("Someone has recreated a file under an "
 300                               "existing inode. Removing: %s\n",
 301                               smb_fname_hash->base_name));
 302                         recursive_rmdir(talloc_tos(), handle->conn,
 303                                         smb_fname_hash);
 304                         SMB_VFS_NEXT_UNLINKAT(handle,
 305                                         handle->conn->cwd_fsp,
 306                                         smb_fname_hash,
 307                                         AT_REMOVEDIR);
 308                 } else {
 309                         newname = talloc_asprintf(talloc_tos(), "lost-%lu",
 310                                                   random());
 311                         DEBUG(3, ("Someone has recreated a file under an "
 312                               "existing inode. Renaming: %s to: %s\n",
 313                               smb_fname_hash->base_name,
 314                               newname));
 315                         if (newname == NULL) {
 316                                 errno = ENOMEM;
 317                                 goto fail;
 318                         }
 319
 320                         smb_fname_new = synthetic_smb_fname(
 321                                                 talloc_tos(),
 322                                                 newname,
 323                                                 NULL,
 324                                                 NULL,
 325                                                 smb_fname->twrp,
 326                                                 smb_fname->flags);
 327                         TALLOC_FREE(newname);
 328                         if (smb_fname_new == NULL) {
 329                                 errno = ENOMEM;
 330                                 goto fail;
 331                         }
 332
 333                         if (SMB_VFS_NEXT_RENAMEAT(handle,
 334                                         handle->conn->cwd_fsp,
 335                                         smb_fname_hash,
 336                                         handle->conn->cwd_fsp,
 337                                         smb_fname_new) == -1) {
 338                                 TALLOC_FREE(smb_fname_new);
 339                                 if ((errno == EEXIST) || (errno == ENOTEMPTY)) {
 340                                         goto again;
 341                                 }
 342                                 goto fail;
 343                         }
 344
 345                         TALLOC_FREE(smb_fname_new);
 346                 }
 347         }
 348
 349         if (!create_it) {
 350                 errno = ENOENT;
 351                 goto fail;
 352         }
 353
 354         ret = SMB_VFS_NEXT_MKDIRAT(handle,
 355                                 handle->conn->cwd_fsp,
 356                                 rootdir_fname,
 357                                 0755);
 358         if ((ret != 0) && (errno != EEXIST)) {
 359                 goto fail;
 360         }
 361
 362         tmp = talloc_asprintf(result, "%s/%2.2X", rootdir, first);
 363         if (tmp == NULL) {
 364                 errno = ENOMEM;
 365                 goto fail;
 366         }
 367
 368         tmp_fname = synthetic_smb_fname(talloc_tos(),
 369                                         tmp,
 370                                         NULL,
 371                                         NULL,
 372                                         smb_fname->twrp,
 373                                         smb_fname->flags);
 374         if (tmp_fname == NULL) {
 375                 errno = ENOMEM;
 376                 goto fail;
 377         }
 378
 379         ret = SMB_VFS_NEXT_MKDIRAT(handle,
 380                                 handle->conn->cwd_fsp,
 381                                 tmp_fname,
 382                                 0755);
 383         if ((ret != 0) && (errno != EEXIST)) {
 384                 goto fail;
 385         }
 386
 387         TALLOC_FREE(tmp);
 388         TALLOC_FREE(tmp_fname);
 389
 390         tmp = talloc_asprintf(result, "%s/%2.2X/%2.2X", rootdir, first,
 391                               second);
 392         if (tmp == NULL) {
 393                 errno = ENOMEM;
 394                 goto fail;
 395         }
 396
 397         tmp_fname = synthetic_smb_fname(talloc_tos(),
 398                                         tmp,
 399                                         NULL,
 400                                         NULL,
 401                                         smb_fname->twrp,
 402                                         smb_fname->flags);
 403         if (tmp_fname == NULL) {
 404                 errno = ENOMEM;
 405                 goto fail;
 406         }
 407
 408         ret = SMB_VFS_NEXT_MKDIRAT(handle,
 409                         handle->conn->cwd_fsp,
 410                         tmp_fname,
 411                         0755);
 412         if ((ret != 0) && (errno != EEXIST)) {
 413                 goto fail;
 414         }
 415
 416         TALLOC_FREE(tmp);
 417         TALLOC_FREE(tmp_fname);
 418
 419         /* smb_fname_hash is the struct smb_filename version of 'result' */
 420         ret = SMB_VFS_NEXT_MKDIRAT(handle,
 421                         handle->conn->cwd_fsp,
 422                         smb_fname_hash,
 423                         0755);
 424         if ((ret != 0) && (errno != EEXIST)) {
 425                 goto fail;
 426         }
 427         pathref = smb_fname;
 428         if (smb_fname->fsp == NULL) {
 429                 NTSTATUS status;
 430                 status = synthetic_pathref(talloc_tos(),
 431                                         handle->conn->cwd_fsp,
 432                                         smb_fname->base_name,
 433                                         NULL,
 434                                         NULL,
 435                                         smb_fname->twrp,
 436                                         smb_fname->flags,
 437                                         &tmpref);
 438                 if (!NT_STATUS_IS_OK(status)) {
 439                         goto fail;
 440                 }
 441                 pathref = tmpref;
 442         }
 443         if (check_valid && !mark_file_valid(handle, pathref)) {
 444                 goto fail;
 445         }
 446
 447         TALLOC_FREE(tmpref);
 448         TALLOC_FREE(rootdir_fname);
 449         TALLOC_FREE(rootdir);
 450         TALLOC_FREE(tmp_fname);
 451         TALLOC_FREE(smb_fname_hash);
 452         return result;
 453
 454  fail:
 455         TALLOC_FREE(tmpref);
 456         TALLOC_FREE(rootdir_fname);
 457         TALLOC_FREE(rootdir);
 458         TALLOC_FREE(tmp_fname);
 459         TALLOC_FREE(smb_fname_hash);
 460         TALLOC_FREE(result);
 461         return NULL;
 462 }
 463 /**
 464  * Given a stream name, populate smb_fname_out with the actual location of the
 465  * stream.
 466  */
 467 static NTSTATUS stream_smb_fname(vfs_handle_struct *handle,
 468                                  const struct smb_filename *smb_fname,
 469                                  struct smb_filename **smb_fname_out,
 470                                  bool create_dir)
 471 {
 472         char *dirname, *stream_fname;
 473         const char *stype;
 474         NTSTATUS status;
 475
 476         *smb_fname_out = NULL;
 477
 478         stype = strchr_m(smb_fname->stream_name + 1, ':');
 479
 480         if (stype) {
 481                 if (strcasecmp_m(stype, ":$DATA") != 0) {
 482                         return NT_STATUS_INVALID_PARAMETER;
 483                 }
 484         }
 485
 486         dirname = stream_dir(handle, smb_fname, NULL, create_dir);
 487
 488         if (dirname == NULL) {
 489                 status = map_nt_error_from_unix(errno);
 490                 goto fail;
 491         }
 492
 493         stream_fname = talloc_asprintf(talloc_tos(), "%s/%s", dirname,
 494                                        smb_fname->stream_name);
 495
 496         if (stream_fname == NULL) {
 497                 status = NT_STATUS_NO_MEMORY;
 498                 goto fail;
 499         }
 500
 501         if (stype == NULL) {
 502                 /* Append an explicit stream type if one wasn't specified. */
 503                 stream_fname = talloc_asprintf(talloc_tos(), "%s:$DATA",
 504                                                stream_fname);
 505                 if (stream_fname == NULL) {
 506                         status = NT_STATUS_NO_MEMORY;
 507                         goto fail;
 508                 }
 509         } else {
 510                 /* Normalize the stream type to upercase. */
 511                 if (!strupper_m(strrchr_m(stream_fname, ':') + 1)) {
 512                         status = NT_STATUS_INVALID_PARAMETER;
 513                         goto fail;
 514                 }
 515         }
 516
 517         DEBUG(10, ("stream filename = %s\n", stream_fname));
 518
 519         /* Create an smb_filename with stream_name == NULL. */
 520         *smb_fname_out = synthetic_smb_fname(talloc_tos(),
 521                                         stream_fname,
 522                                         NULL,
 523                                         NULL,
 524                                         smb_fname->twrp,
 525                                         smb_fname->flags);
 526         if (*smb_fname_out == NULL) {
 527                 return NT_STATUS_NO_MEMORY;
 528         }
 529
 530         return NT_STATUS_OK;
 531
 532  fail:
 533         DEBUG(5, ("stream_name failed: %s\n", strerror(errno)));
 534         TALLOC_FREE(*smb_fname_out);
 535         return status;
 536 }
 537
 538 static NTSTATUS walk_streams(vfs_handle_struct *handle,
 539                              struct smb_filename *smb_fname_base,
 540                              char **pdirname,
 541                              bool (*fn)(const struct smb_filename *dirname,
 542                                         const char *dirent,
 543                                         void *private_data),
 544                              void *private_data)
 545 {
 546         char *dirname;
 547         char *rootdir = NULL;
 548         char *orig_connectpath = NULL;
 549         struct smb_filename *dir_smb_fname = NULL;
 550         struct smb_Dir *dir_hnd = NULL;
 551         const char *dname = NULL;
 552         long offset = 0;
 553         char *talloced = NULL;
 554         NTSTATUS status;
 555
 556         dirname = stream_dir(handle, smb_fname_base, &smb_fname_base->st,
 557                              false);
 558
 559         if (dirname == NULL) {
 560                 if (errno == ENOENT) {
 561                         /*
 562                          * no stream around
 563                          */
 564                         return NT_STATUS_OK;
 565                 }
 566                 return map_nt_error_from_unix(errno);
 567         }
 568
 569         DEBUG(10, ("walk_streams: dirname=%s\n", dirname));
 570
 571         dir_smb_fname = synthetic_smb_fname(talloc_tos(),
 572                                         dirname,
 573                                         NULL,
 574                                         NULL,
 575                                         smb_fname_base->twrp,
 576                                         smb_fname_base->flags);
 577         if (dir_smb_fname == NULL) {
 578                 TALLOC_FREE(dirname);
 579                 return NT_STATUS_NO_MEMORY;
 580         }
 581
 582         /*
 583          * For OpenDir to succeed if the stream rootdir is outside
 584          * the share path, we must temporarily swap out the connect
 585          * path for this share. We're dealing with absolute paths
 586          * here so we don't care about chdir calls.
 587          */
 588         rootdir = stream_rootdir(handle, talloc_tos());
 589         if (rootdir == NULL) {
 590                 TALLOC_FREE(dir_smb_fname);
 591                 TALLOC_FREE(dirname);
 592                 return NT_STATUS_NO_MEMORY;
 593         }
 594
 595         orig_connectpath = handle->conn->connectpath;
 596         handle->conn->connectpath = rootdir;
 597
 598         status = OpenDir(
 599                 talloc_tos(), handle->conn, dir_smb_fname, NULL, 0, &dir_hnd);
 600         if (!NT_STATUS_IS_OK(status)) {
 601                 handle->conn->connectpath = orig_connectpath;
 602                 TALLOC_FREE(rootdir);
 603                 TALLOC_FREE(dir_smb_fname);
 604                 TALLOC_FREE(dirname);
 605                 return status;
 606         }
 607
 608         while ((dname = ReadDirName(dir_hnd, &offset, NULL, &talloced))
 609                != NULL)
 610         {
 611                 if (ISDOT(dname) || ISDOTDOT(dname)) {
 612                         TALLOC_FREE(talloced);
 613                         continue;
 614                 }
 615
 616                 DBG_DEBUG("dirent=%s\n", dname);
 617
 618                 if (!fn(dir_smb_fname, dname, private_data)) {
 619                         TALLOC_FREE(talloced);
 620                         break;
 621                 }
 622                 TALLOC_FREE(talloced);
 623         }
 624
 625         /* Restore the original connectpath. */
 626         handle->conn->connectpath = orig_connectpath;
 627         TALLOC_FREE(rootdir);
 628         TALLOC_FREE(dir_smb_fname);
 629         TALLOC_FREE(dir_hnd);
 630
 631         if (pdirname != NULL) {
 632                 *pdirname = dirname;
 633         }
 634         else {
 635                 TALLOC_FREE(dirname);
 636         }
 637
 638         return NT_STATUS_OK;
 639 }
 640
 641 static int streams_depot_stat(vfs_handle_struct *handle,
 642                               struct smb_filename *smb_fname)
 643 {
 644         struct smb_filename *smb_fname_stream = NULL;
 645         NTSTATUS status;
 646         int ret = -1;
 647
 648         DEBUG(10, ("streams_depot_stat called for [%s]\n",
 649                    smb_fname_str_dbg(smb_fname)));
 650
 651         if (!is_named_stream(smb_fname)) {
 652                 return SMB_VFS_NEXT_STAT(handle, smb_fname);
 653         }
 654
 655         /* Stat the actual stream now. */
 656         status = stream_smb_fname(handle, smb_fname, &smb_fname_stream,
 657                                   false);
 658         if (!NT_STATUS_IS_OK(status)) {
 659                 ret = -1;
 660                 errno = map_errno_from_nt_status(status);
 661                 goto done;
 662         }
 663
 664         ret = SMB_VFS_NEXT_STAT(handle, smb_fname_stream);
 665
 666         /* Update the original smb_fname with the stat info. */
 667         smb_fname->st = smb_fname_stream->st;
 668  done:
 669         TALLOC_FREE(smb_fname_stream);
 670         return ret;
 671 }
 672
 673
 674
 675 static int streams_depot_lstat(vfs_handle_struct *handle,
 676                                struct smb_filename *smb_fname)
 677 {
 678         struct smb_filename *smb_fname_stream = NULL;
 679         NTSTATUS status;
 680         int ret = -1;
 681
 682         DEBUG(10, ("streams_depot_lstat called for [%s]\n",
 683                    smb_fname_str_dbg(smb_fname)));
 684
 685         if (!is_named_stream(smb_fname)) {
 686                 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
 687         }
 688
 689         /* Stat the actual stream now. */
 690         status = stream_smb_fname(handle, smb_fname, &smb_fname_stream,
 691                                   false);
 692         if (!NT_STATUS_IS_OK(status)) {
 693                 ret = -1;
 694                 errno = map_errno_from_nt_status(status);
 695                 goto done;
 696         }
 697
 698         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_stream);
 699
 700  done:
 701         TALLOC_FREE(smb_fname_stream);
 702         return ret;
 703 }
 704
 705 static int streams_depot_openat(struct vfs_handle_struct *handle,
 706                                 const struct files_struct *dirfsp,
 707                                 const struct smb_filename *smb_fname,
 708                                 struct files_struct *fsp,
 709                                 int flags,
 710                                 mode_t mode)
 711 {
 712         struct smb_filename *smb_fname_stream = NULL;
 713         struct files_struct *fspcwd = NULL;
 714         NTSTATUS status;
 715         int ret = -1;
 716
 717         if (!is_named_stream(smb_fname)) {
 718                 return SMB_VFS_NEXT_OPENAT(handle,
 719                                            dirfsp,
 720                                            smb_fname,
 721                                            fsp,
 722                                            flags,
 723                                            mode);
 724         }
 725
 726         SMB_ASSERT(fsp_is_alternate_stream(fsp));
 727         SMB_ASSERT(VALID_STAT(fsp->base_fsp->fsp_name->st));
 728
 729         /* Determine the stream name, and then open it. */
 730         status = stream_smb_fname(handle, smb_fname, &smb_fname_stream, true);
 731         if (!NT_STATUS_IS_OK(status)) {
 732                 ret = -1;
 733                 errno = map_errno_from_nt_status(status);
 734                 goto done;
 735         }
 736
 737         status = vfs_at_fspcwd(talloc_tos(), handle->conn, &fspcwd);
 738         if (!NT_STATUS_IS_OK(status)) {
 739                 ret = -1;
 740                 errno = map_errno_from_nt_status(status);
 741                 goto done;
 742         }
 743
 744         ret = SMB_VFS_NEXT_OPENAT(handle,
 745                                   fspcwd,
 746                                   smb_fname_stream,
 747                                   fsp,
 748                                   flags,
 749                                   mode);
 750
 751  done:
 752         TALLOC_FREE(smb_fname_stream);
 753         TALLOC_FREE(fspcwd);
 754         return ret;
 755 }
 756
 757 static int streams_depot_unlink_internal(vfs_handle_struct *handle,
 758                                 struct files_struct *dirfsp,
 759                                 const struct smb_filename *smb_fname,
 760                                 int flags)
 761 {
 762         struct smb_filename *full_fname = NULL;
 763         char *dirname = NULL;
 764         int ret = -1;
 765
 766         full_fname = full_path_from_dirfsp_atname(talloc_tos(),
 767                                                   dirfsp,
 768                                                   smb_fname);
 769         if (full_fname == NULL) {
 770                 return -1;
 771         }
 772
 773         DEBUG(10, ("streams_depot_unlink called for %s\n",
 774                    smb_fname_str_dbg(full_fname)));
 775
 776         /* If there is a valid stream, just unlink the stream and return. */
 777         if (is_named_stream(full_fname)) {
 778                 struct smb_filename *smb_fname_stream = NULL;
 779                 NTSTATUS status;
 780
 781                 status = stream_smb_fname(handle, full_fname, &smb_fname_stream,
 782                                           false);
 783                 TALLOC_FREE(full_fname);
 784                 if (!NT_STATUS_IS_OK(status)) {
 785                         errno = map_errno_from_nt_status(status);
 786                         return -1;
 787                 }
 788
 789                 ret = SMB_VFS_NEXT_UNLINKAT(handle,
 790                                 dirfsp->conn->cwd_fsp,
 791                                 smb_fname_stream,
 792                                 0);
 793
 794                 TALLOC_FREE(smb_fname_stream);
 795                 return ret;
 796         }
 797
 798         /*
 799          * We potentially need to delete the per-inode streams directory
 800          */
 801
 802         if (full_fname->flags & SMB_FILENAME_POSIX_PATH) {
 803                 ret = SMB_VFS_NEXT_LSTAT(handle, full_fname);
 804         } else {
 805                 ret = SMB_VFS_NEXT_STAT(handle, full_fname);
 806                 if (ret == -1 && (errno == ENOENT || errno == ELOOP)) {
 807                         if (VALID_STAT(smb_fname->st) &&
 808                                         S_ISLNK(smb_fname->st.st_ex_mode)) {
 809                                 /*
 810                                  * Original name was a link - Could be
 811                                  * trying to remove a dangling symlink.
 812                                  */
 813                                 ret = SMB_VFS_NEXT_LSTAT(handle, full_fname);
 814                         }
 815                 }
 816         }
 817         if (ret == -1) {
 818                 TALLOC_FREE(full_fname);
 819                 return -1;
 820         }
 821
 822         /*
 823          * We know the unlink should succeed as the ACL
 824          * check is already done in the caller. Remove the
 825          * file *after* the streams.
 826          */
 827         dirname = stream_dir(handle,
 828                              full_fname,
 829                              &full_fname->st,
 830                              false);
 831         TALLOC_FREE(full_fname);
 832         if (dirname != NULL) {
 833                 struct smb_filename *smb_fname_dir = NULL;
 834
 835                 smb_fname_dir = synthetic_smb_fname(talloc_tos(),
 836                                                     dirname,
 837                                                     NULL,
 838                                                     NULL,
 839                                                     smb_fname->twrp,
 840                                                     smb_fname->flags);
 841                 if (smb_fname_dir == NULL) {
 842                         TALLOC_FREE(dirname);
 843                         errno = ENOMEM;
 844                         return -1;
 845                 }
 846
 847                 SMB_VFS_NEXT_UNLINKAT(handle,
 848                                       dirfsp->conn->cwd_fsp,
 849                                       smb_fname_dir,
 850                                       AT_REMOVEDIR);
 851                 TALLOC_FREE(smb_fname_dir);
 852                 TALLOC_FREE(dirname);
 853         }
 854
 855         ret = SMB_VFS_NEXT_UNLINKAT(handle,
 856                                 dirfsp,
 857                                 smb_fname,
 858                                 flags);
 859         return ret;
 860 }
 861
 862 static int streams_depot_rmdir_internal(vfs_handle_struct *handle,
 863                         struct files_struct *dirfsp,
 864                         const struct smb_filename *smb_fname)
 865 {
 866         struct smb_filename *full_fname = NULL;
 867         struct smb_filename *smb_fname_base = NULL;
 868         int ret = -1;
 869
 870         full_fname = full_path_from_dirfsp_atname(talloc_tos(),
 871                                                   dirfsp,
 872                                                   smb_fname);
 873         if (full_fname == NULL) {
 874                 return -1;
 875         }
 876
 877         DBG_DEBUG("called for %s\n", full_fname->base_name);
 878
 879         /*
 880          * We potentially need to delete the per-inode streams directory
 881          */
 882
 883         smb_fname_base = synthetic_smb_fname(talloc_tos(),
 884                                 full_fname->base_name,
 885                                 NULL,
 886                                 NULL,
 887                                 full_fname->twrp,
 888                                 full_fname->flags);
 889         TALLOC_FREE(full_fname);
 890         if (smb_fname_base == NULL) {
 891                 errno = ENOMEM;
 892                 return -1;
 893         }
 894
 895         if (smb_fname_base->flags & SMB_FILENAME_POSIX_PATH) {
 896                 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname_base);
 897         } else {
 898                 ret = SMB_VFS_NEXT_STAT(handle, smb_fname_base);
 899         }
 900
 901         if (ret == -1) {
 902                 TALLOC_FREE(smb_fname_base);
 903                 return -1;
 904         }
 905
 906         /*
 907          * We know the rmdir should succeed as the ACL
 908          * check is already done in the caller. Remove the
 909          * directory *after* the streams.
 910          */
 911         {
 912                 char *dirname = stream_dir(handle, smb_fname_base,
 913                                            &smb_fname_base->st, false);
 914
 915                 if (dirname != NULL) {
 916                         struct smb_filename *smb_fname_dir =
 917                                 synthetic_smb_fname(talloc_tos(),
 918                                                 dirname,
 919                                                 NULL,
 920                                                 NULL,
 921                                                 smb_fname->twrp,
 922                                                 smb_fname->flags);
 923                         if (smb_fname_dir == NULL) {
 924                                 TALLOC_FREE(smb_fname_base);
 925                                 TALLOC_FREE(dirname);
 926                                 errno = ENOMEM;
 927                                 return -1;
 928                         }
 929                         SMB_VFS_NEXT_UNLINKAT(handle,
 930                                         dirfsp->conn->cwd_fsp,
 931                                         smb_fname_dir,
 932                                         AT_REMOVEDIR);
 933                         TALLOC_FREE(smb_fname_dir);
 934                 }
 935                 TALLOC_FREE(dirname);
 936         }
 937
 938         ret = SMB_VFS_NEXT_UNLINKAT(handle,
 939                                 dirfsp,
 940                                 smb_fname,
 941                                 AT_REMOVEDIR);
 942         TALLOC_FREE(smb_fname_base);
 943         return ret;
 944 }
 945
 946 static int streams_depot_unlinkat(vfs_handle_struct *handle,
 947                         struct files_struct *dirfsp,
 948                         const struct smb_filename *smb_fname,
 949                         int flags)
 950 {
 951         int ret;
 952         if (flags & AT_REMOVEDIR) {
 953                 ret = streams_depot_rmdir_internal(handle,
 954                                 dirfsp,
 955                                 smb_fname);
 956         } else {
 957                 ret = streams_depot_unlink_internal(handle,
 958                                 dirfsp,
 959                                 smb_fname,
 960                                 flags);
 961         }
 962         return ret;
 963 }
 964
 965 static int streams_depot_renameat(vfs_handle_struct *handle,
 966                                 files_struct *srcfsp,
 967                                 const struct smb_filename *smb_fname_src,
 968                                 files_struct *dstfsp,
 969                                 const struct smb_filename *smb_fname_dst)
 970 {
 971         struct smb_filename *smb_fname_src_stream = NULL;
 972         struct smb_filename *smb_fname_dst_stream = NULL;
 973         struct smb_filename *full_src = NULL;
 974         struct smb_filename *full_dst = NULL;
 975         bool src_is_stream, dst_is_stream;
 976         NTSTATUS status;
 977         int ret = -1;
 978
 979         DEBUG(10, ("streams_depot_renameat called for %s => %s\n",
 980                    smb_fname_str_dbg(smb_fname_src),
 981                    smb_fname_str_dbg(smb_fname_dst)));
 982
 983         src_is_stream = is_ntfs_stream_smb_fname(smb_fname_src);
 984         dst_is_stream = is_ntfs_stream_smb_fname(smb_fname_dst);
 985
 986         if (!src_is_stream && !dst_is_stream) {
 987                 return SMB_VFS_NEXT_RENAMEAT(handle,
 988                                         srcfsp,
 989                                         smb_fname_src,
 990                                         dstfsp,
 991                                         smb_fname_dst);
 992         }
 993
 994         /* for now don't allow renames from or to the default stream */
 995         if (is_ntfs_default_stream_smb_fname(smb_fname_src) ||
 996             is_ntfs_default_stream_smb_fname(smb_fname_dst)) {
 997                 errno = ENOSYS;
 998                 goto done;
 999         }
1000
1001         full_src = full_path_from_dirfsp_atname(talloc_tos(),
1002                                                 srcfsp,
1003                                                 smb_fname_src);
1004         if (full_src == NULL) {
1005                 errno = ENOMEM;
1006                 goto done;
1007         }
1008
1009         full_dst = full_path_from_dirfsp_atname(talloc_tos(),
1010                                                 dstfsp,
1011                                                 smb_fname_dst);
1012         if (full_dst == NULL) {
1013                 errno = ENOMEM;
1014                 goto done;
1015         }
1016
1017         status = stream_smb_fname(handle, full_src, &smb_fname_src_stream,
1018                                   false);
1019         if (!NT_STATUS_IS_OK(status)) {
1020                 errno = map_errno_from_nt_status(status);
1021                 goto done;
1022         }
1023
1024         status = stream_smb_fname(handle, full_dst,
1025                                   &smb_fname_dst_stream, false);
1026         if (!NT_STATUS_IS_OK(status)) {
1027                 errno = map_errno_from_nt_status(status);
1028                 goto done;
1029         }
1030
1031         /*
1032          * We must use handle->conn->cwd_fsp as
1033          * srcfsp and dstfsp directory handles here
1034          * as we used the full pathname from the cwd dir
1035          * to calculate the streams directory and filename
1036          * within.
1037          */
1038         ret = SMB_VFS_NEXT_RENAMEAT(handle,
1039                                 handle->conn->cwd_fsp,
1040                                 smb_fname_src_stream,
1041                                 handle->conn->cwd_fsp,
1042                                 smb_fname_dst_stream);
1043
1044 done:
1045         TALLOC_FREE(smb_fname_src_stream);
1046         TALLOC_FREE(smb_fname_dst_stream);
1047         return ret;
1048 }
1049
1050 static bool add_one_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
1051                            struct stream_struct **streams,
1052                            const char *name, off_t size,
1053                            off_t alloc_size)
1054 {
1055         struct stream_struct *tmp;
1056
1057         tmp = talloc_realloc(mem_ctx, *streams, struct stream_struct,
1058                                    (*num_streams)+1);
1059         if (tmp == NULL) {
1060                 return false;
1061         }
1062
1063         tmp[*num_streams].name = talloc_strdup(tmp, name);
1064         if (tmp[*num_streams].name == NULL) {
1065                 return false;
1066         }
1067
1068         tmp[*num_streams].size = size;
1069         tmp[*num_streams].alloc_size = alloc_size;
1070
1071         *streams = tmp;
1072         *num_streams += 1;
1073         return true;
1074 }
1075
1076 struct streaminfo_state {
1077         TALLOC_CTX *mem_ctx;
1078         vfs_handle_struct *handle;
1079         unsigned int num_streams;
1080         struct stream_struct *streams;
1081         NTSTATUS status;
1082 };
1083
1084 static bool collect_one_stream(const struct smb_filename *dirfname,
1085                                const char *dirent,
1086                                void *private_data)
1087 {
1088         const char *dirname = dirfname->base_name;
1089         struct streaminfo_state *state =
1090                 (struct streaminfo_state *)private_data;
1091         struct smb_filename *smb_fname = NULL;
1092         char *sname = NULL;
1093         bool ret;
1094
1095         sname = talloc_asprintf(talloc_tos(), "%s/%s", dirname, dirent);
1096         if (sname == NULL) {
1097                 state->status = NT_STATUS_NO_MEMORY;
1098                 ret = false;
1099                 goto out;
1100         }
1101
1102         smb_fname = synthetic_smb_fname(talloc_tos(),
1103                                         sname,
1104                                         NULL,
1105                                         NULL,
1106                                         dirfname->twrp,
1107                                         0);
1108         if (smb_fname == NULL) {
1109                 state->status = NT_STATUS_NO_MEMORY;
1110                 ret = false;
1111                 goto out;
1112         }
1113
1114         if (SMB_VFS_NEXT_STAT(state->handle, smb_fname) == -1) {
1115                 DEBUG(10, ("Could not stat %s: %s\n", sname,
1116                            strerror(errno)));
1117                 ret = true;
1118                 goto out;
1119         }
1120
1121         if (!add_one_stream(state->mem_ctx,
1122                             &state->num_streams, &state->streams,
1123                             dirent, smb_fname->st.st_ex_size,
1124                             SMB_VFS_GET_ALLOC_SIZE(state->handle->conn, NULL,
1125                                                    &smb_fname->st))) {
1126                 state->status = NT_STATUS_NO_MEMORY;
1127                 ret = false;
1128                 goto out;
1129         }
1130
1131         ret = true;
1132  out:
1133         TALLOC_FREE(sname);
1134         TALLOC_FREE(smb_fname);
1135         return ret;
1136 }
1137
1138 static NTSTATUS streams_depot_fstreaminfo(vfs_handle_struct *handle,
1139                                          struct files_struct *fsp,
1140                                          TALLOC_CTX *mem_ctx,
1141                                          unsigned int *pnum_streams,
1142                                          struct stream_struct **pstreams)
1143 {
1144         struct smb_filename *smb_fname_base = NULL;
1145         int ret;
1146         NTSTATUS status;
1147         struct streaminfo_state state;
1148
1149         smb_fname_base = synthetic_smb_fname(talloc_tos(),
1150                                         fsp->fsp_name->base_name,
1151                                         NULL,
1152                                         NULL,
1153                                         fsp->fsp_name->twrp,
1154                                         fsp->fsp_name->flags);
1155         if (smb_fname_base == NULL) {
1156                 return NT_STATUS_NO_MEMORY;
1157         }
1158
1159         ret = SMB_VFS_NEXT_FSTAT(handle, fsp, &smb_fname_base->st);
1160         if (ret == -1) {
1161                 status = map_nt_error_from_unix(errno);
1162                 goto out;
1163         }
1164
1165         state.streams = *pstreams;
1166         state.num_streams = *pnum_streams;
1167         state.mem_ctx = mem_ctx;
1168         state.handle = handle;
1169         state.status = NT_STATUS_OK;
1170
1171         status = walk_streams(handle,
1172                                 smb_fname_base,
1173                                 NULL,
1174                                 collect_one_stream,
1175                                 &state);
1176
1177         if (!NT_STATUS_IS_OK(status)) {
1178                 TALLOC_FREE(state.streams);
1179                 goto out;
1180         }
1181
1182         if (!NT_STATUS_IS_OK(state.status)) {
1183                 TALLOC_FREE(state.streams);
1184                 status = state.status;
1185                 goto out;
1186         }
1187
1188         *pnum_streams = state.num_streams;
1189         *pstreams = state.streams;
1190         status = SMB_VFS_NEXT_FSTREAMINFO(handle,
1191                                 fsp->base_fsp ? fsp->base_fsp : fsp,
1192                                 mem_ctx,
1193                                 pnum_streams,
1194                                 pstreams);
1195
1196  out:
1197         TALLOC_FREE(smb_fname_base);
1198         return status;
1199 }
1200
1201 static uint32_t streams_depot_fs_capabilities(struct vfs_handle_struct *handle,
1202                         enum timestamp_set_resolution *p_ts_res)
1203 {
1204         return SMB_VFS_NEXT_FS_CAPABILITIES(handle, p_ts_res) | FILE_NAMED_STREAMS;
1205 }
1206
1207 static struct vfs_fn_pointers vfs_streams_depot_fns = {
1208         .fs_capabilities_fn = streams_depot_fs_capabilities,
1209         .openat_fn = streams_depot_openat,
1210         .stat_fn = streams_depot_stat,
1211         .lstat_fn = streams_depot_lstat,
1212         .unlinkat_fn = streams_depot_unlinkat,
1213         .renameat_fn = streams_depot_renameat,
1214         .fstreaminfo_fn = streams_depot_fstreaminfo,
1215 };
1216
1217 static_decl_vfs;
1218 NTSTATUS vfs_streams_depot_init(TALLOC_CTX *ctx)
1219 {
1220         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "streams_depot",
1221                                 &vfs_streams_depot_fns);
1222 }