source3/modules/vfs_shadow_copy2.c

   1 /*
   2  * Third attempt at a shadow copy module
   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  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 /*
  25
  26   This is a 3rd implemetation of a shadow copy module for exposing
  27   snapshots to windows clients as shadow copies. This version has the
  28   following features:
  29
  30      1) you don't need to populate your shares with symlinks to the
  31      snapshots. This can be very important when you have thousands of
  32      shares, or use [homes]
  33
  34      2) the inode number of the files is altered so it is different
  35      from the original. This allows the 'restore' button to work
  36      without a sharing violation
  37
  38      3) shadow copy results can be sorted before being sent to the
  39      client.  This is beneficial for filesystems that don't read
  40      directories alphabetically (the default unix).
  41
  42      4) vanity naming for snapshots. Snapshots can be named in any
  43      format compatible with str[fp]time conversions.
  44
  45      5) time stamps in snapshot names can be represented in localtime
  46      rather than UTC.
  47
  48   Module options:
  49
  50       shadow:snapdir = <directory where snapshots are kept>
  51
  52       This is the directory containing the @GMT-* snapshot directories. If it is an absolute
  53       path it is used as-is. If it is a relative path, then it is taken relative to the mount
  54       point of the filesystem that the root of this share is on
  55
  56       shadow:basedir = <base directory that snapshots are from>
  57
  58       This is an optional parameter that specifies the directory that
  59       the snapshots are relative to. It defaults to the filesystem
  60       mount point
  61
  62       shadow:fixinodes = yes/no
  63
  64       If you enable shadow:fixinodes then this module will modify the
  65       apparent inode number of files in the snapshot directories using
  66       a hash of the files path. This is needed for snapshot systems
  67       where the snapshots have the same device:inode number as the
  68       original files (such as happens with GPFS snapshots). If you
  69       don't set this option then the 'restore' button in the shadow
  70       copy UI will fail with a sharing violation.
  71
  72       shadow:sort = asc/desc, or not specified for unsorted (default)
  73
  74       This is an optional parameter that specifies that the shadow
  75       copy directories should be sorted before sending them to the
  76       client.  This can be beneficial as unix filesystems are usually
  77       not listed alphabetically sorted.  If enabled, you typically
  78       want to specify descending order.
  79
  80       shadow:format = <format specification for snapshot names>
  81
  82       This is an optional parameter that specifies the format
  83       specification for the naming of snapshots.  The format must
  84       be compatible with the conversion specifications recognized
  85       by str[fp]time.  The default value is "@GMT-%Y.%m.%d-%H.%M.%S".
  86
  87       shadow:sscanf = yes/no (default is no)
  88
  89       The time is the unsigned long integer (%lu) in the format string
  90       rather than a time strptime() can parse.  The result must be a unix time_t
  91       time.
  92
  93       shadow:localtime = yes/no (default is no)
  94
  95       This is an optional parameter that indicates whether the
  96       snapshot names are in UTC/GMT or the local time.
  97
  98
  99   The following command would generate a correctly formatted directory name
 100   for use with the default parameters:
 101      date -u +@GMT-%Y.%m.%d-%H.%M.%S
 102  */
 103
 104 #include "includes.h"
 105 #include "system/filesys.h"
 106 #include "include/ntioctl.h"
 107 #include <ccan/hash/hash.h>
 108 #include "util_tdb.h"
 109
 110 static bool shadow_copy2_find_slashes(TALLOC_CTX *mem_ctx, const char *str,
 111                                       size_t **poffsets,
 112                                       unsigned *pnum_offsets)
 113 {
 114         unsigned num_offsets;
 115         size_t *offsets;
 116         const char *p;
 117
 118         num_offsets = 0;
 119
 120         p = str;
 121         while ((p = strchr(p, '/')) != NULL) {
 122                 num_offsets += 1;
 123                 p += 1;
 124         }
 125
 126         offsets = talloc_array(mem_ctx, size_t, num_offsets);
 127         if (offsets == NULL) {
 128                 return false;
 129         }
 130
 131         p = str;
 132         num_offsets = 0;
 133         while ((p = strchr(p, '/')) != NULL) {
 134                 offsets[num_offsets] = p-str;
 135                 num_offsets += 1;
 136                 p += 1;
 137         }
 138
 139         *poffsets = offsets;
 140         *pnum_offsets = num_offsets;
 141         return true;
 142 }
 143
 144 static char *shadow_copy2_insert_string(TALLOC_CTX *mem_ctx,
 145                                         struct vfs_handle_struct *handle,
 146                                         time_t snapshot)
 147 {
 148         const char *fmt;
 149         struct tm snap_tm;
 150         fstring snaptime_string;
 151         size_t snaptime_len;
 152
 153         fmt = lp_parm_const_string(SNUM(handle->conn), "shadow",
 154                                    "format", GMT_FORMAT);
 155
 156         if (lp_parm_bool(SNUM(handle->conn), "shadow", "sscanf", false)) {
 157                 snaptime_len = snprintf(snaptime_string, sizeof(snaptime_string), fmt,
 158                                    (unsigned long)snapshot);
 159                 if (snaptime_len <= 0) {
 160                         DEBUG(10, ("snprintf failed\n"));
 161                         return NULL;
 162                 }
 163         } else {
 164                 if (lp_parm_bool(SNUM(handle->conn), "shadow", "localtime", false)) {
 165                         if (localtime_r(&snapshot, &snap_tm) == 0) {
 166                                 DEBUG(10, ("gmtime_r failed\n"));
 167                                 return NULL;
 168                         }
 169                 } else {
 170                         if (gmtime_r(&snapshot, &snap_tm) == 0) {
 171                                 DEBUG(10, ("gmtime_r failed\n"));
 172                                 return NULL;
 173                         }
 174                 }
 175                 snaptime_len = strftime(snaptime_string, sizeof(snaptime_string), fmt,
 176                                    &snap_tm);
 177                 if (snaptime_len == 0) {
 178                         DEBUG(10, ("strftime failed\n"));
 179                         return NULL;
 180                 }
 181         }
 182         return talloc_asprintf(mem_ctx, "/%s/%s",
 183                                lp_parm_const_string(
 184                                        SNUM(handle->conn), "shadow", "snapdir",
 185                                        ".snapshots"),
 186                                snaptime_string);
 187 }
 188
 189 static bool shadow_copy2_strip_snapshot(TALLOC_CTX *mem_ctx,
 190                                         struct vfs_handle_struct *handle,
 191                                         const char *name,
 192                                         time_t *ptimestamp,
 193                                         char **pstripped)
 194 {
 195         struct tm tm;
 196         time_t timestamp;
 197         const char *p;
 198         char *q;
 199         char *stripped;
 200         size_t rest_len, dst_len;
 201
 202         p = strstr_m(name, "@GMT-");
 203         if (p == NULL) {
 204                 goto no_snapshot;
 205         }
 206         if ((p > name) && (p[-1] != '/')) {
 207                 goto no_snapshot;
 208         }
 209         q = strptime(p, GMT_FORMAT, &tm);
 210         if (q == NULL) {
 211                 goto no_snapshot;
 212         }
 213         tm.tm_isdst = -1;
 214         timestamp = timegm(&tm);
 215         if (timestamp == (time_t)-1) {
 216                 goto no_snapshot;
 217         }
 218         if ((p == name) && (q[0] == '\0')) {
 219                 if (pstripped != NULL) {
 220                         stripped = talloc_strdup(mem_ctx, "");
 221                         if (stripped == NULL) {
 222                                 return false;
 223                         }
 224                         *pstripped = stripped;
 225                 }
 226                 *ptimestamp = timestamp;
 227                 return true;
 228         }
 229         if (q[0] != '/') {
 230                 goto no_snapshot;
 231         }
 232         q += 1;
 233
 234         rest_len = strlen(q);
 235         dst_len = (p-name) + rest_len;
 236
 237         if (lp_parm_bool(SNUM(handle->conn), "shadow", "snapdirseverywhere",
 238                          false)) {
 239                 char *insert;
 240                 bool have_insert;
 241                 insert = shadow_copy2_insert_string(talloc_tos(), handle,
 242                                                     timestamp);
 243                 if (insert == NULL) {
 244                         errno = ENOMEM;
 245                         return false;
 246                 }
 247
 248                 have_insert = (strstr(name, insert+1) != NULL);
 249                 TALLOC_FREE(insert);
 250                 if (have_insert) {
 251                         goto no_snapshot;
 252                 }
 253         }
 254
 255         if (pstripped != NULL) {
 256                 stripped = talloc_array(mem_ctx, char, dst_len+1);
 257                 if (stripped == NULL) {
 258                         errno = ENOMEM;
 259                         return false;
 260                 }
 261                 if (p > name) {
 262                         memcpy(stripped, name, p-name);
 263                 }
 264                 if (rest_len > 0) {
 265                         memcpy(stripped + (p-name), q, rest_len);
 266                 }
 267                 stripped[dst_len] = '\0';
 268                 *pstripped = stripped;
 269         }
 270         *ptimestamp = timestamp;
 271         return true;
 272 no_snapshot:
 273         *ptimestamp = 0;
 274         return true;
 275 }
 276
 277 static char *shadow_copy2_find_mount_point(TALLOC_CTX *mem_ctx,
 278                                            vfs_handle_struct *handle)
 279 {
 280         char *path = talloc_strdup(mem_ctx, handle->conn->connectpath);
 281         dev_t dev;
 282         struct stat st;
 283         char *p;
 284
 285         if (stat(path, &st) != 0) {
 286                 talloc_free(path);
 287                 return NULL;
 288         }
 289
 290         dev = st.st_dev;
 291
 292         while ((p = strrchr(path, '/')) && p > path) {
 293                 *p = 0;
 294                 if (stat(path, &st) != 0) {
 295                         talloc_free(path);
 296                         return NULL;
 297                 }
 298                 if (st.st_dev != dev) {
 299                         *p = '/';
 300                         break;
 301                 }
 302         }
 303
 304         return path;
 305 }
 306
 307 static char *shadow_copy2_convert(TALLOC_CTX *mem_ctx,
 308                                   struct vfs_handle_struct *handle,
 309                                   const char *name, time_t timestamp)
 310 {
 311         struct smb_filename converted_fname;
 312         char *result = NULL;
 313         size_t *slashes = NULL;
 314         unsigned num_slashes;
 315         char *path = NULL;
 316         size_t pathlen;
 317         char *insert = NULL;
 318         char *converted = NULL;
 319         size_t insertlen;
 320         int i, saved_errno;
 321         size_t min_offset;
 322
 323         path = talloc_asprintf(mem_ctx, "%s/%s", handle->conn->connectpath,
 324                                name);
 325         if (path == NULL) {
 326                 errno = ENOMEM;
 327                 goto fail;
 328         }
 329         pathlen = talloc_get_size(path)-1;
 330
 331         DEBUG(10, ("converting %s\n", path));
 332
 333         if (!shadow_copy2_find_slashes(talloc_tos(), path,
 334                                        &slashes, &num_slashes)) {
 335                 goto fail;
 336         }
 337         insert = shadow_copy2_insert_string(talloc_tos(), handle, timestamp);
 338         if (insert == NULL) {
 339                 goto fail;
 340         }
 341         insertlen = talloc_get_size(insert)-1;
 342         converted = talloc_array(mem_ctx, char, pathlen + insertlen + 1);
 343         if (converted == NULL) {
 344                 goto fail;
 345         }
 346
 347         if (path[pathlen-1] != '/') {
 348                 /*
 349                  * Append a fake slash to find the snapshot root
 350                  */
 351                 size_t *tmp;
 352                 tmp = talloc_realloc(talloc_tos(), slashes,
 353                                      size_t, num_slashes+1);
 354                 if (tmp == NULL) {
 355                         goto fail;
 356                 }
 357                 slashes = tmp;
 358                 slashes[num_slashes] = pathlen;
 359                 num_slashes += 1;
 360         }
 361
 362         min_offset = 0;
 363
 364         if (!lp_parm_bool(SNUM(handle->conn), "shadow", "crossmountpoints",
 365                           false)) {
 366                 char *mount_point;
 367
 368                 mount_point = shadow_copy2_find_mount_point(talloc_tos(),
 369                                                             handle);
 370                 if (mount_point == NULL) {
 371                         goto fail;
 372                 }
 373                 min_offset = strlen(mount_point);
 374                 TALLOC_FREE(mount_point);
 375         }
 376
 377         memcpy(converted, path, pathlen+1);
 378         converted[pathlen+insertlen] = '\0';
 379
 380         ZERO_STRUCT(converted_fname);
 381         converted_fname.base_name = converted;
 382
 383         for (i = num_slashes-1; i>=0; i--) {
 384                 int ret;
 385                 size_t offset;
 386
 387                 offset = slashes[i];
 388
 389                 if (offset < min_offset) {
 390                         errno = ENOENT;
 391                         goto fail;
 392                 }
 393
 394                 memcpy(converted+offset, insert, insertlen);
 395
 396                 offset += insertlen;
 397                 memcpy(converted+offset, path + slashes[i],
 398                        pathlen - slashes[i]);
 399
 400                 ret = SMB_VFS_NEXT_LSTAT(handle, &converted_fname);
 401
 402                 DEBUG(10, ("Trying %s: %d (%s)\n", converted,
 403                            ret, ret == 0 ? "ok" : strerror(errno)));
 404                 if (ret == 0) {
 405                         /* success */
 406                         break;
 407                 }
 408                 if (errno == ENOTDIR) {
 409                         /*
 410                          * This is a valid condition: We appended the
 411                          * .snaphots/@GMT.. to a file name. Just try
 412                          * with the upper levels.
 413                          */
 414                         continue;
 415                 }
 416                 if (errno != ENOENT) {
 417                         /* Other problem than "not found" */
 418                         goto fail;
 419                 }
 420         }
 421
 422         if (i >= 0) {
 423                 /*
 424                  * Found something
 425                  */
 426                 DEBUG(10, ("Found %s\n", converted));
 427                 result = converted;
 428                 converted = NULL;
 429         } else {
 430                 errno = ENOENT;
 431         }
 432 fail:
 433         saved_errno = errno;
 434         TALLOC_FREE(converted);
 435         TALLOC_FREE(insert);
 436         TALLOC_FREE(slashes);
 437         TALLOC_FREE(path);
 438         errno = saved_errno;
 439         return result;
 440 }
 441
 442 /*
 443   modify a sbuf return to ensure that inodes in the shadow directory
 444   are different from those in the main directory
 445  */
 446 static void convert_sbuf(vfs_handle_struct *handle, const char *fname,
 447                          SMB_STRUCT_STAT *sbuf)
 448 {
 449         if (lp_parm_bool(SNUM(handle->conn), "shadow", "fixinodes", False)) {
 450                 /* some snapshot systems, like GPFS, return the name
 451                    device:inode for the snapshot files as the current
 452                    files. That breaks the 'restore' button in the shadow copy
 453                    GUI, as the client gets a sharing violation.
 454
 455                    This is a crude way of allowing both files to be
 456                    open at once. It has a slight chance of inode
 457                    number collision, but I can't see a better approach
 458                    without significant VFS changes
 459                 */
 460                 uint32_t shash;
 461
 462                 shash = hash(fname, strlen(fname), 0) & 0xFF000000;
 463                 if (shash == 0) {
 464                         shash = 1;
 465                 }
 466                 sbuf->st_ex_ino ^= shash;
 467         }
 468 }
 469
 470 static DIR *shadow_copy2_opendir(vfs_handle_struct *handle,
 471                                             const char *fname,
 472                                             const char *mask,
 473                                             uint32 attr)
 474 {
 475         time_t timestamp;
 476         char *stripped;
 477         DIR *ret;
 478         int saved_errno;
 479         char *conv;
 480
 481         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 482                                          &timestamp, &stripped)) {
 483                 return NULL;
 484         }
 485         if (timestamp == 0) {
 486                 return SMB_VFS_NEXT_OPENDIR(handle, fname, mask, attr);
 487         }
 488         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 489         TALLOC_FREE(stripped);
 490         if (conv == NULL) {
 491                 return NULL;
 492         }
 493         ret = SMB_VFS_NEXT_OPENDIR(handle, conv, mask, attr);
 494         saved_errno = errno;
 495         TALLOC_FREE(conv);
 496         errno = saved_errno;
 497         return ret;
 498 }
 499
 500 static int shadow_copy2_rename(vfs_handle_struct *handle,
 501                                const struct smb_filename *smb_fname_src,
 502                                const struct smb_filename *smb_fname_dst)
 503 {
 504         time_t timestamp_src, timestamp_dst;
 505
 506         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 507                                          smb_fname_src->base_name,
 508                                          &timestamp_src, NULL)) {
 509                 return -1;
 510         }
 511         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 512                                          smb_fname_dst->base_name,
 513                                          &timestamp_dst, NULL)) {
 514                 return -1;
 515         }
 516         if (timestamp_src != 0) {
 517                 errno = EXDEV;
 518                 return -1;
 519         }
 520         if (timestamp_dst != 0) {
 521                 errno = EROFS;
 522                 return -1;
 523         }
 524         return SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
 525 }
 526
 527 static int shadow_copy2_symlink(vfs_handle_struct *handle,
 528                                 const char *oldname, const char *newname)
 529 {
 530         time_t timestamp_old, timestamp_new;
 531
 532         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
 533                                          &timestamp_old, NULL)) {
 534                 return -1;
 535         }
 536         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
 537                                          &timestamp_new, NULL)) {
 538                 return -1;
 539         }
 540         if ((timestamp_old != 0) || (timestamp_new != 0)) {
 541                 errno = EROFS;
 542                 return -1;
 543         }
 544         return SMB_VFS_NEXT_SYMLINK(handle, oldname, newname);
 545 }
 546
 547 static int shadow_copy2_link(vfs_handle_struct *handle,
 548                              const char *oldname, const char *newname)
 549 {
 550         time_t timestamp_old, timestamp_new;
 551
 552         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, oldname,
 553                                          &timestamp_old, NULL)) {
 554                 return -1;
 555         }
 556         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, newname,
 557                                          &timestamp_new, NULL)) {
 558                 return -1;
 559         }
 560         if ((timestamp_old != 0) || (timestamp_new != 0)) {
 561                 errno = EROFS;
 562                 return -1;
 563         }
 564         return SMB_VFS_NEXT_LINK(handle, oldname, newname);
 565 }
 566
 567 static int shadow_copy2_stat(vfs_handle_struct *handle,
 568                              struct smb_filename *smb_fname)
 569 {
 570         time_t timestamp;
 571         char *stripped, *tmp;
 572         int ret, saved_errno;
 573
 574         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 575                                          smb_fname->base_name,
 576                                          &timestamp, &stripped)) {
 577                 return -1;
 578         }
 579         if (timestamp == 0) {
 580                 return SMB_VFS_NEXT_STAT(handle, smb_fname);
 581         }
 582
 583         tmp = smb_fname->base_name;
 584         smb_fname->base_name = shadow_copy2_convert(
 585                 talloc_tos(), handle, stripped, timestamp);
 586         TALLOC_FREE(stripped);
 587
 588         if (smb_fname->base_name == NULL) {
 589                 smb_fname->base_name = tmp;
 590                 return -1;
 591         }
 592
 593         ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
 594         saved_errno = errno;
 595
 596         TALLOC_FREE(smb_fname->base_name);
 597         smb_fname->base_name = tmp;
 598
 599         if (ret == 0) {
 600                 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
 601         }
 602         errno = saved_errno;
 603         return ret;
 604 }
 605
 606 static int shadow_copy2_lstat(vfs_handle_struct *handle,
 607                               struct smb_filename *smb_fname)
 608 {
 609         time_t timestamp;
 610         char *stripped, *tmp;
 611         int ret, saved_errno;
 612
 613         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 614                                          smb_fname->base_name,
 615                                          &timestamp, &stripped)) {
 616                 return -1;
 617         }
 618         if (timestamp == 0) {
 619                 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
 620         }
 621
 622         tmp = smb_fname->base_name;
 623         smb_fname->base_name = shadow_copy2_convert(
 624                 talloc_tos(), handle, stripped, timestamp);
 625         TALLOC_FREE(stripped);
 626
 627         if (smb_fname->base_name == NULL) {
 628                 smb_fname->base_name = tmp;
 629                 return -1;
 630         }
 631
 632         ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
 633         saved_errno = errno;
 634
 635         TALLOC_FREE(smb_fname->base_name);
 636         smb_fname->base_name = tmp;
 637
 638         if (ret == 0) {
 639                 convert_sbuf(handle, smb_fname->base_name, &smb_fname->st);
 640         }
 641         errno = saved_errno;
 642         return ret;
 643 }
 644
 645 static int shadow_copy2_fstat(vfs_handle_struct *handle, files_struct *fsp,
 646                               SMB_STRUCT_STAT *sbuf)
 647 {
 648         time_t timestamp;
 649         int ret;
 650
 651         ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
 652         if (ret == -1) {
 653                 return ret;
 654         }
 655         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 656                                          fsp->fsp_name->base_name,
 657                                          &timestamp, NULL)) {
 658                 return 0;
 659         }
 660         if (timestamp != 0) {
 661                 convert_sbuf(handle, fsp->fsp_name->base_name, sbuf);
 662         }
 663         return 0;
 664 }
 665
 666 static int shadow_copy2_open(vfs_handle_struct *handle,
 667                              struct smb_filename *smb_fname, files_struct *fsp,
 668                              int flags, mode_t mode)
 669 {
 670         time_t timestamp;
 671         char *stripped, *tmp;
 672         int ret, saved_errno;
 673
 674         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 675                                          smb_fname->base_name,
 676                                          &timestamp, &stripped)) {
 677                 return -1;
 678         }
 679         if (timestamp == 0) {
 680                 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 681         }
 682
 683         tmp = smb_fname->base_name;
 684         smb_fname->base_name = shadow_copy2_convert(
 685                 talloc_tos(), handle, stripped, timestamp);
 686         TALLOC_FREE(stripped);
 687
 688         if (smb_fname->base_name == NULL) {
 689                 smb_fname->base_name = tmp;
 690                 return -1;
 691         }
 692
 693         ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
 694         saved_errno = errno;
 695
 696         TALLOC_FREE(smb_fname->base_name);
 697         smb_fname->base_name = tmp;
 698
 699         errno = saved_errno;
 700         return ret;
 701 }
 702
 703 static int shadow_copy2_unlink(vfs_handle_struct *handle,
 704                                const struct smb_filename *smb_fname)
 705 {
 706         time_t timestamp;
 707         char *stripped;
 708         int ret, saved_errno;
 709         struct smb_filename *conv;
 710         NTSTATUS status;
 711
 712         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 713                                          smb_fname->base_name,
 714                                          &timestamp, &stripped)) {
 715                 return -1;
 716         }
 717         if (timestamp == 0) {
 718                 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
 719         }
 720         status = copy_smb_filename(talloc_tos(), smb_fname, &conv);
 721         if (!NT_STATUS_IS_OK(status)) {
 722                 errno = ENOMEM;
 723                 return -1;
 724         }
 725         conv->base_name = shadow_copy2_convert(
 726                 conv, handle, stripped, timestamp);
 727         TALLOC_FREE(stripped);
 728         if (conv->base_name == NULL) {
 729                 return -1;
 730         }
 731         ret = SMB_VFS_NEXT_UNLINK(handle, conv);
 732         saved_errno = errno;
 733         TALLOC_FREE(conv);
 734         errno = saved_errno;
 735         return ret;
 736 }
 737
 738 static int shadow_copy2_chmod(vfs_handle_struct *handle, const char *fname,
 739                               mode_t mode)
 740 {
 741         time_t timestamp;
 742         char *stripped;
 743         int ret, saved_errno;
 744         char *conv;
 745
 746         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 747                                          &timestamp, &stripped)) {
 748                 return -1;
 749         }
 750         if (timestamp == 0) {
 751                 return SMB_VFS_NEXT_CHMOD(handle, fname, mode);
 752         }
 753         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 754         TALLOC_FREE(stripped);
 755         if (conv == NULL) {
 756                 return -1;
 757         }
 758         ret = SMB_VFS_NEXT_CHMOD(handle, conv, mode);
 759         saved_errno = errno;
 760         TALLOC_FREE(conv);
 761         errno = saved_errno;
 762         return ret;
 763 }
 764
 765 static int shadow_copy2_chown(vfs_handle_struct *handle, const char *fname,
 766                               uid_t uid, gid_t gid)
 767 {
 768         time_t timestamp;
 769         char *stripped;
 770         int ret, saved_errno;
 771         char *conv;
 772
 773         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 774                                          &timestamp, &stripped)) {
 775                 return -1;
 776         }
 777         if (timestamp == 0) {
 778                 return SMB_VFS_NEXT_CHOWN(handle, fname, uid, gid);
 779         }
 780         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 781         TALLOC_FREE(stripped);
 782         if (conv == NULL) {
 783                 return -1;
 784         }
 785         ret = SMB_VFS_NEXT_CHOWN(handle, conv, uid, gid);
 786         saved_errno = errno;
 787         TALLOC_FREE(conv);
 788         errno = saved_errno;
 789         return ret;
 790 }
 791
 792 static int shadow_copy2_chdir(vfs_handle_struct *handle,
 793                               const char *fname)
 794 {
 795         time_t timestamp;
 796         char *stripped;
 797         int ret, saved_errno;
 798         char *conv;
 799
 800         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 801                                          &timestamp, &stripped)) {
 802                 return -1;
 803         }
 804         if (timestamp == 0) {
 805                 return SMB_VFS_NEXT_CHDIR(handle, fname);
 806         }
 807         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 808         TALLOC_FREE(stripped);
 809         if (conv == NULL) {
 810                 return -1;
 811         }
 812         ret = SMB_VFS_NEXT_CHDIR(handle, conv);
 813         saved_errno = errno;
 814         TALLOC_FREE(conv);
 815         errno = saved_errno;
 816         return ret;
 817 }
 818
 819 static int shadow_copy2_ntimes(vfs_handle_struct *handle,
 820                                const struct smb_filename *smb_fname,
 821                                struct smb_file_time *ft)
 822 {
 823         time_t timestamp;
 824         char *stripped;
 825         int ret, saved_errno;
 826         struct smb_filename *conv;
 827         NTSTATUS status;
 828
 829         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
 830                                          smb_fname->base_name,
 831                                          &timestamp, &stripped)) {
 832                 return -1;
 833         }
 834         if (timestamp == 0) {
 835                 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
 836         }
 837         status = copy_smb_filename(talloc_tos(), smb_fname, &conv);
 838         if (!NT_STATUS_IS_OK(status)) {
 839                 errno = ENOMEM;
 840                 return -1;
 841         }
 842         conv->base_name = shadow_copy2_convert(
 843                 conv, handle, stripped, timestamp);
 844         TALLOC_FREE(stripped);
 845         if (conv->base_name == NULL) {
 846                 return -1;
 847         }
 848         ret = SMB_VFS_NEXT_NTIMES(handle, conv, ft);
 849         saved_errno = errno;
 850         TALLOC_FREE(conv);
 851         errno = saved_errno;
 852         return ret;
 853 }
 854
 855 static int shadow_copy2_readlink(vfs_handle_struct *handle,
 856                                  const char *fname, char *buf, size_t bufsiz)
 857 {
 858         time_t timestamp;
 859         char *stripped;
 860         int ret, saved_errno;
 861         char *conv;
 862
 863         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 864                                          &timestamp, &stripped)) {
 865                 return -1;
 866         }
 867         if (timestamp == 0) {
 868                 return SMB_VFS_NEXT_READLINK(handle, fname, buf, bufsiz);
 869         }
 870         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 871         TALLOC_FREE(stripped);
 872         if (conv == NULL) {
 873                 return -1;
 874         }
 875         ret = SMB_VFS_NEXT_READLINK(handle, conv, buf, bufsiz);
 876         saved_errno = errno;
 877         TALLOC_FREE(conv);
 878         errno = saved_errno;
 879         return ret;
 880 }
 881
 882 static int shadow_copy2_mknod(vfs_handle_struct *handle,
 883                               const char *fname, mode_t mode, SMB_DEV_T dev)
 884 {
 885         time_t timestamp;
 886         char *stripped;
 887         int ret, saved_errno;
 888         char *conv;
 889
 890         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 891                                          &timestamp, &stripped)) {
 892                 return -1;
 893         }
 894         if (timestamp == 0) {
 895                 return SMB_VFS_NEXT_MKNOD(handle, fname, mode, dev);
 896         }
 897         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 898         TALLOC_FREE(stripped);
 899         if (conv == NULL) {
 900                 return -1;
 901         }
 902         ret = SMB_VFS_NEXT_MKNOD(handle, conv, mode, dev);
 903         saved_errno = errno;
 904         TALLOC_FREE(conv);
 905         errno = saved_errno;
 906         return ret;
 907 }
 908
 909 static char *shadow_copy2_realpath(vfs_handle_struct *handle,
 910                                    const char *fname)
 911 {
 912         time_t timestamp;
 913         char *stripped = NULL;
 914         char *tmp = NULL;
 915         char *result = NULL;
 916         char *inserted = NULL;
 917         char *inserted_to, *inserted_end;
 918         int saved_errno;
 919
 920         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
 921                                          &timestamp, &stripped)) {
 922                 goto done;
 923         }
 924         if (timestamp == 0) {
 925                 return SMB_VFS_NEXT_REALPATH(handle, fname);
 926         }
 927
 928         tmp = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
 929         if (tmp == NULL) {
 930                 goto done;
 931         }
 932
 933         result = SMB_VFS_NEXT_REALPATH(handle, tmp);
 934         if (result == NULL) {
 935                 goto done;
 936         }
 937
 938         /*
 939          * Take away what we've inserted. This removes the @GMT-thingy
 940          * completely, but will give a path under the share root.
 941          */
 942         inserted = shadow_copy2_insert_string(talloc_tos(), handle, timestamp);
 943         if (inserted == NULL) {
 944                 goto done;
 945         }
 946         inserted_to = strstr_m(result, inserted);
 947         if (inserted_to == NULL) {
 948                 DEBUG(2, ("SMB_VFS_NEXT_REALPATH removed %s\n", inserted));
 949                 goto done;
 950         }
 951         inserted_end = inserted_to + talloc_get_size(inserted) - 1;
 952         memmove(inserted_to, inserted_end, strlen(inserted_end)+1);
 953
 954 done:
 955         saved_errno = errno;
 956         TALLOC_FREE(inserted);
 957         TALLOC_FREE(tmp);
 958         TALLOC_FREE(stripped);
 959         errno = saved_errno;
 960         return result;
 961 }
 962
 963 static char *have_snapdir(struct vfs_handle_struct *handle,
 964                           const char *path)
 965 {
 966         struct smb_filename smb_fname;
 967         int ret;
 968
 969         ZERO_STRUCT(smb_fname);
 970         smb_fname.base_name = talloc_asprintf(
 971                 talloc_tos(), "%s/%s", path,
 972                 lp_parm_const_string(SNUM(handle->conn), "shadow", "snapdir",
 973                                      ".snapshots"));
 974         if (smb_fname.base_name == NULL) {
 975                 return NULL;
 976         }
 977
 978         ret = SMB_VFS_NEXT_STAT(handle, &smb_fname);
 979         if ((ret == 0) && (S_ISDIR(smb_fname.st.st_ex_mode))) {
 980                 return smb_fname.base_name;
 981         }
 982         TALLOC_FREE(smb_fname.base_name);
 983         return NULL;
 984 }
 985
 986 static char *shadow_copy2_find_snapdir(TALLOC_CTX *mem_ctx,
 987                                        struct vfs_handle_struct *handle,
 988                                        struct smb_filename *smb_fname)
 989 {
 990         char *path, *p;
 991         char *snapdir;
 992
 993         path = talloc_asprintf(mem_ctx, "%s/%s",
 994                                handle->conn->connectpath,
 995                                smb_fname->base_name);
 996         if (path == NULL) {
 997                 return NULL;
 998         }
 999
1000         snapdir = have_snapdir(handle, path);
1001         if (snapdir != NULL) {
1002                 TALLOC_FREE(path);
1003                 return snapdir;
1004         }
1005
1006         while ((p = strrchr(path, '/')) && (p > path)) {
1007
1008                 p[0] = '\0';
1009
1010                 snapdir = have_snapdir(handle, path);
1011                 if (snapdir != NULL) {
1012                         TALLOC_FREE(path);
1013                         return snapdir;
1014                 }
1015         }
1016         TALLOC_FREE(path);
1017         return NULL;
1018 }
1019
1020 static bool shadow_copy2_snapshot_to_gmt(vfs_handle_struct *handle,
1021                                          const char *name,
1022                                          char *gmt, size_t gmt_len)
1023 {
1024         struct tm timestamp;
1025         time_t timestamp_t;
1026         unsigned long int timestamp_long;
1027         const char *fmt;
1028
1029         fmt = lp_parm_const_string(SNUM(handle->conn), "shadow",
1030                                    "format", GMT_FORMAT);
1031
1032         ZERO_STRUCT(timestamp);
1033         if (lp_parm_bool(SNUM(handle->conn), "shadow", "sscanf", false)) {
1034                 if (sscanf(name, fmt, &timestamp_long) != 1) {
1035                         DEBUG(10, ("shadow_copy2_snapshot_to_gmt: no sscanf match %s: %s\n",
1036                                    fmt, name));
1037                         return false;
1038                 }
1039                 timestamp_t = timestamp_long;
1040                 gmtime_r(&timestamp_t, &timestamp);
1041         } else {
1042                 if (strptime(name, fmt, &timestamp) == NULL) {
1043                         DEBUG(10, ("shadow_copy2_snapshot_to_gmt: no match %s: %s\n",
1044                                    fmt, name));
1045                         return false;
1046                 }
1047                 DEBUG(10, ("shadow_copy2_snapshot_to_gmt: match %s: %s\n", fmt, name));
1048
1049                 if (lp_parm_bool(SNUM(handle->conn), "shadow", "localtime", false)) {
1050                         timestamp.tm_isdst = -1;
1051                         timestamp_t = mktime(&timestamp);
1052                         gmtime_r(&timestamp_t, &timestamp);
1053                 }
1054         }
1055
1056         strftime(gmt, gmt_len, GMT_FORMAT, &timestamp);
1057         return true;
1058 }
1059
1060 static int shadow_copy2_label_cmp_asc(const void *x, const void *y)
1061 {
1062         return strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1063 }
1064
1065 static int shadow_copy2_label_cmp_desc(const void *x, const void *y)
1066 {
1067         return -strncmp((const char *)x, (const char *)y, sizeof(SHADOW_COPY_LABEL));
1068 }
1069
1070 /*
1071   sort the shadow copy data in ascending or descending order
1072  */
1073 static void shadow_copy2_sort_data(vfs_handle_struct *handle,
1074                                    struct shadow_copy_data *shadow_copy2_data)
1075 {
1076         int (*cmpfunc)(const void *, const void *);
1077         const char *sort;
1078
1079         sort = lp_parm_const_string(SNUM(handle->conn), "shadow",
1080                                     "sort", "desc");
1081         if (sort == NULL) {
1082                 return;
1083         }
1084
1085         if (strcmp(sort, "asc") == 0) {
1086                 cmpfunc = shadow_copy2_label_cmp_asc;
1087         } else if (strcmp(sort, "desc") == 0) {
1088                 cmpfunc = shadow_copy2_label_cmp_desc;
1089         } else {
1090                 return;
1091         }
1092
1093         if (shadow_copy2_data && shadow_copy2_data->num_volumes > 0 &&
1094             shadow_copy2_data->labels)
1095         {
1096                 TYPESAFE_QSORT(shadow_copy2_data->labels,
1097                                shadow_copy2_data->num_volumes,
1098                                cmpfunc);
1099         }
1100 }
1101
1102 static int shadow_copy2_get_shadow_copy_data(
1103         vfs_handle_struct *handle, files_struct *fsp,
1104         struct shadow_copy_data *shadow_copy2_data,
1105         bool labels)
1106 {
1107         DIR *p;
1108         const char *snapdir;
1109         struct dirent *d;
1110         TALLOC_CTX *tmp_ctx = talloc_stackframe();
1111
1112         snapdir = shadow_copy2_find_snapdir(tmp_ctx, handle, fsp->fsp_name);
1113         if (snapdir == NULL) {
1114                 DEBUG(0,("shadow:snapdir not found for %s in get_shadow_copy_data\n",
1115                          handle->conn->connectpath));
1116                 errno = EINVAL;
1117                 talloc_free(tmp_ctx);
1118                 return -1;
1119         }
1120
1121         p = SMB_VFS_NEXT_OPENDIR(handle, snapdir, NULL, 0);
1122
1123         if (!p) {
1124                 DEBUG(2,("shadow_copy2: SMB_VFS_NEXT_OPENDIR() failed for '%s'"
1125                          " - %s\n", snapdir, strerror(errno)));
1126                 talloc_free(tmp_ctx);
1127                 errno = ENOSYS;
1128                 return -1;
1129         }
1130
1131         shadow_copy2_data->num_volumes = 0;
1132         shadow_copy2_data->labels      = NULL;
1133
1134         while ((d = SMB_VFS_NEXT_READDIR(handle, p, NULL))) {
1135                 char snapshot[GMT_NAME_LEN+1];
1136                 SHADOW_COPY_LABEL *tlabels;
1137
1138                 /*
1139                  * ignore names not of the right form in the snapshot
1140                  * directory
1141                  */
1142                 if (!shadow_copy2_snapshot_to_gmt(
1143                             handle, d->d_name,
1144                             snapshot, sizeof(snapshot))) {
1145
1146                         DEBUG(6, ("shadow_copy2_get_shadow_copy_data: "
1147                                   "ignoring %s\n", d->d_name));
1148                         continue;
1149                 }
1150                 DEBUG(6,("shadow_copy2_get_shadow_copy_data: %s -> %s\n",
1151                          d->d_name, snapshot));
1152
1153                 if (!labels) {
1154                         /* the caller doesn't want the labels */
1155                         shadow_copy2_data->num_volumes++;
1156                         continue;
1157                 }
1158
1159                 tlabels = talloc_realloc(shadow_copy2_data,
1160                                          shadow_copy2_data->labels,
1161                                          SHADOW_COPY_LABEL,
1162                                          shadow_copy2_data->num_volumes+1);
1163                 if (tlabels == NULL) {
1164                         DEBUG(0,("shadow_copy2: out of memory\n"));
1165                         SMB_VFS_NEXT_CLOSEDIR(handle, p);
1166                         talloc_free(tmp_ctx);
1167                         return -1;
1168                 }
1169
1170                 strlcpy(tlabels[shadow_copy2_data->num_volumes], snapshot,
1171                         sizeof(*tlabels));
1172
1173                 shadow_copy2_data->num_volumes++;
1174                 shadow_copy2_data->labels = tlabels;
1175         }
1176
1177         SMB_VFS_NEXT_CLOSEDIR(handle,p);
1178
1179         shadow_copy2_sort_data(handle, shadow_copy2_data);
1180
1181         talloc_free(tmp_ctx);
1182         return 0;
1183 }
1184
1185 static NTSTATUS shadow_copy2_fget_nt_acl(vfs_handle_struct *handle,
1186                                         struct files_struct *fsp,
1187                                         uint32 security_info,
1188                                          TALLOC_CTX *mem_ctx,
1189                                         struct security_descriptor **ppdesc)
1190 {
1191         time_t timestamp;
1192         char *stripped;
1193         NTSTATUS status;
1194         char *conv;
1195
1196         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle,
1197                                          fsp->fsp_name->base_name,
1198                                          &timestamp, &stripped)) {
1199                 return map_nt_error_from_unix(errno);
1200         }
1201         if (timestamp == 0) {
1202                 return SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
1203                                                 mem_ctx,
1204                                                 ppdesc);
1205         }
1206         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1207         TALLOC_FREE(stripped);
1208         if (conv == NULL) {
1209                 return map_nt_error_from_unix(errno);
1210         }
1211         status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv, security_info,
1212                                          mem_ctx, ppdesc);
1213         TALLOC_FREE(conv);
1214         return status;
1215 }
1216
1217 static NTSTATUS shadow_copy2_get_nt_acl(vfs_handle_struct *handle,
1218                                         const char *fname,
1219                                         uint32 security_info,
1220                                         TALLOC_CTX *mem_ctx,
1221                                         struct security_descriptor **ppdesc)
1222 {
1223         time_t timestamp;
1224         char *stripped;
1225         NTSTATUS status;
1226         char *conv;
1227
1228         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1229                                          &timestamp, &stripped)) {
1230                 return map_nt_error_from_unix(errno);
1231         }
1232         if (timestamp == 0) {
1233                 return SMB_VFS_NEXT_GET_NT_ACL(handle, fname, security_info,
1234                                                mem_ctx, ppdesc);
1235         }
1236         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1237         TALLOC_FREE(stripped);
1238         if (conv == NULL) {
1239                 return map_nt_error_from_unix(errno);
1240         }
1241         status = SMB_VFS_NEXT_GET_NT_ACL(handle, conv, security_info,
1242                                          mem_ctx, ppdesc);
1243         TALLOC_FREE(conv);
1244         return status;
1245 }
1246
1247 static int shadow_copy2_mkdir(vfs_handle_struct *handle,
1248                               const char *fname, mode_t mode)
1249 {
1250         time_t timestamp;
1251         char *stripped;
1252         int ret, saved_errno;
1253         char *conv;
1254
1255         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1256                                          &timestamp, &stripped)) {
1257                 return -1;
1258         }
1259         if (timestamp == 0) {
1260                 return SMB_VFS_NEXT_MKDIR(handle, fname, mode);
1261         }
1262         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1263         TALLOC_FREE(stripped);
1264         if (conv == NULL) {
1265                 return -1;
1266         }
1267         ret = SMB_VFS_NEXT_MKDIR(handle, conv, mode);
1268         saved_errno = errno;
1269         TALLOC_FREE(conv);
1270         errno = saved_errno;
1271         return ret;
1272 }
1273
1274 static int shadow_copy2_rmdir(vfs_handle_struct *handle, const char *fname)
1275 {
1276         time_t timestamp;
1277         char *stripped;
1278         int ret, saved_errno;
1279         char *conv;
1280
1281         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1282                                          &timestamp, &stripped)) {
1283                 return -1;
1284         }
1285         if (timestamp == 0) {
1286                 return SMB_VFS_NEXT_RMDIR(handle, fname);
1287         }
1288         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1289         TALLOC_FREE(stripped);
1290         if (conv == NULL) {
1291                 return -1;
1292         }
1293         ret = SMB_VFS_NEXT_RMDIR(handle, conv);
1294         saved_errno = errno;
1295         TALLOC_FREE(conv);
1296         errno = saved_errno;
1297         return ret;
1298 }
1299
1300 static int shadow_copy2_chflags(vfs_handle_struct *handle, const char *fname,
1301                                 unsigned int flags)
1302 {
1303         time_t timestamp;
1304         char *stripped;
1305         int ret, saved_errno;
1306         char *conv;
1307
1308         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1309                                          &timestamp, &stripped)) {
1310                 return -1;
1311         }
1312         if (timestamp == 0) {
1313                 return SMB_VFS_NEXT_CHFLAGS(handle, fname, flags);
1314         }
1315         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1316         TALLOC_FREE(stripped);
1317         if (conv == NULL) {
1318                 return -1;
1319         }
1320         ret = SMB_VFS_NEXT_CHFLAGS(handle, conv, flags);
1321         saved_errno = errno;
1322         TALLOC_FREE(conv);
1323         errno = saved_errno;
1324         return ret;
1325 }
1326
1327 static ssize_t shadow_copy2_getxattr(vfs_handle_struct *handle,
1328                                      const char *fname, const char *aname,
1329                                      void *value, size_t size)
1330 {
1331         time_t timestamp;
1332         char *stripped;
1333         ssize_t ret;
1334         int saved_errno;
1335         char *conv;
1336
1337         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1338                                          &timestamp, &stripped)) {
1339                 return -1;
1340         }
1341         if (timestamp == 0) {
1342                 return SMB_VFS_NEXT_GETXATTR(handle, fname, aname, value,
1343                                              size);
1344         }
1345         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1346         TALLOC_FREE(stripped);
1347         if (conv == NULL) {
1348                 return -1;
1349         }
1350         ret = SMB_VFS_NEXT_GETXATTR(handle, conv, aname, value, size);
1351         saved_errno = errno;
1352         TALLOC_FREE(conv);
1353         errno = saved_errno;
1354         return ret;
1355 }
1356
1357 static ssize_t shadow_copy2_listxattr(struct vfs_handle_struct *handle,
1358                                       const char *fname,
1359                                       char *list, size_t size)
1360 {
1361         time_t timestamp;
1362         char *stripped;
1363         ssize_t ret;
1364         int saved_errno;
1365         char *conv;
1366
1367         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1368                                          &timestamp, &stripped)) {
1369                 return -1;
1370         }
1371         if (timestamp == 0) {
1372                 return SMB_VFS_NEXT_LISTXATTR(handle, fname, list, size);
1373         }
1374         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1375         TALLOC_FREE(stripped);
1376         if (conv == NULL) {
1377                 return -1;
1378         }
1379         ret = SMB_VFS_NEXT_LISTXATTR(handle, conv, list, size);
1380         saved_errno = errno;
1381         TALLOC_FREE(conv);
1382         errno = saved_errno;
1383         return ret;
1384 }
1385
1386 static int shadow_copy2_removexattr(vfs_handle_struct *handle,
1387                                     const char *fname, const char *aname)
1388 {
1389         time_t timestamp;
1390         char *stripped;
1391         int ret, saved_errno;
1392         char *conv;
1393
1394         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1395                                          &timestamp, &stripped)) {
1396                 return -1;
1397         }
1398         if (timestamp == 0) {
1399                 return SMB_VFS_NEXT_REMOVEXATTR(handle, fname, aname);
1400         }
1401         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1402         TALLOC_FREE(stripped);
1403         if (conv == NULL) {
1404                 return -1;
1405         }
1406         ret = SMB_VFS_NEXT_REMOVEXATTR(handle, conv, aname);
1407         saved_errno = errno;
1408         TALLOC_FREE(conv);
1409         errno = saved_errno;
1410         return ret;
1411 }
1412
1413 static int shadow_copy2_setxattr(struct vfs_handle_struct *handle,
1414                                  const char *fname,
1415                                  const char *aname, const void *value,
1416                                  size_t size, int flags)
1417 {
1418         time_t timestamp;
1419         char *stripped;
1420         ssize_t ret;
1421         int saved_errno;
1422         char *conv;
1423
1424         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1425                                          &timestamp, &stripped)) {
1426                 return -1;
1427         }
1428         if (timestamp == 0) {
1429                 return SMB_VFS_NEXT_SETXATTR(handle, fname, aname, value, size,
1430                                              flags);
1431         }
1432         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1433         TALLOC_FREE(stripped);
1434         if (conv == NULL) {
1435                 return -1;
1436         }
1437         ret = SMB_VFS_NEXT_SETXATTR(handle, conv, aname, value, size, flags);
1438         saved_errno = errno;
1439         TALLOC_FREE(conv);
1440         errno = saved_errno;
1441         return ret;
1442 }
1443
1444 static int shadow_copy2_chmod_acl(vfs_handle_struct *handle,
1445                                   const char *fname, mode_t mode)
1446 {
1447         time_t timestamp;
1448         char *stripped;
1449         ssize_t ret;
1450         int saved_errno;
1451         char *conv;
1452
1453         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, fname,
1454                                          &timestamp, &stripped)) {
1455                 return -1;
1456         }
1457         if (timestamp == 0) {
1458                 return SMB_VFS_NEXT_CHMOD_ACL(handle, fname, mode);
1459         }
1460         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1461         TALLOC_FREE(stripped);
1462         if (conv == NULL) {
1463                 return -1;
1464         }
1465         ret = SMB_VFS_NEXT_CHMOD_ACL(handle, conv, mode);
1466         saved_errno = errno;
1467         TALLOC_FREE(conv);
1468         errno = saved_errno;
1469         return ret;
1470 }
1471
1472 static int shadow_copy2_get_real_filename(struct vfs_handle_struct *handle,
1473                                           const char *path,
1474                                           const char *name,
1475                                           TALLOC_CTX *mem_ctx,
1476                                           char **found_name)
1477 {
1478         time_t timestamp;
1479         char *stripped;
1480         ssize_t ret;
1481         int saved_errno;
1482         char *conv;
1483
1484         if (!shadow_copy2_strip_snapshot(talloc_tos(), handle, path,
1485                                          &timestamp, &stripped)) {
1486                 return -1;
1487         }
1488         if (timestamp == 0) {
1489                 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
1490                                                       mem_ctx, found_name);
1491         }
1492         if (stripped[0] == '\0') {
1493                 *found_name = talloc_strdup(mem_ctx, name);
1494                 if (*found_name == NULL) {
1495                         errno = ENOMEM;
1496                         return -1;
1497                 }
1498                 return 0;
1499         }
1500         conv = shadow_copy2_convert(talloc_tos(), handle, stripped, timestamp);
1501         TALLOC_FREE(stripped);
1502         if (conv == NULL) {
1503                 return -1;
1504         }
1505         ret = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, conv, name,
1506                                              mem_ctx, found_name);
1507         saved_errno = errno;
1508         TALLOC_FREE(conv);
1509         errno = saved_errno;
1510         return ret;
1511 }
1512
1513
1514 static struct vfs_fn_pointers vfs_shadow_copy2_fns = {
1515         .opendir_fn = shadow_copy2_opendir,
1516         .rename_fn = shadow_copy2_rename,
1517         .link_fn = shadow_copy2_link,
1518         .symlink_fn = shadow_copy2_symlink,
1519         .stat_fn = shadow_copy2_stat,
1520         .lstat_fn = shadow_copy2_lstat,
1521         .fstat_fn = shadow_copy2_fstat,
1522         .open_fn = shadow_copy2_open,
1523         .unlink_fn = shadow_copy2_unlink,
1524         .chmod_fn = shadow_copy2_chmod,
1525         .chown_fn = shadow_copy2_chown,
1526         .chdir_fn = shadow_copy2_chdir,
1527         .ntimes_fn = shadow_copy2_ntimes,
1528         .readlink_fn = shadow_copy2_readlink,
1529         .mknod_fn = shadow_copy2_mknod,
1530         .realpath_fn = shadow_copy2_realpath,
1531         .get_nt_acl_fn = shadow_copy2_get_nt_acl,
1532         .fget_nt_acl_fn = shadow_copy2_fget_nt_acl,
1533         .get_shadow_copy_data_fn = shadow_copy2_get_shadow_copy_data,
1534         .mkdir_fn = shadow_copy2_mkdir,
1535         .rmdir_fn = shadow_copy2_rmdir,
1536         .getxattr_fn = shadow_copy2_getxattr,
1537         .listxattr_fn = shadow_copy2_listxattr,
1538         .removexattr_fn = shadow_copy2_removexattr,
1539         .setxattr_fn = shadow_copy2_setxattr,
1540         .chmod_acl_fn = shadow_copy2_chmod_acl,
1541         .chflags_fn = shadow_copy2_chflags,
1542         .get_real_filename_fn = shadow_copy2_get_real_filename,
1543 };
1544
1545 NTSTATUS vfs_shadow_copy2_init(void);
1546 NTSTATUS vfs_shadow_copy2_init(void)
1547 {
1548         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1549                                 "shadow_copy2", &vfs_shadow_copy2_fns);
1550 }