blob: 27b61284f46be61ec7baefa2e19328d58397d1f9 [file] [log] [blame]
Johannes Schindelin3ecd1532016-01-14 17:51:59 +01001#ifdef __MINGW64_VERSION_MAJOR
2#include <stdint.h>
3#include <wchar.h>
4typedef _sigset_t sigset_t;
5#endif
Johannes Sixtf4626df2007-12-01 21:24:59 +01006#include <winsock2.h>
Martin Storsjöfe3b2b72009-11-24 00:55:50 +02007#include <ws2tcpip.h>
Johannes Sixtf4626df2007-12-01 21:24:59 +01008
Johannes Schindelin3ecd1532016-01-14 17:51:59 +01009/* 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 Chooa4e7e312023-06-28 19:26:22 +000014struct config_context;
15int mingw_core_config(const char *var, const char *value,
16 const struct config_context *ctx, void *cb);
Johannes Schindelin70fc5792018-10-30 11:40:04 -070017#define platform_core_config mingw_core_config
18
Johannes Sixtf4626df2007-12-01 21:24:59 +010019/*
20 * things that are not available in header files
21 */
22
Sebastian Schuberthe7cf4e92009-12-28 18:04:21 +010023typedef int uid_t;
Mike Pape772991a2010-11-04 02:35:09 +010024typedef int socklen_t;
Johannes Schindelin3ecd1532016-01-14 17:51:59 +010025#ifndef __MINGW64_VERSION_MAJOR
26typedef int pid_t;
Johannes Sixtf4626df2007-12-01 21:24:59 +010027#define hstrerror strerror
Johannes Schindelin3ecd1532016-01-14 17:51:59 +010028#endif
Johannes Sixtf4626df2007-12-01 21:24:59 +010029
30#define S_IFLNK 0120000 /* Symbolic link */
31#define S_ISLNK(x) (((x) & S_IFMT) == S_IFLNK)
32#define S_ISSOCK(x) 0
Sebastian Schuberth4091bfc2009-12-28 18:13:52 +010033
Johannes Schindelin59de49f2016-01-15 14:24:29 +010034#ifndef S_IRWXG
Johannes Sixtf4626df2007-12-01 21:24:59 +010035#define S_IRGRP 0
36#define S_IWGRP 0
37#define S_IXGRP 0
Sebastian Schuberth4091bfc2009-12-28 18:13:52 +010038#define S_IRWXG (S_IRGRP | S_IWGRP | S_IXGRP)
Johannes Schindelin59de49f2016-01-15 14:24:29 +010039#endif
40#ifndef S_IRWXO
Johannes Sixtf4626df2007-12-01 21:24:59 +010041#define S_IROTH 0
Sebastian Schuberth4091bfc2009-12-28 18:13:52 +010042#define S_IWOTH 0
Johannes Sixtf4626df2007-12-01 21:24:59 +010043#define S_IXOTH 0
Sebastian Schuberth4091bfc2009-12-28 18:13:52 +010044#define S_IRWXO (S_IROTH | S_IWOTH | S_IXOTH)
Johannes Schindelin59de49f2016-01-15 14:24:29 +010045#endif
Ramsay Jones90110d72012-04-17 19:00:04 +010046
47#define S_ISUID 0004000
48#define S_ISGID 0002000
49#define S_ISVTX 0001000
Johannes Sixtf4626df2007-12-01 21:24:59 +010050
Johannes Sixt303e7c42009-07-04 21:26:38 +020051#define WIFEXITED(x) 1
52#define WIFSIGNALED(x) 0
Johannes Sixtf4626df2007-12-01 21:24:59 +010053#define WEXITSTATUS(x) ((x) & 0xff)
Johannes Sixt303e7c42009-07-04 21:26:38 +020054#define WTERMSIG(x) SIGTERM
Johannes Sixtf4626df2007-12-01 21:24:59 +010055
Karsten Blees61542f72013-09-11 01:22:34 +020056#ifndef EWOULDBLOCK
Ilari Liusvaara419f37d2010-10-12 19:39:41 +030057#define EWOULDBLOCK EAGAIN
Karsten Blees61542f72013-09-11 01:22:34 +020058#endif
Karsten Bleese0a064a2014-07-16 00:53:27 +020059#ifndef ELOOP
60#define ELOOP EMLINK
61#endif
Ilari Liusvaara419f37d2010-10-12 19:39:41 +030062#define SHUT_WR SD_SEND
63
Johannes Sixtd2825062009-01-22 00:57:34 -050064#define SIGHUP 1
65#define SIGQUIT 3
66#define SIGKILL 9
67#define SIGPIPE 13
68#define SIGALRM 14
69#define SIGCHLD 17
Johannes Sixtf4626df2007-12-01 21:24:59 +010070
71#define F_GETFD 1
72#define F_SETFD 2
73#define FD_CLOEXEC 0x1
74
Ben Wijen05d1ed62016-08-22 14:47:55 +020075#if !defined O_CLOEXEC && defined O_NOINHERIT
76#define O_CLOEXEC O_NOINHERIT
77#endif
78
Karsten Blees61542f72013-09-11 01:22:34 +020079#ifndef EAFNOSUPPORT
Mike Pape772991a2010-11-04 02:35:09 +010080#define EAFNOSUPPORT WSAEAFNOSUPPORT
Karsten Blees61542f72013-09-11 01:22:34 +020081#endif
82#ifndef ECONNABORTED
Mike Pape772991a2010-11-04 02:35:09 +010083#define ECONNABORTED WSAECONNABORTED
Karsten Blees61542f72013-09-11 01:22:34 +020084#endif
Johannes Sixtfab60272016-07-21 22:59:06 +020085#ifndef ENOTSOCK
86#define ENOTSOCK WSAENOTSOCK
87#endif
Mike Pape772991a2010-11-04 02:35:09 +010088
Johannes Sixtf4626df2007-12-01 21:24:59 +010089struct passwd {
90 char *pw_name;
91 char *pw_gecos;
92 char *pw_dir;
93};
94
Johannes Sixtf4626df2007-12-01 21:24:59 +010095typedef void (__cdecl *sig_handler_t)(int);
96struct sigaction {
97 sig_handler_t sa_handler;
98 unsigned sa_flags;
99};
Johannes Sixtf4626df2007-12-01 21:24:59 +0100100#define SA_RESTART 0
101
102struct itimerval {
103 struct timeval it_value, it_interval;
104};
105#define ITIMER_REAL 0
106
Nguyễn Thái Ngọc Duy7b6aff02015-03-08 17:12:45 +0700107struct utsname {
108 char sysname[16];
109 char nodename[1];
110 char release[16];
111 char version[16];
112 char machine[1];
113};
114
Johannes Sixtf4626df2007-12-01 21:24:59 +0100115/*
Eric Sunshine77df1f12010-09-27 07:01:59 -0400116 * 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 Sixtf4626df2007-12-01 21:24:59 +0100122 * trivial stubs
123 */
124
125static inline int readlink(const char *path, char *buf, size_t bufsiz)
126{ errno = ENOSYS; return -1; }
127static inline int symlink(const char *oldpath, const char *newpath)
128{ errno = ENOSYS; return -1; }
Johannes Sixtf4626df2007-12-01 21:24:59 +0100129static inline int fchmod(int fildes, mode_t mode)
130{ errno = ENOSYS; return -1; }
Johannes Schindelin3ecd1532016-01-14 17:51:59 +0100131#ifndef __MINGW64_VERSION_MAJOR
Junio C Hamanof0c7fd42011-11-15 15:39:33 -0800132static inline pid_t fork(void)
133{ errno = ENOSYS; return -1; }
Johannes Schindelin3ecd1532016-01-14 17:51:59 +0100134#endif
Johannes Sixtf4626df2007-12-01 21:24:59 +0100135static inline unsigned int alarm(unsigned int seconds)
136{ return 0; }
137static inline int fsync(int fd)
Erik Faye-Lund75f69292010-05-20 20:57:54 +0200138{ return _commit(fd); }
Johannes Sixtf4626df2007-12-01 21:24:59 +0100139static inline void sync(void)
140{}
Sebastian Schuberthe7cf4e92009-12-28 18:04:21 +0100141static inline uid_t getuid(void)
Johannes Sixtf4626df2007-12-01 21:24:59 +0100142{ return 1; }
143static inline struct passwd *getpwnam(const char *name)
144{ return NULL; }
Johannes Sixt5f8763a2010-03-06 16:40:40 +0100145static inline int fcntl(int fd, int cmd, ...)
Johannes Sixtf4626df2007-12-01 21:24:59 +0100146{
147 if (cmd == F_GETFD || cmd == F_SETFD)
148 return 0;
149 errno = EINVAL;
150 return -1;
151}
Jeff Hostetleree4512e2019-02-22 14:25:01 -0800152
Johannes Sixt4e6d2072014-09-22 20:24:34 +0200153#define sigemptyset(x) (void)0
154static inline int sigaddset(sigset_t *set, int signum)
155{ return 0; }
Johannes Sixtf924b522016-05-01 21:08:21 +0200156#define SIG_BLOCK 0
Johannes Sixt4e6d2072014-09-22 20:24:34 +0200157#define SIG_UNBLOCK 0
158static inline int sigprocmask(int how, const sigset_t *set, sigset_t *oldset)
159{ return 0; }
Johannes Sixt9a9a41d2015-04-15 20:29:30 +0200160static inline pid_t getppid(void)
161{ return 1; }
162static inline pid_t getpgid(pid_t pid)
163{ return pid == 0 ? getpid() : pid; }
164static inline pid_t tcgetpgrp(int fd)
165{ return getpid(); }
Johannes Sixtf4626df2007-12-01 21:24:59 +0100166
167/*
168 * simple adaptors
169 */
170
Karsten Blees85faec92012-03-15 18:21:28 +0100171int mingw_mkdir(const char *path, int mode);
Johannes Sixtf4626df2007-12-01 21:24:59 +0100172#define mkdir mingw_mkdir
173
Erik Faye-Lundef7108c2010-11-04 02:35:14 +0100174#define WNOHANG 1
Erik Faye-Lund956d86d2011-12-08 20:39:57 +0100175pid_t waitpid(pid_t pid, int *status, int options);
Johannes Sixtf4626df2007-12-01 21:24:59 +0100176
Erik Faye-Lund82fc07b2010-11-04 02:35:15 +0100177#define kill mingw_kill
178int mingw_kill(pid_t pid, int sig);
179
Matthias Aßhauer2bf46a92023-08-04 04:08:43 +0000180#define locate_in_PATH mingw_locate_in_PATH
181char *mingw_locate_in_PATH(const char *cmd);
182
Erik Faye-Lund514213b2009-10-19 17:42:07 +0200183#ifndef NO_OPENSSL
184#include <openssl/ssl.h>
185static 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
191static 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
197static 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 Sixtf4626df2007-12-01 21:24:59 +0100204/*
205 * implementations of missing functions
206 */
207
Johannes Sixt897bb8c2007-12-07 22:05:36 +0100208int pipe(int filedes[2]);
Johannes Sixtf4626df2007-12-01 21:24:59 +0100209unsigned int sleep (unsigned int seconds);
210int mkstemp(char *template);
211int gettimeofday(struct timeval *tv, void *tz);
Johannes Schindelin3ecd1532016-01-14 17:51:59 +0100212#ifndef __MINGW64_VERSION_MAJOR
Johannes Sixtf4626df2007-12-01 21:24:59 +0100213struct tm *gmtime_r(const time_t *timep, struct tm *result);
214struct tm *localtime_r(const time_t *timep, struct tm *result);
Johannes Schindelin3ecd1532016-01-14 17:51:59 +0100215#endif
Johannes Sixtf4626df2007-12-01 21:24:59 +0100216int getpagesize(void); /* defined in MinGW's libgcc.a */
Sebastian Schuberthe7cf4e92009-12-28 18:04:21 +0100217struct passwd *getpwuid(uid_t uid);
Johannes Sixtf4626df2007-12-01 21:24:59 +0100218int setitimer(int type, struct itimerval *in, struct itimerval *out);
219int sigaction(int sig, struct sigaction *in, struct sigaction *out);
Petr Kodl7be401e2009-01-24 15:04:39 +0100220int link(const char *oldpath, const char *newpath);
Nguyễn Thái Ngọc Duy7b6aff02015-03-08 17:12:45 +0700221int uname(struct utsname *buf);
Johannes Sixt80ba0742007-12-03 21:55:57 +0100222
223/*
Johannes Sixt25fe2172008-03-05 21:51:27 +0100224 * replacements of existing functions
225 */
226
Heiko Voigt337967f2011-02-07 21:49:33 +0100227int mingw_unlink(const char *pathname);
228#define unlink mingw_unlink
229
Heiko Voigt4f288102011-02-07 21:52:34 +0100230int mingw_rmdir(const char *path);
231#define rmdir mingw_rmdir
232
Johannes Sixt3e4a1ba2007-11-15 22:22:47 +0100233int mingw_open (const char *filename, int oflags, ...);
234#define open mingw_open
Jeff King2b081012021-02-26 01:14:35 -0500235#undef OPEN_RETURNS_EINTR
Johannes Sixt3e4a1ba2007-11-15 22:22:47 +0100236
Erik Faye-Lund176478a2012-12-04 09:10:38 +0100237int mingw_fgetc(FILE *stream);
238#define fgetc mingw_fgetc
239
Johannes Sixt3fdcdbd2010-02-25 21:03:44 +0100240FILE *mingw_fopen (const char *filename, const char *otype);
241#define fopen mingw_fopen
242
243FILE *mingw_freopen (const char *filename, const char *otype, FILE *stream);
244#define freopen mingw_freopen
245
Johannes Sixt84adb642012-10-17 09:05:51 +0200246int mingw_fflush(FILE *stream);
247#define fflush mingw_fflush
248
Johannes Schindelin2b862922015-12-17 18:08:15 +0100249ssize_t mingw_write(int fd, const void *buf, size_t len);
250#define write mingw_write
251
Karsten Blees85faec92012-03-15 18:21:28 +0100252int mingw_access(const char *filename, int mode);
253#undef access
254#define access mingw_access
255
256int mingw_chdir(const char *dirname);
257#define chdir mingw_chdir
258
259int mingw_chmod(const char *filename, int mode);
260#define chmod mingw_chmod
261
262char *mingw_mktemp(char *template);
263#define mktemp mingw_mktemp
264
Johannes Sixt25fe2172008-03-05 21:51:27 +0100265char *mingw_getcwd(char *pointer, int len);
266#define getcwd mingw_getcwd
267
Johannes Schindelinfe21c6b2018-10-30 02:22:30 -0700268#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 Sixt6fd6aec2008-06-22 11:35:21 +0200295char *mingw_getenv(const char *name);
Johannes Schindelinfe21c6b2018-10-30 02:22:30 -0700296int mingw_putenv(const char *name);
Johannes Sixt6fd6aec2008-06-22 11:35:21 +0200297
Pat Thoyts13d24b02011-10-15 15:05:20 +0100298int mingw_gethostname(char *host, int namelen);
299#define gethostname mingw_gethostname
300
Johannes Sixt746fb852007-12-26 13:51:18 +0100301struct hostent *mingw_gethostbyname(const char *host);
302#define gethostbyname mingw_gethostbyname
303
Martin Storsjöfe3b2b72009-11-24 00:55:50 +0200304int mingw_getaddrinfo(const char *node, const char *service,
305 const struct addrinfo *hints, struct addrinfo **res);
306#define getaddrinfo mingw_getaddrinfo
307
Johannes Sixt746fb852007-12-26 13:51:18 +0100308int mingw_socket(int domain, int type, int protocol);
309#define socket mingw_socket
310
311int mingw_connect(int sockfd, struct sockaddr *sa, size_t sz);
312#define connect mingw_connect
313
Mike Pape772991a2010-11-04 02:35:09 +0100314int mingw_bind(int sockfd, struct sockaddr *sa, size_t sz);
315#define bind mingw_bind
316
317int mingw_setsockopt(int sockfd, int lvl, int optname, void *optval, int optlen);
318#define setsockopt mingw_setsockopt
319
Johannes Sixta7941792011-05-18 22:24:37 +0200320int mingw_shutdown(int sockfd, int how);
321#define shutdown mingw_shutdown
322
Mike Pape772991a2010-11-04 02:35:09 +0100323int mingw_listen(int sockfd, int backlog);
324#define listen mingw_listen
325
326int mingw_accept(int sockfd, struct sockaddr *sa, socklen_t *sz);
327#define accept mingw_accept
328
Johannes Sixtea9e98c2007-12-07 22:19:40 +0100329int mingw_rename(const char*, const char*);
330#define rename mingw_rename
331
Ramsay Jonesb1b95202009-11-07 20:10:31 +0000332#if defined(USE_WIN32_MMAP) || defined(_MSC_VER)
Janos Laubeb130a722009-03-13 16:50:45 +0100333int mingw_getpagesize(void);
334#define getpagesize mingw_getpagesize
335#endif
336
Neeraj Singhabf38ab2022-03-10 22:43:20 +0000337int win32_fsync_no_flush(int fd);
338#define fsync_no_flush win32_fsync_no_flush
339
Neeraj Singh8a94d832022-04-04 22:20:14 -0700340#define FSYNC_COMPONENTS_PLATFORM_DEFAULT (FSYNC_COMPONENTS_DEFAULT | FSYNC_COMPONENT_LOOSE_OBJECT)
341#define FSYNC_METHOD_DEFAULT (FSYNC_METHOD_BATCH)
342
Erik Faye-Lund38abd9b2011-02-28 22:13:22 +0100343struct rlimit {
344 unsigned int rlim_cur;
345};
346#define RLIMIT_NOFILE 0
347
348static 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 Bleesa2374f52013-09-11 01:23:13 +0200359/*
Karsten Bleesd7e8c872018-10-23 03:23:22 -0700360 * 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-Olsen5411bdc2007-09-03 20:40:26 +0200363 */
Johannes Schindelin3ecd1532016-01-14 17:51:59 +0100364#ifndef __MINGW64_VERSION_MAJOR
Johannes Schindelin1d4e4cd2009-03-05 17:05:12 +0100365#define off_t off64_t
Johannes Schindelin1d4e4cd2009-03-05 17:05:12 +0100366#define lseek _lseeki64
Jeff Hostetler172e54e2019-06-19 14:06:03 -0700367#ifndef _MSC_VER
Karsten Bleesd7e8c872018-10-23 03:23:22 -0700368struct timespec {
369 time_t tv_sec;
370 long tv_nsec;
371};
Johannes Schindelin3ecd1532016-01-14 17:51:59 +0100372#endif
Jeff Hostetler172e54e2019-06-19 14:06:03 -0700373#endif
Karsten Bleesa2374f52013-09-11 01:23:13 +0200374
Karsten Bleesd7e8c872018-10-23 03:23:22 -0700375struct 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 Schuberthfa93bb22013-09-11 18:02:09 +0200393#ifdef stat
394#undef stat
395#endif
Karsten Bleesd7e8c872018-10-23 03:23:22 -0700396#define stat mingw_stat
Johannes Sixt180964f2008-08-18 22:01:06 +0200397int mingw_lstat(const char *file_name, struct stat *buf);
Pat Thoyts9b9784c2010-03-17 15:17:34 +0000398int mingw_stat(const char *file_name, struct stat *buf);
Johannes Sixt180964f2008-08-18 22:01:06 +0200399int mingw_fstat(int fd, struct stat *buf);
Sebastian Schuberthfa93bb22013-09-11 18:02:09 +0200400#ifdef fstat
401#undef fstat
402#endif
Marius Storm-Olsen5411bdc2007-09-03 20:40:26 +0200403#define fstat mingw_fstat
Sebastian Schuberthfa93bb22013-09-11 18:02:09 +0200404#ifdef lstat
405#undef lstat
406#endif
Marius Storm-Olsen5411bdc2007-09-03 20:40:26 +0200407#define lstat mingw_lstat
Karsten Bleesa2374f52013-09-11 01:23:13 +0200408
Marius Storm-Olsen5411bdc2007-09-03 20:40:26 +0200409
Johannes Sixt7c0ffa12007-09-07 13:05:00 +0200410int mingw_utime(const char *file_name, const struct utimbuf *times);
411#define utime mingw_utime
Johannes Schindelin9ee05402018-03-19 17:49:22 +0100412size_t mingw_strftime(char *s, size_t max,
413 const char *format, const struct tm *tm);
414#define strftime mingw_strftime
Johannes Sixt7c0ffa12007-09-07 13:05:00 +0200415
Johannes Sixt75301f92010-01-15 21:12:18 +0100416pid_t mingw_spawnvpe(const char *cmd, const char **argv, char **env,
Johannes Sixtf9a27432010-04-11 22:40:12 +0200417 const char *dir,
Johannes Sixt75301f92010-01-15 21:12:18 +0100418 int fhin, int fhout, int fherr);
Ramsay Jones1696d722012-04-05 18:48:46 +0100419int mingw_execvp(const char *cmd, char *const *argv);
Johannes Sixtf1a4dfb2007-12-04 12:38:32 +0100420#define execvp mingw_execvp
Ramsay Jones1696d722012-04-05 18:48:46 +0100421int mingw_execv(const char *cmd, char *const *argv);
Eric Sunshine5debf9a2010-09-27 07:02:17 -0400422#define execv mingw_execv
Johannes Sixtf1a4dfb2007-12-04 12:38:32 +0100423
Steffen Prohaskacd800ee2007-11-17 19:16:53 +0100424static inline unsigned int git_ntohl(unsigned int x)
425{ return (unsigned int)ntohl(x); }
426#define ntohl git_ntohl
427
Johannes Sixt6072fc32007-11-13 10:14:45 +0100428sig_handler_t mingw_signal(int sig, sig_handler_t handler);
429#define signal mingw_signal
430
Erik Faye-Lund176478a2012-12-04 09:10:38 +0100431int mingw_raise(int sig);
432#define raise mingw_raise
433
Johannes Sixt25fe2172008-03-05 21:51:27 +0100434/*
Peter Harrisc09df8a2008-07-18 09:34:44 +0200435 * ANSI emulation wrappers
436 */
437
Johannes Schindelincbb3f3c2016-12-11 12:16:57 +0100438int winansi_isatty(int fd);
439#define isatty winansi_isatty
440
Johannes Schindelinff8978d2018-10-30 11:44:40 -0700441int winansi_dup2(int oldfd, int newfd);
442#define dup2 winansi_dup2
443
Karsten Bleeseac14f82012-01-14 22:24:19 +0100444void winansi_init(void);
Karsten Bleeseac14f82012-01-14 22:24:19 +0100445HANDLE winansi_get_osfhandle(int fd);
Peter Harrisc09df8a2008-07-18 09:34:44 +0200446
447/*
Johannes Sixt80ba0742007-12-03 21:55:57 +0100448 * git specific compatibility
449 */
450
Johannes Schindelin5ca6b7b2016-03-23 11:55:00 +0100451static inline void convert_slashes(char *path)
452{
453 for (; *path; path++)
454 if (*path == '\\')
455 *path = '/';
456}
Johannes Sixt80ba0742007-12-03 21:55:57 +0100457#define PATH_SEP ';'
Denton Liu7027f502019-09-04 04:09:48 -0700458char *mingw_query_user_email(void);
Johannes Schindelin501afcb2018-10-15 02:47:08 -0700459#define query_user_email mingw_query_user_email
Sven Strickroth0ef60af2016-03-30 13:37:36 +0200460#if !defined(__MINGW64_VERSION_MAJOR) && (!defined(_MSC_VER) || _MSC_VER < 1800)
Johannes Sixt82f8d962007-03-23 10:57:05 +0100461#define PRIuMAX "I64u"
Johannes Sixt1562f3b2013-09-19 09:17:07 +0200462#define PRId64 "I64d"
Johannes Schindelin3ecd1532016-01-14 17:51:59 +0100463#else
464#include <inttypes.h>
465#endif
Johannes Sixtba26f292007-12-07 22:08:59 +0100466
Karsten Blees1c950a52011-11-25 21:05:06 +0100467/**
Johannes Schindelinbdc77d12022-03-02 11:06:24 +0100468 * Verifies that the specified path is owned by the user running the
469 * current process.
470 */
Johannes Schindelin17d38832022-08-08 13:27:47 +0000471int is_path_owned_by_current_sid(const char *path, struct strbuf *report);
Johannes Schindelinbdc77d12022-03-02 11:06:24 +0100472#define is_path_owned_by_current_user is_path_owned_by_current_sid
473
474/**
Johannes Schindelind2c84da2019-09-05 13:27:53 +0200475 * Verifies that the given path is a valid one on Windows.
476 *
Johannes Schindelin817ddd62019-09-05 13:44:21 +0200477 * 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 Schindelind2c84da2019-09-05 13:27:53 +0200482 *
Johannes Schindelin4dc42c62019-12-21 22:05:01 +0000483 * - 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 Schindelind2c84da2019-09-05 13:27:53 +0200490 * Returns 1 upon success, otherwise 0.
491 */
Johannes Schindelin4dc42c62019-12-21 22:05:01 +0000492int is_valid_win32_path(const char *path, int allow_literal_nul);
493#define is_valid_path(path) is_valid_win32_path(path, 0)
Johannes Schindelind2c84da2019-09-05 13:27:53 +0200494
495/**
Karsten Blees1c950a52011-11-25 21:05:06 +0100496 * 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 */
542int 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 */
547static 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 */
557static 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 */
597int xwcstoutf(char *utf, const wchar_t *wcs, size_t utflen);
598
Johannes Sixt35eeef42008-07-21 21:19:57 +0200599/*
Ramsay Jones657b35f2013-04-27 20:18:55 +0100600 * A critical section used in the implementation of the spawn
Elijah Newren15beaaa2019-11-05 17:07:23 +0000601 * functions (mingw_spawnv[p]e()) and waitpid(). Initialised in
Ramsay Jones657b35f2013-04-27 20:18:55 +0100602 * the replacement main() macro below.
603 */
604extern CRITICAL_SECTION pinfo_cs;
605
606/*
Johannes Schindelin396ff752019-06-19 14:05:59 -0700607 * 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 Sixt35eeef42008-07-21 21:19:57 +0200616 */
Johannes Schindelin396ff752019-06-19 14:05:59 -0700617int wmain(int argc, const wchar_t **w_argv);
618int main(int argc, const char **argv);
Marius Storm-Olsene16c60d2009-05-31 18:15:22 +0200619
Andrzej K. Haczewski44626dc2010-01-15 21:12:20 +0100620/*
Johannes Schindelin08809c02020-02-13 21:49:53 +0000621 * 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 Liufcedb372020-10-07 01:31:59 -0700628void open_in_gdb(void);
Johannes Schindelin08809c02020-02-13 21:49:53 +0000629
630/*
Andrzej K. Haczewski44626dc2010-01-15 21:12:20 +0100631 * Used by Pthread API implementation for Windows
632 */
Denton Liu7027f502019-09-04 04:09:48 -0700633int err_win_to_posix(DWORD winerr);
Matthias Aßhauer2406bf52024-04-03 15:42:02 +0000634
635#ifndef NO_UNIX_SOCKETS
636int mingw_have_unix_sockets(void);
637#undef have_unix_sockets
638#define have_unix_sockets mingw_have_unix_sockets
639#endif