rugged 1.1.1 → 1.4.3

data/vendor/libgit2/src/net.c

@@ -9,18 +9,35 @@
 #include "netops.h"
 
 #include <ctype.h>
-#include "git2/errors.h"
 
 #include "posix.h"
-#include "buffer.h"
+#include "str.h"
 #include "http_parser.h"
-#include "global.h"
+#include "runtime.h"
 
 #define DEFAULT_PORT_HTTP  "80"
 #define DEFAULT_PORT_HTTPS "443"
 #define DEFAULT_PORT_GIT   "9418"
 #define DEFAULT_PORT_SSH   "22"
 
+bool git_net_str_is_url(const char *str)
+{
+	const char *c;
+
+	for (c = str; *c; c++) {
+		if (*c == ':' && *(c+1) == '/' && *(c+2) == '/')
+			return true;
+
+		if ((*c < 'a' || *c > 'z') &&
+		    (*c < 'A' || *c > 'Z') &&
+		    (*c < '0' || *c > '9') &&
+		    (*c != '+' && *c != '-' && *c != '.'))
+			break;
+	}
+
+	return false;
+}
+
 static const char *default_port_for_scheme(const char *scheme)
 {
 	if (strcmp(scheme, "http") == 0)
@@ -29,23 +46,65 @@ static const char *default_port_for_scheme(const char *scheme)
 		return DEFAULT_PORT_HTTPS;
 	else if (strcmp(scheme, "git") == 0)
 		return DEFAULT_PORT_GIT;
-	else if (strcmp(scheme, "ssh") == 0)
+	else if (strcmp(scheme, "ssh") == 0 ||
+	         strcmp(scheme, "ssh+git") == 0 ||
+		 strcmp(scheme, "git+ssh") == 0)
 		return DEFAULT_PORT_SSH;
 
 	return NULL;
 }
 
+int git_net_url_dup(git_net_url *out, git_net_url *in)
+{
+	if (in->scheme) {
+		out->scheme = git__strdup(in->scheme);
+		GIT_ERROR_CHECK_ALLOC(out->scheme);
+	}
+
+	if (in->host) {
+		out->host = git__strdup(in->host);
+		GIT_ERROR_CHECK_ALLOC(out->host);
+	}
+
+	if (in->port) {
+		out->port = git__strdup(in->port);
+		GIT_ERROR_CHECK_ALLOC(out->port);
+	}
+
+	if (in->path) {
+		out->path = git__strdup(in->path);
+		GIT_ERROR_CHECK_ALLOC(out->path);
+	}
+
+	if (in->query) {
+		out->query = git__strdup(in->query);
+		GIT_ERROR_CHECK_ALLOC(out->query);
+	}
+
+	if (in->username) {
+		out->username = git__strdup(in->username);
+		GIT_ERROR_CHECK_ALLOC(out->username);
+	}
+
+	if (in->password) {
+		out->password = git__strdup(in->password);
+		GIT_ERROR_CHECK_ALLOC(out->password);
+	}
+
+	return 0;
+}
+
 int git_net_url_parse(git_net_url *url, const char *given)
 {
 	struct http_parser_url u = {0};
 	bool has_scheme, has_host, has_port, has_path, has_query, has_userinfo;
-	git_buf scheme = GIT_BUF_INIT,
-		host = GIT_BUF_INIT,
-		port = GIT_BUF_INIT,
-		path = GIT_BUF_INIT,
-		username = GIT_BUF_INIT,
-		password = GIT_BUF_INIT,
-		query = GIT_BUF_INIT;
+	git_str scheme = GIT_STR_INIT,
+		host = GIT_STR_INIT,
+		port = GIT_STR_INIT,
+		path = GIT_STR_INIT,
+		username = GIT_STR_INIT,
+		password = GIT_STR_INIT,
+		query = GIT_STR_INIT;
 	int error = GIT_EINVALIDSPEC;
 
 	if (http_parser_parse_url(given, strlen(given), false, &u)) {
@@ -63,7 +122,7 @@ int git_net_url_parse(git_net_url *url, const char *given)
 	if (has_scheme) {
 		const char *url_scheme = given + u.field_data[UF_SCHEMA].off;
 		size_t url_scheme_len = u.field_data[UF_SCHEMA].len;
-		git_buf_put(&scheme, url_scheme, url_scheme_len);
+		git_str_put(&scheme, url_scheme, url_scheme_len);
 		git__strntolower(scheme.ptr, scheme.size);
 	} else {
 		git_error_set(GIT_ERROR_NET, "malformed URL '%s'", given);
@@ -73,13 +132,13 @@ int git_net_url_parse(git_net_url *url, const char *given)
 	if (has_host) {
 		const char *url_host = given + u.field_data[UF_HOST].off;
 		size_t url_host_len = u.field_data[UF_HOST].len;
-		git_buf_decode_percent(&host, url_host, url_host_len);
+		git_str_decode_percent(&host, url_host, url_host_len);
 	}
 
 	if (has_port) {
 		const char *url_port = given + u.field_data[UF_PORT].off;
 		size_t url_port_len = u.field_data[UF_PORT].len;
-		git_buf_put(&port, url_port, url_port_len);
+		git_str_put(&port, url_port, url_port_len);
 	} else {
 		const char *default_port = default_port_for_scheme(scheme.ptr);
 
@@ -88,21 +147,21 @@ int git_net_url_parse(git_net_url *url, const char *given)
 			goto done;
 		}
 
-		git_buf_puts(&port, default_port);
+		git_str_puts(&port, default_port);
 	}
 
 	if (has_path) {
 		const char *url_path = given + u.field_data[UF_PATH].off;
 		size_t url_path_len = u.field_data[UF_PATH].len;
-		git_buf_put(&path, url_path, url_path_len);
+		git_str_put(&path, url_path, url_path_len);
 	} else {
-		git_buf_puts(&path, "/");
+		git_str_puts(&path, "/");
 	}
 
 	if (has_query) {
 		const char *url_query = given + u.field_data[UF_QUERY].off;
 		size_t url_query_len = u.field_data[UF_QUERY].len;
-		git_buf_decode_percent(&query, url_query, url_query_len);
+		git_str_decode_percent(&query, url_query, url_query_len);
 	}
 
 	if (has_userinfo) {
@@ -116,49 +175,238 @@ int git_net_url_parse(git_net_url *url, const char *given)
 			const char *url_password = colon + 1;
 			size_t url_password_len = url_userinfo_len - (url_username_len + 1);
 
-			git_buf_decode_percent(&username, url_username, url_username_len);
-			git_buf_decode_percent(&password, url_password, url_password_len);
+			git_str_decode_percent(&username, url_username, url_username_len);
+			git_str_decode_percent(&password, url_password, url_password_len);
 		} else {
-			git_buf_decode_percent(&username, url_userinfo, url_userinfo_len);
+			git_str_decode_percent(&username, url_userinfo, url_userinfo_len);
 		}
 	}
 
-	if (git_buf_oom(&scheme) ||
-	    git_buf_oom(&host) ||
-	    git_buf_oom(&port) ||
-	    git_buf_oom(&path) ||
-	    git_buf_oom(&query) ||
-	    git_buf_oom(&username) ||
-	    git_buf_oom(&password))
+	if (git_str_oom(&scheme) ||
+	    git_str_oom(&host) ||
+	    git_str_oom(&port) ||
+	    git_str_oom(&path) ||
+	    git_str_oom(&query) ||
+	    git_str_oom(&username) ||
+	    git_str_oom(&password))
 		return -1;
 
-	url->scheme = git_buf_detach(&scheme);
-	url->host = git_buf_detach(&host);
-	url->port = git_buf_detach(&port);
-	url->path = git_buf_detach(&path);
-	url->query = git_buf_detach(&query);
-	url->username = git_buf_detach(&username);
-	url->password = git_buf_detach(&password);
+	url->scheme = git_str_detach(&scheme);
+	url->host = git_str_detach(&host);
+	url->port = git_str_detach(&port);
+	url->path = git_str_detach(&path);
+	url->query = git_str_detach(&query);
+	url->username = git_str_detach(&username);
+	url->password = git_str_detach(&password);
 
 	error = 0;
 
 done:
-	git_buf_dispose(&scheme);
-	git_buf_dispose(&host);
-	git_buf_dispose(&port);
-	git_buf_dispose(&path);
-	git_buf_dispose(&query);
-	git_buf_dispose(&username);
-	git_buf_dispose(&password);
+	git_str_dispose(&scheme);
+	git_str_dispose(&host);
+	git_str_dispose(&port);
+	git_str_dispose(&path);
+	git_str_dispose(&query);
+	git_str_dispose(&username);
+	git_str_dispose(&password);
 	return error;
 }
 
+static int scp_invalid(const char *message)
+{
+	git_error_set(GIT_ERROR_NET, "invalid scp-style path: %s", message);
+	return GIT_EINVALIDSPEC;
+}
+
+static bool is_ipv6(const char *str)
+{
+	const char *c;
+	size_t colons = 0;
+
+	if (*str++ != '[')
+		return false;
+
+	for (c = str; *c; c++) {
+		if (*c  == ':')
+			colons++;
+
+		if (*c == ']')
+			return (colons > 1);
+
+		if (*c != ':' &&
+		    (*c < '0' || *c > '9') &&
+		    (*c < 'a' || *c > 'f') &&
+		    (*c < 'A' || *c > 'F'))
+			return false;
+	}
+
+	return false;
+}
+
+static bool has_at(const char *str)
+{
+	const char *c;
+
+	for (c = str; *c; c++) {
+		if (*c == '@')
+			return true;
+
+		if (*c == ':')
+			break;
+	}
+
+	return false;
+}
+
+int git_net_url_parse_scp(git_net_url *url, const char *given)
+{
+	const char *default_port = default_port_for_scheme("ssh");
+	const char *c, *user, *host, *port, *path = NULL;
+	size_t user_len = 0, host_len = 0, port_len = 0;
+	unsigned short bracket = 0;
+
+	enum {
+		NONE,
+		USER,
+		HOST_START, HOST, HOST_END,
+		IPV6, IPV6_END,
+		PORT_START, PORT, PORT_END,
+		PATH_START
+	} state = NONE;
+
+	memset(url, 0, sizeof(git_net_url));
+
+	for (c = given; *c && !path; c++) {
+		switch (state) {
+		case NONE:
+			switch (*c) {
+			case '@':
+				return scp_invalid("unexpected '@'");
+			case ':':
+				return scp_invalid("unexpected ':'");
+			case '[':
+				if (is_ipv6(c)) {
+					state = IPV6;
+					host = c;
+				} else if (bracket++ > 1) {
+					return scp_invalid("unexpected '['");
+				}
+				break;
+			default:
+				if (has_at(c)) {
+					state = USER;
+					user = c;
+				} else {
+					state = HOST;
+					host = c;
+				}
+				break;
+			}
+			break;
+
+		case USER:
+			if (*c == '@') {
+				user_len = (c - user);
+				state = HOST_START;
+			}
+			break;
+
+		case HOST_START:
+			state = (*c == '[') ? IPV6 : HOST;
+			host = c;
+			break;
+
+		case HOST:
+			if (*c == ':') {
+				host_len = (c - host);
+				state = bracket ? PORT_START : PATH_START;
+			} else if (*c == ']') {
+				if (bracket-- == 0)
+					return scp_invalid("unexpected ']'");
+
+				host_len = (c - host);
+				state = HOST_END;
+			}
+			break;
+
+		case HOST_END:
+			if (*c != ':')
+				return scp_invalid("unexpected character after hostname");
+			state = PATH_START;
+			break;
+
+		case IPV6:
+			if (*c == ']')
+				state = IPV6_END;
+			break;
+
+		case IPV6_END:
+			if (*c != ':')
+				return scp_invalid("unexpected character after ipv6 address");
+
+			host_len = (c - host);
+			state = bracket ? PORT_START : PATH_START;
+			break;
+
+		case PORT_START:
+			port = c;
+			state = PORT;
+			break;
+
+		case PORT:
+			if (*c == ']') {
+				if (bracket-- == 0)
+					return scp_invalid("unexpected ']'");
+
+				port_len = c - port;
+				state = PORT_END;
+			}
+			break;
+
+		case PORT_END:
+			if (*c != ':')
+				return scp_invalid("unexpected character after ipv6 address");
+
+			state = PATH_START;
+			break;
+
+		case PATH_START:
+			path = c;
+			break;
+
+		default:
+			GIT_ASSERT("unhandled state");
+		}
+	}
+
+	if (!path)
+		return scp_invalid("path is required");
+
+	GIT_ERROR_CHECK_ALLOC(url->scheme = git__strdup("ssh"));
+
+	if (user_len)
+		GIT_ERROR_CHECK_ALLOC(url->username = git__strndup(user, user_len));
+
+	GIT_ASSERT(host_len);
+	GIT_ERROR_CHECK_ALLOC(url->host = git__strndup(host, host_len));
+
+	if (port_len)
+		GIT_ERROR_CHECK_ALLOC(url->port = git__strndup(port, port_len));
+	else
+		GIT_ERROR_CHECK_ALLOC(url->port = git__strdup(default_port));
+
+	GIT_ASSERT(path);
+	GIT_ERROR_CHECK_ALLOC(url->path = git__strdup(path));
+
+	return 0;
+}
+
 int git_net_url_joinpath(
 	git_net_url *out,
 	git_net_url *one,
 	const char *two)
 {
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	const char *query;
 	size_t one_len, two_len;
 
@@ -186,14 +434,14 @@ int git_net_url_joinpath(
 		two_len--;
 	}
 
-	git_buf_put(&path, one->path, one_len);
-	git_buf_putc(&path, '/');
-	git_buf_put(&path, two, two_len);
+	git_str_put(&path, one->path, one_len);
+	git_str_putc(&path, '/');
+	git_str_put(&path, two, two_len);
 
-	if (git_buf_oom(&path))
+	if (git_str_oom(&path))
 		return -1;
 
-	out->path = git_buf_detach(&path);
+	out->path = git_str_detach(&path);
 
 	if (one->scheme) {
 		out->scheme = git__strdup(one->scheme);
@@ -276,12 +524,14 @@ static void remove_service_suffix(
 int git_net_url_apply_redirect(
 	git_net_url *url,
 	const char *redirect_location,
+	bool allow_offsite,
 	const char *service_suffix)
 {
 	git_net_url tmp = GIT_NET_URL_INIT;
 	int error = 0;
 
-	assert(url && redirect_location);
+	GIT_ASSERT(url);
+	GIT_ASSERT(redirect_location);
 
 	if (redirect_location[0] == '/') {
 		git__free(url->path);
@@ -299,8 +549,8 @@ int git_net_url_apply_redirect(
 		/* Validate that this is a legal redirection */
 
 		if (original->scheme &&
-			strcmp(original->scheme, tmp.scheme) != 0 &&
-			strcmp(tmp.scheme, "https") != 0) {
+		    strcmp(original->scheme, tmp.scheme) != 0 &&
+		    strcmp(tmp.scheme, "https") != 0) {
 			git_error_set(GIT_ERROR_NET, "cannot redirect from '%s' to '%s'",
 				original->scheme, tmp.scheme);
 
@@ -309,6 +559,7 @@ int git_net_url_apply_redirect(
 		}
 
 		if (original->host &&
+		    !allow_offsite &&
 		    git__strcasecmp(original->host, tmp.host) != 0) {
 			git_error_set(GIT_ERROR_NET, "cannot redirect from '%s' to '%s'",
 				original->host, tmp.host);
@@ -334,7 +585,7 @@ bool git_net_url_valid(git_net_url *url)
 	return (url->host && url->port && url->path);
 }
 
-int git_net_url_is_default_port(git_net_url *url)
+bool git_net_url_is_default_port(git_net_url *url)
 {
 	const char *default_port;
 
@@ -344,6 +595,11 @@ int git_net_url_is_default_port(git_net_url *url)
 		return false;
 }
 
+bool git_net_url_is_ipv6(git_net_url *url)
+{
+	return (strchr(url->host, ':') != NULL);
+}
+
 void git_net_url_swap(git_net_url *a, git_net_url *b)
 {
 	git_net_url tmp = GIT_NET_URL_INIT;
@@ -353,49 +609,127 @@ void git_net_url_swap(git_net_url *a, git_net_url *b)
 	memcpy(b, &tmp, sizeof(git_net_url));
 }
 
-int git_net_url_fmt(git_buf *buf, git_net_url *url)
+int git_net_url_fmt(git_str *buf, git_net_url *url)
 {
-	git_buf_puts(buf, url->scheme);
-	git_buf_puts(buf, "://");
+	GIT_ASSERT_ARG(url);
+	GIT_ASSERT_ARG(url->scheme);
+	GIT_ASSERT_ARG(url->host);
+
+	git_str_puts(buf, url->scheme);
+	git_str_puts(buf, "://");
 
 	if (url->username) {
-		git_buf_puts(buf, url->username);
+		git_str_puts(buf, url->username);
 
 		if (url->password) {
-			git_buf_puts(buf, ":");
-			git_buf_puts(buf, url->password);
+			git_str_puts(buf, ":");
+			git_str_puts(buf, url->password);
 		}
 
-		git_buf_putc(buf, '@');
+		git_str_putc(buf, '@');
 	}
 
-	git_buf_puts(buf, url->host);
+	git_str_puts(buf, url->host);
 
 	if (url->port && !git_net_url_is_default_port(url)) {
-		git_buf_putc(buf, ':');
-		git_buf_puts(buf, url->port);
+		git_str_putc(buf, ':');
+		git_str_puts(buf, url->port);
 	}
 
-	git_buf_puts(buf, url->path ? url->path : "/");
+	git_str_puts(buf, url->path ? url->path : "/");
 
 	if (url->query) {
-		git_buf_putc(buf, '?');
-		git_buf_puts(buf, url->query);
+		git_str_putc(buf, '?');
+		git_str_puts(buf, url->query);
 	}
 
-	return git_buf_oom(buf) ? -1 : 0;
+	return git_str_oom(buf) ? -1 : 0;
 }
 
-int git_net_url_fmt_path(git_buf *buf, git_net_url *url)
+int git_net_url_fmt_path(git_str *buf, git_net_url *url)
 {
-	git_buf_puts(buf, url->path ? url->path : "/");
+	git_str_puts(buf, url->path ? url->path : "/");
 
 	if (url->query) {
-		git_buf_putc(buf, '?');
-		git_buf_puts(buf, url->query);
+		git_str_putc(buf, '?');
+		git_str_puts(buf, url->query);
+	}
+
+	return git_str_oom(buf) ? -1 : 0;
+}
+
+static bool matches_pattern(
+	git_net_url *url,
+	const char *pattern,
+	size_t pattern_len)
+{
+	const char *domain, *port = NULL, *colon;
+	size_t host_len, domain_len, port_len = 0, wildcard = 0;
+
+	GIT_UNUSED(url);
+	GIT_UNUSED(pattern);
+
+	if (!pattern_len)
+		return false;
+	else if (pattern_len == 1 && pattern[0] == '*')
+		return true;
+	else if (pattern_len > 1 && pattern[0] == '*' && pattern[1] == '.')
+		wildcard = 2;
+	else if (pattern[0] == '.')
+		wildcard = 1;
+
+	domain = pattern + wildcard;
+	domain_len = pattern_len - wildcard;
+
+	if ((colon = memchr(domain, ':', domain_len)) != NULL) {
+		domain_len = colon - domain;
+		port = colon + 1;
+		port_len = pattern_len - wildcard - domain_len - 1;
+	}
+
+	/* A pattern's port *must* match if it's specified */
+	if (port_len && git__strlcmp(url->port, port, port_len) != 0)
+		return false;
+
+	/* No wildcard?  Host must match exactly. */
+	if (!wildcard)
+		return !git__strlcmp(url->host, domain, domain_len);
+
+	/* Wildcard: ensure there's (at least) a suffix match */
+	if ((host_len = strlen(url->host)) < domain_len ||
+	    memcmp(url->host + (host_len - domain_len), domain, domain_len))
+		return false;
+
+	/* The pattern is *.domain and the host is simply domain */
+	if (host_len == domain_len)
+		return true;
+
+	/* The pattern is *.domain and the host is foo.domain */
+	return (url->host[host_len - domain_len - 1] == '.');
+}
+
+bool git_net_url_matches_pattern(git_net_url *url, const char *pattern)
+{
+	return matches_pattern(url, pattern, strlen(pattern));
+}
+
+bool git_net_url_matches_pattern_list(
+	git_net_url *url,
+	const char *pattern_list)
+{
+	const char *pattern, *pattern_end, *sep;
+
+	for (pattern = pattern_list;
+	     pattern && *pattern;
+	     pattern = sep ? sep + 1 : NULL) {
+		sep = strchr(pattern, ',');
+		pattern_end = sep ? sep : strchr(pattern, '\0');
+
+		if (matches_pattern(url, pattern, (pattern_end - pattern)))
+			return true;
 	}
 
-	return git_buf_oom(buf) ? -1 : 0;
+	return false;
 }
 
 void git_net_url_dispose(git_net_url *url)

data/vendor/libgit2/src/net.h

@@ -21,9 +21,18 @@ typedef struct git_net_url {
 
 #define GIT_NET_URL_INIT { NULL }
 
-/** Parses a string containing a URL into a structure.  */
+/** Is a given string a url? */
+extern bool git_net_str_is_url(const char *str);
+
+/** Duplicate a URL */
+extern int git_net_url_dup(git_net_url *out, git_net_url *in);
+
+/** Parses a string containing a URL into a structure. */
 extern int git_net_url_parse(git_net_url *url, const char *str);
 
+/** Parses a string containing an SCP style path into a URL structure. */
+extern int git_net_url_parse_scp(git_net_url *url, const char *str);
+
 /** Appends a path and/or query string to the given URL */
 extern int git_net_url_joinpath(
 	git_net_url *out,
@@ -33,23 +42,35 @@ extern int git_net_url_joinpath(
 /** Ensures that a URL is minimally valid (contains a host, port and path) */
 extern bool git_net_url_valid(git_net_url *url);
 
-/** Returns nonzero if the URL is on the default port. */
-extern int git_net_url_is_default_port(git_net_url *url);
+/** Returns true if the URL is on the default port. */
+extern bool git_net_url_is_default_port(git_net_url *url);
+
+/** Returns true if the host portion of the URL is an ipv6 address. */
+extern bool git_net_url_is_ipv6(git_net_url *url);
 
 /* Applies a redirect to the URL with a git-aware service suffix. */
 extern int git_net_url_apply_redirect(
 	git_net_url *url,
 	const char *redirect_location,
+	bool allow_offsite,
 	const char *service_suffix);
 
 /** Swaps the contents of one URL for another.  */
 extern void git_net_url_swap(git_net_url *a, git_net_url *b);
 
 /** Places the URL into the given buffer. */
-extern int git_net_url_fmt(git_buf *out, git_net_url *url);
+extern int git_net_url_fmt(git_str *out, git_net_url *url);
 
 /** Place the path and query string into the given buffer. */
-extern int git_net_url_fmt_path(git_buf *buf, git_net_url *url);
+extern int git_net_url_fmt_path(git_str *buf, git_net_url *url);
+
+/** Determines if the url matches given pattern or pattern list */
+extern bool git_net_url_matches_pattern(
+	git_net_url *url,
+	const char *pattern);
+extern bool git_net_url_matches_pattern_list(
+	git_net_url *url,
+	const char *pattern_list);
 
 /** Disposes the contents of the structure. */
 extern void git_net_url_dispose(git_net_url *url);