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