mingw.c · leroysheep/rag-system · siGit Code & Deploy

master

bisect jch maint master next seen test todo

c 3,764 lines 97.2 KB

Raw

1	#define USE_THE_REPOSITORY_VARIABLE
2	#define DISABLE_SIGN_COMPARE_WARNINGS
3
4	#include "git-compat-util.h"
5	#include "abspath.h"
6	#include "alloc.h"
7	#include "config.h"
8	#include "dir.h"
9	#include "environment.h"
10	#include "repository.h"
11	#include "gettext.h"
12	#include "run-command.h"
13	#include "strbuf.h"
14	#include "symlinks.h"
15	#include "trace2.h"
16	#include "win32.h"
17	#include "win32/exit-process.h"
18	#include "win32/lazyload.h"
19	#include "wrapper.h"
20	#include <aclapi.h>
21	#include <conio.h>
22	#include <sddl.h>
23	#define SECURITY_WIN32
24	#include <sspi.h>
25	#include <wchar.h>
26	#include <winioctl.h>
27	#include <winternl.h>
28
29	#define STATUS_DELETE_PENDING ((NTSTATUS) 0xC0000056)
30
31	#define HCAST(type, handle) ((type)(intptr_t)handle)
32
33	void open_in_gdb(void)
34	{
35	static struct child_process cp = CHILD_PROCESS_INIT;
36
37	strvec_pushl(&cp.args, "mintty", "gdb", NULL);
38	strvec_pushf(&cp.args, "--pid=%d", getpid());
39	cp.clean_on_exit = 1;
40	if (start_command(&cp) < 0)
41	die_errno("Could not start gdb");
42	sleep(1);
43	}
44
45	int err_win_to_posix(DWORD winerr)
46	{
47	int error = ENOSYS;
48	switch(winerr) {
49	case ERROR_ACCESS_DENIED: error = EACCES; break;
50	case ERROR_ACCOUNT_DISABLED: error = EACCES; break;
51	case ERROR_ACCOUNT_RESTRICTION: error = EACCES; break;
52	case ERROR_ALREADY_ASSIGNED: error = EBUSY; break;
53	case ERROR_ALREADY_EXISTS: error = EEXIST; break;
54	case ERROR_ARITHMETIC_OVERFLOW: error = ERANGE; break;
55	case ERROR_BAD_COMMAND: error = EIO; break;
56	case ERROR_BAD_DEVICE: error = ENODEV; break;
57	case ERROR_BAD_DRIVER_LEVEL: error = ENXIO; break;
58	case ERROR_BAD_EXE_FORMAT: error = ENOEXEC; break;
59	case ERROR_BAD_FORMAT: error = ENOEXEC; break;
60	case ERROR_BAD_LENGTH: error = EINVAL; break;
61	case ERROR_BAD_PATHNAME: error = ENOENT; break;
62	case ERROR_BAD_PIPE: error = EPIPE; break;
63	case ERROR_BAD_UNIT: error = ENODEV; break;
64	case ERROR_BAD_USERNAME: error = EINVAL; break;
65	case ERROR_BROKEN_PIPE: error = EPIPE; break;
66	case ERROR_BUFFER_OVERFLOW: error = ENAMETOOLONG; break;
67	case ERROR_BUSY: error = EBUSY; break;
68	case ERROR_BUSY_DRIVE: error = EBUSY; break;
69	case ERROR_CALL_NOT_IMPLEMENTED: error = ENOSYS; break;
70	case ERROR_CANNOT_MAKE: error = EACCES; break;
71	case ERROR_CANTOPEN: error = EIO; break;
72	case ERROR_CANTREAD: error = EIO; break;
73	case ERROR_CANTWRITE: error = EIO; break;
74	case ERROR_CRC: error = EIO; break;
75	case ERROR_CURRENT_DIRECTORY: error = EACCES; break;
76	case ERROR_DEVICE_IN_USE: error = EBUSY; break;
77	case ERROR_DEV_NOT_EXIST: error = ENODEV; break;
78	case ERROR_DIRECTORY: error = EINVAL; break;
79	case ERROR_DIR_NOT_EMPTY: error = ENOTEMPTY; break;
80	case ERROR_DISK_CHANGE: error = EIO; break;
81	case ERROR_DISK_FULL: error = ENOSPC; break;
82	case ERROR_DRIVE_LOCKED: error = EBUSY; break;
83	case ERROR_ENVVAR_NOT_FOUND: error = EINVAL; break;
84	case ERROR_EXE_MARKED_INVALID: error = ENOEXEC; break;
85	case ERROR_FILENAME_EXCED_RANGE: error = ENAMETOOLONG; break;
86	case ERROR_FILE_EXISTS: error = EEXIST; break;
87	case ERROR_FILE_INVALID: error = ENODEV; break;
88	case ERROR_FILE_NOT_FOUND: error = ENOENT; break;
89	case ERROR_GEN_FAILURE: error = EIO; break;
90	case ERROR_HANDLE_DISK_FULL: error = ENOSPC; break;
91	case ERROR_INSUFFICIENT_BUFFER: error = ENOMEM; break;
92	case ERROR_INVALID_ACCESS: error = EACCES; break;
93	case ERROR_INVALID_ADDRESS: error = EFAULT; break;
94	case ERROR_INVALID_BLOCK: error = EFAULT; break;
95	case ERROR_INVALID_DATA: error = EINVAL; break;
96	case ERROR_INVALID_DRIVE: error = ENODEV; break;
97	case ERROR_INVALID_EXE_SIGNATURE: error = ENOEXEC; break;
98	case ERROR_INVALID_FLAGS: error = EINVAL; break;
99	case ERROR_INVALID_FUNCTION: error = ENOSYS; break;
100	case ERROR_INVALID_HANDLE: error = EBADF; break;
101	case ERROR_INVALID_LOGON_HOURS: error = EACCES; break;
102	case ERROR_INVALID_NAME: error = EINVAL; break;
103	case ERROR_INVALID_OWNER: error = EINVAL; break;
104	case ERROR_INVALID_PARAMETER: error = EINVAL; break;
105	case ERROR_INVALID_PASSWORD: error = EPERM; break;
106	case ERROR_INVALID_PRIMARY_GROUP: error = EINVAL; break;
107	case ERROR_INVALID_REPARSE_DATA: error = EINVAL; break;
108	case ERROR_INVALID_SIGNAL_NUMBER: error = EINVAL; break;
109	case ERROR_INVALID_TARGET_HANDLE: error = EIO; break;
110	case ERROR_INVALID_WORKSTATION: error = EACCES; break;
111	case ERROR_IO_DEVICE: error = EIO; break;
112	case ERROR_IO_INCOMPLETE: error = EINTR; break;
113	case ERROR_LOCKED: error = EBUSY; break;
114	case ERROR_LOCK_VIOLATION: error = EACCES; break;
115	case ERROR_LOGON_FAILURE: error = EACCES; break;
116	case ERROR_MAPPED_ALIGNMENT: error = EINVAL; break;
117	case ERROR_META_EXPANSION_TOO_LONG: error = E2BIG; break;
118	case ERROR_MORE_DATA: error = EPIPE; break;
119	case ERROR_NEGATIVE_SEEK: error = ESPIPE; break;
120	case ERROR_NOACCESS: error = EFAULT; break;
121	case ERROR_NONE_MAPPED: error = EINVAL; break;
122	case ERROR_NOT_A_REPARSE_POINT: error = EINVAL; break;
123	case ERROR_NOT_ENOUGH_MEMORY: error = ENOMEM; break;
124	case ERROR_NOT_READY: error = EAGAIN; break;
125	case ERROR_NOT_SAME_DEVICE: error = EXDEV; break;
126	case ERROR_NO_DATA: error = EPIPE; break;
127	case ERROR_NO_MORE_SEARCH_HANDLES: error = EIO; break;
128	case ERROR_NO_PROC_SLOTS: error = EAGAIN; break;
129	case ERROR_NO_SUCH_PRIVILEGE: error = EACCES; break;
130	case ERROR_OPEN_FAILED: error = EIO; break;
131	case ERROR_OPEN_FILES: error = EBUSY; break;
132	case ERROR_OPERATION_ABORTED: error = EINTR; break;
133	case ERROR_OUTOFMEMORY: error = ENOMEM; break;
134	case ERROR_PASSWORD_EXPIRED: error = EACCES; break;
135	case ERROR_PATH_BUSY: error = EBUSY; break;
136	case ERROR_PATH_NOT_FOUND: error = ENOENT; break;
137	case ERROR_PIPE_BUSY: error = EBUSY; break;
138	case ERROR_PIPE_CONNECTED: error = EPIPE; break;
139	case ERROR_PIPE_LISTENING: error = EPIPE; break;
140	case ERROR_PIPE_NOT_CONNECTED: error = EPIPE; break;
141	case ERROR_PRIVILEGE_NOT_HELD: error = EACCES; break;
142	case ERROR_READ_FAULT: error = EIO; break;
143	case ERROR_REPARSE_ATTRIBUTE_CONFLICT: error = EINVAL; break;
144	case ERROR_REPARSE_TAG_INVALID: error = EINVAL; break;
145	case ERROR_REPARSE_TAG_MISMATCH: error = EINVAL; break;
146	case ERROR_SEEK: error = EIO; break;
147	case ERROR_SEEK_ON_DEVICE: error = ESPIPE; break;
148	case ERROR_SHARING_BUFFER_EXCEEDED: error = ENFILE; break;
149	case ERROR_SHARING_VIOLATION: error = EACCES; break;
150	case ERROR_STACK_OVERFLOW: error = ENOMEM; break;
151	case ERROR_SUCCESS: BUG("err_win_to_posix() called without an error!");
152	case ERROR_SWAPERROR: error = ENOENT; break;
153	case ERROR_TOO_MANY_MODULES: error = EMFILE; break;
154	case ERROR_TOO_MANY_OPEN_FILES: error = EMFILE; break;
155	case ERROR_UNRECOGNIZED_MEDIA: error = ENXIO; break;
156	case ERROR_UNRECOGNIZED_VOLUME: error = ENODEV; break;
157	case ERROR_WAIT_NO_CHILDREN: error = ECHILD; break;
158	case ERROR_WRITE_FAULT: error = EIO; break;
159	case ERROR_WRITE_PROTECT: error = EROFS; break;
160	}
161	return error;
162	}
163
164	static inline int is_file_in_use_error(DWORD errcode)
165	{
166	switch (errcode) {
167	case ERROR_SHARING_VIOLATION:
168	case ERROR_ACCESS_DENIED:
169	return 1;
170	}
171
172	return 0;
173	}
174
175	static int read_yes_no_answer(void)
176	{
177	char answer[1024];
178
179	if (fgets(answer, sizeof(answer), stdin)) {
180	size_t answer_len = strlen(answer);
181	int got_full_line = 0, c;
182
183	/* remove the newline */
184	if (answer_len >= 2 && answer[answer_len-2] == '\r') {
185	answer[answer_len-2] = '\0';
186	got_full_line = 1;
187	} else if (answer_len >= 1 && answer[answer_len-1] == '\n') {
188	answer[answer_len-1] = '\0';
189	got_full_line = 1;
190	}
191	/* flush the buffer in case we did not get the full line */
192	if (!got_full_line)
193	while ((c = getchar()) != EOF && c != '\n')
194	;
195	} else
196	/* we could not read, return the
197	* default answer which is no */
198	return 0;
199
200	if (tolower(answer[0]) == 'y' && !answer[1])
201	return 1;
202	if (!strncasecmp(answer, "yes", sizeof(answer)))
203	return 1;
204	if (tolower(answer[0]) == 'n' && !answer[1])
205	return 0;
206	if (!strncasecmp(answer, "no", sizeof(answer)))
207	return 0;
208
209	/* did not find an answer we understand */
210	return -1;
211	}
212
213	static int ask_yes_no_if_possible(const char *format, va_list args)
214	{
215	char question[4096];
216	const char *retry_hook;
217
218	vsnprintf(question, sizeof(question), format, args);
219
220	retry_hook = mingw_getenv("GIT_ASK_YESNO");
221	if (retry_hook) {
222	struct child_process cmd = CHILD_PROCESS_INIT;
223
224	strvec_pushl(&cmd.args, retry_hook, question, NULL);
225	return !run_command(&cmd);
226	}
227
228	if (!isatty(_fileno(stdin)) \|\| !isatty(_fileno(stderr)))
229	return 0;
230
231	while (1) {
232	int answer;
233	fprintf(stderr, "%s (y/n) ", question);
234
235	if ((answer = read_yes_no_answer()) >= 0)
236	return answer;
237
238	fprintf(stderr, "Sorry, I did not understand your answer. "
239	"Please type 'y' or 'n'\n");
240	}
241	}
242
243	static int retry_ask_yes_no(int tries, const char format, ...)
244	{
245	static const int delay[] = { 0, 1, 10, 20, 40 };
246	va_list args;
247	int result, saved_errno = errno;
248
249	if ((*tries) < ARRAY_SIZE(delay)) {
250	/*
251	* We assume that some other process had the file open at the wrong
252	* moment and retry. In order to give the other process a higher
253	* chance to complete its operation, we give up our time slice now.
254	* If we have to retry again, we do sleep a bit.
255	*/
256	Sleep(delay[*tries]);
257	(*tries)++;
258	return 1;
259	}
260
261	va_start(args, format);
262	result = ask_yes_no_if_possible(format, args);
263	va_end(args);
264	errno = saved_errno;
265	return result;
266	}
267
268	/* Windows only */
269	enum hide_dotfiles_type {
270	HIDE_DOTFILES_FALSE = 0,
271	HIDE_DOTFILES_TRUE,
272	HIDE_DOTFILES_DOTGITONLY
273	};
274
275	static enum hide_dotfiles_type hide_dotfiles = HIDE_DOTFILES_DOTGITONLY;
276	static char *unset_environment_variables;
277
278	int mingw_core_config(const char var, const char value,
279	const struct config_context *ctx UNUSED,
280	void *cb UNUSED)
281	{
282	if (!strcmp(var, "core.hidedotfiles")) {
283	if (value && !strcasecmp(value, "dotgitonly"))
284	hide_dotfiles = HIDE_DOTFILES_DOTGITONLY;
285	else
286	hide_dotfiles = git_config_bool(var, value);
287	return 0;
288	}
289
290	if (!strcmp(var, "core.unsetenvvars")) {
291	if (!value)
292	return config_error_nonbool(var);
293	free(unset_environment_variables);
294	unset_environment_variables = xstrdup(value);
295	return 0;
296	}
297
298	return 0;
299	}
300
301	static inline int is_wdir_sep(wchar_t wchar)
302	{
303	return wchar == L'/' \|\| wchar == L'\\';
304	}
305
306	static const wchar_t make_relative_to(const wchar_t path,
307	const wchar_t relative_to, wchar_t out,
308	size_t size)
309	{
310	size_t i = wcslen(relative_to), len;
311
312	/* Is `path` already absolute? */
313	if (is_wdir_sep(path[0]) \|\|
314	(iswalpha(path[0]) && path[1] == L':' && is_wdir_sep(path[2])))
315	return path;
316
317	while (i > 0 && !is_wdir_sep(relative_to[i - 1]))
318	i--;
319
320	/* Is `relative_to` in the current directory? */
321	if (!i)
322	return path;
323
324	len = wcslen(path);
325	if (i + len + 1 > size) {
326	error("Could not make '%ls' relative to '%ls' (too large)",
327	path, relative_to);
328	return NULL;
329	}
330
331	memcpy(out, relative_to, i * sizeof(wchar_t));
332	wcscpy(out + i, path);
333	return out;
334	}
335
336	static DWORD symlink_file_flags = 0, symlink_directory_flags = 1;
337
338	enum phantom_symlink_result {
339	PHANTOM_SYMLINK_RETRY,
340	PHANTOM_SYMLINK_DONE,
341	PHANTOM_SYMLINK_DIRECTORY
342	};
343
344	/*
345	* Changes a file symlink to a directory symlink if the target exists and is a
346	* directory.
347	*/
348	static enum phantom_symlink_result
349	process_phantom_symlink(const wchar_t wtarget, const wchar_t wlink)
350	{
351	HANDLE hnd;
352	BY_HANDLE_FILE_INFORMATION fdata;
353	wchar_t relative[MAX_PATH];
354	const wchar_t *rel;
355
356	/* check that wlink is still a file symlink */
357	if ((GetFileAttributesW(wlink)
358	& (FILE_ATTRIBUTE_REPARSE_POINT \| FILE_ATTRIBUTE_DIRECTORY))
359	!= FILE_ATTRIBUTE_REPARSE_POINT)
360	return PHANTOM_SYMLINK_DONE;
361
362	/* make it relative, if necessary */
363	rel = make_relative_to(wtarget, wlink, relative, ARRAY_SIZE(relative));
364	if (!rel)
365	return PHANTOM_SYMLINK_DONE;
366
367	/* let Windows resolve the link by opening it */
368	hnd = CreateFileW(rel, 0,
369	FILE_SHARE_READ \| FILE_SHARE_WRITE \| FILE_SHARE_DELETE, NULL,
370	OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
371	if (hnd == INVALID_HANDLE_VALUE) {
372	errno = err_win_to_posix(GetLastError());
373	return PHANTOM_SYMLINK_RETRY;
374	}
375
376	if (!GetFileInformationByHandle(hnd, &fdata)) {
377	errno = err_win_to_posix(GetLastError());
378	CloseHandle(hnd);
379	return PHANTOM_SYMLINK_RETRY;
380	}
381	CloseHandle(hnd);
382
383	/* if target exists and is a file, we're done */
384	if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
385	return PHANTOM_SYMLINK_DONE;
386
387	/* otherwise recreate the symlink with directory flag */
388	if (DeleteFileW(wlink) &&
389	CreateSymbolicLinkW(wlink, wtarget, symlink_directory_flags))
390	return PHANTOM_SYMLINK_DIRECTORY;
391
392	errno = err_win_to_posix(GetLastError());
393	return PHANTOM_SYMLINK_RETRY;
394	}
395
396	/* keep track of newly created symlinks to non-existing targets */
397	struct phantom_symlink_info {
398	struct phantom_symlink_info *next;
399	wchar_t *wlink;
400	wchar_t *wtarget;
401	};
402
403	static struct phantom_symlink_info *phantom_symlinks = NULL;
404	static CRITICAL_SECTION phantom_symlinks_cs;
405
406	static void process_phantom_symlinks(void)
407	{
408	struct phantom_symlink_info current, *psi;
409	EnterCriticalSection(&phantom_symlinks_cs);
410	/* process phantom symlinks list */
411	psi = &phantom_symlinks;
412	while ((current = *psi)) {
413	enum phantom_symlink_result result = process_phantom_symlink(
414	current->wtarget, current->wlink);
415	if (result == PHANTOM_SYMLINK_RETRY) {
416	psi = &current->next;
417	} else {
418	/* symlink was processed, remove from list */
419	*psi = current->next;
420	free(current);
421	/* if symlink was a directory, start over */
422	if (result == PHANTOM_SYMLINK_DIRECTORY)
423	psi = &phantom_symlinks;
424	}
425	}
426	LeaveCriticalSection(&phantom_symlinks_cs);
427	}
428
429	/* Normalizes NT paths as returned by some low-level APIs. */
430	static wchar_t normalize_ntpath(wchar_t wbuf)
431	{
432	int i;
433	/* fix absolute path prefixes */
434	if (wbuf[0] == '\\') {
435	/* strip NT namespace prefixes */
436	if (!wcsncmp(wbuf, L"\\??\\", 4) \|\|
437	!wcsncmp(wbuf, L"\\\\?\\", 4))
438	wbuf += 4;
439	else if (!wcsnicmp(wbuf, L"\\DosDevices\\", 12))
440	wbuf += 12;
441	/* replace remaining '...UNC\' with '\\' */
442	if (!wcsnicmp(wbuf, L"UNC\\", 4)) {
443	wbuf += 2;
444	*wbuf = '\\';
445	}
446	}
447	/* convert backslashes to slashes */
448	for (i = 0; wbuf[i]; i++)
449	if (wbuf[i] == '\\')
450	wbuf[i] = '/';
451	return wbuf;
452	}
453
454	/*
455	* Use SetFileInformationByHandle(FileDispositionInfo) to force legacy
456	* (non-POSIX) delete semantics. On Windows 11, DeleteFileW() uses POSIX
457	* delete semantics internally, allowing deletion even with active
458	* MapViewOfFile views. This helper simulates Windows 10 behavior where
459	* deletion fails if a file mapping exists.
460	*
461	* Returns nonzero on success (like DeleteFileW), 0 on failure.
462	*/
463	static int legacy_delete_file(const wchar_t *wpathname)
464	{
465	FILE_DISPOSITION_INFO fdi = { TRUE };
466	DWORD gle;
467	HANDLE h = CreateFileW(wpathname, DELETE,
468	FILE_SHARE_READ \| FILE_SHARE_WRITE \|
469	FILE_SHARE_DELETE,
470	NULL, OPEN_EXISTING,
471	FILE_FLAG_OPEN_REPARSE_POINT, NULL);
472	if (h == INVALID_HANDLE_VALUE)
473	return 0;
474
475	if (SetFileInformationByHandle(h, FileDispositionInfo,
476	&fdi, sizeof(fdi))) {
477	CloseHandle(h);
478	return 1;
479	}
480	gle = GetLastError();
481	CloseHandle(h);
482	SetLastError(gle);
483	return 0;
484	}
485
486	static int try_delete_file(const wchar_t *wpathname, int use_legacy)
487	{
488	if (use_legacy)
489	return legacy_delete_file(wpathname);
490	return DeleteFileW(wpathname);
491	}
492
493	int mingw_unlink(const char *pathname, int handle_in_use_error)
494	{
495	static int use_legacy_delete = -1;
496	int tries = 0;
497	wchar_t wpathname[MAX_PATH];
498	if (xutftowcs_path(wpathname, pathname) < 0)
499	return -1;
500
501	if (use_legacy_delete < 0)
502	use_legacy_delete = git_env_bool("GIT_TEST_LEGACY_DELETE", 0);
503
504	if (try_delete_file(wpathname, use_legacy_delete))
505	return 0;
506
507	do {
508	/* read-only files cannot be removed */
509	_wchmod(wpathname, 0666);
510	if (try_delete_file(wpathname, use_legacy_delete))
511	return 0;
512	if (!is_file_in_use_error(GetLastError()))
513	break;
514	/*
515	* _wunlink() / DeleteFileW() for directory symlinks fails with
516	* ERROR_ACCESS_DENIED (EACCES), so try _wrmdir() as well. This is the
517	* same error we get if a file is in use (already checked above).
518	*/
519	if (!_wrmdir(wpathname))
520	return 0;
521
522	if (!handle_in_use_error)
523	return -1;
524	} while (retry_ask_yes_no(&tries, "Unlink of file '%s' failed. "
525	"Should I try again?", pathname));
526	return -1;
527	}
528
529	static int is_dir_empty(const wchar_t *wpath)
530	{
531	WIN32_FIND_DATAW findbuf;
532	HANDLE handle;
533	wchar_t wbuf[MAX_PATH + 2];
534	wcscpy(wbuf, wpath);
535	wcscat(wbuf, L"\\*");
536	handle = FindFirstFileW(wbuf, &findbuf);
537	if (handle == INVALID_HANDLE_VALUE)
538	return GetLastError() == ERROR_NO_MORE_FILES;
539
540	while (!wcscmp(findbuf.cFileName, L".") \|\|
541	!wcscmp(findbuf.cFileName, L".."))
542	if (!FindNextFileW(handle, &findbuf)) {
543	DWORD err = GetLastError();
544	FindClose(handle);
545	return err == ERROR_NO_MORE_FILES;
546	}
547	FindClose(handle);
548	return 0;
549	}
550
551	int mingw_rmdir(const char *pathname)
552	{
553	int tries = 0;
554	wchar_t wpathname[MAX_PATH];
555	struct stat st;
556
557	/*
558	* Contrary to Linux' `rmdir()`, Windows' _wrmdir() and _rmdir()
559	* (and `RemoveDirectoryW()`) will attempt to remove the target of a
560	* symbolic link (if it points to a directory).
561	*
562	* This behavior breaks the assumption of e.g. `remove_path()` which
563	* upon successful deletion of a file will attempt to remove its parent
564	* directories recursively until failure (which usually happens when
565	* the directory is not empty).
566	*
567	* Therefore, before calling `_wrmdir()`, we first check if the path is
568	* a symbolic link. If it is, we exit and return the same error as
569	* Linux' `rmdir()` would, i.e. `ENOTDIR`.
570	*/
571	if (!mingw_lstat(pathname, &st) && S_ISLNK(st.st_mode)) {
572	errno = ENOTDIR;
573	return -1;
574	}
575
576	if (xutftowcs_path(wpathname, pathname) < 0)
577	return -1;
578
579	do {
580	if (!_wrmdir(wpathname)) {
581	invalidate_lstat_cache();
582	return 0;
583	}
584	if (!is_file_in_use_error(GetLastError()))
585	errno = err_win_to_posix(GetLastError());
586	if (errno != EACCES)
587	break;
588	if (!is_dir_empty(wpathname)) {
589	errno = ENOTEMPTY;
590	break;
591	}
592	} while (retry_ask_yes_no(&tries, "Deletion of directory '%s' failed. "
593	"Should I try again?", pathname));
594	return -1;
595	}
596
597	static inline int needs_hiding(const char *path)
598	{
599	const char *basename;
600
601	if (hide_dotfiles == HIDE_DOTFILES_FALSE)
602	return 0;
603
604	/* We cannot use basename(), as it would remove trailing slashes */
605	win32_skip_dos_drive_prefix((char **)&path);
606	if (!*path)
607	return 0;
608
609	for (basename = path; *path; path++)
610	if (is_dir_sep(*path)) {
611	do {
612	path++;
613	} while (is_dir_sep(*path));
614	/* ignore trailing slashes */
615	if (*path)
616	basename = path;
617	else
618	break;
619	}
620
621	if (hide_dotfiles == HIDE_DOTFILES_TRUE)
622	return *basename == '.';
623
624	assert(hide_dotfiles == HIDE_DOTFILES_DOTGITONLY);
625	return !strncasecmp(".git", basename, 4) &&
626	(!basename[4] \|\| is_dir_sep(basename[4]));
627	}
628
629	static int set_hidden_flag(const wchar_t *path, int set)
630	{
631	DWORD original = GetFileAttributesW(path), modified;
632	if (set)
633	modified = original \| FILE_ATTRIBUTE_HIDDEN;
634	else
635	modified = original & ~FILE_ATTRIBUTE_HIDDEN;
636	if (original == modified \|\| SetFileAttributesW(path, modified))
637	return 0;
638	errno = err_win_to_posix(GetLastError());
639	return -1;
640	}
641
642	int mingw_mkdir(const char *path, int mode UNUSED)
643	{
644	int ret;
645	wchar_t wpath[MAX_PATH];
646
647	if (!is_valid_win32_path(path, 0)) {
648	errno = EINVAL;
649	return -1;
650	}
651
652	if (xutftowcs_path(wpath, path) < 0)
653	return -1;
654	ret = _wmkdir(wpath);
655	if (!ret)
656	process_phantom_symlinks();
657	if (!ret && needs_hiding(path))
658	return set_hidden_flag(wpath, 1);
659	return ret;
660	}
661
662	/*
663	* Calling CreateFile() using FILE_APPEND_DATA and without FILE_WRITE_DATA
664	* is documented in [1] as opening a writable file handle in append mode.
665	* (It is believed that) this is atomic since it is maintained by the
666	* kernel unlike the O_APPEND flag which is racily maintained by the CRT.
667	*
668	* [1] https://docs.microsoft.com/en-us/windows/desktop/fileio/file-access-rights-constants
669	*
670	* This trick does not appear to work for named pipes. Instead it creates
671	* a named pipe client handle that cannot be written to. Callers should
672	* just use the regular _wopen() for them. (And since client handle gets
673	* bound to a unique server handle, it isn't really an issue.)
674	*/
675	static int mingw_open_append(wchar_t const *wfilename, int oflags, ...)
676	{
677	HANDLE handle;
678	int fd;
679	DWORD create = (oflags & O_CREAT) ? OPEN_ALWAYS : OPEN_EXISTING;
680
681	/* only these flags are supported */
682	if ((oflags & ~O_CREAT) != (O_WRONLY \| O_APPEND)) {
683	errno = ENOSYS;
684	return -1;
685	}
686
687	/*
688	* FILE_SHARE_WRITE is required to permit child processes
689	* to append to the file.
690	*/
691	handle = CreateFileW(wfilename, FILE_APPEND_DATA,
692	FILE_SHARE_WRITE \| FILE_SHARE_READ \| FILE_SHARE_DELETE,
693	NULL, create, FILE_ATTRIBUTE_NORMAL, NULL);
694	if (handle == INVALID_HANDLE_VALUE) {
695	DWORD err = GetLastError();
696
697	/*
698	* Some network storage solutions (e.g. Isilon) might return
699	* ERROR_INVALID_PARAMETER instead of expected error
700	* ERROR_PATH_NOT_FOUND, which results in an unknown error. If
701	* so, let's turn the error to ERROR_PATH_NOT_FOUND instead.
702	*/
703	if (err == ERROR_INVALID_PARAMETER)
704	err = ERROR_PATH_NOT_FOUND;
705
706	errno = err_win_to_posix(err);
707	return -1;
708	}
709
710	/*
711	* No O_APPEND here, because the CRT uses it only to reset the
712	* file pointer to EOF before each write(); but that is not
713	* necessary (and may lead to races) for a file created with
714	* FILE_APPEND_DATA.
715	*/
716	fd = _open_osfhandle((intptr_t)handle, O_BINARY);
717	if (fd < 0)
718	CloseHandle(handle);
719	return fd;
720	}
721
722	/*
723	* Ideally, we'd use `_wopen()` to implement this functionality so that we
724	* don't have to reimplement it, but unfortunately we do not have tight control
725	* over the share mode there. And while `_wsopen()` and friends exist that give
726	* us _some_ control over the share mode, this family of functions doesn't give
727	* us the ability to enable FILE_SHARE_DELETE, either. But this is a strict
728	* requirement for us though so that we can unlink or rename over files that
729	* are held open by another process.
730	*
731	* We are thus forced to implement our own emulation of `open()`. To make our
732	* life simpler we only implement basic support for this, namely opening
733	* existing files for reading and/or writing. This means that newly created
734	* files won't have their sharing mode set up correctly, but for now I couldn't
735	* find any case where this matters. We may have to revisit that in the future
736	* though based on our needs.
737	*/
738	static int mingw_open_existing(const wchar_t *filename, int oflags, ...)
739	{
740	SECURITY_ATTRIBUTES security_attributes = {
741	.nLength = sizeof(security_attributes),
742	.bInheritHandle = !(oflags & O_NOINHERIT),
743	};
744	HANDLE handle;
745	DWORD access;
746	int fd;
747
748	/* We only support basic flags. */
749	if (oflags & ~(O_ACCMODE \| O_NOINHERIT)) {
750	errno = ENOSYS;
751	return -1;
752	}
753
754	switch (oflags & O_ACCMODE) {
755	case O_RDWR:
756	access = GENERIC_READ \| GENERIC_WRITE;
757	break;
758	case O_WRONLY:
759	access = GENERIC_WRITE;
760	break;
761	default:
762	access = GENERIC_READ;
763	break;
764	}
765
766	handle = CreateFileW(filename, access,
767	FILE_SHARE_WRITE \| FILE_SHARE_READ \| FILE_SHARE_DELETE,
768	&security_attributes, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
769	if (handle == INVALID_HANDLE_VALUE) {
770	DWORD err = GetLastError();
771	if (err == ERROR_ACCESS_DENIED) {
772	DWORD attrs = GetFileAttributesW(filename);
773	if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
774	handle = CreateFileW(filename, access,
775	FILE_SHARE_WRITE \| FILE_SHARE_READ \| FILE_SHARE_DELETE,
776	&security_attributes, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL\| FILE_FLAG_BACKUP_SEMANTICS, NULL);
777	}
778
779	if (handle == INVALID_HANDLE_VALUE) {
780	err = GetLastError();
781
782	/* See `mingw_open_append()` for why we have this conversion. */
783	if (err == ERROR_INVALID_PARAMETER)
784	err = ERROR_PATH_NOT_FOUND;
785
786	errno = err_win_to_posix(err);
787	return -1;
788	}
789	}
790
791	fd = _open_osfhandle((intptr_t)handle, oflags \| O_BINARY);
792	if (fd < 0)
793	CloseHandle(handle);
794	return fd;
795	}
796
797	/*
798	* Does the pathname map to the local named pipe filesystem?
799	* That is, does it have a "//./pipe/" prefix?
800	*/
801	static int is_local_named_pipe_path(const char *filename)
802	{
803	return (is_dir_sep(filename[0]) &&
804	is_dir_sep(filename[1]) &&
805	filename[2] == '.' &&
806	is_dir_sep(filename[3]) &&
807	!strncasecmp(filename+4, "pipe", 4) &&
808	is_dir_sep(filename[8]) &&
809	filename[9]);
810	}
811
812	int mingw_open (const char *filename, int oflags, ...)
813	{
814	typedef int (open_fn_t)(wchar_t const wfilename, int oflags, ...);
815	va_list args;
816	unsigned mode;
817	int fd, create = (oflags & (O_CREAT \| O_EXCL)) == (O_CREAT \| O_EXCL);
818	wchar_t wfilename[MAX_PATH];
819	open_fn_t open_fn;
820	WIN32_FILE_ATTRIBUTE_DATA fdata;
821
822	DECLARE_PROC_ADDR(ntdll.dll, NTSTATUS, NTAPI, RtlGetLastNtStatus, void);
823
824	va_start(args, oflags);
825	mode = va_arg(args, int);
826	va_end(args);
827
828	if (!is_valid_win32_path(filename, !create)) {
829	errno = create ? EINVAL : ENOENT;
830	return -1;
831	}
832
833	if ((oflags & O_APPEND) && !is_local_named_pipe_path(filename))
834	open_fn = mingw_open_append;
835	else if (!(oflags & ~(O_ACCMODE \| O_NOINHERIT)))
836	open_fn = mingw_open_existing;
837	else
838	open_fn = _wopen;
839
840	if (filename && !strcmp(filename, "/dev/null"))
841	wcscpy(wfilename, L"nul");
842	else if (xutftowcs_path(wfilename, filename) < 0)
843	return -1;
844
845	/*
846	* When `symlink` exists and is a symbolic link pointing to a
847	* non-existing file, `_wopen(symlink, O_CREAT \| O_EXCL)` would
848	* create that file. Not what we want: Linux would say `EEXIST`
849	* in that instance, which is therefore what Git expects.
850	*/
851	if (create &&
852	GetFileAttributesExW(wfilename, GetFileExInfoStandard, &fdata) &&
853	(fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)) {
854	errno = EEXIST;
855	return -1;
856	}
857
858	fd = open_fn(wfilename, oflags, mode);
859
860	/*
861	* Internally, `_wopen()` uses the `CreateFile()` API with CREATE_NEW,
862	* which may error out with ERROR_ACCESS_DENIED and an NtStatus of
863	* STATUS_DELETE_PENDING when the file is scheduled for deletion via
864	* `DeleteFileW()`. The file essentially exists, so we map errno to
865	* EEXIST instead of EACCESS so that callers don't have to special-case
866	* this.
867	*
868	* This fixes issues for example with the lockfile interface when one
869	* process has a lock that it is about to commit or release while
870	* another process wants to acquire it.
871	*/
872	if (fd < 0 && create && GetLastError() == ERROR_ACCESS_DENIED &&
873	INIT_PROC_ADDR(RtlGetLastNtStatus) && RtlGetLastNtStatus() == STATUS_DELETE_PENDING)
874	errno = EEXIST;
875	if (fd < 0 && (oflags & O_ACCMODE) != O_RDONLY && errno == EACCES) {
876	DWORD attrs = GetFileAttributesW(wfilename);
877	if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
878	errno = EISDIR;
879	}
880	if ((oflags & O_CREAT) && needs_hiding(filename)) {
881	/*
882	* Internally, _wopen() uses the CreateFile() API which errors
883	* out with an ERROR_ACCESS_DENIED if CREATE_ALWAYS was
884	* specified and an already existing file's attributes do not
885	* match exactly. As there is no mode or flag we can set that
886	* would correspond to FILE_ATTRIBUTE_HIDDEN, let's just try
887	* again without the O_CREAT flag (that corresponds to the
888	* CREATE_ALWAYS flag of CreateFile()).
889	*/
890	if (fd < 0 && errno == EACCES)
891	fd = open_fn(wfilename, oflags & ~O_CREAT, mode);
892	if (fd >= 0 && set_hidden_flag(wfilename, 1))
893	warning("could not mark '%s' as hidden.", filename);
894	}
895	return fd;
896	}
897
898	static BOOL WINAPI ctrl_ignore(DWORD type UNUSED)
899	{
900	return TRUE;
901	}
902
903	#undef fgetc
904	int mingw_fgetc(FILE *stream)
905	{
906	int ch;
907	if (!isatty(_fileno(stream)))
908	return fgetc(stream);
909
910	SetConsoleCtrlHandler(ctrl_ignore, TRUE);
911	while (1) {
912	ch = fgetc(stream);
913	if (ch != EOF \|\| GetLastError() != ERROR_OPERATION_ABORTED)
914	break;
915
916	/* Ctrl+C was pressed, simulate SIGINT and retry */
917	mingw_raise(SIGINT);
918	}
919	SetConsoleCtrlHandler(ctrl_ignore, FALSE);
920	return ch;
921	}
922
923	#undef fopen
924	FILE mingw_fopen (const char filename, const char *otype)
925	{
926	int hide = needs_hiding(filename);
927	FILE *file;
928	wchar_t wfilename[MAX_PATH], wotype[4];
929	if (filename && !strcmp(filename, "/dev/null"))
930	wcscpy(wfilename, L"nul");
931	else if (!is_valid_win32_path(filename, 1)) {
932	int create = otype && strchr(otype, 'w');
933	errno = create ? EINVAL : ENOENT;
934	return NULL;
935	} else if (xutftowcs_path(wfilename, filename) < 0)
936	return NULL;
937
938	if (xutftowcs(wotype, otype, ARRAY_SIZE(wotype)) < 0)
939	return NULL;
940
941	if (hide && !access(filename, F_OK) && set_hidden_flag(wfilename, 0)) {
942	error("could not unhide %s", filename);
943	return NULL;
944	}
945	file = _wfopen(wfilename, wotype);
946	if (!file && GetLastError() == ERROR_INVALID_NAME)
947	errno = ENOENT;
948	if (file && hide && set_hidden_flag(wfilename, 1))
949	warning("could not mark '%s' as hidden.", filename);
950	return file;
951	}
952
953	FILE mingw_freopen (const char filename, const char otype, FILE stream)
954	{
955	int hide = needs_hiding(filename);
956	FILE *file;
957	wchar_t wfilename[MAX_PATH], wotype[4];
958	if (filename && !strcmp(filename, "/dev/null"))
959	wcscpy(wfilename, L"nul");
960	else if (!is_valid_win32_path(filename, 1)) {
961	int create = otype && strchr(otype, 'w');
962	errno = create ? EINVAL : ENOENT;
963	return NULL;
964	} else if (xutftowcs_path(wfilename, filename) < 0)
965	return NULL;
966
967	if (xutftowcs(wotype, otype, ARRAY_SIZE(wotype)) < 0)
968	return NULL;
969
970	if (hide && !access(filename, F_OK) && set_hidden_flag(wfilename, 0)) {
971	error("could not unhide %s", filename);
972	return NULL;
973	}
974	file = _wfreopen(wfilename, wotype, stream);
975	if (file && hide && set_hidden_flag(wfilename, 1))
976	warning("could not mark '%s' as hidden.", filename);
977	return file;
978	}
979
980	#undef fflush
981	int mingw_fflush(FILE *stream)
982	{
983	int ret = fflush(stream);
984
985	/*
986	* write() is used behind the scenes of stdio output functions.
987	* Since git code does not check for errors after each stdio write
988	* operation, it can happen that write() is called by a later
989	* stdio function even if an earlier write() call failed. In the
990	* case of a pipe whose readable end was closed, only the first
991	* call to write() reports EPIPE on Windows. Subsequent write()
992	* calls report EINVAL. It is impossible to notice whether this
993	* fflush invocation triggered such a case, therefore, we have to
994	* catch all EINVAL errors whole-sale.
995	*/
996	if (ret && errno == EINVAL)
997	errno = EPIPE;
998
999	return ret;
1000	}
1001
1002	#undef write
1003	ssize_t mingw_write(int fd, const void *buf, size_t len)
1004	{
1005	ssize_t result = write(fd, buf, len);
1006
1007	if (result < 0 && (errno == EINVAL \|\| errno == ENOSPC) && buf) {
1008	int orig = errno;
1009
1010	/* check if fd is a pipe */
1011	HANDLE h = (HANDLE) _get_osfhandle(fd);
1012	if (GetFileType(h) != FILE_TYPE_PIPE)
1013	errno = orig;
1014	else if (orig == EINVAL)
1015	errno = EPIPE;
1016	else {
1017	DWORD buf_size;
1018
1019	if (!GetNamedPipeInfo(h, NULL, NULL, &buf_size, NULL))
1020	buf_size = 4096;
1021	if (len > buf_size)
1022	return write(fd, buf, buf_size);
1023	errno = orig;
1024	}
1025	}
1026
1027	return result;
1028	}
1029
1030	int mingw_access(const char *filename, int mode)
1031	{
1032	wchar_t wfilename[MAX_PATH];
1033	if (!strcmp("nul", filename) \|\| !strcmp("/dev/null", filename))
1034	return 0;
1035	if (xutftowcs_path(wfilename, filename) < 0)
1036	return -1;
1037	/* X_OK is not supported by the MSVCRT version */
1038	return _waccess(wfilename, mode & ~X_OK);
1039	}
1040
1041	int mingw_chdir(const char *dirname)
1042	{
1043	wchar_t wdirname[MAX_PATH];
1044
1045	if (xutftowcs_path(wdirname, dirname) < 0)
1046	return -1;
1047
1048	if (repo_has_symlinks(the_repository)) {
1049	HANDLE hnd = CreateFileW(wdirname, 0,
1050	FILE_SHARE_READ \| FILE_SHARE_WRITE \| FILE_SHARE_DELETE, NULL,
1051	OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
1052	if (hnd == INVALID_HANDLE_VALUE) {
1053	errno = err_win_to_posix(GetLastError());
1054	return -1;
1055	}
1056	if (!GetFinalPathNameByHandleW(hnd, wdirname, ARRAY_SIZE(wdirname), 0)) {
1057	errno = err_win_to_posix(GetLastError());
1058	CloseHandle(hnd);
1059	return -1;
1060	}
1061	CloseHandle(hnd);
1062	}
1063
1064	return _wchdir(normalize_ntpath(wdirname));
1065	}
1066
1067	int mingw_chmod(const char *filename, int mode)
1068	{
1069	wchar_t wfilename[MAX_PATH];
1070	if (xutftowcs_path(wfilename, filename) < 0)
1071	return -1;
1072	return _wchmod(wfilename, mode);
1073	}
1074
1075	/*
1076	* The unit of FILETIME is 100-nanoseconds since January 1, 1601, UTC.
1077	* Returns the 100-nanoseconds ("hekto nanoseconds") since the epoch.
1078	*/
1079	static inline long long filetime_to_hnsec(const FILETIME *ft)
1080	{
1081	long long winTime = ((long long)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
1082	/* Windows to Unix Epoch conversion */
1083	return winTime - 116444736000000000LL;
1084	}
1085
1086	static inline void filetime_to_timespec(const FILETIME ft, struct timespec ts)
1087	{
1088	long long hnsec = filetime_to_hnsec(ft);
1089	ts->tv_sec = (time_t)(hnsec / 10000000);
1090	ts->tv_nsec = (hnsec % 10000000) * 100;
1091	}
1092
1093	/**
1094	* Verifies that safe_create_leading_directories() would succeed.
1095	*/
1096	static int has_valid_directory_prefix(wchar_t *wfilename)
1097	{
1098	size_t n = wcslen(wfilename);
1099
1100	while (n > 0) {
1101	wchar_t c = wfilename[--n];
1102	DWORD attributes;
1103
1104	if (!is_dir_sep(c))
1105	continue;
1106
1107	wfilename[n] = L'\0';
1108	attributes = GetFileAttributesW(wfilename);
1109	wfilename[n] = c;
1110	if (attributes &
1111	(FILE_ATTRIBUTE_DIRECTORY \| FILE_ATTRIBUTE_DEVICE))
1112	return 1;
1113	if (attributes == INVALID_FILE_ATTRIBUTES)
1114	switch (GetLastError()) {
1115	case ERROR_PATH_NOT_FOUND:
1116	continue;
1117	case ERROR_FILE_NOT_FOUND:
1118	/* This implies parent directory exists. */
1119	return 1;
1120	}
1121	return 0;
1122	}
1123	return 1;
1124	}
1125
1126	#ifndef _WINNT_H
1127	/*
1128	* The REPARSE_DATA_BUFFER structure is defined in the Windows DDK (in
1129	* ntifs.h) and in MSYS1's winnt.h (which defines _WINNT_H). So define
1130	* it ourselves if we are on MSYS2 (whose winnt.h defines _WINNT_).
1131	*/
1132	typedef struct _REPARSE_DATA_BUFFER {
1133	DWORD ReparseTag;
1134	WORD ReparseDataLength;
1135	WORD Reserved;
1136	#ifndef _MSC_VER
1137	_ANONYMOUS_UNION
1138	#endif
1139	union {
1140	struct {
1141	WORD SubstituteNameOffset;
1142	WORD SubstituteNameLength;
1143	WORD PrintNameOffset;
1144	WORD PrintNameLength;
1145	ULONG Flags;
1146	WCHAR PathBuffer[1];
1147	} SymbolicLinkReparseBuffer;
1148	struct {
1149	WORD SubstituteNameOffset;
1150	WORD SubstituteNameLength;
1151	WORD PrintNameOffset;
1152	WORD PrintNameLength;
1153	WCHAR PathBuffer[1];
1154	} MountPointReparseBuffer;
1155	struct {
1156	BYTE DataBuffer[1];
1157	} GenericReparseBuffer;
1158	} DUMMYUNIONNAME;
1159	} REPARSE_DATA_BUFFER, *PREPARSE_DATA_BUFFER;
1160	#endif
1161
1162	static int read_reparse_point(const WCHAR *wpath, BOOL fail_on_unknown_tag,
1163	char tmpbuf, int plen, DWORD *ptag)
1164	{
1165	HANDLE handle;
1166	WCHAR *wbuf;
1167	REPARSE_DATA_BUFFER *b = alloca(MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
1168	DWORD dummy;
1169
1170	/* read reparse point data */
1171	handle = CreateFileW(wpath, 0,
1172	FILE_SHARE_READ \| FILE_SHARE_WRITE \| FILE_SHARE_DELETE, NULL,
1173	OPEN_EXISTING,
1174	FILE_FLAG_BACKUP_SEMANTICS \| FILE_FLAG_OPEN_REPARSE_POINT, NULL);
1175	if (handle == INVALID_HANDLE_VALUE) {
1176	errno = err_win_to_posix(GetLastError());
1177	return -1;
1178	}
1179	if (!DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, NULL, 0, b,
1180	MAXIMUM_REPARSE_DATA_BUFFER_SIZE, &dummy, NULL)) {
1181	errno = err_win_to_posix(GetLastError());
1182	CloseHandle(handle);
1183	return -1;
1184	}
1185	CloseHandle(handle);
1186
1187	/* get target path for symlinks or mount points (aka 'junctions') */
1188	switch ((*ptag = b->ReparseTag)) {
1189	case IO_REPARSE_TAG_SYMLINK:
1190	wbuf = (WCHAR) (((char) b->SymbolicLinkReparseBuffer.PathBuffer)
1191	+ b->SymbolicLinkReparseBuffer.SubstituteNameOffset);
1192	(WCHAR) (((char*) wbuf)
1193	+ b->SymbolicLinkReparseBuffer.SubstituteNameLength) = 0;
1194	break;
1195	case IO_REPARSE_TAG_MOUNT_POINT:
1196	wbuf = (WCHAR) (((char) b->MountPointReparseBuffer.PathBuffer)
1197	+ b->MountPointReparseBuffer.SubstituteNameOffset);
1198	(WCHAR) (((char*) wbuf)
1199	+ b->MountPointReparseBuffer.SubstituteNameLength) = 0;
1200	break;
1201	default:
1202	if (fail_on_unknown_tag) {
1203	errno = EINVAL;
1204	return -1;
1205	} else {
1206	*plen = MAX_PATH;
1207	return 0;
1208	}
1209	}
1210
1211	if ((*plen =
1212	xwcstoutf(tmpbuf, normalize_ntpath(wbuf), MAX_PATH)) < 0)
1213	return -1;
1214	return 0;
1215	}
1216
1217	int mingw_lstat(const char file_name, struct stat buf)
1218	{
1219	WIN32_FILE_ATTRIBUTE_DATA fdata;
1220	DWORD reparse_tag = 0;
1221	int link_len = 0;
1222	wchar_t wfilename[MAX_PATH];
1223	int wlen = xutftowcs_path(wfilename, file_name);
1224	if (wlen < 0)
1225	return -1;
1226
1227	/* strip trailing '/', or GetFileAttributes will fail */
1228	while (wlen && is_dir_sep(wfilename[wlen - 1]))
1229	wfilename[--wlen] = 0;
1230	if (!wlen) {
1231	errno = ENOENT;
1232	return -1;
1233	}
1234
1235	if (GetFileAttributesExW(wfilename, GetFileExInfoStandard, &fdata)) {
1236	/* for reparse points, get the link tag and length */
1237	if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
1238	char tmpbuf[MAX_PATH];
1239
1240	if (read_reparse_point(wfilename, FALSE, tmpbuf,
1241	&link_len, &reparse_tag) < 0)
1242	return -1;
1243	}
1244	buf->st_ino = 0;
1245	buf->st_gid = 0;
1246	buf->st_uid = 0;
1247	buf->st_nlink = 1;
1248	buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes,
1249	reparse_tag);
1250	buf->st_size = S_ISLNK(buf->st_mode) ? link_len :
1251	fdata.nFileSizeLow \| (((off_t) fdata.nFileSizeHigh) << 32);
1252	buf->st_dev = buf->st_rdev = 0; /* not used by Git */
1253	filetime_to_timespec(&(fdata.ftLastAccessTime), &(buf->st_atim));
1254	filetime_to_timespec(&(fdata.ftLastWriteTime), &(buf->st_mtim));
1255	filetime_to_timespec(&(fdata.ftCreationTime), &(buf->st_ctim));
1256	return 0;
1257	}
1258
1259	switch (GetLastError()) {
1260	case ERROR_ACCESS_DENIED:
1261	case ERROR_SHARING_VIOLATION:
1262	case ERROR_LOCK_VIOLATION:
1263	case ERROR_SHARING_BUFFER_EXCEEDED:
1264	errno = EACCES;
1265	break;
1266	case ERROR_BUFFER_OVERFLOW:
1267	errno = ENAMETOOLONG;
1268	break;
1269	case ERROR_NOT_ENOUGH_MEMORY:
1270	errno = ENOMEM;
1271	break;
1272	case ERROR_PATH_NOT_FOUND:
1273	if (!has_valid_directory_prefix(wfilename)) {
1274	errno = ENOTDIR;
1275	break;
1276	}
1277	/* fallthru */
1278	default:
1279	errno = ENOENT;
1280	break;
1281	}
1282	return -1;
1283	}
1284
1285	static int get_file_info_by_handle(HANDLE hnd, struct stat *buf)
1286	{
1287	BY_HANDLE_FILE_INFORMATION fdata;
1288
1289	if (!GetFileInformationByHandle(hnd, &fdata)) {
1290	errno = err_win_to_posix(GetLastError());
1291	return -1;
1292	}
1293
1294	buf->st_ino = 0;
1295	buf->st_gid = 0;
1296	buf->st_uid = 0;
1297	buf->st_nlink = 1;
1298	buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes, 0);
1299	buf->st_size = fdata.nFileSizeLow \|
1300	(((off_t)fdata.nFileSizeHigh)<<32);
1301	buf->st_dev = buf->st_rdev = 0; /* not used by Git */
1302	filetime_to_timespec(&(fdata.ftLastAccessTime), &(buf->st_atim));
1303	filetime_to_timespec(&(fdata.ftLastWriteTime), &(buf->st_mtim));
1304	filetime_to_timespec(&(fdata.ftCreationTime), &(buf->st_ctim));
1305	return 0;
1306	}
1307
1308	int mingw_stat(const char file_name, struct stat buf)
1309	{
1310	wchar_t wfile_name[MAX_PATH];
1311	HANDLE hnd;
1312	int result;
1313
1314	/* open the file and let Windows resolve the links */
1315	if (xutftowcs_path(wfile_name, file_name) < 0)
1316	return -1;
1317	hnd = CreateFileW(wfile_name, 0,
1318	FILE_SHARE_READ \| FILE_SHARE_WRITE \| FILE_SHARE_DELETE, NULL,
1319	OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
1320	if (hnd == INVALID_HANDLE_VALUE) {
1321	DWORD err = GetLastError();
1322
1323	if (err == ERROR_ACCESS_DENIED &&
1324	!mingw_lstat(file_name, buf) &&
1325	!S_ISLNK(buf->st_mode))
1326	/*
1327	* POSIX semantics state to still try to fill
1328	* information, even if permission is denied to create
1329	* a file handle.
1330	*/
1331	return 0;
1332
1333	errno = err_win_to_posix(err);
1334	return -1;
1335	}
1336	result = get_file_info_by_handle(hnd, buf);
1337	CloseHandle(hnd);
1338	return result;
1339	}
1340
1341	int mingw_fstat(int fd, struct stat *buf)
1342	{
1343	HANDLE fh = (HANDLE)_get_osfhandle(fd);
1344	DWORD avail, type = GetFileType(fh) & ~FILE_TYPE_REMOTE;
1345
1346	switch (type) {
1347	case FILE_TYPE_DISK:
1348	return get_file_info_by_handle(fh, buf);
1349
1350	case FILE_TYPE_CHAR:
1351	case FILE_TYPE_PIPE:
1352	/* initialize stat fields */
1353	memset(buf, 0, sizeof(*buf));
1354	buf->st_nlink = 1;
1355
1356	if (type == FILE_TYPE_CHAR) {
1357	buf->st_mode = _S_IFCHR;
1358	} else {
1359	buf->st_mode = _S_IFIFO;
1360	if (PeekNamedPipe(fh, NULL, 0, NULL, &avail, NULL))
1361	buf->st_size = avail;
1362	}
1363	return 0;
1364
1365	default:
1366	errno = EBADF;
1367	return -1;
1368	}
1369	}
1370
1371	static inline void time_t_to_filetime(time_t t, FILETIME *ft)
1372	{
1373	long long winTime = t * 10000000LL + 116444736000000000LL;
1374	ft->dwLowDateTime = winTime;
1375	ft->dwHighDateTime = winTime >> 32;
1376	}
1377
1378	int mingw_utime (const char file_name, const struct utimbuf times)
1379	{
1380	FILETIME mft, aft;
1381	int rc;
1382	DWORD attrs;
1383	wchar_t wfilename[MAX_PATH];
1384	HANDLE osfilehandle;
1385
1386	if (xutftowcs_path(wfilename, file_name) < 0)
1387	return -1;
1388
1389	/* must have write permission */
1390	attrs = GetFileAttributesW(wfilename);
1391	if (attrs != INVALID_FILE_ATTRIBUTES &&
1392	(attrs & FILE_ATTRIBUTE_READONLY)) {
1393	/* ignore errors here; open() will report them */
1394	SetFileAttributesW(wfilename, attrs & ~FILE_ATTRIBUTE_READONLY);
1395	}
1396
1397	osfilehandle = CreateFileW(wfilename,
1398	FILE_WRITE_ATTRIBUTES,
1399	FILE_SHARE_READ \| FILE_SHARE_WRITE \| FILE_SHARE_DELETE,
1400	NULL,
1401	OPEN_EXISTING,
1402	(attrs != INVALID_FILE_ATTRIBUTES &&
1403	(attrs & FILE_ATTRIBUTE_DIRECTORY)) ?
1404	FILE_FLAG_BACKUP_SEMANTICS : 0,
1405	NULL);
1406	if (osfilehandle == INVALID_HANDLE_VALUE) {
1407	errno = err_win_to_posix(GetLastError());
1408	rc = -1;
1409	goto revert_attrs;
1410	}
1411
1412	if (times) {
1413	time_t_to_filetime(times->modtime, &mft);
1414	time_t_to_filetime(times->actime, &aft);
1415	} else {
1416	GetSystemTimeAsFileTime(&mft);
1417	aft = mft;
1418	}
1419
1420	if (!SetFileTime(osfilehandle, NULL, &aft, &mft)) {
1421	errno = EINVAL;
1422	rc = -1;
1423	} else
1424	rc = 0;
1425
1426	if (osfilehandle != INVALID_HANDLE_VALUE)
1427	CloseHandle(osfilehandle);
1428
1429	revert_attrs:
1430	if (attrs != INVALID_FILE_ATTRIBUTES &&
1431	(attrs & FILE_ATTRIBUTE_READONLY)) {
1432	/* ignore errors again */
1433	SetFileAttributesW(wfilename, attrs);
1434	}
1435	return rc;
1436	}
1437
1438	#undef strftime
1439	size_t mingw_strftime(char *s, size_t max,
1440	const char format, const struct tm tm)
1441	{
1442	#ifdef _UCRT
1443	size_t ret = strftime(s, max, format, tm);
1444	#else
1445	/* a pointer to the original strftime in case we can't find the UCRT version */
1446	static size_t (fallback)(char , size_t, const char , const struct tm ) = strftime;
1447	size_t ret;
1448	DECLARE_PROC_ADDR(ucrtbase.dll, size_t, __cdecl, strftime, char *, size_t,
1449	const char , const struct tm );
1450
1451	if (INIT_PROC_ADDR(strftime))
1452	ret = strftime(s, max, format, tm);
1453	else
1454	ret = fallback(s, max, format, tm);
1455	#endif
1456
1457	if (!ret && errno == EINVAL)
1458	die("invalid strftime format: '%s'", format);
1459	return ret;
1460	}
1461
1462	unsigned int sleep (unsigned int seconds)
1463	{
1464	Sleep(seconds*1000);
1465	return 0;
1466	}
1467
1468	int mkstemp(char *template)
1469	{
1470	return git_mkstemp_mode(template, 0600);
1471	}
1472
1473	int gettimeofday(struct timeval tv, void tz UNUSED)
1474	{
1475	FILETIME ft;
1476	long long hnsec;
1477
1478	GetSystemTimeAsFileTime(&ft);
1479	hnsec = filetime_to_hnsec(&ft);
1480	tv->tv_sec = hnsec / 10000000;
1481	tv->tv_usec = (hnsec % 10000000) / 10;
1482	return 0;
1483	}
1484
1485	int pipe(int filedes[2])
1486	{
1487	HANDLE h[2];
1488
1489	/* this creates non-inheritable handles */
1490	if (!CreatePipe(&h[0], &h[1], NULL, 8192)) {
1491	errno = err_win_to_posix(GetLastError());
1492	return -1;
1493	}
1494	filedes[0] = _open_osfhandle(HCAST(int, h[0]), O_NOINHERIT);
1495	if (filedes[0] < 0) {
1496	CloseHandle(h[0]);
1497	CloseHandle(h[1]);
1498	return -1;
1499	}
1500	filedes[1] = _open_osfhandle(HCAST(int, h[1]), O_NOINHERIT);
1501	if (filedes[1] < 0) {
1502	close(filedes[0]);
1503	CloseHandle(h[1]);
1504	return -1;
1505	}
1506	return 0;
1507	}
1508
1509	#ifndef __MINGW64__
1510	struct tm gmtime_r(const time_t timep, struct tm *result)
1511	{
1512	if (gmtime_s(result, timep) == 0)
1513	return result;
1514	return NULL;
1515	}
1516
1517	struct tm localtime_r(const time_t timep, struct tm *result)
1518	{
1519	if (localtime_s(result, timep) == 0)
1520	return result;
1521	return NULL;
1522	}
1523	#endif
1524
1525	char mingw_getcwd(char pointer, int len)
1526	{
1527	wchar_t cwd[MAX_PATH], wpointer[MAX_PATH];
1528	DWORD ret = GetCurrentDirectoryW(ARRAY_SIZE(cwd), cwd);
1529	HANDLE hnd;
1530
1531	if (!ret \|\| ret >= ARRAY_SIZE(cwd)) {
1532	errno = ret ? ENAMETOOLONG : err_win_to_posix(GetLastError());
1533	return NULL;
1534	}
1535	hnd = CreateFileW(cwd, 0,
1536	FILE_SHARE_READ \| FILE_SHARE_WRITE \| FILE_SHARE_DELETE, NULL,
1537	OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
1538	if (hnd != INVALID_HANDLE_VALUE) {
1539	ret = GetFinalPathNameByHandleW(hnd, wpointer, ARRAY_SIZE(wpointer), 0);
1540	CloseHandle(hnd);
1541	if (!ret \|\| ret >= ARRAY_SIZE(wpointer))
1542	return NULL;
1543	if (xwcstoutf(pointer, normalize_ntpath(wpointer), len) < 0)
1544	return NULL;
1545	return pointer;
1546	}
1547	if (GetFileAttributesW(cwd) == INVALID_FILE_ATTRIBUTES) {
1548	errno = ENOENT;
1549	return NULL;
1550	}
1551	if (xwcstoutf(pointer, cwd, len) < 0)
1552	return NULL;
1553	convert_slashes(pointer);
1554	return pointer;
1555	}
1556
1557	/*
1558	* See "Parsing C++ Command-Line Arguments" at Microsoft's Docs:
1559	* https://docs.microsoft.com/en-us/cpp/cpp/parsing-cpp-command-line-arguments
1560	*/
1561	static const char quote_arg_msvc(const char arg)
1562	{
1563	/* count chars to quote */
1564	int len = 0, n = 0;
1565	int force_quotes = 0;
1566	char q, d;
1567	const char *p = arg;
1568	if (!*p) force_quotes = 1;
1569	while (*p) {
1570	if (isspace(p) \|\| p == '' \|\| p == '?' \|\| p == '{' \|\| p == '\'')
1571	force_quotes = 1;
1572	else if (*p == '"')
1573	n++;
1574	else if (*p == '\\') {
1575	int count = 0;
1576	while (*p == '\\') {
1577	count++;
1578	p++;
1579	len++;
1580	}
1581	if (p == '"' \|\| !p)
1582	n += count*2 + 1;
1583	continue;
1584	}
1585	len++;
1586	p++;
1587	}
1588	if (!force_quotes && n == 0)
1589	return arg;
1590
1591	/* insert \ where necessary */
1592	d = q = xmalloc(st_add3(len, n, 3));
1593	*d++ = '"';
1594	while (*arg) {
1595	if (*arg == '"')
1596	*d++ = '\\';
1597	else if (*arg == '\\') {
1598	int count = 0;
1599	while (*arg == '\\') {
1600	count++;
1601	d++ = arg++;
1602	}
1603	if (arg == '"' \|\| !arg) {
1604	while (count-- > 0)
1605	*d++ = '\\';
1606	/* don't escape the surrounding end quote */
1607	if (!*arg)
1608	break;
1609	*d++ = '\\';
1610	}
1611	}
1612	d++ = arg++;
1613	}
1614	*d++ = '"';
1615	*d++ = '\0';
1616	return q;
1617	}
1618
1619	#include "quote.h"
1620
1621	static const char quote_arg_msys2(const char arg)
1622	{
1623	struct strbuf buf = STRBUF_INIT;
1624	const char p2 = arg, p;
1625
1626	for (p = arg; *p; p++) {
1627	int ws = isspace(*p);
1628	if (!ws && p != '\\' && p != '"' && p != '{' && p != '\'' &&
1629	p != '?' && p != '' && p != '~')
1630	continue;
1631	if (!buf.len)
1632	strbuf_addch(&buf, '"');
1633	if (p != p2)
1634	strbuf_add(&buf, p2, p - p2);
1635	if (p == '\\' \|\| p == '"')
1636	strbuf_addch(&buf, '\\');
1637	p2 = p;
1638	}
1639
1640	if (p == arg)
1641	strbuf_addch(&buf, '"');
1642	else if (!buf.len)
1643	return arg;
1644	else
1645	strbuf_add(&buf, p2, p - p2);
1646
1647	strbuf_addch(&buf, '"');
1648	return strbuf_detach(&buf, 0);
1649	}
1650
1651	static const char parse_interpreter(const char cmd)
1652	{
1653	static char buf[100];
1654	char p, opt;
1655	ssize_t n; /* read() can return negative values */
1656	int fd;
1657
1658	/* don't even try a .exe */
1659	n = strlen(cmd);
1660	if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
1661	return NULL;
1662
1663	fd = open(cmd, O_RDONLY);
1664	if (fd < 0)
1665	return NULL;
1666	n = read(fd, buf, sizeof(buf)-1);
1667	close(fd);
1668	if (n < 4) /* at least '#!/x' and not error */
1669	return NULL;
1670
1671	if (buf[0] != '#' \|\| buf[1] != '!')
1672	return NULL;
1673	buf[n] = '\0';
1674	p = buf + strcspn(buf, "\r\n");
1675	if (!*p)
1676	return NULL;
1677
1678	*p = '\0';
1679	if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
1680	return NULL;
1681	/* strip options */
1682	if ((opt = strchr(p+1, ' ')))
1683	*opt = '\0';
1684	return p+1;
1685	}
1686
1687	/*
1688	* exe_only means that we only want to detect .exe files, but not scripts
1689	* (which do not have an extension)
1690	*/
1691	static char lookup_prog(const char dir, int dirlen, const char *cmd,
1692	int isexe, int exe_only)
1693	{
1694	char path[MAX_PATH];
1695	wchar_t wpath[MAX_PATH];
1696	snprintf(path, sizeof(path), "%.*s\\%s.exe", dirlen, dir, cmd);
1697
1698	if (xutftowcs_path(wpath, path) < 0)
1699	return NULL;
1700
1701	if (!isexe && _waccess(wpath, F_OK) == 0)
1702	return xstrdup(path);
1703	wpath[wcslen(wpath)-4] = '\0';
1704	if ((!exe_only \|\| isexe) && _waccess(wpath, F_OK) == 0) {
1705	if (!(GetFileAttributesW(wpath) & FILE_ATTRIBUTE_DIRECTORY)) {
1706	path[strlen(path)-4] = '\0';
1707	return xstrdup(path);
1708	}
1709	}
1710	return NULL;
1711	}
1712
1713	/*
1714	* Determines the absolute path of cmd using the split path in path.
1715	* If cmd contains a slash or backslash, no lookup is performed.
1716	*/
1717	static char path_lookup(const char cmd, int exe_only)
1718	{
1719	const char *path;
1720	char *prog = NULL;
1721	size_t len = strlen(cmd);
1722	int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");
1723
1724	if (strpbrk(cmd, "/\\"))
1725	return xstrdup(cmd);
1726
1727	path = mingw_getenv("PATH");
1728	if (!path)
1729	return NULL;
1730
1731	while (!prog) {
1732	const char *sep = strchrnul(path, ';');
1733	int dirlen = sep - path;
1734	if (dirlen)
1735	prog = lookup_prog(path, dirlen, cmd, isexe, exe_only);
1736	if (!*sep)
1737	break;
1738	path = sep + 1;
1739	}
1740
1741	return prog;
1742	}
1743
1744	char mingw_locate_in_PATH(const char cmd)
1745	{
1746	return path_lookup(cmd, 0);
1747	}
1748
1749	static const wchar_t wcschrnul(const wchar_t s, wchar_t c)
1750	{
1751	while (s && s != c)
1752	s++;
1753	return s;
1754	}
1755
1756	/* Compare only keys */
1757	static int wenvcmp(const void a, const void b)
1758	{
1759	wchar_t p = (wchar_t *)a, q = (wchar_t *)b;
1760	size_t p_len, q_len;
1761
1762	/* Find the keys */
1763	p_len = wcschrnul(p, L'=') - p;
1764	q_len = wcschrnul(q, L'=') - q;
1765
1766	/* If the length differs, include the shorter key's NUL */
1767	if (p_len < q_len)
1768	p_len++;
1769	else if (p_len > q_len)
1770	p_len = q_len + 1;
1771
1772	return _wcsnicmp(p, q, p_len);
1773	}
1774
1775	/*
1776	* Build an environment block combining the inherited environment
1777	* merged with the given list of settings.
1778	*
1779	* Values of the form "KEY=VALUE" in deltaenv override inherited values.
1780	* Values of the form "KEY" in deltaenv delete inherited values.
1781	*
1782	* Multiple entries in deltaenv for the same key are explicitly allowed.
1783	*
1784	* We return a contiguous block of UNICODE strings with a final trailing
1785	* zero word.
1786	*/
1787	static wchar_t make_environment_block(char *deltaenv)
1788	{
1789	wchar_t wenv = GetEnvironmentStringsW(), wdeltaenv, result, p;
1790	size_t wlen, s, delta_size, size;
1791
1792	wchar_t **array = NULL;
1793	size_t alloc = 0, nr = 0, i;
1794
1795	size = 1; /* for extra NUL at the end */
1796
1797	/* If there is no deltaenv to apply, simply return a copy. */
1798	if (!deltaenv \|\| !*deltaenv) {
1799	for (p = wenv; p && *p; ) {
1800	size_t s = wcslen(p) + 1;
1801	size += s;
1802	p += s;
1803	}
1804
1805	DUP_ARRAY(result, wenv, size);
1806	FreeEnvironmentStringsW(wenv);
1807	return result;
1808	}
1809
1810	/*
1811	* If there is a deltaenv, let's accumulate all keys into `array`,
1812	* sort them using the stable git_stable_qsort() and then copy,
1813	* skipping duplicate keys
1814	*/
1815	for (p = wenv; p && *p; ) {
1816	ALLOC_GROW(array, nr + 1, alloc);
1817	s = wcslen(p) + 1;
1818	array[nr++] = p;
1819	p += s;
1820	size += s;
1821	}
1822
1823	/* (over-)assess size needed for wchar version of deltaenv */
1824	for (delta_size = 0, i = 0; deltaenv[i]; i++)
1825	delta_size += strlen(deltaenv[i]) * 2 + 1;
1826	ALLOC_ARRAY(wdeltaenv, delta_size);
1827
1828	/* convert the deltaenv, appending to array */
1829	for (i = 0, p = wdeltaenv; deltaenv[i]; i++) {
1830	ALLOC_GROW(array, nr + 1, alloc);
1831	wlen = xutftowcs(p, deltaenv[i], wdeltaenv + delta_size - p);
1832	array[nr++] = p;
1833	p += wlen + 1;
1834	}
1835
1836	git_stable_qsort(array, nr, sizeof(*array), wenvcmp);
1837	ALLOC_ARRAY(result, size + delta_size);
1838
1839	for (p = result, i = 0; i < nr; i++) {
1840	/* Skip any duplicate keys; last one wins */
1841	while (i + 1 < nr && !wenvcmp(array + i, array + i + 1))
1842	i++;
1843
1844	/* Skip "to delete" entry */
1845	if (!wcschr(array[i], L'='))
1846	continue;
1847
1848	size = wcslen(array[i]) + 1;
1849	COPY_ARRAY(p, array[i], size);
1850	p += size;
1851	}
1852	*p = L'\0';
1853
1854	free(array);
1855	free(wdeltaenv);
1856	FreeEnvironmentStringsW(wenv);
1857	return result;
1858	}
1859
1860	static void do_unset_environment_variables(void)
1861	{
1862	static int done;
1863	char *p = unset_environment_variables;
1864
1865	if (done \|\| !p)
1866	return;
1867	done = 1;
1868
1869	for (;;) {
1870	char *comma = strchr(p, ',');
1871
1872	if (comma)
1873	*comma = '\0';
1874	unsetenv(p);
1875	if (!comma)
1876	break;
1877	p = comma + 1;
1878	}
1879	}
1880
1881	struct pinfo_t {
1882	struct pinfo_t *next;
1883	pid_t pid;
1884	HANDLE proc;
1885	};
1886	static struct pinfo_t *pinfo = NULL;
1887	CRITICAL_SECTION pinfo_cs;
1888
1889	/* Used to match and chomp off path components */
1890	static inline int match_last_path_component(const char path, size_t len,
1891	const char *component)
1892	{
1893	size_t component_len = strlen(component);
1894	if (*len < component_len + 1 \|\|
1895	!is_dir_sep(path[*len - component_len - 1]) \|\|
1896	fspathncmp(path + *len - component_len, component, component_len))
1897	return 0;
1898	*len -= component_len + 1;
1899	/* chomp off repeated dir separators */
1900	while (len > 0 && is_dir_sep(path[len - 1]))
1901	(*len)--;
1902	return 1;
1903	}
1904
1905	static int is_msys2_sh(const char *cmd)
1906	{
1907	if (!cmd)
1908	return 0;
1909
1910	if (!strcmp(cmd, "sh")) {
1911	static int ret = -1;
1912	char *p;
1913
1914	if (ret >= 0)
1915	return ret;
1916
1917	p = path_lookup(cmd, 0);
1918	if (!p)
1919	ret = 0;
1920	else {
1921	size_t len = strlen(p);
1922
1923	ret = match_last_path_component(p, &len, "sh.exe") &&
1924	match_last_path_component(p, &len, "bin") &&
1925	match_last_path_component(p, &len, "usr");
1926	free(p);
1927	}
1928	return ret;
1929	}
1930
1931	if (ends_with(cmd, "\\sh.exe") \|\| ends_with(cmd, "/sh.exe")) {
1932	static char *sh;
1933
1934	if (!sh)
1935	sh = path_lookup("sh", 0);
1936
1937	return !fspathcmp(cmd, sh);
1938	}
1939
1940	return 0;
1941	}
1942
1943	static pid_t mingw_spawnve_fd(const char cmd, const char argv, char *deltaenv,
1944	const char *dir,
1945	int prepend_cmd, int fhin, int fhout, int fherr)
1946	{
1947	STARTUPINFOEXW si;
1948	PROCESS_INFORMATION pi;
1949	LPPROC_THREAD_ATTRIBUTE_LIST attr_list = NULL;
1950	HANDLE stdhandles[3];
1951	DWORD stdhandles_count = 0;
1952	SIZE_T size;
1953	struct strbuf args;
1954	wchar_t wcmd[MAX_PATH], wdir[MAX_PATH], wargs, wenvblk = NULL;
1955	unsigned flags = CREATE_UNICODE_ENVIRONMENT;
1956	BOOL ret;
1957	HANDLE cons;
1958	const char (quote_arg)(const char *arg) =
1959	is_msys2_sh(cmd ? cmd : *argv) ?
1960	quote_arg_msys2 : quote_arg_msvc;
1961	const char *strace_env;
1962
1963	/* Make sure to override previous errors, if any */
1964	errno = 0;
1965
1966	do_unset_environment_variables();
1967
1968	/* Determine whether or not we are associated to a console */
1969	cons = CreateFileW(L"CONOUT$", GENERIC_WRITE,
1970	FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1971	FILE_ATTRIBUTE_NORMAL, NULL);
1972	if (cons == INVALID_HANDLE_VALUE) {
1973	/* There is no console associated with this process.
1974	* Since the child is a console process, Windows
1975	* would normally create a console window. But
1976	* since we'll be redirecting std streams, we do
1977	* not need the console.
1978	* It is necessary to use DETACHED_PROCESS
1979	* instead of CREATE_NO_WINDOW to make ssh
1980	* recognize that it has no console.
1981	*/
1982	flags \|= DETACHED_PROCESS;
1983	} else {
1984	/* There is already a console. If we specified
1985	* DETACHED_PROCESS here, too, Windows would
1986	* disassociate the child from the console.
1987	* The same is true for CREATE_NO_WINDOW.
1988	* Go figure!
1989	*/
1990	CloseHandle(cons);
1991	}
1992	memset(&si, 0, sizeof(si));
1993	si.StartupInfo.cb = sizeof(si);
1994	si.StartupInfo.hStdInput = winansi_get_osfhandle(fhin);
1995	si.StartupInfo.hStdOutput = winansi_get_osfhandle(fhout);
1996	si.StartupInfo.hStdError = winansi_get_osfhandle(fherr);
1997
1998	/* The list of handles cannot contain duplicates */
1999	if (si.StartupInfo.hStdInput != INVALID_HANDLE_VALUE)
2000	stdhandles[stdhandles_count++] = si.StartupInfo.hStdInput;
2001	if (si.StartupInfo.hStdOutput != INVALID_HANDLE_VALUE &&
2002	si.StartupInfo.hStdOutput != si.StartupInfo.hStdInput)
2003	stdhandles[stdhandles_count++] = si.StartupInfo.hStdOutput;
2004	if (si.StartupInfo.hStdError != INVALID_HANDLE_VALUE &&
2005	si.StartupInfo.hStdError != si.StartupInfo.hStdInput &&
2006	si.StartupInfo.hStdError != si.StartupInfo.hStdOutput)
2007	stdhandles[stdhandles_count++] = si.StartupInfo.hStdError;
2008	if (stdhandles_count)
2009	si.StartupInfo.dwFlags \|= STARTF_USESTDHANDLES;
2010
2011	if (argv && !strcmp(cmd, argv))
2012	wcmd[0] = L'\0';
2013	else if (xutftowcs_path(wcmd, cmd) < 0)
2014	return -1;
2015	if (dir && xutftowcs_path(wdir, dir) < 0)
2016	return -1;
2017
2018	/* concatenate argv, quoting args as we go */
2019	strbuf_init(&args, 0);
2020	if (prepend_cmd) {
2021	char quoted = (char )quote_arg(cmd);
2022	strbuf_addstr(&args, quoted);
2023	if (quoted != cmd)
2024	free(quoted);
2025	}
2026	for (; *argv; argv++) {
2027	char quoted = (char )quote_arg(*argv);
2028	if (*args.buf)
2029	strbuf_addch(&args, ' ');
2030	strbuf_addstr(&args, quoted);
2031	if (quoted != *argv)
2032	free(quoted);
2033	}
2034
2035	strace_env = getenv("GIT_STRACE_COMMANDS");
2036	if (strace_env) {
2037	char *p = path_lookup("strace.exe", 1);
2038	if (!p)
2039	return error("strace not found!");
2040	if (xutftowcs_path(wcmd, p) < 0) {
2041	free(p);
2042	return -1;
2043	}
2044	free(p);
2045	if (!strcmp("1", strace_env) \|\|
2046	!strcasecmp("yes", strace_env) \|\|
2047	!strcasecmp("true", strace_env))
2048	strbuf_insert(&args, 0, "strace ", 7);
2049	else {
2050	const char *quoted = quote_arg(strace_env);
2051	struct strbuf buf = STRBUF_INIT;
2052	strbuf_addf(&buf, "strace -o %s ", quoted);
2053	if (quoted != strace_env)
2054	free((char *)quoted);
2055	strbuf_insert(&args, 0, buf.buf, buf.len);
2056	strbuf_release(&buf);
2057	}
2058	}
2059
2060	ALLOC_ARRAY(wargs, st_add(st_mult(2, args.len), 1));
2061	xutftowcs(wargs, args.buf, 2 * args.len + 1);
2062	strbuf_release(&args);
2063
2064	wenvblk = make_environment_block(deltaenv);
2065
2066	memset(&pi, 0, sizeof(pi));
2067	if (stdhandles_count &&
2068	(InitializeProcThreadAttributeList(NULL, 1, 0, &size) \|\|
2069	GetLastError() == ERROR_INSUFFICIENT_BUFFER) &&
2070	(attr_list = (LPPROC_THREAD_ATTRIBUTE_LIST)
2071	(HeapAlloc(GetProcessHeap(), 0, size))) &&
2072	InitializeProcThreadAttributeList(attr_list, 1, 0, &size) &&
2073	UpdateProcThreadAttribute(attr_list, 0,
2074	PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
2075	stdhandles,
2076	stdhandles_count * sizeof(HANDLE),
2077	NULL, NULL)) {
2078	si.lpAttributeList = attr_list;
2079	flags \|= EXTENDED_STARTUPINFO_PRESENT;
2080	}
2081
2082	ret = CreateProcessW(*wcmd ? wcmd : NULL, wargs, NULL, NULL,
2083	stdhandles_count ? TRUE : FALSE,
2084	flags, wenvblk, dir ? wdir : NULL,
2085	&si.StartupInfo, &pi);
2086
2087	/*
2088	* On the off-chance that something with the file handle restriction
2089	* went wrong, silently fall back to trying without it.
2090	*/
2091	if (!ret && stdhandles_count) {
2092	DWORD err = GetLastError();
2093	struct strbuf buf = STRBUF_INIT;
2094
2095	flags &= ~EXTENDED_STARTUPINFO_PRESENT;
2096	ret = CreateProcessW(*wcmd ? wcmd : NULL, wargs, NULL, NULL,
2097	TRUE, flags, wenvblk, dir ? wdir : NULL,
2098	&si.StartupInfo, &pi);
2099	if (!ret)
2100	errno = err_win_to_posix(GetLastError());
2101	if (ret && buf.len) {
2102	warning("failed to restrict file handles (%ld)\n\n%s",
2103	err, buf.buf);
2104	}
2105	strbuf_release(&buf);
2106	} else if (!ret)
2107	errno = err_win_to_posix(GetLastError());
2108
2109	if (si.lpAttributeList)
2110	DeleteProcThreadAttributeList(si.lpAttributeList);
2111	if (attr_list)
2112	HeapFree(GetProcessHeap(), 0, attr_list);
2113
2114	free(wenvblk);
2115	free(wargs);
2116
2117	if (!ret)
2118	return -1;
2119
2120	CloseHandle(pi.hThread);
2121
2122	/*
2123	* The process ID is the human-readable identifier of the process
2124	* that we want to present in log and error messages. The handle
2125	* is not useful for this purpose. But we cannot close it, either,
2126	* because it is not possible to turn a process ID into a process
2127	* handle after the process terminated.
2128	* Keep the handle in a list for waitpid.
2129	*/
2130	EnterCriticalSection(&pinfo_cs);
2131	{
2132	struct pinfo_t *info = xmalloc(sizeof(struct pinfo_t));
2133	info->pid = pi.dwProcessId;
2134	info->proc = pi.hProcess;
2135	info->next = pinfo;
2136	pinfo = info;
2137	}
2138	LeaveCriticalSection(&pinfo_cs);
2139
2140	return (pid_t)pi.dwProcessId;
2141	}
2142
2143	static pid_t mingw_spawnv(const char cmd, const char *argv, int prepend_cmd)
2144	{
2145	return mingw_spawnve_fd(cmd, argv, NULL, NULL, prepend_cmd, 0, 1, 2);
2146	}
2147
2148	pid_t mingw_spawnvpe(const char cmd, const char argv, char *deltaenv,
2149	const char *dir,
2150	int fhin, int fhout, int fherr)
2151	{
2152	pid_t pid;
2153	char *prog = path_lookup(cmd, 0);
2154
2155	if (!prog) {
2156	errno = ENOENT;
2157	pid = -1;
2158	}
2159	else {
2160	const char *interpr = parse_interpreter(prog);
2161
2162	if (interpr) {
2163	const char *argv0 = argv[0];
2164	char *iprog = path_lookup(interpr, 1);
2165	argv[0] = prog;
2166	if (!iprog) {
2167	errno = ENOENT;
2168	pid = -1;
2169	}
2170	else {
2171	pid = mingw_spawnve_fd(iprog, argv, deltaenv, dir, 1,
2172	fhin, fhout, fherr);
2173	free(iprog);
2174	}
2175	argv[0] = argv0;
2176	}
2177	else
2178	pid = mingw_spawnve_fd(prog, argv, deltaenv, dir, 0,
2179	fhin, fhout, fherr);
2180	free(prog);
2181	}
2182	return pid;
2183	}
2184
2185	static int try_shell_exec(const char cmd, char const *argv)
2186	{
2187	const char *interpr = parse_interpreter(cmd);
2188	char *prog;
2189	int pid = 0;
2190
2191	if (!interpr)
2192	return 0;
2193	prog = path_lookup(interpr, 1);
2194	if (prog) {
2195	int exec_id;
2196	int argc = 0;
2197	char **argv2;
2198	while (argv[argc]) argc++;
2199	ALLOC_ARRAY(argv2, argc + 1);
2200	argv2[0] = (char )cmd; / full path to the script file */
2201	COPY_ARRAY(&argv2[1], &argv[1], argc);
2202	exec_id = trace2_exec(prog, (const char **)argv2);
2203	pid = mingw_spawnv(prog, (const char **)argv2, 1);
2204	if (pid >= 0) {
2205	int status;
2206	if (waitpid(pid, &status, 0) < 0)
2207	status = 255;
2208	trace2_exec_result(exec_id, status);
2209	exit(status);
2210	}
2211	trace2_exec_result(exec_id, -1);
2212	pid = 1; /* indicate that we tried but failed */
2213	free(prog);
2214	free(argv2);
2215	}
2216	return pid;
2217	}
2218
2219	int mingw_execv(const char cmd, char const *argv)
2220	{
2221	/* check if git_command is a shell script */
2222	if (!try_shell_exec(cmd, argv)) {
2223	int pid, status;
2224	int exec_id;
2225
2226	exec_id = trace2_exec(cmd, (const char **)argv);
2227	pid = mingw_spawnv(cmd, (const char **)argv, 0);
2228	if (pid < 0) {
2229	trace2_exec_result(exec_id, -1);
2230	return -1;
2231	}
2232	if (waitpid(pid, &status, 0) < 0)
2233	status = 255;
2234	trace2_exec_result(exec_id, status);
2235	exit(status);
2236	}
2237	return -1;
2238	}
2239
2240	int mingw_execvp(const char cmd, char const *argv)
2241	{
2242	char *prog = path_lookup(cmd, 0);
2243
2244	if (prog) {
2245	mingw_execv(prog, argv);
2246	free(prog);
2247	} else
2248	errno = ENOENT;
2249
2250	return -1;
2251	}
2252
2253	int mingw_kill(pid_t pid, int sig)
2254	{
2255	if (pid > 0 && sig == SIGTERM) {
2256	HANDLE h = OpenProcess(PROCESS_CREATE_THREAD \|
2257	PROCESS_QUERY_INFORMATION \|
2258	PROCESS_VM_OPERATION \| PROCESS_VM_WRITE \|
2259	PROCESS_VM_READ \| PROCESS_TERMINATE,
2260	FALSE, pid);
2261	int ret;
2262
2263	if (h)
2264	ret = exit_process(h, 128 + sig);
2265	else {
2266	h = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
2267	if (!h) {
2268	errno = err_win_to_posix(GetLastError());
2269	return -1;
2270	}
2271	ret = terminate_process_tree(h, 128 + sig);
2272	}
2273	if (ret)
2274	errno = err_win_to_posix(GetLastError());
2275	return ret;
2276	} else if (pid > 0 && sig == 0) {
2277	HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
2278	if (h) {
2279	CloseHandle(h);
2280	return 0;
2281	}
2282	/*
2283	* OpenProcess returns ERROR_INVALID_PARAMETER for
2284	* non-existent PIDs. Map this to ESRCH for POSIX
2285	* compatibility with kill(pid, 0).
2286	*/
2287	if (GetLastError() == ERROR_INVALID_PARAMETER)
2288	errno = ESRCH;
2289	else
2290	errno = err_win_to_posix(GetLastError());
2291	return -1;
2292	}
2293
2294	errno = EINVAL;
2295	return -1;
2296	}
2297
2298	/*
2299	* UTF-8 versions of getenv(), putenv() and unsetenv().
2300	* Internally, they use the CRT's stock UNICODE routines
2301	* to avoid data loss.
2302	*/
2303	char mingw_getenv(const char name)
2304	{
2305	#define GETENV_MAX_RETAIN 64
2306	static char *values[GETENV_MAX_RETAIN];
2307	static int value_counter;
2308	size_t len_key, len_value;
2309	wchar_t *w_key;
2310	char *value;
2311	wchar_t w_value[32768];
2312
2313	if (!name \|\| !*name)
2314	return NULL;
2315
2316	len_key = strlen(name) + 1;
2317	/* We cannot use xcalloc() here because that uses getenv() itself */
2318	w_key = calloc(len_key, sizeof(wchar_t));
2319	if (!w_key)
2320	die("Out of memory, (tried to allocate %"PRIuMAX" wchar_t's)",
2321	(uintmax_t)len_key);
2322	xutftowcs(w_key, name, len_key);
2323	/* GetEnvironmentVariableW() only sets the last error upon failure */
2324	SetLastError(ERROR_SUCCESS);
2325	len_value = GetEnvironmentVariableW(w_key, w_value, ARRAY_SIZE(w_value));
2326	if (!len_value && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
2327	free(w_key);
2328	return NULL;
2329	}
2330	free(w_key);
2331
2332	len_value = len_value * 3 + 1;
2333	/* We cannot use xcalloc() here because that uses getenv() itself */
2334	value = calloc(len_value, sizeof(char));
2335	if (!value)
2336	die("Out of memory, (tried to allocate %"PRIuMAX" bytes)",
2337	(uintmax_t)len_value);
2338	xwcstoutf(value, w_value, len_value);
2339
2340	/*
2341	* We return `value` which is an allocated value and the caller is NOT
2342	* expecting to have to free it, so we keep a round-robin array,
2343	* invalidating the buffer after GETENV_MAX_RETAIN getenv() calls.
2344	*/
2345	free(values[value_counter]);
2346	values[value_counter++] = value;
2347	if (value_counter >= ARRAY_SIZE(values))
2348	value_counter = 0;
2349
2350	return value;
2351	}
2352
2353	int mingw_putenv(const char *namevalue)
2354	{
2355	size_t size;
2356	wchar_t wide, equal;
2357	BOOL result;
2358
2359	if (!namevalue \|\| !*namevalue)
2360	return 0;
2361
2362	size = strlen(namevalue) * 2 + 1;
2363	wide = calloc(size, sizeof(wchar_t));
2364	if (!wide)
2365	die("Out of memory, (tried to allocate %" PRIuMAX " wchar_t's)",
2366	(uintmax_t)size);
2367	xutftowcs(wide, namevalue, size);
2368	equal = wcschr(wide, L'=');
2369	if (!equal)
2370	result = SetEnvironmentVariableW(wide, NULL);
2371	else {
2372	*equal = L'\0';
2373	result = SetEnvironmentVariableW(wide, equal + 1);
2374	}
2375	free(wide);
2376
2377	if (!result)
2378	errno = err_win_to_posix(GetLastError());
2379
2380	return result ? 0 : -1;
2381	}
2382
2383	static void ensure_socket_initialization(void)
2384	{
2385	WSADATA wsa;
2386	static int initialized = 0;
2387
2388	if (initialized)
2389	return;
2390
2391	if (WSAStartup(MAKEWORD(2,2), &wsa))
2392	die("unable to initialize winsock subsystem, error %d",
2393	WSAGetLastError());
2394
2395	atexit((void(*)(void)) WSACleanup);
2396	initialized = 1;
2397	}
2398
2399	#undef gethostname
2400	int mingw_gethostname(char *name, int namelen)
2401	{
2402	ensure_socket_initialization();
2403	return gethostname(name, namelen);
2404	}
2405
2406	#undef gethostbyname
2407	struct hostent mingw_gethostbyname(const char host)
2408	{
2409	ensure_socket_initialization();
2410	return gethostbyname(host);
2411	}
2412
2413	#undef getaddrinfo
2414	int mingw_getaddrinfo(const char node, const char service,
2415	const struct addrinfo hints, struct addrinfo *res)
2416	{
2417	ensure_socket_initialization();
2418	return getaddrinfo(node, service, hints, res);
2419	}
2420
2421	int mingw_socket(int domain, int type, int protocol)
2422	{
2423	int sockfd;
2424	SOCKET s;
2425
2426	ensure_socket_initialization();
2427	s = WSASocket(domain, type, protocol, NULL, 0, 0);
2428	if (s == INVALID_SOCKET) {
2429	/*
2430	* WSAGetLastError() values are regular BSD error codes
2431	* biased by WSABASEERR.
2432	* However, strerror() does not know about networking
2433	* specific errors, which are values beginning at 38 or so.
2434	* Therefore, we choose to leave the biased error code
2435	* in errno so that _if_ someone looks up the code somewhere,
2436	* then it is at least the number that are usually listed.
2437	*/
2438	errno = WSAGetLastError();
2439	return -1;
2440	}
2441	/* convert into a file descriptor */
2442	if ((sockfd = _open_osfhandle(s, O_RDWR\|O_BINARY)) < 0) {
2443	closesocket(s);
2444	return error("unable to make a socket file descriptor: %s",
2445	strerror(errno));
2446	}
2447	return sockfd;
2448	}
2449
2450	#undef connect
2451	int mingw_connect(int sockfd, struct sockaddr *sa, size_t sz)
2452	{
2453	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2454	return connect(s, sa, sz);
2455	}
2456
2457	#undef bind
2458	int mingw_bind(int sockfd, struct sockaddr *sa, size_t sz)
2459	{
2460	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2461	return bind(s, sa, sz);
2462	}
2463
2464	#undef setsockopt
2465	int mingw_setsockopt(int sockfd, int lvl, int optname, void *optval, int optlen)
2466	{
2467	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2468	return setsockopt(s, lvl, optname, (const char*)optval, optlen);
2469	}
2470
2471	#undef shutdown
2472	int mingw_shutdown(int sockfd, int how)
2473	{
2474	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2475	return shutdown(s, how);
2476	}
2477
2478	#undef listen
2479	int mingw_listen(int sockfd, int backlog)
2480	{
2481	SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2482	return listen(s, backlog);
2483	}
2484
2485	#undef accept
2486	int mingw_accept(int sockfd1, struct sockaddr sa, socklen_t sz)
2487	{
2488	int sockfd2;
2489
2490	SOCKET s1 = (SOCKET)_get_osfhandle(sockfd1);
2491	SOCKET s2 = accept(s1, sa, sz);
2492
2493	/* convert into a file descriptor */
2494	if ((sockfd2 = _open_osfhandle(s2, O_RDWR\|O_BINARY)) < 0) {
2495	int err = errno;
2496	closesocket(s2);
2497	return error("unable to make a socket file descriptor: %s",
2498	strerror(err));
2499	}
2500	return sockfd2;
2501	}
2502
2503	#undef rename
2504	int mingw_rename(const char pold, const char pnew)
2505	{
2506	static int supports_file_rename_info_ex = 1;
2507	DWORD attrs = INVALID_FILE_ATTRIBUTES, gle;
2508	int tries = 0;
2509	wchar_t wpold[MAX_PATH], wpnew[MAX_PATH];
2510	int wpnew_len;
2511
2512	if (xutftowcs_path(wpold, pold) < 0)
2513	return -1;
2514	wpnew_len = xutftowcs_path(wpnew, pnew);
2515	if (wpnew_len < 0)
2516	return -1;
2517
2518	repeat:
2519	if (supports_file_rename_info_ex) {
2520	/*
2521	* Our minimum required Windows version is still set to Windows
2522	* 8.1. We thus have to declare required infrastructure for
2523	* FileRenameInfoEx ourselves until we bump _WIN32_WINNT to
2524	* 0x0A00. Furthermore, we have to handle cases where the
2525	* FileRenameInfoEx call isn't supported yet.
2526	*/
2527	#define FILE_RENAME_FLAG_REPLACE_IF_EXISTS 0x00000001
2528	#define FILE_RENAME_FLAG_POSIX_SEMANTICS 0x00000002
2529	FILE_INFO_BY_HANDLE_CLASS FileRenameInfoEx = 22;
2530	struct {
2531	/*
2532	* This is usually an unnamed union, but that is not
2533	* part of ISO C99. We thus inline the field, as we
2534	* really only care for the Flags field anyway.
2535	*/
2536	DWORD Flags;
2537	HANDLE RootDirectory;
2538	DWORD FileNameLength;
2539	/*
2540	* The actual structure is defined with a single-character
2541	* flex array so that the structure has to be allocated on
2542	* the heap. As we declare this structure ourselves though
2543	* we can avoid the allocation and define FileName to have
2544	* MAX_PATH bytes.
2545	*/
2546	WCHAR FileName[MAX_PATH];
2547	} rename_info = { 0 };
2548	HANDLE old_handle = INVALID_HANDLE_VALUE;
2549	BOOL success;
2550
2551	old_handle = CreateFileW(wpold, DELETE,
2552	FILE_SHARE_WRITE \| FILE_SHARE_READ \| FILE_SHARE_DELETE,
2553	NULL, OPEN_EXISTING,
2554	FILE_FLAG_BACKUP_SEMANTICS \| FILE_FLAG_OPEN_REPARSE_POINT,
2555	NULL);
2556	if (old_handle == INVALID_HANDLE_VALUE) {
2557	errno = err_win_to_posix(GetLastError());
2558	return -1;
2559	}
2560
2561	rename_info.Flags = FILE_RENAME_FLAG_REPLACE_IF_EXISTS \|
2562	FILE_RENAME_FLAG_POSIX_SEMANTICS;
2563	rename_info.FileNameLength = wpnew_len * sizeof(WCHAR);
2564	memcpy(rename_info.FileName, wpnew, wpnew_len * sizeof(WCHAR));
2565
2566	success = SetFileInformationByHandle(old_handle, FileRenameInfoEx,
2567	&rename_info, sizeof(rename_info));
2568	gle = GetLastError();
2569	CloseHandle(old_handle);
2570	if (success)
2571	return 0;
2572
2573	/*
2574	* When we see ERROR_INVALID_PARAMETER we can assume that the
2575	* current system doesn't support FileRenameInfoEx. Keep us
2576	* from using it in future calls and retry.
2577	*/
2578	if (gle == ERROR_INVALID_PARAMETER \|\|
2579	gle == ERROR_NOT_SUPPORTED \|\|
2580	gle == ERROR_INVALID_FUNCTION) {
2581	supports_file_rename_info_ex = 0;
2582	goto repeat;
2583	}
2584
2585	/*
2586	* In theory, we shouldn't get ERROR_ACCESS_DENIED because we
2587	* always open files with FILE_SHARE_DELETE But in practice we
2588	* cannot assume that Git is the only one accessing files, and
2589	* other applications may not set FILE_SHARE_DELETE. So we have
2590	* to retry.
2591	*/
2592	} else {
2593	if (MoveFileExW(wpold, wpnew,
2594	MOVEFILE_REPLACE_EXISTING \| MOVEFILE_COPY_ALLOWED))
2595	return 0;
2596	gle = GetLastError();
2597	}
2598
2599	/* revert file attributes on failure */
2600	if (attrs != INVALID_FILE_ATTRIBUTES)
2601	SetFileAttributesW(wpnew, attrs);
2602
2603	if (!is_file_in_use_error(gle)) {
2604	errno = err_win_to_posix(gle);
2605	return -1;
2606	}
2607
2608	if (attrs == INVALID_FILE_ATTRIBUTES &&
2609	(attrs = GetFileAttributesW(wpnew)) != INVALID_FILE_ATTRIBUTES) {
2610	if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
2611	DWORD attrsold = GetFileAttributesW(wpold);
2612	if (attrsold == INVALID_FILE_ATTRIBUTES \|\|
2613	!(attrsold & FILE_ATTRIBUTE_DIRECTORY))
2614	errno = EISDIR;
2615	else if (!_wrmdir(wpnew))
2616	goto repeat;
2617	return -1;
2618	}
2619	if ((attrs & FILE_ATTRIBUTE_READONLY) &&
2620	SetFileAttributesW(wpnew, attrs & ~FILE_ATTRIBUTE_READONLY))
2621	goto repeat;
2622	}
2623	if (retry_ask_yes_no(&tries, "Rename from '%s' to '%s' failed. "
2624	"Should I try again?", pold, pnew))
2625	goto repeat;
2626
2627	errno = EACCES;
2628	return -1;
2629	}
2630
2631	/*
2632	* Note that this doesn't return the actual pagesize, but
2633	* the allocation granularity. If future Windows specific git code
2634	* needs the real getpagesize function, we need to find another solution.
2635	*/
2636	int mingw_getpagesize(void)
2637	{
2638	SYSTEM_INFO si;
2639	GetSystemInfo(&si);
2640	return si.dwAllocationGranularity;
2641	}
2642
2643	/* See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724435.aspx */
2644	enum EXTENDED_NAME_FORMAT {
2645	NameDisplay = 3,
2646	NameUserPrincipal = 8
2647	};
2648
2649	static char *get_extended_user_info(enum EXTENDED_NAME_FORMAT type)
2650	{
2651	DECLARE_PROC_ADDR(secur32.dll, BOOL, SEC_ENTRY, GetUserNameExW,
2652	enum EXTENDED_NAME_FORMAT, LPCWSTR, PULONG);
2653	static wchar_t wbuffer[1024];
2654	DWORD len;
2655
2656	if (!INIT_PROC_ADDR(GetUserNameExW))
2657	return NULL;
2658
2659	len = ARRAY_SIZE(wbuffer);
2660	if (GetUserNameExW(type, wbuffer, &len)) {
2661	char converted = xmalloc((len = 3));
2662	if (xwcstoutf(converted, wbuffer, len) >= 0)
2663	return converted;
2664	free(converted);
2665	}
2666
2667	return NULL;
2668	}
2669
2670	char *mingw_query_user_email(void)
2671	{
2672	return get_extended_user_info(NameUserPrincipal);
2673	}
2674
2675	struct passwd *getpwuid(int uid UNUSED)
2676	{
2677	static unsigned initialized;
2678	static char user_name[100];
2679	static struct passwd *p;
2680	wchar_t buf[100];
2681	DWORD len;
2682
2683	if (initialized)
2684	return p;
2685
2686	len = ARRAY_SIZE(buf);
2687	if (!GetUserNameW(buf, &len)) {
2688	initialized = 1;
2689	return NULL;
2690	}
2691
2692	if (xwcstoutf(user_name, buf, sizeof(user_name)) < 0) {
2693	initialized = 1;
2694	return NULL;
2695	}
2696
2697	p = xmalloc(sizeof(*p));
2698	p->pw_name = user_name;
2699	p->pw_gecos = get_extended_user_info(NameDisplay);
2700	if (!p->pw_gecos)
2701	/*
2702	* Data returned by getpwuid(3P) is treated as internal and
2703	* must never be written to or freed.
2704	*/
2705	p->pw_gecos = (char *) "unknown";
2706	p->pw_dir = NULL;
2707
2708	initialized = 1;
2709	return p;
2710	}
2711
2712	static HANDLE timer_event;
2713	static HANDLE timer_thread;
2714	static int timer_interval;
2715	static int one_shot;
2716	static sig_handler_t timer_fn = SIG_DFL, sigint_fn = SIG_DFL;
2717
2718	/* The timer works like this:
2719	* The thread, ticktack(), is a trivial routine that most of the time
2720	* only waits to receive the signal to terminate. The main thread tells
2721	* the thread to terminate by setting the timer_event to the signalled
2722	* state.
2723	* But ticktack() interrupts the wait state after the timer's interval
2724	* length to call the signal handler.
2725	*/
2726
2727	static unsigned __stdcall ticktack(void *dummy UNUSED)
2728	{
2729	while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
2730	mingw_raise(SIGALRM);
2731	if (one_shot)
2732	break;
2733	}
2734	return 0;
2735	}
2736
2737	static int start_timer_thread(void)
2738	{
2739	timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
2740	if (timer_event) {
2741	timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
2742	if (!timer_thread ) {
2743	errno = ENOMEM;
2744	return error("cannot start timer thread");
2745	}
2746	} else {
2747	errno = ENOMEM;
2748	return error("cannot allocate resources for timer");
2749	}
2750	return 0;
2751	}
2752
2753	static void stop_timer_thread(void)
2754	{
2755	if (timer_event)
2756	SetEvent(timer_event); /* tell thread to terminate */
2757	if (timer_thread) {
2758	int rc = WaitForSingleObject(timer_thread, 10000);
2759	if (rc == WAIT_TIMEOUT)
2760	error("timer thread did not terminate timely");
2761	else if (rc != WAIT_OBJECT_0)
2762	error("waiting for timer thread failed: %lu",
2763	GetLastError());
2764	CloseHandle(timer_thread);
2765	}
2766	if (timer_event)
2767	CloseHandle(timer_event);
2768	timer_event = NULL;
2769	timer_thread = NULL;
2770	}
2771
2772	static inline int is_timeval_eq(const struct timeval i1, const struct timeval i2)
2773	{
2774	return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
2775	}
2776
2777	int setitimer(int type UNUSED, struct itimerval in, struct itimerval out)
2778	{
2779	static const struct timeval zero;
2780	static int atexit_done;
2781
2782	if (out) {
2783	errno = EINVAL;
2784	return error("setitimer param 3 != NULL not implemented");
2785	}
2786	if (!is_timeval_eq(&in->it_interval, &zero) &&
2787	!is_timeval_eq(&in->it_interval, &in->it_value)) {
2788	errno = EINVAL;
2789	return error("setitimer: it_interval must be zero or eq it_value");
2790	}
2791
2792	if (timer_thread)
2793	stop_timer_thread();
2794
2795	if (is_timeval_eq(&in->it_value, &zero) &&
2796	is_timeval_eq(&in->it_interval, &zero))
2797	return 0;
2798
2799	timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
2800	one_shot = is_timeval_eq(&in->it_interval, &zero);
2801	if (!atexit_done) {
2802	atexit(stop_timer_thread);
2803	atexit_done = 1;
2804	}
2805	return start_timer_thread();
2806	}
2807
2808	int sigaction(int sig, struct sigaction in, struct sigaction out)
2809	{
2810	if (sig == SIGCHLD)
2811	return -1;
2812	else if (sig != SIGALRM) {
2813	errno = EINVAL;
2814	return error("sigaction only implemented for SIGALRM");
2815	}
2816	if (out) {
2817	errno = EINVAL;
2818	return error("sigaction: param 3 != NULL not implemented");
2819	}
2820
2821	timer_fn = in->sa_handler;
2822	return 0;
2823	}
2824
2825	#undef signal
2826	sig_handler_t mingw_signal(int sig, sig_handler_t handler)
2827	{
2828	sig_handler_t old;
2829
2830	switch (sig) {
2831	case SIGALRM:
2832	old = timer_fn;
2833	timer_fn = handler;
2834	break;
2835
2836	case SIGINT:
2837	old = sigint_fn;
2838	sigint_fn = handler;
2839	break;
2840
2841	default:
2842	return signal(sig, handler);
2843	}
2844
2845	return old;
2846	}
2847
2848	#undef raise
2849	int mingw_raise(int sig)
2850	{
2851	switch (sig) {
2852	case SIGALRM:
2853	if (timer_fn == SIG_DFL) {
2854	if (isatty(STDERR_FILENO))
2855	fputs("Alarm clock\n", stderr);
2856	exit(128 + SIGALRM);
2857	} else if (timer_fn != SIG_IGN)
2858	timer_fn(SIGALRM);
2859	return 0;
2860
2861	case SIGINT:
2862	if (sigint_fn == SIG_DFL)
2863	exit(128 + SIGINT);
2864	else if (sigint_fn != SIG_IGN)
2865	sigint_fn(SIGINT);
2866	return 0;
2867
2868	#if defined(_MSC_VER)
2869	case SIGILL:
2870	case SIGFPE:
2871	case SIGSEGV:
2872	case SIGTERM:
2873	case SIGBREAK:
2874	case SIGABRT:
2875	case SIGABRT_COMPAT:
2876	/*
2877	* The <signal.h> header in the MS C Runtime defines 8 signals
2878	* as being supported on the platform. Anything else causes an
2879	* "Invalid signal or error" (which in DEBUG builds causes the
2880	* Abort/Retry/Ignore dialog). We by-pass the CRT for things we
2881	* already know will fail.
2882	*/
2883	return raise(sig);
2884	default:
2885	errno = EINVAL;
2886	return -1;
2887
2888	#else
2889
2890	default:
2891	return raise(sig);
2892
2893	#endif
2894
2895	}
2896	}
2897
2898	int link(const char oldpath, const char newpath)
2899	{
2900	wchar_t woldpath[MAX_PATH], wnewpath[MAX_PATH];
2901	if (xutftowcs_path(woldpath, oldpath) < 0 \|\|
2902	xutftowcs_path(wnewpath, newpath) < 0)
2903	return -1;
2904
2905	if (!CreateHardLinkW(wnewpath, woldpath, NULL)) {
2906	errno = err_win_to_posix(GetLastError());
2907	return -1;
2908	}
2909	return 0;
2910	}
2911
2912	int symlink(const char target, const char link)
2913	{
2914	wchar_t wtarget[MAX_PATH], wlink[MAX_PATH];
2915	int len;
2916
2917	/* fail if symlinks are disabled or API is not supported (WinXP) */
2918	if (!repo_has_symlinks(the_repository)) {
2919	errno = ENOSYS;
2920	return -1;
2921	}
2922
2923	if ((len = xutftowcs_path(wtarget, target)) < 0
2924	\|\| xutftowcs_path(wlink, link) < 0)
2925	return -1;
2926
2927	/* convert target dir separators to backslashes */
2928	while (len--)
2929	if (wtarget[len] == '/')
2930	wtarget[len] = '\\';
2931
2932	/* create file symlink */
2933	if (!CreateSymbolicLinkW(wlink, wtarget, symlink_file_flags)) {
2934	errno = err_win_to_posix(GetLastError());
2935	return -1;
2936	}
2937
2938	/* convert to directory symlink if target exists */
2939	switch (process_phantom_symlink(wtarget, wlink)) {
2940	case PHANTOM_SYMLINK_RETRY: {
2941	/* if target doesn't exist, add to phantom symlinks list */
2942	wchar_t wfullpath[MAX_PATH];
2943	struct phantom_symlink_info *psi;
2944
2945	/* convert to absolute path to be independent of cwd */
2946	len = GetFullPathNameW(wlink, MAX_PATH, wfullpath, NULL);
2947	if (!len \|\| len >= MAX_PATH) {
2948	errno = err_win_to_posix(GetLastError());
2949	return -1;
2950	}
2951
2952	/* over-allocate and fill phantom_symlink_info structure */
2953	psi = xmalloc(sizeof(struct phantom_symlink_info)
2954	+ sizeof(wchar_t) * (len + wcslen(wtarget) + 2));
2955	psi->wlink = (wchar_t *)(psi + 1);
2956	wcscpy(psi->wlink, wfullpath);
2957	psi->wtarget = psi->wlink + len + 1;
2958	wcscpy(psi->wtarget, wtarget);
2959
2960	EnterCriticalSection(&phantom_symlinks_cs);
2961	psi->next = phantom_symlinks;
2962	phantom_symlinks = psi;
2963	LeaveCriticalSection(&phantom_symlinks_cs);
2964	break;
2965	}
2966	case PHANTOM_SYMLINK_DIRECTORY:
2967	/* if we created a dir symlink, process other phantom symlinks */
2968	process_phantom_symlinks();
2969	break;
2970	default:
2971	break;
2972	}
2973	return 0;
2974	}
2975
2976	int readlink(const char path, char buf, size_t bufsiz)
2977	{
2978	WCHAR wpath[MAX_PATH];
2979	char tmpbuf[MAX_PATH];
2980	int len;
2981	DWORD tag;
2982
2983	if (xutftowcs_path(wpath, path) < 0)
2984	return -1;
2985
2986	if (read_reparse_point(wpath, TRUE, tmpbuf, &len, &tag) < 0)
2987	return -1;
2988
2989	/*
2990	* Adapt to strange readlink() API: Copy up to bufsiz bytes, potentially
2991	* cutting off a UTF-8 sequence. Insufficient bufsize is not a failure
2992	* condition. There is no conversion function that produces invalid UTF-8,
2993	* so convert to a (hopefully large enough) temporary buffer, then memcpy
2994	* the requested number of bytes (including '\0' for robustness).
2995	*/
2996	memcpy(buf, tmpbuf, min(bufsiz, len + 1));
2997	return min(bufsiz, len);
2998	}
2999
3000	pid_t waitpid(pid_t pid, int *status, int options)
3001	{
3002	HANDLE h = OpenProcess(SYNCHRONIZE \| PROCESS_QUERY_INFORMATION,
3003	FALSE, pid);
3004	if (!h) {
3005	errno = ECHILD;
3006	return -1;
3007	}
3008
3009	if (pid > 0 && options & WNOHANG) {
3010	if (WAIT_OBJECT_0 != WaitForSingleObject(h, 0)) {
3011	CloseHandle(h);
3012	return 0;
3013	}
3014	options &= ~WNOHANG;
3015	}
3016
3017	if (options == 0) {
3018	struct pinfo_t **ppinfo;
3019	if (WaitForSingleObject(h, INFINITE) != WAIT_OBJECT_0) {
3020	CloseHandle(h);
3021	return 0;
3022	}
3023
3024	if (status)
3025	GetExitCodeProcess(h, (LPDWORD)status);
3026
3027	EnterCriticalSection(&pinfo_cs);
3028
3029	ppinfo = &pinfo;
3030	while (*ppinfo) {
3031	struct pinfo_t info = ppinfo;
3032	if (info->pid == pid) {
3033	CloseHandle(info->proc);
3034	*ppinfo = info->next;
3035	free(info);
3036	break;
3037	}
3038	ppinfo = &info->next;
3039	}
3040
3041	LeaveCriticalSection(&pinfo_cs);
3042
3043	CloseHandle(h);
3044	return pid;
3045	}
3046	CloseHandle(h);
3047
3048	errno = EINVAL;
3049	return -1;
3050	}
3051
3052	int xutftowcsn(wchar_t wcs, const char utfs, size_t wcslen, int utflen)
3053	{
3054	int upos = 0, wpos = 0;
3055	const unsigned char utf = (const unsigned char) utfs;
3056	if (!utf \|\| !wcs \|\| wcslen < 1) {
3057	errno = EINVAL;
3058	return -1;
3059	}
3060	/* reserve space for \0 */
3061	wcslen--;
3062	if (utflen < 0)
3063	utflen = INT_MAX;
3064
3065	while (upos < utflen) {
3066	int c = utf[upos++] & 0xff;
3067	if (utflen == INT_MAX && c == 0)
3068	break;
3069
3070	if (wpos >= wcslen) {
3071	wcs[wpos] = 0;
3072	errno = ERANGE;
3073	return -1;
3074	}
3075
3076	if (c < 0x80) {
3077	/* ASCII */
3078	wcs[wpos++] = c;
3079	} else if (c >= 0xc2 && c < 0xe0 && upos < utflen &&
3080	(utf[upos] & 0xc0) == 0x80) {
3081	/* 2-byte utf-8 */
3082	c = ((c & 0x1f) << 6);
3083	c \|= (utf[upos++] & 0x3f);
3084	wcs[wpos++] = c;
3085	} else if (c >= 0xe0 && c < 0xf0 && upos + 1 < utflen &&
3086	!(c == 0xe0 && utf[upos] < 0xa0) && /* over-long encoding */
3087	(utf[upos] & 0xc0) == 0x80 &&
3088	(utf[upos + 1] & 0xc0) == 0x80) {
3089	/* 3-byte utf-8 */
3090	c = ((c & 0x0f) << 12);
3091	c \|= ((utf[upos++] & 0x3f) << 6);
3092	c \|= (utf[upos++] & 0x3f);
3093	wcs[wpos++] = c;
3094	} else if (c >= 0xf0 && c < 0xf5 && upos + 2 < utflen &&
3095	wpos + 1 < wcslen &&
3096	!(c == 0xf0 && utf[upos] < 0x90) && /* over-long encoding */
3097	!(c == 0xf4 && utf[upos] >= 0x90) && /* > \u10ffff */
3098	(utf[upos] & 0xc0) == 0x80 &&
3099	(utf[upos + 1] & 0xc0) == 0x80 &&
3100	(utf[upos + 2] & 0xc0) == 0x80) {
3101	/* 4-byte utf-8: convert to \ud8xx \udcxx surrogate pair */
3102	c = ((c & 0x07) << 18);
3103	c \|= ((utf[upos++] & 0x3f) << 12);
3104	c \|= ((utf[upos++] & 0x3f) << 6);
3105	c \|= (utf[upos++] & 0x3f);
3106	c -= 0x10000;
3107	wcs[wpos++] = 0xd800 \| (c >> 10);
3108	wcs[wpos++] = 0xdc00 \| (c & 0x3ff);
3109	} else if (c >= 0xa0) {
3110	/* invalid utf-8 byte, printable unicode char: convert 1:1 */
3111	wcs[wpos++] = c;
3112	} else {
3113	/* invalid utf-8 byte, non-printable unicode: convert to hex */
3114	static const char *hex = "0123456789abcdef";
3115	wcs[wpos++] = hex[c >> 4];
3116	if (wpos < wcslen)
3117	wcs[wpos++] = hex[c & 0x0f];
3118	}
3119	}
3120	wcs[wpos] = 0;
3121	return wpos;
3122	}
3123
3124	int xwcstoutf(char utf, const wchar_t wcs, size_t utflen)
3125	{
3126	if (!wcs \|\| !utf \|\| utflen < 1) {
3127	errno = EINVAL;
3128	return -1;
3129	}
3130	utflen = WideCharToMultiByte(CP_UTF8, 0, wcs, -1, utf, utflen, NULL, NULL);
3131	if (utflen)
3132	return utflen - 1;
3133	errno = ERANGE;
3134	return -1;
3135	}
3136
3137	static void setup_windows_environment(void)
3138	{
3139	char *tmp = getenv("TMPDIR");
3140
3141	/* on Windows it is TMP and TEMP */
3142	if (!tmp) {
3143	if (!(tmp = getenv("TMP")))
3144	tmp = getenv("TEMP");
3145	if (tmp) {
3146	setenv("TMPDIR", tmp, 1);
3147	tmp = getenv("TMPDIR");
3148	}
3149	}
3150
3151	if (tmp) {
3152	/*
3153	* Convert all dir separators to forward slashes,
3154	* to help shell commands called from the Git
3155	* executable (by not mistaking the dir separators
3156	* for escape characters).
3157	*/
3158	convert_slashes(tmp);
3159	}
3160
3161	/* simulate TERM to enable auto-color (see color.c) */
3162	if (!getenv("TERM"))
3163	setenv("TERM", "cygwin", 1);
3164
3165	/* calculate HOME if not set */
3166	if (!getenv("HOME")) {
3167	/*
3168	* try $HOMEDRIVE$HOMEPATH - the home share may be a network
3169	* location, thus also check if the path exists (i.e. is not
3170	* disconnected)
3171	*/
3172	if ((tmp = getenv("HOMEDRIVE"))) {
3173	struct strbuf buf = STRBUF_INIT;
3174	strbuf_addstr(&buf, tmp);
3175	if ((tmp = getenv("HOMEPATH"))) {
3176	strbuf_addstr(&buf, tmp);
3177	if (is_directory(buf.buf))
3178	setenv("HOME", buf.buf, 1);
3179	else
3180	tmp = NULL; /* use $USERPROFILE */
3181	}
3182	strbuf_release(&buf);
3183	}
3184	/* use $USERPROFILE if the home share is not available */
3185	if (!tmp && (tmp = getenv("USERPROFILE")))
3186	setenv("HOME", tmp, 1);
3187	}
3188	}
3189
3190	int mingw_platform_has_symlinks(void)
3191	{
3192	static int has_symlinks = -1;
3193	/*
3194	* Change 'core.symlinks' default to false, unless native symlinks are
3195	* enabled in MSys2 (via 'MSYS=winsymlinks:nativestrict'). Thus we can
3196	* run the test suite (which doesn't obey config files) with or without
3197	* symlink support.
3198	*/
3199	if (has_symlinks < 0) {
3200	const char *tmp = getenv("MSYS");
3201	has_symlinks = (tmp && strstr(tmp, "winsymlinks:nativestrict")) ? 1 : 0;
3202	}
3203
3204	return has_symlinks;
3205	}
3206
3207	static void get_current_user_sid(PSID sid, HANDLE linked_token)
3208	{
3209	HANDLE token;
3210	DWORD len = 0;
3211	TOKEN_ELEVATION_TYPE elevationType;
3212	DWORD size;
3213
3214	*sid = NULL;
3215	*linked_token = NULL;
3216
3217	if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token))
3218	return;
3219
3220	if (!GetTokenInformation(token, TokenUser, NULL, 0, &len)) {
3221	TOKEN_USER *info = xmalloc((size_t)len);
3222	if (GetTokenInformation(token, TokenUser, info, len, &len)) {
3223	len = GetLengthSid(info->User.Sid);
3224	*sid = xmalloc(len);
3225	if (!CopySid(len, *sid, info->User.Sid)) {
3226	error(_("failed to copy SID (%ld)"),
3227	GetLastError());
3228	FREE_AND_NULL(*sid);
3229	}
3230	}
3231	FREE_AND_NULL(info);
3232	}
3233
3234	if (GetTokenInformation(token, TokenElevationType, &elevationType, sizeof(elevationType), &size) &&
3235	elevationType == TokenElevationTypeLimited) {
3236	/*
3237	* The current process is run by a member of the Administrators
3238	* group, but is not running elevated.
3239	*/
3240	if (!GetTokenInformation(token, TokenLinkedToken, linked_token, sizeof(*linked_token), &size))
3241	linked_token = NULL; /* there is no linked token */
3242	}
3243
3244	CloseHandle(token);
3245	}
3246
3247	static BOOL user_sid_to_user_name(PSID sid, LPSTR *str)
3248	{
3249	SID_NAME_USE pe_use;
3250	DWORD len_user = 0, len_domain = 0;
3251	BOOL translate_sid_to_user;
3252
3253	/*
3254	* returns only FALSE, because the string pointers are NULL
3255	*/
3256	LookupAccountSidA(NULL, sid, NULL, &len_user, NULL, &len_domain,
3257	&pe_use);
3258	/*
3259	* Alloc needed space of the strings
3260	*/
3261	ALLOC_ARRAY((*str), (size_t)len_domain + (size_t)len_user);
3262	translate_sid_to_user = LookupAccountSidA(NULL, sid,
3263	(str) + len_domain, &len_user, str, &len_domain, &pe_use);
3264	if (!translate_sid_to_user)
3265	FREE_AND_NULL(*str);
3266	else
3267	(*str)[len_domain] = '/';
3268	return translate_sid_to_user;
3269	}
3270
3271	static int acls_supported(const char *path)
3272	{
3273	size_t offset = offset_1st_component(path);
3274	WCHAR wroot[MAX_PATH];
3275	DWORD file_system_flags;
3276
3277	if (offset &&
3278	xutftowcsn(wroot, path, MAX_PATH, offset) > 0 &&
3279	GetVolumeInformationW(wroot, NULL, 0, NULL, NULL,
3280	&file_system_flags, NULL, 0))
3281	return !!(file_system_flags & FILE_PERSISTENT_ACLS);
3282
3283	return 0;
3284	}
3285
3286	int is_path_owned_by_current_sid(const char path, struct strbuf report)
3287	{
3288	WCHAR wpath[MAX_PATH];
3289	PSID sid = NULL;
3290	PSECURITY_DESCRIPTOR descriptor = NULL;
3291	DWORD err;
3292
3293	static wchar_t home[MAX_PATH];
3294
3295	int result = 0;
3296
3297	if (xutftowcs_path(wpath, path) < 0)
3298	return 0;
3299
3300	/*
3301	* On Windows, the home directory is owned by the administrator, but for
3302	* all practical purposes, it belongs to the user. Do pretend that it is
3303	* owned by the user.
3304	*/
3305	if (!*home) {
3306	DWORD size = ARRAY_SIZE(home);
3307	DWORD len = GetEnvironmentVariableW(L"HOME", home, size);
3308	if (!len \|\| len > size)
3309	wcscpy(home, L"::N/A::");
3310	}
3311	if (!wcsicmp(wpath, home))
3312	return 1;
3313
3314	/* Get the owner SID */
3315	err = GetNamedSecurityInfoW(wpath, SE_FILE_OBJECT,
3316	OWNER_SECURITY_INFORMATION \|
3317	DACL_SECURITY_INFORMATION,
3318	&sid, NULL, NULL, NULL, &descriptor);
3319
3320	if (err != ERROR_SUCCESS)
3321	error(_("failed to get owner for '%s' (%ld)"), path, err);
3322	else if (sid && IsValidSid(sid)) {
3323	/* Now, verify that the SID matches the current user's */
3324	static PSID current_user_sid;
3325	static HANDLE linked_token;
3326	BOOL is_member;
3327
3328	if (!current_user_sid)
3329	get_current_user_sid(&current_user_sid, &linked_token);
3330
3331	if (current_user_sid &&
3332	IsValidSid(current_user_sid) &&
3333	EqualSid(sid, current_user_sid))
3334	result = 1;
3335	else if (IsWellKnownSid(sid, WinBuiltinAdministratorsSid) &&
3336	((CheckTokenMembership(NULL, sid, &is_member) &&
3337	is_member) \|\|
3338	(linked_token &&
3339	CheckTokenMembership(linked_token, sid, &is_member) &&
3340	is_member)))
3341	/*
3342	* If owned by the Administrators group, and the
3343	* current user is an administrator, we consider that
3344	* okay, too.
3345	*/
3346	result = 1;
3347	else if (report &&
3348	IsWellKnownSid(sid, WinWorldSid) &&
3349	!acls_supported(path)) {
3350	/*
3351	* On FAT32 volumes, ownership is not actually recorded.
3352	*/
3353	strbuf_addf(report, "'%s' is on a file system that does "
3354	"not record ownership\n", path);
3355	} else if (report) {
3356	PCSTR str1, str2, str3, str4;
3357	LPSTR to_free1 = NULL, to_free3 = NULL,
3358	to_local_free2 = NULL, to_local_free4 = NULL;
3359
3360	if (user_sid_to_user_name(sid, &to_free1))
3361	str1 = to_free1;
3362	else
3363	str1 = "(inconvertible)";
3364	if (ConvertSidToStringSidA(sid, &to_local_free2))
3365	str2 = to_local_free2;
3366	else
3367	str2 = "(inconvertible)";
3368
3369	if (!current_user_sid) {
3370	str3 = "(none)";
3371	str4 = "(none)";
3372	}
3373	else if (!IsValidSid(current_user_sid)) {
3374	str3 = "(invalid)";
3375	str4 = "(invalid)";
3376	} else {
3377	if (user_sid_to_user_name(current_user_sid,
3378	&to_free3))
3379	str3 = to_free3;
3380	else
3381	str3 = "(inconvertible)";
3382	if (ConvertSidToStringSidA(current_user_sid,
3383	&to_local_free4))
3384	str4 = to_local_free4;
3385	else
3386	str4 = "(inconvertible)";
3387	}
3388	strbuf_addf(report,
3389	"'%s' is owned by:\n"
3390	"\t%s (%s)\nbut the current user is:\n"
3391	"\t%s (%s)\n",
3392	path, str1, str2, str3, str4);
3393	free(to_free1);
3394	LocalFree(to_local_free2);
3395	free(to_free3);
3396	LocalFree(to_local_free4);
3397	}
3398	}
3399
3400	/*
3401	* We can release the security descriptor struct only now because `sid`
3402	* actually points into this struct.
3403	*/
3404	if (descriptor)
3405	LocalFree(descriptor);
3406
3407	return result;
3408	}
3409
3410	int is_valid_win32_path(const char *path, int allow_literal_nul)
3411	{
3412	const char *p = path;
3413	int preceding_space_or_period = 0, i = 0, periods = 0;
3414
3415	if (!repo_protect_ntfs(the_repository))
3416	return 1;
3417
3418	skip_dos_drive_prefix((char **)&path);
3419	goto segment_start;
3420
3421	for (;;) {
3422	char c = *(path++);
3423	switch (c) {
3424	case '\0':
3425	case '/': case '\\':
3426	/* cannot end in ` ` or `.`, except for `.` and `..` */
3427	if (preceding_space_or_period &&
3428	(i != periods \|\| periods > 2))
3429	return 0;
3430	if (!c)
3431	return 1;
3432
3433	i = periods = preceding_space_or_period = 0;
3434
3435	segment_start:
3436	switch (*path) {
3437	case 'a': case 'A': /* AUX */
3438	if (((c = path[++i]) != 'u' && c != 'U') \|\|
3439	((c = path[++i]) != 'x' && c != 'X')) {
3440	not_a_reserved_name:
3441	path += i;
3442	continue;
3443	}
3444	break;
3445	case 'c': case 'C':
3446	/* COM1 ... COM9, CON, CONIN$, CONOUT$ */
3447	if ((c = path[++i]) != 'o' && c != 'O')
3448	goto not_a_reserved_name;
3449	c = path[++i];
3450	if (c == 'm' \|\| c == 'M') { /* COM1 ... COM9 */
3451	c = path[++i];
3452	if (c < '1' \|\| c > '9')
3453	goto not_a_reserved_name;
3454	} else if (c == 'n' \|\| c == 'N') { /* CON */
3455	c = path[i + 1];
3456	if ((c == 'i' \|\| c == 'I') &&
3457	((c = path[i + 2]) == 'n' \|\|
3458	c == 'N') &&
3459	path[i + 3] == '$')
3460	i += 3; /* CONIN$ */
3461	else if ((c == 'o' \|\| c == 'O') &&
3462	((c = path[i + 2]) == 'u' \|\|
3463	c == 'U') &&
3464	((c = path[i + 3]) == 't' \|\|
3465	c == 'T') &&
3466	path[i + 4] == '$')
3467	i += 4; /* CONOUT$ */
3468	} else
3469	goto not_a_reserved_name;
3470	break;
3471	case 'l': case 'L': /* LPT<N> */
3472	if (((c = path[++i]) != 'p' && c != 'P') \|\|
3473	((c = path[++i]) != 't' && c != 'T') \|\|
3474	!isdigit(path[++i]))
3475	goto not_a_reserved_name;
3476	break;
3477	case 'n': case 'N': /* NUL */
3478	if (((c = path[++i]) != 'u' && c != 'U') \|\|
3479	((c = path[++i]) != 'l' && c != 'L') \|\|
3480	(allow_literal_nul &&
3481	!path[i + 1] && p == path))
3482	goto not_a_reserved_name;
3483	break;
3484	case 'p': case 'P': /* PRN */
3485	if (((c = path[++i]) != 'r' && c != 'R') \|\|
3486	((c = path[++i]) != 'n' && c != 'N'))
3487	goto not_a_reserved_name;
3488	break;
3489	default:
3490	continue;
3491	}
3492
3493	/*
3494	* So far, this looks like a reserved name. Let's see
3495	* whether it actually is one: trailing spaces, a file
3496	* extension, or an NTFS Alternate Data Stream do not
3497	* matter, the name is still reserved if any of those
3498	* follow immediately after the actual name.
3499	*/
3500	i++;
3501	if (path[i] == ' ') {
3502	preceding_space_or_period = 1;
3503	while (path[++i] == ' ')
3504	; /* skip all spaces */
3505	}
3506
3507	c = path[i];
3508	if (c && c != '.' && c != ':' && !is_xplatform_dir_sep(c))
3509	goto not_a_reserved_name;
3510
3511	/* contains reserved name */
3512	return 0;
3513	case '.':
3514	periods++;
3515	/* fallthru */
3516	case ' ':
3517	preceding_space_or_period = 1;
3518	i++;
3519	continue;
3520	case ':': /* DOS drive prefix was already skipped */
3521	case '<': case '>': case '"': case '\|': case '?': case '*':
3522	/* illegal character */
3523	return 0;
3524	default:
3525	if (c > '\0' && c < '\x20')
3526	/* illegal character */
3527	return 0;
3528	}
3529	preceding_space_or_period = 0;
3530	i++;
3531	}
3532	}
3533
3534	#if !defined(_MSC_VER)
3535	/*
3536	* Disable MSVCRT command line wildcard expansion (__getmainargs called from
3537	* mingw startup code, see init.c in mingw runtime).
3538	*/
3539	int _CRT_glob = 0;
3540	#endif
3541
3542	static NORETURN void die_startup(void)
3543	{
3544	fputs("fatal: not enough memory for initialization", stderr);
3545	exit(128);
3546	}
3547
3548	static void *malloc_startup(size_t size)
3549	{
3550	void *result = malloc(size);
3551	if (!result)
3552	die_startup();
3553	return result;
3554	}
3555
3556	static char wcstoutfdup_startup(char buffer, const wchar_t *wcs, size_t len)
3557	{
3558	len = xwcstoutf(buffer, wcs, len) + 1;
3559	return memcpy(malloc_startup(len), buffer, len);
3560	}
3561
3562	static void maybe_redirect_std_handle(const wchar_t *key, DWORD std_id, int fd,
3563	DWORD desired_access, DWORD flags)
3564	{
3565	DWORD create_flag = fd ? OPEN_ALWAYS : OPEN_EXISTING;
3566	wchar_t buf[MAX_PATH];
3567	DWORD max = ARRAY_SIZE(buf);
3568	HANDLE handle;
3569	DWORD ret = GetEnvironmentVariableW(key, buf, max);
3570
3571	if (!ret \|\| ret >= max)
3572	return;
3573
3574	/* make sure this does not leak into child processes */
3575	SetEnvironmentVariableW(key, NULL);
3576	if (!wcscmp(buf, L"off")) {
3577	close(fd);
3578	handle = GetStdHandle(std_id);
3579	if (handle != INVALID_HANDLE_VALUE)
3580	CloseHandle(handle);
3581	return;
3582	}
3583	if (std_id == STD_ERROR_HANDLE && !wcscmp(buf, L"2>&1")) {
3584	handle = GetStdHandle(STD_OUTPUT_HANDLE);
3585	if (handle == INVALID_HANDLE_VALUE) {
3586	close(fd);
3587	handle = GetStdHandle(std_id);
3588	if (handle != INVALID_HANDLE_VALUE)
3589	CloseHandle(handle);
3590	} else {
3591	int new_fd = _open_osfhandle((intptr_t)handle, O_BINARY);
3592	SetStdHandle(std_id, handle);
3593	dup2(new_fd, fd);
3594	/* do not close the new_fd: that would close stdout */
3595	}
3596	return;
3597	}
3598	handle = CreateFileW(buf, desired_access, 0, NULL, create_flag,
3599	flags, NULL);
3600	if (handle != INVALID_HANDLE_VALUE) {
3601	int new_fd = _open_osfhandle((intptr_t)handle, O_BINARY);
3602	SetStdHandle(std_id, handle);
3603	dup2(new_fd, fd);
3604	close(new_fd);
3605	}
3606	}
3607
3608	static void maybe_redirect_std_handles(void)
3609	{
3610	maybe_redirect_std_handle(L"GIT_REDIRECT_STDIN", STD_INPUT_HANDLE, 0,
3611	GENERIC_READ, FILE_ATTRIBUTE_NORMAL);
3612	maybe_redirect_std_handle(L"GIT_REDIRECT_STDOUT", STD_OUTPUT_HANDLE, 1,
3613	GENERIC_WRITE, FILE_ATTRIBUTE_NORMAL);
3614	maybe_redirect_std_handle(L"GIT_REDIRECT_STDERR", STD_ERROR_HANDLE, 2,
3615	GENERIC_WRITE, FILE_FLAG_NO_BUFFERING);
3616	}
3617
3618	static void adjust_symlink_flags(void)
3619	{
3620	/*
3621	* Starting with Windows 10 Build 14972, symbolic links can be created
3622	* using CreateSymbolicLink() without elevation by passing the flag
3623	* SYMBOLIC_LINK_FLAG_ALLOW_UNPRIVILEGED_CREATE (0x02) as last
3624	* parameter, provided the Developer Mode has been enabled. Some
3625	* earlier Windows versions complain about this flag with an
3626	* ERROR_INVALID_PARAMETER, hence we have to test the build number
3627	* specifically.
3628	*/
3629	if (GetVersion() >= 14972 << 16) {
3630	symlink_file_flags \|= 2;
3631	symlink_directory_flags \|= 2;
3632	}
3633	}
3634
3635	static BOOL WINAPI handle_ctrl_c(DWORD ctrl_type)
3636	{
3637	if (ctrl_type != CTRL_C_EVENT)
3638	return FALSE; /* we did not handle this */
3639	mingw_raise(SIGINT);
3640	return TRUE; /* we did handle this */
3641	}
3642
3643	#ifdef _MSC_VER
3644	#ifdef _DEBUG
3645	#include <crtdbg.h>
3646	#endif
3647	#endif
3648
3649	/*
3650	* We implement wmain() and compile with -municode, which would
3651	* normally ignore main(), but we call the latter from the former
3652	* so that we can handle non-ASCII command-line parameters
3653	* appropriately.
3654	*
3655	* To be more compatible with the core git code, we convert
3656	* argv into UTF8 and pass them directly to main().
3657	*/
3658	int wmain(int argc, const wchar_t **wargv)
3659	{
3660	int i, exit_status;
3661	size_t maxlen;
3662	char buffer, *save;
3663	const char **argv;
3664
3665	trace2_initialize_clock();
3666
3667	#ifdef _MSC_VER
3668	#ifdef _DEBUG
3669	_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
3670	#endif
3671
3672	#ifdef USE_MSVC_CRTDBG
3673	_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF \| _CRTDBG_LEAK_CHECK_DF);
3674	#endif
3675	#endif
3676
3677	SetConsoleCtrlHandler(handle_ctrl_c, TRUE);
3678
3679	maybe_redirect_std_handles();
3680	adjust_symlink_flags();
3681
3682	/* determine size of argv and environ conversion buffer */
3683	maxlen = wcslen(wargv[0]);
3684	for (i = 1; i < argc; i++)
3685	maxlen = max(maxlen, wcslen(wargv[i]));
3686
3687	/* allocate buffer (wchar_t encodes to max 3 UTF-8 bytes) */
3688	maxlen = 3 * maxlen + 1;
3689	buffer = malloc_startup(maxlen);
3690
3691	/*
3692	* Create a UTF-8 version of w_argv. Also create a "save" copy
3693	* to remember all the string pointers because parse_options()
3694	* will remove claimed items from the argv that we pass down.
3695	*/
3696	ALLOC_ARRAY(argv, argc + 1);
3697	ALLOC_ARRAY(save, argc + 1);
3698	for (i = 0; i < argc; i++)
3699	argv[i] = save[i] = wcstoutfdup_startup(buffer, wargv[i], maxlen);
3700	argv[i] = save[i] = NULL;
3701	free(buffer);
3702
3703	/* fix Windows specific environment settings */
3704	setup_windows_environment();
3705
3706	unset_environment_variables = xstrdup("PERL5LIB");
3707
3708	/* initialize critical section for waitpid pinfo_t list */
3709	InitializeCriticalSection(&pinfo_cs);
3710	InitializeCriticalSection(&phantom_symlinks_cs);
3711
3712	/* set up default file mode and file modes for stdin/out/err */
3713	_fmode = _O_BINARY;
3714	_setmode(_fileno(stdin), _O_BINARY);
3715	_setmode(_fileno(stdout), _O_BINARY);
3716	_setmode(_fileno(stderr), _O_BINARY);
3717
3718	/* initialize Unicode console */
3719	winansi_init();
3720
3721	/* invoke the real main() using our utf8 version of argv. */
3722	exit_status = main(argc, argv);
3723
3724	for (i = 0; i < argc; i++)
3725	free(save[i]);
3726	free(save);
3727	free(argv);
3728
3729	return exit_status;
3730	}
3731
3732	int uname(struct utsname *buf)
3733	{
3734	unsigned v = (unsigned)GetVersion();
3735	memset(buf, 0, sizeof(*buf));
3736	xsnprintf(buf->sysname, sizeof(buf->sysname), "Windows");
3737	xsnprintf(buf->release, sizeof(buf->release),
3738	"%u.%u", v & 0xff, (v >> 8) & 0xff);
3739	/* assuming NT variants only.. */
3740	xsnprintf(buf->version, sizeof(buf->version),
3741	"%u", (v >> 16) & 0x7fff);
3742	return 0;
3743	}
3744
3745	#ifndef NO_UNIX_SOCKETS
3746	int mingw_have_unix_sockets(void)
3747	{
3748	SC_HANDLE scm, srvc;
3749	SERVICE_STATUS_PROCESS status;
3750	DWORD bytes;
3751	int ret = 0;
3752	scm = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
3753	if (scm) {
3754	srvc = OpenServiceA(scm, "afunix", SERVICE_QUERY_STATUS);
3755	if (srvc) {
3756	if(QueryServiceStatusEx(srvc, SC_STATUS_PROCESS_INFO, (LPBYTE)&status, sizeof(SERVICE_STATUS_PROCESS), &bytes))
3757	ret = status.dwCurrentState == SERVICE_RUNNING;
3758	CloseServiceHandle(srvc);
3759	}
3760	CloseServiceHandle(scm);
3761	}
3762	return ret;
3763	}
3764	#endif