/*

 * 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 <stddef.h>

#include "common.h"

#include "repository.h"

#include "index.h"

#include "tree.h"

#include "tree-cache.h"

#include "hash.h"

#include "iterator.h"

#include "pathspec.h"

#include "ignore.h"

#include "blob.h"

#include "idxmap.h"

#include "diff.h"

#include "varint.h"

#include "git2/odb.h"

#include "git2/oid.h"

#include "git2/blob.h"

#include "git2/config.h"

#include "git2/sys/index.h"

#define INSERT_IN_MAP_EX(idx, map, e, err) do {				\

		if ((idx)->ignore_case)					\

			git_idxmap_icase_insert((khash_t(idxicase) *) (map), (e), (e), (err)); \

		else							\

			git_idxmap_insert((map), (e), (e), (err));	\

	} while (0)

#define INSERT_IN_MAP(idx, e, err) INSERT_IN_MAP_EX(idx, (idx)->entries_map, e, err)

#define LOOKUP_IN_MAP(p, idx, k) do {					\

		if ((idx)->ignore_case)					\

			(p) = git_idxmap_icase_lookup_index((khash_t(idxicase) *) index->entries_map, (k)); \

		else							\

			(p) = git_idxmap_lookup_index(index->entries_map, (k)); \

	} while (0)

#define DELETE_IN_MAP(idx, e) do {					\

		if ((idx)->ignore_case)					\

			git_idxmap_icase_delete((khash_t(idxicase) *) (idx)->entries_map, (e)); \

		else							\

			git_idxmap_delete((idx)->entries_map, (e));	\

	} while (0)

static int index_apply_to_wd_diff(git_index *index, int action, const git_strarray *paths,

				  unsigned int flags,

				  git_index_matched_path_cb cb, void *payload);

#define minimal_entry_size (offsetof(struct entry_short, path))

static const size_t INDEX_FOOTER_SIZE = GIT_OID_RAWSZ;

static const size_t INDEX_HEADER_SIZE = 12;

static const unsigned int INDEX_VERSION_NUMBER_DEFAULT = 2;

static const unsigned int INDEX_VERSION_NUMBER_LB = 2;

static const unsigned int INDEX_VERSION_NUMBER_EXT = 3;

static const unsigned int INDEX_VERSION_NUMBER_COMP = 4;

static const unsigned int INDEX_VERSION_NUMBER_UB = 4;

static const unsigned int INDEX_HEADER_SIG = 0x44495243;

static const char INDEX_EXT_TREECACHE_SIG[] = {'T', 'R', 'E', 'E'};

static const char INDEX_EXT_UNMERGED_SIG[] = {'R', 'E', 'U', 'C'};

static const char INDEX_EXT_CONFLICT_NAME_SIG[] = {'N', 'A', 'M', 'E'};

#define INDEX_OWNER(idx) ((git_repository *)(GIT_REFCOUNT_OWNER(idx)))

struct index_header {

	uint32_t signature;

	uint32_t version;

	uint32_t entry_count;

};

struct index_extension {

	char signature[4];

	uint32_t extension_size;

};

struct entry_time {

	uint32_t seconds;

	uint32_t nanoseconds;

};

struct entry_short {

	struct entry_time ctime;

	struct entry_time mtime;

	uint32_t dev;

	uint32_t ino;

	uint32_t mode;

	uint32_t uid;

	uint32_t gid;

	uint32_t file_size;

	git_oid oid;

	uint16_t flags;

	char path[1]; /* arbitrary length */

};

struct entry_long {

	struct entry_time ctime;

	struct entry_time mtime;

	uint32_t dev;

	uint32_t ino;

	uint32_t mode;

	uint32_t uid;

	uint32_t gid;

	uint32_t file_size;

	git_oid oid;

	uint16_t flags;

	uint16_t flags_extended;

	char path[1]; /* arbitrary length */

};

struct entry_srch_key {

	const char *path;

	size_t pathlen;

	int stage;

};

struct entry_internal {

	git_index_entry entry;

	size_t pathlen;

	char path[GIT_FLEX_ARRAY];

};

struct reuc_entry_internal {

	git_index_reuc_entry entry;

	size_t pathlen;

	char path[GIT_FLEX_ARRAY];

};

/* local declarations */

static size_t read_extension(git_index *index, const char *buffer, size_t buffer_size);

static int read_header(struct index_header *dest, const void *buffer);

static int parse_index(git_index *index, const char *buffer, size_t buffer_size);

static bool is_index_extended(git_index *index);

static int write_index(git_oid *checksum, git_index *index, git_filebuf *file);

static void index_entry_free(git_index_entry *entry);

static void index_entry_reuc_free(git_index_reuc_entry *reuc);

int git_index_entry_srch(const void *key, const void *array_member)

{

	const struct entry_srch_key *srch_key = key;

	const struct entry_internal *entry = array_member;

	int cmp;

	size_t len1, len2, len;

	len1 = srch_key->pathlen;

	len2 = entry->pathlen;

	len = len1 < len2 ? len1 : len2;

	cmp = memcmp(srch_key->path, entry->path, len);

	if (cmp)

		return cmp;

	if (len1 < len2)

		return -1;

	if (len1 > len2)

		return 1;

	if (srch_key->stage != GIT_INDEX_STAGE_ANY)

		return srch_key->stage - GIT_IDXENTRY_STAGE(&entry->entry);

	return 0;

}

int git_index_entry_isrch(const void *key, const void *array_member)

{

	const struct entry_srch_key *srch_key = key;

	const struct entry_internal *entry = array_member;

	int cmp;

	size_t len1, len2, len;

	len1 = srch_key->pathlen;

	len2 = entry->pathlen;

	len = len1 < len2 ? len1 : len2;

	cmp = strncasecmp(srch_key->path, entry->path, len);

	if (cmp)

		return cmp;

	if (len1 < len2)

		return -1;

	if (len1 > len2)

		return 1;

	if (srch_key->stage != GIT_INDEX_STAGE_ANY)

		return srch_key->stage - GIT_IDXENTRY_STAGE(&entry->entry);

	return 0;

}

static int index_entry_srch_path(const void *path, const void *array_member)

{

	const git_index_entry *entry = array_member;

	return strcmp((const char *)path, entry->path);

}

static int index_entry_isrch_path(const void *path, const void *array_member)

{

	const git_index_entry *entry = array_member;

	return strcasecmp((const char *)path, entry->path);

}

int git_index_entry_cmp(const void *a, const void *b)

{

	int diff;

	const git_index_entry *entry_a = a;

	const git_index_entry *entry_b = b;

	diff = strcmp(entry_a->path, entry_b->path);

	if (diff == 0)

		diff = (GIT_IDXENTRY_STAGE(entry_a) - GIT_IDXENTRY_STAGE(entry_b));

	return diff;

}

int git_index_entry_icmp(const void *a, const void *b)

{

	int diff;

	const git_index_entry *entry_a = a;

	const git_index_entry *entry_b = b;

	diff = strcasecmp(entry_a->path, entry_b->path);

	if (diff == 0)

		diff = (GIT_IDXENTRY_STAGE(entry_a) - GIT_IDXENTRY_STAGE(entry_b));

	return diff;

}

static int conflict_name_cmp(const void *a, const void *b)

{

	const git_index_name_entry *name_a = a;

	const git_index_name_entry *name_b = b;

	if (name_a->ancestor && !name_b->ancestor)

		return 1;

	if (!name_a->ancestor && name_b->ancestor)

		return -1;

	if (name_a->ancestor)

		return strcmp(name_a->ancestor, name_b->ancestor);

	if (!name_a->ours || !name_b->ours)

		return 0;

	return strcmp(name_a->ours, name_b->ours);

}

/**

 * TODO: enable this when resolving case insensitive conflicts

 */

#if 0

static int conflict_name_icmp(const void *a, const void *b)

{

	const git_index_name_entry *name_a = a;

	const git_index_name_entry *name_b = b;

	if (name_a->ancestor && !name_b->ancestor)

		return 1;

	if (!name_a->ancestor && name_b->ancestor)

		return -1;

	if (name_a->ancestor)

		return strcasecmp(name_a->ancestor, name_b->ancestor);

	if (!name_a->ours || !name_b->ours)

		return 0;

	return strcasecmp(name_a->ours, name_b->ours);

}

#endif

static int reuc_srch(const void *key, const void *array_member)

{

	const git_index_reuc_entry *reuc = array_member;

	return strcmp(key, reuc->path);

}

static int reuc_isrch(const void *key, const void *array_member)

{

	const git_index_reuc_entry *reuc = array_member;

	return strcasecmp(key, reuc->path);

}

static int reuc_cmp(const void *a, const void *b)

{

	const git_index_reuc_entry *info_a = a;

	const git_index_reuc_entry *info_b = b;

	return strcmp(info_a->path, info_b->path);

}

static int reuc_icmp(const void *a, const void *b)

{

	const git_index_reuc_entry *info_a = a;

	const git_index_reuc_entry *info_b = b;

	return strcasecmp(info_a->path, info_b->path);

}

static void index_entry_reuc_free(git_index_reuc_entry *reuc)

{

	git__free(reuc);

}

static void index_entry_free(git_index_entry *entry)

{

	if (!entry)

		return;

	memset(&entry->id, 0, sizeof(entry->id));

	git__free(entry);

}

unsigned int git_index__create_mode(unsigned int mode)

{

	if (S_ISLNK(mode))

		return S_IFLNK;

	if (S_ISDIR(mode) || (mode & S_IFMT) == (S_IFLNK | S_IFDIR))

		return (S_IFLNK | S_IFDIR);

	return S_IFREG | GIT_PERMS_CANONICAL(mode);

}

static unsigned int index_merge_mode(

	git_index *index, git_index_entry *existing, unsigned int mode)

{

	if (index->no_symlinks && S_ISREG(mode) &&

		existing && S_ISLNK(existing->mode))

		return existing->mode;

	if (index->distrust_filemode && S_ISREG(mode))

		return (existing && S_ISREG(existing->mode)) ?

			existing->mode : git_index__create_mode(0666);

	return git_index__create_mode(mode);

}

GIT_INLINE(int) index_find_in_entries(

	size_t *out, git_vector *entries, git_vector_cmp entry_srch,

	const char *path, size_t path_len, int stage)

{

	struct entry_srch_key srch_key;

	srch_key.path = path;

	srch_key.pathlen = !path_len ? strlen(path) : path_len;

	srch_key.stage = stage;

	return git_vector_bsearch2(out, entries, entry_srch, &srch_key);

}

GIT_INLINE(int) index_find(

	size_t *out, git_index *index,

	const char *path, size_t path_len, int stage)

{

	git_vector_sort(&index->entries);

	return index_find_in_entries(

		out, &index->entries, index->entries_search, path, path_len, stage);

}

void git_index__set_ignore_case(git_index *index, bool ignore_case)

{

	index->ignore_case = ignore_case;

	if (ignore_case) {

		index->entries_cmp_path    = git__strcasecmp_cb;

		index->entries_search      = git_index_entry_isrch;

		index->entries_search_path = index_entry_isrch_path;

		index->reuc_search         = reuc_isrch;

	} else {

		index->entries_cmp_path    = git__strcmp_cb;

		index->entries_search      = git_index_entry_srch;

		index->entries_search_path = index_entry_srch_path;

		index->reuc_search         = reuc_srch;

	}

	git_vector_set_cmp(&index->entries,

		ignore_case ? git_index_entry_icmp : git_index_entry_cmp);

	git_vector_sort(&index->entries);

	git_vector_set_cmp(&index->reuc, ignore_case ? reuc_icmp : reuc_cmp);

	git_vector_sort(&index->reuc);

}

int git_index_open(git_index **index_out, const char *index_path)

{

	git_index *index;

	int error = -1;

	assert(index_out);

	index = git__calloc(1, sizeof(git_index));

	GITERR_CHECK_ALLOC(index);

	git_pool_init(&index->tree_pool, 1);

	if (index_path != NULL) {

		index->index_file_path = git__strdup(index_path);

		if (!index->index_file_path)

			goto fail;

		/* Check if index file is stored on disk already */

		if (git_path_exists(index->index_file_path) == true)

			index->on_disk = 1;

	}

	if (git_vector_init(&index->entries, 32, git_index_entry_cmp) < 0 ||

		git_idxmap_alloc(&index->entries_map) < 0 ||

		git_vector_init(&index->names, 8, conflict_name_cmp) < 0 ||

		git_vector_init(&index->reuc, 8, reuc_cmp) < 0 ||

		git_vector_init(&index->deleted, 8, git_index_entry_cmp) < 0)

		goto fail;

	index->entries_cmp_path = git__strcmp_cb;

	index->entries_search = git_index_entry_srch;

	index->entries_search_path = index_entry_srch_path;

	index->reuc_search = reuc_srch;

	index->version = INDEX_VERSION_NUMBER_DEFAULT;

	if (index_path != NULL && (error = git_index_read(index, true)) < 0)

		goto fail;

	*index_out = index;

	GIT_REFCOUNT_INC(index);

	return 0;

fail:

	git_pool_clear(&index->tree_pool);

	git_index_free(index);

	return error;

}

int git_index_new(git_index **out)

{

	return git_index_open(out, NULL);

}

static void index_free(git_index *index)

{

	/* index iterators increment the refcount of the index, so if we

	 * get here then there should be no outstanding iterators.

	 */

	assert(!git_atomic_get(&index->readers));

	git_index_clear(index);

	git_idxmap_free(index->entries_map);

	git_vector_free(&index->entries);

	git_vector_free(&index->names);

	git_vector_free(&index->reuc);

	git_vector_free(&index->deleted);

	git__free(index->index_file_path);

	git__memzero(index, sizeof(*index));

	git__free(index);

}

void git_index_free(git_index *index)

{

	if (index == NULL)

		return;

	GIT_REFCOUNT_DEC(index, index_free);

}

/* call with locked index */

static void index_free_deleted(git_index *index)

{

	int readers = (int)git_atomic_get(&index->readers);

	size_t i;

	if (readers > 0 || !index->deleted.length)

		return;

	for (i = 0; i < index->deleted.length; ++i) {

		git_index_entry *ie = git__swap(index->deleted.contents[i], NULL);

		index_entry_free(ie);

	}

	git_vector_clear(&index->deleted);

}

/* call with locked index */

static int index_remove_entry(git_index *index, size_t pos)

{

	int error = 0;

	git_index_entry *entry = git_vector_get(&index->entries, pos);

	if (entry != NULL) {

		git_tree_cache_invalidate_path(index->tree, entry->path);

		DELETE_IN_MAP(index, entry);

	}

	error = git_vector_remove(&index->entries, pos);

	if (!error) {

		if (git_atomic_get(&index->readers) > 0) {

			error = git_vector_insert(&index->deleted, entry);

		} else {

			index_entry_free(entry);

		}

	}

	return error;

}

int git_index_clear(git_index *index)

{

	int error = 0;

	assert(index);

	index->tree = NULL;

	git_pool_clear(&index->tree_pool);

	git_idxmap_clear(index->entries_map);

	while (!error && index->entries.length > 0)

		error = index_remove_entry(index, index->entries.length - 1);

	index_free_deleted(index);

	git_index_reuc_clear(index);

	git_index_name_clear(index);

	git_futils_filestamp_set(&index->stamp, NULL);

	return error;

}

static int create_index_error(int error, const char *msg)

{

	giterr_set_str(GITERR_INDEX, msg);

	return error;

}

int git_index_set_caps(git_index *index, int caps)

{

	unsigned int old_ignore_case;

	assert(index);

	old_ignore_case = index->ignore_case;

	if (caps == GIT_INDEXCAP_FROM_OWNER) {

		git_repository *repo = INDEX_OWNER(index);

		int val;

		if (!repo)

			return create_index_error(

				-1, "cannot access repository to set index caps");

		if (!git_repository__cvar(&val, repo, GIT_CVAR_IGNORECASE))

			index->ignore_case = (val != 0);

		if (!git_repository__cvar(&val, repo, GIT_CVAR_FILEMODE))

			index->distrust_filemode = (val == 0);

		if (!git_repository__cvar(&val, repo, GIT_CVAR_SYMLINKS))

			index->no_symlinks = (val == 0);

	}

	else {

		index->ignore_case = ((caps & GIT_INDEXCAP_IGNORE_CASE) != 0);

		index->distrust_filemode = ((caps & GIT_INDEXCAP_NO_FILEMODE) != 0);

		index->no_symlinks = ((caps & GIT_INDEXCAP_NO_SYMLINKS) != 0);

	}

	if (old_ignore_case != index->ignore_case) {

		git_index__set_ignore_case(index, (bool)index->ignore_case);

	}

	return 0;

}

int git_index_caps(const git_index *index)

{

	return ((index->ignore_case ? GIT_INDEXCAP_IGNORE_CASE : 0) |

			(index->distrust_filemode ? GIT_INDEXCAP_NO_FILEMODE : 0) |

			(index->no_symlinks ? GIT_INDEXCAP_NO_SYMLINKS : 0));

}

const git_oid *git_index_checksum(git_index *index)

{

	return &index->checksum;

}

/**

 * Returns 1 for changed, 0 for not changed and <0 for errors

 */

static int compare_checksum(git_index *index)

{

	int fd;

	ssize_t bytes_read;

	git_oid checksum = {{ 0 }};

	if ((fd = p_open(index->index_file_path, O_RDONLY)) < 0)

		return fd;

	if (p_lseek(fd, -20, SEEK_END) < 0) {

		p_close(fd);

		giterr_set(GITERR_OS, "failed to seek to end of file");

		return -1;

	}

	bytes_read = p_read(fd, &checksum, GIT_OID_RAWSZ);

	p_close(fd);

	if (bytes_read < 0)

		return -1;

	return !!git_oid_cmp(&checksum, &index->checksum);

}

int git_index_read(git_index *index, int force)

{

	int error = 0, updated;

	git_buf buffer = GIT_BUF_INIT;

	git_futils_filestamp stamp = index->stamp;

	if (!index->index_file_path)

		return create_index_error(-1,

			"failed to read index: The index is in-memory only");

	index->on_disk = git_path_exists(index->index_file_path);

	if (!index->on_disk) {

		if (force)

			return git_index_clear(index);

		return 0;

	}

	if ((updated = git_futils_filestamp_check(&stamp, index->index_file_path) < 0) ||

	    ((updated = compare_checksum(index)) < 0)) {

		giterr_set(

			GITERR_INDEX,

			"failed to read index: '%s' no longer exists",

			index->index_file_path);

		return updated;

	}

	if (!updated && !force)

		return 0;

	error = git_futils_readbuffer(&buffer, index->index_file_path);

	if (error < 0)

		return error;

	index->tree = NULL;

	git_pool_clear(&index->tree_pool);

	error = git_index_clear(index);

	if (!error)

		error = parse_index(index, buffer.ptr, buffer.size);

	if (!error)

		git_futils_filestamp_set(&index->stamp, &stamp);

	git_buf_free(&buffer);

	return error;

}

int git_index__changed_relative_to(

	git_index *index, const git_oid *checksum)

{

	/* attempt to update index (ignoring errors) */

	if (git_index_read(index, false) < 0)

		giterr_clear();

	return !!git_oid_cmp(&index->checksum, checksum);

}

static bool is_racy_entry(git_index *index, const git_index_entry *entry)

{

	/* Git special-cases submodules in the check */

	if (S_ISGITLINK(entry->mode))

		return false;

	return git_index_entry_newer_than_index(entry, index);

}

/*

 * Force the next diff to take a look at those entries which have the

 * same timestamp as the current index.

 */

static int truncate_racily_clean(git_index *index)

{

	size_t i;

	int error;

	git_index_entry *entry;

	git_diff_options diff_opts = GIT_DIFF_OPTIONS_INIT;

	git_diff *diff = NULL;

	git_vector paths = GIT_VECTOR_INIT;

	git_diff_delta *delta;

	/* Nothing to do if there's no repo to talk about */

	if (!INDEX_OWNER(index))

		return 0;

	/* If there's no workdir, we can't know where to even check */

	if (!git_repository_workdir(INDEX_OWNER(index)))

		return 0;

	diff_opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE | GIT_DIFF_IGNORE_SUBMODULES | GIT_DIFF_DISABLE_PATHSPEC_MATCH;

	git_vector_foreach(&index->entries, i, entry) {

		if ((entry->flags_extended & GIT_IDXENTRY_UPTODATE) == 0 &&

			is_racy_entry(index, entry))

			git_vector_insert(&paths, (char *)entry->path);

	}

	if (paths.length == 0)

		goto done;

	diff_opts.pathspec.count = paths.length;

	diff_opts.pathspec.strings = (char **)paths.contents;

	if ((error = git_diff_index_to_workdir(&diff, INDEX_OWNER(index), index, &diff_opts)) < 0)

		return error;

	git_vector_foreach(&diff->deltas, i, delta) {

		entry = (git_index_entry *)git_index_get_bypath(index, delta->old_file.path, 0);

		/* Ensure that we have a stage 0 for this file (ie, it's not a

		 * conflict), otherwise smudging it is quite pointless.

		 */

		if (entry)

			entry->file_size = 0;

	}

done:

	git_diff_free(diff);

	git_vector_free(&paths);

	return 0;

}

unsigned git_index_version(git_index *index)

{

	assert(index);

	return index->version;

}

int git_index_set_version(git_index *index, unsigned int version)

{

	assert(index);

	if (version < INDEX_VERSION_NUMBER_LB ||

	    version > INDEX_VERSION_NUMBER_UB) {

		giterr_set(GITERR_INDEX, "invalid version number");

		return -1;

	}

	index->version = version;

	return 0;

}

int git_index_write(git_index *index)

{

	git_indexwriter writer = GIT_INDEXWRITER_INIT;

	int error;

	truncate_racily_clean(index);

	if ((error = git_indexwriter_init(&writer, index)) == 0)

		error = git_indexwriter_commit(&writer);

	git_indexwriter_cleanup(&writer);

	return error;

}

const char * git_index_path(const git_index *index)

{

	assert(index);

	return index->index_file_path;

}

int git_index_write_tree(git_oid *oid, git_index *index)

{

	git_repository *repo;

	assert(oid && index);

	repo = INDEX_OWNER(index);

	if (repo == NULL)

		return create_index_error(-1, "Failed to write tree. "

		  "the index file is not backed up by an existing repository");

	return git_tree__write_index(oid, index, repo);

}

int git_index_write_tree_to(

	git_oid *oid, git_index *index, git_repository *repo)

{

	assert(oid && index && repo);

	return git_tree__write_index(oid, index, repo);

}

size_t git_index_entrycount(const git_index *index)

{

	assert(index);

	return index->entries.length;

}

const git_index_entry *git_index_get_byindex(

	git_index *index, size_t n)

{

	assert(index);

	git_vector_sort(&index->entries);

	return git_vector_get(&index->entries, n);

}

const git_index_entry *git_index_get_bypath(

	git_index *index, const char *path, int stage)

{

	khiter_t pos;

	git_index_entry key = {{ 0 }};

	assert(index);

	key.path = path;

	GIT_IDXENTRY_STAGE_SET(&key, stage);

	LOOKUP_IN_MAP(pos, index, &key);

	if (git_idxmap_valid_index(index->entries_map, pos))

		return git_idxmap_value_at(index->entries_map, pos);

	giterr_set(GITERR_INDEX, "index does not contain '%s'", path);

	return NULL;

}

void git_index_entry__init_from_stat(

	git_index_entry *entry, struct stat *st, bool trust_mode)

{

	entry->ctime.seconds = (int32_t)st->st_ctime;

	entry->mtime.seconds = (int32_t)st->st_mtime;

#if defined(GIT_USE_NSEC)

	entry->mtime.nanoseconds = st->st_mtime_nsec;

	entry->ctime.nanoseconds = st->st_ctime_nsec;

#endif

	entry->dev  = st->st_rdev;

	entry->ino  = st->st_ino;

	entry->mode = (!trust_mode && S_ISREG(st->st_mode)) ?

		git_index__create_mode(0666) : git_index__create_mode(st->st_mode);

	entry->uid  = st->st_uid;

	entry->gid  = st->st_gid;

	entry->file_size = (uint32_t)st->st_size;

}

static void index_entry_adjust_namemask(

		git_index_entry *entry,

		size_t path_length)

{

	entry->flags &= ~GIT_IDXENTRY_NAMEMASK;

	if (path_length < GIT_IDXENTRY_NAMEMASK)

		entry->flags |= path_length & GIT_IDXENTRY_NAMEMASK;

	else

		entry->flags |= GIT_IDXENTRY_NAMEMASK;

}

/* When `from_workdir` is true, we will validate the paths to avoid placing

 * paths that are invalid for the working directory on the current filesystem

 * (eg, on Windows, we will disallow `GIT~1`, `AUX`, `COM1`, etc).  This

 * function will *always* prevent `.git` and directory traversal `../` from