1 #ifdef __MINGW64_VERSION_MAJOR
4 typedef _sigset_t sigset_t
;
9 /* MinGW-w64 reports to have flockfile, but it does not actually have it. */
10 #ifdef __MINGW64_VERSION_MAJOR
11 #undef _POSIX_THREAD_SAFE_FUNCTIONS
14 int mingw_core_config(const char *var
, const char *value
, void *cb
);
15 #define platform_core_config mingw_core_config
18 * things that are not available in header files
22 typedef int socklen_t
;
23 #ifndef __MINGW64_VERSION_MAJOR
25 #define hstrerror strerror
28 #define S_IFLNK 0120000 /* Symbolic link */
29 #define S_ISLNK(x) (((x) & S_IFMT) == S_IFLNK)
36 #define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
42 #define S_IRWXO (S_IROTH | S_IWOTH | S_IXOTH)
45 #define S_ISUID 0004000
46 #define S_ISGID 0002000
47 #define S_ISVTX 0001000
49 #define WIFEXITED(x) 1
50 #define WIFSIGNALED(x) 0
51 #define WEXITSTATUS(x) ((x) & 0xff)
52 #define WTERMSIG(x) SIGTERM
55 #define EWOULDBLOCK EAGAIN
60 #define SHUT_WR SD_SEND
71 #define FD_CLOEXEC 0x1
73 #if !defined O_CLOEXEC && defined O_NOINHERIT
74 #define O_CLOEXEC O_NOINHERIT
78 #define EAFNOSUPPORT WSAEAFNOSUPPORT
81 #define ECONNABORTED WSAECONNABORTED
84 #define ENOTSOCK WSAENOTSOCK
93 typedef void (__cdecl
*sig_handler_t
)(int);
95 sig_handler_t sa_handler
;
101 struct timeval it_value
, it_interval
;
103 #define ITIMER_REAL 0
114 * sanitize preprocessor namespace polluted by Windows headers defining
115 * macros which collide with git local versions
117 #undef HELP_COMMAND /* from winuser.h */
123 static inline int readlink(const char *path
, char *buf
, size_t bufsiz
)
124 { errno
= ENOSYS
; return -1; }
125 static inline int symlink(const char *oldpath
, const char *newpath
)
126 { errno
= ENOSYS
; return -1; }
127 static inline int fchmod(int fildes
, mode_t mode
)
128 { errno
= ENOSYS
; return -1; }
129 #ifndef __MINGW64_VERSION_MAJOR
130 static inline pid_t
fork(void)
131 { errno
= ENOSYS
; return -1; }
133 static inline unsigned int alarm(unsigned int seconds
)
135 static inline int fsync(int fd
)
136 { return _commit(fd
); }
137 static inline void sync(void)
139 static inline uid_t
getuid(void)
141 static inline struct passwd
*getpwnam(const char *name
)
143 static inline int fcntl(int fd
, int cmd
, ...)
145 if (cmd
== F_GETFD
|| cmd
== F_SETFD
)
151 #define sigemptyset(x) (void)0
152 static inline int sigaddset(sigset_t
*set
, int signum
)
155 #define SIG_UNBLOCK 0
156 static inline int sigprocmask(int how
, const sigset_t
*set
, sigset_t
*oldset
)
158 static inline pid_t
getppid(void)
160 static inline pid_t
getpgid(pid_t pid
)
161 { return pid
== 0 ? getpid() : pid
; }
162 static inline pid_t
tcgetpgrp(int fd
)
169 int mingw_mkdir(const char *path
, int mode
);
170 #define mkdir mingw_mkdir
173 pid_t
waitpid(pid_t pid
, int *status
, int options
);
175 #define kill mingw_kill
176 int mingw_kill(pid_t pid
, int sig
);
178 #define locate_in_PATH mingw_locate_in_PATH
179 char *mingw_locate_in_PATH(const char *cmd
);
182 #include <openssl/ssl.h>
183 static inline int mingw_SSL_set_fd(SSL
*ssl
, int fd
)
185 return SSL_set_fd(ssl
, _get_osfhandle(fd
));
187 #define SSL_set_fd mingw_SSL_set_fd
189 static inline int mingw_SSL_set_rfd(SSL
*ssl
, int fd
)
191 return SSL_set_rfd(ssl
, _get_osfhandle(fd
));
193 #define SSL_set_rfd mingw_SSL_set_rfd
195 static inline int mingw_SSL_set_wfd(SSL
*ssl
, int fd
)
197 return SSL_set_wfd(ssl
, _get_osfhandle(fd
));
199 #define SSL_set_wfd mingw_SSL_set_wfd
203 * implementations of missing functions
206 int pipe(int filedes
[2]);
207 unsigned int sleep (unsigned int seconds
);
208 int mkstemp(char *template);
209 int gettimeofday(struct timeval
*tv
, void *tz
);
210 #ifndef __MINGW64_VERSION_MAJOR
211 struct tm
*gmtime_r(const time_t *timep
, struct tm
*result
);
212 struct tm
*localtime_r(const time_t *timep
, struct tm
*result
);
214 int getpagesize(void); /* defined in MinGW's libgcc.a */
215 struct passwd
*getpwuid(uid_t uid
);
216 int setitimer(int type
, struct itimerval
*in
, struct itimerval
*out
);
217 int sigaction(int sig
, struct sigaction
*in
, struct sigaction
*out
);
218 int link(const char *oldpath
, const char *newpath
);
219 int uname(struct utsname
*buf
);
222 * replacements of existing functions
225 int mingw_unlink(const char *pathname
);
226 #define unlink mingw_unlink
228 int mingw_rmdir(const char *path
);
229 #define rmdir mingw_rmdir
231 int mingw_open (const char *filename
, int oflags
, ...);
232 #define open mingw_open
233 #undef OPEN_RETURNS_EINTR
235 int mingw_fgetc(FILE *stream
);
236 #define fgetc mingw_fgetc
238 FILE *mingw_fopen (const char *filename
, const char *otype
);
239 #define fopen mingw_fopen
241 FILE *mingw_freopen (const char *filename
, const char *otype
, FILE *stream
);
242 #define freopen mingw_freopen
244 int mingw_fflush(FILE *stream
);
245 #define fflush mingw_fflush
247 ssize_t
mingw_write(int fd
, const void *buf
, size_t len
);
248 #define write mingw_write
250 int mingw_access(const char *filename
, int mode
);
252 #define access mingw_access
254 int mingw_chdir(const char *dirname
);
255 #define chdir mingw_chdir
257 int mingw_chmod(const char *filename
, int mode
);
258 #define chmod mingw_chmod
260 char *mingw_mktemp(char *template);
261 #define mktemp mingw_mktemp
263 char *mingw_getcwd(char *pointer
, int len
);
264 #define getcwd mingw_getcwd
267 #error "NO_UNSETENV is incompatible with the Windows-specific startup code!"
271 * We bind *env() routines (even the mingw_ ones) to private mingw_ versions.
272 * These talk to the CRT using UNICODE/wchar_t, but maintain the original
275 * Note that the MSCRT maintains both ANSI (getenv()) and UNICODE (_wgetenv())
276 * routines and stores both versions of each environment variable in parallel
277 * (and secretly updates both when you set one or the other), but it uses CP_ACP
278 * to do the conversion rather than CP_UTF8.
280 * Since everything in the git code base is UTF8, we define the mingw_ routines
281 * to access the CRT using the UNICODE routines and manually convert them to
282 * UTF8. This also avoids round-trip problems.
284 * This also helps with our linkage, since "_wenviron" is publicly exported
285 * from the CRT. But to access "_environ" we would have to statically link
288 * We require NO_SETENV (and let gitsetenv() call our mingw_putenv).
290 #define getenv mingw_getenv
291 #define putenv mingw_putenv
292 #define unsetenv mingw_putenv
293 char *mingw_getenv(const char *name
);
294 int mingw_putenv(const char *name
);
296 int mingw_gethostname(char *host
, int namelen
);
297 #define gethostname mingw_gethostname
299 struct hostent
*mingw_gethostbyname(const char *host
);
300 #define gethostbyname mingw_gethostbyname
302 int mingw_getaddrinfo(const char *node
, const char *service
,
303 const struct addrinfo
*hints
, struct addrinfo
**res
);
304 #define getaddrinfo mingw_getaddrinfo
306 int mingw_socket(int domain
, int type
, int protocol
);
307 #define socket mingw_socket
309 int mingw_connect(int sockfd
, struct sockaddr
*sa
, size_t sz
);
310 #define connect mingw_connect
312 int mingw_bind(int sockfd
, struct sockaddr
*sa
, size_t sz
);
313 #define bind mingw_bind
315 int mingw_setsockopt(int sockfd
, int lvl
, int optname
, void *optval
, int optlen
);
316 #define setsockopt mingw_setsockopt
318 int mingw_shutdown(int sockfd
, int how
);
319 #define shutdown mingw_shutdown
321 int mingw_listen(int sockfd
, int backlog
);
322 #define listen mingw_listen
324 int mingw_accept(int sockfd
, struct sockaddr
*sa
, socklen_t
*sz
);
325 #define accept mingw_accept
327 int mingw_rename(const char*, const char*);
328 #define rename mingw_rename
330 #if defined(USE_WIN32_MMAP) || defined(_MSC_VER)
331 int mingw_getpagesize(void);
332 #define getpagesize mingw_getpagesize
335 int win32_fsync_no_flush(int fd
);
336 #define fsync_no_flush win32_fsync_no_flush
338 #define FSYNC_COMPONENTS_PLATFORM_DEFAULT (FSYNC_COMPONENTS_DEFAULT | FSYNC_COMPONENT_LOOSE_OBJECT)
339 #define FSYNC_METHOD_DEFAULT (FSYNC_METHOD_BATCH)
342 unsigned int rlim_cur
;
344 #define RLIMIT_NOFILE 0
346 static inline int getrlimit(int resource
, struct rlimit
*rlp
)
348 if (resource
!= RLIMIT_NOFILE
) {
353 rlp
->rlim_cur
= 2048;
358 * Use mingw specific stat()/lstat()/fstat() implementations on Windows,
359 * including our own struct stat with 64 bit st_size and nanosecond-precision
362 #ifndef __MINGW64_VERSION_MAJOR
363 #define off_t off64_t
364 #define lseek _lseeki64
382 struct timespec st_atim
;
383 struct timespec st_mtim
;
384 struct timespec st_ctim
;
387 #define st_atime st_atim.tv_sec
388 #define st_mtime st_mtim.tv_sec
389 #define st_ctime st_ctim.tv_sec
394 #define stat mingw_stat
395 int mingw_lstat(const char *file_name
, struct stat
*buf
);
396 int mingw_stat(const char *file_name
, struct stat
*buf
);
397 int mingw_fstat(int fd
, struct stat
*buf
);
401 #define fstat mingw_fstat
405 #define lstat mingw_lstat
408 int mingw_utime(const char *file_name
, const struct utimbuf
*times
);
409 #define utime mingw_utime
410 size_t mingw_strftime(char *s
, size_t max
,
411 const char *format
, const struct tm
*tm
);
412 #define strftime mingw_strftime
414 pid_t
mingw_spawnvpe(const char *cmd
, const char **argv
, char **env
,
416 int fhin
, int fhout
, int fherr
);
417 int mingw_execvp(const char *cmd
, char *const *argv
);
418 #define execvp mingw_execvp
419 int mingw_execv(const char *cmd
, char *const *argv
);
420 #define execv mingw_execv
422 static inline unsigned int git_ntohl(unsigned int x
)
423 { return (unsigned int)ntohl(x
); }
424 #define ntohl git_ntohl
426 sig_handler_t
mingw_signal(int sig
, sig_handler_t handler
);
427 #define signal mingw_signal
429 int mingw_raise(int sig
);
430 #define raise mingw_raise
433 * ANSI emulation wrappers
436 int winansi_isatty(int fd
);
437 #define isatty winansi_isatty
439 int winansi_dup2(int oldfd
, int newfd
);
440 #define dup2 winansi_dup2
442 void winansi_init(void);
443 HANDLE
winansi_get_osfhandle(int fd
);
446 * git specific compatibility
449 static inline void convert_slashes(char *path
)
451 for (; *path
; path
++)
456 char *mingw_query_user_email(void);
457 #define query_user_email mingw_query_user_email
458 #if !defined(__MINGW64_VERSION_MAJOR) && (!defined(_MSC_VER) || _MSC_VER < 1800)
459 #define PRIuMAX "I64u"
460 #define PRId64 "I64d"
462 #include <inttypes.h>
466 * Verifies that the specified path is owned by the user running the
469 int is_path_owned_by_current_sid(const char *path
, struct strbuf
*report
);
470 #define is_path_owned_by_current_user is_path_owned_by_current_sid
473 * Verifies that the given path is a valid one on Windows.
475 * In particular, path segments are disallowed which
477 * - end in a period or a space (except the special directories `.` and `..`).
479 * - contain any of the reserved characters, e.g. `:`, `;`, `*`, etc
481 * - correspond to reserved names (such as `AUX`, `PRN`, etc)
483 * The `allow_literal_nul` parameter controls whether the path `NUL` should
484 * be considered valid (this makes sense e.g. before opening files, as it is
485 * perfectly legitimate to open `NUL` on Windows, just as it is to open
486 * `/dev/null` on Unix/Linux).
488 * Returns 1 upon success, otherwise 0.
490 int is_valid_win32_path(const char *path
, int allow_literal_nul
);
491 #define is_valid_path(path) is_valid_win32_path(path, 0)
494 * Converts UTF-8 encoded string to UTF-16LE.
496 * To support repositories with legacy-encoded file names, invalid UTF-8 bytes
497 * 0xa0 - 0xff are converted to corresponding printable Unicode chars \u00a0 -
498 * \u00ff, and invalid UTF-8 bytes 0x80 - 0x9f (which would make non-printable
499 * Unicode) are converted to hex-code.
501 * Lead-bytes not followed by an appropriate number of trail-bytes, over-long
502 * encodings and 4-byte encodings > \u10ffff are detected as invalid UTF-8.
504 * Maximum space requirement for the target buffer is two wide chars per UTF-8
505 * char (((strlen(utf) * 2) + 1) [* sizeof(wchar_t)]).
507 * The maximum space is needed only if the entire input string consists of
508 * invalid UTF-8 bytes in range 0x80-0x9f, as per the following table:
510 * | | UTF-8 | UTF-16 |
511 * Code point | UTF-8 sequence | bytes | words | ratio
512 * --------------+-------------------+-------+--------+-------
513 * 000000-00007f | 0-7f | 1 | 1 | 1
514 * 000080-0007ff | c2-df + 80-bf | 2 | 1 | 0.5
515 * 000800-00ffff | e0-ef + 2 * 80-bf | 3 | 1 | 0.33
516 * 010000-10ffff | f0-f4 + 3 * 80-bf | 4 | 2 (a) | 0.5
517 * invalid | 80-9f | 1 | 2 (b) | 2
518 * invalid | a0-ff | 1 | 1 | 1
520 * (a) encoded as UTF-16 surrogate pair
521 * (b) encoded as two hex digits
523 * Note that, while the UTF-8 encoding scheme can be extended to 5-byte, 6-byte
524 * or even indefinite-byte sequences, the largest valid code point \u10ffff
525 * encodes as only 4 UTF-8 bytes.
528 * wcs: wide char target buffer
529 * utf: string to convert
530 * wcslen: size of target buffer (in wchar_t's)
531 * utflen: size of string to convert, or -1 if 0-terminated
534 * length of converted string (_wcslen(wcs)), or -1 on failure
537 * EINVAL: one of the input parameters is invalid (e.g. NULL)
538 * ERANGE: the output buffer is too small
540 int xutftowcsn(wchar_t *wcs
, const char *utf
, size_t wcslen
, int utflen
);
543 * Simplified variant of xutftowcsn, assumes input string is \0-terminated.
545 static inline int xutftowcs(wchar_t *wcs
, const char *utf
, size_t wcslen
)
547 return xutftowcsn(wcs
, utf
, wcslen
, -1);
551 * Simplified file system specific variant of xutftowcsn, assumes output
552 * buffer size is MAX_PATH wide chars and input string is \0-terminated,
553 * fails with ENAMETOOLONG if input string is too long.
555 static inline int xutftowcs_path(wchar_t *wcs
, const char *utf
)
557 int result
= xutftowcsn(wcs
, utf
, MAX_PATH
, -1);
558 if (result
< 0 && errno
== ERANGE
)
559 errno
= ENAMETOOLONG
;
564 * Converts UTF-16LE encoded string to UTF-8.
566 * Maximum space requirement for the target buffer is three UTF-8 chars per
567 * wide char ((_wcslen(wcs) * 3) + 1).
569 * The maximum space is needed only if the entire input string consists of
570 * UTF-16 words in range 0x0800-0xd7ff or 0xe000-0xffff (i.e. \u0800-\uffff
571 * modulo surrogate pairs), as per the following table:
573 * | | UTF-16 | UTF-8 |
574 * Code point | UTF-16 sequence | words | bytes | ratio
575 * --------------+-----------------------+--------+-------+-------
576 * 000000-00007f | 0000-007f | 1 | 1 | 1
577 * 000080-0007ff | 0080-07ff | 1 | 2 | 2
578 * 000800-00ffff | 0800-d7ff / e000-ffff | 1 | 3 | 3
579 * 010000-10ffff | d800-dbff + dc00-dfff | 2 | 4 | 2
581 * Note that invalid code points > 10ffff cannot be represented in UTF-16.
585 * wcs: wide string to convert
586 * utflen: size of target buffer
589 * length of converted string, or -1 on failure
592 * EINVAL: one of the input parameters is invalid (e.g. NULL)
593 * ERANGE: the output buffer is too small
595 int xwcstoutf(char *utf
, const wchar_t *wcs
, size_t utflen
);
598 * A critical section used in the implementation of the spawn
599 * functions (mingw_spawnv[p]e()) and waitpid(). Initialised in
600 * the replacement main() macro below.
602 extern CRITICAL_SECTION pinfo_cs
;
605 * Git, like most portable C applications, implements a main() function. On
606 * Windows, this main() function would receive parameters encoded in the
607 * current locale, but Git for Windows would prefer UTF-8 encoded parameters.
609 * To make that happen, we still declare main() here, and then declare and
610 * implement wmain() (which is the Unicode variant of main()) and compile with
611 * -municode. This wmain() function reencodes the parameters from UTF-16 to
612 * UTF-8 format, sets up a couple of other things as required on Windows, and
613 * then hands off to the main() function.
615 int wmain(int argc
, const wchar_t **w_argv
);
616 int main(int argc
, const char **argv
);
619 * For debugging: if a problem occurs, say, in a Git process that is spawned
620 * from another Git process which in turn is spawned from yet another Git
621 * process, it can be quite daunting to figure out what is going on.
623 * Call this function to open a new MinTTY (this assumes you are in Git for
624 * Windows' SDK) with a GDB that attaches to the current process right away.
626 void open_in_gdb(void);
629 * Used by Pthread API implementation for Windows
631 int err_win_to_posix(DWORD winerr
);