?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fourth batch
[git/raj.git] / compat / mingw.c
blob8ee0b6408e945b369b30d9052c91aa7e1f31553a
1 #include "../git-compat-util.h"
2 #include "win32.h"
3 #include <conio.h>
4 #include <wchar.h>
5 #include "../strbuf.h"
6 #include "../run-command.h"
7 #include "../cache.h"
8 #include "win32/lazyload.h"
9 #include "../config.h"
10 #include "dir.h"
11
12 #define HCAST(type, handle) ((type)(intptr_t)handle)
13
14 static const int delay[] = { 0, 1, 10, 20, 40 };
15
16 void open_in_gdb(void)
17 {
18 static struct child_process cp = CHILD_PROCESS_INIT;
19 extern char *_pgmptr;
20
21 argv_array_pushl(&cp.args, "mintty", "gdb", NULL);
22 argv_array_pushf(&cp.args, "--pid=%d", getpid());
23 cp.clean_on_exit = 1;
24 if (start_command(&cp) < 0)
25 die_errno("Could not start gdb");
26 sleep(1);
27 }
28
29 int err_win_to_posix(DWORD winerr)
30 {
31 int error = ENOSYS;
32 switch(winerr) {
33 case ERROR_ACCESS_DENIED: error = EACCES; break;
34 case ERROR_ACCOUNT_DISABLED: error = EACCES; break;
35 case ERROR_ACCOUNT_RESTRICTION: error = EACCES; break;
36 case ERROR_ALREADY_ASSIGNED: error = EBUSY; break;
37 case ERROR_ALREADY_EXISTS: error = EEXIST; break;
38 case ERROR_ARITHMETIC_OVERFLOW: error = ERANGE; break;
39 case ERROR_BAD_COMMAND: error = EIO; break;
40 case ERROR_BAD_DEVICE: error = ENODEV; break;
41 case ERROR_BAD_DRIVER_LEVEL: error = ENXIO; break;
42 case ERROR_BAD_EXE_FORMAT: error = ENOEXEC; break;
43 case ERROR_BAD_FORMAT: error = ENOEXEC; break;
44 case ERROR_BAD_LENGTH: error = EINVAL; break;
45 case ERROR_BAD_PATHNAME: error = ENOENT; break;
46 case ERROR_BAD_PIPE: error = EPIPE; break;
47 case ERROR_BAD_UNIT: error = ENODEV; break;
48 case ERROR_BAD_USERNAME: error = EINVAL; break;
49 case ERROR_BROKEN_PIPE: error = EPIPE; break;
50 case ERROR_BUFFER_OVERFLOW: error = ENAMETOOLONG; break;
51 case ERROR_BUSY: error = EBUSY; break;
52 case ERROR_BUSY_DRIVE: error = EBUSY; break;
53 case ERROR_CALL_NOT_IMPLEMENTED: error = ENOSYS; break;
54 case ERROR_CANNOT_MAKE: error = EACCES; break;
55 case ERROR_CANTOPEN: error = EIO; break;
56 case ERROR_CANTREAD: error = EIO; break;
57 case ERROR_CANTWRITE: error = EIO; break;
58 case ERROR_CRC: error = EIO; break;
59 case ERROR_CURRENT_DIRECTORY: error = EACCES; break;
60 case ERROR_DEVICE_IN_USE: error = EBUSY; break;
61 case ERROR_DEV_NOT_EXIST: error = ENODEV; break;
62 case ERROR_DIRECTORY: error = EINVAL; break;
63 case ERROR_DIR_NOT_EMPTY: error = ENOTEMPTY; break;
64 case ERROR_DISK_CHANGE: error = EIO; break;
65 case ERROR_DISK_FULL: error = ENOSPC; break;
66 case ERROR_DRIVE_LOCKED: error = EBUSY; break;
67 case ERROR_ENVVAR_NOT_FOUND: error = EINVAL; break;
68 case ERROR_EXE_MARKED_INVALID: error = ENOEXEC; break;
69 case ERROR_FILENAME_EXCED_RANGE: error = ENAMETOOLONG; break;
70 case ERROR_FILE_EXISTS: error = EEXIST; break;
71 case ERROR_FILE_INVALID: error = ENODEV; break;
72 case ERROR_FILE_NOT_FOUND: error = ENOENT; break;
73 case ERROR_GEN_FAILURE: error = EIO; break;
74 case ERROR_HANDLE_DISK_FULL: error = ENOSPC; break;
75 case ERROR_INSUFFICIENT_BUFFER: error = ENOMEM; break;
76 case ERROR_INVALID_ACCESS: error = EACCES; break;
77 case ERROR_INVALID_ADDRESS: error = EFAULT; break;
78 case ERROR_INVALID_BLOCK: error = EFAULT; break;
79 case ERROR_INVALID_DATA: error = EINVAL; break;
80 case ERROR_INVALID_DRIVE: error = ENODEV; break;
81 case ERROR_INVALID_EXE_SIGNATURE: error = ENOEXEC; break;
82 case ERROR_INVALID_FLAGS: error = EINVAL; break;
83 case ERROR_INVALID_FUNCTION: error = ENOSYS; break;
84 case ERROR_INVALID_HANDLE: error = EBADF; break;
85 case ERROR_INVALID_LOGON_HOURS: error = EACCES; break;
86 case ERROR_INVALID_NAME: error = EINVAL; break;
87 case ERROR_INVALID_OWNER: error = EINVAL; break;
88 case ERROR_INVALID_PARAMETER: error = EINVAL; break;
89 case ERROR_INVALID_PASSWORD: error = EPERM; break;
90 case ERROR_INVALID_PRIMARY_GROUP: error = EINVAL; break;
91 case ERROR_INVALID_SIGNAL_NUMBER: error = EINVAL; break;
92 case ERROR_INVALID_TARGET_HANDLE: error = EIO; break;
93 case ERROR_INVALID_WORKSTATION: error = EACCES; break;
94 case ERROR_IO_DEVICE: error = EIO; break;
95 case ERROR_IO_INCOMPLETE: error = EINTR; break;
96 case ERROR_LOCKED: error = EBUSY; break;
97 case ERROR_LOCK_VIOLATION: error = EACCES; break;
98 case ERROR_LOGON_FAILURE: error = EACCES; break;
99 case ERROR_MAPPED_ALIGNMENT: error = EINVAL; break;
100 case ERROR_META_EXPANSION_TOO_LONG: error = E2BIG; break;
101 case ERROR_MORE_DATA: error = EPIPE; break;
102 case ERROR_NEGATIVE_SEEK: error = ESPIPE; break;
103 case ERROR_NOACCESS: error = EFAULT; break;
104 case ERROR_NONE_MAPPED: error = EINVAL; break;
105 case ERROR_NOT_ENOUGH_MEMORY: error = ENOMEM; break;
106 case ERROR_NOT_READY: error = EAGAIN; break;
107 case ERROR_NOT_SAME_DEVICE: error = EXDEV; break;
108 case ERROR_NO_DATA: error = EPIPE; break;
109 case ERROR_NO_MORE_SEARCH_HANDLES: error = EIO; break;
110 case ERROR_NO_PROC_SLOTS: error = EAGAIN; break;
111 case ERROR_NO_SUCH_PRIVILEGE: error = EACCES; break;
112 case ERROR_OPEN_FAILED: error = EIO; break;
113 case ERROR_OPEN_FILES: error = EBUSY; break;
114 case ERROR_OPERATION_ABORTED: error = EINTR; break;
115 case ERROR_OUTOFMEMORY: error = ENOMEM; break;
116 case ERROR_PASSWORD_EXPIRED: error = EACCES; break;
117 case ERROR_PATH_BUSY: error = EBUSY; break;
118 case ERROR_PATH_NOT_FOUND: error = ENOENT; break;
119 case ERROR_PIPE_BUSY: error = EBUSY; break;
120 case ERROR_PIPE_CONNECTED: error = EPIPE; break;
121 case ERROR_PIPE_LISTENING: error = EPIPE; break;
122 case ERROR_PIPE_NOT_CONNECTED: error = EPIPE; break;
123 case ERROR_PRIVILEGE_NOT_HELD: error = EACCES; break;
124 case ERROR_READ_FAULT: error = EIO; break;
125 case ERROR_SEEK: error = EIO; break;
126 case ERROR_SEEK_ON_DEVICE: error = ESPIPE; break;
127 case ERROR_SHARING_BUFFER_EXCEEDED: error = ENFILE; break;
128 case ERROR_SHARING_VIOLATION: error = EACCES; break;
129 case ERROR_STACK_OVERFLOW: error = ENOMEM; break;
130 case ERROR_SUCCESS: BUG("err_win_to_posix() called without an error!");
131 case ERROR_SWAPERROR: error = ENOENT; break;
132 case ERROR_TOO_MANY_MODULES: error = EMFILE; break;
133 case ERROR_TOO_MANY_OPEN_FILES: error = EMFILE; break;
134 case ERROR_UNRECOGNIZED_MEDIA: error = ENXIO; break;
135 case ERROR_UNRECOGNIZED_VOLUME: error = ENODEV; break;
136 case ERROR_WAIT_NO_CHILDREN: error = ECHILD; break;
137 case ERROR_WRITE_FAULT: error = EIO; break;
138 case ERROR_WRITE_PROTECT: error = EROFS; break;
139 }
140 return error;
141 }
142
143 static inline int is_file_in_use_error(DWORD errcode)
144 {
145 switch (errcode) {
146 case ERROR_SHARING_VIOLATION:
147 case ERROR_ACCESS_DENIED:
148 return 1;
149 }
150
151 return 0;
152 }
153
154 static int read_yes_no_answer(void)
155 {
156 char answer[1024];
157
158 if (fgets(answer, sizeof(answer), stdin)) {
159 size_t answer_len = strlen(answer);
160 int got_full_line = 0, c;
161
162 /* remove the newline */
163 if (answer_len >= 2 && answer[answer_len-2] == '\r') {
164 answer[answer_len-2] = '\0';
165 got_full_line = 1;
166 } else if (answer_len >= 1 && answer[answer_len-1] == '\n') {
167 answer[answer_len-1] = '\0';
168 got_full_line = 1;
169 }
170 /* flush the buffer in case we did not get the full line */
171 if (!got_full_line)
172 while ((c = getchar()) != EOF && c != '\n')
173 ;
174 } else
175 /* we could not read, return the
176 * default answer which is no */
177 return 0;
178
179 if (tolower(answer[0]) == 'y' && !answer[1])
180 return 1;
181 if (!strncasecmp(answer, "yes", sizeof(answer)))
182 return 1;
183 if (tolower(answer[0]) == 'n' && !answer[1])
184 return 0;
185 if (!strncasecmp(answer, "no", sizeof(answer)))
186 return 0;
187
188 /* did not find an answer we understand */
189 return -1;
190 }
191
192 static int ask_yes_no_if_possible(const char *format, ...)
193 {
194 char question[4096];
195 const char *retry_hook[] = { NULL, NULL, NULL };
196 va_list args;
197
198 va_start(args, format);
199 vsnprintf(question, sizeof(question), format, args);
200 va_end(args);
201
202 if ((retry_hook[0] = mingw_getenv("GIT_ASK_YESNO"))) {
203 retry_hook[1] = question;
204 return !run_command_v_opt(retry_hook, 0);
205 }
206
207 if (!isatty(_fileno(stdin)) || !isatty(_fileno(stderr)))
208 return 0;
209
210 while (1) {
211 int answer;
212 fprintf(stderr, "%s (y/n) ", question);
213
214 if ((answer = read_yes_no_answer()) >= 0)
215 return answer;
216
217 fprintf(stderr, "Sorry, I did not understand your answer. "
218 "Please type 'y' or 'n'\n");
219 }
220 }
221
222 /* Windows only */
223 enum hide_dotfiles_type {
224 HIDE_DOTFILES_FALSE = 0,
225 HIDE_DOTFILES_TRUE,
226 HIDE_DOTFILES_DOTGITONLY
227 };
228
229 static int core_restrict_inherited_handles = -1;
230 static enum hide_dotfiles_type hide_dotfiles = HIDE_DOTFILES_DOTGITONLY;
231 static char *unset_environment_variables;
232
233 int mingw_core_config(const char *var, const char *value, void *cb)
234 {
235 if (!strcmp(var, "core.hidedotfiles")) {
236 if (value && !strcasecmp(value, "dotgitonly"))
237 hide_dotfiles = HIDE_DOTFILES_DOTGITONLY;
238 else
239 hide_dotfiles = git_config_bool(var, value);
240 return 0;
241 }
242
243 if (!strcmp(var, "core.unsetenvvars")) {
244 free(unset_environment_variables);
245 unset_environment_variables = xstrdup(value);
246 return 0;
247 }
248
249 if (!strcmp(var, "core.restrictinheritedhandles")) {
250 if (value && !strcasecmp(value, "auto"))
251 core_restrict_inherited_handles = -1;
252 else
253 core_restrict_inherited_handles =
254 git_config_bool(var, value);
255 return 0;
256 }
257
258 return 0;
259 }
260
261 /* Normalizes NT paths as returned by some low-level APIs. */
262 static wchar_t *normalize_ntpath(wchar_t *wbuf)
263 {
264 int i;
265 /* fix absolute path prefixes */
266 if (wbuf[0] == '\\') {
267 /* strip NT namespace prefixes */
268 if (!wcsncmp(wbuf, L"\\??\\", 4) ||
269 !wcsncmp(wbuf, L"\\\\?\\", 4))
270 wbuf += 4;
271 else if (!wcsnicmp(wbuf, L"\\DosDevices\\", 12))
272 wbuf += 12;
273 /* replace remaining '...UNC\' with '\\' */
274 if (!wcsnicmp(wbuf, L"UNC\\", 4)) {
275 wbuf += 2;
276 *wbuf = '\\';
277 }
278 }
279 /* convert backslashes to slashes */
280 for (i = 0; wbuf[i]; i++)
281 if (wbuf[i] == '\\')
282 wbuf[i] = '/';
283 return wbuf;
284 }
285
286 int mingw_unlink(const char *pathname)
287 {
288 int ret, tries = 0;
289 wchar_t wpathname[MAX_PATH];
290 if (xutftowcs_path(wpathname, pathname) < 0)
291 return -1;
292
293 /* read-only files cannot be removed */
294 _wchmod(wpathname, 0666);
295 while ((ret = _wunlink(wpathname)) == -1 && tries < ARRAY_SIZE(delay)) {
296 if (!is_file_in_use_error(GetLastError()))
297 break;
298 /*
299 * We assume that some other process had the source or
300 * destination file open at the wrong moment and retry.
301 * In order to give the other process a higher chance to
302 * complete its operation, we give up our time slice now.
303 * If we have to retry again, we do sleep a bit.
304 */
305 Sleep(delay[tries]);
306 tries++;
307 }
308 while (ret == -1 && is_file_in_use_error(GetLastError()) &&
309 ask_yes_no_if_possible("Unlink of file '%s' failed. "
310 "Should I try again?", pathname))
311 ret = _wunlink(wpathname);
312 return ret;
313 }
314
315 static int is_dir_empty(const wchar_t *wpath)
316 {
317 WIN32_FIND_DATAW findbuf;
318 HANDLE handle;
319 wchar_t wbuf[MAX_PATH + 2];
320 wcscpy(wbuf, wpath);
321 wcscat(wbuf, L"\\*");
322 handle = FindFirstFileW(wbuf, &findbuf);
323 if (handle == INVALID_HANDLE_VALUE)
324 return GetLastError() == ERROR_NO_MORE_FILES;
325
326 while (!wcscmp(findbuf.cFileName, L".") ||
327 !wcscmp(findbuf.cFileName, L".."))
328 if (!FindNextFileW(handle, &findbuf)) {
329 DWORD err = GetLastError();
330 FindClose(handle);
331 return err == ERROR_NO_MORE_FILES;
332 }
333 FindClose(handle);
334 return 0;
335 }
336
337 int mingw_rmdir(const char *pathname)
338 {
339 int ret, tries = 0;
340 wchar_t wpathname[MAX_PATH];
341 if (xutftowcs_path(wpathname, pathname) < 0)
342 return -1;
343
344 while ((ret = _wrmdir(wpathname)) == -1 && tries < ARRAY_SIZE(delay)) {
345 if (!is_file_in_use_error(GetLastError()))
346 errno = err_win_to_posix(GetLastError());
347 if (errno != EACCES)
348 break;
349 if (!is_dir_empty(wpathname)) {
350 errno = ENOTEMPTY;
351 break;
352 }
353 /*
354 * We assume that some other process had the source or
355 * destination file open at the wrong moment and retry.
356 * In order to give the other process a higher chance to
357 * complete its operation, we give up our time slice now.
358 * If we have to retry again, we do sleep a bit.
359 */
360 Sleep(delay[tries]);
361 tries++;
362 }
363 while (ret == -1 && errno == EACCES && is_file_in_use_error(GetLastError()) &&
364 ask_yes_no_if_possible("Deletion of directory '%s' failed. "
365 "Should I try again?", pathname))
366 ret = _wrmdir(wpathname);
367 return ret;
368 }
369
370 static inline int needs_hiding(const char *path)
371 {
372 const char *basename;
373
374 if (hide_dotfiles == HIDE_DOTFILES_FALSE)
375 return 0;
376
377 /* We cannot use basename(), as it would remove trailing slashes */
378 win32_skip_dos_drive_prefix((char **)&path);
379 if (!*path)
380 return 0;
381
382 for (basename = path; *path; path++)
383 if (is_dir_sep(*path)) {
384 do {
385 path++;
386 } while (is_dir_sep(*path));
387 /* ignore trailing slashes */
388 if (*path)
389 basename = path;
390 else
391 break;
392 }
393
394 if (hide_dotfiles == HIDE_DOTFILES_TRUE)
395 return *basename == '.';
396
397 assert(hide_dotfiles == HIDE_DOTFILES_DOTGITONLY);
398 return !strncasecmp(".git", basename, 4) &&
399 (!basename[4] || is_dir_sep(basename[4]));
400 }
401
402 static int set_hidden_flag(const wchar_t *path, int set)
403 {
404 DWORD original = GetFileAttributesW(path), modified;
405 if (set)
406 modified = original | FILE_ATTRIBUTE_HIDDEN;
407 else
408 modified = original & ~FILE_ATTRIBUTE_HIDDEN;
409 if (original == modified || SetFileAttributesW(path, modified))
410 return 0;
411 errno = err_win_to_posix(GetLastError());
412 return -1;
413 }
414
415 int mingw_mkdir(const char *path, int mode)
416 {
417 int ret;
418 wchar_t wpath[MAX_PATH];
419
420 if (!is_valid_win32_path(path, 0)) {
421 errno = EINVAL;
422 return -1;
423 }
424
425 if (xutftowcs_path(wpath, path) < 0)
426 return -1;
427 ret = _wmkdir(wpath);
428 if (!ret && needs_hiding(path))
429 return set_hidden_flag(wpath, 1);
430 return ret;
431 }
432
433 /*
434 * Calling CreateFile() using FILE_APPEND_DATA and without FILE_WRITE_DATA
435 * is documented in [1] as opening a writable file handle in append mode.
436 * (It is believed that) this is atomic since it is maintained by the
437 * kernel unlike the O_APPEND flag which is racily maintained by the CRT.
438 *
439 * [1] https://docs.microsoft.com/en-us/windows/desktop/fileio/file-access-rights-constants
440 *
441 * This trick does not appear to work for named pipes. Instead it creates
442 * a named pipe client handle that cannot be written to. Callers should
443 * just use the regular _wopen() for them. (And since client handle gets
444 * bound to a unique server handle, it isn't really an issue.)
445 */
446 static int mingw_open_append(wchar_t const *wfilename, int oflags, ...)
447 {
448 HANDLE handle;
449 int fd;
450 DWORD create = (oflags & O_CREAT) ? OPEN_ALWAYS : OPEN_EXISTING;
451
452 /* only these flags are supported */
453 if ((oflags & ~O_CREAT) != (O_WRONLY | O_APPEND))
454 return errno = ENOSYS, -1;
455
456 /*
457 * FILE_SHARE_WRITE is required to permit child processes
458 * to append to the file.
459 */
460 handle = CreateFileW(wfilename, FILE_APPEND_DATA,
461 FILE_SHARE_WRITE | FILE_SHARE_READ,
462 NULL, create, FILE_ATTRIBUTE_NORMAL, NULL);
463 if (handle == INVALID_HANDLE_VALUE) {
464 DWORD err = GetLastError();
465
466 /*
467 * Some network storage solutions (e.g. Isilon) might return
468 * ERROR_INVALID_PARAMETER instead of expected error
469 * ERROR_PATH_NOT_FOUND, which results in an unknown error. If
470 * so, let's turn the error to ERROR_PATH_NOT_FOUND instead.
471 */
472 if (err == ERROR_INVALID_PARAMETER)
473 err = ERROR_PATH_NOT_FOUND;
474
475 errno = err_win_to_posix(err);
476 return -1;
477 }
478
479 /*
480 * No O_APPEND here, because the CRT uses it only to reset the
481 * file pointer to EOF before each write(); but that is not
482 * necessary (and may lead to races) for a file created with
483 * FILE_APPEND_DATA.
484 */
485 fd = _open_osfhandle((intptr_t)handle, O_BINARY);
486 if (fd < 0)
487 CloseHandle(handle);
488 return fd;
489 }
490
491 /*
492 * Does the pathname map to the local named pipe filesystem?
493 * That is, does it have a "//./pipe/" prefix?
494 */
495 static int is_local_named_pipe_path(const char *filename)
496 {
497 return (is_dir_sep(filename[0]) &&
498 is_dir_sep(filename[1]) &&
499 filename[2] == '.' &&
500 is_dir_sep(filename[3]) &&
501 !strncasecmp(filename+4, "pipe", 4) &&
502 is_dir_sep(filename[8]) &&
503 filename[9]);
504 }
505
506 int mingw_open (const char *filename, int oflags, ...)
507 {
508 typedef int (*open_fn_t)(wchar_t const *wfilename, int oflags, ...);
509 va_list args;
510 unsigned mode;
511 int fd, create = (oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
512 wchar_t wfilename[MAX_PATH];
513 open_fn_t open_fn;
514
515 va_start(args, oflags);
516 mode = va_arg(args, int);
517 va_end(args);
518
519 if (!is_valid_win32_path(filename, !create)) {
520 errno = create ? EINVAL : ENOENT;
521 return -1;
522 }
523
524 if ((oflags & O_APPEND) && !is_local_named_pipe_path(filename))
525 open_fn = mingw_open_append;
526 else
527 open_fn = _wopen;
528
529 if (filename && !strcmp(filename, "/dev/null"))
530 wcscpy(wfilename, L"nul");
531 else if (xutftowcs_path(wfilename, filename) < 0)
532 return -1;
533
534 fd = open_fn(wfilename, oflags, mode);
535
536 if (fd < 0 && (oflags & O_ACCMODE) != O_RDONLY && errno == EACCES) {
537 DWORD attrs = GetFileAttributesW(wfilename);
538 if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
539 errno = EISDIR;
540 }
541 if ((oflags & O_CREAT) && needs_hiding(filename)) {
542 /*
543 * Internally, _wopen() uses the CreateFile() API which errors
544 * out with an ERROR_ACCESS_DENIED if CREATE_ALWAYS was
545 * specified and an already existing file's attributes do not
546 * match *exactly*. As there is no mode or flag we can set that
547 * would correspond to FILE_ATTRIBUTE_HIDDEN, let's just try
548 * again *without* the O_CREAT flag (that corresponds to the
549 * CREATE_ALWAYS flag of CreateFile()).
550 */
551 if (fd < 0 && errno == EACCES)
552 fd = open_fn(wfilename, oflags & ~O_CREAT, mode);
553 if (fd >= 0 && set_hidden_flag(wfilename, 1))
554 warning("could not mark '%s' as hidden.", filename);
555 }
556 return fd;
557 }
558
559 static BOOL WINAPI ctrl_ignore(DWORD type)
560 {
561 return TRUE;
562 }
563
564 #undef fgetc
565 int mingw_fgetc(FILE *stream)
566 {
567 int ch;
568 if (!isatty(_fileno(stream)))
569 return fgetc(stream);
570
571 SetConsoleCtrlHandler(ctrl_ignore, TRUE);
572 while (1) {
573 ch = fgetc(stream);
574 if (ch != EOF || GetLastError() != ERROR_OPERATION_ABORTED)
575 break;
576
577 /* Ctrl+C was pressed, simulate SIGINT and retry */
578 mingw_raise(SIGINT);
579 }
580 SetConsoleCtrlHandler(ctrl_ignore, FALSE);
581 return ch;
582 }
583
584 #undef fopen
585 FILE *mingw_fopen (const char *filename, const char *otype)
586 {
587 int hide = needs_hiding(filename);
588 FILE *file;
589 wchar_t wfilename[MAX_PATH], wotype[4];
590 if (filename && !strcmp(filename, "/dev/null"))
591 wcscpy(wfilename, L"nul");
592 else if (!is_valid_win32_path(filename, 1)) {
593 int create = otype && strchr(otype, 'w');
594 errno = create ? EINVAL : ENOENT;
595 return NULL;
596 } else if (xutftowcs_path(wfilename, filename) < 0)
597 return NULL;
598
599 if (xutftowcs(wotype, otype, ARRAY_SIZE(wotype)) < 0)
600 return NULL;
601
602 if (hide && !access(filename, F_OK) && set_hidden_flag(wfilename, 0)) {
603 error("could not unhide %s", filename);
604 return NULL;
605 }
606 file = _wfopen(wfilename, wotype);
607 if (!file && GetLastError() == ERROR_INVALID_NAME)
608 errno = ENOENT;
609 if (file && hide && set_hidden_flag(wfilename, 1))
610 warning("could not mark '%s' as hidden.", filename);
611 return file;
612 }
613
614 FILE *mingw_freopen (const char *filename, const char *otype, FILE *stream)
615 {
616 int hide = needs_hiding(filename);
617 FILE *file;
618 wchar_t wfilename[MAX_PATH], wotype[4];
619 if (filename && !strcmp(filename, "/dev/null"))
620 wcscpy(wfilename, L"nul");
621 else if (!is_valid_win32_path(filename, 1)) {
622 int create = otype && strchr(otype, 'w');
623 errno = create ? EINVAL : ENOENT;
624 return NULL;
625 } else if (xutftowcs_path(wfilename, filename) < 0)
626 return NULL;
627
628 if (xutftowcs(wotype, otype, ARRAY_SIZE(wotype)) < 0)
629 return NULL;
630
631 if (hide && !access(filename, F_OK) && set_hidden_flag(wfilename, 0)) {
632 error("could not unhide %s", filename);
633 return NULL;
634 }
635 file = _wfreopen(wfilename, wotype, stream);
636 if (file && hide && set_hidden_flag(wfilename, 1))
637 warning("could not mark '%s' as hidden.", filename);
638 return file;
639 }
640
641 #undef fflush
642 int mingw_fflush(FILE *stream)
643 {
644 int ret = fflush(stream);
645
646 /*
647 * write() is used behind the scenes of stdio output functions.
648 * Since git code does not check for errors after each stdio write
649 * operation, it can happen that write() is called by a later
650 * stdio function even if an earlier write() call failed. In the
651 * case of a pipe whose readable end was closed, only the first
652 * call to write() reports EPIPE on Windows. Subsequent write()
653 * calls report EINVAL. It is impossible to notice whether this
654 * fflush invocation triggered such a case, therefore, we have to
655 * catch all EINVAL errors whole-sale.
656 */
657 if (ret && errno == EINVAL)
658 errno = EPIPE;
659
660 return ret;
661 }
662
663 #undef write
664 ssize_t mingw_write(int fd, const void *buf, size_t len)
665 {
666 ssize_t result = write(fd, buf, len);
667
668 if (result < 0 && errno == EINVAL && buf) {
669 /* check if fd is a pipe */
670 HANDLE h = (HANDLE) _get_osfhandle(fd);
671 if (GetFileType(h) == FILE_TYPE_PIPE)
672 errno = EPIPE;
673 else
674 errno = EINVAL;
675 }
676
677 return result;
678 }
679
680 int mingw_access(const char *filename, int mode)
681 {
682 wchar_t wfilename[MAX_PATH];
683 if (xutftowcs_path(wfilename, filename) < 0)
684 return -1;
685 /* X_OK is not supported by the MSVCRT version */
686 return _waccess(wfilename, mode & ~X_OK);
687 }
688
689 int mingw_chdir(const char *dirname)
690 {
691 wchar_t wdirname[MAX_PATH];
692 if (xutftowcs_path(wdirname, dirname) < 0)
693 return -1;
694 return _wchdir(wdirname);
695 }
696
697 int mingw_chmod(const char *filename, int mode)
698 {
699 wchar_t wfilename[MAX_PATH];
700 if (xutftowcs_path(wfilename, filename) < 0)
701 return -1;
702 return _wchmod(wfilename, mode);
703 }
704
705 /*
706 * The unit of FILETIME is 100-nanoseconds since January 1, 1601, UTC.
707 * Returns the 100-nanoseconds ("hekto nanoseconds") since the epoch.
708 */
709 static inline long long filetime_to_hnsec(const FILETIME *ft)
710 {
711 long long winTime = ((long long)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
712 /* Windows to Unix Epoch conversion */
713 return winTime - 116444736000000000LL;
714 }
715
716 static inline void filetime_to_timespec(const FILETIME *ft, struct timespec *ts)
717 {
718 long long hnsec = filetime_to_hnsec(ft);
719 ts->tv_sec = (time_t)(hnsec / 10000000);
720 ts->tv_nsec = (hnsec % 10000000) * 100;
721 }
722
723 /**
724 * Verifies that safe_create_leading_directories() would succeed.
725 */
726 static int has_valid_directory_prefix(wchar_t *wfilename)
727 {
728 int n = wcslen(wfilename);
729
730 while (n > 0) {
731 wchar_t c = wfilename[--n];
732 DWORD attributes;
733
734 if (!is_dir_sep(c))
735 continue;
736
737 wfilename[n] = L'\0';
738 attributes = GetFileAttributesW(wfilename);
739 wfilename[n] = c;
740 if (attributes == FILE_ATTRIBUTE_DIRECTORY ||
741 attributes == FILE_ATTRIBUTE_DEVICE)
742 return 1;
743 if (attributes == INVALID_FILE_ATTRIBUTES)
744 switch (GetLastError()) {
745 case ERROR_PATH_NOT_FOUND:
746 continue;
747 case ERROR_FILE_NOT_FOUND:
748 /* This implies parent directory exists. */
749 return 1;
750 }
751 return 0;
752 }
753 return 1;
754 }
755
756 /* We keep the do_lstat code in a separate function to avoid recursion.
757 * When a path ends with a slash, the stat will fail with ENOENT. In
758 * this case, we strip the trailing slashes and stat again.
759 *
760 * If follow is true then act like stat() and report on the link
761 * target. Otherwise report on the link itself.
762 */
763 static int do_lstat(int follow, const char *file_name, struct stat *buf)
764 {
765 WIN32_FILE_ATTRIBUTE_DATA fdata;
766 wchar_t wfilename[MAX_PATH];
767 if (xutftowcs_path(wfilename, file_name) < 0)
768 return -1;
769
770 if (GetFileAttributesExW(wfilename, GetFileExInfoStandard, &fdata)) {
771 buf->st_ino = 0;
772 buf->st_gid = 0;
773 buf->st_uid = 0;
774 buf->st_nlink = 1;
775 buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
776 buf->st_size = fdata.nFileSizeLow |
777 (((off_t)fdata.nFileSizeHigh)<<32);
778 buf->st_dev = buf->st_rdev = 0; /* not used by Git */
779 filetime_to_timespec(&(fdata.ftLastAccessTime), &(buf->st_atim));
780 filetime_to_timespec(&(fdata.ftLastWriteTime), &(buf->st_mtim));
781 filetime_to_timespec(&(fdata.ftCreationTime), &(buf->st_ctim));
782 if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
783 WIN32_FIND_DATAW findbuf;
784 HANDLE handle = FindFirstFileW(wfilename, &findbuf);
785 if (handle != INVALID_HANDLE_VALUE) {
786 if ((findbuf.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) &&
787 (findbuf.dwReserved0 == IO_REPARSE_TAG_SYMLINK)) {
788 if (follow) {
789 char buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
790 buf->st_size = readlink(file_name, buffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE);
791 } else {
792 buf->st_mode = S_IFLNK;
793 }
794 buf->st_mode |= S_IREAD;
795 if (!(findbuf.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
796 buf->st_mode |= S_IWRITE;
797 }
798 FindClose(handle);
799 }
800 }
801 return 0;
802 }
803 switch (GetLastError()) {
804 case ERROR_ACCESS_DENIED:
805 case ERROR_SHARING_VIOLATION:
806 case ERROR_LOCK_VIOLATION:
807 case ERROR_SHARING_BUFFER_EXCEEDED:
808 errno = EACCES;
809 break;
810 case ERROR_BUFFER_OVERFLOW:
811 errno = ENAMETOOLONG;
812 break;
813 case ERROR_NOT_ENOUGH_MEMORY:
814 errno = ENOMEM;
815 break;
816 case ERROR_PATH_NOT_FOUND:
817 if (!has_valid_directory_prefix(wfilename)) {
818 errno = ENOTDIR;
819 break;
820 }
821 /* fallthru */
822 default:
823 errno = ENOENT;
824 break;
825 }
826 return -1;
827 }
828
829 /* We provide our own lstat/fstat functions, since the provided
830 * lstat/fstat functions are so slow. These stat functions are
831 * tailored for Git's usage (read: fast), and are not meant to be
832 * complete. Note that Git stat()s are redirected to mingw_lstat()
833 * too, since Windows doesn't really handle symlinks that well.
834 */
835 static int do_stat_internal(int follow, const char *file_name, struct stat *buf)
836 {
837 int namelen;
838 char alt_name[PATH_MAX];
839
840 if (!do_lstat(follow, file_name, buf))
841 return 0;
842
843 /* if file_name ended in a '/', Windows returned ENOENT;
844 * try again without trailing slashes
845 */
846 if (errno != ENOENT)
847 return -1;
848
849 namelen = strlen(file_name);
850 if (namelen && file_name[namelen-1] != '/')
851 return -1;
852 while (namelen && file_name[namelen-1] == '/')
853 --namelen;
854 if (!namelen || namelen >= PATH_MAX)
855 return -1;
856
857 memcpy(alt_name, file_name, namelen);
858 alt_name[namelen] = 0;
859 return do_lstat(follow, alt_name, buf);
860 }
861
862 static int get_file_info_by_handle(HANDLE hnd, struct stat *buf)
863 {
864 BY_HANDLE_FILE_INFORMATION fdata;
865
866 if (!GetFileInformationByHandle(hnd, &fdata)) {
867 errno = err_win_to_posix(GetLastError());
868 return -1;
869 }
870
871 buf->st_ino = 0;
872 buf->st_gid = 0;
873 buf->st_uid = 0;
874 buf->st_nlink = 1;
875 buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
876 buf->st_size = fdata.nFileSizeLow |
877 (((off_t)fdata.nFileSizeHigh)<<32);
878 buf->st_dev = buf->st_rdev = 0; /* not used by Git */
879 filetime_to_timespec(&(fdata.ftLastAccessTime), &(buf->st_atim));
880 filetime_to_timespec(&(fdata.ftLastWriteTime), &(buf->st_mtim));
881 filetime_to_timespec(&(fdata.ftCreationTime), &(buf->st_ctim));
882 return 0;
883 }
884
885 int mingw_lstat(const char *file_name, struct stat *buf)
886 {
887 return do_stat_internal(0, file_name, buf);
888 }
889 int mingw_stat(const char *file_name, struct stat *buf)
890 {
891 return do_stat_internal(1, file_name, buf);
892 }
893
894 int mingw_fstat(int fd, struct stat *buf)
895 {
896 HANDLE fh = (HANDLE)_get_osfhandle(fd);
897 DWORD avail, type = GetFileType(fh) & ~FILE_TYPE_REMOTE;
898
899 switch (type) {
900 case FILE_TYPE_DISK:
901 return get_file_info_by_handle(fh, buf);
902
903 case FILE_TYPE_CHAR:
904 case FILE_TYPE_PIPE:
905 /* initialize stat fields */
906 memset(buf, 0, sizeof(*buf));
907 buf->st_nlink = 1;
908
909 if (type == FILE_TYPE_CHAR) {
910 buf->st_mode = _S_IFCHR;
911 } else {
912 buf->st_mode = _S_IFIFO;
913 if (PeekNamedPipe(fh, NULL, 0, NULL, &avail, NULL))
914 buf->st_size = avail;
915 }
916 return 0;
917
918 default:
919 errno = EBADF;
920 return -1;
921 }
922 }
923
924 static inline void time_t_to_filetime(time_t t, FILETIME *ft)
925 {
926 long long winTime = t * 10000000LL + 116444736000000000LL;
927 ft->dwLowDateTime = winTime;
928 ft->dwHighDateTime = winTime >> 32;
929 }
930
931 int mingw_utime (const char *file_name, const struct utimbuf *times)
932 {
933 FILETIME mft, aft;
934 int fh, rc;
935 DWORD attrs;
936 wchar_t wfilename[MAX_PATH];
937 if (xutftowcs_path(wfilename, file_name) < 0)
938 return -1;
939
940 /* must have write permission */
941 attrs = GetFileAttributesW(wfilename);
942 if (attrs != INVALID_FILE_ATTRIBUTES &&
943 (attrs & FILE_ATTRIBUTE_READONLY)) {
944 /* ignore errors here; open() will report them */
945 SetFileAttributesW(wfilename, attrs & ~FILE_ATTRIBUTE_READONLY);
946 }
947
948 if ((fh = _wopen(wfilename, O_RDWR | O_BINARY)) < 0) {
949 rc = -1;
950 goto revert_attrs;
951 }
952
953 if (times) {
954 time_t_to_filetime(times->modtime, &mft);
955 time_t_to_filetime(times->actime, &aft);
956 } else {
957 GetSystemTimeAsFileTime(&mft);
958 aft = mft;
959 }
960 if (!SetFileTime((HANDLE)_get_osfhandle(fh), NULL, &aft, &mft)) {
961 errno = EINVAL;
962 rc = -1;
963 } else
964 rc = 0;
965 close(fh);
966
967 revert_attrs:
968 if (attrs != INVALID_FILE_ATTRIBUTES &&
969 (attrs & FILE_ATTRIBUTE_READONLY)) {
970 /* ignore errors again */
971 SetFileAttributesW(wfilename, attrs);
972 }
973 return rc;
974 }
975
976 #undef strftime
977 size_t mingw_strftime(char *s, size_t max,
978 const char *format, const struct tm *tm)
979 {
980 /* a pointer to the original strftime in case we can't find the UCRT version */
981 static size_t (*fallback)(char *, size_t, const char *, const struct tm *) = strftime;
982 size_t ret;
983 DECLARE_PROC_ADDR(ucrtbase.dll, size_t, strftime, char *, size_t,
984 const char *, const struct tm *);
985
986 if (INIT_PROC_ADDR(strftime))
987 ret = strftime(s, max, format, tm);
988 else
989 ret = fallback(s, max, format, tm);
990
991 if (!ret && errno == EINVAL)
992 die("invalid strftime format: '%s'", format);
993 return ret;
994 }
995
996 unsigned int sleep (unsigned int seconds)
997 {
998 Sleep(seconds*1000);
999 return 0;
1000 }
1001
1002 char *mingw_mktemp(char *template)
1003 {
1004 wchar_t wtemplate[MAX_PATH];
1005 if (xutftowcs_path(wtemplate, template) < 0)
1006 return NULL;
1007 if (!_wmktemp(wtemplate))
1008 return NULL;
1009 if (xwcstoutf(template, wtemplate, strlen(template) + 1) < 0)
1010 return NULL;
1011 return template;
1012 }
1013
1014 int mkstemp(char *template)
1015 {
1016 char *filename = mktemp(template);
1017 if (filename == NULL)
1018 return -1;
1019 return open(filename, O_RDWR | O_CREAT, 0600);
1020 }
1021
1022 int gettimeofday(struct timeval *tv, void *tz)
1023 {
1024 FILETIME ft;
1025 long long hnsec;
1026
1027 GetSystemTimeAsFileTime(&ft);
1028 hnsec = filetime_to_hnsec(&ft);
1029 tv->tv_sec = hnsec / 10000000;
1030 tv->tv_usec = (hnsec % 10000000) / 10;
1031 return 0;
1032 }
1033
1034 int pipe(int filedes[2])
1035 {
1036 HANDLE h[2];
1037
1038 /* this creates non-inheritable handles */
1039 if (!CreatePipe(&h[0], &h[1], NULL, 8192)) {
1040 errno = err_win_to_posix(GetLastError());
1041 return -1;
1042 }
1043 filedes[0] = _open_osfhandle(HCAST(int, h[0]), O_NOINHERIT);
1044 if (filedes[0] < 0) {
1045 CloseHandle(h[0]);
1046 CloseHandle(h[1]);
1047 return -1;
1048 }
1049 filedes[1] = _open_osfhandle(HCAST(int, h[1]), O_NOINHERIT);
1050 if (filedes[1] < 0) {
1051 close(filedes[0]);
1052 CloseHandle(h[1]);
1053 return -1;
1054 }
1055 return 0;
1056 }
1057
1058 struct tm *gmtime_r(const time_t *timep, struct tm *result)
1059 {
1060 if (gmtime_s(result, timep) == 0)
1061 return result;
1062 return NULL;
1063 }
1064
1065 struct tm *localtime_r(const time_t *timep, struct tm *result)
1066 {
1067 if (localtime_s(result, timep) == 0)
1068 return result;
1069 return NULL;
1070 }
1071
1072 char *mingw_getcwd(char *pointer, int len)
1073 {
1074 wchar_t cwd[MAX_PATH], wpointer[MAX_PATH];
1075 DWORD ret = GetCurrentDirectoryW(ARRAY_SIZE(cwd), cwd);
1076
1077 if (!ret || ret >= ARRAY_SIZE(cwd)) {
1078 errno = ret ? ENAMETOOLONG : err_win_to_posix(GetLastError());
1079 return NULL;
1080 }
1081 ret = GetLongPathNameW(cwd, wpointer, ARRAY_SIZE(wpointer));
1082 if (!ret && GetLastError() == ERROR_ACCESS_DENIED) {
1083 HANDLE hnd = CreateFileW(cwd, 0,
1084 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL,
1085 OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
1086 if (hnd == INVALID_HANDLE_VALUE)
1087 return NULL;
1088 ret = GetFinalPathNameByHandleW(hnd, wpointer, ARRAY_SIZE(wpointer), 0);
1089 CloseHandle(hnd);
1090 if (!ret || ret >= ARRAY_SIZE(wpointer))
1091 return NULL;
1092 if (xwcstoutf(pointer, normalize_ntpath(wpointer), len) < 0)
1093 return NULL;
1094 return pointer;
1095 }
1096 if (!ret || ret >= ARRAY_SIZE(wpointer))
1097 return NULL;
1098 if (xwcstoutf(pointer, wpointer, len) < 0)
1099 return NULL;
1100 convert_slashes(pointer);
1101 return pointer;
1102 }
1103
1104 /*
1105 * See "Parsing C++ Command-Line Arguments" at Microsoft's Docs:
1106 * https://docs.microsoft.com/en-us/cpp/cpp/parsing-cpp-command-line-arguments
1107 */
1108 static const char *quote_arg_msvc(const char *arg)
1109 {
1110 /* count chars to quote */
1111 int len = 0, n = 0;
1112 int force_quotes = 0;
1113 char *q, *d;
1114 const char *p = arg;
1115 if (!*p) force_quotes = 1;
1116 while (*p) {
1117 if (isspace(*p) || *p == '*' || *p == '?' || *p == '{' || *p == '\'')
1118 force_quotes = 1;
1119 else if (*p == '"')
1120 n++;
1121 else if (*p == '\\') {
1122 int count = 0;
1123 while (*p == '\\') {
1124 count++;
1125 p++;
1126 len++;
1127 }
1128 if (*p == '"' || !*p)
1129 n += count*2 + 1;
1130 continue;
1131 }
1132 len++;
1133 p++;
1134 }
1135 if (!force_quotes && n == 0)
1136 return arg;
1137
1138 /* insert \ where necessary */
1139 d = q = xmalloc(st_add3(len, n, 3));
1140 *d++ = '"';
1141 while (*arg) {
1142 if (*arg == '"')
1143 *d++ = '\\';
1144 else if (*arg == '\\') {
1145 int count = 0;
1146 while (*arg == '\\') {
1147 count++;
1148 *d++ = *arg++;
1149 }
1150 if (*arg == '"' || !*arg) {
1151 while (count-- > 0)
1152 *d++ = '\\';
1153 /* don't escape the surrounding end quote */
1154 if (!*arg)
1155 break;
1156 *d++ = '\\';
1157 }
1158 }
1159 *d++ = *arg++;
1160 }
1161 *d++ = '"';
1162 *d++ = '\0';
1163 return q;
1164 }
1165
1166 #include "quote.h"
1167
1168 static const char *quote_arg_msys2(const char *arg)
1169 {
1170 struct strbuf buf = STRBUF_INIT;
1171 const char *p2 = arg, *p;
1172
1173 for (p = arg; *p; p++) {
1174 int ws = isspace(*p);
1175 if (!ws && *p != '\\' && *p != '"' && *p != '{' && *p != '\'' &&
1176 *p != '?' && *p != '*' && *p != '~')
1177 continue;
1178 if (!buf.len)
1179 strbuf_addch(&buf, '"');
1180 if (p != p2)
1181 strbuf_add(&buf, p2, p - p2);
1182 if (*p == '\\' || *p == '"')
1183 strbuf_addch(&buf, '\\');
1184 p2 = p;
1185 }
1186
1187 if (p == arg)
1188 strbuf_addch(&buf, '"');
1189 else if (!buf.len)
1190 return arg;
1191 else
1192 strbuf_add(&buf, p2, p - p2);
1193
1194 strbuf_addch(&buf, '"');
1195 return strbuf_detach(&buf, 0);
1196 }
1197
1198 static const char *parse_interpreter(const char *cmd)
1199 {
1200 static char buf[100];
1201 char *p, *opt;
1202 int n, fd;
1203
1204 /* don't even try a .exe */
1205 n = strlen(cmd);
1206 if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
1207 return NULL;
1208
1209 fd = open(cmd, O_RDONLY);
1210 if (fd < 0)
1211 return NULL;
1212 n = read(fd, buf, sizeof(buf)-1);
1213 close(fd);
1214 if (n < 4) /* at least '#!/x' and not error */
1215 return NULL;
1216
1217 if (buf[0] != '#' || buf[1] != '!')
1218 return NULL;
1219 buf[n] = '\0';
1220 p = buf + strcspn(buf, "\r\n");
1221 if (!*p)
1222 return NULL;
1223
1224 *p = '\0';
1225 if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
1226 return NULL;
1227 /* strip options */
1228 if ((opt = strchr(p+1, ' ')))
1229 *opt = '\0';
1230 return p+1;
1231 }
1232
1233 /*
1234 * exe_only means that we only want to detect .exe files, but not scripts
1235 * (which do not have an extension)
1236 */
1237 static char *lookup_prog(const char *dir, int dirlen, const char *cmd,
1238 int isexe, int exe_only)
1239 {
1240 char path[MAX_PATH];
1241 wchar_t wpath[MAX_PATH];
1242 snprintf(path, sizeof(path), "%.*s\\%s.exe", dirlen, dir, cmd);
1243
1244 if (xutftowcs_path(wpath, path) < 0)
1245 return NULL;
1246
1247 if (!isexe && _waccess(wpath, F_OK) == 0)
1248 return xstrdup(path);
1249 wpath[wcslen(wpath)-4] = '\0';
1250 if ((!exe_only || isexe) && _waccess(wpath, F_OK) == 0) {
1251 if (!(GetFileAttributesW(wpath) & FILE_ATTRIBUTE_DIRECTORY)) {
1252 path[strlen(path)-4] = '\0';
1253 return xstrdup(path);
1254 }
1255 }
1256 return NULL;
1257 }
1258
1259 /*
1260 * Determines the absolute path of cmd using the split path in path.
1261 * If cmd contains a slash or backslash, no lookup is performed.
1262 */
1263 static char *path_lookup(const char *cmd, int exe_only)
1264 {
1265 const char *path;
1266 char *prog = NULL;
1267 int len = strlen(cmd);
1268 int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");
1269
1270 if (strpbrk(cmd, "/\\"))
1271 return xstrdup(cmd);
1272
1273 path = mingw_getenv("PATH");
1274 if (!path)
1275 return NULL;
1276
1277 while (!prog) {
1278 const char *sep = strchrnul(path, ';');
1279 int dirlen = sep - path;
1280 if (dirlen)
1281 prog = lookup_prog(path, dirlen, cmd, isexe, exe_only);
1282 if (!*sep)
1283 break;
1284 path = sep + 1;
1285 }
1286
1287 return prog;
1288 }
1289
1290 static const wchar_t *wcschrnul(const wchar_t *s, wchar_t c)
1291 {
1292 while (*s && *s != c)
1293 s++;
1294 return s;
1295 }
1296
1297 /* Compare only keys */
1298 static int wenvcmp(const void *a, const void *b)
1299 {
1300 wchar_t *p = *(wchar_t **)a, *q = *(wchar_t **)b;
1301 size_t p_len, q_len;
1302
1303 /* Find the keys */
1304 p_len = wcschrnul(p, L'=') - p;
1305 q_len = wcschrnul(q, L'=') - q;
1306
1307 /* If the length differs, include the shorter key's NUL */
1308 if (p_len < q_len)
1309 p_len++;
1310 else if (p_len > q_len)
1311 p_len = q_len + 1;
1312
1313 return _wcsnicmp(p, q, p_len);
1314 }
1315
1316 /*
1317 * Build an environment block combining the inherited environment
1318 * merged with the given list of settings.
1319 *
1320 * Values of the form "KEY=VALUE" in deltaenv override inherited values.
1321 * Values of the form "KEY" in deltaenv delete inherited values.
1322 *
1323 * Multiple entries in deltaenv for the same key are explicitly allowed.
1324 *
1325 * We return a contiguous block of UNICODE strings with a final trailing
1326 * zero word.
1327 */
1328 static wchar_t *make_environment_block(char **deltaenv)
1329 {
1330 wchar_t *wenv = GetEnvironmentStringsW(), *wdeltaenv, *result, *p;
1331 size_t wlen, s, delta_size, size;
1332
1333 wchar_t **array = NULL;
1334 size_t alloc = 0, nr = 0, i;
1335
1336 size = 1; /* for extra NUL at the end */
1337
1338 /* If there is no deltaenv to apply, simply return a copy. */
1339 if (!deltaenv || !*deltaenv) {
1340 for (p = wenv; p && *p; ) {
1341 size_t s = wcslen(p) + 1;
1342 size += s;
1343 p += s;
1344 }
1345
1346 ALLOC_ARRAY(result, size);
1347 COPY_ARRAY(result, wenv, size);
1348 FreeEnvironmentStringsW(wenv);
1349 return result;
1350 }
1351
1352 /*
1353 * If there is a deltaenv, let's accumulate all keys into `array`,
1354 * sort them using the stable git_stable_qsort() and then copy,
1355 * skipping duplicate keys
1356 */
1357 for (p = wenv; p && *p; ) {
1358 ALLOC_GROW(array, nr + 1, alloc);
1359 s = wcslen(p) + 1;
1360 array[nr++] = p;
1361 p += s;
1362 size += s;
1363 }
1364
1365 /* (over-)assess size needed for wchar version of deltaenv */
1366 for (delta_size = 0, i = 0; deltaenv[i]; i++)
1367 delta_size += strlen(deltaenv[i]) * 2 + 1;
1368 ALLOC_ARRAY(wdeltaenv, delta_size);
1369
1370 /* convert the deltaenv, appending to array */
1371 for (i = 0, p = wdeltaenv; deltaenv[i]; i++) {
1372 ALLOC_GROW(array, nr + 1, alloc);
1373 wlen = xutftowcs(p, deltaenv[i], wdeltaenv + delta_size - p);
1374 array[nr++] = p;
1375 p += wlen + 1;
1376 }
1377
1378 git_stable_qsort(array, nr, sizeof(*array), wenvcmp);
1379 ALLOC_ARRAY(result, size + delta_size);
1380
1381 for (p = result, i = 0; i < nr; i++) {
1382 /* Skip any duplicate keys; last one wins */
1383 while (i + 1 < nr && !wenvcmp(array + i, array + i + 1))
1384 i++;
1385
1386 /* Skip "to delete" entry */
1387 if (!wcschr(array[i], L'='))
1388 continue;
1389
1390 size = wcslen(array[i]) + 1;
1391 COPY_ARRAY(p, array[i], size);
1392 p += size;
1393 }
1394 *p = L'\0';
1395
1396 free(array);
1397 free(wdeltaenv);
1398 FreeEnvironmentStringsW(wenv);
1399 return result;
1400 }
1401
1402 static void do_unset_environment_variables(void)
1403 {
1404 static int done;
1405 char *p = unset_environment_variables;
1406
1407 if (done || !p)
1408 return;
1409 done = 1;
1410
1411 for (;;) {
1412 char *comma = strchr(p, ',');
1413
1414 if (comma)
1415 *comma = '\0';
1416 unsetenv(p);
1417 if (!comma)
1418 break;
1419 p = comma + 1;
1420 }
1421 }
1422
1423 struct pinfo_t {
1424 struct pinfo_t *next;
1425 pid_t pid;
1426 HANDLE proc;
1427 };
1428 static struct pinfo_t *pinfo = NULL;
1429 CRITICAL_SECTION pinfo_cs;
1430
1431 /* Used to match and chomp off path components */
1432 static inline int match_last_path_component(const char *path, size_t *len,
1433 const char *component)
1434 {
1435 size_t component_len = strlen(component);
1436 if (*len < component_len + 1 ||
1437 !is_dir_sep(path[*len - component_len - 1]) ||
1438 fspathncmp(path + *len - component_len, component, component_len))
1439 return 0;
1440 *len -= component_len + 1;
1441 /* chomp off repeated dir separators */
1442 while (*len > 0 && is_dir_sep(path[*len - 1]))
1443 (*len)--;
1444 return 1;
1445 }
1446
1447 static int is_msys2_sh(const char *cmd)
1448 {
1449 if (!cmd)
1450 return 0;
1451
1452 if (!strcmp(cmd, "sh")) {
1453 static int ret = -1;
1454 char *p;
1455
1456 if (ret >= 0)
1457 return ret;
1458
1459 p = path_lookup(cmd, 0);
1460 if (!p)
1461 ret = 0;
1462 else {
1463 size_t len = strlen(p);
1464
1465 ret = match_last_path_component(p, &len, "sh.exe") &&
1466 match_last_path_component(p, &len, "bin") &&
1467 match_last_path_component(p, &len, "usr");
1468 free(p);
1469 }
1470 return ret;
1471 }
1472
1473 if (ends_with(cmd, "\\sh.exe")) {
1474 static char *sh;
1475
1476 if (!sh)
1477 sh = path_lookup("sh", 0);
1478
1479 return !fspathcmp(cmd, sh);
1480 }
1481
1482 return 0;
1483 }
1484
1485 static pid_t mingw_spawnve_fd(const char *cmd, const char **argv, char **deltaenv,
1486 const char *dir,
1487 int prepend_cmd, int fhin, int fhout, int fherr)
1488 {
1489 static int restrict_handle_inheritance = -1;
1490 STARTUPINFOEXW si;
1491 PROCESS_INFORMATION pi;
1492 LPPROC_THREAD_ATTRIBUTE_LIST attr_list = NULL;
1493 HANDLE stdhandles[3];
1494 DWORD stdhandles_count = 0;
1495 SIZE_T size;
1496 struct strbuf args;
1497 wchar_t wcmd[MAX_PATH], wdir[MAX_PATH], *wargs, *wenvblk = NULL;
1498 unsigned flags = CREATE_UNICODE_ENVIRONMENT;
1499 BOOL ret;
1500 HANDLE cons;
1501 const char *(*quote_arg)(const char *arg) =
1502 is_msys2_sh(cmd ? cmd : *argv) ?
1503 quote_arg_msys2 : quote_arg_msvc;
1504 const char *strace_env;
1505
1506 /* Make sure to override previous errors, if any */
1507 errno = 0;
1508
1509 if (restrict_handle_inheritance < 0)
1510 restrict_handle_inheritance = core_restrict_inherited_handles;
1511 /*
1512 * The following code to restrict which handles are inherited seems
1513 * to work properly only on Windows 7 and later, so let's disable it
1514 * on Windows Vista and 2008.
1515 */
1516 if (restrict_handle_inheritance < 0)
1517 restrict_handle_inheritance = GetVersion() >> 16 >= 7601;
1518
1519 do_unset_environment_variables();
1520
1521 /* Determine whether or not we are associated to a console */
1522 cons = CreateFileW(L"CONOUT$", GENERIC_WRITE,
1523 FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1524 FILE_ATTRIBUTE_NORMAL, NULL);
1525 if (cons == INVALID_HANDLE_VALUE) {
1526 /* There is no console associated with this process.
1527 * Since the child is a console process, Windows
1528 * would normally create a console window. But
1529 * since we'll be redirecting std streams, we do
1530 * not need the console.
1531 * It is necessary to use DETACHED_PROCESS
1532 * instead of CREATE_NO_WINDOW to make ssh
1533 * recognize that it has no console.
1534 */
1535 flags |= DETACHED_PROCESS;
1536 } else {
1537 /* There is already a console. If we specified
1538 * DETACHED_PROCESS here, too, Windows would
1539 * disassociate the child from the console.
1540 * The same is true for CREATE_NO_WINDOW.
1541 * Go figure!
1542 */
1543 CloseHandle(cons);
1544 }
1545 memset(&si, 0, sizeof(si));
1546 si.StartupInfo.cb = sizeof(si);
1547 si.StartupInfo.hStdInput = winansi_get_osfhandle(fhin);
1548 si.StartupInfo.hStdOutput = winansi_get_osfhandle(fhout);
1549 si.StartupInfo.hStdError = winansi_get_osfhandle(fherr);
1550
1551 /* The list of handles cannot contain duplicates */
1552 if (si.StartupInfo.hStdInput != INVALID_HANDLE_VALUE)
1553 stdhandles[stdhandles_count++] = si.StartupInfo.hStdInput;
1554 if (si.StartupInfo.hStdOutput != INVALID_HANDLE_VALUE &&
1555 si.StartupInfo.hStdOutput != si.StartupInfo.hStdInput)
1556 stdhandles[stdhandles_count++] = si.StartupInfo.hStdOutput;
1557 if (si.StartupInfo.hStdError != INVALID_HANDLE_VALUE &&
1558 si.StartupInfo.hStdError != si.StartupInfo.hStdInput &&
1559 si.StartupInfo.hStdError != si.StartupInfo.hStdOutput)
1560 stdhandles[stdhandles_count++] = si.StartupInfo.hStdError;
1561 if (stdhandles_count)
1562 si.StartupInfo.dwFlags |= STARTF_USESTDHANDLES;
1563
1564 if (*argv && !strcmp(cmd, *argv))
1565 wcmd[0] = L'\0';
1566 else if (xutftowcs_path(wcmd, cmd) < 0)
1567 return -1;
1568 if (dir && xutftowcs_path(wdir, dir) < 0)
1569 return -1;
1570
1571 /* concatenate argv, quoting args as we go */
1572 strbuf_init(&args, 0);
1573 if (prepend_cmd) {
1574 char *quoted = (char *)quote_arg(cmd);
1575 strbuf_addstr(&args, quoted);
1576 if (quoted != cmd)
1577 free(quoted);
1578 }
1579 for (; *argv; argv++) {
1580 char *quoted = (char *)quote_arg(*argv);
1581 if (*args.buf)
1582 strbuf_addch(&args, ' ');
1583 strbuf_addstr(&args, quoted);
1584 if (quoted != *argv)
1585 free(quoted);
1586 }
1587
1588 strace_env = getenv("GIT_STRACE_COMMANDS");
1589 if (strace_env) {
1590 char *p = path_lookup("strace.exe", 1);
1591 if (!p)
1592 return error("strace not found!");
1593 if (xutftowcs_path(wcmd, p) < 0) {
1594 free(p);
1595 return -1;
1596 }
1597 free(p);
1598 if (!strcmp("1", strace_env) ||
1599 !strcasecmp("yes", strace_env) ||
1600 !strcasecmp("true", strace_env))
1601 strbuf_insert(&args, 0, "strace ", 7);
1602 else {
1603 const char *quoted = quote_arg(strace_env);
1604 struct strbuf buf = STRBUF_INIT;
1605 strbuf_addf(&buf, "strace -o %s ", quoted);
1606 if (quoted != strace_env)
1607 free((char *)quoted);
1608 strbuf_insert(&args, 0, buf.buf, buf.len);
1609 strbuf_release(&buf);
1610 }
1611 }
1612
1613 ALLOC_ARRAY(wargs, st_add(st_mult(2, args.len), 1));
1614 xutftowcs(wargs, args.buf, 2 * args.len + 1);
1615 strbuf_release(&args);
1616
1617 wenvblk = make_environment_block(deltaenv);
1618
1619 memset(&pi, 0, sizeof(pi));
1620 if (restrict_handle_inheritance && stdhandles_count &&
1621 (InitializeProcThreadAttributeList(NULL, 1, 0, &size) ||
1622 GetLastError() == ERROR_INSUFFICIENT_BUFFER) &&
1623 (attr_list = (LPPROC_THREAD_ATTRIBUTE_LIST)
1624 (HeapAlloc(GetProcessHeap(), 0, size))) &&
1625 InitializeProcThreadAttributeList(attr_list, 1, 0, &size) &&
1626 UpdateProcThreadAttribute(attr_list, 0,
1627 PROC_THREAD_ATTRIBUTE_HANDLE_LIST,
1628 stdhandles,
1629 stdhandles_count * sizeof(HANDLE),
1630 NULL, NULL)) {
1631 si.lpAttributeList = attr_list;
1632 flags |= EXTENDED_STARTUPINFO_PRESENT;
1633 }
1634
1635 ret = CreateProcessW(*wcmd ? wcmd : NULL, wargs, NULL, NULL,
1636 stdhandles_count ? TRUE : FALSE,
1637 flags, wenvblk, dir ? wdir : NULL,
1638 &si.StartupInfo, &pi);
1639
1640 /*
1641 * On Windows 2008 R2, it seems that specifying certain types of handles
1642 * (such as FILE_TYPE_CHAR or FILE_TYPE_PIPE) will always produce an
1643 * error. Rather than playing finicky and fragile games, let's just try
1644 * to detect this situation and simply try again without restricting any
1645 * handle inheritance. This is still better than failing to create
1646 * processes.
1647 */
1648 if (!ret && restrict_handle_inheritance && stdhandles_count) {
1649 DWORD err = GetLastError();
1650 struct strbuf buf = STRBUF_INIT;
1651
1652 if (err != ERROR_NO_SYSTEM_RESOURCES &&
1653 /*
1654 * On Windows 7 and earlier, handles on pipes and character
1655 * devices are inherited automatically, and cannot be
1656 * specified in the thread handle list. Rather than trying
1657 * to catch each and every corner case (and running the
1658 * chance of *still* forgetting a few), let's just fall
1659 * back to creating the process without trying to limit the
1660 * handle inheritance.
1661 */
1662 !(err == ERROR_INVALID_PARAMETER &&
1663 GetVersion() >> 16 < 9200) &&
1664 !getenv("SUPPRESS_HANDLE_INHERITANCE_WARNING")) {
1665 DWORD fl = 0;
1666 int i;
1667
1668 setenv("SUPPRESS_HANDLE_INHERITANCE_WARNING", "1", 1);
1669
1670 for (i = 0; i < stdhandles_count; i++) {
1671 HANDLE h = stdhandles[i];
1672 strbuf_addf(&buf, "handle #%d: %p (type %lx, "
1673 "handle info (%d) %lx\n", i, h,
1674 GetFileType(h),
1675 GetHandleInformation(h, &fl),
1676 fl);
1677 }
1678 strbuf_addstr(&buf, "\nThis is a bug; please report it "
1679 "at\nhttps://github.com/git-for-windows/"
1680 "git/issues/new\n\n"
1681 "To suppress this warning, please set "
1682 "the environment variable\n\n"
1683 "\tSUPPRESS_HANDLE_INHERITANCE_WARNING=1"
1684 "\n");
1685 }
1686 restrict_handle_inheritance = 0;
1687 flags &= ~EXTENDED_STARTUPINFO_PRESENT;
1688 ret = CreateProcessW(*wcmd ? wcmd : NULL, wargs, NULL, NULL,
1689 TRUE, flags, wenvblk, dir ? wdir : NULL,
1690 &si.StartupInfo, &pi);
1691 if (!ret)
1692 errno = err_win_to_posix(GetLastError());
1693 if (ret && buf.len) {
1694 warning("failed to restrict file handles (%ld)\n\n%s",
1695 err, buf.buf);
1696 }
1697 strbuf_release(&buf);
1698 } else if (!ret)
1699 errno = err_win_to_posix(GetLastError());
1700
1701 if (si.lpAttributeList)
1702 DeleteProcThreadAttributeList(si.lpAttributeList);
1703 if (attr_list)
1704 HeapFree(GetProcessHeap(), 0, attr_list);
1705
1706 free(wenvblk);
1707 free(wargs);
1708
1709 if (!ret)
1710 return -1;
1711
1712 CloseHandle(pi.hThread);
1713
1714 /*
1715 * The process ID is the human-readable identifier of the process
1716 * that we want to present in log and error messages. The handle
1717 * is not useful for this purpose. But we cannot close it, either,
1718 * because it is not possible to turn a process ID into a process
1719 * handle after the process terminated.
1720 * Keep the handle in a list for waitpid.
1721 */
1722 EnterCriticalSection(&pinfo_cs);
1723 {
1724 struct pinfo_t *info = xmalloc(sizeof(struct pinfo_t));
1725 info->pid = pi.dwProcessId;
1726 info->proc = pi.hProcess;
1727 info->next = pinfo;
1728 pinfo = info;
1729 }
1730 LeaveCriticalSection(&pinfo_cs);
1731
1732 return (pid_t)pi.dwProcessId;
1733 }
1734
1735 static pid_t mingw_spawnv(const char *cmd, const char **argv, int prepend_cmd)
1736 {
1737 return mingw_spawnve_fd(cmd, argv, NULL, NULL, prepend_cmd, 0, 1, 2);
1738 }
1739
1740 pid_t mingw_spawnvpe(const char *cmd, const char **argv, char **deltaenv,
1741 const char *dir,
1742 int fhin, int fhout, int fherr)
1743 {
1744 pid_t pid;
1745 char *prog = path_lookup(cmd, 0);
1746
1747 if (!prog) {
1748 errno = ENOENT;
1749 pid = -1;
1750 }
1751 else {
1752 const char *interpr = parse_interpreter(prog);
1753
1754 if (interpr) {
1755 const char *argv0 = argv[0];
1756 char *iprog = path_lookup(interpr, 1);
1757 argv[0] = prog;
1758 if (!iprog) {
1759 errno = ENOENT;
1760 pid = -1;
1761 }
1762 else {
1763 pid = mingw_spawnve_fd(iprog, argv, deltaenv, dir, 1,
1764 fhin, fhout, fherr);
1765 free(iprog);
1766 }
1767 argv[0] = argv0;
1768 }
1769 else
1770 pid = mingw_spawnve_fd(prog, argv, deltaenv, dir, 0,
1771 fhin, fhout, fherr);
1772 free(prog);
1773 }
1774 return pid;
1775 }
1776
1777 static int try_shell_exec(const char *cmd, char *const *argv)
1778 {
1779 const char *interpr = parse_interpreter(cmd);
1780 char *prog;
1781 int pid = 0;
1782
1783 if (!interpr)
1784 return 0;
1785 prog = path_lookup(interpr, 1);
1786 if (prog) {
1787 int exec_id;
1788 int argc = 0;
1789 #ifndef _MSC_VER
1790 const
1791 #endif
1792 char **argv2;
1793 while (argv[argc]) argc++;
1794 ALLOC_ARRAY(argv2, argc + 1);
1795 argv2[0] = (char *)cmd; /* full path to the script file */
1796 COPY_ARRAY(&argv2[1], &argv[1], argc);
1797 exec_id = trace2_exec(prog, argv2);
1798 pid = mingw_spawnv(prog, argv2, 1);
1799 if (pid >= 0) {
1800 int status;
1801 if (waitpid(pid, &status, 0) < 0)
1802 status = 255;
1803 trace2_exec_result(exec_id, status);
1804 exit(status);
1805 }
1806 trace2_exec_result(exec_id, -1);
1807 pid = 1; /* indicate that we tried but failed */
1808 free(prog);
1809 free(argv2);
1810 }
1811 return pid;
1812 }
1813
1814 int mingw_execv(const char *cmd, char *const *argv)
1815 {
1816 /* check if git_command is a shell script */
1817 if (!try_shell_exec(cmd, argv)) {
1818 int pid, status;
1819 int exec_id;
1820
1821 exec_id = trace2_exec(cmd, (const char **)argv);
1822 pid = mingw_spawnv(cmd, (const char **)argv, 0);
1823 if (pid < 0) {
1824 trace2_exec_result(exec_id, -1);
1825 return -1;
1826 }
1827 if (waitpid(pid, &status, 0) < 0)
1828 status = 255;
1829 trace2_exec_result(exec_id, status);
1830 exit(status);
1831 }
1832 return -1;
1833 }
1834
1835 int mingw_execvp(const char *cmd, char *const *argv)
1836 {
1837 char *prog = path_lookup(cmd, 0);
1838
1839 if (prog) {
1840 mingw_execv(prog, argv);
1841 free(prog);
1842 } else
1843 errno = ENOENT;
1844
1845 return -1;
1846 }
1847
1848 int mingw_kill(pid_t pid, int sig)
1849 {
1850 if (pid > 0 && sig == SIGTERM) {
1851 HANDLE h = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
1852
1853 if (TerminateProcess(h, -1)) {
1854 CloseHandle(h);
1855 return 0;
1856 }
1857
1858 errno = err_win_to_posix(GetLastError());
1859 CloseHandle(h);
1860 return -1;
1861 } else if (pid > 0 && sig == 0) {
1862 HANDLE h = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
1863 if (h) {
1864 CloseHandle(h);
1865 return 0;
1866 }
1867 }
1868
1869 errno = EINVAL;
1870 return -1;
1871 }
1872
1873 /*
1874 * UTF-8 versions of getenv(), putenv() and unsetenv().
1875 * Internally, they use the CRT's stock UNICODE routines
1876 * to avoid data loss.
1877 */
1878 char *mingw_getenv(const char *name)
1879 {
1880 #define GETENV_MAX_RETAIN 64
1881 static char *values[GETENV_MAX_RETAIN];
1882 static int value_counter;
1883 int len_key, len_value;
1884 wchar_t *w_key;
1885 char *value;
1886 wchar_t w_value[32768];
1887
1888 if (!name || !*name)
1889 return NULL;
1890
1891 len_key = strlen(name) + 1;
1892 /* We cannot use xcalloc() here because that uses getenv() itself */
1893 w_key = calloc(len_key, sizeof(wchar_t));
1894 if (!w_key)
1895 die("Out of memory, (tried to allocate %u wchar_t's)", len_key);
1896 xutftowcs(w_key, name, len_key);
1897 /* GetEnvironmentVariableW() only sets the last error upon failure */
1898 SetLastError(ERROR_SUCCESS);
1899 len_value = GetEnvironmentVariableW(w_key, w_value, ARRAY_SIZE(w_value));
1900 if (!len_value && GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
1901 free(w_key);
1902 return NULL;
1903 }
1904 free(w_key);
1905
1906 len_value = len_value * 3 + 1;
1907 /* We cannot use xcalloc() here because that uses getenv() itself */
1908 value = calloc(len_value, sizeof(char));
1909 if (!value)
1910 die("Out of memory, (tried to allocate %u bytes)", len_value);
1911 xwcstoutf(value, w_value, len_value);
1912
1913 /*
1914 * We return `value` which is an allocated value and the caller is NOT
1915 * expecting to have to free it, so we keep a round-robin array,
1916 * invalidating the buffer after GETENV_MAX_RETAIN getenv() calls.
1917 */
1918 free(values[value_counter]);
1919 values[value_counter++] = value;
1920 if (value_counter >= ARRAY_SIZE(values))
1921 value_counter = 0;
1922
1923 return value;
1924 }
1925
1926 int mingw_putenv(const char *namevalue)
1927 {
1928 int size;
1929 wchar_t *wide, *equal;
1930 BOOL result;
1931
1932 if (!namevalue || !*namevalue)
1933 return 0;
1934
1935 size = strlen(namevalue) * 2 + 1;
1936 wide = calloc(size, sizeof(wchar_t));
1937 if (!wide)
1938 die("Out of memory, (tried to allocate %u wchar_t's)", size);
1939 xutftowcs(wide, namevalue, size);
1940 equal = wcschr(wide, L'=');
1941 if (!equal)
1942 result = SetEnvironmentVariableW(wide, NULL);
1943 else {
1944 *equal = L'\0';
1945 result = SetEnvironmentVariableW(wide, equal + 1);
1946 }
1947 free(wide);
1948
1949 if (!result)
1950 errno = err_win_to_posix(GetLastError());
1951
1952 return result ? 0 : -1;
1953 }
1954
1955 static void ensure_socket_initialization(void)
1956 {
1957 WSADATA wsa;
1958 static int initialized = 0;
1959
1960 if (initialized)
1961 return;
1962
1963 if (WSAStartup(MAKEWORD(2,2), &wsa))
1964 die("unable to initialize winsock subsystem, error %d",
1965 WSAGetLastError());
1966
1967 atexit((void(*)(void)) WSACleanup);
1968 initialized = 1;
1969 }
1970
1971 #undef gethostname
1972 int mingw_gethostname(char *name, int namelen)
1973 {
1974 ensure_socket_initialization();
1975 return gethostname(name, namelen);
1976 }
1977
1978 #undef gethostbyname
1979 struct hostent *mingw_gethostbyname(const char *host)
1980 {
1981 ensure_socket_initialization();
1982 return gethostbyname(host);
1983 }
1984
1985 #undef getaddrinfo
1986 int mingw_getaddrinfo(const char *node, const char *service,
1987 const struct addrinfo *hints, struct addrinfo **res)
1988 {
1989 ensure_socket_initialization();
1990 return getaddrinfo(node, service, hints, res);
1991 }
1992
1993 int mingw_socket(int domain, int type, int protocol)
1994 {
1995 int sockfd;
1996 SOCKET s;
1997
1998 ensure_socket_initialization();
1999 s = WSASocket(domain, type, protocol, NULL, 0, 0);
2000 if (s == INVALID_SOCKET) {
2001 /*
2002 * WSAGetLastError() values are regular BSD error codes
2003 * biased by WSABASEERR.
2004 * However, strerror() does not know about networking
2005 * specific errors, which are values beginning at 38 or so.
2006 * Therefore, we choose to leave the biased error code
2007 * in errno so that _if_ someone looks up the code somewhere,
2008 * then it is at least the number that are usually listed.
2009 */
2010 errno = WSAGetLastError();
2011 return -1;
2012 }
2013 /* convert into a file descriptor */
2014 if ((sockfd = _open_osfhandle(s, O_RDWR|O_BINARY)) < 0) {
2015 closesocket(s);
2016 return error("unable to make a socket file descriptor: %s",
2017 strerror(errno));
2018 }
2019 return sockfd;
2020 }
2021
2022 #undef connect
2023 int mingw_connect(int sockfd, struct sockaddr *sa, size_t sz)
2024 {
2025 SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2026 return connect(s, sa, sz);
2027 }
2028
2029 #undef bind
2030 int mingw_bind(int sockfd, struct sockaddr *sa, size_t sz)
2031 {
2032 SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2033 return bind(s, sa, sz);
2034 }
2035
2036 #undef setsockopt
2037 int mingw_setsockopt(int sockfd, int lvl, int optname, void *optval, int optlen)
2038 {
2039 SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2040 return setsockopt(s, lvl, optname, (const char*)optval, optlen);
2041 }
2042
2043 #undef shutdown
2044 int mingw_shutdown(int sockfd, int how)
2045 {
2046 SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2047 return shutdown(s, how);
2048 }
2049
2050 #undef listen
2051 int mingw_listen(int sockfd, int backlog)
2052 {
2053 SOCKET s = (SOCKET)_get_osfhandle(sockfd);
2054 return listen(s, backlog);
2055 }
2056
2057 #undef accept
2058 int mingw_accept(int sockfd1, struct sockaddr *sa, socklen_t *sz)
2059 {
2060 int sockfd2;
2061
2062 SOCKET s1 = (SOCKET)_get_osfhandle(sockfd1);
2063 SOCKET s2 = accept(s1, sa, sz);
2064
2065 /* convert into a file descriptor */
2066 if ((sockfd2 = _open_osfhandle(s2, O_RDWR|O_BINARY)) < 0) {
2067 int err = errno;
2068 closesocket(s2);
2069 return error("unable to make a socket file descriptor: %s",
2070 strerror(err));
2071 }
2072 return sockfd2;
2073 }
2074
2075 #undef rename
2076 int mingw_rename(const char *pold, const char *pnew)
2077 {
2078 DWORD attrs, gle;
2079 int tries = 0;
2080 wchar_t wpold[MAX_PATH], wpnew[MAX_PATH];
2081 if (xutftowcs_path(wpold, pold) < 0 || xutftowcs_path(wpnew, pnew) < 0)
2082 return -1;
2083
2084 /*
2085 * Try native rename() first to get errno right.
2086 * It is based on MoveFile(), which cannot overwrite existing files.
2087 */
2088 if (!_wrename(wpold, wpnew))
2089 return 0;
2090 if (errno != EEXIST)
2091 return -1;
2092 repeat:
2093 if (MoveFileExW(wpold, wpnew, MOVEFILE_REPLACE_EXISTING))
2094 return 0;
2095 /* TODO: translate more errors */
2096 gle = GetLastError();
2097 if (gle == ERROR_ACCESS_DENIED &&
2098 (attrs = GetFileAttributesW(wpnew)) != INVALID_FILE_ATTRIBUTES) {
2099 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
2100 DWORD attrsold = GetFileAttributesW(wpold);
2101 if (attrsold == INVALID_FILE_ATTRIBUTES ||
2102 !(attrsold & FILE_ATTRIBUTE_DIRECTORY))
2103 errno = EISDIR;
2104 else if (!_wrmdir(wpnew))
2105 goto repeat;
2106 return -1;
2107 }
2108 if ((attrs & FILE_ATTRIBUTE_READONLY) &&
2109 SetFileAttributesW(wpnew, attrs & ~FILE_ATTRIBUTE_READONLY)) {
2110 if (MoveFileExW(wpold, wpnew, MOVEFILE_REPLACE_EXISTING))
2111 return 0;
2112 gle = GetLastError();
2113 /* revert file attributes on failure */
2114 SetFileAttributesW(wpnew, attrs);
2115 }
2116 }
2117 if (tries < ARRAY_SIZE(delay) && gle == ERROR_ACCESS_DENIED) {
2118 /*
2119 * We assume that some other process had the source or
2120 * destination file open at the wrong moment and retry.
2121 * In order to give the other process a higher chance to
2122 * complete its operation, we give up our time slice now.
2123 * If we have to retry again, we do sleep a bit.
2124 */
2125 Sleep(delay[tries]);
2126 tries++;
2127 goto repeat;
2128 }
2129 if (gle == ERROR_ACCESS_DENIED &&
2130 ask_yes_no_if_possible("Rename from '%s' to '%s' failed. "
2131 "Should I try again?", pold, pnew))
2132 goto repeat;
2133
2134 errno = EACCES;
2135 return -1;
2136 }
2137
2138 /*
2139 * Note that this doesn't return the actual pagesize, but
2140 * the allocation granularity. If future Windows specific git code
2141 * needs the real getpagesize function, we need to find another solution.
2142 */
2143 int mingw_getpagesize(void)
2144 {
2145 SYSTEM_INFO si;
2146 GetSystemInfo(&si);
2147 return si.dwAllocationGranularity;
2148 }
2149
2150 /* See https://msdn.microsoft.com/en-us/library/windows/desktop/ms724435.aspx */
2151 enum EXTENDED_NAME_FORMAT {
2152 NameDisplay = 3,
2153 NameUserPrincipal = 8
2154 };
2155
2156 static char *get_extended_user_info(enum EXTENDED_NAME_FORMAT type)
2157 {
2158 DECLARE_PROC_ADDR(secur32.dll, BOOL, GetUserNameExW,
2159 enum EXTENDED_NAME_FORMAT, LPCWSTR, PULONG);
2160 static wchar_t wbuffer[1024];
2161 DWORD len;
2162
2163 if (!INIT_PROC_ADDR(GetUserNameExW))
2164 return NULL;
2165
2166 len = ARRAY_SIZE(wbuffer);
2167 if (GetUserNameExW(type, wbuffer, &len)) {
2168 char *converted = xmalloc((len *= 3));
2169 if (xwcstoutf(converted, wbuffer, len) >= 0)
2170 return converted;
2171 free(converted);
2172 }
2173
2174 return NULL;
2175 }
2176
2177 char *mingw_query_user_email(void)
2178 {
2179 return get_extended_user_info(NameUserPrincipal);
2180 }
2181
2182 struct passwd *getpwuid(int uid)
2183 {
2184 static unsigned initialized;
2185 static char user_name[100];
2186 static struct passwd *p;
2187 wchar_t buf[100];
2188 DWORD len;
2189
2190 if (initialized)
2191 return p;
2192
2193 len = ARRAY_SIZE(buf);
2194 if (!GetUserNameW(buf, &len)) {
2195 initialized = 1;
2196 return NULL;
2197 }
2198
2199 if (xwcstoutf(user_name, buf, sizeof(user_name)) < 0) {
2200 initialized = 1;
2201 return NULL;
2202 }
2203
2204 p = xmalloc(sizeof(*p));
2205 p->pw_name = user_name;
2206 p->pw_gecos = get_extended_user_info(NameDisplay);
2207 if (!p->pw_gecos)
2208 p->pw_gecos = "unknown";
2209 p->pw_dir = NULL;
2210
2211 initialized = 1;
2212 return p;
2213 }
2214
2215 static HANDLE timer_event;
2216 static HANDLE timer_thread;
2217 static int timer_interval;
2218 static int one_shot;
2219 static sig_handler_t timer_fn = SIG_DFL, sigint_fn = SIG_DFL;
2220
2221 /* The timer works like this:
2222 * The thread, ticktack(), is a trivial routine that most of the time
2223 * only waits to receive the signal to terminate. The main thread tells
2224 * the thread to terminate by setting the timer_event to the signalled
2225 * state.
2226 * But ticktack() interrupts the wait state after the timer's interval
2227 * length to call the signal handler.
2228 */
2229
2230 static unsigned __stdcall ticktack(void *dummy)
2231 {
2232 while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
2233 mingw_raise(SIGALRM);
2234 if (one_shot)
2235 break;
2236 }
2237 return 0;
2238 }
2239
2240 static int start_timer_thread(void)
2241 {
2242 timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
2243 if (timer_event) {
2244 timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
2245 if (!timer_thread )
2246 return errno = ENOMEM,
2247 error("cannot start timer thread");
2248 } else
2249 return errno = ENOMEM,
2250 error("cannot allocate resources for timer");
2251 return 0;
2252 }
2253
2254 static void stop_timer_thread(void)
2255 {
2256 if (timer_event)
2257 SetEvent(timer_event); /* tell thread to terminate */
2258 if (timer_thread) {
2259 int rc = WaitForSingleObject(timer_thread, 10000);
2260 if (rc == WAIT_TIMEOUT)
2261 error("timer thread did not terminate timely");
2262 else if (rc != WAIT_OBJECT_0)
2263 error("waiting for timer thread failed: %lu",
2264 GetLastError());
2265 CloseHandle(timer_thread);
2266 }
2267 if (timer_event)
2268 CloseHandle(timer_event);
2269 timer_event = NULL;
2270 timer_thread = NULL;
2271 }
2272
2273 static inline int is_timeval_eq(const struct timeval *i1, const struct timeval *i2)
2274 {
2275 return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
2276 }
2277
2278 int setitimer(int type, struct itimerval *in, struct itimerval *out)
2279 {
2280 static const struct timeval zero;
2281 static int atexit_done;
2282
2283 if (out != NULL)
2284 return errno = EINVAL,
2285 error("setitimer param 3 != NULL not implemented");
2286 if (!is_timeval_eq(&in->it_interval, &zero) &&
2287 !is_timeval_eq(&in->it_interval, &in->it_value))
2288 return errno = EINVAL,
2289 error("setitimer: it_interval must be zero or eq it_value");
2290
2291 if (timer_thread)
2292 stop_timer_thread();
2293
2294 if (is_timeval_eq(&in->it_value, &zero) &&
2295 is_timeval_eq(&in->it_interval, &zero))
2296 return 0;
2297
2298 timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
2299 one_shot = is_timeval_eq(&in->it_interval, &zero);
2300 if (!atexit_done) {
2301 atexit(stop_timer_thread);
2302 atexit_done = 1;
2303 }
2304 return start_timer_thread();
2305 }
2306
2307 int sigaction(int sig, struct sigaction *in, struct sigaction *out)
2308 {
2309 if (sig != SIGALRM)
2310 return errno = EINVAL,
2311 error("sigaction only implemented for SIGALRM");
2312 if (out != NULL)
2313 return errno = EINVAL,
2314 error("sigaction: param 3 != NULL not implemented");
2315
2316 timer_fn = in->sa_handler;
2317 return 0;
2318 }
2319
2320 #undef signal
2321 sig_handler_t mingw_signal(int sig, sig_handler_t handler)
2322 {
2323 sig_handler_t old;
2324
2325 switch (sig) {
2326 case SIGALRM:
2327 old = timer_fn;
2328 timer_fn = handler;
2329 break;
2330
2331 case SIGINT:
2332 old = sigint_fn;
2333 sigint_fn = handler;
2334 break;
2335
2336 default:
2337 return signal(sig, handler);
2338 }
2339
2340 return old;
2341 }
2342
2343 #undef raise
2344 int mingw_raise(int sig)
2345 {
2346 switch (sig) {
2347 case SIGALRM:
2348 if (timer_fn == SIG_DFL) {
2349 if (isatty(STDERR_FILENO))
2350 fputs("Alarm clock\n", stderr);
2351 exit(128 + SIGALRM);
2352 } else if (timer_fn != SIG_IGN)
2353 timer_fn(SIGALRM);
2354 return 0;
2355
2356 case SIGINT:
2357 if (sigint_fn == SIG_DFL)
2358 exit(128 + SIGINT);
2359 else if (sigint_fn != SIG_IGN)
2360 sigint_fn(SIGINT);
2361 return 0;
2362
2363 #if defined(_MSC_VER)
2364 case SIGILL:
2365 case SIGFPE:
2366 case SIGSEGV:
2367 case SIGTERM:
2368 case SIGBREAK:
2369 case SIGABRT:
2370 case SIGABRT_COMPAT:
2371 /*
2372 * The <signal.h> header in the MS C Runtime defines 8 signals
2373 * as being supported on the platform. Anything else causes an
2374 * "Invalid signal or error" (which in DEBUG builds causes the
2375 * Abort/Retry/Ignore dialog). We by-pass the CRT for things we
2376 * already know will fail.
2377 */
2378 return raise(sig);
2379 default:
2380 errno = EINVAL;
2381 return -1;
2382
2383 #else
2384
2385 default:
2386 return raise(sig);
2387
2388 #endif
2389
2390 }
2391 }
2392
2393 int link(const char *oldpath, const char *newpath)
2394 {
2395 wchar_t woldpath[MAX_PATH], wnewpath[MAX_PATH];
2396 if (xutftowcs_path(woldpath, oldpath) < 0 ||
2397 xutftowcs_path(wnewpath, newpath) < 0)
2398 return -1;
2399
2400 if (!CreateHardLinkW(wnewpath, woldpath, NULL)) {
2401 errno = err_win_to_posix(GetLastError());
2402 return -1;
2403 }
2404 return 0;
2405 }
2406
2407 pid_t waitpid(pid_t pid, int *status, int options)
2408 {
2409 HANDLE h = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION,
2410 FALSE, pid);
2411 if (!h) {
2412 errno = ECHILD;
2413 return -1;
2414 }
2415
2416 if (pid > 0 && options & WNOHANG) {
2417 if (WAIT_OBJECT_0 != WaitForSingleObject(h, 0)) {
2418 CloseHandle(h);
2419 return 0;
2420 }
2421 options &= ~WNOHANG;
2422 }
2423
2424 if (options == 0) {
2425 struct pinfo_t **ppinfo;
2426 if (WaitForSingleObject(h, INFINITE) != WAIT_OBJECT_0) {
2427 CloseHandle(h);
2428 return 0;
2429 }
2430
2431 if (status)
2432 GetExitCodeProcess(h, (LPDWORD)status);
2433
2434 EnterCriticalSection(&pinfo_cs);
2435
2436 ppinfo = &pinfo;
2437 while (*ppinfo) {
2438 struct pinfo_t *info = *ppinfo;
2439 if (info->pid == pid) {
2440 CloseHandle(info->proc);
2441 *ppinfo = info->next;
2442 free(info);
2443 break;
2444 }
2445 ppinfo = &info->next;
2446 }
2447
2448 LeaveCriticalSection(&pinfo_cs);
2449
2450 CloseHandle(h);
2451 return pid;
2452 }
2453 CloseHandle(h);
2454
2455 errno = EINVAL;
2456 return -1;
2457 }
2458
2459 int xutftowcsn(wchar_t *wcs, const char *utfs, size_t wcslen, int utflen)
2460 {
2461 int upos = 0, wpos = 0;
2462 const unsigned char *utf = (const unsigned char*) utfs;
2463 if (!utf || !wcs || wcslen < 1) {
2464 errno = EINVAL;
2465 return -1;
2466 }
2467 /* reserve space for \0 */
2468 wcslen--;
2469 if (utflen < 0)
2470 utflen = INT_MAX;
2471
2472 while (upos < utflen) {
2473 int c = utf[upos++] & 0xff;
2474 if (utflen == INT_MAX && c == 0)
2475 break;
2476
2477 if (wpos >= wcslen) {
2478 wcs[wpos] = 0;
2479 errno = ERANGE;
2480 return -1;
2481 }
2482
2483 if (c < 0x80) {
2484 /* ASCII */
2485 wcs[wpos++] = c;
2486 } else if (c >= 0xc2 && c < 0xe0 && upos < utflen &&
2487 (utf[upos] & 0xc0) == 0x80) {
2488 /* 2-byte utf-8 */
2489 c = ((c & 0x1f) << 6);
2490 c |= (utf[upos++] & 0x3f);
2491 wcs[wpos++] = c;
2492 } else if (c >= 0xe0 && c < 0xf0 && upos + 1 < utflen &&
2493 !(c == 0xe0 && utf[upos] < 0xa0) && /* over-long encoding */
2494 (utf[upos] & 0xc0) == 0x80 &&
2495 (utf[upos + 1] & 0xc0) == 0x80) {
2496 /* 3-byte utf-8 */
2497 c = ((c & 0x0f) << 12);
2498 c |= ((utf[upos++] & 0x3f) << 6);
2499 c |= (utf[upos++] & 0x3f);
2500 wcs[wpos++] = c;
2501 } else if (c >= 0xf0 && c < 0xf5 && upos + 2 < utflen &&
2502 wpos + 1 < wcslen &&
2503 !(c == 0xf0 && utf[upos] < 0x90) && /* over-long encoding */
2504 !(c == 0xf4 && utf[upos] >= 0x90) && /* > \u10ffff */
2505 (utf[upos] & 0xc0) == 0x80 &&
2506 (utf[upos + 1] & 0xc0) == 0x80 &&
2507 (utf[upos + 2] & 0xc0) == 0x80) {
2508 /* 4-byte utf-8: convert to \ud8xx \udcxx surrogate pair */
2509 c = ((c & 0x07) << 18);
2510 c |= ((utf[upos++] & 0x3f) << 12);
2511 c |= ((utf[upos++] & 0x3f) << 6);
2512 c |= (utf[upos++] & 0x3f);
2513 c -= 0x10000;
2514 wcs[wpos++] = 0xd800 | (c >> 10);
2515 wcs[wpos++] = 0xdc00 | (c & 0x3ff);
2516 } else if (c >= 0xa0) {
2517 /* invalid utf-8 byte, printable unicode char: convert 1:1 */
2518 wcs[wpos++] = c;
2519 } else {
2520 /* invalid utf-8 byte, non-printable unicode: convert to hex */
2521 static const char *hex = "0123456789abcdef";
2522 wcs[wpos++] = hex[c >> 4];
2523 if (wpos < wcslen)
2524 wcs[wpos++] = hex[c & 0x0f];
2525 }
2526 }
2527 wcs[wpos] = 0;
2528 return wpos;
2529 }
2530
2531 int xwcstoutf(char *utf, const wchar_t *wcs, size_t utflen)
2532 {
2533 if (!wcs || !utf || utflen < 1) {
2534 errno = EINVAL;
2535 return -1;
2536 }
2537 utflen = WideCharToMultiByte(CP_UTF8, 0, wcs, -1, utf, utflen, NULL, NULL);
2538 if (utflen)
2539 return utflen - 1;
2540 errno = ERANGE;
2541 return -1;
2542 }
2543
2544 static void setup_windows_environment(void)
2545 {
2546 char *tmp = getenv("TMPDIR");
2547
2548 /* on Windows it is TMP and TEMP */
2549 if (!tmp) {
2550 if (!(tmp = getenv("TMP")))
2551 tmp = getenv("TEMP");
2552 if (tmp) {
2553 setenv("TMPDIR", tmp, 1);
2554 tmp = getenv("TMPDIR");
2555 }
2556 }
2557
2558 if (tmp) {
2559 /*
2560 * Convert all dir separators to forward slashes,
2561 * to help shell commands called from the Git
2562 * executable (by not mistaking the dir separators
2563 * for escape characters).
2564 */
2565 convert_slashes(tmp);
2566 }
2567
2568 /* simulate TERM to enable auto-color (see color.c) */
2569 if (!getenv("TERM"))
2570 setenv("TERM", "cygwin", 1);
2571
2572 /* calculate HOME if not set */
2573 if (!getenv("HOME")) {
2574 /*
2575 * try $HOMEDRIVE$HOMEPATH - the home share may be a network
2576 * location, thus also check if the path exists (i.e. is not
2577 * disconnected)
2578 */
2579 if ((tmp = getenv("HOMEDRIVE"))) {
2580 struct strbuf buf = STRBUF_INIT;
2581 strbuf_addstr(&buf, tmp);
2582 if ((tmp = getenv("HOMEPATH"))) {
2583 strbuf_addstr(&buf, tmp);
2584 if (is_directory(buf.buf))
2585 setenv("HOME", buf.buf, 1);
2586 else
2587 tmp = NULL; /* use $USERPROFILE */
2588 }
2589 strbuf_release(&buf);
2590 }
2591 /* use $USERPROFILE if the home share is not available */
2592 if (!tmp && (tmp = getenv("USERPROFILE")))
2593 setenv("HOME", tmp, 1);
2594 }
2595 }
2596
2597 int is_valid_win32_path(const char *path, int allow_literal_nul)
2598 {
2599 const char *p = path;
2600 int preceding_space_or_period = 0, i = 0, periods = 0;
2601
2602 if (!protect_ntfs)
2603 return 1;
2604
2605 skip_dos_drive_prefix((char **)&path);
2606 goto segment_start;
2607
2608 for (;;) {
2609 char c = *(path++);
2610 switch (c) {
2611 case '\0':
2612 case '/': case '\\':
2613 /* cannot end in ` ` or `.`, except for `.` and `..` */
2614 if (preceding_space_or_period &&
2615 (i != periods || periods > 2))
2616 return 0;
2617 if (!c)
2618 return 1;
2619
2620 i = periods = preceding_space_or_period = 0;
2621
2622 segment_start:
2623 switch (*path) {
2624 case 'a': case 'A': /* AUX */
2625 if (((c = path[++i]) != 'u' && c != 'U') ||
2626 ((c = path[++i]) != 'x' && c != 'X')) {
2627 not_a_reserved_name:
2628 path += i;
2629 continue;
2630 }
2631 break;
2632 case 'c': case 'C':
2633 /* COM1 ... COM9, CON, CONIN$, CONOUT$ */
2634 if ((c = path[++i]) != 'o' && c != 'O')
2635 goto not_a_reserved_name;
2636 c = path[++i];
2637 if (c == 'm' || c == 'M') { /* COM1 ... COM9 */
2638 c = path[++i];
2639 if (c < '1' || c > '9')
2640 goto not_a_reserved_name;
2641 } else if (c == 'n' || c == 'N') { /* CON */
2642 c = path[i + 1];
2643 if ((c == 'i' || c == 'I') &&
2644 ((c = path[i + 2]) == 'n' ||
2645 c == 'N') &&
2646 path[i + 3] == '$')
2647 i += 3; /* CONIN$ */
2648 else if ((c == 'o' || c == 'O') &&
2649 ((c = path[i + 2]) == 'u' ||
2650 c == 'U') &&
2651 ((c = path[i + 3]) == 't' ||
2652 c == 'T') &&
2653 path[i + 4] == '$')
2654 i += 4; /* CONOUT$ */
2655 } else
2656 goto not_a_reserved_name;
2657 break;
2658 case 'l': case 'L': /* LPT<N> */
2659 if (((c = path[++i]) != 'p' && c != 'P') ||
2660 ((c = path[++i]) != 't' && c != 'T') ||
2661 !isdigit(path[++i]))
2662 goto not_a_reserved_name;
2663 break;
2664 case 'n': case 'N': /* NUL */
2665 if (((c = path[++i]) != 'u' && c != 'U') ||
2666 ((c = path[++i]) != 'l' && c != 'L') ||
2667 (allow_literal_nul &&
2668 !path[i + 1] && p == path))
2669 goto not_a_reserved_name;
2670 break;
2671 case 'p': case 'P': /* PRN */
2672 if (((c = path[++i]) != 'r' && c != 'R') ||
2673 ((c = path[++i]) != 'n' && c != 'N'))
2674 goto not_a_reserved_name;
2675 break;
2676 default:
2677 continue;
2678 }
2679
2680 /*
2681 * So far, this looks like a reserved name. Let's see
2682 * whether it actually is one: trailing spaces, a file
2683 * extension, or an NTFS Alternate Data Stream do not
2684 * matter, the name is still reserved if any of those
2685 * follow immediately after the actual name.
2686 */
2687 i++;
2688 if (path[i] == ' ') {
2689 preceding_space_or_period = 1;
2690 while (path[++i] == ' ')
2691 ; /* skip all spaces */
2692 }
2693
2694 c = path[i];
2695 if (c && c != '.' && c != ':' && c != '/' && c != '\\')
2696 goto not_a_reserved_name;
2697
2698 /* contains reserved name */
2699 return 0;
2700 case '.':
2701 periods++;
2702 /* fallthru */
2703 case ' ':
2704 preceding_space_or_period = 1;
2705 i++;
2706 continue;
2707 case ':': /* DOS drive prefix was already skipped */
2708 case '<': case '>': case '"': case '|': case '?': case '*':
2709 /* illegal character */
2710 return 0;
2711 default:
2712 if (c > '\0' && c < '\x20')
2713 /* illegal character */
2714 return 0;
2715 }
2716 preceding_space_or_period = 0;
2717 i++;
2718 }
2719 }
2720
2721 #if !defined(_MSC_VER)
2722 /*
2723 * Disable MSVCRT command line wildcard expansion (__getmainargs called from
2724 * mingw startup code, see init.c in mingw runtime).
2725 */
2726 int _CRT_glob = 0;
2727 #endif
2728
2729 static NORETURN void die_startup(void)
2730 {
2731 fputs("fatal: not enough memory for initialization", stderr);
2732 exit(128);
2733 }
2734
2735 static void *malloc_startup(size_t size)
2736 {
2737 void *result = malloc(size);
2738 if (!result)
2739 die_startup();
2740 return result;
2741 }
2742
2743 static char *wcstoutfdup_startup(char *buffer, const wchar_t *wcs, size_t len)
2744 {
2745 len = xwcstoutf(buffer, wcs, len) + 1;
2746 return memcpy(malloc_startup(len), buffer, len);
2747 }
2748
2749 static void maybe_redirect_std_handle(const wchar_t *key, DWORD std_id, int fd,
2750 DWORD desired_access, DWORD flags)
2751 {
2752 DWORD create_flag = fd ? OPEN_ALWAYS : OPEN_EXISTING;
2753 wchar_t buf[MAX_PATH];
2754 DWORD max = ARRAY_SIZE(buf);
2755 HANDLE handle;
2756 DWORD ret = GetEnvironmentVariableW(key, buf, max);
2757
2758 if (!ret || ret >= max)
2759 return;
2760
2761 /* make sure this does not leak into child processes */
2762 SetEnvironmentVariableW(key, NULL);
2763 if (!wcscmp(buf, L"off")) {
2764 close(fd);
2765 handle = GetStdHandle(std_id);
2766 if (handle != INVALID_HANDLE_VALUE)
2767 CloseHandle(handle);
2768 return;
2769 }
2770 if (std_id == STD_ERROR_HANDLE && !wcscmp(buf, L"2>&1")) {
2771 handle = GetStdHandle(STD_OUTPUT_HANDLE);
2772 if (handle == INVALID_HANDLE_VALUE) {
2773 close(fd);
2774 handle = GetStdHandle(std_id);
2775 if (handle != INVALID_HANDLE_VALUE)
2776 CloseHandle(handle);
2777 } else {
2778 int new_fd = _open_osfhandle((intptr_t)handle, O_BINARY);
2779 SetStdHandle(std_id, handle);
2780 dup2(new_fd, fd);
2781 /* do *not* close the new_fd: that would close stdout */
2782 }
2783 return;
2784 }
2785 handle = CreateFileW(buf, desired_access, 0, NULL, create_flag,
2786 flags, NULL);
2787 if (handle != INVALID_HANDLE_VALUE) {
2788 int new_fd = _open_osfhandle((intptr_t)handle, O_BINARY);
2789 SetStdHandle(std_id, handle);
2790 dup2(new_fd, fd);
2791 close(new_fd);
2792 }
2793 }
2794
2795 static void maybe_redirect_std_handles(void)
2796 {
2797 maybe_redirect_std_handle(L"GIT_REDIRECT_STDIN", STD_INPUT_HANDLE, 0,
2798 GENERIC_READ, FILE_ATTRIBUTE_NORMAL);
2799 maybe_redirect_std_handle(L"GIT_REDIRECT_STDOUT", STD_OUTPUT_HANDLE, 1,
2800 GENERIC_WRITE, FILE_ATTRIBUTE_NORMAL);
2801 maybe_redirect_std_handle(L"GIT_REDIRECT_STDERR", STD_ERROR_HANDLE, 2,
2802 GENERIC_WRITE, FILE_FLAG_NO_BUFFERING);
2803 }
2804
2805 #ifdef _MSC_VER
2806 #ifdef _DEBUG
2807 #include <crtdbg.h>
2808 #endif
2809 #endif
2810
2811 /*
2812 * We implement wmain() and compile with -municode, which would
2813 * normally ignore main(), but we call the latter from the former
2814 * so that we can handle non-ASCII command-line parameters
2815 * appropriately.
2816 *
2817 * To be more compatible with the core git code, we convert
2818 * argv into UTF8 and pass them directly to main().
2819 */
2820 int wmain(int argc, const wchar_t **wargv)
2821 {
2822 int i, maxlen, exit_status;
2823 char *buffer, **save;
2824 const char **argv;
2825
2826 trace2_initialize_clock();
2827
2828 #ifdef _MSC_VER
2829 #ifdef _DEBUG
2830 _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG);
2831 #endif
2832
2833 #ifdef USE_MSVC_CRTDBG
2834 _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
2835 #endif
2836 #endif
2837
2838 maybe_redirect_std_handles();
2839
2840 /* determine size of argv and environ conversion buffer */
2841 maxlen = wcslen(wargv[0]);
2842 for (i = 1; i < argc; i++)
2843 maxlen = max(maxlen, wcslen(wargv[i]));
2844
2845 /* allocate buffer (wchar_t encodes to max 3 UTF-8 bytes) */
2846 maxlen = 3 * maxlen + 1;
2847 buffer = malloc_startup(maxlen);
2848
2849 /*
2850 * Create a UTF-8 version of w_argv. Also create a "save" copy
2851 * to remember all the string pointers because parse_options()
2852 * will remove claimed items from the argv that we pass down.
2853 */
2854 ALLOC_ARRAY(argv, argc + 1);
2855 ALLOC_ARRAY(save, argc + 1);
2856 for (i = 0; i < argc; i++)
2857 argv[i] = save[i] = wcstoutfdup_startup(buffer, wargv[i], maxlen);
2858 argv[i] = save[i] = NULL;
2859 free(buffer);
2860
2861 /* fix Windows specific environment settings */
2862 setup_windows_environment();
2863
2864 unset_environment_variables = xstrdup("PERL5LIB");
2865
2866 /* initialize critical section for waitpid pinfo_t list */
2867 InitializeCriticalSection(&pinfo_cs);
2868
2869 /* set up default file mode and file modes for stdin/out/err */
2870 _fmode = _O_BINARY;
2871 _setmode(_fileno(stdin), _O_BINARY);
2872 _setmode(_fileno(stdout), _O_BINARY);
2873 _setmode(_fileno(stderr), _O_BINARY);
2874
2875 /* initialize Unicode console */
2876 winansi_init();
2877
2878 /* invoke the real main() using our utf8 version of argv. */
2879 exit_status = main(argc, argv);
2880
2881 for (i = 0; i < argc; i++)
2882 free(save[i]);
2883 free(save);
2884 free(argv);
2885
2886 return exit_status;
2887 }
2888
2889 int uname(struct utsname *buf)
2890 {
2891 unsigned v = (unsigned)GetVersion();
2892 memset(buf, 0, sizeof(*buf));
2893 xsnprintf(buf->sysname, sizeof(buf->sysname), "Windows");
2894 xsnprintf(buf->release, sizeof(buf->release),
2895 "%u.%u", v & 0xff, (v >> 8) & 0xff);
2896 /* assuming NT variants only.. */
2897 xsnprintf(buf->version, sizeof(buf->version),
2898 "%u", (v >> 16) & 0x7fff);
2899 return 0;
2900 }
ramsay's fork of git