source3/modules/vfs_shadow_copy2.c

   1 /*
   2  * shadow_copy2: a shadow copy module (second implementation)
   3  *
   4  * Copyright (C) Andrew Tridgell   2007 (portions taken from shadow_copy2)
   5  * Copyright (C) Ed Plese          2009
   6  * Copyright (C) Volker Lendecke   2011
   7  * Copyright (C) Christian Ambach  2011
   8  * Copyright (C) Michael Adam      2013
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 /*
  26  * This is a second implemetation of a shadow copy module for exposing
  27  * file system snapshots to windows clients as shadow copies.
  28  *
  29  * See the manual page for documentation.
  30  */
  31
  32 #include "includes.h"
  33 #include "system/filesys.h"
  34 #include "include/ntioctl.h"
  35 #include <ccan/hash/hash.h>
  36 #include "util_tdb.h"
  37
  38 struct shadow_copy2_config {
  39         char *gmt_format;
  40         bool use_sscanf;
  41         bool use_localtime;
  42         char *snapdir;
  43         bool snapdirseverywhere;
  44         bool crossmountpoints;
  45         bool fixinodes;
  46         char *sort_order;
  47         bool snapdir_absolute;
  48         char *basedir;
  49         char *mount_point;
  50         char *rel_connectpath; /* share root, relative to the basedir */
  51         char *snapshot_basepath; /* the absolute version of snapdir */
  52 };
  53
  54 static bool shadow_copy2_find_slashes(TALLOC_CTX *mem_ctx, const char *str,
  55                                       size_t **poffsets,
  56                                       unsigned *pnum_offsets)
  57 {
  58         unsigned num_offsets;
  59         size_t *offsets;
  60         const char *p;
  61
  62         num_offsets = 0;
  63
  64         p = str;
  65         while ((p = strchr(p, '/')) != NULL) {
  66                 num_offsets += 1;
  67                 p += 1;
  68         }
  69
  70         offsets = talloc_array(mem_ctx, size_t, num_offsets);
  71         if (offsets == NULL) {
  72                 return false;
  73         }
  74
  75         p = str;
  76         num_offsets = 0;
  77         while ((p = strchr(p, '/')) != NULL) {
  78                 offsets[num_offsets] = p-str;
  79                 num_offsets += 1;
  80                 p += 1;
  81         }
  82
  83         *poffsets = offsets;
  84         *pnum_offsets = num_offsets;
  85         return true;
  86 }
  87
  88 /**
  89  * Given a timestamp, build the posix level GMT-tag string
  90  * based on the configurable format.
  91  */
  92 static size_t shadow_copy2_posix_gmt_string(struct vfs_handle_struct *handle,
  93                                             time_t snapshot,
  94                                             char *snaptime_string,
  95                                             size_t len)
  96 {
  97         struct tm snap_tm;
  98         size_t snaptime_len;
  99         struct shadow_copy2_config *config;
 100
 101         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
 102                                 return 0);
 103
 104         if (config->use_sscanf) {
 105                 snaptime_len = snprintf(snaptime_string,
 106                                         len,
 107                                         config->gmt_format,
 108                                         (unsigned long)snapshot);
 109                 if (snaptime_len <= 0) {
 110                         DEBUG(10, ("snprintf failed\n"));
 111                         return snaptime_len;
 112                 }
 113         } else {
 114                 if (config->use_localtime) {
 115                         if (localtime_r(&snapshot, &snap_tm) == 0) {
 116                                 DEBUG(10, ("gmtime_r failed\n"));
 117                                 return -1;
 118                         }
 119                 } else {
 120                         if (gmtime_r(&snapshot, &snap_tm) == 0) {
 121                                 DEBUG(10, ("gmtime_r failed\n"));
 122                                 return -1;
 123                         }
 124                 }
 125                 snaptime_len = strftime(snaptime_string,
 126                                         len,
 127                                         config->gmt_format,
 128                                         &snap_tm);
 129                 if (snaptime_len == 0) {
 130                         DEBUG(10, ("strftime failed\n"));
 131                         return 0;
 132                 }
 133         }
 134
 135         return snaptime_len;
 136 }
 137
 138 /**
 139  * Given a timestamp, build the string to insert into a path
 140  * as a path component for creating the local path to the
 141  * snapshot at the given timestamp of the input path.
 142  *
 143  * In the case of a parallel snapdir (specified with an
 144  * absolute path), this is the inital portion of the
 145  * local path of any snapshot file. The complete path is
 146  * obtained by appending the portion of the file's path
 147  * below the share root's mountpoint.
 148  */
 149 static char *shadow_copy2_insert_string(TALLOC_CTX *mem_ctx,
 150                                         struct vfs_handle_struct *handle,
 151                                         time_t snapshot)
 152 {
 153         fstring snaptime_string;
 154         size_t snaptime_len = 0;
 155         char *result = NULL;
 156         struct shadow_copy2_config *config;
 157
 158         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
 159                                 return NULL);
 160
 161         snaptime_len = shadow_copy2_posix_gmt_string(handle,
 162                                                      snapshot,
 163                                                      snaptime_string,
 164                                                      sizeof(snaptime_string));
 165         if (snaptime_len <= 0) {
 166                 return NULL;
 167         }
 168
 169         if (config->snapdir_absolute) {
 170                 result = talloc_asprintf(mem_ctx, "%s/%s",
 171                                          config->snapdir, snaptime_string);
 172         } else {
 173                 result = talloc_asprintf(mem_ctx, "/%s/%s",
 174                                          config->snapdir, snaptime_string);
 175         }
 176         if (result == NULL) {
 177                 DEBUG(1, (__location__ " talloc_asprintf failed\n"));
 178         }
 179
 180         return result;
 181 }
 182
 183 /**
 184  * Build the posix snapshot path for the connection
 185  * at the given timestamp, i.e. the absolute posix path
 186  * that contains the snapshot for this file system.
 187  *
 188  * This only applies to classical case, i.e. not
 189  * to the "snapdirseverywhere" mode.
 190  */
 191 static char *shadow_copy2_snapshot_path(TALLOC_CTX *mem_ctx,
 192                                         struct vfs_handle_struct *handle,
 193                                         time_t snapshot)
 194 {
 195         fstring snaptime_string;
 196         size_t snaptime_len = 0;
 197         char *result = NULL;
 198         struct shadow_copy2_config *config;
 199
 200         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
 201                                 return NULL);
 202
 203         snaptime_len = shadow_copy2_posix_gmt_string(handle,
 204                                                      snapshot,
 205                                                      snaptime_string,
 206                                                      sizeof(snaptime_string));
 207         if (snaptime_len <= 0) {
 208                 return NULL;
 209         }
 210
 211         result = talloc_asprintf(mem_ctx, "%s/%s",
 212                                  config->snapshot_basepath, snaptime_string);
 213         if (result == NULL) {
 214                 DEBUG(1, (__location__ " talloc_asprintf failed\n"));
 215         }
 216
 217         return result;
 218 }
 219
 220 /**
 221  * Strip a snapshot component from a filename as
 222  * handed in via the smb layer.
 223  * Returns the parsed timestamp and the stripped filename.
 224  */
 225 static bool shadow_copy2_strip_snapshot(TALLOC_CTX *mem_ctx,
 226                                         struct vfs_handle_struct *handle,
 227                                         const char *name,
 228                                         time_t *ptimestamp,
 229                                         char **pstripped)
 230 {
 231         struct tm tm;
 232         time_t timestamp;
 233         const char *p;
 234         char *q;
 235         char *stripped;
 236         size_t rest_len, dst_len;
 237         struct shadow_copy2_config *config;
 238         const char *snapdir;
 239         ssize_t snapdirlen;
 240         ptrdiff_t len_before_gmt;
 241
 242         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
 243                                 return false);
 244
 245         DEBUG(10, (__location__ ": enter path '%s'\n", name));
 246
 247         p = strstr_m(name, "@GMT-");
 248         if (p == NULL) {
 249                 DEBUG(11, ("@GMT not found\n"));
 250                 goto no_snapshot;
 251         }
 252         if ((p > name) && (p[-1] != '/')) {
 253                 /* the GMT-token does not start a path-component */
 254                 DEBUG(10, ("not at start, p=%p, name=%p, p[-1]=%d\n",
 255                            p, name, (int)p[-1]));
 256                 goto no_snapshot;
 257         }
 258
 259         /*
 260          * Figure out whether we got an already converted string. One
 261          * case where this happens is in a smb2 create call with the
 262          * mxac create blob set. We do the get_acl call on
 263          * fsp->fsp_name, which is already converted. We are converted
 264          * if we got a file name of the form ".snapshots/@GMT-",
 265          * i.e. ".snapshots/" precedes "p".
 266          */
 267
 268         snapdir = lp_parm_const_string(SNUM(handle->conn), "shadow", "snapdir",
 269                                        ".snapshots");
 270         snapdirlen = strlen(snapdir);
 271         len_before_gmt = p - name;
 272
 273         if ((len_before_gmt >= (snapdirlen + 1)) && (p[-1] == '/')) {
 274                 const char *parent_snapdir = p - (snapdirlen+1);
 275
 276                 DEBUG(10, ("parent_snapdir = %s\n", parent_snapdir));
 277
 278                 if (strncmp(parent_snapdir, snapdir, snapdirlen) == 0) {
 279                         DEBUG(10, ("name=%s is already converted\n", name));
 280                         goto no_snapshot;
 281                 }
 282         }
 283         q = strptime(p, GMT_FORMAT, &tm);
 284         if (q == NULL) {
 285                 DEBUG(10, ("strptime failed\n"));
 286                 goto no_snapshot;
 287         }
 288         tm.tm_isdst = -1;
 289         timestamp = timegm(&tm);
 290         if (timestamp == (time_t)-1) {
 291                 DEBUG(10, ("timestamp==-1\n"));
 292                 goto no_snapshot;
 293         }
 294         if (q[0] == '\0') {
 295                 /*
 296                  * The name consists of only the GMT token or the GMT
 297                  * token is at the end of the path. XP seems to send
 298                  * @GMT- at the end under certain circumstances even
 299                  * with a path prefix.
 300                  */
 301                 if (pstripped != NULL) {
 302                         stripped = talloc_strndup(mem_ctx, name, p - name);
 303                         if (stripped == NULL) {
 304                                 return false;
 305                         }
 306                         *pstripped = stripped;
 307                 }
 308                 *ptimestamp = timestamp;
 309                 return true;
 310         }
 311         if (q[0] != '/') {
 312                 /*
 313                  * It is not a complete path component, i.e. the path
 314                  * component continues after the gmt-token.
 315                  */
 316                 DEBUG(10, ("q[0] = %d\n", (int)q[0]));
 317                 goto no_snapshot;
 318         }
 319         q += 1;
 320
 321         rest_len = strlen(q);
 322         dst_len = (p-name) + rest_len;
 323
 324         if (config->snapdirseverywhere) {
 325                 char *insert;
 326                 bool have_insert;
 327                 insert = shadow_copy2_insert_string(talloc_tos(), handle,
 328                                                     timestamp);
 329                 if (insert == NULL) {
 330                         errno = ENOMEM;
 331                         return false;
 332                 }
 333
 334                 DEBUG(10, (__location__ ": snapdirseverywhere mode.\n"
 335                            "path '%s'.\n"
 336                            "insert string '%s'\n", name, insert));
 337
 338                 have_insert = (strstr(name, insert+1) != NULL);
 339                 DEBUG(10, ("have_insert=%d, name=%s, insert+1=%s\n",
 340                            (int)have_insert, name, insert+1));
 341                 if (have_insert) {
 342                         DEBUG(10, (__location__ ": insert string '%s' found in "
 343                                    "path '%s' found in snapdirseverywhere mode "
 344                                    "==> already converted\n", insert, name));
 345                         TALLOC_FREE(insert);
 346                         goto no_snapshot;
 347                 }
 348                 TALLOC_FREE(insert);
 349         } else {
 350                 char *snapshot_path;
 351                 char *s;
 352
 353                 snapshot_path = shadow_copy2_snapshot_path(talloc_tos(),
 354                                                            handle,
 355                                                            timestamp);
 356                 if (snapshot_path == NULL) {
 357                         errno = ENOMEM;
 358                         return false;
 359                 }
 360
 361                 DEBUG(10, (__location__ " path: '%s'.\n"
 362                            "snapshot path: '%s'\n", name, snapshot_path));
 363
 364                 s = strstr(name, snapshot_path);
 365                 if (s == name) {
 366                         /*
 367                          * this starts with "snapshot_basepath/GMT-Token"
 368                          * so it is already a converted absolute
 369                          * path. Don't process further.
 370                          */
 371                         DEBUG(10, (__location__ ": path '%s' starts with "
 372                                    "snapshot path '%s' (not in "
 373                                    "snapdirseverywhere mode) ==> "
 374                                    "already converted\n", name, snapshot_path));
 375                         talloc_free(snapshot_path);
 376                         goto no_snapshot;
 377                 }
 378                 talloc_free(snapshot_path);
 379         }
 380
 381         if (pstripped != NULL) {
 382                 stripped = talloc_array(mem_ctx, char, dst_len+1);
 383                 if (stripped == NULL) {
 384                         errno = ENOMEM;
 385                         return false;
 386                 }
 387                 if (p > name) {
 388                         memcpy(stripped, name, p-name);
 389                 }
 390                 if (rest_len > 0) {
 391                         memcpy(stripped + (p-name), q, rest_len);
 392                 }
 393                 stripped[dst_len] = '\0';
 394                 *pstripped = stripped;
 395         }
 396         *ptimestamp = timestamp;
 397         return true;
 398 no_snapshot:
 399         *ptimestamp = 0;
 400         return true;
 401 }
 402
 403 static char *shadow_copy2_find_mount_point(TALLOC_CTX *mem_ctx,
 404                                            vfs_handle_struct *handle)
 405 {
 406         char *path = talloc_strdup(mem_ctx, handle->conn->connectpath);
 407         dev_t dev;
 408         struct stat st;
 409         char *p;
 410
 411         if (stat(path, &st) != 0) {
 412                 talloc_free(path);
 413                 return NULL;
 414         }
 415
 416         dev = st.st_dev;
 417
 418         while ((p = strrchr(path, '/')) && p > path) {
 419                 *p = 0;
 420                 if (stat(path, &st) != 0) {
 421                         talloc_free(path);
 422                         return NULL;
 423                 }
 424                 if (st.st_dev != dev) {
 425                         *p = '/';
 426                         break;
 427                 }
 428         }
 429
 430         return path;
 431 }
 432
 433 /**
 434  * Convert from a name as handed in via the SMB layer
 435  * and a timestamp into the local path of the snapshot
 436  * of the provided file at the provided time.
 437  */
 438 static char *shadow_copy2_convert(TALLOC_CTX *mem_ctx,
 439                                   struct vfs_handle_struct *handle,
 440                                   const char *name, time_t timestamp)
 441 {
 442         struct smb_filename converted_fname;
 443         char *result = NULL;
 444         size_t *slashes = NULL;
 445         unsigned num_slashes;
 446         char *path = NULL;
 447         size_t pathlen;
 448         char *insert = NULL;
 449         char *converted = NULL;
 450         size_t insertlen;
 451         int i, saved_errno;
 452         size_t min_offset;
 453         struct shadow_copy2_config *config;
 454
 455         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
 456                                 return NULL);
 457
 458         DEBUG(10, ("converting '%s'\n", name));
 459
 460         if (!config->snapdirseverywhere) {
 461                 int ret;
 462                 char *snapshot_path;
 463
 464                 snapshot_path = shadow_copy2_snapshot_path(talloc_tos(),
 465                                                            handle,
 466                                                            timestamp);
 467                 if (snapshot_path == NULL) {
 468                         goto fail;
 469                 }
 470
 471                 if (config->rel_connectpath == NULL) {
 472                         converted = talloc_asprintf(mem_ctx, "%s/%s",
 473                                                     snapshot_path, name);
 474                 } else {
 475                         converted = talloc_asprintf(mem_ctx, "%s/%s/%s",
 476                                                     snapshot_path,
 477                                                     config->rel_connectpath,
 478                                                     name);
 479                 }
 480                 if (converted == NULL) {
 481                         goto fail;
 482                 }
 483
 484                 ZERO_STRUCT(converted_fname);
 485                 converted_fname.base_name = converted;
 486
 487                 ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname);
 488                 DEBUG(10, ("Trying[not snapdirseverywhere] %s: %d (%s)\n",
 489                            converted,
 490                            ret, ret == 0 ? "ok" : strerror(errno)));
 491                 if (ret == 0) {
 492                         DEBUG(10, ("Found %s\n", converted));
 493                         result = converted;
 494                         converted = NULL;
 495                         goto fail;
 496                 } else {
 497                         errno = ENOENT;
 498                         goto fail;
 499                 }
 500                 /* never reached ... */
 501         }
 502
 503         if (name[0] == 0) {
 504                 path = talloc_strdup(mem_ctx, handle->conn->connectpath);
 505         } else {
 506                 path = talloc_asprintf(
 507                         mem_ctx, "%s/%s", handle->conn->connectpath, name);
 508         }
 509         if (path == NULL) {
 510                 errno = ENOMEM;
 511                 goto fail;
 512         }
 513         pathlen = talloc_get_size(path)-1;
 514
 515         if (!shadow_copy2_find_slashes(talloc_tos(), path,
 516                                        &slashes, &num_slashes)) {
 517                 goto fail;
 518         }
 519
 520         insert = shadow_copy2_insert_string(talloc_tos(), handle, timestamp);
 521         if (insert == NULL) {
 522                 goto fail;
 523         }
 524         insertlen = talloc_get_size(insert)-1;
 525
 526         /*
 527          * Note: We deliberatly don't expensively initialize the
 528          * array with talloc_zero here: Putting zero into
 529          * converted[pathlen+insertlen] below is sufficient, because
 530          * in the following for loop, the insert string is inserted
 531          * at various slash places. So the memory up to position
 532          * pathlen+insertlen will always be initialized when the
 533          * converted string is used.
 534          */
 535         converted = talloc_array(mem_ctx, char, pathlen + insertlen + 1);
 536         if (converted == NULL) {
 537                 goto fail;
 538         }
 539
 540         if (path[pathlen-1] != '/') {
 541                 /*
 542                  * Append a fake slash to find the snapshot root
 543                  */
 544                 size_t *tmp;
 545                 tmp = talloc_realloc(talloc_tos(), slashes,
 546                                      size_t, num_slashes+1);
 547                 if (tmp == NULL) {
 548                         goto fail;
 549                 }
 550                 slashes = tmp;
 551                 slashes[num_slashes] = pathlen;
 552                 num_slashes += 1;
 553         }
 554
 555         min_offset = 0;
 556
 557         if (!config->crossmountpoints) {
 558                 min_offset = strlen(config->mount_point);
 559         }
 560
 561         memcpy(converted, path, pathlen+1);
 562         converted[pathlen+insertlen] = '\0';
 563
 564         ZERO_STRUCT(converted_fname);
 565         converted_fname.base_name = converted;
 566
 567         for (i = num_slashes-1; i>=0; i--) {
 568                 int ret;
 569                 size_t offset;
 570
 571                 offset = slashes[i];
 572
 573                 if (offset < min_offset) {
 574                         errno = ENOENT;
 575                         goto fail;
 576                 }
 577
 578                 memcpy(converted+offset, insert, insertlen);
 579
 580                 offset += insertlen;
 581                 memcpy(converted+offset, path + slashes[i],
 582                        pathlen - slashes[i]);
 583
 584                 ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname);
 585
 586                 DEBUG(10, ("Trying[snapdirseverywhere] %s: %d (%s)\n",
 587                            converted,
 588                            ret, ret == 0 ? "ok" : strerror(errno)));
 589                 if (ret == 0) {
 590                         /* success */
 591                         break;
 592                 }
 593                 if (errno == ENOTDIR) {
 594                         /*
 595                          * This is a valid condition: We appended the
 596                          * .snaphots/@GMT.. to a file name. Just try
 597                          * with the upper levels.
 598                          */
 599                         continue;
 600                 }
 601                 if (errno != ENOENT) {
 602                         /* Other problem than "not found" */
 603                         goto fail;
 604                 }
 605         }
 606
 607         if (i >= 0) {
 608                 /*
 609                  * Found something
 610                  */
 611                 DEBUG(10, ("Found %s\n", converted));
 612                 result = converted;
 613                 converted = NULL;
 614         } else {
 615                 errno = ENOENT;
 616         }
 617 fail:
 618         saved_errno = errno;
 619         TALLOC_FREE(converted);
 620         TALLOC_FREE(insert);
 621         TALLOC_FREE(slashes);
 622         TALLOC_FREE(path);
 623         errno = saved_errno;
 624         return result;
 625 }
 626
 627 /*
 628   modify a sbuf return to ensure that inodes in the shadow directory
 629   are different from those in the main directory
 630  */
 631 static void convert_sbuf(vfs_handle_struct *handle, const char *fname,
 632                          SMB_STRUCT_STAT *sbuf)
 633 {
 634         struct shadow_copy2_config *config;
 635
 636         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
 637                                 return);
 638
 639         if (config->fixinodes) {
 640                 /* some snapshot systems, like GPFS, return the name
 641                    device:inode for the snapshot files as the current
 642                    files. That breaks the 'restore' button in the shadow copy
 643                    GUI, as the client gets a sharing violation.
 644
 645                    This is a crude way of allowing both files to be
 646                    open at once. It has a slight chance of inode
 647                    number collision, but I can't see a better approach
 648                    without significant VFS changes
 649                 */
 650                 uint32_t shash;
 651
 652                 shash = hash(fname, strlen(fname), 0) & 0xFF000000;
 653                 if (shash == 0) {
 654                         shash = 1;
 655                 }
 656                 sbuf->st_ex_ino ^= shash;
 657         }
 658 }
 659
 660 static DIR *shadow_copy2_opendir(vfs_handle_struct *handle,
 661                                             const char *fname,
 662                                             const char *mask,
 663                                             uint32 attr)
 664 {
 665         time_t timestamp;
 666         char *stripped;
 667         DIR *ret;
 668         int saved_errno;
 669         char *conv;
 670
 671         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 672                                          &timestamp, &stripped)) {
 673                 return NULL;
 674         }
 675         if (timestamp == 0) {
 676                 return SMB_VFS_NEXT_OPENDIR(handle, fname, mask, attr);
 677         }
 678         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 679         TALLOC_FREE(stripped);
 680         if (conv == NULL) {
 681                 return NULL;
 682         }
 683         ret = SMB_VFS_NEXT_OPENDIR(handle, conv, mask, attr);
 684         saved_errno = errno;
 685         TALLOC_FREE(conv);
 686         errno = saved_errno;
 687         return ret;
 688 }
 689
 690 static int shadow_copy2_rename(vfs_handle_struct *handle,
 691                                const struct smb_filename *smb_fname_src,
 692                                const struct smb_filename *smb_fname_dst)
 693 {
 694         time_t timestamp_src, timestamp_dst;
 695
 696         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 697                                          smb_fname_src->base_name,
 698                                          &timestamp_src, NULL)) {
 699                 return -1;
 700         }
 701         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 702                                          smb_fname_dst->base_name,
 703                                          &timestamp_dst, NULL)) {
 704                 return -1;
 705         }
 706         if (timestamp_src != 0) {
 707                 errno = EXDEV;
 708                 return -1;
 709         }
 710         if (timestamp_dst != 0) {
 711                 errno = EROFS;
 712                 return -1;
 713         }
 714         return SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
 715 }
 716
 717 static int shadow_copy2_symlink(vfs_handle_struct *handle,
 718                                 const char *oldname, const char *newname)
 719 {
 720         time_t timestamp_old, timestamp_new;
 721
 722         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
 723                                          &timestamp_old, NULL)) {
 724                 return -1;
 725         }
 726         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
 727                                          &timestamp_new, NULL)) {
 728                 return -1;
 729         }
 730         if ((timestamp_old != 0) || (timestamp_new != 0)) {
 731                 errno = EROFS;
 732                 return -1;
 733         }
 734         return SMB_VFS_NEXT_SYMLINK(handle, oldname, newname);
 735 }
 736
 737 static int shadow_copy2_link(vfs_handle_struct *handle,
 738                              const char *oldname, const char *newname)
 739 {
 740         time_t timestamp_old, timestamp_new;
 741
 742         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
 743                                          &timestamp_old, NULL)) {
 744                 return -1;
 745         }
 746         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
 747                                          &timestamp_new, NULL)) {
 748                 return -1;
 749         }
 750         if ((timestamp_old != 0) || (timestamp_new != 0)) {
 751                 errno = EROFS;
 752                 return -1;
 753         }
 754         return SMB_VFS_NEXT_LINK(handle, oldname, newname);
 755 }
 756
 757 static int shadow_copy2_stat(vfs_handle_struct *handle,
 758                              struct smb_filename *smb_fname)
 759 {
 760         time_t timestamp;
 761         char *stripped, *tmp;
 762         int ret, saved_errno;
 763
 764         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 765                                          smb_fname->base_name,
 766                                          &timestamp, &stripped)) {
 767                 return -1;
 768         }
 769         if (timestamp == 0) {
 770                 return SMB_VFS_NEXT_STAT(handle, smb_fname);
 771         }
 772
 773         tmp = smb_fname->base_name;
 774         smb_fname->base_name = shadow_copy2_convert(
 775                 talloc_tos(), handle, stripped, timestamp);
 776         TALLOC_FREE(stripped);
 777
 778         if (smb_fname->base_name == NULL) {
 779                 smb_fname->base_name = tmp;
 780                 return -1;
 781         }
 782
 783         ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
 784         saved_errno = errno;
 785
 786         TALLOC_FREE(smb_fname->base_name);
 787         smb_fname->base_name = tmp;
 788
 789         if (ret == 0) {
 790                 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
 791         }
 792         errno = saved_errno;
 793         return ret;
 794 }
 795
 796 static int shadow_copy2_lstat(vfs_handle_struct *handle,
 797                               struct smb_filename *smb_fname)
 798 {
 799         time_t timestamp;
 800         char *stripped, *tmp;
 801         int ret, saved_errno;
 802
 803         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 804                                          smb_fname->base_name,
 805                                          &timestamp, &stripped)) {
 806                 return -1;
 807         }
 808         if (timestamp == 0) {
 809                 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
 810         }
 811
 812         tmp = smb_fname->base_name;
 813         smb_fname->base_name = shadow_copy2_convert(
 814                 talloc_tos(), handle, stripped, timestamp);
 815         TALLOC_FREE(stripped);
 816
 817         if (smb_fname->base_name == NULL) {
 818                 smb_fname->base_name = tmp;
 819                 return -1;
 820         }
 821
 822         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
 823         saved_errno = errno;
 824
 825         TALLOC_FREE(smb_fname->base_name);
 826         smb_fname->base_name = tmp;
 827
 828         if (ret == 0) {
 829                 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
 830         }
 831         errno = saved_errno;
 832         return ret;
 833 }
 834
 835 static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp,
 836                               SMB_STRUCT_STAT *sbuf)
 837 {
 838         time_t timestamp;
 839         int ret;
 840
 841         ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
 842         if (ret == -1) {
 843                 return ret;
 844         }
 845         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 846                                          fsp->fsp_name->base_name,
 847                                          &timestamp, NULL)) {
 848                 return 0;
 849         }
 850         if (timestamp != 0) {
 851                 convert_sbuf(handle, fsp->fsp_name->base_name, sbuf);
 852         }
 853         return 0;
 854 }
 855
 856 static int shadow_copy2_open(vfs_handle_struct *handle,
 857                              struct smb_filename *smb_fname, files_struct *fsp,
 858                              int flags, mode_t mode)
 859 {
 860         time_t timestamp;
 861         char *stripped, *tmp;
 862         int ret, saved_errno;
 863
 864         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 865                                          smb_fname->base_name,
 866                                          &timestamp, &stripped)) {
 867                 return -1;
 868         }
 869         if (timestamp == 0) {
 870                 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 871         }
 872
 873         tmp = smb_fname->base_name;
 874         smb_fname->base_name = shadow_copy2_convert(
 875                 talloc_tos(), handle, stripped, timestamp);
 876         TALLOC_FREE(stripped);
 877
 878         if (smb_fname->base_name == NULL) {
 879                 smb_fname->base_name = tmp;
 880                 return -1;
 881         }
 882
 883         ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 884         saved_errno = errno;
 885
 886         TALLOC_FREE(smb_fname->base_name);
 887         smb_fname->base_name = tmp;
 888
 889         errno = saved_errno;
 890         return ret;
 891 }
 892
 893 static int shadow_copy2_unlink(vfs_handle_struct *handle,
 894                                const struct smb_filename *smb_fname)
 895 {
 896         time_t timestamp;
 897         char *stripped;
 898         int ret, saved_errno;
 899         struct smb_filename *conv;
 900
 901         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 902                                          smb_fname->base_name,
 903                                          &timestamp, &stripped)) {
 904                 return -1;
 905         }
 906         if (timestamp == 0) {
 907                 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
 908         }
 909         conv = cp_smb_filename(talloc_tos(), smb_fname);
 910         if (conv == NULL) {
 911                 errno = ENOMEM;
 912                 return -1;
 913         }
 914         conv->base_name = shadow_copy2_convert(
 915                 conv, handle, stripped, timestamp);
 916         TALLOC_FREE(stripped);
 917         if (conv->base_name == NULL) {
 918                 return -1;
 919         }
 920         ret = SMB_VFS_NEXT_UNLINK(handle, conv);
 921         saved_errno = errno;
 922         TALLOC_FREE(conv);
 923         errno = saved_errno;
 924         return ret;
 925 }
 926
 927 static int shadow_copy2_chmod(vfs_handle_struct *handle, const char *fname,
 928                               mode_t mode)
 929 {
 930         time_t timestamp;
 931         char *stripped;
 932         int ret, saved_errno;
 933         char *conv;
 934
 935         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 936                                          &timestamp, &stripped)) {
 937                 return -1;
 938         }
 939         if (timestamp == 0) {
 940                 return SMB_VFS_NEXT_CHMOD(handle, fname, mode);
 941         }
 942         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 943         TALLOC_FREE(stripped);
 944         if (conv == NULL) {
 945                 return -1;
 946         }
 947         ret = SMB_VFS_NEXT_CHMOD(handle, conv, mode);
 948         saved_errno = errno;
 949         TALLOC_FREE(conv);
 950         errno = saved_errno;
 951         return ret;
 952 }
 953
 954 static int shadow_copy2_chown(vfs_handle_struct *handle, const char *fname,
 955                               uid_t uid, gid_t gid)
 956 {
 957         time_t timestamp;
 958         char *stripped;
 959         int ret, saved_errno;
 960         char *conv;
 961
 962         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 963                                          &timestamp, &stripped)) {
 964                 return -1;
 965         }
 966         if (timestamp == 0) {
 967                 return SMB_VFS_NEXT_CHOWN(handle, fname, uid, gid);
 968         }
 969         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 970         TALLOC_FREE(stripped);
 971         if (conv == NULL) {
 972                 return -1;
 973         }
 974         ret = SMB_VFS_NEXT_CHOWN(handle, conv, uid, gid);
 975         saved_errno = errno;
 976         TALLOC_FREE(conv);
 977         errno = saved_errno;
 978         return ret;
 979 }
 980
 981 static int shadow_copy2_chdir(vfs_handle_struct *handle,
 982                               const char *fname)
 983 {
 984         time_t timestamp;
 985         char *stripped;
 986         int ret, saved_errno;
 987         char *conv;
 988
 989         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 990                                          &timestamp, &stripped)) {
 991                 return -1;
 992         }
 993         if (timestamp == 0) {
 994                 return SMB_VFS_NEXT_CHDIR(handle, fname);
 995         }
 996         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 997         TALLOC_FREE(stripped);
 998         if (conv == NULL) {
 999                 return -1;
1000         }
1001         ret = SMB_VFS_NEXT_CHDIR(handle, conv);
1002         saved_errno = errno;
1003         TALLOC_FREE(conv);
1004         errno = saved_errno;
1005         return ret;
1006 }
1007
1008 static int shadow_copy2_ntimes(vfs_handle_struct *handle,
1009                                const struct smb_filename *smb_fname,
1010                                struct smb_file_time *ft)
1011 {
1012         time_t timestamp;
1013         char *stripped;
1014         int ret, saved_errno;
1015         struct smb_filename *conv;
1016
1017         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
1018                                          smb_fname->base_name,
1019                                          &timestamp, &stripped)) {
1020                 return -1;
1021         }
1022         if (timestamp == 0) {
1023                 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
1024         }
1025         conv = cp_smb_filename(talloc_tos(), smb_fname);
1026         if (conv == NULL) {
1027                 errno = ENOMEM;
1028                 return -1;
1029         }
1030         conv->base_name = shadow_copy2_convert(
1031                 conv, handle, stripped, timestamp);
1032         TALLOC_FREE(stripped);
1033         if (conv->base_name == NULL) {
1034                 return -1;
1035         }
1036         ret = SMB_VFS_NEXT_NTIMES(handle, conv, ft);
1037         saved_errno = errno;
1038         TALLOC_FREE(conv);
1039         errno = saved_errno;
1040         return ret;
1041 }
1042
1043 static int shadow_copy2_readlink(vfs_handle_struct *handle,
1044                                  const char *fname, char *buf, size_t bufsiz)
1045 {
1046         time_t timestamp;
1047         char *stripped;
1048         int ret, saved_errno;
1049         char *conv;
1050
1051         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1052                                          &timestamp, &stripped)) {
1053                 return -1;
1054         }
1055         if (timestamp == 0) {
1056                 return SMB_VFS_NEXT_READLINK(handle, fname, buf, bufsiz);
1057         }
1058         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1059         TALLOC_FREE(stripped);
1060         if (conv == NULL) {
1061                 return -1;
1062         }
1063         ret = SMB_VFS_NEXT_READLINK(handle, conv, buf, bufsiz);
1064         saved_errno = errno;
1065         TALLOC_FREE(conv);
1066         errno = saved_errno;
1067         return ret;
1068 }
1069
1070 static int shadow_copy2_mknod(vfs_handle_struct *handle,
1071                               const char *fname, mode_t mode, SMB_DEV_T dev)
1072 {
1073         time_t timestamp;
1074         char *stripped;
1075         int ret, saved_errno;
1076         char *conv;
1077
1078         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1079                                          &timestamp, &stripped)) {
1080                 return -1;
1081         }
1082         if (timestamp == 0) {
1083                 return SMB_VFS_NEXT_MKNOD(handle, fname, mode, dev);
1084         }
1085         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1086         TALLOC_FREE(stripped);
1087         if (conv == NULL) {
1088                 return -1;
1089         }
1090         ret = SMB_VFS_NEXT_MKNOD(handle, conv, mode, dev);
1091         saved_errno = errno;
1092         TALLOC_FREE(conv);
1093         errno = saved_errno;
1094         return ret;
1095 }
1096
1097 static char *shadow_copy2_realpath(vfs_handle_struct *handle,
1098                                    const char *fname)
1099 {
1100         time_t timestamp;
1101         char *stripped = NULL;
1102         char *tmp = NULL;
1103         char *result = NULL;
1104         char *inserted = NULL;
1105         char *inserted_to, *inserted_end;
1106         int saved_errno;
1107
1108         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1109                                          &timestamp, &stripped)) {
1110                 goto done;
1111         }
1112         if (timestamp == 0) {
1113                 return SMB_VFS_NEXT_REALPATH(handle, fname);
1114         }
1115
1116         tmp = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1117         if (tmp == NULL) {
1118                 goto done;
1119         }
1120
1121         result = SMB_VFS_NEXT_REALPATH(handle, tmp);
1122         if (result == NULL) {
1123                 goto done;
1124         }
1125
1126         /*
1127          * Take away what we've inserted. This removes the @GMT-thingy
1128          * completely, but will give a path under the share root.
1129          */
1130         inserted = shadow_copy2_insert_string(talloc_tos(), handle, timestamp);
1131         if (inserted == NULL) {
1132                 goto done;
1133         }
1134         inserted_to = strstr_m(result, inserted);
1135         if (inserted_to == NULL) {
1136                 DEBUG(2, ("SMB_VFS_NEXT_REALPATH removed %s\n", inserted));
1137                 goto done;
1138         }
1139         inserted_end = inserted_to + talloc_get_size(inserted) - 1;
1140         memmove(inserted_to, inserted_end, strlen(inserted_end)+1);
1141
1142 done:
1143         saved_errno = errno;
1144         TALLOC_FREE(inserted);
1145         TALLOC_FREE(tmp);
1146         TALLOC_FREE(stripped);
1147         errno = saved_errno;
1148         return result;
1149 }
1150
1151 /**
1152  * Check whether a given directory contains a
1153  * snapshot directory as direct subdirectory.
1154  * If yes, return the path of the snapshot-subdir,
1155  * otherwise return NULL.
1156  */
1157 static char *have_snapdir(struct vfs_handle_struct *handle,
1158                           const char *path)
1159 {
1160         struct smb_filename smb_fname;
1161         int ret;
1162         struct shadow_copy2_config *config;
1163
1164         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1165                                 return NULL);
1166
1167         ZERO_STRUCT(smb_fname);
1168         smb_fname.base_name = talloc_asprintf(talloc_tos(), "%s/%s",
1169                                               path, config->snapdir);
1170         if (smb_fname.base_name == NULL) {
1171                 return NULL;
1172         }
1173
1174         ret = SMB_VFS_NEXT_STAT(handle, &smb_fname);
1175         if ((ret == 0) && (S_ISDIR(smb_fname.st.st_ex_mode))) {
1176                 return smb_fname.base_name;
1177         }
1178         TALLOC_FREE(smb_fname.base_name);
1179         return NULL;
1180 }
1181
1182 /**
1183  * Find the snapshot directory (if any) for the given
1184  * filename (which is relative to the share).
1185  */
1186 static const char *shadow_copy2_find_snapdir(TALLOC_CTX *mem_ctx,
1187                                              struct vfs_handle_struct *handle,
1188                                              struct smb_filename *smb_fname)
1189 {
1190         char *path, *p;
1191         const char *snapdir;
1192         struct shadow_copy2_config *config;
1193
1194         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1195                                 return NULL);
1196
1197         /*
1198          * If the non-snapdisrseverywhere mode, we should not search!
1199          */
1200         if (!config->snapdirseverywhere) {
1201                 return config->snapshot_basepath;
1202         }
1203
1204         path = talloc_asprintf(mem_ctx, "%s/%s",
1205                                handle->conn->connectpath,
1206                                smb_fname->base_name);
1207         if (path == NULL) {
1208                 return NULL;
1209         }
1210
1211         snapdir = have_snapdir(handle, path);
1212         if (snapdir != NULL) {
1213                 TALLOC_FREE(path);
1214                 return snapdir;
1215         }
1216
1217         while ((p = strrchr(path, '/')) && (p > path)) {
1218
1219                 p[0] = '\0';
1220
1221                 snapdir = have_snapdir(handle, path);
1222                 if (snapdir != NULL) {
1223                         TALLOC_FREE(path);
1224                         return snapdir;
1225                 }
1226         }
1227         TALLOC_FREE(path);
1228         return NULL;
1229 }
1230
1231 static bool shadow_copy2_snapshot_to_gmt(vfs_handle_struct *handle,
1232                                          const char *name,
1233                                          char *gmt, size_t gmt_len)
1234 {
1235         struct tm timestamp;
1236         time_t timestamp_t;
1237         unsigned long int timestamp_long;
1238         const char *fmt;
1239         struct shadow_copy2_config *config;
1240
1241         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1242                                 return NULL);
1243
1244         fmt = config->gmt_format;
1245
1246         ZERO_STRUCT(timestamp);
1247         if (config->use_sscanf) {
1248                 if (sscanf(name, fmt, &timestamp_long) != 1) {
1249                         DEBUG(10, ("shadow_copy2_snapshot_to_gmt: "
1250                                    "no sscanf match %s: %s\n",
1251                                    fmt, name));
1252                         return false;
1253                 }
1254                 timestamp_t = timestamp_long;
1255                 gmtime_r(&timestamp_t, &timestamp);
1256         } else {
1257                 if (strptime(name, fmt, &timestamp) == NULL) {
1258                         DEBUG(10, ("shadow_copy2_snapshot_to_gmt: "
1259                                    "no match %s: %s\n",
1260                                    fmt, name));
1261                         return false;
1262                 }
1263                 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: match %s: %s\n",
1264                            fmt, name));
1265
1266                 if (config->use_localtime) {
1267                         timestamp.tm_isdst = -1;
1268                         timestamp_t = mktime(&timestamp);
1269                         gmtime_r(&timestamp_t, &timestamp);
1270                 }
1271         }
1272
1273         strftime(gmt, gmt_len, GMT_FORMAT, &timestamp);
1274         return true;
1275 }
1276
1277 static int shadow_copy2_label_cmp_asc(const void *x, const void *y)
1278 {
1279         return strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1280 }
1281
1282 static int shadow_copy2_label_cmp_desc(const void *x, const void *y)
1283 {
1284         return -strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1285 }
1286
1287 /*
1288   sort the shadow copy data in ascending or descending order
1289  */
1290 static void shadow_copy2_sort_data(vfs_handle_struct *handle,
1291                                    struct shadow_copy_data *shadow_copy2_data)
1292 {
1293         int (*cmpfunc)(const void *, const void *);
1294         const char *sort;
1295         struct shadow_copy2_config *config;
1296
1297         SMB_VFS_HANDLE_GET_DATA(handle, config, struct shadow_copy2_config,
1298                                 return);
1299
1300         sort = config->sort_order;
1301         if (sort == NULL) {
1302                 return;
1303         }
1304
1305         if (strcmp(sort, "asc") == 0) {
1306                 cmpfunc = shadow_copy2_label_cmp_asc;
1307         } else if (strcmp(sort, "desc") == 0) {
1308                 cmpfunc = shadow_copy2_label_cmp_desc;
1309         } else {
1310                 return;
1311         }
1312
1313         if (shadow_copy2_data && shadow_copy2_data->num_volumes > 0 &&
1314             shadow_copy2_data->labels)
1315         {
1316                 TYPESAFE_QSORT(shadow_copy2_data->labels,
1317                                shadow_copy2_data->num_volumes,
1318                                cmpfunc);
1319         }
1320 }
1321
1322 static int shadow_copy2_get_shadow_copy_data(
1323         vfs_handle_struct *handle, files_struct *fsp,
1324         struct shadow_copy_data *shadow_copy2_data,
1325         bool labels)
1326 {
1327         DIR *p;
1328         const char *snapdir;
1329         struct dirent *d;
1330         TALLOC_CTX *tmp_ctx = talloc_stackframe();
1331
1332         snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle, fsp->fsp_name);
1333         if (snapdir == NULL) {
1334                 DEBUG(0,("shadow:snapdir not found for %s in get_shadow_copy_data\n",
1335                          handle->conn->connectpath));
1336                 errno = EINVAL;
1337                 talloc_free(tmp_ctx);
1338                 return -1;
1339         }
1340
1341         p = SMB_VFS_NEXT_OPENDIR(handle, snapdir, NULL, 0);
1342
1343         if (!p) {
1344                 DEBUG(2,("shadow_copy2: SMB_VFS_NEXT_OPENDIR() failed for '%s'"
1345                          " - %s\n", snapdir, strerror(errno)));
1346                 talloc_free(tmp_ctx);
1347                 errno = ENOSYS;
1348                 return -1;
1349         }
1350
1351         shadow_copy2_data->num_volumes = 0;
1352         shadow_copy2_data->labels      = NULL;
1353
1354         while ((d = SMB_VFS_NEXT_READDIR(handle, p, NULL))) {
1355                 char snapshot[GMT_NAME_LEN+1];
1356                 SHADOW_COPY_LABEL *tlabels;
1357
1358                 /*
1359                  * ignore names not of the right form in the snapshot
1360                  * directory
1361                  */
1362                 if (!shadow_copy2_snapshot_to_gmt(
1363                             handle, d->d_name,
1364                             snapshot, sizeof(snapshot))) {
1365
1366                         DEBUG(6, ("shadow_copy2_get_shadow_copy_data: "
1367                                   "ignoring %s\n", d->d_name));
1368                         continue;
1369                 }
1370                 DEBUG(6,("shadow_copy2_get_shadow_copy_data: %s -> %s\n",
1371                          d->d_name, snapshot));
1372
1373                 if (!labels) {
1374                         /* the caller doesn't want the labels */
1375                         shadow_copy2_data->num_volumes++;
1376                         continue;
1377                 }
1378
1379                 tlabels = talloc_realloc(shadow_copy2_data,
1380                                          shadow_copy2_data->labels,
1381                                          SHADOW_COPY_LABEL,
1382                                          shadow_copy2_data->num_volumes+1);
1383                 if (tlabels == NULL) {
1384                         DEBUG(0,("shadow_copy2: out of memory\n"));
1385                         SMB_VFS_NEXT_CLOSEDIR(handle, p);
1386                         talloc_free(tmp_ctx);
1387                         return -1;
1388                 }
1389
1390                 strlcpy(tlabels[shadow_copy2_data->num_volumes], snapshot,
1391                         sizeof(*tlabels));
1392
1393                 shadow_copy2_data->num_volumes++;
1394                 shadow_copy2_data->labels = tlabels;
1395         }
1396
1397         SMB_VFS_NEXT_CLOSEDIR(handle,p);
1398
1399         shadow_copy2_sort_data(handle, shadow_copy2_data);
1400
1401         talloc_free(tmp_ctx);
1402         return 0;
1403 }
1404
1405 static NTSTATUS shadow_copy2_fget_nt_acl(vfs_handle_struct *handle,
1406                                         struct files_struct *fsp,
1407                                         uint32 security_info,
1408                                          TALLOC_CTX *mem_ctx,
1409                                         struct security_descriptor **ppdesc)
1410 {
1411         time_t timestamp;
1412         char *stripped;
1413         NTSTATUS status;
1414         char *conv;
1415
1416         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
1417                                          fsp->fsp_name->base_name,
1418                                          &timestamp, &stripped)) {
1419                 return map_nt_error_from_unix(errno);
1420         }
1421         if (timestamp == 0) {
1422                 return SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
1423                                                 mem_ctx,
1424                                                 ppdesc);
1425         }
1426         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1427         TALLOC_FREE(stripped);
1428         if (conv == NULL) {
1429                 return map_nt_error_from_unix(errno);
1430         }
1431         status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv, security_info,
1432                                          mem_ctx, ppdesc);
1433         TALLOC_FREE(conv);
1434         return status;
1435 }
1436
1437 static NTSTATUS shadow_copy2_get_nt_acl(vfs_handle_struct *handle,
1438                                         const char *fname,
1439                                         uint32 security_info,
1440                                         TALLOC_CTX *mem_ctx,
1441                                         struct security_descriptor **ppdesc)
1442 {
1443         time_t timestamp;
1444         char *stripped;
1445         NTSTATUS status;
1446         char *conv;
1447
1448         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1449                                          &timestamp, &stripped)) {
1450                 return map_nt_error_from_unix(errno);
1451         }
1452         if (timestamp == 0) {
1453                 return SMB_VFS_NEXT_GET_NT_ACL(handle, fname, security_info,
1454                                                mem_ctx, ppdesc);
1455         }
1456         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1457         TALLOC_FREE(stripped);
1458         if (conv == NULL) {
1459                 return map_nt_error_from_unix(errno);
1460         }
1461         status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv, security_info,
1462                                          mem_ctx, ppdesc);
1463         TALLOC_FREE(conv);
1464         return status;
1465 }
1466
1467 static int shadow_copy2_mkdir(vfs_handle_struct *handle,
1468                               const char *fname, mode_t mode)
1469 {
1470         time_t timestamp;
1471         char *stripped;
1472         int ret, saved_errno;
1473         char *conv;
1474
1475         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1476                                          &timestamp, &stripped)) {
1477                 return -1;
1478         }
1479         if (timestamp == 0) {
1480                 return SMB_VFS_NEXT_MKDIR(handle, fname, mode);
1481         }
1482         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1483         TALLOC_FREE(stripped);
1484         if (conv == NULL) {
1485                 return -1;
1486         }
1487         ret = SMB_VFS_NEXT_MKDIR(handle, conv, mode);
1488         saved_errno = errno;
1489         TALLOC_FREE(conv);
1490         errno = saved_errno;
1491         return ret;
1492 }
1493
1494 static int shadow_copy2_rmdir(vfs_handle_struct *handle, const char *fname)
1495 {
1496         time_t timestamp;
1497         char *stripped;
1498         int ret, saved_errno;
1499         char *conv;
1500
1501         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1502                                          &timestamp, &stripped)) {
1503                 return -1;
1504         }
1505         if (timestamp == 0) {
1506                 return SMB_VFS_NEXT_RMDIR(handle, fname);
1507         }
1508         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1509         TALLOC_FREE(stripped);
1510         if (conv == NULL) {
1511                 return -1;
1512         }
1513         ret = SMB_VFS_NEXT_RMDIR(handle, conv);
1514         saved_errno = errno;
1515         TALLOC_FREE(conv);
1516         errno = saved_errno;
1517         return ret;
1518 }
1519
1520 static int shadow_copy2_chflags(vfs_handle_struct *handle, const char *fname,
1521                                 unsigned int flags)
1522 {
1523         time_t timestamp;
1524         char *stripped;
1525         int ret, saved_errno;
1526         char *conv;
1527
1528         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1529                                          &timestamp, &stripped)) {
1530                 return -1;
1531         }
1532         if (timestamp == 0) {
1533                 return SMB_VFS_NEXT_CHFLAGS(handle, fname, flags);
1534         }
1535         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1536         TALLOC_FREE(stripped);
1537         if (conv == NULL) {
1538                 return -1;
1539         }
1540         ret = SMB_VFS_NEXT_CHFLAGS(handle, conv, flags);
1541         saved_errno = errno;
1542         TALLOC_FREE(conv);
1543         errno = saved_errno;
1544         return ret;
1545 }
1546
1547 static ssize_t shadow_copy2_getxattr(vfs_handle_struct *handle,
1548                                      const char *fname, const char *aname,
1549                                      void *value, size_t size)
1550 {
1551         time_t timestamp;
1552         char *stripped;
1553         ssize_t ret;
1554         int saved_errno;
1555         char *conv;
1556
1557         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1558                                          &timestamp, &stripped)) {
1559                 return -1;
1560         }
1561         if (timestamp == 0) {
1562                 return SMB_VFS_NEXT_GETXATTR(handle, fname, aname, value,
1563                                              size);
1564         }
1565         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1566         TALLOC_FREE(stripped);
1567         if (conv == NULL) {
1568                 return -1;
1569         }
1570         ret = SMB_VFS_NEXT_GETXATTR(handle, conv, aname, value, size);
1571         saved_errno = errno;
1572         TALLOC_FREE(conv);
1573         errno = saved_errno;
1574         return ret;
1575 }
1576
1577 static ssize_t shadow_copy2_listxattr(struct vfs_handle_struct *handle,
1578                                       const char *fname,
1579                                       char *list, size_t size)
1580 {
1581         time_t timestamp;
1582         char *stripped;
1583         ssize_t ret;
1584         int saved_errno;
1585         char *conv;
1586
1587         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1588                                          &timestamp, &stripped)) {
1589                 return -1;
1590         }
1591         if (timestamp == 0) {
1592                 return SMB_VFS_NEXT_LISTXATTR(handle, fname, list, size);
1593         }
1594         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1595         TALLOC_FREE(stripped);
1596         if (conv == NULL) {
1597                 return -1;
1598         }
1599         ret = SMB_VFS_NEXT_LISTXATTR(handle, conv, list, size);
1600         saved_errno = errno;
1601         TALLOC_FREE(conv);
1602         errno = saved_errno;
1603         return ret;
1604 }
1605
1606 static int shadow_copy2_removexattr(vfs_handle_struct *handle,
1607                                     const char *fname, const char *aname)
1608 {
1609         time_t timestamp;
1610         char *stripped;
1611         int ret, saved_errno;
1612         char *conv;
1613
1614         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1615                                          &timestamp, &stripped)) {
1616                 return -1;
1617         }
1618         if (timestamp == 0) {
1619                 return SMB_VFS_NEXT_REMOVEXATTR(handle, fname, aname);
1620         }
1621         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1622         TALLOC_FREE(stripped);
1623         if (conv == NULL) {
1624                 return -1;
1625         }
1626         ret = SMB_VFS_NEXT_REMOVEXATTR(handle, conv, aname);
1627         saved_errno = errno;
1628         TALLOC_FREE(conv);
1629         errno = saved_errno;
1630         return ret;
1631 }
1632
1633 static int shadow_copy2_setxattr(struct vfs_handle_struct *handle,
1634                                  const char *fname,
1635                                  const char *aname, const void *value,
1636                                  size_t size, int flags)
1637 {
1638         time_t timestamp;
1639         char *stripped;
1640         ssize_t ret;
1641         int saved_errno;
1642         char *conv;
1643
1644         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1645                                          &timestamp, &stripped)) {
1646                 return -1;
1647         }
1648         if (timestamp == 0) {
1649                 return SMB_VFS_NEXT_SETXATTR(handle, fname, aname, value, size,
1650                                              flags);
1651         }
1652         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1653         TALLOC_FREE(stripped);
1654         if (conv == NULL) {
1655                 return -1;
1656         }
1657         ret = SMB_VFS_NEXT_SETXATTR(handle, conv, aname, value, size, flags);
1658         saved_errno = errno;
1659         TALLOC_FREE(conv);
1660         errno = saved_errno;
1661         return ret;
1662 }
1663
1664 static int shadow_copy2_chmod_acl(vfs_handle_struct *handle,
1665                                   const char *fname, mode_t mode)
1666 {
1667         time_t timestamp;
1668         char *stripped;
1669         ssize_t ret;
1670         int saved_errno;
1671         char *conv;
1672
1673         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1674                                          &timestamp, &stripped)) {
1675                 return -1;
1676         }
1677         if (timestamp == 0) {
1678                 return SMB_VFS_NEXT_CHMOD_ACL(handle, fname, mode);
1679         }
1680         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1681         TALLOC_FREE(stripped);
1682         if (conv == NULL) {
1683                 return -1;
1684         }
1685         ret = SMB_VFS_NEXT_CHMOD_ACL(handle, conv, mode);
1686         saved_errno = errno;
1687         TALLOC_FREE(conv);
1688         errno = saved_errno;
1689         return ret;
1690 }
1691
1692 static int shadow_copy2_get_real_filename(struct vfs_handle_struct *handle,
1693                                           const char *path,
1694                                           const char *name,
1695                                           TALLOC_CTX *mem_ctx,
1696                                           char **found_name)
1697 {
1698         time_t timestamp;
1699         char *stripped;
1700         ssize_t ret;
1701         int saved_errno;
1702         char *conv;
1703
1704         DEBUG(10, ("shadow_copy2_get_real_filename called for path=[%s], "
1705                    "name=[%s]\n", path, name));
1706
1707         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path,
1708                                          &timestamp, &stripped)) {
1709                 DEBUG(10, ("shadow_copy2_strip_snapshot failed\n"));
1710                 return -1;
1711         }
1712         if (timestamp == 0) {
1713                 DEBUG(10, ("timestamp == 0\n"));
1714                 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
1715                                                       mem_ctx, found_name);
1716         }
1717         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1718         TALLOC_FREE(stripped);
1719         if (conv == NULL) {
1720                 DEBUG(10, ("shadow_copy2_convert failed\n"));
1721                 return -1;
1722         }
1723         DEBUG(10, ("Calling NEXT_GET_REAL_FILE_NAME for conv=[%s], "
1724                    "name=[%s]\n", conv, name));
1725         ret = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, conv, name,
1726                                              mem_ctx, found_name);
1727         DEBUG(10, ("NEXT_REAL_FILE_NAME returned %d\n", (int)ret));
1728         saved_errno = errno;
1729         TALLOC_FREE(conv);
1730         errno = saved_errno;
1731         return ret;
1732 }
1733
1734 static uint64_t shadow_copy2_disk_free(vfs_handle_struct *handle,
1735                                        const char *path, bool small_query,
1736                                        uint64_t *bsize, uint64_t *dfree,
1737                                        uint64_t *dsize)
1738 {
1739         time_t timestamp;
1740         char *stripped;
1741         ssize_t ret;
1742         int saved_errno;
1743         char *conv;
1744
1745         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path,
1746                                          &timestamp, &stripped)) {
1747                 return -1;
1748         }
1749         if (timestamp == 0) {
1750                 return SMB_VFS_NEXT_DISK_FREE(handle, path, small_query,
1751                                               bsize, dfree, dsize);
1752         }
1753
1754         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1755         TALLOC_FREE(stripped);
1756         if (conv == NULL) {
1757                 return -1;
1758         }
1759
1760         ret = SMB_VFS_NEXT_DISK_FREE(handle, conv, small_query, bsize, dfree,
1761                                      dsize);
1762
1763         saved_errno = errno;
1764         TALLOC_FREE(conv);
1765         errno = saved_errno;
1766
1767         return ret;
1768 }
1769
1770 static int shadow_copy2_connect(struct vfs_handle_struct *handle,
1771                                 const char *service, const char *user)
1772 {
1773         struct shadow_copy2_config *config;
1774         int ret;
1775         const char *snapdir;
1776         const char *gmt_format;
1777         const char *sort_order;
1778         const char *basedir;
1779         const char *mount_point;
1780
1781         DEBUG(10, (__location__ ": cnum[%u], connectpath[%s]\n",
1782                    (unsigned)handle->conn->cnum,
1783                    handle->conn->connectpath));
1784
1785         ret = SMB_VFS_NEXT_CONNECT(handle, service, user);
1786         if (ret < 0) {
1787                 return ret;
1788         }
1789
1790         config = talloc_zero(handle->conn, struct shadow_copy2_config);
1791         if (config == NULL) {
1792                 DEBUG(0, ("talloc_zero() failed\n"));
1793                 errno = ENOMEM;
1794                 return -1;
1795         }
1796
1797         gmt_format = lp_parm_const_string(SNUM(handle->conn),
1798                                           "shadow", "format",
1799                                           GMT_FORMAT);
1800         config->gmt_format = talloc_strdup(config, gmt_format);
1801         if (config->gmt_format == NULL) {
1802                 DEBUG(0, ("talloc_strdup() failed\n"));
1803                 errno = ENOMEM;
1804                 return -1;
1805         }
1806
1807         config->use_sscanf = lp_parm_bool(SNUM(handle->conn),
1808                                           "shadow", "sscanf", false);
1809
1810         config->use_localtime = lp_parm_bool(SNUM(handle->conn),
1811                                              "shadow", "localtime",
1812                                              false);
1813
1814         snapdir = lp_parm_const_string(SNUM(handle->conn),
1815                                        "shadow", "snapdir",
1816                                        ".snapshots");
1817         config->snapdir = talloc_strdup(config, snapdir);
1818         if (config->snapdir == NULL) {
1819                 DEBUG(0, ("talloc_strdup() failed\n"));
1820                 errno = ENOMEM;
1821                 return -1;
1822         }
1823
1824         config->snapdirseverywhere = lp_parm_bool(SNUM(handle->conn),
1825                                                   "shadow",
1826                                                   "snapdirseverywhere",
1827                                                   false);
1828
1829         config->crossmountpoints = lp_parm_bool(SNUM(handle->conn),
1830                                                 "shadow", "crossmountpoints",
1831                                                 false);
1832
1833         config->fixinodes = lp_parm_bool(SNUM(handle->conn),
1834                                          "shadow", "fixinodes",
1835                                          false);
1836
1837         sort_order = lp_parm_const_string(SNUM(handle->conn),
1838                                           "shadow", "sort", "desc");
1839         config->sort_order = talloc_strdup(config, sort_order);
1840         if (config->sort_order == NULL) {
1841                 DEBUG(0, ("talloc_strdup() failed\n"));
1842                 errno = ENOMEM;
1843                 return -1;
1844         }
1845
1846         mount_point = lp_parm_const_string(SNUM(handle->conn),
1847                                            "shadow", "mountpoint", NULL);
1848         if (mount_point != NULL) {
1849                 if (mount_point[0] != '/') {
1850                         DEBUG(1, (__location__ " Warning: 'mountpoint' is "
1851                                   "relative ('%s'), but it has to be an "
1852                                   "absolute path. Ignoring provided value.\n",
1853                                   mount_point));
1854                         mount_point = NULL;
1855                 } else {
1856                         char *p;
1857                         p = strstr(handle->conn->connectpath, mount_point);
1858                         if (p != handle->conn->connectpath) {
1859                                 DEBUG(1, ("Warning: mount_point (%s) is not a "
1860                                           "subdirectory of the share root "
1861                                           "(%s). Ignoring provided value.\n",
1862                                           mount_point,
1863                                           handle->conn->connectpath));
1864                                 mount_point = NULL;
1865                         }
1866                 }
1867         }
1868
1869         if (mount_point != NULL) {
1870                 config->mount_point = talloc_strdup(config, mount_point);
1871                 if (config->mount_point == NULL) {
1872                         DEBUG(0, (__location__ " talloc_strdup() failed\n"));
1873                         return -1;
1874                 }
1875         } else {
1876                 config->mount_point = shadow_copy2_find_mount_point(config,
1877                                                                     handle);
1878                 if (config->mount_point == NULL) {
1879                         DEBUG(0, (__location__ ": shadow_copy2_find_mount_point"
1880                                   " failed: %s\n", strerror(errno)));
1881                         return -1;
1882                 }
1883         }
1884
1885         basedir = lp_parm_const_string(SNUM(handle->conn),
1886                                        "shadow", "basedir", NULL);
1887
1888         if (basedir != NULL) {
1889                 if (basedir[0] != '/') {
1890                         DEBUG(1, (__location__ " Warning: 'basedir' is "
1891                                   "relative ('%s'), but it has to be an "
1892                                   "absolute path. Disabling basedir.\n",
1893                                   basedir));
1894                 } else {
1895                         char *p;
1896                         p = strstr(basedir, config->mount_point);
1897                         if (p != basedir) {
1898                                 DEBUG(1, ("Warning: basedir (%s) is not a "
1899                                           "subdirectory of the share root's "
1900                                           "mount point (%s). "
1901                                           "Disabling basedir\n",
1902                                           basedir, config->mount_point));
1903                         } else {
1904                                 config->basedir = talloc_strdup(config,
1905                                                                 basedir);
1906                                 if (config->basedir == NULL) {
1907                                         DEBUG(0, ("talloc_strdup() failed\n"));
1908                                         errno = ENOMEM;
1909                                         return -1;
1910                                 }
1911                         }
1912                 }
1913         }
1914
1915         if (config->snapdirseverywhere && config->basedir != NULL) {
1916                 DEBUG(1, (__location__ " Warning: 'basedir' is incompatible "
1917                           "with 'snapdirseverywhere'. Disabling basedir.\n"));
1918                 TALLOC_FREE(config->basedir);
1919         }
1920
1921         if (config->crossmountpoints && config->basedir != NULL) {
1922                 DEBUG(1, (__location__ " Warning: 'basedir' is incompatible "
1923                           "with 'crossmountpoints'. Disabling basedir.\n"));
1924                 TALLOC_FREE(config->basedir);
1925         }
1926
1927         if (config->basedir == NULL) {
1928                 config->basedir = config->mount_point;
1929         }
1930
1931         if (strlen(config->basedir) != strlen(handle->conn->connectpath)) {
1932                 config->rel_connectpath = talloc_strdup(config,
1933                         handle->conn->connectpath + strlen(config->basedir));
1934                 if (config->rel_connectpath == NULL) {
1935                         DEBUG(0, ("talloc_strdup() failed\n"));
1936                         errno = ENOMEM;
1937                         return -1;
1938                 }
1939         }
1940
1941         if (config->snapdir[0] == '/') {
1942                 config->snapdir_absolute = true;
1943
1944                 if (config->snapdirseverywhere == true) {
1945                         DEBUG(1, (__location__ " Warning: An absolute snapdir "
1946                                   "is incompatible with 'snapdirseverywhere', "
1947                                   "setting 'snapdirseverywhere' to false.\n"));
1948                         config->snapdirseverywhere = false;
1949                 }
1950
1951                 if (config->crossmountpoints == true) {
1952                         DEBUG(1, (__location__ " Warning: 'crossmountpoints' "
1953                                   "is not supported with an absolute snapdir. "
1954                                   "Disabling it.\n"));
1955                         config->crossmountpoints = false;
1956                 }
1957
1958                 config->snapshot_basepath = config->snapdir;
1959         } else {
1960                 config->snapshot_basepath = talloc_asprintf(config, "%s/%s",
1961                                 config->mount_point, config->snapdir);
1962                 if (config->snapshot_basepath == NULL) {
1963                         DEBUG(0, ("talloc_asprintf() failed\n"));
1964                         errno = ENOMEM;
1965                         return -1;
1966                 }
1967         }
1968
1969         DEBUG(10, ("shadow_copy2_connect: configuration:\n"
1970                    "  share root: '%s'\n"
1971                    "  basedir: '%s'\n"
1972                    "  mountpoint: '%s'\n"
1973                    "  rel share root: '%s'\n"
1974                    "  snapdir: '%s'\n"
1975                    "  snapshot base path: '%s'\n"
1976                    "  format: '%s'\n"
1977                    "  use sscanf: %s\n"
1978                    "  snapdirs everywhere: %s\n"
1979                    "  cross mountpoints: %s\n"
1980                    "  fix inodes: %s\n"
1981                    "  sort order: %s\n"
1982                    "",
1983                    handle->conn->connectpath,
1984                    config->basedir,
1985                    config->mount_point,
1986                    config->rel_connectpath,
1987                    config->snapdir,
1988                    config->snapshot_basepath,
1989                    config->gmt_format,
1990                    config->use_sscanf ? "yes" : "no",
1991                    config->snapdirseverywhere ? "yes" : "no",
1992                    config->crossmountpoints ? "yes" : "no",
1993                    config->fixinodes ? "yes" : "no",
1994                    config->sort_order
1995                    ));
1996
1997
1998         SMB_VFS_HANDLE_SET_DATA(handle, config,
1999                                 NULL, struct shadow_copy2_config,
2000                                 return -1);
2001
2002         return 0;
2003 }
2004
2005 static struct vfs_fn_pointers vfs_shadow_copy2_fns = {
2006         .connect_fn = shadow_copy2_connect,
2007         .opendir_fn = shadow_copy2_opendir,
2008         .disk_free_fn = shadow_copy2_disk_free,
2009         .rename_fn = shadow_copy2_rename,
2010         .link_fn = shadow_copy2_link,
2011         .symlink_fn = shadow_copy2_symlink,
2012         .stat_fn = shadow_copy2_stat,
2013         .lstat_fn = shadow_copy2_lstat,
2014         .fstat_fn = shadow_copy2_fstat,
2015         .open_fn = shadow_copy2_open,
2016         .unlink_fn = shadow_copy2_unlink,
2017         .chmod_fn = shadow_copy2_chmod,
2018         .chown_fn = shadow_copy2_chown,
2019         .chdir_fn = shadow_copy2_chdir,
2020         .ntimes_fn = shadow_copy2_ntimes,
2021         .readlink_fn = shadow_copy2_readlink,
2022         .mknod_fn = shadow_copy2_mknod,
2023         .realpath_fn = shadow_copy2_realpath,
2024         .get_nt_acl_fn = shadow_copy2_get_nt_acl,
2025         .fget_nt_acl_fn = shadow_copy2_fget_nt_acl,
2026         .get_shadow_copy_data_fn = shadow_copy2_get_shadow_copy_data,
2027         .mkdir_fn = shadow_copy2_mkdir,
2028         .rmdir_fn = shadow_copy2_rmdir,
2029         .getxattr_fn = shadow_copy2_getxattr,
2030         .listxattr_fn = shadow_copy2_listxattr,
2031         .removexattr_fn = shadow_copy2_removexattr,
2032         .setxattr_fn = shadow_copy2_setxattr,
2033         .chmod_acl_fn = shadow_copy2_chmod_acl,
2034         .chflags_fn = shadow_copy2_chflags,
2035         .get_real_filename_fn = shadow_copy2_get_real_filename,
2036 };
2037
2038 NTSTATUS vfs_shadow_copy2_init(void);
2039 NTSTATUS vfs_shadow_copy2_init(void)
2040 {
2041         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
2042                                 "shadow_copy2", &vfs_shadow_copy2_fns);
2043 }