1 #include "../git-compat-util.h"
4 unsigned int _CRT_fmode
= _O_BINARY
;
7 int mingw_open (const char *filename
, int oflags
, ...)
11 va_start(args
, oflags
);
12 mode
= va_arg(args
, int);
15 if (!strcmp(filename
, "/dev/null"))
17 int fd
= open(filename
, oflags
, mode
);
18 if (fd
< 0 && (oflags
& O_CREAT
) && errno
== EACCES
) {
19 DWORD attrs
= GetFileAttributes(filename
);
20 if (attrs
!= INVALID_FILE_ATTRIBUTES
&& (attrs
& FILE_ATTRIBUTE_DIRECTORY
))
26 static inline time_t filetime_to_time_t(const FILETIME
*ft
)
28 long long winTime
= ((long long)ft
->dwHighDateTime
<< 32) + ft
->dwLowDateTime
;
29 winTime
-= 116444736000000000LL; /* Windows to Unix Epoch conversion */
30 winTime
/= 10000000; /* Nano to seconds resolution */
31 return (time_t)winTime
;
34 static inline size_t size_to_blocks(size_t s
)
39 extern int _getdrive( void );
40 /* We keep the do_lstat code in a separate function to avoid recursion.
41 * When a path ends with a slash, the stat will fail with ENOENT. In
42 * this case, we strip the trailing slashes and stat again.
44 static int do_lstat(const char *file_name
, struct stat
*buf
)
46 WIN32_FILE_ATTRIBUTE_DATA fdata
;
48 if (GetFileAttributesExA(file_name
, GetFileExInfoStandard
, &fdata
)) {
50 if (fdata
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
54 if (!(fdata
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
))
61 buf
->st_size
= fdata
.nFileSizeLow
; /* Can't use nFileSizeHigh, since it's not a stat64 */
62 buf
->st_blocks
= size_to_blocks(buf
->st_size
);
63 buf
->st_dev
= _getdrive() - 1;
64 buf
->st_atime
= filetime_to_time_t(&(fdata
.ftLastAccessTime
));
65 buf
->st_mtime
= filetime_to_time_t(&(fdata
.ftLastWriteTime
));
66 buf
->st_ctime
= filetime_to_time_t(&(fdata
.ftCreationTime
));
71 switch (GetLastError()) {
72 case ERROR_ACCESS_DENIED
:
73 case ERROR_SHARING_VIOLATION
:
74 case ERROR_LOCK_VIOLATION
:
75 case ERROR_SHARING_BUFFER_EXCEEDED
:
78 case ERROR_BUFFER_OVERFLOW
:
81 case ERROR_NOT_ENOUGH_MEMORY
:
91 /* We provide our own lstat/fstat functions, since the provided
92 * lstat/fstat functions are so slow. These stat functions are
93 * tailored for Git's usage (read: fast), and are not meant to be
94 * complete. Note that Git stat()s are redirected to mingw_lstat()
95 * too, since Windows doesn't really handle symlinks that well.
97 int mingw_lstat(const char *file_name
, struct mingw_stat
*buf
)
100 static char alt_name
[PATH_MAX
];
102 if (!do_lstat(file_name
, buf
))
105 /* if file_name ended in a '/', Windows returned ENOENT;
106 * try again without trailing slashes
111 namelen
= strlen(file_name
);
112 if (namelen
&& file_name
[namelen
-1] != '/')
114 while (namelen
&& file_name
[namelen
-1] == '/')
116 if (!namelen
|| namelen
>= PATH_MAX
)
119 memcpy(alt_name
, file_name
, namelen
);
120 alt_name
[namelen
] = 0;
121 return do_lstat(alt_name
, buf
);
126 int mingw_fstat(int fd
, struct mingw_stat
*buf
)
128 HANDLE fh
= (HANDLE
)_get_osfhandle(fd
);
129 BY_HANDLE_FILE_INFORMATION fdata
;
131 if (fh
== INVALID_HANDLE_VALUE
) {
135 /* direct non-file handles to MS's fstat() */
136 if (GetFileType(fh
) != FILE_TYPE_DISK
) {
140 buf
->st_ino
= st
.st_ino
;
141 buf
->st_gid
= st
.st_gid
;
142 buf
->st_uid
= st
.st_uid
;
143 buf
->st_mode
= st
.st_mode
;
144 buf
->st_size
= st
.st_size
;
145 buf
->st_blocks
= size_to_blocks(buf
->st_size
);
146 buf
->st_dev
= st
.st_dev
;
147 buf
->st_atime
= st
.st_atime
;
148 buf
->st_mtime
= st
.st_mtime
;
149 buf
->st_ctime
= st
.st_ctime
;
153 if (GetFileInformationByHandle(fh
, &fdata
)) {
155 if (fdata
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
159 if (!(fdata
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
))
165 buf
->st_mode
= fMode
;
166 buf
->st_size
= fdata
.nFileSizeLow
; /* Can't use nFileSizeHigh, since it's not a stat64 */
167 buf
->st_blocks
= size_to_blocks(buf
->st_size
);
168 buf
->st_dev
= _getdrive() - 1;
169 buf
->st_atime
= filetime_to_time_t(&(fdata
.ftLastAccessTime
));
170 buf
->st_mtime
= filetime_to_time_t(&(fdata
.ftLastWriteTime
));
171 buf
->st_ctime
= filetime_to_time_t(&(fdata
.ftCreationTime
));
178 unsigned int sleep (unsigned int seconds
)
184 int mkstemp(char *template)
186 char *filename
= mktemp(template);
187 if (filename
== NULL
)
189 return open(filename
, O_RDWR
| O_CREAT
, 0600);
192 int gettimeofday(struct timeval
*tv
, void *tz
)
194 extern time_t my_mktime(struct tm
*tm
);
198 tm
.tm_year
= st
.wYear
-1900;
199 tm
.tm_mon
= st
.wMonth
-1;
200 tm
.tm_mday
= st
.wDay
;
201 tm
.tm_hour
= st
.wHour
;
202 tm
.tm_min
= st
.wMinute
;
203 tm
.tm_sec
= st
.wSecond
;
204 tv
->tv_sec
= my_mktime(&tm
);
207 tv
->tv_usec
= st
.wMilliseconds
*1000;
211 int pipe(int filedes
[2])
216 if (_pipe(filedes
, 8192, 0) < 0)
219 parent
= GetCurrentProcess();
221 if (!DuplicateHandle (parent
, (HANDLE
)_get_osfhandle(filedes
[0]),
222 parent
, &h
[0], 0, FALSE
, DUPLICATE_SAME_ACCESS
)) {
227 if (!DuplicateHandle (parent
, (HANDLE
)_get_osfhandle(filedes
[1]),
228 parent
, &h
[1], 0, FALSE
, DUPLICATE_SAME_ACCESS
)) {
234 fd
= _open_osfhandle((int)h
[0], O_NOINHERIT
);
244 fd
= _open_osfhandle((int)h
[1], O_NOINHERIT
);
256 int poll(struct pollfd
*ufds
, unsigned int nfds
, int timeout
)
261 return errno
= EINVAL
, error("poll timeout not supported");
263 /* When there is only one fd to wait for, then we pretend that
264 * input is available and let the actual wait happen when the
265 * caller invokes read().
268 if (!(ufds
[0].events
& POLLIN
))
269 return errno
= EINVAL
, error("POLLIN not set");
270 ufds
[0].revents
= POLLIN
;
276 for (i
= 0; i
< nfds
; i
++) {
278 HANDLE h
= (HANDLE
) _get_osfhandle(ufds
[i
].fd
);
279 if (h
== INVALID_HANDLE_VALUE
)
280 return -1; /* errno was set */
282 if (!(ufds
[i
].events
& POLLIN
))
283 return errno
= EINVAL
, error("POLLIN not set");
285 /* this emulation works only for pipes */
286 if (!PeekNamedPipe(h
, NULL
, 0, NULL
, &avail
, NULL
)) {
287 int err
= GetLastError();
288 if (err
== ERROR_BROKEN_PIPE
) {
289 ufds
[i
].revents
= POLLHUP
;
293 return error("PeekNamedPipe failed,"
294 " GetLastError: %u", err
);
297 ufds
[i
].revents
= POLLIN
;
303 /* The only times that we spin here is when the process
304 * that is connected through the pipes is waiting for
305 * its own input data to become available. But since
306 * the process (pack-objects) is itself CPU intensive,
307 * it will happily pick up the time slice that we are
308 * relinguishing here.
316 struct tm
*gmtime_r(const time_t *timep
, struct tm
*result
)
318 /* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
319 memcpy(result
, gmtime(timep
), sizeof(struct tm
));
323 struct tm
*localtime_r(const time_t *timep
, struct tm
*result
)
325 /* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
326 memcpy(result
, localtime(timep
), sizeof(struct tm
));
331 char *mingw_getcwd(char *pointer
, int len
)
333 char *ret
= getcwd(pointer
, len
);
336 if (pointer
[0] != 0 && pointer
[1] == ':') {
338 for (i
= 2; pointer
[i
]; i
++)
339 /* Thanks, Bill. You'll burn in hell for that. */
340 if (pointer
[i
] == '\\')
347 * See http://msdn2.microsoft.com/en-us/library/17w5ykft(vs.71).aspx
348 * (Parsing C++ Command-Line Arguments)
350 static const char *quote_arg(const char *arg
)
352 /* count chars to quote */
354 int force_quotes
= 0;
357 if (!*p
) force_quotes
= 1;
359 if (isspace(*p
) || *p
== '*' || *p
== '?')
363 else if (*p
== '\\') {
377 if (!force_quotes
&& n
== 0)
380 /* insert \ where necessary */
381 d
= q
= xmalloc(len
+n
+3);
386 else if (*arg
== '\\') {
388 while (*arg
== '\\') {
405 static const char *parse_interpreter(const char *cmd
)
407 static char buf
[100];
411 /* don't even try a .exe */
413 if (n
>= 4 && !strcasecmp(cmd
+n
-4, ".exe"))
416 fd
= open(cmd
, O_RDONLY
);
419 n
= read(fd
, buf
, sizeof(buf
)-1);
421 if (n
< 4) /* at least '#!/x' and not error */
424 if (buf
[0] != '#' || buf
[1] != '!')
427 p
= strchr(buf
, '\n');
432 if (!(p
= strrchr(buf
+2, '/')) && !(p
= strrchr(buf
+2, '\\')))
435 if ((opt
= strchr(p
+1, ' ')))
441 * Splits the PATH into parts.
443 static char **get_path_split(void)
445 char *p
, **path
, *envpath
= getenv("PATH");
448 if (!envpath
|| !*envpath
)
451 envpath
= xstrdup(envpath
);
457 if (*dir
) { /* not earlier, catches series of ; */
464 path
= xmalloc((n
+1)*sizeof(char*));
469 path
[i
++] = xstrdup(p
);
479 static void free_path_split(char **path
)
491 * exe_only means that we only want to detect .exe files, but not scripts
492 * (which do not have an extension)
494 static char *lookup_prog(const char *dir
, const char *cmd
, int isexe
, int exe_only
)
497 snprintf(path
, sizeof(path
), "%s/%s.exe", dir
, cmd
);
499 if (!isexe
&& access(path
, F_OK
) == 0)
500 return xstrdup(path
);
501 path
[strlen(path
)-4] = '\0';
502 if ((!exe_only
|| isexe
) && access(path
, F_OK
) == 0)
503 return xstrdup(path
);
508 * Determines the absolute path of cmd using the the split path in path.
509 * If cmd contains a slash or backslash, no lookup is performed.
511 static char *path_lookup(const char *cmd
, char **path
, int exe_only
)
514 int len
= strlen(cmd
);
515 int isexe
= len
>= 4 && !strcasecmp(cmd
+len
-4, ".exe");
517 if (strchr(cmd
, '/') || strchr(cmd
, '\\'))
520 while (!prog
&& *path
)
521 prog
= lookup_prog(*path
++, cmd
, isexe
, exe_only
);
526 static int env_compare(const void *a
, const void *b
)
530 return strcasecmp(*ea
, *eb
);
533 static pid_t
mingw_spawnve(const char *cmd
, const char **argv
, char **env
,
537 PROCESS_INFORMATION pi
;
538 struct strbuf envblk
, args
;
542 /* Determine whether or not we are associated to a console */
543 HANDLE cons
= CreateFile("CONOUT$", GENERIC_WRITE
,
544 FILE_SHARE_WRITE
, NULL
, OPEN_EXISTING
,
545 FILE_ATTRIBUTE_NORMAL
, NULL
);
546 if (cons
== INVALID_HANDLE_VALUE
) {
547 /* There is no console associated with this process.
548 * Since the child is a console process, Windows
549 * would normally create a console window. But
550 * since we'll be redirecting std streams, we do
551 * not need the console.
553 flags
= CREATE_NO_WINDOW
;
555 /* There is already a console. If we specified
556 * CREATE_NO_WINDOW here, too, Windows would
557 * disassociate the child from the console.
563 memset(&si
, 0, sizeof(si
));
565 si
.dwFlags
= STARTF_USESTDHANDLES
;
566 si
.hStdInput
= (HANDLE
) _get_osfhandle(0);
567 si
.hStdOutput
= (HANDLE
) _get_osfhandle(1);
568 si
.hStdError
= (HANDLE
) _get_osfhandle(2);
570 /* concatenate argv, quoting args as we go */
571 strbuf_init(&args
, 0);
573 char *quoted
= (char *)quote_arg(cmd
);
574 strbuf_addstr(&args
, quoted
);
578 for (; *argv
; argv
++) {
579 char *quoted
= (char *)quote_arg(*argv
);
581 strbuf_addch(&args
, ' ');
582 strbuf_addstr(&args
, quoted
);
589 char **e
, **sorted_env
;
591 for (e
= env
; *e
; e
++)
594 /* environment must be sorted */
595 sorted_env
= xmalloc(sizeof(*sorted_env
) * (count
+ 1));
596 memcpy(sorted_env
, env
, sizeof(*sorted_env
) * (count
+ 1));
597 qsort(sorted_env
, count
, sizeof(*sorted_env
), env_compare
);
599 strbuf_init(&envblk
, 0);
600 for (e
= sorted_env
; *e
; e
++) {
601 strbuf_addstr(&envblk
, *e
);
602 strbuf_addch(&envblk
, '\0');
607 memset(&pi
, 0, sizeof(pi
));
608 ret
= CreateProcess(cmd
, args
.buf
, NULL
, NULL
, TRUE
, flags
,
609 env
? envblk
.buf
: NULL
, NULL
, &si
, &pi
);
612 strbuf_release(&envblk
);
613 strbuf_release(&args
);
619 CloseHandle(pi
.hThread
);
620 return (pid_t
)pi
.hProcess
;
623 pid_t
mingw_spawnvpe(const char *cmd
, const char **argv
, char **env
)
626 char **path
= get_path_split();
627 char *prog
= path_lookup(cmd
, path
, 0);
634 const char *interpr
= parse_interpreter(prog
);
637 const char *argv0
= argv
[0];
638 char *iprog
= path_lookup(interpr
, path
, 1);
645 pid
= mingw_spawnve(iprog
, argv
, env
, 1);
651 pid
= mingw_spawnve(prog
, argv
, env
, 0);
654 free_path_split(path
);
658 static int try_shell_exec(const char *cmd
, char *const *argv
, char **env
)
660 const char *interpr
= parse_interpreter(cmd
);
667 path
= get_path_split();
668 prog
= path_lookup(interpr
, path
, 1);
672 while (argv
[argc
]) argc
++;
673 argv2
= xmalloc(sizeof(*argv
) * (argc
+1));
674 argv2
[0] = (char *)cmd
; /* full path to the script file */
675 memcpy(&argv2
[1], &argv
[1], sizeof(*argv
) * argc
);
676 pid
= mingw_spawnve(prog
, argv2
, env
, 1);
679 if (waitpid(pid
, &status
, 0) < 0)
683 pid
= 1; /* indicate that we tried but failed */
687 free_path_split(path
);
691 static void mingw_execve(const char *cmd
, char *const *argv
, char *const *env
)
693 /* check if git_command is a shell script */
694 if (!try_shell_exec(cmd
, argv
, (char **)env
)) {
697 pid
= mingw_spawnve(cmd
, (const char **)argv
, (char **)env
, 0);
700 if (waitpid(pid
, &status
, 0) < 0)
706 void mingw_execvp(const char *cmd
, char *const *argv
)
708 char **path
= get_path_split();
709 char *prog
= path_lookup(cmd
, path
, 0);
712 mingw_execve(prog
, argv
, environ
);
717 free_path_split(path
);
720 char **copy_environ()
726 env
= xmalloc((i
+1)*sizeof(*env
));
727 for (i
= 0; environ
[i
]; i
++)
728 env
[i
] = xstrdup(environ
[i
]);
733 void free_environ(char **env
)
736 for (i
= 0; env
[i
]; i
++)
741 static int lookup_env(char **env
, const char *name
, size_t nmln
)
745 for (i
= 0; env
[i
]; i
++) {
746 if (0 == strncmp(env
[i
], name
, nmln
)
747 && '=' == env
[i
][nmln
])
755 * If name contains '=', then sets the variable, otherwise it unsets it
757 char **env_setenv(char **env
, const char *name
)
759 char *eq
= strchrnul(name
, '=');
760 int i
= lookup_env(env
, name
, eq
-name
);
764 for (i
= 0; env
[i
]; i
++)
766 env
= xrealloc(env
, (i
+2)*sizeof(*env
));
767 env
[i
] = xstrdup(name
);
774 env
[i
] = xstrdup(name
);
782 /* this is the first function to call into WS_32; initialize it */
784 struct hostent
*mingw_gethostbyname(const char *host
)
788 if (WSAStartup(MAKEWORD(2,2), &wsa
))
789 die("unable to initialize winsock subsystem, error %d",
791 atexit((void(*)(void)) WSACleanup
);
792 return gethostbyname(host
);
795 int mingw_socket(int domain
, int type
, int protocol
)
798 SOCKET s
= WSASocket(domain
, type
, protocol
, NULL
, 0, 0);
799 if (s
== INVALID_SOCKET
) {
801 * WSAGetLastError() values are regular BSD error codes
802 * biased by WSABASEERR.
803 * However, strerror() does not know about networking
804 * specific errors, which are values beginning at 38 or so.
805 * Therefore, we choose to leave the biased error code
806 * in errno so that _if_ someone looks up the code somewhere,
807 * then it is at least the number that are usually listed.
809 errno
= WSAGetLastError();
812 /* convert into a file descriptor */
813 if ((sockfd
= _open_osfhandle(s
, O_RDWR
|O_BINARY
)) < 0) {
815 return error("unable to make a socket file descriptor: %s",
822 int mingw_connect(int sockfd
, struct sockaddr
*sa
, size_t sz
)
824 SOCKET s
= (SOCKET
)_get_osfhandle(sockfd
);
825 return connect(s
, sa
, sz
);
829 int mingw_rename(const char *pold
, const char *pnew
)
832 * Try native rename() first to get errno right.
833 * It is based on MoveFile(), which cannot overwrite existing files.
835 if (!rename(pold
, pnew
))
839 if (MoveFileEx(pold
, pnew
, MOVEFILE_REPLACE_EXISTING
))
841 /* TODO: translate more errors */
842 if (GetLastError() == ERROR_ACCESS_DENIED
) {
843 DWORD attrs
= GetFileAttributes(pnew
);
844 if (attrs
!= INVALID_FILE_ATTRIBUTES
&& (attrs
& FILE_ATTRIBUTE_DIRECTORY
)) {
854 /* Note that the size parameter specifies the available space, i.e.
855 * includes the trailing NUL byte; but Windows's vsnprintf expects the
856 * number of characters to write without the trailing NUL.
859 /* This is out of line because it uses alloca() behind the scenes,
860 * which must not be called in a loop (alloca() reclaims the allocations
861 * only at function exit).
863 static int try_vsnprintf(size_t size
, const char *fmt
, va_list args
)
865 char buf
[size
]; /* gcc-ism */
866 return vsnprintf(buf
, size
-1, fmt
, args
);
869 int mingw_vsnprintf(char *buf
, size_t size
, const char *fmt
, va_list args
)
873 len
= vsnprintf(buf
, size
-1, fmt
, args
);
877 /* ouch, buffer too small; need to compute the size */
882 len
= try_vsnprintf(size
, fmt
, args
);
887 struct passwd
*getpwuid(int uid
)
889 static char user_name
[100];
890 static struct passwd p
;
892 DWORD len
= sizeof(user_name
);
893 if (!GetUserName(user_name
, &len
))
895 p
.pw_name
= user_name
;
896 p
.pw_gecos
= "unknown";
901 static HANDLE timer_event
;
902 static HANDLE timer_thread
;
903 static int timer_interval
;
905 static sig_handler_t timer_fn
= SIG_DFL
;
907 /* The timer works like this:
908 * The thread, ticktack(), is basically a trivial routine that most of the
909 * time only waits to receive the signal to terminate. The main thread
910 * tells the thread to terminate by setting the timer_event to the signalled
912 * But ticktack() does not wait indefinitely; instead, it interrupts the
913 * wait state every now and then, namely exactly after timer's interval
914 * length. At these opportunities it calls the signal handler.
917 static __stdcall
unsigned ticktack(void *dummy
)
919 while (WaitForSingleObject(timer_event
, timer_interval
) == WAIT_TIMEOUT
) {
920 if (timer_fn
== SIG_DFL
)
922 if (timer_fn
!= SIG_IGN
)
930 static int start_timer_thread(void)
932 timer_event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
934 timer_thread
= (HANDLE
) _beginthreadex(NULL
, 0, ticktack
, NULL
, 0, NULL
);
936 return errno
= ENOMEM
,
937 error("cannot start timer thread");
939 return errno
= ENOMEM
,
940 error("cannot allocate resources timer");
944 static void stop_timer_thread(void)
947 SetEvent(timer_event
); /* tell thread to terminate */
949 int rc
= WaitForSingleObject(timer_thread
, 1000);
950 if (rc
== WAIT_TIMEOUT
)
951 error("timer thread did not terminate timely");
952 else if (rc
!= WAIT_OBJECT_0
)
953 error("waiting for timer thread failed: %lu",
955 CloseHandle(timer_thread
);
958 CloseHandle(timer_event
);
963 static inline int is_timeval_eq(const struct timeval
*i1
, const struct timeval
*i2
)
965 return i1
->tv_sec
== i2
->tv_sec
&& i1
->tv_usec
== i2
->tv_usec
;
968 int setitimer(int type
, struct itimerval
*in
, struct itimerval
*out
)
970 static const struct timeval zero
;
971 static int atexit_done
;
974 return errno
= EINVAL
,
975 error("setitmer param 3 != NULL not implemented");
976 if (!is_timeval_eq(&in
->it_interval
, &zero
) &&
977 !is_timeval_eq(&in
->it_interval
, &in
->it_value
))
978 return errno
= EINVAL
,
979 error("setitmer: it_interval must be zero or eq it_value");
984 if (is_timeval_eq(&in
->it_value
, &zero
) &&
985 is_timeval_eq(&in
->it_interval
, &zero
))
988 timer_interval
= in
->it_value
.tv_sec
* 1000 + in
->it_value
.tv_usec
/ 1000;
989 one_shot
= is_timeval_eq(&in
->it_interval
, &zero
);
991 atexit(stop_timer_thread
);
994 return start_timer_thread();
997 int sigaction(int sig
, struct sigaction
*in
, struct sigaction
*out
)
1000 return errno
= EINVAL
,
1001 error("sigaction only implemented for SIGALRM");
1003 return errno
= EINVAL
,
1004 error("sigaction: param 3 != NULL not implemented");
1006 timer_fn
= in
->sa_handler
;
1011 sig_handler_t
mingw_signal(int sig
, sig_handler_t handler
)
1014 return signal(sig
, handler
);
1015 sig_handler_t old
= timer_fn
;