rugged 0.27.10 → 0.27.10.1

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;
 
@@ -340,7 +340,7 @@ typedef struct {
  * This function updates the file stamp to current data for the given path
  * and returns 0 if the file is up-to-date relative to the prior setting,
  * 1 if the file has been changed, or GIT_ENOTFOUND if the file doesn't
- * exist.  This will not call git_error_set, so you must set the error if you
+ * exist.  This will not call giterr_set, so you must set the error if you
  * plan to return an error.
  *
  * @param stamp File stamp to be checked

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"
@@ -157,15 +157,15 @@ static int filter_registry_insert(
 	if (filter_def_scan_attrs(&attrs, &nattr, &nmatch, filter->attributes) < 0)
 		return -1;
 
-	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&alloc_len, nattr, 2);
-	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&alloc_len, alloc_len, sizeof(char *));
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, sizeof(git_filter_def));
+	GITERR_CHECK_ALLOC_MULTIPLY(&alloc_len, nattr, 2);
+	GITERR_CHECK_ALLOC_MULTIPLY(&alloc_len, alloc_len, sizeof(char *));
+	GITERR_CHECK_ALLOC_ADD(&alloc_len, alloc_len, sizeof(git_filter_def));
 
 	fdef = git__calloc(1, alloc_len);
-	GIT_ERROR_CHECK_ALLOC(fdef);
+	GITERR_CHECK_ALLOC(fdef);
 
 	fdef->filter_name = git__strdup(name);
-	GIT_ERROR_CHECK_ALLOC(fdef->filter_name);
+	GITERR_CHECK_ALLOC(fdef->filter_name);
 
 	fdef->filter      = filter;
 	fdef->priority    = priority;
@@ -269,13 +269,13 @@ int git_filter_register(
 	assert(name && filter);
 
 	if (git_rwlock_wrlock(&filter_registry.lock) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
+		giterr_set(GITERR_OS, "failed to lock filter registry");
 		return -1;
 	}
 
 	if (!filter_registry_find(NULL, name)) {
-		git_error_set(
-			GIT_ERROR_FILTER, "attempt to reregister existing filter '%s'", name);
+		giterr_set(
+			GITERR_FILTER, "attempt to reregister existing filter '%s'", name);
 		error = GIT_EEXISTS;
 		goto done;
 	}
@@ -297,17 +297,17 @@ int git_filter_unregister(const char *name)
 
 	/* cannot unregister default filters */
 	if (!strcmp(GIT_FILTER_CRLF, name) || !strcmp(GIT_FILTER_IDENT, name)) {
-		git_error_set(GIT_ERROR_FILTER, "cannot unregister filter '%s'", name);
+		giterr_set(GITERR_FILTER, "cannot unregister filter '%s'", name);
 		return -1;
 	}
 
 	if (git_rwlock_wrlock(&filter_registry.lock) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
+		giterr_set(GITERR_OS, "failed to lock filter registry");
 		return -1;
 	}
 
 	if ((fdef = filter_registry_lookup(&pos, name)) == NULL) {
-		git_error_set(GIT_ERROR_FILTER, "cannot find filter '%s' to unregister", name);
+		giterr_set(GITERR_FILTER, "cannot find filter '%s' to unregister", name);
 		error = GIT_ENOTFOUND;
 		goto done;
 	}
@@ -348,7 +348,7 @@ git_filter *git_filter_lookup(const char *name)
 	git_filter *filter = NULL;
 
 	if (git_rwlock_rdlock(&filter_registry.lock) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
+		giterr_set(GITERR_OS, "failed to lock filter registry");
 		return NULL;
 	}
 
@@ -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)
@@ -404,11 +404,11 @@ static int filter_list_new(
 	git_filter_list *fl = NULL;
 	size_t pathlen = src->path ? strlen(src->path) : 0, alloclen;
 
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, sizeof(git_filter_list), pathlen);
-	GIT_ERROR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, sizeof(git_filter_list), pathlen);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
 
 	fl = git__calloc(1, alloclen);
-	GIT_ERROR_CHECK_ALLOC(fl);
+	GITERR_CHECK_ALLOC(fl);
 
 	if (src->path)
 		memcpy(fl->path, src->path, pathlen);
@@ -428,32 +428,24 @@ 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;
-
-	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;
+	size_t i;
+	const char **strs = git__calloc(fdef->nattrs, sizeof(const char *));
+	GITERR_CHECK_ALLOC(strs);
 
 	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) {
-		git_error_clear();
+		giterr_clear();
 		git__free((void *)strs);
 		return 0;
 	}
 
 	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;
@@ -507,7 +499,7 @@ int git_filter_list__load_ext(
 	git_filter_def *fdef;
 
 	if (git_rwlock_rdlock(&filter_registry.lock) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
+		giterr_set(GITERR_OS, "failed to lock filter registry");
 		return -1;
 	}
 
@@ -559,7 +551,7 @@ int git_filter_list__load_ext(
 			}
 
 			fe = git_array_alloc(fl->filters);
-			GIT_ERROR_CHECK_ALLOC(fe);
+			GITERR_CHECK_ALLOC(fe);
 
 			fe->filter = fdef->filter;
 			fe->filter_name = fdef->filter_name;
@@ -642,7 +634,7 @@ int git_filter_list_push(
 	assert(fl && filter);
 
 	if (git_rwlock_rdlock(&filter_registry.lock) < 0) {
-		git_error_set(GIT_ERROR_OS, "failed to lock filter registry");
+		giterr_set(GITERR_OS, "failed to lock filter registry");
 		return -1;
 	}
 
@@ -654,7 +646,7 @@ int git_filter_list_push(
 	git_rwlock_rdunlock(&filter_registry.lock);
 
 	if (fdef == NULL) {
-		git_error_set(GIT_ERROR_FILTER, "cannot use an unregistered filter");
+		giterr_set(GITERR_FILTER, "cannot use an unregistered filter");
 		return -1;
 	}
 
@@ -662,7 +654,7 @@ int git_filter_list_push(
 		return error;
 
 	fe = git_array_alloc(fl->filters);
-	GIT_ERROR_CHECK_ALLOC(fe);
+	GITERR_CHECK_ALLOC(fe);
 	fe->filter  = filter;
 	fe->payload = payload;
 
@@ -764,10 +756,10 @@ 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");
+		giterr_set(GITERR_OS, "blob is too large to filter");
 		return -1;
 	}
 
@@ -837,9 +829,9 @@ static int proxy_stream_close(git_writestream *s)
 	} else {
 		/* close stream before erroring out taking care
 		 * to preserve the original error */
-		git_error_state_capture(&error_state, error);
+		giterr_state_capture(&error_state, error);
 		proxy_stream->target->close(proxy_stream->target);
-		git_error_state_restore(&error_state);
+		giterr_state_restore(&error_state);
 		return error;
 	}
 
@@ -855,8 +847,8 @@ static void proxy_stream_free(git_writestream *s)
 	struct proxy_stream *proxy_stream = (struct proxy_stream *)s;
 	assert(proxy_stream);
 
-	git_buf_dispose(&proxy_stream->input);
-	git_buf_dispose(&proxy_stream->temp_buf);
+	git_buf_free(&proxy_stream->input);
+	git_buf_free(&proxy_stream->temp_buf);
 	git__free(proxy_stream);
 }
 
@@ -869,7 +861,7 @@ static int proxy_stream_init(
 	git_writestream *target)
 {
 	struct proxy_stream *proxy_stream = git__calloc(1, sizeof(struct proxy_stream));
-	GIT_ERROR_CHECK_ALLOC(proxy_stream);
+	GITERR_CHECK_ALLOC(proxy_stream);
 
 	proxy_stream->parent.write = proxy_stream_write;
 	proxy_stream->parent.close = proxy_stream_close;
@@ -982,7 +974,7 @@ int git_filter_list_stream_file(
 	}
 
 	if (readlen < 0)
-		error = -1;
+		error = readlen;
 
 done:
 	if (initialized)
@@ -991,7 +983,7 @@ done:
 	if (fd >= 0)
 		p_close(fd);
 	stream_list_free(&filter_streams);
-	git_buf_dispose(&abspath);
+	git_buf_free(&abspath);
 	return error;
 }
 

data/vendor/libgit2/src/filter.h

@@ -15,6 +15,16 @@
 /* Amount of file to examine for NUL byte when checking binary-ness */
 #define GIT_FILTER_BYTES_TO_CHECK_NUL 8000
 
+/* Possible CRLF values */
+typedef enum {
+	GIT_CRLF_GUESS = -1,
+	GIT_CRLF_BINARY = 0,
+	GIT_CRLF_TEXT,
+	GIT_CRLF_INPUT,
+	GIT_CRLF_CRLF,
+	GIT_CRLF_AUTO,
+} git_crlf_t;
+
 typedef struct {
 	git_attr_session *attr_session;
 	git_buf *temp_buf;

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);
+}
+