?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msdasql/tests: Test for ITransaction* interfaces on a session.
[wine.git] / dlls / msvcrt / file.c
blob2b0395d753523dcda32be1b304e279543e0417c4
1 /*
2 * msvcrt.dll file functions
3 *
4 * Copyright 1996,1998 Marcus Meissner
5 * Copyright 1996 Jukka Iivonen
6 * Copyright 1997,2000 Uwe Bonnes
7 * Copyright 2000 Jon Griffiths
8 * Copyright 2004 Eric Pouech
9 * Copyright 2004 Juan Lang
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 *
25 */
26
27 #include <direct.h>
28 #include <fcntl.h>
29 #include <io.h>
30 #include <share.h>
31 #include <stdarg.h>
32 #include <sys/locking.h>
33 #include <sys/types.h>
34 #include <sys/utime.h>
35 #include <time.h>
36 #include <limits.h>
37
38 #include "windef.h"
39 #include "winbase.h"
40 #include "wincon.h"
41 #include "winternl.h"
42 #include "winnls.h"
43 #include "msvcrt.h"
44 #include "mtdll.h"
45
46 #include "wine/debug.h"
47
48 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
49
50 #undef _fstat
51 #undef _fstati64
52 #undef _stat
53 #undef _stati64
54 #undef _wstat
55 #undef _wstati64
56 #undef _fstat32
57 #undef _fstat32i64
58 #undef _stat32i64
59 #undef _stat32
60 #undef _wstat32
61 #undef _wstat32i64
62 #undef _fstat64i32
63 #undef _fstat64
64 #undef _stat64
65 #undef _stat64i32
66 #undef _wstat64i32
67 #undef _wstat64
68
69 /* for stat mode, permissions apply to all,owner and group */
70 #define ALL_S_IREAD (_S_IREAD | (_S_IREAD >> 3) | (_S_IREAD >> 6))
71 #define ALL_S_IWRITE (_S_IWRITE | (_S_IWRITE >> 3) | (_S_IWRITE >> 6))
72 #define ALL_S_IEXEC (_S_IEXEC | (_S_IEXEC >> 3) | (_S_IEXEC >> 6))
73
74 /* _access() bit flags FIXME: incomplete */
75 #define MSVCRT_W_OK 0x02
76 #define MSVCRT_R_OK 0x04
77
78 /* values for wxflag in file descriptor */
79 #define WX_OPEN 0x01
80 #define WX_ATEOF 0x02
81 #define WX_READNL 0x04 /* read started with \n */
82 #define WX_PIPE 0x08
83 #define WX_DONTINHERIT 0x10
84 #define WX_APPEND 0x20
85 #define WX_TTY 0x40
86 #define WX_TEXT 0x80
87
88 /* values for exflag - it's used differently in msvcr90.dll*/
89 #define EF_UTF8 0x01
90 #define EF_UTF16 0x02
91 #define EF_CRIT_INIT 0x04
92 #define EF_UNK_UNICODE 0x08
93
94 static char utf8_bom[3] = { 0xef, 0xbb, 0xbf };
95 static char utf16_bom[2] = { 0xff, 0xfe };
96
97 /* FIXME: this should be allocated dynamically */
98 #define MSVCRT_MAX_FILES 2048
99 #define MSVCRT_FD_BLOCK_SIZE 32
100
101 #define MSVCRT_INTERNAL_BUFSIZ 4096
102
103 /* ioinfo structure size is different in msvcrXX.dll's */
104 typedef struct {
105 HANDLE handle;
106 unsigned char wxflag;
107 char lookahead[3];
108 int exflag;
109 CRITICAL_SECTION crit;
110 #if _MSVCR_VER >= 80
111 char textmode : 7;
112 char unicode : 1;
113 char pipech2[2];
114 __int64 startpos;
115 BOOL utf8translations;
116 #endif
117 #if _MSVCR_VER >= 90
118 char dbcsBuffer;
119 BOOL dbcsBufferUsed;
120 #endif
121 } ioinfo;
122
123 /*********************************************************************
124 * __pioinfo (MSVCRT.@)
125 * array of pointers to ioinfo arrays [32]
126 */
127 ioinfo * MSVCRT___pioinfo[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE] = { 0 };
128
129 /*********************************************************************
130 * __badioinfo (MSVCRT.@)
131 */
132 ioinfo MSVCRT___badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };
133
134 typedef struct {
135 FILE file;
136 CRITICAL_SECTION crit;
137 } file_crit;
138
139 FILE MSVCRT__iob[_IOB_ENTRIES] = { { 0 } };
140 static file_crit* MSVCRT_fstream[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE];
141 static int MSVCRT_max_streams = 512, MSVCRT_stream_idx;
142
143 /* INTERNAL: process umask */
144 static int MSVCRT_umask = 0;
145
146 /* INTERNAL: static data for tmpnam and _wtmpname functions */
147 static int tmpnam_unique;
148 static int tmpnam_s_unique;
149
150 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
151 static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
152 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
153 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
154
155 #define TOUL(x) (ULONGLONG)(x)
156 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
157 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
158 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
159 static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
160
161 /* This critical section protects the MSVCRT_fstreams table
162 * and MSVCRT_stream_idx from race conditions. It also
163 * protects fd critical sections creation code.
164 */
165 static CRITICAL_SECTION MSVCRT_file_cs;
166 static CRITICAL_SECTION_DEBUG MSVCRT_file_cs_debug =
167 {
168 0, 0, &MSVCRT_file_cs,
169 { &MSVCRT_file_cs_debug.ProcessLocksList, &MSVCRT_file_cs_debug.ProcessLocksList },
170 0, 0, { (DWORD_PTR)(__FILE__ ": MSVCRT_file_cs") }
171 };
172 static CRITICAL_SECTION MSVCRT_file_cs = { &MSVCRT_file_cs_debug, -1, 0, 0, 0, 0 };
173 #define LOCK_FILES() do { EnterCriticalSection(&MSVCRT_file_cs); } while (0)
174 #define UNLOCK_FILES() do { LeaveCriticalSection(&MSVCRT_file_cs); } while (0)
175
176 static void msvcrt_stat64_to_stat(const struct _stat64 *buf64, struct _stat *buf)
177 {
178 buf->st_dev = buf64->st_dev;
179 buf->st_ino = buf64->st_ino;
180 buf->st_mode = buf64->st_mode;
181 buf->st_nlink = buf64->st_nlink;
182 buf->st_uid = buf64->st_uid;
183 buf->st_gid = buf64->st_gid;
184 buf->st_rdev = buf64->st_rdev;
185 buf->st_size = buf64->st_size;
186 buf->st_atime = buf64->st_atime;
187 buf->st_mtime = buf64->st_mtime;
188 buf->st_ctime = buf64->st_ctime;
189 }
190
191 static void msvcrt_stat64_to_stati64(const struct _stat64 *buf64, struct _stati64 *buf)
192 {
193 buf->st_dev = buf64->st_dev;
194 buf->st_ino = buf64->st_ino;
195 buf->st_mode = buf64->st_mode;
196 buf->st_nlink = buf64->st_nlink;
197 buf->st_uid = buf64->st_uid;
198 buf->st_gid = buf64->st_gid;
199 buf->st_rdev = buf64->st_rdev;
200 buf->st_size = buf64->st_size;
201 buf->st_atime = buf64->st_atime;
202 buf->st_mtime = buf64->st_mtime;
203 buf->st_ctime = buf64->st_ctime;
204 }
205
206 static void msvcrt_stat64_to_stat32(const struct _stat64 *buf64, struct _stat32 *buf)
207 {
208 buf->st_dev = buf64->st_dev;
209 buf->st_ino = buf64->st_ino;
210 buf->st_mode = buf64->st_mode;
211 buf->st_nlink = buf64->st_nlink;
212 buf->st_uid = buf64->st_uid;
213 buf->st_gid = buf64->st_gid;
214 buf->st_rdev = buf64->st_rdev;
215 buf->st_size = buf64->st_size;
216 buf->st_atime = buf64->st_atime;
217 buf->st_mtime = buf64->st_mtime;
218 buf->st_ctime = buf64->st_ctime;
219 }
220
221 static void msvcrt_stat64_to_stat64i32(const struct _stat64 *buf64, struct _stat64i32 *buf)
222 {
223 buf->st_dev = buf64->st_dev;
224 buf->st_ino = buf64->st_ino;
225 buf->st_mode = buf64->st_mode;
226 buf->st_nlink = buf64->st_nlink;
227 buf->st_uid = buf64->st_uid;
228 buf->st_gid = buf64->st_gid;
229 buf->st_rdev = buf64->st_rdev;
230 buf->st_size = buf64->st_size;
231 buf->st_atime = buf64->st_atime;
232 buf->st_mtime = buf64->st_mtime;
233 buf->st_ctime = buf64->st_ctime;
234 }
235
236 static void msvcrt_stat64_to_stat32i64(const struct _stat64 *buf64, struct _stat32i64 *buf)
237 {
238 buf->st_dev = buf64->st_dev;
239 buf->st_ino = buf64->st_ino;
240 buf->st_mode = buf64->st_mode;
241 buf->st_nlink = buf64->st_nlink;
242 buf->st_uid = buf64->st_uid;
243 buf->st_gid = buf64->st_gid;
244 buf->st_rdev = buf64->st_rdev;
245 buf->st_size = buf64->st_size;
246 buf->st_atime = buf64->st_atime;
247 buf->st_mtime = buf64->st_mtime;
248 buf->st_ctime = buf64->st_ctime;
249 }
250
251 static void time_to_filetime( __time64_t time, FILETIME *ft )
252 {
253 /* 1601 to 1970 is 369 years plus 89 leap days */
254 static const __int64 secs_1601_to_1970 = ((369 * 365 + 89) * (__int64)86400);
255
256 __int64 ticks = (time + secs_1601_to_1970) * 10000000;
257 ft->dwHighDateTime = ticks >> 32;
258 ft->dwLowDateTime = ticks;
259 }
260
261 static inline ioinfo* get_ioinfo_nolock(int fd)
262 {
263 ioinfo *ret = NULL;
264 if(fd>=0 && fd<MSVCRT_MAX_FILES)
265 ret = MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE];
266 if(!ret)
267 return &MSVCRT___badioinfo;
268
269 return ret + (fd%MSVCRT_FD_BLOCK_SIZE);
270 }
271
272 static inline void init_ioinfo_cs(ioinfo *info)
273 {
274 if(!(info->exflag & EF_CRIT_INIT)) {
275 LOCK_FILES();
276 if(!(info->exflag & EF_CRIT_INIT)) {
277 InitializeCriticalSection(&info->crit);
278 info->exflag |= EF_CRIT_INIT;
279 }
280 UNLOCK_FILES();
281 }
282 }
283
284 static inline ioinfo* get_ioinfo(int fd)
285 {
286 ioinfo *ret = get_ioinfo_nolock(fd);
287 if(ret == &MSVCRT___badioinfo)
288 return ret;
289 init_ioinfo_cs(ret);
290 EnterCriticalSection(&ret->crit);
291 return ret;
292 }
293
294 static inline BOOL alloc_pioinfo_block(int fd)
295 {
296 ioinfo *block;
297 int i;
298
299 if(fd<0 || fd>=MSVCRT_MAX_FILES)
300 {
301 *_errno() = ENFILE;
302 return FALSE;
303 }
304
305 block = calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(ioinfo));
306 if(!block)
307 {
308 WARN(":out of memory!\n");
309 *_errno() = ENOMEM;
310 return FALSE;
311 }
312 for(i=0; i<MSVCRT_FD_BLOCK_SIZE; i++)
313 block[i].handle = INVALID_HANDLE_VALUE;
314 if(InterlockedCompareExchangePointer((void**)&MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE], block, NULL))
315 free(block);
316 return TRUE;
317 }
318
319 static inline ioinfo* get_ioinfo_alloc_fd(int fd)
320 {
321 ioinfo *ret;
322
323 ret = get_ioinfo(fd);
324 if(ret != &MSVCRT___badioinfo)
325 return ret;
326
327 if(!alloc_pioinfo_block(fd))
328 return &MSVCRT___badioinfo;
329
330 return get_ioinfo(fd);
331 }
332
333 static inline ioinfo* get_ioinfo_alloc(int *fd)
334 {
335 int i;
336
337 *fd = -1;
338 for(i=0; i<MSVCRT_MAX_FILES; i++)
339 {
340 ioinfo *info = get_ioinfo_nolock(i);
341
342 if(info == &MSVCRT___badioinfo)
343 {
344 if(!alloc_pioinfo_block(i))
345 return &MSVCRT___badioinfo;
346 info = get_ioinfo_nolock(i);
347 }
348
349 init_ioinfo_cs(info);
350 if(TryEnterCriticalSection(&info->crit))
351 {
352 if(info->handle == INVALID_HANDLE_VALUE)
353 {
354 *fd = i;
355 return info;
356 }
357 LeaveCriticalSection(&info->crit);
358 }
359 }
360
361 WARN(":files exhausted!\n");
362 *_errno() = ENFILE;
363 return &MSVCRT___badioinfo;
364 }
365
366 static inline void release_ioinfo(ioinfo *info)
367 {
368 if(info!=&MSVCRT___badioinfo && info->exflag & EF_CRIT_INIT)
369 LeaveCriticalSection(&info->crit);
370 }
371
372 static inline FILE* msvcrt_get_file(int i)
373 {
374 file_crit *ret;
375
376 if(i >= MSVCRT_max_streams)
377 return NULL;
378
379 if(i < _IOB_ENTRIES)
380 return &MSVCRT__iob[i];
381
382 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE];
383 if(!ret) {
384 MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] = calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(file_crit));
385 if(!MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE]) {
386 ERR("out of memory\n");
387 *_errno() = ENOMEM;
388 return NULL;
389 }
390
391 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] + (i%MSVCRT_FD_BLOCK_SIZE);
392 } else
393 ret += i%MSVCRT_FD_BLOCK_SIZE;
394
395 return &ret->file;
396 }
397
398 /* INTERNAL: free a file entry fd */
399 static void msvcrt_free_fd(int fd)
400 {
401 ioinfo *fdinfo = get_ioinfo(fd);
402
403 if(fdinfo != &MSVCRT___badioinfo)
404 {
405 fdinfo->handle = INVALID_HANDLE_VALUE;
406 fdinfo->wxflag = 0;
407 }
408 TRACE(":fd (%d) freed\n",fd);
409
410 if (fd < 3)
411 {
412 switch (fd)
413 {
414 case 0:
415 SetStdHandle(STD_INPUT_HANDLE, 0);
416 break;
417 case 1:
418 SetStdHandle(STD_OUTPUT_HANDLE, 0);
419 break;
420 case 2:
421 SetStdHandle(STD_ERROR_HANDLE, 0);
422 break;
423 }
424 }
425 release_ioinfo(fdinfo);
426 }
427
428 static void msvcrt_set_fd(ioinfo *fdinfo, HANDLE hand, int flag)
429 {
430 fdinfo->handle = hand;
431 fdinfo->wxflag = WX_OPEN | (flag & (WX_DONTINHERIT | WX_APPEND | WX_TEXT | WX_PIPE | WX_TTY));
432 fdinfo->lookahead[0] = '\n';
433 fdinfo->lookahead[1] = '\n';
434 fdinfo->lookahead[2] = '\n';
435 fdinfo->exflag &= EF_CRIT_INIT;
436
437 if (hand == MSVCRT_NO_CONSOLE) hand = 0;
438 switch (fdinfo-MSVCRT___pioinfo[0])
439 {
440 case 0: SetStdHandle(STD_INPUT_HANDLE, hand); break;
441 case 1: SetStdHandle(STD_OUTPUT_HANDLE, hand); break;
442 case 2: SetStdHandle(STD_ERROR_HANDLE, hand); break;
443 }
444 }
445
446 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
447 static int msvcrt_alloc_fd(HANDLE hand, int flag)
448 {
449 int fd;
450 ioinfo *info = get_ioinfo_alloc(&fd);
451
452 TRACE(":handle (%p) allocating fd (%d)\n", hand, fd);
453
454 if(info == &MSVCRT___badioinfo)
455 return -1;
456
457 msvcrt_set_fd(info, hand, flag);
458 release_ioinfo(info);
459 return fd;
460 }
461
462 /* INTERNAL: Allocate a FILE* for an fd slot */
463 /* caller must hold the files lock */
464 static FILE* msvcrt_alloc_fp(void)
465 {
466 int i;
467 FILE *file;
468
469 for (i = 3; i < MSVCRT_max_streams; i++)
470 {
471 file = msvcrt_get_file(i);
472 if (!file)
473 return NULL;
474
475 if (file->_flag == 0)
476 {
477 if (i == MSVCRT_stream_idx)
478 {
479 if (file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
480 {
481 InitializeCriticalSection(&((file_crit*)file)->crit);
482 ((file_crit*)file)->crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": file_crit.crit");
483 }
484 MSVCRT_stream_idx++;
485 }
486 return file;
487 }
488 }
489
490 return NULL;
491 }
492
493 /* INTERNAL: initialize a FILE* from an open fd */
494 static int msvcrt_init_fp(FILE* file, int fd, unsigned stream_flags)
495 {
496 TRACE(":fd (%d) allocating FILE*\n",fd);
497 if (!(get_ioinfo_nolock(fd)->wxflag & WX_OPEN))
498 {
499 WARN(":invalid fd %d\n",fd);
500 *__doserrno() = 0;
501 *_errno() = EBADF;
502 return -1;
503 }
504 file->_ptr = file->_base = NULL;
505 file->_cnt = 0;
506 file->_file = fd;
507 file->_flag = stream_flags;
508 file->_tmpfname = NULL;
509
510 TRACE(":got FILE* (%p)\n",file);
511 return 0;
512 }
513
514 /* INTERNAL: Create an inheritance data block (for spawned process)
515 * The inheritance block is made of:
516 * 00 int nb of file descriptor (NBFD)
517 * 04 char file flags (wxflag): repeated for each fd
518 * 4+NBFD HANDLE file handle: repeated for each fd
519 */
520 BOOL msvcrt_create_io_inherit_block(WORD *size, BYTE **block)
521 {
522 int fd, last_fd;
523 char* wxflag_ptr;
524 HANDLE* handle_ptr;
525 ioinfo* fdinfo;
526
527 for (last_fd=MSVCRT_MAX_FILES-1; last_fd>=0; last_fd--)
528 if (get_ioinfo_nolock(last_fd)->handle != INVALID_HANDLE_VALUE)
529 break;
530 last_fd++;
531
532 *size = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * last_fd;
533 *block = calloc(1, *size);
534 if (!*block)
535 {
536 *size = 0;
537 return FALSE;
538 }
539 wxflag_ptr = (char*)*block + sizeof(unsigned);
540 handle_ptr = (HANDLE*)(wxflag_ptr + last_fd);
541
542 *(unsigned*)*block = last_fd;
543 for (fd = 0; fd < last_fd; fd++)
544 {
545 /* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
546 fdinfo = get_ioinfo_nolock(fd);
547 if ((fdinfo->wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
548 {
549 *wxflag_ptr = fdinfo->wxflag;
550 *handle_ptr = fdinfo->handle;
551 }
552 else
553 {
554 *wxflag_ptr = 0;
555 *handle_ptr = INVALID_HANDLE_VALUE;
556 }
557 wxflag_ptr++; handle_ptr++;
558 }
559 return TRUE;
560 }
561
562 /* INTERNAL: Set up all file descriptors,
563 * as well as default streams (stdin, stderr and stdout)
564 */
565 void msvcrt_init_io(void)
566 {
567 STARTUPINFOA si;
568 int i;
569 ioinfo *fdinfo;
570
571 GetStartupInfoA(&si);
572 if (si.cbReserved2 >= sizeof(unsigned int) && si.lpReserved2 != NULL)
573 {
574 BYTE* wxflag_ptr;
575 HANDLE* handle_ptr;
576 unsigned int count;
577
578 count = *(unsigned*)si.lpReserved2;
579 wxflag_ptr = si.lpReserved2 + sizeof(unsigned);
580 handle_ptr = (HANDLE*)(wxflag_ptr + count);
581
582 count = min(count, (si.cbReserved2 - sizeof(unsigned)) / (sizeof(HANDLE) + 1));
583 count = min(count, MSVCRT_MAX_FILES);
584 for (i = 0; i < count; i++)
585 {
586 if ((*wxflag_ptr & WX_OPEN) && GetFileType(*handle_ptr) != FILE_TYPE_UNKNOWN)
587 {
588 fdinfo = get_ioinfo_alloc_fd(i);
589 if(fdinfo != &MSVCRT___badioinfo)
590 msvcrt_set_fd(fdinfo, *handle_ptr, *wxflag_ptr);
591 release_ioinfo(fdinfo);
592 }
593
594 wxflag_ptr++; handle_ptr++;
595 }
596 }
597
598 fdinfo = get_ioinfo_alloc_fd(STDIN_FILENO);
599 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
600 HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
601 DWORD flags = WX_OPEN | WX_TEXT;
602 DWORD type = GetFileType(h);
603
604 if (type == FILE_TYPE_UNKNOWN) {
605 h = MSVCRT_NO_CONSOLE;
606 flags |= WX_TTY;
607 } else if ((type & 0xf) == FILE_TYPE_CHAR) {
608 flags |= WX_TTY;
609 } else if ((type & 0xf) == FILE_TYPE_PIPE) {
610 flags |= WX_PIPE;
611 }
612
613 msvcrt_set_fd(fdinfo, h, flags);
614 }
615 release_ioinfo(fdinfo);
616
617 fdinfo = get_ioinfo_alloc_fd(STDOUT_FILENO);
618 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
619 HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
620 DWORD flags = WX_OPEN | WX_TEXT;
621 DWORD type = GetFileType(h);
622
623 if (type == FILE_TYPE_UNKNOWN) {
624 h = MSVCRT_NO_CONSOLE;
625 flags |= WX_TTY;
626 } else if ((type & 0xf) == FILE_TYPE_CHAR) {
627 flags |= WX_TTY;
628 } else if ((type & 0xf) == FILE_TYPE_PIPE) {
629 flags |= WX_PIPE;
630 }
631
632 msvcrt_set_fd(fdinfo, h, flags);
633 }
634 release_ioinfo(fdinfo);
635
636 fdinfo = get_ioinfo_alloc_fd(STDERR_FILENO);
637 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
638 HANDLE h = GetStdHandle(STD_ERROR_HANDLE);
639 DWORD flags = WX_OPEN | WX_TEXT;
640 DWORD type = GetFileType(h);
641
642 if (type == FILE_TYPE_UNKNOWN) {
643 h = MSVCRT_NO_CONSOLE;
644 flags |= WX_TTY;
645 } else if ((type & 0xf) == FILE_TYPE_CHAR) {
646 flags |= WX_TTY;
647 } else if ((type & 0xf) == FILE_TYPE_PIPE) {
648 flags |= WX_PIPE;
649 }
650
651 msvcrt_set_fd(fdinfo, h, flags);
652 }
653 release_ioinfo(fdinfo);
654
655 TRACE(":handles (%p)(%p)(%p)\n", get_ioinfo_nolock(STDIN_FILENO)->handle,
656 get_ioinfo_nolock(STDOUT_FILENO)->handle,
657 get_ioinfo_nolock(STDERR_FILENO)->handle);
658
659 memset(MSVCRT__iob,0,3*sizeof(FILE));
660 for (i = 0; i < 3; i++)
661 {
662 /* FILE structs for stdin/out/err are static and never deleted */
663 MSVCRT__iob[i]._file = get_ioinfo_nolock(i)->handle == MSVCRT_NO_CONSOLE ?
664 MSVCRT_NO_CONSOLE_FD : i;
665 MSVCRT__iob[i]._tmpfname = NULL;
666 MSVCRT__iob[i]._flag = (i == 0) ? _IOREAD : _IOWRT;
667 }
668 MSVCRT_stream_idx = 3;
669 }
670
671 /* INTERNAL: Flush stdio file buffer */
672 static int msvcrt_flush_buffer(FILE* file)
673 {
674 int ret = 0;
675
676 if((file->_flag & (_IOREAD|_IOWRT)) == _IOWRT &&
677 file->_flag & (_IOMYBUF|MSVCRT__USERBUF)) {
678 int cnt=file->_ptr-file->_base;
679 if(cnt>0 && _write(file->_file, file->_base, cnt) != cnt) {
680 file->_flag |= _IOERR;
681 ret = EOF;
682 } else if(file->_flag & _IORW) {
683 file->_flag &= ~_IOWRT;
684 }
685 }
686
687 file->_ptr=file->_base;
688 file->_cnt=0;
689 return ret;
690 }
691
692 /*********************************************************************
693 * _isatty (MSVCRT.@)
694 */
695 int CDECL _isatty(int fd)
696 {
697 TRACE(":fd (%d)\n",fd);
698
699 return get_ioinfo_nolock(fd)->wxflag & WX_TTY;
700 }
701
702 /* INTERNAL: Allocate stdio file buffer */
703 static BOOL msvcrt_alloc_buffer(FILE* file)
704 {
705 if((file->_file==STDOUT_FILENO || file->_file==STDERR_FILENO)
706 && _isatty(file->_file))
707 return FALSE;
708
709 file->_base = calloc(1, MSVCRT_INTERNAL_BUFSIZ);
710 if(file->_base) {
711 file->_bufsiz = MSVCRT_INTERNAL_BUFSIZ;
712 file->_flag |= _IOMYBUF;
713 } else {
714 file->_base = (char*)(&file->_charbuf);
715 file->_bufsiz = 2;
716 file->_flag |= _IONBF;
717 }
718 file->_ptr = file->_base;
719 file->_cnt = 0;
720 return TRUE;
721 }
722
723 /* INTERNAL: Allocate temporary buffer for stdout and stderr */
724 static BOOL add_std_buffer(FILE *file)
725 {
726 static char buffers[2][BUFSIZ];
727
728 if((file->_file!=STDOUT_FILENO && file->_file!=STDERR_FILENO)
729 || (file->_flag & (_IONBF | _IOMYBUF | MSVCRT__USERBUF))
730 || !_isatty(file->_file))
731 return FALSE;
732
733 file->_ptr = file->_base = buffers[file->_file == STDOUT_FILENO ? 0 : 1];
734 file->_bufsiz = file->_cnt = BUFSIZ;
735 file->_flag |= MSVCRT__USERBUF;
736 return TRUE;
737 }
738
739 /* INTERNAL: Removes temporary buffer from stdout or stderr */
740 /* Only call this function when add_std_buffer returned TRUE */
741 static void remove_std_buffer(FILE *file)
742 {
743 msvcrt_flush_buffer(file);
744 file->_ptr = file->_base = NULL;
745 file->_bufsiz = file->_cnt = 0;
746 file->_flag &= ~MSVCRT__USERBUF;
747 }
748
749 /* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
750 static int msvcrt_int_to_base32(int num, char *str)
751 {
752 char *p;
753 int n = num;
754 int digits = 0;
755
756 while (n != 0)
757 {
758 n >>= 5;
759 digits++;
760 }
761 p = str + digits;
762 *p = 0;
763 while (--p >= str)
764 {
765 *p = (num & 31) + '0';
766 if (*p > '9')
767 *p += ('a' - '0' - 10);
768 num >>= 5;
769 }
770
771 return digits;
772 }
773
774 /* INTERNAL: wide character version of msvcrt_int_to_base32 */
775 static int msvcrt_int_to_base32_w(int num, wchar_t *str)
776 {
777 wchar_t *p;
778 int n = num;
779 int digits = 0;
780
781 while (n != 0)
782 {
783 n >>= 5;
784 digits++;
785 }
786 p = str + digits;
787 *p = 0;
788 while (--p >= str)
789 {
790 *p = (num & 31) + '0';
791 if (*p > '9')
792 *p += ('a' - '0' - 10);
793 num >>= 5;
794 }
795
796 return digits;
797 }
798
799 /*********************************************************************
800 * __iob_func (MSVCRT.@)
801 */
802 #undef __iob_func
803 FILE * CDECL __iob_func(void)
804 {
805 return &MSVCRT__iob[0];
806 }
807
808 #if _MSVCR_VER >= 140
809 /*********************************************************************
810 * __acrt_iob_func(UCRTBASE.@)
811 */
812 FILE * CDECL __acrt_iob_func(unsigned idx)
813 {
814 return &MSVCRT__iob[idx];
815 }
816 #endif
817
818 /*********************************************************************
819 * _access (MSVCRT.@)
820 */
821 int CDECL _access(const char *filename, int mode)
822 {
823 DWORD attr = GetFileAttributesA(filename);
824
825 TRACE("(%s,%d) %d\n",filename,mode,attr);
826
827 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
828 {
829 msvcrt_set_errno(GetLastError());
830 return -1;
831 }
832 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
833 {
834 msvcrt_set_errno(ERROR_ACCESS_DENIED);
835 return -1;
836 }
837 return 0;
838 }
839
840 /*********************************************************************
841 * _access_s (MSVCRT.@)
842 */
843 int CDECL _access_s(const char *filename, int mode)
844 {
845 if (!MSVCRT_CHECK_PMT(filename != NULL)) return *_errno();
846 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return *_errno();
847
848 if (_access(filename, mode) == -1)
849 return *_errno();
850 return 0;
851 }
852
853 /*********************************************************************
854 * _waccess (MSVCRT.@)
855 */
856 int CDECL _waccess(const wchar_t *filename, int mode)
857 {
858 DWORD attr = GetFileAttributesW(filename);
859
860 TRACE("(%s,%d) %d\n",debugstr_w(filename),mode,attr);
861
862 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
863 {
864 msvcrt_set_errno(GetLastError());
865 return -1;
866 }
867 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
868 {
869 msvcrt_set_errno(ERROR_ACCESS_DENIED);
870 return -1;
871 }
872 return 0;
873 }
874
875 /*********************************************************************
876 * _waccess_s (MSVCRT.@)
877 */
878 int CDECL _waccess_s(const wchar_t *filename, int mode)
879 {
880 if (!MSVCRT_CHECK_PMT(filename != NULL)) return *_errno();
881 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return *_errno();
882
883 if (_waccess(filename, mode) == -1)
884 return *_errno();
885 return 0;
886 }
887
888 /*********************************************************************
889 * _chmod (MSVCRT.@)
890 */
891 int CDECL _chmod(const char *path, int flags)
892 {
893 DWORD oldFlags = GetFileAttributesA(path);
894
895 if (oldFlags != INVALID_FILE_ATTRIBUTES)
896 {
897 DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
898 oldFlags | FILE_ATTRIBUTE_READONLY;
899
900 if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
901 return 0;
902 }
903 msvcrt_set_errno(GetLastError());
904 return -1;
905 }
906
907 /*********************************************************************
908 * _wchmod (MSVCRT.@)
909 */
910 int CDECL _wchmod(const wchar_t *path, int flags)
911 {
912 DWORD oldFlags = GetFileAttributesW(path);
913
914 if (oldFlags != INVALID_FILE_ATTRIBUTES)
915 {
916 DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
917 oldFlags | FILE_ATTRIBUTE_READONLY;
918
919 if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
920 return 0;
921 }
922 msvcrt_set_errno(GetLastError());
923 return -1;
924 }
925
926 /*********************************************************************
927 * _unlink (MSVCRT.@)
928 */
929 int CDECL _unlink(const char *path)
930 {
931 TRACE("%s\n",debugstr_a(path));
932 if(DeleteFileA(path))
933 return 0;
934 TRACE("failed (%d)\n",GetLastError());
935 msvcrt_set_errno(GetLastError());
936 return -1;
937 }
938
939 /*********************************************************************
940 * _wunlink (MSVCRT.@)
941 */
942 int CDECL _wunlink(const wchar_t *path)
943 {
944 TRACE("(%s)\n",debugstr_w(path));
945 if(DeleteFileW(path))
946 return 0;
947 TRACE("failed (%d)\n",GetLastError());
948 msvcrt_set_errno(GetLastError());
949 return -1;
950 }
951
952 /*********************************************************************
953 * _commit (MSVCRT.@)
954 */
955 int CDECL _commit(int fd)
956 {
957 ioinfo *info = get_ioinfo(fd);
958 int ret;
959
960 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
961
962 if (info->handle == INVALID_HANDLE_VALUE)
963 ret = -1;
964 else if (!FlushFileBuffers(info->handle))
965 {
966 if (GetLastError() == ERROR_INVALID_HANDLE)
967 {
968 /* FlushFileBuffers fails for console handles
969 * so we ignore this error.
970 */
971 ret = 0;
972 }
973 else
974 {
975 TRACE(":failed-last error (%d)\n",GetLastError());
976 msvcrt_set_errno(GetLastError());
977 ret = -1;
978 }
979 }
980 else
981 {
982 TRACE(":ok\n");
983 ret = 0;
984 }
985
986 release_ioinfo(info);
987 return ret;
988 }
989
990 /* INTERNAL: Flush all stream buffer */
991 static int msvcrt_flush_all_buffers(int mask)
992 {
993 int i, num_flushed = 0;
994 FILE *file;
995
996 LOCK_FILES();
997 for (i = 0; i < MSVCRT_stream_idx; i++) {
998 file = msvcrt_get_file(i);
999
1000 if (file->_flag)
1001 {
1002 if(file->_flag & mask) {
1003 fflush(file);
1004 num_flushed++;
1005 }
1006 }
1007 }
1008 UNLOCK_FILES();
1009
1010 TRACE(":flushed (%d) handles\n",num_flushed);
1011 return num_flushed;
1012 }
1013
1014 /*********************************************************************
1015 * _flushall (MSVCRT.@)
1016 */
1017 int CDECL _flushall(void)
1018 {
1019 return msvcrt_flush_all_buffers(_IOWRT | _IOREAD);
1020 }
1021
1022 /*********************************************************************
1023 * fflush (MSVCRT.@)
1024 */
1025 int CDECL fflush(FILE* file)
1026 {
1027 int ret;
1028
1029 if(!file) {
1030 msvcrt_flush_all_buffers(_IOWRT);
1031 ret = 0;
1032 } else {
1033 _lock_file(file);
1034 ret = _fflush_nolock(file);
1035 _unlock_file(file);
1036 }
1037
1038 return ret;
1039 }
1040
1041 /*********************************************************************
1042 * _fflush_nolock (MSVCRT.@)
1043 */
1044 int CDECL _fflush_nolock(FILE* file)
1045 {
1046 int res;
1047
1048 if(!file) {
1049 msvcrt_flush_all_buffers(_IOWRT);
1050 return 0;
1051 }
1052
1053 res = msvcrt_flush_buffer(file);
1054 if(!res && (file->_flag & MSVCRT__IOCOMMIT))
1055 res = _commit(file->_file) ? EOF : 0;
1056 return res;
1057 }
1058
1059 /*********************************************************************
1060 * _close (MSVCRT.@)
1061 */
1062 int CDECL _close(int fd)
1063 {
1064 ioinfo *info = get_ioinfo(fd);
1065 int ret;
1066
1067 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
1068
1069 if (fd == MSVCRT_NO_CONSOLE_FD) {
1070 *_errno() = EBADF;
1071 ret = -1;
1072 } else if (!MSVCRT_CHECK_PMT_ERR(info->wxflag & WX_OPEN, EBADF)) {
1073 ret = -1;
1074 } else if (fd == STDOUT_FILENO &&
1075 info->handle == get_ioinfo_nolock(STDERR_FILENO)->handle) {
1076 msvcrt_free_fd(fd);
1077 ret = 0;
1078 } else if (fd == STDERR_FILENO &&
1079 info->handle == get_ioinfo_nolock(STDOUT_FILENO)->handle) {
1080 msvcrt_free_fd(fd);
1081 ret = 0;
1082 } else {
1083 ret = CloseHandle(info->handle) ? 0 : -1;
1084 msvcrt_free_fd(fd);
1085 if (ret) {
1086 WARN(":failed-last error (%d)\n",GetLastError());
1087 msvcrt_set_errno(GetLastError());
1088 }
1089 }
1090 release_ioinfo(info);
1091 return ret;
1092 }
1093
1094 /*********************************************************************
1095 * _dup2 (MSVCRT.@)
1096 * NOTES
1097 * MSDN isn't clear on this point, but the remarks for _pipe
1098 * indicate file descriptors duplicated with _dup and _dup2 are always
1099 * inheritable.
1100 */
1101 int CDECL _dup2(int od, int nd)
1102 {
1103 ioinfo *info_od, *info_nd;
1104 int ret;
1105
1106 TRACE("(od=%d, nd=%d)\n", od, nd);
1107
1108 if (od < nd)
1109 {
1110 info_od = get_ioinfo(od);
1111 info_nd = get_ioinfo_alloc_fd(nd);
1112 }
1113 else
1114 {
1115 info_nd = get_ioinfo_alloc_fd(nd);
1116 info_od = get_ioinfo(od);
1117 }
1118
1119 if (info_nd == &MSVCRT___badioinfo)
1120 {
1121 ret = -1;
1122 }
1123 else if (info_od->wxflag & WX_OPEN)
1124 {
1125 HANDLE handle;
1126
1127 if (DuplicateHandle(GetCurrentProcess(), info_od->handle,
1128 GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS))
1129 {
1130 int wxflag = info_od->wxflag & ~WX_DONTINHERIT;
1131
1132 if (info_nd->wxflag & WX_OPEN)
1133 _close(nd);
1134
1135 msvcrt_set_fd(info_nd, handle, wxflag);
1136 /* _dup2 returns 0, not nd, on success */
1137 ret = 0;
1138 }
1139 else
1140 {
1141 ret = -1;
1142 msvcrt_set_errno(GetLastError());
1143 }
1144 }
1145 else
1146 {
1147 *_errno() = EBADF;
1148 ret = -1;
1149 }
1150
1151 release_ioinfo(info_od);
1152 release_ioinfo(info_nd);
1153 return ret;
1154 }
1155
1156 /*********************************************************************
1157 * _dup (MSVCRT.@)
1158 */
1159 int CDECL _dup(int od)
1160 {
1161 int fd, ret;
1162 ioinfo *info = get_ioinfo_alloc(&fd);
1163
1164 if (_dup2(od, fd) == 0)
1165 ret = fd;
1166 else
1167 ret = -1;
1168 release_ioinfo(info);
1169 return ret;
1170 }
1171
1172 /*********************************************************************
1173 * _eof (MSVCRT.@)
1174 */
1175 int CDECL _eof(int fd)
1176 {
1177 ioinfo *info = get_ioinfo(fd);
1178 DWORD curpos,endpos;
1179 LONG hcurpos,hendpos;
1180
1181 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
1182
1183 if (info->handle == INVALID_HANDLE_VALUE)
1184 {
1185 release_ioinfo(info);
1186 return -1;
1187 }
1188
1189 if (info->wxflag & WX_ATEOF)
1190 {
1191 release_ioinfo(info);
1192 return TRUE;
1193 }
1194
1195 /* Otherwise we do it the hard way */
1196 hcurpos = hendpos = 0;
1197 curpos = SetFilePointer(info->handle, 0, &hcurpos, FILE_CURRENT);
1198 endpos = SetFilePointer(info->handle, 0, &hendpos, FILE_END);
1199
1200 if (curpos == endpos && hcurpos == hendpos)
1201 {
1202 /* FIXME: shouldn't WX_ATEOF be set here? */
1203 release_ioinfo(info);
1204 return TRUE;
1205 }
1206
1207 SetFilePointer(info->handle, curpos, &hcurpos, FILE_BEGIN);
1208 release_ioinfo(info);
1209 return FALSE;
1210 }
1211
1212 /*********************************************************************
1213 * _fcloseall (MSVCRT.@)
1214 */
1215 int CDECL _fcloseall(void)
1216 {
1217 int num_closed = 0, i;
1218 FILE *file;
1219
1220 LOCK_FILES();
1221 for (i = 3; i < MSVCRT_stream_idx; i++) {
1222 file = msvcrt_get_file(i);
1223
1224 if (file->_flag && !fclose(file))
1225 num_closed++;
1226 }
1227 UNLOCK_FILES();
1228
1229 TRACE(":closed (%d) handles\n",num_closed);
1230 return num_closed;
1231 }
1232
1233 /* free everything on process exit */
1234 void msvcrt_free_io(void)
1235 {
1236 unsigned int i;
1237 int j;
1238
1239 _flushall();
1240 _fcloseall();
1241
1242 for(i=0; i<ARRAY_SIZE(MSVCRT___pioinfo); i++)
1243 {
1244 if(!MSVCRT___pioinfo[i])
1245 continue;
1246
1247 for(j=0; j<MSVCRT_FD_BLOCK_SIZE; j++)
1248 {
1249 if(MSVCRT___pioinfo[i][j].exflag & EF_CRIT_INIT)
1250 DeleteCriticalSection(&MSVCRT___pioinfo[i][j].crit);
1251 }
1252 free(MSVCRT___pioinfo[i]);
1253 }
1254
1255 for(j=0; j<MSVCRT_stream_idx; j++)
1256 {
1257 FILE *file = msvcrt_get_file(j);
1258 if(file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
1259 {
1260 ((file_crit*)file)->crit.DebugInfo->Spare[0] = 0;
1261 DeleteCriticalSection(&((file_crit*)file)->crit);
1262 }
1263 }
1264
1265 for(i=0; i<ARRAY_SIZE(MSVCRT_fstream); i++)
1266 free(MSVCRT_fstream[i]);
1267 }
1268
1269 /*********************************************************************
1270 * _lseeki64 (MSVCRT.@)
1271 */
1272 __int64 CDECL _lseeki64(int fd, __int64 offset, int whence)
1273 {
1274 ioinfo *info = get_ioinfo(fd);
1275 LARGE_INTEGER ofs;
1276
1277 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
1278
1279 if (info->handle == INVALID_HANDLE_VALUE)
1280 {
1281 *_errno() = EBADF;
1282 release_ioinfo(info);
1283 return -1;
1284 }
1285
1286 if (whence < 0 || whence > 2)
1287 {
1288 release_ioinfo(info);
1289 *_errno() = EINVAL;
1290 return -1;
1291 }
1292
1293 TRACE(":fd (%d) to %s pos %s\n",
1294 fd,wine_dbgstr_longlong(offset),
1295 (whence==SEEK_SET)?"SEEK_SET":
1296 (whence==SEEK_CUR)?"SEEK_CUR":
1297 (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
1298
1299 /* The MoleBox protection scheme expects msvcrt to use SetFilePointer only,
1300 * so a LARGE_INTEGER offset cannot be passed directly via SetFilePointerEx. */
1301 ofs.QuadPart = offset;
1302 if ((ofs.u.LowPart = SetFilePointer(info->handle, ofs.u.LowPart, &ofs.u.HighPart, whence)) != INVALID_SET_FILE_POINTER ||
1303 GetLastError() == ERROR_SUCCESS)
1304 {
1305 info->wxflag &= ~WX_ATEOF;
1306 /* FIXME: What if we seek _to_ EOF - is EOF set? */
1307
1308 release_ioinfo(info);
1309 return ofs.QuadPart;
1310 }
1311 release_ioinfo(info);
1312 TRACE(":error-last error (%d)\n",GetLastError());
1313 msvcrt_set_errno(GetLastError());
1314 return -1;
1315 }
1316
1317 /*********************************************************************
1318 * _lseek (MSVCRT.@)
1319 */
1320 __msvcrt_long CDECL _lseek(int fd, __msvcrt_long offset, int whence)
1321 {
1322 return _lseeki64(fd, offset, whence);
1323 }
1324
1325 /*********************************************************************
1326 * _lock_file (MSVCRT.@)
1327 */
1328 void CDECL _lock_file(FILE *file)
1329 {
1330 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1331 _lock(_STREAM_LOCKS+(file-MSVCRT__iob));
1332 else
1333 EnterCriticalSection(&((file_crit*)file)->crit);
1334 }
1335
1336 /*********************************************************************
1337 * _unlock_file (MSVCRT.@)
1338 */
1339 void CDECL _unlock_file(FILE *file)
1340 {
1341 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1342 _unlock(_STREAM_LOCKS+(file-MSVCRT__iob));
1343 else
1344 LeaveCriticalSection(&((file_crit*)file)->crit);
1345 }
1346
1347 /*********************************************************************
1348 * _locking (MSVCRT.@)
1349 *
1350 * This is untested; the underlying LockFile doesn't work yet.
1351 */
1352 int CDECL _locking(int fd, int mode, __msvcrt_long nbytes)
1353 {
1354 ioinfo *info = get_ioinfo(fd);
1355 BOOL ret;
1356 DWORD cur_locn;
1357
1358 TRACE(":fd (%d) handle (%p)\n", fd, info->handle);
1359 if (info->handle == INVALID_HANDLE_VALUE)
1360 {
1361 release_ioinfo(info);
1362 return -1;
1363 }
1364
1365 if (mode < 0 || mode > 4)
1366 {
1367 release_ioinfo(info);
1368 *_errno() = EINVAL;
1369 return -1;
1370 }
1371
1372 TRACE(":fd (%d) by 0x%08Ix mode %s\n",
1373 fd,nbytes,(mode==_LK_UNLCK)?"_LK_UNLCK":
1374 (mode==_LK_LOCK)?"_LK_LOCK":
1375 (mode==_LK_NBLCK)?"_LK_NBLCK":
1376 (mode==_LK_RLCK)?"_LK_RLCK":
1377 (mode==_LK_NBRLCK)?"_LK_NBRLCK":
1378 "UNKNOWN");
1379
1380 if ((cur_locn = SetFilePointer(info->handle, 0L, NULL, FILE_CURRENT)) == INVALID_SET_FILE_POINTER)
1381 {
1382 release_ioinfo(info);
1383 FIXME ("Seek failed\n");
1384 *_errno() = EINVAL; /* FIXME */
1385 return -1;
1386 }
1387 if (mode == _LK_LOCK || mode == _LK_RLCK)
1388 {
1389 int nretry = 10;
1390 ret = 1; /* just to satisfy gcc */
1391 while (nretry--)
1392 {
1393 ret = LockFile(info->handle, cur_locn, 0L, nbytes, 0L);
1394 if (ret) break;
1395 Sleep(1);
1396 }
1397 }
1398 else if (mode == _LK_UNLCK)
1399 ret = UnlockFile(info->handle, cur_locn, 0L, nbytes, 0L);
1400 else
1401 ret = LockFile(info->handle, cur_locn, 0L, nbytes, 0L);
1402 /* FIXME - what about error settings? */
1403 release_ioinfo(info);
1404 return ret ? 0 : -1;
1405 }
1406
1407 /*********************************************************************
1408 * _fseeki64 (MSVCRT.@)
1409 */
1410 int CDECL _fseeki64(FILE* file, __int64 offset, int whence)
1411 {
1412 int ret;
1413
1414 _lock_file(file);
1415 ret = _fseeki64_nolock(file, offset, whence);
1416 _unlock_file(file);
1417
1418 return ret;
1419 }
1420
1421 /*********************************************************************
1422 * _fseeki64_nolock (MSVCRT.@)
1423 */
1424 int CDECL _fseeki64_nolock(FILE* file, __int64 offset, int whence)
1425 {
1426 int ret;
1427
1428 if(whence == SEEK_CUR && file->_flag & _IOREAD ) {
1429 whence = SEEK_SET;
1430 offset += _ftelli64_nolock(file);
1431 }
1432
1433 /* Flush output if needed */
1434 msvcrt_flush_buffer(file);
1435 /* Reset direction of i/o */
1436 if(file->_flag & _IORW) {
1437 file->_flag &= ~(_IOREAD|_IOWRT);
1438 }
1439 /* Clear end of file flag */
1440 file->_flag &= ~_IOEOF;
1441 ret = (_lseeki64(file->_file,offset,whence) == -1)?-1:0;
1442
1443 return ret;
1444 }
1445
1446 /*********************************************************************
1447 * fseek (MSVCRT.@)
1448 */
1449 int CDECL fseek(FILE* file, __msvcrt_long offset, int whence)
1450 {
1451 return _fseeki64( file, offset, whence );
1452 }
1453
1454 /*********************************************************************
1455 * _fseek_nolock (MSVCRT.@)
1456 */
1457 int CDECL _fseek_nolock(FILE* file, __msvcrt_long offset, int whence)
1458 {
1459 return _fseeki64_nolock( file, offset, whence );
1460 }
1461
1462 /*********************************************************************
1463 * _chsize_s (MSVCRT.@)
1464 */
1465 int CDECL _chsize_s(int fd, __int64 size)
1466 {
1467 ioinfo *info;
1468 __int64 cur, pos;
1469 BOOL ret = FALSE;
1470
1471 TRACE("(fd=%d, size=%s)\n", fd, wine_dbgstr_longlong(size));
1472
1473 if (!MSVCRT_CHECK_PMT(size >= 0)) return EINVAL;
1474
1475
1476 info = get_ioinfo(fd);
1477 if (info->handle != INVALID_HANDLE_VALUE)
1478 {
1479 /* save the current file pointer */
1480 cur = _lseeki64(fd, 0, SEEK_CUR);
1481 if (cur >= 0)
1482 {
1483 pos = _lseeki64(fd, size, SEEK_SET);
1484 if (pos >= 0)
1485 {
1486 ret = SetEndOfFile(info->handle);
1487 if (!ret) msvcrt_set_errno(GetLastError());
1488 }
1489
1490 /* restore the file pointer */
1491 _lseeki64(fd, cur, SEEK_SET);
1492 }
1493 }
1494
1495 release_ioinfo(info);
1496 return ret ? 0 : *_errno();
1497 }
1498
1499 /*********************************************************************
1500 * _chsize (MSVCRT.@)
1501 */
1502 int CDECL _chsize(int fd, __msvcrt_long size)
1503 {
1504 /* _chsize_s returns errno on failure but _chsize should return -1 */
1505 return _chsize_s( fd, size ) == 0 ? 0 : -1;
1506 }
1507
1508 /*********************************************************************
1509 * clearerr (MSVCRT.@)
1510 */
1511 void CDECL clearerr(FILE* file)
1512 {
1513 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1514
1515 _lock_file(file);
1516 file->_flag &= ~(_IOERR | _IOEOF);
1517 _unlock_file(file);
1518 }
1519
1520 /*********************************************************************
1521 * clearerr_s (MSVCRT.@)
1522 */
1523 int CDECL clearerr_s(FILE* file)
1524 {
1525 TRACE(":file (%p)\n",file);
1526
1527 if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
1528
1529 _lock_file(file);
1530 file->_flag &= ~(_IOERR | _IOEOF);
1531 _unlock_file(file);
1532 return 0;
1533 }
1534
1535 /*********************************************************************
1536 * rewind (MSVCRT.@)
1537 */
1538 void CDECL rewind(FILE* file)
1539 {
1540 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1541
1542 _lock_file(file);
1543 _fseek_nolock(file, 0L, SEEK_SET);
1544 clearerr(file);
1545 _unlock_file(file);
1546 }
1547
1548 static int msvcrt_get_flags(const wchar_t* mode, int *open_flags, int* stream_flags)
1549 {
1550 int plus = wcschr(mode, '+') != NULL;
1551
1552 TRACE("%s\n", debugstr_w(mode));
1553
1554 while(*mode == ' ') mode++;
1555
1556 switch(*mode++)
1557 {
1558 case 'R': case 'r':
1559 *open_flags = plus ? _O_RDWR : _O_RDONLY;
1560 *stream_flags = plus ? _IORW : _IOREAD;
1561 break;
1562 case 'W': case 'w':
1563 *open_flags = _O_CREAT | _O_TRUNC | (plus ? _O_RDWR : _O_WRONLY);
1564 *stream_flags = plus ? _IORW : _IOWRT;
1565 break;
1566 case 'A': case 'a':
1567 *open_flags = _O_CREAT | _O_APPEND | (plus ? _O_RDWR : _O_WRONLY);
1568 *stream_flags = plus ? _IORW : _IOWRT;
1569 break;
1570 default:
1571 MSVCRT_INVALID_PMT(0, EINVAL);
1572 return -1;
1573 }
1574
1575 *stream_flags |= MSVCRT__commode;
1576
1577 while (*mode && *mode!=',')
1578 switch (*mode++)
1579 {
1580 case 'B': case 'b':
1581 *open_flags |= _O_BINARY;
1582 *open_flags &= ~_O_TEXT;
1583 break;
1584 case 't':
1585 *open_flags |= _O_TEXT;
1586 *open_flags &= ~_O_BINARY;
1587 break;
1588 #if _MSVCR_VER>=140
1589 case 'x':
1590 if(!MSVCRT_CHECK_PMT((*open_flags & (_O_CREAT | _O_APPEND)) == _O_CREAT))
1591 return -1;
1592 *open_flags |= _O_EXCL;
1593 break;
1594 #endif
1595 case 'D':
1596 *open_flags |= _O_TEMPORARY;
1597 break;
1598 case 'T':
1599 *open_flags |= _O_SHORT_LIVED;
1600 break;
1601 case 'c':
1602 *stream_flags |= MSVCRT__IOCOMMIT;
1603 break;
1604 case 'n':
1605 *stream_flags &= ~MSVCRT__IOCOMMIT;
1606 break;
1607 case 'N':
1608 *open_flags |= _O_NOINHERIT;
1609 break;
1610 case '+':
1611 case ' ':
1612 case 'a':
1613 case 'w':
1614 break;
1615 case 'S':
1616 if (!(*open_flags & _O_RANDOM))
1617 *open_flags |= _O_SEQUENTIAL;
1618 break;
1619 case 'R':
1620 if (!(*open_flags & _O_SEQUENTIAL))
1621 *open_flags |= _O_RANDOM;
1622 break;
1623 default:
1624 ERR("incorrect mode flag: %c\n", mode[-1]);
1625 break;
1626 }
1627
1628 if(*mode == ',')
1629 {
1630 mode++;
1631 while(*mode == ' ') mode++;
1632 if(!MSVCRT_CHECK_PMT(!wcsncmp(L"ccs", mode, 3)))
1633 return -1;
1634 mode += 3;
1635 while(*mode == ' ') mode++;
1636 if(!MSVCRT_CHECK_PMT(*mode == '='))
1637 return -1;
1638 mode++;
1639 while(*mode == ' ') mode++;
1640
1641 if(!_wcsnicmp(L"utf-8", mode, 5))
1642 {
1643 *open_flags |= _O_U8TEXT;
1644 mode += 5;
1645 }
1646 else if(!_wcsnicmp(L"utf-16le", mode, 8))
1647 {
1648 *open_flags |= _O_U16TEXT;
1649 mode += 8;
1650 }
1651 else if(!_wcsnicmp(L"unicode", mode, 7))
1652 {
1653 *open_flags |= _O_WTEXT;
1654 mode += 7;
1655 }
1656 else
1657 {
1658 MSVCRT_INVALID_PMT(0, EINVAL);
1659 return -1;
1660 }
1661
1662 while(*mode == ' ') mode++;
1663 }
1664
1665 if(!MSVCRT_CHECK_PMT(*mode == 0))
1666 return -1;
1667 return 0;
1668 }
1669
1670 /*********************************************************************
1671 * _fdopen (MSVCRT.@)
1672 */
1673 FILE* CDECL _fdopen(int fd, const char *mode)
1674 {
1675 FILE *ret;
1676 wchar_t *modeW = NULL;
1677
1678 if (mode && !(modeW = msvcrt_wstrdupa(mode))) return NULL;
1679
1680 ret = _wfdopen(fd, modeW);
1681
1682 free(modeW);
1683 return ret;
1684 }
1685
1686 /*********************************************************************
1687 * _wfdopen (MSVCRT.@)
1688 */
1689 FILE* CDECL _wfdopen(int fd, const wchar_t *mode)
1690 {
1691 int open_flags, stream_flags;
1692 FILE* file;
1693
1694 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
1695
1696 LOCK_FILES();
1697 if (!(file = msvcrt_alloc_fp()))
1698 file = NULL;
1699 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
1700 {
1701 file->_flag = 0;
1702 file = NULL;
1703 }
1704 else TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
1705 UNLOCK_FILES();
1706
1707 return file;
1708 }
1709
1710 /*********************************************************************
1711 * _filelength (MSVCRT.@)
1712 */
1713 __msvcrt_long CDECL _filelength(int fd)
1714 {
1715 LONG curPos = _lseek(fd, 0, SEEK_CUR);
1716 if (curPos != -1)
1717 {
1718 LONG endPos = _lseek(fd, 0, SEEK_END);
1719 if (endPos != -1)
1720 {
1721 if (endPos != curPos)
1722 _lseek(fd, curPos, SEEK_SET);
1723 return endPos;
1724 }
1725 }
1726 return -1;
1727 }
1728
1729 /*********************************************************************
1730 * _filelengthi64 (MSVCRT.@)
1731 */
1732 __int64 CDECL _filelengthi64(int fd)
1733 {
1734 __int64 curPos = _lseeki64(fd, 0, SEEK_CUR);
1735 if (curPos != -1)
1736 {
1737 __int64 endPos = _lseeki64(fd, 0, SEEK_END);
1738 if (endPos != -1)
1739 {
1740 if (endPos != curPos)
1741 _lseeki64(fd, curPos, SEEK_SET);
1742 return endPos;
1743 }
1744 }
1745 return -1;
1746 }
1747
1748 /*********************************************************************
1749 * _fileno (MSVCRT.@)
1750 */
1751 int CDECL _fileno(FILE* file)
1752 {
1753 TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
1754 return file->_file;
1755 }
1756
1757 /*********************************************************************
1758 * _fstat64 (MSVCRT.@)
1759 */
1760 int CDECL _fstat64(int fd, struct _stat64* buf)
1761 {
1762 ioinfo *info = get_ioinfo(fd);
1763 DWORD dw;
1764 DWORD type;
1765
1766 TRACE(":fd (%d) stat (%p)\n", fd, buf);
1767 if (info->handle == INVALID_HANDLE_VALUE)
1768 {
1769 release_ioinfo(info);
1770 return -1;
1771 }
1772
1773 if (!buf)
1774 {
1775 WARN(":failed-NULL buf\n");
1776 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1777 release_ioinfo(info);
1778 return -1;
1779 }
1780
1781 memset(buf, 0, sizeof(struct _stat64));
1782 type = GetFileType(info->handle);
1783 if (type == FILE_TYPE_PIPE)
1784 {
1785 buf->st_dev = buf->st_rdev = fd;
1786 buf->st_mode = _S_IFIFO;
1787 buf->st_nlink = 1;
1788 }
1789 else if (type == FILE_TYPE_CHAR)
1790 {
1791 buf->st_dev = buf->st_rdev = fd;
1792 buf->st_mode = _S_IFCHR;
1793 buf->st_nlink = 1;
1794 }
1795 else /* FILE_TYPE_DISK etc. */
1796 {
1797 FILE_BASIC_INFORMATION basic_info;
1798 FILE_STANDARD_INFORMATION std_info;
1799 IO_STATUS_BLOCK io;
1800 NTSTATUS status;
1801
1802 if ((status = NtQueryInformationFile( info->handle, &io, &basic_info, sizeof(basic_info), FileBasicInformation )) ||
1803 (status = NtQueryInformationFile( info->handle, &io, &std_info, sizeof(std_info), FileStandardInformation )))
1804 {
1805 WARN(":failed-error %x\n",status);
1806 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1807 release_ioinfo(info);
1808 return -1;
1809 }
1810 buf->st_mode = _S_IFREG | 0444;
1811 if (!(basic_info.FileAttributes & FILE_ATTRIBUTE_READONLY))
1812 buf->st_mode |= 0222;
1813 buf->st_size = std_info.EndOfFile.QuadPart;
1814 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&basic_info.LastAccessTime, &dw);
1815 buf->st_atime = dw;
1816 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&basic_info.LastWriteTime, &dw);
1817 buf->st_mtime = buf->st_ctime = dw;
1818 buf->st_nlink = std_info.NumberOfLinks;
1819 TRACE(":dwFileAttributes = 0x%x, mode set to 0x%x\n",basic_info.FileAttributes, buf->st_mode);
1820 }
1821 release_ioinfo(info);
1822 return 0;
1823 }
1824
1825 /*********************************************************************
1826 * _fstati64 (MSVCRT.@)
1827 */
1828 int CDECL _fstati64(int fd, struct _stati64* buf)
1829 {
1830 int ret;
1831 struct _stat64 buf64;
1832
1833 ret = _fstat64(fd, &buf64);
1834 if (!ret)
1835 msvcrt_stat64_to_stati64(&buf64, buf);
1836 return ret;
1837 }
1838
1839 /*********************************************************************
1840 * _fstat (MSVCRT.@)
1841 */
1842 int CDECL _fstat(int fd, struct _stat* buf)
1843 { int ret;
1844 struct _stat64 buf64;
1845
1846 ret = _fstat64(fd, &buf64);
1847 if (!ret)
1848 msvcrt_stat64_to_stat(&buf64, buf);
1849 return ret;
1850 }
1851
1852 /*********************************************************************
1853 * _fstat32 (MSVCR80.@)
1854 */
1855 int CDECL _fstat32(int fd, struct _stat32* buf)
1856 {
1857 int ret;
1858 struct _stat64 buf64;
1859
1860 ret = _fstat64(fd, &buf64);
1861 if (!ret)
1862 msvcrt_stat64_to_stat32(&buf64, buf);
1863 return ret;
1864 }
1865
1866 /*********************************************************************
1867 * _fstat32i64 (MSVCR80.@)
1868 */
1869 int CDECL _fstat32i64(int fd, struct _stat32i64* buf)
1870 {
1871 int ret;
1872 struct _stat64 buf64;
1873
1874 ret = _fstat64(fd, &buf64);
1875 if (!ret)
1876 msvcrt_stat64_to_stat32i64(&buf64, buf);
1877 return ret;
1878 }
1879
1880 /*********************************************************************
1881 * _fstat64i32 (MSVCR80.@)
1882 */
1883 int CDECL _fstat64i32(int fd, struct _stat64i32* buf)
1884 {
1885 int ret;
1886 struct _stat64 buf64;
1887
1888 ret = _fstat64(fd, &buf64);
1889 if (!ret)
1890 msvcrt_stat64_to_stat64i32(&buf64, buf);
1891 return ret;
1892 }
1893
1894 /*********************************************************************
1895 * _futime64 (MSVCRT.@)
1896 */
1897 int CDECL _futime64(int fd, struct __utimbuf64 *t)
1898 {
1899 ioinfo *info = get_ioinfo(fd);
1900 FILETIME at, wt;
1901
1902 if (!t)
1903 {
1904 time_to_filetime( _time64(NULL), &at );
1905 wt = at;
1906 }
1907 else
1908 {
1909 time_to_filetime( t->actime, &at );
1910 time_to_filetime( t->modtime, &wt );
1911 }
1912
1913 if (!SetFileTime(info->handle, NULL, &at, &wt))
1914 {
1915 release_ioinfo(info);
1916 msvcrt_set_errno(GetLastError());
1917 return -1 ;
1918 }
1919 release_ioinfo(info);
1920 return 0;
1921 }
1922
1923 /*********************************************************************
1924 * _futime32 (MSVCRT.@)
1925 */
1926 int CDECL _futime32(int fd, struct __utimbuf32 *t)
1927 {
1928 if (t)
1929 {
1930 struct __utimbuf64 t64;
1931 t64.actime = t->actime;
1932 t64.modtime = t->modtime;
1933 return _futime64( fd, &t64 );
1934 }
1935 else
1936 return _futime64( fd, NULL );
1937 }
1938
1939 /*********************************************************************
1940 * _get_osfhandle (MSVCRT.@)
1941 */
1942 intptr_t CDECL _get_osfhandle(int fd)
1943 {
1944 HANDLE hand = get_ioinfo_nolock(fd)->handle;
1945 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1946
1947 if(hand == INVALID_HANDLE_VALUE)
1948 *_errno() = EBADF;
1949 return (intptr_t)hand;
1950 }
1951
1952 /*********************************************************************
1953 * _mktemp_s (MSVCRT.@)
1954 */
1955 int CDECL _mktemp_s(char *pattern, size_t size)
1956 {
1957 DWORD len, xno, id;
1958
1959 if(!MSVCRT_CHECK_PMT(pattern!=NULL))
1960 return EINVAL;
1961
1962 for(len=0; len<size; len++)
1963 if(!pattern[len])
1964 break;
1965 if(!MSVCRT_CHECK_PMT(len!=size && len>=6)) {
1966 if(size)
1967 pattern[0] = 0;
1968 return EINVAL;
1969 }
1970
1971 for(xno=1; xno<=6; xno++)
1972 if(!MSVCRT_CHECK_PMT(pattern[len-xno] == 'X'))
1973 return EINVAL;
1974
1975 id = GetCurrentProcessId();
1976 for(xno=1; xno<6; xno++) {
1977 pattern[len-xno] = id%10 + '0';
1978 id /= 10;
1979 }
1980
1981 for(pattern[len-6]='a'; pattern[len-6]<='z'; pattern[len-6]++) {
1982 if(GetFileAttributesA(pattern) == INVALID_FILE_ATTRIBUTES)
1983 return 0;
1984 }
1985
1986 pattern[0] = 0;
1987 *_errno() = EEXIST;
1988 return EEXIST;
1989 }
1990
1991 /*********************************************************************
1992 * _mktemp (MSVCRT.@)
1993 */
1994 char * CDECL _mktemp(char *pattern)
1995 {
1996 int numX = 0;
1997 char *retVal = pattern;
1998 int id;
1999 char letter = 'a';
2000
2001 if(!pattern)
2002 return NULL;
2003
2004 while(*pattern)
2005 numX = (*pattern++ == 'X')? numX + 1 : 0;
2006 if (numX < 6)
2007 return NULL;
2008 pattern--;
2009 id = GetCurrentProcessId();
2010 numX = 6;
2011 while(numX--)
2012 {
2013 int tempNum = id / 10;
2014 *pattern-- = id - (tempNum * 10) + '0';
2015 id = tempNum;
2016 }
2017 pattern++;
2018 do
2019 {
2020 *pattern = letter++;
2021 if (GetFileAttributesA(retVal) == INVALID_FILE_ATTRIBUTES)
2022 return retVal;
2023 } while(letter <= 'z');
2024 return NULL;
2025 }
2026
2027 /*********************************************************************
2028 * _wmktemp_s (MSVCRT.@)
2029 */
2030 int CDECL _wmktemp_s(wchar_t *pattern, size_t size)
2031 {
2032 DWORD len, xno, id;
2033
2034 if(!MSVCRT_CHECK_PMT(pattern!=NULL))
2035 return EINVAL;
2036
2037 for(len=0; len<size; len++)
2038 if(!pattern[len])
2039 break;
2040 if(!MSVCRT_CHECK_PMT(len!=size && len>=6)) {
2041 if(size)
2042 pattern[0] = 0;
2043 return EINVAL;
2044 }
2045
2046 for(xno=1; xno<=6; xno++)
2047 if(!MSVCRT_CHECK_PMT(pattern[len-xno] == 'X'))
2048 return EINVAL;
2049
2050 id = GetCurrentProcessId();
2051 for(xno=1; xno<6; xno++) {
2052 pattern[len-xno] = id%10 + '0';
2053 id /= 10;
2054 }
2055
2056 for(pattern[len-6]='a'; pattern[len-6]<='z'; pattern[len-6]++) {
2057 if(GetFileAttributesW(pattern) == INVALID_FILE_ATTRIBUTES)
2058 return 0;
2059 }
2060
2061 pattern[0] = 0;
2062 *_errno() = EEXIST;
2063 return EEXIST;
2064 }
2065
2066 /*********************************************************************
2067 * _wmktemp (MSVCRT.@)
2068 */
2069 wchar_t * CDECL _wmktemp(wchar_t *pattern)
2070 {
2071 int numX = 0;
2072 wchar_t *retVal = pattern;
2073 int id;
2074 wchar_t letter = 'a';
2075
2076 if(!pattern)
2077 return NULL;
2078
2079 while(*pattern)
2080 numX = (*pattern++ == 'X')? numX + 1 : 0;
2081 if (numX < 6)
2082 return NULL;
2083 pattern--;
2084 id = GetCurrentProcessId();
2085 numX = 6;
2086 while(numX--)
2087 {
2088 int tempNum = id / 10;
2089 *pattern-- = id - (tempNum * 10) + '0';
2090 id = tempNum;
2091 }
2092 pattern++;
2093 do
2094 {
2095 if (GetFileAttributesW(retVal) == INVALID_FILE_ATTRIBUTES)
2096 return retVal;
2097 *pattern = letter++;
2098 } while(letter != '|');
2099 return NULL;
2100 }
2101
2102 static unsigned split_oflags(unsigned oflags)
2103 {
2104 int wxflags = 0;
2105 unsigned unsupp; /* until we support everything */
2106
2107 if (oflags & _O_APPEND) wxflags |= WX_APPEND;
2108 if (oflags & _O_BINARY) {/* Nothing to do */}
2109 else if (oflags & _O_TEXT) wxflags |= WX_TEXT;
2110 else if (oflags & _O_WTEXT) wxflags |= WX_TEXT;
2111 else if (oflags & _O_U16TEXT) wxflags |= WX_TEXT;
2112 else if (oflags & _O_U8TEXT) wxflags |= WX_TEXT;
2113 else
2114 {
2115 int fmode;
2116 _get_fmode(&fmode);
2117 if (!(fmode & _O_BINARY)) wxflags |= WX_TEXT; /* default to TEXT*/
2118 }
2119 if (oflags & _O_NOINHERIT) wxflags |= WX_DONTINHERIT;
2120
2121 if ((unsupp = oflags & ~(_O_BINARY | _O_TEXT | _O_APPEND | _O_TRUNC | _O_EXCL | _O_CREAT |
2122 _O_RDWR | _O_WRONLY | _O_TEMPORARY | _O_NOINHERIT | _O_SEQUENTIAL |
2123 _O_RANDOM | _O_SHORT_LIVED | _O_WTEXT | _O_U16TEXT | _O_U8TEXT)))
2124 ERR(":unsupported oflags 0x%04x\n",unsupp);
2125
2126 return wxflags;
2127 }
2128
2129 /*********************************************************************
2130 * _pipe (MSVCRT.@)
2131 */
2132 int CDECL _pipe(int *pfds, unsigned int psize, int textmode)
2133 {
2134 int ret = -1;
2135 SECURITY_ATTRIBUTES sa;
2136 HANDLE readHandle, writeHandle;
2137
2138 if (!pfds)
2139 {
2140 *_errno() = EINVAL;
2141 return -1;
2142 }
2143
2144 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
2145 sa.bInheritHandle = !(textmode & _O_NOINHERIT);
2146 sa.lpSecurityDescriptor = NULL;
2147 if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
2148 {
2149 unsigned int wxflags = split_oflags(textmode);
2150 int fd;
2151
2152 fd = msvcrt_alloc_fd(readHandle, wxflags|WX_PIPE);
2153 if (fd != -1)
2154 {
2155 pfds[0] = fd;
2156 fd = msvcrt_alloc_fd(writeHandle, wxflags|WX_PIPE);
2157 if (fd != -1)
2158 {
2159 pfds[1] = fd;
2160 ret = 0;
2161 }
2162 else
2163 {
2164 _close(pfds[0]);
2165 CloseHandle(writeHandle);
2166 *_errno() = EMFILE;
2167 }
2168 }
2169 else
2170 {
2171 CloseHandle(readHandle);
2172 CloseHandle(writeHandle);
2173 *_errno() = EMFILE;
2174 }
2175 }
2176 else
2177 msvcrt_set_errno(GetLastError());
2178
2179 return ret;
2180 }
2181
2182 static int check_bom(HANDLE h, int oflags, BOOL seek)
2183 {
2184 char bom[sizeof(utf8_bom)];
2185 DWORD r;
2186
2187 if (!ReadFile(h, bom, sizeof(utf8_bom), &r, NULL))
2188 return oflags;
2189
2190 if (r==sizeof(utf8_bom) && !memcmp(bom, utf8_bom, sizeof(utf8_bom))) {
2191 oflags = (oflags & ~(_O_WTEXT | _O_U16TEXT)) | _O_U8TEXT;
2192 }else if (r>=sizeof(utf16_bom) && !memcmp(bom, utf16_bom, sizeof(utf16_bom))) {
2193 if (seek && r>2)
2194 SetFilePointer(h, 2, NULL, FILE_BEGIN);
2195 oflags = (oflags & ~(_O_WTEXT | _O_U8TEXT)) | _O_U16TEXT;
2196 }else if (seek) {
2197 SetFilePointer(h, 0, NULL, FILE_BEGIN);
2198 }
2199
2200 return oflags;
2201 }
2202
2203 /*********************************************************************
2204 * _wsopen_dispatch (UCRTBASE.@)
2205 */
2206 int CDECL _wsopen_dispatch( const wchar_t* path, int oflags, int shflags, int pmode,
2207 int *fd, int secure )
2208 {
2209 DWORD access = 0, creation = 0, attrib;
2210 SECURITY_ATTRIBUTES sa;
2211 DWORD sharing, type;
2212 int wxflag;
2213 HANDLE hand;
2214
2215 TRACE("path: (%s) oflags: 0x%04x shflags: 0x%04x pmode: 0x%04x fd*: %p secure: %d\n",
2216 debugstr_w(path), oflags, shflags, pmode, fd, secure);
2217
2218 if (!MSVCRT_CHECK_PMT( fd != NULL )) return EINVAL;
2219
2220 *fd = -1;
2221 wxflag = split_oflags(oflags);
2222 switch (oflags & (_O_RDONLY | _O_WRONLY | _O_RDWR))
2223 {
2224 case _O_RDONLY: access |= GENERIC_READ; break;
2225 case _O_WRONLY: access |= GENERIC_WRITE; break;
2226 case _O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
2227 }
2228
2229 if (oflags & _O_CREAT)
2230 {
2231 if (secure && !MSVCRT_CHECK_PMT(!(pmode & ~(_S_IREAD | _S_IWRITE))))
2232 return EINVAL;
2233
2234 if (oflags & _O_EXCL)
2235 creation = CREATE_NEW;
2236 else if (oflags & _O_TRUNC)
2237 creation = CREATE_ALWAYS;
2238 else
2239 creation = OPEN_ALWAYS;
2240 }
2241 else /* no _O_CREAT */
2242 {
2243 if (oflags & _O_TRUNC)
2244 creation = TRUNCATE_EXISTING;
2245 else
2246 creation = OPEN_EXISTING;
2247 }
2248
2249 switch( shflags )
2250 {
2251 case _SH_DENYRW:
2252 sharing = 0L;
2253 break;
2254 case _SH_DENYWR:
2255 sharing = FILE_SHARE_READ;
2256 break;
2257 case _SH_DENYRD:
2258 sharing = FILE_SHARE_WRITE;
2259 break;
2260 case _SH_DENYNO:
2261 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
2262 break;
2263 default:
2264 ERR( "Unhandled shflags 0x%x\n", shflags );
2265 return EINVAL;
2266 }
2267
2268 if (!(pmode & ~MSVCRT_umask & _S_IWRITE))
2269 attrib = FILE_ATTRIBUTE_READONLY;
2270 else
2271 attrib = FILE_ATTRIBUTE_NORMAL;
2272
2273 if (oflags & _O_TEMPORARY)
2274 {
2275 attrib |= FILE_FLAG_DELETE_ON_CLOSE;
2276 access |= DELETE;
2277 sharing |= FILE_SHARE_DELETE;
2278 }
2279
2280 if (oflags & _O_RANDOM)
2281 attrib |= FILE_FLAG_RANDOM_ACCESS;
2282 if (oflags & _O_SEQUENTIAL)
2283 attrib |= FILE_FLAG_SEQUENTIAL_SCAN;
2284 if (oflags & _O_SHORT_LIVED)
2285 attrib |= FILE_ATTRIBUTE_TEMPORARY;
2286
2287 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
2288 sa.lpSecurityDescriptor = NULL;
2289 sa.bInheritHandle = !(oflags & _O_NOINHERIT);
2290
2291 if ((oflags & (_O_WTEXT | _O_U16TEXT | _O_U8TEXT))
2292 && (creation==OPEN_ALWAYS || creation==OPEN_EXISTING)
2293 && !(access&GENERIC_READ))
2294 {
2295 hand = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
2296 &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2297 if (hand != INVALID_HANDLE_VALUE)
2298 {
2299 oflags = check_bom(hand, oflags, FALSE);
2300 CloseHandle(hand);
2301 }
2302 }
2303
2304 hand = CreateFileW(path, access, sharing, &sa, creation, attrib, 0);
2305 if (hand == INVALID_HANDLE_VALUE) {
2306 WARN(":failed-last error (%d)\n",GetLastError());
2307 msvcrt_set_errno(GetLastError());
2308 return *_errno();
2309 }
2310
2311 if (oflags & (_O_WTEXT | _O_U16TEXT | _O_U8TEXT))
2312 {
2313 LARGE_INTEGER size = {{0}};
2314
2315 if ((access & GENERIC_WRITE) && (creation==OPEN_EXISTING || creation==OPEN_ALWAYS))
2316 GetFileSizeEx(hand, &size);
2317
2318 if ((access & GENERIC_WRITE) && (creation==CREATE_NEW
2319 || creation==CREATE_ALWAYS || creation==TRUNCATE_EXISTING
2320 || ((creation==OPEN_EXISTING || creation==OPEN_ALWAYS) && !size.QuadPart)))
2321 {
2322 if (oflags & _O_U8TEXT)
2323 {
2324 DWORD written = 0, tmp;
2325
2326 while(written!=sizeof(utf8_bom) && WriteFile(hand, (char*)utf8_bom+written,
2327 sizeof(utf8_bom)-written, &tmp, NULL))
2328 written += tmp;
2329 if (written != sizeof(utf8_bom)) {
2330 WARN("error writing BOM\n");
2331 CloseHandle(hand);
2332 msvcrt_set_errno(GetLastError());
2333 return *_errno();
2334 }
2335 }
2336 else
2337 {
2338 DWORD written = 0, tmp;
2339
2340 while(written!=sizeof(utf16_bom) && WriteFile(hand, (char*)utf16_bom+written,
2341 sizeof(utf16_bom)-written, &tmp, NULL))
2342 written += tmp;
2343 if (written != sizeof(utf16_bom))
2344 {
2345 WARN("error writing BOM\n");
2346 CloseHandle(hand);
2347 msvcrt_set_errno(GetLastError());
2348 return *_errno();
2349 }
2350 oflags |= _O_U16TEXT;
2351 }
2352 }
2353 else if (access & GENERIC_READ)
2354 oflags = check_bom(hand, oflags, TRUE);
2355 }
2356
2357 type = GetFileType(hand);
2358 if (type == FILE_TYPE_CHAR)
2359 wxflag |= WX_TTY;
2360 else if (type == FILE_TYPE_PIPE)
2361 wxflag |= WX_PIPE;
2362
2363 *fd = msvcrt_alloc_fd(hand, wxflag);
2364 if (*fd == -1)
2365 return *_errno();
2366
2367 if (oflags & _O_WTEXT)
2368 get_ioinfo_nolock(*fd)->exflag |= EF_UNK_UNICODE;
2369
2370 if (oflags & _O_U16TEXT)
2371 get_ioinfo_nolock(*fd)->exflag |= EF_UTF16;
2372 else if (oflags & _O_U8TEXT)
2373 get_ioinfo_nolock(*fd)->exflag |= EF_UTF8;
2374
2375 TRACE(":fd (%d) handle (%p)\n", *fd, hand);
2376 return 0;
2377 }
2378
2379
2380 /*********************************************************************
2381 * _wsopen_s (MSVCRT.@)
2382 */
2383 int CDECL _wsopen_s( int *fd, const wchar_t* path, int oflags, int shflags, int pmode )
2384 {
2385 return _wsopen_dispatch( path, oflags, shflags, pmode, fd, 1 );
2386 }
2387
2388 /*********************************************************************
2389 * _wsopen (MSVCRT.@)
2390 */
2391 int WINAPIV _wsopen( const wchar_t *path, int oflags, int shflags, ... )
2392 {
2393 int pmode;
2394 int fd;
2395
2396 if (oflags & _O_CREAT)
2397 {
2398 va_list ap;
2399
2400 va_start(ap, shflags);
2401 pmode = va_arg(ap, int);
2402 va_end(ap);
2403 }
2404 else
2405 pmode = 0;
2406
2407 return _wsopen_dispatch(path, oflags, shflags, pmode, &fd, 0) ? -1 : fd;
2408 }
2409
2410
2411 /*********************************************************************
2412 * _sopen_dispatch (UCRTBASE.@)
2413 */
2414 int CDECL _sopen_dispatch( const char *path, int oflags, int shflags,
2415 int pmode, int *fd, int secure)
2416 {
2417 wchar_t *pathW;
2418 int ret;
2419
2420 if (!MSVCRT_CHECK_PMT(fd != NULL))
2421 return EINVAL;
2422 *fd = -1;
2423 if(!MSVCRT_CHECK_PMT(path && (pathW = msvcrt_wstrdupa(path))))
2424 return EINVAL;
2425
2426 ret = _wsopen_dispatch(pathW, oflags, shflags, pmode, fd, secure);
2427 free(pathW);
2428 return ret;
2429 }
2430
2431 /*********************************************************************
2432 * _sopen_s (MSVCRT.@)
2433 */
2434 int CDECL _sopen_s( int *fd, const char *path, int oflags, int shflags, int pmode )
2435 {
2436 return _sopen_dispatch(path, oflags, shflags, pmode, fd, 1);
2437 }
2438
2439 /*********************************************************************
2440 * _sopen (MSVCRT.@)
2441 */
2442 int WINAPIV _sopen( const char *path, int oflags, int shflags, ... )
2443 {
2444 int pmode;
2445 int fd;
2446
2447 if (oflags & _O_CREAT)
2448 {
2449 va_list ap;
2450
2451 va_start(ap, shflags);
2452 pmode = va_arg(ap, int);
2453 va_end(ap);
2454 }
2455 else
2456 pmode = 0;
2457
2458 return _sopen_dispatch(path, oflags, shflags, pmode, &fd, 0) ? -1 : fd;
2459 }
2460
2461 /*********************************************************************
2462 * _open (MSVCRT.@)
2463 */
2464 int WINAPIV _open( const char *path, int flags, ... )
2465 {
2466 va_list ap;
2467
2468 if (flags & _O_CREAT)
2469 {
2470 int pmode;
2471 va_start(ap, flags);
2472 pmode = va_arg(ap, int);
2473 va_end(ap);
2474 return _sopen( path, flags, _SH_DENYNO, pmode );
2475 }
2476 else
2477 return _sopen( path, flags, _SH_DENYNO);
2478 }
2479
2480 /*********************************************************************
2481 * _wopen (MSVCRT.@)
2482 */
2483 int WINAPIV _wopen(const wchar_t *path,int flags,...)
2484 {
2485 va_list ap;
2486
2487 if (flags & _O_CREAT)
2488 {
2489 int pmode;
2490 va_start(ap, flags);
2491 pmode = va_arg(ap, int);
2492 va_end(ap);
2493 return _wsopen( path, flags, _SH_DENYNO, pmode );
2494 }
2495 else
2496 return _wsopen( path, flags, _SH_DENYNO);
2497 }
2498
2499 /*********************************************************************
2500 * _creat (MSVCRT.@)
2501 */
2502 int CDECL _creat(const char *path, int pmode)
2503 {
2504 int flags = _O_CREAT | _O_TRUNC | _O_RDWR;
2505 return _open(path, flags, pmode);
2506 }
2507
2508 /*********************************************************************
2509 * _wcreat (MSVCRT.@)
2510 */
2511 int CDECL _wcreat(const wchar_t *path, int pmode)
2512 {
2513 int flags = _O_CREAT | _O_TRUNC | _O_RDWR;
2514 return _wopen(path, flags, pmode);
2515 }
2516
2517 /*********************************************************************
2518 * _open_osfhandle (MSVCRT.@)
2519 */
2520 int CDECL _open_osfhandle(intptr_t handle, int oflags)
2521 {
2522 DWORD flags;
2523 int fd;
2524
2525 /* _O_RDONLY (0) always matches, so set the read flag
2526 * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
2527 * file, so set the write flag. It also only sets _O_TEXT if it wants
2528 * text - it never sets _O_BINARY.
2529 */
2530 /* don't let split_oflags() decide the mode if no mode is passed */
2531 if (!(oflags & (_O_BINARY | _O_TEXT)))
2532 oflags |= _O_BINARY;
2533
2534 flags = GetFileType((HANDLE)handle);
2535 if (flags==FILE_TYPE_UNKNOWN && GetLastError()!=NO_ERROR)
2536 {
2537 msvcrt_set_errno(GetLastError());
2538 return -1;
2539 }
2540
2541 if (flags == FILE_TYPE_CHAR)
2542 flags = WX_TTY;
2543 else if (flags == FILE_TYPE_PIPE)
2544 flags = WX_PIPE;
2545 else
2546 flags = 0;
2547 flags |= split_oflags(oflags);
2548
2549 fd = msvcrt_alloc_fd((HANDLE)handle, flags);
2550 TRACE(":handle (%Iu) fd (%d) flags 0x%08x\n", handle, fd, flags);
2551 return fd;
2552 }
2553
2554 /*********************************************************************
2555 * _rmtmp (MSVCRT.@)
2556 */
2557 int CDECL _rmtmp(void)
2558 {
2559 int num_removed = 0, i;
2560 FILE *file;
2561
2562 LOCK_FILES();
2563 for (i = 3; i < MSVCRT_stream_idx; i++) {
2564 file = msvcrt_get_file(i);
2565
2566 if (file->_tmpfname)
2567 {
2568 fclose(file);
2569 num_removed++;
2570 }
2571 }
2572 UNLOCK_FILES();
2573
2574 if (num_removed)
2575 TRACE(":removed (%d) temp files\n",num_removed);
2576 return num_removed;
2577 }
2578
2579 static inline int get_utf8_char_len(char ch)
2580 {
2581 if((ch&0xf8) == 0xf0)
2582 return 4;
2583 else if((ch&0xf0) == 0xe0)
2584 return 3;
2585 else if((ch&0xe0) == 0xc0)
2586 return 2;
2587 return 1;
2588 }
2589
2590 /*********************************************************************
2591 * (internal) read_utf8
2592 */
2593 static int read_utf8(ioinfo *fdinfo, wchar_t *buf, unsigned int count)
2594 {
2595 HANDLE hand = fdinfo->handle;
2596 char min_buf[4], *readbuf, lookahead;
2597 DWORD readbuf_size, pos=0, num_read=1, char_len, i, j;
2598
2599 /* make the buffer big enough to hold at least one character */
2600 /* read bytes have to fit to output and lookahead buffers */
2601 count /= 2;
2602 readbuf_size = count < 4 ? 4 : count;
2603 if(readbuf_size<=4 || !(readbuf = malloc(readbuf_size))) {
2604 readbuf_size = 4;
2605 readbuf = min_buf;
2606 }
2607
2608 if(fdinfo->lookahead[0] != '\n') {
2609 readbuf[pos++] = fdinfo->lookahead[0];
2610 fdinfo->lookahead[0] = '\n';
2611
2612 if(fdinfo->lookahead[1] != '\n') {
2613 readbuf[pos++] = fdinfo->lookahead[1];
2614 fdinfo->lookahead[1] = '\n';
2615
2616 if(fdinfo->lookahead[2] != '\n') {
2617 readbuf[pos++] = fdinfo->lookahead[2];
2618 fdinfo->lookahead[2] = '\n';
2619 }
2620 }
2621 }
2622
2623 /* NOTE: this case is broken in native dll, reading
2624 * sometimes fails when small buffer is passed
2625 */
2626 if(count < 4) {
2627 if(!pos && !ReadFile(hand, readbuf, 1, &num_read, NULL)) {
2628 if (GetLastError() == ERROR_BROKEN_PIPE) {
2629 fdinfo->wxflag |= WX_ATEOF;
2630 return 0;
2631 }else {
2632 msvcrt_set_errno(GetLastError());
2633 return -1;
2634 }
2635 }else if(!num_read) {
2636 fdinfo->wxflag |= WX_ATEOF;
2637 return 0;
2638 }else {
2639 pos++;
2640 }
2641
2642 char_len = get_utf8_char_len(readbuf[0]);
2643 if(char_len>pos) {
2644 if(ReadFile(hand, readbuf+pos, char_len-pos, &num_read, NULL))
2645 pos += num_read;
2646 }
2647
2648 if(readbuf[0] == '\n')
2649 fdinfo->wxflag |= WX_READNL;
2650 else
2651 fdinfo->wxflag &= ~WX_READNL;
2652
2653 if(readbuf[0] == 0x1a) {
2654 fdinfo->wxflag |= WX_ATEOF;
2655 return 0;
2656 }
2657
2658 if(readbuf[0] == '\r') {
2659 if(!ReadFile(hand, &lookahead, 1, &num_read, NULL) || num_read!=1)
2660 buf[0] = '\r';
2661 else if(lookahead == '\n')
2662 buf[0] = '\n';
2663 else {
2664 buf[0] = '\r';
2665 if(fdinfo->wxflag & (WX_PIPE | WX_TTY))
2666 fdinfo->lookahead[0] = lookahead;
2667 else
2668 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2669 }
2670 return 2;
2671 }
2672
2673 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2674 msvcrt_set_errno(GetLastError());
2675 return -1;
2676 }
2677
2678 return num_read*2;
2679 }
2680
2681 if(!ReadFile(hand, readbuf+pos, readbuf_size-pos, &num_read, NULL)) {
2682 if(pos) {
2683 num_read = 0;
2684 }else if(GetLastError() == ERROR_BROKEN_PIPE) {
2685 fdinfo->wxflag |= WX_ATEOF;
2686 if (readbuf != min_buf) free(readbuf);
2687 return 0;
2688 }else {
2689 msvcrt_set_errno(GetLastError());
2690 if (readbuf != min_buf) free(readbuf);
2691 return -1;
2692 }
2693 }else if(!pos && !num_read) {
2694 fdinfo->wxflag |= WX_ATEOF;
2695 if (readbuf != min_buf) free(readbuf);
2696 return 0;
2697 }
2698
2699 pos += num_read;
2700 if(readbuf[0] == '\n')
2701 fdinfo->wxflag |= WX_READNL;
2702 else
2703 fdinfo->wxflag &= ~WX_READNL;
2704
2705 /* Find first byte of last character (may be incomplete) */
2706 for(i=pos-1; i>0 && i>pos-4; i--)
2707 if((readbuf[i]&0xc0) != 0x80)
2708 break;
2709 char_len = get_utf8_char_len(readbuf[i]);
2710 if(char_len+i <= pos)
2711 i += char_len;
2712
2713 if(fdinfo->wxflag & (WX_PIPE | WX_TTY)) {
2714 if(i < pos)
2715 fdinfo->lookahead[0] = readbuf[i];
2716 if(i+1 < pos)
2717 fdinfo->lookahead[1] = readbuf[i+1];
2718 if(i+2 < pos)
2719 fdinfo->lookahead[2] = readbuf[i+2];
2720 }else if(i < pos) {
2721 SetFilePointer(fdinfo->handle, i-pos, NULL, FILE_CURRENT);
2722 }
2723 pos = i;
2724
2725 for(i=0, j=0; i<pos; i++) {
2726 if(readbuf[i] == 0x1a) {
2727 fdinfo->wxflag |= WX_ATEOF;
2728 break;
2729 }
2730
2731 /* strip '\r' if followed by '\n' */
2732 if(readbuf[i] == '\r' && i+1==pos) {
2733 if(fdinfo->lookahead[0] != '\n' || !ReadFile(hand, &lookahead, 1, &num_read, NULL) || !num_read) {
2734 readbuf[j++] = '\r';
2735 }else if(lookahead == '\n' && j==0) {
2736 readbuf[j++] = '\n';
2737 }else {
2738 if(lookahead != '\n')
2739 readbuf[j++] = '\r';
2740
2741 if(fdinfo->wxflag & (WX_PIPE | WX_TTY))
2742 fdinfo->lookahead[0] = lookahead;
2743 else
2744 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2745 }
2746 }else if(readbuf[i]!='\r' || readbuf[i+1]!='\n') {
2747 readbuf[j++] = readbuf[i];
2748 }
2749 }
2750 pos = j;
2751
2752 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2753 msvcrt_set_errno(GetLastError());
2754 if (readbuf != min_buf) free(readbuf);
2755 return -1;
2756 }
2757
2758 if (readbuf != min_buf) free(readbuf);
2759 return num_read*2;
2760 }
2761
2762 /*********************************************************************
2763 * (internal) read_i
2764 *
2765 * When reading \r as last character in text mode, read() positions
2766 * the file pointer on the \r character while getc() goes on to
2767 * the following \n
2768 */
2769 static int read_i(int fd, ioinfo *fdinfo, void *buf, unsigned int count)
2770 {
2771 DWORD num_read, utf16;
2772 char *bufstart = buf;
2773
2774 if (count == 0)
2775 return 0;
2776
2777 if (fdinfo->wxflag & WX_ATEOF) {
2778 TRACE("already at EOF, returning 0\n");
2779 return 0;
2780 }
2781 /* Don't trace small reads, it gets *very* annoying */
2782 if (count > 4)
2783 TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n", fd, fdinfo->handle, buf, count);
2784 if (fdinfo->handle == INVALID_HANDLE_VALUE)
2785 {
2786 *_errno() = EBADF;
2787 return -1;
2788 }
2789
2790 utf16 = (fdinfo->exflag & EF_UTF16) != 0;
2791 if (((fdinfo->exflag&EF_UTF8) || utf16) && count&1)
2792 {
2793 *_errno() = EINVAL;
2794 return -1;
2795 }
2796
2797 if((fdinfo->wxflag&WX_TEXT) && (fdinfo->exflag&EF_UTF8))
2798 return read_utf8(fdinfo, buf, count);
2799
2800 if (fdinfo->lookahead[0]!='\n' || ReadFile(fdinfo->handle, bufstart, count, &num_read, NULL))
2801 {
2802 if (fdinfo->lookahead[0] != '\n')
2803 {
2804 bufstart[0] = fdinfo->lookahead[0];
2805 fdinfo->lookahead[0] = '\n';
2806
2807 if (utf16)
2808 {
2809 bufstart[1] = fdinfo->lookahead[1];
2810 fdinfo->lookahead[1] = '\n';
2811 }
2812
2813 if(count>1+utf16 && ReadFile(fdinfo->handle, bufstart+1+utf16, count-1-utf16, &num_read, NULL))
2814 num_read += 1+utf16;
2815 else
2816 num_read = 1+utf16;
2817 }
2818
2819 if(utf16 && (num_read&1))
2820 {
2821 /* msvcr90 uses uninitialized value from the buffer in this case */
2822 /* msvcrt ignores additional data */
2823 ERR("got odd number of bytes in UTF16 mode\n");
2824 num_read--;
2825 }
2826
2827 if (count != 0 && num_read == 0)
2828 {
2829 fdinfo->wxflag |= WX_ATEOF;
2830 TRACE(":EOF %s\n",debugstr_an(buf,num_read));
2831 }
2832 else if (fdinfo->wxflag & WX_TEXT)
2833 {
2834 DWORD i, j;
2835
2836 if (bufstart[0]=='\n' && (!utf16 || bufstart[1]==0))
2837 fdinfo->wxflag |= WX_READNL;
2838 else
2839 fdinfo->wxflag &= ~WX_READNL;
2840
2841 for (i=0, j=0; i<num_read; i+=1+utf16)
2842 {
2843 /* in text mode, a ctrl-z signals EOF */
2844 if (bufstart[i]==0x1a && (!utf16 || bufstart[i+1]==0))
2845 {
2846 fdinfo->wxflag |= WX_ATEOF;
2847 TRACE(":^Z EOF %s\n",debugstr_an(buf,num_read));
2848 break;
2849 }
2850
2851 /* in text mode, strip \r if followed by \n */
2852 if (bufstart[i]=='\r' && (!utf16 || bufstart[i+1]==0) && i+1+utf16==num_read)
2853 {
2854 char lookahead[2];
2855 DWORD len;
2856
2857 lookahead[1] = '\n';
2858 if (ReadFile(fdinfo->handle, lookahead, 1+utf16, &len, NULL) && len)
2859 {
2860 if(lookahead[0]=='\n' && (!utf16 || lookahead[1]==0) && j==0)
2861 {
2862 bufstart[j++] = '\n';
2863 if(utf16) bufstart[j++] = 0;
2864 }
2865 else
2866 {
2867 if(lookahead[0]!='\n' || (utf16 && lookahead[1]!=0))
2868 {
2869 bufstart[j++] = '\r';
2870 if(utf16) bufstart[j++] = 0;
2871 }
2872
2873 if (fdinfo->wxflag & (WX_PIPE | WX_TTY))
2874 {
2875 if (lookahead[0]=='\n' && (!utf16 || !lookahead[1]))
2876 {
2877 bufstart[j++] = '\n';
2878 if (utf16) bufstart[j++] = 0;
2879 }
2880 else
2881 {
2882 fdinfo->lookahead[0] = lookahead[0];
2883 fdinfo->lookahead[1] = lookahead[1];
2884 }
2885 }
2886 else
2887 SetFilePointer(fdinfo->handle, -1-utf16, NULL, FILE_CURRENT);
2888 }
2889 }
2890 else
2891 {
2892 bufstart[j++] = '\r';
2893 if(utf16) bufstart[j++] = 0;
2894 }
2895 }
2896 else if((bufstart[i]!='\r' || (utf16 && bufstart[i+1]!=0))
2897 || (bufstart[i+1+utf16]!='\n' || (utf16 && bufstart[i+3]!=0)))
2898 {
2899 bufstart[j++] = bufstart[i];
2900 if(utf16) bufstart[j++] = bufstart[i+1];
2901 }
2902 }
2903 num_read = j;
2904 }
2905 }
2906 else
2907 {
2908 if (GetLastError() == ERROR_BROKEN_PIPE)
2909 {
2910 TRACE(":end-of-pipe\n");
2911 fdinfo->wxflag |= WX_ATEOF;
2912 return 0;
2913 }
2914 else
2915 {
2916 TRACE(":failed-last error (%d)\n",GetLastError());
2917 msvcrt_set_errno(GetLastError());
2918 return -1;
2919 }
2920 }
2921
2922 if (count > 4)
2923 TRACE("(%u), %s\n",num_read,debugstr_an(buf, num_read));
2924 return num_read;
2925 }
2926
2927 /*********************************************************************
2928 * _read (MSVCRT.@)
2929 */
2930 int CDECL _read(int fd, void *buf, unsigned int count)
2931 {
2932 ioinfo *info;
2933 int num_read;
2934
2935 if(fd == MSVCRT_NO_CONSOLE_FD) {
2936 *_errno() = EBADF;
2937 return -1;
2938 }
2939
2940 info = get_ioinfo(fd);
2941 num_read = read_i(fd, info, buf, count);
2942 release_ioinfo(info);
2943 return num_read;
2944 }
2945
2946 /*********************************************************************
2947 * _setmode (MSVCRT.@)
2948 */
2949 int CDECL _setmode(int fd,int mode)
2950 {
2951 ioinfo *info = get_ioinfo(fd);
2952 int ret = info->wxflag & WX_TEXT ? _O_TEXT : _O_BINARY;
2953 if(ret==_O_TEXT && (info->exflag & (EF_UTF8|EF_UTF16)))
2954 ret = _O_WTEXT;
2955
2956 if(mode!=_O_TEXT && mode!=_O_BINARY && mode!=_O_WTEXT
2957 && mode!=_O_U16TEXT && mode!=_O_U8TEXT) {
2958 *_errno() = EINVAL;
2959 release_ioinfo(info);
2960 return -1;
2961 }
2962
2963 if(info == &MSVCRT___badioinfo) {
2964 *_errno() = EBADF;
2965 return EOF;
2966 }
2967
2968 if(mode == _O_BINARY) {
2969 info->wxflag &= ~WX_TEXT;
2970 info->exflag &= ~(EF_UTF8|EF_UTF16);
2971 release_ioinfo(info);
2972 return ret;
2973 }
2974
2975 info->wxflag |= WX_TEXT;
2976 if(mode == _O_TEXT)
2977 info->exflag &= ~(EF_UTF8|EF_UTF16);
2978 else if(mode == _O_U8TEXT)
2979 info->exflag = (info->exflag & ~EF_UTF16) | EF_UTF8;
2980 else
2981 info->exflag = (info->exflag & ~EF_UTF8) | EF_UTF16;
2982
2983 release_ioinfo(info);
2984 return ret;
2985 }
2986
2987 /*********************************************************************
2988 * _stat64 (MSVCRT.@)
2989 */
2990 int CDECL _stat64(const char* path, struct _stat64 * buf)
2991 {
2992 DWORD dw;
2993 WIN32_FILE_ATTRIBUTE_DATA hfi;
2994 unsigned short mode = ALL_S_IREAD;
2995 int plen;
2996
2997 TRACE(":file (%s) buf(%p)\n",path,buf);
2998
2999 plen = strlen(path);
3000 while (plen && path[plen-1]==' ')
3001 plen--;
3002
3003 if (plen==2 && path[1]==':')
3004 {
3005 *_errno() = ENOENT;
3006 return -1;
3007 }
3008
3009 #if _MSVCR_VER<140
3010 if (plen>=2 && path[plen-2]!=':' && (path[plen-1]=='\\' || path[plen-1]=='/'))
3011 {
3012 *_errno() = ENOENT;
3013 return -1;
3014 }
3015 #endif
3016
3017 if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
3018 {
3019 TRACE("failed (%d)\n",GetLastError());
3020 *_errno() = ENOENT;
3021 return -1;
3022 }
3023
3024 memset(buf,0,sizeof(struct _stat64));
3025
3026 /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
3027 Bon 011120: This FIXME seems incorrect
3028 Also a letter as first char isn't enough to be classified
3029 as a drive letter
3030 */
3031 if (isalpha(*path)&& (*(path+1)==':'))
3032 buf->st_dev = buf->st_rdev = _toupper_l(*path, NULL) - 'A'; /* drive num */
3033 else
3034 buf->st_dev = buf->st_rdev = _getdrive() - 1;
3035
3036 /* Dir, or regular file? */
3037 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
3038 mode |= (_S_IFDIR | ALL_S_IEXEC);
3039 else
3040 {
3041 mode |= _S_IFREG;
3042 /* executable? */
3043 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
3044 {
3045 unsigned int ext = _tolower_l(path[plen-1], NULL) |
3046 (_tolower_l(path[plen-2], NULL) << 8) |
3047 (_tolower_l(path[plen-3], NULL) << 16);
3048 if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
3049 mode |= ALL_S_IEXEC;
3050 }
3051 }
3052
3053 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
3054 mode |= ALL_S_IWRITE;
3055
3056 buf->st_mode = mode;
3057 buf->st_nlink = 1;
3058 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
3059 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
3060 buf->st_atime = dw;
3061 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
3062 buf->st_mtime = buf->st_ctime = dw;
3063 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
3064 (int)(buf->st_size >> 32),(int)buf->st_size,
3065 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
3066 return 0;
3067 }
3068
3069 /*********************************************************************
3070 * _stati64 (MSVCRT.@)
3071 */
3072 int CDECL _stati64(const char* path, struct _stati64 * buf)
3073 {
3074 int ret;
3075 struct _stat64 buf64;
3076
3077 ret = _stat64(path, &buf64);
3078 if (!ret)
3079 msvcrt_stat64_to_stati64(&buf64, buf);
3080 return ret;
3081 }
3082
3083 /*********************************************************************
3084 * _stat (MSVCRT.@)
3085 */
3086 int CDECL _stat(const char* path, struct _stat * buf)
3087 {
3088 int ret;
3089 struct _stat64 buf64;
3090
3091 ret = _stat64( path, &buf64);
3092 if (!ret)
3093 msvcrt_stat64_to_stat(&buf64, buf);
3094 return ret;
3095 }
3096
3097 #if _MSVCR_VER >= 80
3098
3099 /*********************************************************************
3100 * _stat32 (MSVCR80.@)
3101 */
3102 int CDECL _stat32(const char *path, struct _stat32 *buf)
3103 {
3104 int ret;
3105 struct _stat64 buf64;
3106
3107 ret = _stat64(path, &buf64);
3108 if (!ret)
3109 msvcrt_stat64_to_stat32(&buf64, buf);
3110 return ret;
3111 }
3112
3113 /*********************************************************************
3114 * _stat32i64 (MSVCR80.@)
3115 */
3116 int CDECL _stat32i64(const char *path, struct _stat32i64 *buf)
3117 {
3118 int ret;
3119 struct _stat64 buf64;
3120
3121 ret = _stat64(path, &buf64);
3122 if (!ret)
3123 msvcrt_stat64_to_stat32i64(&buf64, buf);
3124 return ret;
3125 }
3126
3127 /*********************************************************************
3128 * _stat64i32 (MSVCR80.@)
3129 */
3130 int CDECL _stat64i32(const char* path, struct _stat64i32 *buf)
3131 {
3132 int ret;
3133 struct _stat64 buf64;
3134
3135 ret = _stat64(path, &buf64);
3136 if (!ret)
3137 msvcrt_stat64_to_stat64i32(&buf64, buf);
3138 return ret;
3139 }
3140
3141 #endif /* _MSVCR_VER >= 80 */
3142
3143 /*********************************************************************
3144 * _wstat64 (MSVCRT.@)
3145 */
3146 int CDECL _wstat64(const wchar_t* path, struct _stat64 * buf)
3147 {
3148 DWORD dw;
3149 WIN32_FILE_ATTRIBUTE_DATA hfi;
3150 unsigned short mode = ALL_S_IREAD;
3151 int plen;
3152
3153 TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
3154
3155 plen = wcslen(path);
3156 while (plen && path[plen-1]==' ')
3157 plen--;
3158
3159 if (plen==2 && path[1]==':')
3160 {
3161 *_errno() = ENOENT;
3162 return -1;
3163 }
3164
3165 #if _MSVCR_VER<140
3166 if (plen>=2 && path[plen-2]!=':' && (path[plen-1]=='\\' || path[plen-1]=='/'))
3167 {
3168 *_errno() = ENOENT;
3169 return -1;
3170 }
3171 #endif
3172
3173 if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
3174 {
3175 TRACE("failed (%d)\n",GetLastError());
3176 *_errno() = ENOENT;
3177 return -1;
3178 }
3179
3180 memset(buf,0,sizeof(struct _stat64));
3181
3182 /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
3183 if (iswalpha(*path) && path[1] == ':')
3184 buf->st_dev = buf->st_rdev = towupper(*path) - 'A'; /* drive num */
3185 else
3186 buf->st_dev = buf->st_rdev = _getdrive() - 1;
3187
3188 /* Dir, or regular file? */
3189 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
3190 mode |= (_S_IFDIR | ALL_S_IEXEC);
3191 else
3192 {
3193 mode |= _S_IFREG;
3194 /* executable? */
3195 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
3196 {
3197 ULONGLONG ext = towlower(path[plen-1]) | (towlower(path[plen-2]) << 16) |
3198 ((ULONGLONG)towlower(path[plen-3]) << 32);
3199 if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
3200 mode |= ALL_S_IEXEC;
3201 }
3202 }
3203
3204 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
3205 mode |= ALL_S_IWRITE;
3206
3207 buf->st_mode = mode;
3208 buf->st_nlink = 1;
3209 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
3210 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
3211 buf->st_atime = dw;
3212 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
3213 buf->st_mtime = buf->st_ctime = dw;
3214 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
3215 (int)(buf->st_size >> 32),(int)buf->st_size,
3216 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
3217 return 0;
3218 }
3219
3220 /*********************************************************************
3221 * _wstati64 (MSVCRT.@)
3222 */
3223 int CDECL _wstati64(const wchar_t* path, struct _stati64 * buf)
3224 {
3225 int ret;
3226 struct _stat64 buf64;
3227
3228 ret = _wstat64(path, &buf64);
3229 if (!ret)
3230 msvcrt_stat64_to_stati64(&buf64, buf);
3231 return ret;
3232 }
3233
3234 /*********************************************************************
3235 * _wstat (MSVCRT.@)
3236 */
3237 int CDECL _wstat(const wchar_t* path, struct _stat * buf)
3238 {
3239 int ret;
3240 struct _stat64 buf64;
3241
3242 ret = _wstat64( path, &buf64 );
3243 if (!ret) msvcrt_stat64_to_stat(&buf64, buf);
3244 return ret;
3245 }
3246
3247 #if _MSVCR_VER >= 80
3248
3249 /*********************************************************************
3250 * _wstat32 (MSVCR80.@)
3251 */
3252 int CDECL _wstat32(const wchar_t *path, struct _stat32 *buf)
3253 {
3254 int ret;
3255 struct _stat64 buf64;
3256
3257 ret = _wstat64(path, &buf64);
3258 if (!ret)
3259 msvcrt_stat64_to_stat32(&buf64, buf);
3260 return ret;
3261 }
3262
3263 /*********************************************************************
3264 * _wstat32i64 (MSVCR80.@)
3265 */
3266 int CDECL _wstat32i64(const wchar_t *path, struct _stat32i64 *buf)
3267 {
3268 int ret;
3269 struct _stat64 buf64;
3270
3271 ret = _wstat64(path, &buf64);
3272 if (!ret)
3273 msvcrt_stat64_to_stat32i64(&buf64, buf);
3274 return ret;
3275 }
3276
3277 /*********************************************************************
3278 * _wstat64i32 (MSVCR80.@)
3279 */
3280 int CDECL _wstat64i32(const wchar_t *path, struct _stat64i32 *buf)
3281 {
3282 int ret;
3283 struct _stat64 buf64;
3284
3285 ret = _wstat64(path, &buf64);
3286 if (!ret)
3287 msvcrt_stat64_to_stat64i32(&buf64, buf);
3288 return ret;
3289 }
3290
3291 #endif /* _MSVCR_VER >= 80 */
3292
3293 /*********************************************************************
3294 * _tell (MSVCRT.@)
3295 */
3296 __msvcrt_long CDECL _tell(int fd)
3297 {
3298 return _lseek(fd, 0, SEEK_CUR);
3299 }
3300
3301 /*********************************************************************
3302 * _telli64 (MSVCRT.@)
3303 */
3304 __int64 CDECL _telli64(int fd)
3305 {
3306 return _lseeki64(fd, 0, SEEK_CUR);
3307 }
3308
3309 /*********************************************************************
3310 * _tempnam (MSVCRT.@)
3311 */
3312 char * CDECL _tempnam(const char *dir, const char *prefix)
3313 {
3314 char tmpbuf[MAX_PATH];
3315 const char *tmp_dir = getenv("TMP");
3316
3317 if (tmp_dir) dir = tmp_dir;
3318
3319 TRACE("dir (%s) prefix (%s)\n",dir,prefix);
3320 if (GetTempFileNameA(dir,prefix,0,tmpbuf))
3321 {
3322 TRACE("got name (%s)\n",tmpbuf);
3323 DeleteFileA(tmpbuf);
3324 return _strdup(tmpbuf);
3325 }
3326 TRACE("failed (%d)\n",GetLastError());
3327 return NULL;
3328 }
3329
3330 /*********************************************************************
3331 * _wtempnam (MSVCRT.@)
3332 */
3333 wchar_t * CDECL _wtempnam(const wchar_t *dir, const wchar_t *prefix)
3334 {
3335 wchar_t tmpbuf[MAX_PATH];
3336 const wchar_t *tmp_dir = _wgetenv(L"TMP");
3337
3338 if (tmp_dir) dir = tmp_dir;
3339
3340 TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
3341 if (GetTempFileNameW(dir,prefix,0,tmpbuf))
3342 {
3343 TRACE("got name (%s)\n",debugstr_w(tmpbuf));
3344 DeleteFileW(tmpbuf);
3345 return _wcsdup(tmpbuf);
3346 }
3347 TRACE("failed (%d)\n",GetLastError());
3348 return NULL;
3349 }
3350
3351 /*********************************************************************
3352 * _umask (MSVCRT.@)
3353 */
3354 int CDECL _umask(int umask)
3355 {
3356 int old_umask = MSVCRT_umask;
3357 TRACE("(%d)\n",umask);
3358 MSVCRT_umask = umask;
3359 return old_umask;
3360 }
3361
3362 /*********************************************************************
3363 * _utime64 (MSVCRT.@)
3364 */
3365 int CDECL _utime64(const char* path, struct __utimbuf64 *t)
3366 {
3367 int fd = _open(path, _O_WRONLY | _O_BINARY);
3368
3369 if (fd > 0)
3370 {
3371 int retVal = _futime64(fd, t);
3372 _close(fd);
3373 return retVal;
3374 }
3375 return -1;
3376 }
3377
3378 /*********************************************************************
3379 * _utime32 (MSVCRT.@)
3380 */
3381 int CDECL _utime32(const char* path, struct __utimbuf32 *t)
3382 {
3383 if (t)
3384 {
3385 struct __utimbuf64 t64;
3386 t64.actime = t->actime;
3387 t64.modtime = t->modtime;
3388 return _utime64( path, &t64 );
3389 }
3390 else
3391 return _utime64( path, NULL );
3392 }
3393
3394 /*********************************************************************
3395 * _wutime64 (MSVCRT.@)
3396 */
3397 int CDECL _wutime64(const wchar_t* path, struct __utimbuf64 *t)
3398 {
3399 int fd = _wopen(path, _O_WRONLY | _O_BINARY);
3400
3401 if (fd > 0)
3402 {
3403 int retVal = _futime64(fd, t);
3404 _close(fd);
3405 return retVal;
3406 }
3407 return -1;
3408 }
3409
3410 /*********************************************************************
3411 * _wutime32 (MSVCRT.@)
3412 */
3413 int CDECL _wutime32(const wchar_t* path, struct __utimbuf32 *t)
3414 {
3415 if (t)
3416 {
3417 struct __utimbuf64 t64;
3418 t64.actime = t->actime;
3419 t64.modtime = t->modtime;
3420 return _wutime64( path, &t64 );
3421 }
3422 else
3423 return _wutime64( path, NULL );
3424 }
3425
3426 /*********************************************************************
3427 * _write (MSVCRT.@)
3428 */
3429 int CDECL _write(int fd, const void* buf, unsigned int count)
3430 {
3431 ioinfo *info = get_ioinfo(fd);
3432 HANDLE hand = info->handle;
3433 DWORD num_written, i;
3434 BOOL console = FALSE;
3435
3436 if (hand == INVALID_HANDLE_VALUE || fd == MSVCRT_NO_CONSOLE_FD)
3437 {
3438 *_errno() = EBADF;
3439 release_ioinfo(info);
3440 return -1;
3441 }
3442
3443 if (((info->exflag&EF_UTF8) || (info->exflag&EF_UTF16)) && count&1)
3444 {
3445 *_errno() = EINVAL;
3446 release_ioinfo(info);
3447 return -1;
3448 }
3449
3450 /* If appending, go to EOF */
3451 if (info->wxflag & WX_APPEND)
3452 _lseek(fd, 0, FILE_END);
3453
3454 if (!(info->wxflag & WX_TEXT))
3455 {
3456 if (!WriteFile(hand, buf, count, &num_written, NULL)
3457 || num_written != count)
3458 {
3459 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d)\n", fd,
3460 hand, GetLastError());
3461 msvcrt_set_errno(GetLastError());
3462 num_written = -1;
3463 }
3464
3465 release_ioinfo(info);
3466 return num_written;
3467 }
3468
3469 if (_isatty(fd)) console = VerifyConsoleIoHandle(hand);
3470 for (i = 0; i < count;)
3471 {
3472 const char *s = buf;
3473 char lfbuf[2048];
3474 DWORD j = 0;
3475
3476 if (!(info->exflag & (EF_UTF8|EF_UTF16)) && console)
3477 {
3478 char conv[sizeof(lfbuf)];
3479 size_t len = 0;
3480
3481 #if _MSVCR_VER >= 90
3482 if (info->dbcsBufferUsed)
3483 {
3484 conv[j++] = info->dbcsBuffer;
3485 info->dbcsBufferUsed = FALSE;
3486 conv[j++] = s[i++];
3487 len++;
3488 }
3489 #endif
3490
3491 for (; i < count && j < sizeof(conv)-1 &&
3492 len < (sizeof(lfbuf) - 1) / sizeof(WCHAR); i++, j++, len++)
3493 {
3494 if (isleadbyte((unsigned char)s[i]))
3495 {
3496 conv[j++] = s[i++];
3497
3498 if (i == count)
3499 {
3500 #if _MSVCR_VER >= 90
3501 info->dbcsBuffer = conv[j-1];
3502 info->dbcsBufferUsed = TRUE;
3503 break;
3504 #else
3505 *_errno() = EINVAL;
3506 release_ioinfo(info);
3507 return -1;
3508 #endif
3509 }
3510 }
3511 else if (s[i] == '\n')
3512 {
3513 conv[j++] = '\r';
3514 len++;
3515 }
3516 conv[j] = s[i];
3517 }
3518
3519 len = mbstowcs((WCHAR*)lfbuf, conv, len);
3520 if (len == -1)
3521 {
3522 msvcrt_set_errno(GetLastError());
3523 release_ioinfo(info);
3524 return -1;
3525 }
3526 j = len * 2;
3527 }
3528 else if (!(info->exflag & (EF_UTF8|EF_UTF16)))
3529 {
3530 for (j = 0; i < count && j < sizeof(lfbuf)-1; i++, j++)
3531 {
3532 if (s[i] == '\n')
3533 lfbuf[j++] = '\r';
3534 lfbuf[j] = s[i];
3535 }
3536 }
3537 else if (info->exflag & EF_UTF16 || console)
3538 {
3539 for (j = 0; i < count && j < sizeof(lfbuf)-3; i++, j++)
3540 {
3541 if (s[i] == '\n' && !s[i+1])
3542 {
3543 lfbuf[j++] = '\r';
3544 lfbuf[j++] = 0;
3545 }
3546 lfbuf[j++] = s[i++];
3547 lfbuf[j] = s[i];
3548 }
3549 }
3550 else
3551 {
3552 char conv[sizeof(lfbuf)/4];
3553
3554 for (j = 0; i < count && j < sizeof(conv)-3; i++, j++)
3555 {
3556 if (s[i] == '\n' && !s[i+1])
3557 {
3558 conv[j++] = '\r';
3559 conv[j++] = 0;
3560 }
3561 conv[j++] = s[i++];
3562 conv[j] = s[i];
3563 }
3564
3565 j = WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)conv, j/2, lfbuf, sizeof(lfbuf), NULL, NULL);
3566 if (!j)
3567 {
3568 msvcrt_set_errno(GetLastError());
3569 release_ioinfo(info);
3570 return -1;
3571 }
3572 }
3573
3574 if (console)
3575 {
3576 j = j/2;
3577 if (!WriteConsoleW(hand, lfbuf, j, &num_written, NULL))
3578 num_written = -1;
3579 }
3580 else if (!WriteFile(hand, lfbuf, j, &num_written, NULL))
3581 {
3582 num_written = -1;
3583 }
3584
3585 if (num_written != j)
3586 {
3587 TRACE("WriteFile/WriteConsoleW (fd %d, hand %p) failed-last error (%d)\n", fd,
3588 hand, GetLastError());
3589 msvcrt_set_errno(GetLastError());
3590 release_ioinfo(info);
3591 return -1;
3592 }
3593 }
3594
3595 release_ioinfo(info);
3596 return count;
3597 }
3598
3599 /*********************************************************************
3600 * _putw (MSVCRT.@)
3601 */
3602 int CDECL _putw(int val, FILE* file)
3603 {
3604 int len;
3605
3606 _lock_file(file);
3607 len = _write(file->_file, &val, sizeof(val));
3608 if (len == sizeof(val)) {
3609 _unlock_file(file);
3610 return val;
3611 }
3612
3613 file->_flag |= _IOERR;
3614 _unlock_file(file);
3615 return EOF;
3616 }
3617
3618 /*********************************************************************
3619 * fclose (MSVCRT.@)
3620 */
3621 int CDECL fclose(FILE* file)
3622 {
3623 int ret;
3624
3625 if (!MSVCRT_CHECK_PMT(file != NULL)) return EOF;
3626
3627 _lock_file(file);
3628 ret = _fclose_nolock(file);
3629 _unlock_file(file);
3630
3631 return ret;
3632 }
3633
3634 /*********************************************************************
3635 * _fclose_nolock (MSVCRT.@)
3636 */
3637 int CDECL _fclose_nolock(FILE* file)
3638 {
3639 int r, flag;
3640
3641 if (!MSVCRT_CHECK_PMT(file != NULL)) return EOF;
3642
3643 if(!(file->_flag & (_IOREAD | _IOWRT | _IORW)))
3644 {
3645 file->_flag = 0;
3646 return EOF;
3647 }
3648
3649 flag = file->_flag;
3650 free(file->_tmpfname);
3651 file->_tmpfname = NULL;
3652 /* flush stdio buffers */
3653 if(file->_flag & _IOWRT)
3654 _fflush_nolock(file);
3655 if(file->_flag & _IOMYBUF)
3656 free(file->_base);
3657
3658 r=_close(file->_file);
3659 file->_flag = 0;
3660
3661 return ((r == -1) || (flag & _IOERR) ? EOF : 0);
3662 }
3663
3664 /*********************************************************************
3665 * feof (MSVCRT.@)
3666 */
3667 int CDECL feof(FILE* file)
3668 {
3669 return file->_flag & _IOEOF;
3670 }
3671
3672 /*********************************************************************
3673 * ferror (MSVCRT.@)
3674 */
3675 int CDECL ferror(FILE* file)
3676 {
3677 return file->_flag & _IOERR;
3678 }
3679
3680 /*********************************************************************
3681 * _filbuf (MSVCRT.@)
3682 */
3683 int CDECL _filbuf(FILE* file)
3684 {
3685 unsigned char c;
3686
3687 if(file->_flag & _IOSTRG)
3688 return EOF;
3689
3690 /* Allocate buffer if needed */
3691 if(!(file->_flag & (_IONBF | _IOMYBUF | MSVCRT__USERBUF)))
3692 msvcrt_alloc_buffer(file);
3693
3694 if(!(file->_flag & _IOREAD)) {
3695 if(file->_flag & _IORW)
3696 file->_flag |= _IOREAD;
3697 else
3698 return EOF;
3699 }
3700
3701 if(!(file->_flag & (_IOMYBUF | MSVCRT__USERBUF))) {
3702 int r;
3703 if ((r = _read(file->_file,&c,1)) != 1) {
3704 file->_flag |= (r == 0) ? _IOEOF : _IOERR;
3705 return EOF;
3706 }
3707
3708 return c;
3709 } else {
3710 file->_cnt = _read(file->_file, file->_base, file->_bufsiz);
3711 if(file->_cnt<=0) {
3712 file->_flag |= (file->_cnt == 0) ? _IOEOF : _IOERR;
3713 file->_cnt = 0;
3714 return EOF;
3715 }
3716
3717 file->_cnt--;
3718 file->_ptr = file->_base+1;
3719 c = *(unsigned char *)file->_base;
3720 return c;
3721 }
3722 }
3723
3724 /*********************************************************************
3725 * fgetc (MSVCRT.@)
3726 */
3727 int CDECL fgetc(FILE* file)
3728 {
3729 int ret;
3730
3731 _lock_file(file);
3732 ret = _fgetc_nolock(file);
3733 _unlock_file(file);
3734
3735 return ret;
3736 }
3737
3738 /*********************************************************************
3739 * _fgetc_nolock (MSVCRT.@)
3740 */
3741 int CDECL _fgetc_nolock(FILE* file)
3742 {
3743 unsigned char *i;
3744 unsigned int j;
3745
3746 if (file->_cnt>0) {
3747 file->_cnt--;
3748 i = (unsigned char *)file->_ptr++;
3749 j = *i;
3750 } else
3751 j = _filbuf(file);
3752
3753 return j;
3754 }
3755
3756 /*********************************************************************
3757 * _fgetchar (MSVCRT.@)
3758 */
3759 int CDECL _fgetchar(void)
3760 {
3761 return fgetc(MSVCRT_stdin);
3762 }
3763
3764 /*********************************************************************
3765 * fgets (MSVCRT.@)
3766 */
3767 char * CDECL fgets(char *s, int size, FILE* file)
3768 {
3769 int cc = EOF;
3770 char * buf_start = s;
3771
3772 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3773 file,file->_file,s,size);
3774
3775 _lock_file(file);
3776
3777 while ((size >1) && (cc = _fgetc_nolock(file)) != EOF && cc != '\n')
3778 {
3779 *s++ = (char)cc;
3780 size --;
3781 }
3782 if ((cc == EOF) && (s == buf_start)) /* If nothing read, return 0*/
3783 {
3784 TRACE(":nothing read\n");
3785 _unlock_file(file);
3786 return NULL;
3787 }
3788 if ((cc != EOF) && (size > 1))
3789 *s++ = cc;
3790 *s = '\0';
3791 TRACE(":got %s\n", debugstr_a(buf_start));
3792 _unlock_file(file);
3793 return buf_start;
3794 }
3795
3796 /*********************************************************************
3797 * fgetwc (MSVCRT.@)
3798 */
3799 wint_t CDECL fgetwc(FILE* file)
3800 {
3801 wint_t ret;
3802
3803 _lock_file(file);
3804 ret = _fgetwc_nolock(file);
3805 _unlock_file(file);
3806
3807 return ret;
3808 }
3809
3810 /*********************************************************************
3811 * _fgetwc_nolock (MSVCRT.@)
3812 */
3813 wint_t CDECL _fgetwc_nolock(FILE* file)
3814 {
3815 wint_t ret;
3816 int ch;
3817
3818 if((get_ioinfo_nolock(file->_file)->exflag & (EF_UTF8 | EF_UTF16))
3819 || !(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT)) {
3820 char *p;
3821
3822 for(p=(char*)&ret; (wint_t*)p<&ret+1; p++) {
3823 ch = _fgetc_nolock(file);
3824 if(ch == EOF) {
3825 ret = WEOF;
3826 break;
3827 }
3828 *p = (char)ch;
3829 }
3830 }else {
3831 char mbs[MB_LEN_MAX];
3832 int len = 0;
3833
3834 ch = _fgetc_nolock(file);
3835 if(ch != EOF) {
3836 mbs[0] = (char)ch;
3837 if(isleadbyte((unsigned char)mbs[0])) {
3838 ch = _fgetc_nolock(file);
3839 if(ch != EOF) {
3840 mbs[1] = (char)ch;
3841 len = 2;
3842 }
3843 }else {
3844 len = 1;
3845 }
3846 }
3847
3848 if(!len || mbtowc(&ret, mbs, len)==-1)
3849 ret = WEOF;
3850 }
3851
3852 return ret;
3853 }
3854
3855 /*********************************************************************
3856 * _getw (MSVCRT.@)
3857 */
3858 int CDECL _getw(FILE* file)
3859 {
3860 char *ch;
3861 int i, k;
3862 unsigned int j;
3863 ch = (char *)&i;
3864
3865 _lock_file(file);
3866 for (j=0; j<sizeof(int); j++) {
3867 k = _fgetc_nolock(file);
3868 if (k == EOF) {
3869 file->_flag |= _IOEOF;
3870 _unlock_file(file);
3871 return EOF;
3872 }
3873 ch[j] = k;
3874 }
3875
3876 _unlock_file(file);
3877 return i;
3878 }
3879
3880 /*********************************************************************
3881 * getwc (MSVCRT.@)
3882 */
3883 wint_t CDECL getwc(FILE* file)
3884 {
3885 return fgetwc(file);
3886 }
3887
3888 /*********************************************************************
3889 * _fgetwchar (MSVCRT.@)
3890 */
3891 wint_t CDECL _fgetwchar(void)
3892 {
3893 return fgetwc(MSVCRT_stdin);
3894 }
3895
3896 /*********************************************************************
3897 * getwchar (MSVCRT.@)
3898 */
3899 wint_t CDECL getwchar(void)
3900 {
3901 return _fgetwchar();
3902 }
3903
3904 /*********************************************************************
3905 * fgetws (MSVCRT.@)
3906 */
3907 wchar_t * CDECL fgetws(wchar_t *s, int size, FILE* file)
3908 {
3909 wint_t cc = WEOF;
3910 wchar_t * buf_start = s;
3911
3912 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3913 file,file->_file,s,size);
3914
3915 _lock_file(file);
3916
3917 while ((size >1) && (cc = _fgetwc_nolock(file)) != WEOF && cc != '\n')
3918 {
3919 *s++ = cc;
3920 size --;
3921 }
3922 if ((cc == WEOF) && (s == buf_start)) /* If nothing read, return 0*/
3923 {
3924 TRACE(":nothing read\n");
3925 _unlock_file(file);
3926 return NULL;
3927 }
3928 if ((cc != WEOF) && (size > 1))
3929 *s++ = cc;
3930 *s = 0;
3931 TRACE(":got %s\n", debugstr_w(buf_start));
3932 _unlock_file(file);
3933 return buf_start;
3934 }
3935
3936 /*********************************************************************
3937 * _flsbuf (MSVCRT.@)
3938 */
3939 int CDECL _flsbuf(int c, FILE* file)
3940 {
3941 /* Flush output buffer */
3942 if(!(file->_flag & (_IONBF | _IOMYBUF | MSVCRT__USERBUF))) {
3943 msvcrt_alloc_buffer(file);
3944 }
3945
3946 if(!(file->_flag & _IOWRT)) {
3947 if(!(file->_flag & _IORW)) {
3948 file->_flag |= _IOERR;
3949 *_errno() = EBADF;
3950 return EOF;
3951 }
3952 file->_flag |= _IOWRT;
3953 }
3954 if(file->_flag & _IOREAD) {
3955 if(!(file->_flag & _IOEOF)) {
3956 file->_flag |= _IOERR;
3957 return EOF;
3958 }
3959 file->_cnt = 0;
3960 file->_ptr = file->_base;
3961 file->_flag &= ~(_IOREAD | _IOEOF);
3962 }
3963
3964 if(file->_flag & (_IOMYBUF | MSVCRT__USERBUF)) {
3965 int res = 0;
3966
3967 if(file->_cnt <= 0) {
3968 res = msvcrt_flush_buffer(file);
3969 if(res)
3970 return res;
3971 file->_flag |= _IOWRT;
3972 file->_cnt=file->_bufsiz;
3973 }
3974 *file->_ptr++ = c;
3975 file->_cnt--;
3976 return c&0xff;
3977 } else {
3978 unsigned char cc=c;
3979 int len;
3980 /* set _cnt to 0 for unbuffered FILEs */
3981 file->_cnt = 0;
3982 len = _write(file->_file, &cc, 1);
3983 if (len == 1)
3984 return c & 0xff;
3985 file->_flag |= _IOERR;
3986 return EOF;
3987 }
3988 }
3989
3990 /*********************************************************************
3991 * fwrite (MSVCRT.@)
3992 */
3993 size_t CDECL fwrite(const void *ptr, size_t size, size_t nmemb, FILE* file)
3994 {
3995 size_t ret;
3996
3997 _lock_file(file);
3998 ret = _fwrite_nolock(ptr, size, nmemb, file);
3999 _unlock_file(file);
4000
4001 return ret;
4002 }
4003
4004 /*********************************************************************
4005 * _fwrite_nolock (MSVCRT.@)
4006 */
4007 size_t CDECL _fwrite_nolock(const void *ptr, size_t size, size_t nmemb, FILE* file)
4008 {
4009 size_t wrcnt=size * nmemb;
4010 int written = 0;
4011 if (size == 0)
4012 return 0;
4013
4014 while(wrcnt) {
4015 if(file->_cnt < 0) {
4016 WARN("negative file->_cnt value in %p\n", file);
4017 file->_flag |= _IOERR;
4018 break;
4019 } else if(file->_cnt) {
4020 int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
4021 memcpy(file->_ptr, ptr, pcnt);
4022 file->_cnt -= pcnt;
4023 file->_ptr += pcnt;
4024 written += pcnt;
4025 wrcnt -= pcnt;
4026 ptr = (const char*)ptr + pcnt;
4027 } else if((file->_flag & _IONBF)
4028 || ((file->_flag & (_IOMYBUF | MSVCRT__USERBUF)) && wrcnt >= file->_bufsiz)
4029 || (!(file->_flag & (_IOMYBUF | MSVCRT__USERBUF)) && wrcnt >= MSVCRT_INTERNAL_BUFSIZ)) {
4030 size_t pcnt;
4031 int bufsiz;
4032
4033 if(file->_flag & _IONBF)
4034 bufsiz = 1;
4035 else if(!(file->_flag & (_IOMYBUF | MSVCRT__USERBUF)))
4036 bufsiz = MSVCRT_INTERNAL_BUFSIZ;
4037 else
4038 bufsiz = file->_bufsiz;
4039
4040 pcnt = (wrcnt / bufsiz) * bufsiz;
4041
4042 if(msvcrt_flush_buffer(file) == EOF)
4043 break;
4044
4045 if(_write(file->_file, ptr, pcnt) <= 0) {
4046 file->_flag |= _IOERR;
4047 break;
4048 }
4049 written += pcnt;
4050 wrcnt -= pcnt;
4051 ptr = (const char*)ptr + pcnt;
4052 } else {
4053 if(_flsbuf(*(const char*)ptr, file) == EOF)
4054 break;
4055 written++;
4056 wrcnt--;
4057 ptr = (const char*)ptr + 1;
4058 }
4059 }
4060
4061 return written / size;
4062 }
4063
4064 /*********************************************************************
4065 * fputwc (MSVCRT.@)
4066 */
4067 wint_t CDECL fputwc(wint_t wc, FILE* file)
4068 {
4069 wint_t ret;
4070
4071 _lock_file(file);
4072 ret = _fputwc_nolock(wc, file);
4073 _unlock_file(file);
4074
4075 return ret;
4076 }
4077
4078 /*********************************************************************
4079 * _fputwc_nolock (MSVCRT.@)
4080 */
4081 wint_t CDECL _fputwc_nolock(wint_t wc, FILE* file)
4082 {
4083 wchar_t mwc=wc;
4084 ioinfo *fdinfo;
4085 wint_t ret;
4086
4087 fdinfo = get_ioinfo_nolock(file->_file);
4088
4089 if((fdinfo->wxflag&WX_TEXT) && !(fdinfo->exflag&(EF_UTF8|EF_UTF16))) {
4090 char buf[MB_LEN_MAX];
4091 int char_len;
4092
4093 char_len = wctomb(buf, mwc);
4094 if(char_len!=-1 && _fwrite_nolock(buf, char_len, 1, file)==1)
4095 ret = wc;
4096 else
4097 ret = WEOF;
4098 }else if(_fwrite_nolock(&mwc, sizeof(mwc), 1, file) == 1) {
4099 ret = wc;
4100 }else {
4101 ret = WEOF;
4102 }
4103
4104 return ret;
4105 }
4106
4107 /*********************************************************************
4108 * _fputwchar (MSVCRT.@)
4109 */
4110 wint_t CDECL _fputwchar(wint_t wc)
4111 {
4112 return fputwc(wc, MSVCRT_stdout);
4113 }
4114
4115 /*********************************************************************
4116 * _wfsopen (MSVCRT.@)
4117 */
4118 FILE * CDECL _wfsopen(const wchar_t *path, const wchar_t *mode, int share)
4119 {
4120 FILE* file;
4121 int open_flags, stream_flags, fd;
4122
4123 TRACE("(%s,%s)\n", debugstr_w(path), debugstr_w(mode));
4124
4125 /* map mode string to open() flags. "man fopen" for possibilities. */
4126 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
4127 return NULL;
4128
4129 LOCK_FILES();
4130 fd = _wsopen(path, open_flags, share, _S_IREAD | _S_IWRITE);
4131 if (fd < 0)
4132 file = NULL;
4133 else if ((file = msvcrt_alloc_fp()) && msvcrt_init_fp(file, fd, stream_flags)
4134 != -1)
4135 TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
4136 else if (file)
4137 {
4138 file->_flag = 0;
4139 file = NULL;
4140 }
4141
4142 TRACE(":got (%p)\n",file);
4143 if (fd >= 0 && !file)
4144 _close(fd);
4145 UNLOCK_FILES();
4146 return file;
4147 }
4148
4149 /*********************************************************************
4150 * _fsopen (MSVCRT.@)
4151 */
4152 FILE * CDECL _fsopen(const char *path, const char *mode, int share)
4153 {
4154 FILE *ret;
4155 wchar_t *pathW = NULL, *modeW = NULL;
4156
4157 if (path && !(pathW = msvcrt_wstrdupa(path))) {
4158 _invalid_parameter(NULL, NULL, NULL, 0, 0);
4159 *_errno() = EINVAL;
4160 return NULL;
4161 }
4162 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
4163 {
4164 free(pathW);
4165 _invalid_parameter(NULL, NULL, NULL, 0, 0);
4166 *_errno() = EINVAL;
4167 return NULL;
4168 }
4169
4170 ret = _wfsopen(pathW, modeW, share);
4171
4172 free(pathW);
4173 free(modeW);
4174 return ret;
4175 }
4176
4177 /*********************************************************************
4178 * fopen (MSVCRT.@)
4179 */
4180 FILE * CDECL fopen(const char *path, const char *mode)
4181 {
4182 return _fsopen( path, mode, _SH_DENYNO );
4183 }
4184
4185 /*********************************************************************
4186 * fopen_s (MSVCRT.@)
4187 */
4188 int CDECL fopen_s(FILE** pFile,
4189 const char *filename, const char *mode)
4190 {
4191 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return EINVAL;
4192 if (!MSVCRT_CHECK_PMT(filename != NULL)) return EINVAL;
4193 if (!MSVCRT_CHECK_PMT(mode != NULL)) return EINVAL;
4194
4195 *pFile = fopen(filename, mode);
4196
4197 if(!*pFile)
4198 return *_errno();
4199 return 0;
4200 }
4201
4202 /*********************************************************************
4203 * _wfopen (MSVCRT.@)
4204 */
4205 FILE * CDECL _wfopen(const wchar_t *path, const wchar_t *mode)
4206 {
4207 return _wfsopen( path, mode, _SH_DENYNO );
4208 }
4209
4210 /*********************************************************************
4211 * _wfopen_s (MSVCRT.@)
4212 */
4213 int CDECL _wfopen_s(FILE** pFile, const wchar_t *filename,
4214 const wchar_t *mode)
4215 {
4216 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return EINVAL;
4217 if (!MSVCRT_CHECK_PMT(filename != NULL)) return EINVAL;
4218 if (!MSVCRT_CHECK_PMT(mode != NULL)) return EINVAL;
4219
4220 *pFile = _wfopen(filename, mode);
4221
4222 if(!*pFile)
4223 return *_errno();
4224 return 0;
4225 }
4226
4227 /*********************************************************************
4228 * fputc (MSVCRT.@)
4229 */
4230 int CDECL fputc(int c, FILE* file)
4231 {
4232 int ret;
4233
4234 _lock_file(file);
4235 ret = _fputc_nolock(c, file);
4236 _unlock_file(file);
4237
4238 return ret;
4239 }
4240
4241 /*********************************************************************
4242 * _fputc_nolock (MSVCRT.@)
4243 */
4244 int CDECL _fputc_nolock(int c, FILE* file)
4245 {
4246 int res;
4247
4248 if(file->_cnt>0) {
4249 *file->_ptr++=c;
4250 file->_cnt--;
4251 if (c == '\n')
4252 {
4253 res = msvcrt_flush_buffer(file);
4254 return res ? res : c;
4255 }
4256 else {
4257 return c & 0xff;
4258 }
4259 } else {
4260 res = _flsbuf(c, file);
4261 return res;
4262 }
4263 }
4264
4265 /*********************************************************************
4266 * _fputchar (MSVCRT.@)
4267 */
4268 int CDECL _fputchar(int c)
4269 {
4270 return fputc(c, MSVCRT_stdout);
4271 }
4272
4273 /*********************************************************************
4274 * fread (MSVCRT.@)
4275 */
4276 size_t CDECL fread(void *ptr, size_t size, size_t nmemb, FILE* file)
4277 {
4278 size_t ret;
4279
4280 _lock_file(file);
4281 ret = _fread_nolock(ptr, size, nmemb, file);
4282 _unlock_file(file);
4283
4284 return ret;
4285 }
4286
4287 /*********************************************************************
4288 * _fread_nolock (MSVCRT.@)
4289 */
4290 size_t CDECL _fread_nolock(void *ptr, size_t size, size_t nmemb, FILE* file)
4291 {
4292 size_t rcnt=size * nmemb;
4293 size_t read=0;
4294 size_t pread=0;
4295
4296 if(!rcnt)
4297 return 0;
4298
4299 /* first buffered data */
4300 if(file->_cnt>0) {
4301 int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
4302 memcpy(ptr, file->_ptr, pcnt);
4303 file->_cnt -= pcnt;
4304 file->_ptr += pcnt;
4305 read += pcnt ;
4306 rcnt -= pcnt ;
4307 ptr = (char*)ptr + pcnt;
4308 } else if(!(file->_flag & _IOREAD )) {
4309 if(file->_flag & _IORW) {
4310 file->_flag |= _IOREAD;
4311 } else {
4312 return 0;
4313 }
4314 }
4315
4316 if(rcnt>0 && !(file->_flag & (_IONBF | _IOMYBUF | MSVCRT__USERBUF)))
4317 msvcrt_alloc_buffer(file);
4318
4319 while(rcnt>0)
4320 {
4321 int i;
4322 if (!file->_cnt && rcnt<file->_bufsiz && (file->_flag & (_IOMYBUF | MSVCRT__USERBUF))) {
4323 i = _read(file->_file, file->_base, file->_bufsiz);
4324 file->_ptr = file->_base;
4325 if (i != -1) {
4326 file->_cnt = i;
4327 if (i > rcnt) i = rcnt;
4328 }
4329 /* If the buffer fill reaches eof but fread wouldn't, clear eof. */
4330 if (i > 0 && i < file->_cnt) {
4331 get_ioinfo_nolock(file->_file)->wxflag &= ~WX_ATEOF;
4332 file->_flag &= ~_IOEOF;
4333 }
4334 if (i > 0) {
4335 memcpy(ptr, file->_ptr, i);
4336 file->_cnt -= i;
4337 file->_ptr += i;
4338 }
4339 } else if (rcnt > INT_MAX) {
4340 i = _read(file->_file, ptr, INT_MAX);
4341 } else if (rcnt < (file->_bufsiz ? file->_bufsiz : MSVCRT_INTERNAL_BUFSIZ)) {
4342 i = _read(file->_file, ptr, rcnt);
4343 } else {
4344 i = _read(file->_file, ptr, rcnt - rcnt % (file->_bufsiz ? file->_bufsiz : MSVCRT_INTERNAL_BUFSIZ));
4345 }
4346 pread += i;
4347 rcnt -= i;
4348 ptr = (char *)ptr+i;
4349 /* expose feof condition in the flags
4350 * MFC tests file->_flag for feof, and doesn't call feof())
4351 */
4352 if (get_ioinfo_nolock(file->_file)->wxflag & WX_ATEOF)
4353 file->_flag |= _IOEOF;
4354 else if (i == -1)
4355 {
4356 file->_flag |= _IOERR;
4357 pread = 0;
4358 rcnt = 0;
4359 }
4360 if (i < 1) break;
4361 }
4362 read+=pread;
4363 return read / size;
4364 }
4365
4366 #if _MSVCR_VER >= 80
4367
4368 /*********************************************************************
4369 * fread_s (MSVCR80.@)
4370 */
4371 size_t CDECL fread_s(void *buf, size_t buf_size, size_t elem_size,
4372 size_t count, FILE *stream)
4373 {
4374 size_t ret;
4375
4376 if(!MSVCRT_CHECK_PMT(stream != NULL)) {
4377 if(buf && buf_size)
4378 memset(buf, 0, buf_size);
4379 return 0;
4380 }
4381 if(!elem_size || !count) return 0;
4382
4383 _lock_file(stream);
4384 ret = _fread_nolock_s(buf, buf_size, elem_size, count, stream);
4385 _unlock_file(stream);
4386
4387 return ret;
4388 }
4389
4390 /*********************************************************************
4391 * _fread_nolock_s (MSVCR80.@)
4392 */
4393 size_t CDECL _fread_nolock_s(void *buf, size_t buf_size, size_t elem_size,
4394 size_t count, FILE *stream)
4395 {
4396 size_t bytes_left, buf_pos;
4397
4398 TRACE("(%p %Iu %Iu %Iu %p)\n", buf, buf_size, elem_size, count, stream);
4399
4400 if(!MSVCRT_CHECK_PMT(stream != NULL)) {
4401 if(buf && buf_size)
4402 memset(buf, 0, buf_size);
4403 return 0;
4404 }
4405 if(!elem_size || !count) return 0;
4406 if(!MSVCRT_CHECK_PMT(buf != NULL)) return 0;
4407 if(!MSVCRT_CHECK_PMT(SIZE_MAX/count >= elem_size)) return 0;
4408
4409 bytes_left = elem_size*count;
4410 buf_pos = 0;
4411 while(bytes_left) {
4412 if(stream->_cnt > 0) {
4413 size_t size = bytes_left<stream->_cnt ? bytes_left : stream->_cnt;
4414
4415 if(!MSVCRT_CHECK_PMT_ERR(size <= buf_size-buf_pos, ERANGE)) {
4416 memset(buf, 0, buf_size);
4417 return 0;
4418 }
4419
4420 _fread_nolock((char*)buf+buf_pos, 1, size, stream);
4421 buf_pos += size;
4422 bytes_left -= size;
4423 }else {
4424 int c = _filbuf(stream);
4425
4426 if(c == EOF)
4427 break;
4428
4429 if(!MSVCRT_CHECK_PMT_ERR(buf_size != buf_pos, ERANGE)) {
4430 memset(buf, 0, buf_size);
4431 return 0;
4432 }
4433
4434 ((char*)buf)[buf_pos++] = c;
4435 bytes_left--;
4436 }
4437 }
4438
4439 return buf_pos/elem_size;
4440 }
4441
4442 #endif /* _MSVCR_VER >= 80 */
4443
4444 /*********************************************************************
4445 * _wfreopen (MSVCRT.@)
4446 *
4447 */
4448 FILE* CDECL _wfreopen(const wchar_t *path, const wchar_t *mode, FILE* file)
4449 {
4450 int open_flags, stream_flags, fd;
4451
4452 TRACE(":path (%s) mode (%s) file (%p) fd (%d)\n", debugstr_w(path), debugstr_w(mode), file, file ? file->_file : -1);
4453
4454 LOCK_FILES();
4455 if (!file || ((fd = file->_file) < 0))
4456 file = NULL;
4457 else
4458 {
4459 fclose(file);
4460 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
4461 file = NULL;
4462 else if((fd = _wopen(path, open_flags, _S_IREAD | _S_IWRITE)) < 0)
4463 file = NULL;
4464 else if(msvcrt_init_fp(file, fd, stream_flags) == -1)
4465 {
4466 file->_flag = 0;
4467 file = NULL;
4468 }
4469 }
4470 UNLOCK_FILES();
4471 return file;
4472 }
4473
4474 /*********************************************************************
4475 * _wfreopen_s (MSVCRT.@)
4476 */
4477 int CDECL _wfreopen_s(FILE** pFile,
4478 const wchar_t *path, const wchar_t *mode, FILE* file)
4479 {
4480 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return EINVAL;
4481 if (!MSVCRT_CHECK_PMT(path != NULL)) return EINVAL;
4482 if (!MSVCRT_CHECK_PMT(mode != NULL)) return EINVAL;
4483 if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
4484
4485 *pFile = _wfreopen(path, mode, file);
4486
4487 if(!*pFile)
4488 return *_errno();
4489 return 0;
4490 }
4491
4492 /*********************************************************************
4493 * freopen (MSVCRT.@)
4494 *
4495 */
4496 FILE* CDECL freopen(const char *path, const char *mode, FILE* file)
4497 {
4498 FILE *ret;
4499 wchar_t *pathW = NULL, *modeW = NULL;
4500
4501 if (path && !(pathW = msvcrt_wstrdupa(path))) return NULL;
4502 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
4503 {
4504 free(pathW);
4505 return NULL;
4506 }
4507
4508 ret = _wfreopen(pathW, modeW, file);
4509
4510 free(pathW);
4511 free(modeW);
4512 return ret;
4513 }
4514
4515 /*********************************************************************
4516 * freopen_s (MSVCRT.@)
4517 */
4518 int CDECL freopen_s(FILE** pFile,
4519 const char *path, const char *mode, FILE* file)
4520 {
4521 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return EINVAL;
4522 if (!MSVCRT_CHECK_PMT(path != NULL)) return EINVAL;
4523 if (!MSVCRT_CHECK_PMT(mode != NULL)) return EINVAL;
4524 if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
4525
4526 *pFile = freopen(path, mode, file);
4527
4528 if(!*pFile)
4529 return *_errno();
4530 return 0;
4531 }
4532
4533 /*********************************************************************
4534 * fsetpos (MSVCRT.@)
4535 */
4536 int CDECL fsetpos(FILE* file, fpos_t *pos)
4537 {
4538 int ret;
4539
4540 _lock_file(file);
4541 msvcrt_flush_buffer(file);
4542
4543 /* Reset direction of i/o */
4544 if(file->_flag & _IORW) {
4545 file->_flag &= ~(_IOREAD|_IOWRT);
4546 }
4547
4548 ret = (_lseeki64(file->_file,*pos,SEEK_SET) == -1) ? -1 : 0;
4549 _unlock_file(file);
4550 return ret;
4551 }
4552
4553 /*********************************************************************
4554 * _ftelli64 (MSVCRT.@)
4555 */
4556 __int64 CDECL _ftelli64(FILE* file)
4557 {
4558 __int64 ret;
4559
4560 _lock_file(file);
4561 ret = _ftelli64_nolock(file);
4562 _unlock_file(file);
4563
4564 return ret;
4565 }
4566
4567 /*********************************************************************
4568 * _ftelli64_nolock (MSVCRT.@)
4569 */
4570 __int64 CDECL _ftelli64_nolock(FILE* file)
4571 {
4572 __int64 pos;
4573
4574 pos = _telli64(file->_file);
4575 if(pos == -1)
4576 return -1;
4577 if(file->_flag & (_IOMYBUF | MSVCRT__USERBUF)) {
4578 if(file->_flag & _IOWRT) {
4579 pos += file->_ptr - file->_base;
4580
4581 if(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT) {
4582 char *p;
4583
4584 for(p=file->_base; p<file->_ptr; p++)
4585 if(*p == '\n')
4586 pos++;
4587 }
4588 } else if(!file->_cnt) { /* nothing to do */
4589 } else if(_lseeki64(file->_file, 0, SEEK_END)==pos) {
4590 int i;
4591
4592 pos -= file->_cnt;
4593 if(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT) {
4594 for(i=0; i<file->_cnt; i++)
4595 if(file->_ptr[i] == '\n')
4596 pos--;
4597 }
4598 } else {
4599 char *p;
4600
4601 if(_lseeki64(file->_file, pos, SEEK_SET) != pos)
4602 return -1;
4603
4604 pos -= file->_bufsiz;
4605 pos += file->_ptr - file->_base;
4606
4607 if(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT) {
4608 if(get_ioinfo_nolock(file->_file)->wxflag & WX_READNL)
4609 pos--;
4610
4611 for(p=file->_base; p<file->_ptr; p++)
4612 if(*p == '\n')
4613 pos++;
4614 }
4615 }
4616 }
4617
4618 return pos;
4619 }
4620
4621 /*********************************************************************
4622 * ftell (MSVCRT.@)
4623 */
4624 __msvcrt_long CDECL ftell(FILE* file)
4625 {
4626 return _ftelli64(file);
4627 }
4628
4629 #if _MSVCR_VER >= 80
4630 /*********************************************************************
4631 * _ftell_nolock (MSVCR80.@)
4632 */
4633 __msvcrt_long CDECL _ftell_nolock(FILE* file)
4634 {
4635 return _ftelli64_nolock(file);
4636 }
4637 #endif
4638
4639 /*********************************************************************
4640 * fgetpos (MSVCRT.@)
4641 */
4642 int CDECL fgetpos(FILE* file, fpos_t *pos)
4643 {
4644 *pos = _ftelli64(file);
4645 if(*pos == -1)
4646 return -1;
4647 return 0;
4648 }
4649
4650 /*********************************************************************
4651 * fputs (MSVCRT.@)
4652 */
4653 int CDECL fputs(const char *s, FILE* file)
4654 {
4655 size_t len = strlen(s);
4656 int ret;
4657
4658 _lock_file(file);
4659 ret = _fwrite_nolock(s, sizeof(*s), len, file) == len ? 0 : EOF;
4660 _unlock_file(file);
4661 return ret;
4662 }
4663
4664 /*********************************************************************
4665 * fputws (MSVCRT.@)
4666 */
4667 int CDECL fputws(const wchar_t *s, FILE* file)
4668 {
4669 size_t i, len = wcslen(s);
4670 BOOL tmp_buf;
4671 int ret;
4672
4673 _lock_file(file);
4674 if (!(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT)) {
4675 ret = _fwrite_nolock(s,sizeof(*s),len,file) == len ? 0 : EOF;
4676 _unlock_file(file);
4677 return ret;
4678 }
4679
4680 tmp_buf = add_std_buffer(file);
4681 for (i=0; i<len; i++) {
4682 if(_fputwc_nolock(s[i], file) == WEOF) {
4683 if(tmp_buf) remove_std_buffer(file);
4684 _unlock_file(file);
4685 return WEOF;
4686 }
4687 }
4688
4689 if(tmp_buf) remove_std_buffer(file);
4690 _unlock_file(file);
4691 return 0;
4692 }
4693
4694 /*********************************************************************
4695 * getchar (MSVCRT.@)
4696 */
4697 int CDECL getchar(void)
4698 {
4699 return fgetc(MSVCRT_stdin);
4700 }
4701
4702 /*********************************************************************
4703 * getc (MSVCRT.@)
4704 */
4705 int CDECL getc(FILE* file)
4706 {
4707 return fgetc(file);
4708 }
4709
4710 /*********************************************************************
4711 * gets_s (MSVCR80.@)
4712 */
4713 char * CDECL gets_s(char *buf, size_t len)
4714 {
4715 char *buf_start = buf;
4716 int cc;
4717
4718 if (!MSVCRT_CHECK_PMT(buf != NULL)) return NULL;
4719 if (!MSVCRT_CHECK_PMT(len != 0)) return NULL;
4720
4721 _lock_file(MSVCRT_stdin);
4722 for(cc = _fgetc_nolock(MSVCRT_stdin);
4723 len != 0 && cc != EOF && cc != '\n';
4724 cc = _fgetc_nolock(MSVCRT_stdin))
4725 {
4726 if (cc != '\r')
4727 {
4728 *buf++ = (char)cc;
4729 len--;
4730 }
4731 }
4732 _unlock_file(MSVCRT_stdin);
4733
4734 if (!len)
4735 {
4736 *buf_start = 0;
4737 _invalid_parameter(NULL, NULL, NULL, 0, 0);
4738 return NULL;
4739 }
4740
4741 if ((cc == EOF) && (buf_start == buf))
4742 {
4743 TRACE(":nothing read\n");
4744 return NULL;
4745 }
4746 *buf = '\0';
4747
4748 TRACE("got '%s'\n", buf_start);
4749 return buf_start;
4750 }
4751
4752 /*********************************************************************
4753 * gets (MSVCRT.@)
4754 */
4755 char * CDECL gets(char *buf)
4756 {
4757 return gets_s(buf, -1);
4758 }
4759
4760 /*********************************************************************
4761 * _getws (MSVCRT.@)
4762 */
4763 wchar_t* CDECL _getws(wchar_t* buf)
4764 {
4765 wint_t cc;
4766 wchar_t* ws = buf;
4767
4768 _lock_file(MSVCRT_stdin);
4769 for (cc = _fgetwc_nolock(MSVCRT_stdin); cc != WEOF && cc != '\n';
4770 cc = _fgetwc_nolock(MSVCRT_stdin))
4771 {
4772 if (cc != '\r')
4773 *buf++ = (wchar_t)cc;
4774 }
4775 _unlock_file(MSVCRT_stdin);
4776
4777 if ((cc == WEOF) && (ws == buf))
4778 {
4779 TRACE(":nothing read\n");
4780 return NULL;
4781 }
4782 *buf = '\0';
4783
4784 TRACE("got %s\n", debugstr_w(ws));
4785 return ws;
4786 }
4787
4788 /*********************************************************************
4789 * putc (MSVCRT.@)
4790 */
4791 int CDECL putc(int c, FILE* file)
4792 {
4793 return fputc(c, file);
4794 }
4795
4796 /*********************************************************************
4797 * putchar (MSVCRT.@)
4798 */
4799 int CDECL putchar(int c)
4800 {
4801 return fputc(c, MSVCRT_stdout);
4802 }
4803
4804 /*********************************************************************
4805 * puts (MSVCRT.@)
4806 */
4807 int CDECL puts(const char *s)
4808 {
4809 size_t len = strlen(s);
4810 int ret;
4811
4812 _lock_file(MSVCRT_stdout);
4813 if(_fwrite_nolock(s, sizeof(*s), len, MSVCRT_stdout) != len) {
4814 _unlock_file(MSVCRT_stdout);
4815 return EOF;
4816 }
4817
4818 ret = _fwrite_nolock("\n",1,1,MSVCRT_stdout) == 1 ? 0 : EOF;
4819 _unlock_file(MSVCRT_stdout);
4820 return ret;
4821 }
4822
4823 /*********************************************************************
4824 * _putws (MSVCRT.@)
4825 */
4826 int CDECL _putws(const wchar_t *s)
4827 {
4828 int ret;
4829
4830 _lock_file(MSVCRT_stdout);
4831 ret = fputws(s, MSVCRT_stdout);
4832 if(ret >= 0)
4833 ret = _fputwc_nolock('\n', MSVCRT_stdout);
4834 _unlock_file(MSVCRT_stdout);
4835 return ret >= 0 ? 0 : WEOF;
4836 }
4837
4838 /*********************************************************************
4839 * remove (MSVCRT.@)
4840 */
4841 int CDECL remove(const char *path)
4842 {
4843 TRACE("(%s)\n",path);
4844 if (DeleteFileA(path))
4845 return 0;
4846 TRACE(":failed (%d)\n",GetLastError());
4847 msvcrt_set_errno(GetLastError());
4848 return -1;
4849 }
4850
4851 /*********************************************************************
4852 * _wremove (MSVCRT.@)
4853 */
4854 int CDECL _wremove(const wchar_t *path)
4855 {
4856 TRACE("(%s)\n",debugstr_w(path));
4857 if (DeleteFileW(path))
4858 return 0;
4859 TRACE(":failed (%d)\n",GetLastError());
4860 msvcrt_set_errno(GetLastError());
4861 return -1;
4862 }
4863
4864 /*********************************************************************
4865 * rename (MSVCRT.@)
4866 */
4867 int CDECL rename(const char *oldpath,const char *newpath)
4868 {
4869 TRACE(":from %s to %s\n",oldpath,newpath);
4870 if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4871 return 0;
4872 TRACE(":failed (%d)\n",GetLastError());
4873 msvcrt_set_errno(GetLastError());
4874 return -1;
4875 }
4876
4877 /*********************************************************************
4878 * _wrename (MSVCRT.@)
4879 */
4880 int CDECL _wrename(const wchar_t *oldpath,const wchar_t *newpath)
4881 {
4882 TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
4883 if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4884 return 0;
4885 TRACE(":failed (%d)\n",GetLastError());
4886 msvcrt_set_errno(GetLastError());
4887 return -1;
4888 }
4889
4890 /*********************************************************************
4891 * setvbuf (MSVCRT.@)
4892 */
4893 int CDECL setvbuf(FILE* file, char *buf, int mode, size_t size)
4894 {
4895 if(!MSVCRT_CHECK_PMT(file != NULL)) return -1;
4896 if(!MSVCRT_CHECK_PMT(mode==_IONBF || mode==_IOFBF || mode==_IOLBF)) return -1;
4897 if(!MSVCRT_CHECK_PMT(mode==_IONBF || (size>=2 && size<=INT_MAX))) return -1;
4898
4899 _lock_file(file);
4900
4901 _fflush_nolock(file);
4902 if(file->_flag & _IOMYBUF)
4903 free(file->_base);
4904 file->_flag &= ~(_IONBF | _IOMYBUF | MSVCRT__USERBUF);
4905 file->_cnt = 0;
4906
4907 if(mode == _IONBF) {
4908 file->_flag |= _IONBF;
4909 file->_base = file->_ptr = (char*)&file->_charbuf;
4910 file->_bufsiz = 2;
4911 }else if(buf) {
4912 file->_base = file->_ptr = buf;
4913 file->_flag |= MSVCRT__USERBUF;
4914 file->_bufsiz = size;
4915 }else {
4916 file->_base = file->_ptr = malloc(size);
4917 if(!file->_base) {
4918 file->_bufsiz = 0;
4919 _unlock_file(file);
4920 return -1;
4921 }
4922
4923 file->_flag |= _IOMYBUF;
4924 file->_bufsiz = size;
4925 }
4926 _unlock_file(file);
4927 return 0;
4928 }
4929
4930 /*********************************************************************
4931 * setbuf (MSVCRT.@)
4932 */
4933 void CDECL setbuf(FILE* file, char *buf)
4934 {
4935 setvbuf(file, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
4936 }
4937
4938 static int tmpnam_helper(char *s, size_t size, int *tmpnam_unique, int tmp_max)
4939 {
4940 char tmpstr[8];
4941 char *p = s;
4942 int digits;
4943
4944 if (!MSVCRT_CHECK_PMT(s != NULL)) return EINVAL;
4945
4946 if (size < 3) {
4947 if (size) *s = 0;
4948 *_errno() = ERANGE;
4949 return ERANGE;
4950 }
4951 *p++ = '\\';
4952 *p++ = 's';
4953 size -= 2;
4954 digits = msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
4955 if (digits+1 > size) {
4956 *s = 0;
4957 *_errno() = ERANGE;
4958 return ERANGE;
4959 }
4960 memcpy(p, tmpstr, digits*sizeof(tmpstr[0]));
4961 p += digits;
4962 *p++ = '.';
4963 size -= digits+1;
4964
4965 while(1) {
4966 while ((digits = *tmpnam_unique)+1 < tmp_max) {
4967 if (InterlockedCompareExchange(tmpnam_unique, digits+1, digits) == digits)
4968 break;
4969 }
4970
4971 digits = msvcrt_int_to_base32(digits, tmpstr);
4972 if (digits+1 > size) {
4973 *s = 0;
4974 *_errno() = ERANGE;
4975 return ERANGE;
4976 }
4977 memcpy(p, tmpstr, digits*sizeof(tmpstr[0]));
4978 p[digits] = 0;
4979
4980 if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
4981 GetLastError() == ERROR_FILE_NOT_FOUND)
4982 break;
4983 }
4984 return 0;
4985 }
4986
4987 int CDECL tmpnam_s(char *s, size_t size)
4988 {
4989 return tmpnam_helper(s, size, &tmpnam_s_unique, TMP_MAX_S);
4990 }
4991
4992 /*********************************************************************
4993 * tmpnam (MSVCRT.@)
4994 */
4995 char * CDECL tmpnam(char *s)
4996 {
4997 if (!s) {
4998 thread_data_t *data = msvcrt_get_thread_data();
4999
5000 if(!data->tmpnam_buffer)
5001 data->tmpnam_buffer = malloc(MAX_PATH);
5002
5003 s = data->tmpnam_buffer;
5004 }
5005
5006 return tmpnam_helper(s, -1, &tmpnam_unique, TMP_MAX) ? NULL : s;
5007 }
5008
5009 static int wtmpnam_helper(wchar_t *s, size_t size, int *tmpnam_unique, int tmp_max)
5010 {
5011 wchar_t tmpstr[8];
5012 wchar_t *p = s;
5013 int digits;
5014
5015 if (!MSVCRT_CHECK_PMT(s != NULL)) return EINVAL;
5016
5017 if (size < 3) {
5018 if (size) *s = 0;
5019 *_errno() = ERANGE;
5020 return ERANGE;
5021 }
5022 *p++ = '\\';
5023 *p++ = 's';
5024 size -= 2;
5025 digits = msvcrt_int_to_base32_w(GetCurrentProcessId(), tmpstr);
5026 if (digits+1 > size) {
5027 *s = 0;
5028 *_errno() = ERANGE;
5029 return ERANGE;
5030 }
5031 memcpy(p, tmpstr, digits*sizeof(tmpstr[0]));
5032 p += digits;
5033 *p++ = '.';
5034 size -= digits+1;
5035
5036 while(1) {
5037 while ((digits = *tmpnam_unique)+1 < tmp_max) {
5038 if (InterlockedCompareExchange(tmpnam_unique, digits+1, digits) == digits)
5039 break;
5040 }
5041
5042 digits = msvcrt_int_to_base32_w(digits, tmpstr);
5043 if (digits+1 > size) {
5044 *s = 0;
5045 *_errno() = ERANGE;
5046 return ERANGE;
5047 }
5048 memcpy(p, tmpstr, digits*sizeof(tmpstr[0]));
5049 p[digits] = 0;
5050
5051 if (GetFileAttributesW(s) == INVALID_FILE_ATTRIBUTES &&
5052 GetLastError() == ERROR_FILE_NOT_FOUND)
5053 break;
5054 }
5055 return 0;
5056 }
5057
5058 /*********************************************************************
5059 * _wtmpnam_s (MSVCRT.@)
5060 */
5061 int CDECL _wtmpnam_s(wchar_t *s, size_t size)
5062 {
5063 return wtmpnam_helper(s, size, &tmpnam_s_unique, TMP_MAX_S);
5064 }
5065
5066 /*********************************************************************
5067 * _wtmpnam (MSVCRT.@)
5068 */
5069 wchar_t * CDECL _wtmpnam(wchar_t *s)
5070 {
5071 if (!s) {
5072 thread_data_t *data = msvcrt_get_thread_data();
5073
5074 if(!data->wtmpnam_buffer)
5075 data->wtmpnam_buffer = malloc(sizeof(wchar_t[MAX_PATH]));
5076
5077 s = data->wtmpnam_buffer;
5078 }
5079
5080 return wtmpnam_helper(s, -1, &tmpnam_unique, TMP_MAX) ? NULL : s;
5081 }
5082
5083 /*********************************************************************
5084 * tmpfile (MSVCRT.@)
5085 */
5086 FILE* CDECL tmpfile(void)
5087 {
5088 char *filename = _tempnam(",", "t");
5089 int fd;
5090 FILE* file = NULL;
5091
5092 LOCK_FILES();
5093 fd = _open(filename, _O_CREAT | _O_BINARY | _O_RDWR | _O_TEMPORARY,
5094 _S_IREAD | _S_IWRITE);
5095 if (fd != -1 && (file = msvcrt_alloc_fp()))
5096 {
5097 if (msvcrt_init_fp(file, fd, _IORW) == -1)
5098 {
5099 file->_flag = 0;
5100 file = NULL;
5101 }
5102 else file->_tmpfname = _strdup(filename);
5103 }
5104
5105 if(fd != -1 && !file)
5106 _close(fd);
5107 free(filename);
5108 UNLOCK_FILES();
5109 return file;
5110 }
5111
5112 /*********************************************************************
5113 * tmpfile_s (MSVCRT.@)
5114 */
5115 int CDECL tmpfile_s(FILE** file)
5116 {
5117 if (!MSVCRT_CHECK_PMT(file != NULL)) return EINVAL;
5118
5119 *file = tmpfile();
5120 return 0;
5121 }
5122
5123 static int puts_clbk_file_a(void *file, int len, const char *str)
5124 {
5125 return fwrite(str, sizeof(char), len, file);
5126 }
5127
5128 static int puts_clbk_file_w(void *file, int len, const wchar_t *str)
5129 {
5130 int i, ret;
5131
5132 _lock_file(file);
5133
5134 if(!(get_ioinfo_nolock(((FILE*)file)->_file)->wxflag & WX_TEXT)) {
5135 ret = _fwrite_nolock(str, sizeof(wchar_t), len, file);
5136 _unlock_file(file);
5137 return ret;
5138 }
5139
5140 for(i=0; i<len; i++) {
5141 if(_fputwc_nolock(str[i], file) == WEOF) {
5142 _unlock_file(file);
5143 return -1;
5144 }
5145 }
5146
5147 _unlock_file(file);
5148 return len;
5149 }
5150
5151 static int vfprintf_helper(DWORD options, FILE* file, const char *format,
5152 _locale_t locale, va_list valist)
5153 {
5154 printf_arg args_ctx[_ARGMAX+1];
5155 BOOL tmp_buf;
5156 int ret;
5157
5158 if(!MSVCRT_CHECK_PMT( file != NULL )) return -1;
5159 if(!MSVCRT_CHECK_PMT( format != NULL )) return -1;
5160
5161 if(options & MSVCRT_PRINTF_POSITIONAL_PARAMS) {
5162 memset(args_ctx, 0, sizeof(args_ctx));
5163 ret = create_positional_ctx_a(args_ctx, format, valist);
5164 if(ret < 0) {
5165 _invalid_parameter(NULL, NULL, NULL, 0, 0);
5166 *_errno() = EINVAL;
5167 return ret;
5168 } else if(!ret)
5169 options &= ~MSVCRT_PRINTF_POSITIONAL_PARAMS;
5170 }
5171
5172 _lock_file(file);
5173 tmp_buf = add_std_buffer(file);
5174 ret = pf_printf_a(puts_clbk_file_a, file, format, locale, options,
5175 options & MSVCRT_PRINTF_POSITIONAL_PARAMS ? arg_clbk_positional : arg_clbk_valist,
5176 options & MSVCRT_PRINTF_POSITIONAL_PARAMS ? args_ctx : NULL, &valist);
5177 if(tmp_buf) remove_std_buffer(file);
5178 _unlock_file(file);
5179
5180 return ret;
5181 }
5182
5183 static int vfwprintf_helper(DWORD options, FILE* file, const wchar_t *format,
5184 _locale_t locale, va_list valist)
5185 {
5186 printf_arg args_ctx[_ARGMAX+1];
5187 BOOL tmp_buf;
5188 int ret;
5189
5190 if(!MSVCRT_CHECK_PMT( file != NULL )) return -1;
5191 if(!MSVCRT_CHECK_PMT( format != NULL )) return -1;
5192
5193 if(options & MSVCRT_PRINTF_POSITIONAL_PARAMS) {
5194 memset(args_ctx, 0, sizeof(args_ctx));
5195 ret = create_positional_ctx_w(args_ctx, format, valist);
5196 if(ret < 0) {
5197 _invalid_parameter(NULL, NULL, NULL, 0, 0);
5198 *_errno() = EINVAL;
5199 return ret;
5200 } else if(!ret)
5201 options &= ~MSVCRT_PRINTF_POSITIONAL_PARAMS;
5202 }
5203
5204 _lock_file(file);
5205 tmp_buf = add_std_buffer(file);
5206 ret = pf_printf_w(puts_clbk_file_w, file, format, locale, options,
5207 options & MSVCRT_PRINTF_POSITIONAL_PARAMS ? arg_clbk_positional : arg_clbk_valist,
5208 options & MSVCRT_PRINTF_POSITIONAL_PARAMS ? args_ctx : NULL, &valist);
5209 if(tmp_buf) remove_std_buffer(file);
5210 _unlock_file(file);
5211
5212 return ret;
5213 }
5214
5215 /*********************************************************************
5216 * _vfprintf_s_l (MSVCRT.@)
5217 */
5218 int CDECL _vfprintf_s_l(FILE* file, const char *format,
5219 _locale_t locale, va_list valist)
5220 {
5221 return vfprintf_helper(MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER, file, format, locale, valist);
5222 }
5223
5224 /*********************************************************************
5225 * _vfwprintf_s_l (MSVCRT.@)
5226 */
5227 int CDECL _vfwprintf_s_l(FILE* file, const wchar_t *format,
5228 _locale_t locale, va_list valist)
5229 {
5230 return vfwprintf_helper(MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER, file, format, locale, valist);
5231 }
5232
5233 /*********************************************************************
5234 * vfprintf (MSVCRT.@)
5235 */
5236 int CDECL vfprintf(FILE* file, const char *format, va_list valist)
5237 {
5238 return vfprintf_helper(0, file, format, NULL, valist);
5239 }
5240
5241 /*********************************************************************
5242 * vfprintf_s (MSVCRT.@)
5243 */
5244 int CDECL vfprintf_s(FILE* file, const char *format, va_list valist)
5245 {
5246 return _vfprintf_s_l(file, format, NULL, valist);
5247 }
5248
5249 /*********************************************************************
5250 * vfwprintf (MSVCRT.@)
5251 */
5252 int CDECL vfwprintf(FILE* file, const wchar_t *format, va_list valist)
5253 {
5254 return vfwprintf_helper(0, file, format, NULL, valist);
5255 }
5256
5257 /*********************************************************************
5258 * vfwprintf_s (MSVCRT.@)
5259 */
5260 int CDECL vfwprintf_s(FILE* file, const wchar_t *format, va_list valist)
5261 {
5262 return _vfwprintf_s_l(file, format, NULL, valist);
5263 }
5264
5265 #if _MSVCR_VER >= 140
5266
5267 /*********************************************************************
5268 * __stdio_common_vfprintf (UCRTBASE.@)
5269 */
5270 int CDECL _stdio_common_vfprintf(unsigned __int64 options, FILE *file, const char *format,
5271 _locale_t locale, va_list valist)
5272 {
5273 if (options & ~UCRTBASE_PRINTF_MASK)
5274 FIXME("options %s not handled\n", wine_dbgstr_longlong(options));
5275
5276 return vfprintf_helper(options & UCRTBASE_PRINTF_MASK, file, format, locale, valist);
5277 }
5278
5279 /*********************************************************************
5280 * __stdio_common_vfprintf_p (UCRTBASE.@)
5281 */
5282 int CDECL __stdio_common_vfprintf_p(unsigned __int64 options, FILE *file, const char *format,
5283 _locale_t locale, va_list valist)
5284 {
5285 if (options & ~UCRTBASE_PRINTF_MASK)
5286 FIXME("options %s not handled\n", wine_dbgstr_longlong(options));
5287
5288 return vfprintf_helper((options & UCRTBASE_PRINTF_MASK) | MSVCRT_PRINTF_POSITIONAL_PARAMS
5289 | MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER, file, format, locale, valist);
5290 }
5291
5292
5293 /*********************************************************************
5294 * __stdio_common_vfprintf_s (UCRTBASE.@)
5295 */
5296 int CDECL __stdio_common_vfprintf_s(unsigned __int64 options, FILE *file, const char *format,
5297 _locale_t locale, va_list valist)
5298 {
5299 if (options & ~UCRTBASE_PRINTF_MASK)
5300 FIXME("options %s not handled\n", wine_dbgstr_longlong(options));
5301
5302 return vfprintf_helper((options & UCRTBASE_PRINTF_MASK) | MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER,
5303 file, format, locale, valist);
5304 }
5305
5306 /*********************************************************************
5307 * __stdio_common_vfwprintf (UCRTBASE.@)
5308 */
5309 int CDECL __stdio_common_vfwprintf(unsigned __int64 options, FILE *file, const wchar_t *format,
5310 _locale_t locale, va_list valist)
5311 {
5312 if (options & ~UCRTBASE_PRINTF_MASK)
5313 FIXME("options %s not handled\n", wine_dbgstr_longlong(options));
5314
5315 return vfwprintf_helper(options & UCRTBASE_PRINTF_MASK, file, format, locale, valist);
5316 }
5317
5318 /*********************************************************************
5319 * __stdio_common_vfwprintf_p (UCRTBASE.@)
5320 */
5321 int CDECL __stdio_common_vfwprintf_p(unsigned __int64 options, FILE *file, const wchar_t *format,
5322 _locale_t locale, va_list valist)
5323 {
5324 if (options & ~UCRTBASE_PRINTF_MASK)
5325 FIXME("options %s not handled\n", wine_dbgstr_longlong(options));
5326
5327 return vfwprintf_helper((options & UCRTBASE_PRINTF_MASK) | MSVCRT_PRINTF_POSITIONAL_PARAMS
5328 | MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER, file, format, locale, valist);
5329 }
5330
5331
5332 /*********************************************************************
5333 * __stdio_common_vfwprintf_s (UCRTBASE.@)
5334 */
5335 int CDECL __stdio_common_vfwprintf_s(unsigned __int64 options, FILE *file, const wchar_t *format,
5336 _locale_t locale, va_list valist)
5337 {
5338 if (options & ~UCRTBASE_PRINTF_MASK)
5339 FIXME("options %s not handled\n", wine_dbgstr_longlong(options));
5340
5341 return vfwprintf_helper((options & UCRTBASE_PRINTF_MASK) | MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER,
5342 file, format, locale, valist);
5343 }
5344
5345 #endif /* _MSVCR_VER >= 140 */
5346
5347 /*********************************************************************
5348 * _vfprintf_l (MSVCRT.@)
5349 */
5350 int CDECL _vfprintf_l(FILE* file, const char *format,
5351 _locale_t locale, va_list valist)
5352 {
5353 return vfprintf_helper(0, file, format, locale, valist);
5354 }
5355
5356 /*********************************************************************
5357 * _vfwprintf_l (MSVCRT.@)
5358 */
5359 int CDECL _vfwprintf_l(FILE* file, const wchar_t *format,
5360 _locale_t locale, va_list valist)
5361 {
5362 return vfwprintf_helper(0, file, format, locale, valist);
5363 }
5364
5365 /*********************************************************************
5366 * _vfprintf_p_l (MSVCRT.@)
5367 */
5368 int CDECL _vfprintf_p_l(FILE* file, const char *format,
5369 _locale_t locale, va_list valist)
5370 {
5371 return vfprintf_helper(MSVCRT_PRINTF_POSITIONAL_PARAMS | MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER,
5372 file, format, locale, valist);
5373 }
5374
5375 /*********************************************************************
5376 * _vfprintf_p (MSVCRT.@)
5377 */
5378 int CDECL _vfprintf_p(FILE* file, const char *format, va_list valist)
5379 {
5380 return _vfprintf_p_l(file, format, NULL, valist);
5381 }
5382
5383 /*********************************************************************
5384 * _vfwprintf_p_l (MSVCRT.@)
5385 */
5386 int CDECL _vfwprintf_p_l(FILE* file, const wchar_t *format,
5387 _locale_t locale, va_list valist)
5388 {
5389 return vfwprintf_helper(MSVCRT_PRINTF_POSITIONAL_PARAMS | MSVCRT_PRINTF_INVOKE_INVALID_PARAM_HANDLER,
5390 file, format, locale, valist);
5391 }
5392
5393 /*********************************************************************
5394 * _vfwprintf_p (MSVCRT.@)
5395 */
5396 int CDECL _vfwprintf_p(FILE* file, const wchar_t *format, va_list valist)
5397 {
5398 return _vfwprintf_p_l(file, format, NULL, valist);
5399 }
5400
5401 /*********************************************************************
5402 * vprintf (MSVCRT.@)
5403 */
5404 int CDECL vprintf(const char *format, va_list valist)
5405 {
5406 return vfprintf(MSVCRT_stdout,format,valist);
5407 }
5408
5409 /*********************************************************************
5410 * vprintf_s (MSVCRT.@)
5411 */
5412 int CDECL vprintf_s(const char *format, va_list valist)
5413 {
5414 return vfprintf_s(MSVCRT_stdout,format,valist);
5415 }
5416
5417 /*********************************************************************
5418 * vwprintf (MSVCRT.@)
5419 */
5420 int CDECL vwprintf(const wchar_t *format, va_list valist)
5421 {
5422 return vfwprintf(MSVCRT_stdout,format,valist);
5423 }
5424
5425 /*********************************************************************
5426 * vwprintf_s (MSVCRT.@)
5427 */
5428 int CDECL vwprintf_s(const wchar_t *format, va_list valist)
5429 {
5430 return vfwprintf_s(MSVCRT_stdout,format,valist);
5431 }
5432
5433 /*********************************************************************
5434 * fprintf (MSVCRT.@)
5435 */
5436 int WINAPIV fprintf(FILE* file, const char *format, ...)
5437 {
5438 va_list valist;
5439 int res;
5440 va_start(valist, format);
5441 res = vfprintf(file, format, valist);
5442 va_end(valist);
5443 return res;
5444 }
5445
5446 /*********************************************************************
5447 * fprintf_s (MSVCRT.@)
5448 */
5449 int WINAPIV fprintf_s(FILE* file, const char *format, ...)
5450 {
5451 va_list valist;
5452 int res;
5453 va_start(valist, format);
5454 res = vfprintf_s(file, format, valist);
5455 va_end(valist);
5456 return res;
5457 }
5458
5459 /*********************************************************************
5460 * fwprintf (MSVCRT.@)
5461 */
5462 int WINAPIV fwprintf(FILE* file, const wchar_t *format, ...)
5463 {
5464 va_list valist;
5465 int res;
5466 va_start(valist, format);
5467 res = vfwprintf(file, format, valist);
5468 va_end(valist);
5469 return res;
5470 }
5471
5472 /*********************************************************************
5473 * fwprintf_s (MSVCRT.@)
5474 */
5475 int WINAPIV fwprintf_s(FILE* file, const wchar_t *format, ...)
5476 {
5477 va_list valist;
5478 int res;
5479 va_start(valist, format);
5480 res = vfwprintf_s(file, format, valist);
5481 va_end(valist);
5482 return res;
5483 }
5484
5485 /*********************************************************************
5486 * _fwprintf_l (MSVCRT.@)
5487 */
5488 int WINAPIV _fwprintf_l(FILE* file, const wchar_t *format, _locale_t locale, ...)
5489 {
5490 va_list valist;
5491 int res;
5492 va_start(valist, locale);
5493 res = _vfwprintf_l(file, format, locale, valist);
5494 va_end(valist);
5495 return res;
5496 }
5497
5498 /*********************************************************************
5499 * printf (MSVCRT.@)
5500 */
5501 int WINAPIV printf(const char *format, ...)
5502 {
5503 va_list valist;
5504 int res;
5505 va_start(valist, format);
5506 res = vfprintf(MSVCRT_stdout, format, valist);
5507 va_end(valist);
5508 return res;
5509 }
5510
5511 /*********************************************************************
5512 * printf_s (MSVCRT.@)
5513 */
5514 int WINAPIV printf_s(const char *format, ...)
5515 {
5516 va_list valist;
5517 int res;
5518 va_start(valist, format);
5519 res = vprintf_s(format, valist);
5520 va_end(valist);
5521 return res;
5522 }
5523
5524 /*********************************************************************
5525 * ungetc (MSVCRT.@)
5526 */
5527 int CDECL ungetc(int c, FILE * file)
5528 {
5529 int ret;
5530
5531 if(!MSVCRT_CHECK_PMT(file != NULL)) return EOF;
5532
5533 _lock_file(file);
5534 ret = _ungetc_nolock(c, file);
5535 _unlock_file(file);
5536
5537 return ret;
5538 }
5539
5540 /*********************************************************************
5541 * _ungetc_nolock (MSVCRT.@)
5542 */
5543 int CDECL _ungetc_nolock(int c, FILE * file)
5544 {
5545 if(!MSVCRT_CHECK_PMT(file != NULL)) return EOF;
5546
5547 if (c == EOF || !(file->_flag&_IOREAD ||
5548 (file->_flag&_IORW && !(file->_flag&_IOWRT))))
5549 return EOF;
5550
5551 if((!(file->_flag & (_IONBF | _IOMYBUF | MSVCRT__USERBUF))
5552 && msvcrt_alloc_buffer(file))
5553 || (!file->_cnt && file->_ptr==file->_base))
5554 file->_ptr++;
5555
5556 if(file->_ptr>file->_base) {
5557 file->_ptr--;
5558 if(file->_flag & _IOSTRG) {
5559 if(*file->_ptr != c) {
5560 file->_ptr++;
5561 return EOF;
5562 }
5563 }else {
5564 *file->_ptr = c;
5565 }
5566 file->_cnt++;
5567 file->_flag &= ~(_IOERR | _IOEOF);
5568 file->_flag |= _IOREAD;
5569 return c;
5570 }
5571
5572 return EOF;
5573 }
5574
5575 /*********************************************************************
5576 * ungetwc (MSVCRT.@)
5577 */
5578 wint_t CDECL ungetwc(wint_t wc, FILE * file)
5579 {
5580 wint_t ret;
5581
5582 if(!MSVCRT_CHECK_PMT(file != NULL)) return WEOF;
5583
5584 _lock_file(file);
5585 ret = _ungetwc_nolock(wc, file);
5586 _unlock_file(file);
5587
5588 return ret;
5589 }
5590
5591 /*********************************************************************
5592 * _ungetwc_nolock (MSVCRT.@)
5593 */
5594 wint_t CDECL _ungetwc_nolock(wint_t wc, FILE * file)
5595 {
5596 wchar_t mwc = wc;
5597
5598 if(!MSVCRT_CHECK_PMT(file != NULL)) return WEOF;
5599 if (wc == WEOF)
5600 return WEOF;
5601
5602 if((get_ioinfo_nolock(file->_file)->exflag & (EF_UTF8 | EF_UTF16))
5603 || !(get_ioinfo_nolock(file->_file)->wxflag & WX_TEXT)) {
5604 unsigned char * pp = (unsigned char *)&mwc;
5605 int i;
5606
5607 for(i=sizeof(wchar_t)-1;i>=0;i--) {
5608 if(pp[i] != _ungetc_nolock(pp[i],file))
5609 return WEOF;
5610 }
5611 }else {
5612 char mbs[MB_LEN_MAX];
5613 int len;
5614
5615 len = wctomb(mbs, mwc);
5616 if(len == -1)
5617 return WEOF;
5618
5619 for(len--; len>=0; len--) {
5620 if(mbs[len] != _ungetc_nolock(mbs[len], file))
5621 return WEOF;
5622 }
5623 }
5624
5625 return mwc;
5626 }
5627
5628 /*********************************************************************
5629 * wprintf (MSVCRT.@)
5630 */
5631 int WINAPIV wprintf(const wchar_t *format, ...)
5632 {
5633 va_list valist;
5634 int res;
5635 va_start(valist, format);
5636 res = vwprintf(format, valist);
5637 va_end(valist);
5638 return res;
5639 }
5640
5641 /*********************************************************************
5642 * wprintf_s (MSVCRT.@)
5643 */
5644 int WINAPIV wprintf_s(const wchar_t *format, ...)
5645 {
5646 va_list valist;
5647 int res;
5648 va_start(valist, format);
5649 res = vwprintf_s(format, valist);
5650 va_end(valist);
5651 return res;
5652 }
5653
5654 /*********************************************************************
5655 * _getmaxstdio (MSVCRT.@)
5656 */
5657 int CDECL _getmaxstdio(void)
5658 {
5659 return MSVCRT_max_streams;
5660 }
5661
5662 /*********************************************************************
5663 * _setmaxstdio (MSVCRT.@)
5664 */
5665 int CDECL _setmaxstdio(int newmax)
5666 {
5667 TRACE("%d\n", newmax);
5668
5669 if(newmax<_IOB_ENTRIES || newmax>MSVCRT_MAX_FILES || newmax<MSVCRT_stream_idx)
5670 return -1;
5671
5672 MSVCRT_max_streams = newmax;
5673 return MSVCRT_max_streams;
5674 }
5675
5676 #if _MSVCR_VER >= 140
5677 /*********************************************************************
5678 * _get_stream_buffer_pointers (UCRTBASE.@)
5679 */
5680 int CDECL _get_stream_buffer_pointers(FILE *file, char*** base,
5681 char*** ptr, int** count)
5682 {
5683 if (base)
5684 *base = &file->_base;
5685 if (ptr)
5686 *ptr = &file->_ptr;
5687 if (count)
5688 *count = &file->_cnt;
5689 return 0;
5690 }
5691 #endif
Windows API implementation