/*
 * Copyright (C) 2012, 2014, 2016  J. Ali Harlow <ali@juiblex.co.uk>
 *
 * 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 2 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, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include "config.h"

#if ENABLE_ATOMIC && !HAVE_WINDOWS_KTM

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include "razor-internal.h"

/*
 * Emulated atomic support
 *
 * This implementation is better than nothing, but is certainly not atomic.
 * It does have a couple of advantages over atomic-none:
 *	- If a file operation fails while a package is being installed we
 *	  have a good chance of being able to rollback the transaction to
 *	  a well-known state.
 *	- We behave similarly to atomic-ktm in that changes are not visible
 *	  on disk to non-atomic operations (eg., scripts) until the atomic
 *	  is committed. This makes the testsuite more likely to pick up
 *	  problems that would otherwise only be found when using razor on
 *	  an MS-Windows system which supports KTM.
 */

#ifndef O_BINARY
#define O_BINARY	0
#endif

static void recursive_remove(const char *directory)
{
	void *dp;
	char *name, *buf;

	dp = razor_uri_opendir(directory, NULL);

	if (dp) {
		while((name = razor_uri_readdir(dp, NULL))) {
			buf = razor_concat(directory, "/", name, NULL);
			free(name);
			if (razor_uri_unlink(buf, NULL) < 0)
				recursive_remove(buf);
			free(buf);
		}

		razor_uri_closedir(dp, NULL);
	}

	rmdir(directory);
}

RAZOR_EXPORT struct razor_atomic *razor_atomic_open(const char *description)
{
	struct razor_atomic *atomic;

	atomic = zalloc(sizeof *atomic);

	atomic->description = strdup(description);

	return atomic;
}

RAZOR_EXPORT int razor_atomic_commit(struct razor_atomic *atomic)
{
	struct atomic_action *actions;

	if (razor_atomic_in_error_state(atomic))
		return -1;

	if (atomic->actions) {
		actions = atomic_action_list_reverse(atomic->actions);
		atomic->actions = NULL;
		actions = atomic_action_do(atomic, actions);
		atomic_action_free(actions);
	}

	if (atomic->toplevel) {
		recursive_remove(atomic->toplevel);
		free(atomic->toplevel);
		atomic->toplevel = NULL;
	}

	return razor_atomic_in_error_state(atomic);
}

RAZOR_EXPORT void razor_atomic_destroy(struct razor_atomic *atomic)
{
	if (atomic->actions) {
		atomic_action_free(atomic->actions);
		atomic->actions = NULL;
	}

	if (atomic->toplevel) {
		recursive_remove(atomic->toplevel);
		free(atomic->toplevel);
		atomic->toplevel = NULL;
	}

	if (atomic->error)
		razor_error_free(atomic->error);

	free(atomic->description);

	free(atomic);
}

/*
 * We need a toplevel directory in which to hold temporary files
 * before they are committed. Since we can generally assume that
 * we have write permissions anywhere on the filesystem in
 * question, the best location is at the relevant mount point.
 * The most common case where this assumption fails is when
 * testing, when the current directory is a good choice.
 */

static int
razor_atomic_set_toplevel_from_uri(struct razor_atomic *atomic,
				   const char *uri)
{
	if (razor_atomic_in_error_state(atomic))
		return -1;

	if (atomic->toplevel)
		return 0;

#ifdef MSWIN_API
	atomic->toplevel = razor_uri_mkdtemp_near(uri, "atomic-XXXXXX",
						   &atomic->error);
#else
	atomic->toplevel = razor_uri_mkdtemp_near(uri, ".atomic-XXXXXX",
						   &atomic->error);
#endif

	return !atomic->toplevel;
}

/*
 * If root_uri is empty, then uri can be a URI (but not a relative-ref; ie.,
 * a scheme must be specified). If root_uri is non-empty, then it must be a
 * URI (but not a relative-ref) and uri must be a non-empty path.
 */
RAZOR_EXPORT int
razor_atomic_make_dirs(struct razor_atomic *atomic, const char *root_uri,
		       const char *uri)
{
	struct atomic_action *a;
	struct razor_uri ru;
	struct razor_error *tmp_error = NULL;
	char *fakeroot = NULL;

	razor_atomic_set_toplevel_from_uri(atomic, *root_uri ? root_uri : uri);

	if (razor_atomic_in_error_state(atomic))
		return -1;

	if (!*root_uri) {
		if (razor_uri_parse(&ru, uri, &tmp_error)) {
			razor_atomic_propagate_error(atomic, tmp_error, NULL);
			return -1;
		}
		if (*ru.path == '/') {
			free(ru.path);
			ru.path = strdup("/");
		} else {
			free(ru.path);
			ru.path = strdup("");
		}
		fakeroot = razor_uri_recompose(&ru);
		razor_uri_destroy(&ru);
		root_uri = fakeroot;
		uri += strlen(fakeroot);
	}

	a = atomic_action_new(ACTION_MAKE_DIRS);
	a->args.uri = strdup(uri);
	a->args.u.make_dirs.root = strdup(root_uri);
	atomic->actions = atomic_action_list_prepend(atomic->actions, a);

	if (fakeroot)
		free(fakeroot);

	return 0;
}

RAZOR_EXPORT int
razor_atomic_remove(struct razor_atomic *atomic, const char *uri)
{
	struct atomic_action *a;

	razor_atomic_set_toplevel_from_uri(atomic, uri);

	if (razor_atomic_in_error_state(atomic))
		return -1;

	a = atomic_action_new(ACTION_REMOVE);
	a->args.uri = strdup(uri);
	atomic->actions = atomic_action_list_prepend(atomic->actions, a);

	return 0;
}

RAZOR_EXPORT int
razor_atomic_rename_file(struct razor_atomic *atomic, const char *old_uri,
			 const char *new_uri)
{
	struct atomic_action *a;

	razor_atomic_set_toplevel_from_uri(atomic, new_uri);

	if (razor_atomic_in_error_state(atomic))
		return -1;

	a = atomic_action_new(ACTION_MOVE);
	a->args.uri = strdup(old_uri);
	a->args.u.move.dest = strdup(new_uri);
	atomic->actions = atomic_action_list_prepend(atomic->actions, a);

	return 0;
}

RAZOR_EXPORT int
razor_atomic_create_dir(struct razor_atomic *atomic, const char *uri,
			mode_t mode)
{
	struct atomic_action *a;

	razor_atomic_set_toplevel_from_uri(atomic, uri);

	if (razor_atomic_in_error_state(atomic))
		return -1;

	a = atomic_action_new(ACTION_CREATE_DIR);
	a->args.uri = strdup(uri);
	a->args.u.create_dir.mode = mode;
	atomic->actions = atomic_action_list_prepend(atomic->actions, a);

	return 0;
}

RAZOR_EXPORT int
razor_atomic_create_symlink(struct razor_atomic *atomic, const char *target,
			    const char *uri)
{
#if HAVE_SYMLINK
	struct atomic_action *a;

	razor_atomic_set_toplevel_from_uri(atomic, uri);
#endif

	if (razor_atomic_in_error_state(atomic))
		return -1;

#if HAVE_SYMLINK
	a = atomic_action_new(ACTION_CREATE_SYMLINK);
	a->args.uri = strdup(uri);
	a->args.u.create_symlink.target = strdup(target);
	atomic->actions = atomic_action_list_prepend(atomic->actions, a);

	return 0;
#else
	atomic->error = razor_error_new_str(RAZOR_POSIX_ERROR, ENOSYS, NULL,
					    "Symbolic links not supported "
					    "on this platform");

	return -1;
#endif
}

RAZOR_EXPORT int
razor_atomic_create_file(struct razor_atomic *atomic, const char *uri,
                         mode_t mode)
{
	int fd;
	struct atomic_action *a;
	char *tmpnam;

	razor_atomic_set_toplevel_from_uri(atomic, uri);

	if (razor_atomic_in_error_state(atomic))
		return -1;

	tmpnam = atomic_action_attic_tmpnam(atomic);
	fd = razor_uri_open(tmpnam, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
			    mode & (S_IRWXU | S_IRWXG | S_IRWXO),
			    &atomic->error);

	if (fd >= 0) {
		a = atomic_action_new(ACTION_MOVE);
		a->args.uri = tmpnam;
		a->args.u.move.dest = strdup(uri);
		atomic->actions = atomic_action_list_prepend(atomic->actions,
							     a);
	}

	return fd;
}

#endif	/* ENABLE_ATOMIC && !HAVE_WINDOWS_KTM */