/*

 * Copyright (C) the libgit2 contributors. All rights reserved.

 *

 * This file is part of libgit2, distributed under the GNU GPL v2 with

 * a Linking Exception. For full terms see the included COPYING file.

 */

#include "common.h"

#include "path.h"

#include "posix.h"

#include "repository.h"

#ifdef GIT_WIN32

#include "win32/posix.h"

#include "win32/w32_buffer.h"

#include "win32/w32_util.h"

#include "win32/version.h"

#else

#include <dirent.h>

#endif

#include <stdio.h>

#include <ctype.h>

#define LOOKS_LIKE_DRIVE_PREFIX(S) (git__isalpha((S)[0]) && (S)[1] == ':')

#ifdef GIT_WIN32

static bool looks_like_network_computer_name(const char *path, int pos)

{

	if (pos < 3)

		return false;

	if (path[0] != '/' || path[1] != '/')

		return false;

	while (pos-- > 2) {

		if (path[pos] == '/')

			return false;

	}

	return true;

}

#endif

/*

 * Based on the Android implementation, BSD licensed.

 * http://android.git.kernel.org/

 *

 * Copyright (C) 2008 The Android Open Source Project

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * * Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 * * Redistributions in binary form must reproduce the above copyright

 *   notice, this list of conditions and the following disclaimer in

 *   the documentation and/or other materials provided with the

 *   distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

 * AS IS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS

 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT

 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

int git_path_basename_r(git_buf *buffer, const char *path)

{

	const char *endp, *startp;

	int len, result;

	/* Empty or NULL string gets treated as "." */

	if (path == NULL || *path == '\0') {

		startp = ".";

		len		= 1;

		goto Exit;

	}

	/* Strip trailing slashes */

	endp = path + strlen(path) - 1;

	while (endp > path && *endp == '/')

		endp--;

	/* All slashes becomes "/" */

	if (endp == path && *endp == '/') {

		startp = "/";

		len	= 1;

		goto Exit;

	}

	/* Find the start of the base */

	startp = endp;

	while (startp > path && *(startp - 1) != '/')

		startp--;

	/* Cast is safe because max path < max int */

	len = (int)(endp - startp + 1);

Exit:

	result = len;

	if (buffer != NULL && git_buf_set(buffer, startp, len) < 0)

		return -1;

	return result;

}

/*

 * Determine if the path is a Windows prefix and, if so, returns

 * its actual lentgh. If it is not a prefix, returns -1.

 */

static int win32_prefix_length(const char *path, int len)

{

#ifndef GIT_WIN32

	GIT_UNUSED(path);

	GIT_UNUSED(len);

#else

	/*

	 * Mimic unix behavior where '/.git' returns '/': 'C:/.git' will return

	 * 'C:/' here

	 */

	if (len == 2 && LOOKS_LIKE_DRIVE_PREFIX(path))

		return 2;

	/*

	 * Similarly checks if we're dealing with a network computer name

	 * '//computername/.git' will return '//computername/'

	 */

	if (looks_like_network_computer_name(path, len))

		return len;

#endif

	return -1;

}

/*

 * Based on the Android implementation, BSD licensed.

 * Check http://android.git.kernel.org/

 */

int git_path_dirname_r(git_buf *buffer, const char *path)

{

	const char *endp;

	int is_prefix = 0, len;

	/* Empty or NULL string gets treated as "." */

	if (path == NULL || *path == '\0') {

		path = ".";

		len = 1;

		goto Exit;

	}

	/* Strip trailing slashes */

	endp = path + strlen(path) - 1;

	while (endp > path && *endp == '/')

		endp--;

	if ((len = win32_prefix_length(path, endp - path + 1)) > 0) {

		is_prefix = 1;

		goto Exit;

	}

	/* Find the start of the dir */

	while (endp > path && *endp != '/')

		endp--;

	/* Either the dir is "/" or there are no slashes */

	if (endp == path) {

		path = (*endp == '/') ? "/" : ".";

		len = 1;

		goto Exit;

	}

	do {

		endp--;

	} while (endp > path && *endp == '/');

	if ((len = win32_prefix_length(path, endp - path + 1)) > 0) {

		is_prefix = 1;

		goto Exit;

	}

	/* Cast is safe because max path < max int */

	len = (int)(endp - path + 1);

Exit:

	if (buffer) {

		if (git_buf_set(buffer, path, len) < 0)

			return -1;

		if (is_prefix && git_buf_putc(buffer, '/') < 0)

			return -1;

	}

	return len;

}

char *git_path_dirname(const char *path)

{

	git_buf buf = GIT_BUF_INIT;

	char *dirname;

	git_path_dirname_r(&buf, path);

	dirname = git_buf_detach(&buf;;

	git_buf_free(&buf;; /* avoid memleak if error occurs */

	return dirname;

}

char *git_path_basename(const char *path)

{

	git_buf buf = GIT_BUF_INIT;

	char *basename;

	git_path_basename_r(&buf, path);

	basename = git_buf_detach(&buf;;

	git_buf_free(&buf;; /* avoid memleak if error occurs */

	return basename;

}

size_t git_path_basename_offset(git_buf *buffer)

{

	ssize_t slash;

	if (!buffer || buffer->size <= 0)

		return 0;

	slash = git_buf_rfind_next(buffer, '/');

	if (slash >= 0 && buffer->ptr[slash] == '/')

		return (size_t)(slash + 1);

	return 0;

}

const char *git_path_topdir(const char *path)

{

	size_t len;

	ssize_t i;

	assert(path);

	len = strlen(path);

	if (!len || path[len - 1] != '/')

		return NULL;

	for (i = (ssize_t)len - 2; i >= 0; --i)

		if (path[i] == '/')

			break;

	return &path[i + 1];

}

int git_path_root(const char *path)

{

	int offset = 0;

	/* Does the root of the path look like a windows drive ? */

	if (LOOKS_LIKE_DRIVE_PREFIX(path))

		offset += 2;

#ifdef GIT_WIN32

	/* Are we dealing with a windows network path? */

	else if ((path[0] == '/' && path[1] == '/' && path[2] != '/') ||

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

	{

		offset += 2;

		/* Skip the computer name segment */

		while (path[offset] && path[offset] != '/' && path[offset] != '\\')

			offset++;

	}

#endif

	if (path[offset] == '/' || path[offset] == '\\')

		return offset;

	return -1;	/* Not a real error - signals that path is not rooted */

}

void git_path_trim_slashes(git_buf *path)

{

	int ceiling = git_path_root(path->ptr) + 1;

	assert(ceiling >= 0);

	while (path->size > (size_t)ceiling) {

		if (path->ptr[path->size-1] != '/')

			break;

		path->ptr[path->size-1] = '\0';

		path->size--;

	}

}

int git_path_join_unrooted(

	git_buf *path_out, const char *path, const char *base, ssize_t *root_at)

{

	ssize_t root;

	assert(path && path_out);

	root = (ssize_t)git_path_root(path);

	if (base != NULL && root < 0) {

		if (git_buf_joinpath(path_out, base, path) < 0)

			return -1;

		root = (ssize_t)strlen(base);

	} else {

		if (git_buf_sets(path_out, path) < 0)

			return -1;

		if (root < 0)

			root = 0;

		else if (base)

			git_path_equal_or_prefixed(base, path, &root);

	}

	if (root_at)

		*root_at = root;

	return 0;

}

void git_path_squash_slashes(git_buf *path)

{

	char *p, *q;

	if (path->size == 0)

		return;

	for (p = path->ptr, q = path->ptr; *q; p++, q++) {

		*p = *q;

		while (*q == '/' && *(q+1) == '/') {

			path->size--;

			q++;

		}

	}

	*p = '\0';

}

int git_path_prettify(git_buf *path_out, const char *path, const char *base)

{

	char buf[GIT_PATH_MAX];

	assert(path && path_out);

	/* construct path if needed */

	if (base != NULL && git_path_root(path) < 0) {

		if (git_buf_joinpath(path_out, base, path) < 0)

			return -1;

		path = path_out->ptr;

	}

	if (p_realpath(path, buf) == NULL) {

		/* giterr_set resets the errno when dealing with a GITERR_OS kind of error */

		int error = (errno == ENOENT || errno == ENOTDIR) ? GIT_ENOTFOUND : -1;

		giterr_set(GITERR_OS, "failed to resolve path '%s'", path);

		git_buf_clear(path_out);

		return error;

	}

	return git_buf_sets(path_out, buf);

}

int git_path_prettify_dir(git_buf *path_out, const char *path, const char *base)

{

	int error = git_path_prettify(path_out, path, base);

	return (error < 0) ? error : git_path_to_dir(path_out);

}

int git_path_to_dir(git_buf *path)

{

	if (path->asize > 0 &&

		git_buf_len(path) > 0 &&

		path->ptr[git_buf_len(path) - 1] != '/')

		git_buf_putc(path, '/');

	return git_buf_oom(path) ? -1 : 0;

}

void git_path_string_to_dir(char* path, size_t size)

{

	size_t end = strlen(path);

	if (end && path[end - 1] != '/' && end < size) {

		path[end] = '/';

		path[end + 1] = '\0';

	}

}

int git__percent_decode(git_buf *decoded_out, const char *input)

{

	int len, hi, lo, i;

	assert(decoded_out && input);

	len = (int)strlen(input);

	git_buf_clear(decoded_out);

	for(i = 0; i < len; i++)

	{

		char c = input[i];

		if (c != '%')

			goto append;

		if (i >= len - 2)

			goto append;

		hi = git__fromhex(input[i + 1]);

		lo = git__fromhex(input[i + 2]);

		if (hi < 0 || lo < 0)

			goto append;

		c = (char)(hi << 4 | lo);

		i += 2;

append:

		if (git_buf_putc(decoded_out, c) < 0)

			return -1;

	}

	return 0;

}

static int error_invalid_local_file_uri(const char *uri)

{

	giterr_set(GITERR_CONFIG, "'%s' is not a valid local file URI", uri);

	return -1;

}

static int local_file_url_prefixlen(const char *file_url)

{

	int len = -1;

	if (git__prefixcmp(file_url, "file://") == 0) {

		if (file_url[7] == '/')

			len = 8;

		else if (git__prefixcmp(file_url + 7, "localhost/") == 0)

			len = 17;

	}

	return len;

}

bool git_path_is_local_file_url(const char *file_url)

{

	return (local_file_url_prefixlen(file_url) > 0);

}

int git_path_fromurl(git_buf *local_path_out, const char *file_url)

{

	int offset;

	assert(local_path_out && file_url);

	if ((offset = local_file_url_prefixlen(file_url)) < 0 ||

		file_url[offset] == '\0' || file_url[offset] == '/')

		return error_invalid_local_file_uri(file_url);

#ifndef GIT_WIN32

	offset--;	/* A *nix absolute path starts with a forward slash */

#endif

	git_buf_clear(local_path_out);

	return git__percent_decode(local_path_out, file_url + offset);

}

int git_path_walk_up(

	git_buf *path,

	const char *ceiling,

	int (*cb)(void *data, const char *),

	void *data)

{

	int error = 0;

	git_buf iter;

	ssize_t stop = 0, scan;

	char oldc = '\0';

	assert(path && cb);

	if (ceiling != NULL) {

		if (git__prefixcmp(path->ptr, ceiling) == 0)

			stop = (ssize_t)strlen(ceiling);

		else

			stop = git_buf_len(path);

	}

	scan = git_buf_len(path);

	/* empty path: yield only once */

	if (!scan) {

		error = cb(data, "");

		if (error)

			giterr_set_after_callback(error);

		return error;

	}

	iter.ptr = path->ptr;

	iter.size = git_buf_len(path);

	iter.asize = path->asize;

	while (scan >= stop) {

		error = cb(data, iter.ptr);

		iter.ptr[scan] = oldc;

		if (error) {

			giterr_set_after_callback(error);

			break;

		}

		scan = git_buf_rfind_next(&iter, '/');

		if (scan >= 0) {

			scan++;

			oldc = iter.ptr[scan];

			iter.size = scan;

			iter.ptr[scan] = '\0';

		}

	}

	if (scan >= 0)

		iter.ptr[scan] = oldc;

	/* relative path: yield for the last component */

	if (!error && stop == 0 && iter.ptr[0] != '/') {

		error = cb(data, "");

		if (error)

			giterr_set_after_callback(error);

	}

	return error;

}

bool git_path_exists(const char *path)

{

	assert(path);

	return p_access(path, F_OK) == 0;

}

bool git_path_isdir(const char *path)

{

	struct stat st;

	if (p_stat(path, &st) < 0)

		return false;

	return S_ISDIR(st.st_mode) != 0;

}

bool git_path_isfile(const char *path)

{

	struct stat st;

	assert(path);

	if (p_stat(path, &st) < 0)

		return false;

	return S_ISREG(st.st_mode) != 0;

}

bool git_path_islink(const char *path)

{

	struct stat st;

	assert(path);

	if (p_lstat(path, &st) < 0)

		return false;

	return S_ISLNK(st.st_mode) != 0;

}

#ifdef GIT_WIN32

bool git_path_is_empty_dir(const char *path)

{

	git_win32_path filter_w;

	bool empty = false;

	if (git_win32__findfirstfile_filter(filter_w, path)) {

		WIN32_FIND_DATAW findData;

		HANDLE hFind = FindFirstFileW(filter_w, &findData);

		/* FindFirstFile will fail if there are no children to the given

		 * path, which can happen if the given path is a file (and obviously

		 * has no children) or if the given path is an empty mount point.

		 * (Most directories have at least directory entries '.' and '..',

		 * but ridiculously another volume mounted in another drive letter's

		 * path space do not, and thus have nothing to enumerate.)  If

		 * FindFirstFile fails, check if this is a directory-like thing

		 * (a mount point).

		 */

		if (hFind == INVALID_HANDLE_VALUE)

			return git_path_isdir(path);

		/* If the find handle was created successfully, then it's a directory */

		empty = true;

		do {

			/* Allow the enumeration to return . and .. and still be considered

			 * empty. In the special case of drive roots (i.e. C:\) where . and

			 * .. do not occur, we can still consider the path to be an empty

			 * directory if there's nothing there. */

			if (!git_path_is_dot_or_dotdotW(findData.cFileName)) {

				empty = false;

				break;

			}

		} while (FindNextFileW(hFind, &findData));

		FindClose(hFind);

	}

	return empty;

}

#else

static int path_found_entry(void *payload, git_buf *path)

{

	GIT_UNUSED(payload);

	return !git_path_is_dot_or_dotdot(path->ptr);

}

bool git_path_is_empty_dir(const char *path)

{

	int error;

	git_buf dir = GIT_BUF_INIT;

	if (!git_path_isdir(path))

		return false;

	if ((error = git_buf_sets(&dir, path)) != 0)

		giterr_clear();

	else

		error = git_path_direach(&dir, 0, path_found_entry, NULL);

	git_buf_free(&dir;;

	return !error;

}

#endif

int git_path_set_error(int errno_value, const char *path, const char *action)

{

	switch (errno_value) {

	case ENOENT:

	case ENOTDIR:

		giterr_set(GITERR_OS, "could not find '%s' to %s", path, action);

		return GIT_ENOTFOUND;

	case EINVAL:

	case ENAMETOOLONG:

		giterr_set(GITERR_OS, "invalid path for filesystem '%s'", path);

		return GIT_EINVALIDSPEC;

	case EEXIST:

		giterr_set(GITERR_OS, "failed %s - '%s' already exists", action, path);

		return GIT_EEXISTS;

	case EACCES:

		giterr_set(GITERR_OS, "failed %s - '%s' is locked", action, path);

		return GIT_ELOCKED;

	default:

		giterr_set(GITERR_OS, "could not %s '%s'", action, path);

		return -1;

	}

}

int git_path_lstat(const char *path, struct stat *st)

{

	if (p_lstat(path, st) == 0)

		return 0;

	return git_path_set_error(errno, path, "stat");

}

static bool _check_dir_contents(

	git_buf *dir,

	const char *sub,

	bool (*predicate)(const char *))

{

	bool result;

	size_t dir_size = git_buf_len(dir);

	size_t sub_size = strlen(sub);

	size_t alloc_size;

	/* leave base valid even if we could not make space for subdir */

	if (GIT_ADD_SIZET_OVERFLOW(&alloc_size, dir_size, sub_size) ||

		GIT_ADD_SIZET_OVERFLOW(&alloc_size, alloc_size, 2) ||

		git_buf_try_grow(dir, alloc_size, false) < 0)

		return false;

	/* save excursion */

	if (git_buf_joinpath(dir, dir->ptr, sub) < 0)

		return false;

	result = predicate(dir->ptr);

	/* restore path */

	git_buf_truncate(dir, dir_size);

	return result;

}

bool git_path_contains(git_buf *dir, const char *item)

{

	return _check_dir_contents(dir, item, &git_path_exists);

}

bool git_path_contains_dir(git_buf *base, const char *subdir)

{

	return _check_dir_contents(base, subdir, &git_path_isdir);

}

bool git_path_contains_file(git_buf *base, const char *file)

{

	return _check_dir_contents(base, file, &git_path_isfile);

}

int git_path_find_dir(git_buf *dir, const char *path, const char *base)

{

	int error = git_path_join_unrooted(dir, path, base, NULL);

	if (!error) {

		char buf[GIT_PATH_MAX];

		if (p_realpath(dir->ptr, buf) != NULL)

			error = git_buf_sets(dir, buf);

	}

	/* call dirname if this is not a directory */

	if (!error) /* && git_path_isdir(dir->ptr) == false) */

		error = (git_path_dirname_r(dir, dir->ptr) < 0) ? -1 : 0;

	if (!error)

		error = git_path_to_dir(dir);

	return error;

}

int git_path_resolve_relative(git_buf *path, size_t ceiling)

{

	char *base, *to, *from, *next;

	size_t len;

	GITERR_CHECK_ALLOC_BUF(path);

	if (ceiling > path->size)

		ceiling = path->size;

	/* recognize drive prefixes, etc. that should not be backed over */

	if (ceiling == 0)

		ceiling = git_path_root(path->ptr) + 1;

	/* recognize URL prefixes that should not be backed over */

	if (ceiling == 0) {

		for (next = path->ptr; *next && git__isalpha(*next); ++next);

		if (next[0] == ':' && next[1] == '/' && next[2] == '/')

			ceiling = (next + 3) - path->ptr;

	}

	base = to = from = path->ptr + ceiling;

	while (*from) {

		for (next = from; *next && *next != '/'; ++next);

		len = next - from;

		if (len == 1 && from[0] == '.')

			/* do nothing with singleton dot */;

		else if (len == 2 && from[0] == '.' && from[1] == '.') {

			/* error out if trying to up one from a hard base */

			if (to == base && ceiling != 0) {

				giterr_set(GITERR_INVALID,

					"cannot strip root component off url");

				return -1;

			}

			/* no more path segments to strip,

			 * use '../' as a new base path */

			if (to == base) {

				if (*next == '/')

					len++;

				if (to != from)

					memmove(to, from, len);

				to += len;

				/* this is now the base, can't back up from a

				 * relative prefix */

				base = to;

			} else {

				/* back up a path segment */

				while (to > base && to[-1] == '/') to--;

				while (to > base && to[-1] != '/') to--;

			}

		} else {

			if (*next == '/' && *from != '/')

				len++;

			if (to != from)

				memmove(to, from, len);

			to += len;

		}

		from += len;

		while (*from == '/') from++;

	}

	*to = '\0';

	path->size = to - path->ptr;

	return 0;

}

int git_path_apply_relative(git_buf *target, const char *relpath)

{

	return git_buf_joinpath(target, git_buf_cstr(target), relpath) ||

	    git_path_resolve_relative(target, 0);

}

int git_path_cmp(

	const char *name1, size_t len1, int isdir1,

	const char *name2, size_t len2, int isdir2,

	int (*compare)(const char *, const char *, size_t))

{

	unsigned char c1, c2;

	size_t len = len1 < len2 ? len1 : len2;

	int cmp;

	cmp = compare(name1, name2, len);

	if (cmp)

		return cmp;

	c1 = name1[len];

	c2 = name2[len];

	if (c1 == '\0' && isdir1)

		c1 = '/';

	if (c2 == '\0' && isdir2)

		c2 = '/';

	return (c1 < c2) ? -1 : (c1 > c2) ? 1 : 0;

}

size_t git_path_common_dirlen(const char *one, const char *two)

{

	const char *p, *q, *dirsep = NULL;

	for (p = one, q = two; *p && *q; p++, q++) {

		if (*p == '/' && *q == '/')

			dirsep = p;

		else if (*p != *q)

			break;

	}

	return dirsep ? (dirsep - one) + 1 : 0;

}

int git_path_make_relative(git_buf *path, const char *parent)

{

	const char *p, *q, *p_dirsep, *q_dirsep;

	size_t plen = path->size, newlen, alloclen, depth = 1, i, offset;

	for (p_dirsep = p = path->ptr, q_dirsep = q = parent; *p && *q; p++, q++) {

		if (*p == '/' && *q == '/') {

			p_dirsep = p;

			q_dirsep = q;