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"
38 #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
60 /* values for wxflag in file descriptor */
63 #define WX_DONTINHERIT 0x10
64 #define WX_APPEND 0x20
67 /* FIXME: this should be allocated dynamically */
68 #define MSVCRT_MAX_FILES 2048
73 DWORD unkn[7]; /* critical section and init flag */
76 static ioinfo MSVCRT_fdesc[MSVCRT_MAX_FILES];
78 MSVCRT_FILE MSVCRT__iob[3];
80 static int MSVCRT_fdstart = 3; /* first unallocated fd */
81 static int MSVCRT_fdend = 3; /* highest allocated fd */
83 static MSVCRT_FILE* MSVCRT_fstreams[2048];
84 static int MSVCRT_stream_idx;
86 /* INTERNAL: process umask */
87 static int MSVCRT_umask = 0;
89 /* INTERNAL: Static buffer for temp file name */
90 static char MSVCRT_tmpname[MAX_PATH];
92 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
93 static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
94 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
95 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
97 #define TOUL(x) (ULONGLONG)(x)
98 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
99 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
100 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
101 static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
103 /* This critical section protects the tables MSVCRT_fdesc and MSVCRT_fstreams,
104 * and their related indexes, MSVCRT_fdstart, MSVCRT_fdend,
105 * and MSVCRT_stream_idx, from race conditions.
106 * It doesn't protect against race conditions manipulating the underlying files
107 * or flags; doing so would probably be better accomplished with per-file
108 * protection, rather than locking the whole table for every change.
110 static CRITICAL_SECTION MSVCRT_file_cs;
111 #define LOCK_FILES() do { EnterCriticalSection(&MSVCRT_file_cs); } while (0)
112 #define UNLOCK_FILES() do { LeaveCriticalSection(&MSVCRT_file_cs); } while (0)
114 static void msvcrt_stat64_to_stat(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat *buf)
116 buf->st_dev = buf64->st_dev;
117 buf->st_ino = buf64->st_ino;
118 buf->st_mode = buf64->st_mode;
119 buf->st_nlink = buf64->st_nlink;
120 buf->st_uid = buf64->st_uid;
121 buf->st_gid = buf64->st_gid;
122 buf->st_rdev = buf64->st_rdev;
123 buf->st_size = buf64->st_size;
124 buf->st_atime = buf64->st_atime;
125 buf->st_mtime = buf64->st_mtime;
126 buf->st_ctime = buf64->st_ctime;
129 static void msvcrt_stat64_to_stati64(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stati64 *buf)
131 buf->st_dev = buf64->st_dev;
132 buf->st_ino = buf64->st_ino;
133 buf->st_mode = buf64->st_mode;
134 buf->st_nlink = buf64->st_nlink;
135 buf->st_uid = buf64->st_uid;
136 buf->st_gid = buf64->st_gid;
137 buf->st_rdev = buf64->st_rdev;
138 buf->st_size = buf64->st_size;
139 buf->st_atime = buf64->st_atime;
140 buf->st_mtime = buf64->st_mtime;
141 buf->st_ctime = buf64->st_ctime;
144 static inline BOOL msvcrt_is_valid_fd(int fd)
146 return fd >= 0 && fd < MSVCRT_fdend && (MSVCRT_fdesc[fd].wxflag & WX_OPEN);
149 /* INTERNAL: Get the HANDLE for a fd
150 * This doesn't lock the table, because a failure will result in
151 * INVALID_HANDLE_VALUE being returned, which should be handled correctly. If
152 * it returns a valid handle which is about to be closed, a subsequent call
153 * will fail, most likely in a sane way.
155 static HANDLE msvcrt_fdtoh(int fd)
157 if (!msvcrt_is_valid_fd(fd))
159 WARN(":fd (%d) - no handle!\n",fd);
160 *MSVCRT___doserrno() = 0;
161 *MSVCRT__errno() = MSVCRT_EBADF;
162 return INVALID_HANDLE_VALUE;
164 if (MSVCRT_fdesc[fd].handle == INVALID_HANDLE_VALUE) FIXME("wtf\n");
165 return MSVCRT_fdesc[fd].handle;
168 /* INTERNAL: free a file entry fd */
169 static void msvcrt_free_fd(int fd)
172 MSVCRT_fdesc[fd].handle = INVALID_HANDLE_VALUE;
173 MSVCRT_fdesc[fd].wxflag = 0;
174 TRACE(":fd (%d) freed\n",fd);
175 if (fd < 3) /* don't use 0,1,2 for user files */
179 case 0: SetStdHandle(STD_INPUT_HANDLE, NULL); break;
180 case 1: SetStdHandle(STD_OUTPUT_HANDLE, NULL); break;
181 case 2: SetStdHandle(STD_ERROR_HANDLE, NULL); break;
186 if (fd == MSVCRT_fdend - 1)
188 if (fd < MSVCRT_fdstart)
194 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE, starting from fd */
195 /* caller must hold the files lock */
196 static int msvcrt_alloc_fd_from(HANDLE hand, int flag, int fd)
198 if (fd >= MSVCRT_MAX_FILES)
200 WARN(":files exhausted!\n");
203 MSVCRT_fdesc[fd].handle = hand;
204 MSVCRT_fdesc[fd].wxflag = WX_OPEN | (flag & (WX_DONTINHERIT | WX_APPEND | WX_TEXT));
206 /* locate next free slot */
207 if (fd == MSVCRT_fdstart && fd == MSVCRT_fdend)
208 MSVCRT_fdstart = MSVCRT_fdend + 1;
210 while (MSVCRT_fdstart < MSVCRT_fdend &&
211 MSVCRT_fdesc[MSVCRT_fdstart].handle != INVALID_HANDLE_VALUE)
213 /* update last fd in use */
214 if (fd >= MSVCRT_fdend)
215 MSVCRT_fdend = fd + 1;
216 TRACE("fdstart is %d, fdend is %d\n", MSVCRT_fdstart, MSVCRT_fdend);
220 case 0: SetStdHandle(STD_INPUT_HANDLE, hand); break;
221 case 1: SetStdHandle(STD_OUTPUT_HANDLE, hand); break;
222 case 2: SetStdHandle(STD_ERROR_HANDLE, hand); break;
228 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
229 static int msvcrt_alloc_fd(HANDLE hand, int flag)
234 TRACE(":handle (%p) allocating fd (%d)\n",hand,MSVCRT_fdstart);
235 ret = msvcrt_alloc_fd_from(hand, flag, MSVCRT_fdstart);
240 /* INTERNAL: Allocate a FILE* for an fd slot */
241 /* caller must hold the files lock */
242 static MSVCRT_FILE* msvcrt_alloc_fp(void)
246 for (i = 3; i < sizeof(MSVCRT_fstreams) / sizeof(MSVCRT_fstreams[0]); i++)
248 if (!MSVCRT_fstreams[i] || MSVCRT_fstreams[i]->_flag == 0)
250 if (!MSVCRT_fstreams[i])
252 if (!(MSVCRT_fstreams[i] = MSVCRT_calloc(sizeof(MSVCRT_FILE),1)))
254 if (i == MSVCRT_stream_idx) MSVCRT_stream_idx++;
256 return MSVCRT_fstreams[i];
262 /* INTERNAL: initialize a FILE* from an open fd */
263 static int msvcrt_init_fp(MSVCRT_FILE* file, int fd, unsigned stream_flags)
265 TRACE(":fd (%d) allocating FILE*\n",fd);
266 if (!msvcrt_is_valid_fd(fd))
268 WARN(":invalid fd %d\n",fd);
269 *MSVCRT___doserrno() = 0;
270 *MSVCRT__errno() = MSVCRT_EBADF;
273 memset(file, 0, sizeof(*file));
275 file->_flag = stream_flags;
277 TRACE(":got FILE* (%p)\n",file);
281 /* INTERNAL: Create an inheritance data block (for spawned process)
282 * The inheritance block is made of:
283 * 00 int nb of file descriptor (NBFD)
284 * 04 char file flags (wxflag): repeated for each fd
285 * 4+NBFD HANDLE file handle: repeated for each fd
287 unsigned msvcrt_create_io_inherit_block(STARTUPINFOA* si)
293 si->cbReserved2 = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * MSVCRT_fdend;
294 si->lpReserved2 = MSVCRT_calloc(si->cbReserved2, 1);
295 if (!si->lpReserved2)
300 wxflag_ptr = (char*)si->lpReserved2 + sizeof(unsigned);
301 handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
303 *(unsigned*)si->lpReserved2 = MSVCRT_fdend;
304 for (fd = 0; fd < MSVCRT_fdend; fd++)
306 /* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
307 if ((MSVCRT_fdesc[fd].wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
309 *wxflag_ptr = MSVCRT_fdesc[fd].wxflag;
310 *handle_ptr = MSVCRT_fdesc[fd].handle;
315 *handle_ptr = INVALID_HANDLE_VALUE;
317 wxflag_ptr++; handle_ptr++;
322 /* INTERNAL: Set up all file descriptors,
323 * as well as default streams (stdin, stderr and stdout)
325 void msvcrt_init_io(void)
330 InitializeCriticalSection(&MSVCRT_file_cs);
331 GetStartupInfoA(&si);
332 if (si.cbReserved2 != 0 && si.lpReserved2 != NULL)
337 MSVCRT_fdend = *(unsigned*)si.lpReserved2;
339 wxflag_ptr = (char*)(si.lpReserved2 + sizeof(unsigned));
340 handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
342 MSVCRT_fdend = min(MSVCRT_fdend, sizeof(MSVCRT_fdesc) / sizeof(MSVCRT_fdesc[0]));
343 for (i = 0; i < MSVCRT_fdend; i++)
345 if ((*wxflag_ptr & WX_OPEN) && *handle_ptr != INVALID_HANDLE_VALUE)
347 MSVCRT_fdesc[i].wxflag = *wxflag_ptr;
348 MSVCRT_fdesc[i].handle = *handle_ptr;
352 MSVCRT_fdesc[i].wxflag = 0;
353 MSVCRT_fdesc[i].handle = INVALID_HANDLE_VALUE;
355 wxflag_ptr++; handle_ptr++;
357 for (MSVCRT_fdstart = 3; MSVCRT_fdstart < MSVCRT_fdend; MSVCRT_fdstart++)
358 if (MSVCRT_fdesc[MSVCRT_fdstart].handle == INVALID_HANDLE_VALUE) break;
361 if (!(MSVCRT_fdesc[0].wxflag & WX_OPEN) || MSVCRT_fdesc[0].handle == INVALID_HANDLE_VALUE)
363 DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE),
364 GetCurrentProcess(), &MSVCRT_fdesc[0].handle, 0, TRUE,
365 DUPLICATE_SAME_ACCESS);
366 MSVCRT_fdesc[0].wxflag = WX_OPEN | WX_TEXT;
368 if (!(MSVCRT_fdesc[1].wxflag & WX_OPEN) || MSVCRT_fdesc[1].handle == INVALID_HANDLE_VALUE)
370 DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_OUTPUT_HANDLE),
371 GetCurrentProcess(), &MSVCRT_fdesc[1].handle, 0, TRUE,
372 DUPLICATE_SAME_ACCESS);
373 MSVCRT_fdesc[1].wxflag = WX_OPEN | WX_TEXT;
375 if (!(MSVCRT_fdesc[2].wxflag & WX_OPEN) || MSVCRT_fdesc[2].handle == INVALID_HANDLE_VALUE)
377 DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_ERROR_HANDLE),
378 GetCurrentProcess(), &MSVCRT_fdesc[2].handle, 0, TRUE,
379 DUPLICATE_SAME_ACCESS);
380 MSVCRT_fdesc[2].wxflag = WX_OPEN | WX_TEXT;
383 TRACE(":handles (%p)(%p)(%p)\n",MSVCRT_fdesc[0].handle,
384 MSVCRT_fdesc[1].handle,MSVCRT_fdesc[2].handle);
386 memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
387 for (i = 0; i < 3; i++)
389 /* FILE structs for stdin/out/err are static and never deleted */
390 MSVCRT_fstreams[i] = &MSVCRT__iob[i];
391 MSVCRT__iob[i]._file = i;
392 MSVCRT__iob[i]._tmpfname = NULL;
393 MSVCRT__iob[i]._flag = (i == 0) ? MSVCRT__IOREAD : MSVCRT__IOWRT;
395 MSVCRT_stream_idx = 3;
398 /* INTERNAL: Flush stdio file buffer */
399 static int msvcrt_flush_buffer(MSVCRT_FILE* file)
402 int cnt=file->_ptr-file->_base;
403 if(cnt>0 && _write(file->_file, file->_base, cnt) != cnt) {
404 file->_flag |= MSVCRT__IOERR;
407 file->_ptr=file->_base;
408 file->_cnt=file->_bufsiz;
413 /* INTERNAL: Allocate stdio file buffer */
414 static void msvcrt_alloc_buffer(MSVCRT_FILE* file)
416 file->_base = MSVCRT_calloc(MSVCRT_BUFSIZ,1);
418 file->_bufsiz = MSVCRT_BUFSIZ;
419 file->_flag |= MSVCRT__IOMYBUF;
421 file->_base = (char*)(&file->_charbuf);
423 file->_bufsiz = sizeof(file->_charbuf);
425 file->_ptr = file->_base;
429 /* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
430 static void msvcrt_int_to_base32(int num, char *str)
445 *p = (num & 31) + '0';
447 *p += ('a' - '0' - 10);
452 /*********************************************************************
455 MSVCRT_FILE * CDECL __p__iob(void)
457 return &MSVCRT__iob[0];
460 /*********************************************************************
463 int CDECL _access(const char *filename, int mode)
465 DWORD attr = GetFileAttributesA(filename);
467 TRACE("(%s,%d) %d\n",filename,mode,attr);
469 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
471 msvcrt_set_errno(GetLastError());
474 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
476 msvcrt_set_errno(ERROR_ACCESS_DENIED);
482 /*********************************************************************
483 * _waccess (MSVCRT.@)
485 int CDECL _waccess(const MSVCRT_wchar_t *filename, int mode)
487 DWORD attr = GetFileAttributesW(filename);
489 TRACE("(%s,%d) %d\n",debugstr_w(filename),mode,attr);
491 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
493 msvcrt_set_errno(GetLastError());
496 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
498 msvcrt_set_errno(ERROR_ACCESS_DENIED);
504 /*********************************************************************
507 int CDECL _chmod(const char *path, int flags)
509 DWORD oldFlags = GetFileAttributesA(path);
511 if (oldFlags != INVALID_FILE_ATTRIBUTES)
513 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
514 oldFlags | FILE_ATTRIBUTE_READONLY;
516 if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
519 msvcrt_set_errno(GetLastError());
523 /*********************************************************************
526 int CDECL _wchmod(const MSVCRT_wchar_t *path, int flags)
528 DWORD oldFlags = GetFileAttributesW(path);
530 if (oldFlags != INVALID_FILE_ATTRIBUTES)
532 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
533 oldFlags | FILE_ATTRIBUTE_READONLY;
535 if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
538 msvcrt_set_errno(GetLastError());
542 /*********************************************************************
545 int CDECL _unlink(const char *path)
547 TRACE("%s\n",debugstr_a(path));
548 if(DeleteFileA(path))
550 TRACE("failed (%d)\n",GetLastError());
551 msvcrt_set_errno(GetLastError());
555 /*********************************************************************
556 * _wunlink (MSVCRT.@)
558 int CDECL _wunlink(const MSVCRT_wchar_t *path)
560 TRACE("(%s)\n",debugstr_w(path));
561 if(DeleteFileW(path))
563 TRACE("failed (%d)\n",GetLastError());
564 msvcrt_set_errno(GetLastError());
568 /* _flushall calls MSVCRT_fflush which calls _flushall */
569 int CDECL MSVCRT_fflush(MSVCRT_FILE* file);
571 /*********************************************************************
572 * _flushall (MSVCRT.@)
574 int CDECL _flushall(void)
576 int i, num_flushed = 0;
579 for (i = 3; i < MSVCRT_stream_idx; i++)
580 if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_flag)
583 /* FIXME: flush, do not commit */
584 if (_commit(i) == -1)
585 if (MSVCRT_fstreams[i])
586 MSVCRT_fstreams[i]->_flag |= MSVCRT__IOERR;
588 if(MSVCRT_fstreams[i]->_flag & MSVCRT__IOWRT) {
589 MSVCRT_fflush(MSVCRT_fstreams[i]);
595 TRACE(":flushed (%d) handles\n",num_flushed);
599 /*********************************************************************
602 int CDECL MSVCRT_fflush(MSVCRT_FILE* file)
606 } else if(file->_flag & MSVCRT__IOWRT) {
607 int res=msvcrt_flush_buffer(file);
613 /*********************************************************************
616 int CDECL _close(int fd)
622 hand = msvcrt_fdtoh(fd);
623 TRACE(":fd (%d) handle (%p)\n",fd,hand);
624 if (hand == INVALID_HANDLE_VALUE)
626 else if (!CloseHandle(hand))
628 WARN(":failed-last error (%d)\n",GetLastError());
629 msvcrt_set_errno(GetLastError());
642 /*********************************************************************
645 int CDECL _commit(int fd)
647 HANDLE hand = msvcrt_fdtoh(fd);
649 TRACE(":fd (%d) handle (%p)\n",fd,hand);
650 if (hand == INVALID_HANDLE_VALUE)
653 if (!FlushFileBuffers(hand))
655 if (GetLastError() == ERROR_INVALID_HANDLE)
657 /* FlushFileBuffers fails for console handles
658 * so we ignore this error.
662 TRACE(":failed-last error (%d)\n",GetLastError());
663 msvcrt_set_errno(GetLastError());
670 /*********************************************************************
673 * MSDN isn't clear on this point, but the remarks for _pipe,
674 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt__pipe.asp
675 * indicate file descriptors duplicated with _dup and _dup2 are always
678 int CDECL _dup2(int od, int nd)
682 TRACE("(od=%d, nd=%d)\n", od, nd);
684 if (nd < MSVCRT_MAX_FILES && msvcrt_is_valid_fd(od))
688 if (DuplicateHandle(GetCurrentProcess(), MSVCRT_fdesc[od].handle,
689 GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS))
691 int wxflag = MSVCRT_fdesc[od].wxflag & ~MSVCRT__O_NOINHERIT;
693 if (msvcrt_is_valid_fd(nd))
695 ret = msvcrt_alloc_fd_from(handle, wxflag, nd);
699 *MSVCRT__errno() = MSVCRT_EMFILE;
703 /* _dup2 returns 0, not nd, on success */
710 msvcrt_set_errno(GetLastError());
715 *MSVCRT__errno() = MSVCRT_EBADF;
722 /*********************************************************************
725 int CDECL _dup(int od)
731 if (_dup2(od, fd) == 0)
739 /*********************************************************************
742 int CDECL _eof(int fd)
745 LONG hcurpos,hendpos;
746 HANDLE hand = msvcrt_fdtoh(fd);
748 TRACE(":fd (%d) handle (%p)\n",fd,hand);
750 if (hand == INVALID_HANDLE_VALUE)
753 if (MSVCRT_fdesc[fd].wxflag & WX_ATEOF) return TRUE;
755 /* Otherwise we do it the hard way */
756 hcurpos = hendpos = 0;
757 curpos = SetFilePointer(hand, 0, &hcurpos, FILE_CURRENT);
758 endpos = SetFilePointer(hand, 0, &hendpos, FILE_END);
760 if (curpos == endpos && hcurpos == hendpos)
762 /* FIXME: shouldn't WX_ATEOF be set here? */
766 SetFilePointer(hand, curpos, &hcurpos, FILE_BEGIN);
770 /*********************************************************************
771 * _fcloseall (MSVCRT.@)
773 int CDECL MSVCRT__fcloseall(void)
775 int num_closed = 0, i;
778 for (i = 3; i < MSVCRT_stream_idx; i++)
779 if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_flag &&
780 !MSVCRT_fclose(MSVCRT_fstreams[i]))
784 TRACE(":closed (%d) handles\n",num_closed);
788 /* free everything on process exit */
789 void msvcrt_free_io(void)
792 /* The Win32 _fcloseall() function explicitly doesn't close stdin,
793 * stdout, and stderr (unlike GNU), so we need to fclose() them here
794 * or they won't get flushed.
796 MSVCRT_fclose(&MSVCRT__iob[0]);
797 MSVCRT_fclose(&MSVCRT__iob[1]);
798 MSVCRT_fclose(&MSVCRT__iob[2]);
799 DeleteCriticalSection(&MSVCRT_file_cs);
802 /*********************************************************************
803 * _lseeki64 (MSVCRT.@)
805 __int64 CDECL _lseeki64(int fd, __int64 offset, int whence)
807 HANDLE hand = msvcrt_fdtoh(fd);
808 LARGE_INTEGER ofs, ret;
810 TRACE(":fd (%d) handle (%p)\n",fd,hand);
811 if (hand == INVALID_HANDLE_VALUE)
814 if (whence < 0 || whence > 2)
816 *MSVCRT__errno() = MSVCRT_EINVAL;
820 TRACE(":fd (%d) to %s pos %s\n",
821 fd,wine_dbgstr_longlong(offset),
822 (whence==SEEK_SET)?"SEEK_SET":
823 (whence==SEEK_CUR)?"SEEK_CUR":
824 (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
826 ofs.QuadPart = offset;
827 if (SetFilePointerEx(hand, ofs, &ret, whence))
829 MSVCRT_fdesc[fd].wxflag &= ~WX_ATEOF;
830 /* FIXME: What if we seek _to_ EOF - is EOF set? */
834 TRACE(":error-last error (%d)\n",GetLastError());
835 msvcrt_set_errno(GetLastError());
839 /*********************************************************************
842 LONG CDECL _lseek(int fd, LONG offset, int whence)
844 return _lseeki64(fd, offset, whence);
847 /*********************************************************************
848 * _locking (MSVCRT.@)
850 * This is untested; the underlying LockFile doesn't work yet.
852 int CDECL _locking(int fd, int mode, LONG nbytes)
856 HANDLE hand = msvcrt_fdtoh(fd);
858 TRACE(":fd (%d) handle (%p)\n",fd,hand);
859 if (hand == INVALID_HANDLE_VALUE)
862 if (mode < 0 || mode > 4)
864 *MSVCRT__errno() = MSVCRT_EINVAL;
868 TRACE(":fd (%d) by 0x%08x mode %s\n",
869 fd,nbytes,(mode==MSVCRT__LK_UNLCK)?"_LK_UNLCK":
870 (mode==MSVCRT__LK_LOCK)?"_LK_LOCK":
871 (mode==MSVCRT__LK_NBLCK)?"_LK_NBLCK":
872 (mode==MSVCRT__LK_RLCK)?"_LK_RLCK":
873 (mode==MSVCRT__LK_NBRLCK)?"_LK_NBRLCK":
876 if ((cur_locn = SetFilePointer(hand, 0L, NULL, SEEK_CUR)) == INVALID_SET_FILE_POINTER)
878 FIXME ("Seek failed\n");
879 *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
882 if (mode == MSVCRT__LK_LOCK || mode == MSVCRT__LK_RLCK)
885 ret = 1; /* just to satisfy gcc */
888 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
893 else if (mode == MSVCRT__LK_UNLCK)
894 ret = UnlockFile(hand, cur_locn, 0L, nbytes, 0L);
896 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
897 /* FIXME - what about error settings? */
901 /*********************************************************************
904 int CDECL MSVCRT_fseek(MSVCRT_FILE* file, long offset, int whence)
906 /* Flush output if needed */
907 if(file->_flag & MSVCRT__IOWRT)
908 msvcrt_flush_buffer(file);
910 if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
911 offset -= file->_cnt;
913 /* Discard buffered input */
915 file->_ptr = file->_base;
916 /* Reset direction of i/o */
917 if(file->_flag & MSVCRT__IORW) {
918 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
920 return (_lseek(file->_file,offset,whence) == -1)?-1:0;
923 /*********************************************************************
926 int CDECL _chsize(int fd, long size)
932 TRACE("(fd=%d, size=%ld)\n", fd, size);
936 handle = msvcrt_fdtoh(fd);
937 if (handle != INVALID_HANDLE_VALUE)
939 /* save the current file pointer */
940 cur = _lseek(fd, 0, SEEK_CUR);
943 pos = _lseek(fd, size, SEEK_SET);
946 ret = SetEndOfFile(handle);
947 if (!ret) msvcrt_set_errno(GetLastError());
950 /* restore the file pointer */
951 _lseek(fd, cur, SEEK_SET);
959 /*********************************************************************
960 * clearerr (MSVCRT.@)
962 void CDECL MSVCRT_clearerr(MSVCRT_FILE* file)
964 TRACE(":file (%p) fd (%d)\n",file,file->_file);
965 file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
968 /*********************************************************************
971 void CDECL MSVCRT_rewind(MSVCRT_FILE* file)
973 TRACE(":file (%p) fd (%d)\n",file,file->_file);
974 MSVCRT_fseek(file, 0L, SEEK_SET);
975 MSVCRT_clearerr(file);
978 static int msvcrt_get_flags(const char* mode, int *open_flags, int* stream_flags)
980 int plus = strchr(mode, '+') != NULL;
985 *open_flags = plus ? MSVCRT__O_RDWR : MSVCRT__O_RDONLY;
986 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOREAD;
989 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_TRUNC | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
990 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
993 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_APPEND | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
994 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1004 *open_flags |= MSVCRT__O_BINARY;
1005 *open_flags &= ~MSVCRT__O_TEXT;
1008 *open_flags |= MSVCRT__O_TEXT;
1009 *open_flags &= ~MSVCRT__O_BINARY;
1014 FIXME(":unknown flag %c not supported\n",mode[-1]);
1019 /*********************************************************************
1020 * _fdopen (MSVCRT.@)
1022 MSVCRT_FILE* CDECL MSVCRT__fdopen(int fd, const char *mode)
1024 int open_flags, stream_flags;
1027 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
1030 if (!(file = msvcrt_alloc_fp()))
1032 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
1037 else TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,mode,file);
1043 /*********************************************************************
1044 * _wfdopen (MSVCRT.@)
1046 MSVCRT_FILE* CDECL MSVCRT__wfdopen(int fd, const MSVCRT_wchar_t *mode)
1048 unsigned mlen = strlenW(mode);
1049 char *modea = MSVCRT_calloc(mlen + 1, 1);
1050 MSVCRT_FILE* file = NULL;
1051 int open_flags, stream_flags;
1054 WideCharToMultiByte(CP_ACP,0,mode,mlen,modea,mlen,NULL,NULL))
1056 if (msvcrt_get_flags(modea, &open_flags, &stream_flags) == -1) return NULL;
1058 if (!(file = msvcrt_alloc_fp()))
1060 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
1068 MSVCRT_rewind(file); /* FIXME: is this needed ??? */
1069 TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,debugstr_w(mode),file);
1076 /*********************************************************************
1077 * _filelength (MSVCRT.@)
1079 LONG CDECL _filelength(int fd)
1081 LONG curPos = _lseek(fd, 0, SEEK_CUR);
1084 LONG endPos = _lseek(fd, 0, SEEK_END);
1087 if (endPos != curPos)
1088 _lseek(fd, curPos, SEEK_SET);
1095 /*********************************************************************
1096 * _filelengthi64 (MSVCRT.@)
1098 __int64 CDECL _filelengthi64(int fd)
1100 __int64 curPos = _lseeki64(fd, 0, SEEK_CUR);
1103 __int64 endPos = _lseeki64(fd, 0, SEEK_END);
1106 if (endPos != curPos)
1107 _lseeki64(fd, curPos, SEEK_SET);
1114 /*********************************************************************
1115 * _fileno (MSVCRT.@)
1117 int CDECL MSVCRT__fileno(MSVCRT_FILE* file)
1119 TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
1123 /*********************************************************************
1124 * _fstat64 (MSVCRT.@)
1126 int CDECL MSVCRT__fstat64(int fd, struct MSVCRT__stat64* buf)
1130 BY_HANDLE_FILE_INFORMATION hfi;
1131 HANDLE hand = msvcrt_fdtoh(fd);
1133 TRACE(":fd (%d) stat (%p)\n",fd,buf);
1134 if (hand == INVALID_HANDLE_VALUE)
1139 WARN(":failed-NULL buf\n");
1140 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1144 memset(&hfi, 0, sizeof(hfi));
1145 memset(buf, 0, sizeof(struct MSVCRT__stat64));
1146 type = GetFileType(hand);
1147 if (type == FILE_TYPE_PIPE)
1149 buf->st_dev = buf->st_rdev = fd;
1150 buf->st_mode = S_IFIFO;
1153 else if (type == FILE_TYPE_CHAR)
1155 buf->st_dev = buf->st_rdev = fd;
1156 buf->st_mode = S_IFCHR;
1159 else /* FILE_TYPE_DISK etc. */
1161 if (!GetFileInformationByHandle(hand, &hfi))
1163 WARN(":failed-last error (%d)\n",GetLastError());
1164 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1167 buf->st_mode = S_IFREG | S_IREAD;
1168 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1169 buf->st_mode |= S_IWRITE;
1170 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1171 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1173 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1174 buf->st_mtime = buf->st_ctime = dw;
1175 buf->st_nlink = hfi.nNumberOfLinks;
1177 TRACE(":dwFileAttributes = 0x%x, mode set to 0x%x\n",hfi.dwFileAttributes,
1182 /*********************************************************************
1183 * _fstati64 (MSVCRT.@)
1185 int CDECL MSVCRT__fstati64(int fd, struct MSVCRT__stati64* buf)
1188 struct MSVCRT__stat64 buf64;
1190 ret = MSVCRT__fstat64(fd, &buf64);
1192 msvcrt_stat64_to_stati64(&buf64, buf);
1196 /*********************************************************************
1199 int CDECL MSVCRT__fstat(int fd, struct MSVCRT__stat* buf)
1201 struct MSVCRT__stat64 buf64;
1203 ret = MSVCRT__fstat64(fd, &buf64);
1205 msvcrt_stat64_to_stat(&buf64, buf);
1209 /*********************************************************************
1210 * _futime (MSVCRT.@)
1212 int CDECL _futime(int fd, struct MSVCRT__utimbuf *t)
1214 HANDLE hand = msvcrt_fdtoh(fd);
1219 MSVCRT_time_t currTime;
1220 MSVCRT_time(&currTime);
1221 RtlSecondsSince1970ToTime(currTime, (LARGE_INTEGER *)&at);
1222 memcpy(&wt, &at, sizeof(wt));
1226 RtlSecondsSince1970ToTime(t->actime, (LARGE_INTEGER *)&at);
1227 if (t->actime == t->modtime)
1228 memcpy(&wt, &at, sizeof(wt));
1230 RtlSecondsSince1970ToTime(t->modtime, (LARGE_INTEGER *)&wt);
1233 if (!SetFileTime(hand, NULL, &at, &wt))
1235 msvcrt_set_errno(GetLastError());
1241 /*********************************************************************
1242 * _get_osfhandle (MSVCRT.@)
1244 long CDECL _get_osfhandle(int fd)
1246 HANDLE hand = msvcrt_fdtoh(fd);
1247 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1252 /*********************************************************************
1253 * _isatty (MSVCRT.@)
1255 int CDECL _isatty(int fd)
1257 HANDLE hand = msvcrt_fdtoh(fd);
1259 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1260 if (hand == INVALID_HANDLE_VALUE)
1263 return GetFileType(hand) == FILE_TYPE_CHAR? 1 : 0;
1266 /*********************************************************************
1267 * _mktemp (MSVCRT.@)
1269 char * CDECL _mktemp(char *pattern)
1272 char *retVal = pattern;
1277 numX = (*pattern++ == 'X')? numX + 1 : 0;
1281 id = GetCurrentProcessId();
1285 int tempNum = id / 10;
1286 *pattern-- = id - (tempNum * 10) + '0';
1292 *pattern = letter++;
1293 if (GetFileAttributesA(retVal) == INVALID_FILE_ATTRIBUTES &&
1294 GetLastError() == ERROR_FILE_NOT_FOUND)
1296 } while(letter <= 'z');
1300 /*********************************************************************
1301 * _wmktemp (MSVCRT.@)
1303 MSVCRT_wchar_t * CDECL _wmktemp(MSVCRT_wchar_t *pattern)
1306 MSVCRT_wchar_t *retVal = pattern;
1308 MSVCRT_wchar_t letter = 'a';
1311 numX = (*pattern++ == 'X')? numX + 1 : 0;
1315 id = GetCurrentProcessId();
1319 int tempNum = id / 10;
1320 *pattern-- = id - (tempNum * 10) + '0';
1326 if (GetFileAttributesW(retVal) == INVALID_FILE_ATTRIBUTES &&
1327 GetLastError() == ERROR_FILE_NOT_FOUND)
1329 *pattern = letter++;
1330 } while(letter != '|');
1334 static unsigned split_oflags(unsigned oflags)
1337 unsigned unsupp; /* until we support everything */
1339 if (oflags & MSVCRT__O_APPEND) wxflags |= WX_APPEND;
1340 if (oflags & MSVCRT__O_BINARY) {/* Nothing to do */}
1341 else if (oflags & MSVCRT__O_TEXT) wxflags |= WX_TEXT;
1342 else if (*__p__fmode() & MSVCRT__O_BINARY) {/* Nothing to do */}
1343 else wxflags |= WX_TEXT; /* default to TEXT*/
1344 if (oflags & MSVCRT__O_NOINHERIT) wxflags |= WX_DONTINHERIT;
1346 if ((unsupp = oflags & ~(
1347 MSVCRT__O_BINARY|MSVCRT__O_TEXT|MSVCRT__O_APPEND|
1348 MSVCRT__O_TRUNC|MSVCRT__O_EXCL|MSVCRT__O_CREAT|
1349 MSVCRT__O_RDWR|MSVCRT__O_WRONLY|MSVCRT__O_TEMPORARY|
1350 MSVCRT__O_NOINHERIT|
1351 MSVCRT__O_SEQUENTIAL|MSVCRT__O_RANDOM|MSVCRT__O_SHORT_LIVED
1353 ERR(":unsupported oflags 0x%04x\n",unsupp);
1358 /*********************************************************************
1361 int CDECL _pipe(int *pfds, unsigned int psize, int textmode)
1364 SECURITY_ATTRIBUTES sa;
1365 HANDLE readHandle, writeHandle;
1369 *MSVCRT__errno() = MSVCRT_EINVAL;
1373 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
1374 sa.bInheritHandle = !(textmode & MSVCRT__O_NOINHERIT);
1375 sa.lpSecurityDescriptor = NULL;
1376 if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
1378 unsigned int wxflags = split_oflags(textmode);
1382 fd = msvcrt_alloc_fd(readHandle, wxflags);
1386 fd = msvcrt_alloc_fd(writeHandle, wxflags);
1395 CloseHandle(writeHandle);
1396 *MSVCRT__errno() = MSVCRT_EMFILE;
1401 CloseHandle(readHandle);
1402 CloseHandle(writeHandle);
1403 *MSVCRT__errno() = MSVCRT_EMFILE;
1408 msvcrt_set_errno(GetLastError());
1413 /*********************************************************************
1416 int CDECL MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
1420 DWORD access = 0, creation = 0, attrib;
1424 SECURITY_ATTRIBUTES sa;
1427 TRACE(":file (%s) oflags: 0x%04x shflags: 0x%04x\n",
1428 path, oflags, shflags);
1430 wxflag = split_oflags(oflags);
1431 switch (oflags & (MSVCRT__O_RDONLY | MSVCRT__O_WRONLY | MSVCRT__O_RDWR))
1433 case MSVCRT__O_RDONLY: access |= GENERIC_READ; break;
1434 case MSVCRT__O_WRONLY: access |= GENERIC_WRITE; break;
1435 case MSVCRT__O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
1438 if (oflags & MSVCRT__O_CREAT)
1440 va_start(ap, shflags);
1441 pmode = va_arg(ap, int);
1444 if(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))
1445 FIXME(": pmode 0x%04x ignored\n", pmode);
1447 WARN(": pmode 0x%04x ignored\n", pmode);
1449 if (oflags & MSVCRT__O_EXCL)
1450 creation = CREATE_NEW;
1451 else if (oflags & MSVCRT__O_TRUNC)
1452 creation = CREATE_ALWAYS;
1454 creation = OPEN_ALWAYS;
1456 else /* no MSVCRT__O_CREAT */
1458 if (oflags & MSVCRT__O_TRUNC)
1459 creation = TRUNCATE_EXISTING;
1461 creation = OPEN_EXISTING;
1466 case MSVCRT__SH_DENYRW:
1469 case MSVCRT__SH_DENYWR:
1470 sharing = FILE_SHARE_READ;
1472 case MSVCRT__SH_DENYRD:
1473 sharing = FILE_SHARE_WRITE;
1475 case MSVCRT__SH_DENYNO:
1476 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1479 ERR( "Unhandled shflags 0x%x\n", shflags );
1482 attrib = FILE_ATTRIBUTE_NORMAL;
1484 if (oflags & MSVCRT__O_TEMPORARY)
1486 attrib |= FILE_FLAG_DELETE_ON_CLOSE;
1488 sharing |= FILE_SHARE_DELETE;
1491 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
1492 sa.lpSecurityDescriptor = NULL;
1493 sa.bInheritHandle = (oflags & MSVCRT__O_NOINHERIT) ? FALSE : TRUE;
1495 hand = CreateFileA(path, access, sharing, &sa, creation, attrib, 0);
1497 if (hand == INVALID_HANDLE_VALUE) {
1498 WARN(":failed-last error (%d)\n",GetLastError());
1499 msvcrt_set_errno(GetLastError());
1503 fd = msvcrt_alloc_fd(hand, wxflag);
1505 TRACE(":fd (%d) handle (%p)\n",fd, hand);
1509 /*********************************************************************
1510 * _wsopen (MSVCRT.@)
1512 int CDECL MSVCRT__wsopen( const MSVCRT_wchar_t* path, int oflags, int shflags, ... )
1514 const unsigned int len = strlenW(path);
1515 char *patha = MSVCRT_calloc(len + 1,1);
1519 va_start(ap, shflags);
1520 pmode = va_arg(ap, int);
1523 if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
1525 int retval = MSVCRT__sopen(patha,oflags,shflags,pmode);
1530 msvcrt_set_errno(GetLastError());
1534 /*********************************************************************
1537 int CDECL _open( const char *path, int flags, ... )
1541 if (flags & MSVCRT__O_CREAT)
1544 va_start(ap, flags);
1545 pmode = va_arg(ap, int);
1547 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO, pmode );
1550 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO);
1553 /*********************************************************************
1556 int CDECL _wopen(const MSVCRT_wchar_t *path,int flags,...)
1558 const unsigned int len = strlenW(path);
1559 char *patha = MSVCRT_calloc(len + 1,1);
1563 va_start(ap, flags);
1564 pmode = va_arg(ap, int);
1567 if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
1569 int retval = _open(patha,flags,pmode);
1574 msvcrt_set_errno(GetLastError());
1578 /*********************************************************************
1581 int CDECL _creat(const char *path, int flags)
1583 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
1584 return _open(path, usedFlags);
1587 /*********************************************************************
1588 * _wcreat (MSVCRT.@)
1590 int CDECL _wcreat(const MSVCRT_wchar_t *path, int flags)
1592 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
1593 return _wopen(path, usedFlags);
1596 /*********************************************************************
1597 * _open_osfhandle (MSVCRT.@)
1599 int CDECL _open_osfhandle(long handle, int oflags)
1603 /* MSVCRT__O_RDONLY (0) always matches, so set the read flag
1604 * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
1605 * file, so set the write flag. It also only sets MSVCRT__O_TEXT if it wants
1606 * text - it never sets MSVCRT__O_BINARY.
1608 /* don't let split_oflags() decide the mode if no mode is passed */
1609 if (!(oflags & (MSVCRT__O_BINARY | MSVCRT__O_TEXT)))
1610 oflags |= MSVCRT__O_BINARY;
1612 fd = msvcrt_alloc_fd((HANDLE)handle, split_oflags(oflags));
1613 TRACE(":handle (%ld) fd (%d) flags 0x%08x\n", handle, fd, oflags);
1617 /*********************************************************************
1620 int CDECL _rmtmp(void)
1622 int num_removed = 0, i;
1625 for (i = 3; i < MSVCRT_stream_idx; i++)
1626 if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_tmpfname)
1628 MSVCRT_fclose(MSVCRT_fstreams[i]);
1634 TRACE(":removed (%d) temp files\n",num_removed);
1638 /*********************************************************************
1639 * (internal) remove_cr
1641 * Remove all \r inplace.
1642 * return the number of \r removed
1644 static unsigned int remove_cr(char *buf, unsigned int count)
1648 for (i = 0; i < count; i++) if (buf[i] == '\r') break;
1649 for (j = i + 1; j < count; j++) if (buf[j] != '\r') buf[i++] = buf[j];
1653 /*********************************************************************
1656 static int read_i(int fd, void *buf, unsigned int count)
1659 char *bufstart = buf;
1660 HANDLE hand = msvcrt_fdtoh(fd);
1662 /* Don't trace small reads, it gets *very* annoying */
1664 TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n",fd,hand,buf,count);
1665 if (hand == INVALID_HANDLE_VALUE)
1668 /* Reading single bytes in O_TEXT mode makes things slow
1669 * So read big chunks
1671 if (ReadFile(hand, bufstart, count, &num_read, NULL))
1673 if (MSVCRT_fdesc[fd].wxflag & WX_TEXT)
1676 /* in text mode, a ctrl-z signals EOF */
1677 for (i=0; i<num_read; i++)
1679 if (bufstart[i] == 0x1a)
1686 if (num_read != count)
1688 MSVCRT_fdesc[fd].wxflag |= WX_ATEOF;
1689 TRACE(":EOF %s\n",debugstr_an(buf,num_read));
1694 TRACE(":failed-last error (%d)\n",GetLastError());
1699 TRACE("(%u), %s\n",num_read,debugstr_an(buf, num_read));
1703 /*********************************************************************
1706 int CDECL _read(int fd, void *buf, unsigned int count)
1709 num_read = read_i(fd, buf, count);
1710 if (num_read>0 && MSVCRT_fdesc[fd].wxflag & WX_TEXT)
1712 num_read -= remove_cr(buf,num_read);
1717 /*********************************************************************
1718 * _setmode (MSVCRT.@)
1720 int CDECL _setmode(int fd,int mode)
1722 int ret = MSVCRT_fdesc[fd].wxflag & WX_TEXT ? MSVCRT__O_TEXT : MSVCRT__O_BINARY;
1723 if (mode & (~(MSVCRT__O_TEXT|MSVCRT__O_BINARY)))
1724 FIXME("fd (%d) mode (0x%08x) unknown\n",fd,mode);
1725 if ((mode & MSVCRT__O_TEXT) == MSVCRT__O_TEXT)
1726 MSVCRT_fdesc[fd].wxflag |= WX_TEXT;
1728 MSVCRT_fdesc[fd].wxflag &= ~WX_TEXT;
1732 /*********************************************************************
1733 * _stat64 (MSVCRT.@)
1735 int CDECL MSVCRT__stat64(const char* path, struct MSVCRT__stat64 * buf)
1738 WIN32_FILE_ATTRIBUTE_DATA hfi;
1739 unsigned short mode = ALL_S_IREAD;
1742 TRACE(":file (%s) buf(%p)\n",path,buf);
1744 if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
1746 TRACE("failed (%d)\n",GetLastError());
1747 msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1751 memset(buf,0,sizeof(struct MSVCRT__stat64));
1753 /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
1754 Bon 011120: This FIXME seems incorrect
1755 Also a letter as first char isn't enough to be classified
1758 if (isalpha(*path)&& (*(path+1)==':'))
1759 buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
1761 buf->st_dev = buf->st_rdev = _getdrive() - 1;
1763 plen = strlen(path);
1765 /* Dir, or regular file? */
1766 if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1767 (path[plen-1] == '\\'))
1768 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
1771 mode |= MSVCRT__S_IFREG;
1773 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
1775 unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
1776 (tolower(path[plen-3]) << 16);
1777 if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
1778 mode |= ALL_S_IEXEC;
1782 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1783 mode |= ALL_S_IWRITE;
1785 buf->st_mode = mode;
1787 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1788 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1790 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1791 buf->st_mtime = buf->st_ctime = dw;
1792 TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf->st_mode,buf->st_nlink,
1793 (long)(buf->st_size >> 32),(long)buf->st_size,
1794 (long)buf->st_atime,(long)buf->st_mtime,(long)buf->st_ctime);
1798 /*********************************************************************
1799 * _stati64 (MSVCRT.@)
1801 int CDECL MSVCRT__stati64(const char* path, struct MSVCRT__stati64 * buf)
1804 struct MSVCRT__stat64 buf64;
1806 ret = MSVCRT__stat64(path, &buf64);
1808 msvcrt_stat64_to_stati64(&buf64, buf);
1812 /*********************************************************************
1815 int CDECL MSVCRT__stat(const char* path, struct MSVCRT__stat * buf)
1817 struct MSVCRT__stat64 buf64;
1819 ret = MSVCRT__stat64( path, &buf64);
1821 msvcrt_stat64_to_stat(&buf64, buf);
1825 /*********************************************************************
1826 * _wstat64 (MSVCRT.@)
1828 int CDECL MSVCRT__wstat64(const MSVCRT_wchar_t* path, struct MSVCRT__stat64 * buf)
1831 WIN32_FILE_ATTRIBUTE_DATA hfi;
1832 unsigned short mode = ALL_S_IREAD;
1835 TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
1837 if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
1839 TRACE("failed (%d)\n",GetLastError());
1840 msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1844 memset(buf,0,sizeof(struct MSVCRT__stat64));
1846 /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
1847 if (MSVCRT_iswalpha(*path))
1848 buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
1850 buf->st_dev = buf->st_rdev = _getdrive() - 1;
1852 plen = strlenW(path);
1854 /* Dir, or regular file? */
1855 if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1856 (path[plen-1] == '\\'))
1857 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
1860 mode |= MSVCRT__S_IFREG;
1862 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
1864 ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
1865 ((ULONGLONG)tolowerW(path[plen-3]) << 32);
1866 if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
1867 mode |= ALL_S_IEXEC;
1871 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1872 mode |= ALL_S_IWRITE;
1874 buf->st_mode = mode;
1876 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1877 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1879 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1880 buf->st_mtime = buf->st_ctime = dw;
1881 TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf->st_mode,buf->st_nlink,
1882 (long)(buf->st_size >> 32),(long)buf->st_size,
1883 (long)buf->st_atime,(long)buf->st_mtime,(long)buf->st_ctime);
1887 /*********************************************************************
1888 * _wstati64 (MSVCRT.@)
1890 int CDECL MSVCRT__wstati64(const MSVCRT_wchar_t* path, struct MSVCRT__stati64 * buf)
1893 struct MSVCRT__stat64 buf64;
1895 ret = MSVCRT__wstat64(path, &buf64);
1897 msvcrt_stat64_to_stati64(&buf64, buf);
1901 /*********************************************************************
1904 int CDECL MSVCRT__wstat(const MSVCRT_wchar_t* path, struct MSVCRT__stat * buf)
1907 struct MSVCRT__stat64 buf64;
1909 ret = MSVCRT__wstat64( path, &buf64 );
1910 if (!ret) msvcrt_stat64_to_stat(&buf64, buf);
1914 /*********************************************************************
1917 long CDECL _tell(int fd)
1919 return _lseek(fd, 0, SEEK_CUR);
1922 /*********************************************************************
1923 * _telli64 (MSVCRT.@)
1925 __int64 CDECL _telli64(int fd)
1927 return _lseeki64(fd, 0, SEEK_CUR);
1930 /*********************************************************************
1931 * _tempnam (MSVCRT.@)
1933 char * CDECL _tempnam(const char *dir, const char *prefix)
1935 char tmpbuf[MAX_PATH];
1936 const char *tmp_dir = MSVCRT_getenv("TMP");
1938 if (tmp_dir) dir = tmp_dir;
1940 TRACE("dir (%s) prefix (%s)\n",dir,prefix);
1941 if (GetTempFileNameA(dir,prefix,0,tmpbuf))
1943 TRACE("got name (%s)\n",tmpbuf);
1944 DeleteFileA(tmpbuf);
1945 return _strdup(tmpbuf);
1947 TRACE("failed (%d)\n",GetLastError());
1951 /*********************************************************************
1952 * _wtempnam (MSVCRT.@)
1954 MSVCRT_wchar_t * CDECL _wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
1956 MSVCRT_wchar_t tmpbuf[MAX_PATH];
1958 TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
1959 if (GetTempFileNameW(dir,prefix,0,tmpbuf))
1961 TRACE("got name (%s)\n",debugstr_w(tmpbuf));
1962 DeleteFileW(tmpbuf);
1963 return _wcsdup(tmpbuf);
1965 TRACE("failed (%d)\n",GetLastError());
1969 /*********************************************************************
1972 int CDECL _umask(int umask)
1974 int old_umask = MSVCRT_umask;
1975 TRACE("(%d)\n",umask);
1976 MSVCRT_umask = umask;
1980 /*********************************************************************
1983 int CDECL _utime(const char* path, struct MSVCRT__utimbuf *t)
1985 int fd = _open(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
1989 int retVal = _futime(fd, t);
1996 /*********************************************************************
1997 * _wutime (MSVCRT.@)
1999 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT__utimbuf *t)
2001 int fd = _wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
2005 int retVal = _futime(fd, t);
2012 /*********************************************************************
2015 int CDECL _write(int fd, const void* buf, unsigned int count)
2018 HANDLE hand = msvcrt_fdtoh(fd);
2020 /* Don't trace small writes, it gets *very* annoying */
2023 TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
2025 if (hand == INVALID_HANDLE_VALUE)
2027 *MSVCRT__errno() = MSVCRT_EBADF;
2031 /* If appending, go to EOF */
2032 if (MSVCRT_fdesc[fd].wxflag & WX_APPEND)
2033 _lseek(fd, 0, FILE_END);
2035 if (!(MSVCRT_fdesc[fd].wxflag & WX_TEXT))
2037 if (WriteFile(hand, buf, count, &num_written, NULL)
2038 && (num_written == count))
2040 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d)\n", fd,
2041 hand, GetLastError());
2042 *MSVCRT__errno() = MSVCRT_ENOSPC;
2046 unsigned int i, j, nr_lf;
2049 const char *s = (const char *)buf, *buf_start = (const char *)buf;
2050 /* find number of \n ( without preceding \r ) */
2051 for ( nr_lf=0,i = 0; i <count; i++)
2056 /*if ((i >1) && (s[i-1] == '\r')) nr_lf--; */
2061 if ((q = p = MSVCRT_malloc(count + nr_lf)))
2063 for (s = (const char *)buf, i = 0, j = 0; i < count; i++)
2068 /*if ((i >1) && (s[i-1] == '\r'))j--;*/
2075 FIXME("Malloc failed\n");
2083 if ((WriteFile(hand, q, count+nr_lf, &num_written, NULL) == 0 ) || (num_written != count+nr_lf))
2085 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d), num_written %d\n",
2086 fd, hand, GetLastError(), num_written);
2087 *MSVCRT__errno() = MSVCRT_ENOSPC;
2090 return s - buf_start;
2102 /*********************************************************************
2105 int CDECL MSVCRT__putw(int val, MSVCRT_FILE* file)
2108 len = _write(file->_file, &val, sizeof(val));
2109 if (len == sizeof(val)) return val;
2110 file->_flag |= MSVCRT__IOERR;
2114 /*********************************************************************
2117 int CDECL MSVCRT_fclose(MSVCRT_FILE* file)
2122 MSVCRT_free(file->_tmpfname);
2123 file->_tmpfname = NULL;
2124 /* flush stdio buffers */
2125 if(file->_flag & MSVCRT__IOWRT)
2126 MSVCRT_fflush(file);
2127 if(file->_flag & MSVCRT__IOMYBUF)
2128 MSVCRT_free(file->_base);
2130 r=_close(file->_file);
2134 return ((r == -1) || (flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
2137 /*********************************************************************
2140 int CDECL MSVCRT_feof(MSVCRT_FILE* file)
2142 return file->_flag & MSVCRT__IOEOF;
2145 /*********************************************************************
2148 int CDECL MSVCRT_ferror(MSVCRT_FILE* file)
2150 return file->_flag & MSVCRT__IOERR;
2153 /*********************************************************************
2154 * _filbuf (MSVCRT.@)
2156 int CDECL MSVCRT__filbuf(MSVCRT_FILE* file)
2158 /* Allocate buffer if needed */
2159 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF) ) {
2160 msvcrt_alloc_buffer(file);
2162 if(!(file->_flag & MSVCRT__IOREAD)) {
2163 if(file->_flag & MSVCRT__IORW) {
2164 file->_flag |= MSVCRT__IOREAD;
2169 if(file->_flag & MSVCRT__IONBF) {
2172 if ((r = read_i(file->_file,&c,1)) != 1) {
2173 file->_flag |= (r == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
2178 file->_cnt = read_i(file->_file, file->_base, file->_bufsiz);
2180 file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
2185 file->_ptr = file->_base+1;
2186 return *(unsigned char *)file->_base;
2190 /*********************************************************************
2193 int CDECL MSVCRT_fgetc(MSVCRT_FILE* file)
2200 i = (unsigned char *)file->_ptr++;
2203 j = MSVCRT__filbuf(file);
2204 if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT) || (j != '\r'))
2209 /*********************************************************************
2210 * _fgetchar (MSVCRT.@)
2212 int CDECL _fgetchar(void)
2214 return MSVCRT_fgetc(MSVCRT_stdin);
2217 /*********************************************************************
2220 char * CDECL MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
2222 int cc = MSVCRT_EOF;
2223 char * buf_start = s;
2225 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
2226 file,file->_file,s,size);
2228 while ((size >1) && (cc = MSVCRT_fgetc(file)) != MSVCRT_EOF && cc != '\n')
2233 if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
2235 TRACE(":nothing read\n");
2238 if ((cc != MSVCRT_EOF) && (size > 1))
2241 TRACE(":got %s\n", debugstr_a(buf_start));
2245 /*********************************************************************
2248 * In MSVCRT__O_TEXT mode, multibyte characters are read from the file, dropping
2249 * the CR from CR/LF combinations
2251 MSVCRT_wint_t CDECL MSVCRT_fgetwc(MSVCRT_FILE* file)
2255 if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
2261 for(i=0; i<sizeof(wc); i++)
2271 j = MSVCRT__filbuf(file);
2274 file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
2284 c = MSVCRT_fgetc(file);
2285 if ((*__p___mb_cur_max() > 1) && MSVCRT_isleadbyte(c))
2287 FIXME("Treat Multibyte characters\n");
2289 if (c == MSVCRT_EOF)
2292 return (MSVCRT_wint_t)c;
2295 /*********************************************************************
2298 int CDECL MSVCRT__getw(MSVCRT_FILE* file)
2303 for (j=0; j<sizeof(int); j++) {
2304 k = MSVCRT_fgetc(file);
2305 if (k == MSVCRT_EOF) {
2306 file->_flag |= MSVCRT__IOEOF;
2314 /*********************************************************************
2317 MSVCRT_wint_t CDECL MSVCRT_getwc(MSVCRT_FILE* file)
2319 return MSVCRT_fgetwc(file);
2322 /*********************************************************************
2323 * _fgetwchar (MSVCRT.@)
2325 MSVCRT_wint_t CDECL _fgetwchar(void)
2327 return MSVCRT_fgetwc(MSVCRT_stdin);
2330 /*********************************************************************
2331 * getwchar (MSVCRT.@)
2333 MSVCRT_wint_t CDECL MSVCRT_getwchar(void)
2335 return _fgetwchar();
2338 /*********************************************************************
2341 MSVCRT_wchar_t * CDECL MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
2343 int cc = MSVCRT_WEOF;
2344 MSVCRT_wchar_t * buf_start = s;
2346 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
2347 file,file->_file,s,size);
2349 while ((size >1) && (cc = MSVCRT_fgetwc(file)) != MSVCRT_WEOF && cc != '\n')
2354 if ((cc == MSVCRT_WEOF) && (s == buf_start)) /* If nothing read, return 0*/
2356 TRACE(":nothing read\n");
2359 if ((cc != MSVCRT_WEOF) && (size > 1))
2362 TRACE(":got %s\n", debugstr_w(buf_start));
2366 /*********************************************************************
2369 MSVCRT_size_t CDECL MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
2371 MSVCRT_size_t wrcnt=size * nmemb;
2376 int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
2377 memcpy(file->_ptr, ptr, pcnt);
2382 ptr = (const char*)ptr + pcnt;
2383 } else if(!(file->_flag & MSVCRT__IOWRT)) {
2384 if(file->_flag & MSVCRT__IORW) {
2385 file->_flag |= MSVCRT__IOWRT;
2391 int res=msvcrt_flush_buffer(file);
2393 int pwritten = _write(file->_file, ptr, wrcnt);
2396 file->_flag |= MSVCRT__IOERR;
2399 written += pwritten;
2402 return written / size;
2405 /*********************************************************************
2408 MSVCRT_wint_t CDECL MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
2410 MSVCRT_wchar_t mwc=wc;
2411 if (MSVCRT_fwrite( &mwc, sizeof(mwc), 1, file) != 1)
2416 /*********************************************************************
2417 * _fputwchar (MSVCRT.@)
2419 MSVCRT_wint_t CDECL _fputwchar(MSVCRT_wint_t wc)
2421 return MSVCRT_fputwc(wc, MSVCRT_stdout);
2424 /*********************************************************************
2425 * _fsopen (MSVCRT.@)
2427 MSVCRT_FILE * CDECL MSVCRT__fsopen(const char *path, const char *mode, int share)
2430 int open_flags, stream_flags, fd;
2432 TRACE("(%s,%s)\n",path,mode);
2434 /* map mode string to open() flags. "man fopen" for possibilities. */
2435 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
2439 fd = MSVCRT__sopen(path, open_flags, share, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
2442 else if ((file = msvcrt_alloc_fp()) && msvcrt_init_fp(file, fd, stream_flags)
2444 TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,mode,file);
2451 TRACE(":got (%p)\n",file);
2452 if (fd >= 0 && !file)
2458 /*********************************************************************
2459 * _wfsopen (MSVCRT.@)
2461 MSVCRT_FILE * CDECL MSVCRT__wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
2463 const unsigned int plen = strlenW(path), mlen = strlenW(mode);
2464 char *patha = MSVCRT_calloc(plen + 1, 1);
2465 char *modea = MSVCRT_calloc(mlen + 1, 1);
2467 TRACE("(%s,%s)\n",debugstr_w(path),debugstr_w(mode));
2469 if (patha && modea &&
2470 WideCharToMultiByte(CP_ACP,0,path,plen,patha,plen,NULL,NULL) &&
2471 WideCharToMultiByte(CP_ACP,0,mode,mlen,modea,mlen,NULL,NULL))
2473 MSVCRT_FILE *retval = MSVCRT__fsopen(patha,modea,share);
2479 msvcrt_set_errno(GetLastError());
2483 /*********************************************************************
2486 MSVCRT_FILE * CDECL MSVCRT_fopen(const char *path, const char *mode)
2488 return MSVCRT__fsopen( path, mode, MSVCRT__SH_DENYNO );
2491 /*********************************************************************
2492 * _wfopen (MSVCRT.@)
2494 MSVCRT_FILE * CDECL MSVCRT__wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
2496 return MSVCRT__wfsopen( path, mode, MSVCRT__SH_DENYNO );
2499 /* MSVCRT_fputc calls MSVCRT__flsbuf which calls MSVCRT_fputc */
2500 int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file);
2502 /*********************************************************************
2505 int CDECL MSVCRT_fputc(int c, MSVCRT_FILE* file)
2512 int res = msvcrt_flush_buffer(file);
2513 return res ? res : c;
2518 return MSVCRT__flsbuf(c, file);
2522 /*********************************************************************
2523 * _flsbuf (MSVCRT.@)
2525 int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
2527 /* Flush output buffer */
2528 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
2529 msvcrt_alloc_buffer(file);
2531 if(!(file->_flag & MSVCRT__IOWRT)) {
2532 if(file->_flag & MSVCRT__IORW) {
2533 file->_flag |= MSVCRT__IOWRT;
2539 int res=msvcrt_flush_buffer(file);
2540 return res?res : MSVCRT_fputc(c, file);
2544 len = _write(file->_file, &cc, 1);
2545 if (len == 1) return c;
2546 file->_flag |= MSVCRT__IOERR;
2551 /*********************************************************************
2552 * _fputchar (MSVCRT.@)
2554 int CDECL _fputchar(int c)
2556 return MSVCRT_fputc(c, MSVCRT_stdout);
2559 /*********************************************************************
2562 MSVCRT_size_t CDECL MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
2563 { MSVCRT_size_t rcnt=size * nmemb;
2564 MSVCRT_size_t read=0;
2570 /* first buffered data */
2572 int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
2573 memcpy(ptr, file->_ptr, pcnt);
2576 if (MSVCRT_fdesc[file->_file].wxflag & WX_TEXT)
2577 pcnt -= remove_cr(ptr,pcnt);
2580 ptr = (char*)ptr + pcnt;
2581 } else if(!(file->_flag & MSVCRT__IOREAD )) {
2582 if(file->_flag & MSVCRT__IORW) {
2583 file->_flag |= MSVCRT__IOREAD;
2590 /* Fill the buffer on small reads.
2591 * TODO: Use a better buffering strategy.
2593 if (!file->_cnt && size*nmemb <= MSVCRT_BUFSIZ/2 && !(file->_flag & MSVCRT__IONBF)) {
2594 if (file->_bufsiz == 0) {
2595 msvcrt_alloc_buffer(file);
2597 file->_cnt = _read(file->_file, file->_base, file->_bufsiz);
2598 file->_ptr = file->_base;
2599 i = (file->_cnt<rcnt) ? file->_cnt : rcnt;
2600 /* If the buffer fill reaches eof but fread wouldn't, clear eof. */
2601 if (i > 0 && i < file->_cnt) {
2602 MSVCRT_fdesc[file->_file].wxflag &= ~WX_ATEOF;
2603 file->_flag &= ~MSVCRT__IOEOF;
2606 memcpy(ptr, file->_ptr, i);
2611 i = _read(file->_file,ptr, rcnt);
2615 ptr = (char *)ptr+i;
2616 /* expose feof condition in the flags
2617 * MFC tests file->_flag for feof, and doesn't call feof())
2619 if ( MSVCRT_fdesc[file->_file].wxflag & WX_ATEOF)
2620 file->_flag |= MSVCRT__IOEOF;
2623 file->_flag |= MSVCRT__IOERR;
2633 /*********************************************************************
2634 * freopen (MSVCRT.@)
2637 MSVCRT_FILE* CDECL MSVCRT_freopen(const char *path, const char *mode,MSVCRT_FILE* file)
2639 int open_flags, stream_flags, fd;
2641 TRACE(":path (%p) mode (%s) file (%p) fd (%d)\n",path,mode,file,file->_file);
2644 if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
2648 MSVCRT_fclose(file);
2649 /* map mode string to open() flags. "man fopen" for possibilities. */
2650 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
2654 fd = _open(path, open_flags, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
2657 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
2660 WARN(":failed-last error (%d)\n",GetLastError());
2661 msvcrt_set_errno(GetLastError());
2670 /*********************************************************************
2671 * fsetpos (MSVCRT.@)
2673 int CDECL MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
2675 /* Note that all this has been lifted 'as is' from fseek */
2676 if(file->_flag & MSVCRT__IOWRT)
2677 msvcrt_flush_buffer(file);
2679 /* Discard buffered input */
2681 file->_ptr = file->_base;
2683 /* Reset direction of i/o */
2684 if(file->_flag & MSVCRT__IORW) {
2685 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
2688 return (_lseeki64(file->_file,*pos,SEEK_SET) == -1) ? -1 : 0;
2691 /*********************************************************************
2694 LONG CDECL MSVCRT_ftell(MSVCRT_FILE* file)
2699 if( file->_flag & MSVCRT__IOWRT ) {
2700 off = file->_ptr - file->_base;
2705 pos = _tell(file->_file);
2706 if(pos == -1) return pos;
2710 /*********************************************************************
2711 * fgetpos (MSVCRT.@)
2713 int CDECL MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
2715 /* This code has been lifted form the MSVCRT_ftell function */
2718 *pos = _lseeki64(file->_file,0,SEEK_CUR);
2720 if (*pos == -1) return -1;
2723 if( file->_flag & MSVCRT__IOWRT ) {
2724 off = file->_ptr - file->_base;
2734 /*********************************************************************
2737 int CDECL MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
2739 size_t i, len = strlen(s);
2740 if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
2741 return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
2742 for (i=0; i<len; i++)
2743 if (MSVCRT_fputc(s[i], file) == MSVCRT_EOF)
2748 /*********************************************************************
2751 int CDECL MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
2753 size_t i, len = strlenW(s);
2754 if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
2755 return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
2756 for (i=0; i<len; i++)
2758 if ((s[i] == L'\n') && (MSVCRT_fputc('\r', file) == MSVCRT_EOF))
2760 if (MSVCRT_fputwc(s[i], file) == MSVCRT_WEOF)
2766 /*********************************************************************
2767 * getchar (MSVCRT.@)
2769 int CDECL MSVCRT_getchar(void)
2771 return MSVCRT_fgetc(MSVCRT_stdin);
2774 /*********************************************************************
2777 int CDECL MSVCRT_getc(MSVCRT_FILE* file)
2779 return MSVCRT_fgetc(file);
2782 /*********************************************************************
2785 char * CDECL MSVCRT_gets(char *buf)
2788 char * buf_start = buf;
2790 for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
2791 cc = MSVCRT_fgetc(MSVCRT_stdin))
2792 if(cc != '\r') *buf++ = (char)cc;
2796 TRACE("got '%s'\n", buf_start);
2800 /*********************************************************************
2803 MSVCRT_wchar_t* CDECL MSVCRT__getws(MSVCRT_wchar_t* buf)
2806 MSVCRT_wchar_t* ws = buf;
2808 for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
2809 cc = MSVCRT_fgetwc(MSVCRT_stdin))
2812 *buf++ = (MSVCRT_wchar_t)cc;
2816 TRACE("got %s\n", debugstr_w(ws));
2820 /*********************************************************************
2823 int CDECL MSVCRT_putc(int c, MSVCRT_FILE* file)
2825 return MSVCRT_fputc(c, file);
2828 /*********************************************************************
2829 * putchar (MSVCRT.@)
2831 int CDECL MSVCRT_putchar(int c)
2833 return MSVCRT_fputc(c, MSVCRT_stdout);
2836 /*********************************************************************
2839 int CDECL MSVCRT_puts(const char *s)
2841 size_t len = strlen(s);
2842 if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
2843 return MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
2846 /*********************************************************************
2849 int CDECL _putws(const MSVCRT_wchar_t *s)
2851 static const MSVCRT_wchar_t nl = '\n';
2852 size_t len = strlenW(s);
2853 if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
2854 return MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
2857 /*********************************************************************
2860 int CDECL MSVCRT_remove(const char *path)
2862 TRACE("(%s)\n",path);
2863 if (DeleteFileA(path))
2865 TRACE(":failed (%d)\n",GetLastError());
2866 msvcrt_set_errno(GetLastError());
2870 /*********************************************************************
2871 * _wremove (MSVCRT.@)
2873 int CDECL _wremove(const MSVCRT_wchar_t *path)
2875 TRACE("(%s)\n",debugstr_w(path));
2876 if (DeleteFileW(path))
2878 TRACE(":failed (%d)\n",GetLastError());
2879 msvcrt_set_errno(GetLastError());
2883 /*********************************************************************
2886 int CDECL MSVCRT_rename(const char *oldpath,const char *newpath)
2888 TRACE(":from %s to %s\n",oldpath,newpath);
2889 if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
2891 TRACE(":failed (%d)\n",GetLastError());
2892 msvcrt_set_errno(GetLastError());
2896 /*********************************************************************
2897 * _wrename (MSVCRT.@)
2899 int CDECL _wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
2901 TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
2902 if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
2904 TRACE(":failed (%d)\n",GetLastError());
2905 msvcrt_set_errno(GetLastError());
2909 /*********************************************************************
2910 * setvbuf (MSVCRT.@)
2912 int CDECL MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
2914 /* TODO: Check if file busy */
2916 MSVCRT_free(file->_base);
2920 if(mode == MSVCRT__IOFBF) {
2921 file->_flag &= ~MSVCRT__IONBF;
2922 file->_base = file->_ptr = buf;
2924 file->_bufsiz = size;
2927 file->_flag |= MSVCRT__IONBF;
2932 /*********************************************************************
2935 void CDECL MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
2937 MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
2940 /*********************************************************************
2943 char * CDECL MSVCRT_tmpnam(char *s)
2951 msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
2952 p = s + sprintf(s, "\\s%s.", tmpstr);
2953 for (count = 0; count < MSVCRT_TMP_MAX; count++)
2955 msvcrt_int_to_base32(unique++, tmpstr);
2957 if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
2958 GetLastError() == ERROR_FILE_NOT_FOUND)
2964 /*********************************************************************
2965 * tmpfile (MSVCRT.@)
2967 MSVCRT_FILE* CDECL MSVCRT_tmpfile(void)
2969 char *filename = MSVCRT_tmpnam(NULL);
2971 MSVCRT_FILE* file = NULL;
2974 fd = _open(filename, MSVCRT__O_CREAT | MSVCRT__O_BINARY | MSVCRT__O_RDWR | MSVCRT__O_TEMPORARY);
2975 if (fd != -1 && (file = msvcrt_alloc_fp()))
2977 if (msvcrt_init_fp(file, fd, MSVCRT__O_RDWR) == -1)
2982 else file->_tmpfname = _strdup(filename);
2988 /*********************************************************************
2989 * vfprintf (MSVCRT.@)
2991 int CDECL MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, va_list valist)
2993 char buf[2048], *mem = buf;
2994 int written, resize = sizeof(buf), retval;
2995 /* There are two conventions for vsnprintf failing:
2996 * Return -1 if we truncated, or
2997 * Return the number of bytes that would have been written
2998 * The code below handles both cases
3000 while ((written = MSVCRT_vsnprintf(mem, resize, format, valist)) == -1 ||
3003 resize = (written == -1 ? resize * 2 : written + 1);
3006 if (!(mem = (char *)MSVCRT_malloc(resize)))
3009 retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
3015 /*********************************************************************
3016 * vfwprintf (MSVCRT.@)
3018 * Is final char included in written (then resize is too big) or not
3019 * (then we must test for equality too)?
3021 int CDECL MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, va_list valist)
3023 MSVCRT_wchar_t buf[2048], *mem = buf;
3024 int written, resize = sizeof(buf) / sizeof(MSVCRT_wchar_t), retval;
3025 /* See vfprintf comments */
3026 while ((written = MSVCRT_vsnwprintf(mem, resize, format, valist)) == -1 ||
3029 resize = (written == -1 ? resize * 2 : written + sizeof(MSVCRT_wchar_t));
3032 if (!(mem = (MSVCRT_wchar_t *)MSVCRT_malloc(resize*sizeof(*mem))))
3035 retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
3041 /*********************************************************************
3042 * vprintf (MSVCRT.@)
3044 int CDECL MSVCRT_vprintf(const char *format, va_list valist)
3046 return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
3049 /*********************************************************************
3050 * vwprintf (MSVCRT.@)
3052 int CDECL MSVCRT_vwprintf(const MSVCRT_wchar_t *format, va_list valist)
3054 return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
3057 /*********************************************************************
3058 * fprintf (MSVCRT.@)
3060 int CDECL MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
3064 va_start(valist, format);
3065 res = MSVCRT_vfprintf(file, format, valist);
3070 /*********************************************************************
3071 * fwprintf (MSVCRT.@)
3073 int CDECL MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
3077 va_start(valist, format);
3078 res = MSVCRT_vfwprintf(file, format, valist);
3083 /*********************************************************************
3086 int CDECL MSVCRT_printf(const char *format, ...)
3090 va_start(valist, format);
3091 res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
3096 /*********************************************************************
3099 int CDECL MSVCRT_ungetc(int c, MSVCRT_FILE * file)
3101 if (c == MSVCRT_EOF)
3103 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
3104 msvcrt_alloc_buffer(file);
3107 if(file->_ptr>file->_base) {
3111 MSVCRT_clearerr(file);
3117 /*********************************************************************
3118 * ungetwc (MSVCRT.@)
3120 MSVCRT_wint_t CDECL MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
3122 MSVCRT_wchar_t mwc = wc;
3123 char * pp = (char *)&mwc;
3125 for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
3126 if(pp[i] != MSVCRT_ungetc(pp[i],file))
3132 /*********************************************************************
3133 * wprintf (MSVCRT.@)
3135 int CDECL MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
3139 va_start(valist, format);
3140 res = MSVCRT_vwprintf(format, valist);
3145 /*********************************************************************
3146 * _getmaxstdio (MSVCRT.@)
3148 int CDECL _getmaxstdio(void)
3150 FIXME("stub, always returns 512\n");
3154 /*********************************************************************
3155 * _setmaxstdio_ (MSVCRT.@)
3157 int CDECL _setmaxstdio(int newmax)
3164 FIXME("stub: setting new maximum for number of simultaneously open files not implemented,returning %d\n",res);
3168 /*********************************************************************
3169 * __pioinfo (MSVCRT.@)
3170 * FIXME: see MSVCRT_MAX_FILES define.
3172 ioinfo * MSVCRT___pioinfo[] = { /* array of pointers to ioinfo arrays [64] */
3173 &MSVCRT_fdesc[0 * 64], &MSVCRT_fdesc[1 * 64], &MSVCRT_fdesc[2 * 64],
3174 &MSVCRT_fdesc[3 * 64], &MSVCRT_fdesc[4 * 64], &MSVCRT_fdesc[5 * 64],
3175 &MSVCRT_fdesc[6 * 64], &MSVCRT_fdesc[7 * 64], &MSVCRT_fdesc[8 * 64],
3176 &MSVCRT_fdesc[9 * 64], &MSVCRT_fdesc[10 * 64], &MSVCRT_fdesc[11 * 64],
3177 &MSVCRT_fdesc[12 * 64], &MSVCRT_fdesc[13 * 64], &MSVCRT_fdesc[14 * 64],
3178 &MSVCRT_fdesc[15 * 64], &MSVCRT_fdesc[16 * 64], &MSVCRT_fdesc[17 * 64],
3179 &MSVCRT_fdesc[18 * 64], &MSVCRT_fdesc[19 * 64], &MSVCRT_fdesc[20 * 64],
3180 &MSVCRT_fdesc[21 * 64], &MSVCRT_fdesc[22 * 64], &MSVCRT_fdesc[23 * 64],
3181 &MSVCRT_fdesc[24 * 64], &MSVCRT_fdesc[25 * 64], &MSVCRT_fdesc[26 * 64],
3182 &MSVCRT_fdesc[27 * 64], &MSVCRT_fdesc[28 * 64], &MSVCRT_fdesc[29 * 64],
3183 &MSVCRT_fdesc[30 * 64], &MSVCRT_fdesc[31 * 64]
3186 /*********************************************************************
3187 * __badioinfo (MSVCRT.@)
3189 ioinfo MSVCRT___badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };