rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/{transports → libgit2/transports}/smart.c

@@ -8,34 +8,47 @@
 #include "smart.h"
 
 #include "git2.h"
+#include "git2/sys/remote.h"
 #include "refs.h"
 #include "refspec.h"
 #include "proxy.h"
 
-static int git_smart__recv_cb(gitno_buffer *buf)
+int git_smart__recv(transport_smart *t)
 {
-	transport_smart *t = (transport_smart *) buf->cb_data;
-	size_t old_len, bytes_read;
-	int error;
+	size_t bytes_read;
+	int ret;
 
+	GIT_ASSERT_ARG(t);
 	GIT_ASSERT(t->current_stream);
 
-	old_len = buf->offset;
+	if (git_staticstr_remain(&t->buffer) == 0) {
+		git_error_set(GIT_ERROR_NET, "out of buffer space");
+		return -1;
+	}
 
-	if ((error = t->current_stream->read(t->current_stream, buf->data + buf->offset, buf->len - buf->offset, &bytes_read)) < 0)
-		return error;
+	ret = t->current_stream->read(t->current_stream,
+		git_staticstr_offset(&t->buffer),
+		git_staticstr_remain(&t->buffer),
+		&bytes_read);
+
+	if (ret < 0)
+		return ret;
+
+	GIT_ASSERT(bytes_read <= INT_MAX);
+	GIT_ASSERT(bytes_read <= git_staticstr_remain(&t->buffer));
 
-	buf->offset += bytes_read;
+	git_staticstr_increase(&t->buffer, bytes_read);
 
 	if (t->packetsize_cb && !t->cancelled.val) {
-		error = t->packetsize_cb(bytes_read, t->packetsize_payload);
-		if (error) {
+		ret = t->packetsize_cb(bytes_read, t->packetsize_payload);
+
+		if (ret) {
 			git_atomic32_set(&t->cancelled, 1);
 			return GIT_EUSER;
 		}
 	}
 
-	return (int)(buf->offset - old_len);
+	return (int)bytes_read;
 }
 
 GIT_INLINE(int) git_smart__reset_stream(transport_smart *t, bool close_subtransport)
@@ -53,104 +66,15 @@ GIT_INLINE(int) git_smart__reset_stream(transport_smart *t, bool close_subtransp
 			return -1;
 	}
 
-	return 0;
-}
-
-static int git_smart__set_callbacks(
-	git_transport *transport,
-	git_transport_message_cb progress_cb,
-	git_transport_message_cb error_cb,
-	git_transport_certificate_check_cb certificate_check_cb,
-	void *message_cb_payload)
-{
-	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
+	git__free(t->caps.object_format);
+	t->caps.object_format = NULL;
 
-	t->progress_cb = progress_cb;
-	t->error_cb = error_cb;
-	t->certificate_check_cb = certificate_check_cb;
-	t->message_cb_payload = message_cb_payload;
+	git__free(t->caps.agent);
+	t->caps.agent = NULL;
 
 	return 0;
 }
 
-static size_t http_header_name_length(const char *http_header)
-{
-	const char *colon = strchr(http_header, ':');
-	if (!colon)
-		return 0;
-	return colon - http_header;
-}
-
-static bool is_malformed_http_header(const char *http_header)
-{
-	const char *c;
-	size_t name_len;
-
-	/* Disallow \r and \n */
-	c = strchr(http_header, '\r');
-	if (c)
-		return true;
-	c = strchr(http_header, '\n');
-	if (c)
-		return true;
-
-	/* Require a header name followed by : */
-	name_len = http_header_name_length(http_header);
-	if (name_len < 1)
-		return true;
-
-	return false;
-}
-
-static char *forbidden_custom_headers[] = {
-	"User-Agent",
-	"Host",
-	"Accept",
-	"Content-Type",
-	"Transfer-Encoding",
-	"Content-Length",
-};
-
-static bool is_forbidden_custom_header(const char *custom_header)
-{
-	unsigned long i;
-	size_t name_len = http_header_name_length(custom_header);
-
-	/* Disallow headers that we set */
-	for (i = 0; i < ARRAY_SIZE(forbidden_custom_headers); i++)
-		if (strncmp(forbidden_custom_headers[i], custom_header, name_len) == 0)
-			return true;
-
-	return false;
-}
-
-static int git_smart__set_custom_headers(
-	git_transport *transport,
-	const git_strarray *custom_headers)
-{
-	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
-	size_t i;
-
-	if (t->custom_headers.count)
-		git_strarray_dispose(&t->custom_headers);
-
-	if (!custom_headers)
-		return 0;
-
-	for (i = 0; i < custom_headers->count; i++) {
-		if (is_malformed_http_header(custom_headers->strings[i])) {
-			git_error_set(GIT_ERROR_INVALID, "custom HTTP header '%s' is malformed", custom_headers->strings[i]);
-			return -1;
-		}
-		if (is_forbidden_custom_header(custom_headers->strings[i])) {
-			git_error_set(GIT_ERROR_INVALID, "custom HTTP header '%s' is already set by libgit2", custom_headers->strings[i]);
-			return -1;
-		}
-	}
-
-	return git_strarray_copy(&t->custom_headers, custom_headers);
-}
-
 int git_smart__update_heads(transport_smart *t, git_vector *symrefs)
 {
 	size_t i;
@@ -164,20 +88,20 @@ int git_smart__update_heads(transport_smart *t, git_vector *symrefs)
 
 		if (symrefs) {
 			git_refspec *spec;
-			git_buf buf = GIT_BUF_INIT;
+			git_str buf = GIT_STR_INIT;
 			size_t j;
 			int error = 0;
 
 			git_vector_foreach(symrefs, j, spec) {
-				git_buf_clear(&buf);
+				git_str_clear(&buf);
 				if (git_refspec_src_matches(spec, ref->head.name) &&
-				    !(error = git_refspec_transform(&buf, spec, ref->head.name))) {
+				    !(error = git_refspec__transform(&buf, spec, ref->head.name))) {
 					git__free(ref->head.symref_target);
-					ref->head.symref_target = git_buf_detach(&buf);
+					ref->head.symref_target = git_str_detach(&buf);
 				}
 			}
 
-			git_buf_dispose(&buf);
+			git_str_dispose(&buf);
 
 			if (error < 0)
 				return error;
@@ -200,17 +124,14 @@ static void free_symrefs(git_vector *symrefs)
 		git__free(spec);
 	}
 
-	git_vector_free(symrefs);
+	git_vector_dispose(symrefs);
 }
 
 static int git_smart__connect(
 	git_transport *transport,
 	const char *url,
-	git_credential_acquire_cb cred_acquire_cb,
-	void *cred_acquire_payload,
-	const git_proxy_options *proxy,
 	int direction,
-	int flags)
+	const git_remote_connect_options *connect_opts)
 {
 	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
 	git_smart_subtransport_stream *stream;
@@ -223,24 +144,19 @@ static int git_smart__connect(
 	if (git_smart__reset_stream(t, true) < 0)
 		return -1;
 
+	if (git_remote_connect_options_normalize(&t->connect_opts, t->owner->repo, connect_opts) < 0)
+		return -1;
+
 	t->url = git__strdup(url);
 	GIT_ERROR_CHECK_ALLOC(t->url);
 
-	git_proxy_options_clear(&t->proxy);
-
-	if (git_proxy_options_dup(&t->proxy, proxy) < 0)
-		return -1;
-
 	t->direction = direction;
-	t->flags = flags;
-	t->cred_acquire_cb = cred_acquire_cb;
-	t->cred_acquire_payload = cred_acquire_payload;
 
-	if (GIT_DIRECTION_FETCH == t->direction)
+	if (GIT_DIRECTION_FETCH == t->direction) {
 		service = GIT_SERVICE_UPLOADPACK_LS;
-	else if (GIT_DIRECTION_PUSH == t->direction)
+	} else if (GIT_DIRECTION_PUSH == t->direction) {
 		service = GIT_SERVICE_RECEIVEPACK_LS;
-	else {
+	} else {
 		git_error_set(GIT_ERROR_NET, "invalid direction");
 		return -1;
 	}
@@ -251,8 +167,6 @@ static int git_smart__connect(
 	/* Save off the current stream (i.e. socket) that we are working with */
 	t->current_stream = stream;
 
-	gitno_buffer_setup_callback(&t->buffer, t->buffer_data, sizeof(t->buffer_data), git_smart__recv_cb, t);
-
 	/* 2 flushes for RPC; 1 for stateful */
 	if ((error = git_smart__store_refs(t, t->rpc ? 2 : 1)) < 0)
 		return error;
@@ -315,6 +229,62 @@ cleanup:
 	return error;
 }
 
+static int git_smart__set_connect_opts(
+	git_transport *transport,
+	const git_remote_connect_options *opts)
+{
+	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
+
+	if (!t->connected) {
+		git_error_set(GIT_ERROR_NET, "cannot reconfigure a transport that is not connected");
+		return -1;
+	}
+
+	return git_remote_connect_options_normalize(&t->connect_opts, t->owner->repo, opts);
+}
+
+static int git_smart__capabilities(unsigned int *capabilities, git_transport *transport)
+{
+	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
+
+	*capabilities = 0;
+
+	if (t->caps.push_options)
+		*capabilities |= GIT_REMOTE_CAPABILITY_PUSH_OPTIONS;
+
+	if (t->caps.want_tip_sha1)
+		*capabilities |= GIT_REMOTE_CAPABILITY_TIP_OID;
+
+	if (t->caps.want_reachable_sha1)
+		*capabilities |= GIT_REMOTE_CAPABILITY_REACHABLE_OID;
+
+	return 0;
+}
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+static int git_smart__oid_type(git_oid_t *out, git_transport *transport)
+{
+	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
+
+	*out = 0;
+
+	if (t->caps.object_format == NULL) {
+		*out = GIT_OID_DEFAULT;
+	} else {
+		*out = git_oid_type_fromstr(t->caps.object_format);
+
+		if (!*out) {
+			git_error_set(GIT_ERROR_INVALID,
+				"unknown object format '%s'",
+				t->caps.object_format);
+			return -1;
+		}
+	}
+
+	return 0;
+}
+#endif
+
 static int git_smart__ls(const git_remote_head ***out, size_t *size, git_transport *transport)
 {
 	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
@@ -356,8 +326,6 @@ int git_smart__negotiation_step(git_transport *transport, void *data, size_t len
 	if ((error = stream->write(stream, (const char *)data, len)) < 0)
 		return error;
 
-	gitno_buffer_setup_callback(&t->buffer, t->buffer_data, sizeof(t->buffer_data), git_smart__recv_cb, t);
-
 	return 0;
 }
 
@@ -382,8 +350,6 @@ int git_smart__get_push_stream(transport_smart *t, git_smart_subtransport_stream
 	/* Save off the current stream (i.e. socket) that we are working with */
 	t->current_stream = *stream;
 
-	gitno_buffer_setup_callback(&t->buffer, t->buffer_data, sizeof(t->buffer_data), git_smart__recv_cb, t);
-
 	return 0;
 }
 
@@ -401,32 +367,33 @@ static int git_smart__is_connected(git_transport *transport)
 	return t->connected;
 }
 
-static int git_smart__read_flags(git_transport *transport, int *flags)
-{
-	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
-
-	*flags = t->flags;
-
-	return 0;
-}
-
 static int git_smart__close(git_transport *transport)
 {
 	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
 	git_vector *common = &t->common;
 	unsigned int i;
 	git_pkt *p;
+	git_smart_service_t service;
 	int ret;
 	git_smart_subtransport_stream *stream;
 	const char flush[] = "0000";
 
+	if (t->direction == GIT_DIRECTION_FETCH) {
+		service = GIT_SERVICE_UPLOADPACK;
+	} else if (t->direction == GIT_DIRECTION_PUSH) {
+		service = GIT_SERVICE_RECEIVEPACK;
+	} else {
+		git_error_set(GIT_ERROR_NET, "invalid direction");
+		return -1;
+	}
+
 	/*
 	 * If we're still connected at this point and not using RPC,
 	 * we should say goodbye by sending a flush, or git-daemon
 	 * will complain that we disconnected unexpectedly.
 	 */
 	if (t->connected && !t->rpc &&
-	    !t->wrapped->action(&stream, t->wrapped, t->url, GIT_SERVICE_UPLOADPACK)) {
+	    !t->wrapped->action(&stream, t->wrapped, t->url, service)) {
 		t->current_stream->write(t->current_stream, flush, 4);
 	}
 
@@ -435,7 +402,7 @@ static int git_smart__close(git_transport *transport)
 	git_vector_foreach(common, i, p)
 		git_pkt_free(p);
 
-	git_vector_free(common);
+	git_vector_dispose(common);
 
 	if (t->url) {
 		git__free(t->url);
@@ -460,15 +427,18 @@ static void git_smart__free(git_transport *transport)
 	/* Free the subtransport */
 	t->wrapped->free(t->wrapped);
 
-	git_vector_free(&t->heads);
+	git_vector_dispose(&t->heads);
 	git_vector_foreach(refs, i, p)
 		git_pkt_free(p);
 
-	git_vector_free(refs);
-	git__free((char *)t->proxy.url);
+	git_vector_dispose(refs);
+
+	git_remote_connect_options_dispose(&t->connect_opts);
 
-	git_strarray_dispose(&t->custom_headers);
+	git_array_dispose(t->shallow_roots);
 
+	git__free(t->caps.object_format);
+	git__free(t->caps.agent);
 	git__free(t);
 }
 
@@ -482,34 +452,42 @@ static int ref_name_cmp(const void *a, const void *b)
 int git_transport_smart_certificate_check(git_transport *transport, git_cert *cert, int valid, const char *hostname)
 {
 	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
+	git_remote_connect_options *connect_opts = &t->connect_opts;
 
 	GIT_ASSERT_ARG(transport);
 	GIT_ASSERT_ARG(cert);
 	GIT_ASSERT_ARG(hostname);
 
-	if (!t->certificate_check_cb)
+	if (!connect_opts->callbacks.certificate_check)
 		return GIT_PASSTHROUGH;
 
-	return t->certificate_check_cb(cert, valid, hostname, t->message_cb_payload);
+	return connect_opts->callbacks.certificate_check(cert, valid, hostname, connect_opts->callbacks.payload);
 }
 
 int git_transport_smart_credentials(git_credential **out, git_transport *transport, const char *user, int methods)
 {
 	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
+	git_remote_connect_options *connect_opts = &t->connect_opts;
 
 	GIT_ASSERT_ARG(out);
 	GIT_ASSERT_ARG(transport);
 
-	if (!t->cred_acquire_cb)
+	if (!connect_opts->callbacks.credentials)
 		return GIT_PASSTHROUGH;
 
-	return t->cred_acquire_cb(out, t->url, user, methods, t->cred_acquire_payload);
+	return connect_opts->callbacks.credentials(out, t->url, user, methods, connect_opts->callbacks.payload);
 }
 
-int git_transport_smart_proxy_options(git_proxy_options *out, git_transport *transport)
+int git_transport_remote_connect_options(
+		git_remote_connect_options *out,
+		git_transport *transport)
 {
 	transport_smart *t = GIT_CONTAINER_OF(transport, transport_smart, parent);
-	return git_proxy_options_dup(out, &t->proxy);
+
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(transport);
+
+	return git_remote_connect_options_dup(out, &t->connect_opts);
 }
 
 int git_transport_smart(git_transport **out, git_remote *owner, void *param)
@@ -524,36 +502,35 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param)
 	GIT_ERROR_CHECK_ALLOC(t);
 
 	t->parent.version = GIT_TRANSPORT_VERSION;
-	t->parent.set_callbacks = git_smart__set_callbacks;
-	t->parent.set_custom_headers = git_smart__set_custom_headers;
 	t->parent.connect = git_smart__connect;
+	t->parent.set_connect_opts = git_smart__set_connect_opts;
+	t->parent.capabilities = git_smart__capabilities;
+#ifdef GIT_EXPERIMENTAL_SHA256
+	t->parent.oid_type = git_smart__oid_type;
+#endif
 	t->parent.close = git_smart__close;
 	t->parent.free = git_smart__free;
 	t->parent.negotiate_fetch = git_smart__negotiate_fetch;
+	t->parent.shallow_roots = git_smart__shallow_roots;
 	t->parent.download_pack = git_smart__download_pack;
 	t->parent.push = git_smart__push;
 	t->parent.ls = git_smart__ls;
 	t->parent.is_connected = git_smart__is_connected;
-	t->parent.read_flags = git_smart__read_flags;
 	t->parent.cancel = git_smart__cancel;
 
 	t->owner = owner;
 	t->rpc = definition->rpc;
 
-	if (git_vector_init(&t->refs, 16, ref_name_cmp) < 0) {
+	if (git_vector_init(&t->refs, 16, ref_name_cmp) < 0 ||
+	    git_vector_init(&t->heads, 16, ref_name_cmp) < 0 ||
+	    definition->callback(&t->wrapped, &t->parent, definition->param) < 0) {
+		git_vector_dispose(&t->refs);
+		git_vector_dispose(&t->heads);
 		git__free(t);
 		return -1;
 	}
 
-	if (git_vector_init(&t->heads, 16, ref_name_cmp) < 0) {
-		git__free(t);
-		return -1;
-	}
-
-	if (definition->callback(&t->wrapped, &t->parent, definition->param) < 0) {
-		git__free(t);
-		return -1;
-	}
+	git_staticstr_init(&t->buffer, GIT_SMART_BUFFER_SIZE);
 
 	*out = (git_transport *) t;
 	return 0;

data/vendor/libgit2/src/{transports → libgit2/transports}/smart.h

@@ -11,11 +11,14 @@
 
 #include "git2.h"
 #include "vector.h"
-#include "netops.h"
-#include "buffer.h"
 #include "push.h"
+#include "str.h"
+#include "oidarray.h"
+#include "staticstr.h"
 #include "git2/sys/transport.h"
 
+#define GIT_SMART_BUFFER_SIZE  65536
+
 #define GIT_SIDE_BAND_DATA     1
 #define GIT_SIDE_BAND_PROGRESS 2
 #define GIT_SIDE_BAND_ERROR    3
@@ -30,6 +33,12 @@
 #define GIT_CAP_REPORT_STATUS "report-status"
 #define GIT_CAP_THIN_PACK "thin-pack"
 #define GIT_CAP_SYMREF "symref"
+#define GIT_CAP_WANT_TIP_SHA1 "allow-tip-sha1-in-want"
+#define GIT_CAP_WANT_REACHABLE_SHA1 "allow-reachable-sha1-in-want"
+#define GIT_CAP_SHALLOW "shallow"
+#define GIT_CAP_OBJECT_FORMAT "object-format="
+#define GIT_CAP_AGENT "agent="
+#define GIT_CAP_PUSH_OPTIONS "push-options"
 
 extern bool git_smart__ofs_delta_enabled;
 
@@ -47,6 +56,8 @@ typedef enum {
 	GIT_PKT_OK,
 	GIT_PKT_NG,
 	GIT_PKT_UNPACK,
+	GIT_PKT_SHALLOW,
+	GIT_PKT_UNSHALLOW
 } git_pkt_type;
 
 /* Used for multi_ack and multi_ack_detailed */
@@ -118,17 +129,28 @@ typedef struct {
 	int unpack_ok;
 } git_pkt_unpack;
 
+typedef struct {
+	git_pkt_type type;
+	git_oid oid;
+} git_pkt_shallow;
+
 typedef struct transport_smart_caps {
-	int common:1,
-		ofs_delta:1,
-		multi_ack: 1,
-		multi_ack_detailed: 1,
-		side_band:1,
-		side_band_64k:1,
-		include_tag:1,
-		delete_refs:1,
-		report_status:1,
-		thin_pack:1;
+	unsigned int common:1,
+	             ofs_delta:1,
+	             multi_ack:1,
+	             multi_ack_detailed:1,
+	             side_band:1,
+	             side_band_64k:1,
+	             include_tag:1,
+	             delete_refs:1,
+	             report_status:1,
+	             thin_pack:1,
+	             want_tip_sha1:1,
+	             want_reachable_sha1:1,
+	             shallow:1,
+	             push_options:1;
+	char *object_format;
+	char *agent;
 } transport_smart_caps;
 
 typedef int (*packetsize_cb)(size_t received, void *payload);
@@ -137,63 +159,61 @@ typedef struct {
 	git_transport parent;
 	git_remote *owner;
 	char *url;
-	git_credential_acquire_cb cred_acquire_cb;
-	void *cred_acquire_payload;
-	git_proxy_options proxy;
+	git_remote_connect_options connect_opts;
 	int direction;
-	int flags;
-	git_transport_message_cb progress_cb;
-	git_transport_message_cb error_cb;
-	git_transport_certificate_check_cb certificate_check_cb;
-	void *message_cb_payload;
-	git_strarray custom_headers;
 	git_smart_subtransport *wrapped;
 	git_smart_subtransport_stream *current_stream;
 	transport_smart_caps caps;
 	git_vector refs;
 	git_vector heads;
 	git_vector common;
+	git_array_oid_t shallow_roots;
 	git_atomic32 cancelled;
 	packetsize_cb packetsize_cb;
 	void *packetsize_payload;
 	unsigned rpc : 1,
-		have_refs : 1,
-		connected : 1;
-	gitno_buffer buffer;
-	char buffer_data[65536];
+	         have_refs : 1,
+	         connected : 1;
+	git_staticstr_with_size(GIT_SMART_BUFFER_SIZE) buffer;
 } transport_smart;
 
 /* smart_protocol.c */
 int git_smart__store_refs(transport_smart *t, int flushes);
 int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vector *symrefs);
-int git_smart__push(git_transport *transport, git_push *push, const git_remote_callbacks *cbs);
+int git_smart__push(git_transport *transport, git_push *push);
 
 int git_smart__negotiate_fetch(
 	git_transport *transport,
 	git_repository *repo,
-	const git_remote_head * const *refs,
-	size_t count);
+	const git_fetch_negotiation *wants);
+
+int git_smart__shallow_roots(git_oidarray *out, git_transport *transport);
 
 int git_smart__download_pack(
 	git_transport *transport,
 	git_repository *repo,
-	git_indexer_progress *stats,
-	git_indexer_progress_cb progress_cb,
-	void *progress_payload);
+	git_indexer_progress *stats);
 
 /* smart.c */
+int git_smart__recv(transport_smart *t);
+
 int git_smart__negotiation_step(git_transport *transport, void *data, size_t len);
 int git_smart__get_push_stream(transport_smart *t, git_smart_subtransport_stream **out);
 
 int git_smart__update_heads(transport_smart *t, git_vector *symrefs);
 
 /* smart_pkt.c */
-int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen);
-int git_pkt_buffer_flush(git_buf *buf);
+typedef struct {
+	git_oid_t oid_type;
+	unsigned int seen_capabilities: 1;
+} git_pkt_parse_data;
+
+int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen, git_pkt_parse_data *data);
+int git_pkt_buffer_flush(git_str *buf);
 int git_pkt_send_flush(GIT_SOCKET s);
-int git_pkt_buffer_done(git_buf *buf);
-int git_pkt_buffer_wants(const git_remote_head * const *refs, size_t count, transport_smart_caps *caps, git_buf *buf);
-int git_pkt_buffer_have(git_oid *oid, git_buf *buf);
+int git_pkt_buffer_done(git_str *buf);
+int git_pkt_buffer_wants(const git_fetch_negotiation *wants, transport_smart_caps *caps, git_str *buf);
+int git_pkt_buffer_have(git_oid *oid, git_str *buf);
 void git_pkt_free(git_pkt *pkt);
 
 #endif