2 * msvcrt.dll file functions
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
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.
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.
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
26 * Use the file flag hints O_SEQUENTIAL, O_RANDOM, O_SHORT_LIVED
30 #include "wine/port.h"
37 #include <sys/types.h>
45 #include "wine/unicode.h"
47 #include "wine/debug.h"
49 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
51 /* for stat mode, permissions apply to all,owner and group */
52 #define ALL_S_IREAD (MSVCRT__S_IREAD | (MSVCRT__S_IREAD >> 3) | (MSVCRT__S_IREAD >> 6))
53 #define ALL_S_IWRITE (MSVCRT__S_IWRITE | (MSVCRT__S_IWRITE >> 3) | (MSVCRT__S_IWRITE >> 6))
54 #define ALL_S_IEXEC (MSVCRT__S_IEXEC | (MSVCRT__S_IEXEC >> 3) | (MSVCRT__S_IEXEC >> 6))
56 /* _access() bit flags FIXME: incomplete */
57 #define MSVCRT_W_OK 0x02
58 #define MSVCRT_R_OK 0x04
60 /* values for wxflag in file descriptor */
63 #define WX_READNL 0x04 /* read started with \n */
65 #define WX_DONTINHERIT 0x10
66 #define WX_APPEND 0x20
69 /* values for exflag - it's used differently in msvcr90.dll*/
72 #define EF_CRIT_INIT 0x04
73 #define EF_UNK_UNICODE 0x08
75 static char utf8_bom[3] = { 0xef, 0xbb, 0xbf };
76 static char utf16_bom[2] = { 0xff, 0xfe };
78 /* FIXME: this should be allocated dynamically */
79 #define MSVCRT_MAX_FILES 2048
80 #define MSVCRT_FD_BLOCK_SIZE 32
82 /* ioinfo structure size is different in msvcrXX.dll's */
88 CRITICAL_SECTION crit;
91 /*********************************************************************
92 * __pioinfo (MSVCRT.@)
93 * array of pointers to ioinfo arrays [32]
95 ioinfo * MSVCRT___pioinfo[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE] = { 0 };
97 /*********************************************************************
98 * __badioinfo (MSVCRT.@)
100 ioinfo MSVCRT___badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };
102 static int MSVCRT_fdstart = 3; /* first unallocated fd */
103 static int MSVCRT_fdend = 3; /* highest allocated fd */
107 CRITICAL_SECTION crit;
110 MSVCRT_FILE MSVCRT__iob[_IOB_ENTRIES] = { { 0 } };
111 static file_crit* MSVCRT_fstream[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE];
112 static int MSVCRT_max_streams = 512, MSVCRT_stream_idx;
114 /* INTERNAL: process umask */
115 static int MSVCRT_umask = 0;
117 /* INTERNAL: static data for tmpnam and _wtmpname functions */
118 static int tmpnam_unique;
120 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
121 static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
122 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
123 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
125 #define TOUL(x) (ULONGLONG)(x)
126 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
127 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
128 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
129 static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
131 /* This critical section protects the tables MSVCRT___pioinfo and MSVCRT_fstreams,
132 * and their related indexes, MSVCRT_fdstart, MSVCRT_fdend,
133 * and MSVCRT_stream_idx, from race conditions.
134 * It doesn't protect against race conditions manipulating the underlying files
135 * or flags; doing so would probably be better accomplished with per-file
136 * protection, rather than locking the whole table for every change.
138 static CRITICAL_SECTION MSVCRT_file_cs;
139 static CRITICAL_SECTION_DEBUG MSVCRT_file_cs_debug =
141 0, 0, &MSVCRT_file_cs,
142 { &MSVCRT_file_cs_debug.ProcessLocksList, &MSVCRT_file_cs_debug.ProcessLocksList },
143 0, 0, { (DWORD_PTR)(__FILE__ ": MSVCRT_file_cs") }
145 static CRITICAL_SECTION MSVCRT_file_cs = { &MSVCRT_file_cs_debug, -1, 0, 0, 0, 0 };
146 #define LOCK_FILES() do { EnterCriticalSection(&MSVCRT_file_cs); } while (0)
147 #define UNLOCK_FILES() do { LeaveCriticalSection(&MSVCRT_file_cs); } while (0)
149 static void msvcrt_stat64_to_stat(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat *buf)
151 buf->st_dev = buf64->st_dev;
152 buf->st_ino = buf64->st_ino;
153 buf->st_mode = buf64->st_mode;
154 buf->st_nlink = buf64->st_nlink;
155 buf->st_uid = buf64->st_uid;
156 buf->st_gid = buf64->st_gid;
157 buf->st_rdev = buf64->st_rdev;
158 buf->st_size = buf64->st_size;
159 buf->st_atime = buf64->st_atime;
160 buf->st_mtime = buf64->st_mtime;
161 buf->st_ctime = buf64->st_ctime;
164 static void msvcrt_stat64_to_stati64(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stati64 *buf)
166 buf->st_dev = buf64->st_dev;
167 buf->st_ino = buf64->st_ino;
168 buf->st_mode = buf64->st_mode;
169 buf->st_nlink = buf64->st_nlink;
170 buf->st_uid = buf64->st_uid;
171 buf->st_gid = buf64->st_gid;
172 buf->st_rdev = buf64->st_rdev;
173 buf->st_size = buf64->st_size;
174 buf->st_atime = buf64->st_atime;
175 buf->st_mtime = buf64->st_mtime;
176 buf->st_ctime = buf64->st_ctime;
179 static void time_to_filetime( MSVCRT___time64_t time, FILETIME *ft )
181 /* 1601 to 1970 is 369 years plus 89 leap days */
182 static const __int64 secs_1601_to_1970 = ((369 * 365 + 89) * (__int64)86400);
184 __int64 ticks = (time + secs_1601_to_1970) * 10000000;
185 ft->dwHighDateTime = ticks >> 32;
186 ft->dwLowDateTime = ticks;
189 static inline ioinfo* msvcrt_get_ioinfo(int fd)
192 if(fd < MSVCRT_MAX_FILES)
193 ret = MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE];
195 return &MSVCRT___badioinfo;
197 return ret + (fd%MSVCRT_FD_BLOCK_SIZE);
200 static inline MSVCRT_FILE* msvcrt_get_file(int i)
204 if(i >= MSVCRT_max_streams)
208 return &MSVCRT__iob[i];
210 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE];
212 MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] = MSVCRT_calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(file_crit));
213 if(!MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE]) {
214 ERR("out of memory\n");
215 *MSVCRT__errno() = MSVCRT_ENOMEM;
219 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] + (i%MSVCRT_FD_BLOCK_SIZE);
221 ret += i%MSVCRT_FD_BLOCK_SIZE;
226 static inline BOOL msvcrt_is_valid_fd(int fd)
228 return fd >= 0 && fd < MSVCRT_fdend && (msvcrt_get_ioinfo(fd)->wxflag & WX_OPEN);
231 /* INTERNAL: Get the HANDLE for a fd
232 * This doesn't lock the table, because a failure will result in
233 * INVALID_HANDLE_VALUE being returned, which should be handled correctly. If
234 * it returns a valid handle which is about to be closed, a subsequent call
235 * will fail, most likely in a sane way.
237 static HANDLE msvcrt_fdtoh(int fd)
239 if (!msvcrt_is_valid_fd(fd))
241 WARN(":fd (%d) - no handle!\n",fd);
242 *MSVCRT___doserrno() = 0;
243 *MSVCRT__errno() = MSVCRT_EBADF;
244 return INVALID_HANDLE_VALUE;
246 if (msvcrt_get_ioinfo(fd)->handle == INVALID_HANDLE_VALUE)
247 WARN("returning INVALID_HANDLE_VALUE for %d\n", fd);
248 return msvcrt_get_ioinfo(fd)->handle;
251 /* INTERNAL: free a file entry fd */
252 static void msvcrt_free_fd(int fd)
258 fdinfo = msvcrt_get_ioinfo(fd);
259 old_handle = fdinfo->handle;
260 if(fdinfo != &MSVCRT___badioinfo)
262 fdinfo->handle = INVALID_HANDLE_VALUE;
265 TRACE(":fd (%d) freed\n",fd);
266 if (fd < 3) /* don't use 0,1,2 for user files */
271 if (GetStdHandle(STD_INPUT_HANDLE) == old_handle) SetStdHandle(STD_INPUT_HANDLE, 0);
274 if (GetStdHandle(STD_OUTPUT_HANDLE) == old_handle) SetStdHandle(STD_OUTPUT_HANDLE, 0);
277 if (GetStdHandle(STD_ERROR_HANDLE) == old_handle) SetStdHandle(STD_ERROR_HANDLE, 0);
283 if (fd == MSVCRT_fdend - 1)
285 if (fd < MSVCRT_fdstart)
291 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE, starting from fd */
292 /* caller must hold the files lock */
293 static int msvcrt_alloc_fd_from(HANDLE hand, int flag, int fd)
297 if (fd >= MSVCRT_MAX_FILES)
299 WARN(":files exhausted!\n");
300 *MSVCRT__errno() = MSVCRT_ENFILE;
304 fdinfo = msvcrt_get_ioinfo(fd);
305 if(fdinfo == &MSVCRT___badioinfo) {
308 MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE] = MSVCRT_calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(ioinfo));
309 if(!MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE]) {
310 WARN(":out of memory!\n");
311 *MSVCRT__errno() = MSVCRT_ENOMEM;
315 for(i=0; i<MSVCRT_FD_BLOCK_SIZE; i++)
316 MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE][i].handle = INVALID_HANDLE_VALUE;
318 fdinfo = msvcrt_get_ioinfo(fd);
321 fdinfo->handle = hand;
322 fdinfo->wxflag = WX_OPEN | (flag & (WX_DONTINHERIT | WX_APPEND | WX_TEXT | WX_PIPE));
323 fdinfo->lookahead[0] = '\n';
324 fdinfo->lookahead[1] = '\n';
325 fdinfo->lookahead[2] = '\n';
328 /* locate next free slot */
329 if (fd == MSVCRT_fdstart && fd == MSVCRT_fdend)
330 MSVCRT_fdstart = MSVCRT_fdend + 1;
332 while (MSVCRT_fdstart < MSVCRT_fdend &&
333 msvcrt_get_ioinfo(MSVCRT_fdstart)->handle != INVALID_HANDLE_VALUE)
335 /* update last fd in use */
336 if (fd >= MSVCRT_fdend)
337 MSVCRT_fdend = fd + 1;
338 TRACE("fdstart is %d, fdend is %d\n", MSVCRT_fdstart, MSVCRT_fdend);
342 case 0: SetStdHandle(STD_INPUT_HANDLE, hand); break;
343 case 1: SetStdHandle(STD_OUTPUT_HANDLE, hand); break;
344 case 2: SetStdHandle(STD_ERROR_HANDLE, hand); break;
350 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
351 static int msvcrt_alloc_fd(HANDLE hand, int flag)
356 TRACE(":handle (%p) allocating fd (%d)\n",hand,MSVCRT_fdstart);
357 ret = msvcrt_alloc_fd_from(hand, flag, MSVCRT_fdstart);
362 /* INTERNAL: Allocate a FILE* for an fd slot */
363 /* caller must hold the files lock */
364 static MSVCRT_FILE* msvcrt_alloc_fp(void)
369 for (i = 3; i < MSVCRT_max_streams; i++)
371 file = msvcrt_get_file(i);
375 if (file->_flag == 0)
377 if (i == MSVCRT_stream_idx)
379 if (file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
381 InitializeCriticalSection(&((file_crit*)file)->crit);
382 ((file_crit*)file)->crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": file_crit.crit");
393 /* INTERNAL: initialize a FILE* from an open fd */
394 static int msvcrt_init_fp(MSVCRT_FILE* file, int fd, unsigned stream_flags)
396 TRACE(":fd (%d) allocating FILE*\n",fd);
397 if (!msvcrt_is_valid_fd(fd))
399 WARN(":invalid fd %d\n",fd);
400 *MSVCRT___doserrno() = 0;
401 *MSVCRT__errno() = MSVCRT_EBADF;
404 memset(file, 0, sizeof(*file));
406 file->_flag = stream_flags;
408 TRACE(":got FILE* (%p)\n",file);
412 /* INTERNAL: Create an inheritance data block (for spawned process)
413 * The inheritance block is made of:
414 * 00 int nb of file descriptor (NBFD)
415 * 04 char file flags (wxflag): repeated for each fd
416 * 4+NBFD HANDLE file handle: repeated for each fd
418 unsigned msvcrt_create_io_inherit_block(WORD *size, BYTE **block)
425 *size = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * MSVCRT_fdend;
426 *block = MSVCRT_calloc(*size, 1);
432 wxflag_ptr = (char*)*block + sizeof(unsigned);
433 handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
435 *(unsigned*)*block = MSVCRT_fdend;
436 for (fd = 0; fd < MSVCRT_fdend; fd++)
438 /* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
439 fdinfo = msvcrt_get_ioinfo(fd);
440 if ((fdinfo->wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
442 *wxflag_ptr = fdinfo->wxflag;
443 *handle_ptr = fdinfo->handle;
448 *handle_ptr = INVALID_HANDLE_VALUE;
450 wxflag_ptr++; handle_ptr++;
455 /* INTERNAL: Set up all file descriptors,
456 * as well as default streams (stdin, stderr and stdout)
458 void msvcrt_init_io(void)
464 GetStartupInfoA(&si);
465 if (si.cbReserved2 >= sizeof(unsigned int) && si.lpReserved2 != NULL)
471 count = *(unsigned*)si.lpReserved2;
472 wxflag_ptr = si.lpReserved2 + sizeof(unsigned);
473 handle_ptr = (HANDLE*)(wxflag_ptr + count);
475 count = min(count, (si.cbReserved2 - sizeof(unsigned)) / (sizeof(HANDLE) + 1));
476 count = min(count, MSVCRT_MAX_FILES);
477 for (i = 0; i < count; i++)
479 if ((*wxflag_ptr & WX_OPEN) && *handle_ptr != INVALID_HANDLE_VALUE)
480 msvcrt_alloc_fd_from(*handle_ptr, *wxflag_ptr, i);
482 wxflag_ptr++; handle_ptr++;
484 MSVCRT_fdend = max( 3, count );
485 for (MSVCRT_fdstart = 3; MSVCRT_fdstart < MSVCRT_fdend; MSVCRT_fdstart++)
486 if (msvcrt_get_ioinfo(MSVCRT_fdstart)->handle == INVALID_HANDLE_VALUE) break;
489 if(!MSVCRT___pioinfo[0])
490 msvcrt_alloc_fd_from(INVALID_HANDLE_VALUE, 0, 3);
492 fdinfo = msvcrt_get_ioinfo(0);
493 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE)
495 HANDLE std = GetStdHandle(STD_INPUT_HANDLE);
496 if (std != INVALID_HANDLE_VALUE && DuplicateHandle(GetCurrentProcess(), std,
497 GetCurrentProcess(), &fdinfo->handle,
498 0, TRUE, DUPLICATE_SAME_ACCESS))
499 fdinfo->wxflag = WX_OPEN | WX_TEXT;
500 fdinfo->lookahead[0] = '\n';
501 fdinfo->lookahead[1] = '\n';
502 fdinfo->lookahead[2] = '\n';
506 fdinfo = msvcrt_get_ioinfo(1);
507 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE)
509 HANDLE std = GetStdHandle(STD_OUTPUT_HANDLE);
510 if (std != INVALID_HANDLE_VALUE && DuplicateHandle(GetCurrentProcess(), std,
511 GetCurrentProcess(), &fdinfo->handle,
512 0, TRUE, DUPLICATE_SAME_ACCESS))
513 fdinfo->wxflag = WX_OPEN | WX_TEXT;
514 fdinfo->lookahead[0] = '\n';
515 fdinfo->lookahead[1] = '\n';
516 fdinfo->lookahead[2] = '\n';
520 fdinfo = msvcrt_get_ioinfo(2);
521 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE)
523 HANDLE std = GetStdHandle(STD_ERROR_HANDLE);
524 if (std != INVALID_HANDLE_VALUE && DuplicateHandle(GetCurrentProcess(), std,
525 GetCurrentProcess(), &fdinfo->handle,
526 0, TRUE, DUPLICATE_SAME_ACCESS))
527 fdinfo->wxflag = WX_OPEN | WX_TEXT;
528 fdinfo->lookahead[0] = '\n';
529 fdinfo->lookahead[1] = '\n';
530 fdinfo->lookahead[2] = '\n';
534 TRACE(":handles (%p)(%p)(%p)\n", msvcrt_get_ioinfo(0)->handle,
535 msvcrt_get_ioinfo(1)->handle, msvcrt_get_ioinfo(2)->handle);
537 memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
538 for (i = 0; i < 3; i++)
540 /* FILE structs for stdin/out/err are static and never deleted */
541 MSVCRT__iob[i]._file = i;
542 MSVCRT__iob[i]._tmpfname = NULL;
543 MSVCRT__iob[i]._flag = (i == 0) ? MSVCRT__IOREAD : MSVCRT__IOWRT;
545 MSVCRT_stream_idx = 3;
548 /* INTERNAL: Flush stdio file buffer */
549 static int msvcrt_flush_buffer(MSVCRT_FILE* file)
552 int cnt=file->_ptr-file->_base;
553 if(cnt>0 && MSVCRT__write(file->_file, file->_base, cnt) != cnt) {
554 file->_flag |= MSVCRT__IOERR;
557 file->_ptr=file->_base;
558 file->_cnt=file->_bufsiz;
563 /* INTERNAL: Allocate stdio file buffer */
564 static void msvcrt_alloc_buffer(MSVCRT_FILE* file)
566 file->_base = MSVCRT_calloc(MSVCRT_BUFSIZ,1);
568 file->_bufsiz = MSVCRT_BUFSIZ;
569 file->_flag |= MSVCRT__IOMYBUF;
571 file->_base = (char*)(&file->_charbuf);
573 file->_bufsiz = sizeof(file->_charbuf);
575 file->_ptr = file->_base;
579 /* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
580 static int msvcrt_int_to_base32(int num, char *str)
595 *p = (num & 31) + '0';
597 *p += ('a' - '0' - 10);
604 /* INTERNAL: wide character version of msvcrt_int_to_base32 */
605 static int msvcrt_int_to_base32_w(int num, MSVCRT_wchar_t *str)
620 *p = (num & 31) + '0';
622 *p += ('a' - '0' - 10);
629 /*********************************************************************
630 * __iob_func(MSVCRT.@)
632 MSVCRT_FILE * CDECL MSVCRT___iob_func(void)
634 return &MSVCRT__iob[0];
637 /*********************************************************************
640 int CDECL MSVCRT__access(const char *filename, int mode)
642 DWORD attr = GetFileAttributesA(filename);
644 TRACE("(%s,%d) %d\n",filename,mode,attr);
646 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
648 msvcrt_set_errno(GetLastError());
651 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
653 msvcrt_set_errno(ERROR_ACCESS_DENIED);
659 /*********************************************************************
660 * _access_s (MSVCRT.@)
662 int CDECL _access_s(const char *filename, int mode)
664 if (!MSVCRT_CHECK_PMT(filename != NULL)) return -1;
665 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return -1;
667 return MSVCRT__access(filename, mode);
670 /*********************************************************************
671 * _waccess (MSVCRT.@)
673 int CDECL MSVCRT__waccess(const MSVCRT_wchar_t *filename, int mode)
675 DWORD attr = GetFileAttributesW(filename);
677 TRACE("(%s,%d) %d\n",debugstr_w(filename),mode,attr);
679 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
681 msvcrt_set_errno(GetLastError());
684 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
686 msvcrt_set_errno(ERROR_ACCESS_DENIED);
692 /*********************************************************************
693 * _waccess_s (MSVCRT.@)
695 int CDECL _waccess_s(const MSVCRT_wchar_t *filename, int mode)
697 if (!MSVCRT_CHECK_PMT(filename != NULL)) return -1;
698 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return -1;
700 return MSVCRT__waccess(filename, mode);
703 /*********************************************************************
706 int CDECL MSVCRT__chmod(const char *path, int flags)
708 DWORD oldFlags = GetFileAttributesA(path);
710 if (oldFlags != INVALID_FILE_ATTRIBUTES)
712 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
713 oldFlags | FILE_ATTRIBUTE_READONLY;
715 if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
718 msvcrt_set_errno(GetLastError());
722 /*********************************************************************
725 int CDECL MSVCRT__wchmod(const MSVCRT_wchar_t *path, int flags)
727 DWORD oldFlags = GetFileAttributesW(path);
729 if (oldFlags != INVALID_FILE_ATTRIBUTES)
731 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
732 oldFlags | FILE_ATTRIBUTE_READONLY;
734 if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
737 msvcrt_set_errno(GetLastError());
741 /*********************************************************************
744 int CDECL MSVCRT__unlink(const char *path)
746 TRACE("%s\n",debugstr_a(path));
747 if(DeleteFileA(path))
749 TRACE("failed (%d)\n",GetLastError());
750 msvcrt_set_errno(GetLastError());
754 /*********************************************************************
755 * _wunlink (MSVCRT.@)
757 int CDECL MSVCRT__wunlink(const MSVCRT_wchar_t *path)
759 TRACE("(%s)\n",debugstr_w(path));
760 if(DeleteFileW(path))
762 TRACE("failed (%d)\n",GetLastError());
763 msvcrt_set_errno(GetLastError());
767 /* flush_all_buffers calls MSVCRT_fflush which calls flush_all_buffers */
768 int CDECL MSVCRT_fflush(MSVCRT_FILE* file);
770 /* INTERNAL: Flush all stream buffer */
771 static int msvcrt_flush_all_buffers(int mask)
773 int i, num_flushed = 0;
777 for (i = 3; i < MSVCRT_stream_idx; i++) {
778 file = msvcrt_get_file(i);
782 if(file->_flag & mask) {
790 TRACE(":flushed (%d) handles\n",num_flushed);
794 /*********************************************************************
795 * _flushall (MSVCRT.@)
797 int CDECL MSVCRT__flushall(void)
799 return msvcrt_flush_all_buffers(MSVCRT__IOWRT | MSVCRT__IOREAD);
802 /*********************************************************************
805 int CDECL MSVCRT_fflush(MSVCRT_FILE* file)
808 msvcrt_flush_all_buffers(MSVCRT__IOWRT);
809 } else if(file->_flag & MSVCRT__IOWRT) {
812 MSVCRT__lock_file(file);
813 res = msvcrt_flush_buffer(file);
814 MSVCRT__unlock_file(file);
817 } else if(file->_flag & MSVCRT__IOREAD) {
818 MSVCRT__lock_file(file);
820 file->_ptr = file->_base;
821 MSVCRT__unlock_file(file);
828 /*********************************************************************
831 int CDECL MSVCRT__close(int fd)
837 hand = msvcrt_fdtoh(fd);
838 TRACE(":fd (%d) handle (%p)\n",fd,hand);
839 if (!msvcrt_is_valid_fd(fd)) {
843 ret = CloseHandle(hand) ? 0 : -1;
845 WARN(":failed-last error (%d)\n",GetLastError());
846 msvcrt_set_errno(GetLastError());
854 /*********************************************************************
857 int CDECL MSVCRT__commit(int fd)
859 HANDLE hand = msvcrt_fdtoh(fd);
861 TRACE(":fd (%d) handle (%p)\n",fd,hand);
862 if (hand == INVALID_HANDLE_VALUE)
865 if (!FlushFileBuffers(hand))
867 if (GetLastError() == ERROR_INVALID_HANDLE)
869 /* FlushFileBuffers fails for console handles
870 * so we ignore this error.
874 TRACE(":failed-last error (%d)\n",GetLastError());
875 msvcrt_set_errno(GetLastError());
882 /*********************************************************************
885 * MSDN isn't clear on this point, but the remarks for _pipe
886 * indicate file descriptors duplicated with _dup and _dup2 are always
889 int CDECL MSVCRT__dup2(int od, int nd)
893 TRACE("(od=%d, nd=%d)\n", od, nd);
895 if (nd < MSVCRT_MAX_FILES && nd >= 0 && msvcrt_is_valid_fd(od))
899 if (DuplicateHandle(GetCurrentProcess(), msvcrt_get_ioinfo(od)->handle,
900 GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS))
902 int wxflag = msvcrt_get_ioinfo(od)->wxflag & ~MSVCRT__O_NOINHERIT;
904 if (msvcrt_is_valid_fd(nd))
906 ret = msvcrt_alloc_fd_from(handle, wxflag, nd);
910 *MSVCRT__errno() = MSVCRT_EMFILE;
914 /* _dup2 returns 0, not nd, on success */
921 msvcrt_set_errno(GetLastError());
926 *MSVCRT__errno() = MSVCRT_EBADF;
933 /*********************************************************************
936 int CDECL MSVCRT__dup(int od)
942 if (MSVCRT__dup2(od, fd) == 0)
950 /*********************************************************************
953 int CDECL MSVCRT__eof(int fd)
956 LONG hcurpos,hendpos;
957 HANDLE hand = msvcrt_fdtoh(fd);
959 TRACE(":fd (%d) handle (%p)\n",fd,hand);
961 if (hand == INVALID_HANDLE_VALUE)
964 if (msvcrt_get_ioinfo(fd)->wxflag & WX_ATEOF) return TRUE;
966 /* Otherwise we do it the hard way */
967 hcurpos = hendpos = 0;
968 curpos = SetFilePointer(hand, 0, &hcurpos, FILE_CURRENT);
969 endpos = SetFilePointer(hand, 0, &hendpos, FILE_END);
971 if (curpos == endpos && hcurpos == hendpos)
973 /* FIXME: shouldn't WX_ATEOF be set here? */
977 SetFilePointer(hand, curpos, &hcurpos, FILE_BEGIN);
981 /*********************************************************************
982 * _fcloseall (MSVCRT.@)
984 int CDECL MSVCRT__fcloseall(void)
986 int num_closed = 0, i;
990 for (i = 3; i < MSVCRT_stream_idx; i++) {
991 file = msvcrt_get_file(i);
993 if (file->_flag && !MSVCRT_fclose(file))
998 TRACE(":closed (%d) handles\n",num_closed);
1002 /* free everything on process exit */
1003 void msvcrt_free_io(void)
1007 MSVCRT__fcloseall();
1008 /* The Win32 _fcloseall() function explicitly doesn't close stdin,
1009 * stdout, and stderr (unlike GNU), so we need to fclose() them here
1010 * or they won't get flushed.
1012 MSVCRT_fclose(&MSVCRT__iob[0]);
1013 MSVCRT_fclose(&MSVCRT__iob[1]);
1014 MSVCRT_fclose(&MSVCRT__iob[2]);
1016 for(i=0; i<sizeof(MSVCRT___pioinfo)/sizeof(MSVCRT___pioinfo[0]); i++)
1017 MSVCRT_free(MSVCRT___pioinfo[i]);
1019 for(i=0; i<MSVCRT_stream_idx; i++)
1021 MSVCRT_FILE *file = msvcrt_get_file(i);
1022 if(file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
1024 ((file_crit*)file)->crit.DebugInfo->Spare[0] = 0;
1025 DeleteCriticalSection(&((file_crit*)file)->crit);
1029 for(i=0; i<sizeof(MSVCRT_fstream)/sizeof(MSVCRT_fstream[0]); i++)
1030 MSVCRT_free(MSVCRT_fstream[i]);
1032 DeleteCriticalSection(&MSVCRT_file_cs);
1035 /*********************************************************************
1036 * _lseeki64 (MSVCRT.@)
1038 __int64 CDECL MSVCRT__lseeki64(int fd, __int64 offset, int whence)
1040 HANDLE hand = msvcrt_fdtoh(fd);
1043 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1044 if (hand == INVALID_HANDLE_VALUE)
1047 if (whence < 0 || whence > 2)
1049 *MSVCRT__errno() = MSVCRT_EINVAL;
1053 TRACE(":fd (%d) to %s pos %s\n",
1054 fd,wine_dbgstr_longlong(offset),
1055 (whence==SEEK_SET)?"SEEK_SET":
1056 (whence==SEEK_CUR)?"SEEK_CUR":
1057 (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
1059 /* The MoleBox protection scheme expects msvcrt to use SetFilePointer only,
1060 * so a LARGE_INTEGER offset cannot be passed directly via SetFilePointerEx. */
1061 ofs.QuadPart = offset;
1062 if ((ofs.u.LowPart = SetFilePointer(hand, ofs.u.LowPart, &ofs.u.HighPart, whence)) != INVALID_SET_FILE_POINTER ||
1063 GetLastError() == ERROR_SUCCESS)
1065 msvcrt_get_ioinfo(fd)->wxflag &= ~WX_ATEOF;
1066 /* FIXME: What if we seek _to_ EOF - is EOF set? */
1068 return ofs.QuadPart;
1070 TRACE(":error-last error (%d)\n",GetLastError());
1071 msvcrt_set_errno(GetLastError());
1075 /*********************************************************************
1078 LONG CDECL MSVCRT__lseek(int fd, LONG offset, int whence)
1080 return MSVCRT__lseeki64(fd, offset, whence);
1083 /*********************************************************************
1084 * _lock_file (MSVCRT.@)
1086 void CDECL MSVCRT__lock_file(MSVCRT_FILE *file)
1088 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1089 _lock(_STREAM_LOCKS+(file-MSVCRT__iob));
1091 EnterCriticalSection(&((file_crit*)file)->crit);
1094 /*********************************************************************
1095 * _unlock_file (MSVCRT.@)
1097 void CDECL MSVCRT__unlock_file(MSVCRT_FILE *file)
1099 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1100 _unlock(_STREAM_LOCKS+(file-MSVCRT__iob));
1102 LeaveCriticalSection(&((file_crit*)file)->crit);
1105 /*********************************************************************
1106 * _locking (MSVCRT.@)
1108 * This is untested; the underlying LockFile doesn't work yet.
1110 int CDECL MSVCRT__locking(int fd, int mode, LONG nbytes)
1114 HANDLE hand = msvcrt_fdtoh(fd);
1116 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1117 if (hand == INVALID_HANDLE_VALUE)
1120 if (mode < 0 || mode > 4)
1122 *MSVCRT__errno() = MSVCRT_EINVAL;
1126 TRACE(":fd (%d) by 0x%08x mode %s\n",
1127 fd,nbytes,(mode==MSVCRT__LK_UNLCK)?"_LK_UNLCK":
1128 (mode==MSVCRT__LK_LOCK)?"_LK_LOCK":
1129 (mode==MSVCRT__LK_NBLCK)?"_LK_NBLCK":
1130 (mode==MSVCRT__LK_RLCK)?"_LK_RLCK":
1131 (mode==MSVCRT__LK_NBRLCK)?"_LK_NBRLCK":
1134 if ((cur_locn = SetFilePointer(hand, 0L, NULL, SEEK_CUR)) == INVALID_SET_FILE_POINTER)
1136 FIXME ("Seek failed\n");
1137 *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
1140 if (mode == MSVCRT__LK_LOCK || mode == MSVCRT__LK_RLCK)
1143 ret = 1; /* just to satisfy gcc */
1146 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
1151 else if (mode == MSVCRT__LK_UNLCK)
1152 ret = UnlockFile(hand, cur_locn, 0L, nbytes, 0L);
1154 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
1155 /* FIXME - what about error settings? */
1156 return ret ? 0 : -1;
1159 /*********************************************************************
1160 * _fseeki64 (MSVCRT.@)
1162 int CDECL MSVCRT__fseeki64(MSVCRT_FILE* file, __int64 offset, int whence)
1166 MSVCRT__lock_file(file);
1167 /* Flush output if needed */
1168 if(file->_flag & MSVCRT__IOWRT)
1169 msvcrt_flush_buffer(file);
1171 if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
1173 offset += MSVCRT__ftelli64(file);
1176 /* Discard buffered input */
1178 file->_ptr = file->_base;
1179 /* Reset direction of i/o */
1180 if(file->_flag & MSVCRT__IORW) {
1181 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
1183 /* Clear end of file flag */
1184 file->_flag &= ~MSVCRT__IOEOF;
1185 ret = (MSVCRT__lseeki64(file->_file,offset,whence) == -1)?-1:0;
1187 MSVCRT__unlock_file(file);
1191 /*********************************************************************
1194 int CDECL MSVCRT_fseek(MSVCRT_FILE* file, MSVCRT_long offset, int whence)
1196 return MSVCRT__fseeki64( file, offset, whence );
1199 /*********************************************************************
1200 * _chsize (MSVCRT.@)
1202 int CDECL MSVCRT__chsize(int fd, MSVCRT_long size)
1208 TRACE("(fd=%d, size=%d)\n", fd, size);
1212 handle = msvcrt_fdtoh(fd);
1213 if (handle != INVALID_HANDLE_VALUE)
1215 /* save the current file pointer */
1216 cur = MSVCRT__lseek(fd, 0, SEEK_CUR);
1219 pos = MSVCRT__lseek(fd, size, SEEK_SET);
1222 ret = SetEndOfFile(handle);
1223 if (!ret) msvcrt_set_errno(GetLastError());
1226 /* restore the file pointer */
1227 MSVCRT__lseek(fd, cur, SEEK_SET);
1232 return ret ? 0 : -1;
1235 /*********************************************************************
1236 * clearerr (MSVCRT.@)
1238 void CDECL MSVCRT_clearerr(MSVCRT_FILE* file)
1240 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1242 MSVCRT__lock_file(file);
1243 file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
1244 MSVCRT__unlock_file(file);
1247 /*********************************************************************
1250 void CDECL MSVCRT_rewind(MSVCRT_FILE* file)
1252 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1254 MSVCRT__lock_file(file);
1255 MSVCRT_fseek(file, 0L, SEEK_SET);
1256 MSVCRT_clearerr(file);
1257 MSVCRT__unlock_file(file);
1260 static int msvcrt_get_flags(const MSVCRT_wchar_t* mode, int *open_flags, int* stream_flags)
1262 int plus = strchrW(mode, '+') != NULL;
1264 TRACE("%s\n", debugstr_w(mode));
1266 while(*mode == ' ') mode++;
1271 *open_flags = plus ? MSVCRT__O_RDWR : MSVCRT__O_RDONLY;
1272 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOREAD;
1275 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_TRUNC | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1276 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1279 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_APPEND | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1280 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1283 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1287 while (*mode && *mode!=',')
1291 *open_flags |= MSVCRT__O_BINARY;
1292 *open_flags &= ~MSVCRT__O_TEXT;
1295 *open_flags |= MSVCRT__O_TEXT;
1296 *open_flags &= ~MSVCRT__O_BINARY;
1299 *open_flags |= MSVCRT__O_TEMPORARY;
1302 *open_flags |= MSVCRT__O_SHORT_LIVED;
1310 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1316 static const WCHAR ccs[] = {'c','c','s'};
1317 static const WCHAR utf8[] = {'u','t','f','-','8'};
1318 static const WCHAR utf16le[] = {'u','t','f','-','1','6','l','e'};
1319 static const WCHAR unicode[] = {'u','n','i','c','o','d','e'};
1322 while(*mode == ' ') mode++;
1323 if(!MSVCRT_CHECK_PMT(!strncmpW(ccs, mode, sizeof(ccs)/sizeof(ccs[0]))))
1325 mode += sizeof(ccs)/sizeof(ccs[0]);
1326 while(*mode == ' ') mode++;
1327 if(!MSVCRT_CHECK_PMT(*mode == '='))
1330 while(*mode == ' ') mode++;
1332 if(!strncmpiW(utf8, mode, sizeof(utf8)/sizeof(utf8[0])))
1334 *open_flags |= MSVCRT__O_U8TEXT;
1335 mode += sizeof(utf8)/sizeof(utf8[0]);
1337 else if(!strncmpiW(utf16le, mode, sizeof(utf16le)/sizeof(utf16le[0])))
1339 *open_flags |= MSVCRT__O_U16TEXT;
1340 mode += sizeof(utf16le)/sizeof(utf16le[0]);
1342 else if(!strncmpiW(unicode, mode, sizeof(unicode)/sizeof(unicode[0])))
1344 *open_flags |= MSVCRT__O_WTEXT;
1345 mode += sizeof(unicode)/sizeof(unicode[0]);
1349 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1353 while(*mode == ' ') mode++;
1356 if(!MSVCRT_CHECK_PMT(*mode == 0))
1361 /*********************************************************************
1362 * _fdopen (MSVCRT.@)
1364 MSVCRT_FILE* CDECL MSVCRT__fdopen(int fd, const char *mode)
1367 MSVCRT_wchar_t *modeW = NULL;
1369 if (mode && !(modeW = msvcrt_wstrdupa(mode))) return NULL;
1371 ret = MSVCRT__wfdopen(fd, modeW);
1377 /*********************************************************************
1378 * _wfdopen (MSVCRT.@)
1380 MSVCRT_FILE* CDECL MSVCRT__wfdopen(int fd, const MSVCRT_wchar_t *mode)
1382 int open_flags, stream_flags;
1385 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
1388 if (!(file = msvcrt_alloc_fp()))
1390 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
1395 else TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
1401 /*********************************************************************
1402 * _filelength (MSVCRT.@)
1404 LONG CDECL MSVCRT__filelength(int fd)
1406 LONG curPos = MSVCRT__lseek(fd, 0, SEEK_CUR);
1409 LONG endPos = MSVCRT__lseek(fd, 0, SEEK_END);
1412 if (endPos != curPos)
1413 MSVCRT__lseek(fd, curPos, SEEK_SET);
1420 /*********************************************************************
1421 * _filelengthi64 (MSVCRT.@)
1423 __int64 CDECL MSVCRT__filelengthi64(int fd)
1425 __int64 curPos = MSVCRT__lseeki64(fd, 0, SEEK_CUR);
1428 __int64 endPos = MSVCRT__lseeki64(fd, 0, SEEK_END);
1431 if (endPos != curPos)
1432 MSVCRT__lseeki64(fd, curPos, SEEK_SET);
1439 /*********************************************************************
1440 * _fileno (MSVCRT.@)
1442 int CDECL MSVCRT__fileno(MSVCRT_FILE* file)
1444 TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
1448 /*********************************************************************
1449 * _fstat64 (MSVCRT.@)
1451 int CDECL MSVCRT__fstat64(int fd, struct MSVCRT__stat64* buf)
1455 BY_HANDLE_FILE_INFORMATION hfi;
1456 HANDLE hand = msvcrt_fdtoh(fd);
1458 TRACE(":fd (%d) stat (%p)\n",fd,buf);
1459 if (hand == INVALID_HANDLE_VALUE)
1464 WARN(":failed-NULL buf\n");
1465 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1469 memset(&hfi, 0, sizeof(hfi));
1470 memset(buf, 0, sizeof(struct MSVCRT__stat64));
1471 type = GetFileType(hand);
1472 if (type == FILE_TYPE_PIPE)
1474 buf->st_dev = buf->st_rdev = fd;
1475 buf->st_mode = S_IFIFO;
1478 else if (type == FILE_TYPE_CHAR)
1480 buf->st_dev = buf->st_rdev = fd;
1481 buf->st_mode = S_IFCHR;
1484 else /* FILE_TYPE_DISK etc. */
1486 if (!GetFileInformationByHandle(hand, &hfi))
1488 WARN(":failed-last error (%d)\n",GetLastError());
1489 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1492 buf->st_mode = S_IFREG | 0444;
1493 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1494 buf->st_mode |= 0222;
1495 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1496 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1498 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1499 buf->st_mtime = buf->st_ctime = dw;
1500 buf->st_nlink = hfi.nNumberOfLinks;
1502 TRACE(":dwFileAttributes = 0x%x, mode set to 0x%x\n",hfi.dwFileAttributes,
1507 /*********************************************************************
1508 * _fstati64 (MSVCRT.@)
1510 int CDECL MSVCRT__fstati64(int fd, struct MSVCRT__stati64* buf)
1513 struct MSVCRT__stat64 buf64;
1515 ret = MSVCRT__fstat64(fd, &buf64);
1517 msvcrt_stat64_to_stati64(&buf64, buf);
1521 /*********************************************************************
1524 int CDECL MSVCRT__fstat(int fd, struct MSVCRT__stat* buf)
1526 struct MSVCRT__stat64 buf64;
1528 ret = MSVCRT__fstat64(fd, &buf64);
1530 msvcrt_stat64_to_stat(&buf64, buf);
1534 /*********************************************************************
1535 * _futime64 (MSVCRT.@)
1537 int CDECL _futime64(int fd, struct MSVCRT___utimbuf64 *t)
1539 HANDLE hand = msvcrt_fdtoh(fd);
1544 time_to_filetime( MSVCRT__time64(NULL), &at );
1549 time_to_filetime( t->actime, &at );
1550 time_to_filetime( t->modtime, &wt );
1553 if (!SetFileTime(hand, NULL, &at, &wt))
1555 msvcrt_set_errno(GetLastError());
1561 /*********************************************************************
1562 * _futime32 (MSVCRT.@)
1564 int CDECL _futime32(int fd, struct MSVCRT___utimbuf32 *t)
1568 struct MSVCRT___utimbuf64 t64;
1569 t64.actime = t->actime;
1570 t64.modtime = t->modtime;
1571 return _futime64( fd, &t64 );
1574 return _futime64( fd, NULL );
1577 /*********************************************************************
1578 * _futime (MSVCRT.@)
1581 int CDECL _futime(int fd, struct MSVCRT___utimbuf64 *t)
1583 return _futime64( fd, t );
1586 int CDECL _futime(int fd, struct MSVCRT___utimbuf32 *t)
1588 return _futime32( fd, t );
1592 /*********************************************************************
1593 * _get_osfhandle (MSVCRT.@)
1595 MSVCRT_intptr_t CDECL MSVCRT__get_osfhandle(int fd)
1597 HANDLE hand = msvcrt_fdtoh(fd);
1598 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1600 return (MSVCRT_intptr_t)hand;
1603 /*********************************************************************
1604 * _isatty (MSVCRT.@)
1606 int CDECL MSVCRT__isatty(int fd)
1608 HANDLE hand = msvcrt_fdtoh(fd);
1610 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1611 if (hand == INVALID_HANDLE_VALUE)
1614 return GetFileType(hand) == FILE_TYPE_CHAR? 1 : 0;
1617 /*********************************************************************
1618 * _mktemp (MSVCRT.@)
1620 char * CDECL MSVCRT__mktemp(char *pattern)
1623 char *retVal = pattern;
1628 numX = (*pattern++ == 'X')? numX + 1 : 0;
1632 id = GetCurrentProcessId();
1636 int tempNum = id / 10;
1637 *pattern-- = id - (tempNum * 10) + '0';
1643 *pattern = letter++;
1644 if (GetFileAttributesA(retVal) == INVALID_FILE_ATTRIBUTES &&
1645 GetLastError() == ERROR_FILE_NOT_FOUND)
1647 } while(letter <= 'z');
1651 /*********************************************************************
1652 * _wmktemp (MSVCRT.@)
1654 MSVCRT_wchar_t * CDECL MSVCRT__wmktemp(MSVCRT_wchar_t *pattern)
1657 MSVCRT_wchar_t *retVal = pattern;
1659 MSVCRT_wchar_t letter = 'a';
1662 numX = (*pattern++ == 'X')? numX + 1 : 0;
1666 id = GetCurrentProcessId();
1670 int tempNum = id / 10;
1671 *pattern-- = id - (tempNum * 10) + '0';
1677 if (GetFileAttributesW(retVal) == INVALID_FILE_ATTRIBUTES &&
1678 GetLastError() == ERROR_FILE_NOT_FOUND)
1680 *pattern = letter++;
1681 } while(letter != '|');
1685 static unsigned split_oflags(unsigned oflags)
1688 unsigned unsupp; /* until we support everything */
1690 if (oflags & MSVCRT__O_APPEND) wxflags |= WX_APPEND;
1691 if (oflags & MSVCRT__O_BINARY) {/* Nothing to do */}
1692 else if (oflags & MSVCRT__O_TEXT) wxflags |= WX_TEXT;
1693 else if (oflags & MSVCRT__O_WTEXT) wxflags |= WX_TEXT;
1694 else if (oflags & MSVCRT__O_U16TEXT) wxflags |= WX_TEXT;
1695 else if (oflags & MSVCRT__O_U8TEXT) wxflags |= WX_TEXT;
1696 else if (*__p__fmode() & MSVCRT__O_BINARY) {/* Nothing to do */}
1697 else wxflags |= WX_TEXT; /* default to TEXT*/
1698 if (oflags & MSVCRT__O_NOINHERIT) wxflags |= WX_DONTINHERIT;
1700 if ((unsupp = oflags & ~(
1701 MSVCRT__O_BINARY|MSVCRT__O_TEXT|MSVCRT__O_APPEND|
1702 MSVCRT__O_TRUNC|MSVCRT__O_EXCL|MSVCRT__O_CREAT|
1703 MSVCRT__O_RDWR|MSVCRT__O_WRONLY|MSVCRT__O_TEMPORARY|
1704 MSVCRT__O_NOINHERIT|
1705 MSVCRT__O_SEQUENTIAL|MSVCRT__O_RANDOM|MSVCRT__O_SHORT_LIVED|
1706 MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT
1708 ERR(":unsupported oflags 0x%04x\n",unsupp);
1713 /*********************************************************************
1716 int CDECL MSVCRT__pipe(int *pfds, unsigned int psize, int textmode)
1719 SECURITY_ATTRIBUTES sa;
1720 HANDLE readHandle, writeHandle;
1724 *MSVCRT__errno() = MSVCRT_EINVAL;
1728 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
1729 sa.bInheritHandle = !(textmode & MSVCRT__O_NOINHERIT);
1730 sa.lpSecurityDescriptor = NULL;
1731 if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
1733 unsigned int wxflags = split_oflags(textmode);
1737 fd = msvcrt_alloc_fd(readHandle, wxflags|WX_PIPE);
1741 fd = msvcrt_alloc_fd(writeHandle, wxflags|WX_PIPE);
1749 MSVCRT__close(pfds[0]);
1750 CloseHandle(writeHandle);
1751 *MSVCRT__errno() = MSVCRT_EMFILE;
1756 CloseHandle(readHandle);
1757 CloseHandle(writeHandle);
1758 *MSVCRT__errno() = MSVCRT_EMFILE;
1763 msvcrt_set_errno(GetLastError());
1768 static int check_bom(HANDLE h, int oflags, BOOL seek)
1770 char bom[sizeof(utf8_bom)];
1773 oflags &= ~(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT);
1775 if (!ReadFile(h, bom, sizeof(utf8_bom), &r, NULL))
1778 if (r==sizeof(utf8_bom) && !memcmp(bom, utf8_bom, sizeof(utf8_bom))) {
1779 oflags |= MSVCRT__O_U8TEXT;
1780 }else if (r>=sizeof(utf16_bom) && !memcmp(bom, utf16_bom, sizeof(utf16_bom))) {
1782 SetFilePointer(h, 2, NULL, FILE_BEGIN);
1783 oflags |= MSVCRT__O_U16TEXT;
1785 SetFilePointer(h, 0, NULL, FILE_BEGIN);
1791 /*********************************************************************
1792 * _wsopen_s (MSVCRT.@)
1794 int CDECL MSVCRT__wsopen_s( int *fd, const MSVCRT_wchar_t* path, int oflags, int shflags, int pmode )
1796 DWORD access = 0, creation = 0, attrib;
1797 SECURITY_ATTRIBUTES sa;
1802 TRACE("fd*: %p :file (%s) oflags: 0x%04x shflags: 0x%04x pmode: 0x%04x\n",
1803 fd, debugstr_w(path), oflags, shflags, pmode);
1805 if (!MSVCRT_CHECK_PMT( fd != NULL )) return MSVCRT_EINVAL;
1808 wxflag = split_oflags(oflags);
1809 switch (oflags & (MSVCRT__O_RDONLY | MSVCRT__O_WRONLY | MSVCRT__O_RDWR))
1811 case MSVCRT__O_RDONLY: access |= GENERIC_READ; break;
1812 case MSVCRT__O_WRONLY: access |= GENERIC_WRITE; break;
1813 case MSVCRT__O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
1816 if (oflags & MSVCRT__O_CREAT)
1818 if(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))
1819 FIXME(": pmode 0x%04x ignored\n", pmode);
1821 WARN(": pmode 0x%04x ignored\n", pmode);
1823 if (oflags & MSVCRT__O_EXCL)
1824 creation = CREATE_NEW;
1825 else if (oflags & MSVCRT__O_TRUNC)
1826 creation = CREATE_ALWAYS;
1828 creation = OPEN_ALWAYS;
1830 else /* no MSVCRT__O_CREAT */
1832 if (oflags & MSVCRT__O_TRUNC)
1833 creation = TRUNCATE_EXISTING;
1835 creation = OPEN_EXISTING;
1840 case MSVCRT__SH_DENYRW:
1843 case MSVCRT__SH_DENYWR:
1844 sharing = FILE_SHARE_READ;
1846 case MSVCRT__SH_DENYRD:
1847 sharing = FILE_SHARE_WRITE;
1849 case MSVCRT__SH_DENYNO:
1850 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1853 ERR( "Unhandled shflags 0x%x\n", shflags );
1854 return MSVCRT_EINVAL;
1856 attrib = FILE_ATTRIBUTE_NORMAL;
1858 if (oflags & MSVCRT__O_TEMPORARY)
1860 attrib |= FILE_FLAG_DELETE_ON_CLOSE;
1862 sharing |= FILE_SHARE_DELETE;
1865 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
1866 sa.lpSecurityDescriptor = NULL;
1867 sa.bInheritHandle = !(oflags & MSVCRT__O_NOINHERIT);
1869 if ((oflags&(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT))
1870 && (creation==OPEN_ALWAYS || creation==OPEN_EXISTING)
1871 && !(access&GENERIC_READ))
1873 hand = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
1874 &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
1875 if (hand != INVALID_HANDLE_VALUE)
1877 oflags = check_bom(hand, oflags, FALSE);
1881 oflags &= ~(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT);
1884 hand = CreateFileW(path, access, sharing, &sa, creation, attrib, 0);
1885 if (hand == INVALID_HANDLE_VALUE) {
1886 WARN(":failed-last error (%d)\n",GetLastError());
1887 msvcrt_set_errno(GetLastError());
1888 return *MSVCRT__errno();
1891 if (oflags & (MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT))
1893 if ((access & GENERIC_WRITE) && (creation==CREATE_NEW
1894 || creation==CREATE_ALWAYS || creation==TRUNCATE_EXISTING
1895 || (creation==OPEN_ALWAYS && GetLastError()==ERROR_ALREADY_EXISTS)))
1897 if (oflags & MSVCRT__O_U8TEXT)
1899 DWORD written = 0, tmp;
1901 while(written!=sizeof(utf8_bom) && WriteFile(hand, (char*)utf8_bom+written,
1902 sizeof(utf8_bom)-written, &tmp, NULL))
1904 if (written != sizeof(utf8_bom)) {
1905 WARN("error writting BOM\n");
1907 msvcrt_set_errno(GetLastError());
1908 return *MSVCRT__errno();
1913 DWORD written = 0, tmp;
1915 while(written!=sizeof(utf16_bom) && WriteFile(hand, (char*)utf16_bom+written,
1916 sizeof(utf16_bom)-written, &tmp, NULL))
1918 if (written != sizeof(utf16_bom))
1920 WARN("error writting BOM\n");
1922 msvcrt_set_errno(GetLastError());
1923 return *MSVCRT__errno();
1927 else if (access & GENERIC_READ)
1928 oflags = check_bom(hand, oflags, TRUE);
1931 *fd = msvcrt_alloc_fd(hand, wxflag);
1933 return *MSVCRT__errno();
1935 if (oflags & MSVCRT__O_WTEXT)
1936 msvcrt_get_ioinfo(*fd)->exflag |= EF_UTF16|EF_UNK_UNICODE;
1937 else if (oflags & MSVCRT__O_U16TEXT)
1938 msvcrt_get_ioinfo(*fd)->exflag |= EF_UTF16;
1939 else if (oflags & MSVCRT__O_U8TEXT)
1940 msvcrt_get_ioinfo(*fd)->exflag |= EF_UTF8;
1942 TRACE(":fd (%d) handle (%p)\n", *fd, hand);
1946 /*********************************************************************
1947 * _wsopen (MSVCRT.@)
1949 int CDECL MSVCRT__wsopen( const MSVCRT_wchar_t *path, int oflags, int shflags, ... )
1954 if (oflags & MSVCRT__O_CREAT)
1958 __ms_va_start(ap, shflags);
1959 pmode = va_arg(ap, int);
1965 MSVCRT__wsopen_s(&fd, path, oflags, shflags, pmode);
1969 /*********************************************************************
1970 * _sopen_s (MSVCRT.@)
1972 int CDECL MSVCRT__sopen_s( int *fd, const char *path, int oflags, int shflags, int pmode )
1974 MSVCRT_wchar_t *pathW;
1977 if(!MSVCRT_CHECK_PMT(path && (pathW = msvcrt_wstrdupa(path))))
1978 return MSVCRT_EINVAL;
1980 ret = MSVCRT__wsopen_s(fd, pathW, oflags, shflags, pmode);
1985 /*********************************************************************
1988 int CDECL MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
1993 if (oflags & MSVCRT__O_CREAT)
1997 __ms_va_start(ap, shflags);
1998 pmode = va_arg(ap, int);
2004 MSVCRT__sopen_s(&fd, path, oflags, shflags, pmode);
2008 /*********************************************************************
2011 int CDECL MSVCRT__open( const char *path, int flags, ... )
2015 if (flags & MSVCRT__O_CREAT)
2018 __ms_va_start(ap, flags);
2019 pmode = va_arg(ap, int);
2021 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO, pmode );
2024 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO);
2027 /*********************************************************************
2030 int CDECL MSVCRT__wopen(const MSVCRT_wchar_t *path,int flags,...)
2034 if (flags & MSVCRT__O_CREAT)
2037 __ms_va_start(ap, flags);
2038 pmode = va_arg(ap, int);
2040 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO, pmode );
2043 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO);
2046 /*********************************************************************
2049 int CDECL MSVCRT__creat(const char *path, int flags)
2051 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
2052 return MSVCRT__open(path, usedFlags);
2055 /*********************************************************************
2056 * _wcreat (MSVCRT.@)
2058 int CDECL MSVCRT__wcreat(const MSVCRT_wchar_t *path, int flags)
2060 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
2061 return MSVCRT__wopen(path, usedFlags);
2064 /*********************************************************************
2065 * _open_osfhandle (MSVCRT.@)
2067 int CDECL MSVCRT__open_osfhandle(MSVCRT_intptr_t handle, int oflags)
2071 /* MSVCRT__O_RDONLY (0) always matches, so set the read flag
2072 * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
2073 * file, so set the write flag. It also only sets MSVCRT__O_TEXT if it wants
2074 * text - it never sets MSVCRT__O_BINARY.
2076 /* don't let split_oflags() decide the mode if no mode is passed */
2077 if (!(oflags & (MSVCRT__O_BINARY | MSVCRT__O_TEXT)))
2078 oflags |= MSVCRT__O_BINARY;
2080 fd = msvcrt_alloc_fd((HANDLE)handle, split_oflags(oflags));
2081 TRACE(":handle (%ld) fd (%d) flags 0x%08x\n", handle, fd, oflags);
2085 /*********************************************************************
2088 int CDECL MSVCRT__rmtmp(void)
2090 int num_removed = 0, i;
2094 for (i = 3; i < MSVCRT_stream_idx; i++) {
2095 file = msvcrt_get_file(i);
2097 if (file->_tmpfname)
2099 MSVCRT_fclose(file);
2106 TRACE(":removed (%d) temp files\n",num_removed);
2110 static inline int get_utf8_char_len(char ch)
2112 if((ch&0xf8) == 0xf0)
2114 else if((ch&0xf0) == 0xe0)
2116 else if((ch&0xe0) == 0xc0)
2121 /*********************************************************************
2122 * (internal) read_utf8
2124 static int read_utf8(int fd, MSVCRT_wchar_t *buf, unsigned int count)
2126 ioinfo *fdinfo = msvcrt_get_ioinfo(fd);
2127 HANDLE hand = fdinfo->handle;
2128 char min_buf[4], *readbuf, lookahead;
2129 DWORD readbuf_size, pos=0, num_read=1, char_len, i, j;
2131 /* make the buffer big enough to hold at least one character */
2132 /* read bytes have to fit to output and lookahead buffers */
2134 readbuf_size = count < 4 ? 4 : count;
2135 if(readbuf_size<=4 || !(readbuf = MSVCRT_malloc(readbuf_size))) {
2140 if(fdinfo->lookahead[0] != '\n') {
2141 readbuf[pos++] = fdinfo->lookahead[0];
2142 fdinfo->lookahead[0] = '\n';
2144 if(fdinfo->lookahead[1] != '\n') {
2145 readbuf[pos++] = fdinfo->lookahead[1];
2146 fdinfo->lookahead[1] = '\n';
2148 if(fdinfo->lookahead[2] != '\n') {
2149 readbuf[pos++] = fdinfo->lookahead[2];
2150 fdinfo->lookahead[2] = '\n';
2155 /* NOTE: this case is broken in native dll, reading
2156 * sometimes fails when small buffer is passed
2159 if(!pos && !ReadFile(hand, readbuf, 1, &num_read, NULL)) {
2160 if (GetLastError() == ERROR_BROKEN_PIPE) {
2161 fdinfo->wxflag |= WX_ATEOF;
2164 msvcrt_set_errno(GetLastError());
2167 }else if(!num_read) {
2168 fdinfo->wxflag |= WX_ATEOF;
2174 char_len = get_utf8_char_len(readbuf[0]);
2176 if(ReadFile(hand, readbuf+pos, char_len-pos, &num_read, NULL))
2180 if(readbuf[0] == '\n')
2181 fdinfo->wxflag |= WX_READNL;
2183 fdinfo->wxflag &= ~WX_READNL;
2185 if(readbuf[0] == 0x1a) {
2186 fdinfo->wxflag |= WX_ATEOF;
2190 if(readbuf[0] == '\r') {
2191 if(!ReadFile(hand, &lookahead, 1, &num_read, NULL) || num_read!=1)
2193 else if(lookahead == '\n')
2197 if(fdinfo->wxflag & WX_PIPE)
2198 fdinfo->lookahead[0] = lookahead;
2200 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2205 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2206 msvcrt_set_errno(GetLastError());
2213 if(!ReadFile(hand, readbuf+pos, readbuf_size-pos, &num_read, NULL)) {
2216 }else if(GetLastError() == ERROR_BROKEN_PIPE) {
2217 fdinfo->wxflag |= WX_ATEOF;
2220 msvcrt_set_errno(GetLastError());
2223 }else if(!pos && !num_read) {
2224 fdinfo->wxflag |= WX_ATEOF;
2229 if(readbuf[0] == '\n')
2230 fdinfo->wxflag |= WX_READNL;
2232 fdinfo->wxflag &= ~WX_READNL;
2234 /* Find first byte of last character (may be incomplete) */
2235 for(i=pos-1; i>0 && i>pos-4; i--)
2236 if((readbuf[i]&0xc0) != 0x80)
2238 char_len = get_utf8_char_len(readbuf[i]);
2239 if(char_len+i <= pos)
2242 if(fdinfo->wxflag & WX_PIPE) {
2244 fdinfo->lookahead[0] = readbuf[i];
2246 fdinfo->lookahead[1] = readbuf[i+1];
2248 fdinfo->lookahead[2] = readbuf[i+2];
2250 SetFilePointer(fdinfo->handle, i-pos, NULL, FILE_CURRENT);
2254 for(i=0, j=0; i<pos; i++) {
2255 if(readbuf[i] == 0x1a) {
2256 fdinfo->wxflag |= WX_ATEOF;
2260 /* strip '\r' if followed by '\n' */
2261 if(readbuf[i] == '\r' && i+1==pos) {
2262 if(fdinfo->lookahead[0] != '\n' || !ReadFile(hand, &lookahead, 1, &num_read, NULL) || !num_read) {
2263 readbuf[j++] = '\r';
2264 }else if(lookahead == '\n' && j==0) {
2265 readbuf[j++] = '\n';
2267 if(lookahead != '\n')
2268 readbuf[j++] = '\r';
2270 if(fdinfo->wxflag & WX_PIPE)
2271 fdinfo->lookahead[0] = lookahead;
2273 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2275 }else if(readbuf[i]!='\r' || readbuf[i+1]!='\n') {
2276 readbuf[j++] = readbuf[i];
2281 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2282 msvcrt_set_errno(GetLastError());
2289 /*********************************************************************
2292 * When reading \r as last character in text mode, read() positions
2293 * the file pointer on the \r character while getc() goes on to
2296 static int read_i(int fd, void *buf, unsigned int count)
2298 DWORD num_read, utf16;
2299 char *bufstart = buf;
2300 HANDLE hand = msvcrt_fdtoh(fd);
2301 ioinfo *fdinfo = msvcrt_get_ioinfo(fd);
2306 if (fdinfo->wxflag & WX_ATEOF) {
2307 TRACE("already at EOF, returning 0\n");
2310 /* Don't trace small reads, it gets *very* annoying */
2312 TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n",fd,hand,buf,count);
2313 if (hand == INVALID_HANDLE_VALUE)
2315 *MSVCRT__errno() = MSVCRT_EBADF;
2319 utf16 = (fdinfo->exflag & EF_UTF16) != 0;
2320 if (((fdinfo->exflag&EF_UTF8) || utf16) && count&1)
2322 *MSVCRT__errno() = MSVCRT_EINVAL;
2326 if((fdinfo->wxflag&WX_TEXT) && (fdinfo->exflag&EF_UTF8))
2327 return read_utf8(fd, buf, count);
2329 if (fdinfo->lookahead[0]!='\n' || ReadFile(hand, bufstart, count, &num_read, NULL))
2331 if (fdinfo->lookahead[0] != '\n')
2333 bufstart[0] = fdinfo->lookahead[0];
2334 fdinfo->lookahead[0] = '\n';
2338 bufstart[1] = fdinfo->lookahead[1];
2339 fdinfo->lookahead[1] = '\n';
2342 if(count>1+utf16 && ReadFile(hand, bufstart+1+utf16, count-1-utf16, &num_read, NULL))
2343 num_read += 1+utf16;
2348 if(utf16 && (num_read&1))
2350 /* msvcr90 uses uninitialized value from the buffer in this case */
2351 /* msvcrt ignores additional data */
2352 ERR("got odd number of bytes in UTF16 mode\n");
2356 if (count != 0 && num_read == 0)
2358 fdinfo->wxflag |= WX_ATEOF;
2359 TRACE(":EOF %s\n",debugstr_an(buf,num_read));
2361 else if (fdinfo->wxflag & WX_TEXT)
2365 if (bufstart[0]=='\n' && (!utf16 || bufstart[1]==0))
2366 fdinfo->wxflag |= WX_READNL;
2368 fdinfo->wxflag &= ~WX_READNL;
2370 for (i=0, j=0; i<num_read; i+=1+utf16)
2372 /* in text mode, a ctrl-z signals EOF */
2373 if (bufstart[i]==0x1a && (!utf16 || bufstart[i+1]==0))
2375 fdinfo->wxflag |= WX_ATEOF;
2376 TRACE(":^Z EOF %s\n",debugstr_an(buf,num_read));
2380 /* in text mode, strip \r if followed by \n */
2381 if (bufstart[i]=='\r' && (!utf16 || bufstart[i+1]==0) && i+1+utf16==num_read)
2386 lookahead[1] = '\n';
2387 if (ReadFile(hand, lookahead, 1+utf16, &len, NULL) && len)
2389 if(lookahead[0]=='\n' && (!utf16 || lookahead[1]==0) && j==0)
2391 bufstart[j++] = '\n';
2392 if(utf16) bufstart[j++] = 0;
2396 if(lookahead[0]!='\n' || (utf16 && lookahead[1]!=0))
2398 bufstart[j++] = '\r';
2399 if(utf16) bufstart[j++] = 0;
2402 if (fdinfo->wxflag & WX_PIPE)
2404 fdinfo->lookahead[0] = lookahead[0];
2405 fdinfo->lookahead[1] = lookahead[1];
2408 SetFilePointer(fdinfo->handle, -1-utf16, NULL, FILE_CURRENT);
2413 bufstart[j++] = '\r';
2414 if(utf16) bufstart[j++] = 0;
2417 else if((bufstart[i]!='\r' || (utf16 && bufstart[i+1]!=0))
2418 || (bufstart[i+1+utf16]!='\n' || (utf16 && bufstart[i+3]!=0)))
2420 bufstart[j++] = bufstart[i];
2421 if(utf16) bufstart[j++] = bufstart[i+1];
2429 if (GetLastError() == ERROR_BROKEN_PIPE)
2431 TRACE(":end-of-pipe\n");
2432 fdinfo->wxflag |= WX_ATEOF;
2437 TRACE(":failed-last error (%d)\n",GetLastError());
2443 TRACE("(%u), %s\n",num_read,debugstr_an(buf, num_read));
2447 /*********************************************************************
2450 int CDECL MSVCRT__read(int fd, void *buf, unsigned int count)
2453 num_read = read_i(fd, buf, count);
2457 /*********************************************************************
2458 * _setmode (MSVCRT.@)
2460 int CDECL MSVCRT__setmode(int fd,int mode)
2462 int ret = msvcrt_get_ioinfo(fd)->wxflag & WX_TEXT ? MSVCRT__O_TEXT : MSVCRT__O_BINARY;
2463 if(ret==MSVCRT__O_TEXT && (msvcrt_get_ioinfo(fd)->exflag & (EF_UTF8|EF_UTF16)))
2464 ret = MSVCRT__O_WTEXT;
2466 if(mode!=MSVCRT__O_TEXT && mode!=MSVCRT__O_BINARY && mode!=MSVCRT__O_WTEXT
2467 && mode!=MSVCRT__O_U16TEXT && mode!=MSVCRT__O_U8TEXT) {
2468 *MSVCRT__errno() = MSVCRT_EINVAL;
2472 if(mode == MSVCRT__O_BINARY) {
2473 msvcrt_get_ioinfo(fd)->wxflag &= ~WX_TEXT;
2474 msvcrt_get_ioinfo(fd)->exflag &= ~(EF_UTF8|EF_UTF16);
2478 msvcrt_get_ioinfo(fd)->wxflag |= WX_TEXT;
2479 if(mode == MSVCRT__O_TEXT)
2480 msvcrt_get_ioinfo(fd)->exflag &= ~(EF_UTF8|EF_UTF16);
2481 else if(mode == MSVCRT__O_U8TEXT)
2482 msvcrt_get_ioinfo(fd)->exflag = (msvcrt_get_ioinfo(fd)->exflag & ~EF_UTF16) | EF_UTF8;
2484 msvcrt_get_ioinfo(fd)->exflag = (msvcrt_get_ioinfo(fd)->exflag & ~EF_UTF8) | EF_UTF16;
2489 /*********************************************************************
2490 * _stat64 (MSVCRT.@)
2492 int CDECL MSVCRT_stat64(const char* path, struct MSVCRT__stat64 * buf)
2495 WIN32_FILE_ATTRIBUTE_DATA hfi;
2496 unsigned short mode = ALL_S_IREAD;
2499 TRACE(":file (%s) buf(%p)\n",path,buf);
2501 plen = strlen(path);
2502 while (plen && path[plen-1]==' ')
2505 if (plen && (path[plen-1]=='\\' || path[plen-1]=='/'))
2507 *MSVCRT__errno() = MSVCRT_ENOENT;
2511 if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
2513 TRACE("failed (%d)\n",GetLastError());
2514 *MSVCRT__errno() = MSVCRT_ENOENT;
2518 memset(buf,0,sizeof(struct MSVCRT__stat64));
2520 /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
2521 Bon 011120: This FIXME seems incorrect
2522 Also a letter as first char isn't enough to be classified
2525 if (isalpha(*path)&& (*(path+1)==':'))
2526 buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
2528 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
2530 /* Dir, or regular file? */
2531 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2532 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
2535 mode |= MSVCRT__S_IFREG;
2537 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
2539 unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
2540 (tolower(path[plen-3]) << 16);
2541 if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
2542 mode |= ALL_S_IEXEC;
2546 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
2547 mode |= ALL_S_IWRITE;
2549 buf->st_mode = mode;
2551 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
2552 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
2554 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
2555 buf->st_mtime = buf->st_ctime = dw;
2556 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
2557 (int)(buf->st_size >> 32),(int)buf->st_size,
2558 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
2562 /*********************************************************************
2563 * _stati64 (MSVCRT.@)
2565 int CDECL MSVCRT_stati64(const char* path, struct MSVCRT__stati64 * buf)
2568 struct MSVCRT__stat64 buf64;
2570 ret = MSVCRT_stat64(path, &buf64);
2572 msvcrt_stat64_to_stati64(&buf64, buf);
2576 /*********************************************************************
2579 int CDECL MSVCRT_stat(const char* path, struct MSVCRT__stat * buf)
2581 struct MSVCRT__stat64 buf64;
2583 ret = MSVCRT_stat64( path, &buf64);
2585 msvcrt_stat64_to_stat(&buf64, buf);
2589 /*********************************************************************
2590 * _wstat64 (MSVCRT.@)
2592 int CDECL MSVCRT__wstat64(const MSVCRT_wchar_t* path, struct MSVCRT__stat64 * buf)
2595 WIN32_FILE_ATTRIBUTE_DATA hfi;
2596 unsigned short mode = ALL_S_IREAD;
2599 TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
2601 plen = strlenW(path);
2602 while (plen && path[plen-1]==' ')
2605 if(plen && (path[plen-1]=='\\' || path[plen-1]=='/'))
2607 *MSVCRT__errno() = MSVCRT_ENOENT;
2611 if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
2613 TRACE("failed (%d)\n",GetLastError());
2614 *MSVCRT__errno() = MSVCRT_ENOENT;
2618 memset(buf,0,sizeof(struct MSVCRT__stat64));
2620 /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
2621 if (MSVCRT_iswalpha(*path))
2622 buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
2624 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
2626 /* Dir, or regular file? */
2627 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2628 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
2631 mode |= MSVCRT__S_IFREG;
2633 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
2635 ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
2636 ((ULONGLONG)tolowerW(path[plen-3]) << 32);
2637 if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
2638 mode |= ALL_S_IEXEC;
2642 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
2643 mode |= ALL_S_IWRITE;
2645 buf->st_mode = mode;
2647 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
2648 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
2650 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
2651 buf->st_mtime = buf->st_ctime = dw;
2652 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
2653 (int)(buf->st_size >> 32),(int)buf->st_size,
2654 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
2658 /*********************************************************************
2659 * _wstati64 (MSVCRT.@)
2661 int CDECL MSVCRT__wstati64(const MSVCRT_wchar_t* path, struct MSVCRT__stati64 * buf)
2664 struct MSVCRT__stat64 buf64;
2666 ret = MSVCRT__wstat64(path, &buf64);
2668 msvcrt_stat64_to_stati64(&buf64, buf);
2672 /*********************************************************************
2675 int CDECL MSVCRT__wstat(const MSVCRT_wchar_t* path, struct MSVCRT__stat * buf)
2678 struct MSVCRT__stat64 buf64;
2680 ret = MSVCRT__wstat64( path, &buf64 );
2681 if (!ret) msvcrt_stat64_to_stat(&buf64, buf);
2685 /*********************************************************************
2688 MSVCRT_long CDECL MSVCRT__tell(int fd)
2690 return MSVCRT__lseek(fd, 0, SEEK_CUR);
2693 /*********************************************************************
2694 * _telli64 (MSVCRT.@)
2696 __int64 CDECL _telli64(int fd)
2698 return MSVCRT__lseeki64(fd, 0, SEEK_CUR);
2701 /*********************************************************************
2702 * _tempnam (MSVCRT.@)
2704 char * CDECL MSVCRT__tempnam(const char *dir, const char *prefix)
2706 char tmpbuf[MAX_PATH];
2707 const char *tmp_dir = MSVCRT_getenv("TMP");
2709 if (tmp_dir) dir = tmp_dir;
2711 TRACE("dir (%s) prefix (%s)\n",dir,prefix);
2712 if (GetTempFileNameA(dir,prefix,0,tmpbuf))
2714 TRACE("got name (%s)\n",tmpbuf);
2715 DeleteFileA(tmpbuf);
2716 return MSVCRT__strdup(tmpbuf);
2718 TRACE("failed (%d)\n",GetLastError());
2722 /*********************************************************************
2723 * _wtempnam (MSVCRT.@)
2725 MSVCRT_wchar_t * CDECL MSVCRT__wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
2727 static const MSVCRT_wchar_t tmpW[] = {'T','M','P',0};
2728 MSVCRT_wchar_t tmpbuf[MAX_PATH];
2729 const MSVCRT_wchar_t *tmp_dir = MSVCRT__wgetenv(tmpW);
2731 if (tmp_dir) dir = tmp_dir;
2733 TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
2734 if (GetTempFileNameW(dir,prefix,0,tmpbuf))
2736 TRACE("got name (%s)\n",debugstr_w(tmpbuf));
2737 DeleteFileW(tmpbuf);
2738 return MSVCRT__wcsdup(tmpbuf);
2740 TRACE("failed (%d)\n",GetLastError());
2744 /*********************************************************************
2747 int CDECL MSVCRT__umask(int umask)
2749 int old_umask = MSVCRT_umask;
2750 TRACE("(%d)\n",umask);
2751 MSVCRT_umask = umask;
2755 /*********************************************************************
2756 * _utime64 (MSVCRT.@)
2758 int CDECL _utime64(const char* path, struct MSVCRT___utimbuf64 *t)
2760 int fd = MSVCRT__open(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
2764 int retVal = _futime64(fd, t);
2771 /*********************************************************************
2772 * _utime32 (MSVCRT.@)
2774 int CDECL _utime32(const char* path, struct MSVCRT___utimbuf32 *t)
2778 struct MSVCRT___utimbuf64 t64;
2779 t64.actime = t->actime;
2780 t64.modtime = t->modtime;
2781 return _utime64( path, &t64 );
2784 return _utime64( path, NULL );
2787 /*********************************************************************
2791 int CDECL _utime(const char* path, struct MSVCRT___utimbuf64 *t)
2793 return _utime64( path, t );
2796 int CDECL _utime(const char* path, struct MSVCRT___utimbuf32 *t)
2798 return _utime32( path, t );
2802 /*********************************************************************
2803 * _wutime64 (MSVCRT.@)
2805 int CDECL _wutime64(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
2807 int fd = MSVCRT__wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
2811 int retVal = _futime64(fd, t);
2818 /*********************************************************************
2819 * _wutime32 (MSVCRT.@)
2821 int CDECL _wutime32(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
2825 struct MSVCRT___utimbuf64 t64;
2826 t64.actime = t->actime;
2827 t64.modtime = t->modtime;
2828 return _wutime64( path, &t64 );
2831 return _wutime64( path, NULL );
2834 /*********************************************************************
2835 * _wutime (MSVCRT.@)
2838 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
2840 return _wutime64( path, t );
2843 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
2845 return _wutime32( path, t );
2849 /*********************************************************************
2852 int CDECL MSVCRT__write(int fd, const void* buf, unsigned int count)
2855 ioinfo *info = msvcrt_get_ioinfo(fd);
2856 HANDLE hand = info->handle;
2858 /* Don't trace small writes, it gets *very* annoying */
2861 TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
2863 if (hand == INVALID_HANDLE_VALUE)
2865 *MSVCRT__errno() = MSVCRT_EBADF;
2869 if (((info->exflag&EF_UTF8) || (info->exflag&EF_UTF16)) && count&1)
2871 *MSVCRT__errno() = MSVCRT_EINVAL;
2875 /* If appending, go to EOF */
2876 if (info->wxflag & WX_APPEND)
2877 MSVCRT__lseek(fd, 0, FILE_END);
2879 if (!(info->wxflag & WX_TEXT))
2881 if (WriteFile(hand, buf, count, &num_written, NULL)
2882 && (num_written == count))
2884 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d)\n", fd,
2885 hand, GetLastError());
2886 *MSVCRT__errno() = MSVCRT_ENOSPC;
2890 unsigned int i, j, nr_lf, size;
2893 const char *s = buf, *buf_start = buf;
2895 if (!(info->exflag & (EF_UTF8|EF_UTF16)))
2897 /* find number of \n */
2898 for (nr_lf=0, i=0; i<count; i++)
2904 if ((q = p = MSVCRT_malloc(size)))
2906 for (s = buf, i = 0, j = 0; i < count; i++)
2915 FIXME("Malloc failed\n");
2927 else if (info->exflag & EF_UTF16)
2929 for (nr_lf=0, i=0; i<count; i+=2)
2930 if (s[i]=='\n' && s[i+1]==0)
2935 if ((q = p = MSVCRT_malloc(size)))
2937 for (s=buf, i=0, j=0; i<count; i++)
2939 if (s[i]=='\n' && s[i+1]==0)
2950 FIXME("Malloc failed\n");
2966 for(nr_lf=0, i=0; i<count; i+=2)
2967 if (s[i]=='\n' && s[i+1]==0)
2970 conv_len = WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)buf, count/2, NULL, 0, NULL, NULL);
2972 msvcrt_set_errno(GetLastError());
2977 size = conv_len+nr_lf;
2978 if((p = MSVCRT_malloc(count+nr_lf*2+size)))
2980 for (s=buf, i=0, j=0; i<count; i++)
2982 if (s[i]=='\n' && s[i+1]==0)
2990 q = p+count+nr_lf*2;
2991 WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)p, count/2+nr_lf,
2992 p+count+nr_lf*2, conv_len+nr_lf, NULL, NULL);
2996 FIXME("Malloc failed\n");
3003 if (!WriteFile(hand, q, size, &num_written, NULL))
3007 if (num_written != size)
3009 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d), num_written %d\n",
3010 fd, hand, GetLastError(), num_written);
3011 *MSVCRT__errno() = MSVCRT_ENOSPC;
3012 return s - buf_start;
3020 /*********************************************************************
3023 int CDECL MSVCRT__putw(int val, MSVCRT_FILE* file)
3027 MSVCRT__lock_file(file);
3028 len = MSVCRT__write(file->_file, &val, sizeof(val));
3029 if (len == sizeof(val)) {
3030 MSVCRT__unlock_file(file);
3034 file->_flag |= MSVCRT__IOERR;
3035 MSVCRT__unlock_file(file);
3039 /*********************************************************************
3042 int CDECL MSVCRT_fclose(MSVCRT_FILE* file)
3046 MSVCRT__lock_file(file);
3048 MSVCRT_free(file->_tmpfname);
3049 file->_tmpfname = NULL;
3050 /* flush stdio buffers */
3051 if(file->_flag & MSVCRT__IOWRT)
3052 MSVCRT_fflush(file);
3053 if(file->_flag & MSVCRT__IOMYBUF)
3054 MSVCRT_free(file->_base);
3056 r=MSVCRT__close(file->_file);
3059 MSVCRT__unlock_file(file);
3061 return ((r == -1) || (flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
3064 /*********************************************************************
3067 int CDECL MSVCRT_feof(MSVCRT_FILE* file)
3069 return file->_flag & MSVCRT__IOEOF;
3072 /*********************************************************************
3075 int CDECL MSVCRT_ferror(MSVCRT_FILE* file)
3077 return file->_flag & MSVCRT__IOERR;
3080 /*********************************************************************
3081 * _filbuf (MSVCRT.@)
3083 int CDECL MSVCRT__filbuf(MSVCRT_FILE* file)
3086 MSVCRT__lock_file(file);
3088 /* Allocate buffer if needed */
3089 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF))
3090 msvcrt_alloc_buffer(file);
3092 if(!(file->_flag & MSVCRT__IOREAD)) {
3093 if(file->_flag & MSVCRT__IORW)
3094 file->_flag |= MSVCRT__IOREAD;
3096 MSVCRT__unlock_file(file);
3101 if(file->_flag & MSVCRT__IONBF) {
3103 if ((r = read_i(file->_file,&c,1)) != 1) {
3104 file->_flag |= (r == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
3105 MSVCRT__unlock_file(file);
3109 MSVCRT__unlock_file(file);
3112 file->_cnt = read_i(file->_file, file->_base, file->_bufsiz);
3114 file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
3116 MSVCRT__unlock_file(file);
3121 file->_ptr = file->_base+1;
3122 c = *(unsigned char *)file->_base;
3123 MSVCRT__unlock_file(file);
3128 /*********************************************************************
3131 int CDECL MSVCRT_fgetc(MSVCRT_FILE* file)
3136 MSVCRT__lock_file(file);
3139 i = (unsigned char *)file->_ptr++;
3142 j = MSVCRT__filbuf(file);
3144 MSVCRT__unlock_file(file);
3148 /*********************************************************************
3149 * _fgetchar (MSVCRT.@)
3151 int CDECL MSVCRT__fgetchar(void)
3153 return MSVCRT_fgetc(MSVCRT_stdin);
3156 /*********************************************************************
3159 char * CDECL MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
3161 int cc = MSVCRT_EOF;
3162 char * buf_start = s;
3164 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3165 file,file->_file,s,size);
3167 MSVCRT__lock_file(file);
3169 while ((size >1) && (cc = MSVCRT_fgetc(file)) != MSVCRT_EOF && cc != '\n')
3174 if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
3176 TRACE(":nothing read\n");
3177 MSVCRT__unlock_file(file);
3180 if ((cc != MSVCRT_EOF) && (size > 1))
3183 TRACE(":got %s\n", debugstr_a(buf_start));
3184 MSVCRT__unlock_file(file);
3188 /*********************************************************************
3191 * In MSVCRT__O_TEXT mode, multibyte characters are read from the file, dropping
3192 * the CR from CR/LF combinations
3194 MSVCRT_wint_t CDECL MSVCRT_fgetwc(MSVCRT_FILE* file)
3198 MSVCRT__lock_file(file);
3199 if (!(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT))
3206 for(i=0; i<sizeof(wc); i++)
3216 j = MSVCRT__filbuf(file);
3219 file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
3222 MSVCRT__unlock_file(file);
3229 MSVCRT__unlock_file(file);
3233 c = MSVCRT_fgetc(file);
3234 if ((get_locinfo()->mb_cur_max > 1) && MSVCRT_isleadbyte(c))
3236 FIXME("Treat Multibyte characters\n");
3239 MSVCRT__unlock_file(file);
3240 if (c == MSVCRT_EOF)
3243 return (MSVCRT_wint_t)c;
3246 /*********************************************************************
3249 int CDECL MSVCRT__getw(MSVCRT_FILE* file)
3256 MSVCRT__lock_file(file);
3257 for (j=0; j<sizeof(int); j++) {
3258 k = MSVCRT_fgetc(file);
3259 if (k == MSVCRT_EOF) {
3260 file->_flag |= MSVCRT__IOEOF;
3261 MSVCRT__unlock_file(file);
3267 MSVCRT__unlock_file(file);
3271 /*********************************************************************
3274 MSVCRT_wint_t CDECL MSVCRT_getwc(MSVCRT_FILE* file)
3276 return MSVCRT_fgetwc(file);
3279 /*********************************************************************
3280 * _fgetwchar (MSVCRT.@)
3282 MSVCRT_wint_t CDECL MSVCRT__fgetwchar(void)
3284 return MSVCRT_fgetwc(MSVCRT_stdin);
3287 /*********************************************************************
3288 * getwchar (MSVCRT.@)
3290 MSVCRT_wint_t CDECL MSVCRT_getwchar(void)
3292 return MSVCRT__fgetwchar();
3295 /*********************************************************************
3298 MSVCRT_wchar_t * CDECL MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
3300 int cc = MSVCRT_WEOF;
3301 MSVCRT_wchar_t * buf_start = s;
3303 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3304 file,file->_file,s,size);
3306 MSVCRT__lock_file(file);
3308 while ((size >1) && (cc = MSVCRT_fgetwc(file)) != MSVCRT_WEOF && cc != '\n')
3313 if ((cc == MSVCRT_WEOF) && (s == buf_start)) /* If nothing read, return 0*/
3315 TRACE(":nothing read\n");
3316 MSVCRT__unlock_file(file);
3319 if ((cc != MSVCRT_WEOF) && (size > 1))
3322 TRACE(":got %s\n", debugstr_w(buf_start));
3323 MSVCRT__unlock_file(file);
3327 /*********************************************************************
3330 MSVCRT_size_t CDECL MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
3332 MSVCRT_size_t wrcnt=size * nmemb;
3337 MSVCRT__lock_file(file);
3339 int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
3340 memcpy(file->_ptr, ptr, pcnt);
3345 ptr = (const char*)ptr + pcnt;
3346 } else if(!(file->_flag & MSVCRT__IOWRT)) {
3347 if(file->_flag & MSVCRT__IORW) {
3348 file->_flag |= MSVCRT__IOWRT;
3350 MSVCRT__unlock_file(file);
3357 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF))
3358 msvcrt_alloc_buffer(file);
3361 res=msvcrt_flush_buffer(file);
3363 int pwritten = MSVCRT__write(file->_file, ptr, wrcnt);
3366 file->_flag |= MSVCRT__IOERR;
3369 written += pwritten;
3373 MSVCRT__unlock_file(file);
3374 return written / size;
3377 /*********************************************************************
3380 MSVCRT_wint_t CDECL MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
3382 MSVCRT_wchar_t mwc=wc;
3386 MSVCRT__lock_file(file);
3387 fdinfo = msvcrt_get_ioinfo(file->_file);
3389 if((fdinfo->wxflag&WX_TEXT) && !(fdinfo->exflag&(EF_UTF8|EF_UTF16))) {
3390 char buf[MSVCRT_MB_LEN_MAX];
3393 char_len = MSVCRT_wctomb(buf, mwc);
3394 if(char_len!=-1 && MSVCRT_fwrite(buf, char_len, 1, file)==1)
3398 }else if(MSVCRT_fwrite(&mwc, sizeof(mwc), 1, file) == 1) {
3404 MSVCRT__unlock_file(file);
3408 /*********************************************************************
3409 * _fputwchar (MSVCRT.@)
3411 MSVCRT_wint_t CDECL MSVCRT__fputwchar(MSVCRT_wint_t wc)
3413 return MSVCRT_fputwc(wc, MSVCRT_stdout);
3416 /*********************************************************************
3417 * _wfsopen (MSVCRT.@)
3419 MSVCRT_FILE * CDECL MSVCRT__wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
3422 int open_flags, stream_flags, fd;
3424 TRACE("(%s,%s)\n", debugstr_w(path), debugstr_w(mode));
3426 /* map mode string to open() flags. "man fopen" for possibilities. */
3427 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
3431 fd = MSVCRT__wsopen(path, open_flags, share, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
3434 else if ((file = msvcrt_alloc_fp()) && msvcrt_init_fp(file, fd, stream_flags)
3436 TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
3443 TRACE(":got (%p)\n",file);
3444 if (fd >= 0 && !file)
3450 /*********************************************************************
3451 * _fsopen (MSVCRT.@)
3453 MSVCRT_FILE * CDECL MSVCRT__fsopen(const char *path, const char *mode, int share)
3456 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
3458 if (path && !(pathW = msvcrt_wstrdupa(path))) {
3459 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
3460 *MSVCRT__errno() = MSVCRT_EINVAL;
3463 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
3466 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
3467 *MSVCRT__errno() = MSVCRT_EINVAL;
3471 ret = MSVCRT__wfsopen(pathW, modeW, share);
3478 /*********************************************************************
3481 MSVCRT_FILE * CDECL MSVCRT_fopen(const char *path, const char *mode)
3483 return MSVCRT__fsopen( path, mode, MSVCRT__SH_DENYNO );
3486 /*********************************************************************
3487 * fopen_s (MSVCRT.@)
3489 int CDECL MSVCRT_fopen_s(MSVCRT_FILE** pFile,
3490 const char *filename, const char *mode)
3492 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3493 if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
3494 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3496 *pFile = MSVCRT_fopen(filename, mode);
3499 return *MSVCRT__errno();
3503 /*********************************************************************
3504 * _wfopen (MSVCRT.@)
3506 MSVCRT_FILE * CDECL MSVCRT__wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
3508 return MSVCRT__wfsopen( path, mode, MSVCRT__SH_DENYNO );
3511 /*********************************************************************
3512 * _wfopen_s (MSVCRT.@)
3514 int CDECL MSVCRT__wfopen_s(MSVCRT_FILE** pFile, const MSVCRT_wchar_t *filename,
3515 const MSVCRT_wchar_t *mode)
3517 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3518 if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
3519 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3521 *pFile = MSVCRT__wfopen(filename, mode);
3524 return *MSVCRT__errno();
3528 /*********************************************************************
3529 * _flsbuf (MSVCRT.@)
3531 int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
3533 /* Flush output buffer */
3534 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
3535 msvcrt_alloc_buffer(file);
3537 if(!(file->_flag & MSVCRT__IOWRT)) {
3538 if(file->_flag & MSVCRT__IORW)
3539 file->_flag |= MSVCRT__IOWRT;
3547 res = msvcrt_flush_buffer(file);
3551 res = msvcrt_flush_buffer(file);
3554 return res ? res : c&0xff;
3558 /* set _cnt to 0 for unbuffered FILEs */
3560 len = MSVCRT__write(file->_file, &cc, 1);
3563 file->_flag |= MSVCRT__IOERR;
3568 /*********************************************************************
3571 int CDECL MSVCRT_fputc(int c, MSVCRT_FILE* file)
3575 MSVCRT__lock_file(file);
3581 res = msvcrt_flush_buffer(file);
3582 MSVCRT__unlock_file(file);
3583 return res ? res : c;
3586 MSVCRT__unlock_file(file);
3590 res = MSVCRT__flsbuf(c, file);
3591 MSVCRT__unlock_file(file);
3596 /*********************************************************************
3597 * _fputchar (MSVCRT.@)
3599 int CDECL MSVCRT__fputchar(int c)
3601 return MSVCRT_fputc(c, MSVCRT_stdout);
3604 /*********************************************************************
3607 MSVCRT_size_t CDECL MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
3609 MSVCRT_size_t rcnt=size * nmemb;
3610 MSVCRT_size_t read=0;
3616 MSVCRT__lock_file(file);
3618 /* first buffered data */
3620 int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
3621 memcpy(ptr, file->_ptr, pcnt);
3626 ptr = (char*)ptr + pcnt;
3627 } else if(!(file->_flag & MSVCRT__IOREAD )) {
3628 if(file->_flag & MSVCRT__IORW) {
3629 file->_flag |= MSVCRT__IOREAD;
3631 MSVCRT__unlock_file(file);
3638 /* Fill the buffer on small reads.
3639 * TODO: Use a better buffering strategy.
3641 if (!file->_cnt && size*nmemb <= MSVCRT_BUFSIZ/2 && !(file->_flag & MSVCRT__IONBF)) {
3642 if (file->_bufsiz == 0) {
3643 msvcrt_alloc_buffer(file);
3645 file->_cnt = MSVCRT__read(file->_file, file->_base, file->_bufsiz);
3646 file->_ptr = file->_base;
3647 i = (file->_cnt<rcnt) ? file->_cnt : rcnt;
3648 /* If the buffer fill reaches eof but fread wouldn't, clear eof. */
3649 if (i > 0 && i < file->_cnt) {
3650 msvcrt_get_ioinfo(file->_file)->wxflag &= ~WX_ATEOF;
3651 file->_flag &= ~MSVCRT__IOEOF;
3654 memcpy(ptr, file->_ptr, i);
3659 i = MSVCRT__read(file->_file,ptr, rcnt);
3663 ptr = (char *)ptr+i;
3664 /* expose feof condition in the flags
3665 * MFC tests file->_flag for feof, and doesn't call feof())
3667 if (msvcrt_get_ioinfo(file->_file)->wxflag & WX_ATEOF)
3668 file->_flag |= MSVCRT__IOEOF;
3671 file->_flag |= MSVCRT__IOERR;
3678 MSVCRT__unlock_file(file);
3682 /*********************************************************************
3683 * _wfreopen (MSVCRT.@)
3686 MSVCRT_FILE* CDECL MSVCRT__wfreopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, MSVCRT_FILE* file)
3690 TRACE(":path (%s) mode (%s) file (%p) fd (%d)\n", debugstr_w(path), debugstr_w(mode), file, file->_file);
3693 if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
3697 MSVCRT_fclose(file);
3698 file = MSVCRT__wfsopen(path, mode, MSVCRT__SH_DENYNO);
3704 /*********************************************************************
3705 * _wfreopen_s (MSVCRT.@)
3707 int CDECL MSVCRT__wfreopen_s(MSVCRT_FILE** pFile,
3708 const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, MSVCRT_FILE* file)
3710 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3711 if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
3712 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3713 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
3715 *pFile = MSVCRT__wfreopen(path, mode, file);
3718 return *MSVCRT__errno();
3722 /*********************************************************************
3723 * freopen (MSVCRT.@)
3726 MSVCRT_FILE* CDECL MSVCRT_freopen(const char *path, const char *mode, MSVCRT_FILE* file)
3729 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
3731 if (path && !(pathW = msvcrt_wstrdupa(path))) return NULL;
3732 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
3738 ret = MSVCRT__wfreopen(pathW, modeW, file);
3745 /*********************************************************************
3746 * freopen_s (MSVCRT.@)
3748 int CDECL MSVCRT_freopen_s(MSVCRT_FILE** pFile,
3749 const char *path, const char *mode, MSVCRT_FILE* file)
3751 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3752 if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
3753 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3754 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
3756 *pFile = MSVCRT_freopen(path, mode, file);
3759 return *MSVCRT__errno();
3763 /*********************************************************************
3764 * fsetpos (MSVCRT.@)
3766 int CDECL MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
3770 MSVCRT__lock_file(file);
3771 /* Note that all this has been lifted 'as is' from fseek */
3772 if(file->_flag & MSVCRT__IOWRT)
3773 msvcrt_flush_buffer(file);
3775 /* Discard buffered input */
3777 file->_ptr = file->_base;
3779 /* Reset direction of i/o */
3780 if(file->_flag & MSVCRT__IORW) {
3781 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
3784 ret = (MSVCRT__lseeki64(file->_file,*pos,SEEK_SET) == -1) ? -1 : 0;
3785 MSVCRT__unlock_file(file);
3789 /*********************************************************************
3790 * _ftelli64 (MSVCRT.@)
3792 __int64 CDECL MSVCRT__ftelli64(MSVCRT_FILE* file)
3796 MSVCRT__lock_file(file);
3797 pos = _telli64(file->_file);
3799 MSVCRT__unlock_file(file);
3803 if(file->_flag & MSVCRT__IOWRT) {
3804 pos += file->_ptr - file->_base;
3806 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT) {
3809 for(p=file->_base; p<file->_ptr; p++)
3813 } else if(!file->_cnt) { /* nothing to do */
3814 } else if(MSVCRT__lseeki64(file->_file, 0, SEEK_END)==pos) {
3818 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT) {
3819 for(i=0; i<file->_cnt; i++)
3820 if(file->_ptr[i] == '\n')
3826 if(MSVCRT__lseeki64(file->_file, pos, SEEK_SET) != pos) {
3827 MSVCRT__unlock_file(file);
3831 pos -= file->_bufsiz;
3832 pos += file->_ptr - file->_base;
3834 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT) {
3835 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_READNL)
3838 for(p=file->_base; p<file->_ptr; p++)
3845 MSVCRT__unlock_file(file);
3849 /*********************************************************************
3852 LONG CDECL MSVCRT_ftell(MSVCRT_FILE* file)
3854 return MSVCRT__ftelli64(file);
3857 /*********************************************************************
3858 * fgetpos (MSVCRT.@)
3860 int CDECL MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
3862 *pos = MSVCRT__ftelli64(file);
3868 /*********************************************************************
3871 int CDECL MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
3873 MSVCRT_size_t len = strlen(s);
3876 MSVCRT__lock_file(file);
3877 ret = MSVCRT_fwrite(s, sizeof(*s), len, file) == len ? 0 : MSVCRT_EOF;
3878 MSVCRT__unlock_file(file);
3882 /*********************************************************************
3885 int CDECL MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
3887 MSVCRT_size_t i, len = strlenW(s);
3890 MSVCRT__lock_file(file);
3891 if (!(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT)) {
3892 ret = MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
3893 MSVCRT__unlock_file(file);
3896 for (i=0; i<len; i++) {
3897 if(MSVCRT_fputwc(s[i], file) == MSVCRT_WEOF) {
3898 MSVCRT__unlock_file(file);
3903 MSVCRT__unlock_file(file);
3907 /*********************************************************************
3908 * getchar (MSVCRT.@)
3910 int CDECL MSVCRT_getchar(void)
3912 return MSVCRT_fgetc(MSVCRT_stdin);
3915 /*********************************************************************
3918 int CDECL MSVCRT_getc(MSVCRT_FILE* file)
3920 return MSVCRT_fgetc(file);
3923 /*********************************************************************
3926 char * CDECL MSVCRT_gets(char *buf)
3929 char * buf_start = buf;
3931 MSVCRT__lock_file(MSVCRT_stdin);
3932 for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
3933 cc = MSVCRT_fgetc(MSVCRT_stdin))
3934 if(cc != '\r') *buf++ = (char)cc;
3938 TRACE("got '%s'\n", buf_start);
3939 MSVCRT__unlock_file(MSVCRT_stdin);
3943 /*********************************************************************
3946 MSVCRT_wchar_t* CDECL MSVCRT__getws(MSVCRT_wchar_t* buf)
3949 MSVCRT_wchar_t* ws = buf;
3951 MSVCRT__lock_file(MSVCRT_stdin);
3952 for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
3953 cc = MSVCRT_fgetwc(MSVCRT_stdin))
3956 *buf++ = (MSVCRT_wchar_t)cc;
3960 TRACE("got %s\n", debugstr_w(ws));
3961 MSVCRT__unlock_file(MSVCRT_stdin);
3965 /*********************************************************************
3968 int CDECL MSVCRT_putc(int c, MSVCRT_FILE* file)
3970 return MSVCRT_fputc(c, file);
3973 /*********************************************************************
3974 * putchar (MSVCRT.@)
3976 int CDECL MSVCRT_putchar(int c)
3978 return MSVCRT_fputc(c, MSVCRT_stdout);
3981 /*********************************************************************
3982 * _putwch (MSVCRT.@)
3984 int CDECL MSVCRT__putwch(int c)
3986 return MSVCRT_fputwc(c, MSVCRT_stdout);
3989 /*********************************************************************
3992 int CDECL MSVCRT_puts(const char *s)
3994 MSVCRT_size_t len = strlen(s);
3997 MSVCRT__lock_file(MSVCRT_stdout);
3998 if(MSVCRT_fwrite(s, sizeof(*s), len, MSVCRT_stdout) != len) {
3999 MSVCRT__unlock_file(MSVCRT_stdout);
4003 ret = MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
4004 MSVCRT__unlock_file(MSVCRT_stdout);
4008 /*********************************************************************
4011 int CDECL MSVCRT__putws(const MSVCRT_wchar_t *s)
4013 static const MSVCRT_wchar_t nl = '\n';
4014 MSVCRT_size_t len = strlenW(s);
4017 MSVCRT__lock_file(MSVCRT_stdout);
4018 if(MSVCRT_fwrite(s, sizeof(*s), len, MSVCRT_stdout) != len) {
4019 MSVCRT__unlock_file(MSVCRT_stdout);
4023 ret = MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
4024 MSVCRT__unlock_file(MSVCRT_stdout);
4028 /*********************************************************************
4031 int CDECL MSVCRT_remove(const char *path)
4033 TRACE("(%s)\n",path);
4034 if (DeleteFileA(path))
4036 TRACE(":failed (%d)\n",GetLastError());
4037 msvcrt_set_errno(GetLastError());
4041 /*********************************************************************
4042 * _wremove (MSVCRT.@)
4044 int CDECL MSVCRT__wremove(const MSVCRT_wchar_t *path)
4046 TRACE("(%s)\n",debugstr_w(path));
4047 if (DeleteFileW(path))
4049 TRACE(":failed (%d)\n",GetLastError());
4050 msvcrt_set_errno(GetLastError());
4054 /*********************************************************************
4057 int CDECL MSVCRT_rename(const char *oldpath,const char *newpath)
4059 TRACE(":from %s to %s\n",oldpath,newpath);
4060 if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4062 TRACE(":failed (%d)\n",GetLastError());
4063 msvcrt_set_errno(GetLastError());
4067 /*********************************************************************
4068 * _wrename (MSVCRT.@)
4070 int CDECL MSVCRT__wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
4072 TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
4073 if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4075 TRACE(":failed (%d)\n",GetLastError());
4076 msvcrt_set_errno(GetLastError());
4080 /*********************************************************************
4081 * setvbuf (MSVCRT.@)
4083 int CDECL MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
4085 MSVCRT__lock_file(file);
4087 MSVCRT_free(file->_base);
4091 if(mode == MSVCRT__IOFBF) {
4092 file->_flag &= ~MSVCRT__IONBF;
4093 file->_base = file->_ptr = buf;
4095 file->_bufsiz = size;
4098 file->_flag |= MSVCRT__IONBF;
4100 MSVCRT__unlock_file(file);
4104 /*********************************************************************
4107 void CDECL MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
4109 MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
4112 /*********************************************************************
4115 char * CDECL MSVCRT_tmpnam(char *s)
4122 thread_data_t *data = msvcrt_get_thread_data();
4124 if(!data->tmpnam_buffer)
4125 data->tmpnam_buffer = MSVCRT_malloc(MAX_PATH);
4127 s = data->tmpnam_buffer;
4130 msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
4131 p = s + sprintf(s, "\\s%s.", tmpstr);
4132 for (count = 0; count < MSVCRT_TMP_MAX; count++)
4134 size = msvcrt_int_to_base32(tmpnam_unique++, tmpstr);
4135 memcpy(p, tmpstr, size);
4137 if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
4138 GetLastError() == ERROR_FILE_NOT_FOUND)
4144 /*********************************************************************
4145 * _wtmpnam (MSVCRT.@)
4147 MSVCRT_wchar_t * CDECL MSVCRT_wtmpnam(MSVCRT_wchar_t *s)
4149 static const MSVCRT_wchar_t format[] = {'\\','s','%','s','.',0};
4150 MSVCRT_wchar_t tmpstr[16];
4154 thread_data_t *data = msvcrt_get_thread_data();
4156 if(!data->wtmpnam_buffer)
4157 data->wtmpnam_buffer = MSVCRT_malloc(sizeof(MSVCRT_wchar_t[MAX_PATH]));
4159 s = data->wtmpnam_buffer;
4162 msvcrt_int_to_base32_w(GetCurrentProcessId(), tmpstr);
4163 p = s + MSVCRT__snwprintf(s, MAX_PATH, format, tmpstr);
4164 for (count = 0; count < MSVCRT_TMP_MAX; count++)
4166 size = msvcrt_int_to_base32_w(tmpnam_unique++, tmpstr);
4167 memcpy(p, tmpstr, size*sizeof(MSVCRT_wchar_t));
4169 if (GetFileAttributesW(s) == INVALID_FILE_ATTRIBUTES &&
4170 GetLastError() == ERROR_FILE_NOT_FOUND)
4176 /*********************************************************************
4177 * tmpfile (MSVCRT.@)
4179 MSVCRT_FILE* CDECL MSVCRT_tmpfile(void)
4181 char *filename = MSVCRT_tmpnam(NULL);
4183 MSVCRT_FILE* file = NULL;
4186 fd = MSVCRT__open(filename, MSVCRT__O_CREAT | MSVCRT__O_BINARY | MSVCRT__O_RDWR | MSVCRT__O_TEMPORARY,
4187 MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
4188 if (fd != -1 && (file = msvcrt_alloc_fp()))
4190 if (msvcrt_init_fp(file, fd, MSVCRT__IORW) == -1)
4195 else file->_tmpfname = MSVCRT__strdup(filename);
4198 if(fd != -1 && !file)
4204 /*********************************************************************
4205 * tmpfile_s (MSVCRT.@)
4207 int CDECL MSVCRT_tmpfile_s(MSVCRT_FILE** file)
4209 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
4211 *file = MSVCRT_tmpfile();
4215 static int puts_clbk_file_a(void *file, int len, const char *str)
4217 return MSVCRT_fwrite(str, sizeof(char), len, file);
4220 static int puts_clbk_file_w(void *file, int len, const MSVCRT_wchar_t *str)
4224 MSVCRT__lock_file(file);
4226 if(!(msvcrt_get_ioinfo(((MSVCRT_FILE*)file)->_file)->wxflag & WX_TEXT)) {
4227 ret = MSVCRT_fwrite(str, sizeof(MSVCRT_wchar_t), len, file);
4228 MSVCRT__unlock_file(file);
4232 for(i=0; i<len; i++) {
4233 if(MSVCRT_fputwc(str[i], file) == MSVCRT_WEOF) {
4234 MSVCRT__unlock_file(file);
4239 MSVCRT__unlock_file(file);
4243 /*********************************************************************
4244 * vfprintf (MSVCRT.@)
4246 int CDECL MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, __ms_va_list valist)
4250 MSVCRT__lock_file(file);
4251 ret = pf_printf_a(puts_clbk_file_a, file, format, NULL, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4252 MSVCRT__unlock_file(file);
4257 /*********************************************************************
4258 * vfprintf_s (MSVCRT.@)
4260 int CDECL MSVCRT_vfprintf_s(MSVCRT_FILE* file, const char *format, __ms_va_list valist)
4264 if(!MSVCRT_CHECK_PMT(file != NULL)) return -1;
4266 MSVCRT__lock_file(file);
4267 ret = pf_printf_a(puts_clbk_file_a, file, format, NULL, FALSE, TRUE, arg_clbk_valist, NULL, &valist);
4268 MSVCRT__unlock_file(file);
4273 /*********************************************************************
4274 * vfwprintf (MSVCRT.@)
4276 int CDECL MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, __ms_va_list valist)
4280 MSVCRT__lock_file(file);
4281 ret = pf_printf_w(puts_clbk_file_w, file, format, NULL, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4282 MSVCRT__unlock_file(file);
4287 /*********************************************************************
4288 * vfwprintf_s (MSVCRT.@)
4290 int CDECL MSVCRT_vfwprintf_s(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, __ms_va_list valist)
4294 if (!MSVCRT_CHECK_PMT( file != NULL )) return -1;
4296 MSVCRT__lock_file(file);
4297 ret = pf_printf_w(puts_clbk_file_w, file, format, NULL, FALSE, TRUE, arg_clbk_valist, NULL, &valist);
4298 MSVCRT__unlock_file(file);
4303 /*********************************************************************
4304 * _vfwprintf_l (MSVCRT.@)
4306 int CDECL MSVCRT__vfwprintf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format,
4307 MSVCRT__locale_t locale, __ms_va_list valist)
4311 if (!MSVCRT_CHECK_PMT( file != NULL )) return -1;
4313 MSVCRT__lock_file(file);
4314 ret = pf_printf_w(puts_clbk_file_w, file, format, locale, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4315 MSVCRT__unlock_file(file);
4320 /*********************************************************************
4321 * vprintf (MSVCRT.@)
4323 int CDECL MSVCRT_vprintf(const char *format, __ms_va_list valist)
4325 return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
4328 /*********************************************************************
4329 * vprintf_s (MSVCRT.@)
4331 int CDECL MSVCRT_vprintf_s(const char *format, __ms_va_list valist)
4333 return MSVCRT_vfprintf_s(MSVCRT_stdout,format,valist);
4336 /*********************************************************************
4337 * vwprintf (MSVCRT.@)
4339 int CDECL MSVCRT_vwprintf(const MSVCRT_wchar_t *format, __ms_va_list valist)
4341 return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
4344 /*********************************************************************
4345 * vwprintf_s (MSVCRT.@)
4347 int CDECL MSVCRT_vwprintf_s(const MSVCRT_wchar_t *format, __ms_va_list valist)
4349 return MSVCRT_vfwprintf_s(MSVCRT_stdout,format,valist);
4352 /*********************************************************************
4353 * fprintf (MSVCRT.@)
4355 int CDECL MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
4357 __ms_va_list valist;
4359 __ms_va_start(valist, format);
4360 res = MSVCRT_vfprintf(file, format, valist);
4361 __ms_va_end(valist);
4365 /*********************************************************************
4366 * fprintf_s (MSVCRT.@)
4368 int CDECL MSVCRT_fprintf_s(MSVCRT_FILE* file, const char *format, ...)
4370 __ms_va_list valist;
4372 __ms_va_start(valist, format);
4373 res = MSVCRT_vfprintf_s(file, format, valist);
4374 __ms_va_end(valist);
4378 /*********************************************************************
4379 * fwprintf (MSVCRT.@)
4381 int CDECL MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
4383 __ms_va_list valist;
4385 __ms_va_start(valist, format);
4386 res = MSVCRT_vfwprintf(file, format, valist);
4387 __ms_va_end(valist);
4391 /*********************************************************************
4392 * fwprintf_s (MSVCRT.@)
4394 int CDECL MSVCRT_fwprintf_s(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
4396 __ms_va_list valist;
4398 __ms_va_start(valist, format);
4399 res = MSVCRT_vfwprintf_s(file, format, valist);
4400 __ms_va_end(valist);
4404 /*********************************************************************
4405 * _fwprintf_l (MSVCRT.@)
4407 int CDECL MSVCRT__fwprintf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ...)
4409 __ms_va_list valist;
4411 __ms_va_start(valist, locale);
4412 res = MSVCRT__vfwprintf_l(file, format, locale, valist);
4413 __ms_va_end(valist);
4417 /*********************************************************************
4420 int CDECL MSVCRT_printf(const char *format, ...)
4422 __ms_va_list valist;
4424 __ms_va_start(valist, format);
4425 res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
4426 __ms_va_end(valist);
4430 /*********************************************************************
4431 * printf_s (MSVCRT.@)
4433 int CDECL MSVCRT_printf_s(const char *format, ...)
4435 __ms_va_list valist;
4437 __ms_va_start(valist, format);
4438 res = MSVCRT_vprintf_s(format, valist);
4439 __ms_va_end(valist);
4443 /*********************************************************************
4446 int CDECL MSVCRT_ungetc(int c, MSVCRT_FILE * file)
4448 if (c == MSVCRT_EOF)
4451 MSVCRT__lock_file(file);
4452 if(file->_bufsiz == 0) {
4453 msvcrt_alloc_buffer(file);
4456 if(file->_ptr>file->_base) {
4460 MSVCRT_clearerr(file);
4461 MSVCRT__unlock_file(file);
4465 MSVCRT__unlock_file(file);
4469 /*********************************************************************
4470 * ungetwc (MSVCRT.@)
4472 MSVCRT_wint_t CDECL MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
4474 MSVCRT_wchar_t mwc = wc;
4475 unsigned char * pp = (unsigned char *)&mwc;
4478 if (wc == MSVCRT_WEOF)
4481 MSVCRT__lock_file(file);
4482 for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
4483 if(pp[i] != MSVCRT_ungetc(pp[i],file)) {
4484 MSVCRT__unlock_file(file);
4489 MSVCRT__unlock_file(file);
4493 /*********************************************************************
4494 * wprintf (MSVCRT.@)
4496 int CDECL MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
4498 __ms_va_list valist;
4500 __ms_va_start(valist, format);
4501 res = MSVCRT_vwprintf(format, valist);
4502 __ms_va_end(valist);
4506 /*********************************************************************
4507 * wprintf_s (MSVCRT.@)
4509 int CDECL MSVCRT_wprintf_s(const MSVCRT_wchar_t *format, ...)
4511 __ms_va_list valist;
4513 __ms_va_start(valist, format);
4514 res = MSVCRT_vwprintf_s(format, valist);
4515 __ms_va_end(valist);
4519 /*********************************************************************
4520 * _getmaxstdio (MSVCRT.@)
4522 int CDECL MSVCRT__getmaxstdio(void)
4524 return MSVCRT_max_streams;
4527 /*********************************************************************
4528 * _setmaxstdio (MSVCRT.@)
4530 int CDECL MSVCRT__setmaxstdio(int newmax)
4532 TRACE("%d\n", newmax);
4534 if(newmax<_IOB_ENTRIES || newmax>MSVCRT_MAX_FILES || newmax<MSVCRT_stream_idx)
4537 MSVCRT_max_streams = newmax;
4538 return MSVCRT_max_streams;