[thirdparty/git.git] / builtin-push.c

/*
 * "git push"
 */
#include "cache.h"
#include "refs.h"
#include "run-command.h"
#include "builtin.h"

#define MAX_URI (16)

static const char push_usage[] = "git push [--all] [--tags] [--force] <repository> [<refspec>...]";

static int all = 0, tags = 0, force = 0, thin = 1;
static const char *execute = NULL;

#define BUF_SIZE (2084)
static char buffer[BUF_SIZE];

static const char **refspec = NULL;
static int refspec_nr = 0;

static void add_refspec(const char *ref)
{
	int nr = refspec_nr + 1;
	refspec = xrealloc(refspec, nr * sizeof(char *));
	refspec[nr-1] = ref;
	refspec_nr = nr;
}

static int expand_one_ref(const char *ref, const unsigned char *sha1)
{
	/* Ignore the "refs/" at the beginning of the refname */
	ref += 5;

	if (strncmp(ref, "tags/", 5))
		return 0;

	add_refspec(strdup(ref));
	return 0;
}

static void expand_refspecs(void)
{
	if (all) {
		if (refspec_nr)
			die("cannot mix '--all' and a refspec");

		/*
		 * No need to expand "--all" - we'll just use
		 * the "--all" flag to send-pack
		 */
		return;
	}
	if (!tags)
		return;
	for_each_ref(expand_one_ref);
}

static void set_refspecs(const char **refs, int nr)
{
	if (nr) {
		size_t bytes = nr * sizeof(char *);

		refspec = xrealloc(refspec, bytes);
		memcpy(refspec, refs, bytes);
		refspec_nr = nr;
	}
	expand_refspecs();
}

static int get_remotes_uri(const char *repo, const char *uri[MAX_URI])
{
	int n = 0;
	FILE *f = fopen(git_path("remotes/%s", repo), "r");
	int has_explicit_refspec = refspec_nr || all || tags;

	if (!f)
		return -1;
	while (fgets(buffer, BUF_SIZE, f)) {
		int is_refspec;
		char *s, *p;

		if (!strncmp("URL: ", buffer, 5)) {
			is_refspec = 0;
			s = buffer + 5;
		} else if (!strncmp("Push: ", buffer, 6)) {
			is_refspec = 1;
			s = buffer + 6;
		} else
			continue;

		/* Remove whitespace at the head.. */
		while (isspace(*s))
			s++;
		if (!*s)
			continue;

		/* ..and at the end */
		p = s + strlen(s);
		while (isspace(p[-1]))
			*--p = 0;

		if (!is_refspec) {
			if (n < MAX_URI)
				uri[n++] = strdup(s);
			else
				error("more than %d URL's specified, ignoring the rest", MAX_URI);
		}
		else if (is_refspec && !has_explicit_refspec)
			add_refspec(strdup(s));
	}
	fclose(f);
	if (!n)
		die("remote '%s' has no URL", repo);
	return n;
}

static const char **config_uri;
static const char *config_repo;
static int config_repo_len;
static int config_current_uri;
static int config_get_refspecs;

static int get_remote_config(const char* key, const char* value)
{
	if (!strncmp(key, "remote.", 7) &&
	    !strncmp(key + 7, config_repo, config_repo_len)) {
		if (!strcmp(key + 7 + config_repo_len, ".url")) {
			if (config_current_uri < MAX_URI)
				config_uri[config_current_uri++] = strdup(value);
			else
				error("more than %d URL's specified, ignoring the rest", MAX_URI);
		}
		else if (config_get_refspecs &&
			 !strcmp(key + 7 + config_repo_len, ".push"))
			add_refspec(strdup(value));
	}
	return 0;
}

static int get_config_remotes_uri(const char *repo, const char *uri[MAX_URI])
{
	config_repo_len = strlen(repo);
	config_repo = repo;
	config_current_uri = 0;
	config_uri = uri;
	config_get_refspecs = !(refspec_nr || all || tags);

	git_config(get_remote_config);
	return config_current_uri;
}

static int get_branches_uri(const char *repo, const char *uri[MAX_URI])
{
	const char *slash = strchr(repo, '/');
	int n = slash ? slash - repo : 1000;
	FILE *f = fopen(git_path("branches/%.*s", n, repo), "r");
	char *s, *p;
	int len;

	if (!f)
		return 0;
	s = fgets(buffer, BUF_SIZE, f);
	fclose(f);
	if (!s)
		return 0;
	while (isspace(*s))
		s++;
	if (!*s)
		return 0;
	p = s + strlen(s);
	while (isspace(p[-1]))
		*--p = 0;
	len = p - s;
	if (slash)
		len += strlen(slash);
	p = xmalloc(len + 1);
	strcpy(p, s);
	if (slash)
		strcat(p, slash);
	uri[0] = p;
	return 1;
}

/*
 * Read remotes and branches file, fill the push target URI
 * list.  If there is no command line refspecs, read Push: lines
 * to set up the *refspec list as well.
 * return the number of push target URIs
 */
static int read_config(const char *repo, const char *uri[MAX_URI])
{
	int n;

	if (*repo != '/') {
		n = get_remotes_uri(repo, uri);
		if (n > 0)
			return n;

		n = get_config_remotes_uri(repo, uri);
		if (n > 0)
			return n;

		n = get_branches_uri(repo, uri);
		if (n > 0)
			return n;
	}

	uri[0] = repo;
	return 1;
}

static int do_push(const char *repo)
{
	const char *uri[MAX_URI];
	int i, n;
	int common_argc;
	const char **argv;
	int argc;

	n = read_config(repo, uri);
	if (n <= 0)
		die("bad repository '%s'", repo);

	argv = xmalloc((refspec_nr + 10) * sizeof(char *));
	argv[0] = "dummy-send-pack";
	argc = 1;
	if (all)
		argv[argc++] = "--all";
	if (force)
		argv[argc++] = "--force";
	if (execute)
		argv[argc++] = execute;
	common_argc = argc;

	for (i = 0; i < n; i++) {
		int error;
		int dest_argc = common_argc;
		int dest_refspec_nr = refspec_nr;
		const char **dest_refspec = refspec;
		const char *dest = uri[i];
		const char *sender = "git-send-pack";
		if (!strncmp(dest, "http://", 7) ||
		    !strncmp(dest, "https://", 8))
			sender = "git-http-push";
		else if (thin)
			argv[dest_argc++] = "--thin";
		argv[0] = sender;
		argv[dest_argc++] = dest;
		while (dest_refspec_nr--)
			argv[dest_argc++] = *dest_refspec++;
		argv[dest_argc] = NULL;
		error = run_command_v(argc, argv);
		if (!error)
			continue;
		switch (error) {
		case -ERR_RUN_COMMAND_FORK:
			die("unable to fork for %s", sender);
		case -ERR_RUN_COMMAND_EXEC:
			die("unable to exec %s", sender);
		case -ERR_RUN_COMMAND_WAITPID:
		case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
		case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
		case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
			die("%s died with strange error", sender);
		default:
			return -error;
		}
	}
	return 0;
}

int cmd_push(int argc, const char **argv, const char *prefix)
{
	int i;
	const char *repo = "origin";	/* default repository */

	for (i = 1; i < argc; i++) {
		const char *arg = argv[i];

		if (arg[0] != '-') {
			repo = arg;
			i++;
			break;
		}
		if (!strcmp(arg, "--all")) {
			all = 1;
			continue;
		}
		if (!strcmp(arg, "--tags")) {
			tags = 1;
			continue;
		}
		if (!strcmp(arg, "--force")) {
			force = 1;
			continue;
		}
		if (!strcmp(arg, "--thin")) {
			thin = 1;
			continue;
		}
		if (!strcmp(arg, "--no-thin")) {
			thin = 0;
			continue;
		}
		if (!strncmp(arg, "--exec=", 7)) {
			execute = arg;
			continue;
		}
		usage(push_usage);
	}
	set_refspecs(argv + i, argc - i);
	return do_push(repo);
}
Commit	Line	Data
755225de LT	1	/*
	2	* "git push"
	3	*/
	4	#include "cache.h"
	5	#include "refs.h"
	6	#include "run-command.h"
	7	#include "builtin.h"
	8
	9	#define MAX_URI (16)
	10
	11	static const char push_usage[] = "git push [--all] [--tags] [--force] <repository> [<refspec>...]";
	12
	13	static int all = 0, tags = 0, force = 0, thin = 1;
	14	static const char *execute = NULL;
	15
	16	#define BUF_SIZE (2084)
	17	static char buffer[BUF_SIZE];
	18
	19	static const char **refspec = NULL;
	20	static int refspec_nr = 0;
	21
	22	static void add_refspec(const char *ref)
	23	{
	24	int nr = refspec_nr + 1;
	25	refspec = xrealloc(refspec, nr * sizeof(char *));
	26	refspec[nr-1] = ref;
	27	refspec_nr = nr;
	28	}
	29
	30	static int expand_one_ref(const char ref, const unsigned char sha1)
	31	{
	32	/* Ignore the "refs/" at the beginning of the refname */
	33	ref += 5;
	34
	35	if (strncmp(ref, "tags/", 5))
	36	return 0;
	37
	38	add_refspec(strdup(ref));
	39	return 0;
	40	}
	41
	42	static void expand_refspecs(void)
	43	{
	44	if (all) {
	45	if (refspec_nr)
	46	die("cannot mix '--all' and a refspec");
	47
	48	/*
	49	* No need to expand "--all" - we'll just use
	50	* the "--all" flag to send-pack
	51	*/
	52	return;
	53	}
	54	if (!tags)
	55	return;
	56	for_each_ref(expand_one_ref);
	57	}
	58
	59	static void set_refspecs(const char **refs, int nr)
	60	{
	61	if (nr) {
	62	size_t bytes = nr * sizeof(char *);
	63
	64	refspec = xrealloc(refspec, bytes);
65	memcpy(refspec, refs, bytes);
66	refspec_nr = nr;
67	}
68	expand_refspecs();
69	}
70
71	static int get_remotes_uri(const char repo, const char uri[MAX_URI])
72	{
73	int n = 0;
74	FILE *f = fopen(git_path("remotes/%s", repo), "r");
5edbcd8d	75	int has_explicit_refspec = refspec_nr \|\| all \|\| tags;
755225de LT	76
	77	if (!f)
	78	return -1;
	79	while (fgets(buffer, BUF_SIZE, f)) {
5c477b97	80	int is_refspec;
755225de LT	81	char s, p;
755225de LT	82
5c477b97 JS	83	if (!strncmp("URL: ", buffer, 5)) {
	84	is_refspec = 0;
	85	s = buffer + 5;
	86	} else if (!strncmp("Push: ", buffer, 6)) {
	87	is_refspec = 1;
	88	s = buffer + 6;
	89	} else
755225de	90	continue;
755225de LT	91
	92	/* Remove whitespace at the head.. */
	93	while (isspace(*s))
	94	s++;
	95	if (!*s)
	96	continue;
	97
	98	/* ..and at the end */
	99	p = s + strlen(s);
	100	while (isspace(p[-1]))
	101	*--p = 0;
	102
7aaf83da JH	103	if (!is_refspec) {
	104	if (n < MAX_URI)
	105	uri[n++] = strdup(s);
	106	else
82e5a82f	107	error("more than %d URL's specified, ignoring the rest", MAX_URI);
7aaf83da JH	108	}
	109	else if (is_refspec && !has_explicit_refspec)
	110	add_refspec(strdup(s));
755225de LT	111	}
	112	fclose(f);
	113	if (!n)
	114	die("remote '%s' has no URL", repo);
	115	return n;
	116	}
	117
97d4df0b JS	118	static const char **config_uri;
	119	static const char *config_repo;
	120	static int config_repo_len;
	121	static int config_current_uri;
	122	static int config_get_refspecs;
	123
	124	static int get_remote_config(const char* key, const char* value)
	125	{
	126	if (!strncmp(key, "remote.", 7) &&
	127	!strncmp(key + 7, config_repo, config_repo_len)) {
	128	if (!strcmp(key + 7 + config_repo_len, ".url")) {
	129	if (config_current_uri < MAX_URI)
	130	config_uri[config_current_uri++] = strdup(value);
	131	else
	132	error("more than %d URL's specified, ignoring the rest", MAX_URI);
	133	}
	134	else if (config_get_refspecs &&
	135	!strcmp(key + 7 + config_repo_len, ".push"))
	136	add_refspec(strdup(value));
	137	}
	138	return 0;
	139	}
	140
	141	static int get_config_remotes_uri(const char repo, const char uri[MAX_URI])
	142	{
	143	config_repo_len = strlen(repo);
	144	config_repo = repo;
	145	config_current_uri = 0;
	146	config_uri = uri;
5edbcd8d	147	config_get_refspecs = !(refspec_nr \|\| all \|\| tags);
97d4df0b JS	148
	149	git_config(get_remote_config);
	150	return config_current_uri;
	151	}
	152
755225de LT	153	static int get_branches_uri(const char repo, const char uri[MAX_URI])
	154	{
	155	const char *slash = strchr(repo, '/');
	156	int n = slash ? slash - repo : 1000;
	157	FILE f = fopen(git_path("branches/%.s", n, repo), "r");
	158	char s, p;
	159	int len;
	160
	161	if (!f)
	162	return 0;
	163	s = fgets(buffer, BUF_SIZE, f);
	164	fclose(f);
	165	if (!s)
	166	return 0;
	167	while (isspace(*s))
	168	s++;
	169	if (!*s)
	170	return 0;
	171	p = s + strlen(s);
	172	while (isspace(p[-1]))
	173	*--p = 0;
	174	len = p - s;
	175	if (slash)
	176	len += strlen(slash);
	177	p = xmalloc(len + 1);
	178	strcpy(p, s);
	179	if (slash)
	180	strcat(p, slash);
	181	uri[0] = p;
	182	return 1;
	183	}
	184
7aaf83da JH	185	/*
	186	* Read remotes and branches file, fill the push target URI
	187	* list. If there is no command line refspecs, read Push: lines
	188	* to set up the *refspec list as well.
	189	* return the number of push target URIs
	190	*/
	191	static int read_config(const char repo, const char uri[MAX_URI])
755225de LT	192	{
	193	int n;
	194
	195	if (*repo != '/') {
	196	n = get_remotes_uri(repo, uri);
	197	if (n > 0)
	198	return n;
	199
97d4df0b JS	200	n = get_config_remotes_uri(repo, uri);
	201	if (n > 0)
	202	return n;
	203
755225de LT	204	n = get_branches_uri(repo, uri);
	205	if (n > 0)
	206	return n;
	207	}
	208
	209	uri[0] = repo;
	210	return 1;
	211	}
	212
	213	static int do_push(const char *repo)
	214	{
	215	const char *uri[MAX_URI];
7aaf83da	216	int i, n;
441c823e	217	int common_argc;
755225de LT	218	const char **argv;
	219	int argc;
	220
7aaf83da	221	n = read_config(repo, uri);
755225de LT	222	if (n <= 0)
	223	die("bad repository '%s'", repo);
	224
	225	argv = xmalloc((refspec_nr + 10) * sizeof(char *));
	226	argv[0] = "dummy-send-pack";
	227	argc = 1;
	228	if (all)
	229	argv[argc++] = "--all";
	230	if (force)
	231	argv[argc++] = "--force";
	232	if (execute)
	233	argv[argc++] = execute;
441c823e	234	common_argc = argc;
755225de LT	235
	236	for (i = 0; i < n; i++) {
	237	int error;
441c823e NH	238	int dest_argc = common_argc;
	239	int dest_refspec_nr = refspec_nr;
	240	const char **dest_refspec = refspec;
755225de LT	241	const char *dest = uri[i];
	242	const char *sender = "git-send-pack";
	243	if (!strncmp(dest, "http://", 7) \|\|
	244	!strncmp(dest, "https://", 8))
	245	sender = "git-http-push";
441c823e NH	246	else if (thin)
441c823e NH	247	argv[dest_argc++] = "--thin";
755225de	248	argv[0] = sender;
441c823e NH	249	argv[dest_argc++] = dest;
	250	while (dest_refspec_nr--)
	251	argv[dest_argc++] = *dest_refspec++;
	252	argv[dest_argc] = NULL;
755225de LT	253	error = run_command_v(argc, argv);
	254	if (!error)
	255	continue;
	256	switch (error) {
	257	case -ERR_RUN_COMMAND_FORK:
	258	die("unable to fork for %s", sender);
	259	case -ERR_RUN_COMMAND_EXEC:
	260	die("unable to exec %s", sender);
	261	case -ERR_RUN_COMMAND_WAITPID:
	262	case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
	263	case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
	264	case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
	265	die("%s died with strange error", sender);
	266	default:
	267	return -error;
	268	}
	269	}
	270	return 0;
	271	}
	272
a633fca0	273	int cmd_push(int argc, const char *argv, const char prefix)
755225de LT	274	{
755225de LT	275	int i;
a9486b02	276	const char repo = "origin"; / default repository */
755225de LT	277
	278	for (i = 1; i < argc; i++) {
	279	const char *arg = argv[i];
	280
	281	if (arg[0] != '-') {
	282	repo = arg;
	283	i++;
	284	break;
	285	}
	286	if (!strcmp(arg, "--all")) {
	287	all = 1;
	288	continue;
	289	}
	290	if (!strcmp(arg, "--tags")) {
	291	tags = 1;
	292	continue;
	293	}
	294	if (!strcmp(arg, "--force")) {
	295	force = 1;
	296	continue;
	297	}
	298	if (!strcmp(arg, "--thin")) {
	299	thin = 1;
	300	continue;
	301	}
	302	if (!strcmp(arg, "--no-thin")) {
	303	thin = 0;
	304	continue;
	305	}
	306	if (!strncmp(arg, "--exec=", 7)) {
	307	execute = arg;
	308	continue;
	309	}
	310	usage(push_usage);
	311	}
	312	set_refspecs(argv + i, argc - i);
	313	return do_push(repo);
	314	}