Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 1 | #ifdef __MINGW64_VERSION_MAJOR |
| 2 | #include <stdint.h> |
| 3 | #include <wchar.h> |
| 4 | typedef _sigset_t sigset_t; |
| 5 | #endif |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 6 | #include <winsock2.h> |
Martin Storsjö | fe3b2b7 | 2009-11-24 00:55:50 +0200 | [diff] [blame] | 7 | #include <ws2tcpip.h> |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 8 | |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 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 |
| 12 | #endif |
| 13 | |
Glen Choo | a4e7e31 | 2023-06-28 19:26:22 +0000 | [diff] [blame] | 14 | struct config_context; |
| 15 | int mingw_core_config(const char *var, const char *value, |
| 16 | const struct config_context *ctx, void *cb); |
Johannes Schindelin | 70fc579 | 2018-10-30 11:40:04 -0700 | [diff] [blame] | 17 | #define platform_core_config mingw_core_config |
| 18 | |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 19 | /* |
| 20 | * things that are not available in header files |
| 21 | */ |
| 22 | |
Sebastian Schuberth | e7cf4e9 | 2009-12-28 18:04:21 +0100 | [diff] [blame] | 23 | typedef int uid_t; |
Mike Pape | 772991a | 2010-11-04 02:35:09 +0100 | [diff] [blame] | 24 | typedef int socklen_t; |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 25 | #ifndef __MINGW64_VERSION_MAJOR |
| 26 | typedef int pid_t; |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 27 | #define hstrerror strerror |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 28 | #endif |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 29 | |
| 30 | #define S_IFLNK 0120000 /* Symbolic link */ |
| 31 | #define S_ISLNK(x) (((x) & S_IFMT) == S_IFLNK) |
| 32 | #define S_ISSOCK(x) 0 |
Sebastian Schuberth | 4091bfc | 2009-12-28 18:13:52 +0100 | [diff] [blame] | 33 | |
Johannes Schindelin | 59de49f | 2016-01-15 14:24:29 +0100 | [diff] [blame] | 34 | #ifndef S_IRWXG |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 35 | #define S_IRGRP 0 |
| 36 | #define S_IWGRP 0 |
| 37 | #define S_IXGRP 0 |
Sebastian Schuberth | 4091bfc | 2009-12-28 18:13:52 +0100 | [diff] [blame] | 38 | #define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP) |
Johannes Schindelin | 59de49f | 2016-01-15 14:24:29 +0100 | [diff] [blame] | 39 | #endif |
| 40 | #ifndef S_IRWXO |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 41 | #define S_IROTH 0 |
Sebastian Schuberth | 4091bfc | 2009-12-28 18:13:52 +0100 | [diff] [blame] | 42 | #define S_IWOTH 0 |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 43 | #define S_IXOTH 0 |
Sebastian Schuberth | 4091bfc | 2009-12-28 18:13:52 +0100 | [diff] [blame] | 44 | #define S_IRWXO (S_IROTH | S_IWOTH | S_IXOTH) |
Johannes Schindelin | 59de49f | 2016-01-15 14:24:29 +0100 | [diff] [blame] | 45 | #endif |
Ramsay Jones | 90110d7 | 2012-04-17 19:00:04 +0100 | [diff] [blame] | 46 | |
| 47 | #define S_ISUID 0004000 |
| 48 | #define S_ISGID 0002000 |
| 49 | #define S_ISVTX 0001000 |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 50 | |
Johannes Sixt | 303e7c4 | 2009-07-04 21:26:38 +0200 | [diff] [blame] | 51 | #define WIFEXITED(x) 1 |
| 52 | #define WIFSIGNALED(x) 0 |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 53 | #define WEXITSTATUS(x) ((x) & 0xff) |
Johannes Sixt | 303e7c4 | 2009-07-04 21:26:38 +0200 | [diff] [blame] | 54 | #define WTERMSIG(x) SIGTERM |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 55 | |
Karsten Blees | 61542f7 | 2013-09-11 01:22:34 +0200 | [diff] [blame] | 56 | #ifndef EWOULDBLOCK |
Ilari Liusvaara | 419f37d | 2010-10-12 19:39:41 +0300 | [diff] [blame] | 57 | #define EWOULDBLOCK EAGAIN |
Karsten Blees | 61542f7 | 2013-09-11 01:22:34 +0200 | [diff] [blame] | 58 | #endif |
Karsten Blees | e0a064a | 2014-07-16 00:53:27 +0200 | [diff] [blame] | 59 | #ifndef ELOOP |
| 60 | #define ELOOP EMLINK |
| 61 | #endif |
Ilari Liusvaara | 419f37d | 2010-10-12 19:39:41 +0300 | [diff] [blame] | 62 | #define SHUT_WR SD_SEND |
| 63 | |
Johannes Sixt | d282506 | 2009-01-22 00:57:34 -0500 | [diff] [blame] | 64 | #define SIGHUP 1 |
| 65 | #define SIGQUIT 3 |
| 66 | #define SIGKILL 9 |
| 67 | #define SIGPIPE 13 |
| 68 | #define SIGALRM 14 |
| 69 | #define SIGCHLD 17 |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 70 | |
| 71 | #define F_GETFD 1 |
| 72 | #define F_SETFD 2 |
| 73 | #define FD_CLOEXEC 0x1 |
| 74 | |
Ben Wijen | 05d1ed6 | 2016-08-22 14:47:55 +0200 | [diff] [blame] | 75 | #if !defined O_CLOEXEC && defined O_NOINHERIT |
| 76 | #define O_CLOEXEC O_NOINHERIT |
| 77 | #endif |
| 78 | |
Karsten Blees | 61542f7 | 2013-09-11 01:22:34 +0200 | [diff] [blame] | 79 | #ifndef EAFNOSUPPORT |
Mike Pape | 772991a | 2010-11-04 02:35:09 +0100 | [diff] [blame] | 80 | #define EAFNOSUPPORT WSAEAFNOSUPPORT |
Karsten Blees | 61542f7 | 2013-09-11 01:22:34 +0200 | [diff] [blame] | 81 | #endif |
| 82 | #ifndef ECONNABORTED |
Mike Pape | 772991a | 2010-11-04 02:35:09 +0100 | [diff] [blame] | 83 | #define ECONNABORTED WSAECONNABORTED |
Karsten Blees | 61542f7 | 2013-09-11 01:22:34 +0200 | [diff] [blame] | 84 | #endif |
Johannes Sixt | fab6027 | 2016-07-21 22:59:06 +0200 | [diff] [blame] | 85 | #ifndef ENOTSOCK |
| 86 | #define ENOTSOCK WSAENOTSOCK |
| 87 | #endif |
Mike Pape | 772991a | 2010-11-04 02:35:09 +0100 | [diff] [blame] | 88 | |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 89 | struct passwd { |
| 90 | char *pw_name; |
| 91 | char *pw_gecos; |
| 92 | char *pw_dir; |
| 93 | }; |
| 94 | |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 95 | typedef void (__cdecl *sig_handler_t)(int); |
| 96 | struct sigaction { |
| 97 | sig_handler_t sa_handler; |
| 98 | unsigned sa_flags; |
| 99 | }; |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 100 | #define SA_RESTART 0 |
| 101 | |
| 102 | struct itimerval { |
| 103 | struct timeval it_value, it_interval; |
| 104 | }; |
| 105 | #define ITIMER_REAL 0 |
| 106 | |
Nguyễn Thái Ngọc Duy | 7b6aff0 | 2015-03-08 17:12:45 +0700 | [diff] [blame] | 107 | struct utsname { |
| 108 | char sysname[16]; |
| 109 | char nodename[1]; |
| 110 | char release[16]; |
| 111 | char version[16]; |
| 112 | char machine[1]; |
| 113 | }; |
| 114 | |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 115 | /* |
Eric Sunshine | 77df1f1 | 2010-09-27 07:01:59 -0400 | [diff] [blame] | 116 | * sanitize preprocessor namespace polluted by Windows headers defining |
| 117 | * macros which collide with git local versions |
| 118 | */ |
| 119 | #undef HELP_COMMAND /* from winuser.h */ |
| 120 | |
| 121 | /* |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 122 | * trivial stubs |
| 123 | */ |
| 124 | |
| 125 | static inline int readlink(const char *path, char *buf, size_t bufsiz) |
| 126 | { errno = ENOSYS; return -1; } |
| 127 | static inline int symlink(const char *oldpath, const char *newpath) |
| 128 | { errno = ENOSYS; return -1; } |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 129 | static inline int fchmod(int fildes, mode_t mode) |
| 130 | { errno = ENOSYS; return -1; } |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 131 | #ifndef __MINGW64_VERSION_MAJOR |
Junio C Hamano | f0c7fd4 | 2011-11-15 15:39:33 -0800 | [diff] [blame] | 132 | static inline pid_t fork(void) |
| 133 | { errno = ENOSYS; return -1; } |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 134 | #endif |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 135 | static inline unsigned int alarm(unsigned int seconds) |
| 136 | { return 0; } |
| 137 | static inline int fsync(int fd) |
Erik Faye-Lund | 75f6929 | 2010-05-20 20:57:54 +0200 | [diff] [blame] | 138 | { return _commit(fd); } |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 139 | static inline void sync(void) |
| 140 | {} |
Sebastian Schuberth | e7cf4e9 | 2009-12-28 18:04:21 +0100 | [diff] [blame] | 141 | static inline uid_t getuid(void) |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 142 | { return 1; } |
| 143 | static inline struct passwd *getpwnam(const char *name) |
| 144 | { return NULL; } |
Johannes Sixt | 5f8763a | 2010-03-06 16:40:40 +0100 | [diff] [blame] | 145 | static inline int fcntl(int fd, int cmd, ...) |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 146 | { |
| 147 | if (cmd == F_GETFD || cmd == F_SETFD) |
| 148 | return 0; |
| 149 | errno = EINVAL; |
| 150 | return -1; |
| 151 | } |
Jeff Hostetler | ee4512e | 2019-02-22 14:25:01 -0800 | [diff] [blame] | 152 | |
Johannes Sixt | 4e6d207 | 2014-09-22 20:24:34 +0200 | [diff] [blame] | 153 | #define sigemptyset(x) (void)0 |
| 154 | static inline int sigaddset(sigset_t *set, int signum) |
| 155 | { return 0; } |
Johannes Sixt | f924b52 | 2016-05-01 21:08:21 +0200 | [diff] [blame] | 156 | #define SIG_BLOCK 0 |
Johannes Sixt | 4e6d207 | 2014-09-22 20:24:34 +0200 | [diff] [blame] | 157 | #define SIG_UNBLOCK 0 |
| 158 | static inline int sigprocmask(int how, const sigset_t *set, sigset_t *oldset) |
| 159 | { return 0; } |
Johannes Sixt | 9a9a41d | 2015-04-15 20:29:30 +0200 | [diff] [blame] | 160 | static inline pid_t getppid(void) |
| 161 | { return 1; } |
| 162 | static inline pid_t getpgid(pid_t pid) |
| 163 | { return pid == 0 ? getpid() : pid; } |
| 164 | static inline pid_t tcgetpgrp(int fd) |
| 165 | { return getpid(); } |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 166 | |
| 167 | /* |
| 168 | * simple adaptors |
| 169 | */ |
| 170 | |
Karsten Blees | 85faec9 | 2012-03-15 18:21:28 +0100 | [diff] [blame] | 171 | int mingw_mkdir(const char *path, int mode); |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 172 | #define mkdir mingw_mkdir |
| 173 | |
Erik Faye-Lund | ef7108c | 2010-11-04 02:35:14 +0100 | [diff] [blame] | 174 | #define WNOHANG 1 |
Erik Faye-Lund | 956d86d | 2011-12-08 20:39:57 +0100 | [diff] [blame] | 175 | pid_t waitpid(pid_t pid, int *status, int options); |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 176 | |
Erik Faye-Lund | 82fc07b | 2010-11-04 02:35:15 +0100 | [diff] [blame] | 177 | #define kill mingw_kill |
| 178 | int mingw_kill(pid_t pid, int sig); |
| 179 | |
Matthias Aßhauer | 2bf46a9 | 2023-08-04 04:08:43 +0000 | [diff] [blame] | 180 | #define locate_in_PATH mingw_locate_in_PATH |
| 181 | char *mingw_locate_in_PATH(const char *cmd); |
| 182 | |
Erik Faye-Lund | 514213b | 2009-10-19 17:42:07 +0200 | [diff] [blame] | 183 | #ifndef NO_OPENSSL |
| 184 | #include <openssl/ssl.h> |
| 185 | static inline int mingw_SSL_set_fd(SSL *ssl, int fd) |
| 186 | { |
| 187 | return SSL_set_fd(ssl, _get_osfhandle(fd)); |
| 188 | } |
| 189 | #define SSL_set_fd mingw_SSL_set_fd |
| 190 | |
| 191 | static inline int mingw_SSL_set_rfd(SSL *ssl, int fd) |
| 192 | { |
| 193 | return SSL_set_rfd(ssl, _get_osfhandle(fd)); |
| 194 | } |
| 195 | #define SSL_set_rfd mingw_SSL_set_rfd |
| 196 | |
| 197 | static inline int mingw_SSL_set_wfd(SSL *ssl, int fd) |
| 198 | { |
| 199 | return SSL_set_wfd(ssl, _get_osfhandle(fd)); |
| 200 | } |
| 201 | #define SSL_set_wfd mingw_SSL_set_wfd |
| 202 | #endif |
| 203 | |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 204 | /* |
| 205 | * implementations of missing functions |
| 206 | */ |
| 207 | |
Johannes Sixt | 897bb8c | 2007-12-07 22:05:36 +0100 | [diff] [blame] | 208 | int pipe(int filedes[2]); |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 209 | unsigned int sleep (unsigned int seconds); |
| 210 | int mkstemp(char *template); |
| 211 | int gettimeofday(struct timeval *tv, void *tz); |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 212 | #ifndef __MINGW64_VERSION_MAJOR |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 213 | struct tm *gmtime_r(const time_t *timep, struct tm *result); |
| 214 | struct tm *localtime_r(const time_t *timep, struct tm *result); |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 215 | #endif |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 216 | int getpagesize(void); /* defined in MinGW's libgcc.a */ |
Sebastian Schuberth | e7cf4e9 | 2009-12-28 18:04:21 +0100 | [diff] [blame] | 217 | struct passwd *getpwuid(uid_t uid); |
Johannes Sixt | f4626df | 2007-12-01 21:24:59 +0100 | [diff] [blame] | 218 | int setitimer(int type, struct itimerval *in, struct itimerval *out); |
| 219 | int sigaction(int sig, struct sigaction *in, struct sigaction *out); |
Petr Kodl | 7be401e | 2009-01-24 15:04:39 +0100 | [diff] [blame] | 220 | int link(const char *oldpath, const char *newpath); |
Nguyễn Thái Ngọc Duy | 7b6aff0 | 2015-03-08 17:12:45 +0700 | [diff] [blame] | 221 | int uname(struct utsname *buf); |
Johannes Sixt | 80ba074 | 2007-12-03 21:55:57 +0100 | [diff] [blame] | 222 | |
| 223 | /* |
Johannes Sixt | 25fe217 | 2008-03-05 21:51:27 +0100 | [diff] [blame] | 224 | * replacements of existing functions |
| 225 | */ |
| 226 | |
Heiko Voigt | 337967f | 2011-02-07 21:49:33 +0100 | [diff] [blame] | 227 | int mingw_unlink(const char *pathname); |
| 228 | #define unlink mingw_unlink |
| 229 | |
Heiko Voigt | 4f28810 | 2011-02-07 21:52:34 +0100 | [diff] [blame] | 230 | int mingw_rmdir(const char *path); |
| 231 | #define rmdir mingw_rmdir |
| 232 | |
Johannes Sixt | 3e4a1ba | 2007-11-15 22:22:47 +0100 | [diff] [blame] | 233 | int mingw_open (const char *filename, int oflags, ...); |
| 234 | #define open mingw_open |
Jeff King | 2b08101 | 2021-02-26 01:14:35 -0500 | [diff] [blame] | 235 | #undef OPEN_RETURNS_EINTR |
Johannes Sixt | 3e4a1ba | 2007-11-15 22:22:47 +0100 | [diff] [blame] | 236 | |
Erik Faye-Lund | 176478a | 2012-12-04 09:10:38 +0100 | [diff] [blame] | 237 | int mingw_fgetc(FILE *stream); |
| 238 | #define fgetc mingw_fgetc |
| 239 | |
Johannes Sixt | 3fdcdbd | 2010-02-25 21:03:44 +0100 | [diff] [blame] | 240 | FILE *mingw_fopen (const char *filename, const char *otype); |
| 241 | #define fopen mingw_fopen |
| 242 | |
| 243 | FILE *mingw_freopen (const char *filename, const char *otype, FILE *stream); |
| 244 | #define freopen mingw_freopen |
| 245 | |
Johannes Sixt | 84adb64 | 2012-10-17 09:05:51 +0200 | [diff] [blame] | 246 | int mingw_fflush(FILE *stream); |
| 247 | #define fflush mingw_fflush |
| 248 | |
Johannes Schindelin | 2b86292 | 2015-12-17 18:08:15 +0100 | [diff] [blame] | 249 | ssize_t mingw_write(int fd, const void *buf, size_t len); |
| 250 | #define write mingw_write |
| 251 | |
Karsten Blees | 85faec9 | 2012-03-15 18:21:28 +0100 | [diff] [blame] | 252 | int mingw_access(const char *filename, int mode); |
| 253 | #undef access |
| 254 | #define access mingw_access |
| 255 | |
| 256 | int mingw_chdir(const char *dirname); |
| 257 | #define chdir mingw_chdir |
| 258 | |
| 259 | int mingw_chmod(const char *filename, int mode); |
| 260 | #define chmod mingw_chmod |
| 261 | |
| 262 | char *mingw_mktemp(char *template); |
| 263 | #define mktemp mingw_mktemp |
| 264 | |
Johannes Sixt | 25fe217 | 2008-03-05 21:51:27 +0100 | [diff] [blame] | 265 | char *mingw_getcwd(char *pointer, int len); |
| 266 | #define getcwd mingw_getcwd |
| 267 | |
Johannes Schindelin | fe21c6b | 2018-10-30 02:22:30 -0700 | [diff] [blame] | 268 | #ifdef NO_UNSETENV |
| 269 | #error "NO_UNSETENV is incompatible with the Windows-specific startup code!" |
| 270 | #endif |
| 271 | |
| 272 | /* |
| 273 | * We bind *env() routines (even the mingw_ ones) to private mingw_ versions. |
| 274 | * These talk to the CRT using UNICODE/wchar_t, but maintain the original |
| 275 | * narrow-char API. |
| 276 | * |
| 277 | * Note that the MSCRT maintains both ANSI (getenv()) and UNICODE (_wgetenv()) |
| 278 | * routines and stores both versions of each environment variable in parallel |
| 279 | * (and secretly updates both when you set one or the other), but it uses CP_ACP |
| 280 | * to do the conversion rather than CP_UTF8. |
| 281 | * |
| 282 | * Since everything in the git code base is UTF8, we define the mingw_ routines |
| 283 | * to access the CRT using the UNICODE routines and manually convert them to |
| 284 | * UTF8. This also avoids round-trip problems. |
| 285 | * |
| 286 | * This also helps with our linkage, since "_wenviron" is publicly exported |
| 287 | * from the CRT. But to access "_environ" we would have to statically link |
| 288 | * to the CRT (/MT). |
| 289 | * |
| 290 | * We require NO_SETENV (and let gitsetenv() call our mingw_putenv). |
| 291 | */ |
| 292 | #define getenv mingw_getenv |
| 293 | #define putenv mingw_putenv |
| 294 | #define unsetenv mingw_putenv |
Johannes Sixt | 6fd6aec | 2008-06-22 11:35:21 +0200 | [diff] [blame] | 295 | char *mingw_getenv(const char *name); |
Johannes Schindelin | fe21c6b | 2018-10-30 02:22:30 -0700 | [diff] [blame] | 296 | int mingw_putenv(const char *name); |
Johannes Sixt | 6fd6aec | 2008-06-22 11:35:21 +0200 | [diff] [blame] | 297 | |
Pat Thoyts | 13d24b0 | 2011-10-15 15:05:20 +0100 | [diff] [blame] | 298 | int mingw_gethostname(char *host, int namelen); |
| 299 | #define gethostname mingw_gethostname |
| 300 | |
Johannes Sixt | 746fb85 | 2007-12-26 13:51:18 +0100 | [diff] [blame] | 301 | struct hostent *mingw_gethostbyname(const char *host); |
| 302 | #define gethostbyname mingw_gethostbyname |
| 303 | |
Martin Storsjö | fe3b2b7 | 2009-11-24 00:55:50 +0200 | [diff] [blame] | 304 | int mingw_getaddrinfo(const char *node, const char *service, |
| 305 | const struct addrinfo *hints, struct addrinfo **res); |
| 306 | #define getaddrinfo mingw_getaddrinfo |
| 307 | |
Johannes Sixt | 746fb85 | 2007-12-26 13:51:18 +0100 | [diff] [blame] | 308 | int mingw_socket(int domain, int type, int protocol); |
| 309 | #define socket mingw_socket |
| 310 | |
| 311 | int mingw_connect(int sockfd, struct sockaddr *sa, size_t sz); |
| 312 | #define connect mingw_connect |
| 313 | |
Mike Pape | 772991a | 2010-11-04 02:35:09 +0100 | [diff] [blame] | 314 | int mingw_bind(int sockfd, struct sockaddr *sa, size_t sz); |
| 315 | #define bind mingw_bind |
| 316 | |
| 317 | int mingw_setsockopt(int sockfd, int lvl, int optname, void *optval, int optlen); |
| 318 | #define setsockopt mingw_setsockopt |
| 319 | |
Johannes Sixt | a794179 | 2011-05-18 22:24:37 +0200 | [diff] [blame] | 320 | int mingw_shutdown(int sockfd, int how); |
| 321 | #define shutdown mingw_shutdown |
| 322 | |
Mike Pape | 772991a | 2010-11-04 02:35:09 +0100 | [diff] [blame] | 323 | int mingw_listen(int sockfd, int backlog); |
| 324 | #define listen mingw_listen |
| 325 | |
| 326 | int mingw_accept(int sockfd, struct sockaddr *sa, socklen_t *sz); |
| 327 | #define accept mingw_accept |
| 328 | |
Johannes Sixt | ea9e98c | 2007-12-07 22:19:40 +0100 | [diff] [blame] | 329 | int mingw_rename(const char*, const char*); |
| 330 | #define rename mingw_rename |
| 331 | |
Ramsay Jones | b1b9520 | 2009-11-07 20:10:31 +0000 | [diff] [blame] | 332 | #if defined(USE_WIN32_MMAP) || defined(_MSC_VER) |
Janos Laube | b130a72 | 2009-03-13 16:50:45 +0100 | [diff] [blame] | 333 | int mingw_getpagesize(void); |
| 334 | #define getpagesize mingw_getpagesize |
| 335 | #endif |
| 336 | |
Neeraj Singh | abf38ab | 2022-03-10 22:43:20 +0000 | [diff] [blame] | 337 | int win32_fsync_no_flush(int fd); |
| 338 | #define fsync_no_flush win32_fsync_no_flush |
| 339 | |
Neeraj Singh | 8a94d83 | 2022-04-04 22:20:14 -0700 | [diff] [blame] | 340 | #define FSYNC_COMPONENTS_PLATFORM_DEFAULT (FSYNC_COMPONENTS_DEFAULT | FSYNC_COMPONENT_LOOSE_OBJECT) |
| 341 | #define FSYNC_METHOD_DEFAULT (FSYNC_METHOD_BATCH) |
| 342 | |
Erik Faye-Lund | 38abd9b | 2011-02-28 22:13:22 +0100 | [diff] [blame] | 343 | struct rlimit { |
| 344 | unsigned int rlim_cur; |
| 345 | }; |
| 346 | #define RLIMIT_NOFILE 0 |
| 347 | |
| 348 | static inline int getrlimit(int resource, struct rlimit *rlp) |
| 349 | { |
| 350 | if (resource != RLIMIT_NOFILE) { |
| 351 | errno = EINVAL; |
| 352 | return -1; |
| 353 | } |
| 354 | |
| 355 | rlp->rlim_cur = 2048; |
| 356 | return 0; |
| 357 | } |
| 358 | |
Karsten Blees | a2374f5 | 2013-09-11 01:23:13 +0200 | [diff] [blame] | 359 | /* |
Karsten Blees | d7e8c87 | 2018-10-23 03:23:22 -0700 | [diff] [blame] | 360 | * Use mingw specific stat()/lstat()/fstat() implementations on Windows, |
| 361 | * including our own struct stat with 64 bit st_size and nanosecond-precision |
| 362 | * file times. |
Marius Storm-Olsen | 5411bdc | 2007-09-03 20:40:26 +0200 | [diff] [blame] | 363 | */ |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 364 | #ifndef __MINGW64_VERSION_MAJOR |
Johannes Schindelin | 1d4e4cd | 2009-03-05 17:05:12 +0100 | [diff] [blame] | 365 | #define off_t off64_t |
Johannes Schindelin | 1d4e4cd | 2009-03-05 17:05:12 +0100 | [diff] [blame] | 366 | #define lseek _lseeki64 |
Jeff Hostetler | 172e54e | 2019-06-19 14:06:03 -0700 | [diff] [blame] | 367 | #ifndef _MSC_VER |
Karsten Blees | d7e8c87 | 2018-10-23 03:23:22 -0700 | [diff] [blame] | 368 | struct timespec { |
| 369 | time_t tv_sec; |
| 370 | long tv_nsec; |
| 371 | }; |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 372 | #endif |
Jeff Hostetler | 172e54e | 2019-06-19 14:06:03 -0700 | [diff] [blame] | 373 | #endif |
Karsten Blees | a2374f5 | 2013-09-11 01:23:13 +0200 | [diff] [blame] | 374 | |
Karsten Blees | d7e8c87 | 2018-10-23 03:23:22 -0700 | [diff] [blame] | 375 | struct mingw_stat { |
| 376 | _dev_t st_dev; |
| 377 | _ino_t st_ino; |
| 378 | _mode_t st_mode; |
| 379 | short st_nlink; |
| 380 | short st_uid; |
| 381 | short st_gid; |
| 382 | _dev_t st_rdev; |
| 383 | off64_t st_size; |
| 384 | struct timespec st_atim; |
| 385 | struct timespec st_mtim; |
| 386 | struct timespec st_ctim; |
| 387 | }; |
| 388 | |
| 389 | #define st_atime st_atim.tv_sec |
| 390 | #define st_mtime st_mtim.tv_sec |
| 391 | #define st_ctime st_ctim.tv_sec |
| 392 | |
Sebastian Schuberth | fa93bb2 | 2013-09-11 18:02:09 +0200 | [diff] [blame] | 393 | #ifdef stat |
| 394 | #undef stat |
| 395 | #endif |
Karsten Blees | d7e8c87 | 2018-10-23 03:23:22 -0700 | [diff] [blame] | 396 | #define stat mingw_stat |
Johannes Sixt | 180964f | 2008-08-18 22:01:06 +0200 | [diff] [blame] | 397 | int mingw_lstat(const char *file_name, struct stat *buf); |
Pat Thoyts | 9b9784c | 2010-03-17 15:17:34 +0000 | [diff] [blame] | 398 | int mingw_stat(const char *file_name, struct stat *buf); |
Johannes Sixt | 180964f | 2008-08-18 22:01:06 +0200 | [diff] [blame] | 399 | int mingw_fstat(int fd, struct stat *buf); |
Sebastian Schuberth | fa93bb2 | 2013-09-11 18:02:09 +0200 | [diff] [blame] | 400 | #ifdef fstat |
| 401 | #undef fstat |
| 402 | #endif |
Marius Storm-Olsen | 5411bdc | 2007-09-03 20:40:26 +0200 | [diff] [blame] | 403 | #define fstat mingw_fstat |
Sebastian Schuberth | fa93bb2 | 2013-09-11 18:02:09 +0200 | [diff] [blame] | 404 | #ifdef lstat |
| 405 | #undef lstat |
| 406 | #endif |
Marius Storm-Olsen | 5411bdc | 2007-09-03 20:40:26 +0200 | [diff] [blame] | 407 | #define lstat mingw_lstat |
Karsten Blees | a2374f5 | 2013-09-11 01:23:13 +0200 | [diff] [blame] | 408 | |
Marius Storm-Olsen | 5411bdc | 2007-09-03 20:40:26 +0200 | [diff] [blame] | 409 | |
Johannes Sixt | 7c0ffa1 | 2007-09-07 13:05:00 +0200 | [diff] [blame] | 410 | int mingw_utime(const char *file_name, const struct utimbuf *times); |
| 411 | #define utime mingw_utime |
Johannes Schindelin | 9ee0540 | 2018-03-19 17:49:22 +0100 | [diff] [blame] | 412 | size_t mingw_strftime(char *s, size_t max, |
| 413 | const char *format, const struct tm *tm); |
| 414 | #define strftime mingw_strftime |
Johannes Sixt | 7c0ffa1 | 2007-09-07 13:05:00 +0200 | [diff] [blame] | 415 | |
Johannes Sixt | 75301f9 | 2010-01-15 21:12:18 +0100 | [diff] [blame] | 416 | pid_t mingw_spawnvpe(const char *cmd, const char **argv, char **env, |
Johannes Sixt | f9a2743 | 2010-04-11 22:40:12 +0200 | [diff] [blame] | 417 | const char *dir, |
Johannes Sixt | 75301f9 | 2010-01-15 21:12:18 +0100 | [diff] [blame] | 418 | int fhin, int fhout, int fherr); |
Ramsay Jones | 1696d72 | 2012-04-05 18:48:46 +0100 | [diff] [blame] | 419 | int mingw_execvp(const char *cmd, char *const *argv); |
Johannes Sixt | f1a4dfb | 2007-12-04 12:38:32 +0100 | [diff] [blame] | 420 | #define execvp mingw_execvp |
Ramsay Jones | 1696d72 | 2012-04-05 18:48:46 +0100 | [diff] [blame] | 421 | int mingw_execv(const char *cmd, char *const *argv); |
Eric Sunshine | 5debf9a | 2010-09-27 07:02:17 -0400 | [diff] [blame] | 422 | #define execv mingw_execv |
Johannes Sixt | f1a4dfb | 2007-12-04 12:38:32 +0100 | [diff] [blame] | 423 | |
Steffen Prohaska | cd800ee | 2007-11-17 19:16:53 +0100 | [diff] [blame] | 424 | static inline unsigned int git_ntohl(unsigned int x) |
| 425 | { return (unsigned int)ntohl(x); } |
| 426 | #define ntohl git_ntohl |
| 427 | |
Johannes Sixt | 6072fc3 | 2007-11-13 10:14:45 +0100 | [diff] [blame] | 428 | sig_handler_t mingw_signal(int sig, sig_handler_t handler); |
| 429 | #define signal mingw_signal |
| 430 | |
Erik Faye-Lund | 176478a | 2012-12-04 09:10:38 +0100 | [diff] [blame] | 431 | int mingw_raise(int sig); |
| 432 | #define raise mingw_raise |
| 433 | |
Johannes Sixt | 25fe217 | 2008-03-05 21:51:27 +0100 | [diff] [blame] | 434 | /* |
Peter Harris | c09df8a | 2008-07-18 09:34:44 +0200 | [diff] [blame] | 435 | * ANSI emulation wrappers |
| 436 | */ |
| 437 | |
Johannes Schindelin | cbb3f3c | 2016-12-11 12:16:57 +0100 | [diff] [blame] | 438 | int winansi_isatty(int fd); |
| 439 | #define isatty winansi_isatty |
| 440 | |
Johannes Schindelin | ff8978d | 2018-10-30 11:44:40 -0700 | [diff] [blame] | 441 | int winansi_dup2(int oldfd, int newfd); |
| 442 | #define dup2 winansi_dup2 |
| 443 | |
Karsten Blees | eac14f8 | 2012-01-14 22:24:19 +0100 | [diff] [blame] | 444 | void winansi_init(void); |
Karsten Blees | eac14f8 | 2012-01-14 22:24:19 +0100 | [diff] [blame] | 445 | HANDLE winansi_get_osfhandle(int fd); |
Peter Harris | c09df8a | 2008-07-18 09:34:44 +0200 | [diff] [blame] | 446 | |
| 447 | /* |
Johannes Sixt | 80ba074 | 2007-12-03 21:55:57 +0100 | [diff] [blame] | 448 | * git specific compatibility |
| 449 | */ |
| 450 | |
Johannes Schindelin | 5ca6b7b | 2016-03-23 11:55:00 +0100 | [diff] [blame] | 451 | static inline void convert_slashes(char *path) |
| 452 | { |
| 453 | for (; *path; path++) |
| 454 | if (*path == '\\') |
| 455 | *path = '/'; |
| 456 | } |
Johannes Sixt | 80ba074 | 2007-12-03 21:55:57 +0100 | [diff] [blame] | 457 | #define PATH_SEP ';' |
Denton Liu | 7027f50 | 2019-09-04 04:09:48 -0700 | [diff] [blame] | 458 | char *mingw_query_user_email(void); |
Johannes Schindelin | 501afcb | 2018-10-15 02:47:08 -0700 | [diff] [blame] | 459 | #define query_user_email mingw_query_user_email |
Sven Strickroth | 0ef60af | 2016-03-30 13:37:36 +0200 | [diff] [blame] | 460 | #if !defined(__MINGW64_VERSION_MAJOR) && (!defined(_MSC_VER) || _MSC_VER < 1800) |
Johannes Sixt | 82f8d96 | 2007-03-23 10:57:05 +0100 | [diff] [blame] | 461 | #define PRIuMAX "I64u" |
Johannes Sixt | 1562f3b | 2013-09-19 09:17:07 +0200 | [diff] [blame] | 462 | #define PRId64 "I64d" |
Johannes Schindelin | 3ecd153 | 2016-01-14 17:51:59 +0100 | [diff] [blame] | 463 | #else |
| 464 | #include <inttypes.h> |
| 465 | #endif |
Johannes Sixt | ba26f29 | 2007-12-07 22:08:59 +0100 | [diff] [blame] | 466 | |
Karsten Blees | 1c950a5 | 2011-11-25 21:05:06 +0100 | [diff] [blame] | 467 | /** |
Johannes Schindelin | bdc77d1 | 2022-03-02 11:06:24 +0100 | [diff] [blame] | 468 | * Verifies that the specified path is owned by the user running the |
| 469 | * current process. |
| 470 | */ |
Johannes Schindelin | 17d3883 | 2022-08-08 13:27:47 +0000 | [diff] [blame] | 471 | int is_path_owned_by_current_sid(const char *path, struct strbuf *report); |
Johannes Schindelin | bdc77d1 | 2022-03-02 11:06:24 +0100 | [diff] [blame] | 472 | #define is_path_owned_by_current_user is_path_owned_by_current_sid |
| 473 | |
| 474 | /** |
Johannes Schindelin | d2c84da | 2019-09-05 13:27:53 +0200 | [diff] [blame] | 475 | * Verifies that the given path is a valid one on Windows. |
| 476 | * |
Johannes Schindelin | 817ddd6 | 2019-09-05 13:44:21 +0200 | [diff] [blame] | 477 | * In particular, path segments are disallowed which |
| 478 | * |
| 479 | * - end in a period or a space (except the special directories `.` and `..`). |
| 480 | * |
| 481 | * - contain any of the reserved characters, e.g. `:`, `;`, `*`, etc |
Johannes Schindelin | d2c84da | 2019-09-05 13:27:53 +0200 | [diff] [blame] | 482 | * |
Johannes Schindelin | 4dc42c6 | 2019-12-21 22:05:01 +0000 | [diff] [blame] | 483 | * - correspond to reserved names (such as `AUX`, `PRN`, etc) |
| 484 | * |
| 485 | * The `allow_literal_nul` parameter controls whether the path `NUL` should |
| 486 | * be considered valid (this makes sense e.g. before opening files, as it is |
| 487 | * perfectly legitimate to open `NUL` on Windows, just as it is to open |
| 488 | * `/dev/null` on Unix/Linux). |
| 489 | * |
Johannes Schindelin | d2c84da | 2019-09-05 13:27:53 +0200 | [diff] [blame] | 490 | * Returns 1 upon success, otherwise 0. |
| 491 | */ |
Johannes Schindelin | 4dc42c6 | 2019-12-21 22:05:01 +0000 | [diff] [blame] | 492 | int is_valid_win32_path(const char *path, int allow_literal_nul); |
| 493 | #define is_valid_path(path) is_valid_win32_path(path, 0) |
Johannes Schindelin | d2c84da | 2019-09-05 13:27:53 +0200 | [diff] [blame] | 494 | |
| 495 | /** |
Karsten Blees | 1c950a5 | 2011-11-25 21:05:06 +0100 | [diff] [blame] | 496 | * Converts UTF-8 encoded string to UTF-16LE. |
| 497 | * |
| 498 | * To support repositories with legacy-encoded file names, invalid UTF-8 bytes |
| 499 | * 0xa0 - 0xff are converted to corresponding printable Unicode chars \u00a0 - |
| 500 | * \u00ff, and invalid UTF-8 bytes 0x80 - 0x9f (which would make non-printable |
| 501 | * Unicode) are converted to hex-code. |
| 502 | * |
| 503 | * Lead-bytes not followed by an appropriate number of trail-bytes, over-long |
| 504 | * encodings and 4-byte encodings > \u10ffff are detected as invalid UTF-8. |
| 505 | * |
| 506 | * Maximum space requirement for the target buffer is two wide chars per UTF-8 |
| 507 | * char (((strlen(utf) * 2) + 1) [* sizeof(wchar_t)]). |
| 508 | * |
| 509 | * The maximum space is needed only if the entire input string consists of |
| 510 | * invalid UTF-8 bytes in range 0x80-0x9f, as per the following table: |
| 511 | * |
| 512 | * | | UTF-8 | UTF-16 | |
| 513 | * Code point | UTF-8 sequence | bytes | words | ratio |
| 514 | * --------------+-------------------+-------+--------+------- |
| 515 | * 000000-00007f | 0-7f | 1 | 1 | 1 |
| 516 | * 000080-0007ff | c2-df + 80-bf | 2 | 1 | 0.5 |
| 517 | * 000800-00ffff | e0-ef + 2 * 80-bf | 3 | 1 | 0.33 |
| 518 | * 010000-10ffff | f0-f4 + 3 * 80-bf | 4 | 2 (a) | 0.5 |
| 519 | * invalid | 80-9f | 1 | 2 (b) | 2 |
| 520 | * invalid | a0-ff | 1 | 1 | 1 |
| 521 | * |
| 522 | * (a) encoded as UTF-16 surrogate pair |
| 523 | * (b) encoded as two hex digits |
| 524 | * |
| 525 | * Note that, while the UTF-8 encoding scheme can be extended to 5-byte, 6-byte |
| 526 | * or even indefinite-byte sequences, the largest valid code point \u10ffff |
| 527 | * encodes as only 4 UTF-8 bytes. |
| 528 | * |
| 529 | * Parameters: |
| 530 | * wcs: wide char target buffer |
| 531 | * utf: string to convert |
| 532 | * wcslen: size of target buffer (in wchar_t's) |
| 533 | * utflen: size of string to convert, or -1 if 0-terminated |
| 534 | * |
| 535 | * Returns: |
| 536 | * length of converted string (_wcslen(wcs)), or -1 on failure |
| 537 | * |
| 538 | * Errors: |
| 539 | * EINVAL: one of the input parameters is invalid (e.g. NULL) |
| 540 | * ERANGE: the output buffer is too small |
| 541 | */ |
| 542 | int xutftowcsn(wchar_t *wcs, const char *utf, size_t wcslen, int utflen); |
| 543 | |
| 544 | /** |
| 545 | * Simplified variant of xutftowcsn, assumes input string is \0-terminated. |
| 546 | */ |
| 547 | static inline int xutftowcs(wchar_t *wcs, const char *utf, size_t wcslen) |
| 548 | { |
| 549 | return xutftowcsn(wcs, utf, wcslen, -1); |
| 550 | } |
| 551 | |
| 552 | /** |
| 553 | * Simplified file system specific variant of xutftowcsn, assumes output |
| 554 | * buffer size is MAX_PATH wide chars and input string is \0-terminated, |
| 555 | * fails with ENAMETOOLONG if input string is too long. |
| 556 | */ |
| 557 | static inline int xutftowcs_path(wchar_t *wcs, const char *utf) |
| 558 | { |
| 559 | int result = xutftowcsn(wcs, utf, MAX_PATH, -1); |
| 560 | if (result < 0 && errno == ERANGE) |
| 561 | errno = ENAMETOOLONG; |
| 562 | return result; |
| 563 | } |
| 564 | |
| 565 | /** |
| 566 | * Converts UTF-16LE encoded string to UTF-8. |
| 567 | * |
| 568 | * Maximum space requirement for the target buffer is three UTF-8 chars per |
| 569 | * wide char ((_wcslen(wcs) * 3) + 1). |
| 570 | * |
| 571 | * The maximum space is needed only if the entire input string consists of |
| 572 | * UTF-16 words in range 0x0800-0xd7ff or 0xe000-0xffff (i.e. \u0800-\uffff |
| 573 | * modulo surrogate pairs), as per the following table: |
| 574 | * |
| 575 | * | | UTF-16 | UTF-8 | |
| 576 | * Code point | UTF-16 sequence | words | bytes | ratio |
| 577 | * --------------+-----------------------+--------+-------+------- |
| 578 | * 000000-00007f | 0000-007f | 1 | 1 | 1 |
| 579 | * 000080-0007ff | 0080-07ff | 1 | 2 | 2 |
| 580 | * 000800-00ffff | 0800-d7ff / e000-ffff | 1 | 3 | 3 |
| 581 | * 010000-10ffff | d800-dbff + dc00-dfff | 2 | 4 | 2 |
| 582 | * |
| 583 | * Note that invalid code points > 10ffff cannot be represented in UTF-16. |
| 584 | * |
| 585 | * Parameters: |
| 586 | * utf: target buffer |
| 587 | * wcs: wide string to convert |
| 588 | * utflen: size of target buffer |
| 589 | * |
| 590 | * Returns: |
| 591 | * length of converted string, or -1 on failure |
| 592 | * |
| 593 | * Errors: |
| 594 | * EINVAL: one of the input parameters is invalid (e.g. NULL) |
| 595 | * ERANGE: the output buffer is too small |
| 596 | */ |
| 597 | int xwcstoutf(char *utf, const wchar_t *wcs, size_t utflen); |
| 598 | |
Johannes Sixt | 35eeef4 | 2008-07-21 21:19:57 +0200 | [diff] [blame] | 599 | /* |
Ramsay Jones | 657b35f | 2013-04-27 20:18:55 +0100 | [diff] [blame] | 600 | * A critical section used in the implementation of the spawn |
Elijah Newren | 15beaaa | 2019-11-05 17:07:23 +0000 | [diff] [blame] | 601 | * functions (mingw_spawnv[p]e()) and waitpid(). Initialised in |
Ramsay Jones | 657b35f | 2013-04-27 20:18:55 +0100 | [diff] [blame] | 602 | * the replacement main() macro below. |
| 603 | */ |
| 604 | extern CRITICAL_SECTION pinfo_cs; |
| 605 | |
| 606 | /* |
Johannes Schindelin | 396ff75 | 2019-06-19 14:05:59 -0700 | [diff] [blame] | 607 | * Git, like most portable C applications, implements a main() function. On |
| 608 | * Windows, this main() function would receive parameters encoded in the |
| 609 | * current locale, but Git for Windows would prefer UTF-8 encoded parameters. |
| 610 | * |
| 611 | * To make that happen, we still declare main() here, and then declare and |
| 612 | * implement wmain() (which is the Unicode variant of main()) and compile with |
| 613 | * -municode. This wmain() function reencodes the parameters from UTF-16 to |
| 614 | * UTF-8 format, sets up a couple of other things as required on Windows, and |
| 615 | * then hands off to the main() function. |
Johannes Sixt | 35eeef4 | 2008-07-21 21:19:57 +0200 | [diff] [blame] | 616 | */ |
Johannes Schindelin | 396ff75 | 2019-06-19 14:05:59 -0700 | [diff] [blame] | 617 | int wmain(int argc, const wchar_t **w_argv); |
| 618 | int main(int argc, const char **argv); |
Marius Storm-Olsen | e16c60d | 2009-05-31 18:15:22 +0200 | [diff] [blame] | 619 | |
Andrzej K. Haczewski | 44626dc | 2010-01-15 21:12:20 +0100 | [diff] [blame] | 620 | /* |
Johannes Schindelin | 08809c0 | 2020-02-13 21:49:53 +0000 | [diff] [blame] | 621 | * For debugging: if a problem occurs, say, in a Git process that is spawned |
| 622 | * from another Git process which in turn is spawned from yet another Git |
| 623 | * process, it can be quite daunting to figure out what is going on. |
| 624 | * |
| 625 | * Call this function to open a new MinTTY (this assumes you are in Git for |
| 626 | * Windows' SDK) with a GDB that attaches to the current process right away. |
| 627 | */ |
Denton Liu | fcedb37 | 2020-10-07 01:31:59 -0700 | [diff] [blame] | 628 | void open_in_gdb(void); |
Johannes Schindelin | 08809c0 | 2020-02-13 21:49:53 +0000 | [diff] [blame] | 629 | |
| 630 | /* |
Andrzej K. Haczewski | 44626dc | 2010-01-15 21:12:20 +0100 | [diff] [blame] | 631 | * Used by Pthread API implementation for Windows |
| 632 | */ |
Denton Liu | 7027f50 | 2019-09-04 04:09:48 -0700 | [diff] [blame] | 633 | int err_win_to_posix(DWORD winerr); |
Matthias Aßhauer | 2406bf5 | 2024-04-03 15:42:02 +0000 | [diff] [blame] | 634 | |
| 635 | #ifndef NO_UNIX_SOCKETS |
| 636 | int mingw_have_unix_sockets(void); |
| 637 | #undef have_unix_sockets |
| 638 | #define have_unix_sockets mingw_have_unix_sockets |
| 639 | #endif |