/*

  * Copyright (C) 2012, 2014  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 <sys/types.h>

 #include <sys/stat.h>

 #include <fcntl.h>

 #include <dirent.h>

 #include <errno.h>

 #include <unistd.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)

 {

 	DIR *dp;

 	struct dirent *dirp;

 	char *buf;

 	dp = opendir(directory);

 	while((dirp = readdir(dp))) {

 		if (strcmp(dirp->d_name, ".") && strcmp(dirp->d_name, "..")) {

 			buf = malloc(strlen(directory) + strlen(dirp->d_name)

 				     + 2);

 			sprintf(buf, "%s/%s", directory, dirp->d_name);

 			if (remove(buf) < 0)

 				recursive_remove(buf);

 			free(buf);

 		}

 	}

 	closedir(dp);

 	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);

 }

 #ifndef MSWIN_API

 static char *absolute_path(const char *path)

 {

 	int len;

 	char *result, *subpath, *p, *s, *t;

 	result = realpath(path, NULL);

 	if (!result && errno == ENOENT) {

 		p = strdup(path);

 		s = strrchr(p, '/');

 		while (s) {

 			if (s == p) {

 				result = strdup("/");

 				break;

 			}

 			*s = '\0';

 			subpath = realpath(p, NULL);

 			if (subpath) {

 				*s = '/';

 				len = strlen(subpath);

 				result = malloc(len + strlen(s) + 1);

 				memcpy(result, subpath, len);

 				strcpy(result + len, s);

 				free(subpath);

 				break;

 			} else if (errno != ENOENT)

 				break;

 			t = strrchr(p, '/');

 			*s = '/';

 			s = t;

 		}

 		if (!s)

 			result = realpath(".", NULL);

 		free(p);

 	}

 	return result;

 }

 #endif

 /*

  * 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_path(struct razor_atomic *atomic,

 				    const char *path)

 {

 #ifndef MSWIN_API

 	dev_t filesystem;

 	struct stat buf;

 #endif

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 	if (atomic->toplevel)

 		return 0;

 #ifdef MSWIN_API

 	if (path[0]=='\\' && path[1]=='\\' && path[2] && path[2]!='\\'

 	    && strchr(path+3,'\\')) {

 		/* We have a UNC path: \\servername\sharename... */

 		const char *sharename, *root;

 		int disklen;

 		sharename = strchr(path+3,'\\')+1;

 		root = strchr(sharename,'\\');

 		if (root)

 		    disklen = root - path;

 		else

 		    disklen = strlen(path);

 		atomic->toplevel =

 		  malloc(disklen + strlen("\\atomic-XXXXXX") + 1);

 		memcpy(atomic->toplevel, path, disklen);

 		strcpy(atomic->toplevel + disklen, "\\atomic-XXXXXX");

 	} else if ((*path>='A' && *path<='Z' || *path>='a' && *path<='z') &&

 		    path[1]==':') {

 		atomic->toplevel = strdup("X:\\atomic-XXXXXX");

 		*atomic->toplevel = *path;

 	} else {

 		DWORD n;

 		wchar_t *buf;

 		char *dir;

 		n = GetCurrentDirectoryW(0, NULL);

 		buf = malloc(n * sizeof(wchar_t));

 		if (GetCurrentDirectoryW(n, buf)) {

 			dir = razor_utf16_to_utf8(buf, n - 1);

 			razor_atomic_set_toplevel_from_path(atomic, dir);

 			free(dir);

 			free(buf);

 			return;

 		} else

 			atomic->toplevel = strdup("C:\\atomic-XXXXXX");

 		free(buf);

 	}

 #else

 	{

 		/*

 		 * Find the mount point (assuming we can write to the

 		 * whole filesystem). Otherwise stop at the first

 		 * unwritable directory and take one step back.

 		 */

 		char *s, *abspath, saved;

 		int len, can_step_back = 0;

 		abspath = absolute_path(path);

 		if (!abspath) {

 			atomic->error = razor_error_new_posix(path);

 			return -1;

 		}

 		if (stat(abspath, &buf) < 0) {

 			if (errno == ENOENT)

 				filesystem = 0;

 			else {

 				atomic->error = razor_error_new_posix(abspath);

 				free(abspath);

 				return -1;

 			}

 		} else

 			filesystem = buf.st_dev;

 		len = strlen(abspath);

 		while(len > 1 && (s = strrchr(abspath, '/'))) {

 			if (s == abspath) {

 				saved = s[1];

 				s[1] = '\0';

 				len = s + 1 - abspath;

 			} else {

 				s[0] = '\0';

 				len = s - abspath;

 			}

 			if (stat(abspath, &buf) < 0) {

 				if (errno == ENOENT)

 					continue;

 				else {

 				    atomic->error = razor_error_new_posix(abspath);

 				    free(abspath);

 				    return -1;

 				}

 			} else if (!filesystem)

 				filesystem = buf.st_dev;

 			if (buf.st_dev != filesystem || access(abspath, W_OK)) {

 				if (can_step_back) {

 					if (s == abspath)

 						s[1] = saved;

 					else

 						s[0] = '/';

 				}

 				len = strlen(abspath);

 				break;

 			} else

 				can_step_back = 1;

 		}

 		if (len == 1)

 			len = 0;	/* Avoid an unslightly double slash. */

 		atomic->toplevel = malloc(len + strlen("/.atomic-XXXXXX") + 1);

 		memcpy(atomic->toplevel, abspath, len);

 		strcpy(atomic->toplevel + len, "/.atomic-XXXXXX");

 		free(abspath);

 	}

 #endif

 	if (!mkdtemp(atomic->toplevel)) {

 		int err = errno;

 #ifdef EACCES

 		if (err == EACCES) {

 			char *s = strdup("atomic-XXXXXX");

 #ifndef MSWIN_API

 			if (stat(".", &buf) < 0) {

 				atomic->error = razor_error_new_posix(".");

 				free(s);

 				free(atomic->toplevel);

 				atomic->toplevel = NULL;

 				return -1;

 			}

 			if (buf.st_dev != filesystem)

 				/*

 				 * Don't use a different filesystem. It will

 				 * only fail later on (in rename) and cause

 				 * an unhelpful error message (EXDEV).

 				 */

 				free(s);

 			else

 #endif

 			if (mkdtemp(s)) {

 				free(atomic->toplevel);

 				atomic->toplevel = s;

 				return 0;

 			} else

 				free(s);

 		}

 #endif

 		atomic->error = razor_error_new_str(RAZOR_POSIX_ERROR, err,

 						    atomic->toplevel,

 						    strerror(err));

 		free(atomic->toplevel);

 		atomic->toplevel = NULL;

 	}

 	return !atomic->toplevel;

 }

 RAZOR_EXPORT int

 razor_atomic_make_dirs(struct razor_atomic *atomic, const char *root,

 		       const char *path)

 {

 	struct atomic_action *a;

 	razor_atomic_set_toplevel_from_path(atomic, *root ? root : path);

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 	a = atomic_action_new(ACTION_MAKE_DIRS);

 	a->args.path = strdup(path);

 	a->args.u.make_dirs.root = strdup(root);

 	atomic->actions = atomic_action_list_prepend(atomic->actions, a);

 	return 0;

 }

 RAZOR_EXPORT int

 razor_atomic_remove(struct razor_atomic *atomic, const char *path)

 {

 	struct atomic_action *a;

 	razor_atomic_set_toplevel_from_path(atomic, path);

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 	a = atomic_action_new(ACTION_REMOVE);

 	a->args.path = strdup(path);

 	atomic->actions = atomic_action_list_prepend(atomic->actions, a);

 	return 0;

 }

 RAZOR_EXPORT int

 razor_atomic_rename_file(struct razor_atomic *atomic, const char *oldpath,

 			 const char *newpath)

 {

 	struct atomic_action *a;

 	razor_atomic_set_toplevel_from_path(atomic, newpath);

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 	a = atomic_action_new(ACTION_MOVE);

 	a->args.path = strdup(oldpath);

 	a->args.u.move.dest = strdup(newpath);

 	atomic->actions = atomic_action_list_prepend(atomic->actions, a);

 	return 0;

 }

 RAZOR_EXPORT int

 razor_atomic_create_dir(struct razor_atomic *atomic, const char *dirname,

 			mode_t mode)

 {

 	struct atomic_action *a;

 	razor_atomic_set_toplevel_from_path(atomic, dirname);

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 	a = atomic_action_new(ACTION_CREATE_DIR);

 	a->args.path = strdup(dirname);

 	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 *path)

 {

 #if HAVE_SYMLINK

 	struct atomic_action *a;

 	razor_atomic_set_toplevel_from_path(atomic, path);

 #endif

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 #if HAVE_SYMLINK

 	a = atomic_action_new(ACTION_CREATE_SYMLINK);

 	a->args.path = strdup(path);

 	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 *filename,

                          mode_t mode)

 {

 	int fd;

 	struct atomic_action *a;

 	char *tmpnam;

 	razor_atomic_set_toplevel_from_path(atomic, filename);

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 	tmpnam = atomic_action_attic_tmpnam(atomic);

 	fd = open(tmpnam, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,

 		  mode & (S_IRWXU | S_IRWXG | S_IRWXO));

 	if (fd == -1)

 		atomic->error = razor_error_new_posix(filename);

 	else {

 		a = atomic_action_new(ACTION_MOVE);

 		a->args.path = tmpnam;

 		a->args.u.move.dest = strdup(filename);

 		atomic->actions = atomic_action_list_prepend(atomic->actions,

 							     a);

 	}

 	return fd;

 }

 #endif	/* ENABLE_ATOMIC && !HAVE_WINDOWS_KTM */