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

/*
 * Copyright (c) 2006 Franck Bui-Huu
 * Copyright (c) 2006 Rene Scharfe
 */
#include "cache.h"
#include "builtin.h"
#include "archive.h"
#include "commit.h"
#include "tree-walk.h"
#include "exec_cmd.h"
#include "pkt-line.h"
#include "sideband.h"
#include "attr.h"

static const char archive_usage[] = \
"git-archive --format=<fmt> [--prefix=<prefix>/] [--verbose] [<extra>] <tree-ish> [path...]";

static struct archiver_desc
{
	const char *name;
	write_archive_fn_t write_archive;
	parse_extra_args_fn_t parse_extra;
} archivers[] = {
	{ "tar", write_tar_archive, NULL },
	{ "zip", write_zip_archive, parse_extra_zip_args },
};

static int run_remote_archiver(const char *remote, int argc,
			       const char **argv)
{
	char *url, buf[LARGE_PACKET_MAX];
	int fd[2], i, len, rv;
	pid_t pid;
	const char *exec = "git-upload-archive";
	int exec_at = 0;

	for (i = 1; i < argc; i++) {
		const char *arg = argv[i];
		if (!prefixcmp(arg, "--exec=")) {
			if (exec_at)
				die("multiple --exec specified");
			exec = arg + 7;
			exec_at = i;
			break;
		}
	}

	url = xstrdup(remote);
	pid = git_connect(fd, url, exec, 0);
	if (pid < 0)
		return pid;

	for (i = 1; i < argc; i++) {
		if (i == exec_at)
			continue;
		packet_write(fd[1], "argument %s\n", argv[i]);
	}
	packet_flush(fd[1]);

	len = packet_read_line(fd[0], buf, sizeof(buf));
	if (!len)
		die("git-archive: expected ACK/NAK, got EOF");
	if (buf[len-1] == '\n')
		buf[--len] = 0;
	if (strcmp(buf, "ACK")) {
		if (len > 5 && !prefixcmp(buf, "NACK "))
			die("git-archive: NACK %s", buf + 5);
		die("git-archive: protocol error");
	}

	len = packet_read_line(fd[0], buf, sizeof(buf));
	if (len)
		die("git-archive: expected a flush");

	/* Now, start reading from fd[0] and spit it out to stdout */
	rv = recv_sideband("archive", fd[0], 1, 2);
	close(fd[0]);
	close(fd[1]);
	rv |= finish_connect(pid);

	return !!rv;
}

static void format_subst(const struct commit *commit,
                         const char *src, size_t len,
                         struct strbuf *buf)
{
	char *to_free = NULL;
	struct strbuf fmt;

	if (src == buf->buf)
		to_free = strbuf_detach(buf, NULL);
	strbuf_init(&fmt, 0);
	for (;;) {
		const char *b, *c;

		b = memmem(src, len, "$Format:", 8);
		if (!b || src + len < b + 9)
			break;
		c = memchr(b + 8, '$', len - 8);
		if (!c)
			break;

		strbuf_reset(&fmt);
		strbuf_add(&fmt, b + 8, c - b - 8);

		strbuf_add(buf, src, b - src);
		format_commit_message(commit, fmt.buf, buf);
		len -= c + 1 - src;
		src  = c + 1;
	}
	strbuf_add(buf, src, len);
	strbuf_release(&fmt);
	free(to_free);
}

static int convert_to_archive(const char *path,
                              const void *src, size_t len,
                              struct strbuf *buf,
                              const struct commit *commit)
{
	static struct git_attr *attr_export_subst;
	struct git_attr_check check[1];

	if (!commit)
		return 0;

	if (!attr_export_subst)
		attr_export_subst = git_attr("export-subst", 12);

	check[0].attr = attr_export_subst;
	if (git_checkattr(path, ARRAY_SIZE(check), check))
		return 0;
	if (!ATTR_TRUE(check[0].value))
		return 0;

	format_subst(commit, src, len, buf);
	return 1;
}

void *sha1_file_to_archive(const char *path, const unsigned char *sha1,
                           unsigned int mode, enum object_type *type,
                           unsigned long *sizep,
                           const struct commit *commit)
{
	void *buffer;

	buffer = read_sha1_file(sha1, type, sizep);
	if (buffer && S_ISREG(mode)) {
		struct strbuf buf;
		size_t size = 0;

		strbuf_init(&buf, 0);
		strbuf_attach(&buf, buffer, *sizep, *sizep + 1);
		convert_to_working_tree(path, buf.buf, buf.len, &buf);
		convert_to_archive(path, buf.buf, buf.len, &buf, commit);
		buffer = strbuf_detach(&buf, &size);
		*sizep = size;
	}

	return buffer;
}

static int init_archiver(const char *name, struct archiver *ar)
{
	int rv = -1, i;

	for (i = 0; i < ARRAY_SIZE(archivers); i++) {
		if (!strcmp(name, archivers[i].name)) {
			memset(ar, 0, sizeof(*ar));
			ar->name = archivers[i].name;
			ar->write_archive = archivers[i].write_archive;
			ar->parse_extra = archivers[i].parse_extra;
			rv = 0;
			break;
		}
	}
	return rv;
}

void parse_pathspec_arg(const char **pathspec, struct archiver_args *ar_args)
{
	ar_args->pathspec = get_pathspec(ar_args->base, pathspec);
}

void parse_treeish_arg(const char **argv, struct archiver_args *ar_args,
		       const char *prefix)
{
	const char *name = argv[0];
	const unsigned char *commit_sha1;
	time_t archive_time;
	struct tree *tree;
	const struct commit *commit;
	unsigned char sha1[20];

	if (get_sha1(name, sha1))
		die("Not a valid object name");

	commit = lookup_commit_reference_gently(sha1, 1);
	if (commit) {
		commit_sha1 = commit->object.sha1;
		archive_time = commit->date;
	} else {
		commit_sha1 = NULL;
		archive_time = time(NULL);
	}

	tree = parse_tree_indirect(sha1);
	if (tree == NULL)
		die("not a tree object");

	if (prefix) {
		unsigned char tree_sha1[20];
		unsigned int mode;
		int err;

		err = get_tree_entry(tree->object.sha1, prefix,
				     tree_sha1, &mode);
		if (err || !S_ISDIR(mode))
			die("current working directory is untracked");

		tree = parse_tree_indirect(tree_sha1);
	}
	ar_args->tree = tree;
	ar_args->commit_sha1 = commit_sha1;
	ar_args->commit = commit;
	ar_args->time = archive_time;
}

int parse_archive_args(int argc, const char **argv, struct archiver *ar)
{
	const char *extra_argv[MAX_EXTRA_ARGS];
	int extra_argc = 0;
	const char *format = "tar";
	const char *base = "";
	int verbose = 0;
	int i;

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

		if (!strcmp(arg, "--list") || !strcmp(arg, "-l")) {
			for (i = 0; i < ARRAY_SIZE(archivers); i++)
				printf("%s\n", archivers[i].name);
			exit(0);
		}
		if (!strcmp(arg, "--verbose") || !strcmp(arg, "-v")) {
			verbose = 1;
			continue;
		}
		if (!prefixcmp(arg, "--format=")) {
			format = arg + 9;
			continue;
		}
		if (!prefixcmp(arg, "--prefix=")) {
			base = arg + 9;
			continue;
		}
		if (!strcmp(arg, "--")) {
			i++;
			break;
		}
		if (arg[0] == '-') {
			if (extra_argc > MAX_EXTRA_ARGS - 1)
				die("Too many extra options");
			extra_argv[extra_argc++] = arg;
			continue;
		}
		break;
	}

	/* We need at least one parameter -- tree-ish */
	if (argc - 1 < i)
		usage(archive_usage);
	if (init_archiver(format, ar) < 0)
		die("Unknown archive format '%s'", format);

	if (extra_argc) {
		if (!ar->parse_extra)
			die("'%s' format does not handle %s",
			    ar->name, extra_argv[0]);
		ar->args.extra = ar->parse_extra(extra_argc, extra_argv);
	}
	ar->args.verbose = verbose;
	ar->args.base = base;

	return i;
}

static const char *extract_remote_arg(int *ac, const char **av)
{
	int ix, iy, cnt = *ac;
	int no_more_options = 0;
	const char *remote = NULL;

	for (ix = iy = 1; ix < cnt; ix++) {
		const char *arg = av[ix];
		if (!strcmp(arg, "--"))
			no_more_options = 1;
		if (!no_more_options) {
			if (!prefixcmp(arg, "--remote=")) {
				if (remote)
					die("Multiple --remote specified");
				remote = arg + 9;
				continue;
			}
			if (arg[0] != '-')
				no_more_options = 1;
		}
		if (ix != iy)
			av[iy] = arg;
		iy++;
	}
	if (remote) {
		av[--cnt] = NULL;
		*ac = cnt;
	}
	return remote;
}

int cmd_archive(int argc, const char **argv, const char *prefix)
{
	struct archiver ar;
	int tree_idx;
	const char *remote = NULL;

	remote = extract_remote_arg(&argc, argv);
	if (remote)
		return run_remote_archiver(remote, argc, argv);

	setvbuf(stderr, NULL, _IOLBF, BUFSIZ);

	memset(&ar, 0, sizeof(ar));
	tree_idx = parse_archive_args(argc, argv, &ar);
	if (prefix == NULL)
		prefix = setup_git_directory();

	argv += tree_idx;
	parse_treeish_arg(argv, &ar.args, prefix);
	parse_pathspec_arg(argv + 1, &ar.args);

	return ar.write_archive(&ar.args);
}
Commit	Line	Data
4df096a5 FBH	1	/*
	2	* Copyright (c) 2006 Franck Bui-Huu
	3	* Copyright (c) 2006 Rene Scharfe
	4	*/
4df096a5 FBH	5	#include "cache.h"
	6	#include "builtin.h"
	7	#include "archive.h"
	8	#include "commit.h"
	9	#include "tree-walk.h"
	10	#include "exec_cmd.h"
	11	#include "pkt-line.h"
23d6d112	12	#include "sideband.h"
8460b2fc	13	#include "attr.h"
4df096a5 FBH	14
4df096a5 FBH	15	static const char archive_usage[] = \
e0ffb248	16	"git-archive --format=<fmt> [--prefix=<prefix>/] [--verbose] [<extra>] <tree-ish> [path...]";
4df096a5	17
6c2f207b SP	18	static struct archiver_desc
	19	{
	20	const char *name;
	21	write_archive_fn_t write_archive;
	22	parse_extra_args_fn_t parse_extra;
	23	} archivers[] = {
	24	{ "tar", write_tar_archive, NULL },
	25	{ "zip", write_zip_archive, parse_extra_zip_args },
4df096a5 FBH	26	};
4df096a5 FBH	27
37f94436	28	static int run_remote_archiver(const char *remote, int argc,
4df096a5 FBH	29	const char **argv)
4df096a5 FBH	30	{
23d6d112	31	char *url, buf[LARGE_PACKET_MAX];
4df096a5 FBH	32	int fd[2], i, len, rv;
4df096a5 FBH	33	pid_t pid;
fe5ab763 JH	34	const char *exec = "git-upload-archive";
fe5ab763 JH	35	int exec_at = 0;
4df096a5	36
fe5ab763 JH	37	for (i = 1; i < argc; i++) {
fe5ab763 JH	38	const char *arg = argv[i];
599065a3	39	if (!prefixcmp(arg, "--exec=")) {
fe5ab763 JH	40	if (exec_at)
	41	die("multiple --exec specified");
	42	exec = arg + 7;
	43	exec_at = i;
	44	break;
	45	}
	46	}
4df096a5	47
37f94436	48	url = xstrdup(remote);
7841ce79	49	pid = git_connect(fd, url, exec, 0);
4df096a5 FBH	50	if (pid < 0)
	51	return pid;
	52
fe5ab763 JH	53	for (i = 1; i < argc; i++) {
	54	if (i == exec_at)
	55	continue;
4df096a5	56	packet_write(fd[1], "argument %s\n", argv[i]);
fe5ab763	57	}
4df096a5 FBH	58	packet_flush(fd[1]);
	59
	60	len = packet_read_line(fd[0], buf, sizeof(buf));
	61	if (!len)
	62	die("git-archive: expected ACK/NAK, got EOF");
	63	if (buf[len-1] == '\n')
	64	buf[--len] = 0;
	65	if (strcmp(buf, "ACK")) {
cc44c765	66	if (len > 5 && !prefixcmp(buf, "NACK "))
4df096a5 FBH	67	die("git-archive: NACK %s", buf + 5);
	68	die("git-archive: protocol error");
	69	}
	70
	71	len = packet_read_line(fd[0], buf, sizeof(buf));
	72	if (len)
	73	die("git-archive: expected a flush");
	74
	75	/* Now, start reading from fd[0] and spit it out to stdout */
9ac13ec9	76	rv = recv_sideband("archive", fd[0], 1, 2);
4df096a5	77	close(fd[0]);
ec587fde	78	close(fd[1]);
4df096a5 FBH	79	rv \|= finish_connect(pid);
	80
	81	return !!rv;
	82	}
	83
5ecd293d PH	84	static void format_subst(const struct commit *commit,
	85	const char *src, size_t len,
	86	struct strbuf *buf)
df4a394f	87	{
5ecd293d	88	char *to_free = NULL;
674d1727 PH	89	struct strbuf fmt;
674d1727 PH	90
5ecd293d	91	if (src == buf->buf)
b315c5c0	92	to_free = strbuf_detach(buf, NULL);
674d1727	93	strbuf_init(&fmt, 0);
df4a394f RS	94	for (;;) {
df4a394f RS	95	const char b, c;
df4a394f	96
5ecd293d PH	97	b = memmem(src, len, "$Format:", 8);
5ecd293d PH	98	if (!b \|\| src + len < b + 9)
df4a394f RS	99	break;
	100	c = memchr(b + 8, '$', len - 8);
	101	if (!c)
	102	break;
	103
674d1727 PH	104	strbuf_reset(&fmt);
	105	strbuf_add(&fmt, b + 8, c - b - 8);
	106
5ecd293d PH	107	strbuf_add(buf, src, b - src);
	108	format_commit_message(commit, fmt.buf, buf);
	109	len -= c + 1 - src;
	110	src = c + 1;
df4a394f	111	}
5ecd293d	112	strbuf_add(buf, src, len);
674d1727	113	strbuf_release(&fmt);
5ecd293d	114	free(to_free);
df4a394f RS	115	}
df4a394f RS	116
5ecd293d PH	117	static int convert_to_archive(const char *path,
	118	const void *src, size_t len,
	119	struct strbuf *buf,
	120	const struct commit *commit)
8460b2fc	121	{
38c9c9b7	122	static struct git_attr *attr_export_subst;
8460b2fc	123	struct git_attr_check check[1];
8460b2fc RS	124
8460b2fc RS	125	if (!commit)
5ecd293d	126	return 0;
8460b2fc	127
5ecd293d PH	128	if (!attr_export_subst)
5ecd293d PH	129	attr_export_subst = git_attr("export-subst", 12);
8460b2fc	130
38c9c9b7	131	check[0].attr = attr_export_subst;
8460b2fc	132	if (git_checkattr(path, ARRAY_SIZE(check), check))
5ecd293d	133	return 0;
8460b2fc	134	if (!ATTR_TRUE(check[0].value))
5ecd293d	135	return 0;
8460b2fc	136
5ecd293d PH	137	format_subst(commit, src, len, buf);
5ecd293d PH	138	return 1;
8460b2fc RS	139	}
	140
	141	void sha1_file_to_archive(const char path, const unsigned char *sha1,
	142	unsigned int mode, enum object_type *type,
5ecd293d	143	unsigned long *sizep,
8460b2fc RS	144	const struct commit *commit)
8460b2fc RS	145	{
5ecd293d	146	void *buffer;
8460b2fc	147
5ecd293d	148	buffer = read_sha1_file(sha1, type, sizep);
8460b2fc	149	if (buffer && S_ISREG(mode)) {
5ecd293d	150	struct strbuf buf;
c32f749f	151	size_t size = 0;
5ecd293d PH	152
	153	strbuf_init(&buf, 0);
	154	strbuf_attach(&buf, buffer, sizep, sizep + 1);
	155	convert_to_working_tree(path, buf.buf, buf.len, &buf);
	156	convert_to_archive(path, buf.buf, buf.len, &buf, commit);
c32f749f RS	157	buffer = strbuf_detach(&buf, &size);
c32f749f RS	158	*sizep = size;
8460b2fc RS	159	}
	160
	161	return buffer;
	162	}
	163
4df096a5 FBH	164	static int init_archiver(const char name, struct archiver ar)
	165	{
	166	int rv = -1, i;
	167
	168	for (i = 0; i < ARRAY_SIZE(archivers); i++) {
	169	if (!strcmp(name, archivers[i].name)) {
6c2f207b SP	170	memset(ar, 0, sizeof(*ar));
	171	ar->name = archivers[i].name;
	172	ar->write_archive = archivers[i].write_archive;
	173	ar->parse_extra = archivers[i].parse_extra;
4df096a5 FBH	174	rv = 0;
	175	break;
	176	}
	177	}
	178	return rv;
	179	}
	180
	181	void parse_pathspec_arg(const char *pathspec, struct archiver_args ar_args)
	182	{
	183	ar_args->pathspec = get_pathspec(ar_args->base, pathspec);
	184	}
	185
	186	void parse_treeish_arg(const char *argv, struct archiver_args ar_args,
	187	const char *prefix)
	188	{
	189	const char *name = argv[0];
	190	const unsigned char *commit_sha1;
	191	time_t archive_time;
	192	struct tree *tree;
8460b2fc	193	const struct commit *commit;
4df096a5 FBH	194	unsigned char sha1[20];
	195
	196	if (get_sha1(name, sha1))
	197	die("Not a valid object name");
	198
	199	commit = lookup_commit_reference_gently(sha1, 1);
	200	if (commit) {
	201	commit_sha1 = commit->object.sha1;
	202	archive_time = commit->date;
	203	} else {
	204	commit_sha1 = NULL;
	205	archive_time = time(NULL);
	206	}
	207
	208	tree = parse_tree_indirect(sha1);
	209	if (tree == NULL)
	210	die("not a tree object");
	211
	212	if (prefix) {
	213	unsigned char tree_sha1[20];
	214	unsigned int mode;
	215	int err;
	216
	217	err = get_tree_entry(tree->object.sha1, prefix,
	218	tree_sha1, &mode);
	219	if (err \|\| !S_ISDIR(mode))
	220	die("current working directory is untracked");
	221
4df096a5 FBH	222	tree = parse_tree_indirect(tree_sha1);
	223	}
	224	ar_args->tree = tree;
	225	ar_args->commit_sha1 = commit_sha1;
8460b2fc	226	ar_args->commit = commit;
4df096a5 FBH	227	ar_args->time = archive_time;
	228	}
	229
4df096a5 FBH	230	int parse_archive_args(int argc, const char *argv, struct archiver ar)
	231	{
	232	const char *extra_argv[MAX_EXTRA_ARGS];
	233	int extra_argc = 0;
8ff21b1a	234	const char *format = "tar";
4df096a5	235	const char *base = "";
e0ffb248	236	int verbose = 0;
4df096a5 FBH	237	int i;
	238
	239	for (i = 1; i < argc; i++) {
	240	const char *arg = argv[i];
	241
	242	if (!strcmp(arg, "--list") \|\| !strcmp(arg, "-l")) {
37f94436 JH	243	for (i = 0; i < ARRAY_SIZE(archivers); i++)
	244	printf("%s\n", archivers[i].name);
	245	exit(0);
4df096a5	246	}
e0ffb248 JH	247	if (!strcmp(arg, "--verbose") \|\| !strcmp(arg, "-v")) {
	248	verbose = 1;
	249	continue;
	250	}
cc44c765	251	if (!prefixcmp(arg, "--format=")) {
4df096a5 FBH	252	format = arg + 9;
	253	continue;
	254	}
cc44c765	255	if (!prefixcmp(arg, "--prefix=")) {
4df096a5 FBH	256	base = arg + 9;
	257	continue;
	258	}
4df096a5 FBH	259	if (!strcmp(arg, "--")) {
	260	i++;
	261	break;
	262	}
	263	if (arg[0] == '-') {
	264	if (extra_argc > MAX_EXTRA_ARGS - 1)
	265	die("Too many extra options");
	266	extra_argv[extra_argc++] = arg;
	267	continue;
	268	}
	269	break;
	270	}
	271
37f94436 JH	272	/* We need at least one parameter -- tree-ish */
37f94436 JH	273	if (argc - 1 < i)
4df096a5	274	usage(archive_usage);
4df096a5 FBH	275	if (init_archiver(format, ar) < 0)
	276	die("Unknown archive format '%s'", format);
	277
37f94436 JH	278	if (extra_argc) {
37f94436 JH	279	if (!ar->parse_extra)
2232c0c6 RS	280	die("'%s' format does not handle %s",
2232c0c6 RS	281	ar->name, extra_argv[0]);
4df096a5 FBH	282	ar->args.extra = ar->parse_extra(extra_argc, extra_argv);
4df096a5 FBH	283	}
e0ffb248	284	ar->args.verbose = verbose;
4df096a5 FBH	285	ar->args.base = base;
	286
	287	return i;
	288	}
	289
d751864c	290	static const char extract_remote_arg(int ac, const char **av)
37f94436 JH	291	{
	292	int ix, iy, cnt = *ac;
	293	int no_more_options = 0;
	294	const char *remote = NULL;
	295
	296	for (ix = iy = 1; ix < cnt; ix++) {
	297	const char *arg = av[ix];
	298	if (!strcmp(arg, "--"))
	299	no_more_options = 1;
	300	if (!no_more_options) {
cc44c765	301	if (!prefixcmp(arg, "--remote=")) {
37f94436 JH	302	if (remote)
	303	die("Multiple --remote specified");
	304	remote = arg + 9;
	305	continue;
	306	}
	307	if (arg[0] != '-')
	308	no_more_options = 1;
	309	}
	310	if (ix != iy)
	311	av[iy] = arg;
	312	iy++;
	313	}
	314	if (remote) {
	315	av[--cnt] = NULL;
	316	*ac = cnt;
	317	}
	318	return remote;
	319	}
	320
4df096a5 FBH	321	int cmd_archive(int argc, const char *argv, const char prefix)
	322	{
	323	struct archiver ar;
	324	int tree_idx;
37f94436	325	const char *remote = NULL;
4df096a5	326
d751864c	327	remote = extract_remote_arg(&argc, argv);
37f94436 JH	328	if (remote)
37f94436 JH	329	return run_remote_archiver(remote, argc, argv);
4df096a5	330
aa909861	331	setvbuf(stderr, NULL, _IOLBF, BUFSIZ);
8142f603	332
37f94436 JH	333	memset(&ar, 0, sizeof(ar));
37f94436 JH	334	tree_idx = parse_archive_args(argc, argv, &ar);
265d5280 RS	335	if (prefix == NULL)
265d5280 RS	336	prefix = setup_git_directory();
4df096a5 FBH	337
	338	argv += tree_idx;
	339	parse_treeish_arg(argv, &ar.args, prefix);
	340	parse_pathspec_arg(argv + 1, &ar.args);
	341
	342	return ar.write_archive(&ar.args);
	343	}