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