[libgit2.git] / src / push.c

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

#include "git2.h"

#include "pack.h"
#include "pack-objects.h"
#include "remote.h"
#include "vector.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));
	GIT_ERROR_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;

	GIT_ERROR_CHECK_VERSION(opts, GIT_PUSH_OPTIONS_VERSION, "git_push_options");

	push->pb_parallelism = opts->pb_parallelism;
	push->connection.custom_headers = &opts->custom_headers;
	push->connection.proxy = &opts->proxy_opts;

	return 0;
}

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

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

static int check_rref(char *ref)
{
	if (git__prefixcmp(ref, "refs/")) {
		git_error_set(GIT_ERROR_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)
		git_error_set(GIT_ERROR_REFERENCE,
			"src refspec '%s' does not match any existing object", ref);
	else
		git_error_set(GIT_ERROR_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));
	GIT_ERROR_CHECK_ALLOC(s);

	if (git_refspec__parse(&s->refspec, str, false) < 0) {
		git_error_set(GIT_ERROR_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;

		/* Clear the buffer which can be dirty from previous iteration */
		git_buf_clear(&remote_ref_name);

		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;

			git_error_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_dispose(&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_OBJECT_TAG)) < 0)
		return error;

	while (git_object_type(obj) == GIT_OBJECT_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 queue_objects(git_push *push)
{
	git_remote_head *head;
	push_spec *spec;
	git_revwalk *rw;
	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_object_t 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_OBJECT_TAG) {
			git_object *target;

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

			if (git_object_type(target) == GIT_OBJECT_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)) {
				git_error_set(GIT_ERROR_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))) {
				git_error_set(GIT_ERROR_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);
	}

	error = git_packbuilder_insert_walk(push->pb, rw);

on_error:
	git_revwalk_free(rw);
	return error;
}

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

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

	u->dst_refname = git__strdup(spec->refspec.dst);
	GIT_ERROR_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) {
				git_error_set(GIT_ERROR_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) {
		git_error_set(GIT_ERROR_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, &push->connection)) < 0)
		return error;

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

	if (!push->unpack_ok) {
		error = -1;
		git_error_set(GIT_ERROR_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 git_error_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;
}
Commit	Line	Data
613d5eb9	1	/*
359fc2d2	2	* Copyright (C) the libgit2 contributors. All rights reserved.
613d5eb9 PK	3	*
	4	* This file is part of libgit2, distributed under the GNU GPL v2 with
	5	* a Linking Exception. For full terms see the included COPYING file.
	6	*/
	7
eae0bfdc PP	8	#include "push.h"
eae0bfdc PP	9
613d5eb9 PK	10	#include "git2.h"
613d5eb9 PK	11
613d5eb9 PK	12	#include "pack.h"
	13	#include "pack-objects.h"
	14	#include "remote.h"
	15	#include "vector.h"
799f9a04	16	#include "tree.h"
613d5eb9	17
df93a681 PK	18	static int push_spec_rref_cmp(const void a, const void b)
	19	{
	20	const push_spec push_spec_a = a, push_spec_b = b;
	21
aad638f3	22	return strcmp(push_spec_a->refspec.dst, push_spec_b->refspec.dst);
df93a681 PK	23	}
	24
	25	static int push_status_ref_cmp(const void a, const void b)
	26	{
	27	const push_status push_status_a = a, push_status_b = b;
	28
	29	return strcmp(push_status_a->ref, push_status_b->ref);
	30	}
	31
613d5eb9 PK	32	int git_push_new(git_push *out, git_remote remote)
	33	{
	34	git_push *p;
	35
	36	*out = NULL;
	37
	38	p = git__calloc(1, sizeof(*p));
ac3d33df	39	GIT_ERROR_CHECK_ALLOC(p);
613d5eb9 PK	40
	41	p->repo = remote->repo;
	42	p->remote = remote;
	43	p->report_status = 1;
b8b897bb	44	p->pb_parallelism = 1;
613d5eb9	45
df93a681	46	if (git_vector_init(&p->specs, 0, push_spec_rref_cmp) < 0) {
613d5eb9 PK	47	git__free(p);
	48	return -1;
	49	}
	50
df93a681	51	if (git_vector_init(&p->status, 0, push_status_ref_cmp) < 0) {
613d5eb9 PK	52	git_vector_free(&p->specs);
	53	git__free(p);
	54	return -1;
	55	}
	56
efc2fec5 CMN	57	if (git_vector_init(&p->updates, 0, NULL) < 0) {
	58	git_vector_free(&p->status);
	59	git_vector_free(&p->specs);
	60	git__free(p);
	61	return -1;
	62	}
	63
613d5eb9 PK	64	*out = p;
	65	return 0;
	66	}
	67
b8b897bb PK	68	int git_push_set_options(git_push push, const git_push_options opts)
	69	{
	70	if (!push \|\| !opts)
	71	return -1;
	72
ac3d33df	73	GIT_ERROR_CHECK_VERSION(opts, GIT_PUSH_OPTIONS_VERSION, "git_push_options");
b8b897bb PK	74
b8b897bb PK	75	push->pb_parallelism = opts->pb_parallelism;
ac3d33df JK	76	push->connection.custom_headers = &opts->custom_headers;
ac3d33df JK	77	push->connection.proxy = &opts->proxy_opts;
b8b897bb PK	78
	79	return 0;
	80	}
	81
613d5eb9 PK	82	static void free_refspec(push_spec *spec)
	83	{
	84	if (spec == NULL)
	85	return;
	86
ac3d33df	87	git_refspec__dispose(&spec->refspec);
613d5eb9 PK	88	git__free(spec);
	89	}
	90
087f64d3	91	static int check_rref(char *ref)
613d5eb9	92	{
087f64d3	93	if (git__prefixcmp(ref, "refs/")) {
ac3d33df	94	git_error_set(GIT_ERROR_INVALID, "not a valid reference '%s'", ref);
613d5eb9 PK	95	return -1;
613d5eb9 PK	96	}
087f64d3	97
613d5eb9 PK	98	return 0;
	99	}
	100
087f64d3 JM	101	static int check_lref(git_push push, char ref)
	102	{
	103	/* lref must be resolvable to an existing object */
	104	git_object *obj;
	105	int error = git_revparse_single(&obj, push->repo, ref);
2ebc3c66	106	git_object_free(obj);
087f64d3	107
1aa21fe3 BS	108	if (!error)
1aa21fe3 BS	109	return 0;
087f64d3	110
1aa21fe3	111	if (error == GIT_ENOTFOUND)
ac3d33df	112	git_error_set(GIT_ERROR_REFERENCE,
1aa21fe3 BS	113	"src refspec '%s' does not match any existing object", ref);
1aa21fe3 BS	114	else
ac3d33df	115	git_error_set(GIT_ERROR_INVALID, "not a valid reference '%s'", ref);
1aa21fe3	116	return -1;
087f64d3 JM	117	}
	118
	119	static int parse_refspec(git_push push, push_spec spec, const char str)
613d5eb9 PK	120	{
613d5eb9 PK	121	push_spec *s;
613d5eb9 PK	122
	123	*spec = NULL;
	124
	125	s = git__calloc(1, sizeof(*s));
ac3d33df	126	GIT_ERROR_CHECK_ALLOC(s);
613d5eb9	127
aad638f3	128	if (git_refspec__parse(&s->refspec, str, false) < 0) {
ac3d33df	129	git_error_set(GIT_ERROR_INVALID, "invalid refspec %s", str);
aad638f3	130	goto on_error;
613d5eb9 PK	131	}
613d5eb9 PK	132
aad638f3 CMN	133	if (s->refspec.src && s->refspec.src[0] != '\0' &&
	134	check_lref(push, s->refspec.src) < 0) {
	135	goto on_error;
613d5eb9 PK	136	}
613d5eb9 PK	137
aad638f3	138	if (check_rref(s->refspec.dst) < 0)
613d5eb9 PK	139	goto on_error;
613d5eb9 PK	140
613d5eb9 PK	141	*spec = s;
	142	return 0;
	143
	144	on_error:
	145	free_refspec(s);
	146	return -1;
	147	}
	148
	149	int git_push_add_refspec(git_push push, const char refspec)
	150	{
	151	push_spec *spec;
	152
087f64d3	153	if (parse_refspec(push, &spec, refspec) < 0 \|\|
613d5eb9 PK	154	git_vector_insert(&push->specs, spec) < 0)
	155	return -1;
	156
	157	return 0;
	158	}
	159
8f0104ec	160	int git_push_update_tips(git_push push, const git_remote_callbacks callbacks)
1d645aab	161	{
1d645aab JM	162	git_buf remote_ref_name = GIT_BUF_INIT;
1d645aab JM	163	size_t i, j;
4330ab26	164	git_refspec *fetch_spec;
e583334c	165	push_spec *push_spec = NULL;
1d645aab JM	166	git_reference *remote_ref;
	167	push_status *status;
	168	int error = 0;
	169
	170	git_vector_foreach(&push->status, i, status) {
321d377a	171	int fire_callback = 1;
1d645aab	172
e22ffb42 POL	173	/* Skip unsuccessful updates which have non-empty messages */
	174	if (status->msg)
	175	continue;
	176
1d645aab	177	/* Find the corresponding remote ref */
4330ab26 CMN	178	fetch_spec = git_remote__matching_refspec(push->remote, status->ref);
4330ab26 CMN	179	if (!fetch_spec)
1d645aab JM	180	continue;
1d645aab JM	181
eae0bfdc PP	182	/* Clear the buffer which can be dirty from previous iteration */
	183	git_buf_clear(&remote_ref_name);
	184
bf522e08	185	if ((error = git_refspec_transform(&remote_ref_name, fetch_spec, status->ref)) < 0)
1d645aab JM	186	goto on_error;
	187
	188	/* Find matching push ref spec */
	189	git_vector_foreach(&push->specs, j, push_spec) {
aad638f3	190	if (!strcmp(push_spec->refspec.dst, status->ref))
1d645aab JM	191	break;
	192	}
	193
	194	/* Could not find the corresponding push ref spec for this push update */
	195	if (j == push->specs.length)
	196	continue;
	197
e22ffb42 POL	198	/* Update the remote ref */
	199	if (git_oid_iszero(&push_spec->loid)) {
	200	error = git_reference_lookup(&remote_ref, push->remote->repo, git_buf_cstr(&remote_ref_name));
	201
	202	if (error >= 0) {
	203	error = git_reference_delete(remote_ref);
	204	git_reference_free(remote_ref);
321d377a	205	}
e22ffb42 POL	206	} else {
	207	error = git_reference_create(NULL, push->remote->repo,
	208	git_buf_cstr(&remote_ref_name), &push_spec->loid, 1,
	209	"update by push");
321d377a JG	210	}
	211
	212	if (error < 0) {
	213	if (error != GIT_ENOTFOUND)
1d645aab	214	goto on_error;
321d377a	215
ac3d33df	216	git_error_clear();
321d377a JG	217	fire_callback = 0;
	218	}
	219
8f0104ec CMN	220	if (fire_callback && callbacks && callbacks->update_tips) {
	221	error = callbacks->update_tips(git_buf_cstr(&remote_ref_name),
	222	&push_spec->roid, &push_spec->loid, callbacks->payload);
321d377a JG	223
	224	if (error < 0)
	225	goto on_error;
	226	}
1d645aab JM	227	}
	228
	229	error = 0;
	230
	231	on_error:
ac3d33df	232	git_buf_dispose(&remote_ref_name);
1d645aab JM	233	return error;
	234	}
	235
5ce6c1e9 CMN	236	/**
	237	* Insert all tags until we find a non-tag object, which is returned
	238	* in `out`.
	239	*/
	240	static int enqueue_tag(git_object *out, git_push push, git_oid *id)
	241	{
	242	git_object obj = NULL, target = NULL;
	243	int error;
	244
ac3d33df	245	if ((error = git_object_lookup(&obj, push->repo, id, GIT_OBJECT_TAG)) < 0)
5ce6c1e9 CMN	246	return error;
5ce6c1e9 CMN	247
ac3d33df	248	while (git_object_type(obj) == GIT_OBJECT_TAG) {
5ce6c1e9 CMN	249	if ((error = git_packbuilder_insert(push->pb, git_object_id(obj), NULL)) < 0)
	250	break;
	251
	252	if ((error = git_tag_target(&target, (git_tag *) obj)) < 0)
	253	break;
	254
	255	git_object_free(obj);
	256	obj = target;
	257	}
	258
	259	if (error < 0)
	260	git_object_free(obj);
	261	else
	262	*out = obj;
	263
	264	return error;
	265	}
	266
eae0bfdc	267	static int queue_objects(git_push *push)
613d5eb9 PK	268	{
	269	git_remote_head *head;
	270	push_spec *spec;
	271	git_revwalk *rw;
613d5eb9 PK	272	unsigned int i;
	273	int error = -1;
	274
	275	if (git_revwalk_new(&rw, push->repo) < 0)
	276	return -1;
	277
	278	git_revwalk_sorting(rw, GIT_SORT_TIME);
	279
	280	git_vector_foreach(&push->specs, i, spec) {
ac3d33df	281	git_object_t type;
abeefbbe MS	282	size_t size;
abeefbbe MS	283
613d5eb9 PK	284	if (git_oid_iszero(&spec->loid))
	285	/*
	286	* Delete reference on remote side;
	287	* nothing to do here.
	288	*/
	289	continue;
	290
	291	if (git_oid_equal(&spec->loid, &spec->roid))
	292	continue; /* up-to-date */
	293
abeefbbe MS	294	if (git_odb_read_header(&size, &type, push->repo->_odb, &spec->loid) < 0)
	295	goto on_error;
	296
ac3d33df	297	if (type == GIT_OBJECT_TAG) {
abeefbbe MS	298	git_object *target;
abeefbbe MS	299
5ce6c1e9	300	if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
abeefbbe	301	goto on_error;
abeefbbe	302
ac3d33df	303	if (git_object_type(target) == GIT_OBJECT_COMMIT) {
abeefbbe MS	304	if (git_revwalk_push(rw, git_object_id(target)) < 0) {
	305	git_object_free(target);
	306	goto on_error;
	307	}
	308	} else {
	309	if (git_packbuilder_insert(
	310	push->pb, git_object_id(target), NULL) < 0) {
	311	git_object_free(target);
	312	goto on_error;
	313	}
	314	}
	315	git_object_free(target);
	316	} else if (git_revwalk_push(rw, &spec->loid) < 0)
613d5eb9 PK	317	goto on_error;
613d5eb9 PK	318
aad638f3	319	if (!spec->refspec.force) {
613d5eb9 PK	320	git_oid base;
	321
	322	if (git_oid_iszero(&spec->roid))
	323	continue;
	324
	325	if (!git_odb_exists(push->repo->_odb, &spec->roid)) {
ac3d33df	326	git_error_set(GIT_ERROR_REFERENCE,
909d5494	327	"cannot push because a reference that you are trying to update on the remote contains commits that are not present locally.");
613d5eb9 PK	328	error = GIT_ENONFASTFORWARD;
	329	goto on_error;
	330	}
	331
	332	error = git_merge_base(&base, push->repo,
	333	&spec->loid, &spec->roid);
	334
	335	if (error == GIT_ENOTFOUND \|\|
	336	(!error && !git_oid_equal(&base, &spec->roid))) {
ac3d33df	337	git_error_set(GIT_ERROR_REFERENCE,
909d5494	338	"cannot push non-fastforwardable reference");
613d5eb9 PK	339	error = GIT_ENONFASTFORWARD;
	340	goto on_error;
	341	}
	342
	343	if (error < 0)
	344	goto on_error;
	345	}
	346	}
	347
	348	git_vector_foreach(&push->remote->refs, i, head) {
	349	if (git_oid_iszero(&head->oid))
	350	continue;
	351
	352	/* TODO */
	353	git_revwalk_hide(rw, &head->oid);
	354	}
	355
eae0bfdc	356	error = git_packbuilder_insert_walk(push->pb, rw);
613d5eb9 PK	357
	358	on_error:
	359	git_revwalk_free(rw);
613d5eb9 PK	360	return error;
	361	}
	362
efc2fec5 CMN	363	static int add_update(git_push push, push_spec spec)
	364	{
	365	git_push_update *u = git__calloc(1, sizeof(git_push_update));
ac3d33df	366	GIT_ERROR_CHECK_ALLOC(u);
efc2fec5 CMN	367
efc2fec5 CMN	368	u->src_refname = git__strdup(spec->refspec.src);
ac3d33df	369	GIT_ERROR_CHECK_ALLOC(u->src_refname);
254ff3e9 CMN	370
254ff3e9 CMN	371	u->dst_refname = git__strdup(spec->refspec.dst);
ac3d33df	372	GIT_ERROR_CHECK_ALLOC(u->dst_refname);
efc2fec5	373
254ff3e9 CMN	374	git_oid_cpy(&u->src, &spec->roid);
254ff3e9 CMN	375	git_oid_cpy(&u->dst, &spec->loid);
efc2fec5 CMN	376
	377	return git_vector_insert(&push->updates, u);
	378	}
	379
613d5eb9 PK	380	static int calculate_work(git_push *push)
	381	{
	382	git_remote_head *head;
	383	push_spec *spec;
	384	unsigned int i, j;
	385
4128f5aa CW	386	/* Update local and remote oids*/
4128f5aa CW	387
613d5eb9	388	git_vector_foreach(&push->specs, i, spec) {
aad638f3	389	if (spec->refspec.src && spec->refspec.src[0]!= '\0') {
4128f5aa	390	/* This is a create or update. Local ref must exist. */
613d5eb9	391	if (git_reference_name_to_id(
aad638f3	392	&spec->loid, push->repo, spec->refspec.src) < 0) {
ac3d33df	393	git_error_set(GIT_ERROR_REFERENCE, "no such reference '%s'", spec->refspec.src);
613d5eb9 PK	394	return -1;
613d5eb9 PK	395	}
4128f5aa	396	}
613d5eb9	397
aad638f3 CMN	398	/* Remote ref may or may not (e.g. during create) already exist. */
	399	git_vector_foreach(&push->remote->refs, j, head) {
	400	if (!strcmp(spec->refspec.dst, head->name)) {
	401	git_oid_cpy(&spec->roid, &head->oid);
	402	break;
613d5eb9 PK	403	}
613d5eb9 PK	404	}
efc2fec5 CMN	405
	406	if (add_update(push, spec) < 0)
	407	return -1;
613d5eb9 PK	408	}
	409
	410	return 0;
	411	}
	412
8f0104ec	413	static int do_push(git_push push, const git_remote_callbacks callbacks)
613d5eb9	414	{
5b188225	415	int error = 0;
613d5eb9 PK	416	git_transport *transport = push->remote->transport;
613d5eb9 PK	417
9bf56c7b	418	if (!transport->push) {
ac3d33df	419	git_error_set(GIT_ERROR_NET, "remote transport doesn't support push");
9bf56c7b SB	420	error = -1;
	421	goto on_error;
	422	}
	423
613d5eb9 PK	424	/*
	425	* A pack-file MUST be sent if either create or update command
	426	* is used, even if the server already has all the necessary
	427	* objects. In this case the client MUST send an empty pack-file.
	428	*/
	429
b8b897bb PK	430	if ((error = git_packbuilder_new(&push->pb, push->repo)) < 0)
	431	goto on_error;
	432
	433	git_packbuilder_set_threads(push->pb, push->pb_parallelism);
	434
8f0104ec CMN	435	if (callbacks && callbacks->pack_progress)
8f0104ec CMN	436	if ((error = git_packbuilder_set_callbacks(push->pb, callbacks->pack_progress, callbacks->payload)) < 0)
b176eded JM	437	goto on_error;
b176eded JM	438
efc2fec5 CMN	439	if ((error = calculate_work(push)) < 0)
	440	goto on_error;
	441
8f0104ec CMN	442	if (callbacks && callbacks->push_negotiation &&
	443	(error = callbacks->push_negotiation((const git_push_update **) push->updates.contents,
	444	push->updates.length, callbacks->payload)) < 0)
efc2fec5 CMN	445	goto on_error;
	446
	447	if ((error = queue_objects(push)) < 0 \|\|
8f0104ec	448	(error = transport->push(transport, push, callbacks)) < 0)
613d5eb9 PK	449	goto on_error;
613d5eb9 PK	450
613d5eb9 PK	451	on_error:
	452	git_packbuilder_free(push->pb);
	453	return error;
	454	}
	455
613d5eb9 PK	456	static int filter_refs(git_remote *remote)
613d5eb9 PK	457	{
98eaf39a	458	const git_remote_head **heads;
359dce72 CMN	459	size_t heads_len, i;
359dce72 CMN	460
613d5eb9	461	git_vector_clear(&remote->refs);
359dce72 CMN	462
	463	if (git_remote_ls(&heads, &heads_len, remote) < 0)
	464	return -1;
	465
	466	for (i = 0; i < heads_len; i++) {
98eaf39a	467	if (git_vector_insert(&remote->refs, (void *)heads[i]) < 0)
359dce72 CMN	468	return -1;
	469	}
	470
	471	return 0;
613d5eb9 PK	472	}
613d5eb9 PK	473
8f0104ec	474	int git_push_finish(git_push push, const git_remote_callbacks callbacks)
613d5eb9 PK	475	{
	476	int error;
	477
	478	if (!git_remote_connected(push->remote) &&
ac3d33df	479	(error = git_remote__connect(push->remote, GIT_DIRECTION_PUSH, callbacks, &push->connection)) < 0)
613d5eb9 PK	480	return error;
	481
	482	if ((error = filter_refs(push->remote)) < 0 \|\|
8f0104ec	483	(error = do_push(push, callbacks)) < 0)
613d5eb9 PK	484	return error;
613d5eb9 PK	485
d524b2d3 CMN	486	if (!push->unpack_ok) {
d524b2d3 CMN	487	error = -1;
ac3d33df	488	git_error_set(GIT_ERROR_NET, "unpacking the sent packfile failed on the remote");
d524b2d3	489	}
613d5eb9	490
d524b2d3	491	return error;
613d5eb9 PK	492	}
	493
	494	int git_push_status_foreach(git_push *push,
	495	int (cb)(const char ref, const char msg, void data),
	496	void *data)
	497	{
	498	push_status *status;
	499	unsigned int i;
	500
	501	git_vector_foreach(&push->status, i, status) {
c7b3e1b3 RB	502	int error = cb(status->ref, status->msg, data);
c7b3e1b3 RB	503	if (error)
ac3d33df	504	return git_error_set_after_callback(error);
613d5eb9 PK	505	}
	506
	507	return 0;
	508	}
	509
20858f6e	510	void git_push_status_free(push_status *status)
	511	{
	512	if (status == NULL)
	513	return;
	514
be6996b7	515	git__free(status->msg);
20858f6e	516	git__free(status->ref);
	517	git__free(status);
	518	}
	519
613d5eb9 PK	520	void git_push_free(git_push *push)
	521	{
	522	push_spec *spec;
	523	push_status *status;
3251972e	524	git_push_update *update;
613d5eb9 PK	525	unsigned int i;
	526
	527	if (push == NULL)
	528	return;
	529
	530	git_vector_foreach(&push->specs, i, spec) {
	531	free_refspec(spec);
	532	}
	533	git_vector_free(&push->specs);
	534
	535	git_vector_foreach(&push->status, i, status) {
20858f6e	536	git_push_status_free(status);
613d5eb9 PK	537	}
	538	git_vector_free(&push->status);
	539
3251972e CMN	540	git_vector_foreach(&push->updates, i, update) {
	541	git__free(update->src_refname);
	542	git__free(update->dst_refname);
	543	git__free(update);
	544	}
	545	git_vector_free(&push->updates);
	546
613d5eb9 PK	547	git__free(push);
613d5eb9 PK	548	}
b9f81997	549
702efc89	550	int git_push_init_options(git_push_options *opts, unsigned int version)
b9f81997	551	{
702efc89 RB	552	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
	553	opts, version, git_push_options, GIT_PUSH_OPTIONS_INIT);
	554	return 0;
b9f81997	555	}