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