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
)
334 char *ret
= getcwd(pointer
, len
);
337 for (i
= 0; pointer
[i
]; i
++)
338 if (pointer
[i
] == '\\')
344 * See http://msdn2.microsoft.com/en-us/library/17w5ykft(vs.71).aspx
345 * (Parsing C++ Command-Line Arguments)
347 static const char *quote_arg(const char *arg
)
349 /* count chars to quote */
351 int force_quotes
= 0;
354 if (!*p
) force_quotes
= 1;
356 if (isspace(*p
) || *p
== '*' || *p
== '?')
360 else if (*p
== '\\') {
374 if (!force_quotes
&& n
== 0)
377 /* insert \ where necessary */
378 d
= q
= xmalloc(len
+n
+3);
383 else if (*arg
== '\\') {
385 while (*arg
== '\\') {
402 static const char *parse_interpreter(const char *cmd
)
404 static char buf
[100];
408 /* don't even try a .exe */
410 if (n
>= 4 && !strcasecmp(cmd
+n
-4, ".exe"))
413 fd
= open(cmd
, O_RDONLY
);
416 n
= read(fd
, buf
, sizeof(buf
)-1);
418 if (n
< 4) /* at least '#!/x' and not error */
421 if (buf
[0] != '#' || buf
[1] != '!')
424 p
= strchr(buf
, '\n');
429 if (!(p
= strrchr(buf
+2, '/')) && !(p
= strrchr(buf
+2, '\\')))
432 if ((opt
= strchr(p
+1, ' ')))
438 * Splits the PATH into parts.
440 static char **get_path_split(void)
442 char *p
, **path
, *envpath
= getenv("PATH");
445 if (!envpath
|| !*envpath
)
448 envpath
= xstrdup(envpath
);
454 if (*dir
) { /* not earlier, catches series of ; */
461 path
= xmalloc((n
+1)*sizeof(char*));
466 path
[i
++] = xstrdup(p
);
476 static void free_path_split(char **path
)
488 * exe_only means that we only want to detect .exe files, but not scripts
489 * (which do not have an extension)
491 static char *lookup_prog(const char *dir
, const char *cmd
, int isexe
, int exe_only
)
494 snprintf(path
, sizeof(path
), "%s/%s.exe", dir
, cmd
);
496 if (!isexe
&& access(path
, F_OK
) == 0)
497 return xstrdup(path
);
498 path
[strlen(path
)-4] = '\0';
499 if ((!exe_only
|| isexe
) && access(path
, F_OK
) == 0)
500 return xstrdup(path
);
505 * Determines the absolute path of cmd using the the split path in path.
506 * If cmd contains a slash or backslash, no lookup is performed.
508 static char *path_lookup(const char *cmd
, char **path
, int exe_only
)
511 int len
= strlen(cmd
);
512 int isexe
= len
>= 4 && !strcasecmp(cmd
+len
-4, ".exe");
514 if (strchr(cmd
, '/') || strchr(cmd
, '\\'))
517 while (!prog
&& *path
)
518 prog
= lookup_prog(*path
++, cmd
, isexe
, exe_only
);
523 static int env_compare(const void *a
, const void *b
)
527 return strcasecmp(*ea
, *eb
);
530 static pid_t
mingw_spawnve(const char *cmd
, const char **argv
, char **env
,
534 PROCESS_INFORMATION pi
;
535 struct strbuf envblk
, args
;
539 /* Determine whether or not we are associated to a console */
540 HANDLE cons
= CreateFile("CONOUT$", GENERIC_WRITE
,
541 FILE_SHARE_WRITE
, NULL
, OPEN_EXISTING
,
542 FILE_ATTRIBUTE_NORMAL
, NULL
);
543 if (cons
== INVALID_HANDLE_VALUE
) {
544 /* There is no console associated with this process.
545 * Since the child is a console process, Windows
546 * would normally create a console window. But
547 * since we'll be redirecting std streams, we do
548 * not need the console.
550 flags
= CREATE_NO_WINDOW
;
552 /* There is already a console. If we specified
553 * CREATE_NO_WINDOW here, too, Windows would
554 * disassociate the child from the console.
560 memset(&si
, 0, sizeof(si
));
562 si
.dwFlags
= STARTF_USESTDHANDLES
;
563 si
.hStdInput
= (HANDLE
) _get_osfhandle(0);
564 si
.hStdOutput
= (HANDLE
) _get_osfhandle(1);
565 si
.hStdError
= (HANDLE
) _get_osfhandle(2);
567 /* concatenate argv, quoting args as we go */
568 strbuf_init(&args
, 0);
570 char *quoted
= (char *)quote_arg(cmd
);
571 strbuf_addstr(&args
, quoted
);
575 for (; *argv
; argv
++) {
576 char *quoted
= (char *)quote_arg(*argv
);
578 strbuf_addch(&args
, ' ');
579 strbuf_addstr(&args
, quoted
);
586 char **e
, **sorted_env
;
588 for (e
= env
; *e
; e
++)
591 /* environment must be sorted */
592 sorted_env
= xmalloc(sizeof(*sorted_env
) * (count
+ 1));
593 memcpy(sorted_env
, env
, sizeof(*sorted_env
) * (count
+ 1));
594 qsort(sorted_env
, count
, sizeof(*sorted_env
), env_compare
);
596 strbuf_init(&envblk
, 0);
597 for (e
= sorted_env
; *e
; e
++) {
598 strbuf_addstr(&envblk
, *e
);
599 strbuf_addch(&envblk
, '\0');
604 memset(&pi
, 0, sizeof(pi
));
605 ret
= CreateProcess(cmd
, args
.buf
, NULL
, NULL
, TRUE
, flags
,
606 env
? envblk
.buf
: NULL
, NULL
, &si
, &pi
);
609 strbuf_release(&envblk
);
610 strbuf_release(&args
);
616 CloseHandle(pi
.hThread
);
617 return (pid_t
)pi
.hProcess
;
620 pid_t
mingw_spawnvpe(const char *cmd
, const char **argv
, char **env
)
623 char **path
= get_path_split();
624 char *prog
= path_lookup(cmd
, path
, 0);
631 const char *interpr
= parse_interpreter(prog
);
634 const char *argv0
= argv
[0];
635 char *iprog
= path_lookup(interpr
, path
, 1);
642 pid
= mingw_spawnve(iprog
, argv
, env
, 1);
648 pid
= mingw_spawnve(prog
, argv
, env
, 0);
651 free_path_split(path
);
655 static int try_shell_exec(const char *cmd
, char *const *argv
, char **env
)
657 const char *interpr
= parse_interpreter(cmd
);
664 path
= get_path_split();
665 prog
= path_lookup(interpr
, path
, 1);
669 while (argv
[argc
]) argc
++;
670 argv2
= xmalloc(sizeof(*argv
) * (argc
+1));
671 argv2
[0] = (char *)cmd
; /* full path to the script file */
672 memcpy(&argv2
[1], &argv
[1], sizeof(*argv
) * argc
);
673 pid
= mingw_spawnve(prog
, argv2
, env
, 1);
676 if (waitpid(pid
, &status
, 0) < 0)
680 pid
= 1; /* indicate that we tried but failed */
684 free_path_split(path
);
688 static void mingw_execve(const char *cmd
, char *const *argv
, char *const *env
)
690 /* check if git_command is a shell script */
691 if (!try_shell_exec(cmd
, argv
, (char **)env
)) {
694 pid
= mingw_spawnve(cmd
, (const char **)argv
, (char **)env
, 0);
697 if (waitpid(pid
, &status
, 0) < 0)
703 void mingw_execvp(const char *cmd
, char *const *argv
)
705 char **path
= get_path_split();
706 char *prog
= path_lookup(cmd
, path
, 0);
709 mingw_execve(prog
, argv
, environ
);
714 free_path_split(path
);
717 char **copy_environ()
723 env
= xmalloc((i
+1)*sizeof(*env
));
724 for (i
= 0; environ
[i
]; i
++)
725 env
[i
] = xstrdup(environ
[i
]);
730 void free_environ(char **env
)
733 for (i
= 0; env
[i
]; i
++)
738 static int lookup_env(char **env
, const char *name
, size_t nmln
)
742 for (i
= 0; env
[i
]; i
++) {
743 if (0 == strncmp(env
[i
], name
, nmln
)
744 && '=' == env
[i
][nmln
])
752 * If name contains '=', then sets the variable, otherwise it unsets it
754 char **env_setenv(char **env
, const char *name
)
756 char *eq
= strchrnul(name
, '=');
757 int i
= lookup_env(env
, name
, eq
-name
);
761 for (i
= 0; env
[i
]; i
++)
763 env
= xrealloc(env
, (i
+2)*sizeof(*env
));
764 env
[i
] = xstrdup(name
);
771 env
[i
] = xstrdup(name
);
779 /* this is the first function to call into WS_32; initialize it */
781 struct hostent
*mingw_gethostbyname(const char *host
)
785 if (WSAStartup(MAKEWORD(2,2), &wsa
))
786 die("unable to initialize winsock subsystem, error %d",
788 atexit((void(*)(void)) WSACleanup
);
789 return gethostbyname(host
);
792 int mingw_socket(int domain
, int type
, int protocol
)
795 SOCKET s
= WSASocket(domain
, type
, protocol
, NULL
, 0, 0);
796 if (s
== INVALID_SOCKET
) {
798 * WSAGetLastError() values are regular BSD error codes
799 * biased by WSABASEERR.
800 * However, strerror() does not know about networking
801 * specific errors, which are values beginning at 38 or so.
802 * Therefore, we choose to leave the biased error code
803 * in errno so that _if_ someone looks up the code somewhere,
804 * then it is at least the number that are usually listed.
806 errno
= WSAGetLastError();
809 /* convert into a file descriptor */
810 if ((sockfd
= _open_osfhandle(s
, O_RDWR
|O_BINARY
)) < 0) {
812 return error("unable to make a socket file descriptor: %s",
819 int mingw_connect(int sockfd
, struct sockaddr
*sa
, size_t sz
)
821 SOCKET s
= (SOCKET
)_get_osfhandle(sockfd
);
822 return connect(s
, sa
, sz
);
826 int mingw_rename(const char *pold
, const char *pnew
)
829 * Try native rename() first to get errno right.
830 * It is based on MoveFile(), which cannot overwrite existing files.
832 if (!rename(pold
, pnew
))
836 if (MoveFileEx(pold
, pnew
, MOVEFILE_REPLACE_EXISTING
))
838 /* TODO: translate more errors */
839 if (GetLastError() == ERROR_ACCESS_DENIED
) {
840 DWORD attrs
= GetFileAttributes(pnew
);
841 if (attrs
!= INVALID_FILE_ATTRIBUTES
&& (attrs
& FILE_ATTRIBUTE_DIRECTORY
)) {
850 struct passwd
*getpwuid(int uid
)
852 static char user_name
[100];
853 static struct passwd p
;
855 DWORD len
= sizeof(user_name
);
856 if (!GetUserName(user_name
, &len
))
858 p
.pw_name
= user_name
;
859 p
.pw_gecos
= "unknown";
864 static HANDLE timer_event
;
865 static HANDLE timer_thread
;
866 static int timer_interval
;
868 static sig_handler_t timer_fn
= SIG_DFL
;
870 /* The timer works like this:
871 * The thread, ticktack(), is basically a trivial routine that most of the
872 * time only waits to receive the signal to terminate. The main thread
873 * tells the thread to terminate by setting the timer_event to the signalled
875 * But ticktack() does not wait indefinitely; instead, it interrupts the
876 * wait state every now and then, namely exactly after timer's interval
877 * length. At these opportunities it calls the signal handler.
880 static __stdcall
unsigned ticktack(void *dummy
)
882 while (WaitForSingleObject(timer_event
, timer_interval
) == WAIT_TIMEOUT
) {
883 if (timer_fn
== SIG_DFL
)
885 if (timer_fn
!= SIG_IGN
)
893 static int start_timer_thread(void)
895 timer_event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
897 timer_thread
= (HANDLE
) _beginthreadex(NULL
, 0, ticktack
, NULL
, 0, NULL
);
899 return errno
= ENOMEM
,
900 error("cannot start timer thread");
902 return errno
= ENOMEM
,
903 error("cannot allocate resources timer");
907 static void stop_timer_thread(void)
910 SetEvent(timer_event
); /* tell thread to terminate */
912 int rc
= WaitForSingleObject(timer_thread
, 1000);
913 if (rc
== WAIT_TIMEOUT
)
914 error("timer thread did not terminate timely");
915 else if (rc
!= WAIT_OBJECT_0
)
916 error("waiting for timer thread failed: %lu",
918 CloseHandle(timer_thread
);
921 CloseHandle(timer_event
);
926 static inline int is_timeval_eq(const struct timeval
*i1
, const struct timeval
*i2
)
928 return i1
->tv_sec
== i2
->tv_sec
&& i1
->tv_usec
== i2
->tv_usec
;
931 int setitimer(int type
, struct itimerval
*in
, struct itimerval
*out
)
933 static const struct timeval zero
;
934 static int atexit_done
;
937 return errno
= EINVAL
,
938 error("setitmer param 3 != NULL not implemented");
939 if (!is_timeval_eq(&in
->it_interval
, &zero
) &&
940 !is_timeval_eq(&in
->it_interval
, &in
->it_value
))
941 return errno
= EINVAL
,
942 error("setitmer: it_interval must be zero or eq it_value");
947 if (is_timeval_eq(&in
->it_value
, &zero
) &&
948 is_timeval_eq(&in
->it_interval
, &zero
))
951 timer_interval
= in
->it_value
.tv_sec
* 1000 + in
->it_value
.tv_usec
/ 1000;
952 one_shot
= is_timeval_eq(&in
->it_interval
, &zero
);
954 atexit(stop_timer_thread
);
957 return start_timer_thread();
960 int sigaction(int sig
, struct sigaction
*in
, struct sigaction
*out
)
963 return errno
= EINVAL
,
964 error("sigaction only implemented for SIGALRM");
966 return errno
= EINVAL
,
967 error("sigaction: param 3 != NULL not implemented");
969 timer_fn
= in
->sa_handler
;
974 sig_handler_t
mingw_signal(int sig
, sig_handler_t handler
)
977 return signal(sig
, handler
);
978 sig_handler_t old
= timer_fn
;