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