path.c 18.9 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
static int get_st_mode_bits(const char *path, int *mode)
9 10 11 12 13 14 15 16
{
	struct stat st;
	if (lstat(path, &st) < 0)
		return -1;
	*mode = st.st_mode;
	return 0;
}

17 18
static char bad_path[] = "/bad-path/";

19
static struct strbuf *get_pathname(void)
20
{
21 22 23
	static struct strbuf pathname_array[4] = {
		STRBUF_INIT, STRBUF_INIT, STRBUF_INIT, STRBUF_INIT
	};
24
	static int index;
25 26 27
	struct strbuf *sb = &pathname_array[3 & ++index];
	strbuf_reset(sb);
	return sb;
28 29
}

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

41 42 43 44 45 46 47
static void strbuf_cleanup_path(struct strbuf *sb)
{
	char *path = cleanup_path(sb->buf);
	if (path > sb->buf)
		strbuf_remove(sb, 0, path - sb->buf);
}

48 49 50 51 52 53 54 55 56
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) {
57
		strlcpy(buf, bad_path, n);
58 59 60 61 62
		return buf;
	}
	return cleanup_path(buf);
}

63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
static int dir_prefix(const char *buf, const char *dir)
{
	int len = strlen(dir);
	return !strncmp(buf, dir, len) &&
		(is_dir_sep(buf[len]) || buf[len] == '\0');
}

/* $buf =~ m|$dir/+$file| but without regex */
static int is_dir_file(const char *buf, const char *dir, const char *file)
{
	int len = strlen(dir);
	if (strncmp(buf, dir, len) || !is_dir_sep(buf[len]))
		return 0;
	while (is_dir_sep(buf[len]))
		len++;
	return !strcmp(buf + len, file);
}

static void replace_dir(struct strbuf *buf, int len, const char *newdir)
{
	int newlen = strlen(newdir);
	int need_sep = (buf->buf[len] && !is_dir_sep(buf->buf[len])) &&
		!is_dir_sep(newdir[newlen - 1]);
	if (need_sep)
		len--;	 /* keep one char, to be replaced with '/'  */
	strbuf_splice(buf, 0, len, newdir, newlen);
	if (need_sep)
		buf->buf[newlen] = '/';
}

static void adjust_git_path(struct strbuf *buf, int git_dir_len)
{
	const char *base = buf->buf + git_dir_len;
	if (git_graft_env && is_dir_file(base, "info", "grafts"))
		strbuf_splice(buf, 0, buf->len,
			      get_graft_file(), strlen(get_graft_file()));
	else if (git_index_env && !strcmp(base, "index"))
		strbuf_splice(buf, 0, buf->len,
			      get_index_file(), strlen(get_index_file()));
	else if (git_db_env && dir_prefix(base, "objects"))
		replace_dir(buf, git_dir_len + 7, get_object_directory());
}

106
static void do_git_path(struct strbuf *buf, const char *fmt, va_list args)
107
{
108 109
	int gitdir_len;
	strbuf_addstr(buf, get_git_dir());
110 111
	if (buf->len && !is_dir_sep(buf->buf[buf->len - 1]))
		strbuf_addch(buf, '/');
112
	gitdir_len = buf->len;
113
	strbuf_vaddf(buf, fmt, args);
114
	adjust_git_path(buf, gitdir_len);
115
	strbuf_cleanup_path(buf);
116 117
}

118
void strbuf_git_path(struct strbuf *sb, const char *fmt, ...)
119 120 121
{
	va_list args;
	va_start(args, fmt);
122
	do_git_path(sb, fmt, args);
123 124 125
	va_end(args);
}

126 127 128 129 130 131 132 133 134 135
const char *git_path(const char *fmt, ...)
{
	struct strbuf *pathname = get_pathname();
	va_list args;
	va_start(args, fmt);
	do_git_path(pathname, fmt, args);
	va_end(args);
	return pathname->buf;
}

136 137
char *git_pathdup(const char *fmt, ...)
{
138
	struct strbuf path = STRBUF_INIT;
139 140
	va_list args;
	va_start(args, fmt);
141
	do_git_path(&path, fmt, args);
142
	va_end(args);
143
	return strbuf_detach(&path, NULL);
144 145
}

146 147 148 149 150 151 152
char *mkpathdup(const char *fmt, ...)
{
	struct strbuf sb = STRBUF_INIT;
	va_list args;
	va_start(args, fmt);
	strbuf_vaddf(&sb, fmt, args);
	va_end(args);
153 154
	strbuf_cleanup_path(&sb);
	return strbuf_detach(&sb, NULL);
155 156
}

157
const char *mkpath(const char *fmt, ...)
158 159
{
	va_list args;
160
	struct strbuf *pathname = get_pathname();
161
	va_start(args, fmt);
162
	strbuf_vaddf(pathname, fmt, args);
163
	va_end(args);
164
	return cleanup_path(pathname->buf);
165 166
}

167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
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);
	}

185 186 187 188 189 190
	if (xdg) {
		if (!xdg_home)
			*xdg = NULL;
		else
			*xdg = mkpathdup("%s/git/%s", xdg_home, file);
	}
191 192 193 194

	free(to_free);
}

195
const char *git_path_submodule(const char *path, const char *fmt, ...)
196
{
197
	struct strbuf *buf = get_pathname();
198 199 200
	const char *git_dir;
	va_list args;

201 202 203 204
	strbuf_addstr(buf, path);
	if (buf->len && buf->buf[buf->len - 1] != '/')
		strbuf_addch(buf, '/');
	strbuf_addstr(buf, ".git");
205

206
	git_dir = read_gitfile(buf->buf);
207
	if (git_dir) {
208 209
		strbuf_reset(buf);
		strbuf_addstr(buf, git_dir);
210
	}
211
	strbuf_addch(buf, '/');
212 213

	va_start(args, fmt);
214
	strbuf_vaddf(buf, fmt, args);
215
	va_end(args);
216 217
	strbuf_cleanup_path(buf);
	return buf->buf;
218
}
219

220
int validate_headref(const char *path)
221 222 223
{
	struct stat st;
	char *buf, buffer[256];
224
	unsigned char sha1[20];
225 226
	int fd;
	ssize_t len;
227 228 229 230 231 232 233

	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);
234
		if (len >= 5 && !memcmp("refs/", buffer, 5))
235 236 237 238 239 240 241 242 243 244
			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;
245
	len = read_in_full(fd, buffer, sizeof(buffer)-1);
246 247 248 249 250
	close(fd);

	/*
	 * Is it a symbolic ref?
	 */
251
	if (len < 4)
252
		return -1;
253 254 255 256 257
	if (!memcmp("ref:", buffer, 4)) {
		buf = buffer + 4;
		len -= 4;
		while (len && isspace(*buf))
			buf++, len--;
258
		if (len >= 5 && !memcmp("refs/", buf, 5))
259 260 261 262 263 264 265
			return 0;
	}

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

268 269 270
	return -1;
}

271
static struct passwd *getpw_str(const char *username, size_t len)
272
{
273
	struct passwd *pw;
274
	char *username_z = xmemdupz(username, len);
275 276 277 278
	pw = getpwnam(username_z);
	free(username_z);
	return pw;
}
279

280 281 282 283 284 285 286 287 288 289 290 291 292
/*
 * 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 *to_copy = path;

	if (path == NULL)
		goto return_null;
	if (path[0] == '~') {
293
		const char *first_slash = strchrnul(path, '/');
294 295
		const char *username = path + 1;
		size_t username_len = first_slash - username;
296 297
		if (username_len == 0) {
			const char *home = getenv("HOME");
298 299
			if (!home)
				goto return_null;
300
			strbuf_addstr(&user_path, home);
301 302 303 304
		} else {
			struct passwd *pw = getpw_str(username, username_len);
			if (!pw)
				goto return_null;
305
			strbuf_addstr(&user_path, pw->pw_dir);
306
		}
307
		to_copy = first_slash;
308
	}
309
	strbuf_addstr(&user_path, to_copy);
310 311 312 313
	return strbuf_detach(&user_path, NULL);
return_null:
	strbuf_release(&user_path);
	return NULL;
314 315
}

316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
/*
 * 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.
 */
340
const char *enter_repo(const char *path, int strict)
341
{
342 343 344 345
	static char used_path[PATH_MAX];
	static char validated_path[PATH_MAX];

	if (!path)
346 347
		return NULL;

348 349
	if (!strict) {
		static const char *suffix[] = {
350
			"/.git", "", ".git/.git", ".git", NULL,
351
		};
352
		const char *gitfile;
353 354
		int len = strlen(path);
		int i;
355
		while ((1 < len) && (path[len-1] == '/'))
356
			len--;
357

358
		if (PATH_MAX <= len)
359
			return NULL;
360 361 362 363 364
		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);
365 366
			if (!newpath || (PATH_MAX - 10 < strlen(newpath))) {
				free(newpath);
367
				return NULL;
368 369 370 371 372 373 374 375
			}
			/*
			 * 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);
376 377 378
		}
		else if (PATH_MAX - 10 < len)
			return NULL;
379
		len = strlen(used_path);
380
		for (i = 0; suffix[i]; i++) {
381
			struct stat st;
382
			strcpy(used_path + len, suffix[i]);
383 384 385
			if (!stat(used_path, &st) &&
			    (S_ISREG(st.st_mode) ||
			    (S_ISDIR(st.st_mode) && is_git_directory(used_path)))) {
386 387 388 389
				strcat(validated_path, suffix[i]);
				break;
			}
		}
390 391 392 393 394 395
		if (!suffix[i])
			return NULL;
		gitfile = read_gitfile(used_path) ;
		if (gitfile)
			strcpy(used_path, gitfile);
		if (chdir(used_path))
396
			return NULL;
397
		path = validated_path;
398
	}
399 400
	else if (chdir(path))
		return NULL;
401

402
	if (access("objects", X_OK) == 0 && access("refs", X_OK) == 0 &&
403
	    validate_headref("HEAD") == 0) {
René Scharfe's avatar
René Scharfe committed
404
		set_git_dir(".");
405
		check_repository_format();
406
		return path;
407 408 409 410
	}

	return NULL;
}
411

412
static int calc_shared_perm(int mode)
413
{
414
	int tweak;
415

416
	if (shared_repository < 0)
417
		tweak = -shared_repository;
418
	else
419
		tweak = shared_repository;
420 421 422 423 424 425 426 427 428

	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
429
		mode |= tweak;
430

431 432 433 434 435 436 437 438 439 440 441 442 443 444 445
	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)) {
446
		/* Copy read bits to execute bits */
447 448
		new_mode |= (new_mode & 0444) >> 2;
		new_mode |= FORCE_DIR_SET_GID;
449 450
	}

451 452
	if (((old_mode ^ new_mode) & ~S_IFMT) &&
			chmod(path, (new_mode & ~S_IFMT)) < 0)
453 454 455
		return -2;
	return 0;
}
456

457 458 459 460 461 462 463 464 465 466
static int have_same_root(const char *path1, const char *path2)
{
	int is_abs1, is_abs2;

	is_abs1 = is_absolute_path(path1);
	is_abs2 = is_absolute_path(path2);
	return (is_abs1 && is_abs2 && tolower(path1[0]) == tolower(path2[0])) ||
	       (!is_abs1 && !is_abs2);
}

467 468 469 470 471 472 473 474
/*
 * Give path as relative to prefix.
 *
 * The strbuf may or may not be used, so do not assume it contains the
 * returned path.
 */
const char *relative_path(const char *in, const char *prefix,
			  struct strbuf *sb)
475
{
476 477 478 479
	int in_len = in ? strlen(in) : 0;
	int prefix_len = prefix ? strlen(prefix) : 0;
	int in_off = 0;
	int prefix_off = 0;
480 481
	int i = 0, j = 0;

482 483 484 485 486
	if (!in_len)
		return "./";
	else if (!prefix_len)
		return in;

487 488 489 490 491 492 493 494 495 496
	if (have_same_root(in, prefix)) {
		/* bypass dos_drive, for "c:" is identical to "C:" */
		if (has_dos_drive_prefix(in)) {
			i = 2;
			j = 2;
		}
	} else {
		return in;
	}

497 498 499
	while (i < prefix_len && j < in_len && prefix[i] == in[j]) {
		if (is_dir_sep(prefix[i])) {
			while (is_dir_sep(prefix[i]))
500
				i++;
501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
			while (is_dir_sep(in[j]))
				j++;
			prefix_off = i;
			in_off = j;
		} else {
			i++;
			j++;
		}
	}

	if (
	    /* "prefix" seems like prefix of "in" */
	    i >= prefix_len &&
	    /*
	     * but "/foo" is not a prefix of "/foobar"
	     * (i.e. prefix not end with '/')
	     */
	    prefix_off < prefix_len) {
		if (j >= in_len) {
			/* in="/a/b", prefix="/a/b" */
			in_off = in_len;
		} else if (is_dir_sep(in[j])) {
			/* in="/a/b/c", prefix="/a/b" */
			while (is_dir_sep(in[j]))
525
				j++;
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
			in_off = j;
		} else {
			/* in="/a/bbb/c", prefix="/a/b" */
			i = prefix_off;
		}
	} else if (
		   /* "in" is short than "prefix" */
		   j >= in_len &&
		   /* "in" not end with '/' */
		   in_off < in_len) {
		if (is_dir_sep(prefix[i])) {
			/* in="/a/b", prefix="/a/b/c/" */
			while (is_dir_sep(prefix[i]))
				i++;
			in_off = in_len;
		}
	}
	in += in_off;
	in_len -= in_off;

	if (i >= prefix_len) {
		if (!in_len)
			return "./";
		else
			return in;
	}

	strbuf_reset(sb);
	strbuf_grow(sb, in_len);

	while (i < prefix_len) {
		if (is_dir_sep(prefix[i])) {
			strbuf_addstr(sb, "../");
			while (is_dir_sep(prefix[i]))
				i++;
561 562 563 564
			continue;
		}
		i++;
	}
565 566 567 568 569 570
	if (!is_dir_sep(prefix[prefix_len - 1]))
		strbuf_addstr(sb, "../");

	strbuf_addstr(sb, in);

	return sb->buf;
571
}
572

573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
/*
 * A simpler implementation of relative_path
 *
 * Get relative path by removing "prefix" from "in". This function
 * first appears in v1.5.6-1-g044bbbc, and makes git_dir shorter
 * to increase performance when traversing the path to work_tree.
 */
const char *remove_leading_path(const char *in, const char *prefix)
{
	static char buf[PATH_MAX + 1];
	int i = 0, j = 0;

	if (!prefix || !prefix[0])
		return in;
	while (prefix[i]) {
		if (is_dir_sep(prefix[i])) {
			if (!is_dir_sep(in[j]))
				return in;
			while (is_dir_sep(prefix[i]))
				i++;
			while (is_dir_sep(in[j]))
				j++;
			continue;
		} else if (in[j] != prefix[i]) {
			return in;
		}
		i++;
		j++;
	}
	if (
	    /* "/foo" is a prefix of "/foo" */
	    in[j] &&
	    /* "/foo" is not a prefix of "/foobar" */
	    !is_dir_sep(prefix[i-1]) && !is_dir_sep(in[j])
	   )
		return in;
	while (is_dir_sep(in[j]))
		j++;
	if (!in[j])
		strcpy(buf, ".");
	else
		strcpy(buf, in + j);
	return buf;
}

618
/*
619
 * It is okay if dst == src, but they should not overlap otherwise.
620
 *
621 622 623
 * Performs the following normalizations on src, storing the result in dst:
 * - Ensures that components are separated by '/' (Windows only)
 * - Squashes sequences of '/'.
624 625
 * - Removes "." components.
 * - Removes ".." components, and the components the precede them.
626 627
 * Returns failure (non-zero) if a ".." component appears as first path
 * component anytime during the normalization. Otherwise, returns success (0).
628 629 630
 *
 * Note that this function is purely textual.  It does not follow symlinks,
 * verify the existence of the path, or make any system calls.
631 632 633 634 635 636
 *
 * prefix_len != NULL is for a specific case of prefix_pathspec():
 * assume that src == dst and src[0..prefix_len-1] is already
 * normalized, any time "../" eats up to the prefix_len part,
 * prefix_len is reduced. In the end prefix_len is the remaining
 * prefix that has not been overridden by user pathspec.
637
 */
638
int normalize_path_copy_len(char *dst, const char *src, int *prefix_len)
639
{
640
	char *dst0;
641

642 643 644
	if (has_dos_drive_prefix(src)) {
		*dst++ = *src++;
		*dst++ = *src++;
645
	}
646
	dst0 = dst;
647

648
	if (is_dir_sep(*src)) {
649
		*dst++ = '/';
650 651 652 653 654 655 656 657 658 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
		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;
				}
			}
		}
689

690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
		/* 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.
		 */
707 708
		dst--;	/* go to trailing '/' */
		if (dst <= dst0)
709
			return -1;
710 711 712
		/* Windows: dst[-1] cannot be backslash anymore */
		while (dst0 < dst && dst[-1] != '/')
			dst--;
713 714
		if (prefix_len && *prefix_len > dst - dst0)
			*prefix_len = dst - dst0;
715
	}
716
	*dst = '\0';
717
	return 0;
718
}
719

720 721 722 723 724
int normalize_path_copy(char *dst, const char *src)
{
	return normalize_path_copy_len(dst, src, NULL);
}

725 726
/*
 * path = Canonical absolute path
727 728
 * prefixes = string_list containing normalized, absolute paths without
 * trailing slashes (except for the root directory, which is denoted by "/").
729
 *
730
 * Determines, for each path in prefixes, whether the "prefix"
731 732
 * is an ancestor directory of path.  Returns the length of the longest
 * ancestor directory, excluding any trailing slashes, or -1 if no prefix
733 734
 * is an ancestor.  (Note that this means 0 is returned if prefixes is
 * ["/"].) "/foo" is not considered an ancestor of "/foobar".  Directories
735 736
 * are not considered to be their own ancestors.  path must be in a
 * canonical form: empty components, or "." or ".." components are not
737
 * allowed.
738
 */
739
int longest_ancestor_length(const char *path, struct string_list *prefixes)
740
{
741
	int i, max_len = -1;
742

743
	if (!strcmp(path, "/"))
744 745
		return -1;

746 747
	for (i = 0; i < prefixes->nr; i++) {
		const char *ceil = prefixes->items[i].string;
748 749
		int len = strlen(ceil);

750 751 752 753 754 755
		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 */
756

757
		if (len > max_len)
758 759 760 761 762
			max_len = len;
	}

	return max_len;
}
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798

/* 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));
}
799 800 801 802 803 804 805 806

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()
807
	 * does not do getcwd() based path canonicalization.
808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
	 *
	 * 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;
		}
	}
}