[thirdparty/git.git] / dir.c

/*
 * This handles recursive filename detection with exclude
 * files, index knowledge etc..
 *
 * Copyright (C) Linus Torvalds, 2005-2006
 *		 Junio Hamano, 2005-2006
 */
#include <dirent.h>
#include <fnmatch.h>

#include "cache.h"
#include "dir.h"

int common_prefix(const char **pathspec)
{
	const char *path, *slash, *next;
	int prefix;

	if (!pathspec)
		return 0;

	path = *pathspec;
	slash = strrchr(path, '/');
	if (!slash)
		return 0;

	prefix = slash - path + 1;
	while ((next = *++pathspec) != NULL) {
		int len = strlen(next);
		if (len >= prefix && !memcmp(path, next, len))
			continue;
		for (;;) {
			if (!len)
				return 0;
			if (next[--len] != '/')
				continue;
			if (memcmp(path, next, len+1))
				continue;
			prefix = len + 1;
			break;
		}
	}
	return prefix;
}

static int match_one(const char *match, const char *name, int namelen)
{
	int matchlen;

	/* If the match was just the prefix, we matched */
	matchlen = strlen(match);
	if (!matchlen)
		return 1;

	/*
	 * If we don't match the matchstring exactly,
	 * we need to match by fnmatch
	 */
	if (strncmp(match, name, matchlen))
		return !fnmatch(match, name, 0);

	/*
	 * If we did match the string exactly, we still
	 * need to make sure that it happened on a path
	 * component boundary (ie either the last character
	 * of the match was '/', or the next character of
	 * the name was '/' or the terminating NUL.
	 */
	return	match[matchlen-1] == '/' ||
		name[matchlen] == '/' ||
		!name[matchlen];
}

int match_pathspec(const char **pathspec, const char *name, int namelen, int prefix, char *seen)
{
	int retval;
	const char *match;

	name += prefix;
	namelen -= prefix;

	for (retval = 0; (match = *pathspec++) != NULL; seen++) {
		if (retval & *seen)
			continue;
		match += prefix;
		if (match_one(match, name, namelen)) {
			retval = 1;
			*seen = 1;
		}
	}
	return retval;
}

void add_exclude(const char *string, const char *base,
		 int baselen, struct exclude_list *which)
{
	struct exclude *x = xmalloc(sizeof (*x));

	x->pattern = string;
	x->base = base;
	x->baselen = baselen;
	if (which->nr == which->alloc) {
		which->alloc = alloc_nr(which->alloc);
		which->excludes = xrealloc(which->excludes,
					   which->alloc * sizeof(x));
	}
	which->excludes[which->nr++] = x;
}

static int add_excludes_from_file_1(const char *fname,
				    const char *base,
				    int baselen,
				    struct exclude_list *which)
{
	int fd, i;
	long size;
	char *buf, *entry;

	fd = open(fname, O_RDONLY);
	if (fd < 0)
		goto err;
	size = lseek(fd, 0, SEEK_END);
	if (size < 0)
		goto err;
	lseek(fd, 0, SEEK_SET);
	if (size == 0) {
		close(fd);
		return 0;
	}
	buf = xmalloc(size+1);
	if (read(fd, buf, size) != size)
		goto err;
	close(fd);

	buf[size++] = '\n';
	entry = buf;
	for (i = 0; i < size; i++) {
		if (buf[i] == '\n') {
			if (entry != buf + i && entry[0] != '#') {
				buf[i - (i && buf[i-1] == '\r')] = 0;
				add_exclude(entry, base, baselen, which);
			}
			entry = buf + i + 1;
		}
	}
	return 0;

 err:
	if (0 <= fd)
		close(fd);
	return -1;
}

void add_excludes_from_file(struct dir_struct *dir, const char *fname)
{
	if (add_excludes_from_file_1(fname, "", 0,
				     &dir->exclude_list[EXC_FILE]) < 0)
		die("cannot use %s as an exclude file", fname);
}

static int push_exclude_per_directory(struct dir_struct *dir, const char *base, int baselen)
{
	char exclude_file[PATH_MAX];
	struct exclude_list *el = &dir->exclude_list[EXC_DIRS];
	int current_nr = el->nr;

	if (dir->exclude_per_dir) {
		memcpy(exclude_file, base, baselen);
		strcpy(exclude_file + baselen, dir->exclude_per_dir);
		add_excludes_from_file_1(exclude_file, base, baselen, el);
	}
	return current_nr;
}

static void pop_exclude_per_directory(struct dir_struct *dir, int stk)
{
	struct exclude_list *el = &dir->exclude_list[EXC_DIRS];

	while (stk < el->nr)
		free(el->excludes[--el->nr]);
}

/* Scan the list and let the last match determines the fate.
 * Return 1 for exclude, 0 for include and -1 for undecided.
 */
static int excluded_1(const char *pathname,
		      int pathlen,
		      struct exclude_list *el)
{
	int i;

	if (el->nr) {
		for (i = el->nr - 1; 0 <= i; i--) {
			struct exclude *x = el->excludes[i];
			const char *exclude = x->pattern;
			int to_exclude = 1;

			if (*exclude == '!') {
				to_exclude = 0;
				exclude++;
			}

			if (!strchr(exclude, '/')) {
				/* match basename */
				const char *basename = strrchr(pathname, '/');
				basename = (basename) ? basename+1 : pathname;
				if (fnmatch(exclude, basename, 0) == 0)
					return to_exclude;
			}
			else {
				/* match with FNM_PATHNAME:
				 * exclude has base (baselen long) implicitly
				 * in front of it.
				 */
				int baselen = x->baselen;
				if (*exclude == '/')
					exclude++;

				if (pathlen < baselen ||
				    (baselen && pathname[baselen-1] != '/') ||
				    strncmp(pathname, x->base, baselen))
				    continue;

				if (fnmatch(exclude, pathname+baselen,
					    FNM_PATHNAME) == 0)
					return to_exclude;
			}
		}
	}
	return -1; /* undecided */
}

int excluded(struct dir_struct *dir, const char *pathname)
{
	int pathlen = strlen(pathname);
	int st;

	for (st = EXC_CMDL; st <= EXC_FILE; st++) {
		switch (excluded_1(pathname, pathlen, &dir->exclude_list[st])) {
		case 0:
			return 0;
		case 1:
			return 1;
		}
	}
	return 0;
}

static void add_name(struct dir_struct *dir, const char *pathname, int len)
{
	struct dir_entry *ent;

	if (cache_name_pos(pathname, len) >= 0)
		return;

	if (dir->nr == dir->alloc) {
		int alloc = alloc_nr(dir->alloc);
		dir->alloc = alloc;
		dir->entries = xrealloc(dir->entries, alloc*sizeof(ent));
	}
	ent = xmalloc(sizeof(*ent) + len + 1);
	ent->len = len;
	memcpy(ent->name, pathname, len);
	ent->name[len] = 0;
	dir->entries[dir->nr++] = ent;
}

static int dir_exists(const char *dirname, int len)
{
	int pos = cache_name_pos(dirname, len);
	if (pos >= 0)
		return 1;
	pos = -pos-1;
	if (pos >= active_nr) /* can't */
		return 0;
	return !strncmp(active_cache[pos]->name, dirname, len);
}

/*
 * Read a directory tree. We currently ignore anything but
 * directories, regular files and symlinks. That's because git
 * doesn't handle them at all yet. Maybe that will change some
 * day.
 *
 * Also, we ignore the name ".git" (even if it is not a directory).
 * That likely will not change.
 */
static int read_directory_recursive(struct dir_struct *dir, const char *path, const char *base, int baselen)
{
	DIR *fdir = opendir(path);
	int contents = 0;

	if (fdir) {
		int exclude_stk;
		struct dirent *de;
		char fullname[PATH_MAX + 1];
		memcpy(fullname, base, baselen);

		exclude_stk = push_exclude_per_directory(dir, base, baselen);

		while ((de = readdir(fdir)) != NULL) {
			int len;

			if ((de->d_name[0] == '.') &&
			    (de->d_name[1] == 0 ||
			     !strcmp(de->d_name + 1, ".") ||
			     !strcmp(de->d_name + 1, "git")))
				continue;
			len = strlen(de->d_name);
			memcpy(fullname + baselen, de->d_name, len+1);
			if (excluded(dir, fullname) != dir->show_ignored) {
				if (!dir->show_ignored || DTYPE(de) != DT_DIR) {
					continue;
				}
			}

			switch (DTYPE(de)) {
			struct stat st;
			int subdir, rewind_base;
			default:
				continue;
			case DT_UNKNOWN:
				if (lstat(fullname, &st))
					continue;
				if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))
					break;
				if (!S_ISDIR(st.st_mode))
					continue;
				/* fallthrough */
			case DT_DIR:
				memcpy(fullname + baselen + len, "/", 2);
				len++;
				rewind_base = dir->nr;
				subdir = read_directory_recursive(dir, fullname, fullname,
				                        baselen + len);
				if (dir->show_other_directories &&
				    (subdir || !dir->hide_empty_directories) &&
				    !dir_exists(fullname, baselen + len)) {
					/* Rewind the read subdirectory */
					while (dir->nr > rewind_base)
						free(dir->entries[--dir->nr]);
					break;
				}
				contents += subdir;
				continue;
			case DT_REG:
			case DT_LNK:
				break;
			}
			add_name(dir, fullname, baselen + len);
			contents++;
		}
		closedir(fdir);

		pop_exclude_per_directory(dir, exclude_stk);
	}

	return contents;
}

static int cmp_name(const void *p1, const void *p2)
{
	const struct dir_entry *e1 = *(const struct dir_entry **)p1;
	const struct dir_entry *e2 = *(const struct dir_entry **)p2;

	return cache_name_compare(e1->name, e1->len,
				  e2->name, e2->len);
}

int read_directory(struct dir_struct *dir, const char *path, const char *base, int baselen)
{
	/*
	 * Make sure to do the per-directory exclude for all the
	 * directories leading up to our base.
	 */
	if (baselen) {
		if (dir->exclude_per_dir) {
			char *p, *pp = xmalloc(baselen+1);
			memcpy(pp, base, baselen+1);
			p = pp;
			while (1) {
				char save = *p;
				*p = 0;
				push_exclude_per_directory(dir, pp, p-pp);
				*p++ = save;
				if (!save)
					break;
				p = strchr(p, '/');
				if (p)
					p++;
				else
					p = pp + baselen;
			}
			free(pp);
		}
	}

	read_directory_recursive(dir, path, base, baselen);
	qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);
	return dir->nr;
}
Commit	Line	Data
453ec4bd LT	1	/*
	2	* This handles recursive filename detection with exclude
	3	* files, index knowledge etc..
	4	*
	5	* Copyright (C) Linus Torvalds, 2005-2006
	6	* Junio Hamano, 2005-2006
	7	*/
	8	#include <dirent.h>
	9	#include <fnmatch.h>
	10
	11	#include "cache.h"
	12	#include "dir.h"
	13
3c6a370b LT	14	int common_prefix(const char **pathspec)
	15	{
	16	const char path, slash, *next;
	17	int prefix;
	18
	19	if (!pathspec)
	20	return 0;
	21
	22	path = *pathspec;
	23	slash = strrchr(path, '/');
	24	if (!slash)
	25	return 0;
	26
	27	prefix = slash - path + 1;
	28	while ((next = *++pathspec) != NULL) {
	29	int len = strlen(next);
	30	if (len >= prefix && !memcmp(path, next, len))
	31	continue;
	32	for (;;) {
	33	if (!len)
	34	return 0;
	35	if (next[--len] != '/')
	36	continue;
	37	if (memcmp(path, next, len+1))
	38	continue;
	39	prefix = len + 1;
	40	break;
	41	}
	42	}
	43	return prefix;
	44	}
	45
	46	static int match_one(const char match, const char name, int namelen)
	47	{
	48	int matchlen;
	49
	50	/* If the match was just the prefix, we matched */
	51	matchlen = strlen(match);
	52	if (!matchlen)
	53	return 1;
	54
	55	/*
	56	* If we don't match the matchstring exactly,
	57	* we need to match by fnmatch
	58	*/
	59	if (strncmp(match, name, matchlen))
	60	return !fnmatch(match, name, 0);
	61
	62	/*
	63	* If we did match the string exactly, we still
	64	* need to make sure that it happened on a path
	65	* component boundary (ie either the last character
	66	* of the match was '/', or the next character of
	67	* the name was '/' or the terminating NUL.
	68	*/
	69	return match[matchlen-1] == '/' \|\|
	70	name[matchlen] == '/' \|\|
	71	!name[matchlen];
	72	}
	73
	74	int match_pathspec(const char *pathspec, const char name, int namelen, int prefix, char *seen)
	75	{
	76	int retval;
	77	const char *match;
78
79	name += prefix;
80	namelen -= prefix;
81
82	for (retval = 0; (match = *pathspec++) != NULL; seen++) {
83	if (retval & *seen)
84	continue;
85	match += prefix;
86	if (match_one(match, name, namelen)) {
87	retval = 1;
88	*seen = 1;
89	}
90	}
91	return retval;
92	}
93
453ec4bd LT	94	void add_exclude(const char string, const char base,
	95	int baselen, struct exclude_list *which)
	96	{
	97	struct exclude x = xmalloc(sizeof (x));
	98
	99	x->pattern = string;
	100	x->base = base;
	101	x->baselen = baselen;
	102	if (which->nr == which->alloc) {
	103	which->alloc = alloc_nr(which->alloc);
83572c1a JF	104	which->excludes = xrealloc(which->excludes,
83572c1a JF	105	which->alloc * sizeof(x));
453ec4bd LT	106	}
	107	which->excludes[which->nr++] = x;
	108	}
	109
	110	static int add_excludes_from_file_1(const char *fname,
	111	const char *base,
	112	int baselen,
	113	struct exclude_list *which)
	114	{
	115	int fd, i;
	116	long size;
	117	char buf, entry;
	118
	119	fd = open(fname, O_RDONLY);
	120	if (fd < 0)
	121	goto err;
	122	size = lseek(fd, 0, SEEK_END);
	123	if (size < 0)
	124	goto err;
	125	lseek(fd, 0, SEEK_SET);
	126	if (size == 0) {
	127	close(fd);
	128	return 0;
	129	}
	130	buf = xmalloc(size+1);
	131	if (read(fd, buf, size) != size)
	132	goto err;
	133	close(fd);
	134
	135	buf[size++] = '\n';
	136	entry = buf;
	137	for (i = 0; i < size; i++) {
	138	if (buf[i] == '\n') {
	139	if (entry != buf + i && entry[0] != '#') {
	140	buf[i - (i && buf[i-1] == '\r')] = 0;
	141	add_exclude(entry, base, baselen, which);
	142	}
	143	entry = buf + i + 1;
	144	}
	145	}
	146	return 0;
	147
	148	err:
	149	if (0 <= fd)
	150	close(fd);
	151	return -1;
	152	}
	153
	154	void add_excludes_from_file(struct dir_struct dir, const char fname)
	155	{
	156	if (add_excludes_from_file_1(fname, "", 0,
	157	&dir->exclude_list[EXC_FILE]) < 0)
	158	die("cannot use %s as an exclude file", fname);
	159	}
	160
b4189aa8	161	static int push_exclude_per_directory(struct dir_struct dir, const char base, int baselen)
453ec4bd LT	162	{
	163	char exclude_file[PATH_MAX];
	164	struct exclude_list *el = &dir->exclude_list[EXC_DIRS];
	165	int current_nr = el->nr;
	166
	167	if (dir->exclude_per_dir) {
	168	memcpy(exclude_file, base, baselen);
	169	strcpy(exclude_file + baselen, dir->exclude_per_dir);
	170	add_excludes_from_file_1(exclude_file, base, baselen, el);
	171	}
	172	return current_nr;
	173	}
	174
	175	static void pop_exclude_per_directory(struct dir_struct *dir, int stk)
	176	{
	177	struct exclude_list *el = &dir->exclude_list[EXC_DIRS];
	178
	179	while (stk < el->nr)
	180	free(el->excludes[--el->nr]);
	181	}
	182
	183	/* Scan the list and let the last match determines the fate.
	184	* Return 1 for exclude, 0 for include and -1 for undecided.
	185	*/
	186	static int excluded_1(const char *pathname,
	187	int pathlen,
	188	struct exclude_list *el)
	189	{
	190	int i;
	191
	192	if (el->nr) {
	193	for (i = el->nr - 1; 0 <= i; i--) {
	194	struct exclude *x = el->excludes[i];
	195	const char *exclude = x->pattern;
	196	int to_exclude = 1;
	197
	198	if (*exclude == '!') {
	199	to_exclude = 0;
	200	exclude++;
	201	}
	202
	203	if (!strchr(exclude, '/')) {
	204	/* match basename */
	205	const char *basename = strrchr(pathname, '/');
	206	basename = (basename) ? basename+1 : pathname;
	207	if (fnmatch(exclude, basename, 0) == 0)
	208	return to_exclude;
	209	}
	210	else {
	211	/* match with FNM_PATHNAME:
	212	* exclude has base (baselen long) implicitly
	213	* in front of it.
	214	*/
	215	int baselen = x->baselen;
	216	if (*exclude == '/')
	217	exclude++;
	218
	219	if (pathlen < baselen \|\|
	220	(baselen && pathname[baselen-1] != '/') \|\|
	221	strncmp(pathname, x->base, baselen))
	222	continue;
	223
	224	if (fnmatch(exclude, pathname+baselen,
	225	FNM_PATHNAME) == 0)
226	return to_exclude;
227	}
228	}
229	}
230	return -1; /* undecided */
231	}
232
233	int excluded(struct dir_struct dir, const char pathname)
234	{
235	int pathlen = strlen(pathname);
236	int st;
237
238	for (st = EXC_CMDL; st <= EXC_FILE; st++) {
239	switch (excluded_1(pathname, pathlen, &dir->exclude_list[st])) {
240	case 0:
241	return 0;
242	case 1:
243	return 1;
244	}
245	}
246	return 0;
247	}
248
249	static void add_name(struct dir_struct dir, const char pathname, int len)
250	{
251	struct dir_entry *ent;
252
253	if (cache_name_pos(pathname, len) >= 0)
254	return;
255
256	if (dir->nr == dir->alloc) {
257	int alloc = alloc_nr(dir->alloc);
258	dir->alloc = alloc;
259	dir->entries = xrealloc(dir->entries, alloc*sizeof(ent));
260	}
261	ent = xmalloc(sizeof(*ent) + len + 1);
262	ent->len = len;
263	memcpy(ent->name, pathname, len);
264	ent->name[len] = 0;
265	dir->entries[dir->nr++] = ent;
266	}
267
268	static int dir_exists(const char *dirname, int len)
269	{
270	int pos = cache_name_pos(dirname, len);
271	if (pos >= 0)
272	return 1;
273	pos = -pos-1;
274	if (pos >= active_nr) /* can't */
275	return 0;
276	return !strncmp(active_cache[pos]->name, dirname, len);
277	}
278
279	/*
280	* Read a directory tree. We currently ignore anything but
281	* directories, regular files and symlinks. That's because git
282	* doesn't handle them at all yet. Maybe that will change some
283	* day.
284	*
285	* Also, we ignore the name ".git" (even if it is not a directory).
286	* That likely will not change.
287	*/
288	static int read_directory_recursive(struct dir_struct dir, const char path, const char *base, int baselen)
289	{
290	DIR *fdir = opendir(path);
291	int contents = 0;
292
293	if (fdir) {
294	int exclude_stk;
295	struct dirent *de;
095c424d	296	char fullname[PATH_MAX + 1];
453ec4bd LT	297	memcpy(fullname, base, baselen);
	298
	299	exclude_stk = push_exclude_per_directory(dir, base, baselen);
	300
	301	while ((de = readdir(fdir)) != NULL) {
	302	int len;
	303
	304	if ((de->d_name[0] == '.') &&
	305	(de->d_name[1] == 0 \|\|
	306	!strcmp(de->d_name + 1, ".") \|\|
	307	!strcmp(de->d_name + 1, "git")))
	308	continue;
	309	len = strlen(de->d_name);
	310	memcpy(fullname + baselen, de->d_name, len+1);
	311	if (excluded(dir, fullname) != dir->show_ignored) {
	312	if (!dir->show_ignored \|\| DTYPE(de) != DT_DIR) {
	313	continue;
	314	}
	315	}
	316
	317	switch (DTYPE(de)) {
	318	struct stat st;
	319	int subdir, rewind_base;
	320	default:
	321	continue;
	322	case DT_UNKNOWN:
	323	if (lstat(fullname, &st))
	324	continue;
	325	if (S_ISREG(st.st_mode) \|\| S_ISLNK(st.st_mode))
	326	break;
	327	if (!S_ISDIR(st.st_mode))
	328	continue;
	329	/* fallthrough */
	330	case DT_DIR:
	331	memcpy(fullname + baselen + len, "/", 2);
	332	len++;
	333	rewind_base = dir->nr;
	334	subdir = read_directory_recursive(dir, fullname, fullname,
	335	baselen + len);
	336	if (dir->show_other_directories &&
	337	(subdir \|\| !dir->hide_empty_directories) &&
	338	!dir_exists(fullname, baselen + len)) {
a9486b02	339	/* Rewind the read subdirectory */
453ec4bd LT	340	while (dir->nr > rewind_base)
	341	free(dir->entries[--dir->nr]);
	342	break;
	343	}
	344	contents += subdir;
	345	continue;
	346	case DT_REG:
	347	case DT_LNK:
	348	break;
	349	}
	350	add_name(dir, fullname, baselen + len);
	351	contents++;
	352	}
	353	closedir(fdir);
	354
	355	pop_exclude_per_directory(dir, exclude_stk);
	356	}
	357
	358	return contents;
	359	}
	360
	361	static int cmp_name(const void p1, const void p2)
	362	{
	363	const struct dir_entry e1 = (const struct dir_entry **)p1;
	364	const struct dir_entry e2 = (const struct dir_entry **)p2;
	365
	366	return cache_name_compare(e1->name, e1->len,
	367	e2->name, e2->len);
	368	}
	369
	370	int read_directory(struct dir_struct dir, const char path, const char *base, int baselen)
	371	{
b4189aa8 LT	372	/*
	373	* Make sure to do the per-directory exclude for all the
	374	* directories leading up to our base.
	375	*/
	376	if (baselen) {
	377	if (dir->exclude_per_dir) {
	378	char p, pp = xmalloc(baselen+1);
	379	memcpy(pp, base, baselen+1);
	380	p = pp;
	381	while (1) {
	382	char save = *p;
	383	*p = 0;
	384	push_exclude_per_directory(dir, pp, p-pp);
	385	*p++ = save;
	386	if (!save)
	387	break;
	388	p = strchr(p, '/');
	389	if (p)
	390	p++;
	391	else
	392	p = pp + baselen;
	393	}
	394	free(pp);
	395	}
	396	}
	397
453ec4bd LT	398	read_directory_recursive(dir, path, base, baselen);
	399	qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);
	400	return dir->nr;
	401	}