/*
 * Module for snapshot IO using snapper
 *
 * Copyright (C) David Disseldorp 2012-2014
 *
 * Portions taken from vfs_shadow_copy2.c:
 * Copyright (C) Andrew Tridgell   2007
 * Copyright (C) Ed Plese          2009
 * Copyright (C) Volker Lendecke   2011
 * Copyright (C) Christian Ambach  2011
 * Copyright (C) Michael Adam      2013
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <http://www.gnu.org/licenses/>.
 */

#include <dbus/dbus.h>
#ifdef HAVE_LINUX_IOCTL_H
#include <linux/ioctl.h>
#endif
#include <sys/ioctl.h>
#include <dirent.h>
#include <libgen.h>
#include "includes.h"
#include "include/ntioctl.h"
#include "include/smb.h"
#include "system/filesys.h"
#include "smbd/smbd.h"
#include "lib/util/tevent_ntstatus.h"
#include "lib/util/smb_strtox.h"

#define SNAPPER_SIG_LIST_SNAPS_RSP "a(uquxussa{ss})"
#define SNAPPER_SIG_LIST_CONFS_RSP "a(ssa{ss})"
#define SNAPPER_SIG_CREATE_SNAP_RSP "u"
#define SNAPPER_SIG_DEL_SNAPS_RSP ""
#define SNAPPER_SIG_STRING_DICT "{ss}"

struct snapper_dict {
	char *key;
	char *val;
};

struct snapper_snap {
	uint32_t id;
	uint16_t type;
	uint32_t pre_id;
	int64_t time;
	uint32_t creator_uid;
	char *desc;
	char *cleanup;
	uint32_t num_user_data;
	struct snapper_dict *user_data;
};

struct snapper_conf {
	char *name;
	char *mnt;
	uint32_t num_attrs;
	struct snapper_dict *attrs;
};

static const struct {
	const char *snapper_err_str;
	NTSTATUS status;
} snapper_err_map[] = {
	{ "error.no_permissions", NT_STATUS_ACCESS_DENIED },
};

static NTSTATUS snapper_err_ntstatus_map(const char *snapper_err_str)
{
	size_t i;

	if (snapper_err_str == NULL) {
		return NT_STATUS_UNSUCCESSFUL;
	}
	for (i = 0; i < ARRAY_SIZE(snapper_err_map); i++) {
		if (!strcmp(snapper_err_map[i].snapper_err_str,
			    snapper_err_str)) {
			return snapper_err_map[i].status;
		}
	}
	DEBUG(2, ("no explicit mapping for dbus error: %s\n", snapper_err_str));

	return NT_STATUS_UNSUCCESSFUL;
}

/*
 * Strings are UTF-8. Other characters must be encoded hexadecimal as "\x??".
 * As a consequence "\" must be encoded as "\\".
 */
static NTSTATUS snapper_dbus_str_encode(TALLOC_CTX *mem_ctx, const char *in_str,
					char **_out_str)
{
	size_t in_len;
	char *out_str;
	size_t i;
	int out_off;
	int out_len;

	if (in_str == NULL) {
		return NT_STATUS_INVALID_PARAMETER;
	}

	in_len = strlen(in_str);

	/* output can be max 4 times the length of @in_str, +1 for terminator */
	out_len = (in_len * 4) + 1;

	out_str = talloc_array(mem_ctx, char, out_len);
	if (out_str == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	out_off = 0;
	for (i = 0; i < in_len; i++) {
		size_t pushed;

		if (in_str[i] == '\\') {
			pushed = snprintf(out_str + out_off, out_len - out_off,
					  "\\\\");
		} else if ((unsigned char)in_str[i] > 127) {
			pushed = snprintf(out_str + out_off, out_len - out_off,
					  "\\x%02x", (unsigned char)in_str[i]);
		} else {
			/* regular character */
			*(out_str + out_off) = in_str[i];
			pushed = sizeof(char);
		}
		if (pushed >= out_len - out_off) {
			/* truncated, should never happen */
			talloc_free(out_str);
			return NT_STATUS_INTERNAL_ERROR;
		}
		out_off += pushed;
	}

	*(out_str + out_off) = '\0';
	*_out_str = out_str;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_dbus_str_decode(TALLOC_CTX *mem_ctx, const char *in_str,
					char **_out_str)
{
	size_t in_len;
	char *out_str;
	size_t i;
	int out_off;
	int out_len;

	if (in_str == NULL) {
		return NT_STATUS_INVALID_PARAMETER;
	}

	in_len = strlen(in_str);

	/* output cannot be larger than input, +1 for terminator */
	out_len = in_len + 1;

	out_str = talloc_array(mem_ctx, char, out_len);
	if (out_str == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	out_off = 0;
	for (i = 0; i < in_len; i++) {
		int j;
		char hex_buf[3];
		unsigned int non_ascii_byte;

		if (in_str[i] != '\\') {
			out_str[out_off] = in_str[i];
			out_off++;
			continue;
		}

		i++;
		if (in_str[i] == '\\') {
			out_str[out_off] = '\\';
			out_off++;
			continue;
		} else if (in_str[i] != 'x') {
			goto err_invalid_src_encoding;
		}

		/* non-ASCII, encoded as two hex chars */
		for (j = 0; j < 2; j++) {
			i++;
			if ((in_str[i] == '\0') || !isxdigit(in_str[i])) {
				goto err_invalid_src_encoding;
			}
			hex_buf[j] = in_str[i];
		}
		hex_buf[2] = '\0';

		sscanf(hex_buf, "%x", &non_ascii_byte);
		out_str[out_off] = (unsigned char)non_ascii_byte;
		out_off++;
	}

	out_str[out_off] = '\0';
	*_out_str = out_str;

	return NT_STATUS_OK;
err_invalid_src_encoding:
	DEBUG(0, ("invalid encoding %s\n", in_str));
	return NT_STATUS_INVALID_PARAMETER;
}

static DBusConnection *snapper_dbus_conn_create(void)
{
	DBusError err;
	DBusConnection *dconn;

	dbus_error_init(&err);

	/*
	 * Always create a new DBus connection, to ensure snapperd detects the
	 * correct client [E]UID. With dbus_bus_get() it does not!
	 */
	dconn = dbus_bus_get_private(DBUS_BUS_SYSTEM, &err);
	if (dbus_error_is_set(&err)) {
		DEBUG(0, ("dbus connection error: %s\n", err.message));
		dbus_error_free(&err);
	}
	if (dconn == NULL) {
		return NULL;
	}

	/* dbus_bus_get_private() sets exit-on-disconnect by default, undo it */
	dbus_connection_set_exit_on_disconnect(dconn, false);

	return dconn;
}

static void snapper_dbus_conn_destroy(DBusConnection *dconn)
{
	if (dconn == NULL) {
		DEBUG(2, ("attempt to destroy NULL dbus connection\n"));
		return;
	}

	dbus_connection_close(dconn);
	dbus_connection_unref(dconn);
}

/*
 * send the message @send_msg over the dbus and wait for a response, return the
 * responsee via @recv_msg_out.
 * @send_msg is not freed, dbus_message_unref() must be handled by the caller.
 */
static NTSTATUS snapper_dbus_msg_xchng(DBusConnection *dconn,
				       DBusMessage *send_msg,
				       DBusMessage **recv_msg_out)
{
	DBusPendingCall *pending;
	DBusMessage *recv_msg;

	/* send message and get a handle for a reply */
	if (!dbus_connection_send_with_reply(dconn, send_msg, &pending, -1)) {
		return NT_STATUS_NO_MEMORY;
	}
	if (NULL == pending) {
		DEBUG(0, ("dbus msg send failed\n"));
		return NT_STATUS_UNSUCCESSFUL;
	}

	dbus_connection_flush(dconn);

	/* block until we receive a reply */
	dbus_pending_call_block(pending);

	/* get the reply message */
	recv_msg = dbus_pending_call_steal_reply(pending);
	if (recv_msg == NULL) {
		DEBUG(0, ("Reply Null\n"));
		return NT_STATUS_UNSUCCESSFUL;
	}
	/* free the pending message handle */
	dbus_pending_call_unref(pending);
	*recv_msg_out = recv_msg;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_type_check(DBusMessageIter *iter,
				   int expected_type)
{
	int type = dbus_message_iter_get_arg_type(iter);
	if (type != expected_type) {
		DEBUG(0, ("got type %d, expecting %d\n",
			type, expected_type));
		return NT_STATUS_INVALID_PARAMETER;
	}

	return NT_STATUS_OK;
}

static NTSTATUS snapper_type_check_get(DBusMessageIter *iter,
				       int expected_type,
				       void *val)
{
	NTSTATUS status;
	status = snapper_type_check(iter, expected_type);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	dbus_message_iter_get_basic(iter, val);

	return NT_STATUS_OK;
}

static NTSTATUS snapper_dict_unpack(TALLOC_CTX *mem_ctx,
				    DBusMessageIter *iter,
				    struct snapper_dict *dict_out)

{
	NTSTATUS status;
	DBusMessageIter dct_iter;
	char *key_encoded;
	char *val_encoded;

	status = snapper_type_check(iter, DBUS_TYPE_DICT_ENTRY);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}
	dbus_message_iter_recurse(iter, &dct_iter);

	status = snapper_type_check_get(&dct_iter, DBUS_TYPE_STRING,
					&key_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}
	status = snapper_dbus_str_decode(mem_ctx, key_encoded, &dict_out->key);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	dbus_message_iter_next(&dct_iter);
	status = snapper_type_check_get(&dct_iter, DBUS_TYPE_STRING,
					&val_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(dict_out->key);
		return status;
	}
	status = snapper_dbus_str_decode(mem_ctx, val_encoded, &dict_out->val);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(dict_out->key);
		return status;
	}

	return NT_STATUS_OK;
}

static void snapper_dict_array_print(uint32_t num_dicts,
				     struct snapper_dict *dicts)
{
	size_t i;

	for (i = 0; i < num_dicts; i++) {
		DEBUG(10, ("dict (key: %s, val: %s)\n",
			   dicts[i].key, dicts[i].val));
	}
}

static NTSTATUS snapper_dict_array_unpack(TALLOC_CTX *mem_ctx,
					  DBusMessageIter *iter,
					  uint32_t *num_dicts_out,
					  struct snapper_dict **dicts_out)
{
	NTSTATUS status;
	DBusMessageIter array_iter;
	uint32_t num_dicts;
	struct snapper_dict *dicts = NULL;

	status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}
	dbus_message_iter_recurse(iter, &array_iter);

	num_dicts = 0;
	while (dbus_message_iter_get_arg_type(&array_iter)
							!= DBUS_TYPE_INVALID) {
		num_dicts++;
		dicts = talloc_realloc(mem_ctx, dicts, struct snapper_dict,
				       num_dicts);
		if (dicts == NULL)
			abort();

		status = snapper_dict_unpack(mem_ctx, &array_iter,
					     &dicts[num_dicts - 1]);
		if (!NT_STATUS_IS_OK(status)) {
			talloc_free(dicts);
			return status;
		}
		dbus_message_iter_next(&array_iter);
	}

	*num_dicts_out = num_dicts;
	*dicts_out = dicts;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_list_confs_pack(DBusMessage **req_msg_out)
{
	DBusMessage *msg;

	msg = dbus_message_new_method_call("org.opensuse.Snapper",
					   "/org/opensuse/Snapper",
					   "org.opensuse.Snapper",
					   "ListConfigs");
	if (msg == NULL) {
		DEBUG(0, ("null msg\n"));
		return NT_STATUS_NO_MEMORY;
	}

	/* no arguments to append */
	*req_msg_out = msg;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_conf_unpack(TALLOC_CTX *mem_ctx,
				    DBusMessageIter *iter,
				    struct snapper_conf *conf_out)
{
	NTSTATUS status;
	DBusMessageIter st_iter;
	char *name_encoded;
	char *mnt_encoded;

	status = snapper_type_check(iter, DBUS_TYPE_STRUCT);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}
	dbus_message_iter_recurse(iter, &st_iter);

	status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
					&name_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	status = snapper_dbus_str_decode(mem_ctx, name_encoded,
					 &conf_out->name);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	dbus_message_iter_next(&st_iter);
	status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
					&mnt_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(conf_out->name);
		return status;
	}

	status = snapper_dbus_str_decode(mem_ctx, mnt_encoded,
					 &conf_out->mnt);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(conf_out->name);
		return status;
	}

	dbus_message_iter_next(&st_iter);
	status = snapper_dict_array_unpack(mem_ctx, &st_iter,
					   &conf_out->num_attrs,
					   &conf_out->attrs);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(conf_out->mnt);
		talloc_free(conf_out->name);
		return status;
	}

	return NT_STATUS_OK;
}

static struct snapper_conf *snapper_conf_array_base_find(int32_t num_confs,
						struct snapper_conf *confs,
							 const char *base)
{
	int i;

	for (i = 0; i < num_confs; i++) {
		if (strcmp(confs[i].mnt, base) == 0) {
			DEBUG(5, ("found snapper conf %s for path %s\n",
				  confs[i].name, base));
			return &confs[i];
		}
	}
	DEBUG(5, ("config for base %s not found\n", base));

	return NULL;
}

static void snapper_conf_array_print(int32_t num_confs,
				     struct snapper_conf *confs)
{
	int i;

	for (i = 0; i < num_confs; i++) {
		DEBUG(10, ("name: %s, mnt: %s\n",
			   confs[i].name, confs[i].mnt));
		snapper_dict_array_print(confs[i].num_attrs, confs[i].attrs);
	}
}

static NTSTATUS snapper_conf_array_unpack(TALLOC_CTX *mem_ctx,
					  DBusMessageIter *iter,
					  uint32_t *num_confs_out,
					  struct snapper_conf **confs_out)
{
	uint32_t num_confs;
	NTSTATUS status;
	struct snapper_conf *confs = NULL;
	DBusMessageIter array_iter;


	status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}
	dbus_message_iter_recurse(iter, &array_iter);

	num_confs = 0;
	while (dbus_message_iter_get_arg_type(&array_iter)
							!= DBUS_TYPE_INVALID) {
		num_confs++;
		confs = talloc_realloc(mem_ctx, confs, struct snapper_conf,
				       num_confs);
		if (confs == NULL)
			abort();

		status = snapper_conf_unpack(confs, &array_iter,
					     &confs[num_confs - 1]);
		if (!NT_STATUS_IS_OK(status)) {
			talloc_free(confs);
			return status;
		}
		dbus_message_iter_next(&array_iter);
	}

	*num_confs_out = num_confs;
	*confs_out = confs;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_list_confs_unpack(TALLOC_CTX *mem_ctx,
					  DBusConnection *dconn,
					  DBusMessage *rsp_msg,
					  uint32_t *num_confs_out,
					  struct snapper_conf **confs_out)
{
	NTSTATUS status;
	DBusMessageIter iter;
	int msg_type;
	uint32_t num_confs;
	struct snapper_conf *confs;
	const char *sig;

	msg_type = dbus_message_get_type(rsp_msg);
	if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
		const char *err_str = dbus_message_get_error_name(rsp_msg);
		DEBUG(0, ("list_confs error response: %s\n", err_str));
		return snapper_err_ntstatus_map(err_str);
	}

	if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
		DEBUG(0, ("unexpected list_confs ret type: %d\n",
			  msg_type));
		return NT_STATUS_INVALID_PARAMETER;
	}

	sig = dbus_message_get_signature(rsp_msg);
	if ((sig == NULL)
	 || (strcmp(sig, SNAPPER_SIG_LIST_CONFS_RSP) != 0)) {
		DEBUG(0, ("bad list confs response sig: %s, expected: %s\n",
			  (sig ? sig : "NULL"), SNAPPER_SIG_LIST_CONFS_RSP));
		return NT_STATUS_INVALID_PARAMETER;
	}

	if (!dbus_message_iter_init(rsp_msg, &iter)) {
		/* FIXME return empty? */
		DEBUG(0, ("Message has no arguments!\n"));
		return NT_STATUS_INVALID_PARAMETER;
	}

	status = snapper_conf_array_unpack(mem_ctx, &iter, &num_confs, &confs);
	if (!NT_STATUS_IS_OK(status)) {
		DEBUG(0, ("failed to unpack conf array\n"));
		return status;
	}

	snapper_conf_array_print(num_confs, confs);

	*num_confs_out = num_confs;
	*confs_out = confs;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_list_snaps_pack(TALLOC_CTX *mem_ctx,
					char *snapper_conf,
					DBusMessage **req_msg_out)
{
	DBusMessage *msg;
	DBusMessageIter args;
	char *conf_encoded;
	NTSTATUS status;

	msg = dbus_message_new_method_call("org.opensuse.Snapper", /* target for the method call */
					   "/org/opensuse/Snapper", /* object to call on */
					   "org.opensuse.Snapper", /* interface to call on */
					   "ListSnapshots"); /* method name */
	if (msg == NULL) {
		DEBUG(0, ("failed to create list snaps message\n"));
		return NT_STATUS_NO_MEMORY;
	}

	status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		dbus_message_unref(msg);
		return status;
	}

	/* append arguments */
	dbus_message_iter_init_append(msg, &args);
	if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
					    &conf_encoded)) {
		talloc_free(conf_encoded);
		dbus_message_unref(msg);
		return NT_STATUS_NO_MEMORY;
	}

	*req_msg_out = msg;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_snap_struct_unpack(TALLOC_CTX *mem_ctx,
					   DBusMessageIter *iter,
					   struct snapper_snap *snap_out)
{
	NTSTATUS status;
	DBusMessageIter st_iter;
	char *desc_encoded;
	char *cleanup_encoded;

	status = snapper_type_check(iter, DBUS_TYPE_STRUCT);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}
	dbus_message_iter_recurse(iter, &st_iter);

	status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
					&snap_out->id);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	dbus_message_iter_next(&st_iter);
	status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT16,
					&snap_out->type);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	dbus_message_iter_next(&st_iter);
	status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
					&snap_out->pre_id);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	dbus_message_iter_next(&st_iter);
	status = snapper_type_check_get(&st_iter, DBUS_TYPE_INT64,
					&snap_out->time);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	dbus_message_iter_next(&st_iter);
	status = snapper_type_check_get(&st_iter, DBUS_TYPE_UINT32,
					&snap_out->creator_uid);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	dbus_message_iter_next(&st_iter);
	status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
					&desc_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	status = snapper_dbus_str_decode(mem_ctx, desc_encoded,
					 &snap_out->desc);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	dbus_message_iter_next(&st_iter);
	status = snapper_type_check_get(&st_iter, DBUS_TYPE_STRING,
					&cleanup_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(snap_out->desc);
		return status;
	}

	status = snapper_dbus_str_decode(mem_ctx, cleanup_encoded,
					 &snap_out->cleanup);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(snap_out->desc);
		return status;
	}

	dbus_message_iter_next(&st_iter);
	status = snapper_dict_array_unpack(mem_ctx, &st_iter,
					   &snap_out->num_user_data,
					   &snap_out->user_data);
	if (!NT_STATUS_IS_OK(status)) {
		talloc_free(snap_out->cleanup);
		talloc_free(snap_out->desc);
		return status;
	}

	return NT_STATUS_OK;
}

static void snapper_snap_array_print(int32_t num_snaps,
				     struct snapper_snap *snaps)
{
	int i;

	for (i = 0; i < num_snaps; i++) {
		DEBUG(10, ("id: %u, "
			   "type: %u, "
			   "pre_id: %u, "
			   "time: %ld, "
			   "creator_uid: %u, "
			   "desc: %s, "
			   "cleanup: %s\n",
			   (unsigned int)snaps[i].id,
			   (unsigned int)snaps[i].type,
			   (unsigned int)snaps[i].pre_id,
			   (long int)snaps[i].time,
			   (unsigned int)snaps[i].creator_uid,
			   snaps[i].desc,
			   snaps[i].cleanup));
		snapper_dict_array_print(snaps[i].num_user_data,
					 snaps[i].user_data);
	}
}

static NTSTATUS snapper_snap_array_unpack(TALLOC_CTX *mem_ctx,
					  DBusMessageIter *iter,
					  uint32_t *num_snaps_out,
					  struct snapper_snap **snaps_out)
{
	uint32_t num_snaps;
	NTSTATUS status;
	struct snapper_snap *snaps = NULL;
	DBusMessageIter array_iter;


	status = snapper_type_check(iter, DBUS_TYPE_ARRAY);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}
	dbus_message_iter_recurse(iter, &array_iter);

	num_snaps = 0;
	while (dbus_message_iter_get_arg_type(&array_iter)
							!= DBUS_TYPE_INVALID) {
		num_snaps++;
		snaps = talloc_realloc(mem_ctx, snaps, struct snapper_snap,
				       num_snaps);
		if (snaps == NULL)
			abort();

		status = snapper_snap_struct_unpack(snaps, &array_iter,
						    &snaps[num_snaps - 1]);
		if (!NT_STATUS_IS_OK(status)) {
			talloc_free(snaps);
			return status;
		}
		dbus_message_iter_next(&array_iter);
	}

	*num_snaps_out = num_snaps;
	*snaps_out = snaps;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_list_snaps_unpack(TALLOC_CTX *mem_ctx,
					  DBusMessage *rsp_msg,
					  uint32_t *num_snaps_out,
					  struct snapper_snap **snaps_out)
{
	NTSTATUS status;
	DBusMessageIter iter;
	int msg_type;
	uint32_t num_snaps;
	struct snapper_snap *snaps;
	const char *sig;

	msg_type = dbus_message_get_type(rsp_msg);
	if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
		const char *err_str = dbus_message_get_error_name(rsp_msg);
		DEBUG(0, ("list_snaps error response: %s\n", err_str));
		return snapper_err_ntstatus_map(err_str);
	}

	if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
		DEBUG(0,("unexpected list_snaps ret type: %d\n",
			 msg_type));
		return NT_STATUS_INVALID_PARAMETER;
	}

	sig = dbus_message_get_signature(rsp_msg);
	if ((sig == NULL)
	 || (strcmp(sig, SNAPPER_SIG_LIST_SNAPS_RSP) != 0)) {
		DEBUG(0, ("bad list snaps response sig: %s, "
			  "expected: %s\n",
			  (sig ? sig : "NULL"),
			  SNAPPER_SIG_LIST_SNAPS_RSP));
		return NT_STATUS_INVALID_PARAMETER;
	}

	/* read the parameters */
	if (!dbus_message_iter_init(rsp_msg, &iter)) {
		DEBUG(0, ("response has no arguments!\n"));
		return NT_STATUS_INVALID_PARAMETER;
	}

	status = snapper_snap_array_unpack(mem_ctx, &iter, &num_snaps, &snaps);
	if (!NT_STATUS_IS_OK(status)) {
		DEBUG(0, ("failed to unpack snap array\n"));
		return NT_STATUS_INVALID_PARAMETER;
	}

	snapper_snap_array_print(num_snaps, snaps);

	*num_snaps_out = num_snaps;
	*snaps_out = snaps;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_create_snap_pack(TALLOC_CTX *mem_ctx,
					 const char *snapper_conf,
					 const char *desc,
					 uint32_t num_user_data,
					 struct snapper_dict *user_data,
					 DBusMessage **req_msg_out)
{
	DBusMessage *msg;
	DBusMessageIter args;
	DBusMessageIter array_iter;
	DBusMessageIter struct_iter;
	const char *empty = "";
	char *str_encoded;
	uint32_t i;
	bool ok;
	TALLOC_CTX *enc_ctx;
	NTSTATUS status;

	DEBUG(10, ("CreateSingleSnapshot: %s, %s, %s, num user %u\n",
		  snapper_conf, desc, empty, num_user_data));

	enc_ctx = talloc_new(mem_ctx);
	if (enc_ctx == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	msg = dbus_message_new_method_call("org.opensuse.Snapper",
					   "/org/opensuse/Snapper",
					   "org.opensuse.Snapper",
					   "CreateSingleSnapshot");
	if (msg == NULL) {
		DEBUG(0, ("failed to create req msg\n"));
		talloc_free(enc_ctx);
		return NT_STATUS_NO_MEMORY;
	}

	status = snapper_dbus_str_encode(enc_ctx, snapper_conf, &str_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		dbus_message_unref(msg);
		talloc_free(enc_ctx);
		return status;
	}

	/* append arguments */
	dbus_message_iter_init_append(msg, &args);
	ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
					    &str_encoded);
	if (!ok) {
		dbus_message_unref(msg);
		talloc_free(enc_ctx);
		return NT_STATUS_NO_MEMORY;
	}

	status = snapper_dbus_str_encode(enc_ctx, desc, &str_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		dbus_message_unref(msg);
		talloc_free(enc_ctx);
		return status;
	}

	ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
					    &str_encoded);
	if (!ok) {
		dbus_message_unref(msg);
		talloc_free(enc_ctx);
		return NT_STATUS_NO_MEMORY;
	}

	/* cleanup - no need to encode empty string */
	ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
					    &empty);
	if (!ok) {
		dbus_message_unref(msg);
		talloc_free(enc_ctx);
		return NT_STATUS_NO_MEMORY;
	}

	ok = dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
					      SNAPPER_SIG_STRING_DICT,
					      &array_iter);
	if (!ok) {
		dbus_message_unref(msg);
		talloc_free(enc_ctx);
		return NT_STATUS_NO_MEMORY;
	}

	for (i = 0; i < num_user_data; i++) {
		ok = dbus_message_iter_open_container(&array_iter,
						      DBUS_TYPE_DICT_ENTRY,
						      NULL, &struct_iter);
		if (!ok) {
			dbus_message_unref(msg);
			talloc_free(enc_ctx);
			return NT_STATUS_NO_MEMORY;
		}

		status = snapper_dbus_str_encode(enc_ctx, user_data[i].key,
						 &str_encoded);
		if (!NT_STATUS_IS_OK(status)) {
			dbus_message_unref(msg);
			talloc_free(enc_ctx);
			return status;
		}

		ok = dbus_message_iter_append_basic(&struct_iter,
						    DBUS_TYPE_STRING,
						    &str_encoded);
		if (!ok) {
			dbus_message_unref(msg);
			talloc_free(enc_ctx);
			return NT_STATUS_NO_MEMORY;
		}

		status = snapper_dbus_str_encode(enc_ctx, user_data[i].val,
						 &str_encoded);
		if (!NT_STATUS_IS_OK(status)) {
			dbus_message_unref(msg);
			talloc_free(enc_ctx);
			return status;
		}

		ok = dbus_message_iter_append_basic(&struct_iter,
						    DBUS_TYPE_STRING,
						    &str_encoded);
		if (!ok) {
			dbus_message_unref(msg);
			talloc_free(enc_ctx);
			return NT_STATUS_NO_MEMORY;
		}

		ok = dbus_message_iter_close_container(&array_iter, &struct_iter);
		if (!ok) {
			dbus_message_unref(msg);
			talloc_free(enc_ctx);
			return NT_STATUS_NO_MEMORY;
		}
	}

	ok = dbus_message_iter_close_container(&args, &array_iter);
	if (!ok) {
		dbus_message_unref(msg);
		talloc_free(enc_ctx);
		return NT_STATUS_NO_MEMORY;
	}

	*req_msg_out = msg;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_create_snap_unpack(DBusConnection *conn,
					   DBusMessage *rsp_msg,
					   uint32_t *snap_id_out)
{
	NTSTATUS status;
	DBusMessageIter iter;
	int msg_type;
	const char *sig;
	uint32_t snap_id;

	msg_type = dbus_message_get_type(rsp_msg);
	if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
		const char *err_str = dbus_message_get_error_name(rsp_msg);
		DEBUG(0, ("create snap error response: %s, euid %d egid %d\n",
			  err_str, geteuid(), getegid()));
		return snapper_err_ntstatus_map(err_str);
	}

	if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
		DEBUG(0, ("unexpected create snap ret type: %d\n",
			  msg_type));
		return NT_STATUS_INVALID_PARAMETER;
	}

	sig = dbus_message_get_signature(rsp_msg);
	if ((sig == NULL)
	 || (strcmp(sig, SNAPPER_SIG_CREATE_SNAP_RSP) != 0)) {
		DEBUG(0, ("bad create snap response sig: %s, expected: %s\n",
			  (sig ? sig : "NULL"), SNAPPER_SIG_CREATE_SNAP_RSP));
		return NT_STATUS_INVALID_PARAMETER;
	}

	/* read the parameters */
	if (!dbus_message_iter_init(rsp_msg, &iter)) {
		DEBUG(0, ("response has no arguments!\n"));
		return NT_STATUS_INVALID_PARAMETER;
	}

	status = snapper_type_check_get(&iter, DBUS_TYPE_UINT32, &snap_id);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}
	*snap_id_out = snap_id;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_del_snap_pack(TALLOC_CTX *mem_ctx,
				      const char *snapper_conf,
				      uint32_t snap_id,
				      DBusMessage **req_msg_out)
{
	DBusMessage *msg;
	DBusMessageIter args;
	DBusMessageIter array_iter;
	char *conf_encoded;
	bool ok;
	NTSTATUS status;

	msg = dbus_message_new_method_call("org.opensuse.Snapper",
					   "/org/opensuse/Snapper",
					   "org.opensuse.Snapper",
					   "DeleteSnapshots");
	if (msg == NULL) {
		DEBUG(0, ("failed to create req msg\n"));
		return NT_STATUS_NO_MEMORY;
	}

	status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		dbus_message_unref(msg);
		return status;
	}

	/* append arguments */
	dbus_message_iter_init_append(msg, &args);
	ok = dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
					    &conf_encoded);
	if (!ok) {
		talloc_free(conf_encoded);
		dbus_message_unref(msg);
		return NT_STATUS_NO_MEMORY;
	}

	ok = dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
					       DBUS_TYPE_UINT32_AS_STRING,
					       &array_iter);
	if (!ok) {
		talloc_free(conf_encoded);
		dbus_message_unref(msg);
		return NT_STATUS_NO_MEMORY;
	}

	ok = dbus_message_iter_append_basic(&array_iter,
					    DBUS_TYPE_UINT32,
					    &snap_id);
	if (!ok) {
		talloc_free(conf_encoded);
		dbus_message_unref(msg);
		return NT_STATUS_NO_MEMORY;
	}

	dbus_message_iter_close_container(&args, &array_iter);
	*req_msg_out = msg;

	return NT_STATUS_OK;
}

static NTSTATUS snapper_del_snap_unpack(DBusConnection *conn,
					DBusMessage *rsp_msg)
{
	int msg_type;
	const char *sig;

	msg_type = dbus_message_get_type(rsp_msg);
	if (msg_type == DBUS_MESSAGE_TYPE_ERROR) {
		const char *err_str = dbus_message_get_error_name(rsp_msg);
		DEBUG(0, ("del snap error response: %s\n", err_str));
		return snapper_err_ntstatus_map(err_str);
	}

	if (msg_type != DBUS_MESSAGE_TYPE_METHOD_RETURN) {
		DEBUG(0, ("unexpected del snap ret type: %d\n",
			  msg_type));
		return NT_STATUS_INVALID_PARAMETER;
	}

	sig = dbus_message_get_signature(rsp_msg);
	if ((sig == NULL)
	 || (strcmp(sig, SNAPPER_SIG_DEL_SNAPS_RSP) != 0)) {
		DEBUG(0, ("bad create snap response sig: %s, expected: %s\n",
			  (sig ? sig : "NULL"), SNAPPER_SIG_DEL_SNAPS_RSP));
		return NT_STATUS_INVALID_PARAMETER;
	}

	/* no parameters in response */

	return NT_STATUS_OK;
}

static NTSTATUS snapper_list_snaps_at_time_pack(TALLOC_CTX *mem_ctx,
						const char *snapper_conf,
						time_t time_lower,
						time_t time_upper,
						DBusMessage **req_msg_out)
{
	DBusMessage *msg;
	DBusMessageIter args;
	char *conf_encoded;
	NTSTATUS status;

	msg = dbus_message_new_method_call("org.opensuse.Snapper",
					   "/org/opensuse/Snapper",
					   "org.opensuse.Snapper",
					   "ListSnapshotsAtTime");
	if (msg == NULL) {
		DEBUG(0, ("failed to create list snaps message\n"));
		return NT_STATUS_NO_MEMORY;
	}

	status = snapper_dbus_str_encode(mem_ctx, snapper_conf, &conf_encoded);
	if (!NT_STATUS_IS_OK(status)) {
		dbus_message_unref(msg);
		return status;
	}

	dbus_message_iter_init_append(msg, &args);
	if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_STRING,
					    &conf_encoded)) {
		talloc_free(conf_encoded);
		dbus_message_unref(msg);
		return NT_STATUS_NO_MEMORY;
	}

	if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT64,
					    &time_lower)) {
		talloc_free(conf_encoded);
		dbus_message_unref(msg);
		return NT_STATUS_NO_MEMORY;
	}

	if (!dbus_message_iter_append_basic(&args, DBUS_TYPE_INT64,
					    &time_upper)) {
		talloc_free(conf_encoded);
		dbus_message_unref(msg);
		return NT_STATUS_NO_MEMORY;
	}

	*req_msg_out = msg;

	return NT_STATUS_OK;
}
/* no snapper_list_snaps_at_time_unpack, use snapper_list_snaps_unpack */

/*
 * Determine the snapper snapshot id given a path.
 * Ideally this should be determined via a lookup.
 */
static NTSTATUS snapper_snap_path_to_id(TALLOC_CTX *mem_ctx,
					const char *snap_path,
					uint32_t *snap_id_out)
{
	char *path_dup;
	char *str_idx;
	uint32_t snap_id;
	int error = 0;

	path_dup = talloc_strdup(mem_ctx, snap_path);
	if (path_dup == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	/* trim trailing '/' */
	str_idx = path_dup + strlen(path_dup) - 1;
	while (*str_idx == '/') {
		*str_idx = '\0';
		str_idx--;
	}

	str_idx = strrchr(path_dup, '/');
	if ((str_idx == NULL)
	 || (strcmp(str_idx + 1, "snapshot") != 0)) {
		talloc_free(path_dup);
		return NT_STATUS_INVALID_PARAMETER;
	}

	while (*str_idx == '/') {
		*str_idx = '\0';
		str_idx--;
	}

	str_idx = strrchr(path_dup, '/');
	if (str_idx == NULL) {
		talloc_free(path_dup);
		return NT_STATUS_INVALID_PARAMETER;
	}

	str_idx++;
	snap_id = smb_strtoul(str_idx, NULL, 10, &error, SMB_STR_STANDARD);
	if (error != 0) {
		talloc_free(path_dup);
		return NT_STATUS_INVALID_PARAMETER;
	}

	talloc_free(path_dup);
	*snap_id_out = snap_id;
	return NT_STATUS_OK;
}

/*
 * Determine the snapper snapshot path given an id and base.
 * Ideally this should be determined via a lookup.
 */
static NTSTATUS snapper_snap_id_to_path(TALLOC_CTX *mem_ctx,
					const char *base_path,
					uint32_t snap_id,
					char **snap_path_out)
{
	char *snap_path;

	snap_path = talloc_asprintf(mem_ctx, "%s/.snapshots/%u/snapshot",
				    base_path, snap_id);
	if (snap_path == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	*snap_path_out = snap_path;
	return NT_STATUS_OK;
}

static NTSTATUS snapper_get_conf_call(TALLOC_CTX *mem_ctx,
				      DBusConnection *dconn,
				      const char *path,
				      char **conf_name_out,
				      char **base_path_out)
{
	NTSTATUS status;
	DBusMessage *req_msg;
	DBusMessage *rsp_msg;
	uint32_t num_confs = 0;
	struct snapper_conf *confs = NULL;
	struct snapper_conf *conf;
	char *conf_name;
	char *base_path;

	status = snapper_list_confs_pack(&req_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_out;
	}

	status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_req_free;
	}

	status = snapper_list_confs_unpack(mem_ctx, dconn, rsp_msg,
					   &num_confs, &confs);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_rsp_free;
	}

	/*
	 * for now we only support shares where the path directly corresponds
	 * to a snapper configuration.
	 */
	conf = snapper_conf_array_base_find(num_confs, confs,
					    path);
	if (conf == NULL) {
		status = NT_STATUS_NOT_SUPPORTED;
		goto err_array_free;
	}

	conf_name = talloc_strdup(mem_ctx, conf->name);
	if (conf_name == NULL) {
		status = NT_STATUS_NO_MEMORY;
		goto err_array_free;
	}
	base_path = talloc_strdup(mem_ctx, conf->mnt);
	if (base_path == NULL) {
		status = NT_STATUS_NO_MEMORY;
		goto err_conf_name_free;
	}

	talloc_free(confs);
	dbus_message_unref(rsp_msg);
	dbus_message_unref(req_msg);

	*conf_name_out = conf_name;
	*base_path_out = base_path;

	return NT_STATUS_OK;

err_conf_name_free:
	talloc_free(conf_name);
err_array_free:
	talloc_free(confs);
err_rsp_free:
	dbus_message_unref(rsp_msg);
err_req_free:
	dbus_message_unref(req_msg);
err_out:
	return status;
}

/*
 * Check whether a path can be shadow copied. Return the base volume, allowing
 * the caller to determine if multiple paths lie on the same base volume.
 */
static NTSTATUS snapper_snap_check_path(struct vfs_handle_struct *handle,
					TALLOC_CTX *mem_ctx,
					const char *service_path,
					char **base_volume)
{
	NTSTATUS status;
	DBusConnection *dconn;
	char *conf_name;
	char *base_path;

	dconn = snapper_dbus_conn_create();
	if (dconn == NULL) {
		return NT_STATUS_UNSUCCESSFUL;
	}

	status = snapper_get_conf_call(mem_ctx, dconn, service_path,
				       &conf_name, &base_path);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_conn_close;
	}

	talloc_free(conf_name);
	*base_volume = base_path;
	snapper_dbus_conn_destroy(dconn);

	return NT_STATUS_OK;

err_conn_close:
	snapper_dbus_conn_destroy(dconn);
	return status;
}

static NTSTATUS snapper_create_snap_call(TALLOC_CTX *mem_ctx,
					 DBusConnection *dconn,
					 const char *conf_name,
					 const char *base_path,
					 const char *snap_desc,
					 uint32_t num_user_data,
					 struct snapper_dict *user_data,
					 char **snap_path_out)
{
	NTSTATUS status;
	DBusMessage *req_msg;
	DBusMessage *rsp_msg;
	uint32_t snap_id = 0;
	char *snap_path;

	status = snapper_create_snap_pack(mem_ctx,
					  conf_name,
					  snap_desc,
					  num_user_data,
					  user_data,
					  &req_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_out;
	}

	status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_req_free;
	}

	status = snapper_create_snap_unpack(dconn, rsp_msg, &snap_id);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_rsp_free;
	}

	status = snapper_snap_id_to_path(mem_ctx, base_path, snap_id,
					 &snap_path);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_rsp_free;
	}

	dbus_message_unref(rsp_msg);
	dbus_message_unref(req_msg);

	DEBUG(6, ("created new snapshot %u at %s\n", snap_id, snap_path));
	*snap_path_out = snap_path;

	return NT_STATUS_OK;

err_rsp_free:
	dbus_message_unref(rsp_msg);
err_req_free:
	dbus_message_unref(req_msg);
err_out:
	return status;
}

static NTSTATUS snapper_snap_create(struct vfs_handle_struct *handle,
				    TALLOC_CTX *mem_ctx,
				    const char *base_volume,
				    time_t *tstamp,
				    bool rw,
				    char **_base_path,
				    char **_snap_path)
{
	DBusConnection *dconn;
	NTSTATUS status;
	char *conf_name;
	char *base_path;
	char *snap_path = NULL;
	TALLOC_CTX *tmp_ctx;

	tmp_ctx = talloc_new(mem_ctx);
	if (tmp_ctx == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	dconn = snapper_dbus_conn_create();
	if (dconn == NULL) {
		talloc_free(tmp_ctx);
		return NT_STATUS_UNSUCCESSFUL;
	}

	status = snapper_get_conf_call(tmp_ctx, dconn, base_volume,
				       &conf_name, &base_path);
	if (!NT_STATUS_IS_OK(status)) {
		snapper_dbus_conn_destroy(dconn);
		talloc_free(tmp_ctx);
		return status;
	}

	status = snapper_create_snap_call(tmp_ctx, dconn,
					  conf_name, base_path,
					  "Snapshot created by Samba",
					  0, NULL,
					  &snap_path);
	if (!NT_STATUS_IS_OK(status)) {
		snapper_dbus_conn_destroy(dconn);
		talloc_free(tmp_ctx);
		return status;
	}

	snapper_dbus_conn_destroy(dconn);
	*_base_path = talloc_steal(mem_ctx, base_path);
	*_snap_path = talloc_steal(mem_ctx, snap_path);
	talloc_free(tmp_ctx);

	return NT_STATUS_OK;
}

static NTSTATUS snapper_delete_snap_call(TALLOC_CTX *mem_ctx,
					 DBusConnection *dconn,
					 const char *conf_name,
					 uint32_t snap_id)
{
	NTSTATUS status;
	DBusMessage *req_msg = NULL;
	DBusMessage *rsp_msg;

	status = snapper_del_snap_pack(mem_ctx, conf_name, snap_id, &req_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_out;
	}

	status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_req_free;
	}

	status = snapper_del_snap_unpack(dconn, rsp_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_rsp_free;
	}

	dbus_message_unref(rsp_msg);
	dbus_message_unref(req_msg);

	DEBUG(6, ("deleted snapshot %u\n", snap_id));

	return NT_STATUS_OK;

err_rsp_free:
	dbus_message_unref(rsp_msg);
err_req_free:
	dbus_message_unref(req_msg);
err_out:
	return status;
}

static NTSTATUS snapper_snap_delete(struct vfs_handle_struct *handle,
				    TALLOC_CTX *mem_ctx,
				    char *base_path,
				    char *snap_path)
{
	DBusConnection *dconn;
	NTSTATUS status;
	char *conf_name;
	char *snap_base_path;
	uint32_t snap_id;
	TALLOC_CTX *tmp_ctx;

	tmp_ctx = talloc_new(mem_ctx);
	if (tmp_ctx == NULL) {
		return NT_STATUS_NO_MEMORY;
	}

	dconn = snapper_dbus_conn_create();
	if (dconn == NULL) {
		talloc_free(tmp_ctx);
		return NT_STATUS_UNSUCCESSFUL;
	}

	status = snapper_get_conf_call(tmp_ctx, dconn, base_path,
				       &conf_name, &snap_base_path);
	if (!NT_STATUS_IS_OK(status)) {
		snapper_dbus_conn_destroy(dconn);
		talloc_free(tmp_ctx);
		return status;
	}

	status = snapper_snap_path_to_id(tmp_ctx, snap_path, &snap_id);
	if (!NT_STATUS_IS_OK(status)) {
		snapper_dbus_conn_destroy(dconn);
		talloc_free(tmp_ctx);
		return status;
	}

	status = snapper_delete_snap_call(tmp_ctx, dconn, conf_name, snap_id);
	if (!NT_STATUS_IS_OK(status)) {
		snapper_dbus_conn_destroy(dconn);
		talloc_free(tmp_ctx);
		return status;
	}

	snapper_dbus_conn_destroy(dconn);
	talloc_free(tmp_ctx);

	return NT_STATUS_OK;
}

/* sc_data used as parent talloc context for all labels */
static int snapper_get_shadow_copy_data(struct vfs_handle_struct *handle,
					struct files_struct *fsp,
					struct shadow_copy_data *sc_data,
					bool labels)
{
	DBusConnection *dconn;
	TALLOC_CTX *tmp_ctx;
	NTSTATUS status;
	char *conf_name;
	char *base_path;
	DBusMessage *req_msg = NULL;
	DBusMessage *rsp_msg;
	uint32_t num_snaps;
	struct snapper_snap *snaps;
	uint32_t i;
	uint32_t lbl_off;

	tmp_ctx = talloc_new(sc_data);
	if (tmp_ctx == NULL) {
		status = NT_STATUS_NO_MEMORY;
		goto err_out;
	}

	dconn = snapper_dbus_conn_create();
	if (dconn == NULL) {
		status = NT_STATUS_UNSUCCESSFUL;
		goto err_mem_ctx_free;
	}

	if (fsp->conn->connectpath == NULL) {
		status = NT_STATUS_INVALID_PARAMETER;
		goto err_conn_free;
	}

	status = snapper_get_conf_call(tmp_ctx, dconn,
				       fsp->conn->connectpath,
				       &conf_name,
				       &base_path);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_conn_free;
	}

	status = snapper_list_snaps_pack(tmp_ctx, conf_name, &req_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_conn_free;
	}

	status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_req_free;
	}

	status = snapper_list_snaps_unpack(tmp_ctx, rsp_msg,
					   &num_snaps, &snaps);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_rsp_free;
	}
	/* we should always get at least one snapshot (current) */
	if (num_snaps == 0) {
		DEBUG(1, ("zero snapshots in snap list response\n"));
		status = NT_STATUS_UNSUCCESSFUL;
		goto err_rsp_free;
	}

	/* subtract 1, (current) snapshot is not returned */
	sc_data->num_volumes = num_snaps - 1;
	sc_data->labels = NULL;

	if ((labels == false) || (sc_data->num_volumes == 0)) {
		/* tokens need not be added to the labels array */
		goto done;
	}

	sc_data->labels = talloc_array(sc_data, SHADOW_COPY_LABEL,
				       sc_data->num_volumes);
	if (sc_data->labels == NULL) {
		status = NT_STATUS_NO_MEMORY;
		goto err_rsp_free;
	}

	/* start at end for descending order, do not include 0 (current) */
	lbl_off = 0;
	for (i = num_snaps - 1; i > 0; i--) {
		char *lbl = sc_data->labels[lbl_off++];
		struct tm gmt_snap_time;
		struct tm *tm_ret;
		size_t str_sz;

		tm_ret = gmtime_r((time_t *)&snaps[i].time, &gmt_snap_time);
		if (tm_ret == NULL) {
			status = NT_STATUS_UNSUCCESSFUL;
			goto err_labels_free;
		}
		str_sz = strftime(lbl, sizeof(SHADOW_COPY_LABEL),
				  "@GMT-%Y.%m.%d-%H.%M.%S", &gmt_snap_time);
		if (str_sz == 0) {
			status = NT_STATUS_UNSUCCESSFUL;
			goto err_labels_free;
		}
	}

done:
	talloc_free(tmp_ctx);
	dbus_message_unref(rsp_msg);
	dbus_message_unref(req_msg);
	snapper_dbus_conn_destroy(dconn);

	return 0;

err_labels_free:
	TALLOC_FREE(sc_data->labels);
err_rsp_free:
	dbus_message_unref(rsp_msg);
err_req_free:
	dbus_message_unref(req_msg);
err_conn_free:
	snapper_dbus_conn_destroy(dconn);
err_mem_ctx_free:
	talloc_free(tmp_ctx);
err_out:
	errno = map_errno_from_nt_status(status);
	return -1;
}

static bool snapper_gmt_strip_snapshot(TALLOC_CTX *mem_ctx,
				       struct vfs_handle_struct *handle,
				       const struct smb_filename *smb_fname,
				       time_t *ptimestamp,
				       char **pstripped)
{
	char *stripped;

	if (smb_fname->twrp == 0) {
		goto no_snapshot;
	}

	if (pstripped != NULL) {
		stripped = talloc_strdup(mem_ctx, smb_fname->base_name);
		if (stripped == NULL) {
			return false;
		}
		*pstripped = stripped;
	}

	*ptimestamp = nt_time_to_unix(smb_fname->twrp);
	return true;
no_snapshot:
	*ptimestamp = 0;
	return true;
}

static NTSTATUS snapper_get_snap_at_time_call(TALLOC_CTX *mem_ctx,
					      DBusConnection *dconn,
					      const char *conf_name,
					      const char *base_path,
					      time_t snaptime,
					      char **snap_path_out)
{
	NTSTATUS status;
	DBusMessage *req_msg = NULL;
	DBusMessage *rsp_msg;
	uint32_t num_snaps;
	struct snapper_snap *snaps;
	char *snap_path;

	status = snapper_list_snaps_at_time_pack(mem_ctx,
						 conf_name,
						 snaptime,
						 snaptime,
						 &req_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_out;
	}

	status = snapper_dbus_msg_xchng(dconn, req_msg, &rsp_msg);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_req_free;
	}

	status = snapper_list_snaps_unpack(mem_ctx, rsp_msg,
					   &num_snaps, &snaps);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_rsp_free;
	}

	if (num_snaps == 0) {
		DEBUG(4, ("no snapshots found with time: %lu\n",
			  (unsigned long)snaptime));
		status = NT_STATUS_INVALID_PARAMETER;
		goto err_snap_array_free;
	} else if (num_snaps > 0) {
		DEBUG(4, ("got %u snapshots for single time %lu, using top\n",
			  num_snaps, (unsigned long)snaptime));
	}

	status = snapper_snap_id_to_path(mem_ctx, base_path, snaps[0].id,
					 &snap_path);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_snap_array_free;
	}

	*snap_path_out = snap_path;
err_snap_array_free:
	talloc_free(snaps);
err_rsp_free:
	dbus_message_unref(rsp_msg);
err_req_free:
	dbus_message_unref(req_msg);
err_out:
	return status;
}

static NTSTATUS snapper_snap_path_expand(struct connection_struct *conn,
					 TALLOC_CTX *mem_ctx,
					 time_t snap_time,
					 char **snap_dir_out)
{
	DBusConnection *dconn;
	NTSTATUS status;
	char *conf_name;
	char *base_path;
	char *snap_path = NULL;

	dconn = snapper_dbus_conn_create();
	if (dconn == NULL) {
		status = NT_STATUS_UNSUCCESSFUL;
		goto err_out;
	}

	if (conn->connectpath == NULL) {
		status = NT_STATUS_INVALID_PARAMETER;
		goto err_conn_free;
	}

	status = snapper_get_conf_call(mem_ctx, dconn,
				       conn->connectpath,
				       &conf_name,
				       &base_path);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_conn_free;
	}

	status = snapper_get_snap_at_time_call(mem_ctx, dconn,
					       conf_name, base_path, snap_time,
					       &snap_path);
	if (!NT_STATUS_IS_OK(status)) {
		goto err_conf_name_free;
	}

	/* confirm snapshot path is nested under base path */
	if (strncmp(snap_path, base_path, strlen(base_path)) != 0) {
		status = NT_STATUS_INVALID_PARAMETER;
		goto err_snap_path_free;
	}

	talloc_free(conf_name);
	talloc_free(base_path);
	snapper_dbus_conn_destroy(dconn);
	*snap_dir_out = snap_path;

	return NT_STATUS_OK;

err_snap_path_free:
	talloc_free(snap_path);
err_conf_name_free:
	talloc_free(conf_name);
	talloc_free(base_path);
err_conn_free:
	snapper_dbus_conn_destroy(dconn);
err_out:
	return status;
}

static char *snapper_gmt_convert(TALLOC_CTX *mem_ctx,
			     struct vfs_handle_struct *handle,
			     const char *name, time_t timestamp)
{
	char *snap_path = NULL;
	char *path = NULL;
	NTSTATUS status;
	int saved_errno;

	status = snapper_snap_path_expand(handle->conn, mem_ctx, timestamp,
					  &snap_path);
	if (!NT_STATUS_IS_OK(status)) {
		errno = map_errno_from_nt_status(status);
		goto err_out;
	}

	path = talloc_asprintf(mem_ctx, "%s/%s", snap_path, name);
	if (path == NULL) {
		errno = ENOMEM;
		goto err_snap_path_free;
	}

	DEBUG(10, ("converted %s/%s @ time to %s\n",
		   handle->conn->connectpath, name, path));
	return path;

err_snap_path_free:
	saved_errno = errno;
	talloc_free(snap_path);
	errno = saved_errno;
err_out:
	return NULL;
}

static int snapper_gmt_renameat(vfs_handle_struct *handle,
				files_struct *src_dirfsp,
				const struct smb_filename *smb_fname_src,
				files_struct *dst_dirfsp,
				const struct smb_filename *smb_fname_dst,
				const struct vfs_rename_how *how)
{
	time_t timestamp_src, timestamp_dst;

	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
					smb_fname_src,
					&timestamp_src, NULL)) {
		return -1;
	}
	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
					smb_fname_dst,
					&timestamp_dst, NULL)) {
		return -1;
	}
	if (timestamp_src != 0) {
		errno = EXDEV;
		return -1;
	}
	if (timestamp_dst != 0) {
		errno = EROFS;
		return -1;
	}
	return SMB_VFS_NEXT_RENAMEAT(handle,
				     src_dirfsp,
				     smb_fname_src,
				     dst_dirfsp,
				     smb_fname_dst,
				     how);
}

static int snapper_gmt_symlinkat(vfs_handle_struct *handle,
				const struct smb_filename *link_contents,
				struct files_struct *dirfsp,
				const struct smb_filename *new_smb_fname)
{
	time_t timestamp_old = 0;
	time_t timestamp_new = 0;

	if (!snapper_gmt_strip_snapshot(talloc_tos(),
				handle,
				link_contents,
				&timestamp_old,
				NULL)) {
		return -1;
	}
	if (!snapper_gmt_strip_snapshot(talloc_tos(),
				handle,
				new_smb_fname,
				&timestamp_new,
				NULL)) {
		return -1;
	}
	if ((timestamp_old != 0) || (timestamp_new != 0)) {
		errno = EROFS;
		return -1;
	}
	return SMB_VFS_NEXT_SYMLINKAT(handle,
			link_contents,
			dirfsp,
			new_smb_fname);
}

static int snapper_gmt_linkat(vfs_handle_struct *handle,
			      files_struct *src_dirfsp,
			      const struct smb_filename *old_smb_fname,
			      files_struct *dst_dirfsp,
			      const struct smb_filename *new_smb_fname,
			      int flags)
{
	time_t timestamp_old = 0;
	time_t timestamp_new = 0;

	if (!snapper_gmt_strip_snapshot(talloc_tos(),
				handle,
				old_smb_fname,
				&timestamp_old,
				NULL)) {
		return -1;
	}
	if (!snapper_gmt_strip_snapshot(talloc_tos(),
				handle,
				new_smb_fname,
				&timestamp_new,
				NULL)) {
		return -1;
	}
	if ((timestamp_old != 0) || (timestamp_new != 0)) {
		errno = EROFS;
		return -1;
	}
	return SMB_VFS_NEXT_LINKAT(handle,
				   src_dirfsp,
				   old_smb_fname,
				   dst_dirfsp,
				   new_smb_fname,
				   flags);
}

static int snapper_gmt_fstatat(struct vfs_handle_struct *handle,
			       const struct files_struct *dirfsp,
			       const struct smb_filename *smb_fname,
			       SMB_STRUCT_STAT *sbuf,
			       int flags)
{
	struct smb_filename *tmp_fname = NULL;
	time_t timestamp;
	int ret;

	if (smb_fname->twrp == 0) {
		return SMB_VFS_NEXT_FSTATAT(
			handle, dirfsp, smb_fname, sbuf, flags);
	}

	timestamp = nt_time_to_unix(smb_fname->twrp);

	tmp_fname = cp_smb_filename(talloc_tos(), smb_fname);
	if (tmp_fname == NULL) {
		errno = ENOMEM;
		return -1;
	}

	tmp_fname->base_name = snapper_gmt_convert(tmp_fname,
						   handle,
						   tmp_fname->base_name,
						   timestamp);
	if (tmp_fname->base_name == NULL) {
		TALLOC_FREE(tmp_fname);
		errno = ENOMEM;
		return -1;
	}

	ret = SMB_VFS_NEXT_FSTATAT(handle, dirfsp, tmp_fname, sbuf, flags);

	{
		int err = errno;
		TALLOC_FREE(tmp_fname);
		errno = err;
	}

	return ret;
}

static int snapper_gmt_stat(vfs_handle_struct *handle,
			    struct smb_filename *smb_fname)
{
	return snapper_gmt_fstatat(
		handle, handle->conn->cwd_fsp, smb_fname, &smb_fname->st, 0);
}

static int snapper_gmt_lstat(vfs_handle_struct *handle,
			     struct smb_filename *smb_fname)
{
	return snapper_gmt_fstatat(handle,
				   handle->conn->cwd_fsp,
				   smb_fname,
				   &smb_fname->st,
				   AT_SYMLINK_NOFOLLOW);
}

static int snapper_gmt_openat(struct vfs_handle_struct *handle,
			      const struct files_struct *dirfsp,
			      const struct smb_filename *smb_fname_in,
			      struct files_struct *fsp,
			      const struct vfs_open_how *how)
{
	struct smb_filename *smb_fname = NULL;
	time_t timestamp;
	int ret;
	int saved_errno = 0;

	if (smb_fname_in->twrp == 0) {
		return SMB_VFS_NEXT_OPENAT(handle,
					   dirfsp,
					   smb_fname_in,
					   fsp,
					   how);
	}

	timestamp = nt_time_to_unix(smb_fname_in->twrp);

	smb_fname = full_path_from_dirfsp_atname(talloc_tos(),
				dirfsp,
				smb_fname_in);

	if (smb_fname == NULL) {
		errno = ENOMEM;
		return -1;
	}

	smb_fname->base_name = snapper_gmt_convert(smb_fname,
						   handle,
						   smb_fname->base_name,
						   timestamp);

	if (smb_fname->base_name == NULL) {
		TALLOC_FREE(smb_fname);
		errno = ENOMEM;
		return -1;
	}

	ret = SMB_VFS_NEXT_OPENAT(handle, dirfsp, smb_fname, fsp, how);
	if (ret == -1) {
		saved_errno = errno;
	}
	TALLOC_FREE(smb_fname);
	if (saved_errno != 0) {
		errno = saved_errno;
	}
	return ret;
}

static int snapper_gmt_unlinkat(vfs_handle_struct *handle,
			struct files_struct *dirfsp,
			const struct smb_filename *smb_fname,
			int flags)
{
	time_t timestamp = 0;

	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
					smb_fname,
					&timestamp, NULL)) {
		return -1;
	}
	if (timestamp != 0) {
		errno = EROFS;
		return -1;
	}
	return SMB_VFS_NEXT_UNLINKAT(handle,
			dirfsp,
			smb_fname,
			flags);
}

static int snapper_gmt_fchmod(vfs_handle_struct *handle,
                       struct files_struct *fsp,
                       mode_t mode)
{
	time_t timestamp = 0;
	const struct smb_filename *smb_fname = NULL;

	smb_fname = fsp->fsp_name;

	if (!snapper_gmt_strip_snapshot(talloc_tos(),
					handle,
					smb_fname,
					&timestamp,
					NULL)) {
		return -1;
	}

	if (timestamp != 0) {
		errno = EROFS;
		return -1;
	}
	return SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
}

static int snapper_gmt_chdir(vfs_handle_struct *handle,
			const struct smb_filename *smb_fname)
{
	time_t timestamp = 0;
	char *stripped = NULL;
	int ret;
	int saved_errno = 0;
	char *conv = NULL;
	struct smb_filename *conv_smb_fname = NULL;

	if (!snapper_gmt_strip_snapshot(talloc_tos(),
				handle,
				smb_fname,
				&timestamp,
				&stripped)) {
		return -1;
	}
	if (timestamp == 0) {
		return SMB_VFS_NEXT_CHDIR(handle, smb_fname);
	}
	conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
	TALLOC_FREE(stripped);
	if (conv == NULL) {
		return -1;
	}
	conv_smb_fname = synthetic_smb_fname(talloc_tos(),
					conv,
					NULL,
					NULL,
					0,
					smb_fname->flags);
	if (conv_smb_fname == NULL) {
		TALLOC_FREE(conv);
		errno = ENOMEM;
		return -1;
	}
	ret = SMB_VFS_NEXT_CHDIR(handle, conv_smb_fname);
	if (ret == -1) {
		saved_errno = errno;
	}
	TALLOC_FREE(conv);
	TALLOC_FREE(conv_smb_fname);
	if (saved_errno != 0) {
		errno = saved_errno;
	}
	return ret;
}

static int snapper_gmt_fntimes(vfs_handle_struct *handle,
			       files_struct *fsp,
			       struct smb_file_time *ft)
{
	time_t timestamp = 0;

	if (!snapper_gmt_strip_snapshot(talloc_tos(),
					handle,
					fsp->fsp_name,
					&timestamp,
					NULL)) {
		return -1;
	}

	if (timestamp != 0) {
		errno = EROFS;
		return -1;
	}

	return SMB_VFS_NEXT_FNTIMES(handle, fsp, ft);
}

static int snapper_gmt_readlinkat(vfs_handle_struct *handle,
				const struct files_struct *dirfsp,
				const struct smb_filename *smb_fname,
				char *buf,
				size_t bufsiz)
{
	time_t timestamp = 0;
	int ret;
	int saved_errno = 0;
	struct smb_filename *full_fname = NULL;

	/*
	 * Now this function only looks at smb_fname->twrp
	 * we don't need to copy out the path. Just use
	 * smb_fname->base_name directly.
	 */
	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
					smb_fname,
					&timestamp, NULL)) {
		return -1;
	}
	if (timestamp == 0) {
		return SMB_VFS_NEXT_READLINKAT(handle,
				dirfsp,
				smb_fname,
				buf,
				bufsiz);
	}
	full_fname = full_path_from_dirfsp_atname(talloc_tos(),
				dirfsp,
				smb_fname);
	if (full_fname == NULL) {
		return -1;
	}

	/* Find the snapshot path from the full pathname. */
	full_fname->base_name = snapper_gmt_convert(full_fname,
					handle,
					full_fname->base_name,
					timestamp);
	if (full_fname->base_name == NULL) {
		TALLOC_FREE(full_fname);
		return -1;
	}
	ret = SMB_VFS_NEXT_READLINKAT(handle,
				handle->conn->cwd_fsp,
				full_fname,
				buf,
				bufsiz);
	if (ret == -1) {
		saved_errno = errno;
	}
	TALLOC_FREE(full_fname);
	if (saved_errno != 0) {
		errno = saved_errno;
	}
	return ret;
}

static int snapper_gmt_mknodat(vfs_handle_struct *handle,
			files_struct *dirfsp,
			const struct smb_filename *smb_fname,
			mode_t mode,
			SMB_DEV_T dev)
{
	time_t timestamp = (time_t)0;

	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
					smb_fname,
					&timestamp, NULL)) {
		return -1;
	}
	if (timestamp != 0) {
		errno = EROFS;
		return -1;
	}
	return SMB_VFS_NEXT_MKNODAT(handle,
			dirfsp,
			smb_fname,
			mode,
			dev);
}

static struct smb_filename *snapper_gmt_realpath(vfs_handle_struct *handle,
				TALLOC_CTX *ctx,
				const struct smb_filename *smb_fname)
{
	time_t timestamp = 0;
	char *stripped = NULL;
	struct smb_filename *result_fname = NULL;
	struct smb_filename *conv_smb_fname = NULL;
	int saved_errno = 0;

	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
					smb_fname,
					&timestamp, &stripped)) {
		goto done;
	}
	if (timestamp == 0) {
		return SMB_VFS_NEXT_REALPATH(handle, ctx, smb_fname);
	}

	conv_smb_fname = cp_smb_filename(talloc_tos(), smb_fname);
	if (conv_smb_fname == NULL) {
		goto done;
	}
	conv_smb_fname->base_name = snapper_gmt_convert(conv_smb_fname, handle,
					      stripped, timestamp);
	if (conv_smb_fname->base_name == NULL) {
		goto done;
	}

	result_fname = SMB_VFS_NEXT_REALPATH(handle, ctx, conv_smb_fname);

done:
	if (result_fname == NULL) {
		saved_errno = errno;
	}
	TALLOC_FREE(conv_smb_fname);
	TALLOC_FREE(stripped);
	if (saved_errno != 0) {
		errno = saved_errno;
	}
	return result_fname;
}

static int snapper_gmt_mkdirat(vfs_handle_struct *handle,
				struct files_struct *dirfsp,
				const struct smb_filename *fname,
				mode_t mode)
{
	time_t timestamp = 0;

	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle, fname,
					&timestamp, NULL)) {
		return -1;
	}
	if (timestamp != 0) {
		errno = EROFS;
		return -1;
	}
	return SMB_VFS_NEXT_MKDIRAT(handle,
			dirfsp,
			fname,
			mode);
}

static int snapper_gmt_fchflags(vfs_handle_struct *handle,
				struct files_struct *fsp,
				unsigned int flags)
{
	time_t timestamp = 0;

	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
				fsp->fsp_name, &timestamp, NULL)) {
		return -1;
	}
	if (timestamp != 0) {
		errno = EROFS;
		return -1;
	}
	return SMB_VFS_NEXT_FCHFLAGS(handle, fsp, flags);
}

static int snapper_gmt_fsetxattr(struct vfs_handle_struct *handle,
				struct files_struct *fsp,
				const char *aname, const void *value,
				size_t size, int flags)
{
	time_t timestamp = 0;
	const struct smb_filename *smb_fname = NULL;

	smb_fname = fsp->fsp_name;

	if (!snapper_gmt_strip_snapshot(talloc_tos(),
					handle,
					smb_fname,
					&timestamp,
					NULL)) {
		return -1;
	}
	if (timestamp != 0) {
		errno = EROFS;
		return -1;
	}
	return SMB_VFS_NEXT_FSETXATTR(handle, fsp,
				aname, value, size, flags);
}

static NTSTATUS snapper_gmt_get_real_filename_at(
	struct vfs_handle_struct *handle,
	struct files_struct *dirfsp,
	const char *name,
	TALLOC_CTX *mem_ctx,
	char **found_name)
{
	time_t timestamp;
	char *stripped;
	char *conv;
	struct smb_filename *conv_fname = NULL;
	NTSTATUS status;
	bool ok;

	ok = snapper_gmt_strip_snapshot(
		talloc_tos(), handle, dirfsp->fsp_name,&timestamp, &stripped);
	if (!ok) {
		return NT_STATUS_NO_MEMORY;
	}
	if (timestamp == 0) {
		return SMB_VFS_NEXT_GET_REAL_FILENAME_AT(
			handle, dirfsp, name, mem_ctx, found_name);
	}
	if (stripped[0] == '\0') {
		*found_name = talloc_strdup(mem_ctx, name);
		if (*found_name == NULL) {
			return NT_STATUS_NO_MEMORY;
		}
		return NT_STATUS_OK;
	}
	conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
	TALLOC_FREE(stripped);
	if (conv == NULL) {
		return map_nt_error_from_unix(errno);
	}

	status = synthetic_pathref(
		talloc_tos(),
		dirfsp->conn->cwd_fsp,
		conv,
		NULL,
		NULL,
		0,
		0,
		&conv_fname);

	status = SMB_VFS_NEXT_GET_REAL_FILENAME_AT(
		handle, conv_fname->fsp, name, mem_ctx, found_name);
	TALLOC_FREE(conv);
	return status;
}

static uint64_t snapper_gmt_disk_free(vfs_handle_struct *handle,
				const struct smb_filename *smb_fname,
				uint64_t *bsize,
				uint64_t *dfree,
				uint64_t *dsize)
{
	time_t timestamp = 0;
	char *stripped = NULL;
	uint64_t ret;
	int saved_errno = 0;
	char *conv = NULL;
	struct smb_filename *conv_smb_fname = NULL;

	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
			smb_fname, &timestamp, &stripped)) {
		return (uint64_t)-1;
	}
	if (timestamp == 0) {
		return SMB_VFS_NEXT_DISK_FREE(handle, smb_fname,
					      bsize, dfree, dsize);
	}

	conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
	TALLOC_FREE(stripped);
	if (conv == NULL) {
		return (uint64_t)-1;
	}
	conv_smb_fname = synthetic_smb_fname(talloc_tos(),
					conv,
					NULL,
					NULL,
					0,
					smb_fname->flags);
	if (conv_smb_fname == NULL) {
		TALLOC_FREE(conv);
		errno = ENOMEM;
		return (uint64_t)-1;
	}

	ret = SMB_VFS_NEXT_DISK_FREE(handle, conv_smb_fname,
				bsize, dfree, dsize);

	if (ret == (uint64_t)-1) {
		saved_errno = errno;
	}
	TALLOC_FREE(conv_smb_fname);
	if (saved_errno != 0) {
		errno = saved_errno;
	}
	return ret;
}

static int snapper_gmt_get_quota(vfs_handle_struct *handle,
			const struct smb_filename *smb_fname,
			enum SMB_QUOTA_TYPE qtype,
			unid_t id,
			SMB_DISK_QUOTA *dq)
{
	time_t timestamp = 0;
	char *stripped = NULL;
	int ret;
	int saved_errno = 0;
	char *conv = NULL;
	struct smb_filename *conv_smb_fname = NULL;

	if (!snapper_gmt_strip_snapshot(talloc_tos(), handle,
				smb_fname, &timestamp, &stripped)) {
		return -1;
	}
	if (timestamp == 0) {
		return SMB_VFS_NEXT_GET_QUOTA(handle, smb_fname, qtype, id, dq);
	}

	conv = snapper_gmt_convert(talloc_tos(), handle, stripped, timestamp);
	TALLOC_FREE(stripped);
	if (conv == NULL) {
		return -1;
	}
	conv_smb_fname = synthetic_smb_fname(talloc_tos(),
					conv,
					NULL,
					NULL,
					0,
					smb_fname->flags);
	TALLOC_FREE(conv);
	if (conv_smb_fname == NULL) {
		errno = ENOMEM;
		return -1;
	}

	ret = SMB_VFS_NEXT_GET_QUOTA(handle, conv_smb_fname, qtype, id, dq);

	if (ret == -1) {
		saved_errno = errno;
	}
	TALLOC_FREE(conv_smb_fname);
	if (saved_errno != 0) {
		errno = saved_errno;
	}
	return ret;
}

static NTSTATUS snapper_create_dfs_pathat(struct vfs_handle_struct *handle,
				struct files_struct *dirfsp,
				const struct smb_filename *smb_fname,
				const struct referral *reflist,
				size_t referral_count)
{
	time_t timestamp = 0;

	if (!snapper_gmt_strip_snapshot(talloc_tos(),
					handle,
					smb_fname,
					&timestamp,
					NULL)) {
		return NT_STATUS_NO_MEMORY;
	}
	if (timestamp != 0) {
		return NT_STATUS_MEDIA_WRITE_PROTECTED;
	}
	return SMB_VFS_NEXT_CREATE_DFS_PATHAT(handle,
			dirfsp,
			smb_fname,
			reflist,
			referral_count);
}

static struct vfs_fn_pointers snapper_fns = {
	.snap_check_path_fn = snapper_snap_check_path,
	.snap_create_fn = snapper_snap_create,
	.snap_delete_fn = snapper_snap_delete,
	.get_shadow_copy_data_fn = snapper_get_shadow_copy_data,
	.create_dfs_pathat_fn = snapper_create_dfs_pathat,
	.disk_free_fn = snapper_gmt_disk_free,
	.get_quota_fn = snapper_gmt_get_quota,
	.renameat_fn = snapper_gmt_renameat,
	.linkat_fn = snapper_gmt_linkat,
	.symlinkat_fn = snapper_gmt_symlinkat,
	.stat_fn = snapper_gmt_stat,
	.lstat_fn = snapper_gmt_lstat,
	.fstatat_fn = snapper_gmt_fstatat,
	.openat_fn = snapper_gmt_openat,
	.unlinkat_fn = snapper_gmt_unlinkat,
	.fchmod_fn = snapper_gmt_fchmod,
	.chdir_fn = snapper_gmt_chdir,
	.fntimes_fn = snapper_gmt_fntimes,
	.readlinkat_fn = snapper_gmt_readlinkat,
	.mknodat_fn = snapper_gmt_mknodat,
	.realpath_fn = snapper_gmt_realpath,
	.mkdirat_fn = snapper_gmt_mkdirat,
	.getxattrat_send_fn = vfs_not_implemented_getxattrat_send,
	.getxattrat_recv_fn = vfs_not_implemented_getxattrat_recv,
	.fsetxattr_fn = snapper_gmt_fsetxattr,
	.fchflags_fn = snapper_gmt_fchflags,
	.get_real_filename_at_fn = snapper_gmt_get_real_filename_at,
};

static_decl_vfs;
NTSTATUS vfs_snapper_init(TALLOC_CTX *ctx)
{
	return smb_register_vfs(SMB_VFS_INTERFACE_VERSION,
				"snapper", &snapper_fns);
}
