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