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