rugged 1.6.3 → 1.9.0

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

@@ -0,0 +1,28 @@
+/*
+ * 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.
+ */
+#ifndef INCLUDE_steams_schannel_h__
+#define INCLUDE_steams_schannel_h__
+
+#include "common.h"
+
+#include "git2/sys/stream.h"
+
+#ifdef GIT_SCHANNEL
+
+extern int git_schannel_stream_new(
+	git_stream **out,
+	const char *host,
+	const char *port);
+
+extern int git_schannel_stream_wrap(
+	git_stream **out,
+	git_stream *in,
+	const char *host);
+
+#endif
+
+#endif

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

@@ -8,26 +8,29 @@
 #include "streams/socket.h"
 
 #include "posix.h"
-#include "netops.h"
 #include "registry.h"
+#include "runtime.h"
 #include "stream.h"
 
 #ifndef _WIN32
-#	include <sys/types.h>
-#	include <sys/socket.h>
-#	include <sys/select.h>
-#	include <sys/time.h>
-#	include <netdb.h>
-#	include <netinet/in.h>
-#       include <arpa/inet.h>
+# include <sys/types.h>
+# include <sys/socket.h>
+# include <sys/select.h>
+# include <sys/time.h>
+# include <netdb.h>
+# include <netinet/in.h>
+# include <arpa/inet.h>
 #else
-#	include <winsock2.h>
-#	include <ws2tcpip.h>
-#	ifdef _MSC_VER
-#		pragma comment(lib, "ws2_32")
-#	endif
+# include <winsock2.h>
+# include <ws2tcpip.h>
+# ifdef _MSC_VER
+#  pragma comment(lib, "ws2_32")
+# endif
 #endif
 
+int git_socket_stream__connect_timeout = 0;
+int git_socket_stream__timeout = 0;
+
 #ifdef GIT_WIN32
 static void net_set_error(const char *str)
 {
@@ -54,11 +57,8 @@ static int close_socket(GIT_SOCKET s)
 		return 0;
 
 #ifdef GIT_WIN32
-	if (SOCKET_ERROR == closesocket(s))
-		return -1;
-
-	if (0 != WSACleanup()) {
-		git_error_set(GIT_ERROR_OS, "winsock cleanup failed");
+	if (closesocket(s) != 0) {
+		net_set_error("could not close socket");
 		return -1;
 	}
 
@@ -69,38 +69,119 @@ static int close_socket(GIT_SOCKET s)
 
 }
 
-static int socket_connect(git_stream *stream)
+static int set_nonblocking(GIT_SOCKET s)
 {
-	struct addrinfo *info = NULL, *p;
-	struct addrinfo hints;
-	git_socket_stream *st = (git_socket_stream *) stream;
-	GIT_SOCKET s = INVALID_SOCKET;
-	int ret;
-
 #ifdef GIT_WIN32
-	/* on win32, the WSA context needs to be initialized
-	 * before any socket calls can be performed */
-	WSADATA wsd;
+	unsigned long nonblocking = 1;
 
-	if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) {
-		git_error_set(GIT_ERROR_OS, "winsock init failed");
+	if (ioctlsocket(s, FIONBIO, &nonblocking) != 0) {
+		net_set_error("could not set socket non-blocking");
 		return -1;
 	}
+#else
+	int flags;
+
+	if ((flags = fcntl(s, F_GETFL, 0)) == -1) {
+		net_set_error("could not query socket flags");
+		return -1;
+	}
+
+	flags |= O_NONBLOCK;
 
-	if (LOBYTE(wsd.wVersion) != 2 || HIBYTE(wsd.wVersion) != 2) {
-		WSACleanup();
-		git_error_set(GIT_ERROR_OS, "winsock init failed");
+	if (fcntl(s, F_SETFL, flags) != 0) {
+		net_set_error("could not set socket non-blocking");
 		return -1;
 	}
 #endif
 
+	return 0;
+}
+
+/* Promote a sockerr to an errno for our error handling routines */
+static int handle_sockerr(GIT_SOCKET socket)
+{
+	int sockerr;
+	socklen_t errlen = sizeof(sockerr);
+
+	if (getsockopt(socket, SOL_SOCKET, SO_ERROR,
+			(void *)&sockerr, &errlen) < 0)
+		return -1;
+
+	if (sockerr == ETIMEDOUT)
+		return GIT_TIMEOUT;
+
+	errno = sockerr;
+	return -1;
+}
+
+GIT_INLINE(bool) connect_would_block(int error)
+{
+#ifdef GIT_WIN32
+	if (error == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
+		return true;
+#endif
+
+	if (error == -1 && errno == EINPROGRESS)
+		return true;
+
+	return false;
+}
+
+static int connect_with_timeout(
+	GIT_SOCKET socket,
+	const struct sockaddr *address,
+	socklen_t address_len,
+	int timeout)
+{
+	struct pollfd fd;
+	int error;
+
+	if (timeout && (error = set_nonblocking(socket)) < 0)
+		return error;
+
+	error = connect(socket, address, address_len);
+
+	if (error == 0 || !connect_would_block(error))
+		return error;
+
+	fd.fd = socket;
+	fd.events = POLLOUT;
+	fd.revents = 0;
+
+	error = p_poll(&fd, 1, timeout);
+
+	if (error == 0) {
+		return GIT_TIMEOUT;
+	} else if (error != 1) {
+		return -1;
+	} else if ((fd.revents & (POLLPRI | POLLHUP | POLLERR))) {
+		return handle_sockerr(socket);
+	} else if ((fd.revents & POLLOUT) != POLLOUT) {
+		git_error_set(GIT_ERROR_NET,
+			"unknown error while polling for connect: %d",
+			fd.revents);
+		return -1;
+	}
+
+	return 0;
+}
+
+static int socket_connect(git_stream *stream)
+{
+	git_socket_stream *st = (git_socket_stream *) stream;
+	GIT_SOCKET s = INVALID_SOCKET;
+	struct addrinfo *info = NULL, *p;
+	struct addrinfo hints;
+	int error;
+
 	memset(&hints, 0x0, sizeof(struct addrinfo));
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_family = AF_UNSPEC;
 
-	if ((ret = p_getaddrinfo(st->host, st->port, &hints, &info)) != 0) {
+	if ((error = p_getaddrinfo(st->host, st->port, &hints, &info)) != 0) {
 		git_error_set(GIT_ERROR_NET,
-			   "failed to resolve address for %s: %s", st->host, p_gai_strerror(ret));
+			   "failed to resolve address for %s: %s",
+			   st->host, p_gai_strerror(error));
 		return -1;
 	}
 
@@ -110,51 +191,115 @@ static int socket_connect(git_stream *stream)
 		if (s == INVALID_SOCKET)
 			continue;
 
-		if (connect(s, p->ai_addr, (socklen_t)p->ai_addrlen) == 0)
+		error = connect_with_timeout(s, p->ai_addr,
+				(socklen_t)p->ai_addrlen,
+				st->parent.connect_timeout);
+
+		if (error == 0)
 			break;
 
 		/* If we can't connect, try the next one */
 		close_socket(s);
 		s = INVALID_SOCKET;
+
+		if (error == GIT_TIMEOUT)
+			break;
 	}
 
 	/* 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);
-		p_freeaddrinfo(info);
-		return -1;
+	if (s == INVALID_SOCKET) {
+		if (error == GIT_TIMEOUT)
+			git_error_set(GIT_ERROR_NET, "failed to connect to %s: Operation timed out", st->host);
+		else
+			git_error_set(GIT_ERROR_OS, "failed to connect to %s", st->host);
+		error = -1;
+		goto done;
 	}
 
+	if (st->parent.timeout && !st->parent.connect_timeout &&
+	    (error = set_nonblocking(s)) < 0)
+		return error;
+
 	st->s = s;
+	error = 0;
+
+done:
 	p_freeaddrinfo(info);
-	return 0;
+	return error;
 }
 
-static ssize_t socket_write(git_stream *stream, const char *data, size_t len, int flags)
+static ssize_t socket_write(
+	git_stream *stream,
+	const char *data,
+	size_t len,
+	int flags)
 {
 	git_socket_stream *st = (git_socket_stream *) stream;
-	ssize_t written;
+	struct pollfd fd;
+	ssize_t ret;
 
 	GIT_ASSERT(flags == 0);
 	GIT_UNUSED(flags);
 
-	errno = 0;
+	ret = p_send(st->s, data, len, 0);
 
-	if ((written = p_send(st->s, data, len, 0)) < 0) {
-		net_set_error("error sending data");
+	if (st->parent.timeout && ret < 0 &&
+	    (errno == EAGAIN || errno != EWOULDBLOCK)) {
+		fd.fd = st->s;
+		fd.events = POLLOUT;
+		fd.revents = 0;
+
+		ret = p_poll(&fd, 1, st->parent.timeout);
+
+		if (ret == 1) {
+			ret = p_send(st->s, data, len, 0);
+		} else if (ret == 0) {
+			git_error_set(GIT_ERROR_NET,
+				"could not write to socket: timed out");
+			return GIT_TIMEOUT;
+		}
+	}
+
+	if (ret < 0) {
+		net_set_error("error receiving data from socket");
 		return -1;
 	}
 
-	return written;
+	return ret;
 }
 
-static ssize_t socket_read(git_stream *stream, void *data, size_t len)
+static ssize_t socket_read(
+	git_stream *stream,
+	void *data,
+	size_t len)
 {
-	ssize_t ret;
 	git_socket_stream *st = (git_socket_stream *) stream;
+	struct pollfd fd;
+	ssize_t ret;
 
-	if ((ret = p_recv(st->s, data, len, 0)) < 0)
-		net_set_error("error receiving socket data");
+	ret = p_recv(st->s, data, len, 0);
+
+	if (st->parent.timeout && ret < 0 &&
+	    (errno == EAGAIN || errno != EWOULDBLOCK)) {
+		fd.fd = st->s;
+		fd.events = POLLIN;
+		fd.revents = 0;
+
+		ret = p_poll(&fd, 1, st->parent.timeout);
+
+		if (ret == 1) {
+			ret = p_recv(st->s, data, len, 0);
+		} else if (ret == 0) {
+			git_error_set(GIT_ERROR_NET,
+				"could not read from socket: timed out");
+			return GIT_TIMEOUT;
+		}
+	}
+
+	if (ret < 0) {
+		net_set_error("error receiving data from socket");
+		return -1;
+	}
 
 	return ret;
 }
@@ -202,6 +347,8 @@ static int default_socket_stream_new(
 	}
 
 	st->parent.version = GIT_STREAM_VERSION;
+	st->parent.timeout = git_socket_stream__timeout;
+	st->parent.connect_timeout = git_socket_stream__connect_timeout;
 	st->parent.connect = socket_connect;
 	st->parent.write = socket_write;
 	st->parent.read = socket_read;
@@ -240,3 +387,42 @@ int git_socket_stream_new(
 
 	return init(out, host, port);
 }
+
+#ifdef GIT_WIN32
+
+static void socket_stream_global_shutdown(void)
+{
+	WSACleanup();
+}
+
+int git_socket_stream_global_init(void)
+{
+	WORD winsock_version;
+	WSADATA wsa_data;
+
+	winsock_version = MAKEWORD(2, 2);
+
+	if (WSAStartup(winsock_version, &wsa_data) != 0) {
+		git_error_set(GIT_ERROR_OS, "could not initialize Windows Socket Library");
+		return -1;
+	}
+
+	if (LOBYTE(wsa_data.wVersion) != 2 ||
+	    HIBYTE(wsa_data.wVersion) != 2) {
+		git_error_set(GIT_ERROR_SSL, "Windows Socket Library does not support Winsock 2.2");
+		return -1;
+	}
+
+	return git_runtime_shutdown_register(socket_stream_global_shutdown);
+}
+
+#else
+
+#include "stream.h"
+
+int git_socket_stream_global_init(void)
+{
+	return 0;
+}
+
+ #endif

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

@@ -9,7 +9,7 @@
 
 #include "common.h"
 
-#include "netops.h"
+#include "stream.h"
 
 typedef struct {
 	git_stream parent;
@@ -20,4 +20,6 @@ typedef struct {
 
 extern int git_socket_stream_new(git_stream **out, const char *host, const char *port);
 
+extern int git_socket_stream_global_init(void);
+
 #endif

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

@@ -13,13 +13,16 @@
 #include <Security/SecureTransport.h>
 #include <Security/SecCertificate.h>
 
+#include "common.h"
+#include "trace.h"
 #include "git2/transport.h"
-
 #include "streams/socket.h"
 
 static int stransport_error(OSStatus ret)
 {
-	CFStringRef message;
+	CFStringRef message_ref = NULL;
+	const char *message_cstr = NULL;
+	char *message_ptr = NULL;
 
 	if (ret == noErr || ret == errSSLClosedGraceful) {
 		git_error_clear();
@@ -27,14 +30,39 @@ static int stransport_error(OSStatus ret)
 	}
 
 #if !TARGET_OS_IPHONE
-	message = SecCopyErrorMessageString(ret, NULL);
-	GIT_ERROR_CHECK_ALLOC(message);
+	message_ref = SecCopyErrorMessageString(ret, NULL);
+	GIT_ERROR_CHECK_ALLOC(message_ref);
+
+	/*
+	 * Attempt the cheap CFString conversion; this can return NULL
+	 * when that would be expensive. In that case, call the more
+	 * expensive function.
+	 */
+	message_cstr = CFStringGetCStringPtr(message_ref, kCFStringEncodingUTF8);
+
+	if (!message_cstr) {
+		/* Provide buffer to convert from UTF16 to UTF8 */
+		size_t message_size = CFStringGetLength(message_ref) * 2 + 1;
+
+		message_cstr = message_ptr = git__malloc(message_size);
+		GIT_ERROR_CHECK_ALLOC(message_ptr);
+
+		if (!CFStringGetCString(message_ref, message_ptr, message_size, kCFStringEncodingUTF8)) {
+			git_error_set(GIT_ERROR_NET, "SecureTransport error: %d", (unsigned int)ret);
+			goto done;
+		}
+	}
 
-	git_error_set(GIT_ERROR_NET, "SecureTransport error: %s", CFStringGetCStringPtr(message, kCFStringEncodingUTF8));
-	CFRelease(message);
+	git_error_set(GIT_ERROR_NET, "SecureTransport error: %s", message_cstr);
+
+done:
+	git__free(message_ptr);
+	CFRelease(message_ref);
 #else
 	git_error_set(GIT_ERROR_NET, "SecureTransport error: OSStatus %d", (unsigned int)ret);
-	GIT_UNUSED(message);
+	GIT_UNUSED(message_ref);
+	GIT_UNUSED(message_cstr);
+	GIT_UNUSED(message_ptr);
 #endif
 
 	return -1;
@@ -44,6 +72,7 @@ typedef struct {
 	git_stream parent;
 	git_stream *io;
 	int owned;
+	int error;
 	SSLContextRef ctx;
 	CFDataRef der_data;
 	git_cert_x509 cert_info;
@@ -61,7 +90,10 @@ static int stransport_connect(git_stream *stream)
 		return error;
 
 	ret = SSLHandshake(st->ctx);
-	if (ret != errSSLServerAuthCompleted) {
+
+	if (ret != errSSLServerAuthCompleted && st->error != 0)
+		return -1;
+	else if (ret != errSSLServerAuthCompleted) {
 		git_error_set(GIT_ERROR_SSL, "unexpected return value from ssl handshake %d", (int)ret);
 		return -1;
 	}
@@ -147,10 +179,20 @@ static int stransport_set_proxy(
  */
 static OSStatus write_cb(SSLConnectionRef conn, const void *data, size_t *len)
 {
-	git_stream *io = (git_stream *) conn;
+	stransport_stream *st = (stransport_stream *)conn;
+	git_stream *io = st->io;
+	OSStatus ret;
+
+	st->error = 0;
+
+	ret = git_stream__write_full(io, data, *len, 0);
 
-	if (git_stream__write_full(io, data, *len, 0) < 0)
-		return -36; /* "ioErr" from MacErrors.h which is not available on iOS */
+	if (ret < 0) {
+		st->error = ret;
+		return (ret == GIT_TIMEOUT) ?
+		       -9853 /* errSSLNetworkTimeout */:
+		       -36 /* ioErr */;
+	}
 
 	return noErr;
 }
@@ -164,8 +206,12 @@ static ssize_t stransport_write(git_stream *stream, const char *data, size_t len
 	GIT_UNUSED(flags);
 
 	data_len = min(len, SSIZE_MAX);
-	if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr)
+	if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr) {
+		if (st->error == GIT_TIMEOUT)
+			return GIT_TIMEOUT;
+
 		return stransport_error(ret);
+	}
 
 	GIT_ASSERT(processed < SSIZE_MAX);
 	return (ssize_t)processed;
@@ -182,18 +228,24 @@ static ssize_t stransport_write(git_stream *stream, const char *data, size_t len
  */
 static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len)
 {
-	git_stream *io = (git_stream *) conn;
+	stransport_stream *st = (stransport_stream *)conn;
+	git_stream *io = st->io;
 	OSStatus error = noErr;
 	size_t off = 0;
 	ssize_t ret;
 
+	st->error = 0;
+
 	do {
 		ret = git_stream_read(io, data + off, *len - off);
+
 		if (ret < 0) {
-			error = -36; /* "ioErr" from MacErrors.h which is not available on iOS */
+			st->error = ret;
+			error = (ret == GIT_TIMEOUT) ?
+			        -9853 /* errSSLNetworkTimeout */:
+			        -36 /* ioErr */;
 			break;
-		}
-		if (ret == 0) {
+		} else if (ret == 0) {
 			error = errSSLClosedGraceful;
 			break;
 		}
@@ -207,12 +259,20 @@ static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len)
 
 static ssize_t stransport_read(git_stream *stream, void *data, size_t len)
 {
-	stransport_stream *st = (stransport_stream *) stream;
+	stransport_stream *st = (stransport_stream *)stream;
 	size_t processed;
 	OSStatus ret;
 
-	if ((ret = SSLRead(st->ctx, data, len, &processed)) != noErr)
+	if ((ret = SSLRead(st->ctx, data, len, &processed)) != noErr) {
+		/* This specific SecureTransport error is not well described */
+		if (ret == -9806)
+			git_trace(GIT_TRACE_INFO, "SecureTraceport error during SSLRead: returned -9806 (connection closed via error)");
+
+		if (st->error == GIT_TIMEOUT)
+			return GIT_TIMEOUT;
+
 		return stransport_error(ret);
+	}
 
 	return processed;
 }
@@ -269,7 +329,7 @@ static int stransport_wrap(
 	}
 
 	if ((ret = SSLSetIOFuncs(st->ctx, read_cb, write_cb)) != noErr ||
-	    (ret = SSLSetConnection(st->ctx, st->io)) != noErr ||
+	    (ret = SSLSetConnection(st->ctx, st)) != noErr ||
 	    (ret = SSLSetSessionOption(st->ctx, kSSLSessionOptionBreakOnServerAuth, true)) != noErr ||
 	    (ret = SSLSetProtocolVersionMin(st->ctx, kTLSProtocol1)) != noErr ||
 	    (ret = SSLSetProtocolVersionMax(st->ctx, kTLSProtocol12)) != noErr ||

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

@@ -13,6 +13,7 @@
 #include "streams/mbedtls.h"
 #include "streams/openssl.h"
 #include "streams/stransport.h"
+#include "streams/schannel.h"
 
 int git_tls_stream_new(git_stream **out, const char *host, const char *port)
 {
@@ -33,6 +34,8 @@ int git_tls_stream_new(git_stream **out, const char *host, const char *port)
 		init = git_openssl_stream_new;
 #elif defined(GIT_MBEDTLS)
 		init = git_mbedtls_stream_new;
+#elif defined(GIT_SCHANNEL)
+		init = git_schannel_stream_new;
 #endif
 	} else {
 		return error;
@@ -63,6 +66,8 @@ int git_tls_stream_wrap(git_stream **out, git_stream *in, const char *host)
 		wrap = git_openssl_stream_wrap;
 #elif defined(GIT_MBEDTLS)
 		wrap = git_mbedtls_stream_wrap;
+#elif defined(GIT_SCHANNEL)
+		wrap = git_schannel_stream_wrap;
 #endif
 	}