Merge branch 'jk/common-main' into maint-2.10
[git] / path.c
1 /*
2  * Utilities for paths and pathnames
3  */
4 #include "cache.h"
5 #include "strbuf.h"
6 #include "string-list.h"
7 #include "dir.h"
8 #include "worktree.h"
9
10 static int get_st_mode_bits(const char *path, int *mode)
11 {
12         struct stat st;
13         if (lstat(path, &st) < 0)
14                 return -1;
15         *mode = st.st_mode;
16         return 0;
17 }
18
19 static char bad_path[] = "/bad-path/";
20
21 static struct strbuf *get_pathname(void)
22 {
23         static struct strbuf pathname_array[4] = {
24                 STRBUF_INIT, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
25         };
26         static int index;
27         struct strbuf *sb = &pathname_array[index];
28         index = (index + 1) % ARRAY_SIZE(pathname_array);
29         strbuf_reset(sb);
30         return sb;
31 }
32
33 static char *cleanup_path(char *path)
34 {
35         /* Clean it up */
36         if (!memcmp(path, "./", 2)) {
37                 path += 2;
38                 while (*path == '/')
39                         path++;
40         }
41         return path;
42 }
43
44 static void strbuf_cleanup_path(struct strbuf *sb)
45 {
46         char *path = cleanup_path(sb->buf);
47         if (path > sb->buf)
48                 strbuf_remove(sb, 0, path - sb->buf);
49 }
50
51 char *mksnpath(char *buf, size_t n, const char *fmt, ...)
52 {
53         va_list args;
54         unsigned len;
55
56         va_start(args, fmt);
57         len = vsnprintf(buf, n, fmt, args);
58         va_end(args);
59         if (len >= n) {
60                 strlcpy(buf, bad_path, n);
61                 return buf;
62         }
63         return cleanup_path(buf);
64 }
65
66 static int dir_prefix(const char *buf, const char *dir)
67 {
68         int len = strlen(dir);
69         return !strncmp(buf, dir, len) &&
70                 (is_dir_sep(buf[len]) || buf[len] == '\0');
71 }
72
73 /* $buf =~ m|$dir/+$file| but without regex */
74 static int is_dir_file(const char *buf, const char *dir, const char *file)
75 {
76         int len = strlen(dir);
77         if (strncmp(buf, dir, len) || !is_dir_sep(buf[len]))
78                 return 0;
79         while (is_dir_sep(buf[len]))
80                 len++;
81         return !strcmp(buf + len, file);
82 }
83
84 static void replace_dir(struct strbuf *buf, int len, const char *newdir)
85 {
86         int newlen = strlen(newdir);
87         int need_sep = (buf->buf[len] && !is_dir_sep(buf->buf[len])) &&
88                 !is_dir_sep(newdir[newlen - 1]);
89         if (need_sep)
90                 len--;   /* keep one char, to be replaced with '/'  */
91         strbuf_splice(buf, 0, len, newdir, newlen);
92         if (need_sep)
93                 buf->buf[newlen] = '/';
94 }
95
96 struct common_dir {
97         /* Not considered garbage for report_linked_checkout_garbage */
98         unsigned ignore_garbage:1;
99         unsigned is_dir:1;
100         /* Not common even though its parent is */
101         unsigned exclude:1;
102         const char *dirname;
103 };
104
105 static struct common_dir common_list[] = {
106         { 0, 1, 0, "branches" },
107         { 0, 1, 0, "hooks" },
108         { 0, 1, 0, "info" },
109         { 0, 0, 1, "info/sparse-checkout" },
110         { 1, 1, 0, "logs" },
111         { 1, 1, 1, "logs/HEAD" },
112         { 0, 1, 1, "logs/refs/bisect" },
113         { 0, 1, 0, "lost-found" },
114         { 0, 1, 0, "objects" },
115         { 0, 1, 0, "refs" },
116         { 0, 1, 1, "refs/bisect" },
117         { 0, 1, 0, "remotes" },
118         { 0, 1, 0, "worktrees" },
119         { 0, 1, 0, "rr-cache" },
120         { 0, 1, 0, "svn" },
121         { 0, 0, 0, "config" },
122         { 1, 0, 0, "gc.pid" },
123         { 0, 0, 0, "packed-refs" },
124         { 0, 0, 0, "shallow" },
125         { 0, 0, 0, NULL }
126 };
127
128 /*
129  * A compressed trie.  A trie node consists of zero or more characters that
130  * are common to all elements with this prefix, optionally followed by some
131  * children.  If value is not NULL, the trie node is a terminal node.
132  *
133  * For example, consider the following set of strings:
134  * abc
135  * def
136  * definite
137  * definition
138  *
139  * The trie would look like:
140  * root: len = 0, children a and d non-NULL, value = NULL.
141  *    a: len = 2, contents = bc, value = (data for "abc")
142  *    d: len = 2, contents = ef, children i non-NULL, value = (data for "def")
143  *       i: len = 3, contents = nit, children e and i non-NULL, value = NULL
144  *           e: len = 0, children all NULL, value = (data for "definite")
145  *           i: len = 2, contents = on, children all NULL,
146  *              value = (data for "definition")
147  */
148 struct trie {
149         struct trie *children[256];
150         int len;
151         char *contents;
152         void *value;
153 };
154
155 static struct trie *make_trie_node(const char *key, void *value)
156 {
157         struct trie *new_node = xcalloc(1, sizeof(*new_node));
158         new_node->len = strlen(key);
159         if (new_node->len) {
160                 new_node->contents = xmalloc(new_node->len);
161                 memcpy(new_node->contents, key, new_node->len);
162         }
163         new_node->value = value;
164         return new_node;
165 }
166
167 /*
168  * Add a key/value pair to a trie.  The key is assumed to be \0-terminated.
169  * If there was an existing value for this key, return it.
170  */
171 static void *add_to_trie(struct trie *root, const char *key, void *value)
172 {
173         struct trie *child;
174         void *old;
175         int i;
176
177         if (!*key) {
178                 /* we have reached the end of the key */
179                 old = root->value;
180                 root->value = value;
181                 return old;
182         }
183
184         for (i = 0; i < root->len; i++) {
185                 if (root->contents[i] == key[i])
186                         continue;
187
188                 /*
189                  * Split this node: child will contain this node's
190                  * existing children.
191                  */
192                 child = malloc(sizeof(*child));
193                 memcpy(child->children, root->children, sizeof(root->children));
194
195                 child->len = root->len - i - 1;
196                 if (child->len) {
197                         child->contents = xstrndup(root->contents + i + 1,
198                                                    child->len);
199                 }
200                 child->value = root->value;
201                 root->value = NULL;
202                 root->len = i;
203
204                 memset(root->children, 0, sizeof(root->children));
205                 root->children[(unsigned char)root->contents[i]] = child;
206
207                 /* This is the newly-added child. */
208                 root->children[(unsigned char)key[i]] =
209                         make_trie_node(key + i + 1, value);
210                 return NULL;
211         }
212
213         /* We have matched the entire compressed section */
214         if (key[i]) {
215                 child = root->children[(unsigned char)key[root->len]];
216                 if (child) {
217                         return add_to_trie(child, key + root->len + 1, value);
218                 } else {
219                         child = make_trie_node(key + root->len + 1, value);
220                         root->children[(unsigned char)key[root->len]] = child;
221                         return NULL;
222                 }
223         }
224
225         old = root->value;
226         root->value = value;
227         return old;
228 }
229
230 typedef int (*match_fn)(const char *unmatched, void *data, void *baton);
231
232 /*
233  * Search a trie for some key.  Find the longest /-or-\0-terminated
234  * prefix of the key for which the trie contains a value.  Call fn
235  * with the unmatched portion of the key and the found value, and
236  * return its return value.  If there is no such prefix, return -1.
237  *
238  * The key is partially normalized: consecutive slashes are skipped.
239  *
240  * For example, consider the trie containing only [refs,
241  * refs/worktree] (both with values).
242  *
243  * | key             | unmatched  | val from node | return value |
244  * |-----------------|------------|---------------|--------------|
245  * | a               | not called | n/a           | -1           |
246  * | refs            | \0         | refs          | as per fn    |
247  * | refs/           | /          | refs          | as per fn    |
248  * | refs/w          | /w         | refs          | as per fn    |
249  * | refs/worktree   | \0         | refs/worktree | as per fn    |
250  * | refs/worktree/  | /          | refs/worktree | as per fn    |
251  * | refs/worktree/a | /a         | refs/worktree | as per fn    |
252  * |-----------------|------------|---------------|--------------|
253  *
254  */
255 static int trie_find(struct trie *root, const char *key, match_fn fn,
256                      void *baton)
257 {
258         int i;
259         int result;
260         struct trie *child;
261
262         if (!*key) {
263                 /* we have reached the end of the key */
264                 if (root->value && !root->len)
265                         return fn(key, root->value, baton);
266                 else
267                         return -1;
268         }
269
270         for (i = 0; i < root->len; i++) {
271                 /* Partial path normalization: skip consecutive slashes. */
272                 if (key[i] == '/' && key[i+1] == '/') {
273                         key++;
274                         continue;
275                 }
276                 if (root->contents[i] != key[i])
277                         return -1;
278         }
279
280         /* Matched the entire compressed section */
281         key += i;
282         if (!*key)
283                 /* End of key */
284                 return fn(key, root->value, baton);
285
286         /* Partial path normalization: skip consecutive slashes */
287         while (key[0] == '/' && key[1] == '/')
288                 key++;
289
290         child = root->children[(unsigned char)*key];
291         if (child)
292                 result = trie_find(child, key + 1, fn, baton);
293         else
294                 result = -1;
295
296         if (result >= 0 || (*key != '/' && *key != 0))
297                 return result;
298         if (root->value)
299                 return fn(key, root->value, baton);
300         else
301                 return -1;
302 }
303
304 static struct trie common_trie;
305 static int common_trie_done_setup;
306
307 static void init_common_trie(void)
308 {
309         struct common_dir *p;
310
311         if (common_trie_done_setup)
312                 return;
313
314         for (p = common_list; p->dirname; p++)
315                 add_to_trie(&common_trie, p->dirname, p);
316
317         common_trie_done_setup = 1;
318 }
319
320 /*
321  * Helper function for update_common_dir: returns 1 if the dir
322  * prefix is common.
323  */
324 static int check_common(const char *unmatched, void *value, void *baton)
325 {
326         struct common_dir *dir = value;
327
328         if (!dir)
329                 return 0;
330
331         if (dir->is_dir && (unmatched[0] == 0 || unmatched[0] == '/'))
332                 return !dir->exclude;
333
334         if (!dir->is_dir && unmatched[0] == 0)
335                 return !dir->exclude;
336
337         return 0;
338 }
339
340 static void update_common_dir(struct strbuf *buf, int git_dir_len,
341                               const char *common_dir)
342 {
343         char *base = buf->buf + git_dir_len;
344         init_common_trie();
345         if (!common_dir)
346                 common_dir = get_git_common_dir();
347         if (trie_find(&common_trie, base, check_common, NULL) > 0)
348                 replace_dir(buf, git_dir_len, common_dir);
349 }
350
351 void report_linked_checkout_garbage(void)
352 {
353         struct strbuf sb = STRBUF_INIT;
354         const struct common_dir *p;
355         int len;
356
357         if (!git_common_dir_env)
358                 return;
359         strbuf_addf(&sb, "%s/", get_git_dir());
360         len = sb.len;
361         for (p = common_list; p->dirname; p++) {
362                 const char *path = p->dirname;
363                 if (p->ignore_garbage)
364                         continue;
365                 strbuf_setlen(&sb, len);
366                 strbuf_addstr(&sb, path);
367                 if (file_exists(sb.buf))
368                         report_garbage(PACKDIR_FILE_GARBAGE, sb.buf);
369         }
370         strbuf_release(&sb);
371 }
372
373 static void adjust_git_path(struct strbuf *buf, int git_dir_len)
374 {
375         const char *base = buf->buf + git_dir_len;
376         if (git_graft_env && is_dir_file(base, "info", "grafts"))
377                 strbuf_splice(buf, 0, buf->len,
378                               get_graft_file(), strlen(get_graft_file()));
379         else if (git_index_env && !strcmp(base, "index"))
380                 strbuf_splice(buf, 0, buf->len,
381                               get_index_file(), strlen(get_index_file()));
382         else if (git_db_env && dir_prefix(base, "objects"))
383                 replace_dir(buf, git_dir_len + 7, get_object_directory());
384         else if (git_hooks_path && dir_prefix(base, "hooks"))
385                 replace_dir(buf, git_dir_len + 5, git_hooks_path);
386         else if (git_common_dir_env)
387                 update_common_dir(buf, git_dir_len, NULL);
388 }
389
390 static void do_git_path(const struct worktree *wt, struct strbuf *buf,
391                         const char *fmt, va_list args)
392 {
393         int gitdir_len;
394         strbuf_addstr(buf, get_worktree_git_dir(wt));
395         if (buf->len && !is_dir_sep(buf->buf[buf->len - 1]))
396                 strbuf_addch(buf, '/');
397         gitdir_len = buf->len;
398         strbuf_vaddf(buf, fmt, args);
399         adjust_git_path(buf, gitdir_len);
400         strbuf_cleanup_path(buf);
401 }
402
403 char *git_path_buf(struct strbuf *buf, const char *fmt, ...)
404 {
405         va_list args;
406         strbuf_reset(buf);
407         va_start(args, fmt);
408         do_git_path(NULL, buf, fmt, args);
409         va_end(args);
410         return buf->buf;
411 }
412
413 void strbuf_git_path(struct strbuf *sb, const char *fmt, ...)
414 {
415         va_list args;
416         va_start(args, fmt);
417         do_git_path(NULL, sb, fmt, args);
418         va_end(args);
419 }
420
421 const char *git_path(const char *fmt, ...)
422 {
423         struct strbuf *pathname = get_pathname();
424         va_list args;
425         va_start(args, fmt);
426         do_git_path(NULL, pathname, fmt, args);
427         va_end(args);
428         return pathname->buf;
429 }
430
431 char *git_pathdup(const char *fmt, ...)
432 {
433         struct strbuf path = STRBUF_INIT;
434         va_list args;
435         va_start(args, fmt);
436         do_git_path(NULL, &path, fmt, args);
437         va_end(args);
438         return strbuf_detach(&path, NULL);
439 }
440
441 char *mkpathdup(const char *fmt, ...)
442 {
443         struct strbuf sb = STRBUF_INIT;
444         va_list args;
445         va_start(args, fmt);
446         strbuf_vaddf(&sb, fmt, args);
447         va_end(args);
448         strbuf_cleanup_path(&sb);
449         return strbuf_detach(&sb, NULL);
450 }
451
452 const char *mkpath(const char *fmt, ...)
453 {
454         va_list args;
455         struct strbuf *pathname = get_pathname();
456         va_start(args, fmt);
457         strbuf_vaddf(pathname, fmt, args);
458         va_end(args);
459         return cleanup_path(pathname->buf);
460 }
461
462 const char *worktree_git_path(const struct worktree *wt, const char *fmt, ...)
463 {
464         struct strbuf *pathname = get_pathname();
465         va_list args;
466         va_start(args, fmt);
467         do_git_path(wt, pathname, fmt, args);
468         va_end(args);
469         return pathname->buf;
470 }
471
472 static void do_submodule_path(struct strbuf *buf, const char *path,
473                               const char *fmt, va_list args)
474 {
475         const char *git_dir;
476         struct strbuf git_submodule_common_dir = STRBUF_INIT;
477         struct strbuf git_submodule_dir = STRBUF_INIT;
478
479         strbuf_addstr(buf, path);
480         strbuf_complete(buf, '/');
481         strbuf_addstr(buf, ".git");
482
483         git_dir = read_gitfile(buf->buf);
484         if (git_dir) {
485                 strbuf_reset(buf);
486                 strbuf_addstr(buf, git_dir);
487         }
488         strbuf_addch(buf, '/');
489         strbuf_addbuf(&git_submodule_dir, buf);
490
491         strbuf_vaddf(buf, fmt, args);
492
493         if (get_common_dir_noenv(&git_submodule_common_dir, git_submodule_dir.buf))
494                 update_common_dir(buf, git_submodule_dir.len, git_submodule_common_dir.buf);
495
496         strbuf_cleanup_path(buf);
497
498         strbuf_release(&git_submodule_dir);
499         strbuf_release(&git_submodule_common_dir);
500 }
501
502 char *git_pathdup_submodule(const char *path, const char *fmt, ...)
503 {
504         va_list args;
505         struct strbuf buf = STRBUF_INIT;
506         va_start(args, fmt);
507         do_submodule_path(&buf, path, fmt, args);
508         va_end(args);
509         return strbuf_detach(&buf, NULL);
510 }
511
512 void strbuf_git_path_submodule(struct strbuf *buf, const char *path,
513                                const char *fmt, ...)
514 {
515         va_list args;
516         va_start(args, fmt);
517         do_submodule_path(buf, path, fmt, args);
518         va_end(args);
519 }
520
521 static void do_git_common_path(struct strbuf *buf,
522                                const char *fmt,
523                                va_list args)
524 {
525         strbuf_addstr(buf, get_git_common_dir());
526         if (buf->len && !is_dir_sep(buf->buf[buf->len - 1]))
527                 strbuf_addch(buf, '/');
528         strbuf_vaddf(buf, fmt, args);
529         strbuf_cleanup_path(buf);
530 }
531
532 const char *git_common_path(const char *fmt, ...)
533 {
534         struct strbuf *pathname = get_pathname();
535         va_list args;
536         va_start(args, fmt);
537         do_git_common_path(pathname, fmt, args);
538         va_end(args);
539         return pathname->buf;
540 }
541
542 void strbuf_git_common_path(struct strbuf *sb, const char *fmt, ...)
543 {
544         va_list args;
545         va_start(args, fmt);
546         do_git_common_path(sb, fmt, args);
547         va_end(args);
548 }
549
550 int validate_headref(const char *path)
551 {
552         struct stat st;
553         char *buf, buffer[256];
554         unsigned char sha1[20];
555         int fd;
556         ssize_t len;
557
558         if (lstat(path, &st) < 0)
559                 return -1;
560
561         /* Make sure it is a "refs/.." symlink */
562         if (S_ISLNK(st.st_mode)) {
563                 len = readlink(path, buffer, sizeof(buffer)-1);
564                 if (len >= 5 && !memcmp("refs/", buffer, 5))
565                         return 0;
566                 return -1;
567         }
568
569         /*
570          * Anything else, just open it and try to see if it is a symbolic ref.
571          */
572         fd = open(path, O_RDONLY);
573         if (fd < 0)
574                 return -1;
575         len = read_in_full(fd, buffer, sizeof(buffer)-1);
576         close(fd);
577
578         /*
579          * Is it a symbolic ref?
580          */
581         if (len < 4)
582                 return -1;
583         if (!memcmp("ref:", buffer, 4)) {
584                 buf = buffer + 4;
585                 len -= 4;
586                 while (len && isspace(*buf))
587                         buf++, len--;
588                 if (len >= 5 && !memcmp("refs/", buf, 5))
589                         return 0;
590         }
591
592         /*
593          * Is this a detached HEAD?
594          */
595         if (!get_sha1_hex(buffer, sha1))
596                 return 0;
597
598         return -1;
599 }
600
601 static struct passwd *getpw_str(const char *username, size_t len)
602 {
603         struct passwd *pw;
604         char *username_z = xmemdupz(username, len);
605         pw = getpwnam(username_z);
606         free(username_z);
607         return pw;
608 }
609
610 /*
611  * Return a string with ~ and ~user expanded via getpw*.  If buf != NULL,
612  * then it is a newly allocated string. Returns NULL on getpw failure or
613  * if path is NULL.
614  */
615 char *expand_user_path(const char *path)
616 {
617         struct strbuf user_path = STRBUF_INIT;
618         const char *to_copy = path;
619
620         if (path == NULL)
621                 goto return_null;
622         if (path[0] == '~') {
623                 const char *first_slash = strchrnul(path, '/');
624                 const char *username = path + 1;
625                 size_t username_len = first_slash - username;
626                 if (username_len == 0) {
627                         const char *home = getenv("HOME");
628                         if (!home)
629                                 goto return_null;
630                         strbuf_addstr(&user_path, home);
631 #ifdef GIT_WINDOWS_NATIVE
632                         convert_slashes(user_path.buf);
633 #endif
634                 } else {
635                         struct passwd *pw = getpw_str(username, username_len);
636                         if (!pw)
637                                 goto return_null;
638                         strbuf_addstr(&user_path, pw->pw_dir);
639                 }
640                 to_copy = first_slash;
641         }
642         strbuf_addstr(&user_path, to_copy);
643         return strbuf_detach(&user_path, NULL);
644 return_null:
645         strbuf_release(&user_path);
646         return NULL;
647 }
648
649 /*
650  * First, one directory to try is determined by the following algorithm.
651  *
652  * (0) If "strict" is given, the path is used as given and no DWIM is
653  *     done. Otherwise:
654  * (1) "~/path" to mean path under the running user's home directory;
655  * (2) "~user/path" to mean path under named user's home directory;
656  * (3) "relative/path" to mean cwd relative directory; or
657  * (4) "/absolute/path" to mean absolute directory.
658  *
659  * Unless "strict" is given, we check "%s/.git", "%s", "%s.git/.git", "%s.git"
660  * in this order. We select the first one that is a valid git repository, and
661  * chdir() to it. If none match, or we fail to chdir, we return NULL.
662  *
663  * If all goes well, we return the directory we used to chdir() (but
664  * before ~user is expanded), avoiding getcwd() resolving symbolic
665  * links.  User relative paths are also returned as they are given,
666  * except DWIM suffixing.
667  */
668 const char *enter_repo(const char *path, int strict)
669 {
670         static struct strbuf validated_path = STRBUF_INIT;
671         static struct strbuf used_path = STRBUF_INIT;
672
673         if (!path)
674                 return NULL;
675
676         if (!strict) {
677                 static const char *suffix[] = {
678                         "/.git", "", ".git/.git", ".git", NULL,
679                 };
680                 const char *gitfile;
681                 int len = strlen(path);
682                 int i;
683                 while ((1 < len) && (path[len-1] == '/'))
684                         len--;
685
686                 /*
687                  * We can handle arbitrary-sized buffers, but this remains as a
688                  * sanity check on untrusted input.
689                  */
690                 if (PATH_MAX <= len)
691                         return NULL;
692
693                 strbuf_reset(&used_path);
694                 strbuf_reset(&validated_path);
695                 strbuf_add(&used_path, path, len);
696                 strbuf_add(&validated_path, path, len);
697
698                 if (used_path.buf[0] == '~') {
699                         char *newpath = expand_user_path(used_path.buf);
700                         if (!newpath)
701                                 return NULL;
702                         strbuf_attach(&used_path, newpath, strlen(newpath),
703                                       strlen(newpath));
704                 }
705                 for (i = 0; suffix[i]; i++) {
706                         struct stat st;
707                         size_t baselen = used_path.len;
708                         strbuf_addstr(&used_path, suffix[i]);
709                         if (!stat(used_path.buf, &st) &&
710                             (S_ISREG(st.st_mode) ||
711                             (S_ISDIR(st.st_mode) && is_git_directory(used_path.buf)))) {
712                                 strbuf_addstr(&validated_path, suffix[i]);
713                                 break;
714                         }
715                         strbuf_setlen(&used_path, baselen);
716                 }
717                 if (!suffix[i])
718                         return NULL;
719                 gitfile = read_gitfile(used_path.buf);
720                 if (gitfile) {
721                         strbuf_reset(&used_path);
722                         strbuf_addstr(&used_path, gitfile);
723                 }
724                 if (chdir(used_path.buf))
725                         return NULL;
726                 path = validated_path.buf;
727         }
728         else {
729                 const char *gitfile = read_gitfile(path);
730                 if (gitfile)
731                         path = gitfile;
732                 if (chdir(path))
733                         return NULL;
734         }
735
736         if (is_git_directory(".")) {
737                 set_git_dir(".");
738                 check_repository_format();
739                 return path;
740         }
741
742         return NULL;
743 }
744
745 static int calc_shared_perm(int mode)
746 {
747         int tweak;
748
749         if (get_shared_repository() < 0)
750                 tweak = -get_shared_repository();
751         else
752                 tweak = get_shared_repository();
753
754         if (!(mode & S_IWUSR))
755                 tweak &= ~0222;
756         if (mode & S_IXUSR)
757                 /* Copy read bits to execute bits */
758                 tweak |= (tweak & 0444) >> 2;
759         if (get_shared_repository() < 0)
760                 mode = (mode & ~0777) | tweak;
761         else
762                 mode |= tweak;
763
764         return mode;
765 }
766
767
768 int adjust_shared_perm(const char *path)
769 {
770         int old_mode, new_mode;
771
772         if (!get_shared_repository())
773                 return 0;
774         if (get_st_mode_bits(path, &old_mode) < 0)
775                 return -1;
776
777         new_mode = calc_shared_perm(old_mode);
778         if (S_ISDIR(old_mode)) {
779                 /* Copy read bits to execute bits */
780                 new_mode |= (new_mode & 0444) >> 2;
781                 new_mode |= FORCE_DIR_SET_GID;
782         }
783
784         if (((old_mode ^ new_mode) & ~S_IFMT) &&
785                         chmod(path, (new_mode & ~S_IFMT)) < 0)
786                 return -2;
787         return 0;
788 }
789
790 void safe_create_dir(const char *dir, int share)
791 {
792         if (mkdir(dir, 0777) < 0) {
793                 if (errno != EEXIST) {
794                         perror(dir);
795                         exit(1);
796                 }
797         }
798         else if (share && adjust_shared_perm(dir))
799                 die(_("Could not make %s writable by group"), dir);
800 }
801
802 static int have_same_root(const char *path1, const char *path2)
803 {
804         int is_abs1, is_abs2;
805
806         is_abs1 = is_absolute_path(path1);
807         is_abs2 = is_absolute_path(path2);
808         return (is_abs1 && is_abs2 && tolower(path1[0]) == tolower(path2[0])) ||
809                (!is_abs1 && !is_abs2);
810 }
811
812 /*
813  * Give path as relative to prefix.
814  *
815  * The strbuf may or may not be used, so do not assume it contains the
816  * returned path.
817  */
818 const char *relative_path(const char *in, const char *prefix,
819                           struct strbuf *sb)
820 {
821         int in_len = in ? strlen(in) : 0;
822         int prefix_len = prefix ? strlen(prefix) : 0;
823         int in_off = 0;
824         int prefix_off = 0;
825         int i = 0, j = 0;
826
827         if (!in_len)
828                 return "./";
829         else if (!prefix_len)
830                 return in;
831
832         if (have_same_root(in, prefix))
833                 /* bypass dos_drive, for "c:" is identical to "C:" */
834                 i = j = has_dos_drive_prefix(in);
835         else {
836                 return in;
837         }
838
839         while (i < prefix_len && j < in_len && prefix[i] == in[j]) {
840                 if (is_dir_sep(prefix[i])) {
841                         while (is_dir_sep(prefix[i]))
842                                 i++;
843                         while (is_dir_sep(in[j]))
844                                 j++;
845                         prefix_off = i;
846                         in_off = j;
847                 } else {
848                         i++;
849                         j++;
850                 }
851         }
852
853         if (
854             /* "prefix" seems like prefix of "in" */
855             i >= prefix_len &&
856             /*
857              * but "/foo" is not a prefix of "/foobar"
858              * (i.e. prefix not end with '/')
859              */
860             prefix_off < prefix_len) {
861                 if (j >= in_len) {
862                         /* in="/a/b", prefix="/a/b" */
863                         in_off = in_len;
864                 } else if (is_dir_sep(in[j])) {
865                         /* in="/a/b/c", prefix="/a/b" */
866                         while (is_dir_sep(in[j]))
867                                 j++;
868                         in_off = j;
869                 } else {
870                         /* in="/a/bbb/c", prefix="/a/b" */
871                         i = prefix_off;
872                 }
873         } else if (
874                    /* "in" is short than "prefix" */
875                    j >= in_len &&
876                    /* "in" not end with '/' */
877                    in_off < in_len) {
878                 if (is_dir_sep(prefix[i])) {
879                         /* in="/a/b", prefix="/a/b/c/" */
880                         while (is_dir_sep(prefix[i]))
881                                 i++;
882                         in_off = in_len;
883                 }
884         }
885         in += in_off;
886         in_len -= in_off;
887
888         if (i >= prefix_len) {
889                 if (!in_len)
890                         return "./";
891                 else
892                         return in;
893         }
894
895         strbuf_reset(sb);
896         strbuf_grow(sb, in_len);
897
898         while (i < prefix_len) {
899                 if (is_dir_sep(prefix[i])) {
900                         strbuf_addstr(sb, "../");
901                         while (is_dir_sep(prefix[i]))
902                                 i++;
903                         continue;
904                 }
905                 i++;
906         }
907         if (!is_dir_sep(prefix[prefix_len - 1]))
908                 strbuf_addstr(sb, "../");
909
910         strbuf_addstr(sb, in);
911
912         return sb->buf;
913 }
914
915 /*
916  * A simpler implementation of relative_path
917  *
918  * Get relative path by removing "prefix" from "in". This function
919  * first appears in v1.5.6-1-g044bbbc, and makes git_dir shorter
920  * to increase performance when traversing the path to work_tree.
921  */
922 const char *remove_leading_path(const char *in, const char *prefix)
923 {
924         static struct strbuf buf = STRBUF_INIT;
925         int i = 0, j = 0;
926
927         if (!prefix || !prefix[0])
928                 return in;
929         while (prefix[i]) {
930                 if (is_dir_sep(prefix[i])) {
931                         if (!is_dir_sep(in[j]))
932                                 return in;
933                         while (is_dir_sep(prefix[i]))
934                                 i++;
935                         while (is_dir_sep(in[j]))
936                                 j++;
937                         continue;
938                 } else if (in[j] != prefix[i]) {
939                         return in;
940                 }
941                 i++;
942                 j++;
943         }
944         if (
945             /* "/foo" is a prefix of "/foo" */
946             in[j] &&
947             /* "/foo" is not a prefix of "/foobar" */
948             !is_dir_sep(prefix[i-1]) && !is_dir_sep(in[j])
949            )
950                 return in;
951         while (is_dir_sep(in[j]))
952                 j++;
953
954         strbuf_reset(&buf);
955         if (!in[j])
956                 strbuf_addstr(&buf, ".");
957         else
958                 strbuf_addstr(&buf, in + j);
959         return buf.buf;
960 }
961
962 /*
963  * It is okay if dst == src, but they should not overlap otherwise.
964  *
965  * Performs the following normalizations on src, storing the result in dst:
966  * - Ensures that components are separated by '/' (Windows only)
967  * - Squashes sequences of '/'.
968  * - Removes "." components.
969  * - Removes ".." components, and the components the precede them.
970  * Returns failure (non-zero) if a ".." component appears as first path
971  * component anytime during the normalization. Otherwise, returns success (0).
972  *
973  * Note that this function is purely textual.  It does not follow symlinks,
974  * verify the existence of the path, or make any system calls.
975  *
976  * prefix_len != NULL is for a specific case of prefix_pathspec():
977  * assume that src == dst and src[0..prefix_len-1] is already
978  * normalized, any time "../" eats up to the prefix_len part,
979  * prefix_len is reduced. In the end prefix_len is the remaining
980  * prefix that has not been overridden by user pathspec.
981  *
982  * NEEDSWORK: This function doesn't perform normalization w.r.t. trailing '/'.
983  * For everything but the root folder itself, the normalized path should not
984  * end with a '/', then the callers need to be fixed up accordingly.
985  *
986  */
987 int normalize_path_copy_len(char *dst, const char *src, int *prefix_len)
988 {
989         char *dst0;
990         int i;
991
992         for (i = has_dos_drive_prefix(src); i > 0; i--)
993                 *dst++ = *src++;
994         dst0 = dst;
995
996         if (is_dir_sep(*src)) {
997                 *dst++ = '/';
998                 while (is_dir_sep(*src))
999                         src++;
1000         }
1001
1002         for (;;) {
1003                 char c = *src;
1004
1005                 /*
1006                  * A path component that begins with . could be
1007                  * special:
1008                  * (1) "." and ends   -- ignore and terminate.
1009                  * (2) "./"           -- ignore them, eat slash and continue.
1010                  * (3) ".." and ends  -- strip one and terminate.
1011                  * (4) "../"          -- strip one, eat slash and continue.
1012                  */
1013                 if (c == '.') {
1014                         if (!src[1]) {
1015                                 /* (1) */
1016                                 src++;
1017                         } else if (is_dir_sep(src[1])) {
1018                                 /* (2) */
1019                                 src += 2;
1020                                 while (is_dir_sep(*src))
1021                                         src++;
1022                                 continue;
1023                         } else if (src[1] == '.') {
1024                                 if (!src[2]) {
1025                                         /* (3) */
1026                                         src += 2;
1027                                         goto up_one;
1028                                 } else if (is_dir_sep(src[2])) {
1029                                         /* (4) */
1030                                         src += 3;
1031                                         while (is_dir_sep(*src))
1032                                                 src++;
1033                                         goto up_one;
1034                                 }
1035                         }
1036                 }
1037
1038                 /* copy up to the next '/', and eat all '/' */
1039                 while ((c = *src++) != '\0' && !is_dir_sep(c))
1040                         *dst++ = c;
1041                 if (is_dir_sep(c)) {
1042                         *dst++ = '/';
1043                         while (is_dir_sep(c))
1044                                 c = *src++;
1045                         src--;
1046                 } else if (!c)
1047                         break;
1048                 continue;
1049
1050         up_one:
1051                 /*
1052                  * dst0..dst is prefix portion, and dst[-1] is '/';
1053                  * go up one level.
1054                  */
1055                 dst--;  /* go to trailing '/' */
1056                 if (dst <= dst0)
1057                         return -1;
1058                 /* Windows: dst[-1] cannot be backslash anymore */
1059                 while (dst0 < dst && dst[-1] != '/')
1060                         dst--;
1061                 if (prefix_len && *prefix_len > dst - dst0)
1062                         *prefix_len = dst - dst0;
1063         }
1064         *dst = '\0';
1065         return 0;
1066 }
1067
1068 int normalize_path_copy(char *dst, const char *src)
1069 {
1070         return normalize_path_copy_len(dst, src, NULL);
1071 }
1072
1073 /*
1074  * path = Canonical absolute path
1075  * prefixes = string_list containing normalized, absolute paths without
1076  * trailing slashes (except for the root directory, which is denoted by "/").
1077  *
1078  * Determines, for each path in prefixes, whether the "prefix"
1079  * is an ancestor directory of path.  Returns the length of the longest
1080  * ancestor directory, excluding any trailing slashes, or -1 if no prefix
1081  * is an ancestor.  (Note that this means 0 is returned if prefixes is
1082  * ["/"].) "/foo" is not considered an ancestor of "/foobar".  Directories
1083  * are not considered to be their own ancestors.  path must be in a
1084  * canonical form: empty components, or "." or ".." components are not
1085  * allowed.
1086  */
1087 int longest_ancestor_length(const char *path, struct string_list *prefixes)
1088 {
1089         int i, max_len = -1;
1090
1091         if (!strcmp(path, "/"))
1092                 return -1;
1093
1094         for (i = 0; i < prefixes->nr; i++) {
1095                 const char *ceil = prefixes->items[i].string;
1096                 int len = strlen(ceil);
1097
1098                 if (len == 1 && ceil[0] == '/')
1099                         len = 0; /* root matches anything, with length 0 */
1100                 else if (!strncmp(path, ceil, len) && path[len] == '/')
1101                         ; /* match of length len */
1102                 else
1103                         continue; /* no match */
1104
1105                 if (len > max_len)
1106                         max_len = len;
1107         }
1108
1109         return max_len;
1110 }
1111
1112 /* strip arbitrary amount of directory separators at end of path */
1113 static inline int chomp_trailing_dir_sep(const char *path, int len)
1114 {
1115         while (len && is_dir_sep(path[len - 1]))
1116                 len--;
1117         return len;
1118 }
1119
1120 /*
1121  * If path ends with suffix (complete path components), returns the
1122  * part before suffix (sans trailing directory separators).
1123  * Otherwise returns NULL.
1124  */
1125 char *strip_path_suffix(const char *path, const char *suffix)
1126 {
1127         int path_len = strlen(path), suffix_len = strlen(suffix);
1128
1129         while (suffix_len) {
1130                 if (!path_len)
1131                         return NULL;
1132
1133                 if (is_dir_sep(path[path_len - 1])) {
1134                         if (!is_dir_sep(suffix[suffix_len - 1]))
1135                                 return NULL;
1136                         path_len = chomp_trailing_dir_sep(path, path_len);
1137                         suffix_len = chomp_trailing_dir_sep(suffix, suffix_len);
1138                 }
1139                 else if (path[--path_len] != suffix[--suffix_len])
1140                         return NULL;
1141         }
1142
1143         if (path_len && !is_dir_sep(path[path_len - 1]))
1144                 return NULL;
1145         return xstrndup(path, chomp_trailing_dir_sep(path, path_len));
1146 }
1147
1148 int daemon_avoid_alias(const char *p)
1149 {
1150         int sl, ndot;
1151
1152         /*
1153          * This resurrects the belts and suspenders paranoia check by HPA
1154          * done in <435560F7.4080006@zytor.com> thread, now enter_repo()
1155          * does not do getcwd() based path canonicalization.
1156          *
1157          * sl becomes true immediately after seeing '/' and continues to
1158          * be true as long as dots continue after that without intervening
1159          * non-dot character.
1160          */
1161         if (!p || (*p != '/' && *p != '~'))
1162                 return -1;
1163         sl = 1; ndot = 0;
1164         p++;
1165
1166         while (1) {
1167                 char ch = *p++;
1168                 if (sl) {
1169                         if (ch == '.')
1170                                 ndot++;
1171                         else if (ch == '/') {
1172                                 if (ndot < 3)
1173                                         /* reject //, /./ and /../ */
1174                                         return -1;
1175                                 ndot = 0;
1176                         }
1177                         else if (ch == 0) {
1178                                 if (0 < ndot && ndot < 3)
1179                                         /* reject /.$ and /..$ */
1180                                         return -1;
1181                                 return 0;
1182                         }
1183                         else
1184                                 sl = ndot = 0;
1185                 }
1186                 else if (ch == 0)
1187                         return 0;
1188                 else if (ch == '/') {
1189                         sl = 1;
1190                         ndot = 0;
1191                 }
1192         }
1193 }
1194
1195 static int only_spaces_and_periods(const char *path, size_t len, size_t skip)
1196 {
1197         if (len < skip)
1198                 return 0;
1199         len -= skip;
1200         path += skip;
1201         while (len-- > 0) {
1202                 char c = *(path++);
1203                 if (c != ' ' && c != '.')
1204                         return 0;
1205         }
1206         return 1;
1207 }
1208
1209 int is_ntfs_dotgit(const char *name)
1210 {
1211         int len;
1212
1213         for (len = 0; ; len++)
1214                 if (!name[len] || name[len] == '\\' || is_dir_sep(name[len])) {
1215                         if (only_spaces_and_periods(name, len, 4) &&
1216                                         !strncasecmp(name, ".git", 4))
1217                                 return 1;
1218                         if (only_spaces_and_periods(name, len, 5) &&
1219                                         !strncasecmp(name, "git~1", 5))
1220                                 return 1;
1221                         if (name[len] != '\\')
1222                                 return 0;
1223                         name += len + 1;
1224                         len = -1;
1225                 }
1226 }
1227
1228 char *xdg_config_home(const char *filename)
1229 {
1230         const char *home, *config_home;
1231
1232         assert(filename);
1233         config_home = getenv("XDG_CONFIG_HOME");
1234         if (config_home && *config_home)
1235                 return mkpathdup("%s/git/%s", config_home, filename);
1236
1237         home = getenv("HOME");
1238         if (home)
1239                 return mkpathdup("%s/.config/git/%s", home, filename);
1240         return NULL;
1241 }
1242
1243 GIT_PATH_FUNC(git_path_cherry_pick_head, "CHERRY_PICK_HEAD")
1244 GIT_PATH_FUNC(git_path_revert_head, "REVERT_HEAD")
1245 GIT_PATH_FUNC(git_path_squash_msg, "SQUASH_MSG")
1246 GIT_PATH_FUNC(git_path_merge_msg, "MERGE_MSG")
1247 GIT_PATH_FUNC(git_path_merge_rr, "MERGE_RR")
1248 GIT_PATH_FUNC(git_path_merge_mode, "MERGE_MODE")
1249 GIT_PATH_FUNC(git_path_merge_head, "MERGE_HEAD")
1250 GIT_PATH_FUNC(git_path_fetch_head, "FETCH_HEAD")
1251 GIT_PATH_FUNC(git_path_shallow, "shallow")