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 extern int _getdrive( void );
35 /* We keep the do_lstat code in a separate function to avoid recursion.
36 * When a path ends with a slash, the stat will fail with ENOENT. In
37 * this case, we strip the trailing slashes and stat again.
39 static int do_lstat(const char *file_name
, struct stat
*buf
)
41 WIN32_FILE_ATTRIBUTE_DATA fdata
;
43 if (GetFileAttributesExA(file_name
, GetFileExInfoStandard
, &fdata
)) {
45 if (fdata
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
49 if (!(fdata
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
))
57 buf
->st_size
= fdata
.nFileSizeLow
; /* Can't use nFileSizeHigh, since it's not a stat64 */
58 buf
->st_dev
= buf
->st_rdev
= (_getdrive() - 1);
59 buf
->st_atime
= filetime_to_time_t(&(fdata
.ftLastAccessTime
));
60 buf
->st_mtime
= filetime_to_time_t(&(fdata
.ftLastWriteTime
));
61 buf
->st_ctime
= filetime_to_time_t(&(fdata
.ftCreationTime
));
66 switch (GetLastError()) {
67 case ERROR_ACCESS_DENIED
:
68 case ERROR_SHARING_VIOLATION
:
69 case ERROR_LOCK_VIOLATION
:
70 case ERROR_SHARING_BUFFER_EXCEEDED
:
73 case ERROR_BUFFER_OVERFLOW
:
76 case ERROR_NOT_ENOUGH_MEMORY
:
86 /* We provide our own lstat/fstat functions, since the provided
87 * lstat/fstat functions are so slow. These stat functions are
88 * tailored for Git's usage (read: fast), and are not meant to be
89 * complete. Note that Git stat()s are redirected to mingw_lstat()
90 * too, since Windows doesn't really handle symlinks that well.
92 int mingw_lstat(const char *file_name
, struct stat
*buf
)
95 static char alt_name
[PATH_MAX
];
97 if (!do_lstat(file_name
, buf
))
100 /* if file_name ended in a '/', Windows returned ENOENT;
101 * try again without trailing slashes
106 namelen
= strlen(file_name
);
107 if (namelen
&& file_name
[namelen
-1] != '/')
109 while (namelen
&& file_name
[namelen
-1] == '/')
111 if (!namelen
|| namelen
>= PATH_MAX
)
114 memcpy(alt_name
, file_name
, namelen
);
115 alt_name
[namelen
] = 0;
116 return do_lstat(alt_name
, buf
);
120 int mingw_fstat(int fd
, struct stat
*buf
)
122 HANDLE fh
= (HANDLE
)_get_osfhandle(fd
);
123 BY_HANDLE_FILE_INFORMATION fdata
;
125 if (fh
== INVALID_HANDLE_VALUE
) {
129 /* direct non-file handles to MS's fstat() */
130 if (GetFileType(fh
) != FILE_TYPE_DISK
)
131 return fstat(fd
, buf
);
133 if (GetFileInformationByHandle(fh
, &fdata
)) {
135 if (fdata
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
)
139 if (!(fdata
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
))
146 buf
->st_mode
= fMode
;
147 buf
->st_size
= fdata
.nFileSizeLow
; /* Can't use nFileSizeHigh, since it's not a stat64 */
148 buf
->st_dev
= buf
->st_rdev
= (_getdrive() - 1);
149 buf
->st_atime
= filetime_to_time_t(&(fdata
.ftLastAccessTime
));
150 buf
->st_mtime
= filetime_to_time_t(&(fdata
.ftLastWriteTime
));
151 buf
->st_ctime
= filetime_to_time_t(&(fdata
.ftCreationTime
));
158 unsigned int sleep (unsigned int seconds
)
164 int mkstemp(char *template)
166 char *filename
= mktemp(template);
167 if (filename
== NULL
)
169 return open(filename
, O_RDWR
| O_CREAT
, 0600);
172 int gettimeofday(struct timeval
*tv
, void *tz
)
177 tm
.tm_year
= st
.wYear
-1900;
178 tm
.tm_mon
= st
.wMonth
-1;
179 tm
.tm_mday
= st
.wDay
;
180 tm
.tm_hour
= st
.wHour
;
181 tm
.tm_min
= st
.wMinute
;
182 tm
.tm_sec
= st
.wSecond
;
183 tv
->tv_sec
= tm_to_time_t(&tm
);
186 tv
->tv_usec
= st
.wMilliseconds
*1000;
190 int pipe(int filedes
[2])
195 if (_pipe(filedes
, 8192, 0) < 0)
198 parent
= GetCurrentProcess();
200 if (!DuplicateHandle (parent
, (HANDLE
)_get_osfhandle(filedes
[0]),
201 parent
, &h
[0], 0, FALSE
, DUPLICATE_SAME_ACCESS
)) {
206 if (!DuplicateHandle (parent
, (HANDLE
)_get_osfhandle(filedes
[1]),
207 parent
, &h
[1], 0, FALSE
, DUPLICATE_SAME_ACCESS
)) {
213 fd
= _open_osfhandle((int)h
[0], O_NOINHERIT
);
223 fd
= _open_osfhandle((int)h
[1], O_NOINHERIT
);
235 int poll(struct pollfd
*ufds
, unsigned int nfds
, int timeout
)
240 return errno
= EINVAL
, error("poll timeout not supported");
242 /* When there is only one fd to wait for, then we pretend that
243 * input is available and let the actual wait happen when the
244 * caller invokes read().
247 if (!(ufds
[0].events
& POLLIN
))
248 return errno
= EINVAL
, error("POLLIN not set");
249 ufds
[0].revents
= POLLIN
;
255 for (i
= 0; i
< nfds
; i
++) {
257 HANDLE h
= (HANDLE
) _get_osfhandle(ufds
[i
].fd
);
258 if (h
== INVALID_HANDLE_VALUE
)
259 return -1; /* errno was set */
261 if (!(ufds
[i
].events
& POLLIN
))
262 return errno
= EINVAL
, error("POLLIN not set");
264 /* this emulation works only for pipes */
265 if (!PeekNamedPipe(h
, NULL
, 0, NULL
, &avail
, NULL
)) {
266 int err
= GetLastError();
267 if (err
== ERROR_BROKEN_PIPE
) {
268 ufds
[i
].revents
= POLLHUP
;
272 return error("PeekNamedPipe failed,"
273 " GetLastError: %u", err
);
276 ufds
[i
].revents
= POLLIN
;
282 /* The only times that we spin here is when the process
283 * that is connected through the pipes is waiting for
284 * its own input data to become available. But since
285 * the process (pack-objects) is itself CPU intensive,
286 * it will happily pick up the time slice that we are
287 * relinguishing here.
295 struct tm
*gmtime_r(const time_t *timep
, struct tm
*result
)
297 /* gmtime() in MSVCRT.DLL is thread-safe, but not reentrant */
298 memcpy(result
, gmtime(timep
), sizeof(struct tm
));
302 struct tm
*localtime_r(const time_t *timep
, struct tm
*result
)
304 /* localtime() in MSVCRT.DLL is thread-safe, but not reentrant */
305 memcpy(result
, localtime(timep
), sizeof(struct tm
));
310 char *mingw_getcwd(char *pointer
, int len
)
313 char *ret
= getcwd(pointer
, len
);
316 for (i
= 0; pointer
[i
]; i
++)
317 if (pointer
[i
] == '\\')
323 * See http://msdn2.microsoft.com/en-us/library/17w5ykft(vs.71).aspx
324 * (Parsing C++ Command-Line Arguments)
326 static const char *quote_arg(const char *arg
)
328 /* count chars to quote */
330 int force_quotes
= 0;
333 if (!*p
) force_quotes
= 1;
335 if (isspace(*p
) || *p
== '*' || *p
== '?' || *p
== '{')
339 else if (*p
== '\\') {
353 if (!force_quotes
&& n
== 0)
356 /* insert \ where necessary */
357 d
= q
= xmalloc(len
+n
+3);
362 else if (*arg
== '\\') {
364 while (*arg
== '\\') {
381 static const char *parse_interpreter(const char *cmd
)
383 static char buf
[100];
387 /* don't even try a .exe */
389 if (n
>= 4 && !strcasecmp(cmd
+n
-4, ".exe"))
392 fd
= open(cmd
, O_RDONLY
);
395 n
= read(fd
, buf
, sizeof(buf
)-1);
397 if (n
< 4) /* at least '#!/x' and not error */
400 if (buf
[0] != '#' || buf
[1] != '!')
403 p
= strchr(buf
, '\n');
408 if (!(p
= strrchr(buf
+2, '/')) && !(p
= strrchr(buf
+2, '\\')))
411 if ((opt
= strchr(p
+1, ' ')))
417 * Splits the PATH into parts.
419 static char **get_path_split(void)
421 char *p
, **path
, *envpath
= getenv("PATH");
424 if (!envpath
|| !*envpath
)
427 envpath
= xstrdup(envpath
);
433 if (*dir
) { /* not earlier, catches series of ; */
440 path
= xmalloc((n
+1)*sizeof(char*));
445 path
[i
++] = xstrdup(p
);
455 static void free_path_split(char **path
)
467 * exe_only means that we only want to detect .exe files, but not scripts
468 * (which do not have an extension)
470 static char *lookup_prog(const char *dir
, const char *cmd
, int isexe
, int exe_only
)
473 snprintf(path
, sizeof(path
), "%s/%s.exe", dir
, cmd
);
475 if (!isexe
&& access(path
, F_OK
) == 0)
476 return xstrdup(path
);
477 path
[strlen(path
)-4] = '\0';
478 if ((!exe_only
|| isexe
) && access(path
, F_OK
) == 0)
479 return xstrdup(path
);
484 * Determines the absolute path of cmd using the the split path in path.
485 * If cmd contains a slash or backslash, no lookup is performed.
487 static char *path_lookup(const char *cmd
, char **path
, int exe_only
)
490 int len
= strlen(cmd
);
491 int isexe
= len
>= 4 && !strcasecmp(cmd
+len
-4, ".exe");
493 if (strchr(cmd
, '/') || strchr(cmd
, '\\'))
496 while (!prog
&& *path
)
497 prog
= lookup_prog(*path
++, cmd
, isexe
, exe_only
);
502 static int env_compare(const void *a
, const void *b
)
506 return strcasecmp(*ea
, *eb
);
509 static pid_t
mingw_spawnve(const char *cmd
, const char **argv
, char **env
,
513 PROCESS_INFORMATION pi
;
514 struct strbuf envblk
, args
;
518 /* Determine whether or not we are associated to a console */
519 HANDLE cons
= CreateFile("CONOUT$", GENERIC_WRITE
,
520 FILE_SHARE_WRITE
, NULL
, OPEN_EXISTING
,
521 FILE_ATTRIBUTE_NORMAL
, NULL
);
522 if (cons
== INVALID_HANDLE_VALUE
) {
523 /* There is no console associated with this process.
524 * Since the child is a console process, Windows
525 * would normally create a console window. But
526 * since we'll be redirecting std streams, we do
527 * not need the console.
529 flags
= CREATE_NO_WINDOW
;
531 /* There is already a console. If we specified
532 * CREATE_NO_WINDOW here, too, Windows would
533 * disassociate the child from the console.
539 memset(&si
, 0, sizeof(si
));
541 si
.dwFlags
= STARTF_USESTDHANDLES
;
542 si
.hStdInput
= (HANDLE
) _get_osfhandle(0);
543 si
.hStdOutput
= (HANDLE
) _get_osfhandle(1);
544 si
.hStdError
= (HANDLE
) _get_osfhandle(2);
546 /* concatenate argv, quoting args as we go */
547 strbuf_init(&args
, 0);
549 char *quoted
= (char *)quote_arg(cmd
);
550 strbuf_addstr(&args
, quoted
);
554 for (; *argv
; argv
++) {
555 char *quoted
= (char *)quote_arg(*argv
);
557 strbuf_addch(&args
, ' ');
558 strbuf_addstr(&args
, quoted
);
565 char **e
, **sorted_env
;
567 for (e
= env
; *e
; e
++)
570 /* environment must be sorted */
571 sorted_env
= xmalloc(sizeof(*sorted_env
) * (count
+ 1));
572 memcpy(sorted_env
, env
, sizeof(*sorted_env
) * (count
+ 1));
573 qsort(sorted_env
, count
, sizeof(*sorted_env
), env_compare
);
575 strbuf_init(&envblk
, 0);
576 for (e
= sorted_env
; *e
; e
++) {
577 strbuf_addstr(&envblk
, *e
);
578 strbuf_addch(&envblk
, '\0');
583 memset(&pi
, 0, sizeof(pi
));
584 ret
= CreateProcess(cmd
, args
.buf
, NULL
, NULL
, TRUE
, flags
,
585 env
? envblk
.buf
: NULL
, NULL
, &si
, &pi
);
588 strbuf_release(&envblk
);
589 strbuf_release(&args
);
595 CloseHandle(pi
.hThread
);
596 return (pid_t
)pi
.hProcess
;
599 pid_t
mingw_spawnvpe(const char *cmd
, const char **argv
, char **env
)
602 char **path
= get_path_split();
603 char *prog
= path_lookup(cmd
, path
, 0);
610 const char *interpr
= parse_interpreter(prog
);
613 const char *argv0
= argv
[0];
614 char *iprog
= path_lookup(interpr
, path
, 1);
621 pid
= mingw_spawnve(iprog
, argv
, env
, 1);
627 pid
= mingw_spawnve(prog
, argv
, env
, 0);
630 free_path_split(path
);
634 static int try_shell_exec(const char *cmd
, char *const *argv
, char **env
)
636 const char *interpr
= parse_interpreter(cmd
);
643 path
= get_path_split();
644 prog
= path_lookup(interpr
, path
, 1);
648 while (argv
[argc
]) argc
++;
649 argv2
= xmalloc(sizeof(*argv
) * (argc
+1));
650 argv2
[0] = (char *)cmd
; /* full path to the script file */
651 memcpy(&argv2
[1], &argv
[1], sizeof(*argv
) * argc
);
652 pid
= mingw_spawnve(prog
, argv2
, env
, 1);
655 if (waitpid(pid
, &status
, 0) < 0)
659 pid
= 1; /* indicate that we tried but failed */
663 free_path_split(path
);
667 static void mingw_execve(const char *cmd
, char *const *argv
, char *const *env
)
669 /* check if git_command is a shell script */
670 if (!try_shell_exec(cmd
, argv
, (char **)env
)) {
673 pid
= mingw_spawnve(cmd
, (const char **)argv
, (char **)env
, 0);
676 if (waitpid(pid
, &status
, 0) < 0)
682 void mingw_execvp(const char *cmd
, char *const *argv
)
684 char **path
= get_path_split();
685 char *prog
= path_lookup(cmd
, path
, 0);
688 mingw_execve(prog
, argv
, environ
);
693 free_path_split(path
);
696 char **copy_environ()
702 env
= xmalloc((i
+1)*sizeof(*env
));
703 for (i
= 0; environ
[i
]; i
++)
704 env
[i
] = xstrdup(environ
[i
]);
709 void free_environ(char **env
)
712 for (i
= 0; env
[i
]; i
++)
717 static int lookup_env(char **env
, const char *name
, size_t nmln
)
721 for (i
= 0; env
[i
]; i
++) {
722 if (0 == strncmp(env
[i
], name
, nmln
)
723 && '=' == env
[i
][nmln
])
731 * If name contains '=', then sets the variable, otherwise it unsets it
733 char **env_setenv(char **env
, const char *name
)
735 char *eq
= strchrnul(name
, '=');
736 int i
= lookup_env(env
, name
, eq
-name
);
740 for (i
= 0; env
[i
]; i
++)
742 env
= xrealloc(env
, (i
+2)*sizeof(*env
));
743 env
[i
] = xstrdup(name
);
750 env
[i
] = xstrdup(name
);
758 /* this is the first function to call into WS_32; initialize it */
760 struct hostent
*mingw_gethostbyname(const char *host
)
764 if (WSAStartup(MAKEWORD(2,2), &wsa
))
765 die("unable to initialize winsock subsystem, error %d",
767 atexit((void(*)(void)) WSACleanup
);
768 return gethostbyname(host
);
771 int mingw_socket(int domain
, int type
, int protocol
)
774 SOCKET s
= WSASocket(domain
, type
, protocol
, NULL
, 0, 0);
775 if (s
== INVALID_SOCKET
) {
777 * WSAGetLastError() values are regular BSD error codes
778 * biased by WSABASEERR.
779 * However, strerror() does not know about networking
780 * specific errors, which are values beginning at 38 or so.
781 * Therefore, we choose to leave the biased error code
782 * in errno so that _if_ someone looks up the code somewhere,
783 * then it is at least the number that are usually listed.
785 errno
= WSAGetLastError();
788 /* convert into a file descriptor */
789 if ((sockfd
= _open_osfhandle(s
, O_RDWR
|O_BINARY
)) < 0) {
791 return error("unable to make a socket file descriptor: %s",
798 int mingw_connect(int sockfd
, struct sockaddr
*sa
, size_t sz
)
800 SOCKET s
= (SOCKET
)_get_osfhandle(sockfd
);
801 return connect(s
, sa
, sz
);
805 int mingw_rename(const char *pold
, const char *pnew
)
808 * Try native rename() first to get errno right.
809 * It is based on MoveFile(), which cannot overwrite existing files.
811 if (!rename(pold
, pnew
))
815 if (MoveFileEx(pold
, pnew
, MOVEFILE_REPLACE_EXISTING
))
817 /* TODO: translate more errors */
818 if (GetLastError() == ERROR_ACCESS_DENIED
) {
819 DWORD attrs
= GetFileAttributes(pnew
);
820 if (attrs
!= INVALID_FILE_ATTRIBUTES
&& (attrs
& FILE_ATTRIBUTE_DIRECTORY
)) {
829 struct passwd
*getpwuid(int uid
)
831 static char user_name
[100];
832 static struct passwd p
;
834 DWORD len
= sizeof(user_name
);
835 if (!GetUserName(user_name
, &len
))
837 p
.pw_name
= user_name
;
838 p
.pw_gecos
= "unknown";
843 static HANDLE timer_event
;
844 static HANDLE timer_thread
;
845 static int timer_interval
;
847 static sig_handler_t timer_fn
= SIG_DFL
;
849 /* The timer works like this:
850 * The thread, ticktack(), is a trivial routine that most of the time
851 * only waits to receive the signal to terminate. The main thread tells
852 * the thread to terminate by setting the timer_event to the signalled
854 * But ticktack() interrupts the wait state after the timer's interval
855 * length to call the signal handler.
858 static __stdcall
unsigned ticktack(void *dummy
)
860 while (WaitForSingleObject(timer_event
, timer_interval
) == WAIT_TIMEOUT
) {
861 if (timer_fn
== SIG_DFL
)
863 if (timer_fn
!= SIG_IGN
)
871 static int start_timer_thread(void)
873 timer_event
= CreateEvent(NULL
, FALSE
, FALSE
, NULL
);
875 timer_thread
= (HANDLE
) _beginthreadex(NULL
, 0, ticktack
, NULL
, 0, NULL
);
877 return errno
= ENOMEM
,
878 error("cannot start timer thread");
880 return errno
= ENOMEM
,
881 error("cannot allocate resources for timer");
885 static void stop_timer_thread(void)
888 SetEvent(timer_event
); /* tell thread to terminate */
890 int rc
= WaitForSingleObject(timer_thread
, 1000);
891 if (rc
== WAIT_TIMEOUT
)
892 error("timer thread did not terminate timely");
893 else if (rc
!= WAIT_OBJECT_0
)
894 error("waiting for timer thread failed: %lu",
896 CloseHandle(timer_thread
);
899 CloseHandle(timer_event
);
904 static inline int is_timeval_eq(const struct timeval
*i1
, const struct timeval
*i2
)
906 return i1
->tv_sec
== i2
->tv_sec
&& i1
->tv_usec
== i2
->tv_usec
;
909 int setitimer(int type
, struct itimerval
*in
, struct itimerval
*out
)
911 static const struct timeval zero
;
912 static int atexit_done
;
915 return errno
= EINVAL
,
916 error("setitimer param 3 != NULL not implemented");
917 if (!is_timeval_eq(&in
->it_interval
, &zero
) &&
918 !is_timeval_eq(&in
->it_interval
, &in
->it_value
))
919 return errno
= EINVAL
,
920 error("setitimer: it_interval must be zero or eq it_value");
925 if (is_timeval_eq(&in
->it_value
, &zero
) &&
926 is_timeval_eq(&in
->it_interval
, &zero
))
929 timer_interval
= in
->it_value
.tv_sec
* 1000 + in
->it_value
.tv_usec
/ 1000;
930 one_shot
= is_timeval_eq(&in
->it_interval
, &zero
);
932 atexit(stop_timer_thread
);
935 return start_timer_thread();
938 int sigaction(int sig
, struct sigaction
*in
, struct sigaction
*out
)
941 return errno
= EINVAL
,
942 error("sigaction only implemented for SIGALRM");
944 return errno
= EINVAL
,
945 error("sigaction: param 3 != NULL not implemented");
947 timer_fn
= in
->sa_handler
;
952 sig_handler_t
mingw_signal(int sig
, sig_handler_t handler
)
955 return signal(sig
, handler
);
956 sig_handler_t old
= timer_fn
;