freshlybakedca.ke
Git fork
1#include "mingw-posix.h"
2
3struct config_context;
4int mingw_core_config(const char *var, const char *value,
5 const struct config_context *ctx, void *cb);
6#define platform_core_config mingw_core_config
7
8#ifndef NO_OPENSSL
9#include <openssl/ssl.h>
10static inline int mingw_SSL_set_fd(SSL *ssl, int fd)
11{
12 return SSL_set_fd(ssl, _get_osfhandle(fd));
13}
14#define SSL_set_fd mingw_SSL_set_fd
15
16static inline int mingw_SSL_set_rfd(SSL *ssl, int fd)
17{
18 return SSL_set_rfd(ssl, _get_osfhandle(fd));
19}
20#define SSL_set_rfd mingw_SSL_set_rfd
21
22static inline int mingw_SSL_set_wfd(SSL *ssl, int fd)
23{
24 return SSL_set_wfd(ssl, _get_osfhandle(fd));
25}
26#define SSL_set_wfd mingw_SSL_set_wfd
27#endif
28
29/*
30 * git specific compatibility
31 */
32
33static inline void convert_slashes(char *path)
34{
35 for (; *path; path++)
36 if (*path == '\\')
37 *path = '/';
38}
39#define PATH_SEP ';'
40char *mingw_query_user_email(void);
41#define query_user_email mingw_query_user_email
42
43/**
44 * Verifies that the specified path is owned by the user running the
45 * current process.
46 */
47int is_path_owned_by_current_sid(const char *path, struct strbuf *report);
48#define is_path_owned_by_current_user is_path_owned_by_current_sid
49
50/**
51 * Verifies that the given path is a valid one on Windows.
52 *
53 * In particular, path segments are disallowed which
54 *
55 * - end in a period or a space (except the special directories `.` and `..`).
56 *
57 * - contain any of the reserved characters, e.g. `:`, `;`, `*`, etc
58 *
59 * - correspond to reserved names (such as `AUX`, `PRN`, etc)
60 *
61 * The `allow_literal_nul` parameter controls whether the path `NUL` should
62 * be considered valid (this makes sense e.g. before opening files, as it is
63 * perfectly legitimate to open `NUL` on Windows, just as it is to open
64 * `/dev/null` on Unix/Linux).
65 *
66 * Returns 1 upon success, otherwise 0.
67 */
68int is_valid_win32_path(const char *path, int allow_literal_nul);
69#define is_valid_path(path) is_valid_win32_path(path, 0)
70
71/**
72 * Converts UTF-8 encoded string to UTF-16LE.
73 *
74 * To support repositories with legacy-encoded file names, invalid UTF-8 bytes
75 * 0xa0 - 0xff are converted to corresponding printable Unicode chars \u00a0 -
76 * \u00ff, and invalid UTF-8 bytes 0x80 - 0x9f (which would make non-printable
77 * Unicode) are converted to hex-code.
78 *
79 * Lead-bytes not followed by an appropriate number of trail-bytes, over-long
80 * encodings and 4-byte encodings > \u10ffff are detected as invalid UTF-8.
81 *
82 * Maximum space requirement for the target buffer is two wide chars per UTF-8
83 * char (((strlen(utf) * 2) + 1) [* sizeof(wchar_t)]).
84 *
85 * The maximum space is needed only if the entire input string consists of
86 * invalid UTF-8 bytes in range 0x80-0x9f, as per the following table:
87 *
88 * | | UTF-8 | UTF-16 |
89 * Code point | UTF-8 sequence | bytes | words | ratio
90 * --------------+-------------------+-------+--------+-------
91 * 000000-00007f | 0-7f | 1 | 1 | 1
92 * 000080-0007ff | c2-df + 80-bf | 2 | 1 | 0.5
93 * 000800-00ffff | e0-ef + 2 * 80-bf | 3 | 1 | 0.33
94 * 010000-10ffff | f0-f4 + 3 * 80-bf | 4 | 2 (a) | 0.5
95 * invalid | 80-9f | 1 | 2 (b) | 2
96 * invalid | a0-ff | 1 | 1 | 1
97 *
98 * (a) encoded as UTF-16 surrogate pair
99 * (b) encoded as two hex digits
100 *
101 * Note that, while the UTF-8 encoding scheme can be extended to 5-byte, 6-byte
102 * or even indefinite-byte sequences, the largest valid code point \u10ffff
103 * encodes as only 4 UTF-8 bytes.
104 *
105 * Parameters:
106 * wcs: wide char target buffer
107 * utf: string to convert
108 * wcslen: size of target buffer (in wchar_t's)
109 * utflen: size of string to convert, or -1 if 0-terminated
110 *
111 * Returns:
112 * length of converted string (_wcslen(wcs)), or -1 on failure
113 *
114 * Errors:
115 * EINVAL: one of the input parameters is invalid (e.g. NULL)
116 * ERANGE: the output buffer is too small
117 */
118int xutftowcsn(wchar_t *wcs, const char *utf, size_t wcslen, int utflen);
119
120/**
121 * Simplified variant of xutftowcsn, assumes input string is \0-terminated.
122 */
123static inline int xutftowcs(wchar_t *wcs, const char *utf, size_t wcslen)
124{
125 return xutftowcsn(wcs, utf, wcslen, -1);
126}
127
128/**
129 * Simplified file system specific variant of xutftowcsn, assumes output
130 * buffer size is MAX_PATH wide chars and input string is \0-terminated,
131 * fails with ENAMETOOLONG if input string is too long.
132 */
133static inline int xutftowcs_path(wchar_t *wcs, const char *utf)
134{
135 int result = xutftowcsn(wcs, utf, MAX_PATH, -1);
136 if (result < 0 && errno == ERANGE)
137 errno = ENAMETOOLONG;
138 return result;
139}
140
141/**
142 * Converts UTF-16LE encoded string to UTF-8.
143 *
144 * Maximum space requirement for the target buffer is three UTF-8 chars per
145 * wide char ((_wcslen(wcs) * 3) + 1).
146 *
147 * The maximum space is needed only if the entire input string consists of
148 * UTF-16 words in range 0x0800-0xd7ff or 0xe000-0xffff (i.e. \u0800-\uffff
149 * modulo surrogate pairs), as per the following table:
150 *
151 * | | UTF-16 | UTF-8 |
152 * Code point | UTF-16 sequence | words | bytes | ratio
153 * --------------+-----------------------+--------+-------+-------
154 * 000000-00007f | 0000-007f | 1 | 1 | 1
155 * 000080-0007ff | 0080-07ff | 1 | 2 | 2
156 * 000800-00ffff | 0800-d7ff / e000-ffff | 1 | 3 | 3
157 * 010000-10ffff | d800-dbff + dc00-dfff | 2 | 4 | 2
158 *
159 * Note that invalid code points > 10ffff cannot be represented in UTF-16.
160 *
161 * Parameters:
162 * utf: target buffer
163 * wcs: wide string to convert
164 * utflen: size of target buffer
165 *
166 * Returns:
167 * length of converted string, or -1 on failure
168 *
169 * Errors:
170 * EINVAL: one of the input parameters is invalid (e.g. NULL)
171 * ERANGE: the output buffer is too small
172 */
173int xwcstoutf(char *utf, const wchar_t *wcs, size_t utflen);
174
175/*
176 * A critical section used in the implementation of the spawn
177 * functions (mingw_spawnv[p]e()) and waitpid(). Initialised in
178 * the replacement main() macro below.
179 */
180extern CRITICAL_SECTION pinfo_cs;
181
182/*
183 * Git, like most portable C applications, implements a main() function. On
184 * Windows, this main() function would receive parameters encoded in the
185 * current locale, but Git for Windows would prefer UTF-8 encoded parameters.
186 *
187 * To make that happen, we still declare main() here, and then declare and
188 * implement wmain() (which is the Unicode variant of main()) and compile with
189 * -municode. This wmain() function reencodes the parameters from UTF-16 to
190 * UTF-8 format, sets up a couple of other things as required on Windows, and
191 * then hands off to the main() function.
192 */
193int wmain(int argc, const wchar_t **w_argv);
194int main(int argc, const char **argv);
195
196/*
197 * For debugging: if a problem occurs, say, in a Git process that is spawned
198 * from another Git process which in turn is spawned from yet another Git
199 * process, it can be quite daunting to figure out what is going on.
200 *
201 * Call this function to open a new MinTTY (this assumes you are in Git for
202 * Windows' SDK) with a GDB that attaches to the current process right away.
203 */
204void open_in_gdb(void);
205
206/*
207 * Used by Pthread API implementation for Windows
208 */
209int err_win_to_posix(DWORD winerr);
210
211#ifndef NO_UNIX_SOCKETS
212int mingw_have_unix_sockets(void);
213#undef have_unix_sockets
214#define have_unix_sockets mingw_have_unix_sockets
215#endif