rugged 0.28.4 → 0.28.4.1

data/vendor/libgit2/src/diff_stats.c

@@ -55,7 +55,7 @@ int git_diff_file_stats__full_to_buf(
 {
 	const char *old_path = NULL, *new_path = NULL;
 	size_t padding;
-	git_object_size_t old_size, new_size;
+	git_off_t old_size, new_size;
 
 	old_path = delta->old_file.path;
 	new_path = delta->new_file.path;

data/vendor/libgit2/src/diff_tform.c

@@ -14,7 +14,7 @@
 #include "diff.h"
 #include "diff_generate.h"
 #include "path.h"
-#include "futils.h"
+#include "fileops.h"
 #include "config.h"
 
 git_diff_delta *git_diff__delta_dup(
@@ -510,7 +510,7 @@ static int similarity_sig(
 			if (file->size != git_blob_rawsize(info->blob))
 				file->size = git_blob_rawsize(info->blob);
 
-			sz = git__is_sizet(file->size) ? (size_t)file->size : (size_t)-1;
+			sz = (size_t)(git__is_sizet(file->size) ? file->size : -1);
 
 			error = opts->metric->buffer_signature(
 				&cache[info->idx], info->file,
@@ -560,13 +560,13 @@ static int similarity_measure(
 
 	/* if exact match is requested, force calculation of missing OIDs now */
 	if (exact_match) {
-		if (git_oid_is_zero(&a_file->id) &&
+		if (git_oid_iszero(&a_file->id) &&
 			diff->old_src == GIT_ITERATOR_TYPE_WORKDIR &&
 			!git_diff__oid_for_file(&a_file->id,
 				diff, a_file->path, a_file->mode, a_file->size))
 			a_file->flags |= GIT_DIFF_FLAG_VALID_ID;
 
-		if (git_oid_is_zero(&b_file->id) &&
+		if (git_oid_iszero(&b_file->id) &&
 			diff->new_src == GIT_ITERATOR_TYPE_WORKDIR &&
 			!git_diff__oid_for_file(&b_file->id,
 				diff, b_file->path, b_file->mode, b_file->size))

data/vendor/libgit2/src/errors.c

@@ -49,17 +49,9 @@ void git_error_set_oom(void)
 	GIT_GLOBAL->last_error = &g_git_oom_error;
 }
 
-void git_error_set(int error_class, const char *fmt, ...)
-{
-	va_list ap;
-
-	va_start(ap, fmt);
-	git_error_vset(error_class, fmt, ap);
-	va_end(ap);
-}
-
-void git_error_vset(int error_class, const char *fmt, va_list ap)
+void git_error_set(int error_class, const char *string, ...)
 {
+	va_list arglist;
 #ifdef GIT_WIN32
 	DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0;
 #endif
@@ -67,8 +59,11 @@ void git_error_vset(int error_class, const char *fmt, va_list ap)
 	git_buf *buf = &GIT_GLOBAL->error_buf;
 
 	git_buf_clear(buf);
-	if (fmt) {
-		git_buf_vprintf(buf, fmt, ap);
+	if (string) {
+		va_start(arglist, string);
+		git_buf_vprintf(buf, string, arglist);
+		va_end(arglist);
+
 		if (error_class == GIT_ERROR_OS)
 			git_buf_PUTS(buf, ": ");
 	}
@@ -110,6 +105,21 @@ void git_error_set_str(int error_class, const char *string)
 		set_error_from_buffer(error_class);
 }
 
+int git_error_set_regex(const regex_t *regex, int error_code)
+{
+	char error_buf[1024];
+
+	assert(error_code);
+
+	regerror(error_code, regex, error_buf, sizeof(error_buf));
+	git_error_set_str(GIT_ERROR_REGEX, error_buf);
+
+	if (error_code == REG_NOMATCH)
+		return GIT_ENOTFOUND;
+
+	return GIT_EINVALIDSPEC;
+}
+
 void git_error_clear(void)
 {
 	if (GIT_GLOBAL->last_error != NULL) {

data/vendor/libgit2/src/features.h.in

@@ -15,21 +15,14 @@
 #cmakedefine GIT_USE_STAT_MTIMESPEC 1
 #cmakedefine GIT_USE_STAT_MTIME_NSEC 1
 #cmakedefine GIT_USE_FUTIMENS 1
-
-#cmakedefine GIT_REGEX_REGCOMP_L
-#cmakedefine GIT_REGEX_REGCOMP
-#cmakedefine GIT_REGEX_PCRE
-#cmakedefine GIT_REGEX_PCRE2
-#cmakedefine GIT_REGEX_BUILTIN 1
+#cmakedefine GIT_USE_REGCOMP_L 1
 
 #cmakedefine GIT_SSH 1
 #cmakedefine GIT_SSH_MEMORY_CREDENTIALS 1
 
-#cmakedefine GIT_NTLM 1
 #cmakedefine GIT_GSSAPI 1
-#cmakedefine GIT_GSSFRAMEWORK 1
-
 #cmakedefine GIT_WINHTTP 1
+
 #cmakedefine GIT_HTTPS 1
 #cmakedefine GIT_OPENSSL 1
 #cmakedefine GIT_SECURE_TRANSPORT 1

data/vendor/libgit2/src/fetch.c

@@ -134,7 +134,7 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts)
 int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *callbacks)
 {
 	git_transport *t = remote->transport;
-	git_indexer_progress_cb progress = NULL;
+	git_transfer_progress_cb progress = NULL;
 	void *payload = NULL;
 
 	if (!remote->need_pack)
@@ -148,14 +148,9 @@ int git_fetch_download_pack(git_remote *remote, const git_remote_callbacks *call
 	return t->download_pack(t, remote->repo, &remote->stats, progress, payload);
 }
 
-int git_fetch_options_init(git_fetch_options *opts, unsigned int version)
+int git_fetch_init_options(git_fetch_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_fetch_options, GIT_FETCH_OPTIONS_INIT);
 	return 0;
 }
-
-int git_fetch_init_options(git_fetch_options *opts, unsigned int version)
-{
-	return git_fetch_options_init(opts, version);
-}

data/vendor/libgit2/src/fetchhead.c

@@ -11,7 +11,7 @@
 #include "git2/oid.h"
 
 #include "buffer.h"
-#include "futils.h"
+#include "fileops.h"
 #include "filebuf.h"
 #include "refs.h"
 #include "repository.h"

data/vendor/libgit2/src/filebuf.c

@@ -7,7 +7,7 @@
 
 #include "filebuf.h"
 
-#include "futils.h"
+#include "fileops.h"
 
 static const size_t WRITE_BUFFER_SIZE = (4096 * 2);
 
@@ -44,14 +44,18 @@ static int verify_last_error(git_filebuf *file)
 static int lock_file(git_filebuf *file, int flags, mode_t mode)
 {
 	if (git_path_exists(file->path_lock) == true) {
-		git_error_clear(); /* actual OS error code just confuses */
-		git_error_set(GIT_ERROR_OS,
-			"failed to lock file '%s' for writing", file->path_lock);
-		return GIT_ELOCKED;
+		if (flags & GIT_FILEBUF_FORCE)
+			p_unlink(file->path_lock);
+		else {
+			git_error_clear(); /* actual OS error code just confuses */
+			git_error_set(GIT_ERROR_OS,
+				"failed to lock file '%s' for writing", file->path_lock);
+			return GIT_ELOCKED;
+		}
 	}
 
 	/* create path to the file buffer is required */
-	if (flags & GIT_FILEBUF_CREATE_LEADING_DIRS) {
+	if (flags & GIT_FILEBUF_FORCE) {
 		/* XXX: Should dirmode here be configurable? Or is 0777 always fine? */
 		file->fd = git_futils_creat_locked_withpath(file->path_lock, 0777, mode);
 	} else {

data/vendor/libgit2/src/filebuf.h

@@ -9,7 +9,7 @@
 
 #include "common.h"
 
-#include "futils.h"
+#include "fileops.h"
 #include "hash.h"
 #include <zlib.h>
 
@@ -19,7 +19,7 @@
 
 #define GIT_FILEBUF_HASH_CONTENTS		(1 << 0)
 #define GIT_FILEBUF_APPEND				(1 << 2)
-#define GIT_FILEBUF_CREATE_LEADING_DIRS	(1 << 3)
+#define GIT_FILEBUF_FORCE				(1 << 3)
 #define GIT_FILEBUF_TEMPORARY			(1 << 4)
 #define GIT_FILEBUF_DO_NOT_BUFFER		(1 << 5)
 #define GIT_FILEBUF_FSYNC				(1 << 6)

data/vendor/libgit2/src/{futils.c → fileops.c}

@@ -5,7 +5,7 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include "futils.h"
+#include "fileops.h"
 
 #include "global.h"
 #include "strmap.h"
@@ -112,7 +112,7 @@ int git_futils_truncate(const char *path, int mode)
 	return 0;
 }
 
-int git_futils_filesize(uint64_t *out, git_file fd)
+git_off_t git_futils_filesize(git_file fd)
 {
 	struct stat sb;
 
@@ -121,13 +121,7 @@ int git_futils_filesize(uint64_t *out, git_file fd)
 		return -1;
 	}
 
-	if (sb.st_size < 0) {
-		git_error_set(GIT_ERROR_INVALID, "invalid file size");
-		return -1;
-	}
-
-	*out = sb.st_size;
-	return 0;
+	return sb.st_size;
 }
 
 mode_t git_futils_canonical_mode(mode_t raw_mode)
@@ -307,7 +301,7 @@ int git_futils_mv_withpath(const char *from, const char *to, const mode_t dirmod
 	return 0;
 }
 
-int git_futils_mmap_ro(git_map *out, git_file fd, off64_t begin, size_t len)
+int git_futils_mmap_ro(git_map *out, git_file fd, git_off_t begin, size_t len)
 {
 	return p_mmap(out, len, GIT_PROT_READ, GIT_MAP_SHARED, fd, begin);
 }
@@ -315,14 +309,16 @@ int git_futils_mmap_ro(git_map *out, git_file fd, off64_t begin, size_t len)
 int git_futils_mmap_ro_file(git_map *out, const char *path)
 {
 	git_file fd = git_futils_open_ro(path);
-	uint64_t len;
+	git_off_t len;
 	int result;
 
 	if (fd < 0)
 		return fd;
 
-	if ((result = git_futils_filesize(&len, fd)) < 0)
+	if ((len = git_futils_filesize(fd)) < 0) {
+		result = -1;
 		goto out;
+	}
 
 	if (!git__is_sizet(len)) {
 		git_error_set(GIT_ERROR_OS, "file `%s` too large to mmap", path);
@@ -480,7 +476,6 @@ int git_futils_mkdir(
 			break;
 		} else if (errno != ENOENT) {
 			git_error_set(GIT_ERROR_OS, "failed to stat '%s'", parent_path.ptr);
-			error = -1;
 			goto done;
 		}
 
@@ -500,9 +495,7 @@ int git_futils_mkdir(
 		 * equal to length of the root path).  The path may be less than the
 		 * root path length on Windows, where `C:` == `C:/`.
 		 */
-		if ((len == 1 && parent_path.ptr[0] == '.') ||
-		    (len == 1 && parent_path.ptr[0] == '/') ||
-		    len <= root_len) {
+		if ((len == 1 && parent_path.ptr[0] == '.') || len <= root_len) {
 			relative = make_path.ptr;
 			break;
 		}
@@ -643,12 +636,15 @@ retry_lstat:
 			size_t alloc_size;
 
 			GIT_ERROR_CHECK_ALLOC_ADD(&alloc_size, make_path.size, 1);
-			cache_path = git_pool_malloc(opts->pool, alloc_size);
+			if (!git__is_uint32(alloc_size))
+				return -1;
+			cache_path = git_pool_malloc(opts->pool, (uint32_t)alloc_size);
 			GIT_ERROR_CHECK_ALLOC(cache_path);
 
 			memcpy(cache_path, make_path.ptr, make_path.size + 1);
 
-			if ((error = git_strmap_set(opts->dir_map, cache_path, cache_path)) < 0)
+			git_strmap_insert(opts->dir_map, cache_path, cache_path, &error);
+			if (error < 0)
 				goto done;
 		}
 	}
@@ -1110,7 +1106,7 @@ int git_futils_filestamp_check(
 #if defined(GIT_USE_NSEC)
 		stamp->mtime.tv_nsec == st.st_mtime_nsec &&
 #endif
-		stamp->size  == (uint64_t)st.st_size   &&
+		stamp->size  == (git_off_t)st.st_size   &&
 		stamp->ino   == (unsigned int)st.st_ino)
 		return 0;
 
@@ -1118,7 +1114,7 @@ int git_futils_filestamp_check(
 #if defined(GIT_USE_NSEC)
 	stamp->mtime.tv_nsec = st.st_mtime_nsec;
 #endif
-	stamp->size  = (uint64_t)st.st_size;
+	stamp->size  = (git_off_t)st.st_size;
 	stamp->ino   = (unsigned int)st.st_ino;
 
 	return 1;
@@ -1146,7 +1142,7 @@ void git_futils_filestamp_set_from_stat(
 #else
 		stamp->mtime.tv_nsec = 0;
 #endif
-		stamp->size  = (uint64_t)st->st_size;
+		stamp->size  = (git_off_t)st->st_size;
 		stamp->ino   = (unsigned int)st->st_ino;
 	} else {
 		memset(stamp, 0, sizeof(*stamp));

data/vendor/libgit2/src/{futils.h → fileops.h}

@@ -4,8 +4,8 @@
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */
-#ifndef INCLUDE_futils_h__
-#define INCLUDE_futils_h__
+#ifndef INCLUDE_fileops_h__
+#define INCLUDE_fileops_h__
 
 #include "common.h"
 
@@ -255,7 +255,7 @@ extern int git_futils_truncate(const char *path, int mode);
 /**
  * Get the filesize in bytes of a file
  */
-extern int git_futils_filesize(uint64_t *out, git_file fd);
+extern git_off_t git_futils_filesize(git_file fd);
 
 #define GIT_PERMS_IS_EXEC(MODE)		(((MODE) & 0111) != 0)
 #define GIT_PERMS_CANONICAL(MODE)	(GIT_PERMS_IS_EXEC(MODE) ? 0755 : 0644)
@@ -290,7 +290,7 @@ extern mode_t git_futils_canonical_mode(mode_t raw_mode);
 extern int git_futils_mmap_ro(
 	git_map *out,
 	git_file fd,
-	off64_t begin,
+	git_off_t begin,
 	size_t len);
 
 /**
@@ -330,7 +330,7 @@ extern int git_futils_fake_symlink(const char *new, const char *old);
  */
 typedef struct {
 	struct timespec mtime;
-	uint64_t size;
+	git_off_t  size;
 	unsigned int ino;
 } git_futils_filestamp;
 

data/vendor/libgit2/src/filter.c

@@ -8,7 +8,7 @@
 #include "filter.h"
 
 #include "common.h"
-#include "futils.h"
+#include "fileops.h"
 #include "hash.h"
 #include "repository.h"
 #include "global.h"
@@ -385,7 +385,7 @@ uint16_t git_filter_source_filemode(const git_filter_source *src)
 
 const git_oid *git_filter_source_id(const git_filter_source *src)
 {
-	return git_oid_is_zero(&src->oid) ? NULL : &src->oid;
+	return git_oid_iszero(&src->oid) ? NULL : &src->oid;
 }
 
 git_filter_mode_t git_filter_source_mode(const git_filter_source *src)
@@ -428,21 +428,13 @@ static int filter_list_check_attributes(
 	git_filter_def *fdef,
 	const git_filter_source *src)
 {
-	const char **strs = git__calloc(fdef->nattrs, sizeof(const char *));
-	uint32_t flags = 0;
-	size_t i;
 	int error;
-
+	size_t i;
+	const char **strs = git__calloc(fdef->nattrs, sizeof(const char *));
 	GIT_ERROR_CHECK_ALLOC(strs);
 
-	if ((src->flags & GIT_FILTER_NO_SYSTEM_ATTRIBUTES) != 0)
-		flags |= GIT_ATTR_CHECK_NO_SYSTEM;
-
-	if ((src->flags & GIT_FILTER_ATTRIBUTES_FROM_HEAD) != 0)
-		flags |= GIT_ATTR_CHECK_INCLUDE_HEAD;
-
 	error = git_attr_get_many_with_session(
-		strs, repo, attr_session, flags, src->path, fdef->nattrs, fdef->attrs);
+		strs, repo, attr_session, 0, src->path, fdef->nattrs, fdef->attrs);
 
 	/* if no values were found but no matches are needed, it's okay! */
 	if (error == GIT_ENOTFOUND && !fdef->nmatches) {
@@ -453,7 +445,7 @@ static int filter_list_check_attributes(
 
 	for (i = 0; !error && i < fdef->nattrs; ++i) {
 		const char *want = fdef->attrs[fdef->nattrs + i];
-		git_attr_value_t want_type, found_type;
+		git_attr_t want_type, found_type;
 
 		if (!want)
 			continue;
@@ -463,7 +455,7 @@ static int filter_list_check_attributes(
 
 		if (want_type != found_type)
 			error = GIT_ENOTFOUND;
-		else if (want_type == GIT_ATTR_VALUE_STRING &&
+		else if (want_type == GIT_ATTR_VALUE_T &&
 				strcmp(want, strs[i]) &&
 				strcmp(want, "*"))
 			error = GIT_ENOTFOUND;
@@ -764,7 +756,7 @@ int git_filter_list_apply_to_file(
 
 static int buf_from_blob(git_buf *out, git_blob *blob)
 {
-	git_object_size_t rawsize = git_blob_rawsize(blob);
+	git_off_t rawsize = git_blob_rawsize(blob);
 
 	if (!git__is_sizet(rawsize)) {
 		git_error_set(GIT_ERROR_OS, "blob is too large to filter");

data/vendor/libgit2/src/fnmatch.c

@@ -0,0 +1,248 @@
+/*
+ * 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.
+ */
+
+/*
+ * This file contains code originally derrived from OpenBSD fnmatch.c 
+ *
+ * Copyright (c) 1989, 1993, 1994
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. 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.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
+ */
+
+/*
+ * Function fnmatch() as specified in POSIX 1003.2-1992, section B.6.
+ * Compares a filename or pathname to a pattern.
+ */
+
+#include "fnmatch.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#define EOS		'\0'
+
+#define RANGE_MATCH		1
+#define RANGE_NOMATCH		0
+#define RANGE_ERROR		(-1)
+
+static int rangematch(const char *, char, int, char **);
+
+static int
+p_fnmatchx(const char *pattern, const char *string, int flags, size_t recurs)
+{
+		const char *stringstart;
+		char *newp;
+		char c, test;
+		int recurs_flags = flags & ~FNM_PERIOD;
+
+		if (recurs-- == 0)
+				return FNM_NORES;
+
+		for (stringstart = string;;)
+				switch (c = *pattern++) {
+				case EOS:
+						if ((flags & FNM_LEADING_DIR) && *string == '/')
+								return (0);
+						return (*string == EOS ? 0 : FNM_NOMATCH);
+				case '?':
+						if (*string == EOS)
+								return (FNM_NOMATCH);
+						if (*string == '/' && (flags & FNM_PATHNAME))
+								return (FNM_NOMATCH);
+						if (*string == '.' && (flags & FNM_PERIOD) &&
+							(string == stringstart ||
+							((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+								return (FNM_NOMATCH);
+						++string;
+						break;
+				case '*':
+						c = *pattern;
+
+						/* Let '**' override PATHNAME match for this segment.
+						 * It will be restored if/when we recurse below.
+						 */
+						if (c == '*') {
+							c = *++pattern;
+							/* star-star-slash is at the end, match by default */
+							if (c == EOS)
+								return 0;
+							/* Double-star must be at end or between slashes */
+							if (c != '/')
+								return (FNM_NOMATCH);
+
+							c = *++pattern;
+							do {
+								int e = p_fnmatchx(pattern, string, recurs_flags, recurs);
+								if (e != FNM_NOMATCH)
+									return e;
+								string = strchr(string, '/');
+							} while (string++);
+
+							/* If we get here, we didn't find a match */
+							return FNM_NOMATCH;
+						}
+
+						if (*string == '.' && (flags & FNM_PERIOD) &&
+							(string == stringstart ||
+							((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+								return (FNM_NOMATCH);
+
+						/* Optimize for pattern with * at end or before /. */
+						if (c == EOS) {
+								if (flags & FNM_PATHNAME)
+										return ((flags & FNM_LEADING_DIR) ||
+											strchr(string, '/') == NULL ?
+											0 : FNM_NOMATCH);
+								else
+										return (0);
+						} else if (c == '/' && (flags & FNM_PATHNAME)) {
+								if ((string = strchr(string, '/')) == NULL)
+										return (FNM_NOMATCH);
+								break;
+						}
+
+						/* General case, use recursion. */
+						while ((test = *string) != EOS) {
+								int e;
+
+								e = p_fnmatchx(pattern, string, recurs_flags, recurs);
+								if (e != FNM_NOMATCH)
+										return e;
+								if (test == '/' && (flags & FNM_PATHNAME))
+										break;
+								++string;
+						}
+						return (FNM_NOMATCH);
+				case '[':
+						if (*string == EOS)
+								return (FNM_NOMATCH);
+						if (*string == '/' && (flags & FNM_PATHNAME))
+								return (FNM_NOMATCH);
+						if (*string == '.' && (flags & FNM_PERIOD) &&
+							(string == stringstart ||
+							((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+								return (FNM_NOMATCH);
+
+						switch (rangematch(pattern, *string, flags, &newp)) {
+						case RANGE_ERROR:
+								/* not a good range, treat as normal text */
+								goto normal;
+						case RANGE_MATCH:
+								pattern = newp;
+								break;
+						case RANGE_NOMATCH:
+								return (FNM_NOMATCH);
+						}
+						++string;
+						break;
+				case '\\':
+						if (!(flags & FNM_NOESCAPE)) {
+								if ((c = *pattern++) == EOS) {
+										c = '\\';
+										--pattern;
+								}
+						}
+						/* FALLTHROUGH */
+				default:
+				normal:
+						if (c != *string && !((flags & FNM_CASEFOLD) &&
+									(git__tolower((unsigned char)c) ==
+									git__tolower((unsigned char)*string))))
+								return (FNM_NOMATCH);
+						++string;
+						break;
+				}
+		/* NOTREACHED */
+}
+
+static int
+rangematch(const char *pattern, char test, int flags, char **newp)
+{
+		int negate, ok;
+		char c, c2;
+
+		/*
+			* A bracket expression starting with an unquoted circumflex
+			* character produces unspecified results (IEEE 1003.2-1992,
+			* 3.13.2). This implementation treats it like '!', for
+			* consistency with the regular expression syntax.
+			* J.T. Conklin (conklin@ngai.kaleida.com)
+			*/
+		if ((negate = (*pattern == '!' || *pattern == '^')) != 0)
+				++pattern;
+
+		if (flags & FNM_CASEFOLD)
+				test = (char)git__tolower((unsigned char)test);
+
+		/*
+			* A right bracket shall lose its special meaning and represent
+			* itself in a bracket expression if it occurs first in the list.
+			* -- POSIX.2 2.8.3.2
+			*/
+		ok = 0;
+		c = *pattern++;
+		do {
+				if (c == '\\' && !(flags & FNM_NOESCAPE))
+						c = *pattern++;
+				if (c == EOS)
+						return (RANGE_ERROR);
+				if (c == '/' && (flags & FNM_PATHNAME))
+						return (RANGE_NOMATCH);
+				if ((flags & FNM_CASEFOLD))
+						c = (char)git__tolower((unsigned char)c);
+				if (*pattern == '-'
+					&& (c2 = *(pattern+1)) != EOS && c2 != ']') {
+						pattern += 2;
+						if (c2 == '\\' && !(flags & FNM_NOESCAPE))
+								c2 = *pattern++;
+						if (c2 == EOS)
+								return (RANGE_ERROR);
+						if (flags & FNM_CASEFOLD)
+								c2 = (char)git__tolower((unsigned char)c2);
+						if (c <= test && test <= c2)
+								ok = 1;
+				} else if (c == test)
+						ok = 1;
+		} while ((c = *pattern++) != ']');
+
+		*newp = (char *)pattern;
+		return (ok == negate ? RANGE_NOMATCH : RANGE_MATCH);
+}
+
+int
+p_fnmatch(const char *pattern, const char *string, int flags)
+{
+		return p_fnmatchx(pattern, string, flags, 64);
+}
+