Fix error handling in RAND_DRBG_set
[openssl.git] / apps / win32_init.c
1 /*
2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <windows.h>
11 #include <stdlib.h>
12 #include <string.h>
13 #include <malloc.h>
14
15 #if defined(CP_UTF8)
16
17 static UINT saved_cp;
18 static int newargc;
19 static char **newargv;
20
21 static void cleanup(void)
22 {
23     int i;
24
25     SetConsoleOutputCP(saved_cp);
26
27     for (i = 0; i < newargc; i++)
28         free(newargv[i]);
29
30     free(newargv);
31 }
32
33 /*
34  * Incrementally [re]allocate newargv and keep it NULL-terminated.
35  */
36 static int validate_argv(int argc)
37 {
38     static int size = 0;
39
40     if (argc >= size) {
41         char **ptr;
42
43         while (argc >= size)
44             size += 64;
45
46         ptr = realloc(newargv, size * sizeof(newargv[0]));
47         if (ptr == NULL)
48             return 0;
49
50         (newargv = ptr)[argc] = NULL;
51     } else {
52         newargv[argc] = NULL;
53     }
54
55     return 1;
56 }
57
58 static int process_glob(WCHAR *wstr, int wlen)
59 {
60     int i, slash, udlen;
61     WCHAR saved_char;
62     WIN32_FIND_DATAW data;
63     HANDLE h;
64
65     /*
66      * Note that we support wildcard characters only in filename part
67      * of the path, and not in directories. Windows users are used to
68      * this, that's why recursive glob processing is not implemented.
69      */
70     /*
71      * Start by looking for last slash or backslash, ...
72      */
73     for (slash = 0, i = 0; i < wlen; i++)
74         if (wstr[i] == L'/' || wstr[i] == L'\\')
75             slash = i + 1;
76     /*
77      * ... then look for asterisk or question mark in the file name.
78      */
79     for (i = slash; i < wlen; i++)
80         if (wstr[i] == L'*' || wstr[i] == L'?')
81             break;
82
83     if (i == wlen)
84         return 0;   /* definitely not a glob */
85
86     saved_char = wstr[wlen];
87     wstr[wlen] = L'\0';
88     h = FindFirstFileW(wstr, &data);
89     wstr[wlen] = saved_char;
90     if (h == INVALID_HANDLE_VALUE)
91         return 0;   /* not a valid glob, just pass... */
92
93     if (slash)
94         udlen = WideCharToMultiByte(CP_UTF8, 0, wstr, slash,
95                                     NULL, 0, NULL, NULL);
96     else
97         udlen = 0;
98
99     do {
100         int uflen;
101         char *arg;
102
103         /*
104          * skip over . and ..
105          */
106         if (data.cFileName[0] == L'.') {
107             if ((data.cFileName[1] == L'\0') ||
108                 (data.cFileName[1] == L'.' && data.cFileName[2] == L'\0'))
109                 continue;
110         }
111
112         if (!validate_argv(newargc + 1))
113             break;
114
115         /*
116          * -1 below means "scan for trailing '\0' *and* count it",
117          * so that |uflen| covers even trailing '\0'.
118          */
119         uflen = WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1,
120                                     NULL, 0, NULL, NULL);
121
122         arg = malloc(udlen + uflen);
123         if (arg == NULL)
124             break;
125
126         if (udlen)
127             WideCharToMultiByte(CP_UTF8, 0, wstr, slash,
128                                 arg, udlen, NULL, NULL);
129
130         WideCharToMultiByte(CP_UTF8, 0, data.cFileName, -1,
131                             arg + udlen, uflen, NULL, NULL);
132
133         newargv[newargc++] = arg;
134     } while (FindNextFileW(h, &data));
135
136     CloseHandle(h);
137
138     return 1;
139 }
140
141 void win32_utf8argv(int *argc, char **argv[])
142 {
143     const WCHAR *wcmdline;
144     WCHAR *warg, *wend, *p;
145     int wlen, ulen, valid = 1;
146     char *arg;
147
148     if (GetEnvironmentVariableW(L"OPENSSL_WIN32_UTF8", NULL, 0) == 0)
149         return;
150
151     newargc = 0;
152     newargv = NULL;
153     if (!validate_argv(newargc))
154         return;
155
156     wcmdline = GetCommandLineW();
157     if (wcmdline == NULL) return;
158
159     /*
160      * make a copy of the command line, since we might have to modify it...
161      */
162     wlen = wcslen(wcmdline);
163     p = _alloca((wlen + 1) * sizeof(WCHAR));
164     wcscpy(p, wcmdline);
165
166     while (*p != L'\0') {
167         int in_quote = 0;
168
169         if (*p == L' ' || *p == L'\t') {
170             p++; /* skip over white spaces */
171             continue;
172         }
173
174         /*
175          * Note: because we may need to fiddle with the number of backslashes,
176          * the argument string is copied into itself.  This is safe because
177          * the number of characters will never expand.
178          */
179         warg = wend = p;
180         while (*p != L'\0'
181                && (in_quote || (*p != L' ' && *p != L'\t'))) {
182             switch (*p) {
183             case L'\\':
184                 /*
185                  * Microsoft documentation on how backslashes are treated
186                  * is:
187                  *
188                  * + Backslashes are interpreted literally, unless they
189                  *   immediately precede a double quotation mark.
190                  * + If an even number of backslashes is followed by a double
191                  *   quotation mark, one backslash is placed in the argv array
192                  *   for every pair of backslashes, and the double quotation
193                  *   mark is interpreted as a string delimiter.
194                  * + If an odd number of backslashes is followed by a double
195                  *   quotation mark, one backslash is placed in the argv array
196                  *   for every pair of backslashes, and the double quotation
197                  *   mark is "escaped" by the remaining backslash, causing a
198                  *   literal double quotation mark (") to be placed in argv.
199                  *
200                  * Ref: https://msdn.microsoft.com/en-us/library/17w5ykft.aspx
201                  *
202                  * Though referred page doesn't mention it, multiple qouble
203                  * quotes are also special. Pair of double quotes in quoted
204                  * string is counted as single double quote.
205                  */
206                 {
207                     const WCHAR *q = p;
208                     int i;
209
210                     while (*p == L'\\')
211                         p++;
212
213                     if (*p == L'"') {
214                         int i;
215
216                         for (i = (p - q) / 2; i > 0; i--)
217                             *wend++ = L'\\';
218
219                         /*
220                          * if odd amount of backslashes before the quote,
221                          * said quote is part of the argument, not a delimiter
222                          */
223                         if ((p - q) % 2 == 1)
224                             *wend++ = *p++;
225                     } else {
226                         for (i = p - q; i > 0; i--)
227                             *wend++ = L'\\';
228                     }
229                 }
230                 break;
231             case L'"':
232                 /*
233                  * Without the preceding backslash (or when preceded with an
234                  * even number of backslashes), the double quote is a simple
235                  * string delimiter and just slightly change the parsing state
236                  */
237                 if (in_quote && p[1] == L'"')
238                     *wend++ = *p++;
239                 else
240                     in_quote = !in_quote;
241                 p++;
242                 break;
243             default:
244                 /*
245                  * Any other non-delimiter character is just taken verbatim
246                  */
247                 *wend++ = *p++;
248             }
249         }
250
251         wlen = wend - warg;
252
253         if (wlen == 0 || !process_glob(warg, wlen)) {
254             if (!validate_argv(newargc + 1)) {
255                 valid = 0;
256                 break;
257             }
258
259             ulen = 0;
260             if (wlen > 0) {
261                 ulen = WideCharToMultiByte(CP_UTF8, 0, warg, wlen,
262                                            NULL, 0, NULL, NULL);
263                 if (ulen <= 0)
264                     continue;
265             }
266
267             arg = malloc(ulen + 1);
268             if (arg == NULL) {
269                 valid = 0;
270                 break;
271             }
272
273             if (wlen > 0)
274                 WideCharToMultiByte(CP_UTF8, 0, warg, wlen,
275                                     arg, ulen, NULL, NULL);
276             arg[ulen] = '\0';
277
278             newargv[newargc++] = arg;
279         }
280     }
281
282     if (valid) {
283         saved_cp = GetConsoleOutputCP();
284         SetConsoleOutputCP(CP_UTF8);
285
286         *argc = newargc;
287         *argv = newargv;
288
289         atexit(cleanup);
290     } else if (newargv != NULL) {
291         int i;
292
293         for (i = 0; i < newargc; i++)
294             free(newargv[i]);
295
296         free(newargv);
297
298         newargc = 0;
299         newargv = NULL;
300     }
301
302     return;
303 }
304 #else
305 void win32_utf8argv(int *argc, char **argv[])
306 {   return;   }
307 #endif