Merge branch 'master' into lj/refs
[git/git.git] / dir.c
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
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
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);
104 which->excludes = xrealloc(which->excludes,
105 which->alloc * sizeof(x));
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 struct stat st;
116 int fd, i;
117 long size;
118 char *buf, *entry;
119
120 fd = open(fname, O_RDONLY);
121 if (fd < 0 || fstat(fd, &st) < 0)
122 goto err;
123 size = st.st_size;
124 if (size == 0) {
125 close(fd);
126 return 0;
127 }
128 buf = xmalloc(size+1);
129 if (read(fd, buf, size) != size)
130 goto err;
131 close(fd);
132
133 buf[size++] = '\n';
134 entry = buf;
135 for (i = 0; i < size; i++) {
136 if (buf[i] == '\n') {
137 if (entry != buf + i && entry[0] != '#') {
138 buf[i - (i && buf[i-1] == '\r')] = 0;
139 add_exclude(entry, base, baselen, which);
140 }
141 entry = buf + i + 1;
142 }
143 }
144 return 0;
145
146 err:
147 if (0 <= fd)
148 close(fd);
149 return -1;
150 }
151
152 void add_excludes_from_file(struct dir_struct *dir, const char *fname)
153 {
154 if (add_excludes_from_file_1(fname, "", 0,
155 &dir->exclude_list[EXC_FILE]) < 0)
156 die("cannot use %s as an exclude file", fname);
157 }
158
159 static int push_exclude_per_directory(struct dir_struct *dir, const char *base, int baselen)
160 {
161 char exclude_file[PATH_MAX];
162 struct exclude_list *el = &dir->exclude_list[EXC_DIRS];
163 int current_nr = el->nr;
164
165 if (dir->exclude_per_dir) {
166 memcpy(exclude_file, base, baselen);
167 strcpy(exclude_file + baselen, dir->exclude_per_dir);
168 add_excludes_from_file_1(exclude_file, base, baselen, el);
169 }
170 return current_nr;
171 }
172
173 static void pop_exclude_per_directory(struct dir_struct *dir, int stk)
174 {
175 struct exclude_list *el = &dir->exclude_list[EXC_DIRS];
176
177 while (stk < el->nr)
178 free(el->excludes[--el->nr]);
179 }
180
181 /* Scan the list and let the last match determines the fate.
182 * Return 1 for exclude, 0 for include and -1 for undecided.
183 */
184 static int excluded_1(const char *pathname,
185 int pathlen,
186 struct exclude_list *el)
187 {
188 int i;
189
190 if (el->nr) {
191 for (i = el->nr - 1; 0 <= i; i--) {
192 struct exclude *x = el->excludes[i];
193 const char *exclude = x->pattern;
194 int to_exclude = 1;
195
196 if (*exclude == '!') {
197 to_exclude = 0;
198 exclude++;
199 }
200
201 if (!strchr(exclude, '/')) {
202 /* match basename */
203 const char *basename = strrchr(pathname, '/');
204 basename = (basename) ? basename+1 : pathname;
205 if (fnmatch(exclude, basename, 0) == 0)
206 return to_exclude;
207 }
208 else {
209 /* match with FNM_PATHNAME:
210 * exclude has base (baselen long) implicitly
211 * in front of it.
212 */
213 int baselen = x->baselen;
214 if (*exclude == '/')
215 exclude++;
216
217 if (pathlen < baselen ||
218 (baselen && pathname[baselen-1] != '/') ||
219 strncmp(pathname, x->base, baselen))
220 continue;
221
222 if (fnmatch(exclude, pathname+baselen,
223 FNM_PATHNAME) == 0)
224 return to_exclude;
225 }
226 }
227 }
228 return -1; /* undecided */
229 }
230
231 int excluded(struct dir_struct *dir, const char *pathname)
232 {
233 int pathlen = strlen(pathname);
234 int st;
235
236 for (st = EXC_CMDL; st <= EXC_FILE; st++) {
237 switch (excluded_1(pathname, pathlen, &dir->exclude_list[st])) {
238 case 0:
239 return 0;
240 case 1:
241 return 1;
242 }
243 }
244 return 0;
245 }
246
247 static void add_name(struct dir_struct *dir, const char *pathname, int len)
248 {
249 struct dir_entry *ent;
250
251 if (cache_name_pos(pathname, len) >= 0)
252 return;
253
254 if (dir->nr == dir->alloc) {
255 int alloc = alloc_nr(dir->alloc);
256 dir->alloc = alloc;
257 dir->entries = xrealloc(dir->entries, alloc*sizeof(ent));
258 }
259 ent = xmalloc(sizeof(*ent) + len + 1);
260 ent->len = len;
261 memcpy(ent->name, pathname, len);
262 ent->name[len] = 0;
263 dir->entries[dir->nr++] = ent;
264 }
265
266 static int dir_exists(const char *dirname, int len)
267 {
268 int pos = cache_name_pos(dirname, len);
269 if (pos >= 0)
270 return 1;
271 pos = -pos-1;
272 if (pos >= active_nr) /* can't */
273 return 0;
274 return !strncmp(active_cache[pos]->name, dirname, len);
275 }
276
277 /*
278 * Read a directory tree. We currently ignore anything but
279 * directories, regular files and symlinks. That's because git
280 * doesn't handle them at all yet. Maybe that will change some
281 * day.
282 *
283 * Also, we ignore the name ".git" (even if it is not a directory).
284 * That likely will not change.
285 */
286 static int read_directory_recursive(struct dir_struct *dir, const char *path, const char *base, int baselen, int check_only)
287 {
288 DIR *fdir = opendir(path);
289 int contents = 0;
290
291 if (fdir) {
292 int exclude_stk;
293 struct dirent *de;
294 char fullname[PATH_MAX + 1];
295 memcpy(fullname, base, baselen);
296
297 exclude_stk = push_exclude_per_directory(dir, base, baselen);
298
299 while ((de = readdir(fdir)) != NULL) {
300 int len;
301
302 if ((de->d_name[0] == '.') &&
303 (de->d_name[1] == 0 ||
304 !strcmp(de->d_name + 1, ".") ||
305 !strcmp(de->d_name + 1, "git")))
306 continue;
307 len = strlen(de->d_name);
308 memcpy(fullname + baselen, de->d_name, len+1);
309 if (excluded(dir, fullname) != dir->show_ignored) {
310 if (!dir->show_ignored || DTYPE(de) != DT_DIR) {
311 continue;
312 }
313 }
314
315 switch (DTYPE(de)) {
316 struct stat st;
317 default:
318 continue;
319 case DT_UNKNOWN:
320 if (lstat(fullname, &st))
321 continue;
322 if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))
323 break;
324 if (!S_ISDIR(st.st_mode))
325 continue;
326 /* fallthrough */
327 case DT_DIR:
328 memcpy(fullname + baselen + len, "/", 2);
329 len++;
330 if (dir->show_other_directories &&
331 !dir_exists(fullname, baselen + len)) {
332 if (dir->hide_empty_directories &&
333 !read_directory_recursive(dir,
334 fullname, fullname,
335 baselen + len, 1))
336 continue;
337 break;
338 }
339
340 contents += read_directory_recursive(dir,
341 fullname, fullname, baselen + len, 0);
342 continue;
343 case DT_REG:
344 case DT_LNK:
345 break;
346 }
347 contents++;
348 if (check_only)
349 goto exit_early;
350 else
351 add_name(dir, fullname, baselen + len);
352 }
353 exit_early:
354 closedir(fdir);
355
356 pop_exclude_per_directory(dir, exclude_stk);
357 }
358
359 return contents;
360 }
361
362 static int cmp_name(const void *p1, const void *p2)
363 {
364 const struct dir_entry *e1 = *(const struct dir_entry **)p1;
365 const struct dir_entry *e2 = *(const struct dir_entry **)p2;
366
367 return cache_name_compare(e1->name, e1->len,
368 e2->name, e2->len);
369 }
370
371 int read_directory(struct dir_struct *dir, const char *path, const char *base, int baselen)
372 {
373 /*
374 * Make sure to do the per-directory exclude for all the
375 * directories leading up to our base.
376 */
377 if (baselen) {
378 if (dir->exclude_per_dir) {
379 char *p, *pp = xmalloc(baselen+1);
380 memcpy(pp, base, baselen+1);
381 p = pp;
382 while (1) {
383 char save = *p;
384 *p = 0;
385 push_exclude_per_directory(dir, pp, p-pp);
386 *p++ = save;
387 if (!save)
388 break;
389 p = strchr(p, '/');
390 if (p)
391 p++;
392 else
393 p = pp + baselen;
394 }
395 free(pp);
396 }
397 }
398
399 read_directory_recursive(dir, path, base, baselen, 0);
400 qsort(dir->entries, dir->nr, sizeof(struct dir_entry *), cmp_name);
401 return dir->nr;
402 }
403
404 int
405 file_exists(const char *f)
406 {
407 struct stat sb;
408 return stat(f, &sb) == 0;
409 }