1 /* libFLAC - Free Lossless Audio Codec library
2 * Copyright (C) 2013-2022 Xiph.Org Foundation
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * - Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * - Neither the name of the Xiph.org Foundation nor the names of its
16 * contributors may be used to endorse or promote products derived from
17 * this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifdef HAVE_CONFIG_H
33 # include <config.h>
34 #endif
35
36 #include <io.h>
37 #include <windows.h>
38 #include "share/win_utf8_io.h"
39
40 #define UTF8_BUFFER_SIZE 32768
41
42 #if !defined(WINAPI_FAMILY_PARTITION)
43 #define WINAPI_FAMILY_PARTITION(x) x
44 #define WINAPI_PARTITION_DESKTOP 1
45 #endif
46
local_vsnprintf(char * str,size_t size,const char * fmt,va_list va)47 static int local_vsnprintf(char *str, size_t size, const char *fmt, va_list va)
48 {
49 int rc;
50
51 #if defined _MSC_VER
52 if (size == 0)
53 return 1024;
54 rc = vsnprintf_s(str, size, _TRUNCATE, fmt, va);
55 if (rc < 0)
56 rc = size - 1;
57 #elif defined __MINGW32__
58 rc = __mingw_vsnprintf(str, size, fmt, va);
59 #else
60 rc = vsnprintf(str, size, fmt, va);
61 #endif
62
63 return rc;
64 }
65
66 /* convert WCHAR stored Unicode string to UTF-8. Caller is responsible for freeing memory */
utf8_from_wchar(const wchar_t * wstr)67 static char *utf8_from_wchar(const wchar_t *wstr)
68 {
69 char *utf8str;
70 int len;
71
72 if (!wstr)
73 return NULL;
74 if ((len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL)) == 0)
75 return NULL;
76 if ((utf8str = (char *)malloc(len)) == NULL)
77 return NULL;
78 if (WideCharToMultiByte(CP_UTF8, 0, wstr, -1, utf8str, len, NULL, NULL) == 0) {
79 free(utf8str);
80 utf8str = NULL;
81 }
82
83 return utf8str;
84 }
85
86 /* convert UTF-8 back to WCHAR. Caller is responsible for freeing memory */
wchar_from_utf8(const char * str)87 static wchar_t *wchar_from_utf8(const char *str)
88 {
89 wchar_t *widestr;
90 int len;
91
92 if (!str)
93 return NULL;
94 if ((len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0)) == 0)
95 return NULL;
96 if ((widestr = (wchar_t *)malloc(len*sizeof(wchar_t))) == NULL)
97 return NULL;
98 if (MultiByteToWideChar(CP_UTF8, 0, str, -1, widestr, len) == 0) {
99 free(widestr);
100 widestr = NULL;
101 }
102
103 return widestr;
104 }
105
106 /* retrieve WCHAR commandline, expand wildcards and convert everything to UTF-8 */
get_utf8_argv(int * argc,char *** argv)107 int get_utf8_argv(int *argc, char ***argv)
108 {
109 typedef int (__cdecl *wgetmainargs_t)(int*, wchar_t***, wchar_t***, int, int*);
110 wgetmainargs_t wgetmainargs;
111 HMODULE handle;
112 int wargc;
113 wchar_t **wargv;
114 wchar_t **wenv;
115 char **utf8argv;
116 int ret, i;
117
118 if ((handle = LoadLibraryW(L"msvcrt.dll")) == NULL) return 1;
119 if ((wgetmainargs = (wgetmainargs_t)GetProcAddress(handle, "__wgetmainargs")) == NULL) {
120 FreeLibrary(handle);
121 return 1;
122 }
123 i = 0;
124 /* when the 4th argument is 1, __wgetmainargs expands wildcards but also erroneously converts \\?\c:\path\to\file.flac to \\file.flac */
125 if (wgetmainargs(&wargc, &wargv, &wenv, 1, &i) != 0) {
126 FreeLibrary(handle);
127 return 1;
128 }
129 if ((utf8argv = (char **)calloc(wargc, sizeof(char*))) == NULL) {
130 FreeLibrary(handle);
131 return 1;
132 }
133
134 ret = 0;
135 for (i=0; i<wargc; i++) {
136 if ((utf8argv[i] = utf8_from_wchar(wargv[i])) == NULL) {
137 ret = 1;
138 break;
139 }
140 }
141
142 FreeLibrary(handle); /* do not free it when wargv or wenv are still in use */
143
144 if (ret == 0) {
145 *argc = wargc;
146 *argv = utf8argv;
147 } else {
148 for (i=0; i<wargc; i++)
149 free(utf8argv[i]);
150 free(utf8argv);
151 }
152
153 return ret;
154 }
155
156 /* similar to CreateFileW but accepts UTF-8 encoded lpFileName */
CreateFile_utf8(const char * lpFileName,DWORD dwDesiredAccess,DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpSecurityAttributes,DWORD dwCreationDisposition,DWORD dwFlagsAndAttributes,HANDLE hTemplateFile)157 HANDLE WINAPI CreateFile_utf8(const char *lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
158 {
159 wchar_t *wname;
160 HANDLE handle = INVALID_HANDLE_VALUE;
161
162 if ((wname = wchar_from_utf8(lpFileName)) != NULL) {
163 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
164 handle = CreateFileW(wname, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
165 #else // !WINAPI_PARTITION_DESKTOP
166 CREATEFILE2_EXTENDED_PARAMETERS params;
167 params.dwSize = sizeof(params);
168 params.dwFileAttributes = dwFlagsAndAttributes & 0xFFFF;
169 params.dwFileFlags = dwFlagsAndAttributes & 0xFFF00000;
170 params.dwSecurityQosFlags = dwFlagsAndAttributes & 0x000F0000;
171 params.lpSecurityAttributes = lpSecurityAttributes;
172 params.hTemplateFile = hTemplateFile;
173 handle = CreateFile2(wname, dwDesiredAccess, dwShareMode, dwCreationDisposition, ¶ms);
174 #endif // !WINAPI_PARTITION_DESKTOP
175 free(wname);
176 }
177
178 return handle;
179 }
180
181 /* return number of characters in the UTF-8 string */
strlen_utf8(const char * str)182 size_t strlen_utf8(const char *str)
183 {
184 size_t len;
185 len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0); /* includes terminating null */
186 if (len != 0)
187 return len-1;
188 else
189 return strlen(str);
190 }
191
192 /* get the console width in characters */
win_get_console_width(void)193 int win_get_console_width(void)
194 {
195 int width = 80;
196 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
197 CONSOLE_SCREEN_BUFFER_INFO csbi;
198 HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
199 if(hOut != INVALID_HANDLE_VALUE && hOut != NULL)
200 if (GetConsoleScreenBufferInfo(hOut, &csbi) != 0)
201 width = csbi.dwSize.X;
202 #endif // WINAPI_PARTITION_DESKTOP
203 return width;
204 }
205
206 /* print functions */
207
208 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
wprint_console(FILE * stream,const wchar_t * text,size_t len)209 static int wprint_console(FILE *stream, const wchar_t *text, size_t len)
210 {
211 DWORD out;
212 int ret;
213
214 do {
215 if (stream == stdout) {
216 HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
217 if (hOut == INVALID_HANDLE_VALUE || hOut == NULL || GetFileType(hOut) != FILE_TYPE_CHAR)
218 break;
219 if (WriteConsoleW(hOut, text, len, &out, NULL) == 0)
220 return -1;
221 return out;
222 }
223 if (stream == stderr) {
224 HANDLE hErr = GetStdHandle(STD_ERROR_HANDLE);
225 if (hErr == INVALID_HANDLE_VALUE || hErr == NULL || GetFileType(hErr) != FILE_TYPE_CHAR)
226 break;
227 if (WriteConsoleW(hErr, text, len, &out, NULL) == 0)
228 return -1;
229 return out;
230 }
231 } while(0);
232
233 ret = fputws(text, stream);
234 if (ret < 0)
235 return ret;
236 return len;
237 }
238 #endif // WINAPI_PARTITION_DESKTOP
239
printf_utf8(const char * format,...)240 int printf_utf8(const char *format, ...)
241 {
242 int ret;
243 va_list argptr;
244 va_start(argptr, format);
245
246 ret = vfprintf_utf8(stdout, format, argptr);
247
248 va_end(argptr);
249
250 return ret;
251 }
252
fprintf_utf8(FILE * stream,const char * format,...)253 int fprintf_utf8(FILE *stream, const char *format, ...)
254 {
255 int ret;
256 va_list argptr;
257 va_start(argptr, format);
258
259 ret = vfprintf_utf8(stream, format, argptr);
260
261 va_end(argptr);
262
263 return ret;
264 }
265
vfprintf_utf8(FILE * stream,const char * format,va_list argptr)266 int vfprintf_utf8(FILE *stream, const char *format, va_list argptr)
267 {
268 char *utmp = NULL;
269 wchar_t *wout = NULL;
270 int ret = -1;
271
272 do {
273 if (!(utmp = (char *)malloc(UTF8_BUFFER_SIZE))) break;
274 if ((ret = local_vsnprintf(utmp, UTF8_BUFFER_SIZE, format, argptr)) <= 0) break;
275 if (!(wout = wchar_from_utf8(utmp))) {
276 ret = -1;
277 break;
278 }
279 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
280 ret = wprint_console(stream, wout, wcslen(wout));
281 #else // !WINAPI_PARTITION_DESKTOP
282 OutputDebugStringW(wout);
283 ret = 0;
284 #endif // !WINAPI_PARTITION_DESKTOP
285 } while(0);
286
287 free(utmp);
288 free(wout);
289
290 return ret;
291 }
292
293 /* file functions */
294
fopen_utf8(const char * filename,const char * mode)295 FILE* fopen_utf8(const char *filename, const char *mode)
296 {
297 wchar_t *wname = NULL;
298 wchar_t *wmode = NULL;
299 FILE *f = NULL;
300
301 do {
302 if (!(wname = wchar_from_utf8(filename))) break;
303 if (!(wmode = wchar_from_utf8(mode))) break;
304 f = _wfopen(wname, wmode);
305 } while(0);
306
307 free(wname);
308 free(wmode);
309
310 return f;
311 }
312
stat64_utf8(const char * path,struct __stat64 * buffer)313 int stat64_utf8(const char *path, struct __stat64 *buffer)
314 {
315 wchar_t *wpath;
316 int ret;
317
318 if (!(wpath = wchar_from_utf8(path))) return -1;
319 ret = _wstat64(wpath, buffer);
320 free(wpath);
321
322 return ret;
323 }
324
chmod_utf8(const char * filename,int pmode)325 int chmod_utf8(const char *filename, int pmode)
326 {
327 wchar_t *wname;
328 int ret;
329
330 if (!(wname = wchar_from_utf8(filename))) return -1;
331 ret = _wchmod(wname, pmode);
332 free(wname);
333
334 return ret;
335 }
336
utime_utf8(const char * filename,struct utimbuf * times)337 int utime_utf8(const char *filename, struct utimbuf *times)
338 {
339 wchar_t *wname;
340 struct __utimbuf64 ut;
341 int ret;
342
343 if (!(wname = wchar_from_utf8(filename))) return -1;
344 ut.actime = times->actime;
345 ut.modtime = times->modtime;
346 ret = _wutime64(wname, &ut);
347 free(wname);
348
349 return ret;
350 }
351
unlink_utf8(const char * filename)352 int unlink_utf8(const char *filename)
353 {
354 wchar_t *wname;
355 int ret;
356
357 if (!(wname = wchar_from_utf8(filename))) return -1;
358 ret = _wunlink(wname);
359 free(wname);
360
361 return ret;
362 }
363
rename_utf8(const char * oldname,const char * newname)364 int rename_utf8(const char *oldname, const char *newname)
365 {
366 wchar_t *wold = NULL;
367 wchar_t *wnew = NULL;
368 int ret = -1;
369
370 do {
371 if (!(wold = wchar_from_utf8(oldname))) break;
372 if (!(wnew = wchar_from_utf8(newname))) break;
373 ret = _wrename(wold, wnew);
374 } while(0);
375
376 free(wold);
377 free(wnew);
378
379 return ret;
380 }
381