?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
selftest:Samba4: report when samba is started and ready
[Samba.git] / source3 / modules / vfs_snapper.c
blob443a940b17a8a2e787b6ff4c2d6b68511df17db7
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
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}"
46
47 struct snapper_dict {
48 char *key;
49 char *val;
50 };
51
52 struct snapper_snap {
53 uint32_t id;
54 uint16_t type;
55 uint32_t pre_id;
56 int64_t time;
57 uint32_t creator_uid;
58 char *desc;
59 char *cleanup;
60 uint32_t num_user_data;
61 struct snapper_dict *user_data;
62 };
63
64 struct snapper_conf {
65 char *name;
66 char *mnt;
67 uint32_t num_attrs;
68 struct snapper_dict *attrs;
69 };
70
71 static const struct {
72 const char *snapper_err_str;
73 NTSTATUS status;
74 } snapper_err_map[] = {
75 { "error.no_permissions", NT_STATUS_ACCESS_DENIED },
76 };
77
78 static NTSTATUS snapper_err_ntstatus_map(const char *snapper_err_str)
79 {
80 int i;
81
82 if (snapper_err_str == NULL) {
83 return NT_STATUS_UNSUCCESSFUL;
84 }
85 for (i = 0; i < ARRAY_SIZE(snapper_err_map); i++) {
86 if (!strcmp(snapper_err_map[i].snapper_err_str,
87 snapper_err_str)) {
88 return snapper_err_map[i].status;
89 }
90 }
91 DEBUG(2, ("no explicit mapping for dbus error: %s\n", snapper_err_str));
92
93 return NT_STATUS_UNSUCCESSFUL;
94 }
95
96 /*
97 * Strings are UTF-8. Other characters must be encoded hexadecimal as "\x??".
98 * As a consequence "\" must be encoded as "\\".
99 */
100 static NTSTATUS snapper_dbus_str_encode(TALLOC_CTX *mem_ctx, const char *in_str,
101 char **_out_str)
102 {
103 size_t in_len;
104 char *out_str;
105 int i;
106 int out_off;
107 int out_len;
108
109 if (in_str == NULL) {
110 return NT_STATUS_INVALID_PARAMETER;
111 }
112
113 in_len = strlen(in_str);
114
115 /* output can be max 4 times the length of @in_str, +1 for terminator */
116 out_len = (in_len * 4) + 1;
117
118 out_str = talloc_array(mem_ctx, char, out_len);
119 if (out_str == NULL) {
120 return NT_STATUS_NO_MEMORY;
121 }
122
123 out_off = 0;
124 for (i = 0; i < in_len; i++) {
125 size_t pushed;
126
127 if (in_str[i] == '\\') {
128 pushed = snprintf(out_str + out_off, out_len - out_off,
129 "\\\\");
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]);
133 } else {
134 /* regular character */
135 *(out_str + out_off) = in_str[i];
136 pushed = sizeof(char);
137 }
138 if (pushed >= out_len - out_off) {
139 /* truncated, should never happen */
140 talloc_free(out_str);
141 return NT_STATUS_INTERNAL_ERROR;
142 }
143 out_off += pushed;
144 }
145
146 *(out_str + out_off) = '\0';
147 *_out_str = out_str;
148
149 return NT_STATUS_OK;
150 }
151
152 static NTSTATUS snapper_dbus_str_decode(TALLOC_CTX *mem_ctx, const char *in_str,
153 char **_out_str)
154 {
155 size_t in_len;
156 char *out_str;
157 int i;
158 int out_off;
159 int out_len;
160
161 if (in_str == NULL) {
162 return NT_STATUS_INVALID_PARAMETER;
163 }
164
165 in_len = strlen(in_str);
166
167 /* output cannot be larger than input, +1 for terminator */
168 out_len = in_len + 1;
169
170 out_str = talloc_array(mem_ctx, char, out_len);
171 if (out_str == NULL) {
172 return NT_STATUS_NO_MEMORY;
173 }
174
175 out_off = 0;
176 for (i = 0; i < in_len; i++) {
177 int j;
178 char hex_buf[3];
179 unsigned int non_ascii_byte;
180
181 if (in_str[i] != '\\') {
182 out_str[out_off] = in_str[i];
183 out_off++;
184 continue;
185 }
186
187 i++;
188 if (in_str[i] == '\\') {
189 out_str[out_off] = '\\';
190 out_off++;
191 continue;
192 } else if (in_str[i] != 'x') {
193 goto err_invalid_src_encoding;
194 }
195
196 /* non-ASCII, encoded as two hex chars */
197 for (j = 0; j < 2; j++) {
198 i++;
199 if ((in_str[i] == '\0') || !isxdigit(in_str[i])) {
200 goto err_invalid_src_encoding;
201 }
202 hex_buf[j] = in_str[i];
203 }
204 hex_buf[2] = '\0';
205
206 sscanf(hex_buf, "%x", &non_ascii_byte);
207 out_str[out_off] = (unsigned char)non_ascii_byte;
208 out_off++;
209 }
210
211 out_str[out_off] = '\0';
212 *_out_str = out_str;
213
214 return NT_STATUS_OK;
215 err_invalid_src_encoding:
216 DEBUG(0, ("invalid encoding %s\n", in_str));
217 return NT_STATUS_INVALID_PARAMETER;
218 }
219
220 static DBusConnection *snapper_dbus_conn_create(void)
221 {
222 DBusError err;
223 DBusConnection *dconn;
224
225 dbus_error_init(&err);
226
227 /*
228 * Always create a new DBus connection, to ensure snapperd detects the
229 * correct client [E]UID. With dbus_bus_get() it does not!
230 */
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);
235 }
236 if (dconn == NULL) {
237 return NULL;
238 }
239
240 /* dbus_bus_get_private() sets exit-on-disconnect by default, undo it */
241 dbus_connection_set_exit_on_disconnect(dconn, false);
242
243 return dconn;
244 }
245
246 static void snapper_dbus_conn_destroy(DBusConnection *dconn)
247 {
248 if (dconn == NULL) {
249 DEBUG(2, ("attempt to destroy NULL dbus connection\n"));
250 return;
251 }
252
253 dbus_connection_close(dconn);
254 dbus_connection_unref(dconn);
255 }
256
257 /*
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.
261 */
262 static NTSTATUS snapper_dbus_msg_xchng(DBusConnection *dconn,
263 DBusMessage *send_msg,
264 DBusMessage **recv_msg_out)
265 {
266 DBusPendingCall *pending;
267 DBusMessage *recv_msg;
268
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;
272 }
273 if (NULL == pending) {
274 DEBUG(0, ("dbus msg send failed\n"));
275 return NT_STATUS_UNSUCCESSFUL;
276 }
277
278 dbus_connection_flush(dconn);
279
280 /* block until we receive a reply */
281 dbus_pending_call_block(pending);
282
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;
288 }
289 /* free the pending message handle */
290 dbus_pending_call_unref(pending);
291 *recv_msg_out = recv_msg;
292
293 return NT_STATUS_OK;
294 }
295
296 static NTSTATUS snapper_type_check(DBusMessageIter *iter,
297 int expected_type)
298 {
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;
304 }
305
306 return NT_STATUS_OK;
307 }
308
309 static NTSTATUS snapper_type_check_get(DBusMessageIter *iter,
310 int expected_type,
311 void *val)
312 {
313 NTSTATUS status;
314 status = snapper_type_check(iter, expected_type);
315 if (!NT_STATUS_IS_OK(status)) {
316 return status;
317 }
318
319 dbus_message_iter_get_basic(iter, val);
320
321 return NT_STATUS_OK;
322 }
323
324 static NTSTATUS snapper_dict_unpack(TALLOC_CTX *mem_ctx,
325 DBusMessageIter *iter,
326 struct snapper_dict *dict_out)
327
328 {
329 NTSTATUS status;
330 DBusMessageIter dct_iter;
331 char *key_encoded;
332 char *val_encoded;
333
334 status = snapper_type_check(iter, DBUS_TYPE_DICT_ENTRY);
335 if (!NT_STATUS_IS_OK(status)) {
336 return status;
337 }
338 dbus_message_iter_recurse(iter, &dct_iter);
339
340 status = snapper_type_check_get(&dct_iter, DBUS_TYPE_STRING,
341 &key_encoded);
342 if (!NT_STATUS_IS_OK(status)) {
343 return status;
344 }
345 status = snapper_dbus_str_decode(mem_ctx, key_encoded, &dict_out->key);
346 if (!NT_STATUS_IS_OK(status)) {
347 return status;
348 }
349
350 dbus_message_iter_next(&dct_iter);
351 status = snapper_type_check_get(&dct_iter, DBUS_TYPE_STRING,
352 &val_encoded);
353 if (!NT_STATUS_IS_OK(status)) {
354 talloc_free(dict_out->key);
355 return status;
356 }
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);
360 return status;
361 }
362
363 return NT_STATUS_OK;
364 }
365
366 static void snapper_dict_array_print(uint32_t num_dicts,
367 struct snapper_dict *dicts)
368 {
369 int i;
370
371 for (i = 0; i < num_dicts; i++) {
372 DEBUG(10, ("dict (key: %s, val: %s)\n",
373 dicts[i].key, dicts[i].val));
374 }
375 }
376
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)
381 {
382 NTSTATUS status;
383 DBusMessageIter array_iter;
384 uint32_t num_dicts;
385 struct snapper_dict *dicts = NULL;
386
387 status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
388 if (!NT_STATUS_IS_OK(status)) {
389 return status;
390 }
391 dbus_message_iter_recurse(iter, &array_iter);
392
393 num_dicts = 0;
394 while (dbus_message_iter_get_arg_type(&array_iter)
395 != DBUS_TYPE_INVALID) {
396 num_dicts++;
397 dicts = talloc_realloc(mem_ctx, dicts, struct snapper_dict,
398 num_dicts);
399 if (dicts == NULL)
400 abort();
401
402 status = snapper_dict_unpack(mem_ctx, &array_iter,
403 &dicts[num_dicts - 1]);
404 if (!NT_STATUS_IS_OK(status)) {
405 talloc_free(dicts);
406 return status;
407 }
408 dbus_message_iter_next(&array_iter);
409 }
410
411 *num_dicts_out = num_dicts;
412 *dicts_out = dicts;
413
414 return NT_STATUS_OK;
415 }
416
417 static NTSTATUS snapper_list_confs_pack(DBusMessage **req_msg_out)
418 {
419 DBusMessage *msg;
420
421 msg = dbus_message_new_method_call("org.opensuse.Snapper",
422 "/org/opensuse/Snapper",
423 "org.opensuse.Snapper",
424 "ListConfigs");
425 if (msg == NULL) {
426 DEBUG(0, ("null msg\n"));
427 return NT_STATUS_NO_MEMORY;
428 }
429
430 /* no arguments to append */
431 *req_msg_out = msg;
432
433 return NT_STATUS_OK;
434 }
435
436 static NTSTATUS snapper_conf_unpack(TALLOC_CTX *mem_ctx,
437 DBusMessageIter *iter,
438 struct snapper_conf *conf_out)
439 {
440 NTSTATUS status;
441 DBusMessageIter st_iter;
442 char *name_encoded;
443 char *mnt_encoded;
444
445 status = snapper_type_check(iter, DBUS_TYPE_STRUCT);
446 if (!NT_STATUS_IS_OK(status)) {
447 return status;
448 }
449 dbus_message_iter_recurse(iter, &st_iter);
450
451 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
452 &name_encoded);
453 if (!NT_STATUS_IS_OK(status)) {
454 return status;
455 }
456
457 status = snapper_dbus_str_decode(mem_ctx, name_encoded,
458 &conf_out->name);
459 if (!NT_STATUS_IS_OK(status)) {
460 return status;
461 }
462
463 dbus_message_iter_next(&st_iter);
464 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
465 &mnt_encoded);
466 if (!NT_STATUS_IS_OK(status)) {
467 talloc_free(conf_out->name);
468 return status;
469 }
470
471 status = snapper_dbus_str_decode(mem_ctx, mnt_encoded,
472 &conf_out->mnt);
473 if (!NT_STATUS_IS_OK(status)) {
474 talloc_free(conf_out->name);
475 return status;
476 }
477
478 dbus_message_iter_next(&st_iter);
479 status = snapper_dict_array_unpack(mem_ctx, &st_iter,
480 &conf_out->num_attrs,
481 &conf_out->attrs);
482 if (!NT_STATUS_IS_OK(status)) {
483 talloc_free(conf_out->mnt);
484 talloc_free(conf_out->name);
485 return status;
486 }
487
488 return NT_STATUS_OK;
489 }
490
491 static struct snapper_conf *snapper_conf_array_base_find(int32_t num_confs,
492 struct snapper_conf *confs,
493 const char *base)
494 {
495 int i;
496
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));
501 return &confs[i];
502 }
503 }
504 DEBUG(5, ("config for base %s not found\n", base));
505
506 return NULL;
507 }
508
509 static void snapper_conf_array_print(int32_t num_confs,
510 struct snapper_conf *confs)
511 {
512 int i;
513
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);
518 }
519 }
520
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)
525 {
526 uint32_t num_confs;
527 NTSTATUS status;
528 struct snapper_conf *confs = NULL;
529 DBusMessageIter array_iter;
530
531
532 status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
533 if (!NT_STATUS_IS_OK(status)) {
534 return status;
535 }
536 dbus_message_iter_recurse(iter, &array_iter);
537
538 num_confs = 0;
539 while (dbus_message_iter_get_arg_type(&array_iter)
540 != DBUS_TYPE_INVALID) {
541 num_confs++;
542 confs = talloc_realloc(mem_ctx, confs, struct snapper_conf,
543 num_confs);
544 if (confs == NULL)
545 abort();
546
547 status = snapper_conf_unpack(confs, &array_iter,
548 &confs[num_confs - 1]);
549 if (!NT_STATUS_IS_OK(status)) {
550 talloc_free(confs);
551 return status;
552 }
553 dbus_message_iter_next(&array_iter);
554 }
555
556 *num_confs_out = num_confs;
557 *confs_out = confs;
558
559 return NT_STATUS_OK;
560 }
561
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)
567 {
568 NTSTATUS status;
569 DBusMessageIter iter;
570 int msg_type;
571 uint32_t num_confs;
572 struct snapper_conf *confs;
573 const char *sig;
574
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);
580 }
581
582 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
583 DEBUG(0, ("unexpected list_confs ret type: %d\n",
584 msg_type));
585 return NT_STATUS_INVALID_PARAMETER;
586 }
587
588 sig = dbus_message_get_signature(rsp_msg);
589 if ((sig == NULL)
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;
594 }
595
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;
600 }
601
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"));
605 return status;
606 }
607
608 snapper_conf_array_print(num_confs, confs);
609
610 *num_confs_out = num_confs;
611 *confs_out = confs;
612
613 return NT_STATUS_OK;
614 }
615
616 static NTSTATUS snapper_list_snaps_pack(TALLOC_CTX *mem_ctx,
617 char *snapper_conf,
618 DBusMessage **req_msg_out)
619 {
620 DBusMessage *msg;
621 DBusMessageIter args;
622 char *conf_encoded;
623 NTSTATUS status;
624
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 */
629 if (msg == NULL) {
630 DEBUG(0, ("failed to create list snaps message\n"));
631 return NT_STATUS_NO_MEMORY;
632 }
633
634 status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
635 if (!NT_STATUS_IS_OK(status)) {
636 dbus_message_unref(msg);
637 return status;
638 }
639
640 /* append arguments */
641 dbus_message_iter_init_append(msg, &args);
642 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
643 &conf_encoded)) {
644 talloc_free(conf_encoded);
645 dbus_message_unref(msg);
646 return NT_STATUS_NO_MEMORY;
647 }
648
649 *req_msg_out = msg;
650
651 return NT_STATUS_OK;
652 }
653
654 static NTSTATUS snapper_snap_struct_unpack(TALLOC_CTX *mem_ctx,
655 DBusMessageIter *iter,
656 struct snapper_snap *snap_out)
657 {
658 NTSTATUS status;
659 DBusMessageIter st_iter;
660 char *desc_encoded;
661 char *cleanup_encoded;
662
663 status = snapper_type_check(iter, DBUS_TYPE_STRUCT);
664 if (!NT_STATUS_IS_OK(status)) {
665 return status;
666 }
667 dbus_message_iter_recurse(iter, &st_iter);
668
669 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
670 &snap_out->id);
671 if (!NT_STATUS_IS_OK(status)) {
672 return status;
673 }
674
675 dbus_message_iter_next(&st_iter);
676 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT16,
677 &snap_out->type);
678 if (!NT_STATUS_IS_OK(status)) {
679 return status;
680 }
681
682 dbus_message_iter_next(&st_iter);
683 status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
684 &snap_out->pre_id);
685 if (!NT_STATUS_IS_OK(status)) {
686 return status;
687 }
688
689 dbus_message_iter_next(&st_iter);
690 status = snapper_type_check_get(&st_iter, DBUS_TYPE_INT64,
691 &snap_out->time);
692 if (!NT_STATUS_IS_OK(status)) {
693 return status;
694 }
695
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)) {
700 return status;
701 }
702
703 dbus_message_iter_next(&st_iter);
704 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
705 &desc_encoded);
706 if (!NT_STATUS_IS_OK(status)) {
707 return status;
708 }
709
710 status = snapper_dbus_str_decode(mem_ctx, desc_encoded,
711 &snap_out->desc);
712 if (!NT_STATUS_IS_OK(status)) {
713 return status;
714 }
715
716 dbus_message_iter_next(&st_iter);
717 status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
718 &cleanup_encoded);
719 if (!NT_STATUS_IS_OK(status)) {
720 talloc_free(snap_out->desc);
721 return status;
722 }
723
724 status = snapper_dbus_str_decode(mem_ctx, cleanup_encoded,
725 &snap_out->cleanup);
726 if (!NT_STATUS_IS_OK(status)) {
727 talloc_free(snap_out->desc);
728 return status;
729 }
730
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);
738 return status;
739 }
740
741 return NT_STATUS_OK;
742 }
743
744 static void snapper_snap_array_print(int32_t num_snaps,
745 struct snapper_snap *snaps)
746 {
747 int i;
748
749 for (i = 0; i < num_snaps; i++) {
750 DEBUG(10, ("id: %u, "
751 "type: %u, "
752 "pre_id: %u, "
753 "time: %ld, "
754 "creator_uid: %u, "
755 "desc: %s, "
756 "cleanup: %s\n",
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,
762 snaps[i].desc,
763 snaps[i].cleanup));
764 snapper_dict_array_print(snaps[i].num_user_data,
765 snaps[i].user_data);
766 }
767 }
768
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)
773 {
774 uint32_t num_snaps;
775 NTSTATUS status;
776 struct snapper_snap *snaps = NULL;
777 DBusMessageIter array_iter;
778
779
780 status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
781 if (!NT_STATUS_IS_OK(status)) {
782 return status;
783 }
784 dbus_message_iter_recurse(iter, &array_iter);
785
786 num_snaps = 0;
787 while (dbus_message_iter_get_arg_type(&array_iter)
788 != DBUS_TYPE_INVALID) {
789 num_snaps++;
790 snaps = talloc_realloc(mem_ctx, snaps, struct snapper_snap,
791 num_snaps);
792 if (snaps == NULL)
793 abort();
794
795 status = snapper_snap_struct_unpack(snaps, &array_iter,
796 &snaps[num_snaps - 1]);
797 if (!NT_STATUS_IS_OK(status)) {
798 talloc_free(snaps);
799 return status;
800 }
801 dbus_message_iter_next(&array_iter);
802 }
803
804 *num_snaps_out = num_snaps;
805 *snaps_out = snaps;
806
807 return NT_STATUS_OK;
808 }
809
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)
814 {
815 NTSTATUS status;
816 DBusMessageIter iter;
817 int msg_type;
818 uint32_t num_snaps;
819 struct snapper_snap *snaps;
820 const char *sig;
821
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);
827 }
828
829 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
830 DEBUG(0,("unexpected list_snaps ret type: %d\n",
831 msg_type));
832 return NT_STATUS_INVALID_PARAMETER;
833 }
834
835 sig = dbus_message_get_signature(rsp_msg);
836 if ((sig == NULL)
837 || (strcmp(sig, SNAPPER_SIG_LIST_SNAPS_RSP) != 0)) {
838 DEBUG(0, ("bad list snaps response sig: %s, "
839 "expected: %s\n",
840 (sig ? sig : "NULL"),
841 SNAPPER_SIG_LIST_SNAPS_RSP));
842 return NT_STATUS_INVALID_PARAMETER;
843 }
844
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;
849 }
850
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;
855 }
856
857 snapper_snap_array_print(num_snaps, snaps);
858
859 *num_snaps_out = num_snaps;
860 *snaps_out = snaps;
861
862 return NT_STATUS_OK;
863 }
864
865 static NTSTATUS snapper_create_snap_pack(TALLOC_CTX *mem_ctx,
866 const char *snapper_conf,
867 const char *desc,
868 uint32_t num_user_data,
869 struct snapper_dict *user_data,
870 DBusMessage **req_msg_out)
871 {
872 DBusMessage *msg;
873 DBusMessageIter args;
874 DBusMessageIter array_iter;
875 DBusMessageIter struct_iter;
876 const char *empty = "";
877 char *str_encoded;
878 uint32_t i;
879 bool ok;
880 TALLOC_CTX *enc_ctx;
881 NTSTATUS status;
882
883 DEBUG(10, ("CreateSingleSnapshot: %s, %s, %s, num user %u\n",
884 snapper_conf, desc, empty, num_user_data));
885
886 enc_ctx = talloc_new(mem_ctx);
887 if (enc_ctx == NULL) {
888 return NT_STATUS_NO_MEMORY;
889 }
890
891 msg = dbus_message_new_method_call("org.opensuse.Snapper",
892 "/org/opensuse/Snapper",
893 "org.opensuse.Snapper",
894 "CreateSingleSnapshot");
895 if (msg == NULL) {
896 DEBUG(0, ("failed to create req msg\n"));
897 talloc_free(enc_ctx);
898 return NT_STATUS_NO_MEMORY;
899 }
900
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);
905 return status;
906 }
907
908 /* append arguments */
909 dbus_message_iter_init_append(msg, &args);
910 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
911 &str_encoded);
912 if (!ok) {
913 dbus_message_unref(msg);
914 talloc_free(enc_ctx);
915 return NT_STATUS_NO_MEMORY;
916 }
917
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);
922 return status;
923 }
924
925 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
926 &str_encoded);
927 if (!ok) {
928 dbus_message_unref(msg);
929 talloc_free(enc_ctx);
930 return NT_STATUS_NO_MEMORY;
931 }
932
933 /* cleanup - no need to encode empty string */
934 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
935 &empty);
936 if (!ok) {
937 dbus_message_unref(msg);
938 talloc_free(enc_ctx);
939 return NT_STATUS_NO_MEMORY;
940 }
941
942 ok = dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
943 SNAPPER_SIG_STRING_DICT,
944 &array_iter);
945 if (!ok) {
946 dbus_message_unref(msg);
947 talloc_free(enc_ctx);
948 return NT_STATUS_NO_MEMORY;
949 }
950
951 for (i = 0; i < num_user_data; i++) {
952 ok = dbus_message_iter_open_container(&array_iter,
953 DBUS_TYPE_DICT_ENTRY,
954 NULL, &struct_iter);
955 if (!ok) {
956 dbus_message_unref(msg);
957 talloc_free(enc_ctx);
958 return NT_STATUS_NO_MEMORY;
959 }
960
961 status = snapper_dbus_str_encode(enc_ctx, user_data[i].key,
962 &str_encoded);
963 if (!NT_STATUS_IS_OK(status)) {
964 dbus_message_unref(msg);
965 talloc_free(enc_ctx);
966 return status;
967 }
968
969 ok = dbus_message_iter_append_basic(&struct_iter,
970 DBUS_TYPE_STRING,
971 &str_encoded);
972 if (!ok) {
973 dbus_message_unref(msg);
974 talloc_free(enc_ctx);
975 return NT_STATUS_NO_MEMORY;
976 }
977
978 status = snapper_dbus_str_encode(enc_ctx, user_data[i].val,
979 &str_encoded);
980 if (!NT_STATUS_IS_OK(status)) {
981 dbus_message_unref(msg);
982 talloc_free(enc_ctx);
983 return status;
984 }
985
986 ok = dbus_message_iter_append_basic(&struct_iter,
987 DBUS_TYPE_STRING,
988 &str_encoded);
989 if (!ok) {
990 dbus_message_unref(msg);
991 talloc_free(enc_ctx);
992 return NT_STATUS_NO_MEMORY;
993 }
994
995 ok = dbus_message_iter_close_container(&array_iter, &struct_iter);
996 if (!ok) {
997 dbus_message_unref(msg);
998 talloc_free(enc_ctx);
999 return NT_STATUS_NO_MEMORY;
1000 }
1001 }
1002
1003 ok = dbus_message_iter_close_container(&args, &array_iter);
1004 if (!ok) {
1005 dbus_message_unref(msg);
1006 talloc_free(enc_ctx);
1007 return NT_STATUS_NO_MEMORY;
1008 }
1009
1010 *req_msg_out = msg;
1011
1012 return NT_STATUS_OK;
1013 }
1014
1015 static NTSTATUS snapper_create_snap_unpack(DBusConnection *conn,
1016 DBusMessage *rsp_msg,
1017 uint32_t *snap_id_out)
1018 {
1019 NTSTATUS status;
1020 DBusMessageIter iter;
1021 int msg_type;
1022 const char *sig;
1023 uint32_t snap_id;
1024
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);
1031 }
1032
1033 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
1034 DEBUG(0, ("unexpected create snap ret type: %d\n",
1035 msg_type));
1036 return NT_STATUS_INVALID_PARAMETER;
1037 }
1038
1039 sig = dbus_message_get_signature(rsp_msg);
1040 if ((sig == NULL)
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;
1045 }
1046
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;
1051 }
1052
1053 status = snapper_type_check_get(&iter, DBUS_TYPE_UINT32, &snap_id);
1054 if (!NT_STATUS_IS_OK(status)) {
1055 return status;
1056 }
1057 *snap_id_out = snap_id;
1058
1059 return NT_STATUS_OK;
1060 }
1061
1062 static NTSTATUS snapper_del_snap_pack(TALLOC_CTX *mem_ctx,
1063 const char *snapper_conf,
1064 uint32_t snap_id,
1065 DBusMessage **req_msg_out)
1066 {
1067 DBusMessage *msg;
1068 DBusMessageIter args;
1069 DBusMessageIter array_iter;
1070 char *conf_encoded;
1071 bool ok;
1072 NTSTATUS status;
1073
1074 msg = dbus_message_new_method_call("org.opensuse.Snapper",
1075 "/org/opensuse/Snapper",
1076 "org.opensuse.Snapper",
1077 "DeleteSnapshots");
1078 if (msg == NULL) {
1079 DEBUG(0, ("failed to create req msg\n"));
1080 return NT_STATUS_NO_MEMORY;
1081 }
1082
1083 status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
1084 if (!NT_STATUS_IS_OK(status)) {
1085 dbus_message_unref(msg);
1086 return status;
1087 }
1088
1089 /* append arguments */
1090 dbus_message_iter_init_append(msg, &args);
1091 ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
1092 &conf_encoded);
1093 if (!ok) {
1094 talloc_free(conf_encoded);
1095 dbus_message_unref(msg);
1096 return NT_STATUS_NO_MEMORY;
1097 }
1098
1099 ok = dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
1100 DBUS_TYPE_UINT32_AS_STRING,
1101 &array_iter);
1102 if (!ok) {
1103 talloc_free(conf_encoded);
1104 dbus_message_unref(msg);
1105 return NT_STATUS_NO_MEMORY;
1106 }
1107
1108 ok = dbus_message_iter_append_basic(&array_iter,
1109 DBUS_TYPE_UINT32,
1110 &snap_id);
1111 if (!ok) {
1112 talloc_free(conf_encoded);
1113 dbus_message_unref(msg);
1114 return NT_STATUS_NO_MEMORY;
1115 }
1116
1117 dbus_message_iter_close_container(&args, &array_iter);
1118 *req_msg_out = msg;
1119
1120 return NT_STATUS_OK;
1121 }
1122
1123 static NTSTATUS snapper_del_snap_unpack(DBusConnection *conn,
1124 DBusMessage *rsp_msg)
1125 {
1126 int msg_type;
1127 const char *sig;
1128
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);
1134 }
1135
1136 if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
1137 DEBUG(0, ("unexpected del snap ret type: %d\n",
1138 msg_type));
1139 return NT_STATUS_INVALID_PARAMETER;
1140 }
1141
1142 sig = dbus_message_get_signature(rsp_msg);
1143 if ((sig == NULL)
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;
1148 }
1149
1150 /* no parameters in response */
1151
1152 return NT_STATUS_OK;
1153 }
1154
1155 static NTSTATUS snapper_list_snaps_at_time_pack(TALLOC_CTX *mem_ctx,
1156 const char *snapper_conf,
1157 time_t time_lower,
1158 time_t time_upper,
1159 DBusMessage **req_msg_out)
1160 {
1161 DBusMessage *msg;
1162 DBusMessageIter args;
1163 char *conf_encoded;
1164 NTSTATUS status;
1165
1166 msg = dbus_message_new_method_call("org.opensuse.Snapper",
1167 "/org/opensuse/Snapper",
1168 "org.opensuse.Snapper",
1169 "ListSnapshotsAtTime");
1170 if (msg == NULL) {
1171 DEBUG(0, ("failed to create list snaps message\n"));
1172 return NT_STATUS_NO_MEMORY;
1173 }
1174
1175 status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
1176 if (!NT_STATUS_IS_OK(status)) {
1177 dbus_message_unref(msg);
1178 return status;
1179 }
1180
1181 dbus_message_iter_init_append(msg, &args);
1182 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
1183 &conf_encoded)) {
1184 talloc_free(conf_encoded);
1185 dbus_message_unref(msg);
1186 return NT_STATUS_NO_MEMORY;
1187 }
1188
1189 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT64,
1190 &time_lower)) {
1191 talloc_free(conf_encoded);
1192 dbus_message_unref(msg);
1193 return NT_STATUS_NO_MEMORY;
1194 }
1195
1196 if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT64,
1197 &time_upper)) {
1198 talloc_free(conf_encoded);
1199 dbus_message_unref(msg);
1200 return NT_STATUS_NO_MEMORY;
1201 }
1202
1203 *req_msg_out = msg;
1204
1205 return NT_STATUS_OK;
1206 }
1207 /* no snapper_list_snaps_at_time_unpack, use snapper_list_snaps_unpack */
1208
1209 /*
1210 * Determine the snapper snapshot id given a path.
1211 * Ideally this should be determined via a lookup.
1212 */
1213 static NTSTATUS snapper_snap_path_to_id(TALLOC_CTX *mem_ctx,
1214 const char *snap_path,
1215 uint32_t *snap_id_out)
1216 {
1217 char *path_dup;
1218 char *str_idx;
1219 char *str_end;
1220 uint32_t snap_id;
1221
1222 path_dup = talloc_strdup(mem_ctx, snap_path);
1223 if (path_dup == NULL) {
1224 return NT_STATUS_NO_MEMORY;
1225 }
1226
1227 /* trim trailing '/' */
1228 str_idx = path_dup + strlen(path_dup) - 1;
1229 while (*str_idx == '/') {
1230 *str_idx = '\0';
1231 str_idx--;
1232 }
1233
1234 str_idx = strrchr(path_dup, '/');
1235 if ((str_idx == NULL)
1236 || (strcmp(str_idx + 1, "snapshot") != 0)) {
1237 talloc_free(path_dup);
1238 return NT_STATUS_INVALID_PARAMETER;
1239 }
1240
1241 while (*str_idx == '/') {
1242 *str_idx = '\0';
1243 str_idx--;
1244 }
1245
1246 str_idx = strrchr(path_dup, '/');
1247 if (str_idx == NULL) {
1248 talloc_free(path_dup);
1249 return NT_STATUS_INVALID_PARAMETER;
1250 }
1251
1252 str_idx++;
1253 snap_id = strtoul(str_idx, &str_end, 10);
1254 if (str_idx == str_end) {
1255 talloc_free(path_dup);
1256 return NT_STATUS_INVALID_PARAMETER;
1257 }
1258
1259 talloc_free(path_dup);
1260 *snap_id_out = snap_id;
1261 return NT_STATUS_OK;
1262 }
1263
1264 /*
1265 * Determine the snapper snapshot path given an id and base.
1266 * Ideally this should be determined via a lookup.
1267 */
1268 static NTSTATUS snapper_snap_id_to_path(TALLOC_CTX *mem_ctx,
1269 const char *base_path,
1270 uint32_t snap_id,
1271 char **snap_path_out)
1272 {
1273 char *snap_path;
1274
1275 snap_path = talloc_asprintf(mem_ctx, "%s/.snapshots/%u/snapshot",
1276 base_path, snap_id);
1277 if (snap_path == NULL) {
1278 return NT_STATUS_NO_MEMORY;
1279 }
1280
1281 *snap_path_out = snap_path;
1282 return NT_STATUS_OK;
1283 }
1284
1285 static NTSTATUS snapper_get_conf_call(TALLOC_CTX *mem_ctx,
1286 DBusConnection *dconn,
1287 const char *path,
1288 char **conf_name_out,
1289 char **base_path_out)
1290 {
1291 NTSTATUS status;
1292 DBusMessage *req_msg;
1293 DBusMessage *rsp_msg;
1294 uint32_t num_confs = 0;
1295 struct snapper_conf *confs = NULL;
1296 struct snapper_conf *conf;
1297 char *conf_name;
1298 char *base_path;
1299
1300 status = snapper_list_confs_pack(&req_msg);
1301 if (!NT_STATUS_IS_OK(status)) {
1302 goto err_out;
1303 }
1304
1305 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1306 if (!NT_STATUS_IS_OK(status)) {
1307 goto err_req_free;
1308 }
1309
1310 status = snapper_list_confs_unpack(mem_ctx, dconn, rsp_msg,
1311 &num_confs, &confs);
1312 if (!NT_STATUS_IS_OK(status)) {
1313 goto err_rsp_free;
1314 }
1315
1316 /*
1317 * for now we only support shares where the path directly corresponds
1318 * to a snapper configuration.
1319 */
1320 conf = snapper_conf_array_base_find(num_confs, confs,
1321 path);
1322 if (conf == NULL) {
1323 status = NT_STATUS_NOT_SUPPORTED;
1324 goto err_array_free;
1325 }
1326
1327 conf_name = talloc_strdup(mem_ctx, conf->name);
1328 if (conf_name == NULL) {
1329 status = NT_STATUS_NO_MEMORY;
1330 goto err_array_free;
1331 }
1332 base_path = talloc_strdup(mem_ctx, conf->mnt);
1333 if (base_path == NULL) {
1334 status = NT_STATUS_NO_MEMORY;
1335 goto err_conf_name_free;
1336 }
1337
1338 talloc_free(confs);
1339 dbus_message_unref(rsp_msg);
1340 dbus_message_unref(req_msg);
1341
1342 *conf_name_out = conf_name;
1343 *base_path_out = base_path;
1344
1345 return NT_STATUS_OK;
1346
1347 err_conf_name_free:
1348 talloc_free(conf_name);
1349 err_array_free:
1350 talloc_free(confs);
1351 err_rsp_free:
1352 dbus_message_unref(rsp_msg);
1353 err_req_free:
1354 dbus_message_unref(req_msg);
1355 err_out:
1356 return status;
1357 }
1358
1359 /*
1360 * Check whether a path can be shadow copied. Return the base volume, allowing
1361 * the caller to determine if multiple paths lie on the same base volume.
1362 */
1363 static NTSTATUS snapper_snap_check_path(struct vfs_handle_struct *handle,
1364 TALLOC_CTX *mem_ctx,
1365 const char *service_path,
1366 char **base_volume)
1367 {
1368 NTSTATUS status;
1369 DBusConnection *dconn;
1370 char *conf_name;
1371 char *base_path;
1372
1373 dconn = snapper_dbus_conn_create();
1374 if (dconn == NULL) {
1375 return NT_STATUS_UNSUCCESSFUL;
1376 }
1377
1378 status = snapper_get_conf_call(mem_ctx, dconn, service_path,
1379 &conf_name, &base_path);
1380 if (!NT_STATUS_IS_OK(status)) {
1381 goto err_conn_close;
1382 }
1383
1384 talloc_free(conf_name);
1385 *base_volume = base_path;
1386 snapper_dbus_conn_destroy(dconn);
1387
1388 return NT_STATUS_OK;
1389
1390 err_conn_close:
1391 snapper_dbus_conn_destroy(dconn);
1392 return status;
1393 }
1394
1395 static NTSTATUS snapper_create_snap_call(TALLOC_CTX *mem_ctx,
1396 DBusConnection *dconn,
1397 const char *conf_name,
1398 const char *base_path,
1399 const char *snap_desc,
1400 uint32_t num_user_data,
1401 struct snapper_dict *user_data,
1402 char **snap_path_out)
1403 {
1404 NTSTATUS status;
1405 DBusMessage *req_msg;
1406 DBusMessage *rsp_msg;
1407 uint32_t snap_id = 0;
1408 char *snap_path;
1409
1410 status = snapper_create_snap_pack(mem_ctx,
1411 conf_name,
1412 snap_desc,
1413 num_user_data,
1414 user_data,
1415 &req_msg);
1416 if (!NT_STATUS_IS_OK(status)) {
1417 goto err_out;
1418 }
1419
1420 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1421 if (!NT_STATUS_IS_OK(status)) {
1422 goto err_req_free;
1423 }
1424
1425 status = snapper_create_snap_unpack(dconn, rsp_msg, &snap_id);
1426 if (!NT_STATUS_IS_OK(status)) {
1427 goto err_rsp_free;
1428 }
1429
1430 status = snapper_snap_id_to_path(mem_ctx, base_path, snap_id,
1431 &snap_path);
1432 if (!NT_STATUS_IS_OK(status)) {
1433 goto err_rsp_free;
1434 }
1435
1436 dbus_message_unref(rsp_msg);
1437 dbus_message_unref(req_msg);
1438
1439 DEBUG(6, ("created new snapshot %u at %s\n", snap_id, snap_path));
1440 *snap_path_out = snap_path;
1441
1442 return NT_STATUS_OK;
1443
1444 err_rsp_free:
1445 dbus_message_unref(rsp_msg);
1446 err_req_free:
1447 dbus_message_unref(req_msg);
1448 err_out:
1449 return status;
1450 }
1451
1452 static NTSTATUS snapper_snap_create(struct vfs_handle_struct *handle,
1453 TALLOC_CTX *mem_ctx,
1454 const char *base_volume,
1455 time_t *tstamp,
1456 bool rw,
1457 char **_base_path,
1458 char **_snap_path)
1459 {
1460 DBusConnection *dconn;
1461 NTSTATUS status;
1462 char *conf_name;
1463 char *base_path;
1464 char *snap_path = NULL;
1465 TALLOC_CTX *tmp_ctx;
1466
1467 tmp_ctx = talloc_new(mem_ctx);
1468 if (tmp_ctx == NULL) {
1469 return NT_STATUS_NO_MEMORY;
1470 }
1471
1472 dconn = snapper_dbus_conn_create();
1473 if (dconn == NULL) {
1474 talloc_free(tmp_ctx);
1475 return NT_STATUS_UNSUCCESSFUL;
1476 }
1477
1478 status = snapper_get_conf_call(tmp_ctx, dconn, base_volume,
1479 &conf_name, &base_path);
1480 if (!NT_STATUS_IS_OK(status)) {
1481 snapper_dbus_conn_destroy(dconn);
1482 talloc_free(tmp_ctx);
1483 return status;
1484 }
1485
1486 status = snapper_create_snap_call(tmp_ctx, dconn,
1487 conf_name, base_path,
1488 "Snapshot created by Samba",
1489 0, NULL,
1490 &snap_path);
1491 if (!NT_STATUS_IS_OK(status)) {
1492 snapper_dbus_conn_destroy(dconn);
1493 talloc_free(tmp_ctx);
1494 return status;
1495 }
1496
1497 snapper_dbus_conn_destroy(dconn);
1498 *_base_path = talloc_steal(mem_ctx, base_path);
1499 *_snap_path = talloc_steal(mem_ctx, snap_path);
1500 talloc_free(tmp_ctx);
1501
1502 return NT_STATUS_OK;
1503 }
1504
1505 static NTSTATUS snapper_delete_snap_call(TALLOC_CTX *mem_ctx,
1506 DBusConnection *dconn,
1507 const char *conf_name,
1508 uint32_t snap_id)
1509 {
1510 NTSTATUS status;
1511 DBusMessage *req_msg = NULL;
1512 DBusMessage *rsp_msg;
1513
1514 status = snapper_del_snap_pack(mem_ctx, conf_name, snap_id, &req_msg);
1515 if (!NT_STATUS_IS_OK(status)) {
1516 goto err_out;
1517 }
1518
1519 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1520 if (!NT_STATUS_IS_OK(status)) {
1521 goto err_req_free;
1522 }
1523
1524 status = snapper_del_snap_unpack(dconn, rsp_msg);
1525 if (!NT_STATUS_IS_OK(status)) {
1526 goto err_rsp_free;
1527 }
1528
1529 dbus_message_unref(rsp_msg);
1530 dbus_message_unref(req_msg);
1531
1532 DEBUG(6, ("deleted snapshot %u\n", snap_id));
1533
1534 return NT_STATUS_OK;
1535
1536 err_rsp_free:
1537 dbus_message_unref(rsp_msg);
1538 err_req_free:
1539 dbus_message_unref(req_msg);
1540 err_out:
1541 return status;
1542 }
1543
1544 static NTSTATUS snapper_snap_delete(struct vfs_handle_struct *handle,
1545 TALLOC_CTX *mem_ctx,
1546 char *base_path,
1547 char *snap_path)
1548 {
1549 DBusConnection *dconn;
1550 NTSTATUS status;
1551 char *conf_name;
1552 char *snap_base_path;
1553 uint32_t snap_id;
1554 TALLOC_CTX *tmp_ctx;
1555
1556 tmp_ctx = talloc_new(mem_ctx);
1557 if (tmp_ctx == NULL) {
1558 return NT_STATUS_NO_MEMORY;
1559 }
1560
1561 dconn = snapper_dbus_conn_create();
1562 if (dconn == NULL) {
1563 talloc_free(tmp_ctx);
1564 return NT_STATUS_UNSUCCESSFUL;
1565 }
1566
1567 status = snapper_get_conf_call(tmp_ctx, dconn, base_path,
1568 &conf_name, &snap_base_path);
1569 if (!NT_STATUS_IS_OK(status)) {
1570 snapper_dbus_conn_destroy(dconn);
1571 talloc_free(tmp_ctx);
1572 return status;
1573 }
1574
1575 status = snapper_snap_path_to_id(tmp_ctx, snap_path, &snap_id);
1576 if (!NT_STATUS_IS_OK(status)) {
1577 snapper_dbus_conn_destroy(dconn);
1578 talloc_free(tmp_ctx);
1579 return status;
1580 }
1581
1582 status = snapper_delete_snap_call(tmp_ctx, dconn, conf_name, snap_id);
1583 if (!NT_STATUS_IS_OK(status)) {
1584 snapper_dbus_conn_destroy(dconn);
1585 talloc_free(tmp_ctx);
1586 return status;
1587 }
1588
1589 snapper_dbus_conn_destroy(dconn);
1590 talloc_free(tmp_ctx);
1591
1592 return NT_STATUS_OK;
1593 }
1594
1595 /* sc_data used as parent talloc context for all labels */
1596 static int snapper_get_shadow_copy_data(struct vfs_handle_struct *handle,
1597 struct files_struct *fsp,
1598 struct shadow_copy_data *sc_data,
1599 bool labels)
1600 {
1601 DBusConnection *dconn;
1602 TALLOC_CTX *tmp_ctx;
1603 NTSTATUS status;
1604 char *conf_name;
1605 char *base_path;
1606 DBusMessage *req_msg = NULL;
1607 DBusMessage *rsp_msg;
1608 uint32_t num_snaps;
1609 struct snapper_snap *snaps;
1610 uint32_t i;
1611 uint32_t lbl_off;
1612
1613 tmp_ctx = talloc_new(sc_data);
1614 if (tmp_ctx == NULL) {
1615 status = NT_STATUS_NO_MEMORY;
1616 goto err_out;
1617 }
1618
1619 dconn = snapper_dbus_conn_create();
1620 if (dconn == NULL) {
1621 status = NT_STATUS_UNSUCCESSFUL;
1622 goto err_mem_ctx_free;
1623 }
1624
1625 if (fsp->conn->connectpath == NULL) {
1626 status = NT_STATUS_INVALID_PARAMETER;
1627 goto err_conn_free;
1628 }
1629
1630 status = snapper_get_conf_call(tmp_ctx, dconn,
1631 fsp->conn->connectpath,
1632 &conf_name,
1633 &base_path);
1634 if (!NT_STATUS_IS_OK(status)) {
1635 goto err_conn_free;
1636 }
1637
1638 status = snapper_list_snaps_pack(tmp_ctx, conf_name, &req_msg);
1639 if (!NT_STATUS_IS_OK(status)) {
1640 goto err_conn_free;
1641 }
1642
1643 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1644 if (!NT_STATUS_IS_OK(status)) {
1645 goto err_req_free;
1646 }
1647
1648 status = snapper_list_snaps_unpack(tmp_ctx, rsp_msg,
1649 &num_snaps, &snaps);
1650 if (!NT_STATUS_IS_OK(status)) {
1651 goto err_rsp_free;
1652 }
1653 /* we should always get at least one snapshot (current) */
1654 if (num_snaps == 0) {
1655 DEBUG(1, ("zero snapshots in snap list response\n"));
1656 status = NT_STATUS_UNSUCCESSFUL;
1657 goto err_rsp_free;
1658 }
1659
1660 /* subtract 1, (current) snapshot is not returned */
1661 sc_data->num_volumes = num_snaps - 1;
1662 sc_data->labels = NULL;
1663
1664 if ((labels == false) || (sc_data->num_volumes == 0)) {
1665 /* tokens need not be added to the labels array */
1666 goto done;
1667 }
1668
1669 sc_data->labels = talloc_array(sc_data, SHADOW_COPY_LABEL,
1670 sc_data->num_volumes);
1671 if (sc_data->labels == NULL) {
1672 status = NT_STATUS_NO_MEMORY;
1673 goto err_rsp_free;
1674 }
1675
1676 /* start at end for decending order, do not include 0 (current) */
1677 lbl_off = 0;
1678 for (i = num_snaps - 1; i > 0; i--) {
1679 char *lbl = sc_data->labels[lbl_off++];
1680 struct tm gmt_snap_time;
1681 struct tm *tm_ret;
1682 size_t str_sz;
1683
1684 tm_ret = gmtime_r((time_t *)&snaps[i].time, &gmt_snap_time);
1685 if (tm_ret == NULL) {
1686 status = NT_STATUS_UNSUCCESSFUL;
1687 goto err_labels_free;
1688 }
1689 str_sz = strftime(lbl, sizeof(SHADOW_COPY_LABEL),
1690 "@GMT-%Y.%m.%d-%H.%M.%S", &gmt_snap_time);
1691 if (str_sz == 0) {
1692 status = NT_STATUS_UNSUCCESSFUL;
1693 goto err_labels_free;
1694 }
1695 }
1696
1697 done:
1698 talloc_free(tmp_ctx);
1699 dbus_message_unref(rsp_msg);
1700 dbus_message_unref(req_msg);
1701 snapper_dbus_conn_destroy(dconn);
1702
1703 return 0;
1704
1705 err_labels_free:
1706 TALLOC_FREE(sc_data->labels);
1707 err_rsp_free:
1708 dbus_message_unref(rsp_msg);
1709 err_req_free:
1710 dbus_message_unref(req_msg);
1711 err_conn_free:
1712 snapper_dbus_conn_destroy(dconn);
1713 err_mem_ctx_free:
1714 talloc_free(tmp_ctx);
1715 err_out:
1716 errno = map_errno_from_nt_status(status);
1717 return -1;
1718 }
1719
1720 static bool snapper_gmt_strip_snapshot(TALLOC_CTX *mem_ctx,
1721 struct vfs_handle_struct *handle,
1722 const char *name,
1723 time_t *ptimestamp,
1724 char **pstripped)
1725 {
1726 struct tm tm;
1727 time_t timestamp;
1728 const char *p;
1729 char *q;
1730 char *stripped;
1731 size_t rest_len, dst_len;
1732 ptrdiff_t len_before_gmt;
1733
1734 p = strstr_m(name, "@GMT-");
1735 if (p == NULL) {
1736 goto no_snapshot;
1737 }
1738 if ((p > name) && (p[-1] != '/')) {
1739 goto no_snapshot;
1740 }
1741 len_before_gmt = p - name;
1742 q = strptime(p, GMT_FORMAT, &tm);
1743 if (q == NULL) {
1744 goto no_snapshot;
1745 }
1746 tm.tm_isdst = -1;
1747 timestamp = timegm(&tm);
1748 if (timestamp == (time_t)-1) {
1749 goto no_snapshot;
1750 }
1751 if (q[0] == '\0') {
1752 /*
1753 * The name consists of only the GMT token or the GMT
1754 * token is at the end of the path. XP seems to send
1755 * @GMT- at the end under certain circumstances even
1756 * with a path prefix.
1757 */
1758 if (pstripped != NULL) {
1759 if (len_before_gmt > 0) {
1760 /*
1761 * There is a slash before
1762 * the @GMT-. Remove it.
1763 */
1764 len_before_gmt -= 1;
1765 }
1766 stripped = talloc_strndup(mem_ctx, name,
1767 len_before_gmt);
1768 if (stripped == NULL) {
1769 return false;
1770 }
1771 *pstripped = stripped;
1772 }
1773 *ptimestamp = timestamp;
1774 return true;
1775 }
1776 if (q[0] != '/') {
1777 /*
1778 * It is not a complete path component, i.e. the path
1779 * component continues after the gmt-token.
1780 */
1781 goto no_snapshot;
1782 }
1783 q += 1;
1784
1785 rest_len = strlen(q);
1786 dst_len = len_before_gmt + rest_len;
1787
1788 if (pstripped != NULL) {
1789 stripped = talloc_array(mem_ctx, char, dst_len+1);
1790 if (stripped == NULL) {
1791 errno = ENOMEM;
1792 return false;
1793 }
1794 if (p > name) {
1795 memcpy(stripped, name, len_before_gmt);
1796 }
1797 if (rest_len > 0) {
1798 memcpy(stripped + len_before_gmt, q, rest_len);
1799 }
1800 stripped[dst_len] = '\0';
1801 *pstripped = stripped;
1802 }
1803 *ptimestamp = timestamp;
1804 return true;
1805 no_snapshot:
1806 *ptimestamp = 0;
1807 return true;
1808 }
1809
1810 static NTSTATUS snapper_get_snap_at_time_call(TALLOC_CTX *mem_ctx,
1811 DBusConnection *dconn,
1812 const char *conf_name,
1813 const char *base_path,
1814 time_t snaptime,
1815 char **snap_path_out)
1816 {
1817 NTSTATUS status;
1818 DBusMessage *req_msg = NULL;
1819 DBusMessage *rsp_msg;
1820 uint32_t num_snaps;
1821 struct snapper_snap *snaps;
1822 char *snap_path;
1823
1824 status = snapper_list_snaps_at_time_pack(mem_ctx,
1825 conf_name,
1826 snaptime,
1827 snaptime,
1828 &req_msg);
1829 if (!NT_STATUS_IS_OK(status)) {
1830 goto err_out;
1831 }
1832
1833 status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
1834 if (!NT_STATUS_IS_OK(status)) {
1835 goto err_req_free;
1836 }
1837
1838 status = snapper_list_snaps_unpack(mem_ctx, rsp_msg,
1839 &num_snaps, &snaps);
1840 if (!NT_STATUS_IS_OK(status)) {
1841 goto err_rsp_free;
1842 }
1843
1844 if (num_snaps == 0) {
1845 DEBUG(4, ("no snapshots found with time: %lu\n",
1846 (unsigned long)snaptime));
1847 status = NT_STATUS_INVALID_PARAMETER;
1848 goto err_snap_array_free;
1849 } else if (num_snaps > 0) {
1850 DEBUG(4, ("got %u snapshots for single time %lu, using top\n",
1851 num_snaps, (unsigned long)snaptime));
1852 }
1853
1854 status = snapper_snap_id_to_path(mem_ctx, base_path, snaps[0].id,
1855 &snap_path);
1856 if (!NT_STATUS_IS_OK(status)) {
1857 goto err_snap_array_free;
1858 }
1859
1860 *snap_path_out = snap_path;
1861 err_snap_array_free:
1862 talloc_free(snaps);
1863 err_rsp_free:
1864 dbus_message_unref(rsp_msg);
1865 err_req_free:
1866 dbus_message_unref(req_msg);
1867 err_out:
1868 return status;
1869 }
1870
1871 static NTSTATUS snapper_snap_path_expand(struct connection_struct *conn,
1872 TALLOC_CTX *mem_ctx,
1873 time_t snap_time,
1874 char **snap_dir_out)
1875 {
1876 DBusConnection *dconn;
1877 NTSTATUS status;
1878 char *conf_name;
1879 char *base_path;
1880 char *snap_path = NULL;
1881
1882 dconn = snapper_dbus_conn_create();
1883 if (dconn == NULL) {
1884 status = NT_STATUS_UNSUCCESSFUL;
1885 goto err_out;
1886 }
1887
1888 if (conn->connectpath == NULL) {
1889 status = NT_STATUS_INVALID_PARAMETER;
1890 goto err_conn_free;
1891 }
1892
1893 status = snapper_get_conf_call(mem_ctx, dconn,
1894 conn->connectpath,
1895 &conf_name,
1896 &base_path);
1897 if (!NT_STATUS_IS_OK(status)) {
1898 goto err_conn_free;
1899 }
1900
1901 status = snapper_get_snap_at_time_call(mem_ctx, dconn,
1902 conf_name, base_path, snap_time,
1903 &snap_path);
1904 if (!NT_STATUS_IS_OK(status)) {
1905 goto err_conf_name_free;
1906 }
1907
1908 /* confirm snapshot path is nested under base path */
1909 if (strncmp(snap_path, base_path, strlen(base_path)) != 0) {
1910 status = NT_STATUS_INVALID_PARAMETER;
1911 goto err_snap_path_free;
1912 }
1913
1914 talloc_free(conf_name);
1915 talloc_free(base_path);
1916 snapper_dbus_conn_destroy(dconn);
1917 *snap_dir_out = snap_path;
1918
1919 return NT_STATUS_OK;
1920
1921 err_snap_path_free:
1922 talloc_free(snap_path);
1923 err_conf_name_free:
1924 talloc_free(conf_name);
1925 talloc_free(base_path);
1926 err_conn_free:
1927 snapper_dbus_conn_destroy(dconn);
1928 err_out:
1929 return status;
1930 }
1931
1932 static char *snapper_gmt_convert(TALLOC_CTX *mem_ctx,
1933 struct vfs_handle_struct *handle,
1934 const char *name, time_t timestamp)
1935 {
1936 char *snap_path = NULL;
1937 char *path = NULL;
1938 NTSTATUS status;
1939 int saved_errno;
1940
1941 status = snapper_snap_path_expand(handle->conn, mem_ctx, timestamp,
1942 &snap_path);
1943 if (!NT_STATUS_IS_OK(status)) {
1944 errno = map_errno_from_nt_status(status);
1945 goto err_out;
1946 }
1947
1948 path = talloc_asprintf(mem_ctx, "%s/%s", snap_path, name);
1949 if (path == NULL) {
1950 errno = ENOMEM;
1951 goto err_snap_path_free;
1952 }
1953
1954 DEBUG(10, ("converted %s/%s @ time to %s\n",
1955 handle->conn->connectpath, name, path));
1956 return path;
1957
1958 err_snap_path_free:
1959 saved_errno = errno;
1960 talloc_free(snap_path);
1961 errno = saved_errno;
1962 err_out:
1963 return NULL;
1964 }
1965
1966 static DIR *snapper_gmt_opendir(vfs_handle_struct *handle,
1967 const struct smb_filename *smb_fname,
1968 const char *mask,
1969 uint32_t attr)
1970 {
1971 time_t timestamp;
1972 char *stripped;
1973 DIR *ret;
1974 int saved_errno;
1975 char *conv;
1976 struct smb_filename *conv_smb_fname = NULL;
1977
1978 if (!snapper_gmt_strip_snapshot(talloc_tos(),
1979 handle,
1980 smb_fname->base_name,
1981 &timestamp,
1982 &stripped)) {
1983 return NULL;
1984 }
1985 if (timestamp == 0) {
1986 return SMB_VFS_NEXT_OPENDIR(handle, smb_fname, mask, attr);
1987 }
1988 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
1989 TALLOC_FREE(stripped);
1990 if (conv == NULL) {
1991 return NULL;
1992 }
1993 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
1994 conv,
1995 NULL,
1996 NULL,
1997 smb_fname->flags);
1998 if (conv_smb_fname == NULL) {
1999 TALLOC_FREE(conv);
2000 errno = ENOMEM;
2001 return NULL;
2002 }
2003
2004 ret = SMB_VFS_NEXT_OPENDIR(handle, conv_smb_fname, mask, attr);
2005 saved_errno = errno;
2006 TALLOC_FREE(conv);
2007 TALLOC_FREE(conv_smb_fname);
2008 errno = saved_errno;
2009 return ret;
2010 }
2011
2012 static int snapper_gmt_rename(vfs_handle_struct *handle,
2013 const struct smb_filename *smb_fname_src,
2014 const struct smb_filename *smb_fname_dst)
2015 {
2016 time_t timestamp_src, timestamp_dst;
2017
2018 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2019 smb_fname_src->base_name,
2020 &timestamp_src, NULL)) {
2021 return -1;
2022 }
2023 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2024 smb_fname_dst->base_name,
2025 &timestamp_dst, NULL)) {
2026 return -1;
2027 }
2028 if (timestamp_src != 0) {
2029 errno = EXDEV;
2030 return -1;
2031 }
2032 if (timestamp_dst != 0) {
2033 errno = EROFS;
2034 return -1;
2035 }
2036 return SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
2037 }
2038
2039 static int snapper_gmt_symlink(vfs_handle_struct *handle,
2040 const char *link_contents,
2041 const struct smb_filename *new_smb_fname)
2042 {
2043 time_t timestamp_old = 0;
2044 time_t timestamp_new = 0;
2045
2046 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2047 handle,
2048 link_contents,
2049 &timestamp_old,
2050 NULL)) {
2051 return -1;
2052 }
2053 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2054 handle,
2055 new_smb_fname->base_name,
2056 &timestamp_new,
2057 NULL)) {
2058 return -1;
2059 }
2060 if ((timestamp_old != 0) || (timestamp_new != 0)) {
2061 errno = EROFS;
2062 return -1;
2063 }
2064 return SMB_VFS_NEXT_SYMLINK(handle, link_contents, new_smb_fname);
2065 }
2066
2067 static int snapper_gmt_link(vfs_handle_struct *handle,
2068 const struct smb_filename *old_smb_fname,
2069 const struct smb_filename *new_smb_fname)
2070 {
2071 time_t timestamp_old = 0;
2072 time_t timestamp_new = 0;
2073
2074 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2075 handle,
2076 old_smb_fname->base_name,
2077 &timestamp_old,
2078 NULL)) {
2079 return -1;
2080 }
2081 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2082 handle,
2083 new_smb_fname->base_name,
2084 &timestamp_new,
2085 NULL)) {
2086 return -1;
2087 }
2088 if ((timestamp_old != 0) || (timestamp_new != 0)) {
2089 errno = EROFS;
2090 return -1;
2091 }
2092 return SMB_VFS_NEXT_LINK(handle, old_smb_fname, new_smb_fname);
2093 }
2094
2095 static int snapper_gmt_stat(vfs_handle_struct *handle,
2096 struct smb_filename *smb_fname)
2097 {
2098 time_t timestamp;
2099 char *stripped, *tmp;
2100 int ret, saved_errno;
2101
2102 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2103 smb_fname->base_name,
2104 &timestamp, &stripped)) {
2105 return -1;
2106 }
2107 if (timestamp == 0) {
2108 return SMB_VFS_NEXT_STAT(handle, smb_fname);
2109 }
2110
2111 tmp = smb_fname->base_name;
2112 smb_fname->base_name = snapper_gmt_convert(talloc_tos(), handle,
2113 stripped, timestamp);
2114 TALLOC_FREE(stripped);
2115
2116 if (smb_fname->base_name == NULL) {
2117 smb_fname->base_name = tmp;
2118 return -1;
2119 }
2120
2121 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
2122 saved_errno = errno;
2123
2124 TALLOC_FREE(smb_fname->base_name);
2125 smb_fname->base_name = tmp;
2126
2127 errno = saved_errno;
2128 return ret;
2129 }
2130
2131 static int snapper_gmt_lstat(vfs_handle_struct *handle,
2132 struct smb_filename *smb_fname)
2133 {
2134 time_t timestamp;
2135 char *stripped, *tmp;
2136 int ret, saved_errno;
2137
2138 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2139 smb_fname->base_name,
2140 &timestamp, &stripped)) {
2141 return -1;
2142 }
2143 if (timestamp == 0) {
2144 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
2145 }
2146
2147 tmp = smb_fname->base_name;
2148 smb_fname->base_name = snapper_gmt_convert(talloc_tos(), handle,
2149 stripped, timestamp);
2150 TALLOC_FREE(stripped);
2151
2152 if (smb_fname->base_name == NULL) {
2153 smb_fname->base_name = tmp;
2154 return -1;
2155 }
2156
2157 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
2158 saved_errno = errno;
2159
2160 TALLOC_FREE(smb_fname->base_name);
2161 smb_fname->base_name = tmp;
2162
2163 errno = saved_errno;
2164 return ret;
2165 }
2166
2167 static int snapper_gmt_fstat(vfs_handle_struct *handle, files_struct *fsp,
2168 SMB_STRUCT_STAT *sbuf)
2169 {
2170 time_t timestamp;
2171 int ret;
2172
2173 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
2174 if (ret == -1) {
2175 return ret;
2176 }
2177 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2178 fsp->fsp_name->base_name,
2179 &timestamp, NULL)) {
2180 return 0;
2181 }
2182 return 0;
2183 }
2184
2185 static int snapper_gmt_open(vfs_handle_struct *handle,
2186 struct smb_filename *smb_fname, files_struct *fsp,
2187 int flags, mode_t mode)
2188 {
2189 time_t timestamp;
2190 char *stripped, *tmp;
2191 int ret, saved_errno;
2192
2193 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2194 smb_fname->base_name,
2195 &timestamp, &stripped)) {
2196 return -1;
2197 }
2198 if (timestamp == 0) {
2199 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
2200 }
2201
2202 tmp = smb_fname->base_name;
2203 smb_fname->base_name = snapper_gmt_convert(talloc_tos(), handle,
2204 stripped, timestamp);
2205 TALLOC_FREE(stripped);
2206
2207 if (smb_fname->base_name == NULL) {
2208 smb_fname->base_name = tmp;
2209 return -1;
2210 }
2211
2212 ret = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
2213 saved_errno = errno;
2214
2215 TALLOC_FREE(smb_fname->base_name);
2216 smb_fname->base_name = tmp;
2217
2218 errno = saved_errno;
2219 return ret;
2220 }
2221
2222 static int snapper_gmt_unlink(vfs_handle_struct *handle,
2223 const struct smb_filename *smb_fname)
2224 {
2225 time_t timestamp;
2226 char *stripped;
2227 int ret, saved_errno;
2228 struct smb_filename *conv;
2229
2230 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2231 smb_fname->base_name,
2232 &timestamp, &stripped)) {
2233 return -1;
2234 }
2235 if (timestamp == 0) {
2236 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
2237 }
2238 conv = cp_smb_filename(talloc_tos(), smb_fname);
2239 if (conv == NULL) {
2240 errno = ENOMEM;
2241 return -1;
2242 }
2243 conv->base_name = snapper_gmt_convert(conv, handle,
2244 stripped, timestamp);
2245 TALLOC_FREE(stripped);
2246 if (conv->base_name == NULL) {
2247 return -1;
2248 }
2249 ret = SMB_VFS_NEXT_UNLINK(handle, conv);
2250 saved_errno = errno;
2251 TALLOC_FREE(conv);
2252 errno = saved_errno;
2253 return ret;
2254 }
2255
2256 static int snapper_gmt_chmod(vfs_handle_struct *handle,
2257 const struct smb_filename *smb_fname,
2258 mode_t mode)
2259 {
2260 time_t timestamp;
2261 char *stripped = NULL;
2262 int ret, saved_errno;
2263 char *conv = NULL;
2264 struct smb_filename *conv_smb_fname = NULL;
2265
2266 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2267 handle,
2268 smb_fname->base_name,
2269 &timestamp,
2270 &stripped)) {
2271 return -1;
2272 }
2273 if (timestamp == 0) {
2274 TALLOC_FREE(stripped);
2275 return SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
2276 }
2277 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2278 TALLOC_FREE(stripped);
2279 if (conv == NULL) {
2280 return -1;
2281 }
2282 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2283 conv,
2284 NULL,
2285 NULL,
2286 smb_fname->flags);
2287 if (conv_smb_fname == NULL) {
2288 TALLOC_FREE(conv);
2289 errno = ENOMEM;
2290 return -1;
2291 }
2292
2293 ret = SMB_VFS_NEXT_CHMOD(handle, conv_smb_fname, mode);
2294 saved_errno = errno;
2295 TALLOC_FREE(conv);
2296 TALLOC_FREE(conv_smb_fname);
2297 errno = saved_errno;
2298 return ret;
2299 }
2300
2301 static int snapper_gmt_chown(vfs_handle_struct *handle,
2302 const struct smb_filename *smb_fname,
2303 uid_t uid,
2304 gid_t gid)
2305 {
2306 time_t timestamp;
2307 char *stripped = NULL;
2308 int ret, saved_errno;
2309 char *conv = NULL;
2310 struct smb_filename *conv_smb_fname = NULL;
2311
2312 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2313 handle,
2314 smb_fname->base_name,
2315 &timestamp,
2316 &stripped)) {
2317 return -1;
2318 }
2319 if (timestamp == 0) {
2320 TALLOC_FREE(stripped);
2321 return SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
2322 }
2323 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2324 TALLOC_FREE(stripped);
2325 if (conv == NULL) {
2326 return -1;
2327 }
2328 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2329 conv,
2330 NULL,
2331 NULL,
2332 smb_fname->flags);
2333 if (conv_smb_fname == NULL) {
2334 TALLOC_FREE(conv);
2335 errno = ENOMEM;
2336 return -1;
2337 }
2338 ret = SMB_VFS_NEXT_CHOWN(handle, conv_smb_fname, uid, gid);
2339 saved_errno = errno;
2340 TALLOC_FREE(conv);
2341 TALLOC_FREE(conv_smb_fname);
2342 errno = saved_errno;
2343 return ret;
2344 }
2345
2346 static int snapper_gmt_chdir(vfs_handle_struct *handle,
2347 const struct smb_filename *smb_fname)
2348 {
2349 time_t timestamp = 0;
2350 char *stripped = NULL;
2351 int ret;
2352 int saved_errno = 0;
2353 char *conv = NULL;
2354 struct smb_filename *conv_smb_fname = NULL;
2355
2356 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2357 handle,
2358 smb_fname->base_name,
2359 &timestamp,
2360 &stripped)) {
2361 return -1;
2362 }
2363 if (timestamp == 0) {
2364 return SMB_VFS_NEXT_CHDIR(handle, smb_fname);
2365 }
2366 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2367 TALLOC_FREE(stripped);
2368 if (conv == NULL) {
2369 return -1;
2370 }
2371 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2372 conv,
2373 NULL,
2374 NULL,
2375 smb_fname->flags);
2376 if (conv_smb_fname == NULL) {
2377 TALLOC_FREE(conv);
2378 errno = ENOMEM;
2379 return -1;
2380 }
2381 ret = SMB_VFS_NEXT_CHDIR(handle, conv_smb_fname);
2382 if (ret == -1) {
2383 saved_errno = errno;
2384 }
2385 TALLOC_FREE(conv);
2386 TALLOC_FREE(conv_smb_fname);
2387 if (saved_errno != 0) {
2388 errno = saved_errno;
2389 }
2390 return ret;
2391 }
2392
2393 static int snapper_gmt_ntimes(vfs_handle_struct *handle,
2394 const struct smb_filename *smb_fname,
2395 struct smb_file_time *ft)
2396 {
2397 time_t timestamp;
2398 char *stripped;
2399 int ret, saved_errno;
2400 struct smb_filename *conv;
2401
2402 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2403 smb_fname->base_name,
2404 &timestamp, &stripped)) {
2405 return -1;
2406 }
2407 if (timestamp == 0) {
2408 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
2409 }
2410 conv = cp_smb_filename(talloc_tos(), smb_fname);
2411 if (conv == NULL) {
2412 errno = ENOMEM;
2413 return -1;
2414 }
2415 conv->base_name = snapper_gmt_convert(conv, handle,
2416 stripped, timestamp);
2417 TALLOC_FREE(stripped);
2418 if (conv->base_name == NULL) {
2419 return -1;
2420 }
2421 ret = SMB_VFS_NEXT_NTIMES(handle, conv, ft);
2422 saved_errno = errno;
2423 TALLOC_FREE(conv);
2424 errno = saved_errno;
2425 return ret;
2426 }
2427
2428 static int snapper_gmt_readlink(vfs_handle_struct *handle,
2429 const struct smb_filename *smb_fname,
2430 char *buf,
2431 size_t bufsiz)
2432 {
2433 time_t timestamp = 0;
2434 char *stripped = NULL;
2435 int ret;
2436 int saved_errno = 0;
2437 struct smb_filename *conv = NULL;
2438
2439 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2440 smb_fname->base_name,
2441 &timestamp, &stripped)) {
2442 return -1;
2443 }
2444 if (timestamp == 0) {
2445 return SMB_VFS_NEXT_READLINK(handle, smb_fname, buf, bufsiz);
2446 }
2447 conv = cp_smb_filename(talloc_tos(), smb_fname);
2448 if (conv == NULL) {
2449 TALLOC_FREE(stripped);
2450 errno = ENOMEM;
2451 return -1;
2452 }
2453 conv->base_name = snapper_gmt_convert(conv, handle,
2454 stripped, timestamp);
2455 TALLOC_FREE(stripped);
2456 if (conv->base_name == NULL) {
2457 return -1;
2458 }
2459 ret = SMB_VFS_NEXT_READLINK(handle, conv, buf, bufsiz);
2460 if (ret == -1) {
2461 saved_errno = errno;
2462 }
2463 TALLOC_FREE(conv);
2464 if (saved_errno != 0) {
2465 errno = saved_errno;
2466 }
2467 return ret;
2468 }
2469
2470 static int snapper_gmt_mknod(vfs_handle_struct *handle,
2471 const struct smb_filename *smb_fname,
2472 mode_t mode,
2473 SMB_DEV_T dev)
2474 {
2475 time_t timestamp = (time_t)0;
2476 char *stripped = NULL;
2477 int ret, saved_errno = 0;
2478 struct smb_filename *conv_smb_fname = NULL;
2479
2480 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2481 smb_fname->base_name,
2482 &timestamp, &stripped)) {
2483 return -1;
2484 }
2485 if (timestamp == 0) {
2486 return SMB_VFS_NEXT_MKNOD(handle, smb_fname, mode, dev);
2487 }
2488 conv_smb_fname = cp_smb_filename(talloc_tos(), smb_fname);
2489 if (conv_smb_fname == NULL) {
2490 errno = ENOMEM;
2491 return -1;
2492 }
2493 conv_smb_fname->base_name = snapper_gmt_convert(conv_smb_fname, handle,
2494 stripped, timestamp);
2495 TALLOC_FREE(stripped);
2496 if (conv_smb_fname->base_name == NULL) {
2497 return -1;
2498 }
2499 ret = SMB_VFS_NEXT_MKNOD(handle, conv_smb_fname, mode, dev);
2500 if (ret == -1) {
2501 saved_errno = errno;
2502 }
2503 TALLOC_FREE(conv_smb_fname);
2504 if (saved_errno != 0) {
2505 errno = saved_errno;
2506 }
2507 return ret;
2508 }
2509
2510 static struct smb_filename *snapper_gmt_realpath(vfs_handle_struct *handle,
2511 TALLOC_CTX *ctx,
2512 const struct smb_filename *smb_fname)
2513 {
2514 time_t timestamp = 0;
2515 char *stripped = NULL;
2516 struct smb_filename *result_fname = NULL;
2517 struct smb_filename *conv_smb_fname = NULL;
2518 int saved_errno = 0;
2519
2520 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2521 smb_fname->base_name,
2522 &timestamp, &stripped)) {
2523 goto done;
2524 }
2525 if (timestamp == 0) {
2526 return SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
2527 }
2528
2529 conv_smb_fname = cp_smb_filename(talloc_tos(), smb_fname);
2530 if (conv_smb_fname == NULL) {
2531 goto done;
2532 }
2533 conv_smb_fname->base_name = snapper_gmt_convert(conv_smb_fname, handle,
2534 stripped, timestamp);
2535 if (conv_smb_fname->base_name == NULL) {
2536 goto done;
2537 }
2538
2539 result_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, conv_smb_fname);
2540
2541 done:
2542 if (result_fname == NULL) {
2543 saved_errno = errno;
2544 }
2545 TALLOC_FREE(conv_smb_fname);
2546 TALLOC_FREE(stripped);
2547 if (saved_errno != 0) {
2548 errno = saved_errno;
2549 }
2550 return result_fname;
2551 }
2552
2553 static NTSTATUS snapper_gmt_fget_nt_acl(vfs_handle_struct *handle,
2554 struct files_struct *fsp,
2555 uint32_t security_info,
2556 TALLOC_CTX *mem_ctx,
2557 struct security_descriptor **ppdesc)
2558 {
2559 time_t timestamp;
2560 char *stripped;
2561 NTSTATUS status;
2562 char *conv;
2563 struct smb_filename *smb_fname = NULL;
2564
2565 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2566 fsp->fsp_name->base_name,
2567 &timestamp, &stripped)) {
2568 return map_nt_error_from_unix(errno);
2569 }
2570 if (timestamp == 0) {
2571 return SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
2572 mem_ctx,
2573 ppdesc);
2574 }
2575 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2576 TALLOC_FREE(stripped);
2577 if (conv == NULL) {
2578 return map_nt_error_from_unix(errno);
2579 }
2580
2581 smb_fname = synthetic_smb_fname(talloc_tos(),
2582 conv,
2583 NULL,
2584 NULL,
2585 fsp->fsp_name->flags);
2586 TALLOC_FREE(conv);
2587 if (smb_fname == NULL) {
2588 return NT_STATUS_NO_MEMORY;
2589 }
2590
2591 status = SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info,
2592 mem_ctx, ppdesc);
2593 TALLOC_FREE(smb_fname);
2594 return status;
2595 }
2596
2597 static NTSTATUS snapper_gmt_get_nt_acl(vfs_handle_struct *handle,
2598 const struct smb_filename *fname,
2599 uint32_t security_info,
2600 TALLOC_CTX *mem_ctx,
2601 struct security_descriptor **ppdesc)
2602 {
2603 time_t timestamp;
2604 char *stripped;
2605 NTSTATUS status;
2606 char *conv;
2607 struct smb_filename *smb_fname = NULL;
2608
2609 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, fname->base_name,
2610 &timestamp, &stripped)) {
2611 return map_nt_error_from_unix(errno);
2612 }
2613 if (timestamp == 0) {
2614 return SMB_VFS_NEXT_GET_NT_ACL(handle, fname, security_info,
2615 mem_ctx, ppdesc);
2616 }
2617 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2618 TALLOC_FREE(stripped);
2619 if (conv == NULL) {
2620 return map_nt_error_from_unix(errno);
2621 }
2622 smb_fname = synthetic_smb_fname(talloc_tos(),
2623 conv,
2624 NULL,
2625 NULL,
2626 fname->flags);
2627 TALLOC_FREE(conv);
2628 if (smb_fname == NULL) {
2629 return NT_STATUS_NO_MEMORY;
2630 }
2631
2632 status = SMB_VFS_NEXT_GET_NT_ACL(handle, smb_fname, security_info,
2633 mem_ctx, ppdesc);
2634 TALLOC_FREE(smb_fname);
2635 return status;
2636 }
2637
2638 static int snapper_gmt_mkdir(vfs_handle_struct *handle,
2639 const struct smb_filename *fname,
2640 mode_t mode)
2641 {
2642 time_t timestamp;
2643 char *stripped;
2644 int ret, saved_errno;
2645 char *conv;
2646 struct smb_filename *smb_fname = NULL;
2647
2648 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, fname->base_name,
2649 &timestamp, &stripped)) {
2650 return -1;
2651 }
2652 if (timestamp == 0) {
2653 return SMB_VFS_NEXT_MKDIR(handle, fname, mode);
2654 }
2655 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2656 TALLOC_FREE(stripped);
2657 if (conv == NULL) {
2658 return -1;
2659 }
2660 smb_fname = synthetic_smb_fname(talloc_tos(),
2661 conv,
2662 NULL,
2663 NULL,
2664 fname->flags);
2665 TALLOC_FREE(conv);
2666 if (smb_fname == NULL) {
2667 errno = ENOMEM;
2668 return -1;
2669 }
2670
2671 ret = SMB_VFS_NEXT_MKDIR(handle, smb_fname, mode);
2672 saved_errno = errno;
2673 TALLOC_FREE(smb_fname);
2674 errno = saved_errno;
2675 return ret;
2676 }
2677
2678 static int snapper_gmt_rmdir(vfs_handle_struct *handle,
2679 const struct smb_filename *fname)
2680 {
2681 time_t timestamp;
2682 char *stripped;
2683 int ret, saved_errno;
2684 char *conv;
2685 struct smb_filename *smb_fname = NULL;
2686
2687 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, fname->base_name,
2688 &timestamp, &stripped)) {
2689 return -1;
2690 }
2691 if (timestamp == 0) {
2692 return SMB_VFS_NEXT_RMDIR(handle, fname);
2693 }
2694 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2695 TALLOC_FREE(stripped);
2696 if (conv == NULL) {
2697 return -1;
2698 }
2699 smb_fname = synthetic_smb_fname(talloc_tos(),
2700 conv,
2701 NULL,
2702 NULL,
2703 fname->flags);
2704 TALLOC_FREE(conv);
2705 if (smb_fname == NULL) {
2706 errno = ENOMEM;
2707 return -1;
2708 }
2709 ret = SMB_VFS_NEXT_RMDIR(handle, smb_fname);
2710 saved_errno = errno;
2711 TALLOC_FREE(smb_fname);
2712 errno = saved_errno;
2713 return ret;
2714 }
2715
2716 static int snapper_gmt_chflags(vfs_handle_struct *handle,
2717 const struct smb_filename *smb_fname,
2718 unsigned int flags)
2719 {
2720 time_t timestamp = 0;
2721 char *stripped = NULL;
2722 int ret = -1;
2723 int saved_errno = 0;
2724 char *conv = NULL;
2725 struct smb_filename *conv_smb_fname = NULL;
2726
2727 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
2728 smb_fname->base_name, &timestamp, &stripped)) {
2729 return -1;
2730 }
2731 if (timestamp == 0) {
2732 return SMB_VFS_NEXT_CHFLAGS(handle, smb_fname, flags);
2733 }
2734 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2735 TALLOC_FREE(stripped);
2736 if (conv == NULL) {
2737 return -1;
2738 }
2739 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2740 conv,
2741 NULL,
2742 NULL,
2743 smb_fname->flags);
2744 TALLOC_FREE(conv);
2745 if (conv_smb_fname == NULL) {
2746 errno = ENOMEM;
2747 return -1;
2748 }
2749 ret = SMB_VFS_NEXT_CHFLAGS(handle, conv_smb_fname, flags);
2750 if (ret == -1) {
2751 saved_errno = errno;
2752 }
2753 TALLOC_FREE(conv_smb_fname);
2754 if (saved_errno != 0) {
2755 errno = saved_errno;
2756 }
2757 return ret;
2758 }
2759
2760 static ssize_t snapper_gmt_getxattr(vfs_handle_struct *handle,
2761 const struct smb_filename *smb_fname,
2762 const char *aname,
2763 void *value,
2764 size_t size)
2765 {
2766 time_t timestamp = 0;
2767 char *stripped = NULL;
2768 ssize_t ret;
2769 int saved_errno = 0;
2770 char *conv = NULL;
2771 struct smb_filename *conv_smb_fname = NULL;
2772
2773 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2774 handle,
2775 smb_fname->base_name,
2776 &timestamp,
2777 &stripped)) {
2778 return -1;
2779 }
2780 if (timestamp == 0) {
2781 return SMB_VFS_NEXT_GETXATTR(handle, smb_fname, aname, value,
2782 size);
2783 }
2784 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2785 TALLOC_FREE(stripped);
2786 if (conv == NULL) {
2787 return -1;
2788 }
2789 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2790 conv,
2791 NULL,
2792 NULL,
2793 smb_fname->flags);
2794 TALLOC_FREE(conv);
2795 if (conv_smb_fname == NULL) {
2796 errno = ENOMEM;
2797 return -1;
2798 }
2799 ret = SMB_VFS_NEXT_GETXATTR(handle, conv_smb_fname, aname, value, size);
2800 if (ret == -1) {
2801 saved_errno = errno;
2802 }
2803 TALLOC_FREE(conv_smb_fname);
2804 TALLOC_FREE(conv);
2805 if (saved_errno != 0) {
2806 errno = saved_errno;
2807 }
2808 return ret;
2809 }
2810
2811 static ssize_t snapper_gmt_listxattr(struct vfs_handle_struct *handle,
2812 const struct smb_filename *smb_fname,
2813 char *list, size_t size)
2814 {
2815 time_t timestamp = 0;
2816 char *stripped = NULL;
2817 ssize_t ret;
2818 int saved_errno = 0;
2819 char *conv = NULL;
2820 struct smb_filename *conv_smb_fname = NULL;
2821
2822 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2823 handle,
2824 smb_fname->base_name,
2825 &timestamp,
2826 &stripped)) {
2827 return -1;
2828 }
2829 if (timestamp == 0) {
2830 return SMB_VFS_NEXT_LISTXATTR(handle, smb_fname, list, size);
2831 }
2832 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2833 TALLOC_FREE(stripped);
2834 if (conv == NULL) {
2835 return -1;
2836 }
2837 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2838 conv,
2839 NULL,
2840 NULL,
2841 smb_fname->flags);
2842 TALLOC_FREE(conv);
2843 if (conv_smb_fname == NULL) {
2844 errno = ENOMEM;
2845 return -1;
2846 }
2847 ret = SMB_VFS_NEXT_LISTXATTR(handle, conv_smb_fname, list, size);
2848 if (ret == -1) {
2849 saved_errno = errno;
2850 }
2851 TALLOC_FREE(conv_smb_fname);
2852 TALLOC_FREE(conv);
2853 if (saved_errno != 0) {
2854 errno = saved_errno;
2855 }
2856 return ret;
2857 }
2858
2859 static int snapper_gmt_removexattr(vfs_handle_struct *handle,
2860 const struct smb_filename *smb_fname,
2861 const char *aname)
2862 {
2863 time_t timestamp = 0;
2864 char *stripped = NULL;
2865 ssize_t ret;
2866 int saved_errno = 0;
2867 char *conv = NULL;
2868 struct smb_filename *conv_smb_fname = NULL;
2869
2870 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2871 handle,
2872 smb_fname->base_name,
2873 &timestamp,
2874 &stripped)) {
2875 return -1;
2876 }
2877 if (timestamp == 0) {
2878 return SMB_VFS_NEXT_REMOVEXATTR(handle, smb_fname, aname);
2879 }
2880 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2881 TALLOC_FREE(stripped);
2882 if (conv == NULL) {
2883 return -1;
2884 }
2885 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2886 conv,
2887 NULL,
2888 NULL,
2889 smb_fname->flags);
2890 TALLOC_FREE(conv);
2891 if (conv_smb_fname == NULL) {
2892 errno = ENOMEM;
2893 return -1;
2894 }
2895 ret = SMB_VFS_NEXT_REMOVEXATTR(handle, conv_smb_fname, aname);
2896 if (ret == -1) {
2897 saved_errno = errno;
2898 }
2899 TALLOC_FREE(conv_smb_fname);
2900 TALLOC_FREE(conv);
2901 if (saved_errno != 0) {
2902 errno = saved_errno;
2903 }
2904 return ret;
2905 }
2906
2907 static int snapper_gmt_setxattr(struct vfs_handle_struct *handle,
2908 const struct smb_filename *smb_fname,
2909 const char *aname, const void *value,
2910 size_t size, int flags)
2911 {
2912 time_t timestamp = 0;
2913 char *stripped = NULL;
2914 ssize_t ret;
2915 int saved_errno = 0;
2916 char *conv = NULL;
2917 struct smb_filename *conv_smb_fname = NULL;
2918
2919 if (!snapper_gmt_strip_snapshot(talloc_tos(),
2920 handle,
2921 smb_fname->base_name,
2922 &timestamp,
2923 &stripped)) {
2924 return -1;
2925 }
2926 if (timestamp == 0) {
2927 return SMB_VFS_NEXT_SETXATTR(handle, smb_fname,
2928 aname, value, size, flags);
2929 }
2930 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2931 TALLOC_FREE(stripped);
2932 if (conv == NULL) {
2933 return -1;
2934 }
2935 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
2936 conv,
2937 NULL,
2938 NULL,
2939 smb_fname->flags);
2940 TALLOC_FREE(conv);
2941 if (conv_smb_fname == NULL) {
2942 errno = ENOMEM;
2943 return -1;
2944 }
2945 ret = SMB_VFS_NEXT_SETXATTR(handle, conv_smb_fname,
2946 aname, value, size, flags);
2947 if (ret == -1) {
2948 saved_errno = errno;
2949 }
2950 TALLOC_FREE(conv_smb_fname);
2951 TALLOC_FREE(conv);
2952 if (saved_errno != 0) {
2953 errno = saved_errno;
2954 }
2955 return ret;
2956 }
2957
2958 static int snapper_gmt_get_real_filename(struct vfs_handle_struct *handle,
2959 const char *path,
2960 const char *name,
2961 TALLOC_CTX *mem_ctx,
2962 char **found_name)
2963 {
2964 time_t timestamp;
2965 char *stripped;
2966 ssize_t ret;
2967 int saved_errno;
2968 char *conv;
2969
2970 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, path,
2971 &timestamp, &stripped)) {
2972 return -1;
2973 }
2974 if (timestamp == 0) {
2975 return SMB_VFS_NEXT_GET_REAL_FILENAME(handle, path, name,
2976 mem_ctx, found_name);
2977 }
2978 if (stripped[0] == '\0') {
2979 *found_name = talloc_strdup(mem_ctx, name);
2980 if (*found_name == NULL) {
2981 errno = ENOMEM;
2982 return -1;
2983 }
2984 return 0;
2985 }
2986 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
2987 TALLOC_FREE(stripped);
2988 if (conv == NULL) {
2989 return -1;
2990 }
2991 ret = SMB_VFS_NEXT_GET_REAL_FILENAME(handle, conv, name,
2992 mem_ctx, found_name);
2993 saved_errno = errno;
2994 TALLOC_FREE(conv);
2995 errno = saved_errno;
2996 return ret;
2997 }
2998
2999 static uint64_t snapper_gmt_disk_free(vfs_handle_struct *handle,
3000 const struct smb_filename *smb_fname,
3001 uint64_t *bsize,
3002 uint64_t *dfree,
3003 uint64_t *dsize)
3004 {
3005 time_t timestamp = 0;
3006 char *stripped = NULL;
3007 uint64_t ret;
3008 int saved_errno = 0;
3009 char *conv = NULL;
3010 struct smb_filename *conv_smb_fname = NULL;
3011
3012 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
3013 smb_fname->base_name, &timestamp, &stripped)) {
3014 return (uint64_t)-1;
3015 }
3016 if (timestamp == 0) {
3017 return SMB_VFS_NEXT_DISK_FREE(handle, smb_fname,
3018 bsize, dfree, dsize);
3019 }
3020
3021 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
3022 TALLOC_FREE(stripped);
3023 if (conv == NULL) {
3024 return (uint64_t)-1;
3025 }
3026 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
3027 conv,
3028 NULL,
3029 NULL,
3030 smb_fname->flags);
3031 if (conv_smb_fname == NULL) {
3032 TALLOC_FREE(conv);
3033 errno = ENOMEM;
3034 return (uint64_t)-1;
3035 }
3036
3037 ret = SMB_VFS_NEXT_DISK_FREE(handle, conv_smb_fname,
3038 bsize, dfree, dsize);
3039
3040 if (ret == (uint64_t)-1) {
3041 saved_errno = errno;
3042 }
3043 TALLOC_FREE(conv_smb_fname);
3044 if (saved_errno != 0) {
3045 errno = saved_errno;
3046 }
3047 return ret;
3048 }
3049
3050 static int snapper_gmt_get_quota(vfs_handle_struct *handle,
3051 const struct smb_filename *smb_fname,
3052 enum SMB_QUOTA_TYPE qtype,
3053 unid_t id,
3054 SMB_DISK_QUOTA *dq)
3055 {
3056 time_t timestamp = 0;
3057 char *stripped = NULL;
3058 int ret;
3059 int saved_errno = 0;
3060 char *conv = NULL;
3061 struct smb_filename *conv_smb_fname = NULL;
3062
3063 if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
3064 smb_fname->base_name, &timestamp, &stripped)) {
3065 return -1;
3066 }
3067 if (timestamp == 0) {
3068 return SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, dq);
3069 }
3070
3071 conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
3072 TALLOC_FREE(stripped);
3073 if (conv == NULL) {
3074 return -1;
3075 }
3076 conv_smb_fname = synthetic_smb_fname(talloc_tos(),
3077 conv,
3078 NULL,
3079 NULL,
3080 smb_fname->flags);
3081 TALLOC_FREE(conv);
3082 if (conv_smb_fname == NULL) {
3083 errno = ENOMEM;
3084 return -1;
3085 }
3086
3087 ret = SMB_VFS_NEXT_GET_QUOTA(handle, conv_smb_fname, qtype, id, dq);
3088
3089 if (ret == -1) {
3090 saved_errno = errno;
3091 }
3092 TALLOC_FREE(conv_smb_fname);
3093 if (saved_errno != 0) {
3094 errno = saved_errno;
3095 }
3096 return ret;
3097 }
3098
3099
3100 static struct vfs_fn_pointers snapper_fns = {
3101 .snap_check_path_fn = snapper_snap_check_path,
3102 .snap_create_fn = snapper_snap_create,
3103 .snap_delete_fn = snapper_snap_delete,
3104 .get_shadow_copy_data_fn = snapper_get_shadow_copy_data,
3105 .opendir_fn = snapper_gmt_opendir,
3106 .disk_free_fn = snapper_gmt_disk_free,
3107 .get_quota_fn = snapper_gmt_get_quota,
3108 .rename_fn = snapper_gmt_rename,
3109 .link_fn = snapper_gmt_link,
3110 .symlink_fn = snapper_gmt_symlink,
3111 .stat_fn = snapper_gmt_stat,
3112 .lstat_fn = snapper_gmt_lstat,
3113 .fstat_fn = snapper_gmt_fstat,
3114 .open_fn = snapper_gmt_open,
3115 .unlink_fn = snapper_gmt_unlink,
3116 .chmod_fn = snapper_gmt_chmod,
3117 .chown_fn = snapper_gmt_chown,
3118 .chdir_fn = snapper_gmt_chdir,
3119 .ntimes_fn = snapper_gmt_ntimes,
3120 .readlink_fn = snapper_gmt_readlink,
3121 .mknod_fn = snapper_gmt_mknod,
3122 .realpath_fn = snapper_gmt_realpath,
3123 .get_nt_acl_fn = snapper_gmt_get_nt_acl,
3124 .fget_nt_acl_fn = snapper_gmt_fget_nt_acl,
3125 .mkdir_fn = snapper_gmt_mkdir,
3126 .rmdir_fn = snapper_gmt_rmdir,
3127 .getxattr_fn = snapper_gmt_getxattr,
3128 .getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
3129 .getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
3130 .listxattr_fn = snapper_gmt_listxattr,
3131 .removexattr_fn = snapper_gmt_removexattr,
3132 .setxattr_fn = snapper_gmt_setxattr,
3133 .chflags_fn = snapper_gmt_chflags,
3134 .get_real_filename_fn = snapper_gmt_get_real_filename,
3135 };
3136
3137 static_decl_vfs;
3138 NTSTATUS vfs_snapper_init(TALLOC_CTX *ctx)
3139 {
3140 return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
3141 "snapper", &snapper_fns);
3142 }
Samba GIT mirror