PageRenderTime 113ms CodeModel.GetById 3ms app.highlight 95ms RepoModel.GetById 1ms app.codeStats 1ms

/compat/mingw.c

https://bitbucket.org/ssaasen/git
C | 2224 lines | 1832 code | 209 blank | 183 comment | 372 complexity | 8f17c2199ddbe0492148a569693a65db MD5 | raw file

Large files files are truncated, but you can click here to view the full file

   1#include "../git-compat-util.h"
   2#include "win32.h"
   3#include <conio.h>
   4#include <wchar.h>
   5#include "../strbuf.h"
   6#include "../run-command.h"
   7#include "../cache.h"
   8
   9#define HCAST(type, handle) ((type)(intptr_t)handle)
  10
  11static const int delay[] = { 0, 1, 10, 20, 40 };
  12
  13int err_win_to_posix(DWORD winerr)
  14{
  15	int error = ENOSYS;
  16	switch(winerr) {
  17	case ERROR_ACCESS_DENIED: error = EACCES; break;
  18	case ERROR_ACCOUNT_DISABLED: error = EACCES; break;
  19	case ERROR_ACCOUNT_RESTRICTION: error = EACCES; break;
  20	case ERROR_ALREADY_ASSIGNED: error = EBUSY; break;
  21	case ERROR_ALREADY_EXISTS: error = EEXIST; break;
  22	case ERROR_ARITHMETIC_OVERFLOW: error = ERANGE; break;
  23	case ERROR_BAD_COMMAND: error = EIO; break;
  24	case ERROR_BAD_DEVICE: error = ENODEV; break;
  25	case ERROR_BAD_DRIVER_LEVEL: error = ENXIO; break;
  26	case ERROR_BAD_EXE_FORMAT: error = ENOEXEC; break;
  27	case ERROR_BAD_FORMAT: error = ENOEXEC; break;
  28	case ERROR_BAD_LENGTH: error = EINVAL; break;
  29	case ERROR_BAD_PATHNAME: error = ENOENT; break;
  30	case ERROR_BAD_PIPE: error = EPIPE; break;
  31	case ERROR_BAD_UNIT: error = ENODEV; break;
  32	case ERROR_BAD_USERNAME: error = EINVAL; break;
  33	case ERROR_BROKEN_PIPE: error = EPIPE; break;
  34	case ERROR_BUFFER_OVERFLOW: error = ENAMETOOLONG; break;
  35	case ERROR_BUSY: error = EBUSY; break;
  36	case ERROR_BUSY_DRIVE: error = EBUSY; break;
  37	case ERROR_CALL_NOT_IMPLEMENTED: error = ENOSYS; break;
  38	case ERROR_CANNOT_MAKE: error = EACCES; break;
  39	case ERROR_CANTOPEN: error = EIO; break;
  40	case ERROR_CANTREAD: error = EIO; break;
  41	case ERROR_CANTWRITE: error = EIO; break;
  42	case ERROR_CRC: error = EIO; break;
  43	case ERROR_CURRENT_DIRECTORY: error = EACCES; break;
  44	case ERROR_DEVICE_IN_USE: error = EBUSY; break;
  45	case ERROR_DEV_NOT_EXIST: error = ENODEV; break;
  46	case ERROR_DIRECTORY: error = EINVAL; break;
  47	case ERROR_DIR_NOT_EMPTY: error = ENOTEMPTY; break;
  48	case ERROR_DISK_CHANGE: error = EIO; break;
  49	case ERROR_DISK_FULL: error = ENOSPC; break;
  50	case ERROR_DRIVE_LOCKED: error = EBUSY; break;
  51	case ERROR_ENVVAR_NOT_FOUND: error = EINVAL; break;
  52	case ERROR_EXE_MARKED_INVALID: error = ENOEXEC; break;
  53	case ERROR_FILENAME_EXCED_RANGE: error = ENAMETOOLONG; break;
  54	case ERROR_FILE_EXISTS: error = EEXIST; break;
  55	case ERROR_FILE_INVALID: error = ENODEV; break;
  56	case ERROR_FILE_NOT_FOUND: error = ENOENT; break;
  57	case ERROR_GEN_FAILURE: error = EIO; break;
  58	case ERROR_HANDLE_DISK_FULL: error = ENOSPC; break;
  59	case ERROR_INSUFFICIENT_BUFFER: error = ENOMEM; break;
  60	case ERROR_INVALID_ACCESS: error = EACCES; break;
  61	case ERROR_INVALID_ADDRESS: error = EFAULT; break;
  62	case ERROR_INVALID_BLOCK: error = EFAULT; break;
  63	case ERROR_INVALID_DATA: error = EINVAL; break;
  64	case ERROR_INVALID_DRIVE: error = ENODEV; break;
  65	case ERROR_INVALID_EXE_SIGNATURE: error = ENOEXEC; break;
  66	case ERROR_INVALID_FLAGS: error = EINVAL; break;
  67	case ERROR_INVALID_FUNCTION: error = ENOSYS; break;
  68	case ERROR_INVALID_HANDLE: error = EBADF; break;
  69	case ERROR_INVALID_LOGON_HOURS: error = EACCES; break;
  70	case ERROR_INVALID_NAME: error = EINVAL; break;
  71	case ERROR_INVALID_OWNER: error = EINVAL; break;
  72	case ERROR_INVALID_PARAMETER: error = EINVAL; break;
  73	case ERROR_INVALID_PASSWORD: error = EPERM; break;
  74	case ERROR_INVALID_PRIMARY_GROUP: error = EINVAL; break;
  75	case ERROR_INVALID_SIGNAL_NUMBER: error = EINVAL; break;
  76	case ERROR_INVALID_TARGET_HANDLE: error = EIO; break;
  77	case ERROR_INVALID_WORKSTATION: error = EACCES; break;
  78	case ERROR_IO_DEVICE: error = EIO; break;
  79	case ERROR_IO_INCOMPLETE: error = EINTR; break;
  80	case ERROR_LOCKED: error = EBUSY; break;
  81	case ERROR_LOCK_VIOLATION: error = EACCES; break;
  82	case ERROR_LOGON_FAILURE: error = EACCES; break;
  83	case ERROR_MAPPED_ALIGNMENT: error = EINVAL; break;
  84	case ERROR_META_EXPANSION_TOO_LONG: error = E2BIG; break;
  85	case ERROR_MORE_DATA: error = EPIPE; break;
  86	case ERROR_NEGATIVE_SEEK: error = ESPIPE; break;
  87	case ERROR_NOACCESS: error = EFAULT; break;
  88	case ERROR_NONE_MAPPED: error = EINVAL; break;
  89	case ERROR_NOT_ENOUGH_MEMORY: error = ENOMEM; break;
  90	case ERROR_NOT_READY: error = EAGAIN; break;
  91	case ERROR_NOT_SAME_DEVICE: error = EXDEV; break;
  92	case ERROR_NO_DATA: error = EPIPE; break;
  93	case ERROR_NO_MORE_SEARCH_HANDLES: error = EIO; break;
  94	case ERROR_NO_PROC_SLOTS: error = EAGAIN; break;
  95	case ERROR_NO_SUCH_PRIVILEGE: error = EACCES; break;
  96	case ERROR_OPEN_FAILED: error = EIO; break;
  97	case ERROR_OPEN_FILES: error = EBUSY; break;
  98	case ERROR_OPERATION_ABORTED: error = EINTR; break;
  99	case ERROR_OUTOFMEMORY: error = ENOMEM; break;
 100	case ERROR_PASSWORD_EXPIRED: error = EACCES; break;
 101	case ERROR_PATH_BUSY: error = EBUSY; break;
 102	case ERROR_PATH_NOT_FOUND: error = ENOENT; break;
 103	case ERROR_PIPE_BUSY: error = EBUSY; break;
 104	case ERROR_PIPE_CONNECTED: error = EPIPE; break;
 105	case ERROR_PIPE_LISTENING: error = EPIPE; break;
 106	case ERROR_PIPE_NOT_CONNECTED: error = EPIPE; break;
 107	case ERROR_PRIVILEGE_NOT_HELD: error = EACCES; break;
 108	case ERROR_READ_FAULT: error = EIO; break;
 109	case ERROR_SEEK: error = EIO; break;
 110	case ERROR_SEEK_ON_DEVICE: error = ESPIPE; break;
 111	case ERROR_SHARING_BUFFER_EXCEEDED: error = ENFILE; break;
 112	case ERROR_SHARING_VIOLATION: error = EACCES; break;
 113	case ERROR_STACK_OVERFLOW: error = ENOMEM; break;
 114	case ERROR_SWAPERROR: error = ENOENT; break;
 115	case ERROR_TOO_MANY_MODULES: error = EMFILE; break;
 116	case ERROR_TOO_MANY_OPEN_FILES: error = EMFILE; break;
 117	case ERROR_UNRECOGNIZED_MEDIA: error = ENXIO; break;
 118	case ERROR_UNRECOGNIZED_VOLUME: error = ENODEV; break;
 119	case ERROR_WAIT_NO_CHILDREN: error = ECHILD; break;
 120	case ERROR_WRITE_FAULT: error = EIO; break;
 121	case ERROR_WRITE_PROTECT: error = EROFS; break;
 122	}
 123	return error;
 124}
 125
 126static inline int is_file_in_use_error(DWORD errcode)
 127{
 128	switch (errcode) {
 129	case ERROR_SHARING_VIOLATION:
 130	case ERROR_ACCESS_DENIED:
 131		return 1;
 132	}
 133
 134	return 0;
 135}
 136
 137static int read_yes_no_answer(void)
 138{
 139	char answer[1024];
 140
 141	if (fgets(answer, sizeof(answer), stdin)) {
 142		size_t answer_len = strlen(answer);
 143		int got_full_line = 0, c;
 144
 145		/* remove the newline */
 146		if (answer_len >= 2 && answer[answer_len-2] == '\r') {
 147			answer[answer_len-2] = '\0';
 148			got_full_line = 1;
 149		} else if (answer_len >= 1 && answer[answer_len-1] == '\n') {
 150			answer[answer_len-1] = '\0';
 151			got_full_line = 1;
 152		}
 153		/* flush the buffer in case we did not get the full line */
 154		if (!got_full_line)
 155			while ((c = getchar()) != EOF && c != '\n')
 156				;
 157	} else
 158		/* we could not read, return the
 159		 * default answer which is no */
 160		return 0;
 161
 162	if (tolower(answer[0]) == 'y' && !answer[1])
 163		return 1;
 164	if (!strncasecmp(answer, "yes", sizeof(answer)))
 165		return 1;
 166	if (tolower(answer[0]) == 'n' && !answer[1])
 167		return 0;
 168	if (!strncasecmp(answer, "no", sizeof(answer)))
 169		return 0;
 170
 171	/* did not find an answer we understand */
 172	return -1;
 173}
 174
 175static int ask_yes_no_if_possible(const char *format, ...)
 176{
 177	char question[4096];
 178	const char *retry_hook[] = { NULL, NULL, NULL };
 179	va_list args;
 180
 181	va_start(args, format);
 182	vsnprintf(question, sizeof(question), format, args);
 183	va_end(args);
 184
 185	if ((retry_hook[0] = mingw_getenv("GIT_ASK_YESNO"))) {
 186		retry_hook[1] = question;
 187		return !run_command_v_opt(retry_hook, 0);
 188	}
 189
 190	if (!isatty(_fileno(stdin)) || !isatty(_fileno(stderr)))
 191		return 0;
 192
 193	while (1) {
 194		int answer;
 195		fprintf(stderr, "%s (y/n) ", question);
 196
 197		if ((answer = read_yes_no_answer()) >= 0)
 198			return answer;
 199
 200		fprintf(stderr, "Sorry, I did not understand your answer. "
 201				"Please type 'y' or 'n'\n");
 202	}
 203}
 204
 205int mingw_unlink(const char *pathname)
 206{
 207	int ret, tries = 0;
 208	wchar_t wpathname[MAX_PATH];
 209	if (xutftowcs_path(wpathname, pathname) < 0)
 210		return -1;
 211
 212	/* read-only files cannot be removed */
 213	_wchmod(wpathname, 0666);
 214	while ((ret = _wunlink(wpathname)) == -1 && tries < ARRAY_SIZE(delay)) {
 215		if (!is_file_in_use_error(GetLastError()))
 216			break;
 217		/*
 218		 * We assume that some other process had the source or
 219		 * destination file open at the wrong moment and retry.
 220		 * In order to give the other process a higher chance to
 221		 * complete its operation, we give up our time slice now.
 222		 * If we have to retry again, we do sleep a bit.
 223		 */
 224		Sleep(delay[tries]);
 225		tries++;
 226	}
 227	while (ret == -1 && is_file_in_use_error(GetLastError()) &&
 228	       ask_yes_no_if_possible("Unlink of file '%s' failed. "
 229			"Should I try again?", pathname))
 230	       ret = _wunlink(wpathname);
 231	return ret;
 232}
 233
 234static int is_dir_empty(const wchar_t *wpath)
 235{
 236	WIN32_FIND_DATAW findbuf;
 237	HANDLE handle;
 238	wchar_t wbuf[MAX_PATH + 2];
 239	wcscpy(wbuf, wpath);
 240	wcscat(wbuf, L"\\*");
 241	handle = FindFirstFileW(wbuf, &findbuf);
 242	if (handle == INVALID_HANDLE_VALUE)
 243		return GetLastError() == ERROR_NO_MORE_FILES;
 244
 245	while (!wcscmp(findbuf.cFileName, L".") ||
 246			!wcscmp(findbuf.cFileName, L".."))
 247		if (!FindNextFileW(handle, &findbuf)) {
 248			DWORD err = GetLastError();
 249			FindClose(handle);
 250			return err == ERROR_NO_MORE_FILES;
 251		}
 252	FindClose(handle);
 253	return 0;
 254}
 255
 256int mingw_rmdir(const char *pathname)
 257{
 258	int ret, tries = 0;
 259	wchar_t wpathname[MAX_PATH];
 260	if (xutftowcs_path(wpathname, pathname) < 0)
 261		return -1;
 262
 263	while ((ret = _wrmdir(wpathname)) == -1 && tries < ARRAY_SIZE(delay)) {
 264		if (!is_file_in_use_error(GetLastError()))
 265			errno = err_win_to_posix(GetLastError());
 266		if (errno != EACCES)
 267			break;
 268		if (!is_dir_empty(wpathname)) {
 269			errno = ENOTEMPTY;
 270			break;
 271		}
 272		/*
 273		 * We assume that some other process had the source or
 274		 * destination file open at the wrong moment and retry.
 275		 * In order to give the other process a higher chance to
 276		 * complete its operation, we give up our time slice now.
 277		 * If we have to retry again, we do sleep a bit.
 278		 */
 279		Sleep(delay[tries]);
 280		tries++;
 281	}
 282	while (ret == -1 && errno == EACCES && is_file_in_use_error(GetLastError()) &&
 283	       ask_yes_no_if_possible("Deletion of directory '%s' failed. "
 284			"Should I try again?", pathname))
 285	       ret = _wrmdir(wpathname);
 286	return ret;
 287}
 288
 289int mingw_mkdir(const char *path, int mode)
 290{
 291	int ret;
 292	wchar_t wpath[MAX_PATH];
 293	if (xutftowcs_path(wpath, path) < 0)
 294		return -1;
 295	ret = _wmkdir(wpath);
 296	return ret;
 297}
 298
 299int mingw_open (const char *filename, int oflags, ...)
 300{
 301	va_list args;
 302	unsigned mode;
 303	int fd;
 304	wchar_t wfilename[MAX_PATH];
 305
 306	va_start(args, oflags);
 307	mode = va_arg(args, int);
 308	va_end(args);
 309
 310	if (filename && !strcmp(filename, "/dev/null"))
 311		filename = "nul";
 312
 313	if (xutftowcs_path(wfilename, filename) < 0)
 314		return -1;
 315	fd = _wopen(wfilename, oflags, mode);
 316
 317	if (fd < 0 && (oflags & O_ACCMODE) != O_RDONLY && errno == EACCES) {
 318		DWORD attrs = GetFileAttributesW(wfilename);
 319		if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
 320			errno = EISDIR;
 321	}
 322	return fd;
 323}
 324
 325static BOOL WINAPI ctrl_ignore(DWORD type)
 326{
 327	return TRUE;
 328}
 329
 330#undef fgetc
 331int mingw_fgetc(FILE *stream)
 332{
 333	int ch;
 334	if (!isatty(_fileno(stream)))
 335		return fgetc(stream);
 336
 337	SetConsoleCtrlHandler(ctrl_ignore, TRUE);
 338	while (1) {
 339		ch = fgetc(stream);
 340		if (ch != EOF || GetLastError() != ERROR_OPERATION_ABORTED)
 341			break;
 342
 343		/* Ctrl+C was pressed, simulate SIGINT and retry */
 344		mingw_raise(SIGINT);
 345	}
 346	SetConsoleCtrlHandler(ctrl_ignore, FALSE);
 347	return ch;
 348}
 349
 350#undef fopen
 351FILE *mingw_fopen (const char *filename, const char *otype)
 352{
 353	FILE *file;
 354	wchar_t wfilename[MAX_PATH], wotype[4];
 355	if (filename && !strcmp(filename, "/dev/null"))
 356		filename = "nul";
 357	if (xutftowcs_path(wfilename, filename) < 0 ||
 358		xutftowcs(wotype, otype, ARRAY_SIZE(wotype)) < 0)
 359		return NULL;
 360	file = _wfopen(wfilename, wotype);
 361	return file;
 362}
 363
 364FILE *mingw_freopen (const char *filename, const char *otype, FILE *stream)
 365{
 366	FILE *file;
 367	wchar_t wfilename[MAX_PATH], wotype[4];
 368	if (filename && !strcmp(filename, "/dev/null"))
 369		filename = "nul";
 370	if (xutftowcs_path(wfilename, filename) < 0 ||
 371		xutftowcs(wotype, otype, ARRAY_SIZE(wotype)) < 0)
 372		return NULL;
 373	file = _wfreopen(wfilename, wotype, stream);
 374	return file;
 375}
 376
 377#undef fflush
 378int mingw_fflush(FILE *stream)
 379{
 380	int ret = fflush(stream);
 381
 382	/*
 383	 * write() is used behind the scenes of stdio output functions.
 384	 * Since git code does not check for errors after each stdio write
 385	 * operation, it can happen that write() is called by a later
 386	 * stdio function even if an earlier write() call failed. In the
 387	 * case of a pipe whose readable end was closed, only the first
 388	 * call to write() reports EPIPE on Windows. Subsequent write()
 389	 * calls report EINVAL. It is impossible to notice whether this
 390	 * fflush invocation triggered such a case, therefore, we have to
 391	 * catch all EINVAL errors whole-sale.
 392	 */
 393	if (ret && errno == EINVAL)
 394		errno = EPIPE;
 395
 396	return ret;
 397}
 398
 399#undef write
 400ssize_t mingw_write(int fd, const void *buf, size_t len)
 401{
 402	ssize_t result = write(fd, buf, len);
 403
 404	if (result < 0 && errno == EINVAL && buf) {
 405		/* check if fd is a pipe */
 406		HANDLE h = (HANDLE) _get_osfhandle(fd);
 407		if (GetFileType(h) == FILE_TYPE_PIPE)
 408			errno = EPIPE;
 409		else
 410			errno = EINVAL;
 411	}
 412
 413	return result;
 414}
 415
 416int mingw_access(const char *filename, int mode)
 417{
 418	wchar_t wfilename[MAX_PATH];
 419	if (xutftowcs_path(wfilename, filename) < 0)
 420		return -1;
 421	/* X_OK is not supported by the MSVCRT version */
 422	return _waccess(wfilename, mode & ~X_OK);
 423}
 424
 425int mingw_chdir(const char *dirname)
 426{
 427	wchar_t wdirname[MAX_PATH];
 428	if (xutftowcs_path(wdirname, dirname) < 0)
 429		return -1;
 430	return _wchdir(wdirname);
 431}
 432
 433int mingw_chmod(const char *filename, int mode)
 434{
 435	wchar_t wfilename[MAX_PATH];
 436	if (xutftowcs_path(wfilename, filename) < 0)
 437		return -1;
 438	return _wchmod(wfilename, mode);
 439}
 440
 441/*
 442 * The unit of FILETIME is 100-nanoseconds since January 1, 1601, UTC.
 443 * Returns the 100-nanoseconds ("hekto nanoseconds") since the epoch.
 444 */
 445static inline long long filetime_to_hnsec(const FILETIME *ft)
 446{
 447	long long winTime = ((long long)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
 448	/* Windows to Unix Epoch conversion */
 449	return winTime - 116444736000000000LL;
 450}
 451
 452static inline time_t filetime_to_time_t(const FILETIME *ft)
 453{
 454	return (time_t)(filetime_to_hnsec(ft) / 10000000);
 455}
 456
 457/**
 458 * Verifies that safe_create_leading_directories() would succeed.
 459 */
 460static int has_valid_directory_prefix(wchar_t *wfilename)
 461{
 462	int n = wcslen(wfilename);
 463
 464	while (n > 0) {
 465		wchar_t c = wfilename[--n];
 466		DWORD attributes;
 467
 468		if (!is_dir_sep(c))
 469			continue;
 470
 471		wfilename[n] = L'\0';
 472		attributes = GetFileAttributesW(wfilename);
 473		wfilename[n] = c;
 474		if (attributes == FILE_ATTRIBUTE_DIRECTORY ||
 475				attributes == FILE_ATTRIBUTE_DEVICE)
 476			return 1;
 477		if (attributes == INVALID_FILE_ATTRIBUTES)
 478			switch (GetLastError()) {
 479			case ERROR_PATH_NOT_FOUND:
 480				continue;
 481			case ERROR_FILE_NOT_FOUND:
 482				/* This implies parent directory exists. */
 483				return 1;
 484			}
 485		return 0;
 486	}
 487	return 1;
 488}
 489
 490/* We keep the do_lstat code in a separate function to avoid recursion.
 491 * When a path ends with a slash, the stat will fail with ENOENT. In
 492 * this case, we strip the trailing slashes and stat again.
 493 *
 494 * If follow is true then act like stat() and report on the link
 495 * target. Otherwise report on the link itself.
 496 */
 497static int do_lstat(int follow, const char *file_name, struct stat *buf)
 498{
 499	WIN32_FILE_ATTRIBUTE_DATA fdata;
 500	wchar_t wfilename[MAX_PATH];
 501	if (xutftowcs_path(wfilename, file_name) < 0)
 502		return -1;
 503
 504	if (GetFileAttributesExW(wfilename, GetFileExInfoStandard, &fdata)) {
 505		buf->st_ino = 0;
 506		buf->st_gid = 0;
 507		buf->st_uid = 0;
 508		buf->st_nlink = 1;
 509		buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
 510		buf->st_size = fdata.nFileSizeLow |
 511			(((off_t)fdata.nFileSizeHigh)<<32);
 512		buf->st_dev = buf->st_rdev = 0; /* not used by Git */
 513		buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
 514		buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
 515		buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
 516		if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
 517			WIN32_FIND_DATAW findbuf;
 518			HANDLE handle = FindFirstFileW(wfilename, &findbuf);
 519			if (handle != INVALID_HANDLE_VALUE) {
 520				if ((findbuf.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) &&
 521						(findbuf.dwReserved0 == IO_REPARSE_TAG_SYMLINK)) {
 522					if (follow) {
 523						char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
 524						buf->st_size = readlink(file_name, buffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
 525					} else {
 526						buf->st_mode = S_IFLNK;
 527					}
 528					buf->st_mode |= S_IREAD;
 529					if (!(findbuf.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
 530						buf->st_mode |= S_IWRITE;
 531				}
 532				FindClose(handle);
 533			}
 534		}
 535		return 0;
 536	}
 537	switch (GetLastError()) {
 538	case ERROR_ACCESS_DENIED:
 539	case ERROR_SHARING_VIOLATION:
 540	case ERROR_LOCK_VIOLATION:
 541	case ERROR_SHARING_BUFFER_EXCEEDED:
 542		errno = EACCES;
 543		break;
 544	case ERROR_BUFFER_OVERFLOW:
 545		errno = ENAMETOOLONG;
 546		break;
 547	case ERROR_NOT_ENOUGH_MEMORY:
 548		errno = ENOMEM;
 549		break;
 550	case ERROR_PATH_NOT_FOUND:
 551		if (!has_valid_directory_prefix(wfilename)) {
 552			errno = ENOTDIR;
 553			break;
 554		}
 555		/* fallthru */
 556	default:
 557		errno = ENOENT;
 558		break;
 559	}
 560	return -1;
 561}
 562
 563/* We provide our own lstat/fstat functions, since the provided
 564 * lstat/fstat functions are so slow. These stat functions are
 565 * tailored for Git's usage (read: fast), and are not meant to be
 566 * complete. Note that Git stat()s are redirected to mingw_lstat()
 567 * too, since Windows doesn't really handle symlinks that well.
 568 */
 569static int do_stat_internal(int follow, const char *file_name, struct stat *buf)
 570{
 571	int namelen;
 572	char alt_name[PATH_MAX];
 573
 574	if (!do_lstat(follow, file_name, buf))
 575		return 0;
 576
 577	/* if file_name ended in a '/', Windows returned ENOENT;
 578	 * try again without trailing slashes
 579	 */
 580	if (errno != ENOENT)
 581		return -1;
 582
 583	namelen = strlen(file_name);
 584	if (namelen && file_name[namelen-1] != '/')
 585		return -1;
 586	while (namelen && file_name[namelen-1] == '/')
 587		--namelen;
 588	if (!namelen || namelen >= PATH_MAX)
 589		return -1;
 590
 591	memcpy(alt_name, file_name, namelen);
 592	alt_name[namelen] = 0;
 593	return do_lstat(follow, alt_name, buf);
 594}
 595
 596int mingw_lstat(const char *file_name, struct stat *buf)
 597{
 598	return do_stat_internal(0, file_name, buf);
 599}
 600int mingw_stat(const char *file_name, struct stat *buf)
 601{
 602	return do_stat_internal(1, file_name, buf);
 603}
 604
 605int mingw_fstat(int fd, struct stat *buf)
 606{
 607	HANDLE fh = (HANDLE)_get_osfhandle(fd);
 608	BY_HANDLE_FILE_INFORMATION fdata;
 609
 610	if (fh == INVALID_HANDLE_VALUE) {
 611		errno = EBADF;
 612		return -1;
 613	}
 614	/* direct non-file handles to MS's fstat() */
 615	if (GetFileType(fh) != FILE_TYPE_DISK)
 616		return _fstati64(fd, buf);
 617
 618	if (GetFileInformationByHandle(fh, &fdata)) {
 619		buf->st_ino = 0;
 620		buf->st_gid = 0;
 621		buf->st_uid = 0;
 622		buf->st_nlink = 1;
 623		buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
 624		buf->st_size = fdata.nFileSizeLow |
 625			(((off_t)fdata.nFileSizeHigh)<<32);
 626		buf->st_dev = buf->st_rdev = 0; /* not used by Git */
 627		buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
 628		buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
 629		buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
 630		return 0;
 631	}
 632	errno = EBADF;
 633	return -1;
 634}
 635
 636static inline void time_t_to_filetime(time_t t, FILETIME *ft)
 637{
 638	long long winTime = t * 10000000LL + 116444736000000000LL;
 639	ft->dwLowDateTime = winTime;
 640	ft->dwHighDateTime = winTime >> 32;
 641}
 642
 643int mingw_utime (const char *file_name, const struct utimbuf *times)
 644{
 645	FILETIME mft, aft;
 646	int fh, rc;
 647	DWORD attrs;
 648	wchar_t wfilename[MAX_PATH];
 649	if (xutftowcs_path(wfilename, file_name) < 0)
 650		return -1;
 651
 652	/* must have write permission */
 653	attrs = GetFileAttributesW(wfilename);
 654	if (attrs != INVALID_FILE_ATTRIBUTES &&
 655	    (attrs & FILE_ATTRIBUTE_READONLY)) {
 656		/* ignore errors here; open() will report them */
 657		SetFileAttributesW(wfilename, attrs & ~FILE_ATTRIBUTE_READONLY);
 658	}
 659
 660	if ((fh = _wopen(wfilename, O_RDWR | O_BINARY)) < 0) {
 661		rc = -1;
 662		goto revert_attrs;
 663	}
 664
 665	if (times) {
 666		time_t_to_filetime(times->modtime, &mft);
 667		time_t_to_filetime(times->actime, &aft);
 668	} else {
 669		GetSystemTimeAsFileTime(&mft);
 670		aft = mft;
 671	}
 672	if (!SetFileTime((HANDLE)_get_osfhandle(fh), NULL, &aft, &mft)) {
 673		errno = EINVAL;
 674		rc = -1;
 675	} else
 676		rc = 0;
 677	close(fh);
 678
 679revert_attrs:
 680	if (attrs != INVALID_FILE_ATTRIBUTES &&
 681	    (attrs & FILE_ATTRIBUTE_READONLY)) {
 682		/* ignore errors again */
 683		SetFileAttributesW(wfilename, attrs);
 684	}
 685	return rc;
 686}
 687
 688unsigned int sleep (unsigned int seconds)
 689{
 690	Sleep(seconds*1000);
 691	return 0;
 692}
 693
 694char *mingw_mktemp(char *template)
 695{
 696	wchar_t wtemplate[MAX_PATH];
 697	if (xutftowcs_path(wtemplate, template) < 0)
 698		return NULL;
 699	if (!_wmktemp(wtemplate))
 700		return NULL;
 701	if (xwcstoutf(template, wtemplate, strlen(template) + 1) < 0)
 702		return NULL;
 703	return template;
 704}
 705
 706int mkstemp(char *template)
 707{
 708	char *filename = mktemp(template);
 709	if (filename == NULL)
 710		return -1;
 711	return open(filename, O_RDWR | O_CREAT, 0600);
 712}
 713
 714int gettimeofday(struct timeval *tv, void *tz)
 715{
 716	FILETIME ft;
 717	long long hnsec;
 718
 719	GetSystemTimeAsFileTime(&ft);
 720	hnsec = filetime_to_hnsec(&ft);
 721	tv->tv_sec = hnsec / 10000000;
 722	tv->tv_usec = (hnsec % 10000000) / 10;
 723	return 0;
 724}
 725
 726int pipe(int filedes[2])
 727{
 728	HANDLE h[2];
 729
 730	/* this creates non-inheritable handles */
 731	if (!CreatePipe(&h[0], &h[1], NULL, 8192)) {
 732		errno = err_win_to_posix(GetLastError());
 733		return -1;
 734	}
 735	filedes[0] = _open_osfhandle(HCAST(int, h[0]), O_NOINHERIT);
 736	if (filedes[0] < 0) {
 737		CloseHandle(h[0]);
 738		CloseHandle(h[1]);
 739		return -1;
 740	}
 741	filedes[1] = _open_osfhandle(HCAST(int, h[1]), O_NOINHERIT);
 742	if (filedes[1] < 0) {
 743		close(filedes[0]);
 744		CloseHandle(h[1]);
 745		return -1;
 746	}
 747	return 0;
 748}
 749
 750struct tm *gmtime_r(const time_t *timep, struct tm *result)
 751{
 752	/* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
 753	memcpy(result, gmtime(timep), sizeof(struct tm));
 754	return result;
 755}
 756
 757struct tm *localtime_r(const time_t *timep, struct tm *result)
 758{
 759	/* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
 760	memcpy(result, localtime(timep), sizeof(struct tm));
 761	return result;
 762}
 763
 764char *mingw_getcwd(char *pointer, int len)
 765{
 766	wchar_t wpointer[MAX_PATH];
 767	if (!_wgetcwd(wpointer, ARRAY_SIZE(wpointer)))
 768		return NULL;
 769	if (xwcstoutf(pointer, wpointer, len) < 0)
 770		return NULL;
 771	convert_slashes(pointer);
 772	return pointer;
 773}
 774
 775/*
 776 * See http://msdn2.microsoft.com/en-us/library/17w5ykft(vs.71).aspx
 777 * (Parsing C++ Command-Line Arguments)
 778 */
 779static const char *quote_arg(const char *arg)
 780{
 781	/* count chars to quote */
 782	int len = 0, n = 0;
 783	int force_quotes = 0;
 784	char *q, *d;
 785	const char *p = arg;
 786	if (!*p) force_quotes = 1;
 787	while (*p) {
 788		if (isspace(*p) || *p == '*' || *p == '?' || *p == '{' || *p == '\'')
 789			force_quotes = 1;
 790		else if (*p == '"')
 791			n++;
 792		else if (*p == '\\') {
 793			int count = 0;
 794			while (*p == '\\') {
 795				count++;
 796				p++;
 797				len++;
 798			}
 799			if (*p == '"')
 800				n += count*2 + 1;
 801			continue;
 802		}
 803		len++;
 804		p++;
 805	}
 806	if (!force_quotes && n == 0)
 807		return arg;
 808
 809	/* insert \ where necessary */
 810	d = q = xmalloc(st_add3(len, n, 3));
 811	*d++ = '"';
 812	while (*arg) {
 813		if (*arg == '"')
 814			*d++ = '\\';
 815		else if (*arg == '\\') {
 816			int count = 0;
 817			while (*arg == '\\') {
 818				count++;
 819				*d++ = *arg++;
 820			}
 821			if (*arg == '"') {
 822				while (count-- > 0)
 823					*d++ = '\\';
 824				*d++ = '\\';
 825			}
 826		}
 827		*d++ = *arg++;
 828	}
 829	*d++ = '"';
 830	*d++ = 0;
 831	return q;
 832}
 833
 834static const char *parse_interpreter(const char *cmd)
 835{
 836	static char buf[100];
 837	char *p, *opt;
 838	int n, fd;
 839
 840	/* don't even try a .exe */
 841	n = strlen(cmd);
 842	if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
 843		return NULL;
 844
 845	fd = open(cmd, O_RDONLY);
 846	if (fd < 0)
 847		return NULL;
 848	n = read(fd, buf, sizeof(buf)-1);
 849	close(fd);
 850	if (n < 4)	/* at least '#!/x' and not error */
 851		return NULL;
 852
 853	if (buf[0] != '#' || buf[1] != '!')
 854		return NULL;
 855	buf[n] = '\0';
 856	p = buf + strcspn(buf, "\r\n");
 857	if (!*p)
 858		return NULL;
 859
 860	*p = '\0';
 861	if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
 862		return NULL;
 863	/* strip options */
 864	if ((opt = strchr(p+1, ' ')))
 865		*opt = '\0';
 866	return p+1;
 867}
 868
 869/*
 870 * Splits the PATH into parts.
 871 */
 872static char **get_path_split(void)
 873{
 874	char *p, **path, *envpath = mingw_getenv("PATH");
 875	int i, n = 0;
 876
 877	if (!envpath || !*envpath)
 878		return NULL;
 879
 880	envpath = xstrdup(envpath);
 881	p = envpath;
 882	while (p) {
 883		char *dir = p;
 884		p = strchr(p, ';');
 885		if (p) *p++ = '\0';
 886		if (*dir) {	/* not earlier, catches series of ; */
 887			++n;
 888		}
 889	}
 890	if (!n)
 891		return NULL;
 892
 893	ALLOC_ARRAY(path, n + 1);
 894	p = envpath;
 895	i = 0;
 896	do {
 897		if (*p)
 898			path[i++] = xstrdup(p);
 899		p = p+strlen(p)+1;
 900	} while (i < n);
 901	path[i] = NULL;
 902
 903	free(envpath);
 904
 905	return path;
 906}
 907
 908static void free_path_split(char **path)
 909{
 910	char **p = path;
 911
 912	if (!path)
 913		return;
 914
 915	while (*p)
 916		free(*p++);
 917	free(path);
 918}
 919
 920/*
 921 * exe_only means that we only want to detect .exe files, but not scripts
 922 * (which do not have an extension)
 923 */
 924static char *lookup_prog(const char *dir, const char *cmd, int isexe, int exe_only)
 925{
 926	char path[MAX_PATH];
 927	snprintf(path, sizeof(path), "%s/%s.exe", dir, cmd);
 928
 929	if (!isexe && access(path, F_OK) == 0)
 930		return xstrdup(path);
 931	path[strlen(path)-4] = '\0';
 932	if ((!exe_only || isexe) && access(path, F_OK) == 0)
 933		if (!(GetFileAttributes(path) & FILE_ATTRIBUTE_DIRECTORY))
 934			return xstrdup(path);
 935	return NULL;
 936}
 937
 938/*
 939 * Determines the absolute path of cmd using the split path in path.
 940 * If cmd contains a slash or backslash, no lookup is performed.
 941 */
 942static char *path_lookup(const char *cmd, char **path, int exe_only)
 943{
 944	char *prog = NULL;
 945	int len = strlen(cmd);
 946	int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");
 947
 948	if (strchr(cmd, '/') || strchr(cmd, '\\'))
 949		prog = xstrdup(cmd);
 950
 951	while (!prog && *path)
 952		prog = lookup_prog(*path++, cmd, isexe, exe_only);
 953
 954	return prog;
 955}
 956
 957static int do_putenv(char **env, const char *name, int size, int free_old);
 958
 959/* used number of elements of environ array, including terminating NULL */
 960static int environ_size = 0;
 961/* allocated size of environ array, in bytes */
 962static int environ_alloc = 0;
 963
 964/*
 965 * Create environment block suitable for CreateProcess. Merges current
 966 * process environment and the supplied environment changes.
 967 */
 968static wchar_t *make_environment_block(char **deltaenv)
 969{
 970	wchar_t *wenvblk = NULL;
 971	char **tmpenv;
 972	int i = 0, size = environ_size, wenvsz = 0, wenvpos = 0;
 973
 974	while (deltaenv && deltaenv[i])
 975		i++;
 976
 977	/* copy the environment, leaving space for changes */
 978	ALLOC_ARRAY(tmpenv, size + i);
 979	memcpy(tmpenv, environ, size * sizeof(char*));
 980
 981	/* merge supplied environment changes into the temporary environment */
 982	for (i = 0; deltaenv && deltaenv[i]; i++)
 983		size = do_putenv(tmpenv, deltaenv[i], size, 0);
 984
 985	/* create environment block from temporary environment */
 986	for (i = 0; tmpenv[i]; i++) {
 987		size = 2 * strlen(tmpenv[i]) + 2; /* +2 for final \0 */
 988		ALLOC_GROW(wenvblk, (wenvpos + size) * sizeof(wchar_t), wenvsz);
 989		wenvpos += xutftowcs(&wenvblk[wenvpos], tmpenv[i], size) + 1;
 990	}
 991	/* add final \0 terminator */
 992	wenvblk[wenvpos] = 0;
 993	free(tmpenv);
 994	return wenvblk;
 995}
 996
 997struct pinfo_t {
 998	struct pinfo_t *next;
 999	pid_t pid;
1000	HANDLE proc;
1001};
1002static struct pinfo_t *pinfo = NULL;
1003CRITICAL_SECTION pinfo_cs;
1004
1005static pid_t mingw_spawnve_fd(const char *cmd, const char **argv, char **deltaenv,
1006			      const char *dir,
1007			      int prepend_cmd, int fhin, int fhout, int fherr)
1008{
1009	STARTUPINFOW si;
1010	PROCESS_INFORMATION pi;
1011	struct strbuf args;
1012	wchar_t wcmd[MAX_PATH], wdir[MAX_PATH], *wargs, *wenvblk = NULL;
1013	unsigned flags = CREATE_UNICODE_ENVIRONMENT;
1014	BOOL ret;
1015
1016	/* Determine whether or not we are associated to a console */
1017	HANDLE cons = CreateFile("CONOUT$", GENERIC_WRITE,
1018			FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1019			FILE_ATTRIBUTE_NORMAL, NULL);
1020	if (cons == INVALID_HANDLE_VALUE) {
1021		/* There is no console associated with this process.
1022		 * Since the child is a console process, Windows
1023		 * would normally create a console window. But
1024		 * since we'll be redirecting std streams, we do
1025		 * not need the console.
1026		 * It is necessary to use DETACHED_PROCESS
1027		 * instead of CREATE_NO_WINDOW to make ssh
1028		 * recognize that it has no console.
1029		 */
1030		flags |= DETACHED_PROCESS;
1031	} else {
1032		/* There is already a console. If we specified
1033		 * DETACHED_PROCESS here, too, Windows would
1034		 * disassociate the child from the console.
1035		 * The same is true for CREATE_NO_WINDOW.
1036		 * Go figure!
1037		 */
1038		CloseHandle(cons);
1039	}
1040	memset(&si, 0, sizeof(si));
1041	si.cb = sizeof(si);
1042	si.dwFlags = STARTF_USESTDHANDLES;
1043	si.hStdInput = winansi_get_osfhandle(fhin);
1044	si.hStdOutput = winansi_get_osfhandle(fhout);
1045	si.hStdError = winansi_get_osfhandle(fherr);
1046
1047	if (xutftowcs_path(wcmd, cmd) < 0)
1048		return -1;
1049	if (dir && xutftowcs_path(wdir, dir) < 0)
1050		return -1;
1051
1052	/* concatenate argv, quoting args as we go */
1053	strbuf_init(&args, 0);
1054	if (prepend_cmd) {
1055		char *quoted = (char *)quote_arg(cmd);
1056		strbuf_addstr(&args, quoted);
1057		if (quoted != cmd)
1058			free(quoted);
1059	}
1060	for (; *argv; argv++) {
1061		char *quoted = (char *)quote_arg(*argv);
1062		if (*args.buf)
1063			strbuf_addch(&args, ' ');
1064		strbuf_addstr(&args, quoted);
1065		if (quoted != *argv)
1066			free(quoted);
1067	}
1068
1069	ALLOC_ARRAY(wargs, st_add(st_mult(2, args.len), 1));
1070	xutftowcs(wargs, args.buf, 2 * args.len + 1);
1071	strbuf_release(&args);
1072
1073	wenvblk = make_environment_block(deltaenv);
1074
1075	memset(&pi, 0, sizeof(pi));
1076	ret = CreateProcessW(wcmd, wargs, NULL, NULL, TRUE, flags,
1077		wenvblk, dir ? wdir : NULL, &si, &pi);
1078
1079	free(wenvblk);
1080	free(wargs);
1081
1082	if (!ret) {
1083		errno = ENOENT;
1084		return -1;
1085	}
1086	CloseHandle(pi.hThread);
1087
1088	/*
1089	 * The process ID is the human-readable identifier of the process
1090	 * that we want to present in log and error messages. The handle
1091	 * is not useful for this purpose. But we cannot close it, either,
1092	 * because it is not possible to turn a process ID into a process
1093	 * handle after the process terminated.
1094	 * Keep the handle in a list for waitpid.
1095	 */
1096	EnterCriticalSection(&pinfo_cs);
1097	{
1098		struct pinfo_t *info = xmalloc(sizeof(struct pinfo_t));
1099		info->pid = pi.dwProcessId;
1100		info->proc = pi.hProcess;
1101		info->next = pinfo;
1102		pinfo = info;
1103	}
1104	LeaveCriticalSection(&pinfo_cs);
1105
1106	return (pid_t)pi.dwProcessId;
1107}
1108
1109static pid_t mingw_spawnv(const char *cmd, const char **argv, int prepend_cmd)
1110{
1111	return mingw_spawnve_fd(cmd, argv, NULL, NULL, prepend_cmd, 0, 1, 2);
1112}
1113
1114pid_t mingw_spawnvpe(const char *cmd, const char **argv, char **deltaenv,
1115		     const char *dir,
1116		     int fhin, int fhout, int fherr)
1117{
1118	pid_t pid;
1119	char **path = get_path_split();
1120	char *prog = path_lookup(cmd, path, 0);
1121
1122	if (!prog) {
1123		errno = ENOENT;
1124		pid = -1;
1125	}
1126	else {
1127		const char *interpr = parse_interpreter(prog);
1128
1129		if (interpr) {
1130			const char *argv0 = argv[0];
1131			char *iprog = path_lookup(interpr, path, 1);
1132			argv[0] = prog;
1133			if (!iprog) {
1134				errno = ENOENT;
1135				pid = -1;
1136			}
1137			else {
1138				pid = mingw_spawnve_fd(iprog, argv, deltaenv, dir, 1,
1139						       fhin, fhout, fherr);
1140				free(iprog);
1141			}
1142			argv[0] = argv0;
1143		}
1144		else
1145			pid = mingw_spawnve_fd(prog, argv, deltaenv, dir, 0,
1146					       fhin, fhout, fherr);
1147		free(prog);
1148	}
1149	free_path_split(path);
1150	return pid;
1151}
1152
1153static int try_shell_exec(const char *cmd, char *const *argv)
1154{
1155	const char *interpr = parse_interpreter(cmd);
1156	char **path;
1157	char *prog;
1158	int pid = 0;
1159
1160	if (!interpr)
1161		return 0;
1162	path = get_path_split();
1163	prog = path_lookup(interpr, path, 1);
1164	if (prog) {
1165		int argc = 0;
1166		const char **argv2;
1167		while (argv[argc]) argc++;
1168		ALLOC_ARRAY(argv2, argc + 1);
1169		argv2[0] = (char *)cmd;	/* full path to the script file */
1170		memcpy(&argv2[1], &argv[1], sizeof(*argv) * argc);
1171		pid = mingw_spawnv(prog, argv2, 1);
1172		if (pid >= 0) {
1173			int status;
1174			if (waitpid(pid, &status, 0) < 0)
1175				status = 255;
1176			exit(status);
1177		}
1178		pid = 1;	/* indicate that we tried but failed */
1179		free(prog);
1180		free(argv2);
1181	}
1182	free_path_split(path);
1183	return pid;
1184}
1185
1186int mingw_execv(const char *cmd, char *const *argv)
1187{
1188	/* check if git_command is a shell script */
1189	if (!try_shell_exec(cmd, argv)) {
1190		int pid, status;
1191
1192		pid = mingw_spawnv(cmd, (const char **)argv, 0);
1193		if (pid < 0)
1194			return -1;
1195		if (waitpid(pid, &status, 0) < 0)
1196			status = 255;
1197		exit(status);
1198	}
1199	return -1;
1200}
1201
1202int mingw_execvp(const char *cmd, char *const *argv)
1203{
1204	char **path = get_path_split();
1205	char *prog = path_lookup(cmd, path, 0);
1206
1207	if (prog) {
1208		mingw_execv(prog, argv);
1209		free(prog);
1210	} else
1211		errno = ENOENT;
1212
1213	free_path_split(path);
1214	return -1;
1215}
1216
1217int mingw_kill(pid_t pid, int sig)
1218{
1219	if (pid > 0 && sig == SIGTERM) {
1220		HANDLE h = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
1221
1222		if (TerminateProcess(h, -1)) {
1223			CloseHandle(h);
1224			return 0;
1225		}
1226
1227		errno = err_win_to_posix(GetLastError());
1228		CloseHandle(h);
1229		return -1;
1230	} else if (pid > 0 && sig == 0) {
1231		HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
1232		if (h) {
1233			CloseHandle(h);
1234			return 0;
1235		}
1236	}
1237
1238	errno = EINVAL;
1239	return -1;
1240}
1241
1242/*
1243 * Compare environment entries by key (i.e. stopping at '=' or '\0').
1244 */
1245static int compareenv(const void *v1, const void *v2)
1246{
1247	const char *e1 = *(const char**)v1;
1248	const char *e2 = *(const char**)v2;
1249
1250	for (;;) {
1251		int c1 = *e1++;
1252		int c2 = *e2++;
1253		c1 = (c1 == '=') ? 0 : tolower(c1);
1254		c2 = (c2 == '=') ? 0 : tolower(c2);
1255		if (c1 > c2)
1256			return 1;
1257		if (c1 < c2)
1258			return -1;
1259		if (c1 == 0)
1260			return 0;
1261	}
1262}
1263
1264static int bsearchenv(char **env, const char *name, size_t size)
1265{
1266	unsigned low = 0, high = size;
1267	while (low < high) {
1268		unsigned mid = low + ((high - low) >> 1);
1269		int cmp = compareenv(&env[mid], &name);
1270		if (cmp < 0)
1271			low = mid + 1;
1272		else if (cmp > 0)
1273			high = mid;
1274		else
1275			return mid;
1276	}
1277	return ~low; /* not found, return 1's complement of insert position */
1278}
1279
1280/*
1281 * If name contains '=', then sets the variable, otherwise it unsets it
1282 * Size includes the terminating NULL. Env must have room for size + 1 entries
1283 * (in case of insert). Returns the new size. Optionally frees removed entries.
1284 */
1285static int do_putenv(char **env, const char *name, int size, int free_old)
1286{
1287	int i = bsearchenv(env, name, size - 1);
1288
1289	/* optionally free removed / replaced entry */
1290	if (i >= 0 && free_old)
1291		free(env[i]);
1292
1293	if (strchr(name, '=')) {
1294		/* if new value ('key=value') is specified, insert or replace entry */
1295		if (i < 0) {
1296			i = ~i;
1297			memmove(&env[i + 1], &env[i], (size - i) * sizeof(char*));
1298			size++;
1299		}
1300		env[i] = (char*) name;
1301	} else if (i >= 0) {
1302		/* otherwise ('key') remove existing entry */
1303		size--;
1304		memmove(&env[i], &env[i + 1], (size - i) * sizeof(char*));
1305	}
1306	return size;
1307}
1308
1309char *mingw_getenv(const char *name)
1310{
1311	char *value;
1312	int pos = bsearchenv(environ, name, environ_size - 1);
1313	if (pos < 0)
1314		return NULL;
1315	value = strchr(environ[pos], '=');
1316	return value ? &value[1] : NULL;
1317}
1318
1319int mingw_putenv(const char *namevalue)
1320{
1321	ALLOC_GROW(environ, (environ_size + 1) * sizeof(char*), environ_alloc);
1322	environ_size = do_putenv(environ, namevalue, environ_size, 1);
1323	return 0;
1324}
1325
1326/*
1327 * Note, this isn't a complete replacement for getaddrinfo. It assumes
1328 * that service contains a numerical port, or that it is null. It
1329 * does a simple search using gethostbyname, and returns one IPv4 host
1330 * if one was found.
1331 */
1332static int WSAAPI getaddrinfo_stub(const char *node, const char *service,
1333				   const struct addrinfo *hints,
1334				   struct addrinfo **res)
1335{
1336	struct hostent *h = NULL;
1337	struct addrinfo *ai;
1338	struct sockaddr_in *sin;
1339
1340	if (node) {
1341		h = gethostbyname(node);
1342		if (!h)
1343			return WSAGetLastError();
1344	}
1345
1346	ai = xmalloc(sizeof(struct addrinfo));
1347	*res = ai;
1348	ai->ai_flags = 0;
1349	ai->ai_family = AF_INET;
1350	ai->ai_socktype = hints ? hints->ai_socktype : 0;
1351	switch (ai->ai_socktype) {
1352	case SOCK_STREAM:
1353		ai->ai_protocol = IPPROTO_TCP;
1354		break;
1355	case SOCK_DGRAM:
1356		ai->ai_protocol = IPPROTO_UDP;
1357		break;
1358	default:
1359		ai->ai_protocol = 0;
1360		break;
1361	}
1362	ai->ai_addrlen = sizeof(struct sockaddr_in);
1363	if (hints && (hints->ai_flags & AI_CANONNAME))
1364		ai->ai_canonname = h ? xstrdup(h->h_name) : NULL;
1365	else
1366		ai->ai_canonname = NULL;
1367
1368	sin = xcalloc(1, ai->ai_addrlen);
1369	sin->sin_family = AF_INET;
1370	/* Note: getaddrinfo is supposed to allow service to be a string,
1371	 * which should be looked up using getservbyname. This is
1372	 * currently not implemented */
1373	if (service)
1374		sin->sin_port = htons(atoi(service));
1375	if (h)
1376		sin->sin_addr = *(struct in_addr *)h->h_addr;
1377	else if (hints && (hints->ai_flags & AI_PASSIVE))
1378		sin->sin_addr.s_addr = INADDR_ANY;
1379	else
1380		sin->sin_addr.s_addr = INADDR_LOOPBACK;
1381	ai->ai_addr = (struct sockaddr *)sin;
1382	ai->ai_next = NULL;
1383	return 0;
1384}
1385
1386static void WSAAPI freeaddrinfo_stub(struct addrinfo *res)
1387{
1388	free(res->ai_canonname);
1389	free(res->ai_addr);
1390	free(res);
1391}
1392
1393static int WSAAPI getnameinfo_stub(const struct sockaddr *sa, socklen_t salen,
1394				   char *host, DWORD hostlen,
1395				   char *serv, DWORD servlen, int flags)
1396{
1397	const struct sockaddr_in *sin = (const struct sockaddr_in *)sa;
1398	if (sa->sa_family != AF_INET)
1399		return EAI_FAMILY;
1400	if (!host && !serv)
1401		return EAI_NONAME;
1402
1403	if (host && hostlen > 0) {
1404		struct hostent *ent = NULL;
1405		if (!(flags & NI_NUMERICHOST))
1406			ent = gethostbyaddr((const char *)&sin->sin_addr,
1407					    sizeof(sin->sin_addr), AF_INET);
1408
1409		if (ent)
1410			snprintf(host, hostlen, "%s", ent->h_name);
1411		else if (flags & NI_NAMEREQD)
1412			return EAI_NONAME;
1413		else
1414			snprintf(host, hostlen, "%s", inet_ntoa(sin->sin_addr));
1415	}
1416
1417	if (serv && servlen > 0) {
1418		struct servent *ent = NULL;
1419		if (!(flags & NI_NUMERICSERV))
1420			ent = getservbyport(sin->sin_port,
1421					    flags & NI_DGRAM ? "udp" : "tcp");
1422
1423		if (ent)
1424			snprintf(serv, servlen, "%s", ent->s_name);
1425		else
1426			snprintf(serv, servlen, "%d", ntohs(sin->sin_port));
1427	}
1428
1429	return 0;
1430}
1431
1432static HMODULE ipv6_dll = NULL;
1433static void (WSAAPI *ipv6_freeaddrinfo)(struct addrinfo *res);
1434static int (WSAAPI *ipv6_getaddrinfo)(const char *node, const char *service,
1435				      const struct addrinfo *hints,
1436				      struct addrinfo **res);
1437static int (WSAAPI *ipv6_getnameinfo)(const struct sockaddr *sa, socklen_t salen,
1438				      char *host, DWORD hostlen,
1439				      char *serv, DWORD servlen, int flags);
1440/*
1441 * gai_strerror is an inline function in the ws2tcpip.h header, so we
1442 * don't need to try to load that one dynamically.
1443 */
1444
1445static void socket_cleanup(void)
1446{
1447	WSACleanup();
1448	if (ipv6_dll)
1449		FreeLibrary(ipv6_dll);
1450	ipv6_dll = NULL;
1451	ipv6_freeaddrinfo = freeaddrinfo_stub;
1452	ipv6_getaddrinfo = getaddrinfo_stub;
1453	ipv6_getnameinfo = getnameinfo_stub;
1454}
1455
1456static void ensure_socket_initialization(void)
1457{
1458	WSADATA wsa;
1459	static int initialized = 0;
1460	const char *libraries[] = { "ws2_32.dll", "wship6.dll", NULL };
1461	const char **name;
1462
1463	if (initialized)
1464		return;
1465
1466	if (WSAStartup(MAKEWORD(2,2), &wsa))
1467		die("unable to initialize winsock subsystem, error %d",
1468			WSAGetLastError());
1469
1470	for (name = libraries; *name; name++) {
1471		ipv6_dll = LoadLibrary(*name);
1472		if (!ipv6_dll)
1473			continue;
1474
1475		ipv6_freeaddrinfo = (void (WSAAPI *)(struct addrinfo *))
1476			GetProcAddress(ipv6_dll, "freeaddrinfo");
1477		ipv6_getaddrinfo = (int (WSAAPI *)(const char *, const char *,
1478						   const struct addrinfo *,
1479						   struct addrinfo **))
1480			GetProcAddress(ipv6_dll, "getaddrinfo");
1481		ipv6_getnameinfo = (int (WSAAPI *)(const struct sockaddr *,
1482						   socklen_t, char *, DWORD,
1483						   char *, DWORD, int))
1484			GetProcAddress(ipv6_dll, "getnameinfo");
1485		if (!ipv6_freeaddrinfo || !ipv6_getaddrinfo || !ipv6_getnameinfo) {
1486			FreeLibrary(ipv6_dll);
1487			ipv6_dll = NULL;
1488		} else
1489			break;
1490	}
1491	if (!ipv6_freeaddrinfo || !ipv6_getaddrinfo || !ipv6_getnameinfo) {
1492		ipv6_freeaddrinfo = freeaddrinfo_stub;
1493		ipv6_getaddrinfo = getaddrinfo_stub;
1494		ipv6_getnameinfo = getnameinfo_stub;
1495	}
1496
1497	atexit(socket_cleanup);
1498	initialized = 1;
1499}
1500
1501#undef gethostname
1502int mingw_gethostname(char *name, int namelen)
1503{
1504    ensure_socket_initialization();
1505    return gethostname(name, namelen);
1506}
1507
1508#undef gethostbyname
1509struct hostent *mingw_gethostbyname(const char *host)
1510{
1511	ensure_socket_initialization();
1512	return gethostbyname(host);
1513}
1514
1515void mingw_freeaddrinfo(struct addrinfo *res)
1516{
1517	ipv6_freeaddrinfo(res);
1518}
1519
1520int mingw_getaddrinfo(const char *node, const char *service,
1521		      const struct addrinfo *hints, struct addrinfo **res)
1522{
1523	ensure_socket_initialization();
1524	return ipv6_getaddrinfo(node, service, hints, res);
1525}
1526
1527int mingw_getnameinfo(const struct sockaddr *sa, socklen_t salen,
1528		      char *host, DWORD hostlen, char *serv, DWORD servlen,
1529		      int flags)
1530{
1531	ensure_socket_initialization();
1532	return ipv6_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
1533}
1534
1535int mingw_socket(int domain, int type, int protocol)
1536{
1537	int sockfd;
1538	SOCKET s;
1539
1540	ensure_socket_initialization();
1541	s = WSASocket(domain, type, protocol, NULL, 0, 0);
1542	if (s == INVALID_SOCKET) {
1543		/*
1544		 * WSAGetLastError() values are regular BSD error codes
1545		 * biased by WSABASEERR.
1546		 * However, strerror() does not know about networking
1547		 * specific errors, which are values beginning at 38 or so.
1548		 * Therefore, we choose to leave the biased error code
1549		 * in errno so that _if_ someone looks up the code somewhere,
1550		 * then it is at least the number that are usually listed.
1551		 */
1552		errno = WSAGetLastError();
1553		return -1;
1554	}
1555	/* convert into a file descriptor */
1556	if ((sockfd = _open_osfhandle(s, O_RDWR|O_BINARY)) < 0) {
1557		closesocket(s);
1558		return error("unable to make a socket file descriptor: %s",
1559			strerror(errno));
1560	}
1561	return sockfd;
1562}
1563
1564#undef connect
1565int mingw_connect(int sockfd, struct sockaddr *sa, size_t sz)
1566{
1567	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1568	return connect(s, sa, sz);
1569}
1570
1571#undef bind
1572int mingw_bind(int sockfd, struct sockaddr *sa, size_t sz)
1573{
1574	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1575	return bind(s, sa, sz);
1576}
1577
1578#undef setsockopt
1579int mingw_setsockopt(int sockfd, int lvl, int optname, void *optval, int optlen)
1580{
1581	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1582	return setsockopt(s, lvl, optname, (const char*)optval, optlen);
1583}
1584
1585#undef shutdown
1586int mingw_shutdown(int sockfd, int how)
1587{
1588	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1589	return shutdown(s, how);
1590}
1591
1592#undef listen
1593int mingw_listen(int sockfd, int backlog)
1594{
1595	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1596	return listen(s, backlog);
1597}
1598
1599#undef accept
1600int mingw_accept(int sockfd1, struct sockaddr *sa, socklen_t *sz)
1601{
1602	int sockfd2;
1603
1604	SOCKET s1 = (SOCKET)_get_osfhandle(sockfd1);
1605	SOCKET s2 = accept(s1, sa, sz);
1606
1607	/* convert into a file descriptor */
1608	if ((sockfd2 = _open_osfhandle(s2, O_RDWR|O_BINARY)) < 0) {
1609		int err = errno;
1610		closesocket(s2);
1611		return error("unable to make a socket file descriptor: %s",
1612			strerror(err));
1613	}
1614	return sockfd2;
1615}
1616
1617#undef rename
1618int mingw_rename(const char *pold, const char *pnew)
1619{
1620	DWORD attrs, gle;
1621	int tries = 0;
1622	wchar_t wpold[MAX_PATH], wpnew[MAX_PATH];
1623	if (xutftowcs_path(wpold, pold) < 0 || xutftowcs_path(wpnew, pnew) < 0)
1624		return -1;
1625
1626	/*
1627	 * Try native rename() first to get errno right.
1628	 * It is based on MoveFile(), which cannot overwrite existing files.
1629	 */
1630	if (!_wrename(wpold, wpnew))
1631		return 0;
1632	if (errno != EEXIST)
1633		return -1;
1634repeat:
1635	if (MoveFileExW(wpold, wpnew, MOVEFILE_REPLACE_EXISTING))
1636		return 0;
1637	/* TODO: translate more errors */
1638	gle = GetLastError();
1639	if (gle == ERROR_ACCESS_DENIED &&
1640	    (attrs = GetFileAttributesW(wpnew)) != INVALID_FILE_ATTRIBUTES) {
1641		if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
1642			DWORD attrsold = GetFileAttributesW(wpold);
1643			if (attrsold == INVALID_FILE_ATTRIBUTES ||
1644			    !(attrsold & FILE_ATTRIBUTE_DIRECTORY))
1645				errno = EISDIR;
1646			else if (!_wrmdir(wpnew))
1647				goto repeat;
1648			return -1;
1649		}
1650		if ((attrs & FILE_ATTRIBUTE_READONLY) &&
1651		    SetFileAttributesW(wpnew, attrs & ~FILE_ATTRIBUTE_READONLY)) {
1652			if (MoveFileExW(wpold, wpnew, MOVEFILE_REPLACE_EXISTING))
1653				return 0;
1654			gle = GetLastError();
1655			/* revert file attributes on failure */
1656			SetFileAttributesW(wpnew, attrs);
1657		}
1658	}
1659	if (tries < ARRAY_SIZE(delay) && gle == ERROR_ACCESS_DENIED) {
1660		/*
1661		 * We assume that some other process had the source or
1662		 * destination file open at the wrong moment and retry.
1663		 * In order to give the other process a higher chance to
1664		 * complete its operation, we give up our time slice now.
1665		 * If we have to retry again, we do sleep a bit.
1666		 */
1667		Sleep(delay[tries]);
1668		tries++;
1669		goto repeat;
1670	}
1671	if (gle == ERROR_ACCESS_DENIED &&
1672	       ask_yes_no_if_possible("Rename from '%s' to '%s' failed. "
1673		       "Should I try again?", pold, pnew))
1674		goto repeat;
1675
1676	errno = EACCES;
1677	return -1;
1678}
1679
1680/*
1681 * Note that this doesn't return the actual pagesize, but
1682 * the allocation granularity. If future Windows specific git code
1683 * needs the real getpagesize function, we need to find another solution.
1684 */
1685int mingw_getpagesize(void)
1686{
1687	SYSTEM_INFO si;
1688	GetSystemInfo(&si);
1689	return si.dwAllocationGranularity;
1690}
1691
1692struct passwd *getpwuid(int uid)
1693{
1694	static char user_name[100];
1695	static struct passwd p;
1696
1697	DWORD len = sizeof(user_name);
1698	if (!GetUserName(user_name, &len))
1699		return NULL;
1700	p.pw_name = user_name;
1701	p.pw_gecos = "unknown";
1702	p.pw_dir = NULL;
1703	return &p;
1704}
1705
1706static HANDLE timer_event;
1707static HANDLE timer_thread;
1708static int timer_interval;
1709static int one_shot;
1710static sig_handler_t timer_fn = SIG_DFL, sigint_fn = SIG_DFL;
1711
1712/* The timer works like this:
1713 * The thread, ticktack(), is a trivial routine that most of the time
1714 * only waits to receive the signal to terminate. The main thread tells
1715 * the thread to terminate by setting the timer_event to the signalled
1716 * state.
1717 * But ticktack() interrupts the wait state after the timer's interval
1718 * length to call the signal handler.
1719 */
1720
1721static unsigned __stdcall ticktack(void *dummy)
1722{
1723	while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
1724		mingw_raise(SIGALRM);
1725		if (one_shot)
1726			break;
1727	}
1728	return 0;
1729}
1730
1731static int start_timer_thread(void)
1732{
1733	timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
1734	if (timer_event) {
1735		timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
1736		if (!timer_thread )
1737			return errno = ENOMEM,
1738				error("cannot start timer thread");
1739	} else
1740		return errno = ENOMEM,
1741			error("cannot allocate resources for timer");
1742	return 0;
1743}
1744
1745static void stop_timer_thread(void)
1746{
1747	if (timer_event)
1748		SetEvent(timer_event);	/* tell thread to terminate */
1749	if (timer_thread) {
1750		int rc = WaitForSingleObject(timer_thread, 1000);
1751		if (rc == WAIT_TIMEOUT)
1752			error("timer thread did not terminate timely");
1753		else if (rc != WAIT_OBJECT_0)
1754			error("waiting for timer thread failed: %lu",
1755			      GetLastError());
1756		CloseHandle(timer_thread);
1757	}
1758	if (timer_event)
1759		CloseHandle(timer_event);
1760	timer_event = NULL;
1761	timer_thread = NULL;
1762}
1763
1764static inline int is_timeval_eq(const struct timeval *i1, const struct timeval *i2)
1765{
1766	return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
1767}
1768
1769int setitimer(int type, struct itimerval *in, struct itimerval *out)
1770{
1771	static const struct timeval zero;
1772	static int atexit_done;
1773
1774	if (out != NULL)
1775		return errno = EINVAL,
1776			error("setitimer param 3 != NULL not implemented");
1777	if (!is_timeval_eq(&in->it_interval, &zero) &&
1778	    !is_timeval_eq(&in->it_interval, &in->it_value))
1779		return errno = EINVAL,
1780			error("setitimer: it_interval must be zero or eq it_value");
1781
1782	if (timer_thread)
1783		stop_timer_thread();
1784
1785	if (is_timeval_eq(&in->it_value, &zero) &&
1786	    is_timeval_eq(&in->it_interval, &zero))
1787		return 0;
1788
1789	timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
1790	one_shot = is_timeval_eq(&in->it_interval, &zero);
1791	if (!atexit_done) {
1792		atexit(stop_timer_thread);
1793		atexit_done = 1;
1794	}
1795	return start_timer_thread();
1796}
1797
1798int sigaction(int sig, struct sigaction *in, struct sigaction *out)
1799{
1800	if (sig != SIGALRM)
1801		return errno = EINVAL,
1802			error("sigaction only implemented for SIGALRM");
1803	if (out != NULL)
1804		return errno = EINVAL,
1805			error("sigaction: param 3 != NULL not implemented");
1806
1807	timer_fn = in->sa_handler;
1808	return 0;
1809}
1810
1811#undef signal
1812sig_handler_t mingw_signal(int sig, sig_handler_t handler)
1813{
1814	sig_handler_t old;
1815
1816	switch (sig) {
1817	case SIGALRM:
1818		old = timer_fn;
1819		timer_fn = handler;
1820		break;
1821
1822	case SIGINT:
1823		old = sigint_fn;
1824		sigint_fn = handler;
1825		break;
1826
1827	default:
1828		return signal(sig, handler);
1829	}
1830
1831	return old;
1832}
1833
1834#undef raise
1835int mingw_raise(int sig)
1836{
1837	switch (sig) {
1838	case SIGALRM:
1839		if (timer_fn == SIG_DFL) {
1840			if (isatty(STDERR_FILENO))
1841				fputs("Alarm clock\n", stderr);
1842			exit(128 + SIGALRM);
1843		} else if (timer_fn != SIG_IGN)
1844			timer_fn(SIGALRM);
1845		return 0;
1846
1847	case SIGINT:
1848		if (sigint_fn == SIG_DFL)
1849			exit(128 + SIGINT);
1850		else if (sigint_fn != SIG_IGN)
1851			sigint_fn(SIGINT);
1852		return 0;
1853
1854	default:
1855		return raise(sig);
1856	}
1857}
1858
1859
1860static const char *make_backslash_path(const char *path)
1861{
1862	static char buf[PATH_MAX + 1];
1863	char *c;
1864
1865	if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
1866		die("Too long path: %.*s", 60, path);
1867
1868	for (c = buf; *c; c++) {
1869		if (*c == '/')
1870			*c = '\\';
1871	}
1872	return buf;
1873}
1874
1875void mingw_open_html(const char *unixpath)
1876{
1877	const char *htmlpath = make_backslash_path(unixpath);
1878	typedef HINSTANCE (WINAPI *T)(HWND, const char *,
1879			const char *, const char *, const char *, INT);
1880	T ShellExecute;
1881	HMODULE shell32;
1882	int r;
1883
1884	shell32 = LoadLibrary("shell32.dll");
1885	if (!shell32)
1886		die("cannot load shell32.dll");
1887	ShellExecute = (T)GetProcAddress(shell32, "ShellExecuteA");
1888	if (!ShellExecute)
1889		die("cannot run browser");
1890
1891	printf("Launching default browser to display HTML ...\n");
1892	r = HCAST(int, ShellExecute(NULL, "open", htmlpath,
1893				NULL, "\\", SW_SHOWNORMAL));
1894	FreeLibrary(shell32);
1895	/* see the MSDN documentation referring to the result codes here */
1896	if (r <= 32) {
1897		die("failed to launch browser for %.*s", MAX_PATH, unixpath);
1898	}
1899}
1900
1901int link(const char *oldpath, const char *newpath)
1902{
1903	typedef BOOL (WINAPI *T)(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES);
1904	static T create_hard_link = NULL;
1905	wchar_t woldpath[MAX_PATH], wnewpath[MAX_PATH];
1906	if (xutftowcs_path(woldpath, oldpath) < 0 ||
1907		xutftowcs_path(wnewpath, newpath) < 0)
1908		return -1;
1909
1910	if (!create_hard_link) {
1911		create_hard_link = (T) GetProcAddress(
1912			GetModuleHandle("kernel32.dll"), "CreateHardLinkW");
1913		if (!create_hard_link)
1914			create_hard_link = (T)-1;
1915	}
1916	if (create_hard_link == (T)-1) {
1917		errno = ENOSYS;
1918		return -1;
1919	}
1920	if (!create_hard_link(wnewpath, woldpath, NULL)) {
1921		errno = err_win_to_posix(GetLastError());
1922		return -1;
1923	}
1924	return 0;
1925}
1926
1927pid_

Large files files are truncated, but you can click here to view the full file