src/push.c - third_party/libgit2 - Git at Google

 /*
  * 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 "git2.h"

 #include "common.h"
 #include "pack.h"
 #include "pack-objects.h"
 #include "remote.h"
 #include "vector.h"
 #include "push.h"
 #include "tree.h"

 static int push_spec_rref_cmp(const void *a, const void *b)
 {
 	const push_spec *push_spec_a = a, *push_spec_b = b;

 	return strcmp(push_spec_a->refspec.dst, push_spec_b->refspec.dst);
 }

 static int push_status_ref_cmp(const void *a, const void *b)
 {
 	const push_status *push_status_a = a, *push_status_b = b;

 	return strcmp(push_status_a->ref, push_status_b->ref);
 }

 int git_push_new(git_push **out, git_remote *remote)
 {
 	git_push *p;

 	*out = NULL;

 	p = git__calloc(1, sizeof(*p));
 	GITERR_CHECK_ALLOC(p);

 	p->repo = remote->repo;
 	p->remote = remote;
 	p->report_status = 1;
 	p->pb_parallelism = 1;

 	if (git_vector_init(&p->specs, 0, push_spec_rref_cmp) < 0) {
 		git__free(p);
 		return -1;
 	}

 	if (git_vector_init(&p->status, 0, push_status_ref_cmp) < 0) {
 		git_vector_free(&p->specs);
 		git__free(p);
 		return -1;
 	}

 	if (git_vector_init(&p->updates, 0, NULL) < 0) {
 		git_vector_free(&p->status);
 		git_vector_free(&p->specs);
 		git__free(p);
 		return -1;
 	}

 	*out = p;
 	return 0;
 }

 int git_push_set_options(git_push *push, const git_push_options *opts)
 {
 	if (!push || !opts)
 		return -1;

 	GITERR_CHECK_VERSION(opts, GIT_PUSH_OPTIONS_VERSION, "git_push_options");

 	push->pb_parallelism = opts->pb_parallelism;
 	push->custom_headers = &opts->custom_headers;

 	return 0;
 }

 static void free_refspec(push_spec *spec)
 {
 	if (spec == NULL)
 		return;

 	git_refspec__free(&spec->refspec);
 	git__free(spec);
 }

 static int check_rref(char *ref)
 {
 	if (git__prefixcmp(ref, "refs/")) {
 		giterr_set(GITERR_INVALID, "not a valid reference '%s'", ref);
 		return -1;
 	}

 	return 0;
 }

 static int check_lref(git_push *push, char *ref)
 {
 	/* lref must be resolvable to an existing object */
 	git_object *obj;
 	int error = git_revparse_single(&obj, push->repo, ref);
 	git_object_free(obj);

 	if (!error)
 		return 0;

 	if (error == GIT_ENOTFOUND)
 		giterr_set(GITERR_REFERENCE,
 			"src refspec '%s' does not match any existing object", ref);
 	else
 		giterr_set(GITERR_INVALID, "not a valid reference '%s'", ref);
 	return -1;
 }

 static int parse_refspec(git_push *push, push_spec **spec, const char *str)
 {
 	push_spec *s;

 	*spec = NULL;

 	s = git__calloc(1, sizeof(*s));
 	GITERR_CHECK_ALLOC(s);

 	if (git_refspec__parse(&s->refspec, str, false) < 0) {
 		giterr_set(GITERR_INVALID, "invalid refspec %s", str);
 		goto on_error;
 	}

 	if (s->refspec.src && s->refspec.src[0] != '\0' &&
 	    check_lref(push, s->refspec.src) < 0) {
 		goto on_error;
 	}

 	if (check_rref(s->refspec.dst) < 0)
 		goto on_error;

 	*spec = s;
 	return 0;

 on_error:
 	free_refspec(s);
 	return -1;
 }

 int git_push_add_refspec(git_push *push, const char *refspec)
 {
 	push_spec *spec;

 	if (parse_refspec(push, &spec, refspec) < 0 ||
 	    git_vector_insert(&push->specs, spec) < 0)
 		return -1;

 	return 0;
 }

 int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 {
 	git_buf remote_ref_name = GIT_BUF_INIT;
 	size_t i, j;
 	git_refspec *fetch_spec;
 	push_spec *push_spec = NULL;
 	git_reference *remote_ref;
 	push_status *status;
 	int error = 0;

 	git_vector_foreach(&push->status, i, status) {
 		int fire_callback = 1;

 		/* Skip unsuccessful updates which have non-empty messages */
 		if (status->msg)
 			continue;

 		/* Find the corresponding remote ref */
 		fetch_spec = git_remote__matching_refspec(push->remote, status->ref);
 		if (!fetch_spec)
 			continue;

 		if ((error = git_refspec_transform(&remote_ref_name, fetch_spec, status->ref)) < 0)
 			goto on_error;

 		/* Find matching  push ref spec */
 		git_vector_foreach(&push->specs, j, push_spec) {
 			if (!strcmp(push_spec->refspec.dst, status->ref))
 				break;
 		}

 		/* Could not find the corresponding push ref spec for this push update */
 		if (j == push->specs.length)
 			continue;

 		/* Update the remote ref */
 		if (git_oid_iszero(&push_spec->loid)) {
 			error = git_reference_lookup(&remote_ref, push->remote->repo, git_buf_cstr(&remote_ref_name));

 			if (error >= 0) {
 				error = git_reference_delete(remote_ref);
 				git_reference_free(remote_ref);
 			}
 		} else {
 			error = git_reference_create(NULL, push->remote->repo,
 						git_buf_cstr(&remote_ref_name), &push_spec->loid, 1,
 						"update by push");
 		}

 		if (error < 0) {
 			if (error != GIT_ENOTFOUND)
 				goto on_error;

 			giterr_clear();
 			fire_callback = 0;
 		}

 		if (fire_callback && callbacks && callbacks->update_tips) {
 			error = callbacks->update_tips(git_buf_cstr(&remote_ref_name),
 						&push_spec->roid, &push_spec->loid, callbacks->payload);

 			if (error < 0)
 				goto on_error;
 		}
 	}

 	error = 0;

 on_error:
 	git_buf_free(&remote_ref_name);
 	return error;
 }

 /**
  * Insert all tags until we find a non-tag object, which is returned
  * in `out`.
  */
 static int enqueue_tag(git_object **out, git_push *push, git_oid *id)
 {
 	git_object *obj = NULL, *target = NULL;
 	int error;

 	if ((error = git_object_lookup(&obj, push->repo, id, GIT_OBJ_TAG)) < 0)
 		return error;

 	while (git_object_type(obj) == GIT_OBJ_TAG) {
 		if ((error = git_packbuilder_insert(push->pb, git_object_id(obj), NULL)) < 0)
 			break;

 		if ((error = git_tag_target(&target, (git_tag *) obj)) < 0)
 			break;

 		git_object_free(obj);
 		obj = target;
 	}

 	if (error < 0)
 		git_object_free(obj);
 	else
 		*out = obj;

 	return error;
 }

 static int revwalk(git_vector *commits, git_push *push)
 {
 	git_remote_head *head;
 	push_spec *spec;
 	git_revwalk *rw;
 	git_oid oid;
 	unsigned int i;
 	int error = -1;

 	if (git_revwalk_new(&rw, push->repo) < 0)
 		return -1;

 	git_revwalk_sorting(rw, GIT_SORT_TIME);

 	git_vector_foreach(&push->specs, i, spec) {
 		git_otype type;
 		size_t size;

 		if (git_oid_iszero(&spec->loid))
 			/*
 			 * Delete reference on remote side;
 			 * nothing to do here.
 			 */
 			continue;

 		if (git_oid_equal(&spec->loid, &spec->roid))
 			continue; /* up-to-date */

 		if (git_odb_read_header(&size, &type, push->repo->_odb, &spec->loid) < 0)
 			goto on_error;

 		if (type == GIT_OBJ_TAG) {
 			git_object *target;

 			if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
 				goto on_error;

 			if (git_object_type(target) == GIT_OBJ_COMMIT) {
 				if (git_revwalk_push(rw, git_object_id(target)) < 0) {
 					git_object_free(target);
 					goto on_error;
 				}
 			} else {
 				if (git_packbuilder_insert(
 					push->pb, git_object_id(target), NULL) < 0) {
 					git_object_free(target);
 					goto on_error;
 				}
 			}
 			git_object_free(target);
 		} else if (git_revwalk_push(rw, &spec->loid) < 0)
 			goto on_error;

 		if (!spec->refspec.force) {
 			git_oid base;

 			if (git_oid_iszero(&spec->roid))
 				continue;

 			if (!git_odb_exists(push->repo->_odb, &spec->roid)) {
 				giterr_set(GITERR_REFERENCE,
 					"cannot push because a reference that you are trying to update on the remote contains commits that are not present locally.");
 				error = GIT_ENONFASTFORWARD;
 				goto on_error;
 			}

 			error = git_merge_base(&base, push->repo,
 					       &spec->loid, &spec->roid);

 			if (error == GIT_ENOTFOUND ||
 				(!error && !git_oid_equal(&base, &spec->roid))) {
 				giterr_set(GITERR_REFERENCE,
 					"cannot push non-fastforwardable reference");
 				error = GIT_ENONFASTFORWARD;
 				goto on_error;
 			}

 			if (error < 0)
 				goto on_error;
 		}
 	}

 	git_vector_foreach(&push->remote->refs, i, head) {
 		if (git_oid_iszero(&head->oid))
 			continue;

 		/* TODO */
 		git_revwalk_hide(rw, &head->oid);
 	}

 	while ((error = git_revwalk_next(&oid, rw)) == 0) {
 		git_oid *o = git__malloc(GIT_OID_RAWSZ);
 		if (!o) {
 			error = -1;
 			goto on_error;
 		}
 		git_oid_cpy(o, &oid);
 		if ((error = git_vector_insert(commits, o)) < 0)
 			goto on_error;
 	}

 on_error:
 	git_revwalk_free(rw);
 	return error == GIT_ITEROVER ? 0 : error;
 }

 static int enqueue_object(
 	const git_tree_entry *entry,
 	git_packbuilder *pb)
 {
 	switch (git_tree_entry_type(entry)) {
 		case GIT_OBJ_COMMIT:
 			return 0;
 		case GIT_OBJ_TREE:
 			return git_packbuilder_insert_tree(pb, entry->oid);
 		default:
 			return git_packbuilder_insert(pb, entry->oid, entry->filename);
 	}
 }

 static int queue_differences(
 	git_tree *base,
 	git_tree *delta,
 	git_packbuilder *pb)
 {
 	git_tree *b_child = NULL, *d_child = NULL;
 	size_t b_length = git_tree_entrycount(base);
 	size_t d_length = git_tree_entrycount(delta);
 	size_t i = 0, j = 0;
 	int error;

 	while (i < b_length && j < d_length) {
 		const git_tree_entry *b_entry = git_tree_entry_byindex(base, i);
 		const git_tree_entry *d_entry = git_tree_entry_byindex(delta, j);
 		int cmp = 0;

 		if (!git_oid__cmp(b_entry->oid, d_entry->oid))
 			goto loop;

 		cmp = strcmp(b_entry->filename, d_entry->filename);

 		/* If the entries are both trees and they have the same name but are
 		 * different, then we'll recurse after adding the right-hand entry */
 		if (!cmp &&
 			git_tree_entry__is_tree(b_entry) &&
 			git_tree_entry__is_tree(d_entry)) {
 			/* Add the right-hand entry */
 			if ((error = git_packbuilder_insert(pb, d_entry->oid,
 				d_entry->filename)) < 0)
 				goto on_error;

 			/* Acquire the subtrees and recurse */
 			if ((error = git_tree_lookup(&b_child,
 					git_tree_owner(base), b_entry->oid)) < 0 ||
 				(error = git_tree_lookup(&d_child,
 					git_tree_owner(delta), d_entry->oid)) < 0 ||
 				(error = queue_differences(b_child, d_child, pb)) < 0)
 				goto on_error;

 			git_tree_free(b_child); b_child = NULL;
 			git_tree_free(d_child); d_child = NULL;
 		}
 		/* If the object is new or different in the right-hand tree,
 		 * then enumerate it */
 		else if (cmp >= 0 &&
 			(error = enqueue_object(d_entry, pb)) < 0)
 			goto on_error;

 	loop:
 		if (cmp <= 0) i++;
 		if (cmp >= 0) j++;
 	}

 	/* Drain the right-hand tree of entries */
 	for (; j < d_length; j++)
 		if ((error = enqueue_object(git_tree_entry_byindex(delta, j), pb)) < 0)
 			goto on_error;

 	error = 0;

 on_error:
 	if (b_child)
 		git_tree_free(b_child);

 	if (d_child)
 		git_tree_free(d_child);

 	return error;
 }

 static int queue_objects(git_push *push)
 {
 	git_vector commits = GIT_VECTOR_INIT;
 	git_oid *oid;
 	size_t i;
 	unsigned j;
 	int error;

 	if ((error = revwalk(&commits, push)) < 0)
 		goto on_error;

 	git_vector_foreach(&commits, i, oid) {
 		git_commit *parent = NULL, *commit;
 		git_tree *tree = NULL, *ptree = NULL;
 		size_t parentcount;

 		if ((error = git_commit_lookup(&commit,	push->repo, oid)) < 0)
 			goto on_error;

 		/* Insert the commit */
 		if ((error = git_packbuilder_insert(push->pb, oid, NULL)) < 0)
 			goto loop_error;

 		parentcount = git_commit_parentcount(commit);

 		if (!parentcount) {
 			if ((error = git_packbuilder_insert_tree(push->pb,
 				git_commit_tree_id(commit))) < 0)
 				goto loop_error;
 		} else {
 			if ((error = git_tree_lookup(&tree, push->repo,
 					git_commit_tree_id(commit))) < 0 ||
 				(error = git_packbuilder_insert(push->pb,
 					git_commit_tree_id(commit), NULL)) < 0)
 				goto loop_error;

 			/* For each parent, add the items which are different */
 			for (j = 0; j < parentcount; j++) {
 				if ((error = git_commit_parent(&parent, commit, j)) < 0 ||
 					(error = git_commit_tree(&ptree, parent)) < 0 ||
 					(error = queue_differences(ptree, tree, push->pb)) < 0)
 					goto loop_error;

 				git_tree_free(ptree); ptree = NULL;
 				git_commit_free(parent); parent = NULL;
 			}
 		}

 		error = 0;

 	loop_error:
 		if (tree)
 			git_tree_free(tree);

 		if (ptree)
 			git_tree_free(ptree);

 		if (parent)
 			git_commit_free(parent);

 		git_commit_free(commit);

 		if (error < 0)
 			goto on_error;
 	}

 	error = 0;

 on_error:
 	git_vector_free_deep(&commits);
 	return error;
 }

 static int add_update(git_push *push, push_spec *spec)
 {
 	git_push_update *u = git__calloc(1, sizeof(git_push_update));
 	GITERR_CHECK_ALLOC(u);

 	u->src_refname = git__strdup(spec->refspec.src);
 	GITERR_CHECK_ALLOC(u->src_refname);

 	u->dst_refname = git__strdup(spec->refspec.dst);
 	GITERR_CHECK_ALLOC(u->dst_refname);

 	git_oid_cpy(&u->src, &spec->roid);
 	git_oid_cpy(&u->dst, &spec->loid);

 	return git_vector_insert(&push->updates, u);
 }

 static int calculate_work(git_push *push)
 {
 	git_remote_head *head;
 	push_spec *spec;
 	unsigned int i, j;

 	/* Update local and remote oids*/

 	git_vector_foreach(&push->specs, i, spec) {
 		if (spec->refspec.src && spec->refspec.src[0]!= '\0') {
 			/* This is a create or update.  Local ref must exist. */
 			if (git_reference_name_to_id(
 					&spec->loid, push->repo, spec->refspec.src) < 0) {
 				giterr_set(GITERR_REFERENCE, "no such reference '%s'", spec->refspec.src);
 				return -1;
 			}
 		}

 		/* Remote ref may or may not (e.g. during create) already exist. */
 		git_vector_foreach(&push->remote->refs, j, head) {
 			if (!strcmp(spec->refspec.dst, head->name)) {
 				git_oid_cpy(&spec->roid, &head->oid);
 				break;
 			}
 		}

 		if (add_update(push, spec) < 0)
 			return -1;
 	}

 	return 0;
 }

 static int do_push(git_push *push, const git_remote_callbacks *callbacks)
 {
 	int error = 0;
 	git_transport *transport = push->remote->transport;

 	if (!transport->push) {
 		giterr_set(GITERR_NET, "remote transport doesn't support push");
 		error = -1;
 		goto on_error;
 	}

 	/*
 	 * A pack-file MUST be sent if either create or update command
 	 * is used, even if the server already has all the necessary
 	 * objects.  In this case the client MUST send an empty pack-file.
 	 */

 	if ((error = git_packbuilder_new(&push->pb, push->repo)) < 0)
 		goto on_error;

 	git_packbuilder_set_threads(push->pb, push->pb_parallelism);

 	if (callbacks && callbacks->pack_progress)
 		if ((error = git_packbuilder_set_callbacks(push->pb, callbacks->pack_progress, callbacks->payload)) < 0)
 			goto on_error;

 	if ((error = calculate_work(push)) < 0)
 		goto on_error;

 	if (callbacks && callbacks->push_negotiation &&
 	    (error = callbacks->push_negotiation((const git_push_update **) push->updates.contents,
 					  push->updates.length, callbacks->payload)) < 0)
 	    goto on_error;

 	if ((error = queue_objects(push)) < 0 ||
 	    (error = transport->push(transport, push, callbacks)) < 0)
 		goto on_error;

 on_error:
 	git_packbuilder_free(push->pb);
 	return error;
 }

 static int filter_refs(git_remote *remote)
 {
 	const git_remote_head **heads;
 	size_t heads_len, i;

 	git_vector_clear(&remote->refs);

 	if (git_remote_ls(&heads, &heads_len, remote) < 0)
 		return -1;

 	for (i = 0; i < heads_len; i++) {
 		if (git_vector_insert(&remote->refs, (void *)heads[i]) < 0)
 			return -1;
 	}

 	return 0;
 }

 int git_push_finish(git_push *push, const git_remote_callbacks *callbacks)
 {
 	int error;

 	if (!git_remote_connected(push->remote) &&
 	    (error = git_remote_connect(push->remote, GIT_DIRECTION_PUSH, callbacks, NULL, push->custom_headers)) < 0)
 		return error;

 	if ((error = filter_refs(push->remote)) < 0 ||
 	    (error = do_push(push, callbacks)) < 0)
 		return error;

 	if (!push->unpack_ok) {
 		error = -1;
 		giterr_set(GITERR_NET, "unpacking the sent packfile failed on the remote");
 	}

 	return error;
 }

 int git_push_status_foreach(git_push *push,
 		int (*cb)(const char *ref, const char *msg, void *data),
 		void *data)
 {
 	push_status *status;
 	unsigned int i;

 	git_vector_foreach(&push->status, i, status) {
 		int error = cb(status->ref, status->msg, data);
 		if (error)
 			return giterr_set_after_callback(error);
 	}

 	return 0;
 }

 void git_push_status_free(push_status *status)
 {
 	if (status == NULL)
 		return;

 	git__free(status->msg);
 	git__free(status->ref);
 	git__free(status);
 }

 void git_push_free(git_push *push)
 {
 	push_spec *spec;
 	push_status *status;
 	git_push_update *update;
 	unsigned int i;

 	if (push == NULL)
 		return;

 	git_vector_foreach(&push->specs, i, spec) {
 		free_refspec(spec);
 	}
 	git_vector_free(&push->specs);

 	git_vector_foreach(&push->status, i, status) {
 		git_push_status_free(status);
 	}
 	git_vector_free(&push->status);

 	git_vector_foreach(&push->updates, i, update) {
 		git__free(update->src_refname);
 		git__free(update->dst_refname);
 		git__free(update);
 	}
 	git_vector_free(&push->updates);

 	git__free(push);
 }

 int git_push_init_options(git_push_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_push_options, GIT_PUSH_OPTIONS_INIT);
 	return 0;
 }
	/*
	* 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 "git2.h"

	#include "common.h"
	#include "pack.h"
	#include "pack-objects.h"
	#include "remote.h"
	#include "vector.h"
	#include "push.h"
	#include "tree.h"

	static int push_spec_rref_cmp(const void a, const void b)
	{
	const push_spec push_spec_a = a, push_spec_b = b;

	return strcmp(push_spec_a->refspec.dst, push_spec_b->refspec.dst);
	}

	static int push_status_ref_cmp(const void a, const void b)
	{
	const push_status push_status_a = a, push_status_b = b;

	return strcmp(push_status_a->ref, push_status_b->ref);
	}

	int git_push_new(git_push *out, git_remote remote)
	{
	git_push *p;

	*out = NULL;

	p = git__calloc(1, sizeof(*p));
	GITERR_CHECK_ALLOC(p);

	p->repo = remote->repo;
	p->remote = remote;
	p->report_status = 1;
	p->pb_parallelism = 1;

	if (git_vector_init(&p->specs, 0, push_spec_rref_cmp) < 0) {
	git__free(p);
	return -1;
	}

	if (git_vector_init(&p->status, 0, push_status_ref_cmp) < 0) {
	git_vector_free(&p->specs);
	git__free(p);
	return -1;
	}

	if (git_vector_init(&p->updates, 0, NULL) < 0) {
	git_vector_free(&p->status);
	git_vector_free(&p->specs);
	git__free(p);
	return -1;
	}

	*out = p;
	return 0;
	}

	int git_push_set_options(git_push push, const git_push_options opts)
	{
	if (!push \|\| !opts)
	return -1;

	GITERR_CHECK_VERSION(opts, GIT_PUSH_OPTIONS_VERSION, "git_push_options");

	push->pb_parallelism = opts->pb_parallelism;
	push->custom_headers = &opts->custom_headers;

	return 0;
	}

	static void free_refspec(push_spec *spec)
	{
	if (spec == NULL)
	return;

	git_refspec__free(&spec->refspec);
	git__free(spec);
	}

	static int check_rref(char *ref)
	{
	if (git__prefixcmp(ref, "refs/")) {
	giterr_set(GITERR_INVALID, "not a valid reference '%s'", ref);
	return -1;
	}

	return 0;
	}

	static int check_lref(git_push push, char ref)
	{
	/* lref must be resolvable to an existing object */
	git_object *obj;
	int error = git_revparse_single(&obj, push->repo, ref);
	git_object_free(obj);

	if (!error)
	return 0;

	if (error == GIT_ENOTFOUND)
	giterr_set(GITERR_REFERENCE,
	"src refspec '%s' does not match any existing object", ref);
	else
	giterr_set(GITERR_INVALID, "not a valid reference '%s'", ref);
	return -1;
	}

	static int parse_refspec(git_push push, push_spec spec, const char str)
	{
	push_spec *s;

	*spec = NULL;

	s = git__calloc(1, sizeof(*s));
	GITERR_CHECK_ALLOC(s);

	if (git_refspec__parse(&s->refspec, str, false) < 0) {
	giterr_set(GITERR_INVALID, "invalid refspec %s", str);
	goto on_error;
	}

	if (s->refspec.src && s->refspec.src[0] != '\0' &&
	check_lref(push, s->refspec.src) < 0) {
	goto on_error;
	}

	if (check_rref(s->refspec.dst) < 0)
	goto on_error;

	*spec = s;
	return 0;

	on_error:
	free_refspec(s);
	return -1;
	}

	int git_push_add_refspec(git_push push, const char refspec)
	{
	push_spec *spec;

	if (parse_refspec(push, &spec, refspec) < 0 \|\|
	git_vector_insert(&push->specs, spec) < 0)
	return -1;

	return 0;
	}

	int git_push_update_tips(git_push push, const git_remote_callbacks callbacks)
	{
	git_buf remote_ref_name = GIT_BUF_INIT;
	size_t i, j;
	git_refspec *fetch_spec;
	push_spec *push_spec = NULL;
	git_reference *remote_ref;
	push_status *status;
	int error = 0;

	git_vector_foreach(&push->status, i, status) {
	int fire_callback = 1;

	/* Skip unsuccessful updates which have non-empty messages */
	if (status->msg)
	continue;

	/* Find the corresponding remote ref */
	fetch_spec = git_remote__matching_refspec(push->remote, status->ref);
	if (!fetch_spec)
	continue;

	if ((error = git_refspec_transform(&remote_ref_name, fetch_spec, status->ref)) < 0)
	goto on_error;

	/* Find matching push ref spec */
	git_vector_foreach(&push->specs, j, push_spec) {
	if (!strcmp(push_spec->refspec.dst, status->ref))
	break;
	}

	/* Could not find the corresponding push ref spec for this push update */
	if (j == push->specs.length)
	continue;

	/* Update the remote ref */
	if (git_oid_iszero(&push_spec->loid)) {
	error = git_reference_lookup(&remote_ref, push->remote->repo, git_buf_cstr(&remote_ref_name));

	if (error >= 0) {
	error = git_reference_delete(remote_ref);
	git_reference_free(remote_ref);
	}
	} else {
	error = git_reference_create(NULL, push->remote->repo,
	git_buf_cstr(&remote_ref_name), &push_spec->loid, 1,
	"update by push");
	}

	if (error < 0) {
	if (error != GIT_ENOTFOUND)
	goto on_error;

	giterr_clear();
	fire_callback = 0;
	}

	if (fire_callback && callbacks && callbacks->update_tips) {
	error = callbacks->update_tips(git_buf_cstr(&remote_ref_name),
	&push_spec->roid, &push_spec->loid, callbacks->payload);

	if (error < 0)
	goto on_error;
	}
	}

	error = 0;

	on_error:
	git_buf_free(&remote_ref_name);
	return error;
	}

	/**
	* Insert all tags until we find a non-tag object, which is returned
	* in `out`.
	*/
	static int enqueue_tag(git_object *out, git_push push, git_oid *id)
	{
	git_object obj = NULL, target = NULL;
	int error;

	if ((error = git_object_lookup(&obj, push->repo, id, GIT_OBJ_TAG)) < 0)
	return error;

	while (git_object_type(obj) == GIT_OBJ_TAG) {
	if ((error = git_packbuilder_insert(push->pb, git_object_id(obj), NULL)) < 0)
	break;

	if ((error = git_tag_target(&target, (git_tag *) obj)) < 0)
	break;

	git_object_free(obj);
	obj = target;
	}

	if (error < 0)
	git_object_free(obj);
	else
	*out = obj;

	return error;
	}

	static int revwalk(git_vector commits, git_push push)
	{
	git_remote_head *head;
	push_spec *spec;
	git_revwalk *rw;
	git_oid oid;
	unsigned int i;
	int error = -1;

	if (git_revwalk_new(&rw, push->repo) < 0)
	return -1;

	git_revwalk_sorting(rw, GIT_SORT_TIME);

	git_vector_foreach(&push->specs, i, spec) {
	git_otype type;
	size_t size;

	if (git_oid_iszero(&spec->loid))
	/*
	* Delete reference on remote side;
	* nothing to do here.
	*/
	continue;

	if (git_oid_equal(&spec->loid, &spec->roid))
	continue; /* up-to-date */

	if (git_odb_read_header(&size, &type, push->repo->_odb, &spec->loid) < 0)
	goto on_error;

	if (type == GIT_OBJ_TAG) {
	git_object *target;

	if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
	goto on_error;

	if (git_object_type(target) == GIT_OBJ_COMMIT) {
	if (git_revwalk_push(rw, git_object_id(target)) < 0) {
	git_object_free(target);
	goto on_error;
	}
	} else {
	if (git_packbuilder_insert(
	push->pb, git_object_id(target), NULL) < 0) {
	git_object_free(target);
	goto on_error;
	}
	}
	git_object_free(target);
	} else if (git_revwalk_push(rw, &spec->loid) < 0)
	goto on_error;

	if (!spec->refspec.force) {
	git_oid base;

	if (git_oid_iszero(&spec->roid))
	continue;

	if (!git_odb_exists(push->repo->_odb, &spec->roid)) {
	giterr_set(GITERR_REFERENCE,
	"cannot push because a reference that you are trying to update on the remote contains commits that are not present locally.");
	error = GIT_ENONFASTFORWARD;
	goto on_error;
	}

	error = git_merge_base(&base, push->repo,
	&spec->loid, &spec->roid);

	if (error == GIT_ENOTFOUND \|\|
	(!error && !git_oid_equal(&base, &spec->roid))) {
	giterr_set(GITERR_REFERENCE,
	"cannot push non-fastforwardable reference");
	error = GIT_ENONFASTFORWARD;
	goto on_error;
	}

	if (error < 0)
	goto on_error;
	}
	}

	git_vector_foreach(&push->remote->refs, i, head) {
	if (git_oid_iszero(&head->oid))
	continue;

	/* TODO */
	git_revwalk_hide(rw, &head->oid);
	}

	while ((error = git_revwalk_next(&oid, rw)) == 0) {
	git_oid *o = git__malloc(GIT_OID_RAWSZ);
	if (!o) {
	error = -1;
	goto on_error;
	}
	git_oid_cpy(o, &oid);
	if ((error = git_vector_insert(commits, o)) < 0)
	goto on_error;
	}

	on_error:
	git_revwalk_free(rw);
	return error == GIT_ITEROVER ? 0 : error;
	}

	static int enqueue_object(
	const git_tree_entry *entry,
	git_packbuilder *pb)
	{
	switch (git_tree_entry_type(entry)) {
	case GIT_OBJ_COMMIT:
	return 0;
	case GIT_OBJ_TREE:
	return git_packbuilder_insert_tree(pb, entry->oid);
	default:
	return git_packbuilder_insert(pb, entry->oid, entry->filename);
	}
	}

	static int queue_differences(
	git_tree *base,
	git_tree *delta,
	git_packbuilder *pb)
	{
	git_tree b_child = NULL, d_child = NULL;
	size_t b_length = git_tree_entrycount(base);
	size_t d_length = git_tree_entrycount(delta);
	size_t i = 0, j = 0;
	int error;

	while (i < b_length && j < d_length) {
	const git_tree_entry *b_entry = git_tree_entry_byindex(base, i);
	const git_tree_entry *d_entry = git_tree_entry_byindex(delta, j);
	int cmp = 0;

	if (!git_oid__cmp(b_entry->oid, d_entry->oid))
	goto loop;

	cmp = strcmp(b_entry->filename, d_entry->filename);

	/* If the entries are both trees and they have the same name but are
	* different, then we'll recurse after adding the right-hand entry */
	if (!cmp &&
	git_tree_entry__is_tree(b_entry) &&
	git_tree_entry__is_tree(d_entry)) {
	/* Add the right-hand entry */
	if ((error = git_packbuilder_insert(pb, d_entry->oid,
	d_entry->filename)) < 0)
	goto on_error;

	/* Acquire the subtrees and recurse */
	if ((error = git_tree_lookup(&b_child,
	git_tree_owner(base), b_entry->oid)) < 0 \|\|
	(error = git_tree_lookup(&d_child,
	git_tree_owner(delta), d_entry->oid)) < 0 \|\|
	(error = queue_differences(b_child, d_child, pb)) < 0)
	goto on_error;

	git_tree_free(b_child); b_child = NULL;
	git_tree_free(d_child); d_child = NULL;
	}
	/* If the object is new or different in the right-hand tree,
	* then enumerate it */
	else if (cmp >= 0 &&
	(error = enqueue_object(d_entry, pb)) < 0)
	goto on_error;

	loop:
	if (cmp <= 0) i++;
	if (cmp >= 0) j++;
	}

	/* Drain the right-hand tree of entries */
	for (; j < d_length; j++)
	if ((error = enqueue_object(git_tree_entry_byindex(delta, j), pb)) < 0)
	goto on_error;

	error = 0;

	on_error:
	if (b_child)
	git_tree_free(b_child);

	if (d_child)
	git_tree_free(d_child);

	return error;
	}

	static int queue_objects(git_push *push)
	{
	git_vector commits = GIT_VECTOR_INIT;
	git_oid *oid;
	size_t i;
	unsigned j;
	int error;

	if ((error = revwalk(&commits, push)) < 0)
	goto on_error;

	git_vector_foreach(&commits, i, oid) {
	git_commit parent = NULL, commit;
	git_tree tree = NULL, ptree = NULL;
	size_t parentcount;

	if ((error = git_commit_lookup(&commit, push->repo, oid)) < 0)
	goto on_error;

	/* Insert the commit */
	if ((error = git_packbuilder_insert(push->pb, oid, NULL)) < 0)
	goto loop_error;

	parentcount = git_commit_parentcount(commit);

	if (!parentcount) {
	if ((error = git_packbuilder_insert_tree(push->pb,
	git_commit_tree_id(commit))) < 0)
	goto loop_error;
	} else {
	if ((error = git_tree_lookup(&tree, push->repo,
	git_commit_tree_id(commit))) < 0 \|\|
	(error = git_packbuilder_insert(push->pb,
	git_commit_tree_id(commit), NULL)) < 0)
	goto loop_error;

	/* For each parent, add the items which are different */
	for (j = 0; j < parentcount; j++) {
	if ((error = git_commit_parent(&parent, commit, j)) < 0 \|\|
	(error = git_commit_tree(&ptree, parent)) < 0 \|\|
	(error = queue_differences(ptree, tree, push->pb)) < 0)
	goto loop_error;

	git_tree_free(ptree); ptree = NULL;
	git_commit_free(parent); parent = NULL;
	}
	}

	error = 0;

	loop_error:
	if (tree)
	git_tree_free(tree);

	if (ptree)
	git_tree_free(ptree);

	if (parent)
	git_commit_free(parent);

	git_commit_free(commit);

	if (error < 0)
	goto on_error;
	}

	error = 0;

	on_error:
	git_vector_free_deep(&commits);
	return error;
	}

	static int add_update(git_push push, push_spec spec)
	{
	git_push_update *u = git__calloc(1, sizeof(git_push_update));
	GITERR_CHECK_ALLOC(u);

	u->src_refname = git__strdup(spec->refspec.src);
	GITERR_CHECK_ALLOC(u->src_refname);

	u->dst_refname = git__strdup(spec->refspec.dst);
	GITERR_CHECK_ALLOC(u->dst_refname);

	git_oid_cpy(&u->src, &spec->roid);
	git_oid_cpy(&u->dst, &spec->loid);

	return git_vector_insert(&push->updates, u);
	}

	static int calculate_work(git_push *push)
	{
	git_remote_head *head;
	push_spec *spec;
	unsigned int i, j;

	/* Update local and remote oids*/

	git_vector_foreach(&push->specs, i, spec) {
	if (spec->refspec.src && spec->refspec.src[0]!= '\0') {
	/* This is a create or update. Local ref must exist. */
	if (git_reference_name_to_id(
	&spec->loid, push->repo, spec->refspec.src) < 0) {
	giterr_set(GITERR_REFERENCE, "no such reference '%s'", spec->refspec.src);
	return -1;
	}
	}

	/* Remote ref may or may not (e.g. during create) already exist. */
	git_vector_foreach(&push->remote->refs, j, head) {
	if (!strcmp(spec->refspec.dst, head->name)) {
	git_oid_cpy(&spec->roid, &head->oid);
	break;
	}
	}

	if (add_update(push, spec) < 0)
	return -1;
	}

	return 0;
	}

	static int do_push(git_push push, const git_remote_callbacks callbacks)
	{
	int error = 0;
	git_transport *transport = push->remote->transport;

	if (!transport->push) {
	giterr_set(GITERR_NET, "remote transport doesn't support push");
	error = -1;
	goto on_error;
	}

	/*
	* A pack-file MUST be sent if either create or update command
	* is used, even if the server already has all the necessary
	* objects. In this case the client MUST send an empty pack-file.
	*/

	if ((error = git_packbuilder_new(&push->pb, push->repo)) < 0)
	goto on_error;

	git_packbuilder_set_threads(push->pb, push->pb_parallelism);

	if (callbacks && callbacks->pack_progress)
	if ((error = git_packbuilder_set_callbacks(push->pb, callbacks->pack_progress, callbacks->payload)) < 0)
	goto on_error;

	if ((error = calculate_work(push)) < 0)
	goto on_error;

	if (callbacks && callbacks->push_negotiation &&
	(error = callbacks->push_negotiation((const git_push_update **) push->updates.contents,
	push->updates.length, callbacks->payload)) < 0)
	goto on_error;

	if ((error = queue_objects(push)) < 0 \|\|
	(error = transport->push(transport, push, callbacks)) < 0)
	goto on_error;

	on_error:
	git_packbuilder_free(push->pb);
	return error;
	}

	static int filter_refs(git_remote *remote)
	{
	const git_remote_head **heads;
	size_t heads_len, i;

	git_vector_clear(&remote->refs);

	if (git_remote_ls(&heads, &heads_len, remote) < 0)
	return -1;

	for (i = 0; i < heads_len; i++) {
	if (git_vector_insert(&remote->refs, (void *)heads[i]) < 0)
	return -1;
	}

	return 0;
	}

	int git_push_finish(git_push push, const git_remote_callbacks callbacks)
	{
	int error;

	if (!git_remote_connected(push->remote) &&
	(error = git_remote_connect(push->remote, GIT_DIRECTION_PUSH, callbacks, NULL, push->custom_headers)) < 0)
	return error;

	if ((error = filter_refs(push->remote)) < 0 \|\|
	(error = do_push(push, callbacks)) < 0)
	return error;

	if (!push->unpack_ok) {
	error = -1;
	giterr_set(GITERR_NET, "unpacking the sent packfile failed on the remote");
	}

	return error;
	}

	int git_push_status_foreach(git_push *push,
	int (cb)(const char ref, const char msg, void data),
	void *data)
	{
	push_status *status;
	unsigned int i;

	git_vector_foreach(&push->status, i, status) {
	int error = cb(status->ref, status->msg, data);
	if (error)
	return giterr_set_after_callback(error);
	}

	return 0;
	}

	void git_push_status_free(push_status *status)
	{
	if (status == NULL)
	return;

	git__free(status->msg);
	git__free(status->ref);
	git__free(status);
	}

	void git_push_free(git_push *push)
	{
	push_spec *spec;
	push_status *status;
	git_push_update *update;
	unsigned int i;

	if (push == NULL)
	return;

	git_vector_foreach(&push->specs, i, spec) {
	free_refspec(spec);
	}
	git_vector_free(&push->specs);

	git_vector_foreach(&push->status, i, status) {
	git_push_status_free(status);
	}
	git_vector_free(&push->status);

	git_vector_foreach(&push->updates, i, update) {
	git__free(update->src_refname);
	git__free(update->dst_refname);
	git__free(update);
	}
	git_vector_free(&push->updates);

	git__free(push);
	}

	int git_push_init_options(git_push_options *opts, unsigned int version)
	{
	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
	opts, version, git_push_options, GIT_PUSH_OPTIONS_INIT);
	return 0;
	}