rugged 1.0.0 → 1.2.0

data/vendor/libgit2/src/threadstate.c

@@ -0,0 +1,83 @@
+/*
+ * 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.
+ */
+
+#include "threadstate.h"
+#include "runtime.h"
+
+/**
+ * Handle the thread-local state
+ *
+ * `git_threadstate_global_init` will be called as part
+ * of `git_libgit2_init` (which itself must be called
+ * before calling any other function in the library).
+ *
+ * This function allocates a TLS index to store the per-
+ * thread state.
+ *
+ * Any internal method that requires thread-local state
+ * will then call `git_threadstate_get()` which returns a
+ * pointer to the thread-local state structure; this
+ * structure is lazily allocated on each thread.
+ *
+ * This mechanism will register a shutdown handler
+ * (`git_threadstate_global_shutdown`) which will free the
+ * TLS index.  This shutdown handler will be called by
+ * `git_libgit2_shutdown`.
+ */
+
+static git_tlsdata_key tls_key;
+
+static void threadstate_dispose(git_threadstate *threadstate)
+{
+	if (!threadstate)
+		return;
+
+	git__free(threadstate->error_t.message);
+	threadstate->error_t.message = NULL;
+}
+
+static void GIT_SYSTEM_CALL threadstate_free(void *threadstate)
+{
+	threadstate_dispose(threadstate);
+	git__free(threadstate);
+}
+
+static void git_threadstate_global_shutdown(void)
+{
+	git_threadstate *threadstate;
+
+	threadstate = git_tlsdata_get(tls_key);
+	git_tlsdata_set(tls_key, NULL);
+
+	threadstate_dispose(threadstate);
+	git__free(threadstate);
+
+	git_tlsdata_dispose(tls_key);
+}
+
+int git_threadstate_global_init(void)
+{
+	if (git_tlsdata_init(&tls_key, &threadstate_free) != 0)
+		return -1;
+
+	return git_runtime_shutdown_register(git_threadstate_global_shutdown);
+}
+
+git_threadstate *git_threadstate_get(void)
+{
+	git_threadstate *threadstate;
+
+	if ((threadstate = git_tlsdata_get(tls_key)) != NULL)
+		return threadstate;
+
+	if ((threadstate = git__calloc(1, sizeof(git_threadstate))) == NULL ||
+	    git_buf_init(&threadstate->error_buf, 0) < 0)
+		return NULL;
+
+	git_tlsdata_set(tls_key, threadstate);
+	return threadstate;
+}

data/vendor/libgit2/src/threadstate.h

@@ -0,0 +1,24 @@
+/*
+ * 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_threadstate_h__
+#define INCLUDE_threadstate_h__
+
+#include "common.h"
+
+typedef struct {
+	git_error *last_error;
+	git_error error_t;
+	git_buf error_buf;
+	char oid_fmt[GIT_OID_HEXSZ+1];
+} git_threadstate;
+
+extern int git_threadstate_global_init(void);
+extern git_threadstate *git_threadstate_get(void);
+
+#define GIT_THREADSTATE (git_threadstate_get())
+
+#endif

data/vendor/libgit2/src/trace.c

@@ -8,7 +8,7 @@
 #include "trace.h"
 
 #include "buffer.h"
-#include "global.h"
+#include "runtime.h"
 #include "git2/trace.h"
 
 #ifdef GIT_TRACE
@@ -20,7 +20,7 @@ struct git_trace_data git_trace__data = {0};
 int git_trace_set(git_trace_level_t level, git_trace_cb callback)
 {
 #ifdef GIT_TRACE
-	assert(level == 0 || callback != NULL);
+	GIT_ASSERT_ARG(level == 0 || callback != NULL);
 
 	git_trace__data.level = level;
 	git_trace__data.callback = callback;

data/vendor/libgit2/src/trace.h

@@ -23,28 +23,32 @@ extern struct git_trace_data git_trace__data;
 
 GIT_INLINE(void) git_trace__write_fmt(
 	git_trace_level_t level,
-	const char *fmt, ...)
+	const char *fmt,
+	va_list ap)
 {
 	git_trace_cb callback = git_trace__data.callback;
 	git_buf message = GIT_BUF_INIT;
-	va_list ap;
 
-	va_start(ap, fmt);
 	git_buf_vprintf(&message, fmt, ap);
-	va_end(ap);
 
 	callback(level, git_buf_cstr(&message));
 
 	git_buf_dispose(&message);
 }
 
-#define git_trace_level()		(git_trace__data.level)
-#define git_trace(l, ...)		{ \
-									if (git_trace__data.level >= l && \
-										git_trace__data.callback != NULL) { \
-										git_trace__write_fmt(l, __VA_ARGS__); \
-									} \
-								}
+#define git_trace_level()	(git_trace__data.level)
+
+GIT_INLINE(void) git_trace(git_trace_level_t level, const char *fmt, ...)
+{
+	if (git_trace__data.level >= level &&
+	    git_trace__data.callback != NULL) {
+		va_list ap;
+
+		va_start(ap, fmt);
+		git_trace__write_fmt(level, fmt, ap);
+		va_end(ap);
+	}
+}
 
 #else
 
@@ -56,8 +60,8 @@ GIT_INLINE(void) git_trace__null(
 	GIT_UNUSED(fmt);
 }
 
-#define git_trace_level()		((git_trace_level_t)0)
-#define git_trace			git_trace__null
+#define git_trace_level()	((git_trace_level_t)0)
+#define git_trace		git_trace__null
 
 #endif
 

data/vendor/libgit2/src/transaction.c

@@ -57,7 +57,9 @@ struct git_transaction {
 int git_transaction_config_new(git_transaction **out, git_config *cfg)
 {
 	git_transaction *tx;
-	assert(out && cfg);
+
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(cfg);
 
 	tx = git__calloc(1, sizeof(git_transaction));
 	GIT_ERROR_CHECK_ALLOC(tx);
@@ -74,9 +76,11 @@ int git_transaction_new(git_transaction **out, git_repository *repo)
 	git_pool pool;
 	git_transaction *tx = NULL;
 
-	assert(out && repo);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
 
-	git_pool_init(&pool, 1);
+	if ((error = git_pool_init(&pool, 1)) < 0)
+		goto on_error;
 
 	tx = git_pool_mallocz(&pool, sizeof(git_transaction));
 	if (!tx) {
@@ -108,7 +112,8 @@ int git_transaction_lock_ref(git_transaction *tx, const char *refname)
 	int error;
 	transaction_node *node;
 
-	assert(tx && refname);
+	GIT_ASSERT_ARG(tx);
+	GIT_ASSERT_ARG(refname);
 
 	node = git_pool_mallocz(&tx->pool, sizeof(transaction_node));
 	GIT_ERROR_CHECK_ALLOC(node);
@@ -175,7 +180,9 @@ int git_transaction_set_target(git_transaction *tx, const char *refname, const g
 	int error;
 	transaction_node *node;
 
-	assert(tx && refname && target);
+	GIT_ASSERT_ARG(tx);
+	GIT_ASSERT_ARG(refname);
+	GIT_ASSERT_ARG(target);
 
 	if ((error = find_locked(&node, tx, refname)) < 0)
 		return error;
@@ -194,7 +201,9 @@ int git_transaction_set_symbolic_target(git_transaction *tx, const char *refname
 	int error;
 	transaction_node *node;
 
-	assert(tx && refname && target);
+	GIT_ASSERT_ARG(tx);
+	GIT_ASSERT_ARG(refname);
+	GIT_ASSERT_ARG(target);
 
 	if ((error = find_locked(&node, tx, refname)) < 0)
 		return error;
@@ -271,7 +280,9 @@ int git_transaction_set_reflog(git_transaction *tx, const char *refname, const g
 	int error;
 	transaction_node *node;
 
-	assert(tx && refname && reflog);
+	GIT_ASSERT_ARG(tx);
+	GIT_ASSERT_ARG(refname);
+	GIT_ASSERT_ARG(reflog);
 
 	if ((error = find_locked(&node, tx, refname)) < 0)
 		return error;
@@ -319,7 +330,7 @@ int git_transaction_commit(git_transaction *tx)
 	transaction_node *node;
 	int error = 0;
 
-	assert(tx);
+	GIT_ASSERT_ARG(tx);
 
 	if (tx->type == TRANSACTION_CONFIG) {
 		error = git_config_unlock(tx->cfg, true);
@@ -354,7 +365,8 @@ void git_transaction_free(git_transaction *tx)
 	transaction_node *node;
 	git_pool pool;
 
-	assert(tx);
+	if (!tx)
+		return;
 
 	if (tx->type == TRANSACTION_CONFIG) {
 		if (tx->cfg) {

data/vendor/libgit2/src/transport.c

@@ -148,8 +148,8 @@ int git_transport_register(
 	size_t i;
 	int error = 0;
 
-	assert(scheme);
-	assert(cb);
+	GIT_ASSERT_ARG(scheme);
+	GIT_ASSERT_ARG(cb);
 
 	if ((error = git_buf_printf(&prefix, "%s://", scheme)) < 0)
 		goto on_error;
@@ -186,7 +186,7 @@ int git_transport_unregister(const char *scheme)
 	size_t i;
 	int error = 0;
 
-	assert(scheme);
+	GIT_ASSERT_ARG(scheme);
 
 	if ((error = git_buf_printf(&prefix, "%s://", scheme)) < 0)
 		goto done;

data/vendor/libgit2/src/transports/auth.c

@@ -18,7 +18,7 @@ static int basic_next_token(
 {
 	git_credential_userpass_plaintext *cred;
 	git_buf raw = GIT_BUF_INIT;
-	int error = -1;
+	int error = GIT_EAUTH;
 
 	GIT_UNUSED(ctx);
 

data/vendor/libgit2/src/transports/auth_negotiate.c

@@ -65,7 +65,9 @@ static int negotiate_set_challenge(
 {
 	http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c;
 
-	assert(ctx && ctx->configured && challenge);
+	GIT_ASSERT_ARG(ctx);
+	GIT_ASSERT_ARG(challenge);
+	GIT_ASSERT(ctx->configured);
 
 	git__free(ctx->challenge);
 
@@ -108,7 +110,12 @@ static int negotiate_next_token(
 	size_t challenge_len;
 	int error = 0;
 
-	assert(buf && ctx && ctx->configured && cred && cred->credtype == GIT_CREDENTIAL_DEFAULT);
+	GIT_ASSERT_ARG(buf);
+	GIT_ASSERT_ARG(ctx);
+	GIT_ASSERT_ARG(cred);
+
+	GIT_ASSERT(ctx->configured);
+	GIT_ASSERT(cred->credtype == GIT_CREDENTIAL_DEFAULT);
 
 	if (ctx->complete)
 		return 0;
@@ -202,7 +209,7 @@ static int negotiate_is_complete(git_http_auth_context *c)
 {
 	http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c;
 
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 
 	return (ctx->complete == 1);
 }
@@ -260,7 +267,7 @@ static int negotiate_init_context(
 
 	if (!ctx->oid) {
 		git_error_set(GIT_ERROR_NET, "negotiate authentication is not supported");
-		return -1;
+		return GIT_EAUTH;
 	}
 
 	git_buf_puts(&ctx->target, "HTTP@");

data/vendor/libgit2/src/transports/auth_ntlm.c

@@ -14,7 +14,7 @@
 
 #ifdef GIT_NTLM
 
-#include "ntlm.h"
+#include "ntlmclient.h"
 
 typedef struct {
 	git_http_auth_context parent;
@@ -29,7 +29,8 @@ static int ntlm_set_challenge(
 {
 	http_auth_ntlm_context *ctx = (http_auth_ntlm_context *)c;
 
-	assert(ctx && challenge);
+	GIT_ASSERT_ARG(ctx);
+	GIT_ASSERT_ARG(challenge);
 
 	git__free(ctx->challenge);
 
@@ -46,7 +47,7 @@ static int ntlm_set_credentials(http_auth_ntlm_context *ctx, git_credential *_cr
 	char *domain = NULL, *domainuser = NULL;
 	int error = 0;
 
-	assert(_cred->credtype == GIT_CREDENTIAL_USERPASS_PLAINTEXT);
+	GIT_ASSERT(_cred->credtype == GIT_CREDENTIAL_USERPASS_PLAINTEXT);
 	cred = (git_credential_userpass_plaintext *)_cred;
 
 	if ((sep = strchr(cred->username, '\\')) != NULL) {
@@ -84,9 +85,12 @@ static int ntlm_next_token(
 	git_buf input_buf = GIT_BUF_INIT;
 	const unsigned char *msg;
 	size_t challenge_len, msg_len;
-	int error = -1;
+	int error = GIT_EAUTH;
 
-	assert(buf && ctx && ctx->ntlm);
+	GIT_ASSERT_ARG(buf);
+	GIT_ASSERT_ARG(ctx);
+
+	GIT_ASSERT(ctx->ntlm);
 
 	challenge_len = ctx->challenge ? strlen(ctx->challenge) : 0;
 
@@ -162,7 +166,7 @@ static int ntlm_is_complete(git_http_auth_context *c)
 {
 	http_auth_ntlm_context *ctx = (http_auth_ntlm_context *)c;
 
-	assert(ctx);
+	GIT_ASSERT_ARG(ctx);
 	return (ctx->complete == true);
 }
 

data/vendor/libgit2/src/transports/credential.c

@@ -85,7 +85,9 @@ int git_credential_userpass_plaintext_new(
 {
 	git_credential_userpass_plaintext *c;
 
-	assert(cred && username && password);
+	GIT_ASSERT_ARG(cred);
+	GIT_ASSERT_ARG(username);
+	GIT_ASSERT_ARG(password);
 
 	c = git__malloc(sizeof(git_credential_userpass_plaintext));
 	GIT_ERROR_CHECK_ALLOC(c);
@@ -233,7 +235,9 @@ static int git_credential_ssh_key_type_new(
 {
 	git_credential_ssh_key *c;
 
-	assert(username && cred && privatekey);
+	GIT_ASSERT_ARG(username);
+	GIT_ASSERT_ARG(cred);
+	GIT_ASSERT_ARG(privatekey);
 
 	c = git__calloc(1, sizeof(git_credential_ssh_key));
 	GIT_ERROR_CHECK_ALLOC(c);
@@ -269,7 +273,9 @@ int git_credential_ssh_interactive_new(
 {
 	git_credential_ssh_interactive *c;
 
-	assert(out && username && prompt_callback);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(username);
+	GIT_ASSERT_ARG(prompt_callback);
 
 	c = git__calloc(1, sizeof(git_credential_ssh_interactive));
 	GIT_ERROR_CHECK_ALLOC(c);
@@ -290,7 +296,8 @@ int git_credential_ssh_interactive_new(
 int git_credential_ssh_key_from_agent(git_credential **cred, const char *username) {
 	git_credential_ssh_key *c;
 
-	assert(username && cred);
+	GIT_ASSERT_ARG(username);
+	GIT_ASSERT_ARG(cred);
 
 	c = git__calloc(1, sizeof(git_credential_ssh_key));
 	GIT_ERROR_CHECK_ALLOC(c);
@@ -317,7 +324,8 @@ int git_credential_ssh_custom_new(
 {
 	git_credential_ssh_custom *c;
 
-	assert(username && cred);
+	GIT_ASSERT_ARG(username);
+	GIT_ASSERT_ARG(cred);
 
 	c = git__calloc(1, sizeof(git_credential_ssh_custom));
 	GIT_ERROR_CHECK_ALLOC(c);
@@ -347,7 +355,7 @@ int git_credential_default_new(git_credential **cred)
 {
 	git_credential_default *c;
 
-	assert(cred);
+	GIT_ASSERT_ARG(cred);
 
 	c = git__calloc(1, sizeof(git_credential_default));
 	GIT_ERROR_CHECK_ALLOC(c);
@@ -364,7 +372,7 @@ int git_credential_username_new(git_credential **cred, const char *username)
 	git_credential_username *c;
 	size_t len, allocsize;
 
-	assert(cred);
+	GIT_ASSERT_ARG(cred);
 
 	len = strlen(username);
 
@@ -391,6 +399,7 @@ void git_credential_free(git_credential *cred)
 
 /* Deprecated credential functions */
 
+#ifndef GIT_DEPRECATE_HARD
 int git_cred_has_username(git_credential *cred)
 {
 	return git_credential_has_username(cred);
@@ -474,3 +483,4 @@ void git_cred_free(git_credential *cred)
 {
 	git_credential_free(cred);
 }
+#endif