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