6cb40332401d72544d35416df5eeff58b53382cf
[flac.git] / src / share / win_utf8_io / win_utf8_io.c
1 /* libFLAC - Free Lossless Audio Codec library
2  * Copyright (C) 2013-2014  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 "share/win_utf8_io.h"
44
45 #define UTF8_BUFFER_SIZE 32768
46
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 */
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 */
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 */
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 = LoadLibrary("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                 flac_set_utf8_filenames(true);
146                 *argc = wargc;
147                 *argv = utf8argv;
148         } else {
149                 for (i=0; i<wargc; i++)
150                         free(utf8argv[i]);
151                 free(utf8argv);
152         }
153
154         return ret;
155 }
156
157 /* return number of characters in the UTF-8 string */
158 size_t strlen_utf8(const char *str)
159 {
160         size_t len;
161         len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0); /* includes terminating null */
162         if (len != 0)
163                 return len-1;
164         else
165                 return strlen(str);
166 }
167
168 /* get the console width in characters */
169 int win_get_console_width(void)
170 {
171         int width = 80;
172         CONSOLE_SCREEN_BUFFER_INFO csbi;
173         HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
174         if(hOut != INVALID_HANDLE_VALUE && hOut != NULL)
175                 if (GetConsoleScreenBufferInfo(hOut, &csbi) != 0)
176                         width = csbi.dwSize.X;
177         return width;
178 }
179
180 /* print functions */
181
182 static int wprint_console(FILE *stream, const wchar_t *text, size_t len)
183 {
184         DWORD out;
185         int ret;
186
187         do {
188                 if (stream == stdout) {
189                         HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
190                         if (hOut == INVALID_HANDLE_VALUE || hOut == NULL || GetFileType(hOut) != FILE_TYPE_CHAR)
191                                 break;
192                         if (WriteConsoleW(hOut, text, len, &out, NULL) == 0)
193                                 return -1;
194                         return out;
195                 }
196                 if (stream == stderr) {
197                         HANDLE hErr = GetStdHandle(STD_ERROR_HANDLE);
198                         if (hErr == INVALID_HANDLE_VALUE || hErr == NULL || GetFileType(hErr) != FILE_TYPE_CHAR)
199                                 break;
200                         if (WriteConsoleW(hErr, text, len, &out, NULL) == 0)
201                                 return -1;
202                         return out;
203                 }
204         } while(0);
205
206         ret = fputws(text, stream);
207         if (ret < 0)
208                 return ret;
209         return len;
210 }
211
212 int printf_utf8(const char *format, ...)
213 {
214         int ret;
215         va_list argptr;
216         va_start(argptr, format);
217
218         ret = vfprintf_utf8(stdout, format, argptr);
219
220         va_end(argptr);
221
222         return ret;
223 }
224
225 int fprintf_utf8(FILE *stream, const char *format, ...)
226 {
227         int ret;
228         va_list argptr;
229         va_start(argptr, format);
230
231         ret = vfprintf_utf8(stream, format, argptr);
232
233         va_end(argptr);
234
235         return ret;
236 }
237
238 int vfprintf_utf8(FILE *stream, const char *format, va_list argptr)
239 {
240         char *utmp = NULL;
241         wchar_t *wout = NULL;
242         int ret = -1;
243
244         do {
245                 if (!(utmp = (char *)malloc(UTF8_BUFFER_SIZE))) break;
246                 if ((ret = local_vsnprintf(utmp, UTF8_BUFFER_SIZE, format, argptr)) <= 0) break;
247                 if (!(wout = wchar_from_utf8(utmp))) {
248                         ret = -1;
249                         break;
250                 }
251                 ret = wprint_console(stream, wout, wcslen(wout));
252         } while(0);
253
254         free(utmp);
255         free(wout);
256
257         return ret;
258 }