/*

  * Copyright (C) 2011-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

 #include <stdlib.h>

 #ifdef MSWIN_API

 #include <windows.h>

 #endif

 #include <stdio.h>

 #include <limits.h>

 #include <errno.h>

 #include <unistd.h>

 #include <fcntl.h>

 #include <sys/stat.h>

 #include <string.h>

 #include <assert.h>

 #include "razor.h"

 #include "razor-internal.h"

 #ifndef O_BINARY

 #define O_BINARY	0

 #endif

 RAZOR_EXPORT struct razor_atomic *

 razor_atomic_open(const char *description)

 {

 	struct razor_atomic *atomic;

 	atomic = zalloc(sizeof *atomic);

 	return atomic;

 }

 RAZOR_EXPORT int

 razor_atomic_commit(struct razor_atomic *atomic)

 {

 	return razor_atomic_in_error_state(atomic);

 }

 RAZOR_EXPORT void

 razor_atomic_destroy(struct razor_atomic *atomic)

 {

 	if (atomic->error)

 		razor_error_free(atomic->error);

 	free(atomic);

 }

 RAZOR_EXPORT int

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

 		       const char *path)

 {

 	char buffer[PATH_MAX], *p;

 	const char *slash, *next;

 	struct stat buf;

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 	strcpy(buffer, root);

 	p = buffer + strlen(buffer);

 	slash = path;

 	for (slash = path; *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;

 		if (stat(buffer, &buf) == 0) {

 			if (!S_ISDIR(buf.st_mode)) {

 				atomic->error = razor_error_new_str(buffer,

 								    "Not a directory");

 				return -1;

 			}

 		} else if (mkdir(buffer, 0777) < 0) {

 			atomic->error = razor_error_new_str(buffer,

 							    strerror(errno));

 			return -1;

 		}

 	}

 	return 0;

 }

 RAZOR_EXPORT int

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

 {

 #ifdef MSWIN_API

 	wchar_t *buf;

 	DWORD err;

 #endif

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 #ifdef MSWIN_API

 	buf = razor_utf8_to_utf16(path, -1);

 	if (!DeleteFileW(buf)) {

 		err = GetLastError();

 		if (err != ERROR_FILE_NOT_FOUND &&

 		    err != ERROR_PATH_NOT_FOUND &&

 		    !(SetFileAttributesW(buf, FILE_ATTRIBUTE_NORMAL) &&

 		      DeleteFileW(buf)) &&

 		    !RemoveDirectoryW(buf) &&

 		    GetLastError() != ERROR_DIR_NOT_EMPTY)

 			atomic->error = razor_error_new_mswin(buf, err);

 	}

 	free(buf);

 #else

 	if (remove(path))

 		atomic->error = razor_error_new_str(path, strerror(errno));

 #endif

 	return razor_atomic_in_error_state(atomic);

 }

 RAZOR_EXPORT int

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

 			 const char *newpath)

 {

 #ifdef MSWIN_API

 	wchar_t *oldbuf, *newbuf;

 	const DWORD flags = MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING;

 #endif

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 #ifdef MSWIN_API

 	newbuf = razor_utf8_to_utf16(newpath, -1);

 	oldbuf = razor_utf8_to_utf16(oldpath, -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))

 		atomic->error = razor_error_new_mswin(newbuf, GetLastError());

 	free(newbuf);

 	free(oldbuf);

 #else

 	if (rename(oldpath, newpath))

 		atomic->error = razor_error_new_str(newpath, strerror(errno));

 #endif

 	return razor_atomic_in_error_state(atomic);

 }

 RAZOR_EXPORT int

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

 			mode_t mode)

 {

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 	if (!mkdir(dirname, mode & (S_IRWXU | S_IRWXG | S_IRWXO)))

 		return 0;

 	if (errno != EEXIST) {

 		atomic->error = razor_error_new_str(dirname, strerror(errno));

 		return -1;

 	}

 	if (chmod(dirname, mode & (S_IRWXU | S_IRWXG | S_IRWXO)) < 0) {

 		atomic->error = razor_error_new_str(dirname, strerror(errno));

 		return -1;

 	}

 	return 0;

 }

 RAZOR_EXPORT int

 razor_atomic_create_symlink(struct razor_atomic *atomic, const char *target,

 			    const char *path)

 {

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

 #if HAVE_SYMLINK

 	if (symlink(target, path) < 0) {

 		atomic->error = razor_error_new_str(path, strerror(errno));

 		return -1;

 	}

 	return 0;

 #else

 	atomic->error = razor_error_new_str(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;

 	if (razor_atomic_in_error_state(atomic))

 		return -1;

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

 		  mode & (S_IRWXU | S_IRWXG | S_IRWXO));

 	if (fd == -1)

 		atomic->error = razor_error_new_str(filename, strerror(errno));

 	return fd;

 }

 #endif	/* !ENABLE_ATOMIC */