rugged 0.27.10 → 0.27.10.1

data/vendor/libgit2/src/streams/openssl.h

@@ -13,11 +13,115 @@
 
 extern int git_openssl_stream_global_init(void);
 
-#ifdef GIT_OPENSSL
+extern int git_openssl_stream_new(git_stream **out, const char *host, const char *port);
+
 extern int git_openssl__set_cert_location(const char *file, const char *path);
 
-extern int git_openssl_stream_new(git_stream **out, const char *host, const char *port);
-extern int git_openssl_stream_wrap(git_stream **out, git_stream *in, const char *host);
-#endif
+/*
+ * OpenSSL 1.1 made BIO opaque so we have to use functions to interact with it
+ * which do not exist in previous versions. We define these inline functions so
+ * we can program against the interface instead of littering the implementation
+ * with ifdefs.
+ */
+#ifdef GIT_OPENSSL
+# include <openssl/ssl.h>
+# include <openssl/err.h>
+# include <openssl/x509v3.h>
+# include <openssl/bio.h>
+
+
+
+# if OPENSSL_VERSION_NUMBER < 0x10100000L || \
+     (defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x20700000L)
+
+GIT_INLINE(BIO_METHOD*) BIO_meth_new(int type, const char *name)
+{
+	BIO_METHOD *meth = git__calloc(1, sizeof(BIO_METHOD));
+	if (!meth) {
+		return NULL;
+	}
+
+	meth->type = type;
+	meth->name = name;
+
+	return meth;
+}
+
+GIT_INLINE(void) BIO_meth_free(BIO_METHOD *biom)
+{
+	git__free(biom);
+}
+
+GIT_INLINE(int) BIO_meth_set_write(BIO_METHOD *biom, int (*write) (BIO *, const char *, int))
+{
+	biom->bwrite = write;
+	return 1;
+}
+
+GIT_INLINE(int) BIO_meth_set_read(BIO_METHOD *biom, int (*read) (BIO *, char *, int))
+{
+	biom->bread = read;
+	return 1;
+}
+
+GIT_INLINE(int) BIO_meth_set_puts(BIO_METHOD *biom, int (*puts) (BIO *, const char *))
+{
+	biom->bputs = puts;
+	return 1;
+}
+
+GIT_INLINE(int) BIO_meth_set_gets(BIO_METHOD *biom, int (*gets) (BIO *, char *, int))
+
+{
+	biom->bgets = gets;
+	return 1;
+}
+
+GIT_INLINE(int) BIO_meth_set_ctrl(BIO_METHOD *biom, long (*ctrl) (BIO *, int, long, void *))
+{
+	biom->ctrl = ctrl;
+	return 1;
+}
+
+GIT_INLINE(int) BIO_meth_set_create(BIO_METHOD *biom, int (*create) (BIO *))
+{
+	biom->create = create;
+	return 1;
+}
+
+GIT_INLINE(int) BIO_meth_set_destroy(BIO_METHOD *biom, int (*destroy) (BIO *))
+{
+	biom->destroy = destroy;
+	return 1;
+}
+
+GIT_INLINE(int) BIO_get_new_index(void)
+{
+	/* This exists as of 1.1 so before we'd just have 0 */
+	return 0;
+}
+
+GIT_INLINE(void) BIO_set_init(BIO *b, int init)
+{
+	b->init = init;
+}
+
+GIT_INLINE(void) BIO_set_data(BIO *a, void *ptr)
+{
+	a->ptr = ptr;
+}
+
+GIT_INLINE(void*) BIO_get_data(BIO *a)
+{
+	return a->ptr;
+}
+
+GIT_INLINE(const unsigned char *) ASN1_STRING_get0_data(const ASN1_STRING *x)
+{
+	return ASN1_STRING_data((ASN1_STRING *)x);
+}
+
+# endif // OpenSSL < 1.1
+#endif // GIT_OPENSSL
 
 #endif

data/vendor/libgit2/src/streams/socket.c

@@ -9,7 +9,6 @@
 
 #include "posix.h"
 #include "netops.h"
-#include "registry.h"
 #include "stream.h"
 
 #ifndef _WIN32
@@ -35,16 +34,16 @@ static void net_set_error(const char *str)
 	char * win32_error = git_win32_get_error_message(error);
 
 	if (win32_error) {
-		git_error_set(GIT_ERROR_NET, "%s: %s", str, win32_error);
+		giterr_set(GITERR_NET, "%s: %s", str, win32_error);
 		git__free(win32_error);
 	} else {
-		git_error_set(GIT_ERROR_NET, "%s", str);
+		giterr_set(GITERR_NET, str);
 	}
 }
 #else
 static void net_set_error(const char *str)
 {
-	git_error_set(GIT_ERROR_NET, "%s: %s", str, strerror(errno));
+	giterr_set(GITERR_NET, "%s: %s", str, strerror(errno));
 }
 #endif
 
@@ -58,7 +57,7 @@ static int close_socket(GIT_SOCKET s)
 		return -1;
 
 	if (0 != WSACleanup()) {
-		git_error_set(GIT_ERROR_OS, "winsock cleanup failed");
+		giterr_set(GITERR_OS, "winsock cleanup failed");
 		return -1;
 	}
 
@@ -69,7 +68,7 @@ static int close_socket(GIT_SOCKET s)
 
 }
 
-static int socket_connect(git_stream *stream)
+int socket_connect(git_stream *stream)
 {
 	struct addrinfo *info = NULL, *p;
 	struct addrinfo hints;
@@ -83,13 +82,13 @@ static int socket_connect(git_stream *stream)
 	WSADATA wsd;
 
 	if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) {
-		git_error_set(GIT_ERROR_OS, "winsock init failed");
+		giterr_set(GITERR_OS, "winsock init failed");
 		return -1;
 	}
 
 	if (LOBYTE(wsd.wVersion) != 2 || HIBYTE(wsd.wVersion) != 2) {
 		WSACleanup();
-		git_error_set(GIT_ERROR_OS, "winsock init failed");
+		giterr_set(GITERR_OS, "winsock init failed");
 		return -1;
 	}
 #endif
@@ -99,7 +98,7 @@ static int socket_connect(git_stream *stream)
 	hints.ai_family = AF_UNSPEC;
 
 	if ((ret = p_getaddrinfo(st->host, st->port, &hints, &info)) != 0) {
-		git_error_set(GIT_ERROR_NET,
+		giterr_set(GITERR_NET,
 			   "failed to resolve address for %s: %s", st->host, p_gai_strerror(ret));
 		return -1;
 	}
@@ -120,7 +119,7 @@ static int socket_connect(git_stream *stream)
 
 	/* Oops, we couldn't connect to any address */
 	if (s == INVALID_SOCKET && p == NULL) {
-		git_error_set(GIT_ERROR_OS, "failed to connect to %s", st->host);
+		giterr_set(GITERR_OS, "failed to connect to %s", st->host);
 		p_freeaddrinfo(info);
 		return -1;
 	}
@@ -130,33 +129,38 @@ static int socket_connect(git_stream *stream)
 	return 0;
 }
 
-static ssize_t socket_write(git_stream *stream, const char *data, size_t len, int flags)
+ssize_t socket_write(git_stream *stream, const char *data, size_t len, int flags)
 {
+	ssize_t ret;
+	size_t off = 0;
 	git_socket_stream *st = (git_socket_stream *) stream;
-	ssize_t written;
 
-	errno = 0;
+	while (off < len) {
+		errno = 0;
+		ret = p_send(st->s, data + off, len - off, flags);
+		if (ret < 0) {
+			net_set_error("Error sending data");
+			return -1;
+		}
 
-	if ((written = p_send(st->s, data, len, flags)) < 0) {
-		net_set_error("error sending data");
-		return -1;
+		off += ret;
 	}
 
-	return written;
+	return off;
 }
 
-static ssize_t socket_read(git_stream *stream, void *data, size_t len)
+ssize_t socket_read(git_stream *stream, void *data, size_t len)
 {
 	ssize_t ret;
 	git_socket_stream *st = (git_socket_stream *) stream;
 
 	if ((ret = p_recv(st->s, data, len, 0)) < 0)
-		net_set_error("error receiving socket data");
+		net_set_error("Error receiving socket data");
 
 	return ret;
 }
 
-static int socket_close(git_stream *stream)
+int socket_close(git_stream *stream)
 {
 	git_socket_stream *st = (git_socket_stream *) stream;
 	int error;
@@ -167,7 +171,7 @@ static int socket_close(git_stream *stream)
 	return error;
 }
 
-static void socket_free(git_stream *stream)
+void socket_free(git_stream *stream)
 {
 	git_socket_stream *st = (git_socket_stream *) stream;
 
@@ -176,24 +180,21 @@ static void socket_free(git_stream *stream)
 	git__free(st);
 }
 
-static int default_socket_stream_new(
-	git_stream **out,
-	const char *host,
-	const char *port)
+int git_socket_stream_new(git_stream **out, const char *host, const char *port)
 {
 	git_socket_stream *st;
 
-	assert(out && host && port);
+	assert(out && host);
 
 	st = git__calloc(1, sizeof(git_socket_stream));
-	GIT_ERROR_CHECK_ALLOC(st);
+	GITERR_CHECK_ALLOC(st);
 
 	st->host = git__strdup(host);
-	GIT_ERROR_CHECK_ALLOC(st->host);
+	GITERR_CHECK_ALLOC(st->host);
 
 	if (port) {
 		st->port = git__strdup(port);
-		GIT_ERROR_CHECK_ALLOC(st->port);
+		GITERR_CHECK_ALLOC(st->port);
 	}
 
 	st->parent.version = GIT_STREAM_VERSION;
@@ -207,29 +208,3 @@ static int default_socket_stream_new(
 	*out = (git_stream *) st;
 	return 0;
 }
-
-int git_socket_stream_new(
-	git_stream **out,
-	const char *host,
-	const char *port)
-{
-	int (*init)(git_stream **, const char *, const char *) = NULL;
-	git_stream_registration custom = {0};
-	int error;
-
-	assert(out && host && port);
-
-	if ((error = git_stream_registry_lookup(&custom, GIT_STREAM_STANDARD)) == 0)
-		init = custom.init;
-	else if (error == GIT_ENOTFOUND)
-		init = default_socket_stream_new;
-	else
-		return error;
-
-	if (!init) {
-		git_error_set(GIT_ERROR_NET, "there is no socket stream available");
-		return -1;
-	}
-
-	return init(out, host, port);
-}

data/vendor/libgit2/src/streams/stransport.c

@@ -16,25 +16,26 @@
 #include "git2/transport.h"
 
 #include "streams/socket.h"
+#include "streams/curl.h"
 
 static int stransport_error(OSStatus ret)
 {
 	CFStringRef message;
 
 	if (ret == noErr || ret == errSSLClosedGraceful) {
-		git_error_clear();
+		giterr_clear();
 		return 0;
 	}
 
 #if !TARGET_OS_IPHONE
 	message = SecCopyErrorMessageString(ret, NULL);
-	GIT_ERROR_CHECK_ALLOC(message);
+	GITERR_CHECK_ALLOC(message);
 
-	git_error_set(GIT_ERROR_NET, "SecureTransport error: %s", CFStringGetCStringPtr(message, kCFStringEncodingUTF8));
+	giterr_set(GITERR_NET, "SecureTransport error: %s", CFStringGetCStringPtr(message, kCFStringEncodingUTF8));
 	CFRelease(message);
 #else
-	git_error_set(GIT_ERROR_NET, "SecureTransport error: OSStatus %d", (unsigned int)ret);
-	GIT_UNUSED(message);
+    giterr_set(GITERR_NET, "SecureTransport error: OSStatus %d", (unsigned int)ret);
+    GIT_UNUSED(message);
 #endif
 
 	return -1;
@@ -43,7 +44,6 @@ static int stransport_error(OSStatus ret)
 typedef struct {
 	git_stream parent;
 	git_stream *io;
-	int owned;
 	SSLContextRef ctx;
 	CFDataRef der_data;
 	git_cert_x509 cert_info;
@@ -57,12 +57,12 @@ static int stransport_connect(git_stream *stream)
 	SecTrustResultType sec_res;
 	OSStatus ret;
 
-	if (st->owned && (error = git_stream_connect(st->io)) < 0)
+	if ((error = git_stream_connect(st->io)) < 0)
 		return error;
 
 	ret = SSLHandshake(st->ctx);
 	if (ret != errSSLServerAuthCompleted) {
-		git_error_set(GIT_ERROR_SSL, "unexpected return value from ssl handshake %d", (int)ret);
+		giterr_set(GITERR_SSL, "unexpected return value from ssl handshake %d", ret);
 		return -1;
 	}
 
@@ -78,13 +78,13 @@ static int stransport_connect(git_stream *stream)
 	CFRelease(trust);
 
 	if (sec_res == kSecTrustResultInvalid || sec_res == kSecTrustResultOtherError) {
-		git_error_set(GIT_ERROR_SSL, "internal security trust error");
+		giterr_set(GITERR_SSL, "internal security trust error");
 		return -1;
 	}
 
 	if (sec_res == kSecTrustResultDeny || sec_res == kSecTrustResultRecoverableTrustFailure ||
 	    sec_res == kSecTrustResultFatalTrustFailure) {
-		git_error_set(GIT_ERROR_SSL, "untrusted connection error");
+		giterr_set(GITERR_SSL, "untrusted connection error");
 		return GIT_ECERTIFICATE;
 	}
 
@@ -112,7 +112,7 @@ static int stransport_certificate(git_cert **out, git_stream *stream)
 	CFRelease(trust);
 
 	if (st->der_data == NULL) {
-		git_error_set(GIT_ERROR_SSL, "retrieved invalid certificate data");
+		giterr_set(GITERR_SSL, "retrieved invalid certificate data");
 		return -1;
 	}
 
@@ -149,8 +149,9 @@ static OSStatus write_cb(SSLConnectionRef conn, const void *data, size_t *len)
 {
 	git_stream *io = (git_stream *) conn;
 
-	if (git_stream__write_full(io, data, *len, 0) < 0)
+	if (git_stream_write(io, data, *len, 0) < 0) {
 		return -36; /* "ioErr" from MacErrors.h which is not available on iOS */
+	}
 
 	return noErr;
 }
@@ -163,12 +164,11 @@ static ssize_t stransport_write(git_stream *stream, const char *data, size_t len
 
 	GIT_UNUSED(flags);
 
-	data_len = min(len, SSIZE_MAX);
+	data_len = len;
 	if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr)
 		return stransport_error(ret);
 
-	assert(processed < SSIZE_MAX);
-	return (ssize_t)processed;
+	return processed;
 }
 
 /*
@@ -226,42 +226,45 @@ static int stransport_close(git_stream *stream)
 	if (ret != noErr && ret != errSSLClosedGraceful)
 		return stransport_error(ret);
 
-	return st->owned ? git_stream_close(st->io) : 0;
+	return git_stream_close(st->io);
 }
 
 static void stransport_free(git_stream *stream)
 {
 	stransport_stream *st = (stransport_stream *) stream;
 
-	if (st->owned)
-		git_stream_free(st->io);
-
+	git_stream_free(st->io);
 	CFRelease(st->ctx);
 	if (st->der_data)
 		CFRelease(st->der_data);
 	git__free(st);
 }
 
-static int stransport_wrap(
-	git_stream **out,
-	git_stream *in,
-	const char *host,
-	int owned)
+int git_stransport_stream_new(git_stream **out, const char *host, const char *port)
 {
 	stransport_stream *st;
+	int error;
 	OSStatus ret;
 
-	assert(out && in && host);
+	assert(out && host);
 
 	st = git__calloc(1, sizeof(stransport_stream));
-	GIT_ERROR_CHECK_ALLOC(st);
+	GITERR_CHECK_ALLOC(st);
+
+#ifdef GIT_CURL
+	error = git_curl_stream_new(&st->io, host, port);
+#else
+	error = git_socket_stream_new(&st->io, host, port);
+#endif
 
-	st->io = in;
-	st->owned = owned;
+	if (error < 0){
+		git__free(st);
+		return error;
+	}
 
 	st->ctx = SSLCreateContext(NULL, kSSLClientSide, kSSLStreamType);
 	if (!st->ctx) {
-		git_error_set(GIT_ERROR_NET, "failed to create SSL context");
+		giterr_set(GITERR_NET, "failed to create SSL context");
 		git__free(st);
 		return -1;
 	}
@@ -292,32 +295,4 @@ static int stransport_wrap(
 	return 0;
 }
 
-int git_stransport_stream_wrap(
-	git_stream **out,
-	git_stream *in,
-	const char *host)
-{
-	return stransport_wrap(out, in, host, 0);
-}
-
-int git_stransport_stream_new(git_stream **out, const char *host, const char *port)
-{
-	git_stream *stream = NULL;
-	int error;
-
-	assert(out && host);
-
-	error = git_socket_stream_new(&stream, host, port);
-
-	if (!error)
-		error = stransport_wrap(out, stream, host, 1);
-
-	if (error < 0 && stream) {
-		git_stream_close(stream);
-		git_stream_free(stream);
-	}
-
-	return error;
-}
-
 #endif