rugged 0.17.0.b7 → 0.18.0.b1

data/vendor/libgit2/src/merge.h

@@ -0,0 +1,22 @@
+/*
+ * 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_merge_h__
+#define INCLUDE_merge_h__
+
+#include "git2/types.h"
+#include "git2/merge.h"
+#include "commit_list.h"
+#include "vector.h"
+
+#define GIT_MERGE_MSG_FILE		"MERGE_MSG"
+#define GIT_MERGE_MODE_FILE		"MERGE_MODE"
+
+#define MERGE_CONFIG_FILE_MODE	0666
+
+int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_list_node *one, git_vector *twos);
+
+#endif

data/vendor/libgit2/src/message.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * 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.

data/vendor/libgit2/src/message.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * 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.

data/vendor/libgit2/src/mwindow.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * 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.
@@ -20,17 +20,8 @@
 #define DEFAULT_MAPPED_LIMIT \
 	((1024 * 1024) * (sizeof(void*) >= 8 ? 8192ULL : 256UL))
 
-/*
- * These are the global options for mmmap limits.
- * TODO: allow the user to change these
- */
-static struct {
-	size_t window_size;
-	size_t mapped_limit;
-} _mw_options = {
-	DEFAULT_WINDOW_SIZE,
-	DEFAULT_MAPPED_LIMIT,
-};
+size_t git_mwindow__window_size = DEFAULT_WINDOW_SIZE;
+size_t git_mwindow__mapped_limit = DEFAULT_MAPPED_LIMIT;
 
 /* Whenever you want to read or modify this, grab git__mwindow_mutex */
 static git_mwindow_ctl mem_ctl;
@@ -42,9 +33,12 @@ static git_mwindow_ctl mem_ctl;
 void git_mwindow_free_all(git_mwindow_file *mwf)
 {
 	git_mwindow_ctl *ctl = &mem_ctl;
-	unsigned int i;
+	size_t i;
 
-	git_mutex_lock(&git__mwindow_mutex);
+	if (git_mutex_lock(&git__mwindow_mutex)) {
+		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+		return;
+	}
 
 	/*
 	 * Remove these windows from the global list
@@ -121,7 +115,7 @@ static void git_mwindow_scan_lru(
 static int git_mwindow_close_lru(git_mwindow_file *mwf)
 {
 	git_mwindow_ctl *ctl = &mem_ctl;
-	unsigned int i;
+	size_t i;
 	git_mwindow *lru_w = NULL, *lru_l = NULL, **list = &mwf->windows;
 
 	/* FIXME: Does this give us any advantage? */
@@ -163,7 +157,7 @@ static git_mwindow *new_window(
 	git_off_t offset)
 {
 	git_mwindow_ctl *ctl = &mem_ctl;
-	size_t walign = _mw_options.window_size / 2;
+	size_t walign = git_mwindow__window_size / 2;
 	git_off_t len;
 	git_mwindow *w;
 
@@ -176,16 +170,16 @@ static git_mwindow *new_window(
 	w->offset = (offset / walign) * walign;
 
 	len = size - w->offset;
-	if (len > (git_off_t)_mw_options.window_size)
-		len = (git_off_t)_mw_options.window_size;
+	if (len > (git_off_t)git_mwindow__window_size)
+		len = (git_off_t)git_mwindow__window_size;
 
 	ctl->mapped += (size_t)len;
 
-	while (_mw_options.mapped_limit < ctl->mapped &&
+	while (git_mwindow__mapped_limit < ctl->mapped &&
 			git_mwindow_close_lru(mwf) == 0) /* nop */;
 
 	/*
-	 * We treat _mw_options.mapped_limit as a soft limit. If we can't find a
+	 * We treat `mapped_limit` as a soft limit. If we can't find a
 	 * window to close and are above the limit, we still mmap the new
 	 * window.
 	 */
@@ -221,7 +215,11 @@ unsigned char *git_mwindow_open(
 	git_mwindow_ctl *ctl = &mem_ctl;
 	git_mwindow *w = *cursor;
 
-	git_mutex_lock(&git__mwindow_mutex);
+	if (git_mutex_lock(&git__mwindow_mutex)) {
+		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+		return NULL;
+	}
+
 	if (!w || !(git_mwindow_contains(w, offset) && git_mwindow_contains(w, offset + extra))) {
 		if (w) {
 			w->inuse_cnt--;
@@ -269,7 +267,11 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	git_mwindow_ctl *ctl = &mem_ctl;
 	int ret;
 
-	git_mutex_lock(&git__mwindow_mutex);
+	if (git_mutex_lock(&git__mwindow_mutex)) {
+		giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+		return -1;
+	}
+
 	if (ctl->windowfiles.length == 0 &&
 	    git_vector_init(&ctl->windowfiles, 8, NULL) < 0) {
 		git_mutex_unlock(&git__mwindow_mutex);
@@ -282,31 +284,34 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
 	return ret;
 }
 
-int git_mwindow_file_deregister(git_mwindow_file *mwf)
+void git_mwindow_file_deregister(git_mwindow_file *mwf)
 {
 	git_mwindow_ctl *ctl = &mem_ctl;
 	git_mwindow_file *cur;
-	unsigned int i;
+	size_t i;
+
+	if (git_mutex_lock(&git__mwindow_mutex))
+		return;
 
-	git_mutex_lock(&git__mwindow_mutex);
 	git_vector_foreach(&ctl->windowfiles, i, cur) {
 		if (cur == mwf) {
 			git_vector_remove(&ctl->windowfiles, i);
 			git_mutex_unlock(&git__mwindow_mutex);
-			return 0;
+			return;
 		}
 	}
 	git_mutex_unlock(&git__mwindow_mutex);
-
-	giterr_set(GITERR_ODB, "Failed to find the memory window file to deregister");
-	return -1;
 }
 
 void git_mwindow_close(git_mwindow **window)
 {
 	git_mwindow *w = *window;
 	if (w) {
-		git_mutex_lock(&git__mwindow_mutex);
+		if (git_mutex_lock(&git__mwindow_mutex)) {
+			giterr_set(GITERR_THREAD, "unable to lock mwindow mutex");
+			return;
+		}
+
 		w->inuse_cnt--;
 		git_mutex_unlock(&git__mwindow_mutex);
 		*window = NULL;

data/vendor/libgit2/src/mwindow.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * 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.
@@ -39,7 +39,7 @@ int git_mwindow_contains(git_mwindow *win, git_off_t offset);
 void git_mwindow_free_all(git_mwindow_file *mwf);
 unsigned char *git_mwindow_open(git_mwindow_file *mwf, git_mwindow **cursor, git_off_t offset, size_t extra, unsigned int *left);
 int git_mwindow_file_register(git_mwindow_file *mwf);
-int git_mwindow_file_deregister(git_mwindow_file *mwf);
+void git_mwindow_file_deregister(git_mwindow_file *mwf);
 void git_mwindow_close(git_mwindow **w_cursor);
 
 #endif

data/vendor/libgit2/src/netops.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * 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.
@@ -10,16 +10,22 @@
 #	include <sys/select.h>
 #	include <sys/time.h>
 #	include <netdb.h>
+#	include <netinet/in.h>
 #       include <arpa/inet.h>
 #else
 #	include <ws2tcpip.h>
 #	ifdef _MSC_VER
-#		pragma comment(lib, "ws2_32.lib")
+#		pragma comment(lib, "ws2_32")
 #	endif
 #endif
 
+#ifdef __FreeBSD__
+#	include <netinet/in.h>
+#endif
+
 #ifdef GIT_SSL
 # include <openssl/ssl.h>
+# include <openssl/err.h>
 # include <openssl/x509v3.h>
 #endif
 
@@ -30,19 +36,19 @@
 #include "netops.h"
 #include "posix.h"
 #include "buffer.h"
-#include "transport.h"
 
 #ifdef GIT_WIN32
 static void net_set_error(const char *str)
 {
-	int size, error = WSAGetLastError();
-	LPSTR err_str = NULL;
-
-	size = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
-			     0, error, 0, (LPSTR)&err_str, 0, 0);
+	int error = WSAGetLastError();
+	char * win32_error = git_win32_get_error_message(error);
 
-	giterr_set(GITERR_NET, "%s: %s", str, err_str);
-	LocalFree(err_str);
+	if (win32_error) {
+		giterr_set(GITERR_NET, "%s: %s", str, win32_error);
+		git__free(win32_error);
+	} else {
+		giterr_set(GITERR_NET, str);
+	}
 }
 #else
 static void net_set_error(const char *str)
@@ -108,8 +114,8 @@ static int gitno__recv_ssl(gitno_buffer *buf)
 	int ret;
 
 	do {
-		ret = SSL_read(buf->ssl->ssl, buf->data + buf->offset, buf->len - buf->offset);
-	} while (SSL_get_error(buf->ssl->ssl, ret) == SSL_ERROR_WANT_READ);
+		ret = SSL_read(buf->socket->ssl.ssl, buf->data + buf->offset, buf->len - buf->offset);
+	} while (SSL_get_error(buf->socket->ssl.ssl, ret) == SSL_ERROR_WANT_READ);
 
 	if (ret < 0) {
 		net_set_error("Error receiving socket data");
@@ -121,11 +127,11 @@ static int gitno__recv_ssl(gitno_buffer *buf)
 }
 #endif
 
-int gitno__recv(gitno_buffer *buf)
+static int gitno__recv(gitno_buffer *buf)
 {
 	int ret;
 
-	ret = p_recv(buf->fd, buf->data + buf->offset, buf->len - buf->offset, 0);
+	ret = p_recv(buf->socket->socket, buf->data + buf->offset, buf->len - buf->offset, 0);
 	if (ret < 0) {
 		net_set_error("Error receiving socket data");
 		return -1;
@@ -136,31 +142,31 @@ int gitno__recv(gitno_buffer *buf)
 }
 
 void gitno_buffer_setup_callback(
-	git_transport *t,
+	gitno_socket *socket,
 	gitno_buffer *buf,
 	char *data,
 	size_t len,
 	int (*recv)(gitno_buffer *buf), void *cb_data)
 {
-	memset(buf, 0x0, sizeof(gitno_buffer));
 	memset(data, 0x0, len);
 	buf->data = data;
 	buf->len = len;
 	buf->offset = 0;
-	buf->fd = t->socket;
+	buf->socket = socket;
 	buf->recv = recv;
 	buf->cb_data = cb_data;
 }
 
-void gitno_buffer_setup(git_transport *t, gitno_buffer *buf, char *data, size_t len)
+void gitno_buffer_setup(gitno_socket *socket, gitno_buffer *buf, char *data, size_t len)
 {
 #ifdef GIT_SSL
-	if (t->use_ssl) {
-		gitno_buffer_setup_callback(t, buf, data, len, gitno__recv_ssl, NULL);
-		buf->ssl = &t->ssl;
-	} else
+	if (socket->ssl.ctx) {
+		gitno_buffer_setup_callback(socket, buf, data, len, gitno__recv_ssl, NULL);
+		return;
+	}
 #endif
-		gitno_buffer_setup_callback(t, buf, data, len, gitno__recv, NULL);
+
+	gitno_buffer_setup_callback(socket, buf, data, len, gitno__recv, NULL);
 }
 
 /* Consume up to ptr and move the rest of the buffer to the beginning */
@@ -186,31 +192,23 @@ void gitno_consume_n(gitno_buffer *buf, size_t cons)
 	buf->offset -= cons;
 }
 
-int gitno_ssl_teardown(git_transport *t)
-{
 #ifdef GIT_SSL
-	int ret;
-#endif
 
-	if (!t->use_ssl)
-		return 0;
-
-#ifdef GIT_SSL
+static int gitno_ssl_teardown(gitno_ssl *ssl)
+{
+	int ret;
 
-	do {
-		ret = SSL_shutdown(t->ssl.ssl);
-	} while (ret == 0);
+	ret = SSL_shutdown(ssl->ssl);
 	if (ret < 0)
-		return ssl_set_error(&t->ssl, ret);
+		ret = ssl_set_error(ssl, ret);
+	else
+		ret = 0;
 
-	SSL_free(t->ssl.ssl);
-	SSL_CTX_free(t->ssl.ctx);
-#endif
-	return 0;
+	SSL_free(ssl->ssl);
+	SSL_CTX_free(ssl->ctx);
+	return ret;
 }
 
-
-#ifdef GIT_SSL
 /* Match host names according to RFC 2818 rules */
 static int match_host(const char *pattern, const char *host)
 {
@@ -261,7 +259,7 @@ static int check_host_name(const char *name, const char *host)
 	return 0;
 }
 
-static int verify_server_cert(git_transport *t, const char *host)
+static int verify_server_cert(gitno_ssl *ssl, const char *host)
 {
 	X509 *cert;
 	X509_NAME *peer_name;
@@ -274,24 +272,24 @@ static int verify_server_cert(git_transport *t, const char *host)
 	void *addr;
 	int i = -1,j;
 
-	if (SSL_get_verify_result(t->ssl.ssl) != X509_V_OK) {
+	if (SSL_get_verify_result(ssl->ssl) != X509_V_OK) {
 		giterr_set(GITERR_SSL, "The SSL certificate is invalid");
 		return -1;
 	}
 
 	/* Try to parse the host as an IP address to see if it is */
-	if (inet_pton(AF_INET, host, &addr4)) {
+	if (p_inet_pton(AF_INET, host, &addr4)) {
 		type = GEN_IPADD;
 		addr = &addr4;
 	} else {
-		if(inet_pton(AF_INET6, host, &addr6)) {
+		if(p_inet_pton(AF_INET6, host, &addr6)) {
 			type = GEN_IPADD;
 			addr = &addr6;
 		}
 	}
 
 
-	cert = SSL_get_peer_certificate(t->ssl.ssl);
+	cert = SSL_get_peer_certificate(ssl->ssl);
 
 	/* Check the alternative names */
 	alts = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
@@ -375,7 +373,7 @@ static int verify_server_cert(git_transport *t, const char *host)
 
 on_error:
 	OPENSSL_free(peer_cn);
-	return ssl_set_error(&t->ssl, 0);
+	return ssl_set_error(ssl, 0);
 
 cert_fail:
 	OPENSSL_free(peer_cn);
@@ -383,51 +381,81 @@ cert_fail:
 	return -1;
 }
 
-static int ssl_setup(git_transport *t, const char *host)
+static int ssl_setup(gitno_socket *socket, const char *host, int flags)
 {
 	int ret;
 
 	SSL_library_init();
 	SSL_load_error_strings();
-	t->ssl.ctx = SSL_CTX_new(SSLv23_method());
-	if (t->ssl.ctx == NULL)
-		return ssl_set_error(&t->ssl, 0);
+	socket->ssl.ctx = SSL_CTX_new(SSLv23_method());
+	if (socket->ssl.ctx == NULL)
+		return ssl_set_error(&socket->ssl, 0);
 
-	SSL_CTX_set_mode(t->ssl.ctx, SSL_MODE_AUTO_RETRY);
-	SSL_CTX_set_verify(t->ssl.ctx, SSL_VERIFY_NONE, NULL);
-	if (!SSL_CTX_set_default_verify_paths(t->ssl.ctx))
-		return ssl_set_error(&t->ssl, 0);
+	SSL_CTX_set_mode(socket->ssl.ctx, SSL_MODE_AUTO_RETRY);
+	SSL_CTX_set_verify(socket->ssl.ctx, SSL_VERIFY_NONE, NULL);
+	if (!SSL_CTX_set_default_verify_paths(socket->ssl.ctx))
+		return ssl_set_error(&socket->ssl, 0);
 
-	t->ssl.ssl = SSL_new(t->ssl.ctx);
-	if (t->ssl.ssl == NULL)
-		return ssl_set_error(&t->ssl, 0);
+	socket->ssl.ssl = SSL_new(socket->ssl.ctx);
+	if (socket->ssl.ssl == NULL)
+		return ssl_set_error(&socket->ssl, 0);
 
-	if((ret = SSL_set_fd(t->ssl.ssl, t->socket)) == 0)
-		return ssl_set_error(&t->ssl, ret);
+	if((ret = SSL_set_fd(socket->ssl.ssl, socket->socket)) == 0)
+		return ssl_set_error(&socket->ssl, ret);
 
-	if ((ret = SSL_connect(t->ssl.ssl)) <= 0)
-		return ssl_set_error(&t->ssl, ret);
+	if ((ret = SSL_connect(socket->ssl.ssl)) <= 0)
+		return ssl_set_error(&socket->ssl, ret);
 
-	if (t->check_cert && verify_server_cert(t, host) < 0)
-		return -1;
+	if (GITNO_CONNECT_SSL_NO_CHECK_CERT & flags)
+		return 0;
 
-	return 0;
+	return verify_server_cert(&socket->ssl, host);
 }
-#else
-static int ssl_setup(git_transport *t, const char *host)
+#endif
+
+static int gitno__close(GIT_SOCKET s)
 {
-	GIT_UNUSED(t);
-	GIT_UNUSED(host);
+#ifdef GIT_WIN32
+	if (SOCKET_ERROR == closesocket(s))
+		return -1;
+
+	if (0 != WSACleanup()) {
+		giterr_set(GITERR_OS, "Winsock cleanup failed");
+		return -1;
+	}
+
 	return 0;
-}
+#else
+	return close(s);
 #endif
+}
 
-int gitno_connect(git_transport *t, const char *host, const char *port)
+int gitno_connect(gitno_socket *s_out, const char *host, const char *port, int flags)
 {
 	struct addrinfo *info = NULL, *p;
 	struct addrinfo hints;
-	int ret;
 	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;
+
+	if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) {
+		giterr_set(GITERR_OS, "Winsock init failed");
+		return -1;
+	}
+
+	if (LOBYTE(wsd.wVersion) != 2 || HIBYTE(wsd.wVersion) != 2) {
+		WSACleanup();
+		giterr_set(GITERR_OS, "Winsock init failed");
+		return -1;
+	}
+#endif
+
+	/* Zero the socket structure provided */
+	memset(s_out, 0x0, sizeof(gitno_socket));
 
 	memset(&hints, 0x0, sizeof(struct addrinfo));
 	hints.ai_socktype = SOCK_STREAM;
@@ -451,56 +479,67 @@ int gitno_connect(git_transport *t, const char *host, const char *port)
 			break;
 
 		/* If we can't connect, try the next one */
-		gitno_close(s);
+		gitno__close(s);
 		s = INVALID_SOCKET;
 	}
 
 	/* Oops, we couldn't connect to any address */
 	if (s == INVALID_SOCKET && p == NULL) {
 		giterr_set(GITERR_OS, "Failed to connect to %s", host);
+		p_freeaddrinfo(info);
 		return -1;
 	}
 
-	t->socket = s;
+	s_out->socket = s;
 	p_freeaddrinfo(info);
 
-	if (t->use_ssl && ssl_setup(t, host) < 0)
+#ifdef GIT_SSL
+	if ((flags & GITNO_CONNECT_SSL) && ssl_setup(s_out, host, flags) < 0)
 		return -1;
+#else
+	/* SSL is not supported */
+	if (flags & GITNO_CONNECT_SSL) {
+		giterr_set(GITERR_OS, "SSL is not supported by this copy of libgit2.");
+		return -1;
+	}
+#endif
 
 	return 0;
 }
 
 #ifdef GIT_SSL
-static int send_ssl(gitno_ssl *ssl, const char *msg, size_t len)
+static int gitno_send_ssl(gitno_ssl *ssl, const char *msg, size_t len, int flags)
 {
 	int ret;
 	size_t off = 0;
 
+	GIT_UNUSED(flags);
+
 	while (off < len) {
 		ret = SSL_write(ssl->ssl, msg + off, len - off);
 		if (ret <= 0 && ret != SSL_ERROR_WANT_WRITE)
 			return ssl_set_error(ssl, ret);
 
 		off += ret;
-	}
+	}	
 
 	return off;
 }
 #endif
 
-int gitno_send(git_transport *t, const char *msg, size_t len, int flags)
+int gitno_send(gitno_socket *socket, const char *msg, size_t len, int flags)
 {
 	int ret;
 	size_t off = 0;
 
 #ifdef GIT_SSL
-	if (t->use_ssl)
-		return send_ssl(&t->ssl, msg, len);
+	if (socket->ssl.ctx)
+		return gitno_send_ssl(&socket->ssl, msg, len, flags);
 #endif
 
 	while (off < len) {
 		errno = 0;
-		ret = p_send(t->socket, msg + off, len - off, flags);
+		ret = p_send(socket->socket, msg + off, len - off, flags);
 		if (ret < 0) {
 			net_set_error("Error sending data");
 			return -1;
@@ -512,19 +551,17 @@ int gitno_send(git_transport *t, const char *msg, size_t len, int flags)
 	return (int)off;
 }
 
-
-#ifdef GIT_WIN32
-int gitno_close(GIT_SOCKET s)
+int gitno_close(gitno_socket *s)
 {
-	return closesocket(s) == SOCKET_ERROR ? -1 : 0;
-}
-#else
-int gitno_close(GIT_SOCKET s)
-{
-	return close(s);
-}
+#ifdef GIT_SSL
+	if (s->ssl.ctx &&
+		gitno_ssl_teardown(&s->ssl) < 0)
+		return -1;
 #endif
 
+	return gitno__close(s->socket);
+}
+
 int gitno_select_in(gitno_buffer *buf, long int sec, long int usec)
 {
 	fd_set fds;
@@ -534,33 +571,60 @@ int gitno_select_in(gitno_buffer *buf, long int sec, long int usec)
 	tv.tv_usec = usec;
 
 	FD_ZERO(&fds);
-	FD_SET(buf->fd, &fds);
+	FD_SET(buf->socket->socket, &fds);
 
 	/* The select(2) interface is silly */
-	return select((int)buf->fd + 1, &fds, NULL, NULL, &tv);
+	return select((int)buf->socket->socket + 1, &fds, NULL, NULL, &tv);
 }
 
-int gitno_extract_host_and_port(char **host, char **port, const char *url, const char *default_port)
+int gitno_extract_url_parts(
+		char **host,
+		char **port,
+		char **username,
+		char **password,
+		const char *url,
+		const char *default_port)
 {
-	char *colon, *slash, *delim;
+	char *colon, *slash, *at, *end;
+	const char *start;
+
+	/*
+	 *
+	 * ==> [user[:pass]@]hostname.tld[:port]/resource
+	 */
 
 	colon = strchr(url, ':');
 	slash = strchr(url, '/');
+	at = strchr(url, '@');
 
 	if (slash == NULL) {
 		giterr_set(GITERR_NET, "Malformed URL: missing /");
 		return -1;
 	}
 
+	start = url;
+	if (at && at < slash) {
+		start = at+1;
+		*username = git__substrdup(url, at - url);
+	}
+
+	if (colon && colon < at) {
+		git__free(*username);
+		*username = git__substrdup(url, colon-url);
+		*password = git__substrdup(colon+1, at-colon-1);
+		colon = strchr(at, ':');
+	}
+
 	if (colon == NULL) {
 		*port = git__strdup(default_port);
 	} else {
-		*port = git__strndup(colon + 1, slash - colon - 1);
+		*port = git__substrdup(colon + 1, slash - colon - 1);
 	}
 	GITERR_CHECK_ALLOC(*port);
 
-	delim = colon == NULL ? slash : colon;
-	*host = git__strndup(url, delim - url);
+	end = colon == NULL ? slash : colon;
+
+	*host = git__substrdup(start, end - start);
 	GITERR_CHECK_ALLOC(*host);
 
 	return 0;