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