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