rugged 1.3.1 → 1.9.0

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

@@ -27,11 +27,11 @@ bool git_smart__ofs_delta_enabled = true;
 
 int git_smart__store_refs(transport_smart *t, int flushes)
 {
-	gitno_buffer *buf = &t->buffer;
 	git_vector *refs = &t->refs;
 	int error, flush = 0, recvd;
 	const char *line_end = NULL;
 	git_pkt *pkt = NULL;
+	git_pkt_parse_data pkt_parse_data = { 0 };
 	size_t i;
 
 	/* Clear existing refs in case git_remote_connect() is called again
@@ -44,8 +44,10 @@ int git_smart__store_refs(transport_smart *t, int flushes)
 	pkt = NULL;
 
 	do {
-		if (buf->offset > 0)
-			error = git_pkt_parse_line(&pkt, &line_end, buf->data, buf->offset);
+		if (t->buffer.len > 0)
+			error = git_pkt_parse_line(&pkt, &line_end,
+				t->buffer.data, t->buffer.len,
+				&pkt_parse_data);
 		else
 			error = GIT_EBUFS;
 
@@ -53,19 +55,18 @@ int git_smart__store_refs(transport_smart *t, int flushes)
 			return error;
 
 		if (error == GIT_EBUFS) {
-			if ((recvd = gitno_recv(buf)) < 0)
+			if ((recvd = git_smart__recv(t)) < 0)
 				return recvd;
 
 			if (recvd == 0) {
-				git_error_set(GIT_ERROR_NET, "early EOF");
+				git_error_set(GIT_ERROR_NET, "could not read refs from remote repository");
 				return GIT_EEOF;
 			}
 
 			continue;
 		}
 
-		if (gitno_consume(buf, line_end) < 0)
-			return -1;
+		git_staticstr_consume(&t->buffer, line_end);
 
 		if (pkt->type == GIT_PKT_ERR) {
 			git_error_set(GIT_ERROR_NET, "remote error: %s", ((git_pkt_err *)pkt)->error);
@@ -89,7 +90,7 @@ static int append_symref(const char **out, git_vector *symrefs, const char *ptr)
 {
 	int error;
 	const char *end;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 	git_refspec *mapping = NULL;
 
 	ptr += strlen(GIT_CAP_SYMREF);
@@ -101,15 +102,15 @@ static int append_symref(const char **out, git_vector *symrefs, const char *ptr)
 	    !(end = strchr(ptr, '\0')))
 		goto on_invalid;
 
-	if ((error = git_buf_put(&buf, ptr, end - ptr)) < 0)
+	if ((error = git_str_put(&buf, ptr, end - ptr)) < 0)
 		return error;
 
 	/* symref mapping has refspec format */
 	mapping = git__calloc(1, sizeof(git_refspec));
 	GIT_ERROR_CHECK_ALLOC(mapping);
 
-	error = git_refspec__parse(mapping, git_buf_cstr(&buf), true);
-	git_buf_dispose(&buf);
+	error = git_refspec__parse(mapping, git_str_cstr(&buf), true);
+	git_str_dispose(&buf);
 
 	/* if the error isn't OOM, then it's a parse error; let's use a nicer message */
 	if (error < 0) {
@@ -133,11 +134,14 @@ on_invalid:
 	return -1;
 }
 
-int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vector *symrefs)
+int git_smart__detect_caps(
+	git_pkt_ref *pkt,
+	transport_smart_caps *caps,
+	git_vector *symrefs)
 {
-	const char *ptr;
+	const char *ptr, *start;
 
-	/* No refs or capabilites, odd but not a problem */
+	/* No refs or capabilities, odd but not a problem */
 	if (pkt == NULL || pkt->capabilities == NULL)
 		return GIT_ENOTFOUND;
 
@@ -190,6 +194,12 @@ int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vec
 			continue;
 		}
 
+		if (!git__prefixcmp(ptr, GIT_CAP_PUSH_OPTIONS)) {
+			caps->common = caps->push_options = 1;
+			ptr += strlen(GIT_CAP_PUSH_OPTIONS);
+			continue;
+		}
+
 		if (!git__prefixcmp(ptr, GIT_CAP_THIN_PACK)) {
 			caps->common = caps->thin_pack = 1;
 			ptr += strlen(GIT_CAP_THIN_PACK);
@@ -205,6 +215,46 @@ int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vec
 			continue;
 		}
 
+		if (!git__prefixcmp(ptr, GIT_CAP_WANT_TIP_SHA1)) {
+			caps->common = caps->want_tip_sha1 = 1;
+			ptr += strlen(GIT_CAP_WANT_TIP_SHA1);
+			continue;
+		}
+
+		if (!git__prefixcmp(ptr, GIT_CAP_WANT_REACHABLE_SHA1)) {
+			caps->common = caps->want_reachable_sha1 = 1;
+			ptr += strlen(GIT_CAP_WANT_REACHABLE_SHA1);
+			continue;
+		}
+
+		if (!git__prefixcmp(ptr, GIT_CAP_OBJECT_FORMAT)) {
+			ptr += strlen(GIT_CAP_OBJECT_FORMAT);
+
+			start = ptr;
+			ptr = strchr(ptr, ' ');
+
+			if ((caps->object_format = git__strndup(start, (ptr - start))) == NULL)
+				return -1;
+			continue;
+		}
+
+		if (!git__prefixcmp(ptr, GIT_CAP_AGENT)) {
+			ptr += strlen(GIT_CAP_AGENT);
+
+			start = ptr;
+			ptr = strchr(ptr, ' ');
+
+			if ((caps->agent = git__strndup(start, (ptr - start))) == NULL)
+				return -1;
+			continue;
+		}
+
+		if (!git__prefixcmp(ptr, GIT_CAP_SHALLOW)) {
+			caps->common = caps->shallow = 1;
+			ptr += strlen(GIT_CAP_SHALLOW);
+			continue;
+		}
+
 		/* We don't know this capability, so skip it */
 		ptr = strchr(ptr, ' ');
 	}
@@ -212,15 +262,23 @@ int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vec
 	return 0;
 }
 
-static int recv_pkt(git_pkt **out_pkt, git_pkt_type *out_type, gitno_buffer *buf)
+static int recv_pkt(
+	git_pkt **out_pkt,
+	git_pkt_type *out_type,
+	transport_smart *t)
 {
-	const char *ptr = buf->data, *line_end = ptr;
+	const char *ptr = t->buffer.data, *line_end = ptr;
 	git_pkt *pkt = NULL;
+	git_pkt_parse_data pkt_parse_data = { 0 };
 	int error = 0, ret;
 
+	pkt_parse_data.oid_type = t->owner->repo->oid_type;
+	pkt_parse_data.seen_capabilities = 1;
+
 	do {
-		if (buf->offset > 0)
-			error = git_pkt_parse_line(&pkt, &line_end, ptr, buf->offset);
+		if (t->buffer.len > 0)
+			error = git_pkt_parse_line(&pkt, &line_end, ptr,
+				t->buffer.len, &pkt_parse_data);
 		else
 			error = GIT_EBUFS;
 
@@ -230,16 +288,15 @@ static int recv_pkt(git_pkt **out_pkt, git_pkt_type *out_type, gitno_buffer *buf
 		if (error < 0 && error != GIT_EBUFS)
 			return error;
 
-		if ((ret = gitno_recv(buf)) < 0) {
+		if ((ret = git_smart__recv(t)) < 0) {
 			return ret;
 		} else if (ret == 0) {
-			git_error_set(GIT_ERROR_NET, "early EOF");
+			git_error_set(GIT_ERROR_NET, "could not read from remote repository");
 			return GIT_EEOF;
 		}
 	} while (error);
 
-	if (gitno_consume(buf, line_end) < 0)
-		return -1;
+	git_staticstr_consume(&t->buffer, line_end);
 
 	if (out_type != NULL)
 		*out_type = pkt->type;
@@ -254,13 +311,19 @@ static int recv_pkt(git_pkt **out_pkt, git_pkt_type *out_type, gitno_buffer *buf
 static int store_common(transport_smart *t)
 {
 	git_pkt *pkt = NULL;
-	gitno_buffer *buf = &t->buffer;
 	int error;
 
 	do {
-		if ((error = recv_pkt(&pkt, NULL, buf)) < 0)
+		if ((error = recv_pkt(&pkt, NULL, t)) < 0)
 			return error;
 
+		if (t->rpc && (pkt->type == GIT_PKT_SHALLOW ||
+		               pkt->type == GIT_PKT_UNSHALLOW ||
+		               pkt->type == GIT_PKT_FLUSH)) {
+			git__free(pkt);
+			continue;
+		}
+
 		if (pkt->type != GIT_PKT_ACK) {
 			git__free(pkt);
 			return 0;
@@ -275,7 +338,7 @@ static int store_common(transport_smart *t)
 	return 0;
 }
 
-static int wait_while_ack(gitno_buffer *buf)
+static int wait_while_ack(transport_smart *t)
 {
 	int error;
 	git_pkt *pkt = NULL;
@@ -284,7 +347,7 @@ static int wait_while_ack(gitno_buffer *buf)
 	while (1) {
 		git_pkt_free(pkt);
 
-		if ((error = recv_pkt(&pkt, NULL, buf)) < 0)
+		if ((error = recv_pkt(&pkt, NULL, t)) < 0)
 			return error;
 
 		if (pkt->type == GIT_PKT_NAK)
@@ -305,19 +368,64 @@ static int wait_while_ack(gitno_buffer *buf)
 	return 0;
 }
 
-int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, const git_remote_head * const *wants, size_t count)
+static int cap_not_sup_err(const char *cap_name)
+{
+	git_error_set(GIT_ERROR_NET, "server doesn't support %s", cap_name);
+	return GIT_EINVALID;
+}
+
+/* Disables server capabilities we're not interested in */
+static int setup_caps(
+	transport_smart_caps *caps,
+	const git_fetch_negotiation *wants)
+{
+	if (wants->depth > 0) {
+		if (!caps->shallow)
+			return cap_not_sup_err(GIT_CAP_SHALLOW);
+	} else {
+		caps->shallow = 0;
+	}
+
+	return 0;
+}
+
+static int setup_shallow_roots(
+	git_array_oid_t *out,
+	const git_fetch_negotiation *wants)
+{
+	git_array_clear(*out);
+
+	if (wants->shallow_roots_len > 0) {
+		git_array_init_to_size(*out, wants->shallow_roots_len);
+		GIT_ERROR_CHECK_ALLOC(out->ptr);
+
+		memcpy(out->ptr, wants->shallow_roots,
+		       sizeof(git_oid) * wants->shallow_roots_len);
+		out->size = wants->shallow_roots_len;
+	}
+
+	return 0;
+}
+
+int git_smart__negotiate_fetch(
+	git_transport *transport,
+	git_repository *repo,
+	const git_fetch_negotiation *wants)
 {
 	transport_smart *t = (transport_smart *)transport;
 	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
-	gitno_buffer *buf = &t->buffer;
-	git_buf data = GIT_BUF_INIT;
+	git_str data = GIT_STR_INIT;
 	git_revwalk *walk = NULL;
 	int error = -1;
 	git_pkt_type pkt_type;
 	unsigned int i;
 	git_oid oid;
 
-	if ((error = git_pkt_buffer_wants(wants, count, &t->caps, &data)) < 0)
+	if ((error = setup_caps(&t->caps, wants)) < 0 ||
+	    (error = setup_shallow_roots(&t->shallow_roots, wants)) < 0)
+		return error;
+
+	if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0)
 		return error;
 
 	if ((error = git_revwalk_new(&walk, repo)) < 0)
@@ -327,6 +435,40 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
 	if ((error = git_revwalk__push_glob(walk, "refs/*", &opts)) < 0)
 		goto on_error;
 
+	if (wants->depth > 0) {
+		git_pkt_shallow *pkt;
+
+		if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0)
+			goto on_error;
+
+		if (!t->rpc)
+			git_str_clear(&data);
+
+		while ((error = recv_pkt((git_pkt **)&pkt, NULL, t)) == 0) {
+			bool complete = false;
+
+			if (pkt->type == GIT_PKT_SHALLOW) {
+				error = git_oidarray__add(&t->shallow_roots, &pkt->oid);
+			} else if (pkt->type == GIT_PKT_UNSHALLOW) {
+				git_oidarray__remove(&t->shallow_roots, &pkt->oid);
+			} else if (pkt->type == GIT_PKT_FLUSH) {
+				/* Server is done, stop processing shallow oids */
+				complete = true;
+			} else {
+				git_error_set(GIT_ERROR_NET, "unexpected packet type");
+				error = -1;
+			}
+
+			git_pkt_free((git_pkt *) pkt);
+
+			if (complete || error < 0)
+				break;
+		}
+
+		if (error < 0)
+			goto on_error;
+	}
+
 	/*
 	 * Our support for ACK extensions is simply to parse them. On
 	 * the first ACK we will accept that as enough common
@@ -354,7 +496,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
 			}
 
 			git_pkt_buffer_flush(&data);
-			if (git_buf_oom(&data)) {
+			if (git_str_oom(&data)) {
 				error = -1;
 				goto on_error;
 			}
@@ -362,12 +504,12 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
 			if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0)
 				goto on_error;
 
-			git_buf_clear(&data);
+			git_str_clear(&data);
 			if (t->caps.multi_ack || t->caps.multi_ack_detailed) {
 				if ((error = store_common(t)) < 0)
 					goto on_error;
 			} else {
-				if ((error = recv_pkt(NULL, &pkt_type, buf)) < 0)
+				if ((error = recv_pkt(NULL, &pkt_type, t)) < 0)
 					goto on_error;
 
 				if (pkt_type == GIT_PKT_ACK) {
@@ -389,7 +531,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
 			git_pkt_ack *pkt;
 			unsigned int j;
 
-			if ((error = git_pkt_buffer_wants(wants, count, &t->caps, &data)) < 0)
+			if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0)
 				goto on_error;
 
 			git_vector_foreach(&t->common, j, pkt) {
@@ -397,7 +539,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
 					goto on_error;
 			}
 
-			if (git_buf_oom(&data)) {
+			if (git_str_oom(&data)) {
 				error = -1;
 				goto on_error;
 			}
@@ -409,7 +551,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
 		git_pkt_ack *pkt;
 		unsigned int j;
 
-		if ((error = git_pkt_buffer_wants(wants, count, &t->caps, &data)) < 0)
+		if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0)
 			goto on_error;
 
 		git_vector_foreach(&t->common, j, pkt) {
@@ -417,7 +559,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
 				goto on_error;
 		}
 
-		if (git_buf_oom(&data)) {
+		if (git_str_oom(&data)) {
 			error = -1;
 			goto on_error;
 		}
@@ -427,19 +569,20 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
 		goto on_error;
 
 	if (t->cancelled.val) {
-		git_error_set(GIT_ERROR_NET, "The fetch was cancelled by the user");
+		git_error_set(GIT_ERROR_NET, "the fetch was cancelled");
 		error = GIT_EUSER;
 		goto on_error;
 	}
+
 	if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0)
 		goto on_error;
 
-	git_buf_dispose(&data);
+	git_str_dispose(&data);
 	git_revwalk_free(walk);
 
 	/* Now let's eat up whatever the server gives us */
 	if (!t->caps.multi_ack && !t->caps.multi_ack_detailed) {
-		if ((error = recv_pkt(NULL, &pkt_type, buf)) < 0)
+		if ((error = recv_pkt(NULL, &pkt_type, t)) < 0)
 			return error;
 
 		if (pkt_type != GIT_PKT_ACK && pkt_type != GIT_PKT_NAK) {
@@ -447,18 +590,40 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
 			return -1;
 		}
 	} else {
-		error = wait_while_ack(buf);
+		error = wait_while_ack(t);
 	}
 
 	return error;
 
 on_error:
 	git_revwalk_free(walk);
-	git_buf_dispose(&data);
+	git_str_dispose(&data);
 	return error;
 }
 
-static int no_sideband(transport_smart *t, struct git_odb_writepack *writepack, gitno_buffer *buf, git_indexer_progress *stats)
+int git_smart__shallow_roots(git_oidarray *out, git_transport *transport)
+{
+	transport_smart *t = (transport_smart *)transport;
+	size_t len;
+
+	GIT_ERROR_CHECK_ALLOC_MULTIPLY(&len, t->shallow_roots.size, sizeof(git_oid));
+
+	out->count = t->shallow_roots.size;
+
+	if (len) {
+		out->ids = git__malloc(len);
+		memcpy(out->ids, t->shallow_roots.ptr, len);
+	} else {
+		out->ids = NULL;
+	}
+
+	return 0;
+}
+
+static int no_sideband(
+	transport_smart *t,
+	struct git_odb_writepack *writepack,
+	git_indexer_progress *stats)
 {
 	int recvd;
 
@@ -468,12 +633,12 @@ static int no_sideband(transport_smart *t, struct git_odb_writepack *writepack,
 			return GIT_EUSER;
 		}
 
-		if (writepack->append(writepack, buf->data, buf->offset, stats) < 0)
+		if (writepack->append(writepack, t->buffer.data, t->buffer.len, stats) < 0)
 			return -1;
 
-		gitno_consume_n(buf, buf->offset);
+		git_staticstr_clear(&t->buffer);
 
-		if ((recvd = gitno_recv(buf)) < 0)
+		if ((recvd = git_smart__recv(t)) < 0)
 			return recvd;
 	} while(recvd > 0);
 
@@ -512,17 +677,17 @@ static int network_packetsize(size_t received, void *payload)
 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)
 {
 	transport_smart *t = (transport_smart *)transport;
-	gitno_buffer *buf = &t->buffer;
 	git_odb *odb;
 	struct git_odb_writepack *writepack = NULL;
 	int error = 0;
 	struct network_packetsize_payload npp = {0};
 
+	git_indexer_progress_cb progress_cb = t->connect_opts.callbacks.transfer_progress;
+	void *progress_payload = t->connect_opts.callbacks.payload;
+
 	memset(stats, 0, sizeof(git_indexer_progress));
 
 	if (progress_cb) {
@@ -533,9 +698,10 @@ int git_smart__download_pack(
 		t->packetsize_payload = &npp;
 
 		/* We might have something in the buffer already from negotiate_fetch */
-		if (t->buffer.offset > 0 && !t->cancelled.val)
-			if (t->packetsize_cb(t->buffer.offset, t->packetsize_payload))
+		if (t->buffer.len > 0 && !t->cancelled.val) {
+			if (t->packetsize_cb(t->buffer.len, t->packetsize_payload))
 				git_atomic32_set(&t->cancelled, 1);
+		}
 	}
 
 	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
@@ -548,7 +714,7 @@ int git_smart__download_pack(
 	 * check which one belongs there.
 	 */
 	if (!t->caps.side_band && !t->caps.side_band_64k) {
-		error = no_sideband(t, writepack, buf, stats);
+		error = no_sideband(t, writepack, stats);
 		goto done;
 	}
 
@@ -562,13 +728,13 @@ int git_smart__download_pack(
 			goto done;
 		}
 
-		if ((error = recv_pkt(&pkt, NULL, buf)) >= 0) {
+		if ((error = recv_pkt(&pkt, NULL, t)) >= 0) {
 			/* Check cancellation after network call */
 			if (t->cancelled.val) {
 				git_error_clear();
 				error = GIT_EUSER;
 			} else if (pkt->type == GIT_PKT_PROGRESS) {
-				if (t->progress_cb) {
+				if (t->connect_opts.callbacks.sideband_progress) {
 					git_pkt_progress *p = (git_pkt_progress *) pkt;
 
 					if (p->len > INT_MAX) {
@@ -577,7 +743,7 @@ int git_smart__download_pack(
 						goto done;
 					}
 
-					error = t->progress_cb(p->data, (int)p->len, t->message_cb_payload);
+					error = t->connect_opts.callbacks.sideband_progress(p->data, (int)p->len, t->connect_opts.callbacks.payload);
 				}
 			} else if (pkt->type == GIT_PKT_DATA) {
 				git_pkt_data *p = (git_pkt_data *) pkt;
@@ -626,45 +792,73 @@ done:
 	return error;
 }
 
-static int gen_pktline(git_buf *buf, git_push *push)
+static int gen_pktline(git_str *buf, git_push *push)
 {
 	push_spec *spec;
+	char *option;
 	size_t i, len;
-	char old_id[GIT_OID_HEXSZ+1], new_id[GIT_OID_HEXSZ+1];
-
-	old_id[GIT_OID_HEXSZ] = '\0'; new_id[GIT_OID_HEXSZ] = '\0';
+	char old_id[GIT_OID_MAX_HEXSIZE + 1], new_id[GIT_OID_MAX_HEXSIZE + 1];
+	size_t old_id_len, new_id_len;
 
 	git_vector_foreach(&push->specs, i, spec) {
-		len = 2*GIT_OID_HEXSZ + 7 + strlen(spec->refspec.dst);
+		len = strlen(spec->refspec.dst) + 7;
 
 		if (i == 0) {
-			++len; /* '\0' */
+			/* Need a leading \0 */
+			++len;
+
 			if (push->report_status)
 				len += strlen(GIT_CAP_REPORT_STATUS) + 1;
+
+			if (git_vector_length(&push->remote_push_options) > 0)
+				len += strlen(GIT_CAP_PUSH_OPTIONS) + 1;
+
 			len += strlen(GIT_CAP_SIDE_BAND_64K) + 1;
 		}
 
+		old_id_len = git_oid_hexsize(git_oid_type(&spec->roid));
+		new_id_len = git_oid_hexsize(git_oid_type(&spec->loid));
+
+		len += (old_id_len + new_id_len);
+
 		git_oid_fmt(old_id, &spec->roid);
+		old_id[old_id_len] = '\0';
+
 		git_oid_fmt(new_id, &spec->loid);
+		new_id[new_id_len] = '\0';
 
-		git_buf_printf(buf, "%04"PRIxZ"%s %s %s", len, old_id, new_id, spec->refspec.dst);
+		git_str_printf(buf, "%04"PRIxZ"%.*s %.*s %s", len,
+			(int)old_id_len, old_id, (int)new_id_len, new_id,
+			spec->refspec.dst);
 
 		if (i == 0) {
-			git_buf_putc(buf, '\0');
+			git_str_putc(buf, '\0');
+
 			/* Core git always starts their capabilities string with a space */
 			if (push->report_status) {
-				git_buf_putc(buf, ' ');
-				git_buf_printf(buf, GIT_CAP_REPORT_STATUS);
+				git_str_putc(buf, ' ');
+				git_str_printf(buf, GIT_CAP_REPORT_STATUS);
+			}
+			if (git_vector_length(&push->remote_push_options) > 0) {
+				git_str_putc(buf, ' ');
+				git_str_printf(buf, GIT_CAP_PUSH_OPTIONS);
 			}
-			git_buf_putc(buf, ' ');
-			git_buf_printf(buf, GIT_CAP_SIDE_BAND_64K);
+			git_str_putc(buf, ' ');
+			git_str_printf(buf, GIT_CAP_SIDE_BAND_64K);
 		}
 
-		git_buf_putc(buf, '\n');
+		git_str_putc(buf, '\n');
+	}
+
+	if (git_vector_length(&push->remote_push_options) > 0) {
+		git_str_printf(buf, "0000");
+		git_vector_foreach(&push->remote_push_options, i, option) {
+			git_str_printf(buf, "%04"PRIxZ"%s", strlen(option) + 4 , option);
+		}
 	}
 
-	git_buf_puts(buf, "0000");
-	return git_buf_oom(buf) ? -1 : 0;
+	git_str_puts(buf, "0000");
+	return git_str_oom(buf) ? -1 : 0;
 }
 
 static int add_push_report_pkt(git_push *push, git_pkt *pkt)
@@ -707,9 +901,10 @@ static int add_push_report_pkt(git_push *push, git_pkt *pkt)
 	return 0;
 }
 
-static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, git_buf *data_pkt_buf)
+static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt, git_str *data_pkt_buf)
 {
 	git_pkt *pkt;
+	git_pkt_parse_data pkt_parse_data = { 0 };
 	const char *line, *line_end = NULL;
 	size_t line_len;
 	int error;
@@ -718,7 +913,7 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt,
 	if (reading_from_buf) {
 		/* We had an existing partial packet, so add the new
 		 * packet to the buffer and parse the whole thing */
-		git_buf_put(data_pkt_buf, data_pkt->data, data_pkt->len);
+		git_str_put(data_pkt_buf, data_pkt->data, data_pkt->len);
 		line = data_pkt_buf->ptr;
 		line_len = data_pkt_buf->size;
 	}
@@ -728,13 +923,13 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt,
 	}
 
 	while (line_len > 0) {
-		error = git_pkt_parse_line(&pkt, &line_end, line, line_len);
+		error = git_pkt_parse_line(&pkt, &line_end, line, line_len, &pkt_parse_data);
 
 		if (error == GIT_EBUFS) {
 			/* Buffer the data when the inner packet is split
 			 * across multiple sideband packets */
 			if (!reading_from_buf)
-				git_buf_put(data_pkt_buf, line, line_len);
+				git_str_put(data_pkt_buf, line, line_len);
 			error = 0;
 			goto done;
 		}
@@ -757,22 +952,24 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt,
 
 done:
 	if (reading_from_buf)
-		git_buf_consume(data_pkt_buf, line_end);
+		git_str_consume(data_pkt_buf, line_end);
 	return error;
 }
 
 static int parse_report(transport_smart *transport, git_push *push)
 {
 	git_pkt *pkt = NULL;
+	git_pkt_parse_data pkt_parse_data = { 0 };
 	const char *line_end = NULL;
-	gitno_buffer *buf = &transport->buffer;
 	int error, recvd;
-	git_buf data_pkt_buf = GIT_BUF_INIT;
+	git_str data_pkt_buf = GIT_STR_INIT;
 
 	for (;;) {
-		if (buf->offset > 0)
+		if (transport->buffer.len > 0)
 			error = git_pkt_parse_line(&pkt, &line_end,
-						   buf->data, buf->offset);
+				   transport->buffer.data,
+				   transport->buffer.len,
+				   &pkt_parse_data);
 		else
 			error = GIT_EBUFS;
 
@@ -782,22 +979,20 @@ static int parse_report(transport_smart *transport, git_push *push)
 		}
 
 		if (error == GIT_EBUFS) {
-			if ((recvd = gitno_recv(buf)) < 0) {
+			if ((recvd = git_smart__recv(transport)) < 0) {
 				error = recvd;
 				goto done;
 			}
 
 			if (recvd == 0) {
-				git_error_set(GIT_ERROR_NET, "early EOF");
+				git_error_set(GIT_ERROR_NET, "could not read report from remote repository");
 				error = GIT_EEOF;
 				goto done;
 			}
 			continue;
 		}
 
-		if (gitno_consume(buf, line_end) < 0)
-			return -1;
-
+		git_staticstr_consume(&transport->buffer, line_end);
 		error = 0;
 
 		switch (pkt->type) {
@@ -811,7 +1006,7 @@ static int parse_report(transport_smart *transport, git_push *push)
 				error = -1;
 				break;
 			case GIT_PKT_PROGRESS:
-				if (transport->progress_cb) {
+				if (transport->connect_opts.callbacks.sideband_progress) {
 					git_pkt_progress *p = (git_pkt_progress *) pkt;
 
 					if (p->len > INT_MAX) {
@@ -820,7 +1015,7 @@ static int parse_report(transport_smart *transport, git_push *push)
 						goto done;
 					}
 
-					error = transport->progress_cb(p->data, (int)p->len, transport->message_cb_payload);
+					error = transport->connect_opts.callbacks.sideband_progress(p->data, (int)p->len, transport->connect_opts.callbacks.payload);
 				}
 				break;
 			default:
@@ -847,7 +1042,7 @@ static int parse_report(transport_smart *transport, git_push *push)
 		}
 	}
 done:
-	git_buf_dispose(&data_pkt_buf);
+	git_str_dispose(&data_pkt_buf);
 	return error;
 }
 
@@ -962,7 +1157,7 @@ struct push_packbuilder_payload
 	git_push_transfer_progress_cb cb;
 	void *cb_payload;
 	size_t last_bytes;
-	double last_progress_report_time;
+	uint64_t last_progress_report_time;
 };
 
 static int stream_thunk(void *buf, size_t size, void *data)
@@ -974,11 +1169,11 @@ static int stream_thunk(void *buf, size_t size, void *data)
 		return error;
 
 	if (payload->cb) {
-		double current_time = git__timer();
-		double elapsed = current_time - payload->last_progress_report_time;
+		uint64_t current_time = git_time_monotonic();
+		uint64_t elapsed = current_time - payload->last_progress_report_time;
 		payload->last_bytes += size;
 
-		if (elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+		if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			payload->last_progress_report_time = current_time;
 			error = payload->cb(payload->pb->nr_written, payload->pb->nr_objects, payload->last_bytes, payload->cb_payload);
 		}
@@ -987,11 +1182,12 @@ static int stream_thunk(void *buf, size_t size, void *data)
 	return error;
 }
 
-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)
 {
 	transport_smart *t = (transport_smart *)transport;
+	git_remote_callbacks *cbs = &t->connect_opts.callbacks;
 	struct push_packbuilder_payload packbuilder_payload = {0};
-	git_buf pktline = GIT_BUF_INIT;
+	git_str pktline = GIT_STR_INIT;
 	int error = 0, need_pack = 0;
 	push_spec *spec;
 	unsigned int i;
@@ -1006,7 +1202,7 @@ int git_smart__push(git_transport *transport, git_push *push, const git_remote_c
 #ifdef PUSH_DEBUG
 {
 	git_remote_head *head;
-	char hex[GIT_OID_HEXSZ+1]; hex[GIT_OID_HEXSZ] = '\0';
+	char hex[GIT_OID_MAX_HEXSIZE+1], hex[GIT_OID_MAX_HEXSIZE] = '\0';
 
 	git_vector_foreach(&push->remote->refs, i, head) {
 		git_oid_fmt(hex, &head->oid);
@@ -1034,9 +1230,13 @@ int git_smart__push(git_transport *transport, git_push *push, const git_remote_c
 		}
 	}
 
+	/* prepare pack before sending pack header to avoid timeouts */
+	if (need_pack && ((error = git_packbuilder__prepare(push->pb))) < 0)
+		goto done;
+
 	if ((error = git_smart__get_push_stream(t, &packbuilder_payload.stream)) < 0 ||
 		(error = gen_pktline(&pktline, push)) < 0 ||
-		(error = packbuilder_payload.stream->write(packbuilder_payload.stream, git_buf_cstr(&pktline), git_buf_len(&pktline))) < 0)
+		(error = packbuilder_payload.stream->write(packbuilder_payload.stream, git_str_cstr(&pktline), git_str_len(&pktline))) < 0)
 		goto done;
 
 	if (need_pack &&
@@ -1071,6 +1271,6 @@ int git_smart__push(git_transport *transport, git_push *push, const git_remote_c
 	}
 
 done:
-	git_buf_dispose(&pktline);
+	git_str_dispose(&pktline);
 	return error;
 }