4e507a035dec242a7fcda32fc6bee8f36b3aee78
[flac.git] / src / share / win_utf8_io / win_utf8_io.c
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2013  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 <stdio.h>
37 #include <sys/stat.h>
38 #include <sys/utime.h>
39 #include <io.h>
40 #include <stdlib.h>
41 #include <string.h>
42 #include <stdarg.h>
43 #include <windows.h> /* for WideCharToMultiByte and MultiByteToWideChar */
44
45 #include "share/compat.h"
46 #include "share/win_utf8_io.h"
47
48 static UINT win_utf8_io_codepage = CP_ACP;
49
50 /* convert WCHAR stored Unicode string to UTF-8. Caller is responsible for freeing memory */
51 static
52 char *utf8_from_wchar(const wchar_t *wstr)
53 {
54         char *utf8str;
55         int len;
56
57         if (!wstr) return NULL;
58         if ((len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL)) == 0) return NULL;
59         if ((utf8str = (char *)malloc(++len)) == NULL) return NULL;
60         if (WideCharToMultiByte(CP_UTF8, 0, wstr, -1, utf8str, len, NULL, NULL) == 0) {
61                 free(utf8str);
62                 utf8str = NULL;
63         }
64
65         return utf8str;
66 }
67
68 /* convert UTF-8 back to WCHAR. Caller is responsible for freeing memory */
69 static
70 wchar_t *wchar_from_utf8(const char *str)
71 {
72         wchar_t *widestr;
73         int len;
74
75         if (!str) return NULL;
76         len=(int)strlen(str)+1;
77         if ((widestr = (wchar_t *)malloc(len*sizeof(wchar_t))) != NULL) {
78                 if (MultiByteToWideChar(win_utf8_io_codepage, 0, str, len, widestr, len) == 0) {
79                         if (MultiByteToWideChar(CP_ACP, 0, str, len, widestr, len) == 0) { /* try conversion from Ansi in case the initial UTF-8 conversion had failed */
80                                 free(widestr);
81                                 widestr = NULL;
82                         }
83                 }
84         }
85
86         return widestr;
87 }
88
89 /* retrieve WCHAR commandline, expand wildcards and convert everything to UTF-8 */
90 int get_utf8_argv(int *argc, char ***argv)
91 {
92         typedef int (__cdecl *__wgetmainargs_)(int*, wchar_t***, wchar_t***, int, int*);
93         __wgetmainargs_ __wgetmainargs;
94         HMODULE handle;
95         int wargc;
96         wchar_t **wargv;
97         wchar_t **wenv;
98         char **utf8argv;
99         int ret, i;
100
101         if ((handle = LoadLibrary("msvcrt.dll")) == NULL) return 1;
102         if ((__wgetmainargs = (__wgetmainargs_)GetProcAddress(handle, "__wgetmainargs")) == NULL) return 1;
103         i = 0;
104         if (__wgetmainargs(&wargc, &wargv, &wenv, 1, &i) != 0) return 1;
105         if ((utf8argv = (char **)malloc(wargc*sizeof(char*))) == NULL) return 1;
106         ret = 0;
107
108         for (i=0; i<wargc; i++) {
109                 if ((utf8argv[i] = utf8_from_wchar(wargv[i])) == NULL) {
110                         ret = 1;
111                         break;
112                 }
113                 if (ret != 0) break;
114         }
115
116         FreeLibrary(handle);
117
118         if (ret == 0) {
119                 win_utf8_io_codepage = CP_UTF8;
120                 *argc = wargc;
121                 *argv = utf8argv;
122         } else {
123                 free(utf8argv);
124         }
125
126         return ret;
127 }
128
129 /* return number of characters in the UTF-8 string */
130 size_t strlen_utf8(const char *str)
131 {
132         size_t len;
133         if ((len = MultiByteToWideChar(win_utf8_io_codepage, 0, str, -1, NULL, 0)) == 0)
134                 len = strlen(str);
135         return len;
136 }
137
138 /* get the console width in characters */
139 int win_get_console_width(void)
140 {
141         int width = 80;
142         CONSOLE_SCREEN_BUFFER_INFO csbi;
143         HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
144         if (GetConsoleScreenBufferInfo(hOut, &csbi) != 0) width = csbi.dwSize.X;
145         return width;
146 }
147
148 /* print functions */
149
150 int print_console(FILE *stream, const wchar_t *text, uint32_t len)
151 {
152         static HANDLE hOut;
153         static HANDLE hErr;
154         DWORD out;
155         hOut = GetStdHandle(STD_OUTPUT_HANDLE);
156         hErr = GetStdHandle(STD_ERROR_HANDLE);
157         if (stream == stdout && hOut != INVALID_HANDLE_VALUE && GetFileType(hOut) == FILE_TYPE_CHAR) {
158                 if (WriteConsoleW(hOut, text, len, &out, NULL) == 0) return -1;
159                 return out;
160         } else if (stream == stderr && hErr != INVALID_HANDLE_VALUE && GetFileType(hErr) == FILE_TYPE_CHAR) {
161                 if (WriteConsoleW(hErr, text, len, &out, NULL) == 0) return -1;
162                 return out;
163         } else {
164                 int ret = fwprintf(stream, L"%s", text);
165                 if (ret < 0) return ret;
166                 return len;
167         }
168 }
169
170 int printf_utf8(const char *format, ...)
171 {
172         char *utmp = NULL;
173         wchar_t *wout = NULL;
174         int ret = -1;
175
176         while (1) {
177                 va_list argptr;
178                 if (!(utmp = (char *)malloc(32768*sizeof(char)))) break;
179                 va_start(argptr, format);
180                 ret = vsprintf(utmp, format, argptr);
181                 va_end(argptr);
182                 if (ret < 0) break;
183                 if (!(wout = wchar_from_utf8(utmp))) {
184                         ret = -1;
185                         break;
186                 }
187                 ret = print_console(stdout, wout, wcslen(wout));
188                 break;
189         }
190         if (utmp) free(utmp);
191         if (wout) free(wout);
192
193         return ret;
194 }
195
196 int fprintf_utf8(FILE *stream, const char *format, ...)
197 {
198         char *utmp = NULL;
199         wchar_t *wout = NULL;
200         int ret = -1;
201
202         while (1) {
203                 va_list argptr;
204                 if (!(utmp = (char *)malloc(32768*sizeof(char)))) break;
205                 va_start(argptr, format);
206                 ret = vsprintf(utmp, format, argptr);
207                 va_end(argptr);
208                 if (ret < 0) break;
209                 if (!(wout = wchar_from_utf8(utmp))) {
210                         ret = -1;
211                         break;
212                 }
213                 ret = print_console(stream, wout, wcslen(wout));
214                 break;
215         }
216         if (utmp) free(utmp);
217         if (wout) free(wout);
218
219         return ret;
220 }
221
222 int vfprintf_utf8(FILE *stream, const char *format, va_list argptr)
223 {
224         char *utmp = NULL;
225         wchar_t *wout = NULL;
226         int ret = -1;
227
228         while (1) {
229                 if (!(utmp = (char *)malloc(32768*sizeof(char)))) break;
230                 if ((ret = vsprintf(utmp, format, argptr)) < 0) break;
231                 if (!(wout = wchar_from_utf8(utmp))) {
232                         ret = -1;
233                         break;
234                 }
235                 ret = print_console(stream, wout, wcslen(wout));
236                 break;
237         }
238         if (utmp) free(utmp);
239         if (wout) free(wout);
240
241         return ret;
242 }
243
244 /* file functions */
245
246 FILE *fopen_utf8(const char *filename, const char *mode)
247 {
248         wchar_t *wname = NULL;
249         wchar_t *wmode = NULL;
250         FILE *f = NULL;
251
252         while (1) {
253                 if (!(wname = wchar_from_utf8(filename))) break;
254                 if (!(wmode = wchar_from_utf8(mode))) break;
255                 f = _wfopen(wname, wmode);
256                 break;
257         }
258         if (wname) free(wname);
259         if (wmode) free(wmode);
260
261         return f;
262 }
263
264 int _stat64_utf8(const char *path, struct __stat64 *buffer)
265 {
266         wchar_t *wpath;
267         int ret;
268
269         if (!(wpath = wchar_from_utf8(path))) return -1;
270         ret = _wstat64(wpath, buffer);
271         free(wpath);
272
273         return ret;
274 }
275
276 int chmod_utf8(const char *filename, int pmode)
277 {
278         wchar_t *wname;
279         int ret;
280
281         if (!(wname = wchar_from_utf8(filename))) return -1;
282         ret = _wchmod(wname, pmode);
283         free(wname);
284
285         return ret;
286 }
287
288 int utime_utf8(const char *filename, struct utimbuf *times)
289 {
290         wchar_t *wname;
291         struct __utimbuf64 ut;
292         int ret;
293
294         if (sizeof(*times) == sizeof(ut)) {
295                 memcpy(&ut, times, sizeof(ut));
296         } else {
297                 ut.actime = times->actime;
298                 ut.modtime = times->modtime;
299         }
300
301         if (!(wname = wchar_from_utf8(filename))) return -1;
302         ret = _wutime64(wname, &ut);
303         free(wname);
304
305         return ret;
306 }
307
308 int unlink_utf8(const char *filename)
309 {
310         wchar_t *wname;
311         int ret;
312
313         if (!(wname = wchar_from_utf8(filename))) return -1;
314         ret = _wunlink(wname);
315         free(wname);
316
317         return ret;
318 }
319
320 int rename_utf8(const char *oldname, const char *newname)
321 {
322         wchar_t *wold = NULL;
323         wchar_t *wnew = NULL;
324         int ret = -1;
325
326         while (1) {
327                 if (!(wold = wchar_from_utf8(oldname))) break;
328                 if (!(wnew = wchar_from_utf8(newname))) break;
329                 ret = _wrename(wold, wnew);
330                 break;
331         }
332         if (wold) free(wold);
333         if (wnew) free(wnew);
334
335         return ret;
336 }
337
338 HANDLE WINAPI CreateFile_utf8(const char *lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
339 {
340         wchar_t *wname;
341         HANDLE handle = INVALID_HANDLE_VALUE;
342
343         if ((wname = wchar_from_utf8(lpFileName)) != NULL) {
344                 handle = CreateFileW(wname, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
345                 free(wname);
346         }
347
348         return handle;
349 }