path.c 15.3 KB
Newer Older
1
/*
2
 * Utilities for paths and pathnames
3 4
 */
#include "cache.h"
5
#include "strbuf.h"
6
#include "string-list.h"
7

8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
#ifndef get_st_mode_bits
/*
 * The replacement lstat(2) we use on Cygwin is incomplete and
 * may return wrong permission bits. Most of the time we do not care,
 * but the callsites of this wrapper do care.
 */
int get_st_mode_bits(const char *path, int *mode)
{
	struct stat st;
	if (lstat(path, &st) < 0)
		return -1;
	*mode = st.st_mode;
	return 0;
}
#endif

24 25
static char bad_path[] = "/bad-path/";

26 27 28 29 30 31 32
static char *get_pathname(void)
{
	static char pathname_array[4][PATH_MAX];
	static int index;
	return pathname_array[3 & ++index];
}

33 34 35 36 37 38 39 40 41 42 43
static char *cleanup_path(char *path)
{
	/* Clean it up */
	if (!memcmp(path, "./", 2)) {
		path += 2;
		while (*path == '/')
			path++;
	}
	return path;
}

44 45 46 47 48 49 50 51 52
char *mksnpath(char *buf, size_t n, const char *fmt, ...)
{
	va_list args;
	unsigned len;

	va_start(args, fmt);
	len = vsnprintf(buf, n, fmt, args);
	va_end(args);
	if (len >= n) {
53
		strlcpy(buf, bad_path, n);
54 55 56 57 58
		return buf;
	}
	return cleanup_path(buf);
}

59
static char *vsnpath(char *buf, size_t n, const char *fmt, va_list args)
60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
{
	const char *git_dir = get_git_dir();
	size_t len;

	len = strlen(git_dir);
	if (n < len + 1)
		goto bad;
	memcpy(buf, git_dir, len);
	if (len && !is_dir_sep(git_dir[len-1]))
		buf[len++] = '/';
	len += vsnprintf(buf + len, n - len, fmt, args);
	if (len >= n)
		goto bad;
	return cleanup_path(buf);
bad:
75
	strlcpy(buf, bad_path, n);
76 77 78
	return buf;
}

79 80
char *git_snpath(char *buf, size_t n, const char *fmt, ...)
{
81
	char *ret;
82 83
	va_list args;
	va_start(args, fmt);
84
	ret = vsnpath(buf, n, fmt, args);
85
	va_end(args);
86
	return ret;
87 88 89 90
}

char *git_pathdup(const char *fmt, ...)
{
91
	char path[PATH_MAX], *ret;
92 93
	va_list args;
	va_start(args, fmt);
94
	ret = vsnpath(path, sizeof(path), fmt, args);
95
	va_end(args);
96
	return xstrdup(ret);
97 98
}

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
char *mkpathdup(const char *fmt, ...)
{
	char *path;
	struct strbuf sb = STRBUF_INIT;
	va_list args;

	va_start(args, fmt);
	strbuf_vaddf(&sb, fmt, args);
	va_end(args);
	path = xstrdup(cleanup_path(sb.buf));

	strbuf_release(&sb);
	return path;
}

114 115 116 117
char *mkpath(const char *fmt, ...)
{
	va_list args;
	unsigned len;
118
	char *pathname = get_pathname();
119 120 121 122 123 124 125 126 127 128 129

	va_start(args, fmt);
	len = vsnprintf(pathname, PATH_MAX, fmt, args);
	va_end(args);
	if (len >= PATH_MAX)
		return bad_path;
	return cleanup_path(pathname);
}

char *git_path(const char *fmt, ...)
{
130
	char *pathname = get_pathname();
131
	va_list args;
132
	char *ret;
133 134

	va_start(args, fmt);
135
	ret = vsnpath(pathname, PATH_MAX, fmt, args);
136
	va_end(args);
137
	return ret;
138
}
139

140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165
void home_config_paths(char **global, char **xdg, char *file)
{
	char *xdg_home = getenv("XDG_CONFIG_HOME");
	char *home = getenv("HOME");
	char *to_free = NULL;

	if (!home) {
		if (global)
			*global = NULL;
	} else {
		if (!xdg_home) {
			to_free = mkpathdup("%s/.config", home);
			xdg_home = to_free;
		}
		if (global)
			*global = mkpathdup("%s/.gitconfig", home);
	}

	if (!xdg_home)
		*xdg = NULL;
	else
		*xdg = mkpathdup("%s/git/%s", xdg_home, file);

	free(to_free);
}

166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182
char *git_path_submodule(const char *path, const char *fmt, ...)
{
	char *pathname = get_pathname();
	struct strbuf buf = STRBUF_INIT;
	const char *git_dir;
	va_list args;
	unsigned len;

	len = strlen(path);
	if (len > PATH_MAX-100)
		return bad_path;

	strbuf_addstr(&buf, path);
	if (len && path[len-1] != '/')
		strbuf_addch(&buf, '/');
	strbuf_addstr(&buf, ".git");

183
	git_dir = read_gitfile(buf.buf);
184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
	if (git_dir) {
		strbuf_reset(&buf);
		strbuf_addstr(&buf, git_dir);
	}
	strbuf_addch(&buf, '/');

	if (buf.len >= PATH_MAX)
		return bad_path;
	memcpy(pathname, buf.buf, buf.len + 1);

	strbuf_release(&buf);
	len = strlen(pathname);

	va_start(args, fmt);
	len += vsnprintf(pathname + len, PATH_MAX - len, fmt, args);
	va_end(args);
	if (len >= PATH_MAX)
		return bad_path;
	return cleanup_path(pathname);
}
204

205
int validate_headref(const char *path)
206 207 208
{
	struct stat st;
	char *buf, buffer[256];
209
	unsigned char sha1[20];
210 211
	int fd;
	ssize_t len;
212 213 214 215 216 217 218

	if (lstat(path, &st) < 0)
		return -1;

	/* Make sure it is a "refs/.." symlink */
	if (S_ISLNK(st.st_mode)) {
		len = readlink(path, buffer, sizeof(buffer)-1);
219
		if (len >= 5 && !memcmp("refs/", buffer, 5))
220 221 222 223 224 225 226 227 228 229
			return 0;
		return -1;
	}

	/*
	 * Anything else, just open it and try to see if it is a symbolic ref.
	 */
	fd = open(path, O_RDONLY);
	if (fd < 0)
		return -1;
230
	len = read_in_full(fd, buffer, sizeof(buffer)-1);
231 232 233 234 235
	close(fd);

	/*
	 * Is it a symbolic ref?
	 */
236
	if (len < 4)
237
		return -1;
238 239 240 241 242
	if (!memcmp("ref:", buffer, 4)) {
		buf = buffer + 4;
		len -= 4;
		while (len && isspace(*buf))
			buf++, len--;
243
		if (len >= 5 && !memcmp("refs/", buf, 5))
244 245 246 247 248 249 250
			return 0;
	}

	/*
	 * Is this a detached HEAD?
	 */
	if (!get_sha1_hex(buffer, sha1))
251
		return 0;
252

253 254 255
	return -1;
}

256
static struct passwd *getpw_str(const char *username, size_t len)
257
{
258
	struct passwd *pw;
259 260 261 262 263 264 265
	char *username_z = xmalloc(len + 1);
	memcpy(username_z, username, len);
	username_z[len] = '\0';
	pw = getpwnam(username_z);
	free(username_z);
	return pw;
}
266

267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
/*
 * Return a string with ~ and ~user expanded via getpw*.  If buf != NULL,
 * then it is a newly allocated string. Returns NULL on getpw failure or
 * if path is NULL.
 */
char *expand_user_path(const char *path)
{
	struct strbuf user_path = STRBUF_INIT;
	const char *first_slash = strchrnul(path, '/');
	const char *to_copy = path;

	if (path == NULL)
		goto return_null;
	if (path[0] == '~') {
		const char *username = path + 1;
		size_t username_len = first_slash - username;
283 284
		if (username_len == 0) {
			const char *home = getenv("HOME");
285 286
			if (!home)
				goto return_null;
287 288 289 290 291 292
			strbuf_add(&user_path, home, strlen(home));
		} else {
			struct passwd *pw = getpw_str(username, username_len);
			if (!pw)
				goto return_null;
			strbuf_add(&user_path, pw->pw_dir, strlen(pw->pw_dir));
293
		}
294
		to_copy = first_slash;
295
	}
296 297 298 299 300
	strbuf_add(&user_path, to_copy, strlen(to_copy));
	return strbuf_detach(&user_path, NULL);
return_null:
	strbuf_release(&user_path);
	return NULL;
301 302
}

303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
/*
 * First, one directory to try is determined by the following algorithm.
 *
 * (0) If "strict" is given, the path is used as given and no DWIM is
 *     done. Otherwise:
 * (1) "~/path" to mean path under the running user's home directory;
 * (2) "~user/path" to mean path under named user's home directory;
 * (3) "relative/path" to mean cwd relative directory; or
 * (4) "/absolute/path" to mean absolute directory.
 *
 * Unless "strict" is given, we try access() for existence of "%s.git/.git",
 * "%s/.git", "%s.git", "%s" in this order.  The first one that exists is
 * what we try.
 *
 * Second, we try chdir() to that.  Upon failure, we return NULL.
 *
 * Then, we try if the current directory is a valid git repository.
 * Upon failure, we return NULL.
 *
 * If all goes well, we return the directory we used to chdir() (but
 * before ~user is expanded), avoiding getcwd() resolving symbolic
 * links.  User relative paths are also returned as they are given,
 * except DWIM suffixing.
 */
327
const char *enter_repo(const char *path, int strict)
328
{
329 330 331 332
	static char used_path[PATH_MAX];
	static char validated_path[PATH_MAX];

	if (!path)
333 334
		return NULL;

335 336
	if (!strict) {
		static const char *suffix[] = {
337
			"/.git", "", ".git/.git", ".git", NULL,
338
		};
339
		const char *gitfile;
340 341
		int len = strlen(path);
		int i;
342
		while ((1 < len) && (path[len-1] == '/'))
343
			len--;
344

345
		if (PATH_MAX <= len)
346
			return NULL;
347 348 349 350 351
		strncpy(used_path, path, len); used_path[len] = 0 ;
		strcpy(validated_path, used_path);

		if (used_path[0] == '~') {
			char *newpath = expand_user_path(used_path);
352 353
			if (!newpath || (PATH_MAX - 10 < strlen(newpath))) {
				free(newpath);
354
				return NULL;
355 356 357 358 359 360 361 362
			}
			/*
			 * Copy back into the static buffer. A pity
			 * since newpath was not bounded, but other
			 * branches of the if are limited by PATH_MAX
			 * anyway.
			 */
			strcpy(used_path, newpath); free(newpath);
363 364 365
		}
		else if (PATH_MAX - 10 < len)
			return NULL;
366
		len = strlen(used_path);
367
		for (i = 0; suffix[i]; i++) {
368
			struct stat st;
369
			strcpy(used_path + len, suffix[i]);
370 371 372
			if (!stat(used_path, &st) &&
			    (S_ISREG(st.st_mode) ||
			    (S_ISDIR(st.st_mode) && is_git_directory(used_path)))) {
373 374 375 376
				strcat(validated_path, suffix[i]);
				break;
			}
		}
377 378 379 380 381 382
		if (!suffix[i])
			return NULL;
		gitfile = read_gitfile(used_path) ;
		if (gitfile)
			strcpy(used_path, gitfile);
		if (chdir(used_path))
383
			return NULL;
384
		path = validated_path;
385
	}
386 387
	else if (chdir(path))
		return NULL;
388

389
	if (access("objects", X_OK) == 0 && access("refs", X_OK) == 0 &&
390
	    validate_headref("HEAD") == 0) {
René Scharfe's avatar
René Scharfe committed
391
		set_git_dir(".");
392
		check_repository_format();
393
		return path;
394 395 396 397
	}

	return NULL;
}
398

399
static int calc_shared_perm(int mode)
400
{
401
	int tweak;
402

403
	if (shared_repository < 0)
404
		tweak = -shared_repository;
405
	else
406
		tweak = shared_repository;
407 408 409 410 411 412 413 414 415

	if (!(mode & S_IWUSR))
		tweak &= ~0222;
	if (mode & S_IXUSR)
		/* Copy read bits to execute bits */
		tweak |= (tweak & 0444) >> 2;
	if (shared_repository < 0)
		mode = (mode & ~0777) | tweak;
	else
416
		mode |= tweak;
417

418 419 420 421 422 423 424 425 426 427 428 429 430 431 432
	return mode;
}


int adjust_shared_perm(const char *path)
{
	int old_mode, new_mode;

	if (!shared_repository)
		return 0;
	if (get_st_mode_bits(path, &old_mode) < 0)
		return -1;

	new_mode = calc_shared_perm(old_mode);
	if (S_ISDIR(old_mode)) {
433
		/* Copy read bits to execute bits */
434 435
		new_mode |= (new_mode & 0444) >> 2;
		new_mode |= FORCE_DIR_SET_GID;
436 437
	}

438 439
	if (((old_mode ^ new_mode) & ~S_IFMT) &&
			chmod(path, (new_mode & ~S_IFMT)) < 0)
440 441 442
		return -2;
	return 0;
}
443

444
const char *relative_path(const char *abs, const char *base)
445 446
{
	static char buf[PATH_MAX + 1];
447 448 449
	int i = 0, j = 0;

	if (!base || !base[0])
450
		return abs;
451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
	while (base[i]) {
		if (is_dir_sep(base[i])) {
			if (!is_dir_sep(abs[j]))
				return abs;
			while (is_dir_sep(base[i]))
				i++;
			while (is_dir_sep(abs[j]))
				j++;
			continue;
		} else if (abs[j] != base[i]) {
			return abs;
		}
		i++;
		j++;
	}
	if (
	    /* "/foo" is a prefix of "/foo" */
	    abs[j] &&
	    /* "/foo" is not a prefix of "/foobar" */
	    !is_dir_sep(base[i-1]) && !is_dir_sep(abs[j])
	   )
472
		return abs;
473 474 475 476 477 478
	while (is_dir_sep(abs[j]))
		j++;
	if (!abs[j])
		strcpy(buf, ".");
	else
		strcpy(buf, abs + j);
479 480
	return buf;
}
481 482

/*
483
 * It is okay if dst == src, but they should not overlap otherwise.
484
 *
485 486 487
 * Performs the following normalizations on src, storing the result in dst:
 * - Ensures that components are separated by '/' (Windows only)
 * - Squashes sequences of '/'.
488 489
 * - Removes "." components.
 * - Removes ".." components, and the components the precede them.
490 491
 * Returns failure (non-zero) if a ".." component appears as first path
 * component anytime during the normalization. Otherwise, returns success (0).
492 493 494 495
 *
 * Note that this function is purely textual.  It does not follow symlinks,
 * verify the existence of the path, or make any system calls.
 */
496
int normalize_path_copy(char *dst, const char *src)
497
{
498
	char *dst0;
499

500 501 502
	if (has_dos_drive_prefix(src)) {
		*dst++ = *src++;
		*dst++ = *src++;
503
	}
504
	dst0 = dst;
505

506
	if (is_dir_sep(*src)) {
507
		*dst++ = '/';
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546
		while (is_dir_sep(*src))
			src++;
	}

	for (;;) {
		char c = *src;

		/*
		 * A path component that begins with . could be
		 * special:
		 * (1) "." and ends   -- ignore and terminate.
		 * (2) "./"           -- ignore them, eat slash and continue.
		 * (3) ".." and ends  -- strip one and terminate.
		 * (4) "../"          -- strip one, eat slash and continue.
		 */
		if (c == '.') {
			if (!src[1]) {
				/* (1) */
				src++;
			} else if (is_dir_sep(src[1])) {
				/* (2) */
				src += 2;
				while (is_dir_sep(*src))
					src++;
				continue;
			} else if (src[1] == '.') {
				if (!src[2]) {
					/* (3) */
					src += 2;
					goto up_one;
				} else if (is_dir_sep(src[2])) {
					/* (4) */
					src += 3;
					while (is_dir_sep(*src))
						src++;
					goto up_one;
				}
			}
		}
547

548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
		/* copy up to the next '/', and eat all '/' */
		while ((c = *src++) != '\0' && !is_dir_sep(c))
			*dst++ = c;
		if (is_dir_sep(c)) {
			*dst++ = '/';
			while (is_dir_sep(c))
				c = *src++;
			src--;
		} else if (!c)
			break;
		continue;

	up_one:
		/*
		 * dst0..dst is prefix portion, and dst[-1] is '/';
		 * go up one level.
		 */
565 566
		dst--;	/* go to trailing '/' */
		if (dst <= dst0)
567
			return -1;
568 569 570
		/* Windows: dst[-1] cannot be backslash anymore */
		while (dst0 < dst && dst[-1] != '/')
			dst--;
571
	}
572
	*dst = '\0';
573
	return 0;
574
}
575 576 577

/*
 * path = Canonical absolute path
578 579
 * prefixes = string_list containing normalized, absolute paths without
 * trailing slashes (except for the root directory, which is denoted by "/").
580
 *
581
 * Determines, for each path in prefixes, whether the "prefix"
582 583
 * is an ancestor directory of path.  Returns the length of the longest
 * ancestor directory, excluding any trailing slashes, or -1 if no prefix
584 585
 * is an ancestor.  (Note that this means 0 is returned if prefixes is
 * ["/"].) "/foo" is not considered an ancestor of "/foobar".  Directories
586 587
 * are not considered to be their own ancestors.  path must be in a
 * canonical form: empty components, or "." or ".." components are not
588
 * allowed.
589
 */
590
int longest_ancestor_length(const char *path, struct string_list *prefixes)
591
{
592
	int i, max_len = -1;
593

594
	if (!strcmp(path, "/"))
595 596
		return -1;

597 598
	for (i = 0; i < prefixes->nr; i++) {
		const char *ceil = prefixes->items[i].string;
599 600
		int len = strlen(ceil);

601 602 603 604 605 606
		if (len == 1 && ceil[0] == '/')
			len = 0; /* root matches anything, with length 0 */
		else if (!strncmp(path, ceil, len) && path[len] == '/')
			; /* match of length len */
		else
			continue; /* no match */
607

608
		if (len > max_len)
609 610 611 612 613
			max_len = len;
	}

	return max_len;
}
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649

/* strip arbitrary amount of directory separators at end of path */
static inline int chomp_trailing_dir_sep(const char *path, int len)
{
	while (len && is_dir_sep(path[len - 1]))
		len--;
	return len;
}

/*
 * If path ends with suffix (complete path components), returns the
 * part before suffix (sans trailing directory separators).
 * Otherwise returns NULL.
 */
char *strip_path_suffix(const char *path, const char *suffix)
{
	int path_len = strlen(path), suffix_len = strlen(suffix);

	while (suffix_len) {
		if (!path_len)
			return NULL;

		if (is_dir_sep(path[path_len - 1])) {
			if (!is_dir_sep(suffix[suffix_len - 1]))
				return NULL;
			path_len = chomp_trailing_dir_sep(path, path_len);
			suffix_len = chomp_trailing_dir_sep(suffix, suffix_len);
		}
		else if (path[--path_len] != suffix[--suffix_len])
			return NULL;
	}

	if (path_len && !is_dir_sep(path[path_len - 1]))
		return NULL;
	return xstrndup(path, chomp_trailing_dir_sep(path, path_len));
}
650 651 652 653 654 655 656 657

int daemon_avoid_alias(const char *p)
{
	int sl, ndot;

	/*
	 * This resurrects the belts and suspenders paranoia check by HPA
	 * done in <[email protected]> thread, now enter_repo()
658
	 * does not do getcwd() based path canonicalization.
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
	 *
	 * sl becomes true immediately after seeing '/' and continues to
	 * be true as long as dots continue after that without intervening
	 * non-dot character.
	 */
	if (!p || (*p != '/' && *p != '~'))
		return -1;
	sl = 1; ndot = 0;
	p++;

	while (1) {
		char ch = *p++;
		if (sl) {
			if (ch == '.')
				ndot++;
			else if (ch == '/') {
				if (ndot < 3)
					/* reject //, /./ and /../ */
					return -1;
				ndot = 0;
			}
			else if (ch == 0) {
				if (0 < ndot && ndot < 3)
					/* reject /.$ and /..$ */
					return -1;
				return 0;
			}
			else
				sl = ndot = 0;
		}
		else if (ch == 0)
			return 0;
		else if (ch == '/') {
			sl = 1;
			ndot = 0;
		}
	}
}
697 698 699 700 701 702 703

int offset_1st_component(const char *path)
{
	if (has_dos_drive_prefix(path))
		return 2 + is_dir_sep(path[2]);
	return is_dir_sep(path[0]);
}