fileops.c 17.9 KB
Newer Older
Vicent Marti committed
1
/*
Edward Thomson committed
2
 * Copyright (C) the libgit2 contributors. All rights reserved.
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 = 0;
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
	size_t baselen;
356 357 358 359 360
	uint32_t flags;
	int error;
} futils__rmdir_data;

static int futils__error_cannot_rmdir(const char *path, const char *filemsg)
361
{
362 363 364 365 366
	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);
367

368 369
	return -1;
}
370

371 372 373 374 375 376 377 378 379 380
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;
381
		else if (p_lstat_posixly(path->ptr, &st) == 0) {
382 383 384 385 386 387 388 389 390 391 392 393 394 395
			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;
}

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

401
	if ((data->error = p_lstat_posixly(path->ptr, &st)) < 0) {
402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
		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)) {
417 418 419 420 421 422 423 424 425 426 427 428
		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);
429
		}
430 431
	}

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

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

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

442 443 444 445 446
	return data->error;
}

static int futils__rmdir_empty_parent(void *opaque, git_buf *path)
{
447 448 449 450 451
	futils__rmdir_data *data = opaque;
	int error;

	if (git_buf_len(path) <= data->baselen)
		return GIT_ITEROVER;
452

453
	error = p_rmdir(git_buf_cstr(path));
454 455 456 457 458 459 460 461 462 463 464

	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 {
465
			futils__error_cannot_rmdir(git_buf_cstr(path), NULL);
466 467 468 469
		}
	}

	return error;
470 471
}

472
int git_futils_rmdir_r(
473
	const char *path, const char *base, uint32_t flags)
474
{
475
	int error;
476
	git_buf fullpath = GIT_BUF_INIT;
477
	futils__rmdir_data data;
478 479 480 481 482

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

483 484 485 486
	data.base    = base ? base : "";
	data.baselen = base ? strlen(base) : 0;
	data.flags   = flags;
	data.error   = 0;
487 488 489 490 491 492 493 494 495 496 497

	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;
	}
498 499

	git_buf_free(&fullpath);
500 501

	return error;
502 503
}

504 505 506 507
int git_futils_find_system_file(git_buf *path, const char *filename)
{
#ifdef GIT_WIN32
	// try to find git.exe/git.cmd on path
508
	if (!win32_find_system_file_using_path(path, filename))
509 510 511
		return 0;

	// try to find msysgit installation path using registry
512
	if (!win32_find_system_file_using_registry(path, filename))
513
		return 0;
514
#else
515 516
	if (git_buf_joinpath(path, "/etc", filename) < 0)
		return -1;
517

518
	if (git_path_exists(path->ptr) == true)
519
		return 0;
520
#endif
521 522

	git_buf_clear(path);
523
	giterr_set(GITERR_OS, "The system file '%s' doesn't exist", filename);
524 525
	return GIT_ENOTFOUND;
}
526

527 528
int git_futils_find_global_file(git_buf *path, const char *filename)
{
529
#ifdef GIT_WIN32
530
	struct win32_path root;
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
	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))
546
			return 0;
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));
}