?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
vbscript: Implemented Sgn.
[wine/multimedia.git] / dlls / msvcrt / file.c
blob0e5deba3d97601dea34130be7c5ca39675e2361b
1 /*
2 * msvcrt.dll file functions
3 *
4 * Copyright 1996,1998 Marcus Meissner
5 * Copyright 1996 Jukka Iivonen
6 * Copyright 1997,2000 Uwe Bonnes
7 * Copyright 2000 Jon Griffiths
8 * Copyright 2004 Eric Pouech
9 * Copyright 2004 Juan Lang
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 *
25 * TODO
26 * Use the file flag hints O_SEQUENTIAL, O_RANDOM, O_SHORT_LIVED
27 */
28
29 #include "config.h"
30 #include "wine/port.h"
31
32 #include <stdarg.h>
33 #include <stdio.h>
34 #ifdef HAVE_UNISTD_H
35 # include <unistd.h>
36 #endif
37 #include <sys/types.h>
38 #include <limits.h>
39
40 #include "windef.h"
41 #include "winbase.h"
42 #include "winternl.h"
43 #include "msvcrt.h"
44 #include "mtdll.h"
45
46 #include "wine/unicode.h"
47
48 #include "wine/debug.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
51
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))
56
57 /* _access() bit flags FIXME: incomplete */
58 #define MSVCRT_W_OK 0x02
59 #define MSVCRT_R_OK 0x04
60
61 /* values for wxflag in file descriptor */
62 #define WX_OPEN 0x01
63 #define WX_ATEOF 0x02
64 #define WX_READNL 0x04 /* read started with \n */
65 #define WX_PIPE 0x08
66 #define WX_DONTINHERIT 0x10
67 #define WX_APPEND 0x20
68 #define WX_NOSEEK 0x40
69 #define WX_TEXT 0x80
70
71 /* values for exflag - it's used differently in msvcr90.dll*/
72 #define EF_UTF8 0x01
73 #define EF_UTF16 0x02
74 #define EF_CRIT_INIT 0x04
75 #define EF_UNK_UNICODE 0x08
76
77 static char utf8_bom[3] = { 0xef, 0xbb, 0xbf };
78 static char utf16_bom[2] = { 0xff, 0xfe };
79
80 /* FIXME: this should be allocated dynamically */
81 #define MSVCRT_MAX_FILES 2048
82 #define MSVCRT_FD_BLOCK_SIZE 32
83
84 #define MSVCRT_INTERNAL_BUFSIZ 4096
85
86 /* ioinfo structure size is different in msvcrXX.dll's */
87 typedef struct {
88 HANDLE handle;
89 unsigned char wxflag;
90 char lookahead[3];
91 int exflag;
92 CRITICAL_SECTION crit;
93 #if _MSVCR_VER >= 80
94 char textmode : 7;
95 char unicode : 1;
96 char pipech2[2];
97 __int64 startpos;
98 BOOL utf8translations;
99 #endif
100 #if _MSVCR_VER >= 90
101 char dbcsBuffer;
102 BOOL dbcsBufferUsed;
103 #endif
104 } ioinfo;
105
106 /*********************************************************************
107 * __pioinfo (MSVCRT.@)
108 * array of pointers to ioinfo arrays [32]
109 */
110 ioinfo * MSVCRT___pioinfo[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE] = { 0 };
111
112 /*********************************************************************
113 * __badioinfo (MSVCRT.@)
114 */
115 ioinfo MSVCRT___badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };
116
117 static int MSVCRT_fdstart = 3; /* first unallocated fd */
118 static int MSVCRT_fdend = 3; /* highest allocated fd */
119
120 typedef struct {
121 MSVCRT_FILE file;
122 CRITICAL_SECTION crit;
123 } file_crit;
124
125 MSVCRT_FILE MSVCRT__iob[_IOB_ENTRIES] = { { 0 } };
126 static file_crit* MSVCRT_fstream[MSVCRT_MAX_FILES/MSVCRT_FD_BLOCK_SIZE];
127 static int MSVCRT_max_streams = 512, MSVCRT_stream_idx;
128
129 /* INTERNAL: process umask */
130 static int MSVCRT_umask = 0;
131
132 /* INTERNAL: static data for tmpnam and _wtmpname functions */
133 static int tmpnam_unique;
134
135 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
136 static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
137 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
138 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
139
140 #define TOUL(x) (ULONGLONG)(x)
141 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
142 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
143 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
144 static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
145
146 /* This critical section protects the tables MSVCRT___pioinfo and MSVCRT_fstreams,
147 * and their related indexes, MSVCRT_fdstart, MSVCRT_fdend,
148 * and MSVCRT_stream_idx, from race conditions.
149 * It doesn't protect against race conditions manipulating the underlying files
150 * or flags; doing so would probably be better accomplished with per-file
151 * protection, rather than locking the whole table for every change.
152 */
153 static CRITICAL_SECTION MSVCRT_file_cs;
154 static CRITICAL_SECTION_DEBUG MSVCRT_file_cs_debug =
155 {
156 0, 0, &MSVCRT_file_cs,
157 { &MSVCRT_file_cs_debug.ProcessLocksList, &MSVCRT_file_cs_debug.ProcessLocksList },
158 0, 0, { (DWORD_PTR)(__FILE__ ": MSVCRT_file_cs") }
159 };
160 static CRITICAL_SECTION MSVCRT_file_cs = { &MSVCRT_file_cs_debug, -1, 0, 0, 0, 0 };
161 #define LOCK_FILES() do { EnterCriticalSection(&MSVCRT_file_cs); } while (0)
162 #define UNLOCK_FILES() do { LeaveCriticalSection(&MSVCRT_file_cs); } while (0)
163
164 static void msvcrt_stat64_to_stat(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat *buf)
165 {
166 buf->st_dev = buf64->st_dev;
167 buf->st_ino = buf64->st_ino;
168 buf->st_mode = buf64->st_mode;
169 buf->st_nlink = buf64->st_nlink;
170 buf->st_uid = buf64->st_uid;
171 buf->st_gid = buf64->st_gid;
172 buf->st_rdev = buf64->st_rdev;
173 buf->st_size = buf64->st_size;
174 buf->st_atime = buf64->st_atime;
175 buf->st_mtime = buf64->st_mtime;
176 buf->st_ctime = buf64->st_ctime;
177 }
178
179 static void msvcrt_stat64_to_stati64(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stati64 *buf)
180 {
181 buf->st_dev = buf64->st_dev;
182 buf->st_ino = buf64->st_ino;
183 buf->st_mode = buf64->st_mode;
184 buf->st_nlink = buf64->st_nlink;
185 buf->st_uid = buf64->st_uid;
186 buf->st_gid = buf64->st_gid;
187 buf->st_rdev = buf64->st_rdev;
188 buf->st_size = buf64->st_size;
189 buf->st_atime = buf64->st_atime;
190 buf->st_mtime = buf64->st_mtime;
191 buf->st_ctime = buf64->st_ctime;
192 }
193
194 static void msvcrt_stat64_to_stat32(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat32 *buf)
195 {
196 buf->st_dev = buf64->st_dev;
197 buf->st_ino = buf64->st_ino;
198 buf->st_mode = buf64->st_mode;
199 buf->st_nlink = buf64->st_nlink;
200 buf->st_uid = buf64->st_uid;
201 buf->st_gid = buf64->st_gid;
202 buf->st_rdev = buf64->st_rdev;
203 buf->st_size = buf64->st_size;
204 buf->st_atime = buf64->st_atime;
205 buf->st_mtime = buf64->st_mtime;
206 buf->st_ctime = buf64->st_ctime;
207 }
208
209 static void msvcrt_stat64_to_stat64i32(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat64i32 *buf)
210 {
211 buf->st_dev = buf64->st_dev;
212 buf->st_ino = buf64->st_ino;
213 buf->st_mode = buf64->st_mode;
214 buf->st_nlink = buf64->st_nlink;
215 buf->st_uid = buf64->st_uid;
216 buf->st_gid = buf64->st_gid;
217 buf->st_rdev = buf64->st_rdev;
218 buf->st_size = buf64->st_size;
219 buf->st_atime = buf64->st_atime;
220 buf->st_mtime = buf64->st_mtime;
221 buf->st_ctime = buf64->st_ctime;
222 }
223
224 static void msvcrt_stat64_to_stat32i64(const struct MSVCRT__stat64 *buf64, struct MSVCRT__stat32i64 *buf)
225 {
226 buf->st_dev = buf64->st_dev;
227 buf->st_ino = buf64->st_ino;
228 buf->st_mode = buf64->st_mode;
229 buf->st_nlink = buf64->st_nlink;
230 buf->st_uid = buf64->st_uid;
231 buf->st_gid = buf64->st_gid;
232 buf->st_rdev = buf64->st_rdev;
233 buf->st_size = buf64->st_size;
234 buf->st_atime = buf64->st_atime;
235 buf->st_mtime = buf64->st_mtime;
236 buf->st_ctime = buf64->st_ctime;
237 }
238
239 static void time_to_filetime( MSVCRT___time64_t time, FILETIME *ft )
240 {
241 /* 1601 to 1970 is 369 years plus 89 leap days */
242 static const __int64 secs_1601_to_1970 = ((369 * 365 + 89) * (__int64)86400);
243
244 __int64 ticks = (time + secs_1601_to_1970) * 10000000;
245 ft->dwHighDateTime = ticks >> 32;
246 ft->dwLowDateTime = ticks;
247 }
248
249 static inline ioinfo* msvcrt_get_ioinfo(int fd)
250 {
251 ioinfo *ret = NULL;
252 if(fd < MSVCRT_MAX_FILES)
253 ret = MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE];
254 if(!ret)
255 return &MSVCRT___badioinfo;
256
257 return ret + (fd%MSVCRT_FD_BLOCK_SIZE);
258 }
259
260 static inline MSVCRT_FILE* msvcrt_get_file(int i)
261 {
262 file_crit *ret;
263
264 if(i >= MSVCRT_max_streams)
265 return NULL;
266
267 if(i < _IOB_ENTRIES)
268 return &MSVCRT__iob[i];
269
270 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE];
271 if(!ret) {
272 MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] = MSVCRT_calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(file_crit));
273 if(!MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE]) {
274 ERR("out of memory\n");
275 *MSVCRT__errno() = MSVCRT_ENOMEM;
276 return NULL;
277 }
278
279 ret = MSVCRT_fstream[i/MSVCRT_FD_BLOCK_SIZE] + (i%MSVCRT_FD_BLOCK_SIZE);
280 } else
281 ret += i%MSVCRT_FD_BLOCK_SIZE;
282
283 return &ret->file;
284 }
285
286 static inline BOOL msvcrt_is_valid_fd(int fd)
287 {
288 return fd >= 0 && fd < MSVCRT_fdend && (msvcrt_get_ioinfo(fd)->wxflag & WX_OPEN);
289 }
290
291 /* INTERNAL: Get the HANDLE for a fd
292 * This doesn't lock the table, because a failure will result in
293 * INVALID_HANDLE_VALUE being returned, which should be handled correctly. If
294 * it returns a valid handle which is about to be closed, a subsequent call
295 * will fail, most likely in a sane way.
296 */
297 static HANDLE msvcrt_fdtoh(int fd)
298 {
299 if (!msvcrt_is_valid_fd(fd))
300 {
301 WARN(":fd (%d) - no handle!\n",fd);
302 *MSVCRT___doserrno() = 0;
303 *MSVCRT__errno() = MSVCRT_EBADF;
304 return INVALID_HANDLE_VALUE;
305 }
306 if (msvcrt_get_ioinfo(fd)->handle == INVALID_HANDLE_VALUE)
307 WARN("returning INVALID_HANDLE_VALUE for %d\n", fd);
308 return msvcrt_get_ioinfo(fd)->handle;
309 }
310
311 /* INTERNAL: free a file entry fd */
312 static void msvcrt_free_fd(int fd)
313 {
314 ioinfo *fdinfo;
315
316 LOCK_FILES();
317 fdinfo = msvcrt_get_ioinfo(fd);
318 if(fdinfo != &MSVCRT___badioinfo)
319 {
320 fdinfo->handle = INVALID_HANDLE_VALUE;
321 fdinfo->wxflag = 0;
322 }
323 TRACE(":fd (%d) freed\n",fd);
324
325 if (fd < 3)
326 {
327 switch (fd)
328 {
329 case 0:
330 SetStdHandle(STD_INPUT_HANDLE, 0);
331 break;
332 case 1:
333 SetStdHandle(STD_OUTPUT_HANDLE, 0);
334 break;
335 case 2:
336 SetStdHandle(STD_ERROR_HANDLE, 0);
337 break;
338 }
339 }
340
341 if (fd == MSVCRT_fdend - 1)
342 MSVCRT_fdend--;
343 if (fd < MSVCRT_fdstart)
344 MSVCRT_fdstart = fd;
345 UNLOCK_FILES();
346 }
347
348 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE, starting from fd */
349 /* caller must hold the files lock */
350 static int msvcrt_set_fd(HANDLE hand, int flag, int fd)
351 {
352 ioinfo *fdinfo;
353
354 if (fd >= MSVCRT_MAX_FILES)
355 {
356 WARN(":files exhausted!\n");
357 *MSVCRT__errno() = MSVCRT_ENFILE;
358 return -1;
359 }
360
361 fdinfo = msvcrt_get_ioinfo(fd);
362 if(fdinfo == &MSVCRT___badioinfo) {
363 int i;
364
365 MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE] = MSVCRT_calloc(MSVCRT_FD_BLOCK_SIZE, sizeof(ioinfo));
366 if(!MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE]) {
367 WARN(":out of memory!\n");
368 *MSVCRT__errno() = MSVCRT_ENOMEM;
369 return -1;
370 }
371
372 for(i=0; i<MSVCRT_FD_BLOCK_SIZE; i++)
373 MSVCRT___pioinfo[fd/MSVCRT_FD_BLOCK_SIZE][i].handle = INVALID_HANDLE_VALUE;
374
375 fdinfo = msvcrt_get_ioinfo(fd);
376 }
377
378 fdinfo->handle = hand;
379 fdinfo->wxflag = WX_OPEN | (flag & (WX_DONTINHERIT | WX_APPEND | WX_TEXT | WX_PIPE | WX_NOSEEK));
380 fdinfo->lookahead[0] = '\n';
381 fdinfo->lookahead[1] = '\n';
382 fdinfo->lookahead[2] = '\n';
383 fdinfo->exflag = 0;
384
385 /* locate next free slot */
386 if (fd == MSVCRT_fdstart && fd == MSVCRT_fdend)
387 MSVCRT_fdstart = MSVCRT_fdend + 1;
388 else
389 while (MSVCRT_fdstart < MSVCRT_fdend &&
390 msvcrt_get_ioinfo(MSVCRT_fdstart)->handle != INVALID_HANDLE_VALUE)
391 MSVCRT_fdstart++;
392 /* update last fd in use */
393 if (fd >= MSVCRT_fdend)
394 MSVCRT_fdend = fd + 1;
395 TRACE("fdstart is %d, fdend is %d\n", MSVCRT_fdstart, MSVCRT_fdend);
396
397 switch (fd)
398 {
399 case 0: SetStdHandle(STD_INPUT_HANDLE, hand); break;
400 case 1: SetStdHandle(STD_OUTPUT_HANDLE, hand); break;
401 case 2: SetStdHandle(STD_ERROR_HANDLE, hand); break;
402 }
403
404 return fd;
405 }
406
407 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
408 static int msvcrt_alloc_fd(HANDLE hand, int flag)
409 {
410 int ret;
411
412 LOCK_FILES();
413 TRACE(":handle (%p) allocating fd (%d)\n",hand,MSVCRT_fdstart);
414 ret = msvcrt_set_fd(hand, flag, MSVCRT_fdstart);
415 UNLOCK_FILES();
416 return ret;
417 }
418
419 /* INTERNAL: Allocate a FILE* for an fd slot */
420 /* caller must hold the files lock */
421 static MSVCRT_FILE* msvcrt_alloc_fp(void)
422 {
423 int i;
424 MSVCRT_FILE *file;
425
426 for (i = 3; i < MSVCRT_max_streams; i++)
427 {
428 file = msvcrt_get_file(i);
429 if (!file)
430 return NULL;
431
432 if (file->_flag == 0)
433 {
434 if (i == MSVCRT_stream_idx)
435 {
436 if (file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
437 {
438 InitializeCriticalSection(&((file_crit*)file)->crit);
439 ((file_crit*)file)->crit.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": file_crit.crit");
440 }
441 MSVCRT_stream_idx++;
442 }
443 return file;
444 }
445 }
446
447 return NULL;
448 }
449
450 /* INTERNAL: initialize a FILE* from an open fd */
451 static int msvcrt_init_fp(MSVCRT_FILE* file, int fd, unsigned stream_flags)
452 {
453 TRACE(":fd (%d) allocating FILE*\n",fd);
454 if (!msvcrt_is_valid_fd(fd))
455 {
456 WARN(":invalid fd %d\n",fd);
457 *MSVCRT___doserrno() = 0;
458 *MSVCRT__errno() = MSVCRT_EBADF;
459 return -1;
460 }
461 file->_ptr = file->_base = NULL;
462 file->_cnt = 0;
463 file->_file = fd;
464 file->_flag = stream_flags;
465 file->_tmpfname = NULL;
466
467 TRACE(":got FILE* (%p)\n",file);
468 return 0;
469 }
470
471 /* INTERNAL: Create an inheritance data block (for spawned process)
472 * The inheritance block is made of:
473 * 00 int nb of file descriptor (NBFD)
474 * 04 char file flags (wxflag): repeated for each fd
475 * 4+NBFD HANDLE file handle: repeated for each fd
476 */
477 unsigned msvcrt_create_io_inherit_block(WORD *size, BYTE **block)
478 {
479 int fd;
480 char* wxflag_ptr;
481 HANDLE* handle_ptr;
482 ioinfo* fdinfo;
483
484 *size = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * MSVCRT_fdend;
485 *block = MSVCRT_calloc(*size, 1);
486 if (!*block)
487 {
488 *size = 0;
489 return FALSE;
490 }
491 wxflag_ptr = (char*)*block + sizeof(unsigned);
492 handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
493
494 *(unsigned*)*block = MSVCRT_fdend;
495 for (fd = 0; fd < MSVCRT_fdend; fd++)
496 {
497 /* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
498 fdinfo = msvcrt_get_ioinfo(fd);
499 if ((fdinfo->wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
500 {
501 *wxflag_ptr = fdinfo->wxflag;
502 *handle_ptr = fdinfo->handle;
503 }
504 else
505 {
506 *wxflag_ptr = 0;
507 *handle_ptr = INVALID_HANDLE_VALUE;
508 }
509 wxflag_ptr++; handle_ptr++;
510 }
511 return TRUE;
512 }
513
514 /* INTERNAL: Set up all file descriptors,
515 * as well as default streams (stdin, stderr and stdout)
516 */
517 void msvcrt_init_io(void)
518 {
519 STARTUPINFOA si;
520 int i;
521 ioinfo *fdinfo;
522
523 GetStartupInfoA(&si);
524 if (si.cbReserved2 >= sizeof(unsigned int) && si.lpReserved2 != NULL)
525 {
526 BYTE* wxflag_ptr;
527 HANDLE* handle_ptr;
528 unsigned int count;
529
530 count = *(unsigned*)si.lpReserved2;
531 wxflag_ptr = si.lpReserved2 + sizeof(unsigned);
532 handle_ptr = (HANDLE*)(wxflag_ptr + count);
533
534 count = min(count, (si.cbReserved2 - sizeof(unsigned)) / (sizeof(HANDLE) + 1));
535 count = min(count, MSVCRT_MAX_FILES);
536 for (i = 0; i < count; i++)
537 {
538 if ((*wxflag_ptr & WX_OPEN) && *handle_ptr != INVALID_HANDLE_VALUE)
539 msvcrt_set_fd(*handle_ptr, *wxflag_ptr, i);
540
541 wxflag_ptr++; handle_ptr++;
542 }
543 MSVCRT_fdend = max( 3, count );
544 for (MSVCRT_fdstart = 3; MSVCRT_fdstart < MSVCRT_fdend; MSVCRT_fdstart++)
545 if (msvcrt_get_ioinfo(MSVCRT_fdstart)->handle == INVALID_HANDLE_VALUE) break;
546 }
547
548 fdinfo = msvcrt_get_ioinfo(MSVCRT_STDIN_FILENO);
549 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
550 HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
551 DWORD type = GetFileType(h);
552
553 msvcrt_set_fd(h, WX_OPEN|WX_TEXT|((type&0xf)==FILE_TYPE_CHAR ? WX_NOSEEK : 0)
554 |((type&0xf)==FILE_TYPE_PIPE ? WX_PIPE : 0), MSVCRT_STDIN_FILENO);
555 }
556
557 fdinfo = msvcrt_get_ioinfo(MSVCRT_STDOUT_FILENO);
558 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
559 HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
560 DWORD type = GetFileType(h);
561
562 msvcrt_set_fd(h, WX_OPEN|WX_TEXT|((type&0xf)==FILE_TYPE_CHAR ? WX_NOSEEK : 0)
563 |((type&0xf)==FILE_TYPE_PIPE ? WX_PIPE : 0), MSVCRT_STDOUT_FILENO);
564 }
565
566 fdinfo = msvcrt_get_ioinfo(MSVCRT_STDERR_FILENO);
567 if (!(fdinfo->wxflag & WX_OPEN) || fdinfo->handle == INVALID_HANDLE_VALUE) {
568 HANDLE h = GetStdHandle(STD_ERROR_HANDLE);
569 DWORD type = GetFileType(h);
570
571 msvcrt_set_fd(h, WX_OPEN|WX_TEXT|((type&0xf)==FILE_TYPE_CHAR ? WX_NOSEEK : 0)
572 |((type&0xf)==FILE_TYPE_PIPE ? WX_PIPE : 0), MSVCRT_STDERR_FILENO);
573 }
574
575 TRACE(":handles (%p)(%p)(%p)\n", msvcrt_get_ioinfo(MSVCRT_STDIN_FILENO)->handle,
576 msvcrt_get_ioinfo(MSVCRT_STDOUT_FILENO)->handle,
577 msvcrt_get_ioinfo(MSVCRT_STDERR_FILENO)->handle);
578
579 memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
580 for (i = 0; i < 3; i++)
581 {
582 /* FILE structs for stdin/out/err are static and never deleted */
583 MSVCRT__iob[i]._file = i;
584 MSVCRT__iob[i]._tmpfname = NULL;
585 MSVCRT__iob[i]._flag = (i == 0) ? MSVCRT__IOREAD : MSVCRT__IOWRT;
586 }
587 MSVCRT_stream_idx = 3;
588 }
589
590 /* INTERNAL: Flush stdio file buffer */
591 static int msvcrt_flush_buffer(MSVCRT_FILE* file)
592 {
593 if(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)) {
594 int cnt=file->_ptr-file->_base;
595 if(cnt>0 && MSVCRT__write(file->_file, file->_base, cnt) != cnt) {
596 file->_flag |= MSVCRT__IOERR;
597 return MSVCRT_EOF;
598 }
599 file->_ptr=file->_base;
600 file->_cnt=0;
601 }
602 return 0;
603 }
604
605 /*********************************************************************
606 * _isatty (MSVCRT.@)
607 */
608 int CDECL MSVCRT__isatty(int fd)
609 {
610 HANDLE hand = msvcrt_fdtoh(fd);
611
612 TRACE(":fd (%d) handle (%p)\n",fd,hand);
613 if (hand == INVALID_HANDLE_VALUE)
614 return 0;
615
616 return GetFileType(hand) == FILE_TYPE_CHAR? 1 : 0;
617 }
618
619 /* INTERNAL: Allocate stdio file buffer */
620 static BOOL msvcrt_alloc_buffer(MSVCRT_FILE* file)
621 {
622 if((file->_file==MSVCRT_STDOUT_FILENO || file->_file==MSVCRT_STDERR_FILENO)
623 && MSVCRT__isatty(file->_file))
624 return FALSE;
625
626 file->_base = MSVCRT_calloc(MSVCRT_INTERNAL_BUFSIZ,1);
627 if(file->_base) {
628 file->_bufsiz = MSVCRT_INTERNAL_BUFSIZ;
629 file->_flag |= MSVCRT__IOMYBUF;
630 } else {
631 file->_base = (char*)(&file->_charbuf);
632 file->_bufsiz = 2;
633 file->_flag |= MSVCRT__IONBF;
634 }
635 file->_ptr = file->_base;
636 file->_cnt = 0;
637 return TRUE;
638 }
639
640 /* INTERNAL: Allocate temporary buffer for stdout and stderr */
641 static BOOL add_std_buffer(MSVCRT_FILE *file)
642 {
643 static char buffers[2][MSVCRT_BUFSIZ];
644
645 if((file->_file!=MSVCRT_STDOUT_FILENO && file->_file!=MSVCRT_STDERR_FILENO)
646 || (file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF))
647 || !MSVCRT__isatty(file->_file))
648 return FALSE;
649
650 file->_ptr = file->_base = buffers[file->_file == MSVCRT_STDOUT_FILENO ? 0 : 1];
651 file->_bufsiz = file->_cnt = MSVCRT_BUFSIZ;
652 file->_flag |= MSVCRT__USERBUF;
653 return TRUE;
654 }
655
656 /* INTERNAL: Removes temporary buffer from stdout or stderr */
657 /* Only call this function when add_std_buffer returned TRUE */
658 static void remove_std_buffer(MSVCRT_FILE *file)
659 {
660 msvcrt_flush_buffer(file);
661 file->_ptr = file->_base = NULL;
662 file->_bufsiz = file->_cnt = 0;
663 file->_flag &= ~MSVCRT__USERBUF;
664 }
665
666 /* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
667 static int msvcrt_int_to_base32(int num, char *str)
668 {
669 char *p;
670 int n = num;
671 int digits = 0;
672
673 while (n != 0)
674 {
675 n >>= 5;
676 digits++;
677 }
678 p = str + digits;
679 *p = 0;
680 while (--p >= str)
681 {
682 *p = (num & 31) + '0';
683 if (*p > '9')
684 *p += ('a' - '0' - 10);
685 num >>= 5;
686 }
687
688 return digits;
689 }
690
691 /* INTERNAL: wide character version of msvcrt_int_to_base32 */
692 static int msvcrt_int_to_base32_w(int num, MSVCRT_wchar_t *str)
693 {
694 MSVCRT_wchar_t *p;
695 int n = num;
696 int digits = 0;
697
698 while (n != 0)
699 {
700 n >>= 5;
701 digits++;
702 }
703 p = str + digits;
704 *p = 0;
705 while (--p >= str)
706 {
707 *p = (num & 31) + '0';
708 if (*p > '9')
709 *p += ('a' - '0' - 10);
710 num >>= 5;
711 }
712
713 return digits;
714 }
715
716 /*********************************************************************
717 * __iob_func(MSVCRT.@)
718 */
719 MSVCRT_FILE * CDECL MSVCRT___iob_func(void)
720 {
721 return &MSVCRT__iob[0];
722 }
723
724 /*********************************************************************
725 * _access (MSVCRT.@)
726 */
727 int CDECL MSVCRT__access(const char *filename, int mode)
728 {
729 DWORD attr = GetFileAttributesA(filename);
730
731 TRACE("(%s,%d) %d\n",filename,mode,attr);
732
733 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
734 {
735 msvcrt_set_errno(GetLastError());
736 return -1;
737 }
738 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
739 {
740 msvcrt_set_errno(ERROR_ACCESS_DENIED);
741 return -1;
742 }
743 return 0;
744 }
745
746 /*********************************************************************
747 * _access_s (MSVCRT.@)
748 */
749 int CDECL MSVCRT__access_s(const char *filename, int mode)
750 {
751 if (!MSVCRT_CHECK_PMT(filename != NULL)) return *MSVCRT__errno();
752 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return *MSVCRT__errno();
753
754 if (MSVCRT__access(filename, mode) == -1)
755 return *MSVCRT__errno();
756 return 0;
757 }
758
759 /*********************************************************************
760 * _waccess (MSVCRT.@)
761 */
762 int CDECL MSVCRT__waccess(const MSVCRT_wchar_t *filename, int mode)
763 {
764 DWORD attr = GetFileAttributesW(filename);
765
766 TRACE("(%s,%d) %d\n",debugstr_w(filename),mode,attr);
767
768 if (!filename || attr == INVALID_FILE_ATTRIBUTES)
769 {
770 msvcrt_set_errno(GetLastError());
771 return -1;
772 }
773 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
774 {
775 msvcrt_set_errno(ERROR_ACCESS_DENIED);
776 return -1;
777 }
778 return 0;
779 }
780
781 /*********************************************************************
782 * _waccess_s (MSVCRT.@)
783 */
784 int CDECL MSVCRT__waccess_s(const MSVCRT_wchar_t *filename, int mode)
785 {
786 if (!MSVCRT_CHECK_PMT(filename != NULL)) return *MSVCRT__errno();
787 if (!MSVCRT_CHECK_PMT((mode & ~(MSVCRT_R_OK | MSVCRT_W_OK)) == 0)) return *MSVCRT__errno();
788
789 if (MSVCRT__waccess(filename, mode) == -1)
790 return *MSVCRT__errno();
791 return 0;
792 }
793
794 /*********************************************************************
795 * _chmod (MSVCRT.@)
796 */
797 int CDECL MSVCRT__chmod(const char *path, int flags)
798 {
799 DWORD oldFlags = GetFileAttributesA(path);
800
801 if (oldFlags != INVALID_FILE_ATTRIBUTES)
802 {
803 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
804 oldFlags | FILE_ATTRIBUTE_READONLY;
805
806 if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
807 return 0;
808 }
809 msvcrt_set_errno(GetLastError());
810 return -1;
811 }
812
813 /*********************************************************************
814 * _wchmod (MSVCRT.@)
815 */
816 int CDECL MSVCRT__wchmod(const MSVCRT_wchar_t *path, int flags)
817 {
818 DWORD oldFlags = GetFileAttributesW(path);
819
820 if (oldFlags != INVALID_FILE_ATTRIBUTES)
821 {
822 DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
823 oldFlags | FILE_ATTRIBUTE_READONLY;
824
825 if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
826 return 0;
827 }
828 msvcrt_set_errno(GetLastError());
829 return -1;
830 }
831
832 /*********************************************************************
833 * _unlink (MSVCRT.@)
834 */
835 int CDECL MSVCRT__unlink(const char *path)
836 {
837 TRACE("%s\n",debugstr_a(path));
838 if(DeleteFileA(path))
839 return 0;
840 TRACE("failed (%d)\n",GetLastError());
841 msvcrt_set_errno(GetLastError());
842 return -1;
843 }
844
845 /*********************************************************************
846 * _wunlink (MSVCRT.@)
847 */
848 int CDECL MSVCRT__wunlink(const MSVCRT_wchar_t *path)
849 {
850 TRACE("(%s)\n",debugstr_w(path));
851 if(DeleteFileW(path))
852 return 0;
853 TRACE("failed (%d)\n",GetLastError());
854 msvcrt_set_errno(GetLastError());
855 return -1;
856 }
857
858 /*********************************************************************
859 * _commit (MSVCRT.@)
860 */
861 int CDECL MSVCRT__commit(int fd)
862 {
863 HANDLE hand = msvcrt_fdtoh(fd);
864
865 TRACE(":fd (%d) handle (%p)\n",fd,hand);
866 if (hand == INVALID_HANDLE_VALUE)
867 return -1;
868
869 if (!FlushFileBuffers(hand))
870 {
871 if (GetLastError() == ERROR_INVALID_HANDLE)
872 {
873 /* FlushFileBuffers fails for console handles
874 * so we ignore this error.
875 */
876 return 0;
877 }
878 TRACE(":failed-last error (%d)\n",GetLastError());
879 msvcrt_set_errno(GetLastError());
880 return -1;
881 }
882 TRACE(":ok\n");
883 return 0;
884 }
885
886 /* flush_all_buffers calls MSVCRT_fflush which calls flush_all_buffers */
887 int CDECL MSVCRT_fflush(MSVCRT_FILE* file);
888
889 /* INTERNAL: Flush all stream buffer */
890 static int msvcrt_flush_all_buffers(int mask)
891 {
892 int i, num_flushed = 0;
893 MSVCRT_FILE *file;
894
895 LOCK_FILES();
896 for (i = 0; i < MSVCRT_stream_idx; i++) {
897 file = msvcrt_get_file(i);
898
899 if (file->_flag)
900 {
901 if(file->_flag & mask) {
902 MSVCRT_fflush(file);
903 num_flushed++;
904 }
905 }
906 }
907 UNLOCK_FILES();
908
909 TRACE(":flushed (%d) handles\n",num_flushed);
910 return num_flushed;
911 }
912
913 /*********************************************************************
914 * _flushall (MSVCRT.@)
915 */
916 int CDECL MSVCRT__flushall(void)
917 {
918 return msvcrt_flush_all_buffers(MSVCRT__IOWRT | MSVCRT__IOREAD);
919 }
920
921 /*********************************************************************
922 * fflush (MSVCRT.@)
923 */
924 int CDECL MSVCRT_fflush(MSVCRT_FILE* file)
925 {
926 if(!file) {
927 msvcrt_flush_all_buffers(MSVCRT__IOWRT);
928 } else if(file->_flag & MSVCRT__IOWRT) {
929 int res;
930
931 MSVCRT__lock_file(file);
932 res = msvcrt_flush_buffer(file);
933
934 if(!res && (file->_flag & MSVCRT__IOCOMMIT))
935 res = MSVCRT__commit(file->_file) ? MSVCRT_EOF : 0;
936 MSVCRT__unlock_file(file);
937
938 return res;
939 } else if(file->_flag & MSVCRT__IOREAD) {
940 MSVCRT__lock_file(file);
941 file->_cnt = 0;
942 file->_ptr = file->_base;
943 MSVCRT__unlock_file(file);
944
945 return 0;
946 }
947 return 0;
948 }
949
950 /*********************************************************************
951 * _close (MSVCRT.@)
952 */
953 int CDECL MSVCRT__close(int fd)
954 {
955 HANDLE hand;
956 int ret;
957
958 LOCK_FILES();
959 hand = msvcrt_fdtoh(fd);
960 TRACE(":fd (%d) handle (%p)\n",fd,hand);
961 if (!msvcrt_is_valid_fd(fd)) {
962 ret = -1;
963 } else {
964 msvcrt_free_fd(fd);
965 ret = CloseHandle(hand) ? 0 : -1;
966 if (ret) {
967 WARN(":failed-last error (%d)\n",GetLastError());
968 msvcrt_set_errno(GetLastError());
969 }
970 }
971 UNLOCK_FILES();
972 TRACE(":ok\n");
973 return ret;
974 }
975
976 /*********************************************************************
977 * _dup2 (MSVCRT.@)
978 * NOTES
979 * MSDN isn't clear on this point, but the remarks for _pipe
980 * indicate file descriptors duplicated with _dup and _dup2 are always
981 * inheritable.
982 */
983 int CDECL MSVCRT__dup2(int od, int nd)
984 {
985 int ret;
986
987 TRACE("(od=%d, nd=%d)\n", od, nd);
988 LOCK_FILES();
989 if (nd < MSVCRT_MAX_FILES && nd >= 0 && msvcrt_is_valid_fd(od))
990 {
991 HANDLE handle;
992
993 if (DuplicateHandle(GetCurrentProcess(), msvcrt_get_ioinfo(od)->handle,
994 GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS))
995 {
996 int wxflag = msvcrt_get_ioinfo(od)->wxflag & ~MSVCRT__O_NOINHERIT;
997
998 if (msvcrt_is_valid_fd(nd))
999 MSVCRT__close(nd);
1000 ret = msvcrt_set_fd(handle, wxflag, nd);
1001 if (ret == -1)
1002 {
1003 CloseHandle(handle);
1004 *MSVCRT__errno() = MSVCRT_EMFILE;
1005 }
1006 else
1007 {
1008 /* _dup2 returns 0, not nd, on success */
1009 ret = 0;
1010 }
1011 }
1012 else
1013 {
1014 ret = -1;
1015 msvcrt_set_errno(GetLastError());
1016 }
1017 }
1018 else
1019 {
1020 *MSVCRT__errno() = MSVCRT_EBADF;
1021 ret = -1;
1022 }
1023 UNLOCK_FILES();
1024 return ret;
1025 }
1026
1027 /*********************************************************************
1028 * _dup (MSVCRT.@)
1029 */
1030 int CDECL MSVCRT__dup(int od)
1031 {
1032 int fd, ret;
1033
1034 LOCK_FILES();
1035 fd = MSVCRT_fdstart;
1036 if (MSVCRT__dup2(od, fd) == 0)
1037 ret = fd;
1038 else
1039 ret = -1;
1040 UNLOCK_FILES();
1041 return ret;
1042 }
1043
1044 /*********************************************************************
1045 * _eof (MSVCRT.@)
1046 */
1047 int CDECL MSVCRT__eof(int fd)
1048 {
1049 DWORD curpos,endpos;
1050 LONG hcurpos,hendpos;
1051 HANDLE hand = msvcrt_fdtoh(fd);
1052
1053 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1054
1055 if (hand == INVALID_HANDLE_VALUE)
1056 return -1;
1057
1058 if (msvcrt_get_ioinfo(fd)->wxflag & WX_ATEOF) return TRUE;
1059
1060 /* Otherwise we do it the hard way */
1061 hcurpos = hendpos = 0;
1062 curpos = SetFilePointer(hand, 0, &hcurpos, FILE_CURRENT);
1063 endpos = SetFilePointer(hand, 0, &hendpos, FILE_END);
1064
1065 if (curpos == endpos && hcurpos == hendpos)
1066 {
1067 /* FIXME: shouldn't WX_ATEOF be set here? */
1068 return TRUE;
1069 }
1070
1071 SetFilePointer(hand, curpos, &hcurpos, FILE_BEGIN);
1072 return FALSE;
1073 }
1074
1075 /*********************************************************************
1076 * _fcloseall (MSVCRT.@)
1077 */
1078 int CDECL MSVCRT__fcloseall(void)
1079 {
1080 int num_closed = 0, i;
1081 MSVCRT_FILE *file;
1082
1083 LOCK_FILES();
1084 for (i = 3; i < MSVCRT_stream_idx; i++) {
1085 file = msvcrt_get_file(i);
1086
1087 if (file->_flag && !MSVCRT_fclose(file))
1088 num_closed++;
1089 }
1090 UNLOCK_FILES();
1091
1092 TRACE(":closed (%d) handles\n",num_closed);
1093 return num_closed;
1094 }
1095
1096 /* free everything on process exit */
1097 void msvcrt_free_io(void)
1098 {
1099 unsigned int i;
1100 int j;
1101
1102 MSVCRT__flushall();
1103 MSVCRT__fcloseall();
1104
1105 for(i=0; i<sizeof(MSVCRT___pioinfo)/sizeof(MSVCRT___pioinfo[0]); i++)
1106 MSVCRT_free(MSVCRT___pioinfo[i]);
1107
1108 for(j=0; j<MSVCRT_stream_idx; j++)
1109 {
1110 MSVCRT_FILE *file = msvcrt_get_file(j);
1111 if(file<MSVCRT__iob || file>=MSVCRT__iob+_IOB_ENTRIES)
1112 {
1113 ((file_crit*)file)->crit.DebugInfo->Spare[0] = 0;
1114 DeleteCriticalSection(&((file_crit*)file)->crit);
1115 }
1116 }
1117
1118 for(i=0; i<sizeof(MSVCRT_fstream)/sizeof(MSVCRT_fstream[0]); i++)
1119 MSVCRT_free(MSVCRT_fstream[i]);
1120
1121 DeleteCriticalSection(&MSVCRT_file_cs);
1122 }
1123
1124 /*********************************************************************
1125 * _lseeki64 (MSVCRT.@)
1126 */
1127 __int64 CDECL MSVCRT__lseeki64(int fd, __int64 offset, int whence)
1128 {
1129 HANDLE hand = msvcrt_fdtoh(fd);
1130 LARGE_INTEGER ofs;
1131
1132 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1133 if (hand == INVALID_HANDLE_VALUE)
1134 return -1;
1135
1136 if (whence < 0 || whence > 2)
1137 {
1138 *MSVCRT__errno() = MSVCRT_EINVAL;
1139 return -1;
1140 }
1141
1142 TRACE(":fd (%d) to %s pos %s\n",
1143 fd,wine_dbgstr_longlong(offset),
1144 (whence==SEEK_SET)?"SEEK_SET":
1145 (whence==SEEK_CUR)?"SEEK_CUR":
1146 (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
1147
1148 /* The MoleBox protection scheme expects msvcrt to use SetFilePointer only,
1149 * so a LARGE_INTEGER offset cannot be passed directly via SetFilePointerEx. */
1150 ofs.QuadPart = offset;
1151 if ((ofs.u.LowPart = SetFilePointer(hand, ofs.u.LowPart, &ofs.u.HighPart, whence)) != INVALID_SET_FILE_POINTER ||
1152 GetLastError() == ERROR_SUCCESS)
1153 {
1154 msvcrt_get_ioinfo(fd)->wxflag &= ~WX_ATEOF;
1155 /* FIXME: What if we seek _to_ EOF - is EOF set? */
1156
1157 return ofs.QuadPart;
1158 }
1159 TRACE(":error-last error (%d)\n",GetLastError());
1160 msvcrt_set_errno(GetLastError());
1161 return -1;
1162 }
1163
1164 /*********************************************************************
1165 * _lseek (MSVCRT.@)
1166 */
1167 LONG CDECL MSVCRT__lseek(int fd, LONG offset, int whence)
1168 {
1169 return MSVCRT__lseeki64(fd, offset, whence);
1170 }
1171
1172 /*********************************************************************
1173 * _lock_file (MSVCRT.@)
1174 */
1175 void CDECL MSVCRT__lock_file(MSVCRT_FILE *file)
1176 {
1177 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1178 _lock(_STREAM_LOCKS+(file-MSVCRT__iob));
1179 else
1180 EnterCriticalSection(&((file_crit*)file)->crit);
1181 }
1182
1183 /*********************************************************************
1184 * _unlock_file (MSVCRT.@)
1185 */
1186 void CDECL MSVCRT__unlock_file(MSVCRT_FILE *file)
1187 {
1188 if(file>=MSVCRT__iob && file<MSVCRT__iob+_IOB_ENTRIES)
1189 _unlock(_STREAM_LOCKS+(file-MSVCRT__iob));
1190 else
1191 LeaveCriticalSection(&((file_crit*)file)->crit);
1192 }
1193
1194 /*********************************************************************
1195 * _locking (MSVCRT.@)
1196 *
1197 * This is untested; the underlying LockFile doesn't work yet.
1198 */
1199 int CDECL MSVCRT__locking(int fd, int mode, LONG nbytes)
1200 {
1201 BOOL ret;
1202 DWORD cur_locn;
1203 HANDLE hand = msvcrt_fdtoh(fd);
1204
1205 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1206 if (hand == INVALID_HANDLE_VALUE)
1207 return -1;
1208
1209 if (mode < 0 || mode > 4)
1210 {
1211 *MSVCRT__errno() = MSVCRT_EINVAL;
1212 return -1;
1213 }
1214
1215 TRACE(":fd (%d) by 0x%08x mode %s\n",
1216 fd,nbytes,(mode==MSVCRT__LK_UNLCK)?"_LK_UNLCK":
1217 (mode==MSVCRT__LK_LOCK)?"_LK_LOCK":
1218 (mode==MSVCRT__LK_NBLCK)?"_LK_NBLCK":
1219 (mode==MSVCRT__LK_RLCK)?"_LK_RLCK":
1220 (mode==MSVCRT__LK_NBRLCK)?"_LK_NBRLCK":
1221 "UNKNOWN");
1222
1223 if ((cur_locn = SetFilePointer(hand, 0L, NULL, SEEK_CUR)) == INVALID_SET_FILE_POINTER)
1224 {
1225 FIXME ("Seek failed\n");
1226 *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
1227 return -1;
1228 }
1229 if (mode == MSVCRT__LK_LOCK || mode == MSVCRT__LK_RLCK)
1230 {
1231 int nretry = 10;
1232 ret = 1; /* just to satisfy gcc */
1233 while (nretry--)
1234 {
1235 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
1236 if (ret) break;
1237 Sleep(1);
1238 }
1239 }
1240 else if (mode == MSVCRT__LK_UNLCK)
1241 ret = UnlockFile(hand, cur_locn, 0L, nbytes, 0L);
1242 else
1243 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
1244 /* FIXME - what about error settings? */
1245 return ret ? 0 : -1;
1246 }
1247
1248 /*********************************************************************
1249 * _fseeki64 (MSVCRT.@)
1250 */
1251 int CDECL MSVCRT__fseeki64(MSVCRT_FILE* file, __int64 offset, int whence)
1252 {
1253 int ret;
1254
1255 MSVCRT__lock_file(file);
1256 /* Flush output if needed */
1257 if(file->_flag & MSVCRT__IOWRT)
1258 msvcrt_flush_buffer(file);
1259
1260 if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
1261 whence = SEEK_SET;
1262 offset += MSVCRT__ftelli64(file);
1263 }
1264
1265 /* Discard buffered input */
1266 file->_cnt = 0;
1267 file->_ptr = file->_base;
1268 /* Reset direction of i/o */
1269 if(file->_flag & MSVCRT__IORW) {
1270 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
1271 }
1272 /* Clear end of file flag */
1273 file->_flag &= ~MSVCRT__IOEOF;
1274 ret = (MSVCRT__lseeki64(file->_file,offset,whence) == -1)?-1:0;
1275
1276 MSVCRT__unlock_file(file);
1277 return ret;
1278 }
1279
1280 /*********************************************************************
1281 * fseek (MSVCRT.@)
1282 */
1283 int CDECL MSVCRT_fseek(MSVCRT_FILE* file, MSVCRT_long offset, int whence)
1284 {
1285 return MSVCRT__fseeki64( file, offset, whence );
1286 }
1287
1288 /*********************************************************************
1289 * _chsize_s (MSVCRT.@)
1290 */
1291 int CDECL MSVCRT__chsize_s(int fd, __int64 size)
1292 {
1293 __int64 cur, pos;
1294 HANDLE handle;
1295 BOOL ret = FALSE;
1296
1297 TRACE("(fd=%d, size=%s)\n", fd, wine_dbgstr_longlong(size));
1298
1299 if (!MSVCRT_CHECK_PMT(size >= 0)) return MSVCRT_EINVAL;
1300
1301 LOCK_FILES();
1302
1303 handle = msvcrt_fdtoh(fd);
1304 if (handle != INVALID_HANDLE_VALUE)
1305 {
1306 /* save the current file pointer */
1307 cur = MSVCRT__lseeki64(fd, 0, SEEK_CUR);
1308 if (cur >= 0)
1309 {
1310 pos = MSVCRT__lseeki64(fd, size, SEEK_SET);
1311 if (pos >= 0)
1312 {
1313 ret = SetEndOfFile(handle);
1314 if (!ret) msvcrt_set_errno(GetLastError());
1315 }
1316
1317 /* restore the file pointer */
1318 MSVCRT__lseeki64(fd, cur, SEEK_SET);
1319 }
1320 }
1321
1322 UNLOCK_FILES();
1323 return ret ? 0 : *MSVCRT__errno();
1324 }
1325
1326 /*********************************************************************
1327 * _chsize (MSVCRT.@)
1328 */
1329 int CDECL MSVCRT__chsize(int fd, MSVCRT_long size)
1330 {
1331 /* _chsize_s returns errno on failure but _chsize should return -1 */
1332 return MSVCRT__chsize_s( fd, size ) == 0 ? 0 : -1;
1333 }
1334
1335 /*********************************************************************
1336 * clearerr (MSVCRT.@)
1337 */
1338 void CDECL MSVCRT_clearerr(MSVCRT_FILE* file)
1339 {
1340 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1341
1342 MSVCRT__lock_file(file);
1343 file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
1344 MSVCRT__unlock_file(file);
1345 }
1346
1347 /*********************************************************************
1348 * rewind (MSVCRT.@)
1349 */
1350 void CDECL MSVCRT_rewind(MSVCRT_FILE* file)
1351 {
1352 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1353
1354 MSVCRT__lock_file(file);
1355 MSVCRT_fseek(file, 0L, SEEK_SET);
1356 MSVCRT_clearerr(file);
1357 MSVCRT__unlock_file(file);
1358 }
1359
1360 static int msvcrt_get_flags(const MSVCRT_wchar_t* mode, int *open_flags, int* stream_flags)
1361 {
1362 int plus = strchrW(mode, '+') != NULL;
1363
1364 TRACE("%s\n", debugstr_w(mode));
1365
1366 while(*mode == ' ') mode++;
1367
1368 switch(*mode++)
1369 {
1370 case 'R': case 'r':
1371 *open_flags = plus ? MSVCRT__O_RDWR : MSVCRT__O_RDONLY;
1372 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOREAD;
1373 break;
1374 case 'W': case 'w':
1375 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_TRUNC | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1376 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1377 break;
1378 case 'A': case 'a':
1379 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_APPEND | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1380 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1381 break;
1382 default:
1383 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1384 return -1;
1385 }
1386
1387 *stream_flags |= MSVCRT__commode;
1388
1389 while (*mode && *mode!=',')
1390 switch (*mode++)
1391 {
1392 case 'B': case 'b':
1393 *open_flags |= MSVCRT__O_BINARY;
1394 *open_flags &= ~MSVCRT__O_TEXT;
1395 break;
1396 case 't':
1397 *open_flags |= MSVCRT__O_TEXT;
1398 *open_flags &= ~MSVCRT__O_BINARY;
1399 break;
1400 case 'D':
1401 *open_flags |= MSVCRT__O_TEMPORARY;
1402 break;
1403 case 'T':
1404 *open_flags |= MSVCRT__O_SHORT_LIVED;
1405 break;
1406 case 'c':
1407 *stream_flags |= MSVCRT__IOCOMMIT;
1408 break;
1409 case 'n':
1410 *stream_flags &= ~MSVCRT__IOCOMMIT;
1411 break;
1412 case 'N':
1413 *open_flags |= MSVCRT__O_NOINHERIT;
1414 break;
1415 case '+':
1416 case ' ':
1417 case 'a':
1418 case 'w':
1419 break;
1420 case 'S':
1421 case 'R':
1422 FIXME("ignoring cache optimization flag: %c\n", mode[-1]);
1423 break;
1424 default:
1425 ERR("incorrect mode flag: %c\n", mode[-1]);
1426 break;
1427 }
1428
1429 if(*mode == ',')
1430 {
1431 static const WCHAR ccs[] = {'c','c','s'};
1432 static const WCHAR utf8[] = {'u','t','f','-','8'};
1433 static const WCHAR utf16le[] = {'u','t','f','-','1','6','l','e'};
1434 static const WCHAR unicode[] = {'u','n','i','c','o','d','e'};
1435
1436 mode++;
1437 while(*mode == ' ') mode++;
1438 if(!MSVCRT_CHECK_PMT(!strncmpW(ccs, mode, sizeof(ccs)/sizeof(ccs[0]))))
1439 return -1;
1440 mode += sizeof(ccs)/sizeof(ccs[0]);
1441 while(*mode == ' ') mode++;
1442 if(!MSVCRT_CHECK_PMT(*mode == '='))
1443 return -1;
1444 mode++;
1445 while(*mode == ' ') mode++;
1446
1447 if(!strncmpiW(utf8, mode, sizeof(utf8)/sizeof(utf8[0])))
1448 {
1449 *open_flags |= MSVCRT__O_U8TEXT;
1450 mode += sizeof(utf8)/sizeof(utf8[0]);
1451 }
1452 else if(!strncmpiW(utf16le, mode, sizeof(utf16le)/sizeof(utf16le[0])))
1453 {
1454 *open_flags |= MSVCRT__O_U16TEXT;
1455 mode += sizeof(utf16le)/sizeof(utf16le[0]);
1456 }
1457 else if(!strncmpiW(unicode, mode, sizeof(unicode)/sizeof(unicode[0])))
1458 {
1459 *open_flags |= MSVCRT__O_WTEXT;
1460 mode += sizeof(unicode)/sizeof(unicode[0]);
1461 }
1462 else
1463 {
1464 MSVCRT_INVALID_PMT(0, MSVCRT_EINVAL);
1465 return -1;
1466 }
1467
1468 while(*mode == ' ') mode++;
1469 }
1470
1471 if(!MSVCRT_CHECK_PMT(*mode == 0))
1472 return -1;
1473 return 0;
1474 }
1475
1476 /*********************************************************************
1477 * _fdopen (MSVCRT.@)
1478 */
1479 MSVCRT_FILE* CDECL MSVCRT__fdopen(int fd, const char *mode)
1480 {
1481 MSVCRT_FILE *ret;
1482 MSVCRT_wchar_t *modeW = NULL;
1483
1484 if (mode && !(modeW = msvcrt_wstrdupa(mode))) return NULL;
1485
1486 ret = MSVCRT__wfdopen(fd, modeW);
1487
1488 MSVCRT_free(modeW);
1489 return ret;
1490 }
1491
1492 /*********************************************************************
1493 * _wfdopen (MSVCRT.@)
1494 */
1495 MSVCRT_FILE* CDECL MSVCRT__wfdopen(int fd, const MSVCRT_wchar_t *mode)
1496 {
1497 int open_flags, stream_flags;
1498 MSVCRT_FILE* file;
1499
1500 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
1501
1502 LOCK_FILES();
1503 if (!(file = msvcrt_alloc_fp()))
1504 file = NULL;
1505 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
1506 {
1507 file->_flag = 0;
1508 file = NULL;
1509 }
1510 else TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
1511 UNLOCK_FILES();
1512
1513 return file;
1514 }
1515
1516 /*********************************************************************
1517 * _filelength (MSVCRT.@)
1518 */
1519 LONG CDECL MSVCRT__filelength(int fd)
1520 {
1521 LONG curPos = MSVCRT__lseek(fd, 0, SEEK_CUR);
1522 if (curPos != -1)
1523 {
1524 LONG endPos = MSVCRT__lseek(fd, 0, SEEK_END);
1525 if (endPos != -1)
1526 {
1527 if (endPos != curPos)
1528 MSVCRT__lseek(fd, curPos, SEEK_SET);
1529 return endPos;
1530 }
1531 }
1532 return -1;
1533 }
1534
1535 /*********************************************************************
1536 * _filelengthi64 (MSVCRT.@)
1537 */
1538 __int64 CDECL MSVCRT__filelengthi64(int fd)
1539 {
1540 __int64 curPos = MSVCRT__lseeki64(fd, 0, SEEK_CUR);
1541 if (curPos != -1)
1542 {
1543 __int64 endPos = MSVCRT__lseeki64(fd, 0, SEEK_END);
1544 if (endPos != -1)
1545 {
1546 if (endPos != curPos)
1547 MSVCRT__lseeki64(fd, curPos, SEEK_SET);
1548 return endPos;
1549 }
1550 }
1551 return -1;
1552 }
1553
1554 /*********************************************************************
1555 * _fileno (MSVCRT.@)
1556 */
1557 int CDECL MSVCRT__fileno(MSVCRT_FILE* file)
1558 {
1559 TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
1560 return file->_file;
1561 }
1562
1563 /*********************************************************************
1564 * _fstat64 (MSVCRT.@)
1565 */
1566 int CDECL MSVCRT__fstat64(int fd, struct MSVCRT__stat64* buf)
1567 {
1568 DWORD dw;
1569 DWORD type;
1570 BY_HANDLE_FILE_INFORMATION hfi;
1571 HANDLE hand = msvcrt_fdtoh(fd);
1572
1573 TRACE(":fd (%d) stat (%p)\n",fd,buf);
1574 if (hand == INVALID_HANDLE_VALUE)
1575 return -1;
1576
1577 if (!buf)
1578 {
1579 WARN(":failed-NULL buf\n");
1580 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1581 return -1;
1582 }
1583
1584 memset(&hfi, 0, sizeof(hfi));
1585 memset(buf, 0, sizeof(struct MSVCRT__stat64));
1586 type = GetFileType(hand);
1587 if (type == FILE_TYPE_PIPE)
1588 {
1589 buf->st_dev = buf->st_rdev = fd;
1590 buf->st_mode = S_IFIFO;
1591 buf->st_nlink = 1;
1592 }
1593 else if (type == FILE_TYPE_CHAR)
1594 {
1595 buf->st_dev = buf->st_rdev = fd;
1596 buf->st_mode = S_IFCHR;
1597 buf->st_nlink = 1;
1598 }
1599 else /* FILE_TYPE_DISK etc. */
1600 {
1601 if (!GetFileInformationByHandle(hand, &hfi))
1602 {
1603 WARN(":failed-last error (%d)\n",GetLastError());
1604 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1605 return -1;
1606 }
1607 buf->st_mode = S_IFREG | 0444;
1608 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1609 buf->st_mode |= 0222;
1610 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1611 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1612 buf->st_atime = dw;
1613 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1614 buf->st_mtime = buf->st_ctime = dw;
1615 buf->st_nlink = hfi.nNumberOfLinks;
1616 }
1617 TRACE(":dwFileAttributes = 0x%x, mode set to 0x%x\n",hfi.dwFileAttributes,
1618 buf->st_mode);
1619 return 0;
1620 }
1621
1622 /*********************************************************************
1623 * _fstati64 (MSVCRT.@)
1624 */
1625 int CDECL MSVCRT__fstati64(int fd, struct MSVCRT__stati64* buf)
1626 {
1627 int ret;
1628 struct MSVCRT__stat64 buf64;
1629
1630 ret = MSVCRT__fstat64(fd, &buf64);
1631 if (!ret)
1632 msvcrt_stat64_to_stati64(&buf64, buf);
1633 return ret;
1634 }
1635
1636 /*********************************************************************
1637 * _fstat (MSVCRT.@)
1638 */
1639 int CDECL MSVCRT__fstat(int fd, struct MSVCRT__stat* buf)
1640 { int ret;
1641 struct MSVCRT__stat64 buf64;
1642
1643 ret = MSVCRT__fstat64(fd, &buf64);
1644 if (!ret)
1645 msvcrt_stat64_to_stat(&buf64, buf);
1646 return ret;
1647 }
1648
1649 /*********************************************************************
1650 * _fstat32 (MSVCR80.@)
1651 */
1652 int CDECL MSVCRT__fstat32(int fd, struct MSVCRT__stat32* buf)
1653 {
1654 int ret;
1655 struct MSVCRT__stat64 buf64;
1656
1657 ret = MSVCRT__fstat64(fd, &buf64);
1658 if (!ret)
1659 msvcrt_stat64_to_stat32(&buf64, buf);
1660 return ret;
1661 }
1662
1663 /*********************************************************************
1664 * _fstat64i32 (MSVCR80.@)
1665 */
1666 int CDECL MSVCRT__fstat64i32(int fd, struct MSVCRT__stat64i32* buf)
1667 {
1668 int ret;
1669 struct MSVCRT__stat64 buf64;
1670
1671 ret = MSVCRT__fstat64(fd, &buf64);
1672 if (!ret)
1673 msvcrt_stat64_to_stat64i32(&buf64, buf);
1674 return ret;
1675 }
1676
1677 /*********************************************************************
1678 * _futime64 (MSVCRT.@)
1679 */
1680 int CDECL _futime64(int fd, struct MSVCRT___utimbuf64 *t)
1681 {
1682 HANDLE hand = msvcrt_fdtoh(fd);
1683 FILETIME at, wt;
1684
1685 if (!t)
1686 {
1687 time_to_filetime( MSVCRT__time64(NULL), &at );
1688 wt = at;
1689 }
1690 else
1691 {
1692 time_to_filetime( t->actime, &at );
1693 time_to_filetime( t->modtime, &wt );
1694 }
1695
1696 if (!SetFileTime(hand, NULL, &at, &wt))
1697 {
1698 msvcrt_set_errno(GetLastError());
1699 return -1 ;
1700 }
1701 return 0;
1702 }
1703
1704 /*********************************************************************
1705 * _futime32 (MSVCRT.@)
1706 */
1707 int CDECL _futime32(int fd, struct MSVCRT___utimbuf32 *t)
1708 {
1709 if (t)
1710 {
1711 struct MSVCRT___utimbuf64 t64;
1712 t64.actime = t->actime;
1713 t64.modtime = t->modtime;
1714 return _futime64( fd, &t64 );
1715 }
1716 else
1717 return _futime64( fd, NULL );
1718 }
1719
1720 /*********************************************************************
1721 * _futime (MSVCRT.@)
1722 */
1723 #ifdef _WIN64
1724 int CDECL _futime(int fd, struct MSVCRT___utimbuf64 *t)
1725 {
1726 return _futime64( fd, t );
1727 }
1728 #else
1729 int CDECL _futime(int fd, struct MSVCRT___utimbuf32 *t)
1730 {
1731 return _futime32( fd, t );
1732 }
1733 #endif
1734
1735 /*********************************************************************
1736 * _get_osfhandle (MSVCRT.@)
1737 */
1738 MSVCRT_intptr_t CDECL MSVCRT__get_osfhandle(int fd)
1739 {
1740 HANDLE hand = msvcrt_fdtoh(fd);
1741 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1742
1743 return (MSVCRT_intptr_t)hand;
1744 }
1745
1746 /*********************************************************************
1747 * _mktemp_s (MSVCRT.@)
1748 */
1749 int CDECL MSVCRT__mktemp_s(char *pattern, MSVCRT_size_t size)
1750 {
1751 DWORD len, xno, id;
1752
1753 if(!MSVCRT_CHECK_PMT(pattern!=NULL))
1754 return MSVCRT_EINVAL;
1755
1756 for(len=0; len<size; len++)
1757 if(!pattern[len])
1758 break;
1759 if(!MSVCRT_CHECK_PMT(len!=size && len>=6)) {
1760 if(size)
1761 pattern[0] = 0;
1762 return MSVCRT_EINVAL;
1763 }
1764
1765 for(xno=1; xno<=6; xno++)
1766 if(!MSVCRT_CHECK_PMT(pattern[len-xno] == 'X'))
1767 return MSVCRT_EINVAL;
1768
1769 id = GetCurrentProcessId();
1770 for(xno=1; xno<6; xno++) {
1771 pattern[len-xno] = id%10 + '0';
1772 id /= 10;
1773 }
1774
1775 for(pattern[len-6]='a'; pattern[len-6]<='z'; pattern[len-6]++) {
1776 if(GetFileAttributesA(pattern) == INVALID_FILE_ATTRIBUTES)
1777 return 0;
1778 }
1779
1780 pattern[0] = 0;
1781 *MSVCRT__errno() = MSVCRT_EEXIST;
1782 return MSVCRT_EEXIST;
1783 }
1784
1785 /*********************************************************************
1786 * _mktemp (MSVCRT.@)
1787 */
1788 char * CDECL MSVCRT__mktemp(char *pattern)
1789 {
1790 int numX = 0;
1791 char *retVal = pattern;
1792 int id;
1793 char letter = 'a';
1794
1795 if(!pattern)
1796 return NULL;
1797
1798 while(*pattern)
1799 numX = (*pattern++ == 'X')? numX + 1 : 0;
1800 if (numX < 6)
1801 return NULL;
1802 pattern--;
1803 id = GetCurrentProcessId();
1804 numX = 6;
1805 while(numX--)
1806 {
1807 int tempNum = id / 10;
1808 *pattern-- = id - (tempNum * 10) + '0';
1809 id = tempNum;
1810 }
1811 pattern++;
1812 do
1813 {
1814 *pattern = letter++;
1815 if (GetFileAttributesA(retVal) == INVALID_FILE_ATTRIBUTES)
1816 return retVal;
1817 } while(letter <= 'z');
1818 return NULL;
1819 }
1820
1821 /*********************************************************************
1822 * _wmktemp_s (MSVCRT.@)
1823 */
1824 int CDECL MSVCRT__wmktemp_s(MSVCRT_wchar_t *pattern, MSVCRT_size_t size)
1825 {
1826 DWORD len, xno, id;
1827
1828 if(!MSVCRT_CHECK_PMT(pattern!=NULL))
1829 return MSVCRT_EINVAL;
1830
1831 for(len=0; len<size; len++)
1832 if(!pattern[len])
1833 break;
1834 if(!MSVCRT_CHECK_PMT(len!=size && len>=6)) {
1835 if(size)
1836 pattern[0] = 0;
1837 return MSVCRT_EINVAL;
1838 }
1839
1840 for(xno=1; xno<=6; xno++)
1841 if(!MSVCRT_CHECK_PMT(pattern[len-xno] == 'X'))
1842 return MSVCRT_EINVAL;
1843
1844 id = GetCurrentProcessId();
1845 for(xno=1; xno<6; xno++) {
1846 pattern[len-xno] = id%10 + '0';
1847 id /= 10;
1848 }
1849
1850 for(pattern[len-6]='a'; pattern[len-6]<='z'; pattern[len-6]++) {
1851 if(GetFileAttributesW(pattern) == INVALID_FILE_ATTRIBUTES)
1852 return 0;
1853 }
1854
1855 pattern[0] = 0;
1856 *MSVCRT__errno() = MSVCRT_EEXIST;
1857 return MSVCRT_EEXIST;
1858 }
1859
1860 /*********************************************************************
1861 * _wmktemp (MSVCRT.@)
1862 */
1863 MSVCRT_wchar_t * CDECL MSVCRT__wmktemp(MSVCRT_wchar_t *pattern)
1864 {
1865 int numX = 0;
1866 MSVCRT_wchar_t *retVal = pattern;
1867 int id;
1868 MSVCRT_wchar_t letter = 'a';
1869
1870 if(!pattern)
1871 return NULL;
1872
1873 while(*pattern)
1874 numX = (*pattern++ == 'X')? numX + 1 : 0;
1875 if (numX < 6)
1876 return NULL;
1877 pattern--;
1878 id = GetCurrentProcessId();
1879 numX = 6;
1880 while(numX--)
1881 {
1882 int tempNum = id / 10;
1883 *pattern-- = id - (tempNum * 10) + '0';
1884 id = tempNum;
1885 }
1886 pattern++;
1887 do
1888 {
1889 if (GetFileAttributesW(retVal) == INVALID_FILE_ATTRIBUTES)
1890 return retVal;
1891 *pattern = letter++;
1892 } while(letter != '|');
1893 return NULL;
1894 }
1895
1896 static unsigned split_oflags(unsigned oflags)
1897 {
1898 int wxflags = 0;
1899 unsigned unsupp; /* until we support everything */
1900
1901 if (oflags & MSVCRT__O_APPEND) wxflags |= WX_APPEND;
1902 if (oflags & MSVCRT__O_BINARY) {/* Nothing to do */}
1903 else if (oflags & MSVCRT__O_TEXT) wxflags |= WX_TEXT;
1904 else if (oflags & MSVCRT__O_WTEXT) wxflags |= WX_TEXT;
1905 else if (oflags & MSVCRT__O_U16TEXT) wxflags |= WX_TEXT;
1906 else if (oflags & MSVCRT__O_U8TEXT) wxflags |= WX_TEXT;
1907 else if (*__p__fmode() & MSVCRT__O_BINARY) {/* Nothing to do */}
1908 else wxflags |= WX_TEXT; /* default to TEXT*/
1909 if (oflags & MSVCRT__O_NOINHERIT) wxflags |= WX_DONTINHERIT;
1910
1911 if ((unsupp = oflags & ~(
1912 MSVCRT__O_BINARY|MSVCRT__O_TEXT|MSVCRT__O_APPEND|
1913 MSVCRT__O_TRUNC|MSVCRT__O_EXCL|MSVCRT__O_CREAT|
1914 MSVCRT__O_RDWR|MSVCRT__O_WRONLY|MSVCRT__O_TEMPORARY|
1915 MSVCRT__O_NOINHERIT|
1916 MSVCRT__O_SEQUENTIAL|MSVCRT__O_RANDOM|MSVCRT__O_SHORT_LIVED|
1917 MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT
1918 )))
1919 ERR(":unsupported oflags 0x%04x\n",unsupp);
1920
1921 return wxflags;
1922 }
1923
1924 /*********************************************************************
1925 * _pipe (MSVCRT.@)
1926 */
1927 int CDECL MSVCRT__pipe(int *pfds, unsigned int psize, int textmode)
1928 {
1929 int ret = -1;
1930 SECURITY_ATTRIBUTES sa;
1931 HANDLE readHandle, writeHandle;
1932
1933 if (!pfds)
1934 {
1935 *MSVCRT__errno() = MSVCRT_EINVAL;
1936 return -1;
1937 }
1938
1939 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
1940 sa.bInheritHandle = !(textmode & MSVCRT__O_NOINHERIT);
1941 sa.lpSecurityDescriptor = NULL;
1942 if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
1943 {
1944 unsigned int wxflags = split_oflags(textmode);
1945 int fd;
1946
1947 LOCK_FILES();
1948 fd = msvcrt_alloc_fd(readHandle, wxflags|WX_PIPE);
1949 if (fd != -1)
1950 {
1951 pfds[0] = fd;
1952 fd = msvcrt_alloc_fd(writeHandle, wxflags|WX_PIPE);
1953 if (fd != -1)
1954 {
1955 pfds[1] = fd;
1956 ret = 0;
1957 }
1958 else
1959 {
1960 MSVCRT__close(pfds[0]);
1961 CloseHandle(writeHandle);
1962 *MSVCRT__errno() = MSVCRT_EMFILE;
1963 }
1964 }
1965 else
1966 {
1967 CloseHandle(readHandle);
1968 CloseHandle(writeHandle);
1969 *MSVCRT__errno() = MSVCRT_EMFILE;
1970 }
1971 UNLOCK_FILES();
1972 }
1973 else
1974 msvcrt_set_errno(GetLastError());
1975
1976 return ret;
1977 }
1978
1979 static int check_bom(HANDLE h, int oflags, BOOL seek)
1980 {
1981 char bom[sizeof(utf8_bom)];
1982 DWORD r;
1983
1984 oflags &= ~(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT);
1985
1986 if (!ReadFile(h, bom, sizeof(utf8_bom), &r, NULL))
1987 return oflags;
1988
1989 if (r==sizeof(utf8_bom) && !memcmp(bom, utf8_bom, sizeof(utf8_bom))) {
1990 oflags |= MSVCRT__O_U8TEXT;
1991 }else if (r>=sizeof(utf16_bom) && !memcmp(bom, utf16_bom, sizeof(utf16_bom))) {
1992 if (seek && r>2)
1993 SetFilePointer(h, 2, NULL, FILE_BEGIN);
1994 oflags |= MSVCRT__O_U16TEXT;
1995 }else if (seek) {
1996 SetFilePointer(h, 0, NULL, FILE_BEGIN);
1997 }
1998
1999 return oflags;
2000 }
2001
2002 /*********************************************************************
2003 * _wsopen_s (MSVCRT.@)
2004 */
2005 int CDECL MSVCRT__wsopen_s( int *fd, const MSVCRT_wchar_t* path, int oflags, int shflags, int pmode )
2006 {
2007 DWORD access = 0, creation = 0, attrib;
2008 SECURITY_ATTRIBUTES sa;
2009 DWORD sharing;
2010 int wxflag;
2011 HANDLE hand;
2012
2013 TRACE("fd*: %p :file (%s) oflags: 0x%04x shflags: 0x%04x pmode: 0x%04x\n",
2014 fd, debugstr_w(path), oflags, shflags, pmode);
2015
2016 if (!MSVCRT_CHECK_PMT( fd != NULL )) return MSVCRT_EINVAL;
2017
2018 *fd = -1;
2019 wxflag = split_oflags(oflags);
2020 switch (oflags & (MSVCRT__O_RDONLY | MSVCRT__O_WRONLY | MSVCRT__O_RDWR))
2021 {
2022 case MSVCRT__O_RDONLY: access |= GENERIC_READ; break;
2023 case MSVCRT__O_WRONLY: access |= GENERIC_WRITE; break;
2024 case MSVCRT__O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
2025 }
2026
2027 if (oflags & MSVCRT__O_CREAT)
2028 {
2029 if(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))
2030 FIXME(": pmode 0x%04x ignored\n", pmode);
2031 else
2032 WARN(": pmode 0x%04x ignored\n", pmode);
2033
2034 if (oflags & MSVCRT__O_EXCL)
2035 creation = CREATE_NEW;
2036 else if (oflags & MSVCRT__O_TRUNC)
2037 creation = CREATE_ALWAYS;
2038 else
2039 creation = OPEN_ALWAYS;
2040 }
2041 else /* no MSVCRT__O_CREAT */
2042 {
2043 if (oflags & MSVCRT__O_TRUNC)
2044 creation = TRUNCATE_EXISTING;
2045 else
2046 creation = OPEN_EXISTING;
2047 }
2048
2049 switch( shflags )
2050 {
2051 case MSVCRT__SH_DENYRW:
2052 sharing = 0L;
2053 break;
2054 case MSVCRT__SH_DENYWR:
2055 sharing = FILE_SHARE_READ;
2056 break;
2057 case MSVCRT__SH_DENYRD:
2058 sharing = FILE_SHARE_WRITE;
2059 break;
2060 case MSVCRT__SH_DENYNO:
2061 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
2062 break;
2063 default:
2064 ERR( "Unhandled shflags 0x%x\n", shflags );
2065 return MSVCRT_EINVAL;
2066 }
2067 attrib = FILE_ATTRIBUTE_NORMAL;
2068
2069 if (oflags & MSVCRT__O_TEMPORARY)
2070 {
2071 attrib |= FILE_FLAG_DELETE_ON_CLOSE;
2072 access |= DELETE;
2073 sharing |= FILE_SHARE_DELETE;
2074 }
2075
2076 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
2077 sa.lpSecurityDescriptor = NULL;
2078 sa.bInheritHandle = !(oflags & MSVCRT__O_NOINHERIT);
2079
2080 if ((oflags&(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT))
2081 && (creation==OPEN_ALWAYS || creation==OPEN_EXISTING)
2082 && !(access&GENERIC_READ))
2083 {
2084 hand = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE,
2085 &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
2086 if (hand != INVALID_HANDLE_VALUE)
2087 {
2088 oflags = check_bom(hand, oflags, FALSE);
2089 CloseHandle(hand);
2090 }
2091 else
2092 oflags &= ~(MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT);
2093 }
2094
2095 hand = CreateFileW(path, access, sharing, &sa, creation, attrib, 0);
2096 if (hand == INVALID_HANDLE_VALUE) {
2097 WARN(":failed-last error (%d)\n",GetLastError());
2098 msvcrt_set_errno(GetLastError());
2099 return *MSVCRT__errno();
2100 }
2101
2102 if (oflags & (MSVCRT__O_WTEXT|MSVCRT__O_U16TEXT|MSVCRT__O_U8TEXT))
2103 {
2104 if ((access & GENERIC_WRITE) && (creation==CREATE_NEW
2105 || creation==CREATE_ALWAYS || creation==TRUNCATE_EXISTING
2106 || (creation==OPEN_ALWAYS && GetLastError()==ERROR_ALREADY_EXISTS)))
2107 {
2108 if (oflags & MSVCRT__O_U8TEXT)
2109 {
2110 DWORD written = 0, tmp;
2111
2112 while(written!=sizeof(utf8_bom) && WriteFile(hand, (char*)utf8_bom+written,
2113 sizeof(utf8_bom)-written, &tmp, NULL))
2114 written += tmp;
2115 if (written != sizeof(utf8_bom)) {
2116 WARN("error writing BOM\n");
2117 CloseHandle(hand);
2118 msvcrt_set_errno(GetLastError());
2119 return *MSVCRT__errno();
2120 }
2121 }
2122 else
2123 {
2124 DWORD written = 0, tmp;
2125
2126 while(written!=sizeof(utf16_bom) && WriteFile(hand, (char*)utf16_bom+written,
2127 sizeof(utf16_bom)-written, &tmp, NULL))
2128 written += tmp;
2129 if (written != sizeof(utf16_bom))
2130 {
2131 WARN("error writing BOM\n");
2132 CloseHandle(hand);
2133 msvcrt_set_errno(GetLastError());
2134 return *MSVCRT__errno();
2135 }
2136 }
2137 }
2138 else if (access & GENERIC_READ)
2139 oflags = check_bom(hand, oflags, TRUE);
2140 }
2141
2142 *fd = msvcrt_alloc_fd(hand, wxflag);
2143 if (*fd == -1)
2144 return *MSVCRT__errno();
2145
2146 if (oflags & MSVCRT__O_WTEXT)
2147 msvcrt_get_ioinfo(*fd)->exflag |= EF_UTF16|EF_UNK_UNICODE;
2148 else if (oflags & MSVCRT__O_U16TEXT)
2149 msvcrt_get_ioinfo(*fd)->exflag |= EF_UTF16;
2150 else if (oflags & MSVCRT__O_U8TEXT)
2151 msvcrt_get_ioinfo(*fd)->exflag |= EF_UTF8;
2152
2153 TRACE(":fd (%d) handle (%p)\n", *fd, hand);
2154 return 0;
2155 }
2156
2157 /*********************************************************************
2158 * _wsopen (MSVCRT.@)
2159 */
2160 int CDECL MSVCRT__wsopen( const MSVCRT_wchar_t *path, int oflags, int shflags, ... )
2161 {
2162 int pmode;
2163 int fd;
2164
2165 if (oflags & MSVCRT__O_CREAT)
2166 {
2167 __ms_va_list ap;
2168
2169 __ms_va_start(ap, shflags);
2170 pmode = va_arg(ap, int);
2171 __ms_va_end(ap);
2172 }
2173 else
2174 pmode = 0;
2175
2176 MSVCRT__wsopen_s(&fd, path, oflags, shflags, pmode);
2177 return fd;
2178 }
2179
2180 /*********************************************************************
2181 * _sopen_s (MSVCRT.@)
2182 */
2183 int CDECL MSVCRT__sopen_s( int *fd, const char *path, int oflags, int shflags, int pmode )
2184 {
2185 MSVCRT_wchar_t *pathW;
2186 int ret;
2187
2188 if (!MSVCRT_CHECK_PMT(fd != NULL))
2189 return MSVCRT_EINVAL;
2190 *fd = -1;
2191 if(!MSVCRT_CHECK_PMT(path && (pathW = msvcrt_wstrdupa(path))))
2192 return MSVCRT_EINVAL;
2193
2194 ret = MSVCRT__wsopen_s(fd, pathW, oflags, shflags, pmode);
2195 MSVCRT_free(pathW);
2196 return ret;
2197 }
2198
2199 /*********************************************************************
2200 * _sopen (MSVCRT.@)
2201 */
2202 int CDECL MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
2203 {
2204 int pmode;
2205 int fd;
2206
2207 if (oflags & MSVCRT__O_CREAT)
2208 {
2209 __ms_va_list ap;
2210
2211 __ms_va_start(ap, shflags);
2212 pmode = va_arg(ap, int);
2213 __ms_va_end(ap);
2214 }
2215 else
2216 pmode = 0;
2217
2218 MSVCRT__sopen_s(&fd, path, oflags, shflags, pmode);
2219 return fd;
2220 }
2221
2222 /*********************************************************************
2223 * _open (MSVCRT.@)
2224 */
2225 int CDECL MSVCRT__open( const char *path, int flags, ... )
2226 {
2227 __ms_va_list ap;
2228
2229 if (flags & MSVCRT__O_CREAT)
2230 {
2231 int pmode;
2232 __ms_va_start(ap, flags);
2233 pmode = va_arg(ap, int);
2234 __ms_va_end(ap);
2235 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO, pmode );
2236 }
2237 else
2238 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO);
2239 }
2240
2241 /*********************************************************************
2242 * _wopen (MSVCRT.@)
2243 */
2244 int CDECL MSVCRT__wopen(const MSVCRT_wchar_t *path,int flags,...)
2245 {
2246 __ms_va_list ap;
2247
2248 if (flags & MSVCRT__O_CREAT)
2249 {
2250 int pmode;
2251 __ms_va_start(ap, flags);
2252 pmode = va_arg(ap, int);
2253 __ms_va_end(ap);
2254 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO, pmode );
2255 }
2256 else
2257 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO);
2258 }
2259
2260 /*********************************************************************
2261 * _creat (MSVCRT.@)
2262 */
2263 int CDECL MSVCRT__creat(const char *path, int flags)
2264 {
2265 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
2266 return MSVCRT__open(path, usedFlags);
2267 }
2268
2269 /*********************************************************************
2270 * _wcreat (MSVCRT.@)
2271 */
2272 int CDECL MSVCRT__wcreat(const MSVCRT_wchar_t *path, int flags)
2273 {
2274 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
2275 return MSVCRT__wopen(path, usedFlags);
2276 }
2277
2278 /*********************************************************************
2279 * _open_osfhandle (MSVCRT.@)
2280 */
2281 int CDECL MSVCRT__open_osfhandle(MSVCRT_intptr_t handle, int oflags)
2282 {
2283 DWORD flags;
2284 int fd;
2285
2286 /* MSVCRT__O_RDONLY (0) always matches, so set the read flag
2287 * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
2288 * file, so set the write flag. It also only sets MSVCRT__O_TEXT if it wants
2289 * text - it never sets MSVCRT__O_BINARY.
2290 */
2291 /* don't let split_oflags() decide the mode if no mode is passed */
2292 if (!(oflags & (MSVCRT__O_BINARY | MSVCRT__O_TEXT)))
2293 oflags |= MSVCRT__O_BINARY;
2294
2295 flags = GetFileType((HANDLE)handle);
2296 if (flags==FILE_TYPE_UNKNOWN && GetLastError()!=NO_ERROR)
2297 {
2298 msvcrt_set_errno(GetLastError());
2299 return -1;
2300 }
2301
2302 if (flags == FILE_TYPE_CHAR)
2303 flags = WX_NOSEEK;
2304 else if (flags == FILE_TYPE_PIPE)
2305 flags = WX_PIPE;
2306 else
2307 flags = 0;
2308 flags |= split_oflags(oflags);
2309
2310 fd = msvcrt_alloc_fd((HANDLE)handle, flags);
2311 TRACE(":handle (%ld) fd (%d) flags 0x%08x\n", handle, fd, flags);
2312 return fd;
2313 }
2314
2315 /*********************************************************************
2316 * _rmtmp (MSVCRT.@)
2317 */
2318 int CDECL MSVCRT__rmtmp(void)
2319 {
2320 int num_removed = 0, i;
2321 MSVCRT_FILE *file;
2322
2323 LOCK_FILES();
2324 for (i = 3; i < MSVCRT_stream_idx; i++) {
2325 file = msvcrt_get_file(i);
2326
2327 if (file->_tmpfname)
2328 {
2329 MSVCRT_fclose(file);
2330 num_removed++;
2331 }
2332 }
2333 UNLOCK_FILES();
2334
2335 if (num_removed)
2336 TRACE(":removed (%d) temp files\n",num_removed);
2337 return num_removed;
2338 }
2339
2340 static inline int get_utf8_char_len(char ch)
2341 {
2342 if((ch&0xf8) == 0xf0)
2343 return 4;
2344 else if((ch&0xf0) == 0xe0)
2345 return 3;
2346 else if((ch&0xe0) == 0xc0)
2347 return 2;
2348 return 1;
2349 }
2350
2351 /*********************************************************************
2352 * (internal) read_utf8
2353 */
2354 static int read_utf8(int fd, MSVCRT_wchar_t *buf, unsigned int count)
2355 {
2356 ioinfo *fdinfo = msvcrt_get_ioinfo(fd);
2357 HANDLE hand = fdinfo->handle;
2358 char min_buf[4], *readbuf, lookahead;
2359 DWORD readbuf_size, pos=0, num_read=1, char_len, i, j;
2360
2361 /* make the buffer big enough to hold at least one character */
2362 /* read bytes have to fit to output and lookahead buffers */
2363 count /= 2;
2364 readbuf_size = count < 4 ? 4 : count;
2365 if(readbuf_size<=4 || !(readbuf = MSVCRT_malloc(readbuf_size))) {
2366 readbuf_size = 4;
2367 readbuf = min_buf;
2368 }
2369
2370 if(fdinfo->lookahead[0] != '\n') {
2371 readbuf[pos++] = fdinfo->lookahead[0];
2372 fdinfo->lookahead[0] = '\n';
2373
2374 if(fdinfo->lookahead[1] != '\n') {
2375 readbuf[pos++] = fdinfo->lookahead[1];
2376 fdinfo->lookahead[1] = '\n';
2377
2378 if(fdinfo->lookahead[2] != '\n') {
2379 readbuf[pos++] = fdinfo->lookahead[2];
2380 fdinfo->lookahead[2] = '\n';
2381 }
2382 }
2383 }
2384
2385 /* NOTE: this case is broken in native dll, reading
2386 * sometimes fails when small buffer is passed
2387 */
2388 if(count < 4) {
2389 if(!pos && !ReadFile(hand, readbuf, 1, &num_read, NULL)) {
2390 if (GetLastError() == ERROR_BROKEN_PIPE) {
2391 fdinfo->wxflag |= WX_ATEOF;
2392 return 0;
2393 }else {
2394 msvcrt_set_errno(GetLastError());
2395 return -1;
2396 }
2397 }else if(!num_read) {
2398 fdinfo->wxflag |= WX_ATEOF;
2399 return 0;
2400 }else {
2401 pos++;
2402 }
2403
2404 char_len = get_utf8_char_len(readbuf[0]);
2405 if(char_len>pos) {
2406 if(ReadFile(hand, readbuf+pos, char_len-pos, &num_read, NULL))
2407 pos += num_read;
2408 }
2409
2410 if(readbuf[0] == '\n')
2411 fdinfo->wxflag |= WX_READNL;
2412 else
2413 fdinfo->wxflag &= ~WX_READNL;
2414
2415 if(readbuf[0] == 0x1a) {
2416 fdinfo->wxflag |= WX_ATEOF;
2417 return 0;
2418 }
2419
2420 if(readbuf[0] == '\r') {
2421 if(!ReadFile(hand, &lookahead, 1, &num_read, NULL) || num_read!=1)
2422 buf[0] = '\r';
2423 else if(lookahead == '\n')
2424 buf[0] = '\n';
2425 else {
2426 buf[0] = '\r';
2427 if(fdinfo->wxflag & (WX_PIPE | WX_NOSEEK))
2428 fdinfo->lookahead[0] = lookahead;
2429 else
2430 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2431 }
2432 return 2;
2433 }
2434
2435 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2436 msvcrt_set_errno(GetLastError());
2437 return -1;
2438 }
2439
2440 return num_read*2;
2441 }
2442
2443 if(!ReadFile(hand, readbuf+pos, readbuf_size-pos, &num_read, NULL)) {
2444 if(pos) {
2445 num_read = 0;
2446 }else if(GetLastError() == ERROR_BROKEN_PIPE) {
2447 fdinfo->wxflag |= WX_ATEOF;
2448 if (readbuf != min_buf) MSVCRT_free(readbuf);
2449 return 0;
2450 }else {
2451 msvcrt_set_errno(GetLastError());
2452 if (readbuf != min_buf) MSVCRT_free(readbuf);
2453 return -1;
2454 }
2455 }else if(!pos && !num_read) {
2456 fdinfo->wxflag |= WX_ATEOF;
2457 if (readbuf != min_buf) MSVCRT_free(readbuf);
2458 return 0;
2459 }
2460
2461 pos += num_read;
2462 if(readbuf[0] == '\n')
2463 fdinfo->wxflag |= WX_READNL;
2464 else
2465 fdinfo->wxflag &= ~WX_READNL;
2466
2467 /* Find first byte of last character (may be incomplete) */
2468 for(i=pos-1; i>0 && i>pos-4; i--)
2469 if((readbuf[i]&0xc0) != 0x80)
2470 break;
2471 char_len = get_utf8_char_len(readbuf[i]);
2472 if(char_len+i <= pos)
2473 i += char_len;
2474
2475 if(fdinfo->wxflag & (WX_PIPE | WX_NOSEEK)) {
2476 if(i < pos)
2477 fdinfo->lookahead[0] = readbuf[i];
2478 if(i+1 < pos)
2479 fdinfo->lookahead[1] = readbuf[i+1];
2480 if(i+2 < pos)
2481 fdinfo->lookahead[2] = readbuf[i+2];
2482 }else if(i < pos) {
2483 SetFilePointer(fdinfo->handle, i-pos, NULL, FILE_CURRENT);
2484 }
2485 pos = i;
2486
2487 for(i=0, j=0; i<pos; i++) {
2488 if(readbuf[i] == 0x1a) {
2489 fdinfo->wxflag |= WX_ATEOF;
2490 break;
2491 }
2492
2493 /* strip '\r' if followed by '\n' */
2494 if(readbuf[i] == '\r' && i+1==pos) {
2495 if(fdinfo->lookahead[0] != '\n' || !ReadFile(hand, &lookahead, 1, &num_read, NULL) || !num_read) {
2496 readbuf[j++] = '\r';
2497 }else if(lookahead == '\n' && j==0) {
2498 readbuf[j++] = '\n';
2499 }else {
2500 if(lookahead != '\n')
2501 readbuf[j++] = '\r';
2502
2503 if(fdinfo->wxflag & (WX_PIPE | WX_NOSEEK))
2504 fdinfo->lookahead[0] = lookahead;
2505 else
2506 SetFilePointer(fdinfo->handle, -1, NULL, FILE_CURRENT);
2507 }
2508 }else if(readbuf[i]!='\r' || readbuf[i+1]!='\n') {
2509 readbuf[j++] = readbuf[i];
2510 }
2511 }
2512 pos = j;
2513
2514 if(!(num_read = MultiByteToWideChar(CP_UTF8, 0, readbuf, pos, buf, count))) {
2515 msvcrt_set_errno(GetLastError());
2516 if (readbuf != min_buf) MSVCRT_free(readbuf);
2517 return -1;
2518 }
2519
2520 if (readbuf != min_buf) MSVCRT_free(readbuf);
2521 return num_read*2;
2522 }
2523
2524 /*********************************************************************
2525 * (internal) read_i
2526 *
2527 * When reading \r as last character in text mode, read() positions
2528 * the file pointer on the \r character while getc() goes on to
2529 * the following \n
2530 */
2531 static int read_i(int fd, void *buf, unsigned int count)
2532 {
2533 DWORD num_read, utf16;
2534 char *bufstart = buf;
2535 HANDLE hand = msvcrt_fdtoh(fd);
2536 ioinfo *fdinfo = msvcrt_get_ioinfo(fd);
2537
2538 if (count == 0)
2539 return 0;
2540
2541 if (fdinfo->wxflag & WX_ATEOF) {
2542 TRACE("already at EOF, returning 0\n");
2543 return 0;
2544 }
2545 /* Don't trace small reads, it gets *very* annoying */
2546 if (count > 4)
2547 TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n",fd,hand,buf,count);
2548 if (hand == INVALID_HANDLE_VALUE)
2549 {
2550 *MSVCRT__errno() = MSVCRT_EBADF;
2551 return -1;
2552 }
2553
2554 utf16 = (fdinfo->exflag & EF_UTF16) != 0;
2555 if (((fdinfo->exflag&EF_UTF8) || utf16) && count&1)
2556 {
2557 *MSVCRT__errno() = MSVCRT_EINVAL;
2558 return -1;
2559 }
2560
2561 if((fdinfo->wxflag&WX_TEXT) && (fdinfo->exflag&EF_UTF8))
2562 return read_utf8(fd, buf, count);
2563
2564 if (fdinfo->lookahead[0]!='\n' || ReadFile(hand, bufstart, count, &num_read, NULL))
2565 {
2566 if (fdinfo->lookahead[0] != '\n')
2567 {
2568 bufstart[0] = fdinfo->lookahead[0];
2569 fdinfo->lookahead[0] = '\n';
2570
2571 if (utf16)
2572 {
2573 bufstart[1] = fdinfo->lookahead[1];
2574 fdinfo->lookahead[1] = '\n';
2575 }
2576
2577 if(count>1+utf16 && ReadFile(hand, bufstart+1+utf16, count-1-utf16, &num_read, NULL))
2578 num_read += 1+utf16;
2579 else
2580 num_read = 1+utf16;
2581 }
2582
2583 if(utf16 && (num_read&1))
2584 {
2585 /* msvcr90 uses uninitialized value from the buffer in this case */
2586 /* msvcrt ignores additional data */
2587 ERR("got odd number of bytes in UTF16 mode\n");
2588 num_read--;
2589 }
2590
2591 if (count != 0 && num_read == 0)
2592 {
2593 fdinfo->wxflag |= WX_ATEOF;
2594 TRACE(":EOF %s\n",debugstr_an(buf,num_read));
2595 }
2596 else if (fdinfo->wxflag & WX_TEXT)
2597 {
2598 DWORD i, j;
2599
2600 if (bufstart[0]=='\n' && (!utf16 || bufstart[1]==0))
2601 fdinfo->wxflag |= WX_READNL;
2602 else
2603 fdinfo->wxflag &= ~WX_READNL;
2604
2605 for (i=0, j=0; i<num_read; i+=1+utf16)
2606 {
2607 /* in text mode, a ctrl-z signals EOF */
2608 if (bufstart[i]==0x1a && (!utf16 || bufstart[i+1]==0))
2609 {
2610 fdinfo->wxflag |= WX_ATEOF;
2611 TRACE(":^Z EOF %s\n",debugstr_an(buf,num_read));
2612 break;
2613 }
2614
2615 /* in text mode, strip \r if followed by \n */
2616 if (bufstart[i]=='\r' && (!utf16 || bufstart[i+1]==0) && i+1+utf16==num_read)
2617 {
2618 char lookahead[2];
2619 DWORD len;
2620
2621 lookahead[1] = '\n';
2622 if (ReadFile(hand, lookahead, 1+utf16, &len, NULL) && len)
2623 {
2624 if(lookahead[0]=='\n' && (!utf16 || lookahead[1]==0) && j==0)
2625 {
2626 bufstart[j++] = '\n';
2627 if(utf16) bufstart[j++] = 0;
2628 }
2629 else
2630 {
2631 if(lookahead[0]!='\n' || (utf16 && lookahead[1]!=0))
2632 {
2633 bufstart[j++] = '\r';
2634 if(utf16) bufstart[j++] = 0;
2635 }
2636
2637 if (fdinfo->wxflag & (WX_PIPE | WX_NOSEEK))
2638 {
2639 if (lookahead[0]=='\n' && (!utf16 || !lookahead[1]))
2640 {
2641 bufstart[j++] = '\n';
2642 if (utf16) bufstart[j++] = 0;
2643 }
2644 else
2645 {
2646 fdinfo->lookahead[0] = lookahead[0];
2647 fdinfo->lookahead[1] = lookahead[1];
2648 }
2649 }
2650 else
2651 SetFilePointer(fdinfo->handle, -1-utf16, NULL, FILE_CURRENT);
2652 }
2653 }
2654 else
2655 {
2656 bufstart[j++] = '\r';
2657 if(utf16) bufstart[j++] = 0;
2658 }
2659 }
2660 else if((bufstart[i]!='\r' || (utf16 && bufstart[i+1]!=0))
2661 || (bufstart[i+1+utf16]!='\n' || (utf16 && bufstart[i+3]!=0)))
2662 {
2663 bufstart[j++] = bufstart[i];
2664 if(utf16) bufstart[j++] = bufstart[i+1];
2665 }
2666 }
2667 num_read = j;
2668 }
2669 }
2670 else
2671 {
2672 if (GetLastError() == ERROR_BROKEN_PIPE)
2673 {
2674 TRACE(":end-of-pipe\n");
2675 fdinfo->wxflag |= WX_ATEOF;
2676 return 0;
2677 }
2678 else
2679 {
2680 TRACE(":failed-last error (%d)\n",GetLastError());
2681 return -1;
2682 }
2683 }
2684
2685 if (count > 4)
2686 TRACE("(%u), %s\n",num_read,debugstr_an(buf, num_read));
2687 return num_read;
2688 }
2689
2690 /*********************************************************************
2691 * _read (MSVCRT.@)
2692 */
2693 int CDECL MSVCRT__read(int fd, void *buf, unsigned int count)
2694 {
2695 int num_read;
2696 num_read = read_i(fd, buf, count);
2697 return num_read;
2698 }
2699
2700 /*********************************************************************
2701 * _setmode (MSVCRT.@)
2702 */
2703 int CDECL MSVCRT__setmode(int fd,int mode)
2704 {
2705 int ret = msvcrt_get_ioinfo(fd)->wxflag & WX_TEXT ? MSVCRT__O_TEXT : MSVCRT__O_BINARY;
2706 if(ret==MSVCRT__O_TEXT && (msvcrt_get_ioinfo(fd)->exflag & (EF_UTF8|EF_UTF16)))
2707 ret = MSVCRT__O_WTEXT;
2708
2709 if(mode!=MSVCRT__O_TEXT && mode!=MSVCRT__O_BINARY && mode!=MSVCRT__O_WTEXT
2710 && mode!=MSVCRT__O_U16TEXT && mode!=MSVCRT__O_U8TEXT) {
2711 *MSVCRT__errno() = MSVCRT_EINVAL;
2712 return -1;
2713 }
2714
2715 if(mode == MSVCRT__O_BINARY) {
2716 msvcrt_get_ioinfo(fd)->wxflag &= ~WX_TEXT;
2717 msvcrt_get_ioinfo(fd)->exflag &= ~(EF_UTF8|EF_UTF16);
2718 return ret;
2719 }
2720
2721 msvcrt_get_ioinfo(fd)->wxflag |= WX_TEXT;
2722 if(mode == MSVCRT__O_TEXT)
2723 msvcrt_get_ioinfo(fd)->exflag &= ~(EF_UTF8|EF_UTF16);
2724 else if(mode == MSVCRT__O_U8TEXT)
2725 msvcrt_get_ioinfo(fd)->exflag = (msvcrt_get_ioinfo(fd)->exflag & ~EF_UTF16) | EF_UTF8;
2726 else
2727 msvcrt_get_ioinfo(fd)->exflag = (msvcrt_get_ioinfo(fd)->exflag & ~EF_UTF8) | EF_UTF16;
2728
2729 return ret;
2730 }
2731
2732 /*********************************************************************
2733 * _stat64 (MSVCRT.@)
2734 */
2735 int CDECL MSVCRT_stat64(const char* path, struct MSVCRT__stat64 * buf)
2736 {
2737 DWORD dw;
2738 WIN32_FILE_ATTRIBUTE_DATA hfi;
2739 unsigned short mode = ALL_S_IREAD;
2740 int plen;
2741
2742 TRACE(":file (%s) buf(%p)\n",path,buf);
2743
2744 plen = strlen(path);
2745 while (plen && path[plen-1]==' ')
2746 plen--;
2747
2748 if (plen && (plen<2 || path[plen-2]!=':') &&
2749 (path[plen-1]==':' || path[plen-1]=='\\' || path[plen-1]=='/'))
2750 {
2751 *MSVCRT__errno() = MSVCRT_ENOENT;
2752 return -1;
2753 }
2754
2755 if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
2756 {
2757 TRACE("failed (%d)\n",GetLastError());
2758 *MSVCRT__errno() = MSVCRT_ENOENT;
2759 return -1;
2760 }
2761
2762 memset(buf,0,sizeof(struct MSVCRT__stat64));
2763
2764 /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
2765 Bon 011120: This FIXME seems incorrect
2766 Also a letter as first char isn't enough to be classified
2767 as a drive letter
2768 */
2769 if (isalpha(*path)&& (*(path+1)==':'))
2770 buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
2771 else
2772 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
2773
2774 /* Dir, or regular file? */
2775 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2776 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
2777 else
2778 {
2779 mode |= MSVCRT__S_IFREG;
2780 /* executable? */
2781 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
2782 {
2783 unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
2784 (tolower(path[plen-3]) << 16);
2785 if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
2786 mode |= ALL_S_IEXEC;
2787 }
2788 }
2789
2790 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
2791 mode |= ALL_S_IWRITE;
2792
2793 buf->st_mode = mode;
2794 buf->st_nlink = 1;
2795 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
2796 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
2797 buf->st_atime = dw;
2798 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
2799 buf->st_mtime = buf->st_ctime = dw;
2800 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
2801 (int)(buf->st_size >> 32),(int)buf->st_size,
2802 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
2803 return 0;
2804 }
2805
2806 /*********************************************************************
2807 * _stati64 (MSVCRT.@)
2808 */
2809 int CDECL MSVCRT_stati64(const char* path, struct MSVCRT__stati64 * buf)
2810 {
2811 int ret;
2812 struct MSVCRT__stat64 buf64;
2813
2814 ret = MSVCRT_stat64(path, &buf64);
2815 if (!ret)
2816 msvcrt_stat64_to_stati64(&buf64, buf);
2817 return ret;
2818 }
2819
2820 /*********************************************************************
2821 * _stat (MSVCRT.@)
2822 */
2823 int CDECL MSVCRT_stat(const char* path, struct MSVCRT__stat * buf)
2824 {
2825 int ret;
2826 struct MSVCRT__stat64 buf64;
2827
2828 ret = MSVCRT_stat64( path, &buf64);
2829 if (!ret)
2830 msvcrt_stat64_to_stat(&buf64, buf);
2831 return ret;
2832 }
2833
2834 /*********************************************************************
2835 * _stat32 (MSVCR100.@)
2836 */
2837 int CDECL MSVCRT__stat32(const char *path, struct MSVCRT__stat32 *buf)
2838 {
2839 int ret;
2840 struct MSVCRT__stat64 buf64;
2841
2842 ret = MSVCRT_stat64(path, &buf64);
2843 if (!ret)
2844 msvcrt_stat64_to_stat32(&buf64, buf);
2845 return ret;
2846 }
2847
2848 /*********************************************************************
2849 * _stat32i64 (MSVCR100.@)
2850 */
2851 int CDECL MSVCRT__stat32i64(const char *path, struct MSVCRT__stat32i64 *buf)
2852 {
2853 int ret;
2854 struct MSVCRT__stat64 buf64;
2855
2856 ret = MSVCRT_stat64(path, &buf64);
2857 if (!ret)
2858 msvcrt_stat64_to_stat32i64(&buf64, buf);
2859 return ret;
2860 }
2861
2862 /*********************************************************************
2863 * _stat64i32 (MSVCR100.@)
2864 */
2865 int CDECL MSVCRT__stat64i32(const char* path, struct MSVCRT__stat64i32 *buf)
2866 {
2867 int ret;
2868 struct MSVCRT__stat64 buf64;
2869
2870 ret = MSVCRT_stat64(path, &buf64);
2871 if (!ret)
2872 msvcrt_stat64_to_stat64i32(&buf64, buf);
2873 return ret;
2874 }
2875
2876 /*********************************************************************
2877 * _wstat64 (MSVCRT.@)
2878 */
2879 int CDECL MSVCRT__wstat64(const MSVCRT_wchar_t* path, struct MSVCRT__stat64 * buf)
2880 {
2881 DWORD dw;
2882 WIN32_FILE_ATTRIBUTE_DATA hfi;
2883 unsigned short mode = ALL_S_IREAD;
2884 int plen;
2885
2886 TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
2887
2888 plen = strlenW(path);
2889 while (plen && path[plen-1]==' ')
2890 plen--;
2891
2892 if(plen && (plen<2 || path[plen-2]!=':') &&
2893 (path[plen-1]==':' || path[plen-1]=='\\' || path[plen-1]=='/'))
2894 {
2895 *MSVCRT__errno() = MSVCRT_ENOENT;
2896 return -1;
2897 }
2898
2899 if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
2900 {
2901 TRACE("failed (%d)\n",GetLastError());
2902 *MSVCRT__errno() = MSVCRT_ENOENT;
2903 return -1;
2904 }
2905
2906 memset(buf,0,sizeof(struct MSVCRT__stat64));
2907
2908 /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
2909 if (MSVCRT_iswalpha(*path))
2910 buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
2911 else
2912 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
2913
2914 /* Dir, or regular file? */
2915 if (hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
2916 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
2917 else
2918 {
2919 mode |= MSVCRT__S_IFREG;
2920 /* executable? */
2921 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
2922 {
2923 ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
2924 ((ULONGLONG)tolowerW(path[plen-3]) << 32);
2925 if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
2926 mode |= ALL_S_IEXEC;
2927 }
2928 }
2929
2930 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
2931 mode |= ALL_S_IWRITE;
2932
2933 buf->st_mode = mode;
2934 buf->st_nlink = 1;
2935 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
2936 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
2937 buf->st_atime = dw;
2938 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
2939 buf->st_mtime = buf->st_ctime = dw;
2940 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
2941 (int)(buf->st_size >> 32),(int)buf->st_size,
2942 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
2943 return 0;
2944 }
2945
2946 /*********************************************************************
2947 * _wstati64 (MSVCRT.@)
2948 */
2949 int CDECL MSVCRT__wstati64(const MSVCRT_wchar_t* path, struct MSVCRT__stati64 * buf)
2950 {
2951 int ret;
2952 struct MSVCRT__stat64 buf64;
2953
2954 ret = MSVCRT__wstat64(path, &buf64);
2955 if (!ret)
2956 msvcrt_stat64_to_stati64(&buf64, buf);
2957 return ret;
2958 }
2959
2960 /*********************************************************************
2961 * _wstat (MSVCRT.@)
2962 */
2963 int CDECL MSVCRT__wstat(const MSVCRT_wchar_t* path, struct MSVCRT__stat * buf)
2964 {
2965 int ret;
2966 struct MSVCRT__stat64 buf64;
2967
2968 ret = MSVCRT__wstat64( path, &buf64 );
2969 if (!ret) msvcrt_stat64_to_stat(&buf64, buf);
2970 return ret;
2971 }
2972
2973 /*********************************************************************
2974 * _wstat32 (MSVCR100.@)
2975 */
2976 int CDECL MSVCRT__wstat32(const MSVCRT_wchar_t *path, struct MSVCRT__stat32 *buf)
2977 {
2978 int ret;
2979 struct MSVCRT__stat64 buf64;
2980
2981 ret = MSVCRT__wstat64(path, &buf64);
2982 if (!ret)
2983 msvcrt_stat64_to_stat32(&buf64, buf);
2984 return ret;
2985 }
2986
2987 /*********************************************************************
2988 * _wstat32i64 (MSVCR100.@)
2989 */
2990 int CDECL MSVCRT__wstat32i64(const MSVCRT_wchar_t *path, struct MSVCRT__stat32i64 *buf)
2991 {
2992 int ret;
2993 struct MSVCRT__stat64 buf64;
2994
2995 ret = MSVCRT__wstat64(path, &buf64);
2996 if (!ret)
2997 msvcrt_stat64_to_stat32i64(&buf64, buf);
2998 return ret;
2999 }
3000
3001 /*********************************************************************
3002 * _wstat64i32 (MSVCR100.@)
3003 */
3004 int CDECL MSVCRT__wstat64i32(const MSVCRT_wchar_t *path, struct MSVCRT__stat64i32 *buf)
3005 {
3006 int ret;
3007 struct MSVCRT__stat64 buf64;
3008
3009 ret = MSVCRT__wstat64(path, &buf64);
3010 if (!ret)
3011 msvcrt_stat64_to_stat64i32(&buf64, buf);
3012 return ret;
3013 }
3014
3015 /*********************************************************************
3016 * _tell (MSVCRT.@)
3017 */
3018 MSVCRT_long CDECL MSVCRT__tell(int fd)
3019 {
3020 return MSVCRT__lseek(fd, 0, SEEK_CUR);
3021 }
3022
3023 /*********************************************************************
3024 * _telli64 (MSVCRT.@)
3025 */
3026 __int64 CDECL _telli64(int fd)
3027 {
3028 return MSVCRT__lseeki64(fd, 0, SEEK_CUR);
3029 }
3030
3031 /*********************************************************************
3032 * _tempnam (MSVCRT.@)
3033 */
3034 char * CDECL MSVCRT__tempnam(const char *dir, const char *prefix)
3035 {
3036 char tmpbuf[MAX_PATH];
3037 const char *tmp_dir = MSVCRT_getenv("TMP");
3038
3039 if (tmp_dir) dir = tmp_dir;
3040
3041 TRACE("dir (%s) prefix (%s)\n",dir,prefix);
3042 if (GetTempFileNameA(dir,prefix,0,tmpbuf))
3043 {
3044 TRACE("got name (%s)\n",tmpbuf);
3045 DeleteFileA(tmpbuf);
3046 return MSVCRT__strdup(tmpbuf);
3047 }
3048 TRACE("failed (%d)\n",GetLastError());
3049 return NULL;
3050 }
3051
3052 /*********************************************************************
3053 * _wtempnam (MSVCRT.@)
3054 */
3055 MSVCRT_wchar_t * CDECL MSVCRT__wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
3056 {
3057 static const MSVCRT_wchar_t tmpW[] = {'T','M','P',0};
3058 MSVCRT_wchar_t tmpbuf[MAX_PATH];
3059 const MSVCRT_wchar_t *tmp_dir = MSVCRT__wgetenv(tmpW);
3060
3061 if (tmp_dir) dir = tmp_dir;
3062
3063 TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
3064 if (GetTempFileNameW(dir,prefix,0,tmpbuf))
3065 {
3066 TRACE("got name (%s)\n",debugstr_w(tmpbuf));
3067 DeleteFileW(tmpbuf);
3068 return MSVCRT__wcsdup(tmpbuf);
3069 }
3070 TRACE("failed (%d)\n",GetLastError());
3071 return NULL;
3072 }
3073
3074 /*********************************************************************
3075 * _umask (MSVCRT.@)
3076 */
3077 int CDECL MSVCRT__umask(int umask)
3078 {
3079 int old_umask = MSVCRT_umask;
3080 TRACE("(%d)\n",umask);
3081 MSVCRT_umask = umask;
3082 return old_umask;
3083 }
3084
3085 /*********************************************************************
3086 * _utime64 (MSVCRT.@)
3087 */
3088 int CDECL _utime64(const char* path, struct MSVCRT___utimbuf64 *t)
3089 {
3090 int fd = MSVCRT__open(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
3091
3092 if (fd > 0)
3093 {
3094 int retVal = _futime64(fd, t);
3095 MSVCRT__close(fd);
3096 return retVal;
3097 }
3098 return -1;
3099 }
3100
3101 /*********************************************************************
3102 * _utime32 (MSVCRT.@)
3103 */
3104 int CDECL _utime32(const char* path, struct MSVCRT___utimbuf32 *t)
3105 {
3106 if (t)
3107 {
3108 struct MSVCRT___utimbuf64 t64;
3109 t64.actime = t->actime;
3110 t64.modtime = t->modtime;
3111 return _utime64( path, &t64 );
3112 }
3113 else
3114 return _utime64( path, NULL );
3115 }
3116
3117 /*********************************************************************
3118 * _utime (MSVCRT.@)
3119 */
3120 #ifdef _WIN64
3121 int CDECL _utime(const char* path, struct MSVCRT___utimbuf64 *t)
3122 {
3123 return _utime64( path, t );
3124 }
3125 #else
3126 int CDECL _utime(const char* path, struct MSVCRT___utimbuf32 *t)
3127 {
3128 return _utime32( path, t );
3129 }
3130 #endif
3131
3132 /*********************************************************************
3133 * _wutime64 (MSVCRT.@)
3134 */
3135 int CDECL _wutime64(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
3136 {
3137 int fd = MSVCRT__wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
3138
3139 if (fd > 0)
3140 {
3141 int retVal = _futime64(fd, t);
3142 MSVCRT__close(fd);
3143 return retVal;
3144 }
3145 return -1;
3146 }
3147
3148 /*********************************************************************
3149 * _wutime32 (MSVCRT.@)
3150 */
3151 int CDECL _wutime32(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
3152 {
3153 if (t)
3154 {
3155 struct MSVCRT___utimbuf64 t64;
3156 t64.actime = t->actime;
3157 t64.modtime = t->modtime;
3158 return _wutime64( path, &t64 );
3159 }
3160 else
3161 return _wutime64( path, NULL );
3162 }
3163
3164 /*********************************************************************
3165 * _wutime (MSVCRT.@)
3166 */
3167 #ifdef _WIN64
3168 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
3169 {
3170 return _wutime64( path, t );
3171 }
3172 #else
3173 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
3174 {
3175 return _wutime32( path, t );
3176 }
3177 #endif
3178
3179 /*********************************************************************
3180 * _write (MSVCRT.@)
3181 */
3182 int CDECL MSVCRT__write(int fd, const void* buf, unsigned int count)
3183 {
3184 DWORD num_written;
3185 ioinfo *info = msvcrt_get_ioinfo(fd);
3186 HANDLE hand = info->handle;
3187
3188 /* Don't trace small writes, it gets *very* annoying */
3189 #if 0
3190 if (count > 32)
3191 TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
3192 #endif
3193 if (hand == INVALID_HANDLE_VALUE)
3194 {
3195 *MSVCRT__errno() = MSVCRT_EBADF;
3196 return -1;
3197 }
3198
3199 if (((info->exflag&EF_UTF8) || (info->exflag&EF_UTF16)) && count&1)
3200 {
3201 *MSVCRT__errno() = MSVCRT_EINVAL;
3202 return -1;
3203 }
3204
3205 /* If appending, go to EOF */
3206 if (info->wxflag & WX_APPEND)
3207 MSVCRT__lseek(fd, 0, FILE_END);
3208
3209 if (!(info->wxflag & WX_TEXT))
3210 {
3211 if (WriteFile(hand, buf, count, &num_written, NULL)
3212 && (num_written == count))
3213 return num_written;
3214 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d)\n", fd,
3215 hand, GetLastError());
3216 *MSVCRT__errno() = MSVCRT_ENOSPC;
3217 }
3218 else
3219 {
3220 unsigned int i, j, nr_lf, size;
3221 char *p = NULL;
3222 const char *q;
3223 const char *s = buf, *buf_start = buf;
3224
3225 if (!(info->exflag & (EF_UTF8|EF_UTF16)))
3226 {
3227 /* find number of \n */
3228 for (nr_lf=0, i=0; i<count; i++)
3229 if (s[i] == '\n')
3230 nr_lf++;
3231 if (nr_lf)
3232 {
3233 size = count+nr_lf;
3234 if ((q = p = MSVCRT_malloc(size)))
3235 {
3236 for (s = buf, i = 0, j = 0; i < count; i++)
3237 {
3238 if (s[i] == '\n')
3239 p[j++] = '\r';
3240 p[j++] = s[i];
3241 }
3242 }
3243 else
3244 {
3245 FIXME("Malloc failed\n");
3246 nr_lf = 0;
3247 size = count;
3248 q = buf;
3249 }
3250 }
3251 else
3252 {
3253 size = count;
3254 q = buf;
3255 }
3256 }
3257 else if (info->exflag & EF_UTF16)
3258 {
3259 for (nr_lf=0, i=0; i<count; i+=2)
3260 if (s[i]=='\n' && s[i+1]==0)
3261 nr_lf += 2;
3262 if (nr_lf)
3263 {
3264 size = count+nr_lf;
3265 if ((q = p = MSVCRT_malloc(size)))
3266 {
3267 for (s=buf, i=0, j=0; i<count; i++)
3268 {
3269 if (s[i]=='\n' && s[i+1]==0)
3270 {
3271 p[j++] = '\r';
3272 p[j++] = 0;
3273 }
3274 p[j++] = s[i++];
3275 p[j++] = s[i];
3276 }
3277 }
3278 else
3279 {
3280 FIXME("Malloc failed\n");
3281 nr_lf = 0;
3282 size = count;
3283 q = buf;
3284 }
3285 }
3286 else
3287 {
3288 size = count;
3289 q = buf;
3290 }
3291 }
3292 else
3293 {
3294 DWORD conv_len;
3295
3296 for(nr_lf=0, i=0; i<count; i+=2)
3297 if (s[i]=='\n' && s[i+1]==0)
3298 nr_lf++;
3299
3300 conv_len = WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)buf, count/2, NULL, 0, NULL, NULL);
3301 if(!conv_len) {
3302 msvcrt_set_errno(GetLastError());
3303 MSVCRT_free(p);
3304 return -1;
3305 }
3306
3307 size = conv_len+nr_lf;
3308 if((p = MSVCRT_malloc(count+nr_lf*2+size)))
3309 {
3310 for (s=buf, i=0, j=0; i<count; i++)
3311 {
3312 if (s[i]=='\n' && s[i+1]==0)
3313 {
3314 p[j++] = '\r';
3315 p[j++] = 0;
3316 }
3317 p[j++] = s[i++];
3318 p[j++] = s[i];
3319 }
3320 q = p+count+nr_lf*2;
3321 WideCharToMultiByte(CP_UTF8, 0, (WCHAR*)p, count/2+nr_lf,
3322 p+count+nr_lf*2, conv_len+nr_lf, NULL, NULL);
3323 }
3324 else
3325 {
3326 FIXME("Malloc failed\n");
3327 nr_lf = 0;
3328 size = count;
3329 q = buf;
3330 }
3331 }
3332
3333 if (!WriteFile(hand, q, size, &num_written, NULL))
3334 num_written = -1;
3335 if(p)
3336 MSVCRT_free(p);
3337 if (num_written != size)
3338 {
3339 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d), num_written %d\n",
3340 fd, hand, GetLastError(), num_written);
3341 *MSVCRT__errno() = MSVCRT_ENOSPC;
3342 return s - buf_start;
3343 }
3344 return count;
3345 }
3346
3347 return -1;
3348 }
3349
3350 /*********************************************************************
3351 * _putw (MSVCRT.@)
3352 */
3353 int CDECL MSVCRT__putw(int val, MSVCRT_FILE* file)
3354 {
3355 int len;
3356
3357 MSVCRT__lock_file(file);
3358 len = MSVCRT__write(file->_file, &val, sizeof(val));
3359 if (len == sizeof(val)) {
3360 MSVCRT__unlock_file(file);
3361 return val;
3362 }
3363
3364 file->_flag |= MSVCRT__IOERR;
3365 MSVCRT__unlock_file(file);
3366 return MSVCRT_EOF;
3367 }
3368
3369 /*********************************************************************
3370 * fclose (MSVCRT.@)
3371 */
3372 int CDECL MSVCRT_fclose(MSVCRT_FILE* file)
3373 {
3374 int r, flag;
3375
3376 MSVCRT__lock_file(file);
3377 flag = file->_flag;
3378 MSVCRT_free(file->_tmpfname);
3379 file->_tmpfname = NULL;
3380 /* flush stdio buffers */
3381 if(file->_flag & MSVCRT__IOWRT)
3382 MSVCRT_fflush(file);
3383 if(file->_flag & MSVCRT__IOMYBUF)
3384 MSVCRT_free(file->_base);
3385
3386 r=MSVCRT__close(file->_file);
3387
3388 file->_flag = 0;
3389 MSVCRT__unlock_file(file);
3390
3391 return ((r == -1) || (flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
3392 }
3393
3394 /*********************************************************************
3395 * feof (MSVCRT.@)
3396 */
3397 int CDECL MSVCRT_feof(MSVCRT_FILE* file)
3398 {
3399 return file->_flag & MSVCRT__IOEOF;
3400 }
3401
3402 /*********************************************************************
3403 * ferror (MSVCRT.@)
3404 */
3405 int CDECL MSVCRT_ferror(MSVCRT_FILE* file)
3406 {
3407 return file->_flag & MSVCRT__IOERR;
3408 }
3409
3410 /*********************************************************************
3411 * _filbuf (MSVCRT.@)
3412 */
3413 int CDECL MSVCRT__filbuf(MSVCRT_FILE* file)
3414 {
3415 unsigned char c;
3416 MSVCRT__lock_file(file);
3417
3418 if(file->_flag & MSVCRT__IOSTRG) {
3419 MSVCRT__unlock_file(file);
3420 return MSVCRT_EOF;
3421 }
3422
3423 /* Allocate buffer if needed */
3424 if(!(file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF)))
3425 msvcrt_alloc_buffer(file);
3426
3427 if(!(file->_flag & MSVCRT__IOREAD)) {
3428 if(file->_flag & MSVCRT__IORW)
3429 file->_flag |= MSVCRT__IOREAD;
3430 else {
3431 MSVCRT__unlock_file(file);
3432 return MSVCRT_EOF;
3433 }
3434 }
3435
3436 if(!(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF))) {
3437 int r;
3438 if ((r = read_i(file->_file,&c,1)) != 1) {
3439 file->_flag |= (r == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
3440 MSVCRT__unlock_file(file);
3441 return MSVCRT_EOF;
3442 }
3443
3444 MSVCRT__unlock_file(file);
3445 return c;
3446 } else {
3447 file->_cnt = read_i(file->_file, file->_base, file->_bufsiz);
3448 if(file->_cnt<=0) {
3449 file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
3450 file->_cnt = 0;
3451 MSVCRT__unlock_file(file);
3452 return MSVCRT_EOF;
3453 }
3454
3455 file->_cnt--;
3456 file->_ptr = file->_base+1;
3457 c = *(unsigned char *)file->_base;
3458 MSVCRT__unlock_file(file);
3459 return c;
3460 }
3461 }
3462
3463 /*********************************************************************
3464 * fgetc (MSVCRT.@)
3465 */
3466 int CDECL MSVCRT_fgetc(MSVCRT_FILE* file)
3467 {
3468 unsigned char *i;
3469 unsigned int j;
3470
3471 MSVCRT__lock_file(file);
3472 if (file->_cnt>0) {
3473 file->_cnt--;
3474 i = (unsigned char *)file->_ptr++;
3475 j = *i;
3476 } else
3477 j = MSVCRT__filbuf(file);
3478
3479 MSVCRT__unlock_file(file);
3480 return j;
3481 }
3482
3483 /*********************************************************************
3484 * _fgetchar (MSVCRT.@)
3485 */
3486 int CDECL MSVCRT__fgetchar(void)
3487 {
3488 return MSVCRT_fgetc(MSVCRT_stdin);
3489 }
3490
3491 /*********************************************************************
3492 * fgets (MSVCRT.@)
3493 */
3494 char * CDECL MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
3495 {
3496 int cc = MSVCRT_EOF;
3497 char * buf_start = s;
3498
3499 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3500 file,file->_file,s,size);
3501
3502 MSVCRT__lock_file(file);
3503
3504 while ((size >1) && (cc = MSVCRT_fgetc(file)) != MSVCRT_EOF && cc != '\n')
3505 {
3506 *s++ = (char)cc;
3507 size --;
3508 }
3509 if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
3510 {
3511 TRACE(":nothing read\n");
3512 MSVCRT__unlock_file(file);
3513 return NULL;
3514 }
3515 if ((cc != MSVCRT_EOF) && (size > 1))
3516 *s++ = cc;
3517 *s = '\0';
3518 TRACE(":got %s\n", debugstr_a(buf_start));
3519 MSVCRT__unlock_file(file);
3520 return buf_start;
3521 }
3522
3523 /*********************************************************************
3524 * fgetwc (MSVCRT.@)
3525 */
3526 MSVCRT_wint_t CDECL MSVCRT_fgetwc(MSVCRT_FILE* file)
3527 {
3528 MSVCRT_wint_t ret;
3529 int ch;
3530
3531 MSVCRT__lock_file(file);
3532
3533 if((msvcrt_get_ioinfo(file->_file)->exflag & (EF_UTF8 | EF_UTF16))
3534 || !(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT)) {
3535 char *p;
3536
3537 for(p=(char*)&ret; (MSVCRT_wint_t*)p<&ret+1; p++) {
3538 ch = MSVCRT_fgetc(file);
3539 if(ch == MSVCRT_EOF) {
3540 ret = MSVCRT_WEOF;
3541 break;
3542 }
3543 *p = (char)ch;
3544 }
3545 }else {
3546 char mbs[MSVCRT_MB_LEN_MAX];
3547 int len = 0;
3548
3549 ch = MSVCRT_fgetc(file);
3550 if(ch != MSVCRT_EOF) {
3551 mbs[0] = (char)ch;
3552 if(MSVCRT_isleadbyte((unsigned char)mbs[0])) {
3553 ch = MSVCRT_fgetc(file);
3554 if(ch != MSVCRT_EOF) {
3555 mbs[1] = (char)ch;
3556 len = 2;
3557 }
3558 }else {
3559 len = 1;
3560 }
3561 }
3562
3563 if(!len || MSVCRT_mbtowc(&ret, mbs, len)==-1)
3564 ret = MSVCRT_WEOF;
3565 }
3566
3567 MSVCRT__unlock_file(file);
3568 return ret;
3569 }
3570
3571 /*********************************************************************
3572 * _getw (MSVCRT.@)
3573 */
3574 int CDECL MSVCRT__getw(MSVCRT_FILE* file)
3575 {
3576 char *ch;
3577 int i, k;
3578 unsigned int j;
3579 ch = (char *)&i;
3580
3581 MSVCRT__lock_file(file);
3582 for (j=0; j<sizeof(int); j++) {
3583 k = MSVCRT_fgetc(file);
3584 if (k == MSVCRT_EOF) {
3585 file->_flag |= MSVCRT__IOEOF;
3586 MSVCRT__unlock_file(file);
3587 return EOF;
3588 }
3589 ch[j] = k;
3590 }
3591
3592 MSVCRT__unlock_file(file);
3593 return i;
3594 }
3595
3596 /*********************************************************************
3597 * getwc (MSVCRT.@)
3598 */
3599 MSVCRT_wint_t CDECL MSVCRT_getwc(MSVCRT_FILE* file)
3600 {
3601 return MSVCRT_fgetwc(file);
3602 }
3603
3604 /*********************************************************************
3605 * _fgetwchar (MSVCRT.@)
3606 */
3607 MSVCRT_wint_t CDECL MSVCRT__fgetwchar(void)
3608 {
3609 return MSVCRT_fgetwc(MSVCRT_stdin);
3610 }
3611
3612 /*********************************************************************
3613 * getwchar (MSVCRT.@)
3614 */
3615 MSVCRT_wint_t CDECL MSVCRT_getwchar(void)
3616 {
3617 return MSVCRT__fgetwchar();
3618 }
3619
3620 /*********************************************************************
3621 * fgetws (MSVCRT.@)
3622 */
3623 MSVCRT_wchar_t * CDECL MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
3624 {
3625 MSVCRT_wint_t cc = MSVCRT_WEOF;
3626 MSVCRT_wchar_t * buf_start = s;
3627
3628 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
3629 file,file->_file,s,size);
3630
3631 MSVCRT__lock_file(file);
3632
3633 while ((size >1) && (cc = MSVCRT_fgetwc(file)) != MSVCRT_WEOF && cc != '\n')
3634 {
3635 *s++ = cc;
3636 size --;
3637 }
3638 if ((cc == MSVCRT_WEOF) && (s == buf_start)) /* If nothing read, return 0*/
3639 {
3640 TRACE(":nothing read\n");
3641 MSVCRT__unlock_file(file);
3642 return NULL;
3643 }
3644 if ((cc != MSVCRT_WEOF) && (size > 1))
3645 *s++ = cc;
3646 *s = 0;
3647 TRACE(":got %s\n", debugstr_w(buf_start));
3648 MSVCRT__unlock_file(file);
3649 return buf_start;
3650 }
3651
3652 /*********************************************************************
3653 * _flsbuf (MSVCRT.@)
3654 */
3655 int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
3656 {
3657 /* Flush output buffer */
3658 if(!(file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF))) {
3659 msvcrt_alloc_buffer(file);
3660 }
3661 if(!(file->_flag & MSVCRT__IOWRT)) {
3662 if(file->_flag & MSVCRT__IORW)
3663 file->_flag |= MSVCRT__IOWRT;
3664 else
3665 return MSVCRT_EOF;
3666 }
3667 if(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)) {
3668 int res = 0;
3669
3670 if(file->_cnt <= 0) {
3671 res = msvcrt_flush_buffer(file);
3672 if(res)
3673 return res;
3674 file->_cnt=file->_bufsiz;
3675 }
3676 *file->_ptr++ = c;
3677 file->_cnt--;
3678 return c&0xff;
3679 } else {
3680 unsigned char cc=c;
3681 int len;
3682 /* set _cnt to 0 for unbuffered FILEs */
3683 file->_cnt = 0;
3684 len = MSVCRT__write(file->_file, &cc, 1);
3685 if (len == 1)
3686 return c & 0xff;
3687 file->_flag |= MSVCRT__IOERR;
3688 return MSVCRT_EOF;
3689 }
3690 }
3691
3692 /*********************************************************************
3693 * fwrite (MSVCRT.@)
3694 */
3695 MSVCRT_size_t CDECL MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
3696 {
3697 MSVCRT_size_t wrcnt=size * nmemb;
3698 int written = 0;
3699 if (size == 0)
3700 return 0;
3701
3702 MSVCRT__lock_file(file);
3703
3704 while(wrcnt) {
3705 if(file->_cnt < 0) {
3706 WARN("negative file->_cnt value in %p\n", file);
3707 file->_flag |= MSVCRT__IOERR;
3708 break;
3709 } else if(file->_cnt) {
3710 int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
3711 memcpy(file->_ptr, ptr, pcnt);
3712 file->_cnt -= pcnt;
3713 file->_ptr += pcnt;
3714 written += pcnt;
3715 wrcnt -= pcnt;
3716 ptr = (const char*)ptr + pcnt;
3717 } else if((file->_flag & MSVCRT__IONBF)
3718 || ((file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)) && wrcnt >= file->_bufsiz)
3719 || (!(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)) && wrcnt >= MSVCRT_INTERNAL_BUFSIZ)) {
3720 MSVCRT_size_t pcnt;
3721 int bufsiz;
3722
3723 if(file->_flag & MSVCRT__IONBF)
3724 bufsiz = 1;
3725 else if(!(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)))
3726 bufsiz = MSVCRT_INTERNAL_BUFSIZ;
3727 else
3728 bufsiz = file->_bufsiz;
3729
3730 pcnt = (wrcnt / bufsiz) * bufsiz;
3731
3732 if(msvcrt_flush_buffer(file) == MSVCRT_EOF)
3733 break;
3734
3735 if(MSVCRT__write(file->_file, ptr, pcnt) <= 0) {
3736 file->_flag |= MSVCRT__IOERR;
3737 break;
3738 }
3739 written += pcnt;
3740 wrcnt -= pcnt;
3741 ptr = (const char*)ptr + pcnt;
3742 } else {
3743 if(MSVCRT__flsbuf(*(const char*)ptr, file) == MSVCRT_EOF)
3744 break;
3745 written++;
3746 wrcnt--;
3747 ptr = (const char*)ptr + 1;
3748 }
3749 }
3750
3751 MSVCRT__unlock_file(file);
3752 return written / size;
3753 }
3754
3755 /*********************************************************************
3756 * fputwc (MSVCRT.@)
3757 */
3758 MSVCRT_wint_t CDECL MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
3759 {
3760 MSVCRT_wchar_t mwc=wc;
3761 ioinfo *fdinfo;
3762 MSVCRT_wint_t ret;
3763
3764 MSVCRT__lock_file(file);
3765 fdinfo = msvcrt_get_ioinfo(file->_file);
3766
3767 if((fdinfo->wxflag&WX_TEXT) && !(fdinfo->exflag&(EF_UTF8|EF_UTF16))) {
3768 char buf[MSVCRT_MB_LEN_MAX];
3769 int char_len;
3770
3771 char_len = MSVCRT_wctomb(buf, mwc);
3772 if(char_len!=-1 && MSVCRT_fwrite(buf, char_len, 1, file)==1)
3773 ret = wc;
3774 else
3775 ret = MSVCRT_WEOF;
3776 }else if(MSVCRT_fwrite(&mwc, sizeof(mwc), 1, file) == 1) {
3777 ret = wc;
3778 }else {
3779 ret = MSVCRT_WEOF;
3780 }
3781
3782 MSVCRT__unlock_file(file);
3783 return ret;
3784 }
3785
3786 /*********************************************************************
3787 * _fputwchar (MSVCRT.@)
3788 */
3789 MSVCRT_wint_t CDECL MSVCRT__fputwchar(MSVCRT_wint_t wc)
3790 {
3791 return MSVCRT_fputwc(wc, MSVCRT_stdout);
3792 }
3793
3794 /*********************************************************************
3795 * _wfsopen (MSVCRT.@)
3796 */
3797 MSVCRT_FILE * CDECL MSVCRT__wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
3798 {
3799 MSVCRT_FILE* file;
3800 int open_flags, stream_flags, fd;
3801
3802 TRACE("(%s,%s)\n", debugstr_w(path), debugstr_w(mode));
3803
3804 /* map mode string to open() flags. "man fopen" for possibilities. */
3805 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
3806 return NULL;
3807
3808 LOCK_FILES();
3809 fd = MSVCRT__wsopen(path, open_flags, share, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
3810 if (fd < 0)
3811 file = NULL;
3812 else if ((file = msvcrt_alloc_fp()) && msvcrt_init_fp(file, fd, stream_flags)
3813 != -1)
3814 TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
3815 else if (file)
3816 {
3817 file->_flag = 0;
3818 file = NULL;
3819 }
3820
3821 TRACE(":got (%p)\n",file);
3822 if (fd >= 0 && !file)
3823 MSVCRT__close(fd);
3824 UNLOCK_FILES();
3825 return file;
3826 }
3827
3828 /*********************************************************************
3829 * _fsopen (MSVCRT.@)
3830 */
3831 MSVCRT_FILE * CDECL MSVCRT__fsopen(const char *path, const char *mode, int share)
3832 {
3833 MSVCRT_FILE *ret;
3834 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
3835
3836 if (path && !(pathW = msvcrt_wstrdupa(path))) {
3837 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
3838 *MSVCRT__errno() = MSVCRT_EINVAL;
3839 return NULL;
3840 }
3841 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
3842 {
3843 MSVCRT_free(pathW);
3844 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
3845 *MSVCRT__errno() = MSVCRT_EINVAL;
3846 return NULL;
3847 }
3848
3849 ret = MSVCRT__wfsopen(pathW, modeW, share);
3850
3851 MSVCRT_free(pathW);
3852 MSVCRT_free(modeW);
3853 return ret;
3854 }
3855
3856 /*********************************************************************
3857 * fopen (MSVCRT.@)
3858 */
3859 MSVCRT_FILE * CDECL MSVCRT_fopen(const char *path, const char *mode)
3860 {
3861 return MSVCRT__fsopen( path, mode, MSVCRT__SH_DENYNO );
3862 }
3863
3864 /*********************************************************************
3865 * fopen_s (MSVCRT.@)
3866 */
3867 int CDECL MSVCRT_fopen_s(MSVCRT_FILE** pFile,
3868 const char *filename, const char *mode)
3869 {
3870 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3871 if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
3872 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3873
3874 *pFile = MSVCRT_fopen(filename, mode);
3875
3876 if(!*pFile)
3877 return *MSVCRT__errno();
3878 return 0;
3879 }
3880
3881 /*********************************************************************
3882 * _wfopen (MSVCRT.@)
3883 */
3884 MSVCRT_FILE * CDECL MSVCRT__wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
3885 {
3886 return MSVCRT__wfsopen( path, mode, MSVCRT__SH_DENYNO );
3887 }
3888
3889 /*********************************************************************
3890 * _wfopen_s (MSVCRT.@)
3891 */
3892 int CDECL MSVCRT__wfopen_s(MSVCRT_FILE** pFile, const MSVCRT_wchar_t *filename,
3893 const MSVCRT_wchar_t *mode)
3894 {
3895 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
3896 if (!MSVCRT_CHECK_PMT(filename != NULL)) return MSVCRT_EINVAL;
3897 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
3898
3899 *pFile = MSVCRT__wfopen(filename, mode);
3900
3901 if(!*pFile)
3902 return *MSVCRT__errno();
3903 return 0;
3904 }
3905
3906 /*********************************************************************
3907 * fputc (MSVCRT.@)
3908 */
3909 int CDECL MSVCRT_fputc(int c, MSVCRT_FILE* file)
3910 {
3911 int res;
3912
3913 MSVCRT__lock_file(file);
3914 if(file->_cnt>0) {
3915 *file->_ptr++=c;
3916 file->_cnt--;
3917 if (c == '\n')
3918 {
3919 res = msvcrt_flush_buffer(file);
3920 MSVCRT__unlock_file(file);
3921 return res ? res : c;
3922 }
3923 else {
3924 MSVCRT__unlock_file(file);
3925 return c & 0xff;
3926 }
3927 } else {
3928 res = MSVCRT__flsbuf(c, file);
3929 MSVCRT__unlock_file(file);
3930 return res;
3931 }
3932 }
3933
3934 /*********************************************************************
3935 * _fputchar (MSVCRT.@)
3936 */
3937 int CDECL MSVCRT__fputchar(int c)
3938 {
3939 return MSVCRT_fputc(c, MSVCRT_stdout);
3940 }
3941
3942 /*********************************************************************
3943 * fread (MSVCRT.@)
3944 */
3945 MSVCRT_size_t CDECL MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
3946 {
3947 MSVCRT_size_t rcnt=size * nmemb;
3948 MSVCRT_size_t read=0;
3949 MSVCRT_size_t pread=0;
3950
3951 if(!rcnt)
3952 return 0;
3953
3954 MSVCRT__lock_file(file);
3955
3956 /* first buffered data */
3957 if(file->_cnt>0) {
3958 int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
3959 memcpy(ptr, file->_ptr, pcnt);
3960 file->_cnt -= pcnt;
3961 file->_ptr += pcnt;
3962 read += pcnt ;
3963 rcnt -= pcnt ;
3964 ptr = (char*)ptr + pcnt;
3965 } else if(!(file->_flag & MSVCRT__IOREAD )) {
3966 if(file->_flag & MSVCRT__IORW) {
3967 file->_flag |= MSVCRT__IOREAD;
3968 } else {
3969 MSVCRT__unlock_file(file);
3970 return 0;
3971 }
3972 }
3973
3974 if(rcnt>0 && !(file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF)))
3975 msvcrt_alloc_buffer(file);
3976
3977 while(rcnt>0)
3978 {
3979 int i;
3980 if (!file->_cnt && rcnt<MSVCRT_BUFSIZ && (file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF))) {
3981 file->_cnt = MSVCRT__read(file->_file, file->_base, file->_bufsiz);
3982 file->_ptr = file->_base;
3983 i = (file->_cnt<rcnt) ? file->_cnt : rcnt;
3984 /* If the buffer fill reaches eof but fread wouldn't, clear eof. */
3985 if (i > 0 && i < file->_cnt) {
3986 msvcrt_get_ioinfo(file->_file)->wxflag &= ~WX_ATEOF;
3987 file->_flag &= ~MSVCRT__IOEOF;
3988 }
3989 if (i > 0) {
3990 memcpy(ptr, file->_ptr, i);
3991 file->_cnt -= i;
3992 file->_ptr += i;
3993 }
3994 } else if (rcnt > INT_MAX) {
3995 i = MSVCRT__read(file->_file, ptr, INT_MAX);
3996 } else if (rcnt < MSVCRT_BUFSIZ) {
3997 i = MSVCRT__read(file->_file, ptr, rcnt);
3998 } else {
3999 i = MSVCRT__read(file->_file, ptr, rcnt - MSVCRT_BUFSIZ/2);
4000 }
4001 pread += i;
4002 rcnt -= i;
4003 ptr = (char *)ptr+i;
4004 /* expose feof condition in the flags
4005 * MFC tests file->_flag for feof, and doesn't call feof())
4006 */
4007 if (msvcrt_get_ioinfo(file->_file)->wxflag & WX_ATEOF)
4008 file->_flag |= MSVCRT__IOEOF;
4009 else if (i == -1)
4010 {
4011 file->_flag |= MSVCRT__IOERR;
4012 pread = 0;
4013 rcnt = 0;
4014 }
4015 if (i < 1) break;
4016 }
4017 read+=pread;
4018 MSVCRT__unlock_file(file);
4019 return read / size;
4020 }
4021
4022
4023 /*********************************************************************
4024 * fread_s (MSVCR80.@)
4025 */
4026 MSVCRT_size_t CDECL MSVCRT_fread_s(void *buf, MSVCRT_size_t buf_size, MSVCRT_size_t elem_size,
4027 MSVCRT_size_t count, MSVCRT_FILE *stream)
4028 {
4029 size_t bytes_left, buf_pos;
4030
4031 TRACE("(%p %lu %lu %lu %p\n", buf, buf_size, elem_size, count, stream);
4032
4033 if(!MSVCRT_CHECK_PMT(stream != NULL)) {
4034 if(buf && buf_size)
4035 memset(buf, 0, buf_size);
4036 return 0;
4037 }
4038 if(!elem_size || !count) return 0;
4039 if(!MSVCRT_CHECK_PMT(buf != NULL)) return 0;
4040 if(!MSVCRT_CHECK_PMT(MSVCRT_SIZE_MAX/count >= elem_size)) return 0;
4041
4042 bytes_left = elem_size*count;
4043 buf_pos = 0;
4044 while(bytes_left) {
4045 if(stream->_cnt > 0) {
4046 size_t size = bytes_left<stream->_cnt ? bytes_left : stream->_cnt;
4047
4048 if(!MSVCRT_CHECK_PMT_ERR(size <= buf_size-buf_pos, MSVCRT_ERANGE)) {
4049 memset(buf, 0, buf_size);
4050 return 0;
4051 }
4052
4053 MSVCRT_fread((char*)buf+buf_pos, 1, size, stream);
4054 buf_pos += size;
4055 bytes_left -= size;
4056 }else {
4057 int c = MSVCRT__filbuf(stream);
4058
4059 if(c == EOF)
4060 break;
4061
4062 if(!MSVCRT_CHECK_PMT_ERR(buf_size-buf_pos > 0, MSVCRT_ERANGE)) {
4063 memset(buf, 0, buf_size);
4064 return 0;
4065 }
4066
4067 ((char*)buf)[buf_pos++] = c;
4068 bytes_left--;
4069 }
4070 }
4071
4072 return buf_pos/elem_size;
4073 }
4074
4075 /*********************************************************************
4076 * _wfreopen (MSVCRT.@)
4077 *
4078 */
4079 MSVCRT_FILE* CDECL MSVCRT__wfreopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, MSVCRT_FILE* file)
4080 {
4081 int open_flags, stream_flags, fd;
4082
4083 TRACE(":path (%s) mode (%s) file (%p) fd (%d)\n", debugstr_w(path), debugstr_w(mode), file, file ? file->_file : -1);
4084
4085 LOCK_FILES();
4086 if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
4087 file = NULL;
4088 else
4089 {
4090 MSVCRT_fclose(file);
4091 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
4092 file = NULL;
4093 else if((fd = MSVCRT__wopen(path, open_flags, MSVCRT__S_IREAD | MSVCRT__S_IWRITE)) < 0)
4094 file = NULL;
4095 else if(msvcrt_init_fp(file, fd, stream_flags) == -1)
4096 {
4097 file->_flag = 0;
4098 file = NULL;
4099 }
4100 }
4101 UNLOCK_FILES();
4102 return file;
4103 }
4104
4105 /*********************************************************************
4106 * _wfreopen_s (MSVCRT.@)
4107 */
4108 int CDECL MSVCRT__wfreopen_s(MSVCRT_FILE** pFile,
4109 const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, MSVCRT_FILE* file)
4110 {
4111 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
4112 if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
4113 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
4114 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
4115
4116 *pFile = MSVCRT__wfreopen(path, mode, file);
4117
4118 if(!*pFile)
4119 return *MSVCRT__errno();
4120 return 0;
4121 }
4122
4123 /*********************************************************************
4124 * freopen (MSVCRT.@)
4125 *
4126 */
4127 MSVCRT_FILE* CDECL MSVCRT_freopen(const char *path, const char *mode, MSVCRT_FILE* file)
4128 {
4129 MSVCRT_FILE *ret;
4130 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
4131
4132 if (path && !(pathW = msvcrt_wstrdupa(path))) return NULL;
4133 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
4134 {
4135 MSVCRT_free(pathW);
4136 return NULL;
4137 }
4138
4139 ret = MSVCRT__wfreopen(pathW, modeW, file);
4140
4141 MSVCRT_free(pathW);
4142 MSVCRT_free(modeW);
4143 return ret;
4144 }
4145
4146 /*********************************************************************
4147 * freopen_s (MSVCRT.@)
4148 */
4149 int CDECL MSVCRT_freopen_s(MSVCRT_FILE** pFile,
4150 const char *path, const char *mode, MSVCRT_FILE* file)
4151 {
4152 if (!MSVCRT_CHECK_PMT(pFile != NULL)) return MSVCRT_EINVAL;
4153 if (!MSVCRT_CHECK_PMT(path != NULL)) return MSVCRT_EINVAL;
4154 if (!MSVCRT_CHECK_PMT(mode != NULL)) return MSVCRT_EINVAL;
4155 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
4156
4157 *pFile = MSVCRT_freopen(path, mode, file);
4158
4159 if(!*pFile)
4160 return *MSVCRT__errno();
4161 return 0;
4162 }
4163
4164 /*********************************************************************
4165 * fsetpos (MSVCRT.@)
4166 */
4167 int CDECL MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
4168 {
4169 int ret;
4170
4171 MSVCRT__lock_file(file);
4172 /* Note that all this has been lifted 'as is' from fseek */
4173 if(file->_flag & MSVCRT__IOWRT)
4174 msvcrt_flush_buffer(file);
4175
4176 /* Discard buffered input */
4177 file->_cnt = 0;
4178 file->_ptr = file->_base;
4179
4180 /* Reset direction of i/o */
4181 if(file->_flag & MSVCRT__IORW) {
4182 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
4183 }
4184
4185 ret = (MSVCRT__lseeki64(file->_file,*pos,SEEK_SET) == -1) ? -1 : 0;
4186 MSVCRT__unlock_file(file);
4187 return ret;
4188 }
4189
4190 /*********************************************************************
4191 * _ftelli64 (MSVCRT.@)
4192 */
4193 __int64 CDECL MSVCRT__ftelli64(MSVCRT_FILE* file)
4194 {
4195 __int64 pos;
4196
4197 MSVCRT__lock_file(file);
4198 pos = _telli64(file->_file);
4199 if(pos == -1) {
4200 MSVCRT__unlock_file(file);
4201 return -1;
4202 }
4203 if(file->_flag & (MSVCRT__IOMYBUF | MSVCRT__USERBUF)) {
4204 if(file->_flag & MSVCRT__IOWRT) {
4205 pos += file->_ptr - file->_base;
4206
4207 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT) {
4208 char *p;
4209
4210 for(p=file->_base; p<file->_ptr; p++)
4211 if(*p == '\n')
4212 pos++;
4213 }
4214 } else if(!file->_cnt) { /* nothing to do */
4215 } else if(MSVCRT__lseeki64(file->_file, 0, SEEK_END)==pos) {
4216 int i;
4217
4218 pos -= file->_cnt;
4219 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT) {
4220 for(i=0; i<file->_cnt; i++)
4221 if(file->_ptr[i] == '\n')
4222 pos--;
4223 }
4224 } else {
4225 char *p;
4226
4227 if(MSVCRT__lseeki64(file->_file, pos, SEEK_SET) != pos) {
4228 MSVCRT__unlock_file(file);
4229 return -1;
4230 }
4231
4232 pos -= file->_bufsiz;
4233 pos += file->_ptr - file->_base;
4234
4235 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT) {
4236 if(msvcrt_get_ioinfo(file->_file)->wxflag & WX_READNL)
4237 pos--;
4238
4239 for(p=file->_base; p<file->_ptr; p++)
4240 if(*p == '\n')
4241 pos++;
4242 }
4243 }
4244 }
4245
4246 MSVCRT__unlock_file(file);
4247 return pos;
4248 }
4249
4250 /*********************************************************************
4251 * ftell (MSVCRT.@)
4252 */
4253 LONG CDECL MSVCRT_ftell(MSVCRT_FILE* file)
4254 {
4255 return MSVCRT__ftelli64(file);
4256 }
4257
4258 /*********************************************************************
4259 * fgetpos (MSVCRT.@)
4260 */
4261 int CDECL MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
4262 {
4263 *pos = MSVCRT__ftelli64(file);
4264 if(*pos == -1)
4265 return -1;
4266 return 0;
4267 }
4268
4269 /*********************************************************************
4270 * fputs (MSVCRT.@)
4271 */
4272 int CDECL MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
4273 {
4274 MSVCRT_size_t len = strlen(s);
4275 int ret;
4276
4277 MSVCRT__lock_file(file);
4278 ret = MSVCRT_fwrite(s, sizeof(*s), len, file) == len ? 0 : MSVCRT_EOF;
4279 MSVCRT__unlock_file(file);
4280 return ret;
4281 }
4282
4283 /*********************************************************************
4284 * fputws (MSVCRT.@)
4285 */
4286 int CDECL MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
4287 {
4288 MSVCRT_size_t i, len = strlenW(s);
4289 BOOL tmp_buf;
4290 int ret;
4291
4292 MSVCRT__lock_file(file);
4293 if (!(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT)) {
4294 ret = MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
4295 MSVCRT__unlock_file(file);
4296 return ret;
4297 }
4298
4299 tmp_buf = add_std_buffer(file);
4300 for (i=0; i<len; i++) {
4301 if(MSVCRT_fputwc(s[i], file) == MSVCRT_WEOF) {
4302 if(tmp_buf) remove_std_buffer(file);
4303 MSVCRT__unlock_file(file);
4304 return MSVCRT_WEOF;
4305 }
4306 }
4307
4308 if(tmp_buf) remove_std_buffer(file);
4309 MSVCRT__unlock_file(file);
4310 return 0;
4311 }
4312
4313 /*********************************************************************
4314 * getchar (MSVCRT.@)
4315 */
4316 int CDECL MSVCRT_getchar(void)
4317 {
4318 return MSVCRT_fgetc(MSVCRT_stdin);
4319 }
4320
4321 /*********************************************************************
4322 * getc (MSVCRT.@)
4323 */
4324 int CDECL MSVCRT_getc(MSVCRT_FILE* file)
4325 {
4326 return MSVCRT_fgetc(file);
4327 }
4328
4329 /*********************************************************************
4330 * gets (MSVCRT.@)
4331 */
4332 char * CDECL MSVCRT_gets(char *buf)
4333 {
4334 int cc;
4335 char * buf_start = buf;
4336
4337 MSVCRT__lock_file(MSVCRT_stdin);
4338 for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
4339 cc = MSVCRT_fgetc(MSVCRT_stdin))
4340 if(cc != '\r') *buf++ = (char)cc;
4341
4342 *buf = '\0';
4343
4344 TRACE("got '%s'\n", buf_start);
4345 MSVCRT__unlock_file(MSVCRT_stdin);
4346 return buf_start;
4347 }
4348
4349 /*********************************************************************
4350 * _getws (MSVCRT.@)
4351 */
4352 MSVCRT_wchar_t* CDECL MSVCRT__getws(MSVCRT_wchar_t* buf)
4353 {
4354 MSVCRT_wint_t cc;
4355 MSVCRT_wchar_t* ws = buf;
4356
4357 MSVCRT__lock_file(MSVCRT_stdin);
4358 for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
4359 cc = MSVCRT_fgetwc(MSVCRT_stdin))
4360 {
4361 if (cc != '\r')
4362 *buf++ = (MSVCRT_wchar_t)cc;
4363 }
4364 *buf = '\0';
4365
4366 TRACE("got %s\n", debugstr_w(ws));
4367 MSVCRT__unlock_file(MSVCRT_stdin);
4368 return ws;
4369 }
4370
4371 /*********************************************************************
4372 * putc (MSVCRT.@)
4373 */
4374 int CDECL MSVCRT_putc(int c, MSVCRT_FILE* file)
4375 {
4376 return MSVCRT_fputc(c, file);
4377 }
4378
4379 /*********************************************************************
4380 * putchar (MSVCRT.@)
4381 */
4382 int CDECL MSVCRT_putchar(int c)
4383 {
4384 return MSVCRT_fputc(c, MSVCRT_stdout);
4385 }
4386
4387 /*********************************************************************
4388 * _putwch (MSVCRT.@)
4389 */
4390 int CDECL MSVCRT__putwch(int c)
4391 {
4392 return MSVCRT_fputwc(c, MSVCRT_stdout);
4393 }
4394
4395 /*********************************************************************
4396 * puts (MSVCRT.@)
4397 */
4398 int CDECL MSVCRT_puts(const char *s)
4399 {
4400 MSVCRT_size_t len = strlen(s);
4401 int ret;
4402
4403 MSVCRT__lock_file(MSVCRT_stdout);
4404 if(MSVCRT_fwrite(s, sizeof(*s), len, MSVCRT_stdout) != len) {
4405 MSVCRT__unlock_file(MSVCRT_stdout);
4406 return MSVCRT_EOF;
4407 }
4408
4409 ret = MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
4410 MSVCRT__unlock_file(MSVCRT_stdout);
4411 return ret;
4412 }
4413
4414 /*********************************************************************
4415 * _putws (MSVCRT.@)
4416 */
4417 int CDECL MSVCRT__putws(const MSVCRT_wchar_t *s)
4418 {
4419 static const MSVCRT_wchar_t nl = '\n';
4420 MSVCRT_size_t len = strlenW(s);
4421 int ret;
4422
4423 MSVCRT__lock_file(MSVCRT_stdout);
4424 if(MSVCRT_fwrite(s, sizeof(*s), len, MSVCRT_stdout) != len) {
4425 MSVCRT__unlock_file(MSVCRT_stdout);
4426 return MSVCRT_EOF;
4427 }
4428
4429 ret = MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
4430 MSVCRT__unlock_file(MSVCRT_stdout);
4431 return ret;
4432 }
4433
4434 /*********************************************************************
4435 * remove (MSVCRT.@)
4436 */
4437 int CDECL MSVCRT_remove(const char *path)
4438 {
4439 TRACE("(%s)\n",path);
4440 if (DeleteFileA(path))
4441 return 0;
4442 TRACE(":failed (%d)\n",GetLastError());
4443 msvcrt_set_errno(GetLastError());
4444 return -1;
4445 }
4446
4447 /*********************************************************************
4448 * _wremove (MSVCRT.@)
4449 */
4450 int CDECL MSVCRT__wremove(const MSVCRT_wchar_t *path)
4451 {
4452 TRACE("(%s)\n",debugstr_w(path));
4453 if (DeleteFileW(path))
4454 return 0;
4455 TRACE(":failed (%d)\n",GetLastError());
4456 msvcrt_set_errno(GetLastError());
4457 return -1;
4458 }
4459
4460 /*********************************************************************
4461 * rename (MSVCRT.@)
4462 */
4463 int CDECL MSVCRT_rename(const char *oldpath,const char *newpath)
4464 {
4465 TRACE(":from %s to %s\n",oldpath,newpath);
4466 if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4467 return 0;
4468 TRACE(":failed (%d)\n",GetLastError());
4469 msvcrt_set_errno(GetLastError());
4470 return -1;
4471 }
4472
4473 /*********************************************************************
4474 * _wrename (MSVCRT.@)
4475 */
4476 int CDECL MSVCRT__wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
4477 {
4478 TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
4479 if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
4480 return 0;
4481 TRACE(":failed (%d)\n",GetLastError());
4482 msvcrt_set_errno(GetLastError());
4483 return -1;
4484 }
4485
4486 /*********************************************************************
4487 * setvbuf (MSVCRT.@)
4488 */
4489 int CDECL MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
4490 {
4491 if(!MSVCRT_CHECK_PMT(file != NULL)) return -1;
4492 if(!MSVCRT_CHECK_PMT(mode==MSVCRT__IONBF || mode==MSVCRT__IOFBF || mode==MSVCRT__IOLBF)) return -1;
4493 if(!MSVCRT_CHECK_PMT(mode==MSVCRT__IONBF || (size>=2 && size<=INT_MAX))) return -1;
4494
4495 MSVCRT__lock_file(file);
4496
4497 MSVCRT_fflush(file);
4498 if(file->_flag & MSVCRT__IOMYBUF)
4499 MSVCRT_free(file->_base);
4500 file->_flag &= ~(MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF);
4501 file->_cnt = 0;
4502
4503 if(mode == MSVCRT__IONBF) {
4504 file->_flag |= MSVCRT__IONBF;
4505 file->_base = file->_ptr = (char*)&file->_charbuf;
4506 file->_bufsiz = 2;
4507 }else if(buf) {
4508 file->_base = file->_ptr = buf;
4509 file->_flag |= MSVCRT__USERBUF;
4510 file->_bufsiz = size;
4511 }else {
4512 file->_base = file->_ptr = MSVCRT_malloc(size);
4513 if(!file->_base) {
4514 file->_bufsiz = 0;
4515 MSVCRT__unlock_file(file);
4516 return -1;
4517 }
4518
4519 file->_flag |= MSVCRT__IOMYBUF;
4520 file->_bufsiz = size;
4521 }
4522 MSVCRT__unlock_file(file);
4523 return 0;
4524 }
4525
4526 /*********************************************************************
4527 * setbuf (MSVCRT.@)
4528 */
4529 void CDECL MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
4530 {
4531 MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
4532 }
4533
4534 /*********************************************************************
4535 * tmpnam (MSVCRT.@)
4536 */
4537 char * CDECL MSVCRT_tmpnam(char *s)
4538 {
4539 char tmpstr[16];
4540 char *p;
4541 int count, size;
4542
4543 if (!s) {
4544 thread_data_t *data = msvcrt_get_thread_data();
4545
4546 if(!data->tmpnam_buffer)
4547 data->tmpnam_buffer = MSVCRT_malloc(MAX_PATH);
4548
4549 s = data->tmpnam_buffer;
4550 }
4551
4552 msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
4553 p = s + sprintf(s, "\\s%s.", tmpstr);
4554 for (count = 0; count < MSVCRT_TMP_MAX; count++)
4555 {
4556 size = msvcrt_int_to_base32(tmpnam_unique++, tmpstr);
4557 memcpy(p, tmpstr, size);
4558 p[size] = '\0';
4559 if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
4560 GetLastError() == ERROR_FILE_NOT_FOUND)
4561 break;
4562 }
4563 return s;
4564 }
4565
4566 /*********************************************************************
4567 * _wtmpnam (MSVCRT.@)
4568 */
4569 MSVCRT_wchar_t * CDECL MSVCRT_wtmpnam(MSVCRT_wchar_t *s)
4570 {
4571 static const MSVCRT_wchar_t format[] = {'\\','s','%','s','.',0};
4572 MSVCRT_wchar_t tmpstr[16];
4573 MSVCRT_wchar_t *p;
4574 int count, size;
4575 if (!s) {
4576 thread_data_t *data = msvcrt_get_thread_data();
4577
4578 if(!data->wtmpnam_buffer)
4579 data->wtmpnam_buffer = MSVCRT_malloc(sizeof(MSVCRT_wchar_t[MAX_PATH]));
4580
4581 s = data->wtmpnam_buffer;
4582 }
4583
4584 msvcrt_int_to_base32_w(GetCurrentProcessId(), tmpstr);
4585 p = s + MSVCRT__snwprintf(s, MAX_PATH, format, tmpstr);
4586 for (count = 0; count < MSVCRT_TMP_MAX; count++)
4587 {
4588 size = msvcrt_int_to_base32_w(tmpnam_unique++, tmpstr);
4589 memcpy(p, tmpstr, size*sizeof(MSVCRT_wchar_t));
4590 p[size] = '\0';
4591 if (GetFileAttributesW(s) == INVALID_FILE_ATTRIBUTES &&
4592 GetLastError() == ERROR_FILE_NOT_FOUND)
4593 break;
4594 }
4595 return s;
4596 }
4597
4598 /*********************************************************************
4599 * tmpfile (MSVCRT.@)
4600 */
4601 MSVCRT_FILE* CDECL MSVCRT_tmpfile(void)
4602 {
4603 char *filename = MSVCRT_tmpnam(NULL);
4604 int fd;
4605 MSVCRT_FILE* file = NULL;
4606
4607 LOCK_FILES();
4608 fd = MSVCRT__open(filename, MSVCRT__O_CREAT | MSVCRT__O_BINARY | MSVCRT__O_RDWR | MSVCRT__O_TEMPORARY,
4609 MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
4610 if (fd != -1 && (file = msvcrt_alloc_fp()))
4611 {
4612 if (msvcrt_init_fp(file, fd, MSVCRT__IORW) == -1)
4613 {
4614 file->_flag = 0;
4615 file = NULL;
4616 }
4617 else file->_tmpfname = MSVCRT__strdup(filename);
4618 }
4619
4620 if(fd != -1 && !file)
4621 MSVCRT__close(fd);
4622 UNLOCK_FILES();
4623 return file;
4624 }
4625
4626 /*********************************************************************
4627 * tmpfile_s (MSVCRT.@)
4628 */
4629 int CDECL MSVCRT_tmpfile_s(MSVCRT_FILE** file)
4630 {
4631 if (!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EINVAL;
4632
4633 *file = MSVCRT_tmpfile();
4634 return 0;
4635 }
4636
4637 static int puts_clbk_file_a(void *file, int len, const char *str)
4638 {
4639 return MSVCRT_fwrite(str, sizeof(char), len, file);
4640 }
4641
4642 static int puts_clbk_file_w(void *file, int len, const MSVCRT_wchar_t *str)
4643 {
4644 int i, ret;
4645
4646 MSVCRT__lock_file(file);
4647
4648 if(!(msvcrt_get_ioinfo(((MSVCRT_FILE*)file)->_file)->wxflag & WX_TEXT)) {
4649 ret = MSVCRT_fwrite(str, sizeof(MSVCRT_wchar_t), len, file);
4650 MSVCRT__unlock_file(file);
4651 return ret;
4652 }
4653
4654 for(i=0; i<len; i++) {
4655 if(MSVCRT_fputwc(str[i], file) == MSVCRT_WEOF) {
4656 MSVCRT__unlock_file(file);
4657 return -1;
4658 }
4659 }
4660
4661 MSVCRT__unlock_file(file);
4662 return len;
4663 }
4664
4665 /*********************************************************************
4666 * vfprintf (MSVCRT.@)
4667 */
4668 int CDECL MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, __ms_va_list valist)
4669 {
4670 BOOL tmp_buf;
4671 int ret;
4672
4673 MSVCRT__lock_file(file);
4674 tmp_buf = add_std_buffer(file);
4675 ret = pf_printf_a(puts_clbk_file_a, file, format, NULL, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4676 if(tmp_buf) remove_std_buffer(file);
4677 MSVCRT__unlock_file(file);
4678
4679 return ret;
4680 }
4681
4682 /*********************************************************************
4683 * vfprintf_s (MSVCRT.@)
4684 */
4685 int CDECL MSVCRT_vfprintf_s(MSVCRT_FILE* file, const char *format, __ms_va_list valist)
4686 {
4687 BOOL tmp_buf;
4688 int ret;
4689
4690 if(!MSVCRT_CHECK_PMT(file != NULL)) return -1;
4691
4692 MSVCRT__lock_file(file);
4693 tmp_buf = add_std_buffer(file);
4694 ret = pf_printf_a(puts_clbk_file_a, file, format, NULL, FALSE, TRUE, arg_clbk_valist, NULL, &valist);
4695 if(tmp_buf) remove_std_buffer(file);
4696 MSVCRT__unlock_file(file);
4697
4698 return ret;
4699 }
4700
4701 /*********************************************************************
4702 * vfwprintf (MSVCRT.@)
4703 */
4704 int CDECL MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, __ms_va_list valist)
4705 {
4706 BOOL tmp_buf;
4707 int ret;
4708
4709 MSVCRT__lock_file(file);
4710 tmp_buf = add_std_buffer(file);
4711 ret = pf_printf_w(puts_clbk_file_w, file, format, NULL, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4712 if(tmp_buf) remove_std_buffer(file);
4713 MSVCRT__unlock_file(file);
4714
4715 return ret;
4716 }
4717
4718 /*********************************************************************
4719 * vfwprintf_s (MSVCRT.@)
4720 */
4721 int CDECL MSVCRT_vfwprintf_s(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, __ms_va_list valist)
4722 {
4723 BOOL tmp_buf;
4724 int ret;
4725
4726 if (!MSVCRT_CHECK_PMT( file != NULL )) return -1;
4727
4728 MSVCRT__lock_file(file);
4729 tmp_buf = add_std_buffer(file);
4730 ret = pf_printf_w(puts_clbk_file_w, file, format, NULL, FALSE, TRUE, arg_clbk_valist, NULL, &valist);
4731 if(tmp_buf) remove_std_buffer(file);
4732 MSVCRT__unlock_file(file);
4733
4734 return ret;
4735 }
4736
4737 /*********************************************************************
4738 * _vfwprintf_l (MSVCRT.@)
4739 */
4740 int CDECL MSVCRT__vfwprintf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format,
4741 MSVCRT__locale_t locale, __ms_va_list valist)
4742 {
4743 BOOL tmp_buf;
4744 int ret;
4745
4746 if (!MSVCRT_CHECK_PMT( file != NULL )) return -1;
4747
4748 MSVCRT__lock_file(file);
4749 tmp_buf = add_std_buffer(file);
4750 ret = pf_printf_w(puts_clbk_file_w, file, format, locale, FALSE, FALSE, arg_clbk_valist, NULL, &valist);
4751 if(tmp_buf) remove_std_buffer(file);
4752 MSVCRT__unlock_file(file);
4753
4754 return ret;
4755 }
4756
4757 /*********************************************************************
4758 * vprintf (MSVCRT.@)
4759 */
4760 int CDECL MSVCRT_vprintf(const char *format, __ms_va_list valist)
4761 {
4762 return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
4763 }
4764
4765 /*********************************************************************
4766 * vprintf_s (MSVCRT.@)
4767 */
4768 int CDECL MSVCRT_vprintf_s(const char *format, __ms_va_list valist)
4769 {
4770 return MSVCRT_vfprintf_s(MSVCRT_stdout,format,valist);
4771 }
4772
4773 /*********************************************************************
4774 * vwprintf (MSVCRT.@)
4775 */
4776 int CDECL MSVCRT_vwprintf(const MSVCRT_wchar_t *format, __ms_va_list valist)
4777 {
4778 return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
4779 }
4780
4781 /*********************************************************************
4782 * vwprintf_s (MSVCRT.@)
4783 */
4784 int CDECL MSVCRT_vwprintf_s(const MSVCRT_wchar_t *format, __ms_va_list valist)
4785 {
4786 return MSVCRT_vfwprintf_s(MSVCRT_stdout,format,valist);
4787 }
4788
4789 /*********************************************************************
4790 * fprintf (MSVCRT.@)
4791 */
4792 int CDECL MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
4793 {
4794 __ms_va_list valist;
4795 int res;
4796 __ms_va_start(valist, format);
4797 res = MSVCRT_vfprintf(file, format, valist);
4798 __ms_va_end(valist);
4799 return res;
4800 }
4801
4802 /*********************************************************************
4803 * fprintf_s (MSVCRT.@)
4804 */
4805 int CDECL MSVCRT_fprintf_s(MSVCRT_FILE* file, const char *format, ...)
4806 {
4807 __ms_va_list valist;
4808 int res;
4809 __ms_va_start(valist, format);
4810 res = MSVCRT_vfprintf_s(file, format, valist);
4811 __ms_va_end(valist);
4812 return res;
4813 }
4814
4815 /*********************************************************************
4816 * fwprintf (MSVCRT.@)
4817 */
4818 int CDECL MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
4819 {
4820 __ms_va_list valist;
4821 int res;
4822 __ms_va_start(valist, format);
4823 res = MSVCRT_vfwprintf(file, format, valist);
4824 __ms_va_end(valist);
4825 return res;
4826 }
4827
4828 /*********************************************************************
4829 * fwprintf_s (MSVCRT.@)
4830 */
4831 int CDECL MSVCRT_fwprintf_s(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
4832 {
4833 __ms_va_list valist;
4834 int res;
4835 __ms_va_start(valist, format);
4836 res = MSVCRT_vfwprintf_s(file, format, valist);
4837 __ms_va_end(valist);
4838 return res;
4839 }
4840
4841 /*********************************************************************
4842 * _fwprintf_l (MSVCRT.@)
4843 */
4844 int CDECL MSVCRT__fwprintf_l(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, MSVCRT__locale_t locale, ...)
4845 {
4846 __ms_va_list valist;
4847 int res;
4848 __ms_va_start(valist, locale);
4849 res = MSVCRT__vfwprintf_l(file, format, locale, valist);
4850 __ms_va_end(valist);
4851 return res;
4852 }
4853
4854 /*********************************************************************
4855 * printf (MSVCRT.@)
4856 */
4857 int CDECL MSVCRT_printf(const char *format, ...)
4858 {
4859 __ms_va_list valist;
4860 int res;
4861 __ms_va_start(valist, format);
4862 res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
4863 __ms_va_end(valist);
4864 return res;
4865 }
4866
4867 /*********************************************************************
4868 * printf_s (MSVCRT.@)
4869 */
4870 int CDECL MSVCRT_printf_s(const char *format, ...)
4871 {
4872 __ms_va_list valist;
4873 int res;
4874 __ms_va_start(valist, format);
4875 res = MSVCRT_vprintf_s(format, valist);
4876 __ms_va_end(valist);
4877 return res;
4878 }
4879
4880 /*********************************************************************
4881 * ungetc (MSVCRT.@)
4882 */
4883 int CDECL MSVCRT_ungetc(int c, MSVCRT_FILE * file)
4884 {
4885 if(!MSVCRT_CHECK_PMT(file != NULL)) return MSVCRT_EOF;
4886
4887 if (c == MSVCRT_EOF || !(file->_flag&MSVCRT__IOREAD ||
4888 (file->_flag&MSVCRT__IORW && !(file->_flag&MSVCRT__IOWRT))))
4889 return MSVCRT_EOF;
4890
4891 MSVCRT__lock_file(file);
4892 if((!(file->_flag & (MSVCRT__IONBF | MSVCRT__IOMYBUF | MSVCRT__USERBUF))
4893 && msvcrt_alloc_buffer(file))
4894 || (!file->_cnt && file->_ptr==file->_base))
4895 file->_ptr++;
4896
4897 if(file->_ptr>file->_base) {
4898 file->_ptr--;
4899 if(file->_flag & MSVCRT__IOSTRG) {
4900 if(*file->_ptr != c) {
4901 file->_ptr++;
4902 MSVCRT__unlock_file(file);
4903 return MSVCRT_EOF;
4904 }
4905 }else {
4906 *file->_ptr = c;
4907 }
4908 file->_cnt++;
4909 MSVCRT_clearerr(file);
4910 file->_flag |= MSVCRT__IOREAD;
4911 MSVCRT__unlock_file(file);
4912 return c;
4913 }
4914
4915 MSVCRT__unlock_file(file);
4916 return MSVCRT_EOF;
4917 }
4918
4919 /*********************************************************************
4920 * ungetwc (MSVCRT.@)
4921 */
4922 MSVCRT_wint_t CDECL MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
4923 {
4924 MSVCRT_wchar_t mwc = wc;
4925
4926 if (wc == MSVCRT_WEOF)
4927 return MSVCRT_WEOF;
4928
4929 MSVCRT__lock_file(file);
4930
4931 if((msvcrt_get_ioinfo(file->_file)->exflag & (EF_UTF8 | EF_UTF16))
4932 || !(msvcrt_get_ioinfo(file->_file)->wxflag & WX_TEXT)) {
4933 unsigned char * pp = (unsigned char *)&mwc;
4934 int i;
4935
4936 for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
4937 if(pp[i] != MSVCRT_ungetc(pp[i],file)) {
4938 MSVCRT__unlock_file(file);
4939 return MSVCRT_WEOF;
4940 }
4941 }
4942 }else {
4943 char mbs[MSVCRT_MB_LEN_MAX];
4944 int len;
4945
4946 len = MSVCRT_wctomb(mbs, mwc);
4947 if(len == -1) {
4948 MSVCRT__unlock_file(file);
4949 return MSVCRT_WEOF;
4950 }
4951
4952 for(len--; len>=0; len--) {
4953 if(mbs[len] != MSVCRT_ungetc(mbs[len], file)) {
4954 MSVCRT__unlock_file(file);
4955 return MSVCRT_WEOF;
4956 }
4957 }
4958 }
4959
4960 MSVCRT__unlock_file(file);
4961 return mwc;
4962 }
4963
4964 /*********************************************************************
4965 * wprintf (MSVCRT.@)
4966 */
4967 int CDECL MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
4968 {
4969 __ms_va_list valist;
4970 int res;
4971 __ms_va_start(valist, format);
4972 res = MSVCRT_vwprintf(format, valist);
4973 __ms_va_end(valist);
4974 return res;
4975 }
4976
4977 /*********************************************************************
4978 * wprintf_s (MSVCRT.@)
4979 */
4980 int CDECL MSVCRT_wprintf_s(const MSVCRT_wchar_t *format, ...)
4981 {
4982 __ms_va_list valist;
4983 int res;
4984 __ms_va_start(valist, format);
4985 res = MSVCRT_vwprintf_s(format, valist);
4986 __ms_va_end(valist);
4987 return res;
4988 }
4989
4990 /*********************************************************************
4991 * _getmaxstdio (MSVCRT.@)
4992 */
4993 int CDECL MSVCRT__getmaxstdio(void)
4994 {
4995 return MSVCRT_max_streams;
4996 }
4997
4998 /*********************************************************************
4999 * _setmaxstdio (MSVCRT.@)
5000 */
5001 int CDECL MSVCRT__setmaxstdio(int newmax)
5002 {
5003 TRACE("%d\n", newmax);
5004
5005 if(newmax<_IOB_ENTRIES || newmax>MSVCRT_MAX_FILES || newmax<MSVCRT_stream_idx)
5006 return -1;
5007
5008 MSVCRT_max_streams = newmax;
5009 return MSVCRT_max_streams;
5010 }
Maarten's multimedia branch