5 * things that are not available in header files
10 typedef int socklen_t
;
11 #define hstrerror strerror
13 #define S_IFLNK 0120000 /* Symbolic link */
14 #define S_ISLNK(x) (((x) & S_IFMT) == S_IFLNK)
20 #define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
24 #define S_IRWXO (S_IROTH | S_IWOTH | S_IXOTH)
26 #define S_ISUID 0004000
27 #define S_ISGID 0002000
28 #define S_ISVTX 0001000
30 #define WIFEXITED(x) 1
31 #define WIFSIGNALED(x) 0
32 #define WEXITSTATUS(x) ((x) & 0xff)
33 #define WTERMSIG(x) SIGTERM
36 #define EWOULDBLOCK EAGAIN
38 #define SHUT_WR SD_SEND
49 #define FD_CLOEXEC 0x1
52 #define EAFNOSUPPORT WSAEAFNOSUPPORT
55 #define ECONNABORTED WSAECONNABORTED
64 typedef void (__cdecl
*sig_handler_t
)(int);
66 sig_handler_t sa_handler
;
69 #define sigemptyset(x) (void)0
73 struct timeval it_value
, it_interval
;
78 * sanitize preprocessor namespace polluted by Windows headers defining
79 * macros which collide with git local versions
81 #undef HELP_COMMAND /* from winuser.h */
87 static inline int fchmod(int fildes
, mode_t mode
)
88 { errno
= ENOSYS
; return -1; }
89 static inline pid_t
fork(void)
90 { errno
= ENOSYS
; return -1; }
91 static inline unsigned int alarm(unsigned int seconds
)
93 static inline int fsync(int fd
)
94 { return _commit(fd
); }
95 static inline pid_t
getppid(void)
97 static inline void sync(void)
99 static inline uid_t
getuid(void)
101 static inline struct passwd
*getpwnam(const char *name
)
103 static inline int fcntl(int fd
, int cmd
, ...)
105 if (cmd
== F_GETFD
|| cmd
== F_SETFD
)
110 /* bash cannot reliably detect negative return codes as failure */
111 #define exit(code) exit((code) & 0xff)
117 int mingw_mkdir(const char *path
, int mode
);
118 #define mkdir mingw_mkdir
121 pid_t
waitpid(pid_t pid
, int *status
, int options
);
123 #define kill mingw_kill
124 int mingw_kill(pid_t pid
, int sig
);
127 #include <openssl/ssl.h>
128 static inline int mingw_SSL_set_fd(SSL
*ssl
, int fd
)
130 return SSL_set_fd(ssl
, _get_osfhandle(fd
));
132 #define SSL_set_fd mingw_SSL_set_fd
134 static inline int mingw_SSL_set_rfd(SSL
*ssl
, int fd
)
136 return SSL_set_rfd(ssl
, _get_osfhandle(fd
));
138 #define SSL_set_rfd mingw_SSL_set_rfd
140 static inline int mingw_SSL_set_wfd(SSL
*ssl
, int fd
)
142 return SSL_set_wfd(ssl
, _get_osfhandle(fd
));
144 #define SSL_set_wfd mingw_SSL_set_wfd
147 #undef symlink_with_type
148 #define symlink_with_type(a,b,c) mingw_symlink((a),(b),(c))
149 #define symlink(a,b) mingw_symlink((a),(b),GIT_TARGET_UNKNOWN)
152 * implementations of missing functions
155 int pipe(int filedes
[2]);
156 unsigned int sleep (unsigned int seconds
);
157 int mkstemp(char *template);
158 int gettimeofday(struct timeval
*tv
, void *tz
);
159 struct tm
*gmtime_r(const time_t *timep
, struct tm
*result
);
160 struct tm
*localtime_r(const time_t *timep
, struct tm
*result
);
161 int getpagesize(void); /* defined in MinGW's libgcc.a */
162 struct passwd
*getpwuid(uid_t uid
);
163 int setitimer(int type
, struct itimerval
*in
, struct itimerval
*out
);
164 int sigaction(int sig
, struct sigaction
*in
, struct sigaction
*out
);
165 int link(const char *oldpath
, const char *newpath
);
167 int mingw_symlink(const char *oldpath
, const char *newpath
, enum git_target_type targettype
);
168 int readlink(const char *path
, char *buf
, size_t bufsiz
);
171 * replacements of existing functions
174 int mingw_unlink(const char *pathname
);
175 #define unlink mingw_unlink
177 int mingw_rmdir(const char *path
);
178 #define rmdir mingw_rmdir
180 int mingw_open (const char *filename
, int oflags
, ...);
181 #define open mingw_open
183 int mingw_fgetc(FILE *stream
);
184 #define fgetc mingw_fgetc
186 FILE *mingw_fopen (const char *filename
, const char *otype
);
187 #define fopen mingw_fopen
189 FILE *mingw_freopen (const char *filename
, const char *otype
, FILE *stream
);
190 #define freopen mingw_freopen
192 int mingw_fflush(FILE *stream
);
193 #define fflush mingw_fflush
195 int mingw_access(const char *filename
, int mode
);
197 #define access mingw_access
199 int mingw_chdir(const char *dirname
);
200 #define chdir mingw_chdir
202 int mingw_chmod(const char *filename
, int mode
);
203 #define chmod mingw_chmod
205 char *mingw_mktemp(char *template);
206 #define mktemp mingw_mktemp
208 char *mingw_getcwd(char *pointer
, int len
);
209 #define getcwd mingw_getcwd
211 char *mingw_getenv(const char *name
);
212 #define getenv mingw_getenv
213 int mingw_putenv(const char *namevalue
);
214 #define putenv mingw_putenv
215 #define unsetenv mingw_putenv
217 int mingw_gethostname(char *host
, int namelen
);
218 #define gethostname mingw_gethostname
220 struct hostent
*mingw_gethostbyname(const char *host
);
221 #define gethostbyname mingw_gethostbyname
223 void mingw_freeaddrinfo(struct addrinfo
*res
);
224 #define freeaddrinfo mingw_freeaddrinfo
226 int mingw_getaddrinfo(const char *node
, const char *service
,
227 const struct addrinfo
*hints
, struct addrinfo
**res
);
228 #define getaddrinfo mingw_getaddrinfo
230 int mingw_getnameinfo(const struct sockaddr
*sa
, socklen_t salen
,
231 char *host
, DWORD hostlen
, char *serv
, DWORD servlen
,
233 #define getnameinfo mingw_getnameinfo
235 int mingw_socket(int domain
, int type
, int protocol
);
236 #define socket mingw_socket
238 int mingw_connect(int sockfd
, struct sockaddr
*sa
, size_t sz
);
239 #define connect mingw_connect
241 int mingw_bind(int sockfd
, struct sockaddr
*sa
, size_t sz
);
242 #define bind mingw_bind
244 int mingw_setsockopt(int sockfd
, int lvl
, int optname
, void *optval
, int optlen
);
245 #define setsockopt mingw_setsockopt
247 int mingw_shutdown(int sockfd
, int how
);
248 #define shutdown mingw_shutdown
250 int mingw_listen(int sockfd
, int backlog
);
251 #define listen mingw_listen
253 int mingw_accept(int sockfd
, struct sockaddr
*sa
, socklen_t
*sz
);
254 #define accept mingw_accept
256 int mingw_rename(const char*, const char*);
257 #define rename mingw_rename
259 #if defined(USE_WIN32_MMAP) || defined(_MSC_VER)
260 int mingw_getpagesize(void);
261 #define getpagesize mingw_getpagesize
265 unsigned int rlim_cur
;
267 #define RLIMIT_NOFILE 0
269 static inline int getrlimit(int resource
, struct rlimit
*rlp
)
271 if (resource
!= RLIMIT_NOFILE
) {
276 rlp
->rlim_cur
= 2048;
281 * The unit of FILETIME is 100-nanoseconds since January 1, 1601, UTC.
282 * Returns the 100-nanoseconds ("hekto nanoseconds") since the epoch.
284 static inline long long filetime_to_hnsec(const FILETIME
*ft
)
286 long long winTime
= ((long long)ft
->dwHighDateTime
<< 32) + ft
->dwLowDateTime
;
287 /* Windows to Unix Epoch conversion */
288 return winTime
- 116444736000000000LL;
291 static inline time_t filetime_to_time_t(const FILETIME
*ft
)
293 return (time_t)(filetime_to_hnsec(ft
) / 10000000);
297 * Use mingw specific stat()/lstat()/fstat() implementations on Windows.
299 #define off_t off64_t
300 #define lseek _lseeki64
302 /* use struct stat with 64 bit st_size */
306 #define stat _stati64
307 int mingw_lstat(const char *file_name
, struct stat
*buf
);
308 int mingw_stat(const char *file_name
, struct stat
*buf
);
309 int mingw_fstat(int fd
, struct stat
*buf
);
313 #define fstat mingw_fstat
317 extern int (*lstat
)(const char *file_name
, struct stat
*buf
);
320 # define _stati64(x,y) mingw_stat(x,y)
321 #elif defined (_USE_32BIT_TIME_T)
322 # define _stat32i64(x,y) mingw_stat(x,y)
324 # define _stat64(x,y) mingw_stat(x,y)
327 int mingw_utime(const char *file_name
, const struct utimbuf
*times
);
328 #define utime mingw_utime
330 pid_t
mingw_spawnvpe(const char *cmd
, const char **argv
, char **env
,
332 int fhin
, int fhout
, int fherr
);
333 int mingw_execvp(const char *cmd
, char *const *argv
);
334 #define execvp mingw_execvp
335 int mingw_execv(const char *cmd
, char *const *argv
);
336 #define execv mingw_execv
338 static inline unsigned int git_ntohl(unsigned int x
)
339 { return (unsigned int)ntohl(x
); }
340 #define ntohl git_ntohl
342 sig_handler_t
mingw_signal(int sig
, sig_handler_t handler
);
343 #define signal mingw_signal
345 int mingw_raise(int sig
);
346 #define raise mingw_raise
349 * ANSI emulation wrappers
352 void winansi_init(void);
353 HANDLE
winansi_get_osfhandle(int fd
);
356 * git specific compatibility
359 #define has_dos_drive_prefix(path) (isalpha(*(path)) && (path)[1] == ':')
360 #define is_dir_sep(c) ((c) == '/' || (c) == '\\')
361 static inline char *mingw_find_last_dir_sep(const char *path
)
364 for (; *path
; ++path
)
365 if (is_dir_sep(*path
))
369 #define find_last_dir_sep mingw_find_last_dir_sep
370 int mingw_offset_1st_component(const char *path
);
371 #define offset_1st_component mingw_offset_1st_component
373 #define PRIuMAX "I64u"
374 #define PRId64 "I64d"
376 void mingw_open_html(const char *path
);
377 #define open_html mingw_open_html
379 void mingw_mark_as_git_dir(const char *dir
);
380 #define mark_as_git_dir mingw_mark_as_git_dir
382 char *mingw_resolve_symlink(char *p
, size_t s
);
383 #define resolve_symlink mingw_resolve_symlink
386 * Max length of long paths (exceeding MAX_PATH). The actual maximum supported
387 * by NTFS is 32,767 (* sizeof(wchar_t)), but we choose an arbitrary smaller
388 * value to limit required stack memory.
390 #define MAX_LONG_PATH 4096
393 * Handles paths that would exceed the MAX_PATH limit of Windows Unicode APIs.
395 * With expand == false, the function checks for over-long paths and fails
396 * with ENAMETOOLONG. The path parameter is not modified, except if cwd + path
397 * exceeds max_path, but the resulting absolute path doesn't (e.g. due to
398 * eliminating '..' components). The path parameter must point to a buffer
399 * of max_path wide characters.
401 * With expand == true, an over-long path is automatically converted in place
402 * to an absolute path prefixed with '\\?\', and the new length is returned.
403 * The path parameter must point to a buffer of MAX_LONG_PATH wide characters.
406 * path: path to check and / or convert
407 * len: size of path on input (number of wide chars without \0)
408 * max_path: max short path length to check (usually MAX_PATH = 260, but just
409 * 248 for CreateDirectoryW)
410 * expand: false to only check the length, true to expand the path to a
411 * '\\?\'-prefixed absolute path
414 * length of the resulting path, or -1 on failure
417 * ENAMETOOLONG if path is too long
419 int handle_long_path(wchar_t *path
, int len
, int max_path
, int expand
);
422 * Converts UTF-8 encoded string to UTF-16LE.
424 * To support repositories with legacy-encoded file names, invalid UTF-8 bytes
425 * 0xa0 - 0xff are converted to corresponding printable Unicode chars \u00a0 -
426 * \u00ff, and invalid UTF-8 bytes 0x80 - 0x9f (which would make non-printable
427 * Unicode) are converted to hex-code.
429 * Lead-bytes not followed by an appropriate number of trail-bytes, over-long
430 * encodings and 4-byte encodings > \u10ffff are detected as invalid UTF-8.
432 * Maximum space requirement for the target buffer is two wide chars per UTF-8
433 * char (((strlen(utf) * 2) + 1) [* sizeof(wchar_t)]).
435 * The maximum space is needed only if the entire input string consists of
436 * invalid UTF-8 bytes in range 0x80-0x9f, as per the following table:
438 * | | UTF-8 | UTF-16 |
439 * Code point | UTF-8 sequence | bytes | words | ratio
440 * --------------+-------------------+-------+--------+-------
441 * 000000-00007f | 0-7f | 1 | 1 | 1
442 * 000080-0007ff | c2-df + 80-bf | 2 | 1 | 0.5
443 * 000800-00ffff | e0-ef + 2 * 80-bf | 3 | 1 | 0.33
444 * 010000-10ffff | f0-f4 + 3 * 80-bf | 4 | 2 (a) | 0.5
445 * invalid | 80-9f | 1 | 2 (b) | 2
446 * invalid | a0-ff | 1 | 1 | 1
448 * (a) encoded as UTF-16 surrogate pair
449 * (b) encoded as two hex digits
451 * Note that, while the UTF-8 encoding scheme can be extended to 5-byte, 6-byte
452 * or even indefinite-byte sequences, the largest valid code point \u10ffff
453 * encodes as only 4 UTF-8 bytes.
456 * wcs: wide char target buffer
457 * utf: string to convert
458 * wcslen: size of target buffer (in wchar_t's)
459 * utflen: size of string to convert, or -1 if 0-terminated
462 * length of converted string (_wcslen(wcs)), or -1 on failure
465 * EINVAL: one of the input parameters is invalid (e.g. NULL)
466 * ERANGE: the output buffer is too small
468 int xutftowcsn(wchar_t *wcs
, const char *utf
, size_t wcslen
, int utflen
);
471 * Simplified variant of xutftowcsn, assumes input string is \0-terminated.
473 static inline int xutftowcs(wchar_t *wcs
, const char *utf
, size_t wcslen
)
475 return xutftowcsn(wcs
, utf
, wcslen
, -1);
479 * Simplified file system specific wrapper of xutftowcsn and handle_long_path.
480 * Converts ERANGE to ENAMETOOLONG. If expand is true, wcs must be at least
481 * MAX_LONG_PATH wide chars (see handle_long_path).
483 static inline int xutftowcs_path_ex(wchar_t *wcs
, const char *utf
,
484 size_t wcslen
, int utflen
, int max_path
, int expand
)
486 int result
= xutftowcsn(wcs
, utf
, wcslen
, utflen
);
487 if (result
< 0 && errno
== ERANGE
)
488 errno
= ENAMETOOLONG
;
490 result
= handle_long_path(wcs
, result
, max_path
, expand
);
495 * Simplified file system specific variant of xutftowcsn, assumes output
496 * buffer size is MAX_PATH wide chars and input string is \0-terminated,
497 * fails with ENAMETOOLONG if input string is too long. Typically used for
498 * Windows APIs that don't support long paths, e.g. SetCurrentDirectory,
499 * LoadLibrary, CreateProcess...
501 static inline int xutftowcs_path(wchar_t *wcs
, const char *utf
)
503 return xutftowcs_path_ex(wcs
, utf
, MAX_PATH
, -1, MAX_PATH
, 0);
506 /* need to re-declare that here as mingw.h is included before cache.h */
507 extern int core_long_paths
;
510 * Simplified file system specific variant of xutftowcsn for Windows APIs
511 * that support long paths via '\\?\'-prefix, assumes output buffer size is
512 * MAX_LONG_PATH wide chars, fails with ENAMETOOLONG if input string is too
513 * long. The 'core.longpaths' git-config option controls whether the path
514 * is only checked or expanded to a long path.
516 static inline int xutftowcs_long_path(wchar_t *wcs
, const char *utf
)
518 return xutftowcs_path_ex(wcs
, utf
, MAX_LONG_PATH
, -1, MAX_PATH
,
523 * Converts UTF-16LE encoded string to UTF-8.
525 * Maximum space requirement for the target buffer is three UTF-8 chars per
526 * wide char ((_wcslen(wcs) * 3) + 1).
528 * The maximum space is needed only if the entire input string consists of
529 * UTF-16 words in range 0x0800-0xd7ff or 0xe000-0xffff (i.e. \u0800-\uffff
530 * modulo surrogate pairs), as per the following table:
532 * | | UTF-16 | UTF-8 |
533 * Code point | UTF-16 sequence | words | bytes | ratio
534 * --------------+-----------------------+--------+-------+-------
535 * 000000-00007f | 0000-007f | 1 | 1 | 1
536 * 000080-0007ff | 0080-07ff | 1 | 2 | 2
537 * 000800-00ffff | 0800-d7ff / e000-ffff | 1 | 3 | 3
538 * 010000-10ffff | d800-dbff + dc00-dfff | 2 | 4 | 2
540 * Note that invalid code points > 10ffff cannot be represented in UTF-16.
544 * wcs: wide string to convert
545 * utflen: size of target buffer
548 * length of converted string, or -1 on failure
551 * EINVAL: one of the input parameters is invalid (e.g. NULL)
552 * ERANGE: the output buffer is too small
554 int xwcstoutf(char *utf
, const wchar_t *wcs
, size_t utflen
);
557 * A critical section used in the implementation of the spawn
558 * functions (mingw_spawnv[p]e()) and waitpid(). Intialised in
559 * the replacement main() macro below.
561 extern CRITICAL_SECTION pinfo_cs
;
564 * A replacement of main() that adds win32 specific initialization.
567 void mingw_startup();
568 #define main(c,v) dummy_decl_mingw_main(); \
569 static int mingw_main(c,v); \
573 return mingw_main(__argc, __argv); \
575 static int mingw_main(c,v)
578 * Used by Pthread API implementation for Windows
580 extern int err_win_to_posix(DWORD winerr
);
582 extern const char *get_windows_home_directory();
583 #define get_home_directory() get_windows_home_directory()