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