posix_w32.c 20.4 KB
Newer Older
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 8 9

#include "common.h"

10
#include "../posix.h"
Russell Belfer committed
11
#include "../fileops.h"
12
#include "path.h"
13
#include "path_w32.h"
14
#include "utf-conv.h"
15
#include "repository.h"
16
#include "reparse.h"
17 18
#include "global.h"
#include "buffer.h"
Vicent Marti committed
19
#include <errno.h>
20
#include <io.h>
21
#include <fcntl.h>
22
#include <ws2tcpip.h>
Vicent Marti committed
23

24
#ifndef FILE_NAME_NORMALIZED
25 26 27
# define FILE_NAME_NORMALIZED 0
#endif

28 29 30 31
#ifndef IO_REPARSE_TAG_SYMLINK
#define IO_REPARSE_TAG_SYMLINK (0xA000000CL)
#endif

32 33 34 35
#ifndef SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE
# define SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE 0x02
#endif

36 37 38 39
#ifndef SYMBOLIC_LINK_FLAG_DIRECTORY
# define SYMBOLIC_LINK_FLAG_DIRECTORY 0x01
#endif

40 41 42 43 44 45
/* Allowable mode bits on Win32.  Using mode bits that are not supported on
 * Win32 (eg S_IRWXU) is generally ignored, but Wine warns loudly about it
 * so we simply remove them.
 */
#define WIN32_MODE_MASK (_S_IREAD | _S_IWRITE)

46 47
unsigned long git_win32__createfile_sharemode =
 FILE_SHARE_READ | FILE_SHARE_WRITE;
48
int git_win32__retries = 10;
49

50 51 52 53 54 55 56 57 58 59 60 61 62 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 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 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
GIT_INLINE(void) set_errno(void)
{
	switch (GetLastError()) {
	case ERROR_FILE_NOT_FOUND:
	case ERROR_PATH_NOT_FOUND:
	case ERROR_INVALID_DRIVE:
	case ERROR_NO_MORE_FILES:
	case ERROR_BAD_NETPATH:
	case ERROR_BAD_NET_NAME:
	case ERROR_BAD_PATHNAME:
	case ERROR_FILENAME_EXCED_RANGE:
		errno = ENOENT;
		break;
	case ERROR_BAD_ENVIRONMENT:
		errno = E2BIG;
		break;
	case ERROR_BAD_FORMAT:
	case ERROR_INVALID_STARTING_CODESEG:
	case ERROR_INVALID_STACKSEG:
	case ERROR_INVALID_MODULETYPE:
	case ERROR_INVALID_EXE_SIGNATURE:
	case ERROR_EXE_MARKED_INVALID:
	case ERROR_BAD_EXE_FORMAT:
	case ERROR_ITERATED_DATA_EXCEEDS_64k:
	case ERROR_INVALID_MINALLOCSIZE:
	case ERROR_DYNLINK_FROM_INVALID_RING:
	case ERROR_IOPL_NOT_ENABLED:
	case ERROR_INVALID_SEGDPL:
	case ERROR_AUTODATASEG_EXCEEDS_64k:
	case ERROR_RING2SEG_MUST_BE_MOVABLE:
	case ERROR_RELOC_CHAIN_XEEDS_SEGLIM:
	case ERROR_INFLOOP_IN_RELOC_CHAIN:
		errno = ENOEXEC;
		break;
	case ERROR_INVALID_HANDLE:
	case ERROR_INVALID_TARGET_HANDLE:
	case ERROR_DIRECT_ACCESS_HANDLE:
		errno = EBADF;
		break;
	case ERROR_WAIT_NO_CHILDREN:
	case ERROR_CHILD_NOT_COMPLETE:
		errno = ECHILD;
		break;
	case ERROR_NO_PROC_SLOTS:
	case ERROR_MAX_THRDS_REACHED:
	case ERROR_NESTING_NOT_ALLOWED:
		errno = EAGAIN;
		break;
	case ERROR_ARENA_TRASHED:
	case ERROR_NOT_ENOUGH_MEMORY:
	case ERROR_INVALID_BLOCK:
	case ERROR_NOT_ENOUGH_QUOTA:
		errno = ENOMEM;
		break;
	case ERROR_ACCESS_DENIED:
	case ERROR_CURRENT_DIRECTORY:
	case ERROR_WRITE_PROTECT:
	case ERROR_BAD_UNIT:
	case ERROR_NOT_READY:
	case ERROR_BAD_COMMAND:
	case ERROR_CRC:
	case ERROR_BAD_LENGTH:
	case ERROR_SEEK:
	case ERROR_NOT_DOS_DISK:
	case ERROR_SECTOR_NOT_FOUND:
	case ERROR_OUT_OF_PAPER:
	case ERROR_WRITE_FAULT:
	case ERROR_READ_FAULT:
	case ERROR_GEN_FAILURE:
	case ERROR_SHARING_VIOLATION:
	case ERROR_LOCK_VIOLATION:
	case ERROR_WRONG_DISK:
	case ERROR_SHARING_BUFFER_EXCEEDED:
	case ERROR_NETWORK_ACCESS_DENIED:
	case ERROR_CANNOT_MAKE:
	case ERROR_FAIL_I24:
	case ERROR_DRIVE_LOCKED:
	case ERROR_SEEK_ON_DEVICE:
	case ERROR_NOT_LOCKED:
	case ERROR_LOCK_FAILED:
		errno = EACCES;
		break;
	case ERROR_FILE_EXISTS:
	case ERROR_ALREADY_EXISTS:
		errno = EEXIST;
		break;
	case ERROR_NOT_SAME_DEVICE:
		errno = EXDEV;
		break;
	case ERROR_INVALID_FUNCTION:
	case ERROR_INVALID_ACCESS:
	case ERROR_INVALID_DATA:
	case ERROR_INVALID_PARAMETER:
	case ERROR_NEGATIVE_SEEK:
		errno = EINVAL;
		break;
	case ERROR_TOO_MANY_OPEN_FILES:
		errno = EMFILE;
		break;
	case ERROR_DISK_FULL:
		errno = ENOSPC;
		break;
	case ERROR_BROKEN_PIPE:
		errno = EPIPE;
		break;
	case ERROR_DIR_NOT_EMPTY:
		errno = ENOTEMPTY;
		break;
	default:
		errno = EINVAL;
	}
}

163 164 165 166 167 168 169 170
GIT_INLINE(bool) last_error_retryable(void)
{
	int os_error = GetLastError();

	return (os_error == ERROR_SHARING_VIOLATION ||
		os_error == ERROR_ACCESS_DENIED);
}

171
#define do_with_retries(fn, remediation) \
172
	do {                                                             \
173 174
		int __retry, __ret;                                          \
		for (__retry = git_win32__retries; __retry; __retry--) {     \
175 176
			if ((__ret = (fn)) != GIT_RETRY)                         \
				return __ret;                                        \
177 178 179 180 181
			if (__retry > 1 && (__ret = (remediation)) != 0) {       \
				if (__ret == GIT_RETRY)                              \
					continue;                                        \
				return __ret;                                        \
			}                                                        \
182 183 184 185 186
			Sleep(5);                                                \
		}                                                            \
		return -1;                                                   \
	} while (0)                                                      \

187 188 189 190 191 192 193 194 195 196 197 198 199
static int ensure_writable(wchar_t *path)
{
	DWORD attrs;

	if ((attrs = GetFileAttributesW(path)) == INVALID_FILE_ATTRIBUTES)
		goto on_error;

	if ((attrs & FILE_ATTRIBUTE_READONLY) == 0)
		return 0;

	if (!SetFileAttributesW(path, (attrs & ~FILE_ATTRIBUTE_READONLY)))
		goto on_error;

200
	return GIT_RETRY;
201 202 203 204 205 206

on_error:
	set_errno();
	return -1;
}

207 208 209 210 211 212 213
/**
 * Truncate or extend file.
 *
 * We now take a "git_off_t" rather than "long" because
 * files may be longer than 2Gb.
 */
int p_ftruncate(int fd, git_off_t size)
214
{
215 216 217 218 219
	if (size < 0) {
		errno = EINVAL;
		return -1;
	}

220
#if !defined(__MINGW32__) || defined(MINGW_HAS_SECURE_API)
221
	return ((_chsize_s(fd, size) == 0) ? 0 : -1);
222
#else
223
	/* TODO MINGW32 Find a replacement for _chsize() that handles big files. */
224 225 226 227 228
	if (size > INT32_MAX) {
		errno = EFBIG;
		return -1;
	}
	return _chsize(fd, (long)size);
229 230 231
#endif
}

232 233 234 235 236 237
int p_mkdir(const char *path, mode_t mode)
{
	git_win32_path buf;

	GIT_UNUSED(mode);

238
	if (git_win32_path_from_utf8(buf, path) < 0)
239 240 241 242 243
		return -1;

	return _wmkdir(buf);
}

244 245 246 247 248 249 250 251
int p_link(const char *old, const char *new)
{
	GIT_UNUSED(old);
	GIT_UNUSED(new);
	errno = ENOSYS;
	return -1;
}

252 253 254 255 256 257 258 259 260 261 262 263
GIT_INLINE(int) unlink_once(const wchar_t *path)
{
	if (DeleteFileW(path))
		return 0;

	if (last_error_retryable())
		return GIT_RETRY;

	set_errno();
	return -1;
}

Vicent Marti committed
264 265
int p_unlink(const char *path)
{
266
	git_win32_path wpath;
267

268
	if (git_win32_path_from_utf8(wpath, path) < 0)
269 270
		return -1;

271
	do_with_retries(unlink_once(wpath), ensure_writable(wpath));
Vicent Marti committed
272 273 274 275 276 277
}

int p_fsync(int fd)
{
	HANDLE fh = (HANDLE)_get_osfhandle(fd);

278 279
	p_fsync__cnt++;

Vicent Marti committed
280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298
	if (fh == INVALID_HANDLE_VALUE) {
		errno = EBADF;
		return -1;
	}

	if (!FlushFileBuffers(fh)) {
		DWORD code = GetLastError();

		if (code == ERROR_INVALID_HANDLE)
			errno = EINVAL;
		else
			errno = EIO;

		return -1;
	}

	return 0;
}

299 300 301 302 303 304 305 306 307 308
#define WIN32_IS_WSEP(CH) ((CH) == L'/' || (CH) == L'\\')

static int lstat_w(
	wchar_t *path,
	struct stat *buf,
	bool posix_enotdir)
{
	WIN32_FILE_ATTRIBUTE_DATA fdata;

	if (GetFileAttributesExW(path, GetFileExInfoStandard, &fdata)) {
309 310 311
		if (!buf)
			return 0;

312
		return git_win32__file_attribute_to_stat(buf, &fdata, path);
Vicent Marti committed
313 314
	}

315 316 317 318 319 320 321 322
	switch (GetLastError()) {
	case ERROR_ACCESS_DENIED:
		errno = EACCES;
		break;
	default:
		errno = ENOENT;
		break;
	}
323

324 325
	/* To match POSIX behavior, set ENOTDIR when any of the folders in the
	 * file path is a regular file, otherwise set ENOENT.
326
	 */
327
	if (errno == ENOENT && posix_enotdir) {
328 329
		size_t path_len = wcslen(path);

330 331
		/* scan up path until we find an existing item */
		while (1) {
332 333
			DWORD attrs;

334
			/* remove last directory component */
335
			for (path_len--; path_len > 0 && !WIN32_IS_WSEP(path[path_len]); path_len--);
336

337
			if (path_len <= 0)
338 339
				break;

340 341
			path[path_len] = L'\0';
			attrs = GetFileAttributesW(path);
342

343
			if (attrs != INVALID_FILE_ATTRIBUTES) {
344
				if (!(attrs & FILE_ATTRIBUTE_DIRECTORY))
Eduardo Bart committed
345
					errno = ENOTDIR;
346
				break;
347 348 349 350
			}
		}
	}

351
	return -1;
Vicent Marti committed
352 353
}

354
static int do_lstat(const char *path, struct stat *buf, bool posixly_correct)
Vicent Marti committed
355
{
356 357 358
	git_win32_path path_w;
	int len;

359
	if ((len = git_win32_path_from_utf8(path_w, path)) < 0)
360 361
		return -1;

362
	git_win32_path_trim_end(path_w, len);
363 364

	return lstat_w(path_w, buf, posixly_correct);
365
}
Vicent Marti committed
366

367
int p_lstat(const char *filename, struct stat *buf)
368
{
369
	return do_lstat(filename, buf, false);
Vicent Marti committed
370 371
}

372
int p_lstat_posixly(const char *filename, struct stat *buf)
373
{
374
	return do_lstat(filename, buf, true);
375
}
376

377
int p_readlink(const char *path, char *buf, size_t bufsiz)
Vicent Marti committed
378
{
379 380 381 382 383 384 385 386 387 388 389
	git_win32_path path_w, target_w;
	git_win32_utf8_path target;
	int len;

	/* readlink(2) does not NULL-terminate the string written
	 * to the target buffer. Furthermore, the target buffer need
	 * not be large enough to hold the entire result. A truncated
	 * result should be written in this case. Since this truncation
	 * could occur in the middle of the encoding of a code point,
	 * we need to buffer the result on the stack. */

390
	if (git_win32_path_from_utf8(path_w, path) < 0 ||
391
		git_win32_path_readlink_w(target_w, path_w) < 0 ||
392 393
		(len = git_win32_path_to_utf8(target, target_w)) < 0)
		return -1;
394

395 396
	bufsiz = min((size_t)len, bufsiz);
	memcpy(buf, target, bufsiz);
397

398
	return (int)bufsiz;
Vicent Marti committed
399 400
}

401
int p_symlink(const char *target, const char *path)
Ben Straub committed
402
{
403
	git_win32_path target_w, path_w;
404
	DWORD dwFlags;
405 406 407 408 409

	if (git_win32_path_from_utf8(path_w, path) < 0 ||
		git__utf8_to_16(target_w, MAX_PATH, target) < 0)
		return -1;

410
	dwFlags = SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE;
411 412 413 414 415

	if (GetFileAttributesW(target_w) & FILE_ATTRIBUTE_DIRECTORY)
		dwFlags |= SYMBOLIC_LINK_FLAG_DIRECTORY;

	if (!CreateSymbolicLinkW(path_w, target_w, dwFlags))
416 417 418
		return -1;

	return 0;
Ben Straub committed
419 420
}

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 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 465 466 467 468 469 470 471 472 473 474 475
struct open_opts {
	DWORD access;
	DWORD sharing;
	SECURITY_ATTRIBUTES security;
	DWORD creation_disposition;
	DWORD attributes;
	int osf_flags;
};

GIT_INLINE(void) open_opts_from_posix(struct open_opts *opts, int flags, mode_t mode)
{
	memset(opts, 0, sizeof(struct open_opts));

	switch (flags & (O_WRONLY | O_RDWR)) {
	case O_WRONLY:
		opts->access = GENERIC_WRITE;
		break;
	case O_RDWR:
		opts->access = GENERIC_READ | GENERIC_WRITE;
		break;
	default:
		opts->access = GENERIC_READ;
		break;
	}

	opts->sharing = (DWORD)git_win32__createfile_sharemode;

	switch (flags & (O_CREAT | O_TRUNC | O_EXCL)) {
	case O_CREAT | O_EXCL:
	case O_CREAT | O_TRUNC | O_EXCL:
		opts->creation_disposition = CREATE_NEW;
		break;
	case O_CREAT | O_TRUNC:
		opts->creation_disposition = CREATE_ALWAYS;
		break;
	case O_TRUNC:
		opts->creation_disposition = TRUNCATE_EXISTING;
		break;
	case O_CREAT:
		opts->creation_disposition = OPEN_ALWAYS;
		break;
	default:
		opts->creation_disposition = OPEN_EXISTING;
		break;
	}

	opts->attributes = ((flags & O_CREAT) && !(mode & S_IWRITE)) ?
		FILE_ATTRIBUTE_READONLY : FILE_ATTRIBUTE_NORMAL;
	opts->osf_flags = flags & (O_RDONLY | O_APPEND);

	opts->security.nLength = sizeof(SECURITY_ATTRIBUTES);
	opts->security.lpSecurityDescriptor = NULL;
	opts->security.bInheritHandle = 0;
}

476 477
GIT_INLINE(int) open_once(
	const wchar_t *path,
478
	struct open_opts *opts)
479
{
480 481
	int fd;

482 483
	HANDLE handle = CreateFileW(path, opts->access, opts->sharing,
		&opts->security, opts->creation_disposition, opts->attributes, 0);
484

485 486 487 488 489 490 491 492
	if (handle == INVALID_HANDLE_VALUE) {
		if (last_error_retryable())
			return GIT_RETRY;

		set_errno();
		return -1;
	}

493 494 495 496
	if ((fd = _open_osfhandle((intptr_t)handle, opts->osf_flags)) < 0)
		CloseHandle(handle);

	return fd;
497 498
}

499
int p_open(const char *path, int flags, ...)
500
{
501
	git_win32_path wpath;
502
	mode_t mode = 0;
503
	struct open_opts opts = {0};
504

505
	if (git_win32_path_from_utf8(wpath, path) < 0)
506
		return -1;
507

508
	if (flags & O_CREAT) {
509 510 511
		va_list arg_list;

		va_start(arg_list, flags);
liyuray committed
512
		mode = (mode_t)va_arg(arg_list, int);
513 514 515
		va_end(arg_list);
	}

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
	open_opts_from_posix(&opts, flags, mode);

	do_with_retries(
		open_once(wpath, &opts),
		0);
}

int p_creat(const char *path, mode_t mode)
{
	return p_open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
}

int p_utimes(const char *path, const struct p_timeval times[2])
{
	git_win32_path wpath;
	int fd, error;
	DWORD attrs_orig, attrs_new = 0;
	struct open_opts opts = { 0 };

	if (git_win32_path_from_utf8(wpath, path) < 0)
		return -1;

	attrs_orig = GetFileAttributesW(wpath);

	if (attrs_orig & FILE_ATTRIBUTE_READONLY) {
		attrs_new = attrs_orig & ~FILE_ATTRIBUTE_READONLY;

		if (!SetFileAttributesW(wpath, attrs_new)) {
544
			git_error_set(GIT_ERROR_OS, "failed to set attributes");
545 546
			return -1;
		}
547 548
	}

549
	open_opts_from_posix(&opts, O_RDWR, 0);
550

551 552 553
	if ((fd = open_once(wpath, &opts)) < 0) {
		error = -1;
		goto done;
554 555
	}

556 557
	error = p_futimes(fd, times);
	close(fd);
558

559 560 561 562 563 564 565 566
done:
	if (attrs_orig != attrs_new) {
		DWORD os_error = GetLastError();
		SetFileAttributesW(wpath, attrs_orig);
		SetLastError(os_error);
	}

	return error;
567 568
}

569
int p_futimes(int fd, const struct p_timeval times[2])
570
{
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
	HANDLE handle;
	FILETIME atime = { 0 }, mtime = { 0 };

	if (times == NULL) {
		SYSTEMTIME st;

		GetSystemTime(&st);
		SystemTimeToFileTime(&st, &atime);
		SystemTimeToFileTime(&st, &mtime);
	}
	else {
		git_win32__timeval_to_filetime(&atime, times[0]);
		git_win32__timeval_to_filetime(&mtime, times[1]);
	}

	if ((handle = (HANDLE)_get_osfhandle(fd)) == INVALID_HANDLE_VALUE)
		return -1;

	if (SetFileTime(handle, NULL, &atime, &mtime) == 0)
		return -1;

	return 0;
593 594 595 596
}

int p_getcwd(char *buffer_out, size_t size)
{
597 598
	git_win32_path buf;
	wchar_t *cwd = _wgetcwd(buf, GIT_WIN_PATH_UTF16);
599

600
	if (!cwd)
601 602
		return -1;

603 604 605
	/* Convert the working directory back to UTF-8 */
	if (git__utf16_to_8(buffer_out, size, cwd) < 0) {
		DWORD code = GetLastError();
606

607 608 609 610
		if (code == ERROR_INSUFFICIENT_BUFFER)
			errno = ERANGE;
		else
			errno = EINVAL;
611

612 613
		return -1;
	}
614

615
	return 0;
616 617
}

618 619 620 621 622 623 624 625 626 627 628 629 630
static int getfinalpath_w(
	git_win32_path dest,
	const wchar_t *path)
{
	HANDLE hFile;
	DWORD dwChars;

	/* Use FILE_FLAG_BACKUP_SEMANTICS so we can open a directory. Do not
	* specify FILE_FLAG_OPEN_REPARSE_POINT; we want to open a handle to the
	* target of the link. */
	hFile = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE,
		NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);

631
	if (INVALID_HANDLE_VALUE == hFile)
632 633 634
		return -1;

	/* Call GetFinalPathNameByHandle */
635
	dwChars = GetFinalPathNameByHandleW(hFile, dest, GIT_WIN_PATH_UTF16, FILE_NAME_NORMALIZED);
636
	CloseHandle(hFile);
637

638
	if (!dwChars || dwChars >= GIT_WIN_PATH_UTF16)
639 640
		return -1;

641 642
	/* The path may be delivered to us with a namespace prefix; remove */
	return (int)git_win32_path_remove_namespace(dest, dwChars);
643 644 645 646 647 648 649 650 651 652 653 654
}

static int follow_and_lstat_link(git_win32_path path, struct stat* buf)
{
	git_win32_path target_w;

	if (getfinalpath_w(target_w, path) < 0)
		return -1;

	return lstat_w(target_w, buf, false);
}

655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670
int p_fstat(int fd, struct stat *buf)
{
	BY_HANDLE_FILE_INFORMATION fhInfo;

	HANDLE fh = (HANDLE)_get_osfhandle(fd);

	if (fh == INVALID_HANDLE_VALUE ||
		!GetFileInformationByHandle(fh, &fhInfo)) {
		errno = EBADF;
		return -1;
	}

	git_win32__file_information_to_stat(buf, &fhInfo);
	return 0;
}

671 672
int p_stat(const char* path, struct stat* buf)
{
673 674
	git_win32_path path_w;
	int len;
675

676 677
	if ((len = git_win32_path_from_utf8(path_w, path)) < 0 ||
		lstat_w(path_w, buf, false) < 0)
678 679 680 681 682 683 684 685
		return -1;

	/* The item is a symbolic link or mount point. No need to iterate
	 * to follow multiple links; use GetFinalPathNameFromHandle. */
	if (S_ISLNK(buf->st_mode))
		return follow_and_lstat_link(path_w, buf);

	return 0;
686 687 688 689
}

int p_chdir(const char* path)
{
690
	git_win32_path buf;
691

692
	if (git_win32_path_from_utf8(buf, path) < 0)
693 694
		return -1;

695
	return _wchdir(buf);
696 697
}

698
int p_chmod(const char* path, mode_t mode)
699
{
700
	git_win32_path buf;
701

702
	if (git_win32_path_from_utf8(buf, path) < 0)
703 704
		return -1;

705
	return _wchmod(buf, mode);
706 707 708 709
}

int p_rmdir(const char* path)
{
710
	git_win32_path buf;
711 712
	int error;

713
	if (git_win32_path_from_utf8(buf, path) < 0)
714
		return -1;
715 716 717

	error = _wrmdir(buf);

718
	if (error == -1) {
719 720 721 722 723 724 725 726
		switch (GetLastError()) {
			/* _wrmdir() is documented to return EACCES if "A program has an open
			 * handle to the directory."  This sounds like what everybody else calls
			 * EBUSY.  Let's convert appropriate error codes.
			 */
			case ERROR_SHARING_VIOLATION:
				errno = EBUSY;
				break;
727

728 729 730 731 732 733
			/* This error can be returned when trying to rmdir an extant file. */
			case ERROR_DIRECTORY:
				errno = ENOTDIR;
				break;
		}
	}
734

735
	return error;
Vicent Marti committed
736 737
}

738
char *p_realpath(const char *orig_path, char *buffer)
739
{
740
	git_win32_path orig_path_w, buffer_w;
741

742
	if (git_win32_path_from_utf8(orig_path_w, orig_path) < 0)
743
		return NULL;
744

745 746 747 748 749 750 751 752
	/* Note that if the path provided is a relative path, then the current directory
	 * is used to resolve the path -- which is a concurrency issue because the current
	 * directory is a process-wide variable. */
	if (!GetFullPathNameW(orig_path_w, GIT_WIN_PATH_UTF16, buffer_w, NULL)) {
		if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
			errno = ENAMETOOLONG;
		else
			errno = EINVAL;
753

754 755
		return NULL;
	}
756

757
	/* The path must exist. */
758
	if (GetFileAttributesW(buffer_w) == INVALID_FILE_ATTRIBUTES) {
759
		errno = ENOENT;
760
		return NULL;
761
	}
762

763 764 765
	if (!buffer && !(buffer = git__malloc(GIT_WIN_PATH_UTF8))) {
		errno = ENOMEM;
		return NULL;
766 767
	}

768 769 770 771 772 773
	/* Convert the path to UTF-8. If the caller provided a buffer, then it
	 * is assumed to be GIT_WIN_PATH_UTF8 characters in size. If it isn't,
	 * then we may overflow. */
	if (git_win32_path_to_utf8(buffer, buffer_w) < 0)
		return NULL;

774
	git_path_mkposix(buffer);
775

776
	return buffer;
777 778
}

779 780
int p_vsnprintf(char *buffer, size_t count, const char *format, va_list argptr)
{
781
#if defined(_MSC_VER)
782 783
	int len;

784 785 786 787 788 789 790 791 792 793
	if (count == 0)
		return _vscprintf(format, argptr);

	#if _MSC_VER >= 1500
	len = _vsnprintf_s(buffer, count, _TRUNCATE, format, argptr);
	#else
	len = _vsnprintf(buffer, count, format, argptr);
	#endif

	if (len < 0)
794
		return _vscprintf(format, argptr);
795 796

	return len;
797 798 799 800
#else /* MinGW */
	return vsnprintf(buffer, count, format, argptr);
#endif
}
801 802 803 804 805 806 807 808 809 810 811 812

int p_snprintf(char *buffer, size_t count, const char *format, ...)
{
	va_list va;
	int r;

	va_start(va, format);
	r = p_vsnprintf(buffer, count, format, va);
	va_end(va);

	return r;
}
813

814
/* TODO: wut? */
815 816
int p_mkstemp(char *tmp_path)
{
817
#if defined(_MSC_VER) && _MSC_VER >= 1500
818
	if (_mktemp_s(tmp_path, strlen(tmp_path) + 1) != 0)
819
		return -1;
820
#else
Vicent Marti committed
821
	if (_mktemp(tmp_path) == NULL)
822
		return -1;
Vicent Marti committed
823
#endif
824

825
	return p_open(tmp_path, O_RDWR | O_CREAT | O_EXCL, 0744); /* -V536 */
826
}
827

828
int p_access(const char* path, mode_t mode)
829
{
830
	git_win32_path buf;
831

832
	if (git_win32_path_from_utf8(buf, path) < 0)
833 834
		return -1;

835
	return _waccess(buf, mode & WIN32_MODE_MASK);
836
}
837

838 839 840 841 842 843 844 845 846 847
GIT_INLINE(int) rename_once(const wchar_t *from, const wchar_t *to)
{
	if (MoveFileExW(from, to, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED))
		return 0;

	if (last_error_retryable())
		return GIT_RETRY;

	set_errno();
	return -1;
848 849
}

850
int p_rename(const char *from, const char *to)
851
{
852
	git_win32_path wfrom, wto;
853

854 855
	if (git_win32_path_from_utf8(wfrom, from) < 0 ||
		git_win32_path_from_utf8(wto, to) < 0)
856
		return -1;
857

858
	do_with_retries(rename_once(wfrom, wto), ensure_writable(wto));
859
}
860 861 862 863

int p_recv(GIT_SOCKET socket, void *buffer, size_t length, int flags)
{
	if ((size_t)((int)length) != length)
864
		return -1; /* git_error_set will be done by caller */
865 866 867 868 869 870 871

	return recv(socket, buffer, (int)length, flags);
}

int p_send(GIT_SOCKET socket, const void *buffer, size_t length, int flags)
{
	if ((size_t)((int)length) != length)
872
		return -1; /* git_error_set will be done by caller */
873 874 875

	return send(socket, buffer, (int)length, flags);
}
Ben Straub committed
876 877 878 879 880

/**
 * Borrowed from http://old.nabble.com/Porting-localtime_r-and-gmtime_r-td15282276.html
 * On Win32, `gmtime_r` doesn't exist but `gmtime` is threadsafe, so we can use that
 */
Linquize committed
881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903
struct tm *
p_localtime_r (const time_t *timer, struct tm *result)
{
	struct tm *local_result;
	local_result = localtime (timer);

	if (local_result == NULL || result == NULL)
		return NULL;

	memcpy (result, local_result, sizeof (struct tm));
	return result;
}
struct tm *
p_gmtime_r (const time_t *timer, struct tm *result)
{
	struct tm *local_result;
	local_result = gmtime (timer);

	if (local_result == NULL || result == NULL)
		return NULL;

	memcpy (result, local_result, sizeof (struct tm));
	return result;
Ben Straub committed
904 905
}

906
int p_inet_pton(int af, const char *src, void *dst)
907
{
908 909 910 911
	struct sockaddr_storage sin;
	void *addr;
	int sin_len = sizeof(struct sockaddr_storage), addr_len;
	int error = 0;
912

913 914 915 916 917 918 919 920 921
	if (af == AF_INET) {
		addr = &((struct sockaddr_in *)&sin)->sin_addr;
		addr_len = sizeof(struct in_addr);
	} else if (af == AF_INET6) {
		addr = &((struct sockaddr_in6 *)&sin)->sin6_addr;
		addr_len = sizeof(struct in6_addr);
	} else {
		errno = EAFNOSUPPORT;
		return -1;
922 923
	}

924 925 926
	if ((error = WSAStringToAddressA((LPSTR)src, af, NULL, (LPSOCKADDR)&sin, &sin_len)) == 0) {
		memcpy(dst, addr, addr_len);
		return 1;
927 928
	}

929 930 931 932 933 934 935 936 937
	switch(WSAGetLastError()) {
	case WSAEINVAL:
		return 0;
	case WSAEFAULT:
		errno = ENOSPC;
		return -1;
	case WSA_NOT_ENOUGH_MEMORY:
		errno = ENOMEM;
		return -1;
938 939
	}

940 941
	errno = EINVAL;
	return -1;
942
}