/*

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

#include "git2/types.h"

#include "git2/oid.h"

#include "git2/net.h"

#include "common.h"

#include "config.h"

#include "repository.h"

#include "remote.h"

#include "fetch.h"

#include "refs.h"

#include "refspec.h"

#include "fetchhead.h"

#include "push.h"

#define CONFIG_URL_FMT "remote.%s.url"

#define CONFIG_PUSHURL_FMT "remote.%s.pushurl"

#define CONFIG_FETCH_FMT "remote.%s.fetch"

#define CONFIG_PUSH_FMT "remote.%s.push"

#define CONFIG_TAGOPT_FMT "remote.%s.tagopt"

static int dwim_refspecs(git_vector *out, git_vector *refspecs, git_vector *refs);

static int lookup_remote_prune_config(git_remote *remote, git_config *config, const char *name);

char *apply_insteadof(git_config *config, const char *url, int direction);

static int add_refspec_to(git_vector *vector, const char *string, bool is_fetch)

{

	git_refspec *spec;

	spec = git__calloc(1, sizeof(git_refspec));

	GITERR_CHECK_ALLOC(spec);

	if (git_refspec__parse(spec, string, is_fetch) < 0) {

		git__free(spec);

		return -1;

	}

	spec->push = !is_fetch;

	if (git_vector_insert(vector, spec) < 0) {

		git_refspec__free(spec);

		git__free(spec);

		return -1;

	}

	return 0;

}

static int add_refspec(git_remote *remote, const char *string, bool is_fetch)

{

	return add_refspec_to(&remote->refspecs, string, is_fetch);

}

static int download_tags_value(git_remote *remote, git_config *cfg)

{

	git_config_entry *ce;

	git_buf buf = GIT_BUF_INIT;

	int error;

	if (git_buf_printf(&buf, "remote.%s.tagopt", remote->name) < 0)

		return -1;

	error = git_config__lookup_entry(&ce, cfg, git_buf_cstr(&buf), false);

	git_buf_free(&buf;;

	if (!error && ce && ce->value) {

		if (!strcmp(ce->value, "--no-tags"))

			remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_NONE;

		else if (!strcmp(ce->value, "--tags"))

			remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;

	}

	git_config_entry_free(ce);

	return error;

}

static int ensure_remote_name_is_valid(const char *name)

{

	int error = 0;

	if (!git_remote_is_valid_name(name)) {

		giterr_set(

			GITERR_CONFIG,

			"'%s' is not a valid remote name.", name ? name : "(null)");

		error = GIT_EINVALIDSPEC;

	}

	return error;

}

static int write_add_refspec(git_repository *repo, const char *name, const char *refspec, bool fetch)

{

	git_config *cfg;

	git_buf var = GIT_BUF_INIT;

	git_refspec spec;

	const char *fmt;

	int error;

	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)

	    return error;

	fmt = fetch ? CONFIG_FETCH_FMT : CONFIG_PUSH_FMT;

	if ((error = ensure_remote_name_is_valid(name)) < 0)

		return error;

	if ((error = git_refspec__parse(&spec, refspec, fetch)) < 0) {

		if (giterr_last()->klass != GITERR_NOMEMORY)

			error = GIT_EINVALIDSPEC;

		return error;

	}

	git_refspec__free(&spec);

	if ((error = git_buf_printf(&var, fmt, name)) < 0)

		return error;

	/*

	 * "$^" is a unmatcheable regexp: it will not match anything at all, so

	 * all values will be considered new and we will not replace any

	 * present value.

	 */

	if ((error = git_config_set_multivar(cfg, var.ptr, "$^", refspec)) < 0) {

		goto cleanup;

	}

cleanup:

	git_buf_free(&var);

	return 0;

}

#if 0

/* We could export this as a helper */

static int get_check_cert(int *out, git_repository *repo)

{

	git_config *cfg;

	const char *val;

	int error = 0;

	assert(out && repo);

	/* By default, we *DO* want to verify the certificate. */

	*out = 1;

	/* Go through the possible sources for SSL verification settings, from

	 * most specific to least specific. */

	/* GIT_SSL_NO_VERIFY environment variable */

	if ((val = p_getenv("GIT_SSL_NO_VERIFY")) != NULL)

		return git_config_parse_bool(out, val);

	/* http.sslVerify config setting */

	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)

		return error;

	*out = git_config__get_bool_force(cfg, "http.sslverify", 1);

	return 0;

}

#endif

static int canonicalize_url(git_buf *out, const char *in)

{

	if (in == NULL || strlen(in) == 0) {

		giterr_set(GITERR_INVALID, "cannot set empty URL");

		return GIT_EINVALIDSPEC;

	}

#ifdef GIT_WIN32

	/* Given a UNC path like \\server\path, we need to convert this

	 * to //server/path for compatibility with core git.

	 */

	if (in[0] == '\\' && in[1] == '\\' &&

		(git__isalpha(in[2]) || git__isdigit(in[2]))) {

		const char *c;

		for (c = in; *c; c++)

			git_buf_putc(out, *c == '\\' ? '/' : *c);

		return git_buf_oom(out) ? -1 : 0;

	}

#endif

	return git_buf_puts(out, in);

}

static int create_internal(git_remote **out, git_repository *repo, const char *name, const char *url, const char *fetch)

{

	git_remote *remote;

	git_config *config_ro = NULL, *config_rw;

	git_buf canonical_url = GIT_BUF_INIT;

	git_buf var = GIT_BUF_INIT;

	int error = -1;

	/* name is optional */

	assert(out && repo && url);

	if ((error = git_repository_config_snapshot(&config_ro, repo)) < 0)

		return error;

	remote = git__calloc(1, sizeof(git_remote));

	GITERR_CHECK_ALLOC(remote);

	remote->repo = repo;

	if ((error = git_vector_init(&remote->refs, 32, NULL)) < 0 ||

		(error = canonicalize_url(&canonical_url, url)) < 0)

		goto on_error;

	remote->url = apply_insteadof(config_ro, canonical_url.ptr, GIT_DIRECTION_FETCH);

	GITERR_CHECK_ALLOC(remote->url);

	if (name != NULL) {

		remote->name = git__strdup(name);

		GITERR_CHECK_ALLOC(remote->name);

		if ((error = git_buf_printf(&var, CONFIG_URL_FMT, name)) < 0)

			goto on_error;

		if ((error = git_repository_config__weakptr(&config_rw, repo)) < 0 ||

			(error = git_config_set_string(config_rw, var.ptr, canonical_url.ptr)) < 0)

			goto on_error;

	}

	if (fetch != NULL) {

		if ((error = add_refspec(remote, fetch, true)) < 0)

			goto on_error;

		/* only write for non-anonymous remotes */

		if (name && (error = write_add_refspec(repo, name, fetch, true)) < 0)

			goto on_error;

		if ((error = lookup_remote_prune_config(remote, config_ro, name)) < 0)

			goto on_error;

		/* Move the data over to where the matching functions can find them */

		if ((error = dwim_refspecs(&remote->active_refspecs, &remote->refspecs, &remote->refs)) < 0)

			goto on_error;

	}

	/* A remote without a name doesn't download tags */

	if (!name)

		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_NONE;

	else

		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_AUTO;

	git_buf_free(&var);

	*out = remote;

	error = 0;

on_error:

	if (error)

		git_remote_free(remote);

	git_config_free(config_ro);

	git_buf_free(&canonical_url);

	git_buf_free(&var);

	return error;

}

static int ensure_remote_doesnot_exist(git_repository *repo, const char *name)

{

	int error;

	git_remote *remote;

	error = git_remote_lookup(&remote, repo, name);

	if (error == GIT_ENOTFOUND)

		return 0;

	if (error < 0)

		return error;

	git_remote_free(remote);

	giterr_set(

		GITERR_CONFIG,

		"remote '%s' already exists", name);

	return GIT_EEXISTS;

}

int git_remote_create(git_remote **out, git_repository *repo, const char *name, const char *url)

{

	git_buf buf = GIT_BUF_INIT;

	int error;

	if (git_buf_printf(&buf, "+refs/heads/*:refs/remotes/%s/*", name) < 0)

		return -1;

	error = git_remote_create_with_fetchspec(out, repo, name, url, git_buf_cstr(&buf));

	git_buf_free(&buf;;

	return error;

}

int git_remote_create_with_fetchspec(git_remote **out, git_repository *repo, const char *name, const char *url, const char *fetch)

{

	git_remote *remote = NULL;

	int error;

	if ((error = ensure_remote_name_is_valid(name)) < 0)

		return error;

	if ((error = ensure_remote_doesnot_exist(repo, name)) < 0)

		return error;

	if (create_internal(&remote, repo, name, url, fetch) < 0)

		goto on_error;

	*out = remote;

	return 0;

on_error:

	git_remote_free(remote);

	return -1;

}

int git_remote_create_anonymous(git_remote **out, git_repository *repo, const char *url)

{

	return create_internal(out, repo, NULL, url, NULL);

}

int git_remote_dup(git_remote **dest, git_remote *source)

{

	size_t i;

	int error = 0;

	git_refspec *spec;

	git_remote *remote = git__calloc(1, sizeof(git_remote));

	GITERR_CHECK_ALLOC(remote);

	if (source->name != NULL) {

		remote->name = git__strdup(source->name);

		GITERR_CHECK_ALLOC(remote->name);

	}

	if (source->url != NULL) {

		remote->url = git__strdup(source->url);

		GITERR_CHECK_ALLOC(remote->url);

	}

	if (source->pushurl != NULL) {

		remote->pushurl = git__strdup(source->pushurl);

		GITERR_CHECK_ALLOC(remote->pushurl);

	}

	remote->repo = source->repo;

	remote->download_tags = source->download_tags;

	remote->prune_refs = source->prune_refs;

	if (git_vector_init(&remote->refs, 32, NULL) < 0 ||

	    git_vector_init(&remote->refspecs, 2, NULL) < 0 ||

	    git_vector_init(&remote->active_refspecs, 2, NULL) < 0) {

		error = -1;

		goto cleanup;

	}

	git_vector_foreach(&source->refspecs, i, spec) {

		if ((error = add_refspec(remote, spec->string, !spec->push)) < 0)

			goto cleanup;

	}

	*dest = remote;

cleanup:

	if (error < 0)

		git__free(remote);

	return error;

}

struct refspec_cb_data {

	git_remote *remote;

	int fetch;

};

static int refspec_cb(const git_config_entry *entry, void *payload)

{

	struct refspec_cb_data *data = (struct refspec_cb_data *)payload;

	return add_refspec(data->remote, entry->value, data->fetch);

}

static int get_optional_config(

	bool *found, git_config *config, git_buf *buf,

	git_config_foreach_cb cb, void *payload)

{

	int error = 0;

	const char *key = git_buf_cstr(buf);

	if (git_buf_oom(buf))

		return -1;

	if (cb != NULL)

		error = git_config_get_multivar_foreach(config, key, NULL, cb, payload);

	else

		error = git_config_get_string(payload, config, key);

	if (found)

		*found = !error;

	if (error == GIT_ENOTFOUND) {

		giterr_clear();

		error = 0;

	}

	return error;

}

int git_remote_lookup(git_remote **out, git_repository *repo, const char *name)

{

	git_remote *remote;

	git_buf buf = GIT_BUF_INIT;

	const char *val;

	int error = 0;

	git_config *config;

	struct refspec_cb_data data = { NULL };

	bool optional_setting_found = false, found;

	assert(out && repo && name);

	if ((error = ensure_remote_name_is_valid(name)) < 0)

		return error;

	if ((error = git_repository_config_snapshot(&config, repo)) < 0)

		return error;

	remote = git__calloc(1, sizeof(git_remote));

	GITERR_CHECK_ALLOC(remote);

	remote->name = git__strdup(name);

	GITERR_CHECK_ALLOC(remote->name);

	if (git_vector_init(&remote->refs, 32, NULL) < 0 ||

	    git_vector_init(&remote->refspecs, 2, NULL) < 0 ||

	    git_vector_init(&remote->passive_refspecs, 2, NULL) < 0 ||

	    git_vector_init(&remote->active_refspecs, 2, NULL) < 0) {

		error = -1;

		goto cleanup;

	}

	if ((error = git_buf_printf(&buf, "remote.%s.url", name)) < 0)

		goto cleanup;

	if ((error = get_optional_config(&found, config, &buf, NULL, (void *)&val)) < 0)

		goto cleanup;

	optional_setting_found |= found;

	remote->repo = repo;

	remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_AUTO;

	if (found && strlen(val) > 0) {

		remote->url = apply_insteadof(config, val, GIT_DIRECTION_FETCH);

		GITERR_CHECK_ALLOC(remote->url);

	}

	val = NULL;

	git_buf_clear(&buf;;

	git_buf_printf(&buf, "remote.%s.pushurl", name);

	if ((error = get_optional_config(&found, config, &buf, NULL, (void *)&val)) < 0)

		goto cleanup;

	optional_setting_found |= found;

	if (!optional_setting_found) {

		error = GIT_ENOTFOUND;

		giterr_set(GITERR_CONFIG, "remote '%s' does not exist", name);

		goto cleanup;

	}

	if (found && strlen(val) > 0) {

		remote->pushurl = apply_insteadof(config, val, GIT_DIRECTION_PUSH);

		GITERR_CHECK_ALLOC(remote->pushurl);

	}

	data.remote = remote;

	data.fetch = true;

	git_buf_clear(&buf;;

	git_buf_printf(&buf, "remote.%s.fetch", name);

	if ((error = get_optional_config(NULL, config, &buf, refspec_cb, &data)) < 0)

		goto cleanup;

	data.fetch = false;

	git_buf_clear(&buf;;

	git_buf_printf(&buf, "remote.%s.push", name);

	if ((error = get_optional_config(NULL, config, &buf, refspec_cb, &data)) < 0)

		goto cleanup;

	if (download_tags_value(remote, config) < 0)

		goto cleanup;

	if ((error = lookup_remote_prune_config(remote, config, name)) < 0)

		goto cleanup;

	/* Move the data over to where the matching functions can find them */

	if ((error = dwim_refspecs(&remote->active_refspecs, &remote->refspecs, &remote->refs)) < 0)

		goto cleanup;

	*out = remote;

cleanup:

	git_config_free(config);

	git_buf_free(&buf;;

	if (error < 0)

		git_remote_free(remote);

	return error;

}

static int lookup_remote_prune_config(git_remote *remote, git_config *config, const char *name)

{

	git_buf buf = GIT_BUF_INIT;

	int error = 0;

	git_buf_printf(&buf, "remote.%s.prune", name);

	if ((error = git_config_get_bool(&remote->prune_refs, config, git_buf_cstr(&buf))) < 0) {

		if (error == GIT_ENOTFOUND) {

			giterr_clear();

			if ((error = git_config_get_bool(&remote->prune_refs, config, "fetch.prune")) < 0) {

				if (error == GIT_ENOTFOUND) {

					giterr_clear();

					error = 0;

				}

			}

		}

	}

	git_buf_free(&buf;;

	return error;

}

const char *git_remote_name(const git_remote *remote)

{

	assert(remote);

	return remote->name;

}

git_repository *git_remote_owner(const git_remote *remote)

{

	assert(remote);

	return remote->repo;

}

const char *git_remote_url(const git_remote *remote)

{

	assert(remote);

	return remote->url;

}

static int set_url(git_repository *repo, const char *remote, const char *pattern, const char *url)

{

	git_config *cfg;

	git_buf buf = GIT_BUF_INIT, canonical_url = GIT_BUF_INIT;

	int error;

	assert(repo && remote);

	if ((error = ensure_remote_name_is_valid(remote)) < 0)

		return error;

	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)

		return error;

	if ((error = git_buf_printf(&buf, pattern, remote)) < 0)

		return error;

	if (url) {

		if ((error = canonicalize_url(&canonical_url, url)) < 0)

			goto cleanup;

		error = git_config_set_string(cfg, buf.ptr, url);

	} else {

		error = git_config_delete_entry(cfg, buf.ptr);

	}

cleanup:

	git_buf_free(&canonical_url);

	git_buf_free(&buf;;

	return error;

}

int git_remote_set_url(git_repository *repo, const char *remote, const char *url)

{

	return set_url(repo, remote, CONFIG_URL_FMT, url);

}

const char *git_remote_pushurl(const git_remote *remote)

{

	assert(remote);

	return remote->pushurl;

}

int git_remote_set_pushurl(git_repository *repo, const char *remote, const char* url)

{

	return set_url(repo, remote, CONFIG_PUSHURL_FMT, url);

}

const char* git_remote__urlfordirection(git_remote *remote, int direction)

{

	assert(remote);

	assert(direction == GIT_DIRECTION_FETCH || direction == GIT_DIRECTION_PUSH);

	if (direction == GIT_DIRECTION_FETCH) {

		return remote->url;

	}

	if (direction == GIT_DIRECTION_PUSH) {

		return remote->pushurl ? remote->pushurl : remote->url;

	}

	return NULL;

}

int set_transport_callbacks(git_transport *t, const git_remote_callbacks *cbs)

{

	if (!t->set_callbacks || !cbs)

		return 0;

	return t->set_callbacks(t, cbs->sideband_progress, NULL,

				cbs->certificate_check, cbs->payload);

}

static int set_transport_custom_headers(git_transport *t, const git_strarray *custom_headers)

{

	if (!t->set_custom_headers)

		return 0;

	return t->set_custom_headers(t, custom_headers);

}

int git_remote_connect(git_remote *remote, git_direction direction, const git_remote_callbacks *callbacks, const git_proxy_options *proxy, const git_strarray *custom_headers)

{

	git_transport *t;

	const char *url;

	int flags = GIT_TRANSPORTFLAGS_NONE;

	int error;

	void *payload = NULL;

	git_cred_acquire_cb credentials = NULL;

	git_transport_cb transport = NULL;

	assert(remote);

	if (callbacks) {

		GITERR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");

		credentials = callbacks->credentials;

		transport   = callbacks->transport;

		payload     = callbacks->payload;

	}

	if (proxy)

		GITERR_CHECK_VERSION(proxy, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");

	t = remote->transport;

	url = git_remote__urlfordirection(remote, direction);

	if (url == NULL) {

		giterr_set(GITERR_INVALID,

			"Malformed remote '%s' - missing URL", remote->name);

		return -1;

	}

	/* If we don't have a transport object yet, and the caller specified a

	 * custom transport factory, use that */

	if (!t && transport &&

		(error = transport(&t, remote, payload)) < 0)

		return error;

	/* If we still don't have a transport, then use the global

	 * transport registrations which map URI schemes to transport factories */

	if (!t && (error = git_transport_new(&t, remote, url)) < 0)

		return error;

	if ((error = set_transport_custom_headers(t, custom_headers)) != 0)

		goto on_error;

	if ((error = set_transport_callbacks(t, callbacks)) < 0 ||

	    (error = t->connect(t, url, credentials, payload, proxy, direction, flags)) != 0)

		goto on_error;

	remote->transport = t;

	return 0;

on_error:

	t->free(t);

	if (t == remote->transport)

		remote->transport = NULL;

	return error;

}

int git_remote_ls(const git_remote_head ***out, size_t *size, git_remote *remote)

{

	assert(remote);

	if (!remote->transport) {

		giterr_set(GITERR_NET, "this remote has never connected");

		return -1;

	}

	return remote->transport->ls(out, size, remote->transport);

}

int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_url)

{

	git_config *cfg;

	git_config_entry *ce = NULL;

	git_buf val = GIT_BUF_INIT;

	int error;

	assert(remote);

	if (!proxy_url || !remote->repo)

		return -1;

	*proxy_url = NULL;

	if ((error = git_repository_config__weakptr(&cfg, remote->repo)) < 0)

		return error;

	/* Go through the possible sources for proxy configuration, from most specific

	 * to least specific. */

	/* remote.<name>.proxy config setting */

	if (remote->name && remote->name[0]) {

		git_buf buf = GIT_BUF_INIT;

		if ((error = git_buf_printf(&buf, "remote.%s.proxy", remote->name)) < 0)

			return error;

		error = git_config__lookup_entry(&ce, cfg, git_buf_cstr(&buf), false);

		git_buf_free(&buf;;

		if (error < 0)

			return error;

		if (ce && ce->value) {

			*proxy_url = git__strdup(ce->value);

			goto found;

		}

	}

	/* http.proxy config setting */

	if ((error = git_config__lookup_entry(&ce, cfg, "http.proxy", false)) < 0)

		return error;

	if (ce && ce->value) {

		*proxy_url = git__strdup(ce->value);

		goto found;

	}

	/* http_proxy / https_proxy environment variables */

	error = git__getenv(&val, use_ssl ? "https_proxy" : "http_proxy");

	/* try uppercase environment variables */

	if (error == GIT_ENOTFOUND)

		error = git__getenv(&val, use_ssl ? "HTTPS_PROXY" : "HTTP_PROXY");

	if (error < 0) {

		if (error == GIT_ENOTFOUND) {

			giterr_clear();

			error = 0;

		}

		return error;

	}

	*proxy_url = git_buf_detach(&val;;

found:

	GITERR_CHECK_ALLOC(*proxy_url);

	git_config_entry_free(ce);

	return 0;

}

/* DWIM `refspecs` based on `refs` and append the output to `out` */

static int dwim_refspecs(git_vector *out, git_vector *refspecs, git_vector *refs)

{

	size_t i;

	git_refspec *spec;

	git_vector_foreach(refspecs, i, spec) {

		if (git_refspec__dwim_one(out, spec, refs) < 0)

			return -1;

	}

	return 0;

}

static void free_refspecs(git_vector *vec)

{

	size_t i;

	git_refspec *spec;

	git_vector_foreach(vec, i, spec) {

		git_refspec__free(spec);

		git__free(spec);

	}

	git_vector_clear(vec);

}

static int remote_head_cmp(const void *_a, const void *_b)

{

	const git_remote_head *a = (git_remote_head *) _a;

	const git_remote_head *b = (git_remote_head *) _b;

	return git__strcmp_cb(a->name, b->name);

}

static int ls_to_vector(git_vector *out, git_remote *remote)

{

	git_remote_head **heads;

	size_t heads_len, i;

	if (git_remote_ls((const git_remote_head ***)&heads, &heads_len, remote) < 0)

		return -1;

	if (git_vector_init(out, heads_len, remote_head_cmp) < 0)

		return -1;

	for (i = 0; i < heads_len; i++) {

		if (git_vector_insert(out, heads[i]) < 0)

			return -1;

	}

	return 0;

}

int git_remote_download(git_remote *remote, const git_strarray *refspecs, const git_fetch_options *opts)

{

	int error = -1;

	size_t i;

	git_vector *to_active, specs = GIT_VECTOR_INIT, refs = GIT_VECTOR_INIT;

	const git_remote_callbacks *cbs = NULL;

	const git_strarray *custom_headers = NULL;

	const git_proxy_options *proxy = NULL;

	assert(remote);

	if (opts) {

		GITERR_CHECK_VERSION(&opts->callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");

		cbs = &opts->callbacks;

		custom_headers = &opts->custom_headers;

		GITERR_CHECK_VERSION(&opts->proxy_opts, GIT_PROXY_OPTIONS_VERSION, "git_proxy_options");

		proxy = &opts->proxy_opts;

	}

	if (!git_remote_connected(remote) &&

	    (error = git_remote_connect(remote, GIT_DIRECTION_FETCH, cbs, proxy, custom_headers)) < 0)

		goto on_error;

	if (ls_to_vector(&refs, remote) < 0)

		return -1;

	if ((git_vector_init(&specs, 0, NULL)) < 0)

		goto on_error;

	remote->passed_refspecs = 0;