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