?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
python: move clean_file() to samba/tests/libsmb.py
[Samba.git] / source3 / modules / vfs_snapper.c
blobf12a94befd61c9ed04852c0cbe07055ec52b0791
1 /*
2 * Module for snapshot IO using snapper
3 *
4 * Copyright (C) David Disseldorp 2012-2014
5 *
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
12 *
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.
17 *
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.
22 *
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/>.
25 */
26
27 #include <dbus/dbus.h>
28 #ifdef HAVE_LINUX_IOCTL_H
29 #include <linux/ioctl.h>
30 #endif
31 #include <sys/ioctl.h>
32 #include <dirent.h>
33 #include <libgen.h>
34 #include "includes.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"
40 #include "lib/util/smb_strtox.h"
41
42 #define SNAPPER_SIG_LIST_SNAPS_RSP "a(uquxussa{ss})"
43 #define SNAPPER_SIG_LIST_CONFS_RSP "a(ssa{ss})"
44 #define SNAPPER_SIG_CREATE_SNAP_RSP "u"
45 #define SNAPPER_SIG_DEL_SNAPS_RSP ""
46 #define SNAPPER_SIG_STRING_DICT "{ss}"
47
48 struct snapper_dict {
49 char *key;
50 char *val;
51 };
52
53 struct snapper_snap {
54 uint32_t id;
55 uint16_t type;
56 uint32_t pre_id;
57 int64_t time;
58 uint32_t creator_uid;
59 char *desc;
60 char *cleanup;
61 uint32_t num_user_data;
62 struct snapper_dict *user_data;
63 };
64
65 struct snapper_conf {
66 char *name;
67 char *mnt;
68 uint32_t num_attrs;
69 struct snapper_dict *attrs;
70 };
71
72 static const struct {
73 const char *snapper_err_str;
74 NTSTATUS status;
75 } snapper_err_map[] = {
76 { "error.no_permissions", NT_STATUS_ACCESS_DENIED },
77 };
78
79 static NTSTATUS snapper_err_ntstatus_map(const char *snapper_err_str)
80 {
81 int i;
82
83 if (snapper_err_str == NULL) {
84 return NT_STATUS_UNSUCCESSFUL;
85 }
86 for (i = 0; i < ARRAY_SIZE(snapper_err_map); i++) {
87 if (!strcmp(snapper_err_map[i].snapper_err_str,
88 snapper_err_str)) {
89 return snapper_err_map[i].status;
90 }
91 }
92 DEBUG(2, ("no explicit mapping for dbus error: %s\n", snapper_err_str));
93
94 return NT_STATUS_UNSUCCESSFUL;
95 }
96
97 /*
98 * Strings are UTF-8. Other characters must be encoded hexadecimal as "\x??".
99 * As a consequence "\" must be encoded as "\\".
100 */
101 static NTSTATUS snapper_dbus_str_encode(TALLOC_CTX *mem_ctx, const char *in_str,
102 char **_out_str)
103 {
104 size_t in_len;
105 char *out_str;
106 int i;
107 int out_off;
108 int out_len;
109
110 if (in_str == NULL) {
111 return NT_STATUS_INVALID_PARAMETER;
112 }
113
114 in_len = strlen(in_str);
115
116 /* output can be max 4 times the length of @in_str, +1 for terminator */
117 out_len = (in_len * 4) + 1;
118
119 out_str = talloc_array(mem_ctx, char, out_len);
120 if (out_str == NULL) {
121 return NT_STATUS_NO_MEMORY;
122 }
123
124 out_off = 0;
125 for (i = 0; i < in_len; i++) {
126 size_t pushed;
127
128 if (in_str[i] == '\\') {
129 pushed = snprintf(out_str + out_off, out_len - out_off,
130 "\\\\");
131 } else if ((unsigned char)in_str[i] > 127) {
132 pushed = snprintf(out_str + out_off, out_len - out_off,
133 "\\x%02x", (unsigned char)in_str[i]);
134 } else {
135 /* regular character */
136 *(out_str + out_off) = in_str[i];
137 pushed = sizeof(char);
138 }
139 if (pushed >= out_len - out_off) {
140 /* truncated, should never happen */
141 talloc_free(out_str);
142 return NT_STATUS_INTERNAL_ERROR;
143 }
144 out_off += pushed;
145 }
146
147 *(out_str + out_off) = '\0';
148 *_out_str = out_str;
149
150 return NT_STATUS_OK;
151 }
152
153 static NTSTATUS snapper_dbus_str_decode(TALLOC_CTX *mem_ctx, const char *in_str,
154 char **_out_str)
155 {
156 size_t in_len;
157 char *out_str;
158 int i;
159 int out_off;
160 int out_len;
161
162 if (in_str == NULL) {
163 return NT_STATUS_INVALID_PARAMETER;
164 }
165
166 in_len = strlen(in_str);
167
168 /* output cannot be larger than input, +1 for terminator */
169 out_len = in_len + 1;
170
171 out_str = talloc_array(mem_ctx, char, out_len);
172 if (out_str == NULL) {
173 return NT_STATUS_NO_MEMORY;
174 }
175
176 out_off = 0;
177 for (i = 0; i < in_len; i++) {
178 int j;
179 char hex_buf[3];
180 unsigned int non_ascii_byte;
181
182 if (in_str[i] != '\\') {
183 out_str[out_off] = in_str[i];
184 out_off++;
185 continue;
186 }
187
188 i++;
189 if (in_str[i] == '\\') {
190 out_str[out_off] = '\\';
191 out_off++;
192 continue;
193 } else if (in_str[i] != 'x') {
194 goto err_invalid_src_encoding;
195 }
196
197 /* non-ASCII, encoded as two hex chars */
198 for (j = 0; j < 2; j++) {
199 i++;
200 if ((in_str[i] == '\0') || !isxdigit(in_str[i])) {
201 goto err_invalid_src_encoding;
202 }
203 hex_buf[j] = in_str[i];
204 }
205 hex_buf[2] = '\0';
206
207 sscanf(hex_buf, "%x", &non_ascii_byte);
208 out_str[out_off] = (unsigned char)non_ascii_byte;
209 out_off++;
210 }
211
212 out_str[out_off] = '\0';
213 *_out_str = out_str;
214
215 return NT_STATUS_OK;
216 err_invalid_src_encoding:
217 DEBUG(0, ("invalid encoding %s\n", in_str));
218 return NT_STATUS_INVALID_PARAMETER;
219 }
220
221 static DBusConnection *snapper_dbus_conn_create(void)
222 {
223 DBusError err;
224 DBusConnection *dconn;
225
226 dbus_error_init(&err);
227
228 /*
229 * Always create a new DBus connection, to ensure snapperd detects the
230 * correct client [E]UID. With dbus_bus_get() it does not!
231 */
232 dconn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
233 if (dbus_error_is_set(&err)) {
234 DEBUG(0, ("dbus connection error: %s\n", err.message));
235 dbus_error_free(&err);
236 }
237 if (dconn == NULL) {
238 return NULL;
239 }
240
241 /* dbus_bus_get_private() sets exit-on-disconnect by default, undo it */
242 dbus_connection_set_exit_on_disconnect(dconn, false);
243
244 return dconn;
245 }
246
247 static void snapper_dbus_conn_destroy(DBusConnection *dconn)
248 {
249 if (dconn == NULL) {
250 DEBUG(2, ("attempt to destroy NULL dbus connection\n"));
251 return;
252 }
253
254 dbus_connection_close(dconn);
255 dbus_connection_unref(dconn);
256 }
257
258 /*
259 * send the message @send_msg over the dbus and wait for a response, return the
260 * responsee via @recv_msg_out.
261 * @send_msg is not freed, dbus_message_unref() must be handled by the caller.
262 */
263 static NTSTATUS snapper_dbus_msg_xchng(DBusConnection *dconn,
264 DBusMessage *send_msg,
265 DBusMessage **recv_msg_out)
266 {
267 DBusPendingCall *pending;
268 DBusMessage *recv_msg;
269
270 /* send message and get a handle for a reply */
271 if (!dbus_connection_send_with_reply(dconn, send_msg, &pending, -1)) {
272 return NT_STATUS_NO_MEMORY;
273 }
274 if (NULL == pending) {
275 DEBUG(0, ("dbus msg send failed\n"));
276 return NT_STATUS_UNSUCCESSFUL;
277 }
278
279 dbus_connection_flush(dconn);
280
281 /* block until we receive a reply */
282 dbus_pending_call_block(pending);
283
284 /* get the reply message */
285 recv_msg = dbus_pending_call_steal_reply(pending);
286 if (recv_msg == NULL) {
287 DEBUG(0, ("Reply Null\n"));
288 return NT_STATUS_UNSUCCESSFUL;
289 }
290 /* free the pending message handle */
291 dbus_pending_call_unref(pending);
292 *recv_msg_out = recv_msg;
293
294 return NT_STATUS_OK;
295 }
296
297 static NTSTATUS snapper_type_check(DBusMessageIter *iter,
298 int expected_type)
299 {
300 int type = dbus_message_iter_get_arg_type(iter);
301 if (type != expected_type) {
302 DEBUG(0, ("got type %d, expecting %d\n",
303 type, expected_type));
304 return NT_STATUS_INVALID_PARAMETER;
305 }
306
307 return NT_STATUS_OK;
308 }
309
310 static NTSTATUS snapper_type_check_get(DBusMessageIter *iter,
311 int expected_type,
312 void *val)
313 {
314 NTSTATUS status;
315 status = snapper_type_check(iter, expected_type);
316 if (!NT_STATUS_IS_OK(status)) {
317 return status;
318 }
319
320 dbus_message_iter_get_basic(iter, val);
321
322 return NT_STATUS_OK;
323 }
324
325 static NTSTATUS snapper_dict_unpack(TALLOC_CTX *mem_ctx,
326 DBusMessageIter *iter,
327 struct snapper_dict *dict_out)
328
329 {
330 NTSTATUS status;
331 DBusMessageIter dct_iter;
332 char *key_encoded;
333 char *val_encoded;
334
335 status = snapper_type_check(iter, DBUS_TYPE_DICT_ENTRY);
336 if (!NT_STATUS_IS_OK(status)) {
337 return status;
338 }
339 dbus_message_iter_recurse(iter, &dct_iter);
340
341 status = snapper_type_check_get(&dct_iter, DBUS_TYPE_STRING,
342 &key_encoded);
343 if (!NT_STATUS_IS_OK(status)) {
344 return status;
345 }
346 status = snapper_dbus_str_decode(mem_ctx, key_encoded, &dict_out->key);
347 if (!NT_STATUS_IS_OK(status)) {
348 return status;
349 }
350
351 dbus_message_iter_next(&dct_iter);
352 status = snapper_type_check_get(&dct_iter, DBUS_TYPE_STRING,
353 &val_encoded);
354 if (!NT_STATUS_IS_OK(status)) {
355 talloc_free(dict_out->key);
356 return status;
357 }
358 status = snapper_dbus_str_decode(mem_ctx, val_encoded, &dict_out->val);
359 if (!NT_STATUS_IS_OK(status)) {
360 talloc_free(dict_out->key);
361 return status;
362 }
363
364 return NT_STATUS_OK;
365 }
366
367 static void snapper_dict_array_print(uint32_t num_dicts,
368 struct snapper_dict *dicts)
369 {
370 int i;
371
372 for (i = 0; i < num_dicts; i++) {
373 DEBUG(10, ("dict (key: %s, val: %s)\n",
374 dicts[i].key, dicts[i].val));
375 }
376 }
377
378 static NTSTATUS snapper_dict_array_unpack(TALLOC_CTX *mem_ctx,
379 DBusMessageIter *iter,
380 uint32_t *num_dicts_out,
381 struct snapper_dict **dicts_out)
382 {
383 NTSTATUS status;
384 DBusMessageIter array_iter;
385 uint32_t num_dicts;
386 struct snapper_dict *dicts = NULL;
387
388 status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
389 if (!NT_STATUS_IS_OK(status)) {
390 return status;
391 }
392 dbus_message_iter_recurse(iter, &array_iter);
393
394 num_dicts = 0;
395 while (dbus_message_iter_get_arg_type(&array_iter)
396 != DBUS_TYPE_INVALID) {
397 num_dicts++;
398 dicts = talloc_realloc(mem_ctx, dicts, struct snapper_dict,
399 num_dicts);
400 if (dicts == NULL)
401 abort();
402
403 status = snapper_dict_unpack(mem_ctx, &array_iter,
404 &dicts[num_dicts - 1]);
405 if (!NT_STATUS_IS_OK(status)) {
406 talloc_free(dicts);
407 return status;
408 }
409 dbus_message_iter_next(&array_iter);
410 }
411
412 *num_dicts_out = num_dicts;
413 *dicts_out = dicts;
414
415 return NT_STATUS_OK;
416 }
417
418 static NTSTATUS snapper_list_confs_pack(DBusMessage **req_msg_out)
419 {
420 DBusMessage *msg;
421
422 msg = dbus_message_new_method_call("org.opensuse.Snapper",
423 "/org/opensuse/Snapper",
424 "org.opensuse.Snapper",
425 "ListConfigs");
426 if (msg == NULL) {
427 DEBUG(0, ("null msg\n"));
428 return NT_STATUS_NO_MEMORY;
429 }
430
431 /* no arguments to append */
432 *req_msg_out = msg;
433
434 return NT_STATUS_OK;
435 }
436
437 static NTSTATUS snapper_conf_unpack(TALLOC_CTX *mem_ctx,
438 DBusMessageIter *iter,
439 struct snapper_conf *conf_out)
440 {
441 NTSTATUS status;
442 DBusMessageIter st_iter;
443 char *name_encoded;
444 char *mnt_encoded;
445
446 status = snapper_type_check(iter, DBUS_TYPE_STRUCT);
447 if (!NT_STATUS_IS_OK(status)) {
448 return status;
449 }
450 dbus_message_iter_recurse(iter, &st_iter);
451
452 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
453 &name_encoded);
454 if (!NT_STATUS_IS_OK(status)) {
455 return status;
456 }
457
458 status = snapper_dbus_str_decode(mem_ctx, name_encoded,
459 &conf_out->name);
460 if (!NT_STATUS_IS_OK(status)) {
461 return status;
462 }
463
464 dbus_message_iter_next(&st_iter);
465 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
466 &mnt_encoded);
467 if (!NT_STATUS_IS_OK(status)) {
468 talloc_free(conf_out->name);
469 return status;
470 }
471
472 status = snapper_dbus_str_decode(mem_ctx, mnt_encoded,
473 &conf_out->mnt);
474 if (!NT_STATUS_IS_OK(status)) {
475 talloc_free(conf_out->name);
476 return status;
477 }
478
479 dbus_message_iter_next(&st_iter);
480 status = snapper_dict_array_unpack(mem_ctx, &st_iter,
481 &conf_out->num_attrs,
482 &conf_out->attrs);
483 if (!NT_STATUS_IS_OK(status)) {
484 talloc_free(conf_out->mnt);
485 talloc_free(conf_out->name);
486 return status;
487 }
488
489 return NT_STATUS_OK;
490 }
491
492 static struct snapper_conf *snapper_conf_array_base_find(int32_t num_confs,
493 struct snapper_conf *confs,
494 const char *base)
495 {
496 int i;
497
498 for (i = 0; i < num_confs; i++) {
499 if (strcmp(confs[i].mnt, base) == 0) {
500 DEBUG(5, ("found snapper conf %s for path %s\n",
501 confs[i].name, base));
502 return &confs[i];
503 }
504 }
505 DEBUG(5, ("config for base %s not found\n", base));
506
507 return NULL;
508 }
509
510 static void snapper_conf_array_print(int32_t num_confs,
511 struct snapper_conf *confs)
512 {
513 int i;
514
515 for (i = 0; i < num_confs; i++) {
516 DEBUG(10, ("name: %s, mnt: %s\n",
517 confs[i].name, confs[i].mnt));
518 snapper_dict_array_print(confs[i].num_attrs, confs[i].attrs);
519 }
520 }
521
522 static NTSTATUS snapper_conf_array_unpack(TALLOC_CTX *mem_ctx,
523 DBusMessageIter *iter,
524 uint32_t *num_confs_out,
525 struct snapper_conf **confs_out)
526 {
527 uint32_t num_confs;
528 NTSTATUS status;
529 struct snapper_conf *confs = NULL;
530 DBusMessageIter array_iter;
531
532
533 status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
534 if (!NT_STATUS_IS_OK(status)) {
535 return status;
536 }
537 dbus_message_iter_recurse(iter, &array_iter);
538
539 num_confs = 0;
540 while (dbus_message_iter_get_arg_type(&array_iter)
541 != DBUS_TYPE_INVALID) {
542 num_confs++;
543 confs = talloc_realloc(mem_ctx, confs, struct snapper_conf,
544 num_confs);
545 if (confs == NULL)
546 abort();
547
548 status = snapper_conf_unpack(confs, &array_iter,
549 &confs[num_confs - 1]);
550 if (!NT_STATUS_IS_OK(status)) {
551 talloc_free(confs);
552 return status;
553 }
554 dbus_message_iter_next(&array_iter);
555 }
556
557 *num_confs_out = num_confs;
558 *confs_out = confs;
559
560 return NT_STATUS_OK;
561 }
562
563 static NTSTATUS snapper_list_confs_unpack(TALLOC_CTX *mem_ctx,
564 DBusConnection *dconn,
565 DBusMessage *rsp_msg,
566 uint32_t *num_confs_out,
567 struct snapper_conf **confs_out)
568 {
569 NTSTATUS status;
570 DBusMessageIter iter;
571 int msg_type;
572 uint32_t num_confs;
573 struct snapper_conf *confs;
574 const char *sig;
575
576 msg_type = dbus_message_get_type(rsp_msg);
577 if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
578 const char *err_str = dbus_message_get_error_name(rsp_msg);
579 DEBUG(0, ("list_confs error response: %s\n", err_str));
580 return snapper_err_ntstatus_map(err_str);
581 }
582
583 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
584 DEBUG(0, ("unexpected list_confs ret type: %d\n",
585 msg_type));
586 return NT_STATUS_INVALID_PARAMETER;
587 }
588
589 sig = dbus_message_get_signature(rsp_msg);
590 if ((sig == NULL)
591 || (strcmp(sig, SNAPPER_SIG_LIST_CONFS_RSP) != 0)) {
592 DEBUG(0, ("bad list confs response sig: %s, expected: %s\n",
593 (sig ? sig : "NULL"), SNAPPER_SIG_LIST_CONFS_RSP));
594 return NT_STATUS_INVALID_PARAMETER;
595 }
596
597 if (!dbus_message_iter_init(rsp_msg, &iter)) {
598 /* FIXME return empty? */
599 DEBUG(0, ("Message has no arguments!\n"));
600 return NT_STATUS_INVALID_PARAMETER;
601 }
602
603 status = snapper_conf_array_unpack(mem_ctx, &iter, &num_confs, &confs);
604 if (!NT_STATUS_IS_OK(status)) {
605 DEBUG(0, ("failed to unpack conf array\n"));
606 return status;
607 }
608
609 snapper_conf_array_print(num_confs, confs);
610
611 *num_confs_out = num_confs;
612 *confs_out = confs;
613
614 return NT_STATUS_OK;
615 }
616
617 static NTSTATUS snapper_list_snaps_pack(TALLOC_CTX *mem_ctx,
618 char *snapper_conf,
619 DBusMessage **req_msg_out)
620 {
621 DBusMessage *msg;
622 DBusMessageIter args;
623 char *conf_encoded;
624 NTSTATUS status;
625
626 msg = dbus_message_new_method_call("org.opensuse.Snapper", /* target for the method call */
627 "/org/opensuse/Snapper", /* object to call on */
628 "org.opensuse.Snapper", /* interface to call on */
629 "ListSnapshots"); /* method name */
630 if (msg == NULL) {
631 DEBUG(0, ("failed to create list snaps message\n"));
632 return NT_STATUS_NO_MEMORY;
633 }
634
635 status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
636 if (!NT_STATUS_IS_OK(status)) {
637 dbus_message_unref(msg);
638 return status;
639 }
640
641 /* append arguments */
642 dbus_message_iter_init_append(msg, &args);
643 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
644 &conf_encoded)) {
645 talloc_free(conf_encoded);
646 dbus_message_unref(msg);
647 return NT_STATUS_NO_MEMORY;
648 }
649
650 *req_msg_out = msg;
651
652 return NT_STATUS_OK;
653 }
654
655 static NTSTATUS snapper_snap_struct_unpack(TALLOC_CTX *mem_ctx,
656 DBusMessageIter *iter,
657 struct snapper_snap *snap_out)
658 {
659 NTSTATUS status;
660 DBusMessageIter st_iter;
661 char *desc_encoded;
662 char *cleanup_encoded;
663
664 status = snapper_type_check(iter, DBUS_TYPE_STRUCT);
665 if (!NT_STATUS_IS_OK(status)) {
666 return status;
667 }
668 dbus_message_iter_recurse(iter, &st_iter);
669
670 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
671 &snap_out->id);
672 if (!NT_STATUS_IS_OK(status)) {
673 return status;
674 }
675
676 dbus_message_iter_next(&st_iter);
677 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT16,
678 &snap_out->type);
679 if (!NT_STATUS_IS_OK(status)) {
680 return status;
681 }
682
683 dbus_message_iter_next(&st_iter);
684 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
685 &snap_out->pre_id);
686 if (!NT_STATUS_IS_OK(status)) {
687 return status;
688 }
689
690 dbus_message_iter_next(&st_iter);
691 status = snapper_type_check_get(&st_iter, DBUS_TYPE_INT64,
692 &snap_out->time);
693 if (!NT_STATUS_IS_OK(status)) {
694 return status;
695 }
696
697 dbus_message_iter_next(&st_iter);
698 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
699 &snap_out->creator_uid);
700 if (!NT_STATUS_IS_OK(status)) {
701 return status;
702 }
703
704 dbus_message_iter_next(&st_iter);
705 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
706 &desc_encoded);
707 if (!NT_STATUS_IS_OK(status)) {
708 return status;
709 }
710
711 status = snapper_dbus_str_decode(mem_ctx, desc_encoded,
712 &snap_out->desc);
713 if (!NT_STATUS_IS_OK(status)) {
714 return status;
715 }
716
717 dbus_message_iter_next(&st_iter);
718 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
719 &cleanup_encoded);
720 if (!NT_STATUS_IS_OK(status)) {
721 talloc_free(snap_out->desc);
722 return status;
723 }
724
725 status = snapper_dbus_str_decode(mem_ctx, cleanup_encoded,
726 &snap_out->cleanup);
727 if (!NT_STATUS_IS_OK(status)) {
728 talloc_free(snap_out->desc);
729 return status;
730 }
731
732 dbus_message_iter_next(&st_iter);
733 status = snapper_dict_array_unpack(mem_ctx, &st_iter,
734 &snap_out->num_user_data,
735 &snap_out->user_data);
736 if (!NT_STATUS_IS_OK(status)) {
737 talloc_free(snap_out->cleanup);
738 talloc_free(snap_out->desc);
739 return status;
740 }
741
742 return NT_STATUS_OK;
743 }
744
745 static void snapper_snap_array_print(int32_t num_snaps,
746 struct snapper_snap *snaps)
747 {
748 int i;
749
750 for (i = 0; i < num_snaps; i++) {
751 DEBUG(10, ("id: %u, "
752 "type: %u, "
753 "pre_id: %u, "
754 "time: %ld, "
755 "creator_uid: %u, "
756 "desc: %s, "
757 "cleanup: %s\n",
758 (unsigned int)snaps[i].id,
759 (unsigned int)snaps[i].type,
760 (unsigned int)snaps[i].pre_id,
761 (long int)snaps[i].time,
762 (unsigned int)snaps[i].creator_uid,
763 snaps[i].desc,
764 snaps[i].cleanup));
765 snapper_dict_array_print(snaps[i].num_user_data,
766 snaps[i].user_data);
767 }
768 }
769
770 static NTSTATUS snapper_snap_array_unpack(TALLOC_CTX *mem_ctx,
771 DBusMessageIter *iter,
772 uint32_t *num_snaps_out,
773 struct snapper_snap **snaps_out)
774 {
775 uint32_t num_snaps;
776 NTSTATUS status;
777 struct snapper_snap *snaps = NULL;
778 DBusMessageIter array_iter;
779
780
781 status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
782 if (!NT_STATUS_IS_OK(status)) {
783 return status;
784 }
785 dbus_message_iter_recurse(iter, &array_iter);
786
787 num_snaps = 0;
788 while (dbus_message_iter_get_arg_type(&array_iter)
789 != DBUS_TYPE_INVALID) {
790 num_snaps++;
791 snaps = talloc_realloc(mem_ctx, snaps, struct snapper_snap,
792 num_snaps);
793 if (snaps == NULL)
794 abort();
795
796 status = snapper_snap_struct_unpack(snaps, &array_iter,
797 &snaps[num_snaps - 1]);
798 if (!NT_STATUS_IS_OK(status)) {
799 talloc_free(snaps);
800 return status;
801 }
802 dbus_message_iter_next(&array_iter);
803 }
804
805 *num_snaps_out = num_snaps;
806 *snaps_out = snaps;
807
808 return NT_STATUS_OK;
809 }
810
811 static NTSTATUS snapper_list_snaps_unpack(TALLOC_CTX *mem_ctx,
812 DBusMessage *rsp_msg,
813 uint32_t *num_snaps_out,
814 struct snapper_snap **snaps_out)
815 {
816 NTSTATUS status;
817 DBusMessageIter iter;
818 int msg_type;
819 uint32_t num_snaps;
820 struct snapper_snap *snaps;
821 const char *sig;
822
823 msg_type = dbus_message_get_type(rsp_msg);
824 if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
825 const char *err_str = dbus_message_get_error_name(rsp_msg);
826 DEBUG(0, ("list_snaps error response: %s\n", err_str));
827 return snapper_err_ntstatus_map(err_str);
828 }
829
830 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
831 DEBUG(0,("unexpected list_snaps ret type: %d\n",
832 msg_type));
833 return NT_STATUS_INVALID_PARAMETER;
834 }
835
836 sig = dbus_message_get_signature(rsp_msg);
837 if ((sig == NULL)
838 || (strcmp(sig, SNAPPER_SIG_LIST_SNAPS_RSP) != 0)) {
839 DEBUG(0, ("bad list snaps response sig: %s, "
840 "expected: %s\n",
841 (sig ? sig : "NULL"),
842 SNAPPER_SIG_LIST_SNAPS_RSP));
843 return NT_STATUS_INVALID_PARAMETER;
844 }
845
846 /* read the parameters */
847 if (!dbus_message_iter_init(rsp_msg, &iter)) {
848 DEBUG(0, ("response has no arguments!\n"));
849 return NT_STATUS_INVALID_PARAMETER;
850 }
851
852 status = snapper_snap_array_unpack(mem_ctx, &iter, &num_snaps, &snaps);
853 if (!NT_STATUS_IS_OK(status)) {
854 DEBUG(0, ("failed to unpack snap array\n"));
855 return NT_STATUS_INVALID_PARAMETER;
856 }
857
858 snapper_snap_array_print(num_snaps, snaps);
859
860 *num_snaps_out = num_snaps;
861 *snaps_out = snaps;
862
863 return NT_STATUS_OK;
864 }
865
866 static NTSTATUS snapper_create_snap_pack(TALLOC_CTX *mem_ctx,
867 const char *snapper_conf,
868 const char *desc,
869 uint32_t num_user_data,
870 struct snapper_dict *user_data,
871 DBusMessage **req_msg_out)
872 {
873 DBusMessage *msg;
874 DBusMessageIter args;
875 DBusMessageIter array_iter;
876 DBusMessageIter struct_iter;
877 const char *empty = "";
878 char *str_encoded;
879 uint32_t i;
880 bool ok;
881 TALLOC_CTX *enc_ctx;
882 NTSTATUS status;
883
884 DEBUG(10, ("CreateSingleSnapshot: %s, %s, %s, num user %u\n",
885 snapper_conf, desc, empty, num_user_data));
886
887 enc_ctx = talloc_new(mem_ctx);
888 if (enc_ctx == NULL) {
889 return NT_STATUS_NO_MEMORY;
890 }
891
892 msg = dbus_message_new_method_call("org.opensuse.Snapper",
893 "/org/opensuse/Snapper",
894 "org.opensuse.Snapper",
895 "CreateSingleSnapshot");
896 if (msg == NULL) {
897 DEBUG(0, ("failed to create req msg\n"));
898 talloc_free(enc_ctx);
899 return NT_STATUS_NO_MEMORY;
900 }
901
902 status = snapper_dbus_str_encode(enc_ctx, snapper_conf, &str_encoded);
903 if (!NT_STATUS_IS_OK(status)) {
904 dbus_message_unref(msg);
905 talloc_free(enc_ctx);
906 return status;
907 }
908
909 /* append arguments */
910 dbus_message_iter_init_append(msg, &args);
911 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
912 &str_encoded);
913 if (!ok) {
914 dbus_message_unref(msg);
915 talloc_free(enc_ctx);
916 return NT_STATUS_NO_MEMORY;
917 }
918
919 status = snapper_dbus_str_encode(enc_ctx, desc, &str_encoded);
920 if (!NT_STATUS_IS_OK(status)) {
921 dbus_message_unref(msg);
922 talloc_free(enc_ctx);
923 return status;
924 }
925
926 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
927 &str_encoded);
928 if (!ok) {
929 dbus_message_unref(msg);
930 talloc_free(enc_ctx);
931 return NT_STATUS_NO_MEMORY;
932 }
933
934 /* cleanup - no need to encode empty string */
935 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
936 &empty);
937 if (!ok) {
938 dbus_message_unref(msg);
939 talloc_free(enc_ctx);
940 return NT_STATUS_NO_MEMORY;
941 }
942
943 ok = dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
944 SNAPPER_SIG_STRING_DICT,
945 &array_iter);
946 if (!ok) {
947 dbus_message_unref(msg);
948 talloc_free(enc_ctx);
949 return NT_STATUS_NO_MEMORY;
950 }
951
952 for (i = 0; i < num_user_data; i++) {
953 ok = dbus_message_iter_open_container(&array_iter,
954 DBUS_TYPE_DICT_ENTRY,
955 NULL, &struct_iter);
956 if (!ok) {
957 dbus_message_unref(msg);
958 talloc_free(enc_ctx);
959 return NT_STATUS_NO_MEMORY;
960 }
961
962 status = snapper_dbus_str_encode(enc_ctx, user_data[i].key,
963 &str_encoded);
964 if (!NT_STATUS_IS_OK(status)) {
965 dbus_message_unref(msg);
966 talloc_free(enc_ctx);
967 return status;
968 }
969
970 ok = dbus_message_iter_append_basic(&struct_iter,
971 DBUS_TYPE_STRING,
972 &str_encoded);
973 if (!ok) {
974 dbus_message_unref(msg);
975 talloc_free(enc_ctx);
976 return NT_STATUS_NO_MEMORY;
977 }
978
979 status = snapper_dbus_str_encode(enc_ctx, user_data[i].val,
980 &str_encoded);
981 if (!NT_STATUS_IS_OK(status)) {
982 dbus_message_unref(msg);
983 talloc_free(enc_ctx);
984 return status;
985 }
986
987 ok = dbus_message_iter_append_basic(&struct_iter,
988 DBUS_TYPE_STRING,
989 &str_encoded);
990 if (!ok) {
991 dbus_message_unref(msg);
992 talloc_free(enc_ctx);
993 return NT_STATUS_NO_MEMORY;
994 }
995
996 ok = dbus_message_iter_close_container(&array_iter, &struct_iter);
997 if (!ok) {
998 dbus_message_unref(msg);
999 talloc_free(enc_ctx);
1000 return NT_STATUS_NO_MEMORY;
1001 }
1002 }
1003
1004 ok = dbus_message_iter_close_container(&args, &array_iter);
1005 if (!ok) {
1006 dbus_message_unref(msg);
1007 talloc_free(enc_ctx);
1008 return NT_STATUS_NO_MEMORY;
1009 }
1010
1011 *req_msg_out = msg;
1012
1013 return NT_STATUS_OK;
1014 }
1015
1016 static NTSTATUS snapper_create_snap_unpack(DBusConnection *conn,
1017 DBusMessage *rsp_msg,
1018 uint32_t *snap_id_out)
1019 {
1020 NTSTATUS status;
1021 DBusMessageIter iter;
1022 int msg_type;
1023 const char *sig;
1024 uint32_t snap_id;
1025
1026 msg_type = dbus_message_get_type(rsp_msg);
1027 if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
1028 const char *err_str = dbus_message_get_error_name(rsp_msg);
1029 DEBUG(0, ("create snap error response: %s, euid %d egid %d\n",
1030 err_str, geteuid(), getegid()));
1031 return snapper_err_ntstatus_map(err_str);
1032 }
1033
1034 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
1035 DEBUG(0, ("unexpected create snap ret type: %d\n",
1036 msg_type));
1037 return NT_STATUS_INVALID_PARAMETER;
1038 }
1039
1040 sig = dbus_message_get_signature(rsp_msg);
1041 if ((sig == NULL)
1042 || (strcmp(sig, SNAPPER_SIG_CREATE_SNAP_RSP) != 0)) {
1043 DEBUG(0, ("bad create snap response sig: %s, expected: %s\n",
1044 (sig ? sig : "NULL"), SNAPPER_SIG_CREATE_SNAP_RSP));
1045 return NT_STATUS_INVALID_PARAMETER;
1046 }
1047
1048 /* read the parameters */
1049 if (!dbus_message_iter_init(rsp_msg, &iter)) {
1050 DEBUG(0, ("response has no arguments!\n"));
1051 return NT_STATUS_INVALID_PARAMETER;
1052 }
1053
1054 status = snapper_type_check_get(&iter, DBUS_TYPE_UINT32, &snap_id);
1055 if (!NT_STATUS_IS_OK(status)) {
1056 return status;
1057 }
1058 *snap_id_out = snap_id;
1059
1060 return NT_STATUS_OK;
1061 }
1062
1063 static NTSTATUS snapper_del_snap_pack(TALLOC_CTX *mem_ctx,
1064 const char *snapper_conf,
1065 uint32_t snap_id,
1066 DBusMessage **req_msg_out)
1067 {
1068 DBusMessage *msg;
1069 DBusMessageIter args;
1070 DBusMessageIter array_iter;
1071 char *conf_encoded;
1072 bool ok;
1073 NTSTATUS status;
1074
1075 msg = dbus_message_new_method_call("org.opensuse.Snapper",
1076 "/org/opensuse/Snapper",
1077 "org.opensuse.Snapper",
1078 "DeleteSnapshots");
1079 if (msg == NULL) {
1080 DEBUG(0, ("failed to create req msg\n"));
1081 return NT_STATUS_NO_MEMORY;
1082 }
1083
1084 status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
1085 if (!NT_STATUS_IS_OK(status)) {
1086 dbus_message_unref(msg);
1087 return status;
1088 }
1089
1090 /* append arguments */
1091 dbus_message_iter_init_append(msg, &args);
1092 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
1093 &conf_encoded);
1094 if (!ok) {
1095 talloc_free(conf_encoded);
1096 dbus_message_unref(msg);
1097 return NT_STATUS_NO_MEMORY;
1098 }
1099
1100 ok = dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
1101 DBUS_TYPE_UINT32_AS_STRING,
1102 &array_iter);
1103 if (!ok) {
1104 talloc_free(conf_encoded);
1105 dbus_message_unref(msg);
1106 return NT_STATUS_NO_MEMORY;
1107 }
1108
1109 ok = dbus_message_iter_append_basic(&array_iter,
1110 DBUS_TYPE_UINT32,
1111 &snap_id);
1112 if (!ok) {
1113 talloc_free(conf_encoded);
1114 dbus_message_unref(msg);
1115 return NT_STATUS_NO_MEMORY;
1116 }
1117
1118 dbus_message_iter_close_container(&args, &array_iter);
1119 *req_msg_out = msg;
1120
1121 return NT_STATUS_OK;
1122 }
1123
1124 static NTSTATUS snapper_del_snap_unpack(DBusConnection *conn,
1125 DBusMessage *rsp_msg)
1126 {
1127 int msg_type;
1128 const char *sig;
1129
1130 msg_type = dbus_message_get_type(rsp_msg);
1131 if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
1132 const char *err_str = dbus_message_get_error_name(rsp_msg);
1133 DEBUG(0, ("del snap error response: %s\n", err_str));
1134 return snapper_err_ntstatus_map(err_str);
1135 }
1136
1137 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
1138 DEBUG(0, ("unexpected del snap ret type: %d\n",
1139 msg_type));
1140 return NT_STATUS_INVALID_PARAMETER;
1141 }
1142
1143 sig = dbus_message_get_signature(rsp_msg);
1144 if ((sig == NULL)
1145 || (strcmp(sig, SNAPPER_SIG_DEL_SNAPS_RSP) != 0)) {
1146 DEBUG(0, ("bad create snap response sig: %s, expected: %s\n",
1147 (sig ? sig : "NULL"), SNAPPER_SIG_DEL_SNAPS_RSP));
1148 return NT_STATUS_INVALID_PARAMETER;
1149 }
1150
1151 /* no parameters in response */
1152
1153 return NT_STATUS_OK;
1154 }
1155
1156 static NTSTATUS snapper_list_snaps_at_time_pack(TALLOC_CTX *mem_ctx,
1157 const char *snapper_conf,
1158 time_t time_lower,
1159 time_t time_upper,
1160 DBusMessage **req_msg_out)
1161 {
1162 DBusMessage *msg;
1163 DBusMessageIter args;
1164 char *conf_encoded;
1165 NTSTATUS status;
1166
1167 msg = dbus_message_new_method_call("org.opensuse.Snapper",
1168 "/org/opensuse/Snapper",
1169 "org.opensuse.Snapper",
1170 "ListSnapshotsAtTime");
1171 if (msg == NULL) {
1172 DEBUG(0, ("failed to create list snaps message\n"));
1173 return NT_STATUS_NO_MEMORY;
1174 }
1175
1176 status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
1177 if (!NT_STATUS_IS_OK(status)) {
1178 dbus_message_unref(msg);
1179 return status;
1180 }
1181
1182 dbus_message_iter_init_append(msg, &args);
1183 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
1184 &conf_encoded)) {
1185 talloc_free(conf_encoded);
1186 dbus_message_unref(msg);
1187 return NT_STATUS_NO_MEMORY;
1188 }
1189
1190 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT64,
1191 &time_lower)) {
1192 talloc_free(conf_encoded);
1193 dbus_message_unref(msg);
1194 return NT_STATUS_NO_MEMORY;
1195 }
1196
1197 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT64,
1198 &time_upper)) {
1199 talloc_free(conf_encoded);
1200 dbus_message_unref(msg);
1201 return NT_STATUS_NO_MEMORY;
1202 }
1203
1204 *req_msg_out = msg;
1205
1206 return NT_STATUS_OK;
1207 }
1208 /* no snapper_list_snaps_at_time_unpack, use snapper_list_snaps_unpack */
1209
1210 /*
1211 * Determine the snapper snapshot id given a path.
1212 * Ideally this should be determined via a lookup.
1213 */
1214 static NTSTATUS snapper_snap_path_to_id(TALLOC_CTX *mem_ctx,
1215 const char *snap_path,
1216 uint32_t *snap_id_out)
1217 {
1218 char *path_dup;
1219 char *str_idx;
1220 uint32_t snap_id;
1221 int error = 0;
1222
1223 path_dup = talloc_strdup(mem_ctx, snap_path);
1224 if (path_dup == NULL) {
1225 return NT_STATUS_NO_MEMORY;
1226 }
1227
1228 /* trim trailing '/' */
1229 str_idx = path_dup + strlen(path_dup) - 1;
1230 while (*str_idx == '/') {
1231 *str_idx = '\0';
1232 str_idx--;
1233 }
1234
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;
1240 }
1241
1242 while (*str_idx == '/') {
1243 *str_idx = '\0';
1244 str_idx--;
1245 }
1246
1247 str_idx = strrchr(path_dup, '/');
1248 if (str_idx == NULL) {
1249 talloc_free(path_dup);
1250 return NT_STATUS_INVALID_PARAMETER;
1251 }
1252
1253 str_idx++;
1254 snap_id = smb_strtoul(str_idx, NULL, 10, &error, SMB_STR_STANDARD);
1255 if (error != 0) {
1256 talloc_free(path_dup);
1257 return NT_STATUS_INVALID_PARAMETER;
1258 }
1259
1260 talloc_free(path_dup);
1261 *snap_id_out = snap_id;
1262 return NT_STATUS_OK;
1263 }
1264
1265 /*
1266 * Determine the snapper snapshot path given an id and base.
1267 * Ideally this should be determined via a lookup.
1268 */
1269 static NTSTATUS snapper_snap_id_to_path(TALLOC_CTX *mem_ctx,
1270 const char *base_path,
1271 uint32_t snap_id,
1272 char **snap_path_out)
1273 {
1274 char *snap_path;
1275
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;
1280 }
1281
1282 *snap_path_out = snap_path;
1283 return NT_STATUS_OK;
1284 }
1285
1286 static NTSTATUS snapper_get_conf_call(TALLOC_CTX *mem_ctx,
1287 DBusConnection *dconn,
1288 const char *path,
1289 char **conf_name_out,
1290 char **base_path_out)
1291 {
1292 NTSTATUS status;
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;
1298 char *conf_name;
1299 char *base_path;
1300
1301 status = snapper_list_confs_pack(&req_msg);
1302 if (!NT_STATUS_IS_OK(status)) {
1303 goto err_out;
1304 }
1305
1306 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1307 if (!NT_STATUS_IS_OK(status)) {
1308 goto err_req_free;
1309 }
1310
1311 status = snapper_list_confs_unpack(mem_ctx, dconn, rsp_msg,
1312 &num_confs, &confs);
1313 if (!NT_STATUS_IS_OK(status)) {
1314 goto err_rsp_free;
1315 }
1316
1317 /*
1318 * for now we only support shares where the path directly corresponds
1319 * to a snapper configuration.
1320 */
1321 conf = snapper_conf_array_base_find(num_confs, confs,
1322 path);
1323 if (conf == NULL) {
1324 status = NT_STATUS_NOT_SUPPORTED;
1325 goto err_array_free;
1326 }
1327
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;
1332 }
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;
1337 }
1338
1339 talloc_free(confs);
1340 dbus_message_unref(rsp_msg);
1341 dbus_message_unref(req_msg);
1342
1343 *conf_name_out = conf_name;
1344 *base_path_out = base_path;
1345
1346 return NT_STATUS_OK;
1347
1348 err_conf_name_free:
1349 talloc_free(conf_name);
1350 err_array_free:
1351 talloc_free(confs);
1352 err_rsp_free:
1353 dbus_message_unref(rsp_msg);
1354 err_req_free:
1355 dbus_message_unref(req_msg);
1356 err_out:
1357 return status;
1358 }
1359
1360 /*
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.
1363 */
1364 static NTSTATUS snapper_snap_check_path(struct vfs_handle_struct *handle,
1365 TALLOC_CTX *mem_ctx,
1366 const char *service_path,
1367 char **base_volume)
1368 {
1369 NTSTATUS status;
1370 DBusConnection *dconn;
1371 char *conf_name;
1372 char *base_path;
1373
1374 dconn = snapper_dbus_conn_create();
1375 if (dconn == NULL) {
1376 return NT_STATUS_UNSUCCESSFUL;
1377 }
1378
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;
1383 }
1384
1385 talloc_free(conf_name);
1386 *base_volume = base_path;
1387 snapper_dbus_conn_destroy(dconn);
1388
1389 return NT_STATUS_OK;
1390
1391 err_conn_close:
1392 snapper_dbus_conn_destroy(dconn);
1393 return status;
1394 }
1395
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)
1404 {
1405 NTSTATUS status;
1406 DBusMessage *req_msg;
1407 DBusMessage *rsp_msg;
1408 uint32_t snap_id = 0;
1409 char *snap_path;
1410
1411 status = snapper_create_snap_pack(mem_ctx,
1412 conf_name,
1413 snap_desc,
1414 num_user_data,
1415 user_data,
1416 &req_msg);
1417 if (!NT_STATUS_IS_OK(status)) {
1418 goto err_out;
1419 }
1420
1421 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1422 if (!NT_STATUS_IS_OK(status)) {
1423 goto err_req_free;
1424 }
1425
1426 status = snapper_create_snap_unpack(dconn, rsp_msg, &snap_id);
1427 if (!NT_STATUS_IS_OK(status)) {
1428 goto err_rsp_free;
1429 }
1430
1431 status = snapper_snap_id_to_path(mem_ctx, base_path, snap_id,
1432 &snap_path);
1433 if (!NT_STATUS_IS_OK(status)) {
1434 goto err_rsp_free;
1435 }
1436
1437 dbus_message_unref(rsp_msg);
1438 dbus_message_unref(req_msg);
1439
1440 DEBUG(6, ("created new snapshot %u at %s\n", snap_id, snap_path));
1441 *snap_path_out = snap_path;
1442
1443 return NT_STATUS_OK;
1444
1445 err_rsp_free:
1446 dbus_message_unref(rsp_msg);
1447 err_req_free:
1448 dbus_message_unref(req_msg);
1449 err_out:
1450 return status;
1451 }
1452
1453 static NTSTATUS snapper_snap_create(struct vfs_handle_struct *handle,
1454 TALLOC_CTX *mem_ctx,
1455 const char *base_volume,
1456 time_t *tstamp,
1457 bool rw,
1458 char **_base_path,
1459 char **_snap_path)
1460 {
1461 DBusConnection *dconn;
1462 NTSTATUS status;
1463 char *conf_name;
1464 char *base_path;
1465 char *snap_path = NULL;
1466 TALLOC_CTX *tmp_ctx;
1467
1468 tmp_ctx = talloc_new(mem_ctx);
1469 if (tmp_ctx == NULL) {
1470 return NT_STATUS_NO_MEMORY;
1471 }
1472
1473 dconn = snapper_dbus_conn_create();
1474 if (dconn == NULL) {
1475 talloc_free(tmp_ctx);
1476 return NT_STATUS_UNSUCCESSFUL;
1477 }
1478
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);
1484 return status;
1485 }
1486
1487 status = snapper_create_snap_call(tmp_ctx, dconn,
1488 conf_name, base_path,
1489 "Snapshot created by Samba",
1490 0, NULL,
1491 &snap_path);
1492 if (!NT_STATUS_IS_OK(status)) {
1493 snapper_dbus_conn_destroy(dconn);
1494 talloc_free(tmp_ctx);
1495 return status;
1496 }
1497
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);
1502
1503 return NT_STATUS_OK;
1504 }
1505
1506 static NTSTATUS snapper_delete_snap_call(TALLOC_CTX *mem_ctx,
1507 DBusConnection *dconn,
1508 const char *conf_name,
1509 uint32_t snap_id)
1510 {
1511 NTSTATUS status;
1512 DBusMessage *req_msg = NULL;
1513 DBusMessage *rsp_msg;
1514
1515 status = snapper_del_snap_pack(mem_ctx, conf_name, snap_id, &req_msg);
1516 if (!NT_STATUS_IS_OK(status)) {
1517 goto err_out;
1518 }
1519
1520 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1521 if (!NT_STATUS_IS_OK(status)) {
1522 goto err_req_free;
1523 }
1524
1525 status = snapper_del_snap_unpack(dconn, rsp_msg);
1526 if (!NT_STATUS_IS_OK(status)) {
1527 goto err_rsp_free;
1528 }
1529
1530 dbus_message_unref(rsp_msg);
1531 dbus_message_unref(req_msg);
1532
1533 DEBUG(6, ("deleted snapshot %u\n", snap_id));
1534
1535 return NT_STATUS_OK;
1536
1537 err_rsp_free:
1538 dbus_message_unref(rsp_msg);
1539 err_req_free:
1540 dbus_message_unref(req_msg);
1541 err_out:
1542 return status;
1543 }
1544
1545 static NTSTATUS snapper_snap_delete(struct vfs_handle_struct *handle,
1546 TALLOC_CTX *mem_ctx,
1547 char *base_path,
1548 char *snap_path)
1549 {
1550 DBusConnection *dconn;
1551 NTSTATUS status;
1552 char *conf_name;
1553 char *snap_base_path;
1554 uint32_t snap_id;
1555 TALLOC_CTX *tmp_ctx;
1556
1557 tmp_ctx = talloc_new(mem_ctx);
1558 if (tmp_ctx == NULL) {
1559 return NT_STATUS_NO_MEMORY;
1560 }
1561
1562 dconn = snapper_dbus_conn_create();
1563 if (dconn == NULL) {
1564 talloc_free(tmp_ctx);
1565 return NT_STATUS_UNSUCCESSFUL;
1566 }
1567
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);
1573 return status;
1574 }
1575
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);
1580 return status;
1581 }
1582
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);
1587 return status;
1588 }
1589
1590 snapper_dbus_conn_destroy(dconn);
1591 talloc_free(tmp_ctx);
1592
1593 return NT_STATUS_OK;
1594 }
1595
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,
1600 bool labels)
1601 {
1602 DBusConnection *dconn;
1603 TALLOC_CTX *tmp_ctx;
1604 NTSTATUS status;
1605 char *conf_name;
1606 char *base_path;
1607 DBusMessage *req_msg = NULL;
1608 DBusMessage *rsp_msg;
1609 uint32_t num_snaps;
1610 struct snapper_snap *snaps;
1611 uint32_t i;
1612 uint32_t lbl_off;
1613
1614 tmp_ctx = talloc_new(sc_data);
1615 if (tmp_ctx == NULL) {
1616 status = NT_STATUS_NO_MEMORY;
1617 goto err_out;
1618 }
1619
1620 dconn = snapper_dbus_conn_create();
1621 if (dconn == NULL) {
1622 status = NT_STATUS_UNSUCCESSFUL;
1623 goto err_mem_ctx_free;
1624 }
1625
1626 if (fsp->conn->connectpath == NULL) {
1627 status = NT_STATUS_INVALID_PARAMETER;
1628 goto err_conn_free;
1629 }
1630
1631 status = snapper_get_conf_call(tmp_ctx, dconn,
1632 fsp->conn->connectpath,
1633 &conf_name,
1634 &base_path);
1635 if (!NT_STATUS_IS_OK(status)) {
1636 goto err_conn_free;
1637 }
1638
1639 status = snapper_list_snaps_pack(tmp_ctx, conf_name, &req_msg);
1640 if (!NT_STATUS_IS_OK(status)) {
1641 goto err_conn_free;
1642 }
1643
1644 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1645 if (!NT_STATUS_IS_OK(status)) {
1646 goto err_req_free;
1647 }
1648
1649 status = snapper_list_snaps_unpack(tmp_ctx, rsp_msg,
1650 &num_snaps, &snaps);
1651 if (!NT_STATUS_IS_OK(status)) {
1652 goto err_rsp_free;
1653 }
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;
1658 goto err_rsp_free;
1659 }
1660
1661 /* subtract 1, (current) snapshot is not returned */
1662 sc_data->num_volumes = num_snaps - 1;
1663 sc_data->labels = NULL;
1664
1665 if ((labels == false) || (sc_data->num_volumes == 0)) {
1666 /* tokens need not be added to the labels array */
1667 goto done;
1668 }
1669
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;
1674 goto err_rsp_free;
1675 }
1676
1677 /* start at end for descending order, do not include 0 (current) */
1678 lbl_off = 0;
1679 for (i = num_snaps - 1; i > 0; i--) {
1680 char *lbl = sc_data->labels[lbl_off++];
1681 struct tm gmt_snap_time;
1682 struct tm *tm_ret;
1683 size_t str_sz;
1684
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;
1689 }
1690 str_sz = strftime(lbl, sizeof(SHADOW_COPY_LABEL),
1691 "@GMT-%Y.%m.%d-%H.%M.%S", &gmt_snap_time);
1692 if (str_sz == 0) {
1693 status = NT_STATUS_UNSUCCESSFUL;
1694 goto err_labels_free;
1695 }
1696 }
1697
1698 done:
1699 talloc_free(tmp_ctx);
1700 dbus_message_unref(rsp_msg);
1701 dbus_message_unref(req_msg);
1702 snapper_dbus_conn_destroy(dconn);
1703
1704 return 0;
1705
1706 err_labels_free:
1707 TALLOC_FREE(sc_data->labels);
1708 err_rsp_free:
1709 dbus_message_unref(rsp_msg);
1710 err_req_free:
1711 dbus_message_unref(req_msg);
1712 err_conn_free:
1713 snapper_dbus_conn_destroy(dconn);
1714 err_mem_ctx_free:
1715 talloc_free(tmp_ctx);
1716 err_out:
1717 errno = map_errno_from_nt_status(status);
1718 return -1;
1719 }
1720
1721 static bool snapper_gmt_strip_snapshot(TALLOC_CTX *mem_ctx,
1722 struct vfs_handle_struct *handle,
1723 const struct smb_filename *smb_fname,
1724 time_t *ptimestamp,
1725 char **pstripped)
1726 {
1727 char *stripped;
1728
1729 if (smb_fname->twrp == 0) {
1730 goto no_snapshot;
1731 }
1732
1733 if (pstripped != NULL) {
1734 stripped = talloc_strdup(mem_ctx, smb_fname->base_name);
1735 if (stripped == NULL) {
1736 return false;
1737 }
1738 *pstripped = stripped;
1739 }
1740
1741 *ptimestamp = nt_time_to_unix(smb_fname->twrp);
1742 return true;
1743 no_snapshot:
1744 *ptimestamp = 0;
1745 return true;
1746 }
1747
1748 static NTSTATUS snapper_get_snap_at_time_call(TALLOC_CTX *mem_ctx,
1749 DBusConnection *dconn,
1750 const char *conf_name,
1751 const char *base_path,
1752 time_t snaptime,
1753 char **snap_path_out)
1754 {
1755 NTSTATUS status;
1756 DBusMessage *req_msg = NULL;
1757 DBusMessage *rsp_msg;
1758 uint32_t num_snaps;
1759 struct snapper_snap *snaps;
1760 char *snap_path;
1761
1762 status = snapper_list_snaps_at_time_pack(mem_ctx,
1763 conf_name,
1764 snaptime,
1765 snaptime,
1766 &req_msg);
1767 if (!NT_STATUS_IS_OK(status)) {
1768 goto err_out;
1769 }
1770
1771 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1772 if (!NT_STATUS_IS_OK(status)) {
1773 goto err_req_free;
1774 }
1775
1776 status = snapper_list_snaps_unpack(mem_ctx, rsp_msg,
1777 &num_snaps, &snaps);
1778 if (!NT_STATUS_IS_OK(status)) {
1779 goto err_rsp_free;
1780 }
1781
1782 if (num_snaps == 0) {
1783 DEBUG(4, ("no snapshots found with time: %lu\n",
1784 (unsigned long)snaptime));
1785 status = NT_STATUS_INVALID_PARAMETER;
1786 goto err_snap_array_free;
1787 } else if (num_snaps > 0) {
1788 DEBUG(4, ("got %u snapshots for single time %lu, using top\n",
1789 num_snaps, (unsigned long)snaptime));
1790 }
1791
1792 status = snapper_snap_id_to_path(mem_ctx, base_path, snaps[0].id,
1793 &snap_path);
1794 if (!NT_STATUS_IS_OK(status)) {
1795 goto err_snap_array_free;
1796 }
1797
1798 *snap_path_out = snap_path;
1799 err_snap_array_free:
1800 talloc_free(snaps);
1801 err_rsp_free:
1802 dbus_message_unref(rsp_msg);
1803 err_req_free:
1804 dbus_message_unref(req_msg);
1805 err_out:
1806 return status;
1807 }
1808
1809 static NTSTATUS snapper_snap_path_expand(struct connection_struct *conn,
1810 TALLOC_CTX *mem_ctx,
1811 time_t snap_time,
1812 char **snap_dir_out)
1813 {
1814 DBusConnection *dconn;
1815 NTSTATUS status;
1816 char *conf_name;
1817 char *base_path;
1818 char *snap_path = NULL;
1819
1820 dconn = snapper_dbus_conn_create();
1821 if (dconn == NULL) {
1822 status = NT_STATUS_UNSUCCESSFUL;
1823 goto err_out;
1824 }
1825
1826 if (conn->connectpath == NULL) {
1827 status = NT_STATUS_INVALID_PARAMETER;
1828 goto err_conn_free;
1829 }
1830
1831 status = snapper_get_conf_call(mem_ctx, dconn,
1832 conn->connectpath,
1833 &conf_name,
1834 &base_path);
1835 if (!NT_STATUS_IS_OK(status)) {
1836 goto err_conn_free;
1837 }
1838
1839 status = snapper_get_snap_at_time_call(mem_ctx, dconn,
1840 conf_name, base_path, snap_time,
1841 &snap_path);
1842 if (!NT_STATUS_IS_OK(status)) {
1843 goto err_conf_name_free;
1844 }
1845
1846 /* confirm snapshot path is nested under base path */
1847 if (strncmp(snap_path, base_path, strlen(base_path)) != 0) {
1848 status = NT_STATUS_INVALID_PARAMETER;
1849 goto err_snap_path_free;
1850 }
1851
1852 talloc_free(conf_name);
1853 talloc_free(base_path);
1854 snapper_dbus_conn_destroy(dconn);
1855 *snap_dir_out = snap_path;
1856
1857 return NT_STATUS_OK;
1858
1859 err_snap_path_free:
1860 talloc_free(snap_path);
1861 err_conf_name_free:
1862 talloc_free(conf_name);
1863 talloc_free(base_path);
1864 err_conn_free:
1865 snapper_dbus_conn_destroy(dconn);
1866 err_out:
1867 return status;
1868 }
1869
1870 static char *snapper_gmt_convert(TALLOC_CTX *mem_ctx,
1871 struct vfs_handle_struct *handle,
1872 const char *name, time_t timestamp)
1873 {
1874 char *snap_path = NULL;
1875 char *path = NULL;
1876 NTSTATUS status;
1877 int saved_errno;
1878
1879 status = snapper_snap_path_expand(handle->conn, mem_ctx, timestamp,
1880 &snap_path);
1881 if (!NT_STATUS_IS_OK(status)) {
1882 errno = map_errno_from_nt_status(status);
1883 goto err_out;
1884 }
1885
1886 path = talloc_asprintf(mem_ctx, "%s/%s", snap_path, name);
1887 if (path == NULL) {
1888 errno = ENOMEM;
1889 goto err_snap_path_free;
1890 }
1891
1892 DEBUG(10, ("converted %s/%s @ time to %s\n",
1893 handle->conn->connectpath, name, path));
1894 return path;
1895
1896 err_snap_path_free:
1897 saved_errno = errno;
1898 talloc_free(snap_path);
1899 errno = saved_errno;
1900 err_out:
1901 return NULL;
1902 }
1903
1904 static int snapper_gmt_renameat(vfs_handle_struct *handle,
1905 files_struct *srcfsp,
1906 const struct smb_filename *smb_fname_src,
1907 files_struct *dstfsp,
1908 const struct smb_filename *smb_fname_dst)
1909 {
1910 time_t timestamp_src, timestamp_dst;
1911
1912 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
1913 smb_fname_src,
1914 &timestamp_src, NULL)) {
1915 return -1;
1916 }
1917 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
1918 smb_fname_dst,
1919 &timestamp_dst, NULL)) {
1920 return -1;
1921 }
1922 if (timestamp_src != 0) {
1923 errno = EXDEV;
1924 return -1;
1925 }
1926 if (timestamp_dst != 0) {
1927 errno = EROFS;
1928 return -1;
1929 }
1930 return SMB_VFS_NEXT_RENAMEAT(handle,
1931 srcfsp,
1932 smb_fname_src,
1933 dstfsp,
1934 smb_fname_dst);
1935 }
1936
1937 static int snapper_gmt_symlinkat(vfs_handle_struct *handle,
1938 const struct smb_filename *link_contents,
1939 struct files_struct *dirfsp,
1940 const struct smb_filename *new_smb_fname)
1941 {
1942 time_t timestamp_old = 0;
1943 time_t timestamp_new = 0;
1944
1945 if (!snapper_gmt_strip_snapshot(talloc_tos(),
1946 handle,
1947 link_contents,
1948 &timestamp_old,
1949 NULL)) {
1950 return -1;
1951 }
1952 if (!snapper_gmt_strip_snapshot(talloc_tos(),
1953 handle,
1954 new_smb_fname,
1955 &timestamp_new,
1956 NULL)) {
1957 return -1;
1958 }
1959 if ((timestamp_old != 0) || (timestamp_new != 0)) {
1960 errno = EROFS;
1961 return -1;
1962 }
1963 return SMB_VFS_NEXT_SYMLINKAT(handle,
1964 link_contents,
1965 dirfsp,
1966 new_smb_fname);
1967 }
1968
1969 static int snapper_gmt_linkat(vfs_handle_struct *handle,
1970 files_struct *srcfsp,
1971 const struct smb_filename *old_smb_fname,
1972 files_struct *dstfsp,
1973 const struct smb_filename *new_smb_fname,
1974 int flags)
1975 {
1976 time_t timestamp_old = 0;
1977 time_t timestamp_new = 0;
1978
1979 if (!snapper_gmt_strip_snapshot(talloc_tos(),
1980 handle,
1981 old_smb_fname,
1982 &timestamp_old,
1983 NULL)) {
1984 return -1;
1985 }
1986 if (!snapper_gmt_strip_snapshot(talloc_tos(),
1987 handle,
1988 new_smb_fname,
1989 &timestamp_new,
1990 NULL)) {
1991 return -1;
1992 }
1993 if ((timestamp_old != 0) || (timestamp_new != 0)) {
1994 errno = EROFS;
1995 return -1;
1996 }
1997 return SMB_VFS_NEXT_LINKAT(handle,
1998 srcfsp,
1999 old_smb_fname,
2000 dstfsp,
2001 new_smb_fname,
2002 flags);
2003 }
2004
2005 static int snapper_gmt_stat(vfs_handle_struct *handle,
2006 struct smb_filename *smb_fname)
2007 {
2008 time_t timestamp;
2009 char *stripped, *tmp;
2010 int ret, saved_errno;
2011
2012 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2013 smb_fname,
2014 &timestamp, &stripped)) {
2015 return -1;
2016 }
2017 if (timestamp == 0) {
2018 return SMB_VFS_NEXT_STAT(handle, smb_fname);
2019 }
2020
2021 tmp = smb_fname->base_name;
2022 smb_fname->base_name = snapper_gmt_convert(talloc_tos(), handle,
2023 stripped, timestamp);
2024 TALLOC_FREE(stripped);
2025
2026 if (smb_fname->base_name == NULL) {
2027 smb_fname->base_name = tmp;
2028 return -1;
2029 }
2030
2031 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
2032 saved_errno = errno;
2033
2034 TALLOC_FREE(smb_fname->base_name);
2035 smb_fname->base_name = tmp;
2036
2037 errno = saved_errno;
2038 return ret;
2039 }
2040
2041 static int snapper_gmt_lstat(vfs_handle_struct *handle,
2042 struct smb_filename *smb_fname)
2043 {
2044 time_t timestamp;
2045 char *stripped, *tmp;
2046 int ret, saved_errno;
2047
2048 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2049 smb_fname,
2050 &timestamp, &stripped)) {
2051 return -1;
2052 }
2053 if (timestamp == 0) {
2054 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
2055 }
2056
2057 tmp = smb_fname->base_name;
2058 smb_fname->base_name = snapper_gmt_convert(talloc_tos(), handle,
2059 stripped, timestamp);
2060 TALLOC_FREE(stripped);
2061
2062 if (smb_fname->base_name == NULL) {
2063 smb_fname->base_name = tmp;
2064 return -1;
2065 }
2066
2067 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
2068 saved_errno = errno;
2069
2070 TALLOC_FREE(smb_fname->base_name);
2071 smb_fname->base_name = tmp;
2072
2073 errno = saved_errno;
2074 return ret;
2075 }
2076
2077 static int snapper_gmt_openat(struct vfs_handle_struct *handle,
2078 const struct files_struct *dirfsp,
2079 const struct smb_filename *smb_fname_in,
2080 struct files_struct *fsp,
2081 const struct vfs_open_how *how)
2082 {
2083 struct smb_filename *smb_fname = NULL;
2084 time_t timestamp;
2085 char *stripped = NULL;
2086 int ret;
2087 int saved_errno = 0;
2088
2089 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2090 smb_fname_in,
2091 &timestamp, &stripped)) {
2092 return -1;
2093 }
2094 if (timestamp == 0) {
2095 return SMB_VFS_NEXT_OPENAT(handle,
2096 dirfsp,
2097 smb_fname_in,
2098 fsp,
2099 how);
2100 }
2101
2102 smb_fname = cp_smb_filename(talloc_tos(), smb_fname_in);
2103 if (smb_fname == NULL) {
2104 TALLOC_FREE(stripped);
2105 return -1;
2106 }
2107
2108 smb_fname->base_name = snapper_gmt_convert(smb_fname, handle,
2109 stripped, timestamp);
2110 TALLOC_FREE(stripped);
2111
2112 if (smb_fname->base_name == NULL) {
2113 TALLOC_FREE(smb_fname);
2114 errno = ENOMEM;
2115 return -1;
2116 }
2117
2118 ret = SMB_VFS_NEXT_OPENAT(handle, dirfsp, smb_fname, fsp, how);
2119 if (ret == -1) {
2120 saved_errno = errno;
2121 }
2122 TALLOC_FREE(smb_fname);
2123 if (saved_errno != 0) {
2124 errno = saved_errno;
2125 }
2126 return ret;
2127 }
2128
2129 static int snapper_gmt_unlinkat(vfs_handle_struct *handle,
2130 struct files_struct *dirfsp,
2131 const struct smb_filename *smb_fname,
2132 int flags)
2133 {
2134 time_t timestamp = 0;
2135
2136 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2137 smb_fname,
2138 &timestamp, NULL)) {
2139 return -1;
2140 }
2141 if (timestamp != 0) {
2142 errno = EROFS;
2143 return -1;
2144 }
2145 return SMB_VFS_NEXT_UNLINKAT(handle,
2146 dirfsp,
2147 smb_fname,
2148 flags);
2149 }
2150
2151 static int snapper_gmt_fchmod(vfs_handle_struct *handle,
2152 struct files_struct *fsp,
2153 mode_t mode)
2154 {
2155 time_t timestamp = 0;
2156 const struct smb_filename *smb_fname = NULL;
2157
2158 smb_fname = fsp->fsp_name;
2159
2160 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2161 handle,
2162 smb_fname,
2163 &timestamp,
2164 NULL)) {
2165 return -1;
2166 }
2167
2168 if (timestamp != 0) {
2169 errno = EROFS;
2170 return -1;
2171 }
2172 return SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
2173 }
2174
2175 static int snapper_gmt_chdir(vfs_handle_struct *handle,
2176 const struct smb_filename *smb_fname)
2177 {
2178 time_t timestamp = 0;
2179 char *stripped = NULL;
2180 int ret;
2181 int saved_errno = 0;
2182 char *conv = NULL;
2183 struct smb_filename *conv_smb_fname = NULL;
2184
2185 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2186 handle,
2187 smb_fname,
2188 &timestamp,
2189 &stripped)) {
2190 return -1;
2191 }
2192 if (timestamp == 0) {
2193 return SMB_VFS_NEXT_CHDIR(handle, smb_fname);
2194 }
2195 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2196 TALLOC_FREE(stripped);
2197 if (conv == NULL) {
2198 return -1;
2199 }
2200 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2201 conv,
2202 NULL,
2203 NULL,
2204 0,
2205 smb_fname->flags);
2206 if (conv_smb_fname == NULL) {
2207 TALLOC_FREE(conv);
2208 errno = ENOMEM;
2209 return -1;
2210 }
2211 ret = SMB_VFS_NEXT_CHDIR(handle, conv_smb_fname);
2212 if (ret == -1) {
2213 saved_errno = errno;
2214 }
2215 TALLOC_FREE(conv);
2216 TALLOC_FREE(conv_smb_fname);
2217 if (saved_errno != 0) {
2218 errno = saved_errno;
2219 }
2220 return ret;
2221 }
2222
2223 static int snapper_gmt_fntimes(vfs_handle_struct *handle,
2224 files_struct *fsp,
2225 struct smb_file_time *ft)
2226 {
2227 time_t timestamp = 0;
2228
2229 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2230 handle,
2231 fsp->fsp_name,
2232 &timestamp,
2233 NULL)) {
2234 return -1;
2235 }
2236
2237 if (timestamp != 0) {
2238 errno = EROFS;
2239 return -1;
2240 }
2241
2242 return SMB_VFS_NEXT_FNTIMES(handle, fsp, ft);
2243 }
2244
2245 static int snapper_gmt_readlinkat(vfs_handle_struct *handle,
2246 const struct files_struct *dirfsp,
2247 const struct smb_filename *smb_fname,
2248 char *buf,
2249 size_t bufsiz)
2250 {
2251 time_t timestamp = 0;
2252 int ret;
2253 int saved_errno = 0;
2254 struct smb_filename *full_fname = NULL;
2255
2256 /*
2257 * Now this function only looks at smb_fname->twrp
2258 * we don't need to copy out the path. Just use
2259 * smb_fname->base_name directly.
2260 */
2261 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2262 smb_fname,
2263 &timestamp, NULL)) {
2264 return -1;
2265 }
2266 if (timestamp == 0) {
2267 return SMB_VFS_NEXT_READLINKAT(handle,
2268 dirfsp,
2269 smb_fname,
2270 buf,
2271 bufsiz);
2272 }
2273 full_fname = full_path_from_dirfsp_atname(talloc_tos(),
2274 dirfsp,
2275 smb_fname);
2276 if (full_fname == NULL) {
2277 return -1;
2278 }
2279
2280 /* Find the snapshot path from the full pathname. */
2281 full_fname->base_name = snapper_gmt_convert(full_fname,
2282 handle,
2283 full_fname->base_name,
2284 timestamp);
2285 if (full_fname->base_name == NULL) {
2286 TALLOC_FREE(full_fname);
2287 return -1;
2288 }
2289 ret = SMB_VFS_NEXT_READLINKAT(handle,
2290 handle->conn->cwd_fsp,
2291 full_fname,
2292 buf,
2293 bufsiz);
2294 if (ret == -1) {
2295 saved_errno = errno;
2296 }
2297 TALLOC_FREE(full_fname);
2298 if (saved_errno != 0) {
2299 errno = saved_errno;
2300 }
2301 return ret;
2302 }
2303
2304 static int snapper_gmt_mknodat(vfs_handle_struct *handle,
2305 files_struct *dirfsp,
2306 const struct smb_filename *smb_fname,
2307 mode_t mode,
2308 SMB_DEV_T dev)
2309 {
2310 time_t timestamp = (time_t)0;
2311
2312 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2313 smb_fname,
2314 &timestamp, NULL)) {
2315 return -1;
2316 }
2317 if (timestamp != 0) {
2318 errno = EROFS;
2319 return -1;
2320 }
2321 return SMB_VFS_NEXT_MKNODAT(handle,
2322 dirfsp,
2323 smb_fname,
2324 mode,
2325 dev);
2326 }
2327
2328 static struct smb_filename *snapper_gmt_realpath(vfs_handle_struct *handle,
2329 TALLOC_CTX *ctx,
2330 const struct smb_filename *smb_fname)
2331 {
2332 time_t timestamp = 0;
2333 char *stripped = NULL;
2334 struct smb_filename *result_fname = NULL;
2335 struct smb_filename *conv_smb_fname = NULL;
2336 int saved_errno = 0;
2337
2338 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2339 smb_fname,
2340 &timestamp, &stripped)) {
2341 goto done;
2342 }
2343 if (timestamp == 0) {
2344 return SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
2345 }
2346
2347 conv_smb_fname = cp_smb_filename(talloc_tos(), smb_fname);
2348 if (conv_smb_fname == NULL) {
2349 goto done;
2350 }
2351 conv_smb_fname->base_name = snapper_gmt_convert(conv_smb_fname, handle,
2352 stripped, timestamp);
2353 if (conv_smb_fname->base_name == NULL) {
2354 goto done;
2355 }
2356
2357 result_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, conv_smb_fname);
2358
2359 done:
2360 if (result_fname == NULL) {
2361 saved_errno = errno;
2362 }
2363 TALLOC_FREE(conv_smb_fname);
2364 TALLOC_FREE(stripped);
2365 if (saved_errno != 0) {
2366 errno = saved_errno;
2367 }
2368 return result_fname;
2369 }
2370
2371 static int snapper_gmt_mkdirat(vfs_handle_struct *handle,
2372 struct files_struct *dirfsp,
2373 const struct smb_filename *fname,
2374 mode_t mode)
2375 {
2376 time_t timestamp = 0;
2377
2378 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, fname,
2379 &timestamp, NULL)) {
2380 return -1;
2381 }
2382 if (timestamp != 0) {
2383 errno = EROFS;
2384 return -1;
2385 }
2386 return SMB_VFS_NEXT_MKDIRAT(handle,
2387 dirfsp,
2388 fname,
2389 mode);
2390 }
2391
2392 static int snapper_gmt_fchflags(vfs_handle_struct *handle,
2393 struct files_struct *fsp,
2394 unsigned int flags)
2395 {
2396 time_t timestamp = 0;
2397
2398 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2399 fsp->fsp_name, &timestamp, NULL)) {
2400 return -1;
2401 }
2402 if (timestamp != 0) {
2403 errno = EROFS;
2404 return -1;
2405 }
2406 return SMB_VFS_NEXT_FCHFLAGS(handle, fsp, flags);
2407 }
2408
2409 static int snapper_gmt_fsetxattr(struct vfs_handle_struct *handle,
2410 struct files_struct *fsp,
2411 const char *aname, const void *value,
2412 size_t size, int flags)
2413 {
2414 time_t timestamp = 0;
2415 const struct smb_filename *smb_fname = NULL;
2416
2417 smb_fname = fsp->fsp_name;
2418
2419 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2420 handle,
2421 smb_fname,
2422 &timestamp,
2423 NULL)) {
2424 return -1;
2425 }
2426 if (timestamp != 0) {
2427 errno = EROFS;
2428 return -1;
2429 }
2430 return SMB_VFS_NEXT_FSETXATTR(handle, fsp,
2431 aname, value, size, flags);
2432 }
2433
2434 static NTSTATUS snapper_gmt_get_real_filename_at(
2435 struct vfs_handle_struct *handle,
2436 struct files_struct *dirfsp,
2437 const char *name,
2438 TALLOC_CTX *mem_ctx,
2439 char **found_name)
2440 {
2441 time_t timestamp;
2442 char *stripped;
2443 char *conv;
2444 struct smb_filename *conv_fname = NULL;
2445 NTSTATUS status;
2446 bool ok;
2447
2448 ok = snapper_gmt_strip_snapshot(
2449 talloc_tos(), handle, dirfsp->fsp_name,&timestamp, &stripped);
2450 if (!ok) {
2451 return NT_STATUS_NO_MEMORY;
2452 }
2453 if (timestamp == 0) {
2454 return SMB_VFS_NEXT_GET_REAL_FILENAME_AT(
2455 handle, dirfsp, name, mem_ctx, found_name);
2456 }
2457 if (stripped[0] == '\0') {
2458 *found_name = talloc_strdup(mem_ctx, name);
2459 if (*found_name == NULL) {
2460 return NT_STATUS_NO_MEMORY;
2461 }
2462 return NT_STATUS_OK;
2463 }
2464 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2465 TALLOC_FREE(stripped);
2466 if (conv == NULL) {
2467 return map_nt_error_from_unix(errno);
2468 }
2469
2470 status = synthetic_pathref(
2471 talloc_tos(),
2472 dirfsp->conn->cwd_fsp,
2473 conv,
2474 NULL,
2475 NULL,
2476 0,
2477 0,
2478 &conv_fname);
2479
2480 status = SMB_VFS_NEXT_GET_REAL_FILENAME_AT(
2481 handle, conv_fname->fsp, name, mem_ctx, found_name);
2482 TALLOC_FREE(conv);
2483 return status;
2484 }
2485
2486 static uint64_t snapper_gmt_disk_free(vfs_handle_struct *handle,
2487 const struct smb_filename *smb_fname,
2488 uint64_t *bsize,
2489 uint64_t *dfree,
2490 uint64_t *dsize)
2491 {
2492 time_t timestamp = 0;
2493 char *stripped = NULL;
2494 uint64_t ret;
2495 int saved_errno = 0;
2496 char *conv = NULL;
2497 struct smb_filename *conv_smb_fname = NULL;
2498
2499 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2500 smb_fname, &timestamp, &stripped)) {
2501 return (uint64_t)-1;
2502 }
2503 if (timestamp == 0) {
2504 return SMB_VFS_NEXT_DISK_FREE(handle, smb_fname,
2505 bsize, dfree, dsize);
2506 }
2507
2508 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2509 TALLOC_FREE(stripped);
2510 if (conv == NULL) {
2511 return (uint64_t)-1;
2512 }
2513 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2514 conv,
2515 NULL,
2516 NULL,
2517 0,
2518 smb_fname->flags);
2519 if (conv_smb_fname == NULL) {
2520 TALLOC_FREE(conv);
2521 errno = ENOMEM;
2522 return (uint64_t)-1;
2523 }
2524
2525 ret = SMB_VFS_NEXT_DISK_FREE(handle, conv_smb_fname,
2526 bsize, dfree, dsize);
2527
2528 if (ret == (uint64_t)-1) {
2529 saved_errno = errno;
2530 }
2531 TALLOC_FREE(conv_smb_fname);
2532 if (saved_errno != 0) {
2533 errno = saved_errno;
2534 }
2535 return ret;
2536 }
2537
2538 static int snapper_gmt_get_quota(vfs_handle_struct *handle,
2539 const struct smb_filename *smb_fname,
2540 enum SMB_QUOTA_TYPE qtype,
2541 unid_t id,
2542 SMB_DISK_QUOTA *dq)
2543 {
2544 time_t timestamp = 0;
2545 char *stripped = NULL;
2546 int ret;
2547 int saved_errno = 0;
2548 char *conv = NULL;
2549 struct smb_filename *conv_smb_fname = NULL;
2550
2551 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2552 smb_fname, &timestamp, &stripped)) {
2553 return -1;
2554 }
2555 if (timestamp == 0) {
2556 return SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, dq);
2557 }
2558
2559 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2560 TALLOC_FREE(stripped);
2561 if (conv == NULL) {
2562 return -1;
2563 }
2564 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2565 conv,
2566 NULL,
2567 NULL,
2568 0,
2569 smb_fname->flags);
2570 TALLOC_FREE(conv);
2571 if (conv_smb_fname == NULL) {
2572 errno = ENOMEM;
2573 return -1;
2574 }
2575
2576 ret = SMB_VFS_NEXT_GET_QUOTA(handle, conv_smb_fname, qtype, id, dq);
2577
2578 if (ret == -1) {
2579 saved_errno = errno;
2580 }
2581 TALLOC_FREE(conv_smb_fname);
2582 if (saved_errno != 0) {
2583 errno = saved_errno;
2584 }
2585 return ret;
2586 }
2587
2588 static NTSTATUS snapper_create_dfs_pathat(struct vfs_handle_struct *handle,
2589 struct files_struct *dirfsp,
2590 const struct smb_filename *smb_fname,
2591 const struct referral *reflist,
2592 size_t referral_count)
2593 {
2594 time_t timestamp = 0;
2595
2596 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2597 handle,
2598 smb_fname,
2599 &timestamp,
2600 NULL)) {
2601 return NT_STATUS_NO_MEMORY;
2602 }
2603 if (timestamp != 0) {
2604 return NT_STATUS_MEDIA_WRITE_PROTECTED;
2605 }
2606 return SMB_VFS_NEXT_CREATE_DFS_PATHAT(handle,
2607 dirfsp,
2608 smb_fname,
2609 reflist,
2610 referral_count);
2611 }
2612
2613 static struct vfs_fn_pointers snapper_fns = {
2614 .snap_check_path_fn = snapper_snap_check_path,
2615 .snap_create_fn = snapper_snap_create,
2616 .snap_delete_fn = snapper_snap_delete,
2617 .get_shadow_copy_data_fn = snapper_get_shadow_copy_data,
2618 .create_dfs_pathat_fn = snapper_create_dfs_pathat,
2619 .disk_free_fn = snapper_gmt_disk_free,
2620 .get_quota_fn = snapper_gmt_get_quota,
2621 .renameat_fn = snapper_gmt_renameat,
2622 .linkat_fn = snapper_gmt_linkat,
2623 .symlinkat_fn = snapper_gmt_symlinkat,
2624 .stat_fn = snapper_gmt_stat,
2625 .lstat_fn = snapper_gmt_lstat,
2626 .openat_fn = snapper_gmt_openat,
2627 .unlinkat_fn = snapper_gmt_unlinkat,
2628 .fchmod_fn = snapper_gmt_fchmod,
2629 .chdir_fn = snapper_gmt_chdir,
2630 .fntimes_fn = snapper_gmt_fntimes,
2631 .readlinkat_fn = snapper_gmt_readlinkat,
2632 .mknodat_fn = snapper_gmt_mknodat,
2633 .realpath_fn = snapper_gmt_realpath,
2634 .mkdirat_fn = snapper_gmt_mkdirat,
2635 .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
2636 .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
2637 .fsetxattr_fn = snapper_gmt_fsetxattr,
2638 .fchflags_fn = snapper_gmt_fchflags,
2639 .get_real_filename_at_fn = snapper_gmt_get_real_filename_at,
2640 };
2641
2642 static_decl_vfs;
2643 NTSTATUS vfs_snapper_init(TALLOC_CTX *ctx)
2644 {
2645 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
2646 "snapper", &snapper_fns);
2647 }
Samba GIT mirror