2 * I'm tired of doing "vsnprintf()" etc just to open a
3 * file, so here's a "return static buffer with printf"
6 * It's obviously not thread-safe. Sue me. But it's quite
7 * useful for doing things like
9 * f = open(mkpath("%s/%s.git", base, name), O_RDONLY);
11 * which is what it's designed for.
15 static char bad_path
[] = "/bad-path/";
17 static char *get_pathname(void)
19 static char pathname_array
[4][PATH_MAX
];
21 return pathname_array
[3 & ++index
];
24 static char *cleanup_path(char *path
)
27 if (!memcmp(path
, "./", 2)) {
35 char *mksnpath(char *buf
, size_t n
, const char *fmt
, ...)
41 len
= vsnprintf(buf
, n
, fmt
, args
);
44 snprintf(buf
, n
, bad_path
);
47 return cleanup_path(buf
);
50 char *git_snpath(char *buf
, size_t n
, const char *fmt
, ...)
52 const char *git_dir
= get_git_dir();
56 len
= strlen(git_dir
);
59 memcpy(buf
, git_dir
, len
);
60 if (len
&& !is_dir_sep(git_dir
[len
-1]))
63 len
+= vsnprintf(buf
+ len
, n
- len
, fmt
, args
);
67 return cleanup_path(buf
);
69 snprintf(buf
, n
, bad_path
);
73 char *mkpath(const char *fmt
, ...)
77 char *pathname
= get_pathname();
80 len
= vsnprintf(pathname
, PATH_MAX
, fmt
, args
);
84 return cleanup_path(pathname
);
87 char *git_path(const char *fmt
, ...)
89 const char *git_dir
= get_git_dir();
90 char *pathname
= get_pathname();
94 len
= strlen(git_dir
);
95 if (len
> PATH_MAX
-100)
97 memcpy(pathname
, git_dir
, len
);
98 if (len
&& git_dir
[len
-1] != '/')
99 pathname
[len
++] = '/';
101 len
+= vsnprintf(pathname
+ len
, PATH_MAX
- len
, fmt
, args
);
105 return cleanup_path(pathname
);
109 /* git_mkstemp() - create tmp file honoring TMPDIR variable */
110 int git_mkstemp(char *path
, size_t len
, const char *template)
115 tmp
= getenv("TMPDIR");
118 n
= snprintf(path
, len
, "%s/%s", tmp
, template);
120 errno
= ENAMETOOLONG
;
123 return mkstemp(path
);
127 int validate_headref(const char *path
)
130 char *buf
, buffer
[256];
131 unsigned char sha1
[20];
135 if (lstat(path
, &st
) < 0)
138 /* Make sure it is a "refs/.." symlink */
139 if (S_ISLNK(st
.st_mode
)) {
140 len
= readlink(path
, buffer
, sizeof(buffer
)-1);
141 if (len
>= 5 && !memcmp("refs/", buffer
, 5))
147 * Anything else, just open it and try to see if it is a symbolic ref.
149 fd
= open(path
, O_RDONLY
);
152 len
= read_in_full(fd
, buffer
, sizeof(buffer
)-1);
156 * Is it a symbolic ref?
160 if (!memcmp("ref:", buffer
, 4)) {
163 while (len
&& isspace(*buf
))
165 if (len
>= 5 && !memcmp("refs/", buf
, 5))
170 * Is this a detached HEAD?
172 if (!get_sha1_hex(buffer
, sha1
))
178 static char *user_path(char *buf
, char *path
, int sz
)
184 if (!path
|| path
[0] != '~')
187 slash
= strchr(path
, '/');
188 if (path
[0] == '/' || !path
[0]) {
189 pw
= getpwuid(getuid());
200 if (!pw
|| !pw
->pw_dir
|| sz
<= strlen(pw
->pw_dir
))
202 baselen
= strlen(pw
->pw_dir
);
203 memcpy(buf
, pw
->pw_dir
, baselen
);
204 while ((1 < baselen
) && (buf
[baselen
-1] == '/')) {
208 if (slash
&& slash
[1]) {
210 if (sz
<= baselen
+ len
)
212 memcpy(buf
+ baselen
, slash
, len
+ 1);
218 * First, one directory to try is determined by the following algorithm.
220 * (0) If "strict" is given, the path is used as given and no DWIM is
222 * (1) "~/path" to mean path under the running user's home directory;
223 * (2) "~user/path" to mean path under named user's home directory;
224 * (3) "relative/path" to mean cwd relative directory; or
225 * (4) "/absolute/path" to mean absolute directory.
227 * Unless "strict" is given, we try access() for existence of "%s.git/.git",
228 * "%s/.git", "%s.git", "%s" in this order. The first one that exists is
231 * Second, we try chdir() to that. Upon failure, we return NULL.
233 * Then, we try if the current directory is a valid git repository.
234 * Upon failure, we return NULL.
236 * If all goes well, we return the directory we used to chdir() (but
237 * before ~user is expanded), avoiding getcwd() resolving symbolic
238 * links. User relative paths are also returned as they are given,
239 * except DWIM suffixing.
241 char *enter_repo(char *path
, int strict
)
243 static char used_path
[PATH_MAX
];
244 static char validated_path
[PATH_MAX
];
250 static const char *suffix
[] = {
251 ".git/.git", "/.git", ".git", "", NULL
,
253 int len
= strlen(path
);
255 while ((1 < len
) && (path
[len
-1] == '/')) {
261 if (path
[0] == '~') {
262 if (!user_path(used_path
, path
, PATH_MAX
))
264 strcpy(validated_path
, path
);
267 else if (PATH_MAX
- 10 < len
)
270 path
= strcpy(used_path
, path
);
271 strcpy(validated_path
, path
);
274 for (i
= 0; suffix
[i
]; i
++) {
275 strcpy(path
+ len
, suffix
[i
]);
276 if (!access(path
, F_OK
)) {
277 strcat(validated_path
, suffix
[i
]);
281 if (!suffix
[i
] || chdir(path
))
283 path
= validated_path
;
285 else if (chdir(path
))
288 if (access("objects", X_OK
) == 0 && access("refs", X_OK
) == 0 &&
289 validate_headref("HEAD") == 0) {
290 setenv(GIT_DIR_ENVIRONMENT
, ".", 1);
291 check_repository_format();
298 int adjust_shared_perm(const char *path
)
303 if (!shared_repository
)
305 if (lstat(path
, &st
) < 0)
309 if (shared_repository
) {
310 int tweak
= shared_repository
;
311 if (!(mode
& S_IWUSR
))
315 /* Preserve old PERM_UMASK behaviour */
321 mode
|= FORCE_DIR_SET_GID
;
323 /* Copy read bits to execute bits */
324 mode
|= (shared_repository
& 0444) >> 2;
327 if ((mode
& st
.st_mode
) != mode
&& chmod(path
, mode
) < 0)
332 const char *make_relative_path(const char *abs
, const char *base
)
334 static char buf
[PATH_MAX
+ 1];
338 baselen
= strlen(base
);
339 if (prefixcmp(abs
, base
))
341 if (abs
[baselen
] == '/')
343 else if (base
[baselen
- 1] != '/')
345 strcpy(buf
, abs
+ baselen
);
350 * path = absolute path
351 * buf = buffer of at least max(2, strlen(path)+1) bytes
352 * It is okay if buf == path, but they should not overlap otherwise.
354 * Performs the following normalizations on path, storing the result in buf:
355 * - Removes trailing slashes.
356 * - Removes empty components.
357 * - Removes "." components.
358 * - Removes ".." components, and the components the precede them.
359 * "" and paths that contain only slashes are normalized to "/".
360 * Returns the length of the output.
362 * Note that this function is purely textual. It does not follow symlinks,
363 * verify the existence of the path, or make any system calls.
365 int normalize_absolute_path(char *buf
, const char *path
)
367 const char *comp_start
= path
, *comp_end
= path
;
373 while (*comp_start
) {
374 assert(*comp_start
== '/');
375 while (*++comp_end
&& *comp_end
!= '/')
377 comp_len
= comp_end
- comp_start
;
379 if (!strncmp("/", comp_start
, comp_len
) ||
380 !strncmp("/.", comp_start
, comp_len
))
383 if (!strncmp("/..", comp_start
, comp_len
)) {
384 while (dst
> buf
&& *--dst
!= '/')
389 memcpy(dst
, comp_start
, comp_len
);
392 comp_start
= comp_end
;
403 * path = Canonical absolute path
404 * prefix_list = Colon-separated list of absolute paths
406 * Determines, for each path in prefix_list, whether the "prefix" really
407 * is an ancestor directory of path. Returns the length of the longest
408 * ancestor directory, excluding any trailing slashes, or -1 if no prefix
409 * is an ancestor. (Note that this means 0 is returned if prefix_list is
410 * "/".) "/foo" is not considered an ancestor of "/foobar". Directories
411 * are not considered to be their own ancestors. path must be in a
412 * canonical form: empty components, or "." or ".." components are not
413 * allowed. prefix_list may be null, which is like "".
415 int longest_ancestor_length(const char *path
, const char *prefix_list
)
417 char buf
[PATH_MAX
+1];
418 const char *ceil
, *colon
;
419 int len
, max_len
= -1;
421 if (prefix_list
== NULL
|| !strcmp(path
, "/"))
424 for (colon
= ceil
= prefix_list
; *colon
; ceil
= colon
+1) {
425 for (colon
= ceil
; *colon
&& *colon
!= ':'; colon
++);
427 if (len
== 0 || len
> PATH_MAX
|| !is_absolute_path(ceil
))
429 strlcpy(buf
, ceil
, len
+1);
430 len
= normalize_absolute_path(buf
, buf
);
431 /* Strip "trailing slashes" from "/". */
435 if (!strncmp(path
, buf
, len
) &&