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