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_cp_from_stati64(const struct MSVCRT__stati64
*bufi64
, struct MSVCRT__stat
*buf
)
116 buf
->st_dev
= bufi64
->st_dev
;
117 buf
->st_ino
= bufi64
->st_ino
;
118 buf
->st_mode
= bufi64
->st_mode
;
119 buf
->st_nlink
= bufi64
->st_nlink
;
120 buf
->st_uid
= bufi64
->st_uid
;
121 buf
->st_gid
= bufi64
->st_gid
;
122 buf
->st_rdev
= bufi64
->st_rdev
;
123 buf
->st_size
= bufi64
->st_size
;
124 buf
->st_atime
= bufi64
->st_atime
;
125 buf
->st_mtime
= bufi64
->st_mtime
;
126 buf
->st_ctime
= bufi64
->st_ctime
;
129 static inline BOOL
msvcrt_is_valid_fd(int fd
)
131 return fd
>= 0 && fd
< MSVCRT_fdend
&& (MSVCRT_fdesc
[fd
].wxflag
& WX_OPEN
);
134 /* INTERNAL: Get the HANDLE for a fd
135 * This doesn't lock the table, because a failure will result in
136 * INVALID_HANDLE_VALUE being returned, which should be handled correctly. If
137 * it returns a valid handle which is about to be closed, a subsequent call
138 * will fail, most likely in a sane way.
140 static HANDLE
msvcrt_fdtoh(int fd
)
142 if (!msvcrt_is_valid_fd(fd
))
144 WARN(":fd (%d) - no handle!\n",fd
);
145 *MSVCRT___doserrno() = 0;
146 *MSVCRT__errno() = MSVCRT_EBADF
;
147 return INVALID_HANDLE_VALUE
;
149 if (MSVCRT_fdesc
[fd
].handle
== INVALID_HANDLE_VALUE
) FIXME("wtf\n");
150 return MSVCRT_fdesc
[fd
].handle
;
153 /* INTERNAL: free a file entry fd */
154 static void msvcrt_free_fd(int fd
)
157 MSVCRT_fdesc
[fd
].handle
= INVALID_HANDLE_VALUE
;
158 MSVCRT_fdesc
[fd
].wxflag
= 0;
159 TRACE(":fd (%d) freed\n",fd
);
160 if (fd
< 3) /* don't use 0,1,2 for user files */
164 case 0: SetStdHandle(STD_INPUT_HANDLE
, NULL
); break;
165 case 1: SetStdHandle(STD_OUTPUT_HANDLE
, NULL
); break;
166 case 2: SetStdHandle(STD_ERROR_HANDLE
, NULL
); break;
171 if (fd
== MSVCRT_fdend
- 1)
173 if (fd
< MSVCRT_fdstart
)
179 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE, starting from fd */
180 /* caller must hold the files lock */
181 static int msvcrt_alloc_fd_from(HANDLE hand
, int flag
, int fd
)
183 if (fd
>= MSVCRT_MAX_FILES
)
185 WARN(":files exhausted!\n");
188 MSVCRT_fdesc
[fd
].handle
= hand
;
189 MSVCRT_fdesc
[fd
].wxflag
= WX_OPEN
| (flag
& (WX_DONTINHERIT
| WX_APPEND
| WX_TEXT
));
191 /* locate next free slot */
192 if (fd
== MSVCRT_fdstart
&& fd
== MSVCRT_fdend
)
193 MSVCRT_fdstart
= MSVCRT_fdend
+ 1;
195 while (MSVCRT_fdstart
< MSVCRT_fdend
&&
196 MSVCRT_fdesc
[MSVCRT_fdstart
].handle
!= INVALID_HANDLE_VALUE
)
198 /* update last fd in use */
199 if (fd
>= MSVCRT_fdend
)
200 MSVCRT_fdend
= fd
+ 1;
201 TRACE("fdstart is %d, fdend is %d\n", MSVCRT_fdstart
, MSVCRT_fdend
);
205 case 0: SetStdHandle(STD_INPUT_HANDLE
, hand
); break;
206 case 1: SetStdHandle(STD_OUTPUT_HANDLE
, hand
); break;
207 case 2: SetStdHandle(STD_ERROR_HANDLE
, hand
); break;
213 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
214 static int msvcrt_alloc_fd(HANDLE hand
, int flag
)
219 TRACE(":handle (%p) allocating fd (%d)\n",hand
,MSVCRT_fdstart
);
220 ret
= msvcrt_alloc_fd_from(hand
, flag
, MSVCRT_fdstart
);
225 /* INTERNAL: Allocate a FILE* for an fd slot */
226 /* caller must hold the files lock */
227 static MSVCRT_FILE
* msvcrt_alloc_fp(void)
231 for (i
= 3; i
< sizeof(MSVCRT_fstreams
) / sizeof(MSVCRT_fstreams
[0]); i
++)
233 if (!MSVCRT_fstreams
[i
] || MSVCRT_fstreams
[i
]->_flag
== 0)
235 if (!MSVCRT_fstreams
[i
])
237 if (!(MSVCRT_fstreams
[i
] = MSVCRT_calloc(sizeof(MSVCRT_FILE
),1)))
239 if (i
== MSVCRT_stream_idx
) MSVCRT_stream_idx
++;
241 return MSVCRT_fstreams
[i
];
247 /* INTERNAL: initialize a FILE* from an open fd */
248 static int msvcrt_init_fp(MSVCRT_FILE
* file
, int fd
, unsigned stream_flags
)
250 TRACE(":fd (%d) allocating FILE*\n",fd
);
251 if (!msvcrt_is_valid_fd(fd
))
253 WARN(":invalid fd %d\n",fd
);
254 *MSVCRT___doserrno() = 0;
255 *MSVCRT__errno() = MSVCRT_EBADF
;
258 memset(file
, 0, sizeof(*file
));
260 file
->_flag
= stream_flags
;
262 TRACE(":got FILE* (%p)\n",file
);
266 /* INTERNAL: Create an inheritance data block (for spawned process)
267 * The inheritance block is made of:
268 * 00 int nb of file descriptor (NBFD)
269 * 04 char file flags (wxflag): repeated for each fd
270 * 4+NBFD HANDLE file handle: repeated for each fd
272 unsigned msvcrt_create_io_inherit_block(STARTUPINFOA
* si
)
278 si
->cbReserved2
= sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE
)) * MSVCRT_fdend
;
279 si
->lpReserved2
= MSVCRT_calloc(si
->cbReserved2
, 1);
280 if (!si
->lpReserved2
)
285 wxflag_ptr
= (char*)si
->lpReserved2
+ sizeof(unsigned);
286 handle_ptr
= (HANDLE
*)(wxflag_ptr
+ MSVCRT_fdend
* sizeof(char));
288 *(unsigned*)si
->lpReserved2
= MSVCRT_fdend
;
289 for (fd
= 0; fd
< MSVCRT_fdend
; fd
++)
291 /* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
292 if ((MSVCRT_fdesc
[fd
].wxflag
& (WX_OPEN
| WX_DONTINHERIT
)) == WX_OPEN
)
294 *wxflag_ptr
= MSVCRT_fdesc
[fd
].wxflag
;
295 *handle_ptr
= MSVCRT_fdesc
[fd
].handle
;
300 *handle_ptr
= INVALID_HANDLE_VALUE
;
302 wxflag_ptr
++; handle_ptr
++;
307 /* INTERNAL: Set up all file descriptors,
308 * as well as default streams (stdin, stderr and stdout)
310 void msvcrt_init_io(void)
315 InitializeCriticalSection(&MSVCRT_file_cs
);
316 GetStartupInfoA(&si
);
317 if (si
.cbReserved2
!= 0 && si
.lpReserved2
!= NULL
)
322 MSVCRT_fdend
= *(unsigned*)si
.lpReserved2
;
324 wxflag_ptr
= (char*)(si
.lpReserved2
+ sizeof(unsigned));
325 handle_ptr
= (HANDLE
*)(wxflag_ptr
+ MSVCRT_fdend
* sizeof(char));
327 MSVCRT_fdend
= min(MSVCRT_fdend
, sizeof(MSVCRT_fdesc
) / sizeof(MSVCRT_fdesc
[0]));
328 for (i
= 0; i
< MSVCRT_fdend
; i
++)
330 if ((*wxflag_ptr
& WX_OPEN
) && *handle_ptr
!= INVALID_HANDLE_VALUE
)
332 MSVCRT_fdesc
[i
].wxflag
= *wxflag_ptr
;
333 MSVCRT_fdesc
[i
].handle
= *handle_ptr
;
337 MSVCRT_fdesc
[i
].wxflag
= 0;
338 MSVCRT_fdesc
[i
].handle
= INVALID_HANDLE_VALUE
;
340 wxflag_ptr
++; handle_ptr
++;
342 for (MSVCRT_fdstart
= 3; MSVCRT_fdstart
< MSVCRT_fdend
; MSVCRT_fdstart
++)
343 if (MSVCRT_fdesc
[MSVCRT_fdstart
].handle
== INVALID_HANDLE_VALUE
) break;
346 if (!(MSVCRT_fdesc
[0].wxflag
& WX_OPEN
) || MSVCRT_fdesc
[0].handle
== INVALID_HANDLE_VALUE
)
348 DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE
),
349 GetCurrentProcess(), &MSVCRT_fdesc
[0].handle
, 0, TRUE
,
350 DUPLICATE_SAME_ACCESS
);
351 MSVCRT_fdesc
[0].wxflag
= WX_OPEN
| WX_TEXT
;
353 if (!(MSVCRT_fdesc
[1].wxflag
& WX_OPEN
) || MSVCRT_fdesc
[1].handle
== INVALID_HANDLE_VALUE
)
355 DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_OUTPUT_HANDLE
),
356 GetCurrentProcess(), &MSVCRT_fdesc
[1].handle
, 0, TRUE
,
357 DUPLICATE_SAME_ACCESS
);
358 MSVCRT_fdesc
[1].wxflag
= WX_OPEN
| WX_TEXT
;
360 if (!(MSVCRT_fdesc
[2].wxflag
& WX_OPEN
) || MSVCRT_fdesc
[2].handle
== INVALID_HANDLE_VALUE
)
362 DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_ERROR_HANDLE
),
363 GetCurrentProcess(), &MSVCRT_fdesc
[2].handle
, 0, TRUE
,
364 DUPLICATE_SAME_ACCESS
);
365 MSVCRT_fdesc
[2].wxflag
= WX_OPEN
| WX_TEXT
;
368 TRACE(":handles (%p)(%p)(%p)\n",MSVCRT_fdesc
[0].handle
,
369 MSVCRT_fdesc
[1].handle
,MSVCRT_fdesc
[2].handle
);
371 memset(MSVCRT__iob
,0,3*sizeof(MSVCRT_FILE
));
372 for (i
= 0; i
< 3; i
++)
374 /* FILE structs for stdin/out/err are static and never deleted */
375 MSVCRT_fstreams
[i
] = &MSVCRT__iob
[i
];
376 MSVCRT__iob
[i
]._file
= i
;
377 MSVCRT__iob
[i
]._tmpfname
= NULL
;
378 MSVCRT__iob
[i
]._flag
= (i
== 0) ? MSVCRT__IOREAD
: MSVCRT__IOWRT
;
380 MSVCRT_stream_idx
= 3;
383 /* INTERNAL: Flush stdio file buffer */
384 static int msvcrt_flush_buffer(MSVCRT_FILE
* file
)
387 int cnt
=file
->_ptr
-file
->_base
;
388 if(cnt
>0 && _write(file
->_file
, file
->_base
, cnt
) != cnt
) {
389 file
->_flag
|= MSVCRT__IOERR
;
392 file
->_ptr
=file
->_base
;
393 file
->_cnt
=file
->_bufsiz
;
398 /* INTERNAL: Allocate stdio file buffer */
399 static void msvcrt_alloc_buffer(MSVCRT_FILE
* file
)
401 file
->_base
= MSVCRT_calloc(MSVCRT_BUFSIZ
,1);
403 file
->_bufsiz
= MSVCRT_BUFSIZ
;
404 file
->_flag
|= MSVCRT__IOMYBUF
;
406 file
->_base
= (char*)(&file
->_charbuf
);
408 file
->_bufsiz
= sizeof(file
->_charbuf
);
410 file
->_ptr
= file
->_base
;
414 /* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
415 static void msvcrt_int_to_base32(int num
, char *str
)
430 *p
= (num
& 31) + '0';
432 *p
+= ('a' - '0' - 10);
437 /*********************************************************************
440 MSVCRT_FILE
* CDECL
__p__iob(void)
442 return &MSVCRT__iob
[0];
445 /*********************************************************************
448 int CDECL
_access(const char *filename
, int mode
)
450 DWORD attr
= GetFileAttributesA(filename
);
452 TRACE("(%s,%d) %d\n",filename
,mode
,attr
);
454 if (!filename
|| attr
== INVALID_FILE_ATTRIBUTES
)
456 msvcrt_set_errno(GetLastError());
459 if ((attr
& FILE_ATTRIBUTE_READONLY
) && (mode
& MSVCRT_W_OK
))
461 msvcrt_set_errno(ERROR_ACCESS_DENIED
);
467 /*********************************************************************
468 * _waccess (MSVCRT.@)
470 int CDECL
_waccess(const MSVCRT_wchar_t
*filename
, int mode
)
472 DWORD attr
= GetFileAttributesW(filename
);
474 TRACE("(%s,%d) %d\n",debugstr_w(filename
),mode
,attr
);
476 if (!filename
|| attr
== INVALID_FILE_ATTRIBUTES
)
478 msvcrt_set_errno(GetLastError());
481 if ((attr
& FILE_ATTRIBUTE_READONLY
) && (mode
& MSVCRT_W_OK
))
483 msvcrt_set_errno(ERROR_ACCESS_DENIED
);
489 /*********************************************************************
492 int CDECL
_chmod(const char *path
, int flags
)
494 DWORD oldFlags
= GetFileAttributesA(path
);
496 if (oldFlags
!= INVALID_FILE_ATTRIBUTES
)
498 DWORD newFlags
= (flags
& MSVCRT__S_IWRITE
)? oldFlags
& ~FILE_ATTRIBUTE_READONLY
:
499 oldFlags
| FILE_ATTRIBUTE_READONLY
;
501 if (newFlags
== oldFlags
|| SetFileAttributesA(path
, newFlags
))
504 msvcrt_set_errno(GetLastError());
508 /*********************************************************************
511 int CDECL
_wchmod(const MSVCRT_wchar_t
*path
, int flags
)
513 DWORD oldFlags
= GetFileAttributesW(path
);
515 if (oldFlags
!= INVALID_FILE_ATTRIBUTES
)
517 DWORD newFlags
= (flags
& MSVCRT__S_IWRITE
)? oldFlags
& ~FILE_ATTRIBUTE_READONLY
:
518 oldFlags
| FILE_ATTRIBUTE_READONLY
;
520 if (newFlags
== oldFlags
|| SetFileAttributesW(path
, newFlags
))
523 msvcrt_set_errno(GetLastError());
527 /*********************************************************************
530 int CDECL
_unlink(const char *path
)
532 TRACE("%s\n",debugstr_a(path
));
533 if(DeleteFileA(path
))
535 TRACE("failed (%d)\n",GetLastError());
536 msvcrt_set_errno(GetLastError());
540 /*********************************************************************
541 * _wunlink (MSVCRT.@)
543 int CDECL
_wunlink(const MSVCRT_wchar_t
*path
)
545 TRACE("(%s)\n",debugstr_w(path
));
546 if(DeleteFileW(path
))
548 TRACE("failed (%d)\n",GetLastError());
549 msvcrt_set_errno(GetLastError());
553 /* _flushall calls MSVCRT_fflush which calls _flushall */
554 int CDECL
MSVCRT_fflush(MSVCRT_FILE
* file
);
556 /*********************************************************************
557 * _flushall (MSVCRT.@)
559 int CDECL
_flushall(void)
561 int i
, num_flushed
= 0;
564 for (i
= 3; i
< MSVCRT_stream_idx
; i
++)
565 if (MSVCRT_fstreams
[i
] && MSVCRT_fstreams
[i
]->_flag
)
568 /* FIXME: flush, do not commit */
569 if (_commit(i
) == -1)
570 if (MSVCRT_fstreams
[i
])
571 MSVCRT_fstreams
[i
]->_flag
|= MSVCRT__IOERR
;
573 if(MSVCRT_fstreams
[i
]->_flag
& MSVCRT__IOWRT
) {
574 MSVCRT_fflush(MSVCRT_fstreams
[i
]);
580 TRACE(":flushed (%d) handles\n",num_flushed
);
584 /*********************************************************************
587 int CDECL
MSVCRT_fflush(MSVCRT_FILE
* file
)
591 } else if(file
->_flag
& MSVCRT__IOWRT
) {
592 int res
=msvcrt_flush_buffer(file
);
598 /*********************************************************************
601 int CDECL
_close(int fd
)
607 hand
= msvcrt_fdtoh(fd
);
608 TRACE(":fd (%d) handle (%p)\n",fd
,hand
);
609 if (hand
== INVALID_HANDLE_VALUE
)
611 else if (!CloseHandle(hand
))
613 WARN(":failed-last error (%d)\n",GetLastError());
614 msvcrt_set_errno(GetLastError());
627 /*********************************************************************
630 int CDECL
_commit(int fd
)
632 HANDLE hand
= msvcrt_fdtoh(fd
);
634 TRACE(":fd (%d) handle (%p)\n",fd
,hand
);
635 if (hand
== INVALID_HANDLE_VALUE
)
638 if (!FlushFileBuffers(hand
))
640 if (GetLastError() == ERROR_INVALID_HANDLE
)
642 /* FlushFileBuffers fails for console handles
643 * so we ignore this error.
647 TRACE(":failed-last error (%d)\n",GetLastError());
648 msvcrt_set_errno(GetLastError());
655 /*********************************************************************
658 * MSDN isn't clear on this point, but the remarks for _pipe,
659 * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt__pipe.asp
660 * indicate file descriptors duplicated with _dup and _dup2 are always
663 int CDECL
_dup2(int od
, int nd
)
667 TRACE("(od=%d, nd=%d)\n", od
, nd
);
669 if (nd
< MSVCRT_MAX_FILES
&& msvcrt_is_valid_fd(od
))
673 if (DuplicateHandle(GetCurrentProcess(), MSVCRT_fdesc
[od
].handle
,
674 GetCurrentProcess(), &handle
, 0, TRUE
, DUPLICATE_SAME_ACCESS
))
676 int wxflag
= MSVCRT_fdesc
[od
].wxflag
& ~MSVCRT__O_NOINHERIT
;
678 if (msvcrt_is_valid_fd(nd
))
680 ret
= msvcrt_alloc_fd_from(handle
, wxflag
, nd
);
684 *MSVCRT__errno() = MSVCRT_EMFILE
;
688 /* _dup2 returns 0, not nd, on success */
695 msvcrt_set_errno(GetLastError());
700 *MSVCRT__errno() = MSVCRT_EBADF
;
707 /*********************************************************************
710 int CDECL
_dup(int od
)
716 if (_dup2(od
, fd
) == 0)
724 /*********************************************************************
727 int CDECL
_eof(int fd
)
730 LONG hcurpos
,hendpos
;
731 HANDLE hand
= msvcrt_fdtoh(fd
);
733 TRACE(":fd (%d) handle (%p)\n",fd
,hand
);
735 if (hand
== INVALID_HANDLE_VALUE
)
738 if (MSVCRT_fdesc
[fd
].wxflag
& WX_ATEOF
) return TRUE
;
740 /* Otherwise we do it the hard way */
741 hcurpos
= hendpos
= 0;
742 curpos
= SetFilePointer(hand
, 0, &hcurpos
, FILE_CURRENT
);
743 endpos
= SetFilePointer(hand
, 0, &hendpos
, FILE_END
);
745 if (curpos
== endpos
&& hcurpos
== hendpos
)
747 /* FIXME: shouldn't WX_ATEOF be set here? */
751 SetFilePointer(hand
, curpos
, &hcurpos
, FILE_BEGIN
);
755 /*********************************************************************
756 * _fcloseall (MSVCRT.@)
758 int CDECL
MSVCRT__fcloseall(void)
760 int num_closed
= 0, i
;
763 for (i
= 3; i
< MSVCRT_stream_idx
; i
++)
764 if (MSVCRT_fstreams
[i
] && MSVCRT_fstreams
[i
]->_flag
&&
765 !MSVCRT_fclose(MSVCRT_fstreams
[i
]))
769 TRACE(":closed (%d) handles\n",num_closed
);
773 /* free everything on process exit */
774 void msvcrt_free_io(void)
777 /* The Win32 _fcloseall() function explicitly doesn't close stdin,
778 * stdout, and stderr (unlike GNU), so we need to fclose() them here
779 * or they won't get flushed.
781 MSVCRT_fclose(&MSVCRT__iob
[0]);
782 MSVCRT_fclose(&MSVCRT__iob
[1]);
783 MSVCRT_fclose(&MSVCRT__iob
[2]);
784 DeleteCriticalSection(&MSVCRT_file_cs
);
787 /*********************************************************************
788 * _lseeki64 (MSVCRT.@)
790 __int64 CDECL
_lseeki64(int fd
, __int64 offset
, int whence
)
792 HANDLE hand
= msvcrt_fdtoh(fd
);
793 LARGE_INTEGER ofs
, ret
;
795 TRACE(":fd (%d) handle (%p)\n",fd
,hand
);
796 if (hand
== INVALID_HANDLE_VALUE
)
799 if (whence
< 0 || whence
> 2)
801 *MSVCRT__errno() = MSVCRT_EINVAL
;
805 TRACE(":fd (%d) to %s pos %s\n",
806 fd
,wine_dbgstr_longlong(offset
),
807 (whence
==SEEK_SET
)?"SEEK_SET":
808 (whence
==SEEK_CUR
)?"SEEK_CUR":
809 (whence
==SEEK_END
)?"SEEK_END":"UNKNOWN");
811 ofs
.QuadPart
= offset
;
812 if (SetFilePointerEx(hand
, ofs
, &ret
, whence
))
814 MSVCRT_fdesc
[fd
].wxflag
&= ~WX_ATEOF
;
815 /* FIXME: What if we seek _to_ EOF - is EOF set? */
819 TRACE(":error-last error (%d)\n",GetLastError());
820 msvcrt_set_errno(GetLastError());
824 /*********************************************************************
827 LONG CDECL
_lseek(int fd
, LONG offset
, int whence
)
829 return _lseeki64(fd
, offset
, whence
);
832 /*********************************************************************
833 * _locking (MSVCRT.@)
835 * This is untested; the underlying LockFile doesn't work yet.
837 int CDECL
_locking(int fd
, int mode
, LONG nbytes
)
841 HANDLE hand
= msvcrt_fdtoh(fd
);
843 TRACE(":fd (%d) handle (%p)\n",fd
,hand
);
844 if (hand
== INVALID_HANDLE_VALUE
)
847 if (mode
< 0 || mode
> 4)
849 *MSVCRT__errno() = MSVCRT_EINVAL
;
853 TRACE(":fd (%d) by 0x%08x mode %s\n",
854 fd
,nbytes
,(mode
==MSVCRT__LK_UNLCK
)?"_LK_UNLCK":
855 (mode
==MSVCRT__LK_LOCK
)?"_LK_LOCK":
856 (mode
==MSVCRT__LK_NBLCK
)?"_LK_NBLCK":
857 (mode
==MSVCRT__LK_RLCK
)?"_LK_RLCK":
858 (mode
==MSVCRT__LK_NBRLCK
)?"_LK_NBRLCK":
861 if ((cur_locn
= SetFilePointer(hand
, 0L, NULL
, SEEK_CUR
)) == INVALID_SET_FILE_POINTER
)
863 FIXME ("Seek failed\n");
864 *MSVCRT__errno() = MSVCRT_EINVAL
; /* FIXME */
867 if (mode
== MSVCRT__LK_LOCK
|| mode
== MSVCRT__LK_RLCK
)
870 ret
= 1; /* just to satisfy gcc */
873 ret
= LockFile(hand
, cur_locn
, 0L, nbytes
, 0L);
878 else if (mode
== MSVCRT__LK_UNLCK
)
879 ret
= UnlockFile(hand
, cur_locn
, 0L, nbytes
, 0L);
881 ret
= LockFile(hand
, cur_locn
, 0L, nbytes
, 0L);
882 /* FIXME - what about error settings? */
886 /*********************************************************************
889 int CDECL
MSVCRT_fseek(MSVCRT_FILE
* file
, long offset
, int whence
)
891 /* Flush output if needed */
892 if(file
->_flag
& MSVCRT__IOWRT
)
893 msvcrt_flush_buffer(file
);
895 if(whence
== SEEK_CUR
&& file
->_flag
& MSVCRT__IOREAD
) {
896 offset
-= file
->_cnt
;
898 /* Discard buffered input */
900 file
->_ptr
= file
->_base
;
901 /* Reset direction of i/o */
902 if(file
->_flag
& MSVCRT__IORW
) {
903 file
->_flag
&= ~(MSVCRT__IOREAD
|MSVCRT__IOWRT
);
905 return (_lseek(file
->_file
,offset
,whence
) == -1)?-1:0;
908 /*********************************************************************
911 int CDECL
_chsize(int fd
, long size
)
917 TRACE("(fd=%d, size=%ld)\n", fd
, size
);
921 handle
= msvcrt_fdtoh(fd
);
922 if (handle
!= INVALID_HANDLE_VALUE
)
924 /* save the current file pointer */
925 cur
= _lseek(fd
, 0, SEEK_CUR
);
928 pos
= _lseek(fd
, size
, SEEK_SET
);
931 ret
= SetEndOfFile(handle
);
932 if (!ret
) msvcrt_set_errno(GetLastError());
935 /* restore the file pointer */
936 _lseek(fd
, cur
, SEEK_SET
);
944 /*********************************************************************
945 * clearerr (MSVCRT.@)
947 void CDECL
MSVCRT_clearerr(MSVCRT_FILE
* file
)
949 TRACE(":file (%p) fd (%d)\n",file
,file
->_file
);
950 file
->_flag
&= ~(MSVCRT__IOERR
| MSVCRT__IOEOF
);
953 /*********************************************************************
956 void CDECL
MSVCRT_rewind(MSVCRT_FILE
* file
)
958 TRACE(":file (%p) fd (%d)\n",file
,file
->_file
);
959 MSVCRT_fseek(file
, 0L, SEEK_SET
);
960 MSVCRT_clearerr(file
);
963 static int msvcrt_get_flags(const char* mode
, int *open_flags
, int* stream_flags
)
965 int plus
= strchr(mode
, '+') != NULL
;
970 *open_flags
= plus
? MSVCRT__O_RDWR
: MSVCRT__O_RDONLY
;
971 *stream_flags
= plus
? MSVCRT__IORW
: MSVCRT__IOREAD
;
974 *open_flags
= MSVCRT__O_CREAT
| MSVCRT__O_TRUNC
| (plus
? MSVCRT__O_RDWR
: MSVCRT__O_WRONLY
);
975 *stream_flags
= plus
? MSVCRT__IORW
: MSVCRT__IOWRT
;
978 *open_flags
= MSVCRT__O_CREAT
| MSVCRT__O_APPEND
| (plus
? MSVCRT__O_RDWR
: MSVCRT__O_WRONLY
);
979 *stream_flags
= plus
? MSVCRT__IORW
: MSVCRT__IOWRT
;
989 *open_flags
|= MSVCRT__O_BINARY
;
990 *open_flags
&= ~MSVCRT__O_TEXT
;
993 *open_flags
|= MSVCRT__O_TEXT
;
994 *open_flags
&= ~MSVCRT__O_BINARY
;
999 FIXME(":unknown flag %c not supported\n",mode
[-1]);
1004 /*********************************************************************
1005 * _fdopen (MSVCRT.@)
1007 MSVCRT_FILE
* CDECL
MSVCRT__fdopen(int fd
, const char *mode
)
1009 int open_flags
, stream_flags
;
1012 if (msvcrt_get_flags(mode
, &open_flags
, &stream_flags
) == -1) return NULL
;
1015 if (!(file
= msvcrt_alloc_fp()))
1017 else if (msvcrt_init_fp(file
, fd
, stream_flags
) == -1)
1022 else TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd
,mode
,file
);
1028 /*********************************************************************
1029 * _wfdopen (MSVCRT.@)
1031 MSVCRT_FILE
* CDECL
MSVCRT__wfdopen(int fd
, const MSVCRT_wchar_t
*mode
)
1033 unsigned mlen
= strlenW(mode
);
1034 char *modea
= MSVCRT_calloc(mlen
+ 1, 1);
1035 MSVCRT_FILE
* file
= NULL
;
1036 int open_flags
, stream_flags
;
1039 WideCharToMultiByte(CP_ACP
,0,mode
,mlen
,modea
,mlen
,NULL
,NULL
))
1041 if (msvcrt_get_flags(modea
, &open_flags
, &stream_flags
) == -1) return NULL
;
1043 if (!(file
= msvcrt_alloc_fp()))
1045 else if (msvcrt_init_fp(file
, fd
, stream_flags
) == -1)
1053 MSVCRT_rewind(file
); /* FIXME: is this needed ??? */
1054 TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd
,debugstr_w(mode
),file
);
1061 /*********************************************************************
1062 * _filelength (MSVCRT.@)
1064 LONG CDECL
_filelength(int fd
)
1066 LONG curPos
= _lseek(fd
, 0, SEEK_CUR
);
1069 LONG endPos
= _lseek(fd
, 0, SEEK_END
);
1072 if (endPos
!= curPos
)
1073 _lseek(fd
, curPos
, SEEK_SET
);
1080 /*********************************************************************
1081 * _filelengthi64 (MSVCRT.@)
1083 __int64 CDECL
_filelengthi64(int fd
)
1085 __int64 curPos
= _lseeki64(fd
, 0, SEEK_CUR
);
1088 __int64 endPos
= _lseeki64(fd
, 0, SEEK_END
);
1091 if (endPos
!= curPos
)
1092 _lseeki64(fd
, curPos
, SEEK_SET
);
1099 /*********************************************************************
1100 * _fileno (MSVCRT.@)
1102 int CDECL
MSVCRT__fileno(MSVCRT_FILE
* file
)
1104 TRACE(":FILE* (%p) fd (%d)\n",file
,file
->_file
);
1108 /*********************************************************************
1109 * _fstati64 (MSVCRT.@)
1111 int CDECL
MSVCRT__fstati64(int fd
, struct MSVCRT__stati64
* buf
)
1114 BY_HANDLE_FILE_INFORMATION hfi
;
1115 HANDLE hand
= msvcrt_fdtoh(fd
);
1117 TRACE(":fd (%d) stat (%p)\n",fd
,buf
);
1118 if (hand
== INVALID_HANDLE_VALUE
)
1123 WARN(":failed-NULL buf\n");
1124 msvcrt_set_errno(ERROR_INVALID_PARAMETER
);
1128 memset(&hfi
, 0, sizeof(hfi
));
1129 memset(buf
, 0, sizeof(struct MSVCRT__stati64
));
1130 if (!GetFileInformationByHandle(hand
, &hfi
))
1132 WARN(":failed-last error (%d)\n",GetLastError());
1133 msvcrt_set_errno(ERROR_INVALID_PARAMETER
);
1136 dw
= GetFileType(hand
);
1137 buf
->st_mode
= S_IREAD
;
1138 if (!(hfi
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
))
1139 buf
->st_mode
|= S_IWRITE
;
1140 /* interestingly, Windows never seems to set S_IFDIR */
1141 if (dw
== FILE_TYPE_CHAR
)
1142 buf
->st_mode
|= S_IFCHR
;
1143 else if (dw
== FILE_TYPE_PIPE
)
1144 buf
->st_mode
|= S_IFIFO
;
1146 buf
->st_mode
|= S_IFREG
;
1147 TRACE(":dwFileAttributes = 0x%x, mode set to 0x%x\n",hfi
.dwFileAttributes
,
1149 buf
->st_nlink
= hfi
.nNumberOfLinks
;
1150 buf
->st_size
= ((__int64
)hfi
.nFileSizeHigh
<< 32) + hfi
.nFileSizeLow
;
1151 RtlTimeToSecondsSince1970((LARGE_INTEGER
*)&hfi
.ftLastAccessTime
, &dw
);
1153 RtlTimeToSecondsSince1970((LARGE_INTEGER
*)&hfi
.ftLastWriteTime
, &dw
);
1154 buf
->st_mtime
= buf
->st_ctime
= dw
;
1158 /*********************************************************************
1161 int CDECL
MSVCRT__fstat(int fd
, struct MSVCRT__stat
* buf
)
1163 struct MSVCRT__stati64 bufi64
;
1165 ret
= MSVCRT__fstati64(fd
, &bufi64
);
1167 msvcrt_cp_from_stati64(&bufi64
, buf
);
1171 /*********************************************************************
1172 * _futime (MSVCRT.@)
1174 int CDECL
_futime(int fd
, struct MSVCRT__utimbuf
*t
)
1176 HANDLE hand
= msvcrt_fdtoh(fd
);
1181 MSVCRT_time_t currTime
;
1182 MSVCRT_time(&currTime
);
1183 RtlSecondsSince1970ToTime(currTime
, (LARGE_INTEGER
*)&at
);
1184 memcpy(&wt
, &at
, sizeof(wt
));
1188 RtlSecondsSince1970ToTime(t
->actime
, (LARGE_INTEGER
*)&at
);
1189 if (t
->actime
== t
->modtime
)
1190 memcpy(&wt
, &at
, sizeof(wt
));
1192 RtlSecondsSince1970ToTime(t
->modtime
, (LARGE_INTEGER
*)&wt
);
1195 if (!SetFileTime(hand
, NULL
, &at
, &wt
))
1197 msvcrt_set_errno(GetLastError());
1203 /*********************************************************************
1204 * _get_osfhandle (MSVCRT.@)
1206 long CDECL
_get_osfhandle(int fd
)
1208 HANDLE hand
= msvcrt_fdtoh(fd
);
1209 TRACE(":fd (%d) handle (%p)\n",fd
,hand
);
1214 /*********************************************************************
1215 * _isatty (MSVCRT.@)
1217 int CDECL
_isatty(int fd
)
1219 HANDLE hand
= msvcrt_fdtoh(fd
);
1221 TRACE(":fd (%d) handle (%p)\n",fd
,hand
);
1222 if (hand
== INVALID_HANDLE_VALUE
)
1225 return GetFileType(hand
) == FILE_TYPE_CHAR
? 1 : 0;
1228 /*********************************************************************
1229 * _mktemp (MSVCRT.@)
1231 char * CDECL
_mktemp(char *pattern
)
1234 char *retVal
= pattern
;
1239 numX
= (*pattern
++ == 'X')? numX
+ 1 : 0;
1243 id
= GetCurrentProcessId();
1247 int tempNum
= id
/ 10;
1248 *pattern
-- = id
- (tempNum
* 10) + '0';
1254 *pattern
= letter
++;
1255 if (GetFileAttributesA(retVal
) == INVALID_FILE_ATTRIBUTES
&&
1256 GetLastError() == ERROR_FILE_NOT_FOUND
)
1258 } while(letter
<= 'z');
1262 /*********************************************************************
1263 * _wmktemp (MSVCRT.@)
1265 MSVCRT_wchar_t
* CDECL
_wmktemp(MSVCRT_wchar_t
*pattern
)
1268 MSVCRT_wchar_t
*retVal
= pattern
;
1270 MSVCRT_wchar_t letter
= 'a';
1273 numX
= (*pattern
++ == 'X')? numX
+ 1 : 0;
1277 id
= GetCurrentProcessId();
1281 int tempNum
= id
/ 10;
1282 *pattern
-- = id
- (tempNum
* 10) + '0';
1288 if (GetFileAttributesW(retVal
) == INVALID_FILE_ATTRIBUTES
&&
1289 GetLastError() == ERROR_FILE_NOT_FOUND
)
1291 *pattern
= letter
++;
1292 } while(letter
!= '|');
1296 static unsigned split_oflags(unsigned oflags
)
1299 unsigned unsupp
; /* until we support everything */
1301 if (oflags
& MSVCRT__O_APPEND
) wxflags
|= WX_APPEND
;
1302 if (oflags
& MSVCRT__O_BINARY
) {/* Nothing to do */}
1303 else if (oflags
& MSVCRT__O_TEXT
) wxflags
|= WX_TEXT
;
1304 else if (*__p__fmode() & MSVCRT__O_BINARY
) {/* Nothing to do */}
1305 else wxflags
|= WX_TEXT
; /* default to TEXT*/
1306 if (oflags
& MSVCRT__O_NOINHERIT
) wxflags
|= WX_DONTINHERIT
;
1308 if ((unsupp
= oflags
& ~(
1309 MSVCRT__O_BINARY
|MSVCRT__O_TEXT
|MSVCRT__O_APPEND
|
1310 MSVCRT__O_TRUNC
|MSVCRT__O_EXCL
|MSVCRT__O_CREAT
|
1311 MSVCRT__O_RDWR
|MSVCRT__O_WRONLY
|MSVCRT__O_TEMPORARY
|
1312 MSVCRT__O_NOINHERIT
|
1313 MSVCRT__O_SEQUENTIAL
|MSVCRT__O_RANDOM
|MSVCRT__O_SHORT_LIVED
1315 ERR(":unsupported oflags 0x%04x\n",unsupp
);
1320 /*********************************************************************
1323 int CDECL
_pipe(int *pfds
, unsigned int psize
, int textmode
)
1326 SECURITY_ATTRIBUTES sa
;
1327 HANDLE readHandle
, writeHandle
;
1331 *MSVCRT__errno() = MSVCRT_EINVAL
;
1335 sa
.nLength
= sizeof(SECURITY_ATTRIBUTES
);
1336 sa
.bInheritHandle
= !(textmode
& MSVCRT__O_NOINHERIT
);
1337 sa
.lpSecurityDescriptor
= NULL
;
1338 if (CreatePipe(&readHandle
, &writeHandle
, &sa
, psize
))
1340 unsigned int wxflags
= split_oflags(textmode
);
1344 fd
= msvcrt_alloc_fd(readHandle
, wxflags
);
1348 fd
= msvcrt_alloc_fd(writeHandle
, wxflags
);
1357 CloseHandle(writeHandle
);
1358 *MSVCRT__errno() = MSVCRT_EMFILE
;
1363 CloseHandle(readHandle
);
1364 CloseHandle(writeHandle
);
1365 *MSVCRT__errno() = MSVCRT_EMFILE
;
1370 msvcrt_set_errno(GetLastError());
1375 /*********************************************************************
1378 int CDECL
MSVCRT__sopen( const char *path
, int oflags
, int shflags
, ... )
1382 DWORD access
= 0, creation
= 0, attrib
;
1386 SECURITY_ATTRIBUTES sa
;
1389 TRACE(":file (%s) oflags: 0x%04x shflags: 0x%04x\n",
1390 path
, oflags
, shflags
);
1392 wxflag
= split_oflags(oflags
);
1393 switch (oflags
& (MSVCRT__O_RDONLY
| MSVCRT__O_WRONLY
| MSVCRT__O_RDWR
))
1395 case MSVCRT__O_RDONLY
: access
|= GENERIC_READ
; break;
1396 case MSVCRT__O_WRONLY
: access
|= GENERIC_WRITE
; break;
1397 case MSVCRT__O_RDWR
: access
|= GENERIC_WRITE
| GENERIC_READ
; break;
1400 if (oflags
& MSVCRT__O_CREAT
)
1402 va_start(ap
, shflags
);
1403 pmode
= va_arg(ap
, int);
1406 if(pmode
& ~(MSVCRT__S_IREAD
| MSVCRT__S_IWRITE
))
1407 FIXME(": pmode 0x%04x ignored\n", pmode
);
1409 WARN(": pmode 0x%04x ignored\n", pmode
);
1411 if (oflags
& MSVCRT__O_EXCL
)
1412 creation
= CREATE_NEW
;
1413 else if (oflags
& MSVCRT__O_TRUNC
)
1414 creation
= CREATE_ALWAYS
;
1416 creation
= OPEN_ALWAYS
;
1418 else /* no MSVCRT__O_CREAT */
1420 if (oflags
& MSVCRT__O_TRUNC
)
1421 creation
= TRUNCATE_EXISTING
;
1423 creation
= OPEN_EXISTING
;
1428 case MSVCRT__SH_DENYRW
:
1431 case MSVCRT__SH_DENYWR
:
1432 sharing
= FILE_SHARE_READ
;
1434 case MSVCRT__SH_DENYRD
:
1435 sharing
= FILE_SHARE_WRITE
;
1437 case MSVCRT__SH_DENYNO
:
1438 sharing
= FILE_SHARE_READ
| FILE_SHARE_WRITE
;
1441 ERR( "Unhandled shflags 0x%x\n", shflags
);
1444 attrib
= FILE_ATTRIBUTE_NORMAL
;
1446 if (oflags
& MSVCRT__O_TEMPORARY
)
1448 attrib
|= FILE_FLAG_DELETE_ON_CLOSE
;
1450 sharing
|= FILE_SHARE_DELETE
;
1453 sa
.nLength
= sizeof( SECURITY_ATTRIBUTES
);
1454 sa
.lpSecurityDescriptor
= NULL
;
1455 sa
.bInheritHandle
= (oflags
& MSVCRT__O_NOINHERIT
) ? FALSE
: TRUE
;
1457 hand
= CreateFileA(path
, access
, sharing
, &sa
, creation
, attrib
, 0);
1459 if (hand
== INVALID_HANDLE_VALUE
) {
1460 WARN(":failed-last error (%d)\n",GetLastError());
1461 msvcrt_set_errno(GetLastError());
1465 fd
= msvcrt_alloc_fd(hand
, wxflag
);
1467 TRACE(":fd (%d) handle (%p)\n",fd
, hand
);
1471 /*********************************************************************
1472 * _wsopen (MSVCRT.@)
1474 int CDECL
MSVCRT__wsopen( const MSVCRT_wchar_t
* path
, int oflags
, int shflags
, ... )
1476 const unsigned int len
= strlenW(path
);
1477 char *patha
= MSVCRT_calloc(len
+ 1,1);
1481 va_start(ap
, shflags
);
1482 pmode
= va_arg(ap
, int);
1485 if (patha
&& WideCharToMultiByte(CP_ACP
,0,path
,len
,patha
,len
,NULL
,NULL
))
1487 int retval
= MSVCRT__sopen(patha
,oflags
,shflags
,pmode
);
1492 msvcrt_set_errno(GetLastError());
1496 /*********************************************************************
1499 int CDECL
_open( const char *path
, int flags
, ... )
1503 if (flags
& MSVCRT__O_CREAT
)
1506 va_start(ap
, flags
);
1507 pmode
= va_arg(ap
, int);
1509 return MSVCRT__sopen( path
, flags
, MSVCRT__SH_DENYNO
, pmode
);
1512 return MSVCRT__sopen( path
, flags
, MSVCRT__SH_DENYNO
);
1515 /*********************************************************************
1518 int CDECL
_wopen(const MSVCRT_wchar_t
*path
,int flags
,...)
1520 const unsigned int len
= strlenW(path
);
1521 char *patha
= MSVCRT_calloc(len
+ 1,1);
1525 va_start(ap
, flags
);
1526 pmode
= va_arg(ap
, int);
1529 if (patha
&& WideCharToMultiByte(CP_ACP
,0,path
,len
,patha
,len
,NULL
,NULL
))
1531 int retval
= _open(patha
,flags
,pmode
);
1536 msvcrt_set_errno(GetLastError());
1540 /*********************************************************************
1543 int CDECL
_creat(const char *path
, int flags
)
1545 int usedFlags
= (flags
& MSVCRT__O_TEXT
)| MSVCRT__O_CREAT
| MSVCRT__O_WRONLY
| MSVCRT__O_TRUNC
;
1546 return _open(path
, usedFlags
);
1549 /*********************************************************************
1550 * _wcreat (MSVCRT.@)
1552 int CDECL
_wcreat(const MSVCRT_wchar_t
*path
, int flags
)
1554 int usedFlags
= (flags
& MSVCRT__O_TEXT
)| MSVCRT__O_CREAT
| MSVCRT__O_WRONLY
| MSVCRT__O_TRUNC
;
1555 return _wopen(path
, usedFlags
);
1558 /*********************************************************************
1559 * _open_osfhandle (MSVCRT.@)
1561 int CDECL
_open_osfhandle(long handle
, int oflags
)
1565 /* MSVCRT__O_RDONLY (0) always matches, so set the read flag
1566 * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
1567 * file, so set the write flag. It also only sets MSVCRT__O_TEXT if it wants
1568 * text - it never sets MSVCRT__O_BINARY.
1570 /* FIXME: handle more flags */
1571 if (!(oflags
& (MSVCRT__O_BINARY
| MSVCRT__O_TEXT
)) && (*__p__fmode() & MSVCRT__O_BINARY
))
1572 oflags
|= MSVCRT__O_BINARY
;
1574 oflags
|= MSVCRT__O_TEXT
;
1576 fd
= msvcrt_alloc_fd((HANDLE
)handle
, split_oflags(oflags
));
1577 TRACE(":handle (%ld) fd (%d) flags 0x%08x\n", handle
, fd
, oflags
);
1581 /*********************************************************************
1584 int CDECL
_rmtmp(void)
1586 int num_removed
= 0, i
;
1589 for (i
= 3; i
< MSVCRT_stream_idx
; i
++)
1590 if (MSVCRT_fstreams
[i
] && MSVCRT_fstreams
[i
]->_tmpfname
)
1592 MSVCRT_fclose(MSVCRT_fstreams
[i
]);
1598 TRACE(":removed (%d) temp files\n",num_removed
);
1602 /*********************************************************************
1603 * (internal) remove_cr
1605 * Remove all \r inplace.
1606 * return the number of \r removed
1608 static unsigned int remove_cr(char *buf
, unsigned int count
)
1612 for (i
= 0; i
< count
; i
++) if (buf
[i
] == '\r') break;
1613 for (j
= i
+ 1; j
< count
; j
++) if (buf
[j
] != '\r') buf
[i
++] = buf
[j
];
1617 /*********************************************************************
1620 static int read_i(int fd
, void *buf
, unsigned int count
)
1623 char *bufstart
= buf
;
1624 HANDLE hand
= msvcrt_fdtoh(fd
);
1626 /* Don't trace small reads, it gets *very* annoying */
1628 TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n",fd
,hand
,buf
,count
);
1629 if (hand
== INVALID_HANDLE_VALUE
)
1632 /* Reading single bytes in O_TEXT mode makes things slow
1633 * So read big chunks
1635 if (ReadFile(hand
, bufstart
, count
, &num_read
, NULL
))
1637 if (MSVCRT_fdesc
[fd
].wxflag
& WX_TEXT
)
1640 /* in text mode, a ctrl-z signals EOF */
1641 for (i
=0; i
<num_read
; i
++)
1643 if (bufstart
[i
] == 0x1a)
1650 if (num_read
!= count
)
1652 MSVCRT_fdesc
[fd
].wxflag
|= WX_ATEOF
;
1653 TRACE(":EOF %s\n",debugstr_an(buf
,num_read
));
1658 TRACE(":failed-last error (%d)\n",GetLastError());
1663 TRACE("(%u), %s\n",num_read
,debugstr_an(buf
, num_read
));
1667 /*********************************************************************
1670 int CDECL
_read(int fd
, void *buf
, unsigned int count
)
1673 num_read
= read_i(fd
, buf
, count
);
1674 if (num_read
>0 && MSVCRT_fdesc
[fd
].wxflag
& WX_TEXT
)
1676 num_read
-= remove_cr(buf
,num_read
);
1681 /*********************************************************************
1682 * _setmode (MSVCRT.@)
1684 int CDECL
_setmode(int fd
,int mode
)
1686 int ret
= MSVCRT_fdesc
[fd
].wxflag
& WX_TEXT
? MSVCRT__O_TEXT
: MSVCRT__O_BINARY
;
1687 if (mode
& (~(MSVCRT__O_TEXT
|MSVCRT__O_BINARY
)))
1688 FIXME("fd (%d) mode (0x%08x) unknown\n",fd
,mode
);
1689 if ((mode
& MSVCRT__O_TEXT
) == MSVCRT__O_TEXT
)
1690 MSVCRT_fdesc
[fd
].wxflag
|= WX_TEXT
;
1692 MSVCRT_fdesc
[fd
].wxflag
&= ~WX_TEXT
;
1696 /*********************************************************************
1697 * _stati64 (MSVCRT.@)
1699 int CDECL
MSVCRT__stati64(const char* path
, struct MSVCRT__stati64
* buf
)
1702 WIN32_FILE_ATTRIBUTE_DATA hfi
;
1703 unsigned short mode
= ALL_S_IREAD
;
1706 TRACE(":file (%s) buf(%p)\n",path
,buf
);
1708 if (!GetFileAttributesExA(path
, GetFileExInfoStandard
, &hfi
))
1710 TRACE("failed (%d)\n",GetLastError());
1711 msvcrt_set_errno(ERROR_FILE_NOT_FOUND
);
1715 memset(buf
,0,sizeof(struct MSVCRT__stati64
));
1717 /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
1718 Bon 011120: This FIXME seems incorrect
1719 Also a letter as first char isn't enough to be classified
1722 if (isalpha(*path
)&& (*(path
+1)==':'))
1723 buf
->st_dev
= buf
->st_rdev
= toupper(*path
) - 'A'; /* drive num */
1725 buf
->st_dev
= buf
->st_rdev
= _getdrive() - 1;
1727 plen
= strlen(path
);
1729 /* Dir, or regular file? */
1730 if ((hfi
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ||
1731 (path
[plen
-1] == '\\'))
1732 mode
|= (MSVCRT__S_IFDIR
| ALL_S_IEXEC
);
1735 mode
|= MSVCRT__S_IFREG
;
1737 if (plen
> 6 && path
[plen
-4] == '.') /* shortest exe: "\x.exe" */
1739 unsigned int ext
= tolower(path
[plen
-1]) | (tolower(path
[plen
-2]) << 8) |
1740 (tolower(path
[plen
-3]) << 16);
1741 if (ext
== EXE
|| ext
== BAT
|| ext
== CMD
|| ext
== COM
)
1742 mode
|= ALL_S_IEXEC
;
1746 if (!(hfi
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
))
1747 mode
|= ALL_S_IWRITE
;
1749 buf
->st_mode
= mode
;
1751 buf
->st_size
= ((__int64
)hfi
.nFileSizeHigh
<< 32) + hfi
.nFileSizeLow
;
1752 RtlTimeToSecondsSince1970((LARGE_INTEGER
*)&hfi
.ftLastAccessTime
, &dw
);
1754 RtlTimeToSecondsSince1970((LARGE_INTEGER
*)&hfi
.ftLastWriteTime
, &dw
);
1755 buf
->st_mtime
= buf
->st_ctime
= dw
;
1756 TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf
->st_mode
,buf
->st_nlink
,
1757 (long)(buf
->st_size
>> 32),(long)buf
->st_size
,
1758 buf
->st_atime
,buf
->st_mtime
, buf
->st_ctime
);
1762 /*********************************************************************
1765 int CDECL
MSVCRT__stat(const char* path
, struct MSVCRT__stat
* buf
)
1767 struct MSVCRT__stati64 bufi64
;
1769 ret
= MSVCRT__stati64( path
, &bufi64
);
1771 msvcrt_cp_from_stati64(&bufi64
, buf
);
1775 /*********************************************************************
1776 * _wstati64 (MSVCRT.@)
1778 int CDECL
MSVCRT__wstati64(const MSVCRT_wchar_t
* path
, struct MSVCRT__stati64
* buf
)
1781 WIN32_FILE_ATTRIBUTE_DATA hfi
;
1782 unsigned short mode
= ALL_S_IREAD
;
1785 TRACE(":file (%s) buf(%p)\n",debugstr_w(path
),buf
);
1787 if (!GetFileAttributesExW(path
, GetFileExInfoStandard
, &hfi
))
1789 TRACE("failed (%d)\n",GetLastError());
1790 msvcrt_set_errno(ERROR_FILE_NOT_FOUND
);
1794 memset(buf
,0,sizeof(struct MSVCRT__stat
));
1796 /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
1797 if (MSVCRT_iswalpha(*path
))
1798 buf
->st_dev
= buf
->st_rdev
= toupperW(*path
- 'A'); /* drive num */
1800 buf
->st_dev
= buf
->st_rdev
= _getdrive() - 1;
1802 plen
= strlenW(path
);
1804 /* Dir, or regular file? */
1805 if ((hfi
.dwFileAttributes
& FILE_ATTRIBUTE_DIRECTORY
) ||
1806 (path
[plen
-1] == '\\'))
1807 mode
|= (MSVCRT__S_IFDIR
| ALL_S_IEXEC
);
1810 mode
|= MSVCRT__S_IFREG
;
1812 if (plen
> 6 && path
[plen
-4] == '.') /* shortest exe: "\x.exe" */
1814 ULONGLONG ext
= tolowerW(path
[plen
-1]) | (tolowerW(path
[plen
-2]) << 16) |
1815 ((ULONGLONG
)tolowerW(path
[plen
-3]) << 32);
1816 if (ext
== WCEXE
|| ext
== WCBAT
|| ext
== WCCMD
|| ext
== WCCOM
)
1817 mode
|= ALL_S_IEXEC
;
1821 if (!(hfi
.dwFileAttributes
& FILE_ATTRIBUTE_READONLY
))
1822 mode
|= ALL_S_IWRITE
;
1824 buf
->st_mode
= mode
;
1826 buf
->st_size
= ((__int64
)hfi
.nFileSizeHigh
<< 32) + hfi
.nFileSizeLow
;
1827 RtlTimeToSecondsSince1970((LARGE_INTEGER
*)&hfi
.ftLastAccessTime
, &dw
);
1829 RtlTimeToSecondsSince1970((LARGE_INTEGER
*)&hfi
.ftLastWriteTime
, &dw
);
1830 buf
->st_mtime
= buf
->st_ctime
= dw
;
1831 TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf
->st_mode
,buf
->st_nlink
,
1832 (long)(buf
->st_size
>> 32),(long)buf
->st_size
,
1833 buf
->st_atime
,buf
->st_mtime
, buf
->st_ctime
);
1837 /*********************************************************************
1840 int CDECL
MSVCRT__wstat(const MSVCRT_wchar_t
* path
, struct MSVCRT__stat
* buf
)
1843 struct MSVCRT__stati64 bufi64
;
1845 ret
= MSVCRT__wstati64( path
, &bufi64
);
1846 if (!ret
) msvcrt_cp_from_stati64(&bufi64
, buf
);
1850 /*********************************************************************
1853 long CDECL
_tell(int fd
)
1855 return _lseek(fd
, 0, SEEK_CUR
);
1858 /*********************************************************************
1859 * _telli64 (MSVCRT.@)
1861 __int64 CDECL
_telli64(int fd
)
1863 return _lseeki64(fd
, 0, SEEK_CUR
);
1866 /*********************************************************************
1867 * _tempnam (MSVCRT.@)
1869 char * CDECL
_tempnam(const char *dir
, const char *prefix
)
1871 char tmpbuf
[MAX_PATH
];
1872 const char *tmp_dir
= MSVCRT_getenv("TMP");
1874 if (tmp_dir
) dir
= tmp_dir
;
1876 TRACE("dir (%s) prefix (%s)\n",dir
,prefix
);
1877 if (GetTempFileNameA(dir
,prefix
,0,tmpbuf
))
1879 TRACE("got name (%s)\n",tmpbuf
);
1880 DeleteFileA(tmpbuf
);
1881 return _strdup(tmpbuf
);
1883 TRACE("failed (%d)\n",GetLastError());
1887 /*********************************************************************
1888 * _wtempnam (MSVCRT.@)
1890 MSVCRT_wchar_t
* CDECL
_wtempnam(const MSVCRT_wchar_t
*dir
, const MSVCRT_wchar_t
*prefix
)
1892 MSVCRT_wchar_t tmpbuf
[MAX_PATH
];
1894 TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir
),debugstr_w(prefix
));
1895 if (GetTempFileNameW(dir
,prefix
,0,tmpbuf
))
1897 TRACE("got name (%s)\n",debugstr_w(tmpbuf
));
1898 DeleteFileW(tmpbuf
);
1899 return _wcsdup(tmpbuf
);
1901 TRACE("failed (%d)\n",GetLastError());
1905 /*********************************************************************
1908 int CDECL
_umask(int umask
)
1910 int old_umask
= MSVCRT_umask
;
1911 TRACE("(%d)\n",umask
);
1912 MSVCRT_umask
= umask
;
1916 /*********************************************************************
1919 int CDECL
_utime(const char* path
, struct MSVCRT__utimbuf
*t
)
1921 int fd
= _open(path
, MSVCRT__O_WRONLY
| MSVCRT__O_BINARY
);
1925 int retVal
= _futime(fd
, t
);
1932 /*********************************************************************
1933 * _wutime (MSVCRT.@)
1935 int CDECL
_wutime(const MSVCRT_wchar_t
* path
, struct MSVCRT__utimbuf
*t
)
1937 int fd
= _wopen(path
, MSVCRT__O_WRONLY
| MSVCRT__O_BINARY
);
1941 int retVal
= _futime(fd
, t
);
1948 /*********************************************************************
1951 int CDECL
_write(int fd
, const void* buf
, unsigned int count
)
1954 HANDLE hand
= msvcrt_fdtoh(fd
);
1956 /* Don't trace small writes, it gets *very* annoying */
1959 TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd
,hand
,buf
,count
);
1961 if (hand
== INVALID_HANDLE_VALUE
)
1963 *MSVCRT__errno() = MSVCRT_EBADF
;
1967 /* If appending, go to EOF */
1968 if (MSVCRT_fdesc
[fd
].wxflag
& WX_APPEND
)
1969 _lseek(fd
, 0, FILE_END
);
1971 if (!(MSVCRT_fdesc
[fd
].wxflag
& WX_TEXT
))
1973 if (WriteFile(hand
, buf
, count
, &num_written
, NULL
)
1974 && (num_written
== count
))
1976 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d)\n", fd
,
1977 hand
, GetLastError());
1978 *MSVCRT__errno() = MSVCRT_ENOSPC
;
1982 unsigned int i
, j
, nr_lf
;
1985 const char *s
= (const char *)buf
, *buf_start
= (const char *)buf
;
1986 /* find number of \n ( without preceding \r ) */
1987 for ( nr_lf
=0,i
= 0; i
<count
; i
++)
1992 /*if ((i >1) && (s[i-1] == '\r')) nr_lf--; */
1997 if ((q
= p
= MSVCRT_malloc(count
+ nr_lf
)))
1999 for (s
= (const char *)buf
, i
= 0, j
= 0; i
< count
; i
++)
2004 /*if ((i >1) && (s[i-1] == '\r'))j--;*/
2011 FIXME("Malloc failed\n");
2019 if ((WriteFile(hand
, q
, count
+nr_lf
, &num_written
, NULL
) == 0 ) || (num_written
!= count
+nr_lf
))
2021 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d), num_written %d\n",
2022 fd
, hand
, GetLastError(), num_written
);
2023 *MSVCRT__errno() = MSVCRT_ENOSPC
;
2026 return s
- buf_start
;
2038 /*********************************************************************
2041 int CDECL
MSVCRT__putw(int val
, MSVCRT_FILE
* file
)
2044 len
= _write(file
->_file
, &val
, sizeof(val
));
2045 if (len
== sizeof(val
)) return val
;
2046 file
->_flag
|= MSVCRT__IOERR
;
2050 /*********************************************************************
2053 int CDECL
MSVCRT_fclose(MSVCRT_FILE
* file
)
2058 MSVCRT_free(file
->_tmpfname
);
2059 file
->_tmpfname
= NULL
;
2060 /* flush stdio buffers */
2061 if(file
->_flag
& MSVCRT__IOWRT
)
2062 MSVCRT_fflush(file
);
2063 if(file
->_flag
& MSVCRT__IOMYBUF
)
2064 MSVCRT_free(file
->_base
);
2066 r
=_close(file
->_file
);
2070 return ((r
== -1) || (flag
& MSVCRT__IOERR
) ? MSVCRT_EOF
: 0);
2073 /*********************************************************************
2076 int CDECL
MSVCRT_feof(MSVCRT_FILE
* file
)
2078 return file
->_flag
& MSVCRT__IOEOF
;
2081 /*********************************************************************
2084 int CDECL
MSVCRT_ferror(MSVCRT_FILE
* file
)
2086 return file
->_flag
& MSVCRT__IOERR
;
2089 /*********************************************************************
2090 * _filbuf (MSVCRT.@)
2092 int CDECL
MSVCRT__filbuf(MSVCRT_FILE
* file
)
2094 /* Allocate buffer if needed */
2095 if(file
->_bufsiz
== 0 && !(file
->_flag
& MSVCRT__IONBF
) ) {
2096 msvcrt_alloc_buffer(file
);
2098 if(!(file
->_flag
& MSVCRT__IOREAD
)) {
2099 if(file
->_flag
& MSVCRT__IORW
) {
2100 file
->_flag
|= MSVCRT__IOREAD
;
2105 if(file
->_flag
& MSVCRT__IONBF
) {
2108 if ((r
= read_i(file
->_file
,&c
,1)) != 1) {
2109 file
->_flag
|= (r
== 0) ? MSVCRT__IOEOF
: MSVCRT__IOERR
;
2114 file
->_cnt
= read_i(file
->_file
, file
->_base
, file
->_bufsiz
);
2116 file
->_flag
|= (file
->_cnt
== 0) ? MSVCRT__IOEOF
: MSVCRT__IOERR
;
2121 file
->_ptr
= file
->_base
+1;
2122 return *(unsigned char *)file
->_base
;
2126 /*********************************************************************
2129 int CDECL
MSVCRT_fgetc(MSVCRT_FILE
* file
)
2136 i
= (unsigned char *)file
->_ptr
++;
2139 j
= MSVCRT__filbuf(file
);
2140 if (!(MSVCRT_fdesc
[file
->_file
].wxflag
& WX_TEXT
) || (j
!= '\r'))
2145 /*********************************************************************
2146 * _fgetchar (MSVCRT.@)
2148 int CDECL
_fgetchar(void)
2150 return MSVCRT_fgetc(MSVCRT_stdin
);
2153 /*********************************************************************
2156 char * CDECL
MSVCRT_fgets(char *s
, int size
, MSVCRT_FILE
* file
)
2158 int cc
= MSVCRT_EOF
;
2159 char * buf_start
= s
;
2161 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
2162 file
,file
->_file
,s
,size
);
2164 while ((size
>1) && (cc
= MSVCRT_fgetc(file
)) != MSVCRT_EOF
&& cc
!= '\n')
2169 if ((cc
== MSVCRT_EOF
) && (s
== buf_start
)) /* If nothing read, return 0*/
2171 TRACE(":nothing read\n");
2174 if ((cc
!= MSVCRT_EOF
) && (size
> 1))
2177 TRACE(":got %s\n", debugstr_a(buf_start
));
2181 /*********************************************************************
2184 * In MSVCRT__O_TEXT mode, multibyte characters are read from the file, dropping
2185 * the CR from CR/LF combinations
2187 MSVCRT_wint_t CDECL
MSVCRT_fgetwc(MSVCRT_FILE
* file
)
2191 if (!(MSVCRT_fdesc
[file
->_file
].wxflag
& WX_TEXT
))
2197 for(i
=0; i
<sizeof(wc
); i
++)
2207 j
= MSVCRT__filbuf(file
);
2210 file
->_flag
|= (file
->_cnt
== 0) ? MSVCRT__IOEOF
: MSVCRT__IOERR
;
2220 c
= MSVCRT_fgetc(file
);
2221 if ((*__p___mb_cur_max() > 1) && MSVCRT_isleadbyte(c
))
2223 FIXME("Treat Multibyte characters\n");
2225 if (c
== MSVCRT_EOF
)
2228 return (MSVCRT_wint_t
)c
;
2231 /*********************************************************************
2234 int CDECL
MSVCRT__getw(MSVCRT_FILE
* file
)
2239 for (j
=0; j
<sizeof(int); j
++) {
2240 k
= MSVCRT_fgetc(file
);
2241 if (k
== MSVCRT_EOF
) {
2242 file
->_flag
|= MSVCRT__IOEOF
;
2250 /*********************************************************************
2253 MSVCRT_wint_t CDECL
MSVCRT_getwc(MSVCRT_FILE
* file
)
2255 return MSVCRT_fgetwc(file
);
2258 /*********************************************************************
2259 * _fgetwchar (MSVCRT.@)
2261 MSVCRT_wint_t CDECL
_fgetwchar(void)
2263 return MSVCRT_fgetwc(MSVCRT_stdin
);
2266 /*********************************************************************
2267 * getwchar (MSVCRT.@)
2269 MSVCRT_wint_t CDECL
MSVCRT_getwchar(void)
2271 return _fgetwchar();
2274 /*********************************************************************
2277 MSVCRT_wchar_t
* CDECL
MSVCRT_fgetws(MSVCRT_wchar_t
*s
, int size
, MSVCRT_FILE
* file
)
2279 int cc
= MSVCRT_WEOF
;
2280 MSVCRT_wchar_t
* buf_start
= s
;
2282 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
2283 file
,file
->_file
,s
,size
);
2285 while ((size
>1) && (cc
= MSVCRT_fgetwc(file
)) != MSVCRT_WEOF
&& cc
!= '\n')
2290 if ((cc
== MSVCRT_WEOF
) && (s
== buf_start
)) /* If nothing read, return 0*/
2292 TRACE(":nothing read\n");
2295 if ((cc
!= MSVCRT_WEOF
) && (size
> 1))
2298 TRACE(":got %s\n", debugstr_w(buf_start
));
2302 /*********************************************************************
2305 MSVCRT_size_t CDECL
MSVCRT_fwrite(const void *ptr
, MSVCRT_size_t size
, MSVCRT_size_t nmemb
, MSVCRT_FILE
* file
)
2307 MSVCRT_size_t wrcnt
=size
* nmemb
;
2312 int pcnt
=(file
->_cnt
>wrcnt
)? wrcnt
: file
->_cnt
;
2313 memcpy(file
->_ptr
, ptr
, pcnt
);
2318 ptr
= (const char*)ptr
+ pcnt
;
2319 } else if(!(file
->_flag
& MSVCRT__IOWRT
)) {
2320 if(file
->_flag
& MSVCRT__IORW
) {
2321 file
->_flag
|= MSVCRT__IOWRT
;
2327 int res
=msvcrt_flush_buffer(file
);
2329 int pwritten
= _write(file
->_file
, ptr
, wrcnt
);
2332 file
->_flag
|= MSVCRT__IOERR
;
2335 written
+= pwritten
;
2338 return written
/ size
;
2341 /*********************************************************************
2344 MSVCRT_wint_t CDECL
MSVCRT_fputwc(MSVCRT_wint_t wc
, MSVCRT_FILE
* file
)
2346 MSVCRT_wchar_t mwc
=wc
;
2347 if (MSVCRT_fwrite( &mwc
, sizeof(mwc
), 1, file
) != 1)
2352 /*********************************************************************
2353 * _fputwchar (MSVCRT.@)
2355 MSVCRT_wint_t CDECL
_fputwchar(MSVCRT_wint_t wc
)
2357 return MSVCRT_fputwc(wc
, MSVCRT_stdout
);
2360 /*********************************************************************
2363 MSVCRT_FILE
* CDECL
MSVCRT_fopen(const char *path
, const char *mode
)
2366 int open_flags
, stream_flags
, fd
;
2368 TRACE("(%s,%s)\n",path
,mode
);
2370 /* map mode string to open() flags. "man fopen" for possibilities. */
2371 if (msvcrt_get_flags(mode
, &open_flags
, &stream_flags
) == -1)
2375 fd
= _open(path
, open_flags
, MSVCRT__S_IREAD
| MSVCRT__S_IWRITE
);
2378 else if ((file
= msvcrt_alloc_fp()) && msvcrt_init_fp(file
, fd
, stream_flags
)
2380 TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd
,mode
,file
);
2387 TRACE(":got (%p)\n",file
);
2388 if (fd
>= 0 && !file
)
2394 /*********************************************************************
2395 * _wfopen (MSVCRT.@)
2397 MSVCRT_FILE
* CDECL
MSVCRT__wfopen(const MSVCRT_wchar_t
*path
, const MSVCRT_wchar_t
*mode
)
2399 const unsigned int plen
= strlenW(path
), mlen
= strlenW(mode
);
2400 char *patha
= MSVCRT_calloc(plen
+ 1, 1);
2401 char *modea
= MSVCRT_calloc(mlen
+ 1, 1);
2403 TRACE("(%s,%s)\n",debugstr_w(path
),debugstr_w(mode
));
2405 if (patha
&& modea
&&
2406 WideCharToMultiByte(CP_ACP
,0,path
,plen
,patha
,plen
,NULL
,NULL
) &&
2407 WideCharToMultiByte(CP_ACP
,0,mode
,mlen
,modea
,mlen
,NULL
,NULL
))
2409 MSVCRT_FILE
*retval
= MSVCRT_fopen(patha
,modea
);
2415 msvcrt_set_errno(GetLastError());
2419 /*********************************************************************
2420 * _fsopen (MSVCRT.@)
2422 MSVCRT_FILE
* CDECL
MSVCRT__fsopen(const char *path
, const char *mode
, int share
)
2424 FIXME(":(%s,%s,%d),ignoring share mode!\n",path
,mode
,share
);
2425 return MSVCRT_fopen(path
,mode
);
2428 /*********************************************************************
2429 * _wfsopen (MSVCRT.@)
2431 MSVCRT_FILE
* CDECL
MSVCRT__wfsopen(const MSVCRT_wchar_t
*path
, const MSVCRT_wchar_t
*mode
, int share
)
2433 FIXME(":(%s,%s,%d),ignoring share mode!\n",
2434 debugstr_w(path
),debugstr_w(mode
),share
);
2435 return MSVCRT__wfopen(path
,mode
);
2438 /* MSVCRT_fputc calls MSVCRT__flsbuf which calls MSVCRT_fputc */
2439 int CDECL
MSVCRT__flsbuf(int c
, MSVCRT_FILE
* file
);
2441 /*********************************************************************
2444 int CDECL
MSVCRT_fputc(int c
, MSVCRT_FILE
* file
)
2451 int res
= msvcrt_flush_buffer(file
);
2452 return res
? res
: c
;
2457 return MSVCRT__flsbuf(c
, file
);
2461 /*********************************************************************
2462 * _flsbuf (MSVCRT.@)
2464 int CDECL
MSVCRT__flsbuf(int c
, MSVCRT_FILE
* file
)
2466 /* Flush output buffer */
2467 if(file
->_bufsiz
== 0 && !(file
->_flag
& MSVCRT__IONBF
)) {
2468 msvcrt_alloc_buffer(file
);
2470 if(!(file
->_flag
& MSVCRT__IOWRT
)) {
2471 if(file
->_flag
& MSVCRT__IORW
) {
2472 file
->_flag
|= MSVCRT__IOWRT
;
2478 int res
=msvcrt_flush_buffer(file
);
2479 return res
?res
: MSVCRT_fputc(c
, file
);
2483 len
= _write(file
->_file
, &cc
, 1);
2484 if (len
== 1) return c
;
2485 file
->_flag
|= MSVCRT__IOERR
;
2490 /*********************************************************************
2491 * _fputchar (MSVCRT.@)
2493 int CDECL
_fputchar(int c
)
2495 return MSVCRT_fputc(c
, MSVCRT_stdout
);
2498 /*********************************************************************
2501 MSVCRT_size_t CDECL
MSVCRT_fread(void *ptr
, MSVCRT_size_t size
, MSVCRT_size_t nmemb
, MSVCRT_FILE
* file
)
2502 { MSVCRT_size_t rcnt
=size
* nmemb
;
2503 MSVCRT_size_t read
=0;
2509 /* first buffered data */
2511 int pcnt
= (rcnt
>file
->_cnt
)? file
->_cnt
:rcnt
;
2512 memcpy(ptr
, file
->_ptr
, pcnt
);
2515 if (MSVCRT_fdesc
[file
->_file
].wxflag
& WX_TEXT
)
2516 pcnt
-= remove_cr(ptr
,pcnt
);
2519 ptr
= (char*)ptr
+ pcnt
;
2520 } else if(!(file
->_flag
& MSVCRT__IOREAD
)) {
2521 if(file
->_flag
& MSVCRT__IORW
) {
2522 file
->_flag
|= MSVCRT__IOREAD
;
2529 /* Fill the buffer on small reads.
2530 * TODO: Use a better buffering strategy.
2532 if (!file
->_cnt
&& size
*nmemb
<= MSVCRT_BUFSIZ
/2 && !(file
->_flag
& MSVCRT__IONBF
)) {
2533 if (file
->_bufsiz
== 0) {
2534 msvcrt_alloc_buffer(file
);
2536 file
->_cnt
= _read(file
->_file
, file
->_base
, file
->_bufsiz
);
2537 file
->_ptr
= file
->_base
;
2538 i
= (file
->_cnt
<rcnt
) ? file
->_cnt
: rcnt
;
2539 /* If the buffer fill reaches eof but fread wouldn't, clear eof. */
2540 if (i
> 0 && i
< file
->_cnt
) {
2541 MSVCRT_fdesc
[file
->_file
].wxflag
&= ~WX_ATEOF
;
2542 file
->_flag
&= ~MSVCRT__IOEOF
;
2545 memcpy(ptr
, file
->_ptr
, i
);
2550 i
= _read(file
->_file
,ptr
, rcnt
);
2554 ptr
= (char *)ptr
+i
;
2555 /* expose feof condition in the flags
2556 * MFC tests file->_flag for feof, and doesn't call feof())
2558 if ( MSVCRT_fdesc
[file
->_file
].wxflag
& WX_ATEOF
)
2559 file
->_flag
|= MSVCRT__IOEOF
;
2562 file
->_flag
|= MSVCRT__IOERR
;
2572 /*********************************************************************
2573 * freopen (MSVCRT.@)
2576 MSVCRT_FILE
* CDECL
MSVCRT_freopen(const char *path
, const char *mode
,MSVCRT_FILE
* file
)
2578 int open_flags
, stream_flags
, fd
;
2580 TRACE(":path (%p) mode (%s) file (%p) fd (%d)\n",path
,mode
,file
,file
->_file
);
2583 if (!file
|| ((fd
= file
->_file
) < 0) || fd
> MSVCRT_fdend
)
2587 MSVCRT_fclose(file
);
2588 /* map mode string to open() flags. "man fopen" for possibilities. */
2589 if (msvcrt_get_flags(mode
, &open_flags
, &stream_flags
) == -1)
2593 fd
= _open(path
, open_flags
, MSVCRT__S_IREAD
| MSVCRT__S_IWRITE
);
2596 else if (msvcrt_init_fp(file
, fd
, stream_flags
) == -1)
2599 WARN(":failed-last error (%d)\n",GetLastError());
2600 msvcrt_set_errno(GetLastError());
2609 /*********************************************************************
2610 * fsetpos (MSVCRT.@)
2612 int CDECL
MSVCRT_fsetpos(MSVCRT_FILE
* file
, MSVCRT_fpos_t
*pos
)
2614 /* Note that all this has been lifted 'as is' from fseek */
2615 if(file
->_flag
& MSVCRT__IOWRT
)
2616 msvcrt_flush_buffer(file
);
2618 /* Discard buffered input */
2620 file
->_ptr
= file
->_base
;
2622 /* Reset direction of i/o */
2623 if(file
->_flag
& MSVCRT__IORW
) {
2624 file
->_flag
&= ~(MSVCRT__IOREAD
|MSVCRT__IOWRT
);
2627 return (_lseeki64(file
->_file
,*pos
,SEEK_SET
) == -1) ? -1 : 0;
2630 /*********************************************************************
2633 LONG CDECL
MSVCRT_ftell(MSVCRT_FILE
* file
)
2638 if( file
->_flag
& MSVCRT__IOWRT
) {
2639 off
= file
->_ptr
- file
->_base
;
2644 pos
= _tell(file
->_file
);
2645 if(pos
== -1) return pos
;
2649 /*********************************************************************
2650 * fgetpos (MSVCRT.@)
2652 int CDECL
MSVCRT_fgetpos(MSVCRT_FILE
* file
, MSVCRT_fpos_t
*pos
)
2654 /* This code has been lifted form the MSVCRT_ftell function */
2657 *pos
= _lseeki64(file
->_file
,0,SEEK_CUR
);
2659 if (*pos
== -1) return -1;
2662 if( file
->_flag
& MSVCRT__IOWRT
) {
2663 off
= file
->_ptr
- file
->_base
;
2673 /*********************************************************************
2676 int CDECL
MSVCRT_fputs(const char *s
, MSVCRT_FILE
* file
)
2678 size_t i
, len
= strlen(s
);
2679 if (!(MSVCRT_fdesc
[file
->_file
].wxflag
& WX_TEXT
))
2680 return MSVCRT_fwrite(s
,sizeof(*s
),len
,file
) == len
? 0 : MSVCRT_EOF
;
2681 for (i
=0; i
<len
; i
++)
2682 if (MSVCRT_fputc(s
[i
], file
) == MSVCRT_EOF
)
2687 /*********************************************************************
2690 int CDECL
MSVCRT_fputws(const MSVCRT_wchar_t
*s
, MSVCRT_FILE
* file
)
2692 size_t i
, len
= strlenW(s
);
2693 if (!(MSVCRT_fdesc
[file
->_file
].wxflag
& WX_TEXT
))
2694 return MSVCRT_fwrite(s
,sizeof(*s
),len
,file
) == len
? 0 : MSVCRT_EOF
;
2695 for (i
=0; i
<len
; i
++)
2697 if ((s
[i
] == L
'\n') && (MSVCRT_fputc('\r', file
) == MSVCRT_EOF
))
2699 if (MSVCRT_fputwc(s
[i
], file
) == MSVCRT_WEOF
)
2705 /*********************************************************************
2706 * getchar (MSVCRT.@)
2708 int CDECL
MSVCRT_getchar(void)
2710 return MSVCRT_fgetc(MSVCRT_stdin
);
2713 /*********************************************************************
2716 int CDECL
MSVCRT_getc(MSVCRT_FILE
* file
)
2718 return MSVCRT_fgetc(file
);
2721 /*********************************************************************
2724 char * CDECL
MSVCRT_gets(char *buf
)
2727 char * buf_start
= buf
;
2729 for(cc
= MSVCRT_fgetc(MSVCRT_stdin
); cc
!= MSVCRT_EOF
&& cc
!= '\n';
2730 cc
= MSVCRT_fgetc(MSVCRT_stdin
))
2731 if(cc
!= '\r') *buf
++ = (char)cc
;
2735 TRACE("got '%s'\n", buf_start
);
2739 /*********************************************************************
2742 MSVCRT_wchar_t
* CDECL
MSVCRT__getws(MSVCRT_wchar_t
* buf
)
2745 MSVCRT_wchar_t
* ws
= buf
;
2747 for (cc
= MSVCRT_fgetwc(MSVCRT_stdin
); cc
!= MSVCRT_WEOF
&& cc
!= '\n';
2748 cc
= MSVCRT_fgetwc(MSVCRT_stdin
))
2751 *buf
++ = (MSVCRT_wchar_t
)cc
;
2755 TRACE("got '%s'\n", debugstr_w(ws
));
2759 /*********************************************************************
2762 int CDECL
MSVCRT_putc(int c
, MSVCRT_FILE
* file
)
2764 return MSVCRT_fputc(c
, file
);
2767 /*********************************************************************
2768 * putchar (MSVCRT.@)
2770 int CDECL
MSVCRT_putchar(int c
)
2772 return MSVCRT_fputc(c
, MSVCRT_stdout
);
2775 /*********************************************************************
2778 int CDECL
MSVCRT_puts(const char *s
)
2780 size_t len
= strlen(s
);
2781 if (MSVCRT_fwrite(s
,sizeof(*s
),len
,MSVCRT_stdout
) != len
) return MSVCRT_EOF
;
2782 return MSVCRT_fwrite("\n",1,1,MSVCRT_stdout
) == 1 ? 0 : MSVCRT_EOF
;
2785 /*********************************************************************
2788 int CDECL
_putws(const MSVCRT_wchar_t
*s
)
2790 static const MSVCRT_wchar_t nl
= '\n';
2791 size_t len
= strlenW(s
);
2792 if (MSVCRT_fwrite(s
,sizeof(*s
),len
,MSVCRT_stdout
) != len
) return MSVCRT_EOF
;
2793 return MSVCRT_fwrite(&nl
,sizeof(nl
),1,MSVCRT_stdout
) == 1 ? 0 : MSVCRT_EOF
;
2796 /*********************************************************************
2799 int CDECL
MSVCRT_remove(const char *path
)
2801 TRACE("(%s)\n",path
);
2802 if (DeleteFileA(path
))
2804 TRACE(":failed (%d)\n",GetLastError());
2805 msvcrt_set_errno(GetLastError());
2809 /*********************************************************************
2810 * _wremove (MSVCRT.@)
2812 int CDECL
_wremove(const MSVCRT_wchar_t
*path
)
2814 TRACE("(%s)\n",debugstr_w(path
));
2815 if (DeleteFileW(path
))
2817 TRACE(":failed (%d)\n",GetLastError());
2818 msvcrt_set_errno(GetLastError());
2822 /*********************************************************************
2825 int CDECL
MSVCRT_rename(const char *oldpath
,const char *newpath
)
2827 TRACE(":from %s to %s\n",oldpath
,newpath
);
2828 if (MoveFileExA(oldpath
, newpath
, MOVEFILE_COPY_ALLOWED
))
2830 TRACE(":failed (%d)\n",GetLastError());
2831 msvcrt_set_errno(GetLastError());
2835 /*********************************************************************
2836 * _wrename (MSVCRT.@)
2838 int CDECL
_wrename(const MSVCRT_wchar_t
*oldpath
,const MSVCRT_wchar_t
*newpath
)
2840 TRACE(":from %s to %s\n",debugstr_w(oldpath
),debugstr_w(newpath
));
2841 if (MoveFileExW(oldpath
, newpath
, MOVEFILE_COPY_ALLOWED
))
2843 TRACE(":failed (%d)\n",GetLastError());
2844 msvcrt_set_errno(GetLastError());
2848 /*********************************************************************
2849 * setvbuf (MSVCRT.@)
2851 int CDECL
MSVCRT_setvbuf(MSVCRT_FILE
* file
, char *buf
, int mode
, MSVCRT_size_t size
)
2853 /* TODO: Check if file busy */
2855 MSVCRT_free(file
->_base
);
2859 if(mode
== MSVCRT__IOFBF
) {
2860 file
->_flag
&= ~MSVCRT__IONBF
;
2861 file
->_base
= file
->_ptr
= buf
;
2863 file
->_bufsiz
= size
;
2866 file
->_flag
|= MSVCRT__IONBF
;
2871 /*********************************************************************
2874 void CDECL
MSVCRT_setbuf(MSVCRT_FILE
* file
, char *buf
)
2876 MSVCRT_setvbuf(file
, buf
, buf
? MSVCRT__IOFBF
: MSVCRT__IONBF
, MSVCRT_BUFSIZ
);
2879 /*********************************************************************
2882 char * CDECL
MSVCRT_tmpnam(char *s
)
2890 msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr
);
2891 p
= s
+ sprintf(s
, "\\s%s.", tmpstr
);
2892 for (count
= 0; count
< MSVCRT_TMP_MAX
; count
++)
2894 msvcrt_int_to_base32(unique
++, tmpstr
);
2896 if (GetFileAttributesA(s
) == INVALID_FILE_ATTRIBUTES
&&
2897 GetLastError() == ERROR_FILE_NOT_FOUND
)
2903 /*********************************************************************
2904 * tmpfile (MSVCRT.@)
2906 MSVCRT_FILE
* CDECL
MSVCRT_tmpfile(void)
2908 char *filename
= MSVCRT_tmpnam(NULL
);
2910 MSVCRT_FILE
* file
= NULL
;
2913 fd
= _open(filename
, MSVCRT__O_CREAT
| MSVCRT__O_BINARY
| MSVCRT__O_RDWR
| MSVCRT__O_TEMPORARY
);
2914 if (fd
!= -1 && (file
= msvcrt_alloc_fp()))
2916 if (msvcrt_init_fp(file
, fd
, MSVCRT__O_RDWR
) == -1)
2921 else file
->_tmpfname
= _strdup(filename
);
2927 /*********************************************************************
2928 * vfprintf (MSVCRT.@)
2930 int CDECL
MSVCRT_vfprintf(MSVCRT_FILE
* file
, const char *format
, va_list valist
)
2932 char buf
[2048], *mem
= buf
;
2933 int written
, resize
= sizeof(buf
), retval
;
2934 /* There are two conventions for vsnprintf failing:
2935 * Return -1 if we truncated, or
2936 * Return the number of bytes that would have been written
2937 * The code below handles both cases
2939 while ((written
= MSVCRT_vsnprintf(mem
, resize
, format
, valist
)) == -1 ||
2942 resize
= (written
== -1 ? resize
* 2 : written
+ 1);
2945 if (!(mem
= (char *)MSVCRT_malloc(resize
)))
2948 retval
= MSVCRT_fwrite(mem
, sizeof(*mem
), written
, file
);
2954 /*********************************************************************
2955 * vfwprintf (MSVCRT.@)
2957 * Is final char included in written (then resize is too big) or not
2958 * (then we must test for equality too)?
2960 int CDECL
MSVCRT_vfwprintf(MSVCRT_FILE
* file
, const MSVCRT_wchar_t
*format
, va_list valist
)
2962 MSVCRT_wchar_t buf
[2048], *mem
= buf
;
2963 int written
, resize
= sizeof(buf
) / sizeof(MSVCRT_wchar_t
), retval
;
2964 /* See vfprintf comments */
2965 while ((written
= MSVCRT_vsnwprintf(mem
, resize
, format
, valist
)) == -1 ||
2968 resize
= (written
== -1 ? resize
* 2 : written
+ sizeof(MSVCRT_wchar_t
));
2971 if (!(mem
= (MSVCRT_wchar_t
*)MSVCRT_malloc(resize
*sizeof(*mem
))))
2974 retval
= MSVCRT_fwrite(mem
, sizeof(*mem
), written
, file
);
2980 /*********************************************************************
2981 * vprintf (MSVCRT.@)
2983 int CDECL
MSVCRT_vprintf(const char *format
, va_list valist
)
2985 return MSVCRT_vfprintf(MSVCRT_stdout
,format
,valist
);
2988 /*********************************************************************
2989 * vwprintf (MSVCRT.@)
2991 int CDECL
MSVCRT_vwprintf(const MSVCRT_wchar_t
*format
, va_list valist
)
2993 return MSVCRT_vfwprintf(MSVCRT_stdout
,format
,valist
);
2996 /*********************************************************************
2997 * fprintf (MSVCRT.@)
2999 int CDECL
MSVCRT_fprintf(MSVCRT_FILE
* file
, const char *format
, ...)
3003 va_start(valist
, format
);
3004 res
= MSVCRT_vfprintf(file
, format
, valist
);
3009 /*********************************************************************
3010 * fwprintf (MSVCRT.@)
3012 int CDECL
MSVCRT_fwprintf(MSVCRT_FILE
* file
, const MSVCRT_wchar_t
*format
, ...)
3016 va_start(valist
, format
);
3017 res
= MSVCRT_vfwprintf(file
, format
, valist
);
3022 /*********************************************************************
3025 int CDECL
MSVCRT_printf(const char *format
, ...)
3029 va_start(valist
, format
);
3030 res
= MSVCRT_vfprintf(MSVCRT_stdout
, format
, valist
);
3035 /*********************************************************************
3038 int CDECL
MSVCRT_ungetc(int c
, MSVCRT_FILE
* file
)
3040 if (c
== MSVCRT_EOF
)
3042 if(file
->_bufsiz
== 0 && !(file
->_flag
& MSVCRT__IONBF
)) {
3043 msvcrt_alloc_buffer(file
);
3046 if(file
->_ptr
>file
->_base
) {
3050 MSVCRT_clearerr(file
);
3056 /*********************************************************************
3057 * ungetwc (MSVCRT.@)
3059 MSVCRT_wint_t CDECL
MSVCRT_ungetwc(MSVCRT_wint_t wc
, MSVCRT_FILE
* file
)
3061 MSVCRT_wchar_t mwc
= wc
;
3062 char * pp
= (char *)&mwc
;
3064 for(i
=sizeof(MSVCRT_wchar_t
)-1;i
>=0;i
--) {
3065 if(pp
[i
] != MSVCRT_ungetc(pp
[i
],file
))
3071 /*********************************************************************
3072 * wprintf (MSVCRT.@)
3074 int CDECL
MSVCRT_wprintf(const MSVCRT_wchar_t
*format
, ...)
3078 va_start(valist
, format
);
3079 res
= MSVCRT_vwprintf(format
, valist
);
3084 /*********************************************************************
3085 * _getmaxstdio (MSVCRT.@)
3087 int CDECL
_getmaxstdio(void)
3089 FIXME("stub, always returns 512\n");
3093 /*********************************************************************
3094 * _setmaxstdio_ (MSVCRT.@)
3096 int CDECL
_setmaxstdio(int newmax
)
3103 FIXME("stub: setting new maximum for number of simultaneously open files not implemented,returning %d\n",res
);
3107 /*********************************************************************
3108 * __pioinfo (MSVCRT.@)
3109 * FIXME: see MSVCRT_MAX_FILES define.
3111 ioinfo
* MSVCRT___pioinfo
[] = { /* array of pointers to ioinfo arrays [64] */
3112 &MSVCRT_fdesc
[0 * 64], &MSVCRT_fdesc
[1 * 64], &MSVCRT_fdesc
[2 * 64],
3113 &MSVCRT_fdesc
[3 * 64], &MSVCRT_fdesc
[4 * 64], &MSVCRT_fdesc
[5 * 64],
3114 &MSVCRT_fdesc
[6 * 64], &MSVCRT_fdesc
[7 * 64], &MSVCRT_fdesc
[8 * 64],
3115 &MSVCRT_fdesc
[9 * 64], &MSVCRT_fdesc
[10 * 64], &MSVCRT_fdesc
[11 * 64],
3116 &MSVCRT_fdesc
[12 * 64], &MSVCRT_fdesc
[13 * 64], &MSVCRT_fdesc
[14 * 64],
3117 &MSVCRT_fdesc
[15 * 64], &MSVCRT_fdesc
[16 * 64], &MSVCRT_fdesc
[17 * 64],
3118 &MSVCRT_fdesc
[18 * 64], &MSVCRT_fdesc
[19 * 64], &MSVCRT_fdesc
[20 * 64],
3119 &MSVCRT_fdesc
[21 * 64], &MSVCRT_fdesc
[22 * 64], &MSVCRT_fdesc
[23 * 64],
3120 &MSVCRT_fdesc
[24 * 64], &MSVCRT_fdesc
[25 * 64], &MSVCRT_fdesc
[26 * 64],
3121 &MSVCRT_fdesc
[27 * 64], &MSVCRT_fdesc
[28 * 64], &MSVCRT_fdesc
[29 * 64],
3122 &MSVCRT_fdesc
[30 * 64], &MSVCRT_fdesc
[31 * 64]
3125 /*********************************************************************
3126 * __badioinfo (MSVCRT.@)
3128 ioinfo MSVCRT___badioinfo
= { INVALID_HANDLE_VALUE
, WX_TEXT
};