?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
libsmb: Convert cli_NetServerEnum() away from cli_api()
[samba4-gss.git] / source3 / modules / vfs_ceph_snapshots.c
blob98b8f5f6b5d9744ad069cf9cc0ba57f18d97232d
1 /*
2 * Module for accessing CephFS snapshots as Previous Versions. This module is
3 * separate to vfs_ceph, so that it can also be used atop a CephFS kernel backed
4 * share with vfs_default.
5 *
6 * Copyright (C) David Disseldorp 2019
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include <dirent.h>
23 #include <libgen.h>
24 #include "includes.h"
25 #include "include/ntioctl.h"
26 #include "include/smb.h"
27 #include "system/filesys.h"
28 #include "smbd/smbd.h"
29 #include "lib/util/tevent_ntstatus.h"
30 #include "lib/util/smb_strtox.h"
31 #include "source3/smbd/dir.h"
32
33 #undef DBGC_CLASS
34 #define DBGC_CLASS DBGC_VFS
35
36 /*
37 * CephFS has a magic snapshots subdirectory in all parts of the directory tree.
38 * This module automatically makes all snapshots in this subdir visible to SMB
39 * clients (if permitted by corresponding access control).
40 */
41 #define CEPH_SNAP_SUBDIR_DEFAULT ".snap"
42 /*
43 * The ceph.snap.btime (virtual) extended attribute carries the snapshot
44 * creation time in $secs.$nsecs format. It was added as part of
45 * https://tracker.ceph.com/issues/38838. Running Samba atop old Ceph versions
46 * which don't provide this xattr will not be able to enumerate or access
47 * snapshots using this module. As an alternative, vfs_shadow_copy2 could be
48 * used instead, alongside special shadow:format snapshot directory names.
49 */
50 #define CEPH_SNAP_BTIME_XATTR "ceph.snap.btime"
51
52 static int ceph_snap_get_btime_fsp(struct vfs_handle_struct *handle,
53 struct files_struct *fsp,
54 time_t *_snap_secs)
55 {
56 int ret;
57 char snap_btime[33];
58 char *s = NULL;
59 char *endptr = NULL;
60 struct timespec snap_timespec;
61 int err;
62
63 ret = SMB_VFS_NEXT_FGETXATTR(handle,
64 fsp,
65 CEPH_SNAP_BTIME_XATTR,
66 snap_btime,
67 sizeof(snap_btime));
68 if (ret < 0) {
69 DBG_ERR("failed to get %s xattr: %s\n",
70 CEPH_SNAP_BTIME_XATTR, strerror(errno));
71 return -errno;
72 }
73
74 if (ret == 0 || ret >= sizeof(snap_btime) - 1) {
75 return -EINVAL;
76 }
77
78 /* ensure zero termination */
79 snap_btime[ret] = '\0';
80
81 /* format is sec.nsec */
82 s = strchr(snap_btime, '.');
83 if (s == NULL) {
84 DBG_ERR("invalid %s xattr value: %s\n",
85 CEPH_SNAP_BTIME_XATTR, snap_btime);
86 return -EINVAL;
87 }
88
89 /* First component is seconds, extract it */
90 *s = '\0';
91 snap_timespec.tv_sec = smb_strtoull(snap_btime,
92 &endptr,
93 10,
94 &err,
95 SMB_STR_FULL_STR_CONV);
96 if (err != 0) {
97 return -err;
98 }
99
100 /* second component is nsecs */
101 s++;
102 snap_timespec.tv_nsec = smb_strtoul(s,
103 &endptr,
104 10,
105 &err,
106 SMB_STR_FULL_STR_CONV);
107 if (err != 0) {
108 return -err;
109 }
110
111 /*
112 * >> 30 is a rough divide by ~10**9. No need to be exact, as @GMT
113 * tokens only offer 1-second resolution (while twrp is nsec).
114 */
115 *_snap_secs = snap_timespec.tv_sec + (snap_timespec.tv_nsec >> 30);
116
117 return 0;
118 }
119
120 /*
121 * XXX Ceph snapshots can be created with sub-second granularity, which means
122 * that multiple snapshots may be mapped to the same @GMT- label.
123 *
124 * @this_label is a pre-zeroed buffer to be filled with a @GMT label
125 * @return 0 if label successfully filled or -errno on error.
126 */
127 static int ceph_snap_fill_label(struct vfs_handle_struct *handle,
128 TALLOC_CTX *tmp_ctx,
129 struct files_struct *dirfsp,
130 const char *subdir,
131 SHADOW_COPY_LABEL this_label)
132 {
133 const char *parent_snapsdir = dirfsp->fsp_name->base_name;
134 struct smb_filename *smb_fname;
135 struct smb_filename *atname = NULL;
136 time_t snap_secs;
137 struct tm gmt_snap_time;
138 struct tm *tm_ret;
139 size_t str_sz;
140 char snap_path[PATH_MAX + 1];
141 int ret;
142 NTSTATUS status;
143
144 /*
145 * CephFS snapshot creation times are available via a special
146 * xattr - snapshot b/m/ctimes all match the snap source.
147 */
148 ret = snprintf(snap_path, sizeof(snap_path), "%s/%s",
149 parent_snapsdir, subdir);
150 if (ret >= sizeof(snap_path)) {
151 return -EINVAL;
152 }
153
154 smb_fname = synthetic_smb_fname(tmp_ctx,
155 snap_path,
156 NULL,
157 NULL,
158 0,
159 0);
160 if (smb_fname == NULL) {
161 return -ENOMEM;
162 }
163
164 ret = vfs_stat(handle->conn, smb_fname);
165 if (ret < 0) {
166 ret = -errno;
167 TALLOC_FREE(smb_fname);
168 return ret;
169 }
170
171 atname = synthetic_smb_fname(tmp_ctx,
172 subdir,
173 NULL,
174 &smb_fname->st,
175 0,
176 0);
177 if (atname == NULL) {
178 TALLOC_FREE(smb_fname);
179 return -ENOMEM;
180 }
181
182 status = openat_pathref_fsp(dirfsp, atname);
183 if (!NT_STATUS_IS_OK(status)) {
184 TALLOC_FREE(smb_fname);
185 TALLOC_FREE(atname);
186 return -map_errno_from_nt_status(status);
187 }
188
189 ret = ceph_snap_get_btime_fsp(handle, atname->fsp, &snap_secs);
190 if (ret < 0) {
191 TALLOC_FREE(smb_fname);
192 TALLOC_FREE(atname);
193 return ret;
194 }
195 TALLOC_FREE(smb_fname);
196 TALLOC_FREE(atname);
197
198 tm_ret = gmtime_r(&snap_secs, &gmt_snap_time);
199 if (tm_ret == NULL) {
200 return -EINVAL;
201 }
202 str_sz = strftime(this_label, sizeof(SHADOW_COPY_LABEL),
203 "@GMT-%Y.%m.%d-%H.%M.%S", &gmt_snap_time);
204 if (str_sz == 0) {
205 DBG_ERR("failed to convert tm to @GMT token\n");
206 return -EINVAL;
207 }
208
209 DBG_DEBUG("mapped snapshot at %s to enum snaps label %s\n",
210 snap_path, this_label);
211
212 return 0;
213 }
214
215 static int ceph_snap_enum_snapdir(struct vfs_handle_struct *handle,
216 struct smb_filename *snaps_dname,
217 bool labels,
218 struct shadow_copy_data *sc_data)
219 {
220 TALLOC_CTX *frame = talloc_stackframe();
221 struct smb_Dir *dir_hnd = NULL;
222 struct files_struct *dirfsp = NULL;
223 const char *dname = NULL;
224 char *talloced = NULL;
225 NTSTATUS status;
226 int ret;
227 uint32_t slots;
228
229 DBG_DEBUG("enumerating shadow copy dir at %s\n",
230 snaps_dname->base_name);
231
232 /*
233 * CephFS stat(dir).size *normally* returns the number of child entries
234 * for a given dir, but it unfortunately that's not the case for the one
235 * place we need it (dir=.snap), so we need to dynamically determine it
236 * via readdir.
237 */
238
239 status = OpenDir(frame,
240 handle->conn,
241 snaps_dname,
242 NULL,
243 0,
244 &dir_hnd);
245 if (!NT_STATUS_IS_OK(status)) {
246 ret = -map_errno_from_nt_status(status);
247 goto err_out;
248 }
249
250 /* Check we have SEC_DIR_LIST access on this fsp. */
251 dirfsp = dir_hnd_fetch_fsp(dir_hnd);
252 status = smbd_check_access_rights_fsp(dirfsp->conn->cwd_fsp,
253 dirfsp,
254 false,
255 SEC_DIR_LIST);
256 if (!NT_STATUS_IS_OK(status)) {
257 DBG_ERR("user does not have list permission "
258 "on snapdir %s\n",
259 fsp_str_dbg(dirfsp));
260 ret = -map_errno_from_nt_status(status);
261 goto err_out;
262 }
263
264 slots = 0;
265 sc_data->num_volumes = 0;
266 sc_data->labels = NULL;
267
268 while ((dname = ReadDirName(dir_hnd, &talloced)) != NULL) {
269 if (ISDOT(dname) || ISDOTDOT(dname)) {
270 TALLOC_FREE(talloced);
271 continue;
272 }
273 sc_data->num_volumes++;
274 if (!labels) {
275 TALLOC_FREE(talloced);
276 continue;
277 }
278 if (sc_data->num_volumes > slots) {
279 uint32_t new_slot_count = slots + 10;
280 SMB_ASSERT(new_slot_count > slots);
281 sc_data->labels = talloc_realloc(sc_data,
282 sc_data->labels,
283 SHADOW_COPY_LABEL,
284 new_slot_count);
285 if (sc_data->labels == NULL) {
286 TALLOC_FREE(talloced);
287 ret = -ENOMEM;
288 goto err_closedir;
289 }
290 memset(sc_data->labels[slots], 0,
291 sizeof(SHADOW_COPY_LABEL) * 10);
292
293 DBG_DEBUG("%d->%d slots for enum_snaps response\n",
294 slots, new_slot_count);
295 slots = new_slot_count;
296 }
297 DBG_DEBUG("filling shadow copy label for %s/%s\n",
298 snaps_dname->base_name, dname);
299 ret = ceph_snap_fill_label(handle,
300 snaps_dname,
301 dirfsp,
302 dname,
303 sc_data->labels[sc_data->num_volumes - 1]);
304 if (ret < 0) {
305 TALLOC_FREE(talloced);
306 goto err_closedir;
307 }
308 TALLOC_FREE(talloced);
309 }
310
311 DBG_DEBUG("%s shadow copy enumeration found %d labels \n",
312 snaps_dname->base_name, sc_data->num_volumes);
313
314 TALLOC_FREE(frame);
315 return 0;
316
317 err_closedir:
318 TALLOC_FREE(frame);
319 err_out:
320 TALLOC_FREE(sc_data->labels);
321 return ret;
322 }
323
324 /*
325 * Prior reading: The Meaning of Path Names
326 * https://wiki.samba.org/index.php/Writing_a_Samba_VFS_Module
327 *
328 * translate paths so that we can use the parent dir for .snap access:
329 * myfile -> parent= trimmed=myfile
330 * /a -> parent=/ trimmed=a
331 * dir/sub/file -> parent=dir/sub trimmed=file
332 * /dir/sub -> parent=/dir/ trimmed=sub
333 */
334 static int ceph_snap_get_parent_path(const char *connectpath,
335 const char *path,
336 char *_parent_buf,
337 size_t buflen,
338 const char **_trimmed)
339 {
340 const char *p;
341 size_t len;
342 int ret;
343
344 if (!strcmp(path, "/")) {
345 DBG_ERR("can't go past root for %s .snap dir\n", path);
346 return -EINVAL;
347 }
348
349 p = strrchr_m(path, '/'); /* Find final '/', if any */
350 if (p == NULL) {
351 DBG_DEBUG("parent .snap dir for %s is cwd\n", path);
352 ret = strlcpy(_parent_buf, "", buflen);
353 if (ret >= buflen) {
354 return -EINVAL;
355 }
356 if (_trimmed != NULL) {
357 *_trimmed = path;
358 }
359 return 0;
360 }
361
362 SMB_ASSERT(p >= path);
363 len = p - path;
364
365 ret = snprintf(_parent_buf, buflen, "%.*s", (int)len, path);
366 if (ret >= buflen) {
367 return -EINVAL;
368 }
369
370 /* for absolute paths, check that we're not going outside the share */
371 if ((len > 0) && (_parent_buf[0] == '/')) {
372 bool connectpath_match = false;
373 size_t clen = strlen(connectpath);
374 DBG_DEBUG("checking absolute path %s lies within share at %s\n",
375 _parent_buf, connectpath);
376 /* need to check for separator, to avoid /x/abcd vs /x/ab */
377 connectpath_match = (strncmp(connectpath,
378 _parent_buf,
379 clen) == 0);
380 if (!connectpath_match
381 || ((_parent_buf[clen] != '/') && (_parent_buf[clen] != '\0'))) {
382 DBG_ERR("%s parent path is outside of share at %s\n",
383 _parent_buf, connectpath);
384 return -EINVAL;
385 }
386 }
387
388 if (_trimmed != NULL) {
389 /*
390 * point to path component which was trimmed from _parent_buf
391 * excluding path separator.
392 */
393 *_trimmed = p + 1;
394 }
395
396 DBG_DEBUG("generated parent .snap path for %s as %s (trimmed \"%s\")\n",
397 path, _parent_buf, p + 1);
398
399 return 0;
400 }
401
402 static int ceph_snap_get_shadow_copy_data(struct vfs_handle_struct *handle,
403 struct files_struct *fsp,
404 struct shadow_copy_data *sc_data,
405 bool labels)
406 {
407 int ret;
408 TALLOC_CTX *tmp_ctx;
409 const char *parent_dir = NULL;
410 char tmp[PATH_MAX + 1];
411 char snaps_path[PATH_MAX + 1];
412 struct smb_filename *snaps_dname = NULL;
413 const char *snapdir = lp_parm_const_string(SNUM(handle->conn),
414 "ceph", "snapdir",
415 CEPH_SNAP_SUBDIR_DEFAULT);
416
417 DBG_DEBUG("getting shadow copy data for %s\n",
418 fsp->fsp_name->base_name);
419
420 tmp_ctx = talloc_new(fsp);
421 if (tmp_ctx == NULL) {
422 ret = -ENOMEM;
423 goto err_out;
424 }
425
426 if (sc_data == NULL) {
427 ret = -EINVAL;
428 goto err_out;
429 }
430
431 if (fsp->fsp_flags.is_directory) {
432 parent_dir = fsp->fsp_name->base_name;
433 } else {
434 ret = ceph_snap_get_parent_path(handle->conn->connectpath,
435 fsp->fsp_name->base_name,
436 tmp,
437 sizeof(tmp),
438 NULL); /* trimmed */
439 if (ret < 0) {
440 goto err_out;
441 }
442 parent_dir = tmp;
443 }
444
445 if (strlen(parent_dir) == 0) {
446 ret = strlcpy(snaps_path, snapdir, sizeof(snaps_path));
447 } else {
448 ret = snprintf(snaps_path, sizeof(snaps_path), "%s/%s",
449 parent_dir, snapdir);
450 }
451 if (ret >= sizeof(snaps_path)) {
452 ret = -EINVAL;
453 goto err_out;
454 }
455
456 snaps_dname = synthetic_smb_fname(tmp_ctx,
457 snaps_path,
458 NULL,
459 NULL,
460 0,
461 fsp->fsp_name->flags);
462 if (snaps_dname == NULL) {
463 ret = -ENOMEM;
464 goto err_out;
465 }
466
467 ret = ceph_snap_enum_snapdir(handle, snaps_dname, labels, sc_data);
468 if (ret < 0) {
469 goto err_out;
470 }
471
472 talloc_free(tmp_ctx);
473 return 0;
474
475 err_out:
476 talloc_free(tmp_ctx);
477 errno = -ret;
478 return -1;
479 }
480
481 static int ceph_snap_gmt_strip_snapshot(struct vfs_handle_struct *handle,
482 const struct smb_filename *smb_fname,
483 time_t *_timestamp,
484 char *_stripped_buf,
485 size_t buflen)
486 {
487 size_t len;
488
489 if (smb_fname->twrp == 0) {
490 goto no_snapshot;
491 }
492
493 if (_stripped_buf != NULL) {
494 len = strlcpy(_stripped_buf, smb_fname->base_name, buflen);
495 if (len >= buflen) {
496 return -ENAMETOOLONG;
497 }
498 }
499
500 *_timestamp = nt_time_to_unix(smb_fname->twrp);
501 return 0;
502 no_snapshot:
503 *_timestamp = 0;
504 return 0;
505 }
506
507 static int ceph_snap_gmt_convert_dir(struct vfs_handle_struct *handle,
508 const char *name,
509 time_t timestamp,
510 char *_converted_buf,
511 size_t buflen)
512 {
513 int ret;
514 NTSTATUS status;
515 struct smb_Dir *dir_hnd = NULL;
516 struct files_struct *dirfsp = NULL;
517 const char *dname = NULL;
518 char *talloced = NULL;
519 struct smb_filename *snaps_dname = NULL;
520 const char *snapdir = lp_parm_const_string(SNUM(handle->conn),
521 "ceph", "snapdir",
522 CEPH_SNAP_SUBDIR_DEFAULT);
523 TALLOC_CTX *tmp_ctx = talloc_new(NULL);
524
525 if (tmp_ctx == NULL) {
526 ret = -ENOMEM;
527 goto err_out;
528 }
529
530 /*
531 * Temporally use the caller's return buffer for this.
532 */
533 if (strlen(name) == 0) {
534 ret = strlcpy(_converted_buf, snapdir, buflen);
535 } else {
536 ret = snprintf(_converted_buf, buflen, "%s/%s", name, snapdir);
537 }
538 if (ret >= buflen) {
539 ret = -EINVAL;
540 goto err_out;
541 }
542
543 snaps_dname = synthetic_smb_fname(tmp_ctx,
544 _converted_buf,
545 NULL,
546 NULL,
547 0,
548 0); /* XXX check? */
549 if (snaps_dname == NULL) {
550 ret = -ENOMEM;
551 goto err_out;
552 }
553
554 /* stat first to trigger error fallback in ceph_snap_gmt_convert() */
555 ret = SMB_VFS_NEXT_STAT(handle, snaps_dname);
556 if (ret < 0) {
557 ret = -errno;
558 goto err_out;
559 }
560
561 DBG_DEBUG("enumerating shadow copy dir at %s\n",
562 snaps_dname->base_name);
563
564 status = OpenDir(tmp_ctx,
565 handle->conn,
566 snaps_dname,
567 NULL,
568 0,
569 &dir_hnd);
570 if (!NT_STATUS_IS_OK(status)) {
571 ret = -map_errno_from_nt_status(status);
572 goto err_out;
573 }
574
575 /* Check we have SEC_DIR_LIST access on this fsp. */
576 dirfsp = dir_hnd_fetch_fsp(dir_hnd);
577 status = smbd_check_access_rights_fsp(dirfsp->conn->cwd_fsp,
578 dirfsp,
579 false,
580 SEC_DIR_LIST);
581 if (!NT_STATUS_IS_OK(status)) {
582 DBG_ERR("user does not have list permission "
583 "on snapdir %s\n",
584 fsp_str_dbg(dirfsp));
585 ret = -map_errno_from_nt_status(status);
586 goto err_out;
587 }
588
589 while ((dname = ReadDirName(dir_hnd, &talloced)) != NULL) {
590 struct smb_filename *smb_fname = NULL;
591 struct smb_filename *atname = NULL;
592 time_t snap_secs = 0;
593
594 if (ISDOT(dname) || ISDOTDOT(dname)) {
595 TALLOC_FREE(talloced);
596 continue;
597 }
598
599 ret = snprintf(_converted_buf, buflen, "%s/%s",
600 snaps_dname->base_name, dname);
601 if (ret >= buflen) {
602 ret = -EINVAL;
603 goto err_out;
604 }
605
606 smb_fname = synthetic_smb_fname(tmp_ctx,
607 _converted_buf,
608 NULL,
609 NULL,
610 0,
611 0);
612 if (smb_fname == NULL) {
613 ret = -ENOMEM;
614 goto err_out;
615 }
616
617 ret = vfs_stat(handle->conn, smb_fname);
618 if (ret < 0) {
619 ret = -errno;
620 TALLOC_FREE(smb_fname);
621 goto err_out;
622 }
623
624 atname = synthetic_smb_fname(tmp_ctx,
625 dname,
626 NULL,
627 &smb_fname->st,
628 0,
629 0);
630 if (atname == NULL) {
631 TALLOC_FREE(smb_fname);
632 ret = -ENOMEM;
633 goto err_out;
634 }
635
636 status = openat_pathref_fsp(dirfsp, atname);
637 if (!NT_STATUS_IS_OK(status)) {
638 TALLOC_FREE(smb_fname);
639 TALLOC_FREE(atname);
640 ret = -map_errno_from_nt_status(status);
641 goto err_out;
642 }
643
644 ret = ceph_snap_get_btime_fsp(handle, atname->fsp, &snap_secs);
645 if (ret < 0) {
646 TALLOC_FREE(smb_fname);
647 TALLOC_FREE(atname);
648 goto err_out;
649 }
650
651 TALLOC_FREE(smb_fname);
652 TALLOC_FREE(atname);
653
654 /*
655 * check gmt_snap_time matches @timestamp
656 */
657 if (timestamp == snap_secs) {
658 break;
659 }
660 DBG_DEBUG("[connectpath %s] %s@%lld no match for snap %s@%lld\n",
661 handle->conn->connectpath, name, (long long)timestamp,
662 dname, (long long)snap_secs);
663 TALLOC_FREE(talloced);
664 }
665
666 if (dname == NULL) {
667 DBG_INFO("[connectpath %s] failed to find %s @ time %lld\n",
668 handle->conn->connectpath, name, (long long)timestamp);
669 ret = -ENOENT;
670 goto err_out;
671 }
672
673 /* found, _converted_buf already contains path of interest */
674 DBG_DEBUG("[connectpath %s] converted %s @ time %lld to %s\n",
675 handle->conn->connectpath, name, (long long)timestamp,
676 _converted_buf);
677
678 TALLOC_FREE(talloced);
679 talloc_free(tmp_ctx);
680 return 0;
681
682 err_out:
683 TALLOC_FREE(talloced);
684 talloc_free(tmp_ctx);
685 return ret;
686 }
687
688 static int ceph_snap_gmt_convert(struct vfs_handle_struct *handle,
689 const char *name,
690 time_t timestamp,
691 char *_converted_buf,
692 size_t buflen)
693 {
694 int ret;
695 char parent[PATH_MAX + 1];
696 const char *trimmed = NULL;
697 /*
698 * CephFS Snapshots for a given dir are nested under the ./.snap subdir
699 * *or* under ../.snap/dir (and subsequent parent dirs).
700 * Child dirs inherit snapshots created in parent dirs if the child
701 * exists at the time of snapshot creation.
702 *
703 * At this point we don't know whether @name refers to a file or dir, so
704 * first assume it's a dir (with a corresponding .snaps subdir)
705 */
706 ret = ceph_snap_gmt_convert_dir(handle,
707 name,
708 timestamp,
709 _converted_buf,
710 buflen);
711 if (ret >= 0) {
712 /* all done: .snap subdir exists - @name is a dir */
713 DBG_DEBUG("%s is a dir, accessing snaps via .snap\n", name);
714 return ret;
715 }
716
717 /* @name/.snap access failed, attempt snapshot access via parent */
718 DBG_DEBUG("%s/.snap access failed, attempting parent access\n",
719 name);
720
721 ret = ceph_snap_get_parent_path(handle->conn->connectpath,
722 name,
723 parent,
724 sizeof(parent),
725 &trimmed);
726 if (ret < 0) {
727 return ret;
728 }
729
730 ret = ceph_snap_gmt_convert_dir(handle,
731 parent,
732 timestamp,
733 _converted_buf,
734 buflen);
735 if (ret < 0) {
736 return ret;
737 }
738
739 /*
740 * found snapshot via parent. Append the child path component
741 * that was trimmed... +1 for path separator + 1 for null termination.
742 */
743 if (strlen(_converted_buf) + 1 + strlen(trimmed) + 1 > buflen) {
744 return -EINVAL;
745 }
746 strlcat(_converted_buf, "/", buflen);
747 strlcat(_converted_buf, trimmed, buflen);
748
749 return 0;
750 }
751
752 static int ceph_snap_gmt_renameat(vfs_handle_struct *handle,
753 files_struct *srcfsp,
754 const struct smb_filename *smb_fname_src,
755 files_struct *dstfsp,
756 const struct smb_filename *smb_fname_dst)
757 {
758 int ret;
759 time_t timestamp_src, timestamp_dst;
760
761 ret = ceph_snap_gmt_strip_snapshot(handle,
762 smb_fname_src,
763 &timestamp_src, NULL, 0);
764 if (ret < 0) {
765 errno = -ret;
766 return -1;
767 }
768 ret = ceph_snap_gmt_strip_snapshot(handle,
769 smb_fname_dst,
770 &timestamp_dst, NULL, 0);
771 if (ret < 0) {
772 errno = -ret;
773 return -1;
774 }
775 if (timestamp_src != 0) {
776 errno = EXDEV;
777 return -1;
778 }
779 if (timestamp_dst != 0) {
780 errno = EROFS;
781 return -1;
782 }
783 return SMB_VFS_NEXT_RENAMEAT(handle,
784 srcfsp,
785 smb_fname_src,
786 dstfsp,
787 smb_fname_dst);
788 }
789
790 /* block links from writeable shares to snapshots for now, like other modules */
791 static int ceph_snap_gmt_symlinkat(vfs_handle_struct *handle,
792 const struct smb_filename *link_contents,
793 struct files_struct *dirfsp,
794 const struct smb_filename *new_smb_fname)
795 {
796 int ret;
797 time_t timestamp_old = 0;
798 time_t timestamp_new = 0;
799
800 ret = ceph_snap_gmt_strip_snapshot(handle,
801 link_contents,
802 &timestamp_old,
803 NULL, 0);
804 if (ret < 0) {
805 errno = -ret;
806 return -1;
807 }
808 ret = ceph_snap_gmt_strip_snapshot(handle,
809 new_smb_fname,
810 &timestamp_new,
811 NULL, 0);
812 if (ret < 0) {
813 errno = -ret;
814 return -1;
815 }
816 if ((timestamp_old != 0) || (timestamp_new != 0)) {
817 errno = EROFS;
818 return -1;
819 }
820 return SMB_VFS_NEXT_SYMLINKAT(handle,
821 link_contents,
822 dirfsp,
823 new_smb_fname);
824 }
825
826 static int ceph_snap_gmt_linkat(vfs_handle_struct *handle,
827 files_struct *srcfsp,
828 const struct smb_filename *old_smb_fname,
829 files_struct *dstfsp,
830 const struct smb_filename *new_smb_fname,
831 int flags)
832 {
833 int ret;
834 time_t timestamp_old = 0;
835 time_t timestamp_new = 0;
836
837 ret = ceph_snap_gmt_strip_snapshot(handle,
838 old_smb_fname,
839 &timestamp_old,
840 NULL, 0);
841 if (ret < 0) {
842 errno = -ret;
843 return -1;
844 }
845 ret = ceph_snap_gmt_strip_snapshot(handle,
846 new_smb_fname,
847 &timestamp_new,
848 NULL, 0);
849 if (ret < 0) {
850 errno = -ret;
851 return -1;
852 }
853 if ((timestamp_old != 0) || (timestamp_new != 0)) {
854 errno = EROFS;
855 return -1;
856 }
857 return SMB_VFS_NEXT_LINKAT(handle,
858 srcfsp,
859 old_smb_fname,
860 dstfsp,
861 new_smb_fname,
862 flags);
863 }
864
865 static int ceph_snap_gmt_stat(vfs_handle_struct *handle,
866 struct smb_filename *smb_fname)
867 {
868 time_t timestamp = 0;
869 char stripped[PATH_MAX + 1];
870 char conv[PATH_MAX + 1];
871 char *tmp;
872 int ret;
873
874 ret = ceph_snap_gmt_strip_snapshot(handle,
875 smb_fname,
876 &timestamp, stripped, sizeof(stripped));
877 if (ret < 0) {
878 errno = -ret;
879 return -1;
880 }
881 if (timestamp == 0) {
882 return SMB_VFS_NEXT_STAT(handle, smb_fname);
883 }
884
885 ret = ceph_snap_gmt_convert(handle, stripped,
886 timestamp, conv, sizeof(conv));
887 if (ret < 0) {
888 errno = -ret;
889 return -1;
890 }
891 tmp = smb_fname->base_name;
892 smb_fname->base_name = conv;
893
894 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
895 smb_fname->base_name = tmp;
896 return ret;
897 }
898
899 static int ceph_snap_gmt_lstat(vfs_handle_struct *handle,
900 struct smb_filename *smb_fname)
901 {
902 time_t timestamp = 0;
903 char stripped[PATH_MAX + 1];
904 char conv[PATH_MAX + 1];
905 char *tmp;
906 int ret;
907
908 ret = ceph_snap_gmt_strip_snapshot(handle,
909 smb_fname,
910 &timestamp, stripped, sizeof(stripped));
911 if (ret < 0) {
912 errno = -ret;
913 return -1;
914 }
915 if (timestamp == 0) {
916 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
917 }
918
919 ret = ceph_snap_gmt_convert(handle, stripped,
920 timestamp, conv, sizeof(conv));
921 if (ret < 0) {
922 errno = -ret;
923 return -1;
924 }
925 tmp = smb_fname->base_name;
926 smb_fname->base_name = conv;
927
928 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
929 smb_fname->base_name = tmp;
930 return ret;
931 }
932
933 static int ceph_snap_gmt_openat(vfs_handle_struct *handle,
934 const struct files_struct *dirfsp,
935 const struct smb_filename *smb_fname_in,
936 files_struct *fsp,
937 const struct vfs_open_how *how)
938 {
939 time_t timestamp = 0;
940 struct smb_filename *smb_fname = NULL;
941 char stripped[PATH_MAX + 1];
942 char conv[PATH_MAX + 1];
943 int ret;
944 int saved_errno = 0;
945
946 ret = ceph_snap_gmt_strip_snapshot(handle,
947 smb_fname_in,
948 &timestamp,
949 stripped,
950 sizeof(stripped));
951 if (ret < 0) {
952 errno = -ret;
953 return -1;
954 }
955 if (timestamp == 0) {
956 return SMB_VFS_NEXT_OPENAT(handle,
957 dirfsp,
958 smb_fname_in,
959 fsp,
960 how);
961 }
962
963 ret = ceph_snap_gmt_convert(handle,
964 stripped,
965 timestamp,
966 conv,
967 sizeof(conv));
968 if (ret < 0) {
969 errno = -ret;
970 return -1;
971 }
972 smb_fname = cp_smb_filename(talloc_tos(), smb_fname_in);
973 if (smb_fname == NULL) {
974 return -1;
975 }
976 smb_fname->base_name = conv;
977
978 ret = SMB_VFS_NEXT_OPENAT(handle,
979 dirfsp,
980 smb_fname,
981 fsp,
982 how);
983 if (ret == -1) {
984 saved_errno = errno;
985 }
986 TALLOC_FREE(smb_fname);
987 if (saved_errno != 0) {
988 errno = saved_errno;
989 }
990 return ret;
991 }
992
993 static int ceph_snap_gmt_unlinkat(vfs_handle_struct *handle,
994 struct files_struct *dirfsp,
995 const struct smb_filename *csmb_fname,
996 int flags)
997 {
998 time_t timestamp = 0;
999 int ret;
1000
1001 ret = ceph_snap_gmt_strip_snapshot(handle,
1002 csmb_fname,
1003 &timestamp, NULL, 0);
1004 if (ret < 0) {
1005 errno = -ret;
1006 return -1;
1007 }
1008 if (timestamp != 0) {
1009 errno = EROFS;
1010 return -1;
1011 }
1012 return SMB_VFS_NEXT_UNLINKAT(handle,
1013 dirfsp,
1014 csmb_fname,
1015 flags);
1016 }
1017
1018 static int ceph_snap_gmt_fchmod(vfs_handle_struct *handle,
1019 struct files_struct *fsp,
1020 mode_t mode)
1021 {
1022 const struct smb_filename *csmb_fname = NULL;
1023 time_t timestamp = 0;
1024 int ret;
1025
1026 csmb_fname = fsp->fsp_name;
1027 ret = ceph_snap_gmt_strip_snapshot(handle,
1028 csmb_fname,
1029 &timestamp, NULL, 0);
1030 if (ret < 0) {
1031 errno = -ret;
1032 return -1;
1033 }
1034 if (timestamp != 0) {
1035 errno = EROFS;
1036 return -1;
1037 }
1038 return SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
1039 }
1040
1041 static int ceph_snap_gmt_chdir(vfs_handle_struct *handle,
1042 const struct smb_filename *csmb_fname)
1043 {
1044 time_t timestamp = 0;
1045 char stripped[PATH_MAX + 1];
1046 char conv[PATH_MAX + 1];
1047 int ret;
1048 struct smb_filename *new_fname;
1049 int saved_errno;
1050
1051 ret = ceph_snap_gmt_strip_snapshot(handle,
1052 csmb_fname,
1053 &timestamp, stripped, sizeof(stripped));
1054 if (ret < 0) {
1055 errno = -ret;
1056 return -1;
1057 }
1058 if (timestamp == 0) {
1059 return SMB_VFS_NEXT_CHDIR(handle, csmb_fname);
1060 }
1061
1062 ret = ceph_snap_gmt_convert_dir(handle, stripped,
1063 timestamp, conv, sizeof(conv));
1064 if (ret < 0) {
1065 errno = -ret;
1066 return -1;
1067 }
1068 new_fname = cp_smb_filename(talloc_tos(), csmb_fname);
1069 if (new_fname == NULL) {
1070 errno = ENOMEM;
1071 return -1;
1072 }
1073 new_fname->base_name = conv;
1074
1075 ret = SMB_VFS_NEXT_CHDIR(handle, new_fname);
1076 saved_errno = errno;
1077 TALLOC_FREE(new_fname);
1078 errno = saved_errno;
1079 return ret;
1080 }
1081
1082 static int ceph_snap_gmt_fntimes(vfs_handle_struct *handle,
1083 files_struct *fsp,
1084 struct smb_file_time *ft)
1085 {
1086 time_t timestamp = 0;
1087 int ret;
1088
1089 ret = ceph_snap_gmt_strip_snapshot(handle,
1090 fsp->fsp_name,
1091 &timestamp,
1092 NULL,
1093 0);
1094 if (ret < 0) {
1095 errno = -ret;
1096 return -1;
1097 }
1098 if (timestamp != 0) {
1099 errno = EROFS;
1100 return -1;
1101 }
1102 return SMB_VFS_NEXT_FNTIMES(handle, fsp, ft);
1103 }
1104
1105 static int ceph_snap_gmt_readlinkat(vfs_handle_struct *handle,
1106 const struct files_struct *dirfsp,
1107 const struct smb_filename *csmb_fname,
1108 char *buf,
1109 size_t bufsiz)
1110 {
1111 time_t timestamp = 0;
1112 char conv[PATH_MAX + 1];
1113 int ret;
1114 struct smb_filename *full_fname = NULL;
1115 int saved_errno;
1116
1117 /*
1118 * Now this function only looks at csmb_fname->twrp
1119 * we don't need to copy out the path. Just use
1120 * csmb_fname->base_name directly.
1121 */
1122 ret = ceph_snap_gmt_strip_snapshot(handle,
1123 csmb_fname,
1124 &timestamp, NULL, 0);
1125 if (ret < 0) {
1126 errno = -ret;
1127 return -1;
1128 }
1129 if (timestamp == 0) {
1130 return SMB_VFS_NEXT_READLINKAT(handle,
1131 dirfsp,
1132 csmb_fname,
1133 buf,
1134 bufsiz);
1135 }
1136
1137 full_fname = full_path_from_dirfsp_atname(talloc_tos(),
1138 dirfsp,
1139 csmb_fname);
1140 if (full_fname == NULL) {
1141 return -1;
1142 }
1143
1144 /* Find the snapshot path from the full pathname. */
1145 ret = ceph_snap_gmt_convert(handle,
1146 full_fname->base_name,
1147 timestamp,
1148 conv,
1149 sizeof(conv));
1150 if (ret < 0) {
1151 TALLOC_FREE(full_fname);
1152 errno = -ret;
1153 return -1;
1154 }
1155 full_fname->base_name = conv;
1156
1157 ret = SMB_VFS_NEXT_READLINKAT(handle,
1158 handle->conn->cwd_fsp,
1159 full_fname,
1160 buf,
1161 bufsiz);
1162 saved_errno = errno;
1163 TALLOC_FREE(full_fname);
1164 errno = saved_errno;
1165 return ret;
1166 }
1167
1168 static int ceph_snap_gmt_mknodat(vfs_handle_struct *handle,
1169 files_struct *dirfsp,
1170 const struct smb_filename *csmb_fname,
1171 mode_t mode,
1172 SMB_DEV_T dev)
1173 {
1174 time_t timestamp = 0;
1175 int ret;
1176
1177 ret = ceph_snap_gmt_strip_snapshot(handle,
1178 csmb_fname,
1179 &timestamp, NULL, 0);
1180 if (ret < 0) {
1181 errno = -ret;
1182 return -1;
1183 }
1184 if (timestamp != 0) {
1185 errno = EROFS;
1186 return -1;
1187 }
1188 return SMB_VFS_NEXT_MKNODAT(handle,
1189 dirfsp,
1190 csmb_fname,
1191 mode,
1192 dev);
1193 }
1194
1195 static struct smb_filename *ceph_snap_gmt_realpath(vfs_handle_struct *handle,
1196 TALLOC_CTX *ctx,
1197 const struct smb_filename *csmb_fname)
1198 {
1199 time_t timestamp = 0;
1200 char stripped[PATH_MAX + 1];
1201 char conv[PATH_MAX + 1];
1202 struct smb_filename *result_fname;
1203 int ret;
1204 struct smb_filename *new_fname;
1205 int saved_errno;
1206
1207 ret = ceph_snap_gmt_strip_snapshot(handle,
1208 csmb_fname,
1209 &timestamp, stripped, sizeof(stripped));
1210 if (ret < 0) {
1211 errno = -ret;
1212 return NULL;
1213 }
1214 if (timestamp == 0) {
1215 return SMB_VFS_NEXT_REALPATH(handle, ctx, csmb_fname);
1216 }
1217 ret = ceph_snap_gmt_convert(handle, stripped,
1218 timestamp, conv, sizeof(conv));
1219 if (ret < 0) {
1220 errno = -ret;
1221 return NULL;
1222 }
1223 new_fname = cp_smb_filename(talloc_tos(), csmb_fname);
1224 if (new_fname == NULL) {
1225 errno = ENOMEM;
1226 return NULL;
1227 }
1228 new_fname->base_name = conv;
1229
1230 result_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, new_fname);
1231 saved_errno = errno;
1232 TALLOC_FREE(new_fname);
1233 errno = saved_errno;
1234 return result_fname;
1235 }
1236
1237 static int ceph_snap_gmt_mkdirat(vfs_handle_struct *handle,
1238 struct files_struct *dirfsp,
1239 const struct smb_filename *csmb_fname,
1240 mode_t mode)
1241 {
1242 time_t timestamp = 0;
1243 int ret;
1244
1245 ret = ceph_snap_gmt_strip_snapshot(handle,
1246 csmb_fname,
1247 &timestamp, NULL, 0);
1248 if (ret < 0) {
1249 errno = -ret;
1250 return -1;
1251 }
1252 if (timestamp != 0) {
1253 errno = EROFS;
1254 return -1;
1255 }
1256 return SMB_VFS_NEXT_MKDIRAT(handle,
1257 dirfsp,
1258 csmb_fname,
1259 mode);
1260 }
1261
1262 static int ceph_snap_gmt_fchflags(vfs_handle_struct *handle,
1263 struct files_struct *fsp,
1264 unsigned int flags)
1265 {
1266 time_t timestamp = 0;
1267 int ret;
1268
1269 ret = ceph_snap_gmt_strip_snapshot(handle,
1270 fsp->fsp_name,
1271 &timestamp, NULL, 0);
1272 if (ret < 0) {
1273 errno = -ret;
1274 return -1;
1275 }
1276 if (timestamp != 0) {
1277 errno = EROFS;
1278 return -1;
1279 }
1280 return SMB_VFS_NEXT_FCHFLAGS(handle, fsp, flags);
1281 }
1282
1283 static int ceph_snap_gmt_fsetxattr(struct vfs_handle_struct *handle,
1284 struct files_struct *fsp,
1285 const char *aname, const void *value,
1286 size_t size, int flags)
1287 {
1288 const struct smb_filename *csmb_fname = NULL;
1289 time_t timestamp = 0;
1290 int ret;
1291
1292 csmb_fname = fsp->fsp_name;
1293 ret = ceph_snap_gmt_strip_snapshot(handle,
1294 csmb_fname,
1295 &timestamp, NULL, 0);
1296 if (ret < 0) {
1297 errno = -ret;
1298 return -1;
1299 }
1300 if (timestamp != 0) {
1301 errno = EROFS;
1302 return -1;
1303 }
1304 return SMB_VFS_NEXT_FSETXATTR(handle, fsp,
1305 aname, value, size, flags);
1306 }
1307
1308 static NTSTATUS ceph_snap_gmt_get_real_filename_at(
1309 struct vfs_handle_struct *handle,
1310 struct files_struct *dirfsp,
1311 const char *name,
1312 TALLOC_CTX *mem_ctx,
1313 char **found_name)
1314 {
1315 time_t timestamp = 0;
1316 char stripped[PATH_MAX + 1];
1317 char conv[PATH_MAX + 1];
1318 struct smb_filename *conv_fname = NULL;
1319 int ret;
1320 NTSTATUS status;
1321
1322 ret = ceph_snap_gmt_strip_snapshot(
1323 handle,
1324 dirfsp->fsp_name,
1325 &timestamp,
1326 stripped,
1327 sizeof(stripped));
1328 if (ret < 0) {
1329 return map_nt_error_from_unix(-ret);
1330 }
1331 if (timestamp == 0) {
1332 return SMB_VFS_NEXT_GET_REAL_FILENAME_AT(
1333 handle, dirfsp, name, mem_ctx, found_name);
1334 }
1335 ret = ceph_snap_gmt_convert_dir(handle, stripped,
1336 timestamp, conv, sizeof(conv));
1337 if (ret < 0) {
1338 return map_nt_error_from_unix(-ret);
1339 }
1340
1341 status = synthetic_pathref(
1342 talloc_tos(),
1343 dirfsp->conn->cwd_fsp,
1344 conv,
1345 NULL,
1346 NULL,
1347 0,
1348 0,
1349 &conv_fname);
1350 if (!NT_STATUS_IS_OK(status)) {
1351 return status;
1352 }
1353
1354 status = SMB_VFS_NEXT_GET_REAL_FILENAME_AT(
1355 handle, conv_fname->fsp, name, mem_ctx, found_name);
1356 TALLOC_FREE(conv_fname);
1357 return status;
1358 }
1359
1360 static uint64_t ceph_snap_gmt_disk_free(vfs_handle_struct *handle,
1361 const struct smb_filename *csmb_fname,
1362 uint64_t *bsize,
1363 uint64_t *dfree,
1364 uint64_t *dsize)
1365 {
1366 time_t timestamp = 0;
1367 char stripped[PATH_MAX + 1];
1368 char conv[PATH_MAX + 1];
1369 int ret;
1370 struct smb_filename *new_fname;
1371 int saved_errno;
1372
1373 ret = ceph_snap_gmt_strip_snapshot(handle,
1374 csmb_fname,
1375 &timestamp, stripped, sizeof(stripped));
1376 if (ret < 0) {
1377 errno = -ret;
1378 return -1;
1379 }
1380 if (timestamp == 0) {
1381 return SMB_VFS_NEXT_DISK_FREE(handle, csmb_fname,
1382 bsize, dfree, dsize);
1383 }
1384 ret = ceph_snap_gmt_convert(handle, stripped,
1385 timestamp, conv, sizeof(conv));
1386 if (ret < 0) {
1387 errno = -ret;
1388 return -1;
1389 }
1390 new_fname = cp_smb_filename(talloc_tos(), csmb_fname);
1391 if (new_fname == NULL) {
1392 errno = ENOMEM;
1393 return -1;
1394 }
1395 new_fname->base_name = conv;
1396
1397 ret = SMB_VFS_NEXT_DISK_FREE(handle, new_fname,
1398 bsize, dfree, dsize);
1399 saved_errno = errno;
1400 TALLOC_FREE(new_fname);
1401 errno = saved_errno;
1402 return ret;
1403 }
1404
1405 static int ceph_snap_gmt_get_quota(vfs_handle_struct *handle,
1406 const struct smb_filename *csmb_fname,
1407 enum SMB_QUOTA_TYPE qtype,
1408 unid_t id,
1409 SMB_DISK_QUOTA *dq)
1410 {
1411 time_t timestamp = 0;
1412 char stripped[PATH_MAX + 1];
1413 char conv[PATH_MAX + 1];
1414 int ret;
1415 struct smb_filename *new_fname;
1416 int saved_errno;
1417
1418 ret = ceph_snap_gmt_strip_snapshot(handle,
1419 csmb_fname,
1420 &timestamp, stripped, sizeof(stripped));
1421 if (ret < 0) {
1422 errno = -ret;
1423 return -1;
1424 }
1425 if (timestamp == 0) {
1426 return SMB_VFS_NEXT_GET_QUOTA(handle, csmb_fname, qtype, id, dq);
1427 }
1428 ret = ceph_snap_gmt_convert(handle, stripped,
1429 timestamp, conv, sizeof(conv));
1430 if (ret < 0) {
1431 errno = -ret;
1432 return -1;
1433 }
1434 new_fname = cp_smb_filename(talloc_tos(), csmb_fname);
1435 if (new_fname == NULL) {
1436 errno = ENOMEM;
1437 return -1;
1438 }
1439 new_fname->base_name = conv;
1440
1441 ret = SMB_VFS_NEXT_GET_QUOTA(handle, new_fname, qtype, id, dq);
1442 saved_errno = errno;
1443 TALLOC_FREE(new_fname);
1444 errno = saved_errno;
1445 return ret;
1446 }
1447
1448 static struct vfs_fn_pointers ceph_snap_fns = {
1449 .get_shadow_copy_data_fn = ceph_snap_get_shadow_copy_data,
1450 .disk_free_fn = ceph_snap_gmt_disk_free,
1451 .get_quota_fn = ceph_snap_gmt_get_quota,
1452 .renameat_fn = ceph_snap_gmt_renameat,
1453 .linkat_fn = ceph_snap_gmt_linkat,
1454 .symlinkat_fn = ceph_snap_gmt_symlinkat,
1455 .stat_fn = ceph_snap_gmt_stat,
1456 .lstat_fn = ceph_snap_gmt_lstat,
1457 .openat_fn = ceph_snap_gmt_openat,
1458 .unlinkat_fn = ceph_snap_gmt_unlinkat,
1459 .fchmod_fn = ceph_snap_gmt_fchmod,
1460 .chdir_fn = ceph_snap_gmt_chdir,
1461 .fntimes_fn = ceph_snap_gmt_fntimes,
1462 .readlinkat_fn = ceph_snap_gmt_readlinkat,
1463 .mknodat_fn = ceph_snap_gmt_mknodat,
1464 .realpath_fn = ceph_snap_gmt_realpath,
1465 .mkdirat_fn = ceph_snap_gmt_mkdirat,
1466 .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
1467 .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
1468 .fsetxattr_fn = ceph_snap_gmt_fsetxattr,
1469 .fchflags_fn = ceph_snap_gmt_fchflags,
1470 .get_real_filename_at_fn = ceph_snap_gmt_get_real_filename_at,
1471 };
1472
1473 static_decl_vfs;
1474 NTSTATUS vfs_ceph_snapshots_init(TALLOC_CTX *ctx)
1475 {
1476 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
1477 "ceph_snapshots", &ceph_snap_fns);
1478 }
GSS-enabled samba4