2 * Module for snapshot IO using snapper
4 * Copyright (C) David Disseldorp 2012-2014
6 * Portions taken from vfs_shadow_copy2.c:
7 * Copyright (C) Andrew Tridgell 2007
8 * Copyright (C) Ed Plese 2009
9 * Copyright (C) Volker Lendecke 2011
10 * Copyright (C) Christian Ambach 2011
11 * Copyright (C) Michael Adam 2013
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 3 of the License, or
16 * (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, see <http://www.gnu.org/licenses/>.
27 #include <dbus/dbus.h>
28 #ifdef HAVE_LINUX_IOCTL_H
29 #include <linux/ioctl.h>
31 #include <sys/ioctl.h>
35 #include "include/ntioctl.h"
36 #include "include/smb.h"
37 #include "system/filesys.h"
38 #include "smbd/smbd.h"
39 #include "lib/util/tevent_ntstatus.h"
41 #define SNAPPER_SIG_LIST_SNAPS_RSP "a(uquxussa{ss})"
42 #define SNAPPER_SIG_LIST_CONFS_RSP "a(ssa{ss})"
43 #define SNAPPER_SIG_CREATE_SNAP_RSP "u"
44 #define SNAPPER_SIG_DEL_SNAPS_RSP ""
45 #define SNAPPER_SIG_STRING_DICT "{ss}"
60 uint32_t num_user_data;
61 struct snapper_dict *user_data;
68 struct snapper_dict *attrs;
72 const char *snapper_err_str;
74 } snapper_err_map[] = {
75 { "error.no_permissions", NT_STATUS_ACCESS_DENIED },
78 static NTSTATUS snapper_err_ntstatus_map(const char *snapper_err_str)
82 if (snapper_err_str == NULL) {
83 return NT_STATUS_UNSUCCESSFUL;
85 for (i = 0; i < ARRAY_SIZE(snapper_err_map); i++) {
86 if (!strcmp(snapper_err_map[i].snapper_err_str,
88 return snapper_err_map[i].status;
91 DEBUG(2, ("no explicit mapping for dbus error: %s\n", snapper_err_str));
93 return NT_STATUS_UNSUCCESSFUL;
97 * Strings are UTF-8. Other characters must be encoded hexadecimal as "\x??".
98 * As a consequence "\" must be encoded as "\\".
100 static NTSTATUS snapper_dbus_str_encode(TALLOC_CTX *mem_ctx, const char *in_str,
109 if (in_str == NULL) {
110 return NT_STATUS_INVALID_PARAMETER;
113 in_len = strlen(in_str);
115 /* output can be max 4 times the length of @in_str, +1 for terminator */
116 out_len = (in_len * 4) + 1;
118 out_str = talloc_array(mem_ctx, char, out_len);
119 if (out_str == NULL) {
120 return NT_STATUS_NO_MEMORY;
124 for (i = 0; i < in_len; i++) {
127 if (in_str[i] == '\\') {
128 pushed = snprintf(out_str + out_off, out_len - out_off,
130 } else if ((unsigned char)in_str[i] > 127) {
131 pushed = snprintf(out_str + out_off, out_len - out_off,
132 "\\x%02x", (unsigned char)in_str[i]);
134 /* regular character */
135 *(out_str + out_off) = in_str[i];
136 pushed = sizeof(char);
138 if (pushed >= out_len - out_off) {
139 /* truncated, should never happen */
140 talloc_free(out_str);
141 return NT_STATUS_INTERNAL_ERROR;
146 *(out_str + out_off) = '\0';
152 static NTSTATUS snapper_dbus_str_decode(TALLOC_CTX *mem_ctx, const char *in_str,
161 if (in_str == NULL) {
162 return NT_STATUS_INVALID_PARAMETER;
165 in_len = strlen(in_str);
167 /* output cannot be larger than input, +1 for terminator */
168 out_len = in_len + 1;
170 out_str = talloc_array(mem_ctx, char, out_len);
171 if (out_str == NULL) {
172 return NT_STATUS_NO_MEMORY;
176 for (i = 0; i < in_len; i++) {
179 unsigned int non_ascii_byte;
181 if (in_str[i] != '\\') {
182 out_str[out_off] = in_str[i];
188 if (in_str[i] == '\\') {
189 out_str[out_off] = '\\';
192 } else if (in_str[i] != 'x') {
193 goto err_invalid_src_encoding;
196 /* non-ASCII, encoded as two hex chars */
197 for (j = 0; j < 2; j++) {
199 if ((in_str[i] == '\0') || !isxdigit(in_str[i])) {
200 goto err_invalid_src_encoding;
202 hex_buf[j] = in_str[i];
206 sscanf(hex_buf, "%x", &non_ascii_byte);
207 out_str[out_off] = (unsigned char)non_ascii_byte;
211 out_str[out_off] = '\0';
215 err_invalid_src_encoding:
216 DEBUG(0, ("invalid encoding %s\n", in_str));
217 return NT_STATUS_INVALID_PARAMETER;
220 static DBusConnection *snapper_dbus_conn_create(void)
223 DBusConnection *dconn;
225 dbus_error_init(&err);
228 * Always create a new DBus connection, to ensure snapperd detects the
229 * correct client [E]UID. With dbus_bus_get() it does not!
231 dconn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
232 if (dbus_error_is_set(&err)) {
233 DEBUG(0, ("dbus connection error: %s\n", err.message));
234 dbus_error_free(&err);
240 /* dbus_bus_get_private() sets exit-on-disconnect by default, undo it */
241 dbus_connection_set_exit_on_disconnect(dconn, false);
246 static void snapper_dbus_conn_destroy(DBusConnection *dconn)
249 DEBUG(2, ("attempt to destroy NULL dbus connection\n"));
253 dbus_connection_close(dconn);
254 dbus_connection_unref(dconn);
258 * send the message @send_msg over the dbus and wait for a response, return the
259 * responsee via @recv_msg_out.
260 * @send_msg is not freed, dbus_message_unref() must be handled by the caller.
262 static NTSTATUS snapper_dbus_msg_xchng(DBusConnection *dconn,
263 DBusMessage *send_msg,
264 DBusMessage **recv_msg_out)
266 DBusPendingCall *pending;
267 DBusMessage *recv_msg;
269 /* send message and get a handle for a reply */
270 if (!dbus_connection_send_with_reply(dconn, send_msg, &pending, -1)) {
271 return NT_STATUS_NO_MEMORY;
273 if (NULL == pending) {
274 DEBUG(0, ("dbus msg send failed\n"));
275 return NT_STATUS_UNSUCCESSFUL;
278 dbus_connection_flush(dconn);
280 /* block until we receive a reply */
281 dbus_pending_call_block(pending);
283 /* get the reply message */
284 recv_msg = dbus_pending_call_steal_reply(pending);
285 if (recv_msg == NULL) {
286 DEBUG(0, ("Reply Null\n"));
287 return NT_STATUS_UNSUCCESSFUL;
289 /* free the pending message handle */
290 dbus_pending_call_unref(pending);
291 *recv_msg_out = recv_msg;
296 static NTSTATUS snapper_type_check(DBusMessageIter *iter,
299 int type = dbus_message_iter_get_arg_type(iter);
300 if (type != expected_type) {
301 DEBUG(0, ("got type %d, expecting %d\n",
302 type, expected_type));
303 return NT_STATUS_INVALID_PARAMETER;
309 static NTSTATUS snapper_type_check_get(DBusMessageIter *iter,
314 status = snapper_type_check(iter, expected_type);
315 if (!NT_STATUS_IS_OK(status)) {
319 dbus_message_iter_get_basic(iter, val);
324 static NTSTATUS snapper_dict_unpack(TALLOC_CTX *mem_ctx,
325 DBusMessageIter *iter,
326 struct snapper_dict *dict_out)
330 DBusMessageIter dct_iter;
334 status = snapper_type_check(iter, DBUS_TYPE_DICT_ENTRY);
335 if (!NT_STATUS_IS_OK(status)) {
338 dbus_message_iter_recurse(iter, &dct_iter);
340 status = snapper_type_check_get(&dct_iter, DBUS_TYPE_STRING,
342 if (!NT_STATUS_IS_OK(status)) {
345 status = snapper_dbus_str_decode(mem_ctx, key_encoded, &dict_out->key);
346 if (!NT_STATUS_IS_OK(status)) {
350 dbus_message_iter_next(&dct_iter);
351 status = snapper_type_check_get(&dct_iter, DBUS_TYPE_STRING,
353 if (!NT_STATUS_IS_OK(status)) {
354 talloc_free(dict_out->key);
357 status = snapper_dbus_str_decode(mem_ctx, val_encoded, &dict_out->val);
358 if (!NT_STATUS_IS_OK(status)) {
359 talloc_free(dict_out->key);
366 static void snapper_dict_array_print(uint32_t num_dicts,
367 struct snapper_dict *dicts)
371 for (i = 0; i < num_dicts; i++) {
372 DEBUG(10, ("dict (key: %s, val: %s)\n",
373 dicts[i].key, dicts[i].val));
377 static NTSTATUS snapper_dict_array_unpack(TALLOC_CTX *mem_ctx,
378 DBusMessageIter *iter,
379 uint32_t *num_dicts_out,
380 struct snapper_dict **dicts_out)
383 DBusMessageIter array_iter;
385 struct snapper_dict *dicts = NULL;
387 status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
388 if (!NT_STATUS_IS_OK(status)) {
391 dbus_message_iter_recurse(iter, &array_iter);
394 while (dbus_message_iter_get_arg_type(&array_iter)
395 != DBUS_TYPE_INVALID) {
397 dicts = talloc_realloc(mem_ctx, dicts, struct snapper_dict,
402 status = snapper_dict_unpack(mem_ctx, &array_iter,
403 &dicts[num_dicts - 1]);
404 if (!NT_STATUS_IS_OK(status)) {
408 dbus_message_iter_next(&array_iter);
411 *num_dicts_out = num_dicts;
417 static NTSTATUS snapper_list_confs_pack(DBusMessage **req_msg_out)
421 msg = dbus_message_new_method_call("org.opensuse.Snapper",
422 "/org/opensuse/Snapper",
423 "org.opensuse.Snapper",
426 DEBUG(0, ("null msg\n"));
427 return NT_STATUS_NO_MEMORY;
430 /* no arguments to append */
436 static NTSTATUS snapper_conf_unpack(TALLOC_CTX *mem_ctx,
437 DBusMessageIter *iter,
438 struct snapper_conf *conf_out)
441 DBusMessageIter st_iter;
445 status = snapper_type_check(iter, DBUS_TYPE_STRUCT);
446 if (!NT_STATUS_IS_OK(status)) {
449 dbus_message_iter_recurse(iter, &st_iter);
451 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
453 if (!NT_STATUS_IS_OK(status)) {
457 status = snapper_dbus_str_decode(mem_ctx, name_encoded,
459 if (!NT_STATUS_IS_OK(status)) {
463 dbus_message_iter_next(&st_iter);
464 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
466 if (!NT_STATUS_IS_OK(status)) {
467 talloc_free(conf_out->name);
471 status = snapper_dbus_str_decode(mem_ctx, mnt_encoded,
473 if (!NT_STATUS_IS_OK(status)) {
474 talloc_free(conf_out->name);
478 dbus_message_iter_next(&st_iter);
479 status = snapper_dict_array_unpack(mem_ctx, &st_iter,
480 &conf_out->num_attrs,
482 if (!NT_STATUS_IS_OK(status)) {
483 talloc_free(conf_out->mnt);
484 talloc_free(conf_out->name);
491 static struct snapper_conf *snapper_conf_array_base_find(int32_t num_confs,
492 struct snapper_conf *confs,
497 for (i = 0; i < num_confs; i++) {
498 if (strcmp(confs[i].mnt, base) == 0) {
499 DEBUG(5, ("found snapper conf %s for path %s\n",
500 confs[i].name, base));
504 DEBUG(5, ("config for base %s not found\n", base));
509 static void snapper_conf_array_print(int32_t num_confs,
510 struct snapper_conf *confs)
514 for (i = 0; i < num_confs; i++) {
515 DEBUG(10, ("name: %s, mnt: %s\n",
516 confs[i].name, confs[i].mnt));
517 snapper_dict_array_print(confs[i].num_attrs, confs[i].attrs);
521 static NTSTATUS snapper_conf_array_unpack(TALLOC_CTX *mem_ctx,
522 DBusMessageIter *iter,
523 uint32_t *num_confs_out,
524 struct snapper_conf **confs_out)
528 struct snapper_conf *confs = NULL;
529 DBusMessageIter array_iter;
532 status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
533 if (!NT_STATUS_IS_OK(status)) {
536 dbus_message_iter_recurse(iter, &array_iter);
539 while (dbus_message_iter_get_arg_type(&array_iter)
540 != DBUS_TYPE_INVALID) {
542 confs = talloc_realloc(mem_ctx, confs, struct snapper_conf,
547 status = snapper_conf_unpack(confs, &array_iter,
548 &confs[num_confs - 1]);
549 if (!NT_STATUS_IS_OK(status)) {
553 dbus_message_iter_next(&array_iter);
556 *num_confs_out = num_confs;
562 static NTSTATUS snapper_list_confs_unpack(TALLOC_CTX *mem_ctx,
563 DBusConnection *dconn,
564 DBusMessage *rsp_msg,
565 uint32_t *num_confs_out,
566 struct snapper_conf **confs_out)
569 DBusMessageIter iter;
572 struct snapper_conf *confs;
575 msg_type = dbus_message_get_type(rsp_msg);
576 if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
577 const char *err_str = dbus_message_get_error_name(rsp_msg);
578 DEBUG(0, ("list_confs error response: %s\n", err_str));
579 return snapper_err_ntstatus_map(err_str);
582 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
583 DEBUG(0, ("unexpected list_confs ret type: %d\n",
585 return NT_STATUS_INVALID_PARAMETER;
588 sig = dbus_message_get_signature(rsp_msg);
590 || (strcmp(sig, SNAPPER_SIG_LIST_CONFS_RSP) != 0)) {
591 DEBUG(0, ("bad list confs response sig: %s, expected: %s\n",
592 (sig ? sig : "NULL"), SNAPPER_SIG_LIST_CONFS_RSP));
593 return NT_STATUS_INVALID_PARAMETER;
596 if (!dbus_message_iter_init(rsp_msg, &iter)) {
597 /* FIXME return empty? */
598 DEBUG(0, ("Message has no arguments!\n"));
599 return NT_STATUS_INVALID_PARAMETER;
602 status = snapper_conf_array_unpack(mem_ctx, &iter, &num_confs, &confs);
603 if (!NT_STATUS_IS_OK(status)) {
604 DEBUG(0, ("failed to unpack conf array\n"));
608 snapper_conf_array_print(num_confs, confs);
610 *num_confs_out = num_confs;
616 static NTSTATUS snapper_list_snaps_pack(TALLOC_CTX *mem_ctx,
618 DBusMessage **req_msg_out)
621 DBusMessageIter args;
625 msg = dbus_message_new_method_call("org.opensuse.Snapper", /* target for the method call */
626 "/org/opensuse/Snapper", /* object to call on */
627 "org.opensuse.Snapper", /* interface to call on */
628 "ListSnapshots"); /* method name */
630 DEBUG(0, ("failed to create list snaps message\n"));
631 return NT_STATUS_NO_MEMORY;
634 status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
635 if (!NT_STATUS_IS_OK(status)) {
636 dbus_message_unref(msg);
640 /* append arguments */
641 dbus_message_iter_init_append(msg, &args);
642 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
644 talloc_free(conf_encoded);
645 dbus_message_unref(msg);
646 return NT_STATUS_NO_MEMORY;
654 static NTSTATUS snapper_snap_struct_unpack(TALLOC_CTX *mem_ctx,
655 DBusMessageIter *iter,
656 struct snapper_snap *snap_out)
659 DBusMessageIter st_iter;
661 char *cleanup_encoded;
663 status = snapper_type_check(iter, DBUS_TYPE_STRUCT);
664 if (!NT_STATUS_IS_OK(status)) {
667 dbus_message_iter_recurse(iter, &st_iter);
669 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
671 if (!NT_STATUS_IS_OK(status)) {
675 dbus_message_iter_next(&st_iter);
676 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT16,
678 if (!NT_STATUS_IS_OK(status)) {
682 dbus_message_iter_next(&st_iter);
683 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
685 if (!NT_STATUS_IS_OK(status)) {
689 dbus_message_iter_next(&st_iter);
690 status = snapper_type_check_get(&st_iter, DBUS_TYPE_INT64,
692 if (!NT_STATUS_IS_OK(status)) {
696 dbus_message_iter_next(&st_iter);
697 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
698 &snap_out->creator_uid);
699 if (!NT_STATUS_IS_OK(status)) {
703 dbus_message_iter_next(&st_iter);
704 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
706 if (!NT_STATUS_IS_OK(status)) {
710 status = snapper_dbus_str_decode(mem_ctx, desc_encoded,
712 if (!NT_STATUS_IS_OK(status)) {
716 dbus_message_iter_next(&st_iter);
717 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
719 if (!NT_STATUS_IS_OK(status)) {
720 talloc_free(snap_out->desc);
724 status = snapper_dbus_str_decode(mem_ctx, cleanup_encoded,
726 if (!NT_STATUS_IS_OK(status)) {
727 talloc_free(snap_out->desc);
731 dbus_message_iter_next(&st_iter);
732 status = snapper_dict_array_unpack(mem_ctx, &st_iter,
733 &snap_out->num_user_data,
734 &snap_out->user_data);
735 if (!NT_STATUS_IS_OK(status)) {
736 talloc_free(snap_out->cleanup);
737 talloc_free(snap_out->desc);
744 static void snapper_snap_array_print(int32_t num_snaps,
745 struct snapper_snap *snaps)
749 for (i = 0; i < num_snaps; i++) {
750 DEBUG(10, ("id: %u, "
757 (unsigned int)snaps[i].id,
758 (unsigned int)snaps[i].type,
759 (unsigned int)snaps[i].pre_id,
760 (long int)snaps[i].time,
761 (unsigned int)snaps[i].creator_uid,
764 snapper_dict_array_print(snaps[i].num_user_data,
769 static NTSTATUS snapper_snap_array_unpack(TALLOC_CTX *mem_ctx,
770 DBusMessageIter *iter,
771 uint32_t *num_snaps_out,
772 struct snapper_snap **snaps_out)
776 struct snapper_snap *snaps = NULL;
777 DBusMessageIter array_iter;
780 status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
781 if (!NT_STATUS_IS_OK(status)) {
784 dbus_message_iter_recurse(iter, &array_iter);
787 while (dbus_message_iter_get_arg_type(&array_iter)
788 != DBUS_TYPE_INVALID) {
790 snaps = talloc_realloc(mem_ctx, snaps, struct snapper_snap,
795 status = snapper_snap_struct_unpack(snaps, &array_iter,
796 &snaps[num_snaps - 1]);
797 if (!NT_STATUS_IS_OK(status)) {
801 dbus_message_iter_next(&array_iter);
804 *num_snaps_out = num_snaps;
810 static NTSTATUS snapper_list_snaps_unpack(TALLOC_CTX *mem_ctx,
811 DBusMessage *rsp_msg,
812 uint32_t *num_snaps_out,
813 struct snapper_snap **snaps_out)
816 DBusMessageIter iter;
819 struct snapper_snap *snaps;
822 msg_type = dbus_message_get_type(rsp_msg);
823 if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
824 const char *err_str = dbus_message_get_error_name(rsp_msg);
825 DEBUG(0, ("list_snaps error response: %s\n", err_str));
826 return snapper_err_ntstatus_map(err_str);
829 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
830 DEBUG(0,("unexpected list_snaps ret type: %d\n",
832 return NT_STATUS_INVALID_PARAMETER;
835 sig = dbus_message_get_signature(rsp_msg);
837 || (strcmp(sig, SNAPPER_SIG_LIST_SNAPS_RSP) != 0)) {
838 DEBUG(0, ("bad list snaps response sig: %s, "
840 (sig ? sig : "NULL"),
841 SNAPPER_SIG_LIST_SNAPS_RSP));
842 return NT_STATUS_INVALID_PARAMETER;
845 /* read the parameters */
846 if (!dbus_message_iter_init(rsp_msg, &iter)) {
847 DEBUG(0, ("response has no arguments!\n"));
848 return NT_STATUS_INVALID_PARAMETER;
851 status = snapper_snap_array_unpack(mem_ctx, &iter, &num_snaps, &snaps);
852 if (!NT_STATUS_IS_OK(status)) {
853 DEBUG(0, ("failed to unpack snap array\n"));
854 return NT_STATUS_INVALID_PARAMETER;
857 snapper_snap_array_print(num_snaps, snaps);
859 *num_snaps_out = num_snaps;
865 static NTSTATUS snapper_create_snap_pack(TALLOC_CTX *mem_ctx,
866 const char *snapper_conf,
868 uint32_t num_user_data,
869 struct snapper_dict *user_data,
870 DBusMessage **req_msg_out)
873 DBusMessageIter args;
874 DBusMessageIter array_iter;
875 DBusMessageIter struct_iter;
876 const char *empty = "";
883 DEBUG(10, ("CreateSingleSnapshot: %s, %s, %s, num user %u\n",
884 snapper_conf, desc, empty, num_user_data));
886 enc_ctx = talloc_new(mem_ctx);
887 if (enc_ctx == NULL) {
888 return NT_STATUS_NO_MEMORY;
891 msg = dbus_message_new_method_call("org.opensuse.Snapper",
892 "/org/opensuse/Snapper",
893 "org.opensuse.Snapper",
894 "CreateSingleSnapshot");
896 DEBUG(0, ("failed to create req msg\n"));
897 talloc_free(enc_ctx);
898 return NT_STATUS_NO_MEMORY;
901 status = snapper_dbus_str_encode(enc_ctx, snapper_conf, &str_encoded);
902 if (!NT_STATUS_IS_OK(status)) {
903 dbus_message_unref(msg);
904 talloc_free(enc_ctx);
908 /* append arguments */
909 dbus_message_iter_init_append(msg, &args);
910 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
913 dbus_message_unref(msg);
914 talloc_free(enc_ctx);
915 return NT_STATUS_NO_MEMORY;
918 status = snapper_dbus_str_encode(enc_ctx, desc, &str_encoded);
919 if (!NT_STATUS_IS_OK(status)) {
920 dbus_message_unref(msg);
921 talloc_free(enc_ctx);
925 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
928 dbus_message_unref(msg);
929 talloc_free(enc_ctx);
930 return NT_STATUS_NO_MEMORY;
933 /* cleanup - no need to encode empty string */
934 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
937 dbus_message_unref(msg);
938 talloc_free(enc_ctx);
939 return NT_STATUS_NO_MEMORY;
942 ok = dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
943 SNAPPER_SIG_STRING_DICT,
946 dbus_message_unref(msg);
947 talloc_free(enc_ctx);
948 return NT_STATUS_NO_MEMORY;
951 for (i = 0; i < num_user_data; i++) {
952 ok = dbus_message_iter_open_container(&array_iter,
953 DBUS_TYPE_DICT_ENTRY,
956 dbus_message_unref(msg);
957 talloc_free(enc_ctx);
958 return NT_STATUS_NO_MEMORY;
961 status = snapper_dbus_str_encode(enc_ctx, user_data[i].key,
963 if (!NT_STATUS_IS_OK(status)) {
964 dbus_message_unref(msg);
965 talloc_free(enc_ctx);
969 ok = dbus_message_iter_append_basic(&struct_iter,
973 dbus_message_unref(msg);
974 talloc_free(enc_ctx);
975 return NT_STATUS_NO_MEMORY;
978 status = snapper_dbus_str_encode(enc_ctx, user_data[i].val,
980 if (!NT_STATUS_IS_OK(status)) {
981 dbus_message_unref(msg);
982 talloc_free(enc_ctx);
986 ok = dbus_message_iter_append_basic(&struct_iter,
990 dbus_message_unref(msg);
991 talloc_free(enc_ctx);
992 return NT_STATUS_NO_MEMORY;
995 ok = dbus_message_iter_close_container(&array_iter, &struct_iter);
997 dbus_message_unref(msg);
998 talloc_free(enc_ctx);
999 return NT_STATUS_NO_MEMORY;
1003 ok = dbus_message_iter_close_container(&args, &array_iter);
1005 dbus_message_unref(msg);
1006 talloc_free(enc_ctx);
1007 return NT_STATUS_NO_MEMORY;
1012 return NT_STATUS_OK;
1015 static NTSTATUS snapper_create_snap_unpack(DBusConnection *conn,
1016 DBusMessage *rsp_msg,
1017 uint32_t *snap_id_out)
1020 DBusMessageIter iter;
1025 msg_type = dbus_message_get_type(rsp_msg);
1026 if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
1027 const char *err_str = dbus_message_get_error_name(rsp_msg);
1028 DEBUG(0, ("create snap error response: %s, euid %d egid %d\n",
1029 err_str, geteuid(), getegid()));
1030 return snapper_err_ntstatus_map(err_str);
1033 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
1034 DEBUG(0, ("unexpected create snap ret type: %d\n",
1036 return NT_STATUS_INVALID_PARAMETER;
1039 sig = dbus_message_get_signature(rsp_msg);
1041 || (strcmp(sig, SNAPPER_SIG_CREATE_SNAP_RSP) != 0)) {
1042 DEBUG(0, ("bad create snap response sig: %s, expected: %s\n",
1043 (sig ? sig : "NULL"), SNAPPER_SIG_CREATE_SNAP_RSP));
1044 return NT_STATUS_INVALID_PARAMETER;
1047 /* read the parameters */
1048 if (!dbus_message_iter_init(rsp_msg, &iter)) {
1049 DEBUG(0, ("response has no arguments!\n"));
1050 return NT_STATUS_INVALID_PARAMETER;
1053 status = snapper_type_check_get(&iter, DBUS_TYPE_UINT32, &snap_id);
1054 if (!NT_STATUS_IS_OK(status)) {
1057 *snap_id_out = snap_id;
1059 return NT_STATUS_OK;
1062 static NTSTATUS snapper_del_snap_pack(TALLOC_CTX *mem_ctx,
1063 const char *snapper_conf,
1065 DBusMessage **req_msg_out)
1068 DBusMessageIter args;
1069 DBusMessageIter array_iter;
1074 msg = dbus_message_new_method_call("org.opensuse.Snapper",
1075 "/org/opensuse/Snapper",
1076 "org.opensuse.Snapper",
1079 DEBUG(0, ("failed to create req msg\n"));
1080 return NT_STATUS_NO_MEMORY;
1083 status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
1084 if (!NT_STATUS_IS_OK(status)) {
1085 dbus_message_unref(msg);
1089 /* append arguments */
1090 dbus_message_iter_init_append(msg, &args);
1091 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
1094 talloc_free(conf_encoded);
1095 dbus_message_unref(msg);
1096 return NT_STATUS_NO_MEMORY;
1099 ok = dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
1100 DBUS_TYPE_UINT32_AS_STRING,
1103 talloc_free(conf_encoded);
1104 dbus_message_unref(msg);
1105 return NT_STATUS_NO_MEMORY;
1108 ok = dbus_message_iter_append_basic(&array_iter,
1112 talloc_free(conf_encoded);
1113 dbus_message_unref(msg);
1114 return NT_STATUS_NO_MEMORY;
1117 dbus_message_iter_close_container(&args, &array_iter);
1120 return NT_STATUS_OK;
1123 static NTSTATUS snapper_del_snap_unpack(DBusConnection *conn,
1124 DBusMessage *rsp_msg)
1129 msg_type = dbus_message_get_type(rsp_msg);
1130 if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
1131 const char *err_str = dbus_message_get_error_name(rsp_msg);
1132 DEBUG(0, ("del snap error response: %s\n", err_str));
1133 return snapper_err_ntstatus_map(err_str);
1136 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
1137 DEBUG(0, ("unexpected del snap ret type: %d\n",
1139 return NT_STATUS_INVALID_PARAMETER;
1142 sig = dbus_message_get_signature(rsp_msg);
1144 || (strcmp(sig, SNAPPER_SIG_DEL_SNAPS_RSP) != 0)) {
1145 DEBUG(0, ("bad create snap response sig: %s, expected: %s\n",
1146 (sig ? sig : "NULL"), SNAPPER_SIG_DEL_SNAPS_RSP));
1147 return NT_STATUS_INVALID_PARAMETER;
1150 /* no parameters in response */
1152 return NT_STATUS_OK;
1155 static NTSTATUS snapper_list_snaps_at_time_pack(TALLOC_CTX *mem_ctx,
1156 const char *snapper_conf,
1159 DBusMessage **req_msg_out)
1162 DBusMessageIter args;
1166 msg = dbus_message_new_method_call("org.opensuse.Snapper",
1167 "/org/opensuse/Snapper",
1168 "org.opensuse.Snapper",
1169 "ListSnapshotsAtTime");
1171 DEBUG(0, ("failed to create list snaps message\n"));
1172 return NT_STATUS_NO_MEMORY;
1175 status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
1176 if (!NT_STATUS_IS_OK(status)) {
1177 dbus_message_unref(msg);
1181 dbus_message_iter_init_append(msg, &args);
1182 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
1184 talloc_free(conf_encoded);
1185 dbus_message_unref(msg);
1186 return NT_STATUS_NO_MEMORY;
1189 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT64,
1191 talloc_free(conf_encoded);
1192 dbus_message_unref(msg);
1193 return NT_STATUS_NO_MEMORY;
1196 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT64,
1198 talloc_free(conf_encoded);
1199 dbus_message_unref(msg);
1200 return NT_STATUS_NO_MEMORY;
1205 return NT_STATUS_OK;
1207 /* no snapper_list_snaps_at_time_unpack, use snapper_list_snaps_unpack */
1210 * Determine the snapper snapshot id given a path.
1211 * Ideally this should be determined via a lookup.
1213 static NTSTATUS snapper_snap_path_to_id(TALLOC_CTX *mem_ctx,
1214 const char *snap_path,
1215 uint32_t *snap_id_out)
1223 path_dup = talloc_strdup(mem_ctx, snap_path);
1224 if (path_dup == NULL) {
1225 return NT_STATUS_NO_MEMORY;
1228 /* trim trailing '/' */
1229 str_idx = path_dup + strlen(path_dup) - 1;
1230 while (*str_idx == '/') {
1235 str_idx = strrchr(path_dup, '/');
1236 if ((str_idx == NULL)
1237 || (strcmp(str_idx + 1, "snapshot") != 0)) {
1238 talloc_free(path_dup);
1239 return NT_STATUS_INVALID_PARAMETER;
1242 while (*str_idx == '/') {
1247 str_idx = strrchr(path_dup, '/');
1248 if (str_idx == NULL) {
1249 talloc_free(path_dup);
1250 return NT_STATUS_INVALID_PARAMETER;
1254 snap_id = strtoul_err(str_idx, &str_end, 10, &error);
1255 if (error != 0 || str_idx == str_end) {
1256 talloc_free(path_dup);
1257 return NT_STATUS_INVALID_PARAMETER;
1260 talloc_free(path_dup);
1261 *snap_id_out = snap_id;
1262 return NT_STATUS_OK;
1266 * Determine the snapper snapshot path given an id and base.
1267 * Ideally this should be determined via a lookup.
1269 static NTSTATUS snapper_snap_id_to_path(TALLOC_CTX *mem_ctx,
1270 const char *base_path,
1272 char **snap_path_out)
1276 snap_path = talloc_asprintf(mem_ctx, "%s/.snapshots/%u/snapshot",
1277 base_path, snap_id);
1278 if (snap_path == NULL) {
1279 return NT_STATUS_NO_MEMORY;
1282 *snap_path_out = snap_path;
1283 return NT_STATUS_OK;
1286 static NTSTATUS snapper_get_conf_call(TALLOC_CTX *mem_ctx,
1287 DBusConnection *dconn,
1289 char **conf_name_out,
1290 char **base_path_out)
1293 DBusMessage *req_msg;
1294 DBusMessage *rsp_msg;
1295 uint32_t num_confs = 0;
1296 struct snapper_conf *confs = NULL;
1297 struct snapper_conf *conf;
1301 status = snapper_list_confs_pack(&req_msg);
1302 if (!NT_STATUS_IS_OK(status)) {
1306 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1307 if (!NT_STATUS_IS_OK(status)) {
1311 status = snapper_list_confs_unpack(mem_ctx, dconn, rsp_msg,
1312 &num_confs, &confs);
1313 if (!NT_STATUS_IS_OK(status)) {
1318 * for now we only support shares where the path directly corresponds
1319 * to a snapper configuration.
1321 conf = snapper_conf_array_base_find(num_confs, confs,
1324 status = NT_STATUS_NOT_SUPPORTED;
1325 goto err_array_free;
1328 conf_name = talloc_strdup(mem_ctx, conf->name);
1329 if (conf_name == NULL) {
1330 status = NT_STATUS_NO_MEMORY;
1331 goto err_array_free;
1333 base_path = talloc_strdup(mem_ctx, conf->mnt);
1334 if (base_path == NULL) {
1335 status = NT_STATUS_NO_MEMORY;
1336 goto err_conf_name_free;
1340 dbus_message_unref(rsp_msg);
1341 dbus_message_unref(req_msg);
1343 *conf_name_out = conf_name;
1344 *base_path_out = base_path;
1346 return NT_STATUS_OK;
1349 talloc_free(conf_name);
1353 dbus_message_unref(rsp_msg);
1355 dbus_message_unref(req_msg);
1361 * Check whether a path can be shadow copied. Return the base volume, allowing
1362 * the caller to determine if multiple paths lie on the same base volume.
1364 static NTSTATUS snapper_snap_check_path(struct vfs_handle_struct *handle,
1365 TALLOC_CTX *mem_ctx,
1366 const char *service_path,
1370 DBusConnection *dconn;
1374 dconn = snapper_dbus_conn_create();
1375 if (dconn == NULL) {
1376 return NT_STATUS_UNSUCCESSFUL;
1379 status = snapper_get_conf_call(mem_ctx, dconn, service_path,
1380 &conf_name, &base_path);
1381 if (!NT_STATUS_IS_OK(status)) {
1382 goto err_conn_close;
1385 talloc_free(conf_name);
1386 *base_volume = base_path;
1387 snapper_dbus_conn_destroy(dconn);
1389 return NT_STATUS_OK;
1392 snapper_dbus_conn_destroy(dconn);
1396 static NTSTATUS snapper_create_snap_call(TALLOC_CTX *mem_ctx,
1397 DBusConnection *dconn,
1398 const char *conf_name,
1399 const char *base_path,
1400 const char *snap_desc,
1401 uint32_t num_user_data,
1402 struct snapper_dict *user_data,
1403 char **snap_path_out)
1406 DBusMessage *req_msg;
1407 DBusMessage *rsp_msg;
1408 uint32_t snap_id = 0;
1411 status = snapper_create_snap_pack(mem_ctx,
1417 if (!NT_STATUS_IS_OK(status)) {
1421 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1422 if (!NT_STATUS_IS_OK(status)) {
1426 status = snapper_create_snap_unpack(dconn, rsp_msg, &snap_id);
1427 if (!NT_STATUS_IS_OK(status)) {
1431 status = snapper_snap_id_to_path(mem_ctx, base_path, snap_id,
1433 if (!NT_STATUS_IS_OK(status)) {
1437 dbus_message_unref(rsp_msg);
1438 dbus_message_unref(req_msg);
1440 DEBUG(6, ("created new snapshot %u at %s\n", snap_id, snap_path));
1441 *snap_path_out = snap_path;
1443 return NT_STATUS_OK;
1446 dbus_message_unref(rsp_msg);
1448 dbus_message_unref(req_msg);
1453 static NTSTATUS snapper_snap_create(struct vfs_handle_struct *handle,
1454 TALLOC_CTX *mem_ctx,
1455 const char *base_volume,
1461 DBusConnection *dconn;
1465 char *snap_path = NULL;
1466 TALLOC_CTX *tmp_ctx;
1468 tmp_ctx = talloc_new(mem_ctx);
1469 if (tmp_ctx == NULL) {
1470 return NT_STATUS_NO_MEMORY;
1473 dconn = snapper_dbus_conn_create();
1474 if (dconn == NULL) {
1475 talloc_free(tmp_ctx);
1476 return NT_STATUS_UNSUCCESSFUL;
1479 status = snapper_get_conf_call(tmp_ctx, dconn, base_volume,
1480 &conf_name, &base_path);
1481 if (!NT_STATUS_IS_OK(status)) {
1482 snapper_dbus_conn_destroy(dconn);
1483 talloc_free(tmp_ctx);
1487 status = snapper_create_snap_call(tmp_ctx, dconn,
1488 conf_name, base_path,
1489 "Snapshot created by Samba",
1492 if (!NT_STATUS_IS_OK(status)) {
1493 snapper_dbus_conn_destroy(dconn);
1494 talloc_free(tmp_ctx);
1498 snapper_dbus_conn_destroy(dconn);
1499 *_base_path = talloc_steal(mem_ctx, base_path);
1500 *_snap_path = talloc_steal(mem_ctx, snap_path);
1501 talloc_free(tmp_ctx);
1503 return NT_STATUS_OK;
1506 static NTSTATUS snapper_delete_snap_call(TALLOC_CTX *mem_ctx,
1507 DBusConnection *dconn,
1508 const char *conf_name,
1512 DBusMessage *req_msg = NULL;
1513 DBusMessage *rsp_msg;
1515 status = snapper_del_snap_pack(mem_ctx, conf_name, snap_id, &req_msg);
1516 if (!NT_STATUS_IS_OK(status)) {
1520 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1521 if (!NT_STATUS_IS_OK(status)) {
1525 status = snapper_del_snap_unpack(dconn, rsp_msg);
1526 if (!NT_STATUS_IS_OK(status)) {
1530 dbus_message_unref(rsp_msg);
1531 dbus_message_unref(req_msg);
1533 DEBUG(6, ("deleted snapshot %u\n", snap_id));
1535 return NT_STATUS_OK;
1538 dbus_message_unref(rsp_msg);
1540 dbus_message_unref(req_msg);
1545 static NTSTATUS snapper_snap_delete(struct vfs_handle_struct *handle,
1546 TALLOC_CTX *mem_ctx,
1550 DBusConnection *dconn;
1553 char *snap_base_path;
1555 TALLOC_CTX *tmp_ctx;
1557 tmp_ctx = talloc_new(mem_ctx);
1558 if (tmp_ctx == NULL) {
1559 return NT_STATUS_NO_MEMORY;
1562 dconn = snapper_dbus_conn_create();
1563 if (dconn == NULL) {
1564 talloc_free(tmp_ctx);
1565 return NT_STATUS_UNSUCCESSFUL;
1568 status = snapper_get_conf_call(tmp_ctx, dconn, base_path,
1569 &conf_name, &snap_base_path);
1570 if (!NT_STATUS_IS_OK(status)) {
1571 snapper_dbus_conn_destroy(dconn);
1572 talloc_free(tmp_ctx);
1576 status = snapper_snap_path_to_id(tmp_ctx, snap_path, &snap_id);
1577 if (!NT_STATUS_IS_OK(status)) {
1578 snapper_dbus_conn_destroy(dconn);
1579 talloc_free(tmp_ctx);
1583 status = snapper_delete_snap_call(tmp_ctx, dconn, conf_name, snap_id);
1584 if (!NT_STATUS_IS_OK(status)) {
1585 snapper_dbus_conn_destroy(dconn);
1586 talloc_free(tmp_ctx);
1590 snapper_dbus_conn_destroy(dconn);
1591 talloc_free(tmp_ctx);
1593 return NT_STATUS_OK;
1596 /* sc_data used as parent talloc context for all labels */
1597 static int snapper_get_shadow_copy_data(struct vfs_handle_struct *handle,
1598 struct files_struct *fsp,
1599 struct shadow_copy_data *sc_data,
1602 DBusConnection *dconn;
1603 TALLOC_CTX *tmp_ctx;
1607 DBusMessage *req_msg = NULL;
1608 DBusMessage *rsp_msg;
1610 struct snapper_snap *snaps;
1614 tmp_ctx = talloc_new(sc_data);
1615 if (tmp_ctx == NULL) {
1616 status = NT_STATUS_NO_MEMORY;
1620 dconn = snapper_dbus_conn_create();
1621 if (dconn == NULL) {
1622 status = NT_STATUS_UNSUCCESSFUL;
1623 goto err_mem_ctx_free;
1626 if (fsp->conn->connectpath == NULL) {
1627 status = NT_STATUS_INVALID_PARAMETER;
1631 status = snapper_get_conf_call(tmp_ctx, dconn,
1632 fsp->conn->connectpath,
1635 if (!NT_STATUS_IS_OK(status)) {
1639 status = snapper_list_snaps_pack(tmp_ctx, conf_name, &req_msg);
1640 if (!NT_STATUS_IS_OK(status)) {
1644 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1645 if (!NT_STATUS_IS_OK(status)) {
1649 status = snapper_list_snaps_unpack(tmp_ctx, rsp_msg,
1650 &num_snaps, &snaps);
1651 if (!NT_STATUS_IS_OK(status)) {
1654 /* we should always get at least one snapshot (current) */
1655 if (num_snaps == 0) {
1656 DEBUG(1, ("zero snapshots in snap list response\n"));
1657 status = NT_STATUS_UNSUCCESSFUL;
1661 /* subtract 1, (current) snapshot is not returned */
1662 sc_data->num_volumes = num_snaps - 1;
1663 sc_data->labels = NULL;
1665 if ((labels == false) || (sc_data->num_volumes == 0)) {
1666 /* tokens need not be added to the labels array */
1670 sc_data->labels = talloc_array(sc_data, SHADOW_COPY_LABEL,
1671 sc_data->num_volumes);
1672 if (sc_data->labels == NULL) {
1673 status = NT_STATUS_NO_MEMORY;
1677 /* start at end for decending order, do not include 0 (current) */
1679 for (i = num_snaps - 1; i > 0; i--) {
1680 char *lbl = sc_data->labels[lbl_off++];
1681 struct tm gmt_snap_time;
1685 tm_ret = gmtime_r((time_t *)&snaps[i].time, &gmt_snap_time);
1686 if (tm_ret == NULL) {
1687 status = NT_STATUS_UNSUCCESSFUL;
1688 goto err_labels_free;
1690 str_sz = strftime(lbl, sizeof(SHADOW_COPY_LABEL),
1691 "@GMT-%Y.%m.%d-%H.%M.%S", &gmt_snap_time);
1693 status = NT_STATUS_UNSUCCESSFUL;
1694 goto err_labels_free;
1699 talloc_free(tmp_ctx);
1700 dbus_message_unref(rsp_msg);
1701 dbus_message_unref(req_msg);
1702 snapper_dbus_conn_destroy(dconn);
1707 TALLOC_FREE(sc_data->labels);
1709 dbus_message_unref(rsp_msg);
1711 dbus_message_unref(req_msg);
1713 snapper_dbus_conn_destroy(dconn);
1715 talloc_free(tmp_ctx);
1717 errno = map_errno_from_nt_status(status);
1721 static bool snapper_gmt_strip_snapshot(TALLOC_CTX *mem_ctx,
1722 struct vfs_handle_struct *handle,
1732 size_t rest_len, dst_len;
1733 ptrdiff_t len_before_gmt;
1735 p = strstr_m(name, "@GMT-");
1739 if ((p > name) && (p[-1] != '/')) {
1742 len_before_gmt = p - name;
1743 q = strptime(p, GMT_FORMAT, &tm);
1748 timestamp = timegm(&tm);
1749 if (timestamp == (time_t)-1) {
1754 * The name consists of only the GMT token or the GMT
1755 * token is at the end of the path. XP seems to send
1756 * @GMT- at the end under certain circumstances even
1757 * with a path prefix.
1759 if (pstripped != NULL) {
1760 if (len_before_gmt > 0) {
1762 * There is a slash before
1763 * the @GMT-. Remove it.
1765 len_before_gmt -= 1;
1767 stripped = talloc_strndup(mem_ctx, name,
1769 if (stripped == NULL) {
1772 *pstripped = stripped;
1774 *ptimestamp = timestamp;
1779 * It is not a complete path component, i.e. the path
1780 * component continues after the gmt-token.
1786 rest_len = strlen(q);
1787 dst_len = len_before_gmt + rest_len;
1789 if (pstripped != NULL) {
1790 stripped = talloc_array(mem_ctx, char, dst_len+1);
1791 if (stripped == NULL) {
1796 memcpy(stripped, name, len_before_gmt);
1799 memcpy(stripped + len_before_gmt, q, rest_len);
1801 stripped[dst_len] = '\0';
1802 *pstripped = stripped;
1804 *ptimestamp = timestamp;
1811 static NTSTATUS snapper_get_snap_at_time_call(TALLOC_CTX *mem_ctx,
1812 DBusConnection *dconn,
1813 const char *conf_name,
1814 const char *base_path,
1816 char **snap_path_out)
1819 DBusMessage *req_msg = NULL;
1820 DBusMessage *rsp_msg;
1822 struct snapper_snap *snaps;
1825 status = snapper_list_snaps_at_time_pack(mem_ctx,
1830 if (!NT_STATUS_IS_OK(status)) {
1834 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1835 if (!NT_STATUS_IS_OK(status)) {
1839 status = snapper_list_snaps_unpack(mem_ctx, rsp_msg,
1840 &num_snaps, &snaps);
1841 if (!NT_STATUS_IS_OK(status)) {
1845 if (num_snaps == 0) {
1846 DEBUG(4, ("no snapshots found with time: %lu\n",
1847 (unsigned long)snaptime));
1848 status = NT_STATUS_INVALID_PARAMETER;
1849 goto err_snap_array_free;
1850 } else if (num_snaps > 0) {
1851 DEBUG(4, ("got %u snapshots for single time %lu, using top\n",
1852 num_snaps, (unsigned long)snaptime));
1855 status = snapper_snap_id_to_path(mem_ctx, base_path, snaps[0].id,
1857 if (!NT_STATUS_IS_OK(status)) {
1858 goto err_snap_array_free;
1861 *snap_path_out = snap_path;
1862 err_snap_array_free:
1865 dbus_message_unref(rsp_msg);
1867 dbus_message_unref(req_msg);
1872 static NTSTATUS snapper_snap_path_expand(struct connection_struct *conn,
1873 TALLOC_CTX *mem_ctx,
1875 char **snap_dir_out)
1877 DBusConnection *dconn;
1881 char *snap_path = NULL;
1883 dconn = snapper_dbus_conn_create();
1884 if (dconn == NULL) {
1885 status = NT_STATUS_UNSUCCESSFUL;
1889 if (conn->connectpath == NULL) {
1890 status = NT_STATUS_INVALID_PARAMETER;
1894 status = snapper_get_conf_call(mem_ctx, dconn,
1898 if (!NT_STATUS_IS_OK(status)) {
1902 status = snapper_get_snap_at_time_call(mem_ctx, dconn,
1903 conf_name, base_path, snap_time,
1905 if (!NT_STATUS_IS_OK(status)) {
1906 goto err_conf_name_free;
1909 /* confirm snapshot path is nested under base path */
1910 if (strncmp(snap_path, base_path, strlen(base_path)) != 0) {
1911 status = NT_STATUS_INVALID_PARAMETER;
1912 goto err_snap_path_free;
1915 talloc_free(conf_name);
1916 talloc_free(base_path);
1917 snapper_dbus_conn_destroy(dconn);
1918 *snap_dir_out = snap_path;
1920 return NT_STATUS_OK;
1923 talloc_free(snap_path);
1925 talloc_free(conf_name);
1926 talloc_free(base_path);
1928 snapper_dbus_conn_destroy(dconn);
1933 static char *snapper_gmt_convert(TALLOC_CTX *mem_ctx,
1934 struct vfs_handle_struct *handle,
1935 const char *name, time_t timestamp)
1937 char *snap_path = NULL;
1942 status = snapper_snap_path_expand(handle->conn, mem_ctx, timestamp,
1944 if (!NT_STATUS_IS_OK(status)) {
1945 errno = map_errno_from_nt_status(status);
1949 path = talloc_asprintf(mem_ctx, "%s/%s", snap_path, name);
1952 goto err_snap_path_free;
1955 DEBUG(10, ("converted %s/%s @ time to %s\n",
1956 handle->conn->connectpath, name, path));
1960 saved_errno = errno;
1961 talloc_free(snap_path);
1962 errno = saved_errno;
1967 static DIR *snapper_gmt_opendir(vfs_handle_struct *handle,
1968 const struct smb_filename *smb_fname,
1977 struct smb_filename *conv_smb_fname = NULL;
1979 if (!snapper_gmt_strip_snapshot(talloc_tos(),
1981 smb_fname->base_name,
1986 if (timestamp == 0) {
1987 return SMB_VFS_NEXT_OPENDIR(handle, smb_fname, mask, attr);
1989 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
1990 TALLOC_FREE(stripped);
1994 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
1999 if (conv_smb_fname == NULL) {
2005 ret = SMB_VFS_NEXT_OPENDIR(handle, conv_smb_fname, mask, attr);
2006 saved_errno = errno;
2008 TALLOC_FREE(conv_smb_fname);
2009 errno = saved_errno;
2013 static int snapper_gmt_rename(vfs_handle_struct *handle,
2014 const struct smb_filename *smb_fname_src,
2015 const struct smb_filename *smb_fname_dst)
2017 time_t timestamp_src, timestamp_dst;
2019 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2020 smb_fname_src->base_name,
2021 ×tamp_src, NULL)) {
2024 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2025 smb_fname_dst->base_name,
2026 ×tamp_dst, NULL)) {
2029 if (timestamp_src != 0) {
2033 if (timestamp_dst != 0) {
2037 return SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
2040 static int snapper_gmt_symlink(vfs_handle_struct *handle,
2041 const char *link_contents,
2042 const struct smb_filename *new_smb_fname)
2044 time_t timestamp_old = 0;
2045 time_t timestamp_new = 0;
2047 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2054 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2056 new_smb_fname->base_name,
2061 if ((timestamp_old != 0) || (timestamp_new != 0)) {
2065 return SMB_VFS_NEXT_SYMLINK(handle, link_contents, new_smb_fname);
2068 static int snapper_gmt_link(vfs_handle_struct *handle,
2069 const struct smb_filename *old_smb_fname,
2070 const struct smb_filename *new_smb_fname)
2072 time_t timestamp_old = 0;
2073 time_t timestamp_new = 0;
2075 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2077 old_smb_fname->base_name,
2082 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2084 new_smb_fname->base_name,
2089 if ((timestamp_old != 0) || (timestamp_new != 0)) {
2093 return SMB_VFS_NEXT_LINK(handle, old_smb_fname, new_smb_fname);
2096 static int snapper_gmt_stat(vfs_handle_struct *handle,
2097 struct smb_filename *smb_fname)
2100 char *stripped, *tmp;
2101 int ret, saved_errno;
2103 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2104 smb_fname->base_name,
2105 ×tamp, &stripped)) {
2108 if (timestamp == 0) {
2109 return SMB_VFS_NEXT_STAT(handle, smb_fname);
2112 tmp = smb_fname->base_name;
2113 smb_fname->base_name = snapper_gmt_convert(talloc_tos(), handle,
2114 stripped, timestamp);
2115 TALLOC_FREE(stripped);
2117 if (smb_fname->base_name == NULL) {
2118 smb_fname->base_name = tmp;
2122 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
2123 saved_errno = errno;
2125 TALLOC_FREE(smb_fname->base_name);
2126 smb_fname->base_name = tmp;
2128 errno = saved_errno;
2132 static int snapper_gmt_lstat(vfs_handle_struct *handle,
2133 struct smb_filename *smb_fname)
2136 char *stripped, *tmp;
2137 int ret, saved_errno;
2139 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2140 smb_fname->base_name,
2141 ×tamp, &stripped)) {
2144 if (timestamp == 0) {
2145 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
2148 tmp = smb_fname->base_name;
2149 smb_fname->base_name = snapper_gmt_convert(talloc_tos(), handle,
2150 stripped, timestamp);
2151 TALLOC_FREE(stripped);
2153 if (smb_fname->base_name == NULL) {
2154 smb_fname->base_name = tmp;
2158 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
2159 saved_errno = errno;
2161 TALLOC_FREE(smb_fname->base_name);
2162 smb_fname->base_name = tmp;
2164 errno = saved_errno;
2168 static int snapper_gmt_open(vfs_handle_struct *handle,
2169 struct smb_filename *smb_fname, files_struct *fsp,
2170 int flags, mode_t mode)
2173 char *stripped, *tmp;
2174 int ret, saved_errno;
2176 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2177 smb_fname->base_name,
2178 ×tamp, &stripped)) {
2181 if (timestamp == 0) {
2182 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
2185 tmp = smb_fname->base_name;
2186 smb_fname->base_name = snapper_gmt_convert(talloc_tos(), handle,
2187 stripped, timestamp);
2188 TALLOC_FREE(stripped);
2190 if (smb_fname->base_name == NULL) {
2191 smb_fname->base_name = tmp;
2195 ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
2196 saved_errno = errno;
2198 TALLOC_FREE(smb_fname->base_name);
2199 smb_fname->base_name = tmp;
2201 errno = saved_errno;
2205 static int snapper_gmt_unlink(vfs_handle_struct *handle,
2206 const struct smb_filename *smb_fname)
2210 int ret, saved_errno;
2211 struct smb_filename *conv;
2213 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2214 smb_fname->base_name,
2215 ×tamp, &stripped)) {
2218 if (timestamp == 0) {
2219 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
2221 conv = cp_smb_filename(talloc_tos(), smb_fname);
2226 conv->base_name = snapper_gmt_convert(conv, handle,
2227 stripped, timestamp);
2228 TALLOC_FREE(stripped);
2229 if (conv->base_name == NULL) {
2232 ret = SMB_VFS_NEXT_UNLINK(handle, conv);
2233 saved_errno = errno;
2235 errno = saved_errno;
2239 static int snapper_gmt_chmod(vfs_handle_struct *handle,
2240 const struct smb_filename *smb_fname,
2244 char *stripped = NULL;
2245 int ret, saved_errno;
2247 struct smb_filename *conv_smb_fname = NULL;
2249 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2251 smb_fname->base_name,
2256 if (timestamp == 0) {
2257 TALLOC_FREE(stripped);
2258 return SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
2260 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2261 TALLOC_FREE(stripped);
2265 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2270 if (conv_smb_fname == NULL) {
2276 ret = SMB_VFS_NEXT_CHMOD(handle, conv_smb_fname, mode);
2277 saved_errno = errno;
2279 TALLOC_FREE(conv_smb_fname);
2280 errno = saved_errno;
2284 static int snapper_gmt_chown(vfs_handle_struct *handle,
2285 const struct smb_filename *smb_fname,
2290 char *stripped = NULL;
2291 int ret, saved_errno;
2293 struct smb_filename *conv_smb_fname = NULL;
2295 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2297 smb_fname->base_name,
2302 if (timestamp == 0) {
2303 TALLOC_FREE(stripped);
2304 return SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
2306 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2307 TALLOC_FREE(stripped);
2311 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2316 if (conv_smb_fname == NULL) {
2321 ret = SMB_VFS_NEXT_CHOWN(handle, conv_smb_fname, uid, gid);
2322 saved_errno = errno;
2324 TALLOC_FREE(conv_smb_fname);
2325 errno = saved_errno;
2329 static int snapper_gmt_chdir(vfs_handle_struct *handle,
2330 const struct smb_filename *smb_fname)
2332 time_t timestamp = 0;
2333 char *stripped = NULL;
2335 int saved_errno = 0;
2337 struct smb_filename *conv_smb_fname = NULL;
2339 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2341 smb_fname->base_name,
2346 if (timestamp == 0) {
2347 return SMB_VFS_NEXT_CHDIR(handle, smb_fname);
2349 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2350 TALLOC_FREE(stripped);
2354 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2359 if (conv_smb_fname == NULL) {
2364 ret = SMB_VFS_NEXT_CHDIR(handle, conv_smb_fname);
2366 saved_errno = errno;
2369 TALLOC_FREE(conv_smb_fname);
2370 if (saved_errno != 0) {
2371 errno = saved_errno;
2376 static int snapper_gmt_ntimes(vfs_handle_struct *handle,
2377 const struct smb_filename *smb_fname,
2378 struct smb_file_time *ft)
2382 int ret, saved_errno;
2383 struct smb_filename *conv;
2385 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2386 smb_fname->base_name,
2387 ×tamp, &stripped)) {
2390 if (timestamp == 0) {
2391 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
2393 conv = cp_smb_filename(talloc_tos(), smb_fname);
2398 conv->base_name = snapper_gmt_convert(conv, handle,
2399 stripped, timestamp);
2400 TALLOC_FREE(stripped);
2401 if (conv->base_name == NULL) {
2404 ret = SMB_VFS_NEXT_NTIMES(handle, conv, ft);
2405 saved_errno = errno;
2407 errno = saved_errno;
2411 static int snapper_gmt_readlink(vfs_handle_struct *handle,
2412 const struct smb_filename *smb_fname,
2416 time_t timestamp = 0;
2417 char *stripped = NULL;
2419 int saved_errno = 0;
2420 struct smb_filename *conv = NULL;
2422 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2423 smb_fname->base_name,
2424 ×tamp, &stripped)) {
2427 if (timestamp == 0) {
2428 return SMB_VFS_NEXT_READLINK(handle, smb_fname, buf, bufsiz);
2430 conv = cp_smb_filename(talloc_tos(), smb_fname);
2432 TALLOC_FREE(stripped);
2436 conv->base_name = snapper_gmt_convert(conv, handle,
2437 stripped, timestamp);
2438 TALLOC_FREE(stripped);
2439 if (conv->base_name == NULL) {
2442 ret = SMB_VFS_NEXT_READLINK(handle, conv, buf, bufsiz);
2444 saved_errno = errno;
2447 if (saved_errno != 0) {
2448 errno = saved_errno;
2453 static int snapper_gmt_mknod(vfs_handle_struct *handle,
2454 const struct smb_filename *smb_fname,
2458 time_t timestamp = (time_t)0;
2459 char *stripped = NULL;
2460 int ret, saved_errno = 0;
2461 struct smb_filename *conv_smb_fname = NULL;
2463 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2464 smb_fname->base_name,
2465 ×tamp, &stripped)) {
2468 if (timestamp == 0) {
2469 return SMB_VFS_NEXT_MKNOD(handle, smb_fname, mode, dev);
2471 conv_smb_fname = cp_smb_filename(talloc_tos(), smb_fname);
2472 if (conv_smb_fname == NULL) {
2476 conv_smb_fname->base_name = snapper_gmt_convert(conv_smb_fname, handle,
2477 stripped, timestamp);
2478 TALLOC_FREE(stripped);
2479 if (conv_smb_fname->base_name == NULL) {
2482 ret = SMB_VFS_NEXT_MKNOD(handle, conv_smb_fname, mode, dev);
2484 saved_errno = errno;
2486 TALLOC_FREE(conv_smb_fname);
2487 if (saved_errno != 0) {
2488 errno = saved_errno;
2493 static struct smb_filename *snapper_gmt_realpath(vfs_handle_struct *handle,
2495 const struct smb_filename *smb_fname)
2497 time_t timestamp = 0;
2498 char *stripped = NULL;
2499 struct smb_filename *result_fname = NULL;
2500 struct smb_filename *conv_smb_fname = NULL;
2501 int saved_errno = 0;
2503 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2504 smb_fname->base_name,
2505 ×tamp, &stripped)) {
2508 if (timestamp == 0) {
2509 return SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
2512 conv_smb_fname = cp_smb_filename(talloc_tos(), smb_fname);
2513 if (conv_smb_fname == NULL) {
2516 conv_smb_fname->base_name = snapper_gmt_convert(conv_smb_fname, handle,
2517 stripped, timestamp);
2518 if (conv_smb_fname->base_name == NULL) {
2522 result_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, conv_smb_fname);
2525 if (result_fname == NULL) {
2526 saved_errno = errno;
2528 TALLOC_FREE(conv_smb_fname);
2529 TALLOC_FREE(stripped);
2530 if (saved_errno != 0) {
2531 errno = saved_errno;
2533 return result_fname;
2536 static NTSTATUS snapper_gmt_fget_nt_acl(vfs_handle_struct *handle,
2537 struct files_struct *fsp,
2538 uint32_t security_info,
2539 TALLOC_CTX *mem_ctx,
2540 struct security_descriptor **ppdesc)
2546 struct smb_filename *smb_fname = NULL;
2548 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2549 fsp->fsp_name->base_name,
2550 ×tamp, &stripped)) {
2551 return map_nt_error_from_unix(errno);
2553 if (timestamp == 0) {
2554 return SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
2558 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2559 TALLOC_FREE(stripped);
2561 return map_nt_error_from_unix(errno);
2564 smb_fname = synthetic_smb_fname(talloc_tos(),
2568 fsp->fsp_name->flags);
2570 if (smb_fname == NULL) {
2571 return NT_STATUS_NO_MEMORY;
2574 status = SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info,
2576 TALLOC_FREE(smb_fname);
2580 static NTSTATUS snapper_gmt_get_nt_acl(vfs_handle_struct *handle,
2581 const struct smb_filename *fname,
2582 uint32_t security_info,
2583 TALLOC_CTX *mem_ctx,
2584 struct security_descriptor **ppdesc)
2590 struct smb_filename *smb_fname = NULL;
2592 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, fname->base_name,
2593 ×tamp, &stripped)) {
2594 return map_nt_error_from_unix(errno);
2596 if (timestamp == 0) {
2597 return SMB_VFS_NEXT_GET_NT_ACL(handle, fname, security_info,
2600 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2601 TALLOC_FREE(stripped);
2603 return map_nt_error_from_unix(errno);
2605 smb_fname = synthetic_smb_fname(talloc_tos(),
2611 if (smb_fname == NULL) {
2612 return NT_STATUS_NO_MEMORY;
2615 status = SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info,
2617 TALLOC_FREE(smb_fname);
2621 static int snapper_gmt_mkdir(vfs_handle_struct *handle,
2622 const struct smb_filename *fname,
2627 int ret, saved_errno;
2629 struct smb_filename *smb_fname = NULL;
2631 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, fname->base_name,
2632 ×tamp, &stripped)) {
2635 if (timestamp == 0) {
2636 return SMB_VFS_NEXT_MKDIR(handle, fname, mode);
2638 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2639 TALLOC_FREE(stripped);
2643 smb_fname = synthetic_smb_fname(talloc_tos(),
2649 if (smb_fname == NULL) {
2654 ret = SMB_VFS_NEXT_MKDIR(handle, smb_fname, mode);
2655 saved_errno = errno;
2656 TALLOC_FREE(smb_fname);
2657 errno = saved_errno;
2661 static int snapper_gmt_rmdir(vfs_handle_struct *handle,
2662 const struct smb_filename *fname)
2666 int ret, saved_errno;
2668 struct smb_filename *smb_fname = NULL;
2670 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, fname->base_name,
2671 ×tamp, &stripped)) {
2674 if (timestamp == 0) {
2675 return SMB_VFS_NEXT_RMDIR(handle, fname);
2677 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2678 TALLOC_FREE(stripped);
2682 smb_fname = synthetic_smb_fname(talloc_tos(),
2688 if (smb_fname == NULL) {
2692 ret = SMB_VFS_NEXT_RMDIR(handle, smb_fname);
2693 saved_errno = errno;
2694 TALLOC_FREE(smb_fname);
2695 errno = saved_errno;
2699 static int snapper_gmt_chflags(vfs_handle_struct *handle,
2700 const struct smb_filename *smb_fname,
2703 time_t timestamp = 0;
2704 char *stripped = NULL;
2706 int saved_errno = 0;
2708 struct smb_filename *conv_smb_fname = NULL;
2710 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2711 smb_fname->base_name, ×tamp, &stripped)) {
2714 if (timestamp == 0) {
2715 return SMB_VFS_NEXT_CHFLAGS(handle, smb_fname, flags);
2717 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2718 TALLOC_FREE(stripped);
2722 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2728 if (conv_smb_fname == NULL) {
2732 ret = SMB_VFS_NEXT_CHFLAGS(handle, conv_smb_fname, flags);
2734 saved_errno = errno;
2736 TALLOC_FREE(conv_smb_fname);
2737 if (saved_errno != 0) {
2738 errno = saved_errno;
2743 static ssize_t snapper_gmt_getxattr(vfs_handle_struct *handle,
2744 const struct smb_filename *smb_fname,
2749 time_t timestamp = 0;
2750 char *stripped = NULL;
2752 int saved_errno = 0;
2754 struct smb_filename *conv_smb_fname = NULL;
2756 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2758 smb_fname->base_name,
2763 if (timestamp == 0) {
2764 return SMB_VFS_NEXT_GETXATTR(handle, smb_fname, aname, value,
2767 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2768 TALLOC_FREE(stripped);
2772 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2778 if (conv_smb_fname == NULL) {
2782 ret = SMB_VFS_NEXT_GETXATTR(handle, conv_smb_fname, aname, value, size);
2784 saved_errno = errno;
2786 TALLOC_FREE(conv_smb_fname);
2788 if (saved_errno != 0) {
2789 errno = saved_errno;
2794 static ssize_t snapper_gmt_listxattr(struct vfs_handle_struct *handle,
2795 const struct smb_filename *smb_fname,
2796 char *list, size_t size)
2798 time_t timestamp = 0;
2799 char *stripped = NULL;
2801 int saved_errno = 0;
2803 struct smb_filename *conv_smb_fname = NULL;
2805 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2807 smb_fname->base_name,
2812 if (timestamp == 0) {
2813 return SMB_VFS_NEXT_LISTXATTR(handle, smb_fname, list, size);
2815 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2816 TALLOC_FREE(stripped);
2820 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2826 if (conv_smb_fname == NULL) {
2830 ret = SMB_VFS_NEXT_LISTXATTR(handle, conv_smb_fname, list, size);
2832 saved_errno = errno;
2834 TALLOC_FREE(conv_smb_fname);
2836 if (saved_errno != 0) {
2837 errno = saved_errno;
2842 static int snapper_gmt_removexattr(vfs_handle_struct *handle,
2843 const struct smb_filename *smb_fname,
2846 time_t timestamp = 0;
2847 char *stripped = NULL;
2849 int saved_errno = 0;
2851 struct smb_filename *conv_smb_fname = NULL;
2853 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2855 smb_fname->base_name,
2860 if (timestamp == 0) {
2861 return SMB_VFS_NEXT_REMOVEXATTR(handle, smb_fname, aname);
2863 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2864 TALLOC_FREE(stripped);
2868 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2874 if (conv_smb_fname == NULL) {
2878 ret = SMB_VFS_NEXT_REMOVEXATTR(handle, conv_smb_fname, aname);
2880 saved_errno = errno;
2882 TALLOC_FREE(conv_smb_fname);
2884 if (saved_errno != 0) {
2885 errno = saved_errno;
2890 static int snapper_gmt_setxattr(struct vfs_handle_struct *handle,
2891 const struct smb_filename *smb_fname,
2892 const char *aname, const void *value,
2893 size_t size, int flags)
2895 time_t timestamp = 0;
2896 char *stripped = NULL;
2898 int saved_errno = 0;
2900 struct smb_filename *conv_smb_fname = NULL;
2902 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2904 smb_fname->base_name,
2909 if (timestamp == 0) {
2910 return SMB_VFS_NEXT_SETXATTR(handle, smb_fname,
2911 aname, value, size, flags);
2913 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2914 TALLOC_FREE(stripped);
2918 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2924 if (conv_smb_fname == NULL) {
2928 ret = SMB_VFS_NEXT_SETXATTR(handle, conv_smb_fname,
2929 aname, value, size, flags);
2931 saved_errno = errno;
2933 TALLOC_FREE(conv_smb_fname);
2935 if (saved_errno != 0) {
2936 errno = saved_errno;
2941 static int snapper_gmt_get_real_filename(struct vfs_handle_struct *handle,
2944 TALLOC_CTX *mem_ctx,
2953 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, path,
2954 ×tamp, &stripped)) {
2957 if (timestamp == 0) {
2958 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
2959 mem_ctx, found_name);
2961 if (stripped[0] == '\0') {
2962 *found_name = talloc_strdup(mem_ctx, name);
2963 if (*found_name == NULL) {
2969 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2970 TALLOC_FREE(stripped);
2974 ret = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, conv, name,
2975 mem_ctx, found_name);
2976 saved_errno = errno;
2978 errno = saved_errno;
2982 static uint64_t snapper_gmt_disk_free(vfs_handle_struct *handle,
2983 const struct smb_filename *smb_fname,
2988 time_t timestamp = 0;
2989 char *stripped = NULL;
2991 int saved_errno = 0;
2993 struct smb_filename *conv_smb_fname = NULL;
2995 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2996 smb_fname->base_name, ×tamp, &stripped)) {
2997 return (uint64_t)-1;
2999 if (timestamp == 0) {
3000 return SMB_VFS_NEXT_DISK_FREE(handle, smb_fname,
3001 bsize, dfree, dsize);
3004 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
3005 TALLOC_FREE(stripped);
3007 return (uint64_t)-1;
3009 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
3014 if (conv_smb_fname == NULL) {
3017 return (uint64_t)-1;
3020 ret = SMB_VFS_NEXT_DISK_FREE(handle, conv_smb_fname,
3021 bsize, dfree, dsize);
3023 if (ret == (uint64_t)-1) {
3024 saved_errno = errno;
3026 TALLOC_FREE(conv_smb_fname);
3027 if (saved_errno != 0) {
3028 errno = saved_errno;
3033 static int snapper_gmt_get_quota(vfs_handle_struct *handle,
3034 const struct smb_filename *smb_fname,
3035 enum SMB_QUOTA_TYPE qtype,
3039 time_t timestamp = 0;
3040 char *stripped = NULL;
3042 int saved_errno = 0;
3044 struct smb_filename *conv_smb_fname = NULL;
3046 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
3047 smb_fname->base_name, ×tamp, &stripped)) {
3050 if (timestamp == 0) {
3051 return SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, dq);
3054 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
3055 TALLOC_FREE(stripped);
3059 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
3065 if (conv_smb_fname == NULL) {
3070 ret = SMB_VFS_NEXT_GET_QUOTA(handle, conv_smb_fname, qtype, id, dq);
3073 saved_errno = errno;
3075 TALLOC_FREE(conv_smb_fname);
3076 if (saved_errno != 0) {
3077 errno = saved_errno;
3083 static struct vfs_fn_pointers snapper_fns = {
3084 .snap_check_path_fn = snapper_snap_check_path,
3085 .snap_create_fn = snapper_snap_create,
3086 .snap_delete_fn = snapper_snap_delete,
3087 .get_shadow_copy_data_fn = snapper_get_shadow_copy_data,
3088 .opendir_fn = snapper_gmt_opendir,
3089 .disk_free_fn = snapper_gmt_disk_free,
3090 .get_quota_fn = snapper_gmt_get_quota,
3091 .rename_fn = snapper_gmt_rename,
3092 .link_fn = snapper_gmt_link,
3093 .symlink_fn = snapper_gmt_symlink,
3094 .stat_fn = snapper_gmt_stat,
3095 .lstat_fn = snapper_gmt_lstat,
3096 .open_fn = snapper_gmt_open,
3097 .unlink_fn = snapper_gmt_unlink,
3098 .chmod_fn = snapper_gmt_chmod,
3099 .chown_fn = snapper_gmt_chown,
3100 .chdir_fn = snapper_gmt_chdir,
3101 .ntimes_fn = snapper_gmt_ntimes,
3102 .readlink_fn = snapper_gmt_readlink,
3103 .mknod_fn = snapper_gmt_mknod,
3104 .realpath_fn = snapper_gmt_realpath,
3105 .get_nt_acl_fn = snapper_gmt_get_nt_acl,
3106 .fget_nt_acl_fn = snapper_gmt_fget_nt_acl,
3107 .mkdir_fn = snapper_gmt_mkdir,
3108 .rmdir_fn = snapper_gmt_rmdir,
3109 .getxattr_fn = snapper_gmt_getxattr,
3110 .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
3111 .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
3112 .listxattr_fn = snapper_gmt_listxattr,
3113 .removexattr_fn = snapper_gmt_removexattr,
3114 .setxattr_fn = snapper_gmt_setxattr,
3115 .chflags_fn = snapper_gmt_chflags,
3116 .get_real_filename_fn = snapper_gmt_get_real_filename,
3120 NTSTATUS vfs_snapper_init(TALLOC_CTX *ctx)
3122 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
3123 "snapper", &snapper_fns);