/*

 * 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 */