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>
46 #include "wine/unicode.h"
48 #include "wine/debug.h"
50 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
52 /* for stat mode, permissions apply to all,owner and group */
53 #define ALL_S_IREAD (MSVCRT__S_IREAD | (MSVCRT__S_IREAD >> 3) | (MSVCRT__S_IREAD >> 6))
54 #define ALL_S_IWRITE (MSVCRT__S_IWRITE | (MSVCRT__S_IWRITE >> 3) | (MSVCRT__S_IWRITE >> 6))
55 #define ALL_S_IEXEC (MSVCRT__S_IEXEC | (MSVCRT__S_IEXEC >> 3) | (MSVCRT__S_IEXEC >> 6))
57 /* _access() bit flags FIXME: incomplete */
58 #define MSVCRT_W_OK 0x02
59 #define MSVCRT_R_OK 0x04
61 /* values for wxflag in file descriptor */
64 #define WX_READNL 0x04 /* read started with \n */
66 #define WX_DONTINHERIT 0x10
67 #define WX_APPEND 0x20
70 /* values for exflag - it's used differently in msvcr90.dll*/
73 #define EF_CRIT_INIT 0x04
74 #define EF_UNK_UNICODE 0x08
76 static char utf8_bom[3] = { 0xef, 0xbb, 0xbf };
77 static char utf16_bom[2] = { 0xff, 0xfe };
79 /* FIXME: this should be allocated dynamically */
80 #define MSVCRT_MAX_FILES 2048
81 #define MSVCRT_FD_BLOCK_SIZE 32
83 /* ioinfo structure size is different in msvcrXX.dll's */
89 CRITICAL_SECTION crit;
92 /*********************************************************************
93 * __pioinfo (MSVCRT.@)
94 * array of pointers to ioinfo arrays [32]
96 ioinfo * MSVCRT___pioinfo[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE] = { 0 };
98 /*********************************************************************
99 * __badioinfo (MSVCRT.@)
101 ioinfo MSVCRT___badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };
103 static int MSVCRT_fdstart = 3; /* first unallocated fd */
104 static int MSVCRT_fdend = 3; /* highest allocated fd */
108 CRITICAL_SECTION crit;
111 MSVCRT_FILE MSVCRT__iob[_IOB_ENTRIES] = { { 0 } };
112 static file_crit* MSVCRT_fstream[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE];
113 static int MSVCRT_max_streams = 512, MSVCRT_stream_idx;
115 /* INTERNAL: process umask */
116 static int MSVCRT_umask = 0;
118 /* INTERNAL: static data for tmpnam and _wtmpname functions */
119 static int tmpnam_unique;
121 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
122 static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
123 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
124 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
126 #define TOUL(x) (ULONGLONG)(x)
127 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
128 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
129 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
130 static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
132 /* This critical section protects the tables MSVCRT___pioinfo and MSVCRT_fstreams,
133 * and their related indexes, MSVCRT_fdstart, MSVCRT_fdend,
134 * and MSVCRT_stream_idx, from race conditions.
135 * It doesn't protect against race conditions manipulating the underlying files
136 * or flags; doing so would probably be better accomplished with per-file
137 * protection, rather than locking the whole table for every change.
139 static CRITICAL_SECTION MSVCRT_file_cs;
140 static CRITICAL_SECTION_DEBUG MSVCRT_file_cs_debug =
142 0, 0, &MSVCRT_file_cs,
143 { &MSVCRT_file_cs_debug.ProcessLocksList, &MSVCRT_file_cs_debug.ProcessLocksList },
144 0, 0, { (DWORD_PTR)(__FILE__ ": MSVCRT_file_cs") }
146 static CRITICAL_SECTION MSVCRT_file_cs = { &MSVCRT_file_cs_debug, -1, 0, 0, 0, 0 };
147 #define LOCK_FILES() do { EnterCriticalSection(&MSVCRT_file_cs); } while (0)
148 #define UNLOCK_FILES() do { LeaveCriticalSection(&MSVCRT_file_cs); } while (0)
150 static void msvcrt_stat64_to_stat(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat *buf)
152 buf->st_dev = buf64->st_dev;
153 buf->st_ino = buf64->st_ino;
154 buf->st_mode = buf64->st_mode;
155 buf->st_nlink = buf64->st_nlink;
156 buf->st_uid = buf64->st_uid;
157 buf->st_gid = buf64->st_gid;
158 buf->st_rdev = buf64->st_rdev;
159 buf->st_size = buf64->st_size;
160 buf->st_atime = buf64->st_atime;
161 buf->st_mtime = buf64->st_mtime;
162 buf->st_ctime = buf64->st_ctime;
165 static void msvcrt_stat64_to_stati64(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stati64 *buf)
167 buf->st_dev = buf64->st_dev;
168 buf->st_ino = buf64->st_ino;
169 buf->st_mode = buf64->st_mode;
170 buf->st_nlink = buf64->st_nlink;
171 buf->st_uid = buf64->st_uid;
172 buf->st_gid = buf64->st_gid;
173 buf->st_rdev = buf64->st_rdev;
174 buf->st_size = buf64->st_size;
175 buf->st_atime = buf64->st_atime;
176 buf->st_mtime = buf64->st_mtime;
177 buf->st_ctime = buf64->st_ctime;
180 static void time_to_filetime( MSVCRT___time64_t time, FILETIME *ft )
182 /* 1601 to 1970 is 369 years plus 89 leap days */
183 static const __int64 secs_1601_to_1970 = ((369 * 365 + 89) * (__int64)86400);
185 __int64 ticks = (time + secs_1601_to_1970) * 10000000;
186 ft->dwHighDateTime = ticks >> 32;
187 ft->dwLowDateTime = ticks;
190 static inline ioinfo* msvcrt_get_ioinfo(int fd)
193 if(fd < MSVCRT_MAX_FILES)
194 ret = MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE];
196 return &MSVCRT___badioinfo;
198 return ret + (fd%MSVCRT_FD_BLOCK_SIZE);
201 static inline MSVCRT_FILE* msvcrt_get_file(int i)
205 if(i >= MSVCRT_max_streams)
209 return &MSVCRT__iob[i];
211 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE];
213 MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] = MSVCRT_calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(file_crit));
214 if(!MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE]) {
215 ERR("out of memory\n");
216 *MSVCRT__errno() = MSVCRT_ENOMEM;
220 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] + (i%MSVCRT_FD_BLOCK_SIZE);
222 ret += i%MSVCRT_FD_BLOCK_SIZE;
227 static inline BOOL msvcrt_is_valid_fd(int fd)
229 return fd >= 0 && fd < MSVCRT_fdend && (msvcrt_get_ioinfo(fd)->wxflag & WX_OPEN);
232 /* INTERNAL: Get the HANDLE for a fd
233 * This doesn't lock the table, because a failure will result in
234 * INVALID_HANDLE_VALUE being returned, which should be handled correctly. If
235 * it returns a valid handle which is about to be closed, a subsequent call
236 * will fail, most likely in a sane way.
238 static HANDLE msvcrt_fdtoh(int fd)
240 if (!msvcrt_is_valid_fd(fd))
242 WARN(":fd (%d) - no handle!\n",fd);
243 *MSVCRT___doserrno() = 0;
244 *MSVCRT__errno() = MSVCRT_EBADF;
245 return INVALID_HANDLE_VALUE;
247 if (msvcrt_get_ioinfo(fd)->handle == INVALID_HANDLE_VALUE)
248 WARN("returning INVALID_HANDLE_VALUE for %d\n", fd);
249 return msvcrt_get_ioinfo(fd)->handle;
252 /* INTERNAL: free a file entry fd */
253 static void msvcrt_free_fd(int fd)
258 fdinfo = msvcrt_get_ioinfo(fd);
259 if(fdinfo != &MSVCRT___badioinfo)
261 fdinfo->handle = INVALID_HANDLE_VALUE;
264 TRACE(":fd (%d) freed\n",fd);
271 SetStdHandle(STD_INPUT_HANDLE, 0);
274 SetStdHandle(STD_OUTPUT_HANDLE, 0);
277 SetStdHandle(STD_ERROR_HANDLE, 0);
282 if (fd == MSVCRT_fdend - 1)
284 if (fd < MSVCRT_fdstart)
289 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE, starting from fd */
290 /* caller must hold the files lock */
291 static int msvcrt_set_fd(HANDLE hand, int flag, int fd)
295 if (fd >= MSVCRT_MAX_FILES)
297 WARN(":files exhausted!\n");
298 *MSVCRT__errno() = MSVCRT_ENFILE;
302 fdinfo = msvcrt_get_ioinfo(fd);
303 if(fdinfo == &MSVCRT___badioinfo) {
306 MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE] = MSVCRT_calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(ioinfo));
307 if(!MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE]) {
308 WARN(":out of memory!\n");
309 *MSVCRT__errno() = MSVCRT_ENOMEM;
313 for(i=0; i<MSVCRT_FD_BLOCK_SIZE; i++)
314 MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE][i].handle = INVALID_HANDLE_VALUE;
316 fdinfo = msvcrt_get_ioinfo(fd);
319 fdinfo->handle = hand;
320 fdinfo->wxflag = WX_OPEN | (flag & (WX_DONTINHERIT | WX_APPEND | WX_TEXT | WX_PIPE));
321 fdinfo->lookahead[0] = '\n';
322 fdinfo->lookahead[1] = '\n';
323 fdinfo->lookahead[2] = '\n';
326 /* locate next free slot */
327 if (fd == MSVCRT_fdstart && fd == MSVCRT_fdend)
328 MSVCRT_fdstart = MSVCRT_fdend + 1;
330 while (MSVCRT_fdstart < MSVCRT_fdend &&
331 msvcrt_get_ioinfo(MSVCRT_fdstart)->handle != INVALID_HANDLE_VALUE)
333 /* update last fd in use */
334 if (fd >= MSVCRT_fdend)
335 MSVCRT_fdend = fd + 1;
336 TRACE("fdstart is %d, fdend is %d\n", MSVCRT_fdstart, MSVCRT_fdend);
340 case 0: SetStdHandle(STD_INPUT_HANDLE, hand); break;
341 case 1: SetStdHandle(STD_OUTPUT_HANDLE, hand); break;
342 case 2: SetStdHandle(STD_ERROR_HANDLE, hand); break;
348 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
349 static int msvcrt_alloc_fd(HANDLE hand, int flag)
354 TRACE(":handle (%p) allocating fd (%d)\n",hand,MSVCRT_fdstart);
355 ret = msvcrt_set_fd(hand, flag, MSVCRT_fdstart);
360 /* INTERNAL: Allocate a FILE* for an fd slot */
361 /* caller must hold the files lock */
362 static MSVCRT_FILE* msvcrt_alloc_fp(void)
367 for (i = 3; i < MSVCRT_max_streams; i++)
369 file = msvcrt_get_file(i);
373 if (file->_flag == 0)
375 if (i == MSVCRT_stream_idx)
377 if (file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
379 InitializeCriticalSection(&((file_crit*)file)->crit);
380 ((file_crit*)file)->crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": file_crit.crit");
391 /* INTERNAL: initialize a FILE* from an open fd */
392 static int msvcrt_init_fp(MSVCRT_FILE* file, int fd, unsigned stream_flags)
394 TRACE(":fd (%d) allocating FILE*\n",fd);
395 if (!msvcrt_is_valid_fd(fd))
397 WARN(":invalid fd %d\n",fd);
398 *MSVCRT___doserrno() = 0;
399 *MSVCRT__errno() = MSVCRT_EBADF;
402 memset(file, 0, sizeof(*file));
404 file->_flag = stream_flags;
406 TRACE(":got FILE* (%p)\n",file);
410 /* INTERNAL: Create an inheritance data block (for spawned process)
411 * The inheritance block is made of:
412 * 00 int nb of file descriptor (NBFD)
413 * 04 char file flags (wxflag): repeated for each fd
414 * 4+NBFD HANDLE file handle: repeated for each fd
416 unsigned msvcrt_create_io_inherit_block(WORD *size, BYTE **block)
423 *size = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * MSVCRT_fdend;
424 *block = MSVCRT_calloc(*size, 1);
430 wxflag_ptr = (char*)*block + sizeof(unsigned);
431 handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
433 *(unsigned*)*block = MSVCRT_fdend;
434 for (fd = 0; fd < MSVCRT_fdend; fd++)
436 /* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
437 fdinfo = msvcrt_get_ioinfo(fd);
438 if ((fdinfo->wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
440 *wxflag_ptr = fdinfo->wxflag;
441 *handle_ptr = fdinfo->handle;
446 *handle_ptr = INVALID_HANDLE_VALUE;
448 wxflag_ptr++; handle_ptr++;
453 /* INTERNAL: Set up all file descriptors,
454 * as well as default streams (stdin, stderr and stdout)
456 void msvcrt_init_io(void)
462 GetStartupInfoA(&si);
463 if (si.cbReserved2 >= sizeof(unsigned int) && si.lpReserved2 != NULL)
469 count = *(unsigned*)si.lpReserved2;
470 wxflag_ptr = si.lpReserved2 + sizeof(unsigned);
471 handle_ptr = (HANDLE*)(wxflag_ptr + count);
473 count = min(count, (si.cbReserved2 - sizeof(unsigned)) / (sizeof(HANDLE) + 1));
474 count = min(count, MSVCRT_MAX_FILES);
475 for (i = 0; i < count; i++)
477 if ((*wxflag_ptr & WX_OPEN) && *handle_ptr != INVALID_HANDLE_VALUE)
478 msvcrt_set_fd(*handle_ptr, *wxflag_ptr, i);
480 wxflag_ptr++; handle_ptr++;
482 MSVCRT_fdend = max( 3, count );
483 for (MSVCRT_fdstart = 3; MSVCRT_fdstart < MSVCRT_fdend; MSVCRT_fdstart++)
484 if (msvcrt_get_ioinfo(MSVCRT_fdstart)->handle == INVALID_HANDLE_VALUE) break;
487 fdinfo = msvcrt_get_ioinfo(MSVCRT_STDIN_FILENO);
488 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE)
489 msvcrt_set_fd(GetStdHandle(STD_INPUT_HANDLE), WX_OPEN|WX_TEXT, MSVCRT_STDIN_FILENO);
491 fdinfo = msvcrt_get_ioinfo(MSVCRT_STDOUT_FILENO);
492 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE)
493 msvcrt_set_fd(GetStdHandle(STD_OUTPUT_HANDLE), WX_OPEN|WX_TEXT, MSVCRT_STDOUT_FILENO);
495 fdinfo = msvcrt_get_ioinfo(MSVCRT_STDERR_FILENO);
496 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE)
497 msvcrt_set_fd(GetStdHandle(STD_ERROR_HANDLE), WX_OPEN|WX_TEXT, MSVCRT_STDERR_FILENO);
499 TRACE(":handles (%p)(%p)(%p)\n", msvcrt_get_ioinfo(MSVCRT_STDIN_FILENO)->handle,
500 msvcrt_get_ioinfo(MSVCRT_STDOUT_FILENO)->handle,
501 msvcrt_get_ioinfo(MSVCRT_STDERR_FILENO)->handle);
503 memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
504 for (i = 0; i < 3; i++)
506 /* FILE structs for stdin/out/err are static and never deleted */
507 MSVCRT__iob[i]._file = i;
508 MSVCRT__iob[i]._tmpfname = NULL;
509 MSVCRT__iob[i]._flag = (i == 0) ? MSVCRT__IOREAD : MSVCRT__IOWRT;
511 MSVCRT_stream_idx = 3;
514 /* INTERNAL: Flush stdio file buffer */
515 static int msvcrt_flush_buffer(MSVCRT_FILE* file)
518 int cnt=file->_ptr-file->_base;
519 if(cnt>0 && MSVCRT__write(file->_file, file->_base, cnt) != cnt) {
520 file->_flag |= MSVCRT__IOERR;
523 file->_ptr=file->_base;
524 file->_cnt=file->_bufsiz;
529 /*********************************************************************
532 int CDECL MSVCRT__isatty(int fd)
534 HANDLE hand = msvcrt_fdtoh(fd);
536 TRACE(":fd (%d) handle (%p)\n",fd,hand);
537 if (hand == INVALID_HANDLE_VALUE)
540 return GetFileType(hand) == FILE_TYPE_CHAR? 1 : 0;
543 /* INTERNAL: Allocate stdio file buffer */
544 static BOOL msvcrt_alloc_buffer(MSVCRT_FILE* file)
546 if((file->_file==MSVCRT_STDOUT_FILENO || file->_file==MSVCRT_STDERR_FILENO)
547 && MSVCRT__isatty(file->_file))
550 file->_base = MSVCRT_calloc(MSVCRT_BUFSIZ,1);
552 file->_bufsiz = MSVCRT_BUFSIZ;
553 file->_flag |= MSVCRT__IOMYBUF;
555 file->_base = (char*)(&file->_charbuf);
557 file->_bufsiz = sizeof(file->_charbuf);
559 file->_ptr = file->_base;
564 /* INTERNAL: Allocate temporary buffer for stdout and stderr */
565 static BOOL add_std_buffer(MSVCRT_FILE *file)
567 static char buffers[2][MSVCRT_BUFSIZ];
569 if((file->_file!=MSVCRT_STDOUT_FILENO && file->_file!=MSVCRT_STDERR_FILENO)
570 || !MSVCRT__isatty(file->_file) || file->_bufsiz)
573 file->_ptr = file->_base = buffers[file->_file == MSVCRT_STDOUT_FILENO ? 0 : 1];
574 file->_bufsiz = file->_cnt = MSVCRT_BUFSIZ;
578 /* INTERNAL: Removes temporary buffer from stdout or stderr */
579 /* Only call this function when add_std_buffer returned TRUE */
580 static void remove_std_buffer(MSVCRT_FILE *file)
582 msvcrt_flush_buffer(file);
583 file->_ptr = file->_base = NULL;
584 file->_bufsiz = file->_cnt = 0;
587 /* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
588 static int msvcrt_int_to_base32(int num, char *str)
603 *p = (num & 31) + '0';
605 *p += ('a' - '0' - 10);
612 /* INTERNAL: wide character version of msvcrt_int_to_base32 */
613 static int msvcrt_int_to_base32_w(int num, MSVCRT_wchar_t *str)
628 *p = (num & 31) + '0';
630 *p += ('a' - '0' - 10);
637 /*********************************************************************
638 * __iob_func(MSVCRT.@)
640 MSVCRT_FILE * CDECL MSVCRT___iob_func(void)
642 return &MSVCRT__iob[0];
645 /*********************************************************************
648 int CDECL MSVCRT__access(const char *filename, int mode)
650 DWORD attr = GetFileAttributesA(filename);
652 TRACE("(%s,%d) %d\n",filename,mode,attr);
654 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
656 msvcrt_set_errno(GetLastError());
659 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
661 msvcrt_set_errno(ERROR_ACCESS_DENIED);
667 /*********************************************************************
668 * _access_s (MSVCRT.@)
670 int CDECL _access_s(const char *filename, int mode)
672 if (!MSVCRT_CHECK_PMT(filename != NULL)) return -1;
673 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return -1;
675 return MSVCRT__access(filename, mode);
678 /*********************************************************************
679 * _waccess (MSVCRT.@)
681 int CDECL MSVCRT__waccess(const MSVCRT_wchar_t *filename, int mode)
683 DWORD attr = GetFileAttributesW(filename);
685 TRACE("(%s,%d) %d\n",debugstr_w(filename),mode,attr);
687 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
689 msvcrt_set_errno(GetLastError());
692 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
694 msvcrt_set_errno(ERROR_ACCESS_DENIED);
700 /*********************************************************************
701 * _waccess_s (MSVCRT.@)
703 int CDECL _waccess_s(const MSVCRT_wchar_t *filename, int mode)
705 if (!MSVCRT_CHECK_PMT(filename != NULL)) return -1;
706 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return -1;
708 return MSVCRT__waccess(filename, mode);
711 /*********************************************************************
714 int CDECL MSVCRT__chmod(const char *path, int flags)
716 DWORD oldFlags = GetFileAttributesA(path);
718 if (oldFlags != INVALID_FILE_ATTRIBUTES)
720 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
721 oldFlags | FILE_ATTRIBUTE_READONLY;
723 if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
726 msvcrt_set_errno(GetLastError());
730 /*********************************************************************
733 int CDECL MSVCRT__wchmod(const MSVCRT_wchar_t *path, int flags)
735 DWORD oldFlags = GetFileAttributesW(path);
737 if (oldFlags != INVALID_FILE_ATTRIBUTES)
739 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
740 oldFlags | FILE_ATTRIBUTE_READONLY;
742 if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
745 msvcrt_set_errno(GetLastError());
749 /*********************************************************************
752 int CDECL MSVCRT__unlink(const char *path)
754 TRACE("%s\n",debugstr_a(path));
755 if(DeleteFileA(path))
757 TRACE("failed (%d)\n",GetLastError());
758 msvcrt_set_errno(GetLastError());
762 /*********************************************************************
763 * _wunlink (MSVCRT.@)
765 int CDECL MSVCRT__wunlink(const MSVCRT_wchar_t *path)
767 TRACE("(%s)\n",debugstr_w(path));
768 if(DeleteFileW(path))
770 TRACE("failed (%d)\n",GetLastError());
771 msvcrt_set_errno(GetLastError());
775 /*********************************************************************
778 int CDECL MSVCRT__commit(int fd)
780 HANDLE hand = msvcrt_fdtoh(fd);
782 TRACE(":fd (%d) handle (%p)\n",fd,hand);
783 if (hand == INVALID_HANDLE_VALUE)
786 if (!FlushFileBuffers(hand))
788 if (GetLastError() == ERROR_INVALID_HANDLE)
790 /* FlushFileBuffers fails for console handles
791 * so we ignore this error.
795 TRACE(":failed-last error (%d)\n",GetLastError());
796 msvcrt_set_errno(GetLastError());
803 /* flush_all_buffers calls MSVCRT_fflush which calls flush_all_buffers */
804 int CDECL MSVCRT_fflush(MSVCRT_FILE* file);
806 /* INTERNAL: Flush all stream buffer */
807 static int msvcrt_flush_all_buffers(int mask)
809 int i, num_flushed = 0;
813 for (i = 3; i < MSVCRT_stream_idx; i++) {
814 file = msvcrt_get_file(i);
818 if(file->_flag & mask) {
826 TRACE(":flushed (%d) handles\n",num_flushed);
830 /*********************************************************************
831 * _flushall (MSVCRT.@)
833 int CDECL MSVCRT__flushall(void)
835 return msvcrt_flush_all_buffers(MSVCRT__IOWRT | MSVCRT__IOREAD);
838 /*********************************************************************
841 int CDECL MSVCRT_fflush(MSVCRT_FILE* file)
844 msvcrt_flush_all_buffers(MSVCRT__IOWRT);
845 } else if(file->_flag & MSVCRT__IOWRT) {
848 MSVCRT__lock_file(file);
849 res = msvcrt_flush_buffer(file);
851 if(!res && (file->_flag & MSVCRT__IOCOMMIT))
852 res = MSVCRT__commit(file->_file) ? MSVCRT_EOF : 0;
853 MSVCRT__unlock_file(file);
856 } else if(file->_flag & MSVCRT__IOREAD) {
857 MSVCRT__lock_file(file);
859 file->_ptr = file->_base;
860 MSVCRT__unlock_file(file);
867 /*********************************************************************
870 int CDECL MSVCRT__close(int fd)
876 hand = msvcrt_fdtoh(fd);
877 TRACE(":fd (%d) handle (%p)\n",fd,hand);
878 if (!msvcrt_is_valid_fd(fd)) {
882 ret = CloseHandle(hand) ? 0 : -1;
884 WARN(":failed-last error (%d)\n",GetLastError());
885 msvcrt_set_errno(GetLastError());
893 /*********************************************************************
896 * MSDN isn't clear on this point, but the remarks for _pipe
897 * indicate file descriptors duplicated with _dup and _dup2 are always
900 int CDECL MSVCRT__dup2(int od, int nd)
904 TRACE("(od=%d, nd=%d)\n", od, nd);
906 if (nd < MSVCRT_MAX_FILES && nd >= 0 && msvcrt_is_valid_fd(od))
910 if (DuplicateHandle(GetCurrentProcess(), msvcrt_get_ioinfo(od)->handle,
911 GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS))
913 int wxflag = msvcrt_get_ioinfo(od)->wxflag & ~MSVCRT__O_NOINHERIT;
915 if (msvcrt_is_valid_fd(nd))
917 ret = msvcrt_set_fd(handle, wxflag, nd);
921 *MSVCRT__errno() = MSVCRT_EMFILE;
925 /* _dup2 returns 0, not nd, on success */
932 msvcrt_set_errno(GetLastError());
937 *MSVCRT__errno() = MSVCRT_EBADF;
944 /*********************************************************************
947 int CDECL MSVCRT__dup(int od)
953 if (MSVCRT__dup2(od, fd) == 0)
961 /*********************************************************************
964 int CDECL MSVCRT__eof(int fd)
967 LONG hcurpos,hendpos;
968 HANDLE hand = msvcrt_fdtoh(fd);
970 TRACE(":fd (%d) handle (%p)\n",fd,hand);
972 if (hand == INVALID_HANDLE_VALUE)
975 if (msvcrt_get_ioinfo(fd)->wxflag & WX_ATEOF) return TRUE;
977 /* Otherwise we do it the hard way */
978 hcurpos = hendpos = 0;
979 curpos = SetFilePointer(hand, 0, &hcurpos, FILE_CURRENT);
980 endpos = SetFilePointer(hand, 0, &hendpos, FILE_END);
982 if (curpos == endpos && hcurpos == hendpos)
984 /* FIXME: shouldn't WX_ATEOF be set here? */
988 SetFilePointer(hand, curpos, &hcurpos, FILE_BEGIN);
992 /*********************************************************************
993 * _fcloseall (MSVCRT.@)
995 int CDECL MSVCRT__fcloseall(void)
997 int num_closed = 0, i;
1001 for (i = 3; i < MSVCRT_stream_idx; i++) {
1002 file = msvcrt_get_file(i);
1004 if (file->_flag && !MSVCRT_fclose(file))
1009 TRACE(":closed (%d) handles\n",num_closed);
1013 /* free everything on process exit */
1014 void msvcrt_free_io(void)
1019 MSVCRT__fcloseall();
1020 /* The Win32 _fcloseall() function explicitly doesn't close stdin,
1021 * stdout, and stderr (unlike GNU), so we need to fclose() them here
1022 * or they won't get flushed.
1024 MSVCRT_fclose(&MSVCRT__iob[0]);
1025 MSVCRT_fclose(&MSVCRT__iob[1]);
1026 MSVCRT_fclose(&MSVCRT__iob[2]);
1028 for(i=0; i<sizeof(MSVCRT___pioinfo)/sizeof(MSVCRT___pioinfo[0]); i++)
1029 MSVCRT_free(MSVCRT___pioinfo[i]);
1031 for(j=0; j<MSVCRT_stream_idx; j++)
1033 MSVCRT_FILE *file = msvcrt_get_file(j);
1034 if(file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
1036 ((file_crit*)file)->crit.DebugInfo->Spare[0] = 0;
1037 DeleteCriticalSection(&((file_crit*)file)->crit);
1041 for(i=0; i<sizeof(MSVCRT_fstream)/sizeof(MSVCRT_fstream[0]); i++)
1042 MSVCRT_free(MSVCRT_fstream[i]);
1044 DeleteCriticalSection(&MSVCRT_file_cs);
1047 /*********************************************************************
1048 * _lseeki64 (MSVCRT.@)
1050 __int64 CDECL MSVCRT__lseeki64(int fd, __int64 offset, int whence)
1052 HANDLE hand = msvcrt_fdtoh(fd);
1055 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1056 if (hand == INVALID_HANDLE_VALUE)
1059 if (whence < 0 || whence > 2)
1061 *MSVCRT__errno() = MSVCRT_EINVAL;
1065 TRACE(":fd (%d) to %s pos %s\n",
1066 fd,wine_dbgstr_longlong(offset),
1067 (whence==SEEK_SET)?"SEEK_SET":
1068 (whence==SEEK_CUR)?"SEEK_CUR":
1069 (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
1071 /* The MoleBox protection scheme expects msvcrt to use SetFilePointer only,
1072 * so a LARGE_INTEGER offset cannot be passed directly via SetFilePointerEx. */
1073 ofs.QuadPart = offset;
1074 if ((ofs.u.LowPart = SetFilePointer(hand, ofs.u.LowPart, &ofs.u.HighPart, whence)) != INVALID_SET_FILE_POINTER ||
1075 GetLastError() == ERROR_SUCCESS)
1077 msvcrt_get_ioinfo(fd)->wxflag &= ~WX_ATEOF;
1078 /* FIXME: What if we seek _to_ EOF - is EOF set? */
1080 return ofs.QuadPart;
1082 TRACE(":error-last error (%d)\n",GetLastError());
1083 msvcrt_set_errno(GetLastError());
1087 /*********************************************************************
1090 LONG CDECL MSVCRT__lseek(int fd, LONG offset, int whence)
1092 return MSVCRT__lseeki64(fd, offset, whence);
1095 /*********************************************************************
1096 * _lock_file (MSVCRT.@)
1098 void CDECL MSVCRT__lock_file(MSVCRT_FILE *file)
1100 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1101 _lock(_STREAM_LOCKS+(file-MSVCRT__iob));
1103 EnterCriticalSection(&((file_crit*)file)->crit);
1106 /*********************************************************************
1107 * _unlock_file (MSVCRT.@)
1109 void CDECL MSVCRT__unlock_file(MSVCRT_FILE *file)
1111 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1112 _unlock(_STREAM_LOCKS+(file-MSVCRT__iob));
1114 LeaveCriticalSection(&((file_crit*)file)->crit);
1117 /*********************************************************************
1118 * _locking (MSVCRT.@)
1120 * This is untested; the underlying LockFile doesn't work yet.
1122 int CDECL MSVCRT__locking(int fd, int mode, LONG nbytes)
1126 HANDLE hand = msvcrt_fdtoh(fd);
1128 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1129 if (hand == INVALID_HANDLE_VALUE)
1132 if (mode < 0 || mode > 4)
1134 *MSVCRT__errno() = MSVCRT_EINVAL;
1138 TRACE(":fd (%d) by 0x%08x mode %s\n",
1139 fd,nbytes,(mode==MSVCRT__LK_UNLCK)?"_LK_UNLCK":
1140 (mode==MSVCRT__LK_LOCK)?"_LK_LOCK":
1141 (mode==MSVCRT__LK_NBLCK)?"_LK_NBLCK":
1142 (mode==MSVCRT__LK_RLCK)?"_LK_RLCK":
1143 (mode==MSVCRT__LK_NBRLCK)?"_LK_NBRLCK":
1146 if ((cur_locn = SetFilePointer(hand, 0L, NULL, SEEK_CUR)) == INVALID_SET_FILE_POINTER)
1148 FIXME ("Seek failed\n");
1149 *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
1152 if (mode == MSVCRT__LK_LOCK || mode == MSVCRT__LK_RLCK)
1155 ret = 1; /* just to satisfy gcc */
1158 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
1163 else if (mode == MSVCRT__LK_UNLCK)
1164 ret = UnlockFile(hand, cur_locn, 0L, nbytes, 0L);
1166 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
1167 /* FIXME - what about error settings? */
1168 return ret ? 0 : -1;
1171 /*********************************************************************
1172 * _fseeki64 (MSVCRT.@)
1174 int CDECL MSVCRT__fseeki64(MSVCRT_FILE* file, __int64 offset, int whence)
1178 MSVCRT__lock_file(file);
1179 /* Flush output if needed */
1180 if(file->_flag & MSVCRT__IOWRT)
1181 msvcrt_flush_buffer(file);
1183 if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
1185 offset += MSVCRT__ftelli64(file);
1188 /* Discard buffered input */
1190 file->_ptr = file->_base;
1191 /* Reset direction of i/o */
1192 if(file->_flag & MSVCRT__IORW) {
1193 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
1195 /* Clear end of file flag */
1196 file->_flag &= ~MSVCRT__IOEOF;
1197 ret = (MSVCRT__lseeki64(file->_file,offset,whence) == -1)?-1:0;
1199 MSVCRT__unlock_file(file);
1203 /*********************************************************************
1206 int CDECL MSVCRT_fseek(MSVCRT_FILE* file, MSVCRT_long offset, int whence)
1208 return MSVCRT__fseeki64( file, offset, whence );
1211 /*********************************************************************
1212 * _chsize (MSVCRT.@)
1214 int CDECL MSVCRT__chsize(int fd, MSVCRT_long size)
1220 TRACE("(fd=%d, size=%d)\n", fd, size);
1224 handle = msvcrt_fdtoh(fd);
1225 if (handle != INVALID_HANDLE_VALUE)
1227 /* save the current file pointer */
1228 cur = MSVCRT__lseek(fd, 0, SEEK_CUR);
1231 pos = MSVCRT__lseek(fd, size, SEEK_SET);
1234 ret = SetEndOfFile(handle);
1235 if (!ret) msvcrt_set_errno(GetLastError());
1238 /* restore the file pointer */
1239 MSVCRT__lseek(fd, cur, SEEK_SET);
1244 return ret ? 0 : -1;
1247 /*********************************************************************
1248 * clearerr (MSVCRT.@)
1250 void CDECL MSVCRT_clearerr(MSVCRT_FILE* file)
1252 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1254 MSVCRT__lock_file(file);
1255 file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
1256 MSVCRT__unlock_file(file);
1259 /*********************************************************************
1262 void CDECL MSVCRT_rewind(MSVCRT_FILE* file)
1264 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1266 MSVCRT__lock_file(file);
1267 MSVCRT_fseek(file, 0L, SEEK_SET);
1268 MSVCRT_clearerr(file);
1269 MSVCRT__unlock_file(file);
1272 static int msvcrt_get_flags(const MSVCRT_wchar_t* mode, int *open_flags, int* stream_flags)
1274 int plus = strchrW(mode, '+') != NULL;
1276 TRACE("%s\n", debugstr_w(mode));
1278 while(*mode == ' ') mode++;
1283 *open_flags = plus ? MSVCRT__O_RDWR : MSVCRT__O_RDONLY;
1284 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOREAD;
1287 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_TRUNC | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1288 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1291 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_APPEND | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1292 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1295 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1299 *stream_flags |= MSVCRT__commode;
1301 while (*mode && *mode!=',')
1305 *open_flags |= MSVCRT__O_BINARY;
1306 *open_flags &= ~MSVCRT__O_TEXT;
1309 *open_flags |= MSVCRT__O_TEXT;
1310 *open_flags &= ~MSVCRT__O_BINARY;
1313 *open_flags |= MSVCRT__O_TEMPORARY;
1316 *open_flags |= MSVCRT__O_SHORT_LIVED;
1319 *stream_flags |= MSVCRT__IOCOMMIT;
1322 *stream_flags &= ~MSVCRT__IOCOMMIT;
1325 *open_flags |= MSVCRT__O_NOINHERIT;
1334 FIXME("ignoring cache optimization flag: %c\n", mode[-1]);
1337 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1343 static const WCHAR ccs[] = {'c','c','s'};
1344 static const WCHAR utf8[] = {'u','t','f','-','8'};
1345 static const WCHAR utf16le[] = {'u','t','f','-','1','6','l','e'};
1346 static const WCHAR unicode[] = {'u','n','i','c','o','d','e'};
1349 while(*mode == ' ') mode++;
1350 if(!MSVCRT_CHECK_PMT(!strncmpW(ccs, mode, sizeof(ccs)/sizeof(ccs[0]))))
1352 mode += sizeof(ccs)/sizeof(ccs[0]);
1353 while(*mode == ' ') mode++;
1354 if(!MSVCRT_CHECK_PMT(*mode == '='))
1357 while(*mode == ' ') mode++;
1359 if(!strncmpiW(utf8, mode, sizeof(utf8)/sizeof(utf8[0])))
1361 *open_flags |= MSVCRT__O_U8TEXT;
1362 mode += sizeof(utf8)/sizeof(utf8[0]);
1364 else if(!strncmpiW(utf16le, mode, sizeof(utf16le)/sizeof(utf16le[0])))
1366 *open_flags |= MSVCRT__O_U16TEXT;
1367 mode += sizeof(utf16le)/sizeof(utf16le[0]);
1369 else if(!strncmpiW(unicode, mode, sizeof(unicode)/sizeof(unicode[0])))
1371 *open_flags |= MSVCRT__O_WTEXT;
1372 mode += sizeof(unicode)/sizeof(unicode[0]);
1376 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1380 while(*mode == ' ') mode++;
1383 if(!MSVCRT_CHECK_PMT(*mode == 0))
1388 /*********************************************************************
1389 * _fdopen (MSVCRT.@)
1391 MSVCRT_FILE* CDECL MSVCRT__fdopen(int fd, const char *mode)
1394 MSVCRT_wchar_t *modeW = NULL;
1396 if (mode && !(modeW = msvcrt_wstrdupa(mode))) return NULL;
1398 ret = MSVCRT__wfdopen(fd, modeW);
1404 /*********************************************************************
1405 * _wfdopen (MSVCRT.@)
1407 MSVCRT_FILE* CDECL MSVCRT__wfdopen(int fd, const MSVCRT_wchar_t *mode)
1409 int open_flags, stream_flags;
1412 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
1415 if (!(file = msvcrt_alloc_fp()))
1417 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
1422 else TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
1428 /*********************************************************************
1429 * _filelength (MSVCRT.@)
1431 LONG CDECL MSVCRT__filelength(int fd)
1433 LONG curPos = MSVCRT__lseek(fd, 0, SEEK_CUR);
1436 LONG endPos = MSVCRT__lseek(fd, 0, SEEK_END);
1439 if (endPos != curPos)
1440 MSVCRT__lseek(fd, curPos, SEEK_SET);
1447 /*********************************************************************
1448 * _filelengthi64 (MSVCRT.@)
1450 __int64 CDECL MSVCRT__filelengthi64(int fd)
1452 __int64 curPos = MSVCRT__lseeki64(fd, 0, SEEK_CUR);
1455 __int64 endPos = MSVCRT__lseeki64(fd, 0, SEEK_END);
1458 if (endPos != curPos)
1459 MSVCRT__lseeki64(fd, curPos, SEEK_SET);
1466 /*********************************************************************
1467 * _fileno (MSVCRT.@)
1469 int CDECL MSVCRT__fileno(MSVCRT_FILE* file)
1471 TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
1475 /*********************************************************************
1476 * _fstat64 (MSVCRT.@)
1478 int CDECL MSVCRT__fstat64(int fd, struct MSVCRT__stat64* buf)
1482 BY_HANDLE_FILE_INFORMATION hfi;
1483 HANDLE hand = msvcrt_fdtoh(fd);
1485 TRACE(":fd (%d) stat (%p)\n",fd,buf);
1486 if (hand == INVALID_HANDLE_VALUE)
1491 WARN(":failed-NULL buf\n");
1492 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1496 memset(&hfi, 0, sizeof(hfi));
1497 memset(buf, 0, sizeof(struct MSVCRT__stat64));
1498 type = GetFileType(hand);
1499 if (type == FILE_TYPE_PIPE)
1501 buf->st_dev = buf->st_rdev = fd;
1502 buf->st_mode = S_IFIFO;
1505 else if (type == FILE_TYPE_CHAR)
1507 buf->st_dev = buf->st_rdev = fd;
1508 buf->st_mode = S_IFCHR;
1511 else /* FILE_TYPE_DISK etc. */
1513 if (!GetFileInformationByHandle(hand, &hfi))
1515 WARN(":failed-last error (%d)\n",GetLastError());
1516 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1519 buf->st_mode = S_IFREG | 0444;
1520 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1521 buf->st_mode |= 0222;
1522 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1523 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1525 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1526 buf->st_mtime = buf->st_ctime = dw;
1527 buf->st_nlink = hfi.nNumberOfLinks;
1529 TRACE(":dwFileAttributes = 0x%x, mode set to 0x%x\n",hfi.dwFileAttributes,
1534 /*********************************************************************
1535 * _fstati64 (MSVCRT.@)
1537 int CDECL MSVCRT__fstati64(int fd, struct MSVCRT__stati64* buf)
1540 struct MSVCRT__stat64 buf64;
1542 ret = MSVCRT__fstat64(fd, &buf64);
1544 msvcrt_stat64_to_stati64(&buf64, buf);
1548 /*********************************************************************
1551 int CDECL MSVCRT__fstat(int fd, struct MSVCRT__stat* buf)
1553 struct MSVCRT__stat64 buf64;
1555 ret = MSVCRT__fstat64(fd, &buf64);
1557 msvcrt_stat64_to_stat(&buf64, buf);
1561 /*********************************************************************
1562 * _futime64 (MSVCRT.@)
1564 int CDECL _futime64(int fd, struct MSVCRT___utimbuf64 *t)
1566 HANDLE hand = msvcrt_fdtoh(fd);
1571 time_to_filetime( MSVCRT__time64(NULL), &at );
1576 time_to_filetime( t->actime, &at );
1577 time_to_filetime( t->modtime, &wt );
1580 if (!SetFileTime(hand, NULL, &at, &wt))
1582 msvcrt_set_errno(GetLastError());
1588 /*********************************************************************
1589 * _futime32 (MSVCRT.@)
1591 int CDECL _futime32(int fd, struct MSVCRT___utimbuf32 *t)
1595 struct MSVCRT___utimbuf64 t64;
1596 t64.actime = t->actime;
1597 t64.modtime = t->modtime;
1598 return _futime64( fd, &t64 );
1601 return _futime64( fd, NULL );
1604 /*********************************************************************
1605 * _futime (MSVCRT.@)
1608 int CDECL _futime(int fd, struct MSVCRT___utimbuf64 *t)
1610 return _futime64( fd, t );
1613 int CDECL _futime(int fd, struct MSVCRT___utimbuf32 *t)
1615 return _futime32( fd, t );
1619 /*********************************************************************
1620 * _get_osfhandle (MSVCRT.@)
1622 MSVCRT_intptr_t CDECL MSVCRT__get_osfhandle(int fd)
1624 HANDLE hand = msvcrt_fdtoh(fd);
1625 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1627 return (MSVCRT_intptr_t)hand;
1630 /*********************************************************************
1631 * _mktemp (MSVCRT.@)
1633 char * CDECL MSVCRT__mktemp(char *pattern)
1636 char *retVal = pattern;
1641 numX = (*pattern++ == 'X')? numX + 1 : 0;
1645 id = GetCurrentProcessId();
1649 int tempNum = id / 10;
1650 *pattern-- = id - (tempNum * 10) + '0';
1656 *pattern = letter++;
1657 if (GetFileAttributesA(retVal) == INVALID_FILE_ATTRIBUTES &&
1658 GetLastError() == ERROR_FILE_NOT_FOUND)
1660 } while(letter <= 'z');
1664 /*********************************************************************
1665 * _wmktemp (MSVCRT.@)
1667 MSVCRT_wchar_t * CDECL MSVCRT__wmktemp(MSVCRT_wchar_t *pattern)
1670 MSVCRT_wchar_t *retVal = pattern;
1672 MSVCRT_wchar_t letter = 'a';
1675 numX = (*pattern++ == 'X')? numX + 1 : 0;
1679 id = GetCurrentProcessId();
1683 int tempNum = id / 10;
1684 *pattern-- = id - (tempNum * 10) + '0';
1690 if (GetFileAttributesW(retVal) == INVALID_FILE_ATTRIBUTES &&
1691 GetLastError() == ERROR_FILE_NOT_FOUND)
1693 *pattern = letter++;
1694 } while(letter != '|');
1698 static unsigned split_oflags(unsigned oflags)
1701 unsigned unsupp; /* until we support everything */
1703 if (oflags & MSVCRT__O_APPEND) wxflags |= WX_APPEND;
1704 if (oflags & MSVCRT__O_BINARY) {/* Nothing to do */}
1705 else if (oflags & MSVCRT__O_TEXT) wxflags |= WX_TEXT;
1706 else if (oflags & MSVCRT__O_WTEXT) wxflags |= WX_TEXT;
1707 else if (oflags & MSVCRT__O_U16TEXT) wxflags |= WX_TEXT;
1708 else if (oflags & MSVCRT__O_U8TEXT) wxflags |= WX_TEXT;
1709 else if (*__p__fmode() & MSVCRT__O_BINARY) {/* Nothing to do */}
1710 else wxflags |= WX_TEXT; /* default to TEXT*/
1711 if (oflags & MSVCRT__O_NOINHERIT) wxflags |= WX_DONTINHERIT;
1713 if ((unsupp = oflags & ~(
1714 MSVCRT__O_BINARY|MSVCRT__O_TEXT|MSVCRT__O_APPEND|
1715 MSVCRT__O_TRUNC|MSVCRT__O_EXCL|MSVCRT__O_CREAT|
1716 MSVCRT__O_RDWR|MSVCRT__O_WRONLY|MSVCRT__O_TEMPORARY|
1717 MSVCRT__O_NOINHERIT|
1718 MSVCRT__O_SEQUENTIAL|MSVCRT__O_RANDOM|MSVCRT__O_SHORT_LIVED|
1719 MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT
1721 ERR(":unsupported oflags 0x%04x\n",unsupp);
1726 /*********************************************************************
1729 int CDECL MSVCRT__pipe(int *pfds, unsigned int psize, int textmode)
1732 SECURITY_ATTRIBUTES sa;
1733 HANDLE readHandle, writeHandle;
1737 *MSVCRT__errno() = MSVCRT_EINVAL;
1741 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
1742 sa.bInheritHandle = !(textmode & MSVCRT__O_NOINHERIT);
1743 sa.lpSecurityDescriptor = NULL;
1744 if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
1746 unsigned int wxflags = split_oflags(textmode);
1750 fd = msvcrt_alloc_fd(readHandle, wxflags|WX_PIPE);
1754 fd = msvcrt_alloc_fd(writeHandle, wxflags|WX_PIPE);
1762 MSVCRT__close(pfds[0]);
1763 CloseHandle(writeHandle);
1764 *MSVCRT__errno() = MSVCRT_EMFILE;
1769 CloseHandle(readHandle);
1770 CloseHandle(writeHandle);
1771 *MSVCRT__errno() = MSVCRT_EMFILE;
1776 msvcrt_set_errno(GetLastError());
1781 static int check_bom(HANDLE h, int oflags, BOOL seek)
1783 char bom[sizeof(utf8_bom)];
1786 oflags &= ~(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT);
1788 if (!ReadFile(h, bom, sizeof(utf8_bom), &r, NULL))
1791 if (r==sizeof(utf8_bom) && !memcmp(bom, utf8_bom, sizeof(utf8_bom))) {
1792 oflags |= MSVCRT__O_U8TEXT;
1793 }else if (r>=sizeof(utf16_bom) && !memcmp(bom, utf16_bom, sizeof(utf16_bom))) {
1795 SetFilePointer(h, 2, NULL, FILE_BEGIN);
1796 oflags |= MSVCRT__O_U16TEXT;
1798 SetFilePointer(h, 0, NULL, FILE_BEGIN);
1804 /*********************************************************************
1805 * _wsopen_s (MSVCRT.@)
1807 int CDECL MSVCRT__wsopen_s( int *fd, const MSVCRT_wchar_t* path, int oflags, int shflags, int pmode )
1809 DWORD access = 0, creation = 0, attrib;
1810 SECURITY_ATTRIBUTES sa;
1815 TRACE("fd*: %p :file (%s) oflags: 0x%04x shflags: 0x%04x pmode: 0x%04x\n",
1816 fd, debugstr_w(path), oflags, shflags, pmode);
1818 if (!MSVCRT_CHECK_PMT( fd != NULL )) return MSVCRT_EINVAL;
1821 wxflag = split_oflags(oflags);
1822 switch (oflags & (MSVCRT__O_RDONLY | MSVCRT__O_WRONLY | MSVCRT__O_RDWR))
1824 case MSVCRT__O_RDONLY: access |= GENERIC_READ; break;
1825 case MSVCRT__O_WRONLY: access |= GENERIC_WRITE; break;
1826 case MSVCRT__O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
1829 if (oflags & MSVCRT__O_CREAT)
1831 if(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))
1832 FIXME(": pmode 0x%04x ignored\n", pmode);
1834 WARN(": pmode 0x%04x ignored\n", pmode);
1836 if (oflags & MSVCRT__O_EXCL)
1837 creation = CREATE_NEW;
1838 else if (oflags & MSVCRT__O_TRUNC)
1839 creation = CREATE_ALWAYS;
1841 creation = OPEN_ALWAYS;
1843 else /* no MSVCRT__O_CREAT */
1845 if (oflags & MSVCRT__O_TRUNC)
1846 creation = TRUNCATE_EXISTING;
1848 creation = OPEN_EXISTING;
1853 case MSVCRT__SH_DENYRW:
1856 case MSVCRT__SH_DENYWR:
1857 sharing = FILE_SHARE_READ;
1859 case MSVCRT__SH_DENYRD:
1860 sharing = FILE_SHARE_WRITE;
1862 case MSVCRT__SH_DENYNO:
1863 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1866 ERR( "Unhandled shflags 0x%x\n", shflags );
1867 return MSVCRT_EINVAL;
1869 attrib = FILE_ATTRIBUTE_NORMAL;
1871 if (oflags & MSVCRT__O_TEMPORARY)
1873 attrib |= FILE_FLAG_DELETE_ON_CLOSE;
1875 sharing |= FILE_SHARE_DELETE;
1878 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
1879 sa.lpSecurityDescriptor = NULL;
1880 sa.bInheritHandle = !(oflags & MSVCRT__O_NOINHERIT);
1882 if ((oflags&(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT))
1883 && (creation==OPEN_ALWAYS || creation==OPEN_EXISTING)
1884 && !(access&GENERIC_READ))
1886 hand = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
1887 &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
1888 if (hand != INVALID_HANDLE_VALUE)
1890 oflags = check_bom(hand, oflags, FALSE);
1894 oflags &= ~(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT);
1897 hand = CreateFileW(path, access, sharing, &sa, creation, attrib, 0);
1898 if (hand == INVALID_HANDLE_VALUE) {
1899 WARN(":failed-last error (%d)\n",GetLastError());
1900 msvcrt_set_errno(GetLastError());
1901 return *MSVCRT__errno();
1904 if (oflags & (MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT))
1906 if ((access & GENERIC_WRITE) && (creation==CREATE_NEW
1907 || creation==CREATE_ALWAYS || creation==TRUNCATE_EXISTING
1908 || (creation==OPEN_ALWAYS && GetLastError()==ERROR_ALREADY_EXISTS)))
1910 if (oflags & MSVCRT__O_U8TEXT)
1912 DWORD written = 0, tmp;
1914 while(written!=sizeof(utf8_bom) && WriteFile(hand, (char*)utf8_bom+written,
1915 sizeof(utf8_bom)-written, &tmp, NULL))
1917 if (written != sizeof(utf8_bom)) {
1918 WARN("error writing BOM\n");
1920 msvcrt_set_errno(GetLastError());
1921 return *MSVCRT__errno();
1926 DWORD written = 0, tmp;
1928 while(written!=sizeof(utf16_bom) && WriteFile(hand, (char*)utf16_bom+written,
1929 sizeof(utf16_bom)-written, &tmp, NULL))
1931 if (written != sizeof(utf16_bom))
1933 WARN("error writing BOM\n");
1935 msvcrt_set_errno(GetLastError());
1936 return *MSVCRT__errno();
1940 else if (access & GENERIC_READ)
1941 oflags = check_bom(hand, oflags, TRUE);
1944 *fd = msvcrt_alloc_fd(hand, wxflag);
1946 return *MSVCRT__errno();
1948 if (oflags & MSVCRT__O_WTEXT)
1949 msvcrt_get_ioinfo(*fd)->exflag |= EF_UTF16|EF_UNK_UNICODE;
1950 else if (oflags & MSVCRT__O_U16TEXT)
1951 msvcrt_get_ioinfo(*fd)->exflag |= EF_UTF16;
1952 else if (oflags & MSVCRT__O_U8TEXT)
1953 msvcrt_get_ioinfo(*fd)->exflag |= EF_UTF8;
1955 TRACE(":fd (%d) handle (%p)\n", *fd, hand);
1959 /*********************************************************************
1960 * _wsopen (MSVCRT.@)
1962 int CDECL MSVCRT__wsopen( const MSVCRT_wchar_t *path, int oflags, int shflags, ... )
1967 if (oflags & MSVCRT__O_CREAT)
1971 __ms_va_start(ap, shflags);
1972 pmode = va_arg(ap, int);
1978 MSVCRT__wsopen_s(&fd, path, oflags, shflags, pmode);
1982 /*********************************************************************
1983 * _sopen_s (MSVCRT.@)
1985 int CDECL MSVCRT__sopen_s( int *fd, const char *path, int oflags, int shflags, int pmode )
1987 MSVCRT_wchar_t *pathW;
1990 if(!MSVCRT_CHECK_PMT(path && (pathW = msvcrt_wstrdupa(path))))
1991 return MSVCRT_EINVAL;
1993 ret = MSVCRT__wsopen_s(fd, pathW, oflags, shflags, pmode);
1998 /*********************************************************************
2001 int CDECL MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
2006 if (oflags & MSVCRT__O_CREAT)
2010 __ms_va_start(ap, shflags);
2011 pmode = va_arg(ap, int);
2017 MSVCRT__sopen_s(&fd, path, oflags, shflags, pmode);
2021 /*********************************************************************
2024 int CDECL MSVCRT__open( const char *path, int flags, ... )
2028 if (flags & MSVCRT__O_CREAT)
2031 __ms_va_start(ap, flags);
2032 pmode = va_arg(ap, int);
2034 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO, pmode );
2037 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO);
2040 /*********************************************************************
2043 int CDECL MSVCRT__wopen(const MSVCRT_wchar_t *path,int flags,...)
2047 if (flags & MSVCRT__O_CREAT)
2050 __ms_va_start(ap, flags);
2051 pmode = va_arg(ap, int);
2053 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO, pmode );
2056 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO);
2059 /*********************************************************************
2062 int CDECL MSVCRT__creat(const char *path, int flags)
2064 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
2065 return MSVCRT__open(path, usedFlags);
2068 /*********************************************************************
2069 * _wcreat (MSVCRT.@)
2071 int CDECL MSVCRT__wcreat(const MSVCRT_wchar_t *path, int flags)
2073 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
2074 return MSVCRT__wopen(path, usedFlags);
2077 /*********************************************************************
2078 * _open_osfhandle (MSVCRT.@)
2080 int CDECL MSVCRT__open_osfhandle(MSVCRT_intptr_t handle, int oflags)
2084 /* MSVCRT__O_RDONLY (0) always matches, so set the read flag
2085 * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
2086 * file, so set the write flag. It also only sets MSVCRT__O_TEXT if it wants
2087 * text - it never sets MSVCRT__O_BINARY.
2089 /* don't let split_oflags() decide the mode if no mode is passed */
2090 if (!(oflags & (MSVCRT__O_BINARY | MSVCRT__O_TEXT)))
2091 oflags |= MSVCRT__O_BINARY;
2093 fd = msvcrt_alloc_fd((HANDLE)handle, split_oflags(oflags));
2094 TRACE(":handle (%ld) fd (%d) flags 0x%08x\n", handle, fd, oflags);
2098 /*********************************************************************
2101 int CDECL MSVCRT__rmtmp(void)
2103 int num_removed = 0, i;
2107 for (i = 3; i < MSVCRT_stream_idx; i++) {
2108 file = msvcrt_get_file(i);
2110 if (file->_tmpfname)
2112 MSVCRT_fclose(file);
2119 TRACE(":removed (%d) temp files\n",num_removed);
2123 static inline int get_utf8_char_len(char ch)
2125 if((ch&0xf8) == 0xf0)
2127 else if((ch&0xf0) == 0xe0)
2129 else if((ch&0xe0) == 0xc0)
2134 /*********************************************************************
2135 * (internal) read_utf8
2137 static int read_utf8(int fd, MSVCRT_wchar_t *buf, unsigned int count)
2139 ioinfo *fdinfo = msvcrt_get_ioinfo(fd);
2140 HANDLE hand = fdinfo->handle;
2141 char min_buf[4], *readbuf, lookahead;
2142 DWORD readbuf_size, pos=0, num_read=1, char_len, i, j;
2144 /* make the buffer big enough to hold at least one character */
2145 /* read bytes have to fit to output and lookahead buffers */
2147 readbuf_size = count < 4 ? 4 : count;
2148 if(readbuf_size<=4 || !(readbuf = MSVCRT_malloc(readbuf_size))) {
2153 if(fdinfo->lookahead[0] != '\n') {
2154 readbuf[pos++] = fdinfo->lookahead[0];
2155 fdinfo->lookahead[0] = '\n';
2157 if(fdinfo->lookahead[1] != '\n') {
2158 readbuf[pos++] = fdinfo->lookahead[1];
2159 fdinfo->lookahead[1] = '\n';
2161 if(fdinfo->lookahead[2] != '\n') {
2162 readbuf[pos++] = fdinfo->lookahead[2];
2163 fdinfo->lookahead[2] = '\n';
2168 /* NOTE: this case is broken in native dll, reading
2169 * sometimes fails when small buffer is passed
2172 if(!pos && !ReadFile(hand, readbuf, 1, &num_read, NULL)) {
2173 if (GetLastError() == ERROR_BROKEN_PIPE) {
2174 fdinfo->wxflag |= WX_ATEOF;
2177 msvcrt_set_errno(GetLastError());
2180 }else if(!num_read) {
2181 fdinfo->wxflag |= WX_ATEOF;
2187 char_len = get_utf8_char_len(readbuf[0]);
2189 if(ReadFile(hand, readbuf+pos, char_len-pos, &num_read, NULL))
2193 if(readbuf[0] == '\n')
2194 fdinfo->wxflag |= WX_READNL;
2196 fdinfo->wxflag &= ~WX_READNL;
2198 if(readbuf[0] == 0x1a) {
2199 fdinfo->wxflag |= WX_ATEOF;
2203 if(readbuf[0] == '\r') {
2204 if(!ReadFile(hand, &lookahead, 1, &num_read, NULL) || num_read!=1)
2206 else if(lookahead == '\n')
2210 if(fdinfo->wxflag & WX_PIPE)
2211 fdinfo->lookahead[0] = lookahead;
2213 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2218 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2219 msvcrt_set_errno(GetLastError());
2226 if(!ReadFile(hand, readbuf+pos, readbuf_size-pos, &num_read, NULL)) {
2229 }else if(GetLastError() == ERROR_BROKEN_PIPE) {
2230 fdinfo->wxflag |= WX_ATEOF;
2231 if (readbuf != min_buf) MSVCRT_free(readbuf);
2234 msvcrt_set_errno(GetLastError());
2235 if (readbuf != min_buf) MSVCRT_free(readbuf);
2238 }else if(!pos && !num_read) {
2239 fdinfo->wxflag |= WX_ATEOF;
2240 if (readbuf != min_buf) MSVCRT_free(readbuf);
2245 if(readbuf[0] == '\n')
2246 fdinfo->wxflag |= WX_READNL;
2248 fdinfo->wxflag &= ~WX_READNL;
2250 /* Find first byte of last character (may be incomplete) */
2251 for(i=pos-1; i>0 && i>pos-4; i--)
2252 if((readbuf[i]&0xc0) != 0x80)
2254 char_len = get_utf8_char_len(readbuf[i]);
2255 if(char_len+i <= pos)
2258 if(fdinfo->wxflag & WX_PIPE) {
2260 fdinfo->lookahead[0] = readbuf[i];
2262 fdinfo->lookahead[1] = readbuf[i+1];
2264 fdinfo->lookahead[2] = readbuf[i+2];
2266 SetFilePointer(fdinfo->handle, i-pos, NULL, FILE_CURRENT);
2270 for(i=0, j=0; i<pos; i++) {
2271 if(readbuf[i] == 0x1a) {
2272 fdinfo->wxflag |= WX_ATEOF;
2276 /* strip '\r' if followed by '\n' */
2277 if(readbuf[i] == '\r' && i+1==pos) {
2278 if(fdinfo->lookahead[0] != '\n' || !ReadFile(hand, &lookahead, 1, &num_read, NULL) || !num_read) {
2279 readbuf[j++] = '\r';
2280 }else if(lookahead == '\n' && j==0) {
2281 readbuf[j++] = '\n';
2283 if(lookahead != '\n')
2284 readbuf[j++] = '\r';
2286 if(fdinfo->wxflag & WX_PIPE)
2287 fdinfo->lookahead[0] = lookahead;
2289 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2291 }else if(readbuf[i]!='\r' || readbuf[i+1]!='\n') {
2292 readbuf[j++] = readbuf[i];
2297 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2298 msvcrt_set_errno(GetLastError());
2299 if (readbuf != min_buf) MSVCRT_free(readbuf);
2303 if (readbuf != min_buf) MSVCRT_free(readbuf);
2307 /*********************************************************************
2310 * When reading \r as last character in text mode, read() positions
2311 * the file pointer on the \r character while getc() goes on to
2314 static int read_i(int fd, void *buf, unsigned int count)
2316 DWORD num_read, utf16;
2317 char *bufstart = buf;
2318 HANDLE hand = msvcrt_fdtoh(fd);
2319 ioinfo *fdinfo = msvcrt_get_ioinfo(fd);
2324 if (fdinfo->wxflag & WX_ATEOF) {
2325 TRACE("already at EOF, returning 0\n");
2328 /* Don't trace small reads, it gets *very* annoying */
2330 TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n",fd,hand,buf,count);
2331 if (hand == INVALID_HANDLE_VALUE)
2333 *MSVCRT__errno() = MSVCRT_EBADF;
2337 utf16 = (fdinfo->exflag & EF_UTF16) != 0;
2338 if (((fdinfo->exflag&EF_UTF8) || utf16) && count&1)
2340 *MSVCRT__errno() = MSVCRT_EINVAL;
2344 if((fdinfo->wxflag&WX_TEXT) && (fdinfo->exflag&EF_UTF8))
2345 return read_utf8(fd, buf, count);
2347 if (fdinfo->lookahead[0]!='\n' || ReadFile(hand, bufstart, count, &num_read, NULL))
2349 if (fdinfo->lookahead[0] != '\n')
2351 bufstart[0] = fdinfo->lookahead[0];
2352 fdinfo->lookahead[0] = '\n';
2356 bufstart[1] = fdinfo->lookahead[1];
2357 fdinfo->lookahead[1] = '\n';
2360 if(count>1+utf16 && ReadFile(hand, bufstart+1+utf16, count-1-utf16, &num_read, NULL))
2361 num_read += 1+utf16;
2366 if(utf16 && (num_read&1))
2368 /* msvcr90 uses uninitialized value from the buffer in this case */
2369 /* msvcrt ignores additional data */
2370 ERR("got odd number of bytes in UTF16 mode\n");
2374 if (count != 0 && num_read == 0)
2376 fdinfo->wxflag |= WX_ATEOF;
2377 TRACE(":EOF %s\n",debugstr_an(buf,num_read));
2379 else if (fdinfo->wxflag & WX_TEXT)
2383 if (bufstart[0]=='\n' && (!utf16 || bufstart[1]==0))
2384 fdinfo->wxflag |= WX_READNL;
2386 fdinfo->wxflag &= ~WX_READNL;
2388 for (i=0, j=0; i<num_read; i+=1+utf16)
2390 /* in text mode, a ctrl-z signals EOF */
2391 if (bufstart[i]==0x1a && (!utf16 || bufstart[i+1]==0))
2393 fdinfo->wxflag |= WX_ATEOF;
2394 TRACE(":^Z EOF %s\n",debugstr_an(buf,num_read));
2398 /* in text mode, strip \r if followed by \n */
2399 if (bufstart[i]=='\r' && (!utf16 || bufstart[i+1]==0) && i+1+utf16==num_read)
2404 lookahead[1] = '\n';
2405 if (ReadFile(hand, lookahead, 1+utf16, &len, NULL) && len)
2407 if(lookahead[0]=='\n' && (!utf16 || lookahead[1]==0) && j==0)
2409 bufstart[j++] = '\n';
2410 if(utf16) bufstart[j++] = 0;
2414 if(lookahead[0]!='\n' || (utf16 && lookahead[1]!=0))
2416 bufstart[j++] = '\r';
2417 if(utf16) bufstart[j++] = 0;
2420 if (fdinfo->wxflag & WX_PIPE)
2422 fdinfo->lookahead[0] = lookahead[0];
2423 fdinfo->lookahead[1] = lookahead[1];
2426 SetFilePointer(fdinfo->handle, -1-utf16, NULL, FILE_CURRENT);
2431 bufstart[j++] = '\r';
2432 if(utf16) bufstart[j++] = 0;
2435 else if((bufstart[i]!='\r' || (utf16 && bufstart[i+1]!=0))
2436 || (bufstart[i+1+utf16]!='\n' || (utf16 && bufstart[i+3]!=0)))
2438 bufstart[j++] = bufstart[i];
2439 if(utf16) bufstart[j++] = bufstart[i+1];
2447 if (GetLastError() == ERROR_BROKEN_PIPE)
2449 TRACE(":end-of-pipe\n");
2450 fdinfo->wxflag |= WX_ATEOF;
2455 TRACE(":failed-last error (%d)\n",GetLastError());
2461 TRACE("(%u), %s\n",num_read,debugstr_an(buf, num_read));
2465 /*********************************************************************
2468 int CDECL MSVCRT__read(int fd, void *buf, unsigned int count)
2471 num_read = read_i(fd, buf, count);
2475 /*********************************************************************
2476 * _setmode (MSVCRT.@)
2478 int CDECL MSVCRT__setmode(int fd,int mode)
2480 int ret = msvcrt_get_ioinfo(fd)->wxflag & WX_TEXT ? MSVCRT__O_TEXT : MSVCRT__O_BINARY;
2481 if(ret==MSVCRT__O_TEXT && (msvcrt_get_ioinfo(fd)->exflag & (EF_UTF8|EF_UTF16)))
2482 ret = MSVCRT__O_WTEXT;
2484 if(mode!=MSVCRT__O_TEXT && mode!=MSVCRT__O_BINARY && mode!=MSVCRT__O_WTEXT
2485 && mode!=MSVCRT__O_U16TEXT && mode!=MSVCRT__O_U8TEXT) {
2486 *MSVCRT__errno() = MSVCRT_EINVAL;
2490 if(mode == MSVCRT__O_BINARY) {
2491 msvcrt_get_ioinfo(fd)->wxflag &= ~WX_TEXT;
2492 msvcrt_get_ioinfo(fd)->exflag &= ~(EF_UTF8|EF_UTF16);
2496 msvcrt_get_ioinfo(fd)->wxflag |= WX_TEXT;
2497 if(mode == MSVCRT__O_TEXT)
2498 msvcrt_get_ioinfo(fd)->exflag &= ~(EF_UTF8|EF_UTF16);
2499 else if(mode == MSVCRT__O_U8TEXT)
2500 msvcrt_get_ioinfo(fd)->exflag = (msvcrt_get_ioinfo(fd)->exflag & ~EF_UTF16) | EF_UTF8;
2502 msvcrt_get_ioinfo(fd)->exflag = (msvcrt_get_ioinfo(fd)->exflag & ~EF_UTF8) | EF_UTF16;
2507 /*********************************************************************
2508 * _stat64 (MSVCRT.@)
2510 int CDECL MSVCRT_stat64(const char* path, struct MSVCRT__stat64 * buf)
2513 WIN32_FILE_ATTRIBUTE_DATA hfi;
2514 unsigned short mode = ALL_S_IREAD;
2517 TRACE(":file (%s) buf(%p)\n",path,buf);
2519 plen = strlen(path);
2520 while (plen && path[plen-1]==' ')
2523 if (plen && (path[plen-1]=='\\' || path[plen-1]=='/'))
2525 *MSVCRT__errno() = MSVCRT_ENOENT;
2529 if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
2531 TRACE("failed (%d)\n",GetLastError());
2532 *MSVCRT__errno() = MSVCRT_ENOENT;
2536 memset(buf,0,sizeof(struct MSVCRT__stat64));
2538 /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
2539 Bon 011120: This FIXME seems incorrect
2540 Also a letter as first char isn't enough to be classified
2543 if (isalpha(*path)&& (*(path+1)==':'))
2544 buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
2546 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
2548 /* Dir, or regular file? */
2549 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2550 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
2553 mode |= MSVCRT__S_IFREG;
2555 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
2557 unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
2558 (tolower(path[plen-3]) << 16);
2559 if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
2560 mode |= ALL_S_IEXEC;
2564 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
2565 mode |= ALL_S_IWRITE;
2567 buf->st_mode = mode;
2569 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
2570 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
2572 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
2573 buf->st_mtime = buf->st_ctime = dw;
2574 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
2575 (int)(buf->st_size >> 32),(int)buf->st_size,
2576 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
2580 /*********************************************************************
2581 * _stati64 (MSVCRT.@)
2583 int CDECL MSVCRT_stati64(const char* path, struct MSVCRT__stati64 * buf)
2586 struct MSVCRT__stat64 buf64;
2588 ret = MSVCRT_stat64(path, &buf64);
2590 msvcrt_stat64_to_stati64(&buf64, buf);
2594 /*********************************************************************
2597 int CDECL MSVCRT_stat(const char* path, struct MSVCRT__stat * buf)
2599 struct MSVCRT__stat64 buf64;
2601 ret = MSVCRT_stat64( path, &buf64);
2603 msvcrt_stat64_to_stat(&buf64, buf);
2607 /*********************************************************************
2608 * _wstat64 (MSVCRT.@)
2610 int CDECL MSVCRT__wstat64(const MSVCRT_wchar_t* path, struct MSVCRT__stat64 * buf)
2613 WIN32_FILE_ATTRIBUTE_DATA hfi;
2614 unsigned short mode = ALL_S_IREAD;
2617 TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
2619 plen = strlenW(path);
2620 while (plen && path[plen-1]==' ')
2623 if(plen && (path[plen-1]=='\\' || path[plen-1]=='/'))
2625 *MSVCRT__errno() = MSVCRT_ENOENT;
2629 if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
2631 TRACE("failed (%d)\n",GetLastError());
2632 *MSVCRT__errno() = MSVCRT_ENOENT;
2636 memset(buf,0,sizeof(struct MSVCRT__stat64));
2638 /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
2639 if (MSVCRT_iswalpha(*path))
2640 buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
2642 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
2644 /* Dir, or regular file? */
2645 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2646 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
2649 mode |= MSVCRT__S_IFREG;
2651 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
2653 ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
2654 ((ULONGLONG)tolowerW(path[plen-3]) << 32);
2655 if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
2656 mode |= ALL_S_IEXEC;
2660 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
2661 mode |= ALL_S_IWRITE;
2663 buf->st_mode = mode;
2665 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
2666 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
2668 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
2669 buf->st_mtime = buf->st_ctime = dw;
2670 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
2671 (int)(buf->st_size >> 32),(int)buf->st_size,
2672 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
2676 /*********************************************************************
2677 * _wstati64 (MSVCRT.@)
2679 int CDECL MSVCRT__wstati64(const MSVCRT_wchar_t* path, struct MSVCRT__stati64 * buf)
2682 struct MSVCRT__stat64 buf64;
2684 ret = MSVCRT__wstat64(path, &buf64);
2686 msvcrt_stat64_to_stati64(&buf64, buf);
2690 /*********************************************************************
2693 int CDECL MSVCRT__wstat(const MSVCRT_wchar_t* path, struct MSVCRT__stat * buf)
2696 struct MSVCRT__stat64 buf64;
2698 ret = MSVCRT__wstat64( path, &buf64 );
2699 if (!ret) msvcrt_stat64_to_stat(&buf64, buf);
2703 /*********************************************************************
2706 MSVCRT_long CDECL MSVCRT__tell(int fd)
2708 return MSVCRT__lseek(fd, 0, SEEK_CUR);
2711 /*********************************************************************
2712 * _telli64 (MSVCRT.@)
2714 __int64 CDECL _telli64(int fd)
2716 return MSVCRT__lseeki64(fd, 0, SEEK_CUR);
2719 /*********************************************************************
2720 * _tempnam (MSVCRT.@)
2722 char * CDECL MSVCRT__tempnam(const char *dir, const char *prefix)
2724 char tmpbuf[MAX_PATH];
2725 const char *tmp_dir = MSVCRT_getenv("TMP");
2727 if (tmp_dir) dir = tmp_dir;
2729 TRACE("dir (%s) prefix (%s)\n",dir,prefix);
2730 if (GetTempFileNameA(dir,prefix,0,tmpbuf))
2732 TRACE("got name (%s)\n",tmpbuf);
2733 DeleteFileA(tmpbuf);
2734 return MSVCRT__strdup(tmpbuf);
2736 TRACE("failed (%d)\n",GetLastError());
2740 /*********************************************************************
2741 * _wtempnam (MSVCRT.@)
2743 MSVCRT_wchar_t * CDECL MSVCRT__wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
2745 static const MSVCRT_wchar_t tmpW[] = {'T','M','P',0};
2746 MSVCRT_wchar_t tmpbuf[MAX_PATH];
2747 const MSVCRT_wchar_t *tmp_dir = MSVCRT__wgetenv(tmpW);
2749 if (tmp_dir) dir = tmp_dir;
2751 TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
2752 if (GetTempFileNameW(dir,prefix,0,tmpbuf))
2754 TRACE("got name (%s)\n",debugstr_w(tmpbuf));
2755 DeleteFileW(tmpbuf);
2756 return MSVCRT__wcsdup(tmpbuf);
2758 TRACE("failed (%d)\n",GetLastError());
2762 /*********************************************************************
2765 int CDECL MSVCRT__umask(int umask)
2767 int old_umask = MSVCRT_umask;
2768 TRACE("(%d)\n",umask);
2769 MSVCRT_umask = umask;
2773 /*********************************************************************
2774 * _utime64 (MSVCRT.@)
2776 int CDECL _utime64(const char* path, struct MSVCRT___utimbuf64 *t)
2778 int fd = MSVCRT__open(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
2782 int retVal = _futime64(fd, t);
2789 /*********************************************************************
2790 * _utime32 (MSVCRT.@)
2792 int CDECL _utime32(const char* path, struct MSVCRT___utimbuf32 *t)
2796 struct MSVCRT___utimbuf64 t64;
2797 t64.actime = t->actime;
2798 t64.modtime = t->modtime;
2799 return _utime64( path, &t64 );
2802 return _utime64( path, NULL );
2805 /*********************************************************************
2809 int CDECL _utime(const char* path, struct MSVCRT___utimbuf64 *t)
2811 return _utime64( path, t );
2814 int CDECL _utime(const char* path, struct MSVCRT___utimbuf32 *t)
2816 return _utime32( path, t );
2820 /*********************************************************************
2821 * _wutime64 (MSVCRT.@)
2823 int CDECL _wutime64(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
2825 int fd = MSVCRT__wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
2829 int retVal = _futime64(fd, t);
2836 /*********************************************************************
2837 * _wutime32 (MSVCRT.@)
2839 int CDECL _wutime32(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
2843 struct MSVCRT___utimbuf64 t64;
2844 t64.actime = t->actime;
2845 t64.modtime = t->modtime;
2846 return _wutime64( path, &t64 );
2849 return _wutime64( path, NULL );
2852 /*********************************************************************
2853 * _wutime (MSVCRT.@)
2856 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
2858 return _wutime64( path, t );
2861 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
2863 return _wutime32( path, t );
2867 /*********************************************************************
2870 int CDECL MSVCRT__write(int fd, const void* buf, unsigned int count)
2873 ioinfo *info = msvcrt_get_ioinfo(fd);
2874 HANDLE hand = info->handle;
2876 /* Don't trace small writes, it gets *very* annoying */
2879 TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
2881 if (hand == INVALID_HANDLE_VALUE)
2883 *MSVCRT__errno() = MSVCRT_EBADF;
2887 if (((info->exflag&EF_UTF8) || (info->exflag&EF_UTF16)) && count&1)
2889 *MSVCRT__errno() = MSVCRT_EINVAL;
2893 /* If appending, go to EOF */
2894 if (info->wxflag & WX_APPEND)
2895 MSVCRT__lseek(fd, 0, FILE_END);
2897 if (!(info->wxflag & WX_TEXT))
2899 if (WriteFile(hand, buf, count, &num_written, NULL)
2900 && (num_written == count))
2902 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d)\n", fd,
2903 hand, GetLastError());
2904 *MSVCRT__errno() = MSVCRT_ENOSPC;
2908 unsigned int i, j, nr_lf, size;
2911 const char *s = buf, *buf_start = buf;
2913 if (!(info->exflag & (EF_UTF8|EF_UTF16)))
2915 /* find number of \n */
2916 for (nr_lf=0, i=0; i<count; i++)
2922 if ((q = p = MSVCRT_malloc(size)))
2924 for (s = buf, i = 0, j = 0; i < count; i++)
2933 FIXME("Malloc failed\n");
2945 else if (info->exflag & EF_UTF16)
2947 for (nr_lf=0, i=0; i<count; i+=2)
2948 if (s[i]=='\n' && s[i+1]==0)
2953 if ((q = p = MSVCRT_malloc(size)))
2955 for (s=buf, i=0, j=0; i<count; i++)
2957 if (s[i]=='\n' && s[i+1]==0)
2968 FIXME("Malloc failed\n");
2984 for(nr_lf=0, i=0; i<count; i+=2)
2985 if (s[i]=='\n' && s[i+1]==0)
2988 conv_len = WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)buf, count/2, NULL, 0, NULL, NULL);
2990 msvcrt_set_errno(GetLastError());
2995 size = conv_len+nr_lf;
2996 if((p = MSVCRT_malloc(count+nr_lf*2+size)))
2998 for (s=buf, i=0, j=0; i<count; i++)
3000 if (s[i]=='\n' && s[i+1]==0)
3008 q = p+count+nr_lf*2;
3009 WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)p, count/2+nr_lf,
3010 p+count+nr_lf*2, conv_len+nr_lf, NULL, NULL);
3014 FIXME("Malloc failed\n");
3021 if (!WriteFile(hand, q, size, &num_written, NULL))
3025 if (num_written != size)
3027 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d), num_written %d\n",
3028 fd, hand, GetLastError(), num_written);
3029 *MSVCRT__errno() = MSVCRT_ENOSPC;
3030 return s - buf_start;
3038 /*********************************************************************
3041 int CDECL MSVCRT__putw(int val, MSVCRT_FILE* file)
3045 MSVCRT__lock_file(file);
3046 len = MSVCRT__write(file->_file, &val, sizeof(val));
3047 if (len == sizeof(val)) {
3048 MSVCRT__unlock_file(file);
3052 file->_flag |= MSVCRT__IOERR;
3053 MSVCRT__unlock_file(file);
3057 /*********************************************************************
3060 int CDECL MSVCRT_fclose(MSVCRT_FILE* file)
3064 MSVCRT__lock_file(file);
3066 MSVCRT_free(file->_tmpfname);
3067 file->_tmpfname = NULL;
3068 /* flush stdio buffers */
3069 if(file->_flag & MSVCRT__IOWRT)
3070 MSVCRT_fflush(file);
3071 if(file->_flag & MSVCRT__IOMYBUF)
3072 MSVCRT_free(file->_base);
3074 r=MSVCRT__close(file->_file);
3077 MSVCRT__unlock_file(file);
3079 return ((r == -1) || (flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
3082 /*********************************************************************
3085 int CDECL MSVCRT_feof(MSVCRT_FILE* file)
3087 return file->_flag & MSVCRT__IOEOF;
3090 /*********************************************************************
3093 int CDECL MSVCRT_ferror(MSVCRT_FILE* file)
3095 return file->_flag & MSVCRT__IOERR;
3098 /*********************************************************************
3099 * _filbuf (MSVCRT.@)
3101 int CDECL MSVCRT__filbuf(MSVCRT_FILE* file)
3104 MSVCRT__lock_file(file);
3106 /* Allocate buffer if needed */
3107 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF))
3108 msvcrt_alloc_buffer(file);
3110 if(!(file->_flag & MSVCRT__IOREAD)) {
3111 if(file->_flag & MSVCRT__IORW)
3112 file->_flag |= MSVCRT__IOREAD;
3114 MSVCRT__unlock_file(file);
3119 if(file->_flag & MSVCRT__IONBF) {
3121 if ((r = read_i(file->_file,&c,1)) != 1) {
3122 file->_flag |= (r == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
3123 MSVCRT__unlock_file(file);
3127 MSVCRT__unlock_file(file);
3130 file->_cnt = read_i(file->_file, file->_base, file->_bufsiz);
3132 file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
3134 MSVCRT__unlock_file(file);
3139 file->_ptr = file->_base+1;
3140 c = *(unsigned char *)file->_base;
3141 MSVCRT__unlock_file(file);
3146 /*********************************************************************
3149 int CDECL MSVCRT_fgetc(MSVCRT_FILE* file)
3154 MSVCRT__lock_file(file);
3157 i = (unsigned char *)file->_ptr++;
3160 j = MSVCRT__filbuf(file);
3162 MSVCRT__unlock_file(file);
3166 /*********************************************************************
3167 * _fgetchar (MSVCRT.@)
3169 int CDECL MSVCRT__fgetchar(void)
3171 return MSVCRT_fgetc(MSVCRT_stdin);
3174 /*********************************************************************
3177 char * CDECL MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
3179 int cc = MSVCRT_EOF;
3180 char * buf_start = s;
3182 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3183 file,file->_file,s,size);
3185 MSVCRT__lock_file(file);
3187 while ((size >1) && (cc = MSVCRT_fgetc(file)) != MSVCRT_EOF && cc != '\n')
3192 if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
3194 TRACE(":nothing read\n");
3195 MSVCRT__unlock_file(file);
3198 if ((cc != MSVCRT_EOF) && (size > 1))
3201 TRACE(":got %s\n", debugstr_a(buf_start));
3202 MSVCRT__unlock_file(file);
3206 /*********************************************************************
3209 MSVCRT_wint_t CDECL MSVCRT_fgetwc(MSVCRT_FILE* file)
3214 MSVCRT__lock_file(file);
3216 if((msvcrt_get_ioinfo(file->_file)->exflag & (EF_UTF8 | EF_UTF16))
3217 || !(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT)) {
3220 for(p=(char*)&ret; (MSVCRT_wint_t*)p<&ret+1; p++) {
3221 ch = MSVCRT_fgetc(file);
3222 if(ch == MSVCRT_EOF) {
3229 char mbs[MSVCRT_MB_LEN_MAX];
3232 ch = MSVCRT_fgetc(file);
3233 if(ch != MSVCRT_EOF) {
3235 if(MSVCRT_isleadbyte((unsigned char)mbs[0])) {
3236 ch = MSVCRT_fgetc(file);
3237 if(ch != MSVCRT_EOF) {
3246 if(!len || MSVCRT_mbtowc(&ret, mbs, len)==-1)
3250 MSVCRT__unlock_file(file);
3254 /*********************************************************************
3257 int CDECL MSVCRT__getw(MSVCRT_FILE* file)
3264 MSVCRT__lock_file(file);
3265 for (j=0; j<sizeof(int); j++) {
3266 k = MSVCRT_fgetc(file);
3267 if (k == MSVCRT_EOF) {
3268 file->_flag |= MSVCRT__IOEOF;
3269 MSVCRT__unlock_file(file);
3275 MSVCRT__unlock_file(file);
3279 /*********************************************************************
3282 MSVCRT_wint_t CDECL MSVCRT_getwc(MSVCRT_FILE* file)
3284 return MSVCRT_fgetwc(file);
3287 /*********************************************************************
3288 * _fgetwchar (MSVCRT.@)
3290 MSVCRT_wint_t CDECL MSVCRT__fgetwchar(void)
3292 return MSVCRT_fgetwc(MSVCRT_stdin);
3295 /*********************************************************************
3296 * getwchar (MSVCRT.@)
3298 MSVCRT_wint_t CDECL MSVCRT_getwchar(void)
3300 return MSVCRT__fgetwchar();
3303 /*********************************************************************
3306 MSVCRT_wchar_t * CDECL MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
3308 MSVCRT_wint_t cc = MSVCRT_WEOF;
3309 MSVCRT_wchar_t * buf_start = s;
3311 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3312 file,file->_file,s,size);
3314 MSVCRT__lock_file(file);
3316 while ((size >1) && (cc = MSVCRT_fgetwc(file)) != MSVCRT_WEOF && cc != '\n')
3321 if ((cc == MSVCRT_WEOF) && (s == buf_start)) /* If nothing read, return 0*/
3323 TRACE(":nothing read\n");
3324 MSVCRT__unlock_file(file);
3327 if ((cc != MSVCRT_WEOF) && (size > 1))
3330 TRACE(":got %s\n", debugstr_w(buf_start));
3331 MSVCRT__unlock_file(file);
3335 /*********************************************************************
3338 MSVCRT_size_t CDECL MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
3340 MSVCRT_size_t wrcnt=size * nmemb;
3345 MSVCRT__lock_file(file);
3347 int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
3348 memcpy(file->_ptr, ptr, pcnt);
3353 ptr = (const char*)ptr + pcnt;
3354 } else if(!(file->_flag & MSVCRT__IOWRT)) {
3355 if(file->_flag & MSVCRT__IORW) {
3356 file->_flag |= MSVCRT__IOWRT;
3358 MSVCRT__unlock_file(file);
3365 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF))
3366 msvcrt_alloc_buffer(file);
3369 res=msvcrt_flush_buffer(file);
3371 int pwritten = MSVCRT__write(file->_file, ptr, wrcnt);
3374 file->_flag |= MSVCRT__IOERR;
3377 written += pwritten;
3381 MSVCRT__unlock_file(file);
3382 return written / size;
3385 /*********************************************************************
3388 MSVCRT_wint_t CDECL MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
3390 MSVCRT_wchar_t mwc=wc;
3394 MSVCRT__lock_file(file);
3395 fdinfo = msvcrt_get_ioinfo(file->_file);
3397 if((fdinfo->wxflag&WX_TEXT) && !(fdinfo->exflag&(EF_UTF8|EF_UTF16))) {
3398 char buf[MSVCRT_MB_LEN_MAX];
3401 char_len = MSVCRT_wctomb(buf, mwc);
3402 if(char_len!=-1 && MSVCRT_fwrite(buf, char_len, 1, file)==1)
3406 }else if(MSVCRT_fwrite(&mwc, sizeof(mwc), 1, file) == 1) {
3412 MSVCRT__unlock_file(file);
3416 /*********************************************************************
3417 * _fputwchar (MSVCRT.@)
3419 MSVCRT_wint_t CDECL MSVCRT__fputwchar(MSVCRT_wint_t wc)
3421 return MSVCRT_fputwc(wc, MSVCRT_stdout);
3424 /*********************************************************************
3425 * _wfsopen (MSVCRT.@)
3427 MSVCRT_FILE * CDECL MSVCRT__wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
3430 int open_flags, stream_flags, fd;
3432 TRACE("(%s,%s)\n", debugstr_w(path), debugstr_w(mode));
3434 /* map mode string to open() flags. "man fopen" for possibilities. */
3435 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
3439 fd = MSVCRT__wsopen(path, open_flags, share, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
3442 else if ((file = msvcrt_alloc_fp()) && msvcrt_init_fp(file, fd, stream_flags)
3444 TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
3451 TRACE(":got (%p)\n",file);
3452 if (fd >= 0 && !file)
3458 /*********************************************************************
3459 * _fsopen (MSVCRT.@)
3461 MSVCRT_FILE * CDECL MSVCRT__fsopen(const char *path, const char *mode, int share)
3464 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
3466 if (path && !(pathW = msvcrt_wstrdupa(path))) {
3467 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
3468 *MSVCRT__errno() = MSVCRT_EINVAL;
3471 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
3474 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
3475 *MSVCRT__errno() = MSVCRT_EINVAL;
3479 ret = MSVCRT__wfsopen(pathW, modeW, share);
3486 /*********************************************************************
3489 MSVCRT_FILE * CDECL MSVCRT_fopen(const char *path, const char *mode)
3491 return MSVCRT__fsopen( path, mode, MSVCRT__SH_DENYNO );
3494 /*********************************************************************
3495 * fopen_s (MSVCRT.@)
3497 int CDECL MSVCRT_fopen_s(MSVCRT_FILE** pFile,
3498 const char *filename, const char *mode)
3500 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3501 if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
3502 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3504 *pFile = MSVCRT_fopen(filename, mode);
3507 return *MSVCRT__errno();
3511 /*********************************************************************
3512 * _wfopen (MSVCRT.@)
3514 MSVCRT_FILE * CDECL MSVCRT__wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
3516 return MSVCRT__wfsopen( path, mode, MSVCRT__SH_DENYNO );
3519 /*********************************************************************
3520 * _wfopen_s (MSVCRT.@)
3522 int CDECL MSVCRT__wfopen_s(MSVCRT_FILE** pFile, const MSVCRT_wchar_t *filename,
3523 const MSVCRT_wchar_t *mode)
3525 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3526 if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
3527 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3529 *pFile = MSVCRT__wfopen(filename, mode);
3532 return *MSVCRT__errno();
3536 /*********************************************************************
3537 * _flsbuf (MSVCRT.@)
3539 int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
3541 /* Flush output buffer */
3542 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
3543 msvcrt_alloc_buffer(file);
3545 if(!(file->_flag & MSVCRT__IOWRT)) {
3546 if(file->_flag & MSVCRT__IORW)
3547 file->_flag |= MSVCRT__IOWRT;
3555 res = msvcrt_flush_buffer(file);
3559 res = msvcrt_flush_buffer(file);
3562 return res ? res : c&0xff;
3566 /* set _cnt to 0 for unbuffered FILEs */
3568 len = MSVCRT__write(file->_file, &cc, 1);
3571 file->_flag |= MSVCRT__IOERR;
3576 /*********************************************************************
3579 int CDECL MSVCRT_fputc(int c, MSVCRT_FILE* file)
3583 MSVCRT__lock_file(file);
3589 res = msvcrt_flush_buffer(file);
3590 MSVCRT__unlock_file(file);
3591 return res ? res : c;
3594 MSVCRT__unlock_file(file);
3598 res = MSVCRT__flsbuf(c, file);
3599 MSVCRT__unlock_file(file);
3604 /*********************************************************************
3605 * _fputchar (MSVCRT.@)
3607 int CDECL MSVCRT__fputchar(int c)
3609 return MSVCRT_fputc(c, MSVCRT_stdout);
3612 /*********************************************************************
3615 MSVCRT_size_t CDECL MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
3617 MSVCRT_size_t rcnt=size * nmemb;
3618 MSVCRT_size_t read=0;
3624 MSVCRT__lock_file(file);
3626 /* first buffered data */
3628 int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
3629 memcpy(ptr, file->_ptr, pcnt);
3634 ptr = (char*)ptr + pcnt;
3635 } else if(!(file->_flag & MSVCRT__IOREAD )) {
3636 if(file->_flag & MSVCRT__IORW) {
3637 file->_flag |= MSVCRT__IOREAD;
3639 MSVCRT__unlock_file(file);
3646 if (!file->_cnt && rcnt<MSVCRT_BUFSIZ && !(file->_flag & MSVCRT__IONBF)
3647 && (file->_bufsiz != 0 || msvcrt_alloc_buffer(file))) {
3648 file->_cnt = MSVCRT__read(file->_file, file->_base, file->_bufsiz);
3649 file->_ptr = file->_base;
3650 i = (file->_cnt<rcnt) ? file->_cnt : rcnt;
3651 /* If the buffer fill reaches eof but fread wouldn't, clear eof. */
3652 if (i > 0 && i < file->_cnt) {
3653 msvcrt_get_ioinfo(file->_file)->wxflag &= ~WX_ATEOF;
3654 file->_flag &= ~MSVCRT__IOEOF;
3657 memcpy(ptr, file->_ptr, i);
3661 } else if (rcnt > UINT_MAX) {
3662 i = MSVCRT__read(file->_file, ptr, UINT_MAX);
3663 } else if (rcnt < MSVCRT_BUFSIZ) {
3664 i = MSVCRT__read(file->_file, ptr, rcnt);
3666 i = MSVCRT__read(file->_file, ptr, rcnt - MSVCRT_BUFSIZ/2);
3670 ptr = (char *)ptr+i;
3671 /* expose feof condition in the flags
3672 * MFC tests file->_flag for feof, and doesn't call feof())
3674 if (msvcrt_get_ioinfo(file->_file)->wxflag & WX_ATEOF)
3675 file->_flag |= MSVCRT__IOEOF;
3678 file->_flag |= MSVCRT__IOERR;
3685 MSVCRT__unlock_file(file);
3690 /* fread_s - not exported in native msvcrt */
3691 MSVCRT_size_t CDECL fread_s(void *buf, MSVCRT_size_t buf_size, MSVCRT_size_t elem_size,
3692 MSVCRT_size_t count, MSVCRT_FILE *stream)
3694 size_t bytes_left, buf_pos;
3696 TRACE("(%p %lu %lu %lu %p\n", buf, buf_size, elem_size, count, stream);
3698 if(!MSVCRT_CHECK_PMT(stream != NULL)) {
3700 memset(buf, 0, buf_size);
3703 if(!elem_size || !count) return 0;
3704 if(!MSVCRT_CHECK_PMT(buf != NULL)) return 0;
3705 if(!MSVCRT_CHECK_PMT(MSVCRT_SIZE_MAX/count >= elem_size)) return 0;
3707 bytes_left = elem_size*count;
3710 if(stream->_cnt > 0) {
3711 size_t size = bytes_left<stream->_cnt ? bytes_left : stream->_cnt;
3713 if(!MSVCRT_CHECK_PMT_ERR(size <= buf_size-buf_pos, MSVCRT_ERANGE)) {
3714 memset(buf, 0, buf_size);
3718 MSVCRT_fread((char*)buf+buf_pos, 1, size, stream);
3722 int c = MSVCRT__filbuf(stream);
3727 if(!MSVCRT_CHECK_PMT_ERR(buf_size-buf_pos > 0, MSVCRT_ERANGE)) {
3728 memset(buf, 0, buf_size);
3732 ((char*)buf)[buf_pos++] = c;
3737 return buf_pos/elem_size;
3740 /*********************************************************************
3741 * _wfreopen (MSVCRT.@)
3744 MSVCRT_FILE* CDECL MSVCRT__wfreopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, MSVCRT_FILE* file)
3748 TRACE(":path (%s) mode (%s) file (%p) fd (%d)\n", debugstr_w(path), debugstr_w(mode), file, file->_file);
3751 if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
3755 MSVCRT_fclose(file);
3756 file = MSVCRT__wfsopen(path, mode, MSVCRT__SH_DENYNO);
3762 /*********************************************************************
3763 * _wfreopen_s (MSVCRT.@)
3765 int CDECL MSVCRT__wfreopen_s(MSVCRT_FILE** pFile,
3766 const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, MSVCRT_FILE* file)
3768 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3769 if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
3770 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3771 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
3773 *pFile = MSVCRT__wfreopen(path, mode, file);
3776 return *MSVCRT__errno();
3780 /*********************************************************************
3781 * freopen (MSVCRT.@)
3784 MSVCRT_FILE* CDECL MSVCRT_freopen(const char *path, const char *mode, MSVCRT_FILE* file)
3787 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
3789 if (path && !(pathW = msvcrt_wstrdupa(path))) return NULL;
3790 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
3796 ret = MSVCRT__wfreopen(pathW, modeW, file);
3803 /*********************************************************************
3804 * freopen_s (MSVCRT.@)
3806 int CDECL MSVCRT_freopen_s(MSVCRT_FILE** pFile,
3807 const char *path, const char *mode, MSVCRT_FILE* file)
3809 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3810 if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
3811 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3812 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
3814 *pFile = MSVCRT_freopen(path, mode, file);
3817 return *MSVCRT__errno();
3821 /*********************************************************************
3822 * fsetpos (MSVCRT.@)
3824 int CDECL MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
3828 MSVCRT__lock_file(file);
3829 /* Note that all this has been lifted 'as is' from fseek */
3830 if(file->_flag & MSVCRT__IOWRT)
3831 msvcrt_flush_buffer(file);
3833 /* Discard buffered input */
3835 file->_ptr = file->_base;
3837 /* Reset direction of i/o */
3838 if(file->_flag & MSVCRT__IORW) {
3839 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
3842 ret = (MSVCRT__lseeki64(file->_file,*pos,SEEK_SET) == -1) ? -1 : 0;
3843 MSVCRT__unlock_file(file);
3847 /*********************************************************************
3848 * _ftelli64 (MSVCRT.@)
3850 __int64 CDECL MSVCRT__ftelli64(MSVCRT_FILE* file)
3854 MSVCRT__lock_file(file);
3855 pos = _telli64(file->_file);
3857 MSVCRT__unlock_file(file);
3861 if(file->_flag & MSVCRT__IOWRT) {
3862 pos += file->_ptr - file->_base;
3864 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT) {
3867 for(p=file->_base; p<file->_ptr; p++)
3871 } else if(!file->_cnt) { /* nothing to do */
3872 } else if(MSVCRT__lseeki64(file->_file, 0, SEEK_END)==pos) {
3876 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT) {
3877 for(i=0; i<file->_cnt; i++)
3878 if(file->_ptr[i] == '\n')
3884 if(MSVCRT__lseeki64(file->_file, pos, SEEK_SET) != pos) {
3885 MSVCRT__unlock_file(file);
3889 pos -= file->_bufsiz;
3890 pos += file->_ptr - file->_base;
3892 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT) {
3893 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_READNL)
3896 for(p=file->_base; p<file->_ptr; p++)
3903 MSVCRT__unlock_file(file);
3907 /*********************************************************************
3910 LONG CDECL MSVCRT_ftell(MSVCRT_FILE* file)
3912 return MSVCRT__ftelli64(file);
3915 /*********************************************************************
3916 * fgetpos (MSVCRT.@)
3918 int CDECL MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
3920 *pos = MSVCRT__ftelli64(file);
3926 /*********************************************************************
3929 int CDECL MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
3931 MSVCRT_size_t len = strlen(s);
3934 MSVCRT__lock_file(file);
3935 ret = MSVCRT_fwrite(s, sizeof(*s), len, file) == len ? 0 : MSVCRT_EOF;
3936 MSVCRT__unlock_file(file);
3940 /*********************************************************************
3943 int CDECL MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
3945 MSVCRT_size_t i, len = strlenW(s);
3949 MSVCRT__lock_file(file);
3950 if (!(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT)) {
3951 ret = MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
3952 MSVCRT__unlock_file(file);
3956 tmp_buf = add_std_buffer(file);
3957 for (i=0; i<len; i++) {
3958 if(MSVCRT_fputwc(s[i], file) == MSVCRT_WEOF) {
3959 if(tmp_buf) remove_std_buffer(file);
3960 MSVCRT__unlock_file(file);
3965 if(tmp_buf) remove_std_buffer(file);
3966 MSVCRT__unlock_file(file);
3970 /*********************************************************************
3971 * getchar (MSVCRT.@)
3973 int CDECL MSVCRT_getchar(void)
3975 return MSVCRT_fgetc(MSVCRT_stdin);
3978 /*********************************************************************
3981 int CDECL MSVCRT_getc(MSVCRT_FILE* file)
3983 return MSVCRT_fgetc(file);
3986 /*********************************************************************
3989 char * CDECL MSVCRT_gets(char *buf)
3992 char * buf_start = buf;
3994 MSVCRT__lock_file(MSVCRT_stdin);
3995 for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
3996 cc = MSVCRT_fgetc(MSVCRT_stdin))
3997 if(cc != '\r') *buf++ = (char)cc;
4001 TRACE("got '%s'\n", buf_start);
4002 MSVCRT__unlock_file(MSVCRT_stdin);
4006 /*********************************************************************
4009 MSVCRT_wchar_t* CDECL MSVCRT__getws(MSVCRT_wchar_t* buf)
4012 MSVCRT_wchar_t* ws = buf;
4014 MSVCRT__lock_file(MSVCRT_stdin);
4015 for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
4016 cc = MSVCRT_fgetwc(MSVCRT_stdin))
4019 *buf++ = (MSVCRT_wchar_t)cc;
4023 TRACE("got %s\n", debugstr_w(ws));
4024 MSVCRT__unlock_file(MSVCRT_stdin);
4028 /*********************************************************************
4031 int CDECL MSVCRT_putc(int c, MSVCRT_FILE* file)
4033 return MSVCRT_fputc(c, file);
4036 /*********************************************************************
4037 * putchar (MSVCRT.@)
4039 int CDECL MSVCRT_putchar(int c)
4041 return MSVCRT_fputc(c, MSVCRT_stdout);
4044 /*********************************************************************
4045 * _putwch (MSVCRT.@)
4047 int CDECL MSVCRT__putwch(int c)
4049 return MSVCRT_fputwc(c, MSVCRT_stdout);
4052 /*********************************************************************
4055 int CDECL MSVCRT_puts(const char *s)
4057 MSVCRT_size_t len = strlen(s);
4060 MSVCRT__lock_file(MSVCRT_stdout);
4061 if(MSVCRT_fwrite(s, sizeof(*s), len, MSVCRT_stdout) != len) {
4062 MSVCRT__unlock_file(MSVCRT_stdout);
4066 ret = MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
4067 MSVCRT__unlock_file(MSVCRT_stdout);
4071 /*********************************************************************
4074 int CDECL MSVCRT__putws(const MSVCRT_wchar_t *s)
4076 static const MSVCRT_wchar_t nl = '\n';
4077 MSVCRT_size_t len = strlenW(s);
4080 MSVCRT__lock_file(MSVCRT_stdout);
4081 if(MSVCRT_fwrite(s, sizeof(*s), len, MSVCRT_stdout) != len) {
4082 MSVCRT__unlock_file(MSVCRT_stdout);
4086 ret = MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
4087 MSVCRT__unlock_file(MSVCRT_stdout);
4091 /*********************************************************************
4094 int CDECL MSVCRT_remove(const char *path)
4096 TRACE("(%s)\n",path);
4097 if (DeleteFileA(path))
4099 TRACE(":failed (%d)\n",GetLastError());
4100 msvcrt_set_errno(GetLastError());
4104 /*********************************************************************
4105 * _wremove (MSVCRT.@)
4107 int CDECL MSVCRT__wremove(const MSVCRT_wchar_t *path)
4109 TRACE("(%s)\n",debugstr_w(path));
4110 if (DeleteFileW(path))
4112 TRACE(":failed (%d)\n",GetLastError());
4113 msvcrt_set_errno(GetLastError());
4117 /*********************************************************************
4120 int CDECL MSVCRT_rename(const char *oldpath,const char *newpath)
4122 TRACE(":from %s to %s\n",oldpath,newpath);
4123 if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4125 TRACE(":failed (%d)\n",GetLastError());
4126 msvcrt_set_errno(GetLastError());
4130 /*********************************************************************
4131 * _wrename (MSVCRT.@)
4133 int CDECL MSVCRT__wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
4135 TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
4136 if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4138 TRACE(":failed (%d)\n",GetLastError());
4139 msvcrt_set_errno(GetLastError());
4143 /*********************************************************************
4144 * setvbuf (MSVCRT.@)
4146 int CDECL MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
4148 MSVCRT__lock_file(file);
4150 MSVCRT_free(file->_base);
4154 if(mode == MSVCRT__IOFBF) {
4155 file->_flag &= ~MSVCRT__IONBF;
4156 file->_base = file->_ptr = buf;
4158 file->_bufsiz = size;
4161 file->_flag |= MSVCRT__IONBF;
4163 MSVCRT__unlock_file(file);
4167 /*********************************************************************
4170 void CDECL MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
4172 MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
4175 /*********************************************************************
4178 char * CDECL MSVCRT_tmpnam(char *s)
4185 thread_data_t *data = msvcrt_get_thread_data();
4187 if(!data->tmpnam_buffer)
4188 data->tmpnam_buffer = MSVCRT_malloc(MAX_PATH);
4190 s = data->tmpnam_buffer;
4193 msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
4194 p = s + sprintf(s, "\\s%s.", tmpstr);
4195 for (count = 0; count < MSVCRT_TMP_MAX; count++)
4197 size = msvcrt_int_to_base32(tmpnam_unique++, tmpstr);
4198 memcpy(p, tmpstr, size);
4200 if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
4201 GetLastError() == ERROR_FILE_NOT_FOUND)
4207 /*********************************************************************
4208 * _wtmpnam (MSVCRT.@)
4210 MSVCRT_wchar_t * CDECL MSVCRT_wtmpnam(MSVCRT_wchar_t *s)
4212 static const MSVCRT_wchar_t format[] = {'\\','s','%','s','.',0};
4213 MSVCRT_wchar_t tmpstr[16];
4217 thread_data_t *data = msvcrt_get_thread_data();
4219 if(!data->wtmpnam_buffer)
4220 data->wtmpnam_buffer = MSVCRT_malloc(sizeof(MSVCRT_wchar_t[MAX_PATH]));
4222 s = data->wtmpnam_buffer;
4225 msvcrt_int_to_base32_w(GetCurrentProcessId(), tmpstr);
4226 p = s + MSVCRT__snwprintf(s, MAX_PATH, format, tmpstr);
4227 for (count = 0; count < MSVCRT_TMP_MAX; count++)
4229 size = msvcrt_int_to_base32_w(tmpnam_unique++, tmpstr);
4230 memcpy(p, tmpstr, size*sizeof(MSVCRT_wchar_t));
4232 if (GetFileAttributesW(s) == INVALID_FILE_ATTRIBUTES &&
4233 GetLastError() == ERROR_FILE_NOT_FOUND)
4239 /*********************************************************************
4240 * tmpfile (MSVCRT.@)
4242 MSVCRT_FILE* CDECL MSVCRT_tmpfile(void)
4244 char *filename = MSVCRT_tmpnam(NULL);
4246 MSVCRT_FILE* file = NULL;
4249 fd = MSVCRT__open(filename, MSVCRT__O_CREAT | MSVCRT__O_BINARY | MSVCRT__O_RDWR | MSVCRT__O_TEMPORARY,
4250 MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
4251 if (fd != -1 && (file = msvcrt_alloc_fp()))
4253 if (msvcrt_init_fp(file, fd, MSVCRT__IORW) == -1)
4258 else file->_tmpfname = MSVCRT__strdup(filename);
4261 if(fd != -1 && !file)
4267 /*********************************************************************
4268 * tmpfile_s (MSVCRT.@)
4270 int CDECL MSVCRT_tmpfile_s(MSVCRT_FILE** file)
4272 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
4274 *file = MSVCRT_tmpfile();
4278 static int puts_clbk_file_a(void *file, int len, const char *str)
4280 return MSVCRT_fwrite(str, sizeof(char), len, file);
4283 static int puts_clbk_file_w(void *file, int len, const MSVCRT_wchar_t *str)
4287 MSVCRT__lock_file(file);
4289 if(!(msvcrt_get_ioinfo(((MSVCRT_FILE*)file)->_file)->wxflag & WX_TEXT)) {
4290 ret = MSVCRT_fwrite(str, sizeof(MSVCRT_wchar_t), len, file);
4291 MSVCRT__unlock_file(file);
4295 for(i=0; i<len; i++) {
4296 if(MSVCRT_fputwc(str[i], file) == MSVCRT_WEOF) {
4297 MSVCRT__unlock_file(file);
4302 MSVCRT__unlock_file(file);
4306 /*********************************************************************
4307 * vfprintf (MSVCRT.@)
4309 int CDECL MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, __ms_va_list valist)
4314 MSVCRT__lock_file(file);
4315 tmp_buf = add_std_buffer(file);
4316 ret = pf_printf_a(puts_clbk_file_a, file, format, NULL, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4317 if(tmp_buf) remove_std_buffer(file);
4318 MSVCRT__unlock_file(file);
4323 /*********************************************************************
4324 * vfprintf_s (MSVCRT.@)
4326 int CDECL MSVCRT_vfprintf_s(MSVCRT_FILE* file, const char *format, __ms_va_list valist)
4331 if(!MSVCRT_CHECK_PMT(file != NULL)) return -1;
4333 MSVCRT__lock_file(file);
4334 tmp_buf = add_std_buffer(file);
4335 ret = pf_printf_a(puts_clbk_file_a, file, format, NULL, FALSE, TRUE, arg_clbk_valist, NULL, &valist);
4336 if(tmp_buf) remove_std_buffer(file);
4337 MSVCRT__unlock_file(file);
4342 /*********************************************************************
4343 * vfwprintf (MSVCRT.@)
4345 int CDECL MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, __ms_va_list valist)
4350 MSVCRT__lock_file(file);
4351 tmp_buf = add_std_buffer(file);
4352 ret = pf_printf_w(puts_clbk_file_w, file, format, NULL, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4353 if(tmp_buf) remove_std_buffer(file);
4354 MSVCRT__unlock_file(file);
4359 /*********************************************************************
4360 * vfwprintf_s (MSVCRT.@)
4362 int CDECL MSVCRT_vfwprintf_s(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, __ms_va_list valist)
4367 if (!MSVCRT_CHECK_PMT( file != NULL )) return -1;
4369 MSVCRT__lock_file(file);
4370 tmp_buf = add_std_buffer(file);
4371 ret = pf_printf_w(puts_clbk_file_w, file, format, NULL, FALSE, TRUE, arg_clbk_valist, NULL, &valist);
4372 if(tmp_buf) remove_std_buffer(file);
4373 MSVCRT__unlock_file(file);
4378 /*********************************************************************
4379 * _vfwprintf_l (MSVCRT.@)
4381 int CDECL MSVCRT__vfwprintf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format,
4382 MSVCRT__locale_t locale, __ms_va_list valist)
4387 if (!MSVCRT_CHECK_PMT( file != NULL )) return -1;
4389 MSVCRT__lock_file(file);
4390 tmp_buf = add_std_buffer(file);
4391 ret = pf_printf_w(puts_clbk_file_w, file, format, locale, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4392 if(tmp_buf) remove_std_buffer(file);
4393 MSVCRT__unlock_file(file);
4398 /*********************************************************************
4399 * vprintf (MSVCRT.@)
4401 int CDECL MSVCRT_vprintf(const char *format, __ms_va_list valist)
4403 return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
4406 /*********************************************************************
4407 * vprintf_s (MSVCRT.@)
4409 int CDECL MSVCRT_vprintf_s(const char *format, __ms_va_list valist)
4411 return MSVCRT_vfprintf_s(MSVCRT_stdout,format,valist);
4414 /*********************************************************************
4415 * vwprintf (MSVCRT.@)
4417 int CDECL MSVCRT_vwprintf(const MSVCRT_wchar_t *format, __ms_va_list valist)
4419 return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
4422 /*********************************************************************
4423 * vwprintf_s (MSVCRT.@)
4425 int CDECL MSVCRT_vwprintf_s(const MSVCRT_wchar_t *format, __ms_va_list valist)
4427 return MSVCRT_vfwprintf_s(MSVCRT_stdout,format,valist);
4430 /*********************************************************************
4431 * fprintf (MSVCRT.@)
4433 int CDECL MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
4435 __ms_va_list valist;
4437 __ms_va_start(valist, format);
4438 res = MSVCRT_vfprintf(file, format, valist);
4439 __ms_va_end(valist);
4443 /*********************************************************************
4444 * fprintf_s (MSVCRT.@)
4446 int CDECL MSVCRT_fprintf_s(MSVCRT_FILE* file, const char *format, ...)
4448 __ms_va_list valist;
4450 __ms_va_start(valist, format);
4451 res = MSVCRT_vfprintf_s(file, format, valist);
4452 __ms_va_end(valist);
4456 /*********************************************************************
4457 * fwprintf (MSVCRT.@)
4459 int CDECL MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
4461 __ms_va_list valist;
4463 __ms_va_start(valist, format);
4464 res = MSVCRT_vfwprintf(file, format, valist);
4465 __ms_va_end(valist);
4469 /*********************************************************************
4470 * fwprintf_s (MSVCRT.@)
4472 int CDECL MSVCRT_fwprintf_s(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
4474 __ms_va_list valist;
4476 __ms_va_start(valist, format);
4477 res = MSVCRT_vfwprintf_s(file, format, valist);
4478 __ms_va_end(valist);
4482 /*********************************************************************
4483 * _fwprintf_l (MSVCRT.@)
4485 int CDECL MSVCRT__fwprintf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ...)
4487 __ms_va_list valist;
4489 __ms_va_start(valist, locale);
4490 res = MSVCRT__vfwprintf_l(file, format, locale, valist);
4491 __ms_va_end(valist);
4495 /*********************************************************************
4498 int CDECL MSVCRT_printf(const char *format, ...)
4500 __ms_va_list valist;
4502 __ms_va_start(valist, format);
4503 res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
4504 __ms_va_end(valist);
4508 /*********************************************************************
4509 * printf_s (MSVCRT.@)
4511 int CDECL MSVCRT_printf_s(const char *format, ...)
4513 __ms_va_list valist;
4515 __ms_va_start(valist, format);
4516 res = MSVCRT_vprintf_s(format, valist);
4517 __ms_va_end(valist);
4521 /*********************************************************************
4524 int CDECL MSVCRT_ungetc(int c, MSVCRT_FILE * file)
4526 if (c == MSVCRT_EOF)
4529 MSVCRT__lock_file(file);
4530 if(file->_bufsiz == 0 && msvcrt_alloc_buffer(file))
4532 if(file->_ptr>file->_base) {
4536 MSVCRT_clearerr(file);
4537 MSVCRT__unlock_file(file);
4541 MSVCRT__unlock_file(file);
4545 /*********************************************************************
4546 * ungetwc (MSVCRT.@)
4548 MSVCRT_wint_t CDECL MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
4550 MSVCRT_wchar_t mwc = wc;
4551 unsigned char * pp = (unsigned char *)&mwc;
4554 if (wc == MSVCRT_WEOF)
4557 MSVCRT__lock_file(file);
4558 for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
4559 if(pp[i] != MSVCRT_ungetc(pp[i],file)) {
4560 MSVCRT__unlock_file(file);
4565 MSVCRT__unlock_file(file);
4569 /*********************************************************************
4570 * wprintf (MSVCRT.@)
4572 int CDECL MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
4574 __ms_va_list valist;
4576 __ms_va_start(valist, format);
4577 res = MSVCRT_vwprintf(format, valist);
4578 __ms_va_end(valist);
4582 /*********************************************************************
4583 * wprintf_s (MSVCRT.@)
4585 int CDECL MSVCRT_wprintf_s(const MSVCRT_wchar_t *format, ...)
4587 __ms_va_list valist;
4589 __ms_va_start(valist, format);
4590 res = MSVCRT_vwprintf_s(format, valist);
4591 __ms_va_end(valist);
4595 /*********************************************************************
4596 * _getmaxstdio (MSVCRT.@)
4598 int CDECL MSVCRT__getmaxstdio(void)
4600 return MSVCRT_max_streams;
4603 /*********************************************************************
4604 * _setmaxstdio (MSVCRT.@)
4606 int CDECL MSVCRT__setmaxstdio(int newmax)
4608 TRACE("%d\n", newmax);
4610 if(newmax<_IOB_ENTRIES || newmax>MSVCRT_MAX_FILES || newmax<MSVCRT_stream_idx)
4613 MSVCRT_max_streams = newmax;
4614 return MSVCRT_max_streams;