t4201 (shortlog): Test output format with multiple authors
[git/dscho.git] / compat / mingw.c
blob59b18dc7ca51180426a0dbf11e651a93c5eedc81
1 #include "../git-compat-util.h"
2 #include "win32.h"
3 #include <conio.h>
4 #include "../strbuf.h"
6 int err_win_to_posix(DWORD winerr)
8 int error = ENOSYS;
9 switch(winerr) {
10 case ERROR_ACCESS_DENIED: error = EACCES; break;
11 case ERROR_ACCOUNT_DISABLED: error = EACCES; break;
12 case ERROR_ACCOUNT_RESTRICTION: error = EACCES; break;
13 case ERROR_ALREADY_ASSIGNED: error = EBUSY; break;
14 case ERROR_ALREADY_EXISTS: error = EEXIST; break;
15 case ERROR_ARITHMETIC_OVERFLOW: error = ERANGE; break;
16 case ERROR_BAD_COMMAND: error = EIO; break;
17 case ERROR_BAD_DEVICE: error = ENODEV; break;
18 case ERROR_BAD_DRIVER_LEVEL: error = ENXIO; break;
19 case ERROR_BAD_EXE_FORMAT: error = ENOEXEC; break;
20 case ERROR_BAD_FORMAT: error = ENOEXEC; break;
21 case ERROR_BAD_LENGTH: error = EINVAL; break;
22 case ERROR_BAD_PATHNAME: error = ENOENT; break;
23 case ERROR_BAD_PIPE: error = EPIPE; break;
24 case ERROR_BAD_UNIT: error = ENODEV; break;
25 case ERROR_BAD_USERNAME: error = EINVAL; break;
26 case ERROR_BROKEN_PIPE: error = EPIPE; break;
27 case ERROR_BUFFER_OVERFLOW: error = ENAMETOOLONG; break;
28 case ERROR_BUSY: error = EBUSY; break;
29 case ERROR_BUSY_DRIVE: error = EBUSY; break;
30 case ERROR_CALL_NOT_IMPLEMENTED: error = ENOSYS; break;
31 case ERROR_CANNOT_MAKE: error = EACCES; break;
32 case ERROR_CANTOPEN: error = EIO; break;
33 case ERROR_CANTREAD: error = EIO; break;
34 case ERROR_CANTWRITE: error = EIO; break;
35 case ERROR_CRC: error = EIO; break;
36 case ERROR_CURRENT_DIRECTORY: error = EACCES; break;
37 case ERROR_DEVICE_IN_USE: error = EBUSY; break;
38 case ERROR_DEV_NOT_EXIST: error = ENODEV; break;
39 case ERROR_DIRECTORY: error = EINVAL; break;
40 case ERROR_DIR_NOT_EMPTY: error = ENOTEMPTY; break;
41 case ERROR_DISK_CHANGE: error = EIO; break;
42 case ERROR_DISK_FULL: error = ENOSPC; break;
43 case ERROR_DRIVE_LOCKED: error = EBUSY; break;
44 case ERROR_ENVVAR_NOT_FOUND: error = EINVAL; break;
45 case ERROR_EXE_MARKED_INVALID: error = ENOEXEC; break;
46 case ERROR_FILENAME_EXCED_RANGE: error = ENAMETOOLONG; break;
47 case ERROR_FILE_EXISTS: error = EEXIST; break;
48 case ERROR_FILE_INVALID: error = ENODEV; break;
49 case ERROR_FILE_NOT_FOUND: error = ENOENT; break;
50 case ERROR_GEN_FAILURE: error = EIO; break;
51 case ERROR_HANDLE_DISK_FULL: error = ENOSPC; break;
52 case ERROR_INSUFFICIENT_BUFFER: error = ENOMEM; break;
53 case ERROR_INVALID_ACCESS: error = EACCES; break;
54 case ERROR_INVALID_ADDRESS: error = EFAULT; break;
55 case ERROR_INVALID_BLOCK: error = EFAULT; break;
56 case ERROR_INVALID_DATA: error = EINVAL; break;
57 case ERROR_INVALID_DRIVE: error = ENODEV; break;
58 case ERROR_INVALID_EXE_SIGNATURE: error = ENOEXEC; break;
59 case ERROR_INVALID_FLAGS: error = EINVAL; break;
60 case ERROR_INVALID_FUNCTION: error = ENOSYS; break;
61 case ERROR_INVALID_HANDLE: error = EBADF; break;
62 case ERROR_INVALID_LOGON_HOURS: error = EACCES; break;
63 case ERROR_INVALID_NAME: error = EINVAL; break;
64 case ERROR_INVALID_OWNER: error = EINVAL; break;
65 case ERROR_INVALID_PARAMETER: error = EINVAL; break;
66 case ERROR_INVALID_PASSWORD: error = EPERM; break;
67 case ERROR_INVALID_PRIMARY_GROUP: error = EINVAL; break;
68 case ERROR_INVALID_SIGNAL_NUMBER: error = EINVAL; break;
69 case ERROR_INVALID_TARGET_HANDLE: error = EIO; break;
70 case ERROR_INVALID_WORKSTATION: error = EACCES; break;
71 case ERROR_IO_DEVICE: error = EIO; break;
72 case ERROR_IO_INCOMPLETE: error = EINTR; break;
73 case ERROR_LOCKED: error = EBUSY; break;
74 case ERROR_LOCK_VIOLATION: error = EACCES; break;
75 case ERROR_LOGON_FAILURE: error = EACCES; break;
76 case ERROR_MAPPED_ALIGNMENT: error = EINVAL; break;
77 case ERROR_META_EXPANSION_TOO_LONG: error = E2BIG; break;
78 case ERROR_MORE_DATA: error = EPIPE; break;
79 case ERROR_NEGATIVE_SEEK: error = ESPIPE; break;
80 case ERROR_NOACCESS: error = EFAULT; break;
81 case ERROR_NONE_MAPPED: error = EINVAL; break;
82 case ERROR_NOT_ENOUGH_MEMORY: error = ENOMEM; break;
83 case ERROR_NOT_READY: error = EAGAIN; break;
84 case ERROR_NOT_SAME_DEVICE: error = EXDEV; break;
85 case ERROR_NO_DATA: error = EPIPE; break;
86 case ERROR_NO_MORE_SEARCH_HANDLES: error = EIO; break;
87 case ERROR_NO_PROC_SLOTS: error = EAGAIN; break;
88 case ERROR_NO_SUCH_PRIVILEGE: error = EACCES; break;
89 case ERROR_OPEN_FAILED: error = EIO; break;
90 case ERROR_OPEN_FILES: error = EBUSY; break;
91 case ERROR_OPERATION_ABORTED: error = EINTR; break;
92 case ERROR_OUTOFMEMORY: error = ENOMEM; break;
93 case ERROR_PASSWORD_EXPIRED: error = EACCES; break;
94 case ERROR_PATH_BUSY: error = EBUSY; break;
95 case ERROR_PATH_NOT_FOUND: error = ENOENT; break;
96 case ERROR_PIPE_BUSY: error = EBUSY; break;
97 case ERROR_PIPE_CONNECTED: error = EPIPE; break;
98 case ERROR_PIPE_LISTENING: error = EPIPE; break;
99 case ERROR_PIPE_NOT_CONNECTED: error = EPIPE; break;
100 case ERROR_PRIVILEGE_NOT_HELD: error = EACCES; break;
101 case ERROR_READ_FAULT: error = EIO; break;
102 case ERROR_SEEK: error = EIO; break;
103 case ERROR_SEEK_ON_DEVICE: error = ESPIPE; break;
104 case ERROR_SHARING_BUFFER_EXCEEDED: error = ENFILE; break;
105 case ERROR_SHARING_VIOLATION: error = EACCES; break;
106 case ERROR_STACK_OVERFLOW: error = ENOMEM; break;
107 case ERROR_SWAPERROR: error = ENOENT; break;
108 case ERROR_TOO_MANY_MODULES: error = EMFILE; break;
109 case ERROR_TOO_MANY_OPEN_FILES: error = EMFILE; break;
110 case ERROR_UNRECOGNIZED_MEDIA: error = ENXIO; break;
111 case ERROR_UNRECOGNIZED_VOLUME: error = ENODEV; break;
112 case ERROR_WAIT_NO_CHILDREN: error = ECHILD; break;
113 case ERROR_WRITE_FAULT: error = EIO; break;
114 case ERROR_WRITE_PROTECT: error = EROFS; break;
116 return error;
119 #undef open
120 int mingw_open (const char *filename, int oflags, ...)
122 va_list args;
123 unsigned mode;
124 int fd;
126 va_start(args, oflags);
127 mode = va_arg(args, int);
128 va_end(args);
130 if (!strcmp(filename, "/dev/null"))
131 filename = "nul";
133 fd = open(filename, oflags, mode);
135 if (fd < 0 && (oflags & O_CREAT) && errno == EACCES) {
136 DWORD attrs = GetFileAttributes(filename);
137 if (attrs != INVALID_FILE_ATTRIBUTES && (attrs & FILE_ATTRIBUTE_DIRECTORY))
138 errno = EISDIR;
140 return fd;
144 * The unit of FILETIME is 100-nanoseconds since January 1, 1601, UTC.
145 * Returns the 100-nanoseconds ("hekto nanoseconds") since the epoch.
147 static inline long long filetime_to_hnsec(const FILETIME *ft)
149 long long winTime = ((long long)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
150 /* Windows to Unix Epoch conversion */
151 return winTime - 116444736000000000LL;
154 static inline time_t filetime_to_time_t(const FILETIME *ft)
156 return (time_t)(filetime_to_hnsec(ft) / 10000000);
159 /* We keep the do_lstat code in a separate function to avoid recursion.
160 * When a path ends with a slash, the stat will fail with ENOENT. In
161 * this case, we strip the trailing slashes and stat again.
163 static int do_lstat(const char *file_name, struct stat *buf)
165 WIN32_FILE_ATTRIBUTE_DATA fdata;
167 if (!(errno = get_file_attr(file_name, &fdata))) {
168 buf->st_ino = 0;
169 buf->st_gid = 0;
170 buf->st_uid = 0;
171 buf->st_nlink = 1;
172 buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
173 buf->st_size = fdata.nFileSizeLow |
174 (((off_t)fdata.nFileSizeHigh)<<32);
175 buf->st_dev = buf->st_rdev = 0; /* not used by Git */
176 buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
177 buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
178 buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
179 return 0;
181 return -1;
184 /* We provide our own lstat/fstat functions, since the provided
185 * lstat/fstat functions are so slow. These stat functions are
186 * tailored for Git's usage (read: fast), and are not meant to be
187 * complete. Note that Git stat()s are redirected to mingw_lstat()
188 * too, since Windows doesn't really handle symlinks that well.
190 int mingw_lstat(const char *file_name, struct stat *buf)
192 int namelen;
193 static char alt_name[PATH_MAX];
195 if (!do_lstat(file_name, buf))
196 return 0;
198 /* if file_name ended in a '/', Windows returned ENOENT;
199 * try again without trailing slashes
201 if (errno != ENOENT)
202 return -1;
204 namelen = strlen(file_name);
205 if (namelen && file_name[namelen-1] != '/')
206 return -1;
207 while (namelen && file_name[namelen-1] == '/')
208 --namelen;
209 if (!namelen || namelen >= PATH_MAX)
210 return -1;
212 memcpy(alt_name, file_name, namelen);
213 alt_name[namelen] = 0;
214 return do_lstat(alt_name, buf);
217 #undef fstat
218 int mingw_fstat(int fd, struct stat *buf)
220 HANDLE fh = (HANDLE)_get_osfhandle(fd);
221 BY_HANDLE_FILE_INFORMATION fdata;
223 if (fh == INVALID_HANDLE_VALUE) {
224 errno = EBADF;
225 return -1;
227 /* direct non-file handles to MS's fstat() */
228 if (GetFileType(fh) != FILE_TYPE_DISK)
229 return _fstati64(fd, buf);
231 if (GetFileInformationByHandle(fh, &fdata)) {
232 buf->st_ino = 0;
233 buf->st_gid = 0;
234 buf->st_uid = 0;
235 buf->st_nlink = 1;
236 buf->st_mode = file_attr_to_st_mode(fdata.dwFileAttributes);
237 buf->st_size = fdata.nFileSizeLow |
238 (((off_t)fdata.nFileSizeHigh)<<32);
239 buf->st_dev = buf->st_rdev = 0; /* not used by Git */
240 buf->st_atime = filetime_to_time_t(&(fdata.ftLastAccessTime));
241 buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
242 buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
243 return 0;
245 errno = EBADF;
246 return -1;
249 static inline void time_t_to_filetime(time_t t, FILETIME *ft)
251 long long winTime = t * 10000000LL + 116444736000000000LL;
252 ft->dwLowDateTime = winTime;
253 ft->dwHighDateTime = winTime >> 32;
256 int mingw_utime (const char *file_name, const struct utimbuf *times)
258 FILETIME mft, aft;
259 int fh, rc;
261 /* must have write permission */
262 DWORD attrs = GetFileAttributes(file_name);
263 if (attrs != INVALID_FILE_ATTRIBUTES &&
264 (attrs & FILE_ATTRIBUTE_READONLY)) {
265 /* ignore errors here; open() will report them */
266 SetFileAttributes(file_name, attrs & ~FILE_ATTRIBUTE_READONLY);
269 if ((fh = open(file_name, O_RDWR | O_BINARY)) < 0) {
270 rc = -1;
271 goto revert_attrs;
274 time_t_to_filetime(times->modtime, &mft);
275 time_t_to_filetime(times->actime, &aft);
276 if (!SetFileTime((HANDLE)_get_osfhandle(fh), NULL, &aft, &mft)) {
277 errno = EINVAL;
278 rc = -1;
279 } else
280 rc = 0;
281 close(fh);
283 revert_attrs:
284 if (attrs != INVALID_FILE_ATTRIBUTES &&
285 (attrs & FILE_ATTRIBUTE_READONLY)) {
286 /* ignore errors again */
287 SetFileAttributes(file_name, attrs);
289 return rc;
292 unsigned int sleep (unsigned int seconds)
294 Sleep(seconds*1000);
295 return 0;
298 int mkstemp(char *template)
300 char *filename = mktemp(template);
301 if (filename == NULL)
302 return -1;
303 return open(filename, O_RDWR | O_CREAT, 0600);
306 int gettimeofday(struct timeval *tv, void *tz)
308 FILETIME ft;
309 long long hnsec;
311 GetSystemTimeAsFileTime(&ft);
312 hnsec = filetime_to_hnsec(&ft);
313 tv->tv_sec = hnsec / 10000000;
314 tv->tv_usec = (hnsec % 10000000) / 10;
315 return 0;
318 int pipe(int filedes[2])
320 HANDLE h[2];
322 /* this creates non-inheritable handles */
323 if (!CreatePipe(&h[0], &h[1], NULL, 8192)) {
324 errno = err_win_to_posix(GetLastError());
325 return -1;
327 filedes[0] = _open_osfhandle((int)h[0], O_NOINHERIT);
328 if (filedes[0] < 0) {
329 CloseHandle(h[0]);
330 CloseHandle(h[1]);
331 return -1;
333 filedes[1] = _open_osfhandle((int)h[1], O_NOINHERIT);
334 if (filedes[0] < 0) {
335 close(filedes[0]);
336 CloseHandle(h[1]);
337 return -1;
339 return 0;
342 int poll(struct pollfd *ufds, unsigned int nfds, int timeout)
344 int i, pending;
346 if (timeout >= 0) {
347 if (nfds == 0) {
348 Sleep(timeout);
349 return 0;
351 return errno = EINVAL, error("poll timeout not supported");
354 /* When there is only one fd to wait for, then we pretend that
355 * input is available and let the actual wait happen when the
356 * caller invokes read().
358 if (nfds == 1) {
359 if (!(ufds[0].events & POLLIN))
360 return errno = EINVAL, error("POLLIN not set");
361 ufds[0].revents = POLLIN;
362 return 0;
365 repeat:
366 pending = 0;
367 for (i = 0; i < nfds; i++) {
368 DWORD avail = 0;
369 HANDLE h = (HANDLE) _get_osfhandle(ufds[i].fd);
370 if (h == INVALID_HANDLE_VALUE)
371 return -1; /* errno was set */
373 if (!(ufds[i].events & POLLIN))
374 return errno = EINVAL, error("POLLIN not set");
376 /* this emulation works only for pipes */
377 if (!PeekNamedPipe(h, NULL, 0, NULL, &avail, NULL)) {
378 int err = GetLastError();
379 if (err == ERROR_BROKEN_PIPE) {
380 ufds[i].revents = POLLHUP;
381 pending++;
382 } else {
383 errno = EINVAL;
384 return error("PeekNamedPipe failed,"
385 " GetLastError: %u", err);
387 } else if (avail) {
388 ufds[i].revents = POLLIN;
389 pending++;
390 } else
391 ufds[i].revents = 0;
393 if (!pending) {
394 /* The only times that we spin here is when the process
395 * that is connected through the pipes is waiting for
396 * its own input data to become available. But since
397 * the process (pack-objects) is itself CPU intensive,
398 * it will happily pick up the time slice that we are
399 * relinquishing here.
401 Sleep(0);
402 goto repeat;
404 return 0;
407 struct tm *gmtime_r(const time_t *timep, struct tm *result)
409 /* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
410 memcpy(result, gmtime(timep), sizeof(struct tm));
411 return result;
414 struct tm *localtime_r(const time_t *timep, struct tm *result)
416 /* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
417 memcpy(result, localtime(timep), sizeof(struct tm));
418 return result;
421 #undef getcwd
422 char *mingw_getcwd(char *pointer, int len)
424 int i;
425 char *ret = getcwd(pointer, len);
426 if (!ret)
427 return ret;
428 for (i = 0; pointer[i]; i++)
429 if (pointer[i] == '\\')
430 pointer[i] = '/';
431 return ret;
434 #undef getenv
435 char *mingw_getenv(const char *name)
437 char *result = getenv(name);
438 if (!result && !strcmp(name, "TMPDIR")) {
439 /* on Windows it is TMP and TEMP */
440 result = getenv("TMP");
441 if (!result)
442 result = getenv("TEMP");
444 return result;
448 * See http://msdn2.microsoft.com/en-us/library/17w5ykft(vs.71).aspx
449 * (Parsing C++ Command-Line Arguments)
451 static const char *quote_arg(const char *arg)
453 /* count chars to quote */
454 int len = 0, n = 0;
455 int force_quotes = 0;
456 char *q, *d;
457 const char *p = arg;
458 if (!*p) force_quotes = 1;
459 while (*p) {
460 if (isspace(*p) || *p == '*' || *p == '?' || *p == '{' || *p == '\'')
461 force_quotes = 1;
462 else if (*p == '"')
463 n++;
464 else if (*p == '\\') {
465 int count = 0;
466 while (*p == '\\') {
467 count++;
468 p++;
469 len++;
471 if (*p == '"')
472 n += count*2 + 1;
473 continue;
475 len++;
476 p++;
478 if (!force_quotes && n == 0)
479 return arg;
481 /* insert \ where necessary */
482 d = q = xmalloc(len+n+3);
483 *d++ = '"';
484 while (*arg) {
485 if (*arg == '"')
486 *d++ = '\\';
487 else if (*arg == '\\') {
488 int count = 0;
489 while (*arg == '\\') {
490 count++;
491 *d++ = *arg++;
493 if (*arg == '"') {
494 while (count-- > 0)
495 *d++ = '\\';
496 *d++ = '\\';
499 *d++ = *arg++;
501 *d++ = '"';
502 *d++ = 0;
503 return q;
506 static const char *parse_interpreter(const char *cmd)
508 static char buf[100];
509 char *p, *opt;
510 int n, fd;
512 /* don't even try a .exe */
513 n = strlen(cmd);
514 if (n >= 4 && !strcasecmp(cmd+n-4, ".exe"))
515 return NULL;
517 fd = open(cmd, O_RDONLY);
518 if (fd < 0)
519 return NULL;
520 n = read(fd, buf, sizeof(buf)-1);
521 close(fd);
522 if (n < 4) /* at least '#!/x' and not error */
523 return NULL;
525 if (buf[0] != '#' || buf[1] != '!')
526 return NULL;
527 buf[n] = '\0';
528 p = buf + strcspn(buf, "\r\n");
529 if (!*p)
530 return NULL;
532 *p = '\0';
533 if (!(p = strrchr(buf+2, '/')) && !(p = strrchr(buf+2, '\\')))
534 return NULL;
535 /* strip options */
536 if ((opt = strchr(p+1, ' ')))
537 *opt = '\0';
538 return p+1;
542 * Splits the PATH into parts.
544 static char **get_path_split(void)
546 char *p, **path, *envpath = getenv("PATH");
547 int i, n = 0;
549 if (!envpath || !*envpath)
550 return NULL;
552 envpath = xstrdup(envpath);
553 p = envpath;
554 while (p) {
555 char *dir = p;
556 p = strchr(p, ';');
557 if (p) *p++ = '\0';
558 if (*dir) { /* not earlier, catches series of ; */
559 ++n;
562 if (!n)
563 return NULL;
565 path = xmalloc((n+1)*sizeof(char *));
566 p = envpath;
567 i = 0;
568 do {
569 if (*p)
570 path[i++] = xstrdup(p);
571 p = p+strlen(p)+1;
572 } while (i < n);
573 path[i] = NULL;
575 free(envpath);
577 return path;
580 static void free_path_split(char **path)
582 char **p = path;
584 if (!path)
585 return;
587 while (*p)
588 free(*p++);
589 free(path);
593 * exe_only means that we only want to detect .exe files, but not scripts
594 * (which do not have an extension)
596 static char *lookup_prog(const char *dir, const char *cmd, int isexe, int exe_only)
598 char path[MAX_PATH];
599 snprintf(path, sizeof(path), "%s/%s.exe", dir, cmd);
601 if (!isexe && access(path, F_OK) == 0)
602 return xstrdup(path);
603 path[strlen(path)-4] = '\0';
604 if ((!exe_only || isexe) && access(path, F_OK) == 0)
605 if (!(GetFileAttributes(path) & FILE_ATTRIBUTE_DIRECTORY))
606 return xstrdup(path);
607 return NULL;
611 * Determines the absolute path of cmd using the the split path in path.
612 * If cmd contains a slash or backslash, no lookup is performed.
614 static char *path_lookup(const char *cmd, char **path, int exe_only)
616 char *prog = NULL;
617 int len = strlen(cmd);
618 int isexe = len >= 4 && !strcasecmp(cmd+len-4, ".exe");
620 if (strchr(cmd, '/') || strchr(cmd, '\\'))
621 prog = xstrdup(cmd);
623 while (!prog && *path)
624 prog = lookup_prog(*path++, cmd, isexe, exe_only);
626 return prog;
629 static int env_compare(const void *a, const void *b)
631 char *const *ea = a;
632 char *const *eb = b;
633 return strcasecmp(*ea, *eb);
636 static pid_t mingw_spawnve_fd(const char *cmd, const char **argv, char **env,
637 int prepend_cmd, int fhin, int fhout, int fherr)
639 STARTUPINFO si;
640 PROCESS_INFORMATION pi;
641 struct strbuf envblk, args;
642 unsigned flags;
643 BOOL ret;
645 /* Determine whether or not we are associated to a console */
646 HANDLE cons = CreateFile("CONOUT$", GENERIC_WRITE,
647 FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
648 FILE_ATTRIBUTE_NORMAL, NULL);
649 if (cons == INVALID_HANDLE_VALUE) {
650 /* There is no console associated with this process.
651 * Since the child is a console process, Windows
652 * would normally create a console window. But
653 * since we'll be redirecting std streams, we do
654 * not need the console.
655 * It is necessary to use DETACHED_PROCESS
656 * instead of CREATE_NO_WINDOW to make ssh
657 * recognize that it has no console.
659 flags = DETACHED_PROCESS;
660 } else {
661 /* There is already a console. If we specified
662 * DETACHED_PROCESS here, too, Windows would
663 * disassociate the child from the console.
664 * The same is true for CREATE_NO_WINDOW.
665 * Go figure!
667 flags = 0;
668 CloseHandle(cons);
670 memset(&si, 0, sizeof(si));
671 si.cb = sizeof(si);
672 si.dwFlags = STARTF_USESTDHANDLES;
673 si.hStdInput = (HANDLE) _get_osfhandle(fhin);
674 si.hStdOutput = (HANDLE) _get_osfhandle(fhout);
675 si.hStdError = (HANDLE) _get_osfhandle(fherr);
677 /* concatenate argv, quoting args as we go */
678 strbuf_init(&args, 0);
679 if (prepend_cmd) {
680 char *quoted = (char *)quote_arg(cmd);
681 strbuf_addstr(&args, quoted);
682 if (quoted != cmd)
683 free(quoted);
685 for (; *argv; argv++) {
686 char *quoted = (char *)quote_arg(*argv);
687 if (*args.buf)
688 strbuf_addch(&args, ' ');
689 strbuf_addstr(&args, quoted);
690 if (quoted != *argv)
691 free(quoted);
694 if (env) {
695 int count = 0;
696 char **e, **sorted_env;
698 for (e = env; *e; e++)
699 count++;
701 /* environment must be sorted */
702 sorted_env = xmalloc(sizeof(*sorted_env) * (count + 1));
703 memcpy(sorted_env, env, sizeof(*sorted_env) * (count + 1));
704 qsort(sorted_env, count, sizeof(*sorted_env), env_compare);
706 strbuf_init(&envblk, 0);
707 for (e = sorted_env; *e; e++) {
708 strbuf_addstr(&envblk, *e);
709 strbuf_addch(&envblk, '\0');
711 free(sorted_env);
714 memset(&pi, 0, sizeof(pi));
715 ret = CreateProcess(cmd, args.buf, NULL, NULL, TRUE, flags,
716 env ? envblk.buf : NULL, NULL, &si, &pi);
718 if (env)
719 strbuf_release(&envblk);
720 strbuf_release(&args);
722 if (!ret) {
723 errno = ENOENT;
724 return -1;
726 CloseHandle(pi.hThread);
727 return (pid_t)pi.hProcess;
730 static pid_t mingw_spawnve(const char *cmd, const char **argv, char **env,
731 int prepend_cmd)
733 return mingw_spawnve_fd(cmd, argv, env, prepend_cmd, 0, 1, 2);
736 pid_t mingw_spawnvpe(const char *cmd, const char **argv, char **env,
737 int fhin, int fhout, int fherr)
739 pid_t pid;
740 char **path = get_path_split();
741 char *prog = path_lookup(cmd, path, 0);
743 if (!prog) {
744 errno = ENOENT;
745 pid = -1;
747 else {
748 const char *interpr = parse_interpreter(prog);
750 if (interpr) {
751 const char *argv0 = argv[0];
752 char *iprog = path_lookup(interpr, path, 1);
753 argv[0] = prog;
754 if (!iprog) {
755 errno = ENOENT;
756 pid = -1;
758 else {
759 pid = mingw_spawnve_fd(iprog, argv, env, 1,
760 fhin, fhout, fherr);
761 free(iprog);
763 argv[0] = argv0;
765 else
766 pid = mingw_spawnve_fd(prog, argv, env, 0,
767 fhin, fhout, fherr);
768 free(prog);
770 free_path_split(path);
771 return pid;
774 static int try_shell_exec(const char *cmd, char *const *argv, char **env)
776 const char *interpr = parse_interpreter(cmd);
777 char **path;
778 char *prog;
779 int pid = 0;
781 if (!interpr)
782 return 0;
783 path = get_path_split();
784 prog = path_lookup(interpr, path, 1);
785 if (prog) {
786 int argc = 0;
787 const char **argv2;
788 while (argv[argc]) argc++;
789 argv2 = xmalloc(sizeof(*argv) * (argc+1));
790 argv2[0] = (char *)cmd; /* full path to the script file */
791 memcpy(&argv2[1], &argv[1], sizeof(*argv) * argc);
792 pid = mingw_spawnve(prog, argv2, env, 1);
793 if (pid >= 0) {
794 int status;
795 if (waitpid(pid, &status, 0) < 0)
796 status = 255;
797 exit(status);
799 pid = 1; /* indicate that we tried but failed */
800 free(prog);
801 free(argv2);
803 free_path_split(path);
804 return pid;
807 static void mingw_execve(const char *cmd, char *const *argv, char *const *env)
809 /* check if git_command is a shell script */
810 if (!try_shell_exec(cmd, argv, (char **)env)) {
811 int pid, status;
813 pid = mingw_spawnve(cmd, (const char **)argv, (char **)env, 0);
814 if (pid < 0)
815 return;
816 if (waitpid(pid, &status, 0) < 0)
817 status = 255;
818 exit(status);
822 void mingw_execvp(const char *cmd, char *const *argv)
824 char **path = get_path_split();
825 char *prog = path_lookup(cmd, path, 0);
827 if (prog) {
828 mingw_execve(prog, argv, environ);
829 free(prog);
830 } else
831 errno = ENOENT;
833 free_path_split(path);
836 static char **copy_environ(void)
838 char **env;
839 int i = 0;
840 while (environ[i])
841 i++;
842 env = xmalloc((i+1)*sizeof(*env));
843 for (i = 0; environ[i]; i++)
844 env[i] = xstrdup(environ[i]);
845 env[i] = NULL;
846 return env;
849 void free_environ(char **env)
851 int i;
852 for (i = 0; env[i]; i++)
853 free(env[i]);
854 free(env);
857 static int lookup_env(char **env, const char *name, size_t nmln)
859 int i;
861 for (i = 0; env[i]; i++) {
862 if (0 == strncmp(env[i], name, nmln)
863 && '=' == env[i][nmln])
864 /* matches */
865 return i;
867 return -1;
871 * If name contains '=', then sets the variable, otherwise it unsets it
873 static char **env_setenv(char **env, const char *name)
875 char *eq = strchrnul(name, '=');
876 int i = lookup_env(env, name, eq-name);
878 if (i < 0) {
879 if (*eq) {
880 for (i = 0; env[i]; i++)
882 env = xrealloc(env, (i+2)*sizeof(*env));
883 env[i] = xstrdup(name);
884 env[i+1] = NULL;
887 else {
888 free(env[i]);
889 if (*eq)
890 env[i] = xstrdup(name);
891 else
892 for (; env[i]; i++)
893 env[i] = env[i+1];
895 return env;
899 * Copies global environ and adjusts variables as specified by vars.
901 char **make_augmented_environ(const char *const *vars)
903 char **env = copy_environ();
905 while (*vars)
906 env = env_setenv(env, *vars++);
907 return env;
911 * Note, this isn't a complete replacement for getaddrinfo. It assumes
912 * that service contains a numerical port, or that it it is null. It
913 * does a simple search using gethostbyname, and returns one IPv4 host
914 * if one was found.
916 static int WSAAPI getaddrinfo_stub(const char *node, const char *service,
917 const struct addrinfo *hints,
918 struct addrinfo **res)
920 struct hostent *h = gethostbyname(node);
921 struct addrinfo *ai;
922 struct sockaddr_in *sin;
924 if (!h)
925 return WSAGetLastError();
927 ai = xmalloc(sizeof(struct addrinfo));
928 *res = ai;
929 ai->ai_flags = 0;
930 ai->ai_family = AF_INET;
931 ai->ai_socktype = hints->ai_socktype;
932 switch (hints->ai_socktype) {
933 case SOCK_STREAM:
934 ai->ai_protocol = IPPROTO_TCP;
935 break;
936 case SOCK_DGRAM:
937 ai->ai_protocol = IPPROTO_UDP;
938 break;
939 default:
940 ai->ai_protocol = 0;
941 break;
943 ai->ai_addrlen = sizeof(struct sockaddr_in);
944 ai->ai_canonname = strdup(h->h_name);
946 sin = xmalloc(ai->ai_addrlen);
947 memset(sin, 0, ai->ai_addrlen);
948 sin->sin_family = AF_INET;
949 if (service)
950 sin->sin_port = htons(atoi(service));
951 sin->sin_addr = *(struct in_addr *)h->h_addr;
952 ai->ai_addr = (struct sockaddr *)sin;
953 ai->ai_next = 0;
954 return 0;
957 static void WSAAPI freeaddrinfo_stub(struct addrinfo *res)
959 free(res->ai_canonname);
960 free(res->ai_addr);
961 free(res);
964 static int WSAAPI getnameinfo_stub(const struct sockaddr *sa, socklen_t salen,
965 char *host, DWORD hostlen,
966 char *serv, DWORD servlen, int flags)
968 const struct sockaddr_in *sin = (const struct sockaddr_in *)sa;
969 if (sa->sa_family != AF_INET)
970 return EAI_FAMILY;
971 if (!host && !serv)
972 return EAI_NONAME;
974 if (host && hostlen > 0) {
975 struct hostent *ent = NULL;
976 if (!(flags & NI_NUMERICHOST))
977 ent = gethostbyaddr((const char *)&sin->sin_addr,
978 sizeof(sin->sin_addr), AF_INET);
980 if (ent)
981 snprintf(host, hostlen, "%s", ent->h_name);
982 else if (flags & NI_NAMEREQD)
983 return EAI_NONAME;
984 else
985 snprintf(host, hostlen, "%s", inet_ntoa(sin->sin_addr));
988 if (serv && servlen > 0) {
989 struct servent *ent = NULL;
990 if (!(flags & NI_NUMERICSERV))
991 ent = getservbyport(sin->sin_port,
992 flags & NI_DGRAM ? "udp" : "tcp");
994 if (ent)
995 snprintf(serv, servlen, "%s", ent->s_name);
996 else
997 snprintf(serv, servlen, "%d", ntohs(sin->sin_port));
1000 return 0;
1003 static HMODULE ipv6_dll = NULL;
1004 static void (WSAAPI *ipv6_freeaddrinfo)(struct addrinfo *res);
1005 static int (WSAAPI *ipv6_getaddrinfo)(const char *node, const char *service,
1006 const struct addrinfo *hints,
1007 struct addrinfo **res);
1008 static int (WSAAPI *ipv6_getnameinfo)(const struct sockaddr *sa, socklen_t salen,
1009 char *host, DWORD hostlen,
1010 char *serv, DWORD servlen, int flags);
1012 * gai_strerror is an inline function in the ws2tcpip.h header, so we
1013 * don't need to try to load that one dynamically.
1016 static void socket_cleanup(void)
1018 WSACleanup();
1019 if (ipv6_dll)
1020 FreeLibrary(ipv6_dll);
1021 ipv6_dll = NULL;
1022 ipv6_freeaddrinfo = freeaddrinfo_stub;
1023 ipv6_getaddrinfo = getaddrinfo_stub;
1024 ipv6_getnameinfo = getnameinfo_stub;
1027 static void ensure_socket_initialization(void)
1029 WSADATA wsa;
1030 static int initialized = 0;
1031 const char *libraries[] = { "ws2_32.dll", "wship6.dll", NULL };
1032 const char **name;
1034 if (initialized)
1035 return;
1037 if (WSAStartup(MAKEWORD(2,2), &wsa))
1038 die("unable to initialize winsock subsystem, error %d",
1039 WSAGetLastError());
1041 for (name = libraries; *name; name++) {
1042 ipv6_dll = LoadLibrary(*name);
1043 if (!ipv6_dll)
1044 continue;
1046 ipv6_freeaddrinfo = (void (WSAAPI *)(struct addrinfo *))
1047 GetProcAddress(ipv6_dll, "freeaddrinfo");
1048 ipv6_getaddrinfo = (int (WSAAPI *)(const char *, const char *,
1049 const struct addrinfo *,
1050 struct addrinfo **))
1051 GetProcAddress(ipv6_dll, "getaddrinfo");
1052 ipv6_getnameinfo = (int (WSAAPI *)(const struct sockaddr *,
1053 socklen_t, char *, DWORD,
1054 char *, DWORD, int))
1055 GetProcAddress(ipv6_dll, "getnameinfo");
1056 if (!ipv6_freeaddrinfo || !ipv6_getaddrinfo || !ipv6_getnameinfo) {
1057 FreeLibrary(ipv6_dll);
1058 ipv6_dll = NULL;
1059 } else
1060 break;
1062 if (!ipv6_freeaddrinfo || !ipv6_getaddrinfo || !ipv6_getnameinfo) {
1063 ipv6_freeaddrinfo = freeaddrinfo_stub;
1064 ipv6_getaddrinfo = getaddrinfo_stub;
1065 ipv6_getnameinfo = getnameinfo_stub;
1068 atexit(socket_cleanup);
1069 initialized = 1;
1072 #undef gethostbyname
1073 struct hostent *mingw_gethostbyname(const char *host)
1075 ensure_socket_initialization();
1076 return gethostbyname(host);
1079 void mingw_freeaddrinfo(struct addrinfo *res)
1081 ipv6_freeaddrinfo(res);
1084 int mingw_getaddrinfo(const char *node, const char *service,
1085 const struct addrinfo *hints, struct addrinfo **res)
1087 ensure_socket_initialization();
1088 return ipv6_getaddrinfo(node, service, hints, res);
1091 int mingw_getnameinfo(const struct sockaddr *sa, socklen_t salen,
1092 char *host, DWORD hostlen, char *serv, DWORD servlen,
1093 int flags)
1095 ensure_socket_initialization();
1096 return ipv6_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
1099 int mingw_socket(int domain, int type, int protocol)
1101 int sockfd;
1102 SOCKET s = WSASocket(domain, type, protocol, NULL, 0, 0);
1103 if (s == INVALID_SOCKET) {
1105 * WSAGetLastError() values are regular BSD error codes
1106 * biased by WSABASEERR.
1107 * However, strerror() does not know about networking
1108 * specific errors, which are values beginning at 38 or so.
1109 * Therefore, we choose to leave the biased error code
1110 * in errno so that _if_ someone looks up the code somewhere,
1111 * then it is at least the number that are usually listed.
1113 errno = WSAGetLastError();
1114 return -1;
1116 /* convert into a file descriptor */
1117 if ((sockfd = _open_osfhandle(s, O_RDWR|O_BINARY)) < 0) {
1118 closesocket(s);
1119 return error("unable to make a socket file descriptor: %s",
1120 strerror(errno));
1122 return sockfd;
1125 #undef connect
1126 int mingw_connect(int sockfd, struct sockaddr *sa, size_t sz)
1128 SOCKET s = (SOCKET)_get_osfhandle(sockfd);
1129 return connect(s, sa, sz);
1132 #undef rename
1133 int mingw_rename(const char *pold, const char *pnew)
1135 DWORD attrs, gle;
1136 int tries = 0;
1137 static const int delay[] = { 0, 1, 10, 20, 40 };
1140 * Try native rename() first to get errno right.
1141 * It is based on MoveFile(), which cannot overwrite existing files.
1143 if (!rename(pold, pnew))
1144 return 0;
1145 if (errno != EEXIST)
1146 return -1;
1147 repeat:
1148 if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
1149 return 0;
1150 /* TODO: translate more errors */
1151 gle = GetLastError();
1152 if (gle == ERROR_ACCESS_DENIED &&
1153 (attrs = GetFileAttributes(pnew)) != INVALID_FILE_ATTRIBUTES) {
1154 if (attrs & FILE_ATTRIBUTE_DIRECTORY) {
1155 errno = EISDIR;
1156 return -1;
1158 if ((attrs & FILE_ATTRIBUTE_READONLY) &&
1159 SetFileAttributes(pnew, attrs & ~FILE_ATTRIBUTE_READONLY)) {
1160 if (MoveFileEx(pold, pnew, MOVEFILE_REPLACE_EXISTING))
1161 return 0;
1162 gle = GetLastError();
1163 /* revert file attributes on failure */
1164 SetFileAttributes(pnew, attrs);
1167 if (tries < ARRAY_SIZE(delay) && gle == ERROR_ACCESS_DENIED) {
1169 * We assume that some other process had the source or
1170 * destination file open at the wrong moment and retry.
1171 * In order to give the other process a higher chance to
1172 * complete its operation, we give up our time slice now.
1173 * If we have to retry again, we do sleep a bit.
1175 Sleep(delay[tries]);
1176 tries++;
1177 goto repeat;
1179 errno = EACCES;
1180 return -1;
1184 * Note that this doesn't return the actual pagesize, but
1185 * the allocation granularity. If future Windows specific git code
1186 * needs the real getpagesize function, we need to find another solution.
1188 int mingw_getpagesize(void)
1190 SYSTEM_INFO si;
1191 GetSystemInfo(&si);
1192 return si.dwAllocationGranularity;
1195 struct passwd *getpwuid(int uid)
1197 static char user_name[100];
1198 static struct passwd p;
1200 DWORD len = sizeof(user_name);
1201 if (!GetUserName(user_name, &len))
1202 return NULL;
1203 p.pw_name = user_name;
1204 p.pw_gecos = "unknown";
1205 p.pw_dir = NULL;
1206 return &p;
1209 static HANDLE timer_event;
1210 static HANDLE timer_thread;
1211 static int timer_interval;
1212 static int one_shot;
1213 static sig_handler_t timer_fn = SIG_DFL;
1215 /* The timer works like this:
1216 * The thread, ticktack(), is a trivial routine that most of the time
1217 * only waits to receive the signal to terminate. The main thread tells
1218 * the thread to terminate by setting the timer_event to the signalled
1219 * state.
1220 * But ticktack() interrupts the wait state after the timer's interval
1221 * length to call the signal handler.
1224 static unsigned __stdcall ticktack(void *dummy)
1226 while (WaitForSingleObject(timer_event, timer_interval) == WAIT_TIMEOUT) {
1227 if (timer_fn == SIG_DFL)
1228 die("Alarm");
1229 if (timer_fn != SIG_IGN)
1230 timer_fn(SIGALRM);
1231 if (one_shot)
1232 break;
1234 return 0;
1237 static int start_timer_thread(void)
1239 timer_event = CreateEvent(NULL, FALSE, FALSE, NULL);
1240 if (timer_event) {
1241 timer_thread = (HANDLE) _beginthreadex(NULL, 0, ticktack, NULL, 0, NULL);
1242 if (!timer_thread )
1243 return errno = ENOMEM,
1244 error("cannot start timer thread");
1245 } else
1246 return errno = ENOMEM,
1247 error("cannot allocate resources for timer");
1248 return 0;
1251 static void stop_timer_thread(void)
1253 if (timer_event)
1254 SetEvent(timer_event); /* tell thread to terminate */
1255 if (timer_thread) {
1256 int rc = WaitForSingleObject(timer_thread, 1000);
1257 if (rc == WAIT_TIMEOUT)
1258 error("timer thread did not terminate timely");
1259 else if (rc != WAIT_OBJECT_0)
1260 error("waiting for timer thread failed: %lu",
1261 GetLastError());
1262 CloseHandle(timer_thread);
1264 if (timer_event)
1265 CloseHandle(timer_event);
1266 timer_event = NULL;
1267 timer_thread = NULL;
1270 static inline int is_timeval_eq(const struct timeval *i1, const struct timeval *i2)
1272 return i1->tv_sec == i2->tv_sec && i1->tv_usec == i2->tv_usec;
1275 int setitimer(int type, struct itimerval *in, struct itimerval *out)
1277 static const struct timeval zero;
1278 static int atexit_done;
1280 if (out != NULL)
1281 return errno = EINVAL,
1282 error("setitimer param 3 != NULL not implemented");
1283 if (!is_timeval_eq(&in->it_interval, &zero) &&
1284 !is_timeval_eq(&in->it_interval, &in->it_value))
1285 return errno = EINVAL,
1286 error("setitimer: it_interval must be zero or eq it_value");
1288 if (timer_thread)
1289 stop_timer_thread();
1291 if (is_timeval_eq(&in->it_value, &zero) &&
1292 is_timeval_eq(&in->it_interval, &zero))
1293 return 0;
1295 timer_interval = in->it_value.tv_sec * 1000 + in->it_value.tv_usec / 1000;
1296 one_shot = is_timeval_eq(&in->it_interval, &zero);
1297 if (!atexit_done) {
1298 atexit(stop_timer_thread);
1299 atexit_done = 1;
1301 return start_timer_thread();
1304 int sigaction(int sig, struct sigaction *in, struct sigaction *out)
1306 if (sig != SIGALRM)
1307 return errno = EINVAL,
1308 error("sigaction only implemented for SIGALRM");
1309 if (out != NULL)
1310 return errno = EINVAL,
1311 error("sigaction: param 3 != NULL not implemented");
1313 timer_fn = in->sa_handler;
1314 return 0;
1317 #undef signal
1318 sig_handler_t mingw_signal(int sig, sig_handler_t handler)
1320 sig_handler_t old = timer_fn;
1321 if (sig != SIGALRM)
1322 return signal(sig, handler);
1323 timer_fn = handler;
1324 return old;
1327 static const char *make_backslash_path(const char *path)
1329 static char buf[PATH_MAX + 1];
1330 char *c;
1332 if (strlcpy(buf, path, PATH_MAX) >= PATH_MAX)
1333 die("Too long path: %.*s", 60, path);
1335 for (c = buf; *c; c++) {
1336 if (*c == '/')
1337 *c = '\\';
1339 return buf;
1342 void mingw_open_html(const char *unixpath)
1344 const char *htmlpath = make_backslash_path(unixpath);
1345 typedef HINSTANCE (WINAPI *T)(HWND, const char *,
1346 const char *, const char *, const char *, INT);
1347 T ShellExecute;
1348 HMODULE shell32;
1350 shell32 = LoadLibrary("shell32.dll");
1351 if (!shell32)
1352 die("cannot load shell32.dll");
1353 ShellExecute = (T)GetProcAddress(shell32, "ShellExecuteA");
1354 if (!ShellExecute)
1355 die("cannot run browser");
1357 printf("Launching default browser to display HTML ...\n");
1358 ShellExecute(NULL, "open", htmlpath, NULL, "\\", 0);
1360 FreeLibrary(shell32);
1363 int link(const char *oldpath, const char *newpath)
1365 typedef BOOL (WINAPI *T)(const char*, const char*, LPSECURITY_ATTRIBUTES);
1366 static T create_hard_link = NULL;
1367 if (!create_hard_link) {
1368 create_hard_link = (T) GetProcAddress(
1369 GetModuleHandle("kernel32.dll"), "CreateHardLinkA");
1370 if (!create_hard_link)
1371 create_hard_link = (T)-1;
1373 if (create_hard_link == (T)-1) {
1374 errno = ENOSYS;
1375 return -1;
1377 if (!create_hard_link(newpath, oldpath, NULL)) {
1378 errno = err_win_to_posix(GetLastError());
1379 return -1;
1381 return 0;
1384 char *getpass(const char *prompt)
1386 struct strbuf buf = STRBUF_INIT;
1388 fputs(prompt, stderr);
1389 for (;;) {
1390 char c = _getch();
1391 if (c == '\r' || c == '\n')
1392 break;
1393 strbuf_addch(&buf, c);
1395 fputs("\n", stderr);
1396 return strbuf_detach(&buf, NULL);
1399 #ifndef NO_MINGW_REPLACE_READDIR
1400 /* MinGW readdir implementation to avoid extra lstats for Git */
1401 struct mingw_DIR
1403 struct _finddata_t dd_dta; /* disk transfer area for this dir */
1404 struct mingw_dirent dd_dir; /* Our own implementation, including d_type */
1405 long dd_handle; /* _findnext handle */
1406 int dd_stat; /* 0 = next entry to read is first entry, -1 = off the end, positive = 0 based index of next entry */
1407 char dd_name[1]; /* given path for dir with search pattern (struct is extended) */
1410 struct dirent *mingw_readdir(DIR *dir)
1412 WIN32_FIND_DATAA buf;
1413 HANDLE handle;
1414 struct mingw_DIR *mdir = (struct mingw_DIR*)dir;
1416 if (!dir->dd_handle) {
1417 errno = EBADF; /* No set_errno for mingw */
1418 return NULL;
1421 if (dir->dd_handle == (long)INVALID_HANDLE_VALUE && dir->dd_stat == 0)
1423 DWORD lasterr;
1424 handle = FindFirstFileA(dir->dd_name, &buf);
1425 lasterr = GetLastError();
1426 dir->dd_handle = (long)handle;
1427 if (handle == INVALID_HANDLE_VALUE && (lasterr != ERROR_NO_MORE_FILES)) {
1428 errno = err_win_to_posix(lasterr);
1429 return NULL;
1431 } else if (dir->dd_handle == (long)INVALID_HANDLE_VALUE) {
1432 return NULL;
1433 } else if (!FindNextFileA((HANDLE)dir->dd_handle, &buf)) {
1434 DWORD lasterr = GetLastError();
1435 FindClose((HANDLE)dir->dd_handle);
1436 dir->dd_handle = (long)INVALID_HANDLE_VALUE;
1437 /* POSIX says you shouldn't set errno when readdir can't
1438 find any more files; so, if another error we leave it set. */
1439 if (lasterr != ERROR_NO_MORE_FILES)
1440 errno = err_win_to_posix(lasterr);
1441 return NULL;
1444 /* We get here if `buf' contains valid data. */
1445 strcpy(dir->dd_dir.d_name, buf.cFileName);
1446 ++dir->dd_stat;
1448 /* Set file type, based on WIN32_FIND_DATA */
1449 mdir->dd_dir.d_type = 0;
1450 if (buf.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
1451 mdir->dd_dir.d_type |= DT_DIR;
1452 else
1453 mdir->dd_dir.d_type |= DT_REG;
1455 return (struct dirent*)&dir->dd_dir;
1457 #endif // !NO_MINGW_REPLACE_READDIR