[thirdparty/git.git] / entry.c

#include "cache.h"
#include "blob.h"
#include "dir.h"
#include "streaming.h"
#include "submodule.h"

static void create_directories(const char *path, int path_len,
			       const struct checkout *state)
{
	char *buf = xmallocz(path_len);
	int len = 0;

	while (len < path_len) {
		do {
			buf[len] = path[len];
			len++;
		} while (len < path_len && path[len] != '/');
		if (len >= path_len)
			break;
		buf[len] = 0;

		/*
		 * For 'checkout-index --prefix=<dir>', <dir> is
		 * allowed to be a symlink to an existing directory,
		 * and we set 'state->base_dir_len' below, such that
		 * we test the path components of the prefix with the
		 * stat() function instead of the lstat() function.
		 */
		if (has_dirs_only_path(buf, len, state->base_dir_len))
			continue; /* ok, it is already a directory. */

		/*
		 * If this mkdir() would fail, it could be that there
		 * is already a symlink or something else exists
		 * there, therefore we then try to unlink it and try
		 * one more time to create the directory.
		 */
		if (mkdir(buf, 0777)) {
			if (errno == EEXIST && state->force &&
			    !unlink_or_warn(buf) && !mkdir(buf, 0777))
				continue;
			die_errno("cannot create directory at '%s'", buf);
		}
	}
	free(buf);
}

static void remove_subtree(struct strbuf *path)
{
	DIR *dir = opendir(path->buf);
	struct dirent *de;
	int origlen = path->len;

	if (!dir)
		die_errno("cannot opendir '%s'", path->buf);
	while ((de = readdir(dir)) != NULL) {
		struct stat st;

		if (is_dot_or_dotdot(de->d_name))
			continue;

		strbuf_addch(path, '/');
		strbuf_addstr(path, de->d_name);
		if (lstat(path->buf, &st))
			die_errno("cannot lstat '%s'", path->buf);
		if (S_ISDIR(st.st_mode))
			remove_subtree(path);
		else if (unlink(path->buf))
			die_errno("cannot unlink '%s'", path->buf);
		strbuf_setlen(path, origlen);
	}
	closedir(dir);
	if (rmdir(path->buf))
		die_errno("cannot rmdir '%s'", path->buf);
}

static int create_file(const char *path, unsigned int mode)
{
	mode = (mode & 0100) ? 0777 : 0666;
	return open(path, O_WRONLY | O_CREAT | O_EXCL, mode);
}

static void *read_blob_entry(const struct cache_entry *ce, unsigned long *size)
{
	enum object_type type;
	void *new = read_sha1_file(ce->oid.hash, &type, size);

	if (new) {
		if (type == OBJ_BLOB)
			return new;
		free(new);
	}
	return NULL;
}

static int open_output_fd(char *path, const struct cache_entry *ce, int to_tempfile)
{
	int symlink = (ce->ce_mode & S_IFMT) != S_IFREG;
	if (to_tempfile) {
		xsnprintf(path, TEMPORARY_FILENAME_LENGTH, "%s",
			  symlink ? ".merge_link_XXXXXX" : ".merge_file_XXXXXX");
		return mkstemp(path);
	} else {
		return create_file(path, !symlink ? ce->ce_mode : 0666);
	}
}

static int fstat_output(int fd, const struct checkout *state, struct stat *st)
{
	/* use fstat() only when path == ce->name */
	if (fstat_is_reliable() &&
	    state->refresh_cache && !state->base_dir_len) {
		fstat(fd, st);
		return 1;
	}
	return 0;
}

static int streaming_write_entry(const struct cache_entry *ce, char *path,
				 struct stream_filter *filter,
				 const struct checkout *state, int to_tempfile,
				 int *fstat_done, struct stat *statbuf)
{
	int result = 0;
	int fd;

	fd = open_output_fd(path, ce, to_tempfile);
	if (fd < 0)
		return -1;

	result |= stream_blob_to_fd(fd, &ce->oid, filter, 1);
	*fstat_done = fstat_output(fd, state, statbuf);
	result |= close(fd);

	if (result)
		unlink(path);
	return result;
}

static int write_entry(struct cache_entry *ce,
		       char *path, const struct checkout *state, int to_tempfile)
{
	unsigned int ce_mode_s_ifmt = ce->ce_mode & S_IFMT;
	int fd, ret, fstat_done = 0;
	char *new;
	struct strbuf buf = STRBUF_INIT;
	unsigned long size;
	size_t wrote, newsize = 0;
	struct stat st;
	const struct submodule *sub;

	if (ce_mode_s_ifmt == S_IFREG) {
		struct stream_filter *filter = get_stream_filter(ce->name,
								 ce->oid.hash);
		if (filter &&
		    !streaming_write_entry(ce, path, filter,
					   state, to_tempfile,
					   &fstat_done, &st))
			goto finish;
	}

	switch (ce_mode_s_ifmt) {
	case S_IFREG:
	case S_IFLNK:
		new = read_blob_entry(ce, &size);
		if (!new)
			return error("unable to read sha1 file of %s (%s)",
				path, oid_to_hex(&ce->oid));

		if (ce_mode_s_ifmt == S_IFLNK && has_symlinks && !to_tempfile) {
			ret = symlink(new, path);
			free(new);
			if (ret)
				return error_errno("unable to create symlink %s",
						   path);
			break;
		}

		/*
		 * Convert from git internal format to working tree format
		 */
		if (ce_mode_s_ifmt == S_IFREG &&
		    convert_to_working_tree(ce->name, new, size, &buf)) {
			free(new);
			new = strbuf_detach(&buf, &newsize);
			size = newsize;
		}

		fd = open_output_fd(path, ce, to_tempfile);
		if (fd < 0) {
			free(new);
			return error_errno("unable to create file %s", path);
		}

		wrote = write_in_full(fd, new, size);
		if (!to_tempfile)
			fstat_done = fstat_output(fd, state, &st);
		close(fd);
		free(new);
		if (wrote != size)
			return error("unable to write file %s", path);
		break;
	case S_IFGITLINK:
		if (to_tempfile)
			return error("cannot create temporary submodule %s", path);
		if (mkdir(path, 0777) < 0)
			return error("cannot create submodule directory %s", path);
		sub = submodule_from_ce(ce);
		if (sub)
			return submodule_move_head(ce->name,
				NULL, oid_to_hex(&ce->oid),
				state->force ? SUBMODULE_MOVE_HEAD_FORCE : 0);
		break;
	default:
		return error("unknown file mode for %s in index", path);
	}

finish:
	if (state->refresh_cache) {
		assert(state->istate);
		if (!fstat_done)
			lstat(ce->name, &st);
		fill_stat_cache_info(ce, &st);
		ce->ce_flags |= CE_UPDATE_IN_BASE;
		state->istate->cache_changed |= CE_ENTRY_CHANGED;
	}
	return 0;
}

/*
 * This is like 'lstat()', except it refuses to follow symlinks
 * in the path, after skipping "skiplen".
 */
static int check_path(const char *path, int len, struct stat *st, int skiplen)
{
	const char *slash = path + len;

	while (path < slash && *slash != '/')
		slash--;
	if (!has_dirs_only_path(path, slash - path, skiplen)) {
		errno = ENOENT;
		return -1;
	}
	return lstat(path, st);
}

/*
 * Write the contents from ce out to the working tree.
 *
 * When topath[] is not NULL, instead of writing to the working tree
 * file named by ce, a temporary file is created by this function and
 * its name is returned in topath[], which must be able to hold at
 * least TEMPORARY_FILENAME_LENGTH bytes long.
 */
int checkout_entry(struct cache_entry *ce,
		   const struct checkout *state, char *topath)
{
	static struct strbuf path = STRBUF_INIT;
	struct stat st;

	if (topath)
		return write_entry(ce, topath, state, 1);

	strbuf_reset(&path);
	strbuf_add(&path, state->base_dir, state->base_dir_len);
	strbuf_add(&path, ce->name, ce_namelen(ce));

	if (!check_path(path.buf, path.len, &st, state->base_dir_len)) {
		const struct submodule *sub;
		unsigned changed = ce_match_stat(ce, &st, CE_MATCH_IGNORE_VALID|CE_MATCH_IGNORE_SKIP_WORKTREE);
		/*
		 * Needs to be checked before !changed returns early,
		 * as the possibly empty directory was not changed
		 */
		sub = submodule_from_ce(ce);
		if (sub) {
			int err;
			if (!is_submodule_populated_gently(ce->name, &err)) {
				struct stat sb;
				if (lstat(ce->name, &sb))
					die(_("could not stat file '%s'"), ce->name);
				if (!(st.st_mode & S_IFDIR))
					unlink_or_warn(ce->name);

				return submodule_move_head(ce->name,
					NULL, oid_to_hex(&ce->oid), 0);
			} else
				return submodule_move_head(ce->name,
					"HEAD", oid_to_hex(&ce->oid),
					state->force ? SUBMODULE_MOVE_HEAD_FORCE : 0);
		}

		if (!changed)
			return 0;
		if (!state->force) {
			if (!state->quiet)
				fprintf(stderr,
					"%s already exists, no checkout\n",
					path.buf);
			return -1;
		}

		/*
		 * We unlink the old file, to get the new one with the
		 * right permissions (including umask, which is nasty
		 * to emulate by hand - much easier to let the system
		 * just do the right thing)
		 */
		if (S_ISDIR(st.st_mode)) {
			/* If it is a gitlink, leave it alone! */
			if (S_ISGITLINK(ce->ce_mode))
				return 0;
			if (!state->force)
				return error("%s is a directory", path.buf);
			remove_subtree(&path);
		} else if (unlink(path.buf))
			return error_errno("unable to unlink old '%s'", path.buf);
	} else if (state->not_new)
		return 0;

	create_directories(path.buf, path.len, state);
	return write_entry(ce, path.buf, state, 0);
}
Commit	Line	Data
12dccc16	1	#include "cache.h"
8e440259	2	#include "blob.h"
8ca12c0d	3	#include "dir.h"
dd8e9121	4	#include "streaming.h"
6d14eac3	5	#include "submodule.h"
12dccc16	6
81a9aa60 KB	7	static void create_directories(const char *path, int path_len,
81a9aa60 KB	8	const struct checkout *state)
12dccc16	9	{
3733e694	10	char *buf = xmallocz(path_len);
81a9aa60 KB	11	int len = 0;
	12
	13	while (len < path_len) {
	14	do {
	15	buf[len] = path[len];
	16	len++;
	17	} while (len < path_len && path[len] != '/');
	18	if (len >= path_len)
	19	break;
12dccc16	20	buf[len] = 0;
fa2e71c9	21
bad4a54f KB	22	/*
	23	* For 'checkout-index --prefix=<dir>', <dir> is
	24	* allowed to be a symlink to an existing directory,
	25	* and we set 'state->base_dir_len' below, such that
	26	* we test the path components of the prefix with the
	27	* stat() function instead of the lstat() function.
	28	*/
57199892	29	if (has_dirs_only_path(buf, len, state->base_dir_len))
fa2e71c9 JH	30	continue; /* ok, it is already a directory. */
	31
	32	/*
bad4a54f KB	33	* If this mkdir() would fail, it could be that there
	34	* is already a symlink or something else exists
	35	* there, therefore we then try to unlink it and try
	36	* one more time to create the directory.
fa2e71c9	37	*/
f312de01	38	if (mkdir(buf, 0777)) {
fa2e71c9	39	if (errno == EEXIST && state->force &&
691f1a28	40	!unlink_or_warn(buf) && !mkdir(buf, 0777))
fa2e71c9	41	continue;
0721c314	42	die_errno("cannot create directory at '%s'", buf);
12dccc16 LT	43	}
	44	}
	45	free(buf);
	46	}
	47
2f29e0c6	48	static void remove_subtree(struct strbuf *path)
12dccc16	49	{
2f29e0c6	50	DIR *dir = opendir(path->buf);
12dccc16	51	struct dirent *de;
2f29e0c6	52	int origlen = path->len;
a6080a0a	53
12dccc16	54	if (!dir)
2f29e0c6	55	die_errno("cannot opendir '%s'", path->buf);
12dccc16 LT	56	while ((de = readdir(dir)) != NULL) {
12dccc16 LT	57	struct stat st;
2f29e0c6	58
8ca12c0d	59	if (is_dot_or_dotdot(de->d_name))
12dccc16	60	continue;
2f29e0c6 MH	61
	62	strbuf_addch(path, '/');
	63	strbuf_addstr(path, de->d_name);
	64	if (lstat(path->buf, &st))
	65	die_errno("cannot lstat '%s'", path->buf);
12dccc16	66	if (S_ISDIR(st.st_mode))
2f29e0c6 MH	67	remove_subtree(path);
	68	else if (unlink(path->buf))
	69	die_errno("cannot unlink '%s'", path->buf);
	70	strbuf_setlen(path, origlen);
12dccc16 LT	71	}
12dccc16 LT	72	closedir(dir);
2f29e0c6 MH	73	if (rmdir(path->buf))
2f29e0c6 MH	74	die_errno("cannot rmdir '%s'", path->buf);
12dccc16 LT	75	}
12dccc16 LT	76
d48a72f3	77	static int create_file(const char *path, unsigned int mode)
12dccc16	78	{
12dccc16	79	mode = (mode & 0100) ? 0777 : 0666;
781411ed	80	return open(path, O_WRONLY \| O_CREAT \| O_EXCL, mode);
12dccc16 LT	81	}
12dccc16 LT	82
9c5e6c80	83	static void read_blob_entry(const struct cache_entry ce, unsigned long *size)
f0807e62 LT	84	{
f0807e62 LT	85	enum object_type type;
99d1a986	86	void *new = read_sha1_file(ce->oid.hash, &type, size);
f0807e62 LT	87
	88	if (new) {
	89	if (type == OBJ_BLOB)
	90	return new;
	91	free(new);
	92	}
	93	return NULL;
	94	}
	95
9c5e6c80	96	static int open_output_fd(char path, const struct cache_entry ce, int to_tempfile)
fd5db55d JH	97	{
	98	int symlink = (ce->ce_mode & S_IFMT) != S_IFREG;
	99	if (to_tempfile) {
330c8e26 JK	100	xsnprintf(path, TEMPORARY_FILENAME_LENGTH, "%s",
330c8e26 JK	101	symlink ? ".merge_link_XXXXXX" : ".merge_file_XXXXXX");
fd5db55d JH	102	return mkstemp(path);
	103	} else {
	104	return create_file(path, !symlink ? ce->ce_mode : 0666);
	105	}
	106	}
	107
	108	static int fstat_output(int fd, const struct checkout state, struct stat st)
	109	{
	110	/* use fstat() only when path == ce->name */
	111	if (fstat_is_reliable() &&
	112	state->refresh_cache && !state->base_dir_len) {
	113	fstat(fd, st);
	114	return 1;
	115	}
	116	return 0;
	117	}
	118
9c5e6c80	119	static int streaming_write_entry(const struct cache_entry ce, char path,
b6691092	120	struct stream_filter *filter,
dd8e9121 JH	121	const struct checkout *state, int to_tempfile,
	122	int fstat_done, struct stat statbuf)
	123	{
d9c31e14	124	int result = 0;
47a02ff2	125	int fd;
dd8e9121 JH	126
dd8e9121 JH	127	fd = open_output_fd(path, ce, to_tempfile);
d9c31e14 JK	128	if (fd < 0)
	129	return -1;
	130
7eda0e4f	131	result \|= stream_blob_to_fd(fd, &ce->oid, filter, 1);
d9c31e14 JK	132	*fstat_done = fstat_output(fd, state, statbuf);
	133	result \|= close(fd);
	134
	135	if (result)
dd8e9121 JH	136	unlink(path);
	137	return result;
	138	}
	139
9c5e6c80 NTND	140	static int write_entry(struct cache_entry *ce,
9c5e6c80 NTND	141	char path, const struct checkout state, int to_tempfile)
12dccc16	142	{
4857c761	143	unsigned int ce_mode_s_ifmt = ce->ce_mode & S_IFMT;
e4c72923	144	int fd, ret, fstat_done = 0;
4857c761 KB	145	char *new;
	146	struct strbuf buf = STRBUF_INIT;
	147	unsigned long size;
	148	size_t wrote, newsize = 0;
e4c72923	149	struct stat st;
6d14eac3	150	const struct submodule *sub;
4857c761	151
b6691092	152	if (ce_mode_s_ifmt == S_IFREG) {
99d1a986	153	struct stream_filter *filter = get_stream_filter(ce->name,
99d1a986	154	ce->oid.hash);
b6691092 JH	155	if (filter &&
	156	!streaming_write_entry(ce, path, filter,
	157	state, to_tempfile,
	158	&fstat_done, &st))
	159	goto finish;
	160	}
dd8e9121	161
4857c761	162	switch (ce_mode_s_ifmt) {
12dccc16	163	case S_IFREG:
4857c761 KB	164	case S_IFLNK:
4857c761 KB	165	new = read_blob_entry(ce, &size);
f0807e62	166	if (!new)
d43e9073	167	return error("unable to read sha1 file of %s (%s)",
99d1a986	168	path, oid_to_hex(&ce->oid));
1a9d7e9b	169
4857c761 KB	170	if (ce_mode_s_ifmt == S_IFLNK && has_symlinks && !to_tempfile) {
	171	ret = symlink(new, path);
	172	free(new);
	173	if (ret)
e1ebb3c2 NTND	174	return error_errno("unable to create symlink %s",
e1ebb3c2 NTND	175	path);
4857c761 KB	176	break;
	177	}
	178
1a9d7e9b JH	179	/*
	180	* Convert from git internal format to working tree format
	181	*/
4857c761 KB	182	if (ce_mode_s_ifmt == S_IFREG &&
4857c761 KB	183	convert_to_working_tree(ce->name, new, size, &buf)) {
1a9d7e9b	184	free(new);
c32f749f RS	185	new = strbuf_detach(&buf, &newsize);
c32f749f RS	186	size = newsize;
1a9d7e9b JH	187	}
1a9d7e9b JH	188
fd5db55d	189	fd = open_output_fd(path, ce, to_tempfile);
12dccc16 LT	190	if (fd < 0) {
12dccc16 LT	191	free(new);
e1ebb3c2	192	return error_errno("unable to create file %s", path);
12dccc16	193	}
6c510bee	194
93822c22	195	wrote = write_in_full(fd, new, size);
fd5db55d JH	196	if (!to_tempfile)
fd5db55d JH	197	fstat_done = fstat_output(fd, state, &st);
12dccc16 LT	198	close(fd);
	199	free(new);
	200	if (wrote != size)
d43e9073	201	return error("unable to write file %s", path);
12dccc16	202	break;
302b9282	203	case S_IFGITLINK:
f0807e62	204	if (to_tempfile)
42063f95	205	return error("cannot create temporary submodule %s", path);
f0807e62	206	if (mkdir(path, 0777) < 0)
42063f95	207	return error("cannot create submodule directory %s", path);
6d14eac3 SB	208	sub = submodule_from_ce(ce);
	209	if (sub)
	210	return submodule_move_head(ce->name,
cd279e2e SB	211	NULL, oid_to_hex(&ce->oid),
cd279e2e SB	212	state->force ? SUBMODULE_MOVE_HEAD_FORCE : 0);
f0807e62	213	break;
12dccc16	214	default:
d43e9073	215	return error("unknown file mode for %s in index", path);
12dccc16 LT	216	}
12dccc16 LT	217
dd8e9121	218	finish:
6ee67f26	219	if (state->refresh_cache) {
d4a2024a	220	assert(state->istate);
e4c72923 KB	221	if (!fstat_done)
e4c72923 KB	222	lstat(ce->name, &st);
12dccc16	223	fill_stat_cache_info(ce, &st);
078a58e8	224	ce->ce_flags \|= CE_UPDATE_IN_BASE;
d4a2024a	225	state->istate->cache_changed \|= CE_ENTRY_CHANGED;
12dccc16 LT	226	}
	227	return 0;
	228	}
	229
b6986d8a LT	230	/*
b6986d8a LT	231	* This is like 'lstat()', except it refuses to follow symlinks
da02ca50	232	* in the path, after skipping "skiplen".
b6986d8a	233	*/
61b97df7	234	static int check_path(const char path, int len, struct stat st, int skiplen)
b6986d8a	235	{
da02ca50 JH	236	const char *slash = path + len;
	237
	238	while (path < slash && *slash != '/')
	239	slash--;
	240	if (!has_dirs_only_path(path, slash - path, skiplen)) {
b6986d8a LT	241	errno = ENOENT;
	242	return -1;
	243	}
	244	return lstat(path, st);
	245	}
	246
af2a651d JH	247	/*
	248	* Write the contents from ce out to the working tree.
	249	*
	250	* When topath[] is not NULL, instead of writing to the working tree
	251	* file named by ce, a temporary file is created by this function and
	252	* its name is returned in topath[], which must be able to hold at
	253	* least TEMPORARY_FILENAME_LENGTH bytes long.
	254	*/
9c5e6c80 NTND	255	int checkout_entry(struct cache_entry *ce,
9c5e6c80 NTND	256	const struct checkout state, char topath)
12dccc16	257	{
f63272a3	258	static struct strbuf path = STRBUF_INIT;
de84f99c	259	struct stat st;
12dccc16	260
de84f99c SP	261	if (topath)
	262	return write_entry(ce, topath, state, 1);
	263
f63272a3 MH	264	strbuf_reset(&path);
	265	strbuf_add(&path, state->base_dir, state->base_dir_len);
	266	strbuf_add(&path, ce->name, ce_namelen(ce));
12dccc16	267
f63272a3	268	if (!check_path(path.buf, path.len, &st, state->base_dir_len)) {
6d14eac3	269	const struct submodule *sub;
56cac48c	270	unsigned changed = ce_match_stat(ce, &st, CE_MATCH_IGNORE_VALID\|CE_MATCH_IGNORE_SKIP_WORKTREE);
6d14eac3 SB	271	/*
	272	* Needs to be checked before !changed returns early,
	273	* as the possibly empty directory was not changed
	274	*/
	275	sub = submodule_from_ce(ce);
	276	if (sub) {
	277	int err;
	278	if (!is_submodule_populated_gently(ce->name, &err)) {
	279	struct stat sb;
	280	if (lstat(ce->name, &sb))
	281	die(_("could not stat file '%s'"), ce->name);
	282	if (!(st.st_mode & S_IFDIR))
	283	unlink_or_warn(ce->name);
	284
	285	return submodule_move_head(ce->name,
cd279e2e	286	NULL, oid_to_hex(&ce->oid), 0);
6d14eac3 SB	287	} else
	288	return submodule_move_head(ce->name,
	289	"HEAD", oid_to_hex(&ce->oid),
cd279e2e	290	state->force ? SUBMODULE_MOVE_HEAD_FORCE : 0);
6d14eac3 SB	291	}
6d14eac3 SB	292
12dccc16 LT	293	if (!changed)
	294	return 0;
	295	if (!state->force) {
	296	if (!state->quiet)
f63272a3 MH	297	fprintf(stderr,
	298	"%s already exists, no checkout\n",
	299	path.buf);
4b12dae6	300	return -1;
12dccc16 LT	301	}
	302
	303	/*
	304	* We unlink the old file, to get the new one with the
	305	* right permissions (including umask, which is nasty
	306	* to emulate by hand - much easier to let the system
	307	* just do the right thing)
	308	*/
d48a72f3	309	if (S_ISDIR(st.st_mode)) {
f0807e62	310	/* If it is a gitlink, leave it alone! */
7a51ed66	311	if (S_ISGITLINK(ce->ce_mode))
f0807e62	312	return 0;
d48a72f3	313	if (!state->force)
f63272a3	314	return error("%s is a directory", path.buf);
2f29e0c6	315	remove_subtree(&path);
f63272a3	316	} else if (unlink(path.buf))
e1ebb3c2	317	return error_errno("unable to unlink old '%s'", path.buf);
de84f99c	318	} else if (state->not_new)
12dccc16	319	return 0;
f63272a3 MH	320
	321	create_directories(path.buf, path.len, state);
	322	return write_entry(ce, path.buf, state, 0);
12dccc16	323	}