fileops.c 17.9 KB
Newer Older
Vicent Marti committed
1
/*
schu committed
2
 * Copyright (C) 2009-2012 the libgit2 contributors
Vicent Marti committed
3 4 5 6
 *
 * This file is part of libgit2, distributed under the GNU GPL v2 with
 * a Linking Exception. For full terms see the included COPYING file.
 */
7
#include "common.h"
8
#include "fileops.h"
9
#include <ctype.h>
10 11 12
#if GIT_WIN32
#include "win32/findfile.h"
#endif
13

14
int git_futils_mkpath2file(const char *file_path, const mode_t mode)
15
{
16
	return git_futils_mkdir(
17 18
		file_path, NULL, mode,
		GIT_MKDIR_PATH | GIT_MKDIR_SKIP_LAST | GIT_MKDIR_VERIFY_DIR);
19 20
}

21
int git_futils_mktmp(git_buf *path_out, const char *filename)
Vicent Marti committed
22 23 24
{
	int fd;

25 26 27 28
	git_buf_sets(path_out, filename);
	git_buf_puts(path_out, "_git2_XXXXXX");

	if (git_buf_oom(path_out))
29
		return -1;
Vicent Marti committed
30

31 32
	if ((fd = p_mkstemp(path_out->ptr)) < 0) {
		giterr_set(GITERR_OS,
33
			"Failed to create temporary file '%s'", path_out->ptr);
34 35
		return -1;
	}
Vicent Marti committed
36

37
	return fd;
Vicent Marti committed
38 39
}

40
int git_futils_creat_withpath(const char *path, const mode_t dirmode, const mode_t mode)
41
{
42
	int fd;
43

44 45 46 47 48
	if (git_futils_mkpath2file(path, dirmode) < 0)
		return -1;

	fd = p_creat(path, mode);
	if (fd < 0) {
49
		giterr_set(GITERR_OS, "Failed to create file '%s'", path);
50 51 52 53
		return -1;
	}

	return fd;
54 55
}

56
int git_futils_creat_locked(const char *path, const mode_t mode)
57
{
58 59 60
	int fd;

#ifdef GIT_WIN32
61
	wchar_t buf[GIT_WIN_PATH];
62

63
	git__utf8_to_16(buf, GIT_WIN_PATH, path);
64 65 66 67 68
	fd = _wopen(buf, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_EXCL, mode);
#else
	fd = open(path, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY | O_EXCL, mode);
#endif

69
	if (fd < 0) {
70
		giterr_set(GITERR_OS, "Failed to create locked file '%s'", path);
71 72 73 74
		return -1;
	}

	return fd;
75 76
}

77
int git_futils_creat_locked_withpath(const char *path, const mode_t dirmode, const mode_t mode)
78
{
79 80
	if (git_futils_mkpath2file(path, dirmode) < 0)
		return -1;
81

Vicent Marti committed
82
	return git_futils_creat_locked(path, mode);
83 84
}

85 86 87 88
int git_futils_open_ro(const char *path)
{
	int fd = p_open(path, O_RDONLY);
	if (fd < 0) {
89
		if (errno == ENOENT || errno == ENOTDIR)
90 91 92 93 94 95
			fd = GIT_ENOTFOUND;
		giterr_set(GITERR_OS, "Failed to open '%s'", path);
	}
	return fd;
}

Vicent Marti committed
96
git_off_t git_futils_filesize(git_file fd)
97
{
98
	struct stat sb;
99 100 101 102 103

	if (p_fstat(fd, &sb)) {
		giterr_set(GITERR_OS, "Failed to stat file descriptor");
		return -1;
	}
104

105 106
	return sb.st_size;
}
107

108 109 110 111 112 113 114 115
mode_t git_futils_canonical_mode(mode_t raw_mode)
{
	if (S_ISREG(raw_mode))
		return S_IFREG | GIT_CANONICAL_PERMS(raw_mode);
	else if (S_ISLNK(raw_mode))
		return S_IFLNK;
	else if (S_ISGITLINK(raw_mode))
		return S_IFGITLINK;
116 117
	else if (S_ISDIR(raw_mode))
		return S_IFDIR;
118 119 120 121
	else
		return 0;
}

122 123
int git_futils_readbuffer_fd(git_buf *buf, git_file fd, size_t len)
{
124
	ssize_t read_size;
125 126 127 128 129 130

	git_buf_clear(buf);

	if (git_buf_grow(buf, len + 1) < 0)
		return -1;

131 132
	/* p_read loops internally to read len bytes */
	read_size = p_read(fd, buf->ptr, len);
133

Vicent Marti committed
134
	if (read_size != (ssize_t)len) {
135 136
		giterr_set(GITERR_OS, "Failed to read descriptor");
		return -1;
137 138
	}

139 140 141
	buf->ptr[read_size] = '\0';
	buf->size = read_size;

142 143 144 145
	return 0;
}

int git_futils_readbuffer_updated(
146
	git_buf *buf, const char *path, time_t *mtime, size_t *size, int *updated)
147 148
{
	git_file fd;
149
	struct stat st;
150
	bool changed = false;
151

152
	assert(buf && path && *path);
153

154 155
	if (updated != NULL)
		*updated = 0;
156

157 158
	if ((fd = git_futils_open_ro(path)) < 0)
		return fd;
159

160
	if (p_fstat(fd, &st) < 0 || S_ISDIR(st.st_mode) || !git__is_sizet(st.st_size+1)) {
161
		p_close(fd);
162 163
		giterr_set(GITERR_OS, "Invalid regular file stat for '%s'", path);
		return -1;
164
	}
165 166

	/*
167 168
	 * If we were given a time and/or a size, we only want to read the file
	 * if it has been modified.
169
	 */
170 171 172 173 174 175 176 177
	if (size && *size != (size_t)st.st_size)
		changed = true;
	if (mtime && *mtime != st.st_mtime)
		changed = true;
	if (!size && !mtime)
		changed = true;

	if (!changed) {
178
		p_close(fd);
179 180
		return 0;
	}
181 182 183

	if (mtime != NULL)
		*mtime = st.st_mtime;
184 185
	if (size != NULL)
		*size = (size_t)st.st_size;
186

187
	if (git_futils_readbuffer_fd(buf, fd, (size_t)st.st_size) < 0) {
188 189
		p_close(fd);
		return -1;
190 191
	}

Vicent Marti committed
192
	p_close(fd);
193

194 195 196
	if (updated != NULL)
		*updated = 1;

197
	return 0;
198 199
}

200
int git_futils_readbuffer(git_buf *buf, const char *path)
201
{
202
	return git_futils_readbuffer_updated(buf, path, NULL, NULL, NULL);
203 204
}

205
int git_futils_mv_withpath(const char *from, const char *to, const mode_t dirmode)
206
{
207 208
	if (git_futils_mkpath2file(to, dirmode) < 0)
		return -1;
209

210 211 212 213 214 215
	if (p_rename(from, to) < 0) {
		giterr_set(GITERR_OS, "Failed to rename '%s' to '%s'", from, to);
		return -1;
	}

	return 0;
216 217
}

Vicent Marti committed
218
int git_futils_mmap_ro(git_map *out, git_file fd, git_off_t begin, size_t len)
219
{
Vicent Marti committed
220
	return p_mmap(out, len, GIT_PROT_READ, GIT_MAP_SHARED, fd, begin);
221 222
}

223 224
int git_futils_mmap_ro_file(git_map *out, const char *path)
{
225 226
	git_file fd = git_futils_open_ro(path);
	git_off_t len;
227
	int result;
228 229 230 231 232

	if (fd < 0)
		return fd;

	len = git_futils_filesize(fd);
233 234 235 236
	if (!git__is_sizet(len)) {
		giterr_set(GITERR_OS, "File `%s` too large to mmap", path);
		return -1;
	}
237

238
	result = git_futils_mmap_ro(out, fd, 0, (size_t)len);
239 240 241 242
	p_close(fd);
	return result;
}

Vicent Marti committed
243
void git_futils_mmap_free(git_map *out)
244
{
Vicent Marti committed
245
	p_munmap(out);
246 247
}

248 249 250 251 252
int git_futils_mkdir(
	const char *path,
	const char *base,
	mode_t mode,
	uint32_t flags)
253
{
254
	int error = -1;
255
	git_buf make_path = GIT_BUF_INIT;
256 257
	ssize_t root = 0;
	char lastch, *tail;
258

259 260 261
	/* build path and find "root" where we should start calling mkdir */
	if (git_path_join_unrooted(&make_path, path, base, &root) < 0)
		return -1;
262

263 264 265
	if (make_path.size == 0) {
		giterr_set(GITERR_OS, "Attempt to create empty path");
		goto fail;
266
	}
267

268 269 270 271 272
	/* remove trailing slashes on path */
	while (make_path.ptr[make_path.size - 1] == '/') {
		make_path.size--;
		make_path.ptr[make_path.size] = '\0';
	}
273

274 275 276 277 278 279 280 281 282 283 284
	/* if we are not supposed to made the last element, truncate it */
	if ((flags & GIT_MKDIR_SKIP_LAST) != 0)
		git_buf_rtruncate_at_char(&make_path, '/');

	/* if we are not supposed to make the whole path, reset root */
	if ((flags & GIT_MKDIR_PATH) == 0)
		root = git_buf_rfind(&make_path, '/');

	/* clip root to make_path length */
	if (root >= (ssize_t)make_path.size)
		root = (ssize_t)make_path.size - 1;
285 286
	if (root < 0)
		root = 0;
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301

	tail = & make_path.ptr[root];

	while (*tail) {
		/* advance tail to include next path component */
		while (*tail == '/')
			tail++;
		while (*tail && *tail != '/')
			tail++;

		/* truncate path at next component */
		lastch = *tail;
		*tail = '\0';

		/* make directory */
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323
		if (p_mkdir(make_path.ptr, mode) < 0) {
			if (errno == EEXIST) {
				if (!lastch && (flags & GIT_MKDIR_VERIFY_DIR) != 0) {
					if (!git_path_isdir(make_path.ptr)) {
						giterr_set(
							GITERR_OS, "Existing path is not a directory '%s'",
							make_path.ptr);
						error = GIT_ENOTFOUND;
						goto fail;
					}
				}
				if ((flags & GIT_MKDIR_EXCL) != 0) {
					giterr_set(GITERR_OS, "Directory already exists '%s'",
						make_path.ptr);
					error = GIT_EEXISTS;
					goto fail;
				}
			} else {
				giterr_set(GITERR_OS, "Failed to make directory '%s'",
					make_path.ptr);
				goto fail;
			}
324
		}
325

326 327 328 329 330 331 332 333 334 335
		/* chmod if requested */
		if ((flags & GIT_MKDIR_CHMOD_PATH) != 0 ||
			((flags & GIT_MKDIR_CHMOD) != 0 && lastch == '\0'))
		{
			if (p_chmod(make_path.ptr, mode) < 0) {
				giterr_set(GITERR_OS, "Failed to set permissions on '%s'",
					make_path.ptr);
				goto fail;
			}
		}
336

337
		*tail = lastch;
338
	}
339

340
	git_buf_free(&make_path);
341
	return 0;
342

343 344
fail:
	git_buf_free(&make_path);
345
	return error;
346
}
347

348 349 350
int git_futils_mkdir_r(const char *path, const char *base, const mode_t mode)
{
	return git_futils_mkdir(path, base, mode, GIT_MKDIR_PATH);
351 352
}

353
typedef struct {
354
	const char *base;
355 356 357 358 359
	uint32_t flags;
	int error;
} futils__rmdir_data;

static int futils__error_cannot_rmdir(const char *path, const char *filemsg)
360
{
361 362 363 364 365
	if (filemsg)
		giterr_set(GITERR_OS, "Could not remove directory. File '%s' %s",
				   path, filemsg);
	else
		giterr_set(GITERR_OS, "Could not remove directory '%s'", path);
366

367 368
	return -1;
}
369

370 371 372 373 374 375 376 377 378 379
static int futils__rm_first_parent(git_buf *path, const char *ceiling)
{
	int error = GIT_ENOTFOUND;
	struct stat st;

	while (error == GIT_ENOTFOUND) {
		git_buf_rtruncate_at_char(path, '/');

		if (!path->size || git__prefixcmp(path->ptr, ceiling) != 0)
			error = 0;
380
		else if (p_lstat_posixly(path->ptr, &st) == 0) {
381 382 383 384 385 386 387 388 389 390 391 392 393 394
			if (S_ISREG(st.st_mode) || S_ISLNK(st.st_mode))
				error = p_unlink(path->ptr);
			else if (!S_ISDIR(st.st_mode))
				error = -1; /* fail to remove non-regular file */
		} else if (errno != ENOTDIR)
			error = -1;
	}

	if (error)
		futils__error_cannot_rmdir(path->ptr, "cannot remove parent");

	return error;
}

395 396
static int futils__rmdir_recurs_foreach(void *opaque, git_buf *path)
{
397
	struct stat st;
398
	futils__rmdir_data *data = opaque;
399

400
	if ((data->error = p_lstat_posixly(path->ptr, &st)) < 0) {
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
		if (errno == ENOENT)
			data->error = 0;
		else if (errno == ENOTDIR) {
			/* asked to remove a/b/c/d/e and a/b is a normal file */
			if ((data->flags & GIT_RMDIR_REMOVE_BLOCKERS) != 0)
				data->error = futils__rm_first_parent(path, data->base);
			else
				futils__error_cannot_rmdir(
					path->ptr, "parent is not directory");
		}
		else
			futils__error_cannot_rmdir(path->ptr, "cannot access");
	}

	else if (S_ISDIR(st.st_mode)) {
416 417 418 419 420 421 422 423 424 425 426 427
		int error = git_path_direach(path, futils__rmdir_recurs_foreach, data);
		if (error < 0)
			return (error == GIT_EUSER) ? data->error : error;

		data->error = p_rmdir(path->ptr);

		if (data->error < 0) {
			if ((data->flags & GIT_RMDIR_SKIP_NONEMPTY) != 0 &&
				(errno == ENOTEMPTY || errno == EEXIST))
				data->error = 0;
			else
				futils__error_cannot_rmdir(path->ptr, NULL);
428
		}
429 430
	}

431 432
	else if ((data->flags & GIT_RMDIR_REMOVE_FILES) != 0) {
		data->error = p_unlink(path->ptr);
433

434 435
		if (data->error < 0)
			futils__error_cannot_rmdir(path->ptr, "cannot be removed");
436 437
	}

438
	else if ((data->flags & GIT_RMDIR_SKIP_NONEMPTY) == 0)
439
		data->error = futils__error_cannot_rmdir(path->ptr, "still present");
440

441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464
	return data->error;
}

static int futils__rmdir_empty_parent(void *opaque, git_buf *path)
{
	int error = p_rmdir(path->ptr);

	GIT_UNUSED(opaque);

	if (error) {
		int en = errno;

		if (en == ENOENT || en == ENOTDIR) {
			giterr_clear();
			error = 0;
		} else if (en == ENOTEMPTY || en == EEXIST) {
			giterr_clear();
			error = GIT_ITEROVER;
		} else {
			futils__error_cannot_rmdir(path->ptr, NULL);
		}
	}

	return error;
465 466
}

467
int git_futils_rmdir_r(
468
	const char *path, const char *base, uint32_t flags)
469
{
470
	int error;
471
	git_buf fullpath = GIT_BUF_INIT;
472
	futils__rmdir_data data;
473 474 475 476 477

	/* build path and find "root" where we should start calling mkdir */
	if (git_path_join_unrooted(&fullpath, path, base, NULL) < 0)
		return -1;

478
	data.base  = base ? base : "";
479 480 481 482 483 484 485 486 487 488 489 490 491
	data.flags = flags;
	data.error = 0;

	error = futils__rmdir_recurs_foreach(&data, &fullpath);

	/* remove now-empty parents if requested */
	if (!error && (flags & GIT_RMDIR_EMPTY_PARENTS) != 0) {
		error = git_path_walk_up(
			&fullpath, base, futils__rmdir_empty_parent, &data);

		if (error == GIT_ITEROVER)
			error = 0;
	}
492 493

	git_buf_free(&fullpath);
494 495

	return error;
496 497
}

498 499 500 501
int git_futils_find_system_file(git_buf *path, const char *filename)
{
#ifdef GIT_WIN32
	// try to find git.exe/git.cmd on path
502
	if (!win32_find_system_file_using_path(path, filename))
503 504 505
		return 0;

	// try to find msysgit installation path using registry
506
	if (!win32_find_system_file_using_registry(path, filename))
507
		return 0;
508
#else
509 510
	if (git_buf_joinpath(path, "/etc", filename) < 0)
		return -1;
511

512
	if (git_path_exists(path->ptr) == true)
513
		return 0;
514
#endif
515 516

	git_buf_clear(path);
517
	giterr_set(GITERR_OS, "The system file '%s' doesn't exist", filename);
518 519
	return GIT_ENOTFOUND;
}
520

521 522
int git_futils_find_global_file(git_buf *path, const char *filename)
{
523
#ifdef GIT_WIN32
524
	struct win32_path root;
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
	static const wchar_t *tmpls[4] = {
		L"%HOME%\\",
		L"%HOMEDRIVE%%HOMEPATH%\\",
		L"%USERPROFILE%\\",
		NULL,
	};
	const wchar_t **tmpl;

	for (tmpl = tmpls; *tmpl != NULL; tmpl++) {
		/* try to expand environment variable, skipping if not set */
		if (win32_expand_path(&root, *tmpl) != 0 || root.path[0] == L'%')
			continue;

		/* try to look up file under path */
		if (!win32_find_file(path, &root, filename))
540 541
			return 0;

542 543 544 545 546
		/* No error if file not found under %HOME%, b/c we don't trust it,
		 * but do error if another var is set and yet file is not found.
		 */
		if (tmpl != tmpls)
			break;
547 548
	}

549 550
	giterr_set(GITERR_OS, "The global file '%s' doesn't exist", filename);
	git_buf_clear(path);
551

552
	return GIT_ENOTFOUND;
553
#else
554 555
	const char *home = getenv("HOME");

556 557 558
	if (home == NULL) {
		giterr_set(GITERR_OS, "Global file lookup failed. "
			"Cannot locate the user's home directory");
559
		return GIT_ENOTFOUND;
560 561 562 563 564 565
	}

	if (git_buf_joinpath(path, home, filename) < 0)
		return -1;

	if (git_path_exists(path->ptr) == false) {
566
		giterr_set(GITERR_OS, "The global file '%s' doesn't exist", filename);
567 568 569 570 571
		git_buf_clear(path);
		return GIT_ENOTFOUND;
	}

	return 0;
572 573
#endif
}
574 575 576 577 578 579 580 581 582 583 584

int git_futils_fake_symlink(const char *old, const char *new)
{
	int retcode = GIT_ERROR;
	int fd = git_futils_creat_withpath(new, 0755, 0644);
	if (fd >= 0) {
		retcode = p_write(fd, old, strlen(old));
		p_close(fd);
	}
	return retcode;
}
585

586
static int cp_by_fd(int ifd, int ofd, bool close_fd_when_done)
587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
{
	int error = 0;
	char buffer[4096];
	ssize_t len = 0;

	while (!error && (len = p_read(ifd, buffer, sizeof(buffer))) > 0)
		/* p_write() does not have the same semantics as write().  It loops
		 * internally and will return 0 when it has completed writing.
		 */
		error = p_write(ofd, buffer, len);

	if (len < 0) {
		giterr_set(GITERR_OS, "Read error while copying file");
		error = (int)len;
	}

603
	if (close_fd_when_done) {
604 605 606 607 608 609 610
		p_close(ifd);
		p_close(ofd);
	}

	return error;
}

611
int git_futils_cp(const char *from, const char *to, mode_t filemode)
612 613 614 615 616 617 618 619 620 621 622 623 624 625
{
	int ifd, ofd;

	if ((ifd = git_futils_open_ro(from)) < 0)
		return ifd;

	if ((ofd = p_open(to, O_WRONLY | O_CREAT | O_EXCL, filemode)) < 0) {
		if (errno == ENOENT || errno == ENOTDIR)
			ofd = GIT_ENOTFOUND;
		giterr_set(GITERR_OS, "Failed to open '%s' for writing", to);
		p_close(ifd);
		return ofd;
	}

626
	return cp_by_fd(ifd, ofd, true);
627 628
}

629
static int cp_link(const char *from, const char *to, size_t link_size)
630 631 632
{
	int error = 0;
	ssize_t read_len;
633
	char *link_data = git__malloc(link_size + 1);
634 635
	GITERR_CHECK_ALLOC(link_data);

636 637
	read_len = p_readlink(from, link_data, link_size);
	if (read_len != (ssize_t)link_size) {
638 639 640 641 642 643 644 645 646 647 648 649 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
		giterr_set(GITERR_OS, "Failed to read symlink data for '%s'", from);
		error = -1;
	}
	else {
		link_data[read_len] = '\0';

		if (p_symlink(link_data, to) < 0) {
			giterr_set(GITERR_OS, "Could not symlink '%s' as '%s'",
				link_data, to);
			error = -1;
		}
	}

	git__free(link_data);
	return error;
}

typedef struct {
	const char *to_root;
	git_buf to;
	ssize_t from_prefix;
	uint32_t flags;
	uint32_t mkdir_flags;
	mode_t dirmode;
} cp_r_info;

static int _cp_r_callback(void *ref, git_buf *from)
{
	cp_r_info *info = ref;
	struct stat from_st, to_st;
	bool exists = false;

	if ((info->flags & GIT_CPDIR_COPY_DOTFILES) == 0 &&
		from->ptr[git_path_basename_offset(from)] == '.')
		return 0;

	if (git_buf_joinpath(
			&info->to, info->to_root, from->ptr + info->from_prefix) < 0)
		return -1;

	if (p_lstat(info->to.ptr, &to_st) < 0) {
679
		if (errno != ENOENT && errno != ENOTDIR) {
680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737
			giterr_set(GITERR_OS,
				"Could not access %s while copying files", info->to.ptr);
			return -1;
		}
	} else
		exists = true;

	if (git_path_lstat(from->ptr, &from_st) < 0)
		return -1;

	if (S_ISDIR(from_st.st_mode)) {
		int error = 0;
		mode_t oldmode = info->dirmode;

		/* if we are not chmod'ing, then overwrite dirmode */
		if ((info->flags & GIT_CPDIR_CHMOD) == 0)
			info->dirmode = from_st.st_mode;

		/* make directory now if CREATE_EMPTY_DIRS is requested and needed */
		if (!exists && (info->flags & GIT_CPDIR_CREATE_EMPTY_DIRS) != 0)
			error = git_futils_mkdir(
				info->to.ptr, NULL, info->dirmode, info->mkdir_flags);

		/* recurse onto target directory */
		if (!exists || S_ISDIR(to_st.st_mode))
			error = git_path_direach(from, _cp_r_callback, info);

		if (oldmode != 0)
			info->dirmode = oldmode;

		return error;
	}

	if (exists) {
		if ((info->flags & GIT_CPDIR_OVERWRITE) == 0)
			return 0;

		if (p_unlink(info->to.ptr) < 0) {
			giterr_set(GITERR_OS, "Cannot overwrite existing file '%s'",
				info->to.ptr);
			return -1;
		}
	}

	/* Done if this isn't a regular file or a symlink */
	if (!S_ISREG(from_st.st_mode) &&
		(!S_ISLNK(from_st.st_mode) ||
		 (info->flags & GIT_CPDIR_COPY_SYMLINKS) == 0))
		return 0;

	/* Make container directory on demand if needed */
	if ((info->flags & GIT_CPDIR_CREATE_EMPTY_DIRS) == 0 &&
		git_futils_mkdir(
			info->to.ptr, NULL, info->dirmode, info->mkdir_flags) < 0)
		return -1;

	/* make symlink or regular file */
	if (S_ISLNK(from_st.st_mode))
738
		return cp_link(from->ptr, info->to.ptr, (size_t)from_st.st_size);
739
	else
740
		return git_futils_cp(from->ptr, info->to.ptr, from_st.st_mode);
741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
}

int git_futils_cp_r(
	const char *from,
	const char *to,
	uint32_t flags,
	mode_t dirmode)
{
	int error;
	git_buf path = GIT_BUF_INIT;
	cp_r_info info;

	if (git_buf_sets(&path, from) < 0)
		return -1;

	info.to_root = to;
	info.flags   = flags;
	info.dirmode = dirmode;
	info.from_prefix = path.size;
	git_buf_init(&info.to, 0);

	/* precalculate mkdir flags */
	if ((flags & GIT_CPDIR_CREATE_EMPTY_DIRS) == 0) {
		info.mkdir_flags = GIT_MKDIR_PATH | GIT_MKDIR_SKIP_LAST;
		if ((flags & GIT_CPDIR_CHMOD) != 0)
			info.mkdir_flags |= GIT_MKDIR_CHMOD_PATH;
	} else {
		info.mkdir_flags =
			((flags & GIT_CPDIR_CHMOD) != 0) ? GIT_MKDIR_CHMOD : 0;
	}

	error = _cp_r_callback(&info, &path);

	git_buf_free(&path);
Russell Belfer committed
775
	git_buf_free(&info.to);
776 777 778

	return error;
}
779

Vicent Marti committed
780 781
int git_futils_filestamp_check(
	git_futils_filestamp *stamp, const char *path)
782 783 784
{
	struct stat st;

785 786
	/* if the stamp is NULL, then always reload */
	if (stamp == NULL)
787 788 789 790 791
		return 1;

	if (p_stat(path, &st) < 0)
		return GIT_ENOTFOUND;

792 793 794
	if (stamp->mtime == (git_time_t)st.st_mtime &&
		stamp->size  == (git_off_t)st.st_size   &&
		stamp->ino   == (unsigned int)st.st_ino)
795 796
		return 0;

797 798 799
	stamp->mtime = (git_time_t)st.st_mtime;
	stamp->size  = (git_off_t)st.st_size;
	stamp->ino   = (unsigned int)st.st_ino;
800 801 802 803

	return 1;
}

Vicent Marti committed
804 805
void git_futils_filestamp_set(
	git_futils_filestamp *target, const git_futils_filestamp *source)
806 807 808 809 810 811 812 813
{
	assert(target);

	if (source)
		memcpy(target, source, sizeof(*target));
	else
		memset(target, 0, sizeof(*target));
}