win_utf8_io.c 9.21 KB
Newer Older
1
/* libFLAC - Free Lossless Audio Codec library
Erik de Castro Lopo's avatar
Erik de Castro Lopo committed
2
 * Copyright (C) 2013-2014  Xiph.Org Foundation
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 * - Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * - Neither the name of the Xiph.org Foundation nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
31

32
#ifdef HAVE_CONFIG_H
33
34
35
#  include <config.h>
#endif

36
37
38
39
40
41
42
#include <stdio.h>
#include <sys/stat.h>
#include <sys/utime.h>
#include <io.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
43
44
#include "share/win_utf8_io.h"

45
46
#define UTF8_BUFFER_SIZE 32768

47
static int local_vsnprintf(char *str, size_t size, const char *fmt, va_list va)
48
49
50
51
52
53
{
	int rc;

#if defined _MSC_VER
	if (size == 0)
		return 1024;
54
	rc = vsnprintf_s(str, size, _TRUNCATE, fmt, va);
55
56
57
	if (rc < 0)
		rc = size - 1;
#elif defined __MINGW32__
58
	rc = __mingw_vsnprintf(str, size, fmt, va);
59
#else
60
	rc = vsnprintf(str, size, fmt, va);
61
62
63
64
65
#endif

	return rc;
}

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
70
71
{
	char *utf8str;
	int len;

72
73
74
75
76
77
	if (!wstr)
		return NULL;
	if ((len = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL)) == 0)
		return NULL;
	if ((utf8str = (char *)malloc(len)) == NULL)
		return NULL;
78
79
80
81
82
83
84
85
86
	if (WideCharToMultiByte(CP_UTF8, 0, wstr, -1, utf8str, len, NULL, NULL) == 0) {
		free(utf8str);
		utf8str = NULL;
	}

	return utf8str;
}

/* convert UTF-8 back to WCHAR. Caller is responsible for freeing memory */
87
static wchar_t *wchar_from_utf8(const char *str)
88
89
90
91
{
	wchar_t *widestr;
	int len;

92
93
94
95
96
97
98
99
100
	if (!str)
		return NULL;
	if ((len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0)) == 0)
		return NULL;
	if ((widestr = (wchar_t *)malloc(len*sizeof(wchar_t))) == NULL)
		return NULL;
	if (MultiByteToWideChar(CP_UTF8, 0, str, -1, widestr, len) == 0) {
		free(widestr);
		widestr = NULL;
101
102
103
104
105
	}

	return widestr;
}

106
static void set_filename_utf8(int b);
107

108
109
110
/* retrieve WCHAR commandline, expand wildcards and convert everything to UTF-8 */
int get_utf8_argv(int *argc, char ***argv)
{
Erik de Castro Lopo's avatar
Erik de Castro Lopo committed
111
112
	typedef int (__cdecl *wgetmainargs_t)(int*, wchar_t***, wchar_t***, int, int*);
	wgetmainargs_t wgetmainargs;
113
114
115
116
117
118
119
120
	HMODULE handle;
	int wargc;
	wchar_t **wargv;
	wchar_t **wenv;
	char **utf8argv;
	int ret, i;

	if ((handle = LoadLibrary("msvcrt.dll")) == NULL) return 1;
121
122
123
124
	if ((wgetmainargs = (wgetmainargs_t)GetProcAddress(handle, "__wgetmainargs")) == NULL) {
		FreeLibrary(handle);
		return 1;
	}
125
	i = 0;
126
	/* when the 4th argument is 1,  __wgetmainargs expands wildcards but also erroneously converts \\?\c:\path\to\file.flac to \\file.flac */
127
128
129
130
131
132
133
134
	if (wgetmainargs(&wargc, &wargv, &wenv, 1, &i) != 0) {
		FreeLibrary(handle);
		return 1;
	}
	if ((utf8argv = (char **)calloc(wargc, sizeof(char*))) == NULL) {
		FreeLibrary(handle);
		return 1;
	}
135

136
	ret = 0;
137
138
139
140
141
142
143
	for (i=0; i<wargc; i++) {
		if ((utf8argv[i] = utf8_from_wchar(wargv[i])) == NULL) {
			ret = 1;
			break;
		}
	}

144
	FreeLibrary(handle); /* do not free it when wargv or wenv are still in use */
145

146
	if (ret == 0) {
147
		set_filename_utf8(1);
148
149
150
		*argc = wargc;
		*argv = utf8argv;
	} else {
151
152
		for (i=0; i<wargc; i++)
			free(utf8argv[i]);
153
154
155
156
157
158
		free(utf8argv);
	}

	return ret;
}

159
160
161
162
/* return number of characters in the UTF-8 string */
size_t strlen_utf8(const char *str)
{
	size_t len;
163
164
165
166
167
	len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0); /* includes terminating null */
	if (len != 0)
		return len-1;
	else
		return strlen(str);
168
169
170
}

/* get the console width in characters */
171
int win_get_console_width(void)
172
173
174
175
{
	int width = 80;
	CONSOLE_SCREEN_BUFFER_INFO csbi;
	HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
176
177
178
	if(hOut != INVALID_HANDLE_VALUE && hOut != NULL)
		if (GetConsoleScreenBufferInfo(hOut, &csbi) != 0)
			width = csbi.dwSize.X;
179
180
181
	return width;
}

182
183
/* print functions */

184
static int wprint_console(FILE *stream, const wchar_t *text, size_t len)
185
186
{
	DWORD out;
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
	int ret;

	do {
		if (stream == stdout) {
			HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
			if (hOut == INVALID_HANDLE_VALUE || hOut == NULL || GetFileType(hOut) != FILE_TYPE_CHAR)
				break;
			if (WriteConsoleW(hOut, text, len, &out, NULL) == 0)
				return -1;
			return out;
		}
		if (stream == stderr) {
			HANDLE hErr = GetStdHandle(STD_ERROR_HANDLE);
			if (hErr == INVALID_HANDLE_VALUE || hErr == NULL || GetFileType(hErr) != FILE_TYPE_CHAR)
				break;
			if (WriteConsoleW(hErr, text, len, &out, NULL) == 0)
				return -1;
			return out;
		}
	} while(0);

	ret = fputws(text, stream);
	if (ret < 0)
		return ret;
	return len;
212
213
}

214
215
int printf_utf8(const char *format, ...)
{
216
217
218
	int ret;
	va_list argptr;
	va_start(argptr, format);
219

220
221
222
	ret = vfprintf_utf8(stdout, format, argptr);

	va_end(argptr);
223
224
225
226
227
228

	return ret;
}

int fprintf_utf8(FILE *stream, const char *format, ...)
{
229
230
231
	int ret;
	va_list argptr;
	va_start(argptr, format);
232

233
234
235
	ret = vfprintf_utf8(stream, format, argptr);

	va_end(argptr);
236
237
238
239
240
241
242
243
244
245

	return ret;
}

int vfprintf_utf8(FILE *stream, const char *format, va_list argptr)
{
	char *utmp = NULL;
	wchar_t *wout = NULL;
	int ret = -1;

246
247
248
	do {
		if (!(utmp = (char *)malloc(UTF8_BUFFER_SIZE))) break;
		if ((ret = local_vsnprintf(utmp, UTF8_BUFFER_SIZE, format, argptr)) <= 0) break;
249
250
251
252
		if (!(wout = wchar_from_utf8(utmp))) {
			ret = -1;
			break;
		}
253
254
255
256
257
		ret = wprint_console(stream, wout, wcslen(wout));
	} while(0);

	free(utmp);
	free(wout);
258
259
260
261
262
263

	return ret;
}

/* file functions */

264
265
266
267
268
269
270
static int utf8_filename = 0;

static void set_filename_utf8(int b)
{
	utf8_filename = b ? 1: 0;
}

271
272
FILE *fopen_utf8(const char *filename, const char *mode)
{
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
	if (0 == utf8_filename) {
		return fopen(filename, mode);
	} else {
		wchar_t *wname = NULL;
		wchar_t *wmode = NULL;
		FILE *f = NULL;

		do {
			if (!(wname = wchar_from_utf8(filename))) break;
			if (!(wmode = wchar_from_utf8(mode))) break;
			f = _wfopen(wname, wmode);
		} while(0);

		free(wname);
		free(wmode);
288

289
290
		return f;
	}
291
292
}

293
int _stat64_utf8(const char *path, struct __stat64 *buffer)
294
{
295
296
297
298
299
	if (0 == utf8_filename) {
		return _stat64(path, buffer);
	} else {
		wchar_t *wpath;
		int ret;
300

301
302
303
		if (!(wpath = wchar_from_utf8(path))) return -1;
		ret = _wstat64(wpath, buffer);
		free(wpath);
304

305
306
		return ret;
	}
307
308
309
310
}

int chmod_utf8(const char *filename, int pmode)
{
311
312
313
314
315
	if (0 == utf8_filename) {
		return _chmod(filename, pmode);
	} else {
		wchar_t *wname;
		int ret;
316

317
318
319
		if (!(wname = wchar_from_utf8(filename))) return -1;
		ret = _wchmod(wname, pmode);
		free(wname);
320

321
322
		return ret;
	}
323
324
325
326
}

int utime_utf8(const char *filename, struct utimbuf *times)
{
327
328
	if (0 == utf8_filename) {
		return utime(filename, times);
Janne Hyvärinen's avatar
Janne Hyvärinen committed
329
	} else {
330
331
332
333
334
		wchar_t *wname;
		struct __utimbuf64 ut;
		int ret;

		if (!(wname = wchar_from_utf8(filename))) return -1;
Janne Hyvärinen's avatar
Janne Hyvärinen committed
335
336
		ut.actime = times->actime;
		ut.modtime = times->modtime;
337
338
		ret = _wutime64(wname, &ut);
		free(wname);
339

340
341
		return ret;
	}
342
343
344
345
}

int unlink_utf8(const char *filename)
{
346
347
348
349
350
	if (0 == utf8_filename) {
		return _unlink(filename);
	} else {
		wchar_t *wname;
		int ret;
351

352
353
354
		if (!(wname = wchar_from_utf8(filename))) return -1;
		ret = _wunlink(wname);
		free(wname);
355

356
357
		return ret;
	}
358
359
360
361
}

int rename_utf8(const char *oldname, const char *newname)
{
362
363
364
365
366
367
	if (0 == utf8_filename) {
		return rename(oldname, newname);
	} else {
		wchar_t *wold = NULL;
		wchar_t *wnew = NULL;
		int ret = -1;
368

369
370
371
372
373
		do {
			if (!(wold = wchar_from_utf8(oldname))) break;
			if (!(wnew = wchar_from_utf8(newname))) break;
			ret = _wrename(wold, wnew);
		} while(0);
374

375
376
377
378
379
		free(wold);
		free(wnew);

		return ret;
	}
380
}
381
382
383

HANDLE WINAPI CreateFile_utf8(const char *lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
384
385
386
387
388
	if (0 == utf8_filename) {
		return CreateFileA(lpFileName, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
	} else {
		wchar_t *wname;
		HANDLE handle = INVALID_HANDLE_VALUE;
389

390
391
392
393
		if ((wname = wchar_from_utf8(lpFileName)) != NULL) {
			handle = CreateFileW(wname, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
			free(wname);
		}
394

395
396
		return handle;
	}
397
}