/*

  * Copyright (C) 2012  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 <limits.h>

 #include <errno.h>

 #include <sys/stat.h>

 #include <sys/types.h>

 #include <dirent.h>

 #include <assert.h>

 #include "razor-internal.h"

 char *atomic_action_attic_tmpnam(struct razor_atomic *atomic)

 {

 	char filename[17];

 	sprintf(filename,"%03X",atomic->next_file_tag++);

 	return razor_concat(atomic->toplevel, "/", filename, NULL);

 }

 static struct atomic_action *

 atomic_action_list_pop_head(struct atomic_action **list)

 {

 	struct atomic_action *head;

 	head = *list;

 	if (head) {

 		*list = head->next;

 		head->next = NULL;

 	}

 	return head;

 }

 struct atomic_action *

 atomic_action_list_prepend(struct atomic_action *list,

 			   struct atomic_action *action)

 {

 	assert(action->next == NULL);

 	action->next=list;

 	return action;

 }

 static struct atomic_action *

 atomic_action_list_concat(struct atomic_action *list1,

 			  struct atomic_action *list2)

 {

 	struct atomic_action *action;

 	if (!list1)

 		return list2;

 	for(action=list1;action->next;action=action->next)

 		;

 	action->next=list2;

 	return list1;

 }

 void atomic_action_free(struct atomic_action *action)

 {

 	struct atomic_action *a;

 	while(action) {

 		a = atomic_action_list_pop_head(&action);

 		free(a->args.path);

 		switch(a->type) {

 		case ACTION_MAKE_DIRS:

 			free(a->args.u.make_dirs.root);

 			break;

 		case ACTION_MOVE:

 			free(a->args.u.move.dest);

 			break;

 #if HAVE_SYMLINK

 		case ACTION_CREATE_SYMLINK:

 			free(a->args.u.create_symlink.target);

 			break;

 #endif

 		case ACTION_REMOVE:

 		case ACTION_CREATE_DIR:

 			break;

 		}

 		free(a);

 	}

 }

 struct atomic_action *atomic_action_new(enum atomic_action_type type)

 {

 	struct atomic_action *action;

 	action = zalloc(sizeof *action);

 	action->type = type;

 	return action;

 }

 struct atomic_action *atomic_action_list_reverse(struct atomic_action *list)

 {

 	struct atomic_action *prev = NULL, *next;

 	while(list) {

 		next = list->next;

 		list->next = prev;

 		prev = list;

 		list = next;

 	}

 	return prev;

 }

 /*

  * All action_ functions take 1 action and return a list of primitive

  * actions they took (such that the first action in the list is the

  * last action they took). Primitive actions are always reversable.

  *

  * On failure, an error should be set on the atomic object (if it is

  * not already set), the action freed and NULL returned.

  *

  * Whether they succeed or fail, they take ownership of the passed

  * action and should thus either free it or return it back to their

  * caller as appropriate.

  *

  * A NULL return means that nothing was done which may, or may not,

  * indicate an error.

  */

 static struct atomic_action *

 atomic_action_make_dirs(struct razor_atomic *atomic,

 			struct atomic_action *action)

 {

 	char buffer[PATH_MAX], *p;

 	const char *slash, *next;

 	struct atomic_action *primitives = NULL;

 	struct atomic_action *prim;

 	if (razor_atomic_in_error_state(atomic)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	strcpy(buffer, action->args.u.make_dirs.root);

 	p = buffer + strlen(buffer);

 	slash = action->args.path;

 	for (; *slash != '\0'; slash = next) {

 #ifdef MSWIN_API

 		next = strpbrk(slash + 1, "/\\");

 #else

 		next = strchr(slash + 1, '/');

 #endif

 		if (next == NULL)

 			break;

 		memcpy(p, slash, next - slash);

 		p += next - slash;

 		*p = '\0';

 		if (razor_valid_root_name(buffer))

 			continue;

 		prim = atomic_action_new(ACTION_CREATE_DIR);

 		prim->args.path = strdup(buffer);

 		prim->args.u.create_dir.mode = S_IRWXU | S_IRWXG | S_IRWXO;

 		primitives = atomic_action_list_prepend(primitives, prim);

 	}

 	primitives = atomic_action_list_reverse(primitives);

 	atomic_action_free(action);

 	return atomic_action_do(atomic, primitives);

 }

 static struct atomic_action *

 atomic_action_remove(struct razor_atomic *atomic, struct atomic_action *action)

 {

 #ifdef MSWIN_API

 	wchar_t *path;

 	_WDIR *dir;

 #else

 	DIR *dir;

 #endif

 	struct atomic_action *prim;

 	if (razor_atomic_in_error_state(atomic)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	/*

 	 * Non-empty directories should NOT be removed

 	 */

 #ifdef MSWIN_API

 	path = razor_utf8_to_utf16(action->args.path, -1);

 	dir = _wopendir(path);

 	if (dir && _wreaddir(dir)) {

 		atomic_action_free(action);

 		action = NULL;

 	}

 	_wclosedir(dir);

 #else

 	dir = opendir(action->args.path);

 	if (dir && readdir(dir)) {

 		atomic_action_free(action);

 		action = NULL;

 	}

 	closedir(dir);

 #endif

 	if (action) {

 		prim = atomic_action_new(ACTION_MOVE);

 		prim->args.path = strdup(action->args.path);

 		prim->args.u.move.dest = atomic_action_attic_tmpnam(atomic);

 		atomic_action_free(action);

 	} else

 		prim = NULL;

 	return prim ? atomic_action_do(atomic, prim) : NULL;

 }

 static struct atomic_action *

 atomic_action_create_dir(struct razor_atomic *atomic,

 			 struct atomic_action *action)

 {

 	mode_t mode;

 	struct stat buf;

 	if (razor_atomic_in_error_state(atomic)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	mode = action->args.u.create_dir.mode & (S_IRWXU | S_IRWXG | S_IRWXO);

 	if (!mkdir(action->args.path, mode))

 		return action;

 	if (errno != EEXIST || stat(action->args.path, &buf)) {

 		if (!atomic->error)

 			atomic->error = razor_error_new_posix(action->args.path);

 		atomic_action_free(action);

 		return NULL;

 	}

 	if (!S_ISDIR(buf.st_mode) && !atomic->error)

 		atomic->error = razor_error_new_str(RAZOR_POSIX_ERROR, EEXIST,

 						    action->args.path,

 						    "Not a directory");

 	atomic_action_free(action);

 	return NULL;

 }

 static struct atomic_action *atomic_action_rmdir(struct razor_atomic *atomic,

 						 struct atomic_action *action)

 {

 	if (razor_atomic_in_error_state(atomic)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	if (rmdir(action->args.path) < 0) {

 		if (!atomic->error)

 			atomic->error = razor_error_new_posix(action->args.path);

 		atomic_action_free(action);

 		return NULL;

 	} else

 		return action;

 }

 #if HAVE_SYMLINK

 static struct atomic_action *

 atomic_action_create_symlink(struct razor_atomic *atomic,

 			     struct atomic_action *action)

 {

 	int r;

 	if (razor_atomic_in_error_state(atomic)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	r = symlink(action->args.u.create_symlink.target, action->args.path);

 	if (r < 0) {

 		if (!atomic->error)

 			atomic->error = razor_error_new_posix(action->args.path);

 		atomic_action_free(action);

 		return NULL;

 	}

 	return action;

 }

 static struct atomic_action *

 atomic_action_remove_symlink(struct razor_atomic *atomic,

 			     struct atomic_action *action)

 {

 	if (razor_atomic_in_error_state(atomic)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	if (unlink(action->args.path) < 0) {

 		if (!atomic->error)

 			atomic->error = razor_error_new_posix(action->args.path);

 		atomic_action_free(action);

 		return NULL;

 	}

 	return action;

 }

 #endif

 static int

 move_file(struct razor_atomic *atomic, const char *path, const char *dest)

 {

 #ifdef MSWIN_API

 	wchar_t *oldbuf, *newbuf;

 	const DWORD flags = MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING;

 	newbuf = razor_utf8_to_utf16(dest, -1);

 	oldbuf = razor_utf8_to_utf16(path, -1);

 	/*

 	 * Passing MOVEFILE_REPLACE_EXISTING to MoveFileEx() will

 	 * cover every case we care about _except_ replacing an empty

 	 * directory with a file. Calling RemoveDirectory() will deal

 	 * with this case while having no effect in all other cases.

 	 */

 	(void)RemoveDirectoryW(newbuf);

 	if (!MoveFileExW(oldbuf, newbuf, flags)) {

 		if (!atomic->error)

 			atomic->error = razor_error_new_mswin(newbuf,

 							      GetLastError());

 		return -1;

 	}

 	free(newbuf);

 	free(oldbuf);

 #else

 	int code;

 	const char *object;

 	if (rename(path, dest)) {

 		if (!atomic->error) {

 			code = errno;

 			if (access(path, F_OK) < 0)

 				object = path;

 			else

 				object = dest;

 			atomic->error = razor_error_new_str(RAZOR_POSIX_ERROR,

 							    code, object,

 							    strerror(code));

 		}

 		return -1;

 	}

 #endif

 	return 0;

 }

 static struct atomic_action *

 atomic_action_move(struct razor_atomic *atomic, struct atomic_action *action)

 {

 	if (razor_atomic_in_error_state(atomic)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	if (move_file(atomic, action->args.path, action->args.u.move.dest)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	return action;

 }

 static struct atomic_action *

 atomic_action_unmove(struct razor_atomic *atomic, struct atomic_action *action)

 {

 	if (razor_atomic_in_error_state(atomic)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	if (move_file(atomic, action->args.u.move.dest, action->args.path)) {

 		atomic_action_free(action);

 		return NULL;

 	}

 	return action;

 }

 static struct atomic_action *atomic_action_apply(struct razor_atomic *atomic,

 						 struct atomic_action *action)

 {

 	switch(action->type) {

 	case ACTION_MAKE_DIRS:

 		action = atomic_action_make_dirs(atomic, action);

 		break;

 	case ACTION_REMOVE:

 		action = atomic_action_remove(atomic, action);

 		break;

 	case ACTION_CREATE_DIR:

 		action = atomic_action_create_dir(atomic, action);

 		break;

 	case ACTION_MOVE:

 		action = atomic_action_move(atomic, action);

 		break;

 #if HAVE_SYMLINK

 	case ACTION_CREATE_SYMLINK:

 		action = atomic_action_create_symlink(atomic, action);

 		break;

 #endif

 	}

 	return action;

 }

 static struct atomic_action *atomic_action_reverse(struct razor_atomic *atomic,

 						   struct atomic_action *action)

 {

 	switch(action->type) {

 	case ACTION_MAKE_DIRS:

 	case ACTION_REMOVE:

 		/* Complex actions: should never happen */

 		break;

 	case ACTION_CREATE_DIR:

 		action = atomic_action_rmdir(atomic, action);

 		break;

 	case ACTION_MOVE:

 		action = atomic_action_unmove(atomic, action);

 		break;

 #if HAVE_SYMLINK

 	case ACTION_CREATE_SYMLINK:

 		action = atomic_action_remove_symlink(atomic, action);

 		break;

 #endif

 	}

 	return action;

 }

 /*

  * Note that undo has no error checking.

  */

 void atomic_action_undo(struct razor_atomic *atomic,

 			struct atomic_action *actions)

 {

 	struct atomic_action *a;

 	atomic->in_undo = 1;

 	while (actions) {

 		a = atomic_action_list_pop_head(&actions);

 		a = atomic_action_reverse(atomic, a);

 		atomic_action_free(a);

 	}

 	atomic->in_undo = 0;

 }

 struct atomic_action *atomic_action_do(struct razor_atomic *atomic,

 				       struct atomic_action *actions)

 {

 	struct atomic_action *done = NULL, *a;

 	if (razor_atomic_in_error_state(atomic)) {

 		atomic_action_free(actions);

 		return NULL;

 	}

 	while (actions) {

 		a = atomic_action_list_pop_head(&actions);

 		a = atomic_action_apply(atomic, a);

 		if (a)

 			done = atomic_action_list_concat(a, done);

 		if (razor_atomic_in_error_state(atomic)) {

 			atomic_action_undo(atomic, done);

 			done = NULL;

 			atomic_action_free(a);

 		}

 	}

 	return done;

 }

 #endif	/* ENABLE_ATOMIC && !HAVE_WINDOWS_KTM */