?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
msvcrt: Add stub functions _lock_file and _unlock_file.
[wine/multimedia.git] / dlls / msvcrt / file.c
blobc3dbafa3dd7e740afefb59f9c356eaa37c19d9a6
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 * _lock_file (MSVCRT.@)
876 */
877 void CDECL MSVCRT__lock_file(MSVCRT_FILE *file)
878 {
879 FIXME("(%p) stub\n",file);
880 }
881
882 /*********************************************************************
883 * _unlock_file (MSVCRT.@)
884 */
885 void CDECL MSVCRT__unlock_file(MSVCRT_FILE *file)
886 {
887 FIXME("(%p) stub\n",file);
888 }
889
890 /*********************************************************************
891 * _locking (MSVCRT.@)
892 *
893 * This is untested; the underlying LockFile doesn't work yet.
894 */
895 int CDECL MSVCRT__locking(int fd, int mode, LONG nbytes)
896 {
897 BOOL ret;
898 DWORD cur_locn;
899 HANDLE hand = msvcrt_fdtoh(fd);
900
901 TRACE(":fd (%d) handle (%p)\n",fd,hand);
902 if (hand == INVALID_HANDLE_VALUE)
903 return -1;
904
905 if (mode < 0 || mode > 4)
906 {
907 *MSVCRT__errno() = MSVCRT_EINVAL;
908 return -1;
909 }
910
911 TRACE(":fd (%d) by 0x%08x mode %s\n",
912 fd,nbytes,(mode==MSVCRT__LK_UNLCK)?"_LK_UNLCK":
913 (mode==MSVCRT__LK_LOCK)?"_LK_LOCK":
914 (mode==MSVCRT__LK_NBLCK)?"_LK_NBLCK":
915 (mode==MSVCRT__LK_RLCK)?"_LK_RLCK":
916 (mode==MSVCRT__LK_NBRLCK)?"_LK_NBRLCK":
917 "UNKNOWN");
918
919 if ((cur_locn = SetFilePointer(hand, 0L, NULL, SEEK_CUR)) == INVALID_SET_FILE_POINTER)
920 {
921 FIXME ("Seek failed\n");
922 *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
923 return -1;
924 }
925 if (mode == MSVCRT__LK_LOCK || mode == MSVCRT__LK_RLCK)
926 {
927 int nretry = 10;
928 ret = 1; /* just to satisfy gcc */
929 while (nretry--)
930 {
931 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
932 if (ret) break;
933 Sleep(1);
934 }
935 }
936 else if (mode == MSVCRT__LK_UNLCK)
937 ret = UnlockFile(hand, cur_locn, 0L, nbytes, 0L);
938 else
939 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
940 /* FIXME - what about error settings? */
941 return ret ? 0 : -1;
942 }
943
944 /*********************************************************************
945 * fseek (MSVCRT.@)
946 */
947 int CDECL MSVCRT_fseek(MSVCRT_FILE* file, MSVCRT_long offset, int whence)
948 {
949 /* Flush output if needed */
950 if(file->_flag & MSVCRT__IOWRT)
951 msvcrt_flush_buffer(file);
952
953 if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
954 offset -= file->_cnt;
955 if (MSVCRT_fdesc[file->_file].wxflag & WX_TEXT) {
956 /* Black magic correction for CR removal */
957 int i;
958 for (i=0; i<file->_cnt; i++) {
959 if (file->_ptr[i] == '\n')
960 offset--;
961 }
962 /* Black magic when reading CR at buffer boundary*/
963 if(MSVCRT_fdesc[file->_file].wxflag & WX_READCR)
964 offset--;
965 }
966 }
967 /* Discard buffered input */
968 file->_cnt = 0;
969 file->_ptr = file->_base;
970 /* Reset direction of i/o */
971 if(file->_flag & MSVCRT__IORW) {
972 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
973 }
974 /* Clear end of file flag */
975 file->_flag &= ~MSVCRT__IOEOF;
976 return (MSVCRT__lseek(file->_file,offset,whence) == -1)?-1:0;
977 }
978
979 /*********************************************************************
980 * _chsize (MSVCRT.@)
981 */
982 int CDECL MSVCRT__chsize(int fd, MSVCRT_long size)
983 {
984 LONG cur, pos;
985 HANDLE handle;
986 BOOL ret = FALSE;
987
988 TRACE("(fd=%d, size=%d)\n", fd, size);
989
990 LOCK_FILES();
991
992 handle = msvcrt_fdtoh(fd);
993 if (handle != INVALID_HANDLE_VALUE)
994 {
995 /* save the current file pointer */
996 cur = MSVCRT__lseek(fd, 0, SEEK_CUR);
997 if (cur >= 0)
998 {
999 pos = MSVCRT__lseek(fd, size, SEEK_SET);
1000 if (pos >= 0)
1001 {
1002 ret = SetEndOfFile(handle);
1003 if (!ret) msvcrt_set_errno(GetLastError());
1004 }
1005
1006 /* restore the file pointer */
1007 MSVCRT__lseek(fd, cur, SEEK_SET);
1008 }
1009 }
1010
1011 UNLOCK_FILES();
1012 return ret ? 0 : -1;
1013 }
1014
1015 /*********************************************************************
1016 * clearerr (MSVCRT.@)
1017 */
1018 void CDECL MSVCRT_clearerr(MSVCRT_FILE* file)
1019 {
1020 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1021 file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
1022 }
1023
1024 /*********************************************************************
1025 * rewind (MSVCRT.@)
1026 */
1027 void CDECL MSVCRT_rewind(MSVCRT_FILE* file)
1028 {
1029 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1030 MSVCRT_fseek(file, 0L, SEEK_SET);
1031 MSVCRT_clearerr(file);
1032 }
1033
1034 static int msvcrt_get_flags(const MSVCRT_wchar_t* mode, int *open_flags, int* stream_flags)
1035 {
1036 int plus = strchrW(mode, '+') != NULL;
1037
1038 switch(*mode++)
1039 {
1040 case 'R': case 'r':
1041 *open_flags = plus ? MSVCRT__O_RDWR : MSVCRT__O_RDONLY;
1042 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOREAD;
1043 break;
1044 case 'W': case 'w':
1045 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_TRUNC | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1046 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1047 break;
1048 case 'A': case 'a':
1049 *open_flags = MSVCRT__O_CREAT | MSVCRT__O_APPEND | (plus ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
1050 *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
1051 break;
1052 default:
1053 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
1054 *MSVCRT__errno() = MSVCRT_EINVAL;
1055 return -1;
1056 }
1057
1058 while (*mode)
1059 switch (*mode++)
1060 {
1061 case 'B': case 'b':
1062 *open_flags |= MSVCRT__O_BINARY;
1063 *open_flags &= ~MSVCRT__O_TEXT;
1064 break;
1065 case 'T': case 't':
1066 *open_flags |= MSVCRT__O_TEXT;
1067 *open_flags &= ~MSVCRT__O_BINARY;
1068 break;
1069 case '+':
1070 case ' ':
1071 break;
1072 default:
1073 FIXME(":unknown flag %c not supported\n",mode[-1]);
1074 }
1075 return 0;
1076 }
1077
1078 /*********************************************************************
1079 * _fdopen (MSVCRT.@)
1080 */
1081 MSVCRT_FILE* CDECL MSVCRT__fdopen(int fd, const char *mode)
1082 {
1083 MSVCRT_FILE *ret;
1084 MSVCRT_wchar_t *modeW = NULL;
1085
1086 if (mode && !(modeW = msvcrt_wstrdupa(mode))) return NULL;
1087
1088 ret = MSVCRT__wfdopen(fd, modeW);
1089
1090 MSVCRT_free(modeW);
1091 return ret;
1092 }
1093
1094 /*********************************************************************
1095 * _wfdopen (MSVCRT.@)
1096 */
1097 MSVCRT_FILE* CDECL MSVCRT__wfdopen(int fd, const MSVCRT_wchar_t *mode)
1098 {
1099 int open_flags, stream_flags;
1100 MSVCRT_FILE* file;
1101
1102 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
1103
1104 LOCK_FILES();
1105 if (!(file = msvcrt_alloc_fp()))
1106 file = NULL;
1107 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
1108 {
1109 file->_flag = 0;
1110 file = NULL;
1111 }
1112 else TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
1113 UNLOCK_FILES();
1114
1115 return file;
1116 }
1117
1118 /*********************************************************************
1119 * _filelength (MSVCRT.@)
1120 */
1121 LONG CDECL MSVCRT__filelength(int fd)
1122 {
1123 LONG curPos = MSVCRT__lseek(fd, 0, SEEK_CUR);
1124 if (curPos != -1)
1125 {
1126 LONG endPos = MSVCRT__lseek(fd, 0, SEEK_END);
1127 if (endPos != -1)
1128 {
1129 if (endPos != curPos)
1130 MSVCRT__lseek(fd, curPos, SEEK_SET);
1131 return endPos;
1132 }
1133 }
1134 return -1;
1135 }
1136
1137 /*********************************************************************
1138 * _filelengthi64 (MSVCRT.@)
1139 */
1140 __int64 CDECL MSVCRT__filelengthi64(int fd)
1141 {
1142 __int64 curPos = MSVCRT__lseeki64(fd, 0, SEEK_CUR);
1143 if (curPos != -1)
1144 {
1145 __int64 endPos = MSVCRT__lseeki64(fd, 0, SEEK_END);
1146 if (endPos != -1)
1147 {
1148 if (endPos != curPos)
1149 MSVCRT__lseeki64(fd, curPos, SEEK_SET);
1150 return endPos;
1151 }
1152 }
1153 return -1;
1154 }
1155
1156 /*********************************************************************
1157 * _fileno (MSVCRT.@)
1158 */
1159 int CDECL MSVCRT__fileno(MSVCRT_FILE* file)
1160 {
1161 TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
1162 return file->_file;
1163 }
1164
1165 /*********************************************************************
1166 * _fstat64 (MSVCRT.@)
1167 */
1168 int CDECL MSVCRT__fstat64(int fd, struct MSVCRT__stat64* buf)
1169 {
1170 DWORD dw;
1171 DWORD type;
1172 BY_HANDLE_FILE_INFORMATION hfi;
1173 HANDLE hand = msvcrt_fdtoh(fd);
1174
1175 TRACE(":fd (%d) stat (%p)\n",fd,buf);
1176 if (hand == INVALID_HANDLE_VALUE)
1177 return -1;
1178
1179 if (!buf)
1180 {
1181 WARN(":failed-NULL buf\n");
1182 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1183 return -1;
1184 }
1185
1186 memset(&hfi, 0, sizeof(hfi));
1187 memset(buf, 0, sizeof(struct MSVCRT__stat64));
1188 type = GetFileType(hand);
1189 if (type == FILE_TYPE_PIPE)
1190 {
1191 buf->st_dev = buf->st_rdev = fd;
1192 buf->st_mode = S_IFIFO;
1193 buf->st_nlink = 1;
1194 }
1195 else if (type == FILE_TYPE_CHAR)
1196 {
1197 buf->st_dev = buf->st_rdev = fd;
1198 buf->st_mode = S_IFCHR;
1199 buf->st_nlink = 1;
1200 }
1201 else /* FILE_TYPE_DISK etc. */
1202 {
1203 if (!GetFileInformationByHandle(hand, &hfi))
1204 {
1205 WARN(":failed-last error (%d)\n",GetLastError());
1206 msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1207 return -1;
1208 }
1209 buf->st_mode = S_IFREG | 0444;
1210 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1211 buf->st_mode |= 0222;
1212 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1213 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1214 buf->st_atime = dw;
1215 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1216 buf->st_mtime = buf->st_ctime = dw;
1217 buf->st_nlink = hfi.nNumberOfLinks;
1218 }
1219 TRACE(":dwFileAttributes = 0x%x, mode set to 0x%x\n",hfi.dwFileAttributes,
1220 buf->st_mode);
1221 return 0;
1222 }
1223
1224 /*********************************************************************
1225 * _fstati64 (MSVCRT.@)
1226 */
1227 int CDECL MSVCRT__fstati64(int fd, struct MSVCRT__stati64* buf)
1228 {
1229 int ret;
1230 struct MSVCRT__stat64 buf64;
1231
1232 ret = MSVCRT__fstat64(fd, &buf64);
1233 if (!ret)
1234 msvcrt_stat64_to_stati64(&buf64, buf);
1235 return ret;
1236 }
1237
1238 /*********************************************************************
1239 * _fstat (MSVCRT.@)
1240 */
1241 int CDECL MSVCRT__fstat(int fd, struct MSVCRT__stat* buf)
1242 { int ret;
1243 struct MSVCRT__stat64 buf64;
1244
1245 ret = MSVCRT__fstat64(fd, &buf64);
1246 if (!ret)
1247 msvcrt_stat64_to_stat(&buf64, buf);
1248 return ret;
1249 }
1250
1251 /*********************************************************************
1252 * _futime64 (MSVCRT.@)
1253 */
1254 int CDECL _futime64(int fd, struct MSVCRT___utimbuf64 *t)
1255 {
1256 HANDLE hand = msvcrt_fdtoh(fd);
1257 FILETIME at, wt;
1258
1259 if (!t)
1260 {
1261 time_to_filetime( MSVCRT__time64(NULL), &at );
1262 wt = at;
1263 }
1264 else
1265 {
1266 time_to_filetime( t->actime, &at );
1267 time_to_filetime( t->modtime, &wt );
1268 }
1269
1270 if (!SetFileTime(hand, NULL, &at, &wt))
1271 {
1272 msvcrt_set_errno(GetLastError());
1273 return -1 ;
1274 }
1275 return 0;
1276 }
1277
1278 /*********************************************************************
1279 * _futime32 (MSVCRT.@)
1280 */
1281 int CDECL _futime32(int fd, struct MSVCRT___utimbuf32 *t)
1282 {
1283 struct MSVCRT___utimbuf64 t64;
1284 t64.actime = t->actime;
1285 t64.modtime = t->modtime;
1286 return _futime64( fd, &t64 );
1287 }
1288
1289 /*********************************************************************
1290 * _futime (MSVCRT.@)
1291 */
1292 #ifdef _WIN64
1293 int CDECL _futime(int fd, struct MSVCRT___utimbuf64 *t)
1294 {
1295 return _futime64( fd, t );
1296 }
1297 #else
1298 int CDECL _futime(int fd, struct MSVCRT___utimbuf32 *t)
1299 {
1300 return _futime32( fd, t );
1301 }
1302 #endif
1303
1304 /*********************************************************************
1305 * _get_osfhandle (MSVCRT.@)
1306 */
1307 MSVCRT_intptr_t CDECL _get_osfhandle(int fd)
1308 {
1309 HANDLE hand = msvcrt_fdtoh(fd);
1310 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1311
1312 return (MSVCRT_intptr_t)hand;
1313 }
1314
1315 /*********************************************************************
1316 * _isatty (MSVCRT.@)
1317 */
1318 int CDECL _isatty(int fd)
1319 {
1320 HANDLE hand = msvcrt_fdtoh(fd);
1321
1322 TRACE(":fd (%d) handle (%p)\n",fd,hand);
1323 if (hand == INVALID_HANDLE_VALUE)
1324 return 0;
1325
1326 return GetFileType(hand) == FILE_TYPE_CHAR? 1 : 0;
1327 }
1328
1329 /*********************************************************************
1330 * _mktemp (MSVCRT.@)
1331 */
1332 char * CDECL _mktemp(char *pattern)
1333 {
1334 int numX = 0;
1335 char *retVal = pattern;
1336 int id;
1337 char letter = 'a';
1338
1339 while(*pattern)
1340 numX = (*pattern++ == 'X')? numX + 1 : 0;
1341 if (numX < 5)
1342 return NULL;
1343 pattern--;
1344 id = GetCurrentProcessId();
1345 numX = 6;
1346 while(numX--)
1347 {
1348 int tempNum = id / 10;
1349 *pattern-- = id - (tempNum * 10) + '0';
1350 id = tempNum;
1351 }
1352 pattern++;
1353 do
1354 {
1355 *pattern = letter++;
1356 if (GetFileAttributesA(retVal) == INVALID_FILE_ATTRIBUTES &&
1357 GetLastError() == ERROR_FILE_NOT_FOUND)
1358 return retVal;
1359 } while(letter <= 'z');
1360 return NULL;
1361 }
1362
1363 /*********************************************************************
1364 * _wmktemp (MSVCRT.@)
1365 */
1366 MSVCRT_wchar_t * CDECL _wmktemp(MSVCRT_wchar_t *pattern)
1367 {
1368 int numX = 0;
1369 MSVCRT_wchar_t *retVal = pattern;
1370 int id;
1371 MSVCRT_wchar_t letter = 'a';
1372
1373 while(*pattern)
1374 numX = (*pattern++ == 'X')? numX + 1 : 0;
1375 if (numX < 5)
1376 return NULL;
1377 pattern--;
1378 id = GetCurrentProcessId();
1379 numX = 6;
1380 while(numX--)
1381 {
1382 int tempNum = id / 10;
1383 *pattern-- = id - (tempNum * 10) + '0';
1384 id = tempNum;
1385 }
1386 pattern++;
1387 do
1388 {
1389 if (GetFileAttributesW(retVal) == INVALID_FILE_ATTRIBUTES &&
1390 GetLastError() == ERROR_FILE_NOT_FOUND)
1391 return retVal;
1392 *pattern = letter++;
1393 } while(letter != '|');
1394 return NULL;
1395 }
1396
1397 static unsigned split_oflags(unsigned oflags)
1398 {
1399 int wxflags = 0;
1400 unsigned unsupp; /* until we support everything */
1401
1402 if (oflags & MSVCRT__O_APPEND) wxflags |= WX_APPEND;
1403 if (oflags & MSVCRT__O_BINARY) {/* Nothing to do */}
1404 else if (oflags & MSVCRT__O_TEXT) wxflags |= WX_TEXT;
1405 else if (*__p__fmode() & MSVCRT__O_BINARY) {/* Nothing to do */}
1406 else wxflags |= WX_TEXT; /* default to TEXT*/
1407 if (oflags & MSVCRT__O_NOINHERIT) wxflags |= WX_DONTINHERIT;
1408
1409 if ((unsupp = oflags & ~(
1410 MSVCRT__O_BINARY|MSVCRT__O_TEXT|MSVCRT__O_APPEND|
1411 MSVCRT__O_TRUNC|MSVCRT__O_EXCL|MSVCRT__O_CREAT|
1412 MSVCRT__O_RDWR|MSVCRT__O_WRONLY|MSVCRT__O_TEMPORARY|
1413 MSVCRT__O_NOINHERIT|
1414 MSVCRT__O_SEQUENTIAL|MSVCRT__O_RANDOM|MSVCRT__O_SHORT_LIVED
1415 )))
1416 ERR(":unsupported oflags 0x%04x\n",unsupp);
1417
1418 return wxflags;
1419 }
1420
1421 /*********************************************************************
1422 * _pipe (MSVCRT.@)
1423 */
1424 int CDECL MSVCRT__pipe(int *pfds, unsigned int psize, int textmode)
1425 {
1426 int ret = -1;
1427 SECURITY_ATTRIBUTES sa;
1428 HANDLE readHandle, writeHandle;
1429
1430 if (!pfds)
1431 {
1432 *MSVCRT__errno() = MSVCRT_EINVAL;
1433 return -1;
1434 }
1435
1436 sa.nLength = sizeof(SECURITY_ATTRIBUTES);
1437 sa.bInheritHandle = !(textmode & MSVCRT__O_NOINHERIT);
1438 sa.lpSecurityDescriptor = NULL;
1439 if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
1440 {
1441 unsigned int wxflags = split_oflags(textmode);
1442 int fd;
1443
1444 LOCK_FILES();
1445 fd = msvcrt_alloc_fd(readHandle, wxflags);
1446 if (fd != -1)
1447 {
1448 pfds[0] = fd;
1449 fd = msvcrt_alloc_fd(writeHandle, wxflags);
1450 if (fd != -1)
1451 {
1452 pfds[1] = fd;
1453 ret = 0;
1454 }
1455 else
1456 {
1457 MSVCRT__close(pfds[0]);
1458 CloseHandle(writeHandle);
1459 *MSVCRT__errno() = MSVCRT_EMFILE;
1460 }
1461 }
1462 else
1463 {
1464 CloseHandle(readHandle);
1465 CloseHandle(writeHandle);
1466 *MSVCRT__errno() = MSVCRT_EMFILE;
1467 }
1468 UNLOCK_FILES();
1469 }
1470 else
1471 msvcrt_set_errno(GetLastError());
1472
1473 return ret;
1474 }
1475
1476 /*********************************************************************
1477 * _sopen (MSVCRT.@)
1478 */
1479 int CDECL MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
1480 {
1481 __ms_va_list ap;
1482 int pmode;
1483 DWORD access = 0, creation = 0, attrib;
1484 DWORD sharing;
1485 int wxflag = 0, fd;
1486 HANDLE hand;
1487 SECURITY_ATTRIBUTES sa;
1488
1489
1490 TRACE(":file (%s) oflags: 0x%04x shflags: 0x%04x\n",
1491 path, oflags, shflags);
1492
1493 wxflag = split_oflags(oflags);
1494 switch (oflags & (MSVCRT__O_RDONLY | MSVCRT__O_WRONLY | MSVCRT__O_RDWR))
1495 {
1496 case MSVCRT__O_RDONLY: access |= GENERIC_READ; break;
1497 case MSVCRT__O_WRONLY: access |= GENERIC_WRITE; break;
1498 case MSVCRT__O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
1499 }
1500
1501 if (oflags & MSVCRT__O_CREAT)
1502 {
1503 __ms_va_start(ap, shflags);
1504 pmode = va_arg(ap, int);
1505 __ms_va_end(ap);
1506
1507 if(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))
1508 FIXME(": pmode 0x%04x ignored\n", pmode);
1509 else
1510 WARN(": pmode 0x%04x ignored\n", pmode);
1511
1512 if (oflags & MSVCRT__O_EXCL)
1513 creation = CREATE_NEW;
1514 else if (oflags & MSVCRT__O_TRUNC)
1515 creation = CREATE_ALWAYS;
1516 else
1517 creation = OPEN_ALWAYS;
1518 }
1519 else /* no MSVCRT__O_CREAT */
1520 {
1521 if (oflags & MSVCRT__O_TRUNC)
1522 creation = TRUNCATE_EXISTING;
1523 else
1524 creation = OPEN_EXISTING;
1525 }
1526
1527 switch( shflags )
1528 {
1529 case MSVCRT__SH_DENYRW:
1530 sharing = 0L;
1531 break;
1532 case MSVCRT__SH_DENYWR:
1533 sharing = FILE_SHARE_READ;
1534 break;
1535 case MSVCRT__SH_DENYRD:
1536 sharing = FILE_SHARE_WRITE;
1537 break;
1538 case MSVCRT__SH_DENYNO:
1539 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1540 break;
1541 default:
1542 ERR( "Unhandled shflags 0x%x\n", shflags );
1543 return -1;
1544 }
1545 attrib = FILE_ATTRIBUTE_NORMAL;
1546
1547 if (oflags & MSVCRT__O_TEMPORARY)
1548 {
1549 attrib |= FILE_FLAG_DELETE_ON_CLOSE;
1550 access |= DELETE;
1551 sharing |= FILE_SHARE_DELETE;
1552 }
1553
1554 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
1555 sa.lpSecurityDescriptor = NULL;
1556 sa.bInheritHandle = (oflags & MSVCRT__O_NOINHERIT) ? FALSE : TRUE;
1557
1558 hand = CreateFileA(path, access, sharing, &sa, creation, attrib, 0);
1559
1560 if (hand == INVALID_HANDLE_VALUE) {
1561 WARN(":failed-last error (%d)\n",GetLastError());
1562 msvcrt_set_errno(GetLastError());
1563 return -1;
1564 }
1565
1566 fd = msvcrt_alloc_fd(hand, wxflag);
1567
1568 TRACE(":fd (%d) handle (%p)\n",fd, hand);
1569 return fd;
1570 }
1571
1572 /*********************************************************************
1573 * _wsopen (MSVCRT.@)
1574 */
1575 int CDECL MSVCRT__wsopen( const MSVCRT_wchar_t* path, int oflags, int shflags, ... )
1576 {
1577 __ms_va_list ap;
1578 int pmode;
1579 DWORD access = 0, creation = 0, attrib;
1580 DWORD sharing;
1581 int wxflag = 0, fd;
1582 HANDLE hand;
1583 SECURITY_ATTRIBUTES sa;
1584
1585
1586 TRACE(":file (%s) oflags: 0x%04x shflags: 0x%04x\n",
1587 debugstr_w(path), oflags, shflags);
1588
1589 wxflag = split_oflags(oflags);
1590 switch (oflags & (MSVCRT__O_RDONLY | MSVCRT__O_WRONLY | MSVCRT__O_RDWR))
1591 {
1592 case MSVCRT__O_RDONLY: access |= GENERIC_READ; break;
1593 case MSVCRT__O_WRONLY: access |= GENERIC_WRITE; break;
1594 case MSVCRT__O_RDWR: access |= GENERIC_WRITE | GENERIC_READ; break;
1595 }
1596
1597 if (oflags & MSVCRT__O_CREAT)
1598 {
1599 __ms_va_start(ap, shflags);
1600 pmode = va_arg(ap, int);
1601 __ms_va_end(ap);
1602
1603 if(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))
1604 FIXME(": pmode 0x%04x ignored\n", pmode);
1605 else
1606 WARN(": pmode 0x%04x ignored\n", pmode);
1607
1608 if (oflags & MSVCRT__O_EXCL)
1609 creation = CREATE_NEW;
1610 else if (oflags & MSVCRT__O_TRUNC)
1611 creation = CREATE_ALWAYS;
1612 else
1613 creation = OPEN_ALWAYS;
1614 }
1615 else /* no MSVCRT__O_CREAT */
1616 {
1617 if (oflags & MSVCRT__O_TRUNC)
1618 creation = TRUNCATE_EXISTING;
1619 else
1620 creation = OPEN_EXISTING;
1621 }
1622
1623 switch( shflags )
1624 {
1625 case MSVCRT__SH_DENYRW:
1626 sharing = 0L;
1627 break;
1628 case MSVCRT__SH_DENYWR:
1629 sharing = FILE_SHARE_READ;
1630 break;
1631 case MSVCRT__SH_DENYRD:
1632 sharing = FILE_SHARE_WRITE;
1633 break;
1634 case MSVCRT__SH_DENYNO:
1635 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1636 break;
1637 default:
1638 ERR( "Unhandled shflags 0x%x\n", shflags );
1639 return -1;
1640 }
1641 attrib = FILE_ATTRIBUTE_NORMAL;
1642
1643 if (oflags & MSVCRT__O_TEMPORARY)
1644 {
1645 attrib |= FILE_FLAG_DELETE_ON_CLOSE;
1646 access |= DELETE;
1647 sharing |= FILE_SHARE_DELETE;
1648 }
1649
1650 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
1651 sa.lpSecurityDescriptor = NULL;
1652 sa.bInheritHandle = (oflags & MSVCRT__O_NOINHERIT) ? FALSE : TRUE;
1653
1654 hand = CreateFileW(path, access, sharing, &sa, creation, attrib, 0);
1655
1656 if (hand == INVALID_HANDLE_VALUE) {
1657 WARN(":failed-last error (%d)\n",GetLastError());
1658 msvcrt_set_errno(GetLastError());
1659 return -1;
1660 }
1661
1662 fd = msvcrt_alloc_fd(hand, wxflag);
1663
1664 TRACE(":fd (%d) handle (%p)\n",fd, hand);
1665 return fd;
1666 }
1667
1668 /*********************************************************************
1669 * _open (MSVCRT.@)
1670 */
1671 int CDECL MSVCRT__open( const char *path, int flags, ... )
1672 {
1673 __ms_va_list ap;
1674
1675 if (flags & MSVCRT__O_CREAT)
1676 {
1677 int pmode;
1678 __ms_va_start(ap, flags);
1679 pmode = va_arg(ap, int);
1680 __ms_va_end(ap);
1681 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO, pmode );
1682 }
1683 else
1684 return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO);
1685 }
1686
1687 /*********************************************************************
1688 * _wopen (MSVCRT.@)
1689 */
1690 int CDECL _wopen(const MSVCRT_wchar_t *path,int flags,...)
1691 {
1692 __ms_va_list ap;
1693
1694 if (flags & MSVCRT__O_CREAT)
1695 {
1696 int pmode;
1697 __ms_va_start(ap, flags);
1698 pmode = va_arg(ap, int);
1699 __ms_va_end(ap);
1700 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO, pmode );
1701 }
1702 else
1703 return MSVCRT__wsopen( path, flags, MSVCRT__SH_DENYNO);
1704 }
1705
1706 /*********************************************************************
1707 * _creat (MSVCRT.@)
1708 */
1709 int CDECL MSVCRT__creat(const char *path, int flags)
1710 {
1711 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
1712 return MSVCRT__open(path, usedFlags);
1713 }
1714
1715 /*********************************************************************
1716 * _wcreat (MSVCRT.@)
1717 */
1718 int CDECL _wcreat(const MSVCRT_wchar_t *path, int flags)
1719 {
1720 int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
1721 return _wopen(path, usedFlags);
1722 }
1723
1724 /*********************************************************************
1725 * _open_osfhandle (MSVCRT.@)
1726 */
1727 int CDECL _open_osfhandle(MSVCRT_intptr_t handle, int oflags)
1728 {
1729 int fd;
1730
1731 /* MSVCRT__O_RDONLY (0) always matches, so set the read flag
1732 * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
1733 * file, so set the write flag. It also only sets MSVCRT__O_TEXT if it wants
1734 * text - it never sets MSVCRT__O_BINARY.
1735 */
1736 /* don't let split_oflags() decide the mode if no mode is passed */
1737 if (!(oflags & (MSVCRT__O_BINARY | MSVCRT__O_TEXT)))
1738 oflags |= MSVCRT__O_BINARY;
1739
1740 fd = msvcrt_alloc_fd((HANDLE)handle, split_oflags(oflags));
1741 TRACE(":handle (%ld) fd (%d) flags 0x%08x\n", handle, fd, oflags);
1742 return fd;
1743 }
1744
1745 /*********************************************************************
1746 * _rmtmp (MSVCRT.@)
1747 */
1748 int CDECL _rmtmp(void)
1749 {
1750 int num_removed = 0, i;
1751
1752 LOCK_FILES();
1753 for (i = 3; i < MSVCRT_stream_idx; i++)
1754 if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_tmpfname)
1755 {
1756 MSVCRT_fclose(MSVCRT_fstreams[i]);
1757 num_removed++;
1758 }
1759 UNLOCK_FILES();
1760
1761 if (num_removed)
1762 TRACE(":removed (%d) temp files\n",num_removed);
1763 return num_removed;
1764 }
1765
1766 /*********************************************************************
1767 * (internal) read_i
1768 *
1769 * When reading \r as last character in text mode, read() positions
1770 * the file pointer on the \r character while getc() goes on to
1771 * the following \n
1772 */
1773 static int read_i(int fd, void *buf, unsigned int count)
1774 {
1775 DWORD num_read;
1776 char *bufstart = buf;
1777 HANDLE hand = msvcrt_fdtoh(fd);
1778
1779 if (count == 0)
1780 return 0;
1781
1782 if (MSVCRT_fdesc[fd].wxflag & WX_READEOF) {
1783 MSVCRT_fdesc[fd].wxflag |= WX_ATEOF;
1784 TRACE("already at EOF, returning 0\n");
1785 return 0;
1786 }
1787 /* Don't trace small reads, it gets *very* annoying */
1788 if (count > 4)
1789 TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n",fd,hand,buf,count);
1790 if (hand == INVALID_HANDLE_VALUE)
1791 return -1;
1792
1793 /* Reading single bytes in O_TEXT mode makes things slow
1794 * So read big chunks
1795 */
1796 if (ReadFile(hand, bufstart, count, &num_read, NULL))
1797 {
1798 if (count != 0 && num_read == 0)
1799 {
1800 MSVCRT_fdesc[fd].wxflag |= (WX_ATEOF|WX_READEOF);
1801 TRACE(":EOF %s\n",debugstr_an(buf,num_read));
1802 }
1803 else if (MSVCRT_fdesc[fd].wxflag & WX_TEXT)
1804 {
1805 DWORD i, j;
1806 if (bufstart[num_read-1] == '\r')
1807 {
1808 if(count == 1)
1809 {
1810 MSVCRT_fdesc[fd].wxflag &= ~WX_READCR;
1811 ReadFile(hand, bufstart, 1, &num_read, NULL);
1812 }
1813 else
1814 {
1815 MSVCRT_fdesc[fd].wxflag |= WX_READCR;
1816 num_read--;
1817 }
1818 }
1819 else
1820 MSVCRT_fdesc[fd].wxflag &= ~WX_READCR;
1821 for (i=0, j=0; i<num_read; i++)
1822 {
1823 /* in text mode, a ctrl-z signals EOF */
1824 if (bufstart[i] == 0x1a)
1825 {
1826 MSVCRT_fdesc[fd].wxflag |= (WX_ATEOF|WX_READEOF);
1827 TRACE(":^Z EOF %s\n",debugstr_an(buf,num_read));
1828 break;
1829 }
1830 /* in text mode, strip \r if followed by \n.
1831 * BUG: should save state across calls somehow, so CR LF that
1832 * straddles buffer boundary gets recognized properly?
1833 */
1834 if ((bufstart[i] != '\r')
1835 || ((i+1) < num_read && bufstart[i+1] != '\n'))
1836 bufstart[j++] = bufstart[i];
1837 }
1838 num_read = j;
1839 }
1840 }
1841 else
1842 {
1843 if (GetLastError() == ERROR_BROKEN_PIPE)
1844 {
1845 TRACE(":end-of-pipe\n");
1846 MSVCRT_fdesc[fd].wxflag |= (WX_ATEOF|WX_READEOF);
1847 return 0;
1848 }
1849 else
1850 {
1851 TRACE(":failed-last error (%d)\n",GetLastError());
1852 return -1;
1853 }
1854 }
1855
1856 if (count > 4)
1857 TRACE("(%u), %s\n",num_read,debugstr_an(buf, num_read));
1858 return num_read;
1859 }
1860
1861 /*********************************************************************
1862 * _read (MSVCRT.@)
1863 */
1864 int CDECL MSVCRT__read(int fd, void *buf, unsigned int count)
1865 {
1866 int num_read;
1867 num_read = read_i(fd, buf, count);
1868 return num_read;
1869 }
1870
1871 /*********************************************************************
1872 * _setmode (MSVCRT.@)
1873 */
1874 int CDECL _setmode(int fd,int mode)
1875 {
1876 int ret = MSVCRT_fdesc[fd].wxflag & WX_TEXT ? MSVCRT__O_TEXT : MSVCRT__O_BINARY;
1877 if (mode & (~(MSVCRT__O_TEXT|MSVCRT__O_BINARY)))
1878 FIXME("fd (%d) mode (0x%08x) unknown\n",fd,mode);
1879 if ((mode & MSVCRT__O_TEXT) == MSVCRT__O_TEXT)
1880 MSVCRT_fdesc[fd].wxflag |= WX_TEXT;
1881 else
1882 MSVCRT_fdesc[fd].wxflag &= ~WX_TEXT;
1883 return ret;
1884 }
1885
1886 /*********************************************************************
1887 * _stat64 (MSVCRT.@)
1888 */
1889 int CDECL MSVCRT_stat64(const char* path, struct MSVCRT__stat64 * buf)
1890 {
1891 DWORD dw;
1892 WIN32_FILE_ATTRIBUTE_DATA hfi;
1893 unsigned short mode = ALL_S_IREAD;
1894 int plen;
1895
1896 TRACE(":file (%s) buf(%p)\n",path,buf);
1897
1898 if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
1899 {
1900 TRACE("failed (%d)\n",GetLastError());
1901 msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1902 return -1;
1903 }
1904
1905 memset(buf,0,sizeof(struct MSVCRT__stat64));
1906
1907 /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
1908 Bon 011120: This FIXME seems incorrect
1909 Also a letter as first char isn't enough to be classified
1910 as a drive letter
1911 */
1912 if (isalpha(*path)&& (*(path+1)==':'))
1913 buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
1914 else
1915 buf->st_dev = buf->st_rdev = _getdrive() - 1;
1916
1917 plen = strlen(path);
1918
1919 /* Dir, or regular file? */
1920 if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1921 (path[plen-1] == '\\'))
1922 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
1923 else
1924 {
1925 mode |= MSVCRT__S_IFREG;
1926 /* executable? */
1927 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
1928 {
1929 unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
1930 (tolower(path[plen-3]) << 16);
1931 if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
1932 mode |= ALL_S_IEXEC;
1933 }
1934 }
1935
1936 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1937 mode |= ALL_S_IWRITE;
1938
1939 buf->st_mode = mode;
1940 buf->st_nlink = 1;
1941 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1942 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1943 buf->st_atime = dw;
1944 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1945 buf->st_mtime = buf->st_ctime = dw;
1946 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
1947 (int)(buf->st_size >> 32),(int)buf->st_size,
1948 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
1949 return 0;
1950 }
1951
1952 /*********************************************************************
1953 * _stati64 (MSVCRT.@)
1954 */
1955 int CDECL MSVCRT_stati64(const char* path, struct MSVCRT__stati64 * buf)
1956 {
1957 int ret;
1958 struct MSVCRT__stat64 buf64;
1959
1960 ret = MSVCRT_stat64(path, &buf64);
1961 if (!ret)
1962 msvcrt_stat64_to_stati64(&buf64, buf);
1963 return ret;
1964 }
1965
1966 /*********************************************************************
1967 * _stat (MSVCRT.@)
1968 */
1969 int CDECL MSVCRT_stat(const char* path, struct MSVCRT__stat * buf)
1970 { int ret;
1971 struct MSVCRT__stat64 buf64;
1972
1973 ret = MSVCRT_stat64( path, &buf64);
1974 if (!ret)
1975 msvcrt_stat64_to_stat(&buf64, buf);
1976 return ret;
1977 }
1978
1979 /*********************************************************************
1980 * _wstat64 (MSVCRT.@)
1981 */
1982 int CDECL MSVCRT__wstat64(const MSVCRT_wchar_t* path, struct MSVCRT__stat64 * buf)
1983 {
1984 DWORD dw;
1985 WIN32_FILE_ATTRIBUTE_DATA hfi;
1986 unsigned short mode = ALL_S_IREAD;
1987 int plen;
1988
1989 TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
1990
1991 if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
1992 {
1993 TRACE("failed (%d)\n",GetLastError());
1994 msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1995 return -1;
1996 }
1997
1998 memset(buf,0,sizeof(struct MSVCRT__stat64));
1999
2000 /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
2001 if (MSVCRT_iswalpha(*path))
2002 buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
2003 else
2004 buf->st_dev = buf->st_rdev = _getdrive() - 1;
2005
2006 plen = strlenW(path);
2007
2008 /* Dir, or regular file? */
2009 if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
2010 (path[plen-1] == '\\'))
2011 mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
2012 else
2013 {
2014 mode |= MSVCRT__S_IFREG;
2015 /* executable? */
2016 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
2017 {
2018 ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
2019 ((ULONGLONG)tolowerW(path[plen-3]) << 32);
2020 if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
2021 mode |= ALL_S_IEXEC;
2022 }
2023 }
2024
2025 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
2026 mode |= ALL_S_IWRITE;
2027
2028 buf->st_mode = mode;
2029 buf->st_nlink = 1;
2030 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
2031 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
2032 buf->st_atime = dw;
2033 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
2034 buf->st_mtime = buf->st_ctime = dw;
2035 TRACE("%d %d 0x%08x%08x %d %d %d\n", buf->st_mode,buf->st_nlink,
2036 (int)(buf->st_size >> 32),(int)buf->st_size,
2037 (int)buf->st_atime,(int)buf->st_mtime,(int)buf->st_ctime);
2038 return 0;
2039 }
2040
2041 /*********************************************************************
2042 * _wstati64 (MSVCRT.@)
2043 */
2044 int CDECL MSVCRT__wstati64(const MSVCRT_wchar_t* path, struct MSVCRT__stati64 * buf)
2045 {
2046 int ret;
2047 struct MSVCRT__stat64 buf64;
2048
2049 ret = MSVCRT__wstat64(path, &buf64);
2050 if (!ret)
2051 msvcrt_stat64_to_stati64(&buf64, buf);
2052 return ret;
2053 }
2054
2055 /*********************************************************************
2056 * _wstat (MSVCRT.@)
2057 */
2058 int CDECL MSVCRT__wstat(const MSVCRT_wchar_t* path, struct MSVCRT__stat * buf)
2059 {
2060 int ret;
2061 struct MSVCRT__stat64 buf64;
2062
2063 ret = MSVCRT__wstat64( path, &buf64 );
2064 if (!ret) msvcrt_stat64_to_stat(&buf64, buf);
2065 return ret;
2066 }
2067
2068 /*********************************************************************
2069 * _tell (MSVCRT.@)
2070 */
2071 MSVCRT_long CDECL MSVCRT__tell(int fd)
2072 {
2073 return MSVCRT__lseek(fd, 0, SEEK_CUR);
2074 }
2075
2076 /*********************************************************************
2077 * _telli64 (MSVCRT.@)
2078 */
2079 __int64 CDECL _telli64(int fd)
2080 {
2081 return MSVCRT__lseeki64(fd, 0, SEEK_CUR);
2082 }
2083
2084 /*********************************************************************
2085 * _tempnam (MSVCRT.@)
2086 */
2087 char * CDECL _tempnam(const char *dir, const char *prefix)
2088 {
2089 char tmpbuf[MAX_PATH];
2090 const char *tmp_dir = MSVCRT_getenv("TMP");
2091
2092 if (tmp_dir) dir = tmp_dir;
2093
2094 TRACE("dir (%s) prefix (%s)\n",dir,prefix);
2095 if (GetTempFileNameA(dir,prefix,0,tmpbuf))
2096 {
2097 TRACE("got name (%s)\n",tmpbuf);
2098 DeleteFileA(tmpbuf);
2099 return _strdup(tmpbuf);
2100 }
2101 TRACE("failed (%d)\n",GetLastError());
2102 return NULL;
2103 }
2104
2105 /*********************************************************************
2106 * _wtempnam (MSVCRT.@)
2107 */
2108 MSVCRT_wchar_t * CDECL _wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
2109 {
2110 MSVCRT_wchar_t tmpbuf[MAX_PATH];
2111
2112 TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
2113 if (GetTempFileNameW(dir,prefix,0,tmpbuf))
2114 {
2115 TRACE("got name (%s)\n",debugstr_w(tmpbuf));
2116 DeleteFileW(tmpbuf);
2117 return _wcsdup(tmpbuf);
2118 }
2119 TRACE("failed (%d)\n",GetLastError());
2120 return NULL;
2121 }
2122
2123 /*********************************************************************
2124 * _umask (MSVCRT.@)
2125 */
2126 int CDECL MSVCRT__umask(int umask)
2127 {
2128 int old_umask = MSVCRT_umask;
2129 TRACE("(%d)\n",umask);
2130 MSVCRT_umask = umask;
2131 return old_umask;
2132 }
2133
2134 /*********************************************************************
2135 * _utime64 (MSVCRT.@)
2136 */
2137 int CDECL _utime64(const char* path, struct MSVCRT___utimbuf64 *t)
2138 {
2139 int fd = MSVCRT__open(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
2140
2141 if (fd > 0)
2142 {
2143 int retVal = _futime64(fd, t);
2144 MSVCRT__close(fd);
2145 return retVal;
2146 }
2147 return -1;
2148 }
2149
2150 /*********************************************************************
2151 * _utime32 (MSVCRT.@)
2152 */
2153 int CDECL _utime32(const char* path, struct MSVCRT___utimbuf32 *t)
2154 {
2155 struct MSVCRT___utimbuf64 t64;
2156 t64.actime = t->actime;
2157 t64.modtime = t->modtime;
2158 return _utime64( path, &t64 );
2159 }
2160
2161 /*********************************************************************
2162 * _utime (MSVCRT.@)
2163 */
2164 #ifdef _WIN64
2165 int CDECL _utime(const char* path, struct MSVCRT___utimbuf64 *t)
2166 {
2167 return _utime64( path, t );
2168 }
2169 #else
2170 int CDECL _utime(const char* path, struct MSVCRT___utimbuf32 *t)
2171 {
2172 return _utime32( path, t );
2173 }
2174 #endif
2175
2176 /*********************************************************************
2177 * _wutime64 (MSVCRT.@)
2178 */
2179 int CDECL _wutime64(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
2180 {
2181 int fd = _wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
2182
2183 if (fd > 0)
2184 {
2185 int retVal = _futime64(fd, t);
2186 MSVCRT__close(fd);
2187 return retVal;
2188 }
2189 return -1;
2190 }
2191
2192 /*********************************************************************
2193 * _wutime32 (MSVCRT.@)
2194 */
2195 int CDECL _wutime32(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
2196 {
2197 struct MSVCRT___utimbuf64 t64;
2198 t64.actime = t->actime;
2199 t64.modtime = t->modtime;
2200 return _wutime64( path, &t64 );
2201 }
2202
2203 /*********************************************************************
2204 * _wutime (MSVCRT.@)
2205 */
2206 #ifdef _WIN64
2207 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf64 *t)
2208 {
2209 return _wutime64( path, t );
2210 }
2211 #else
2212 int CDECL _wutime(const MSVCRT_wchar_t* path, struct MSVCRT___utimbuf32 *t)
2213 {
2214 return _wutime32( path, t );
2215 }
2216 #endif
2217
2218 /*********************************************************************
2219 * _write (MSVCRT.@)
2220 */
2221 int CDECL MSVCRT__write(int fd, const void* buf, unsigned int count)
2222 {
2223 DWORD num_written;
2224 HANDLE hand = msvcrt_fdtoh(fd);
2225
2226 /* Don't trace small writes, it gets *very* annoying */
2227 #if 0
2228 if (count > 32)
2229 TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
2230 #endif
2231 if (hand == INVALID_HANDLE_VALUE)
2232 {
2233 *MSVCRT__errno() = MSVCRT_EBADF;
2234 return -1;
2235 }
2236
2237 /* If appending, go to EOF */
2238 if (MSVCRT_fdesc[fd].wxflag & WX_APPEND)
2239 MSVCRT__lseek(fd, 0, FILE_END);
2240
2241 if (!(MSVCRT_fdesc[fd].wxflag & WX_TEXT))
2242 {
2243 if (WriteFile(hand, buf, count, &num_written, NULL)
2244 && (num_written == count))
2245 return num_written;
2246 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d)\n", fd,
2247 hand, GetLastError());
2248 *MSVCRT__errno() = MSVCRT_ENOSPC;
2249 }
2250 else
2251 {
2252 unsigned int i, j, nr_lf;
2253 char *p = NULL;
2254 const char *q;
2255 const char *s = buf, *buf_start = buf;
2256 /* find number of \n ( without preceding \r ) */
2257 for ( nr_lf=0,i = 0; i <count; i++)
2258 {
2259 if (s[i]== '\n')
2260 {
2261 nr_lf++;
2262 /*if ((i >1) && (s[i-1] == '\r')) nr_lf--; */
2263 }
2264 }
2265 if (nr_lf)
2266 {
2267 if ((q = p = MSVCRT_malloc(count + nr_lf)))
2268 {
2269 for (s = buf, i = 0, j = 0; i < count; i++)
2270 {
2271 if (s[i]== '\n')
2272 {
2273 p[j++] = '\r';
2274 /*if ((i >1) && (s[i-1] == '\r'))j--;*/
2275 }
2276 p[j++] = s[i];
2277 }
2278 }
2279 else
2280 {
2281 FIXME("Malloc failed\n");
2282 nr_lf =0;
2283 q = buf;
2284 }
2285 }
2286 else
2287 q = buf;
2288
2289 if ((WriteFile(hand, q, count+nr_lf, &num_written, NULL) == 0 ) || (num_written != count+nr_lf))
2290 {
2291 TRACE("WriteFile (fd %d, hand %p) failed-last error (%d), num_written %d\n",
2292 fd, hand, GetLastError(), num_written);
2293 *MSVCRT__errno() = MSVCRT_ENOSPC;
2294 if(nr_lf)
2295 MSVCRT_free(p);
2296 return s - buf_start;
2297 }
2298 else
2299 {
2300 if(nr_lf)
2301 MSVCRT_free(p);
2302 return count;
2303 }
2304 }
2305 return -1;
2306 }
2307
2308 /*********************************************************************
2309 * _putw (MSVCRT.@)
2310 */
2311 int CDECL MSVCRT__putw(int val, MSVCRT_FILE* file)
2312 {
2313 int len;
2314 len = MSVCRT__write(file->_file, &val, sizeof(val));
2315 if (len == sizeof(val)) return val;
2316 file->_flag |= MSVCRT__IOERR;
2317 return MSVCRT_EOF;
2318 }
2319
2320 /*********************************************************************
2321 * fclose (MSVCRT.@)
2322 */
2323 int CDECL MSVCRT_fclose(MSVCRT_FILE* file)
2324 {
2325 int r, flag;
2326
2327 flag = file->_flag;
2328 MSVCRT_free(file->_tmpfname);
2329 file->_tmpfname = NULL;
2330 /* flush stdio buffers */
2331 if(file->_flag & MSVCRT__IOWRT)
2332 MSVCRT_fflush(file);
2333 if(file->_flag & MSVCRT__IOMYBUF)
2334 MSVCRT_free(file->_base);
2335
2336 r=MSVCRT__close(file->_file);
2337
2338 file->_flag = 0;
2339
2340 return ((r == -1) || (flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
2341 }
2342
2343 /*********************************************************************
2344 * feof (MSVCRT.@)
2345 */
2346 int CDECL MSVCRT_feof(MSVCRT_FILE* file)
2347 {
2348 return file->_flag & MSVCRT__IOEOF;
2349 }
2350
2351 /*********************************************************************
2352 * ferror (MSVCRT.@)
2353 */
2354 int CDECL MSVCRT_ferror(MSVCRT_FILE* file)
2355 {
2356 return file->_flag & MSVCRT__IOERR;
2357 }
2358
2359 /*********************************************************************
2360 * _filbuf (MSVCRT.@)
2361 */
2362 int CDECL MSVCRT__filbuf(MSVCRT_FILE* file)
2363 {
2364 /* Allocate buffer if needed */
2365 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF) ) {
2366 msvcrt_alloc_buffer(file);
2367 }
2368 if(!(file->_flag & MSVCRT__IOREAD)) {
2369 if(file->_flag & MSVCRT__IORW) {
2370 file->_flag |= MSVCRT__IOREAD;
2371 } else {
2372 return MSVCRT_EOF;
2373 }
2374 }
2375 if(file->_flag & MSVCRT__IONBF) {
2376 unsigned char c;
2377 int r;
2378 if ((r = read_i(file->_file,&c,1)) != 1) {
2379 file->_flag |= (r == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
2380 return MSVCRT_EOF;
2381 }
2382 return c;
2383 } else {
2384 file->_cnt = read_i(file->_file, file->_base, file->_bufsiz);
2385 if(file->_cnt<=0) {
2386 file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
2387 file->_cnt = 0;
2388 return MSVCRT_EOF;
2389 }
2390 file->_cnt--;
2391 file->_ptr = file->_base+1;
2392 return *(unsigned char *)file->_base;
2393 }
2394 }
2395
2396 /*********************************************************************
2397 * fgetc (MSVCRT.@)
2398 */
2399 int CDECL MSVCRT_fgetc(MSVCRT_FILE* file)
2400 {
2401 unsigned char *i;
2402 unsigned int j;
2403 if (file->_cnt>0) {
2404 file->_cnt--;
2405 i = (unsigned char *)file->_ptr++;
2406 j = *i;
2407 } else
2408 j = MSVCRT__filbuf(file);
2409 return j;
2410 }
2411
2412 /*********************************************************************
2413 * _fgetchar (MSVCRT.@)
2414 */
2415 int CDECL _fgetchar(void)
2416 {
2417 return MSVCRT_fgetc(MSVCRT_stdin);
2418 }
2419
2420 /*********************************************************************
2421 * fgets (MSVCRT.@)
2422 */
2423 char * CDECL MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
2424 {
2425 int cc = MSVCRT_EOF;
2426 char * buf_start = s;
2427
2428 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
2429 file,file->_file,s,size);
2430
2431 while ((size >1) && (cc = MSVCRT_fgetc(file)) != MSVCRT_EOF && cc != '\n')
2432 {
2433 *s++ = (char)cc;
2434 size --;
2435 }
2436 if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
2437 {
2438 TRACE(":nothing read\n");
2439 return NULL;
2440 }
2441 if ((cc != MSVCRT_EOF) && (size > 1))
2442 *s++ = cc;
2443 *s = '\0';
2444 TRACE(":got %s\n", debugstr_a(buf_start));
2445 return buf_start;
2446 }
2447
2448 /*********************************************************************
2449 * fgetwc (MSVCRT.@)
2450 *
2451 * In MSVCRT__O_TEXT mode, multibyte characters are read from the file, dropping
2452 * the CR from CR/LF combinations
2453 */
2454 MSVCRT_wint_t CDECL MSVCRT_fgetwc(MSVCRT_FILE* file)
2455 {
2456 char c;
2457
2458 if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
2459 {
2460 MSVCRT_wchar_t wc;
2461 unsigned int i;
2462 int j;
2463 char *chp, *wcp;
2464 wcp = (char *)&wc;
2465 for(i=0; i<sizeof(wc); i++)
2466 {
2467 if (file->_cnt>0)
2468 {
2469 file->_cnt--;
2470 chp = file->_ptr++;
2471 wcp[i] = *chp;
2472 }
2473 else
2474 {
2475 j = MSVCRT__filbuf(file);
2476 if(file->_cnt<=0)
2477 {
2478 file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
2479 file->_cnt = 0;
2480 return MSVCRT_WEOF;
2481 }
2482 wcp[i] = j;
2483 }
2484 }
2485 return wc;
2486 }
2487
2488 c = MSVCRT_fgetc(file);
2489 if ((get_locale()->locinfo->mb_cur_max > 1) && MSVCRT_isleadbyte(c))
2490 {
2491 FIXME("Treat Multibyte characters\n");
2492 }
2493 if (c == MSVCRT_EOF)
2494 return MSVCRT_WEOF;
2495 else
2496 return (MSVCRT_wint_t)c;
2497 }
2498
2499 /*********************************************************************
2500 * _getw (MSVCRT.@)
2501 */
2502 int CDECL MSVCRT__getw(MSVCRT_FILE* file)
2503 {
2504 char *ch;
2505 int i, k;
2506 unsigned int j;
2507 ch = (char *)&i;
2508 for (j=0; j<sizeof(int); j++) {
2509 k = MSVCRT_fgetc(file);
2510 if (k == MSVCRT_EOF) {
2511 file->_flag |= MSVCRT__IOEOF;
2512 return EOF;
2513 }
2514 ch[j] = k;
2515 }
2516 return i;
2517 }
2518
2519 /*********************************************************************
2520 * getwc (MSVCRT.@)
2521 */
2522 MSVCRT_wint_t CDECL MSVCRT_getwc(MSVCRT_FILE* file)
2523 {
2524 return MSVCRT_fgetwc(file);
2525 }
2526
2527 /*********************************************************************
2528 * _fgetwchar (MSVCRT.@)
2529 */
2530 MSVCRT_wint_t CDECL _fgetwchar(void)
2531 {
2532 return MSVCRT_fgetwc(MSVCRT_stdin);
2533 }
2534
2535 /*********************************************************************
2536 * getwchar (MSVCRT.@)
2537 */
2538 MSVCRT_wint_t CDECL MSVCRT_getwchar(void)
2539 {
2540 return _fgetwchar();
2541 }
2542
2543 /*********************************************************************
2544 * fgetws (MSVCRT.@)
2545 */
2546 MSVCRT_wchar_t * CDECL MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
2547 {
2548 int cc = MSVCRT_WEOF;
2549 MSVCRT_wchar_t * buf_start = s;
2550
2551 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
2552 file,file->_file,s,size);
2553
2554 while ((size >1) && (cc = MSVCRT_fgetwc(file)) != MSVCRT_WEOF && cc != '\n')
2555 {
2556 *s++ = (char)cc;
2557 size --;
2558 }
2559 if ((cc == MSVCRT_WEOF) && (s == buf_start)) /* If nothing read, return 0*/
2560 {
2561 TRACE(":nothing read\n");
2562 return NULL;
2563 }
2564 if ((cc != MSVCRT_WEOF) && (size > 1))
2565 *s++ = cc;
2566 *s = 0;
2567 TRACE(":got %s\n", debugstr_w(buf_start));
2568 return buf_start;
2569 }
2570
2571 /*********************************************************************
2572 * fwrite (MSVCRT.@)
2573 */
2574 MSVCRT_size_t CDECL MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
2575 {
2576 MSVCRT_size_t wrcnt=size * nmemb;
2577 int written = 0;
2578 if (size == 0)
2579 return 0;
2580 if(file->_cnt) {
2581 int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
2582 memcpy(file->_ptr, ptr, pcnt);
2583 file->_cnt -= pcnt;
2584 file->_ptr += pcnt;
2585 written = pcnt;
2586 wrcnt -= pcnt;
2587 ptr = (const char*)ptr + pcnt;
2588 } else if(!(file->_flag & MSVCRT__IOWRT)) {
2589 if(file->_flag & MSVCRT__IORW) {
2590 file->_flag |= MSVCRT__IOWRT;
2591 } else
2592 return 0;
2593 }
2594 if(wrcnt) {
2595 /* Flush buffer */
2596 int res=msvcrt_flush_buffer(file);
2597 if(!res) {
2598 int pwritten = MSVCRT__write(file->_file, ptr, wrcnt);
2599 if (pwritten <= 0)
2600 {
2601 file->_flag |= MSVCRT__IOERR;
2602 pwritten=0;
2603 }
2604 written += pwritten;
2605 }
2606 }
2607 return written / size;
2608 }
2609
2610 /*********************************************************************
2611 * fputwc (MSVCRT.@)
2612 */
2613 MSVCRT_wint_t CDECL MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
2614 {
2615 MSVCRT_wchar_t mwc=wc;
2616 if (MSVCRT_fwrite( &mwc, sizeof(mwc), 1, file) != 1)
2617 return MSVCRT_WEOF;
2618 return wc;
2619 }
2620
2621 /*********************************************************************
2622 * _fputwchar (MSVCRT.@)
2623 */
2624 MSVCRT_wint_t CDECL _fputwchar(MSVCRT_wint_t wc)
2625 {
2626 return MSVCRT_fputwc(wc, MSVCRT_stdout);
2627 }
2628
2629 /*********************************************************************
2630 * _wfsopen (MSVCRT.@)
2631 */
2632 MSVCRT_FILE * CDECL MSVCRT__wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
2633 {
2634 MSVCRT_FILE* file;
2635 int open_flags, stream_flags, fd;
2636
2637 TRACE("(%s,%s)\n", debugstr_w(path), debugstr_w(mode));
2638
2639 /* map mode string to open() flags. "man fopen" for possibilities. */
2640 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
2641 return NULL;
2642
2643 LOCK_FILES();
2644 fd = MSVCRT__wsopen(path, open_flags, share, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
2645 if (fd < 0)
2646 file = NULL;
2647 else if ((file = msvcrt_alloc_fp()) && msvcrt_init_fp(file, fd, stream_flags)
2648 != -1)
2649 TRACE(":fd (%d) mode (%s) FILE* (%p)\n", fd, debugstr_w(mode), file);
2650 else if (file)
2651 {
2652 file->_flag = 0;
2653 file = NULL;
2654 }
2655
2656 TRACE(":got (%p)\n",file);
2657 if (fd >= 0 && !file)
2658 MSVCRT__close(fd);
2659 UNLOCK_FILES();
2660 return file;
2661 }
2662
2663 /*********************************************************************
2664 * _fsopen (MSVCRT.@)
2665 */
2666 MSVCRT_FILE * CDECL MSVCRT__fsopen(const char *path, const char *mode, int share)
2667 {
2668 MSVCRT_FILE *ret;
2669 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
2670
2671 if (path && !(pathW = msvcrt_wstrdupa(path))) {
2672 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
2673 *MSVCRT__errno() = MSVCRT_EINVAL;
2674 return NULL;
2675 }
2676 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
2677 {
2678 MSVCRT_free(pathW);
2679 MSVCRT__invalid_parameter(NULL, NULL, NULL, 0, 0);
2680 *MSVCRT__errno() = MSVCRT_EINVAL;
2681 return NULL;
2682 }
2683
2684 ret = MSVCRT__wfsopen(pathW, modeW, share);
2685
2686 MSVCRT_free(pathW);
2687 MSVCRT_free(modeW);
2688 return ret;
2689 }
2690
2691 /*********************************************************************
2692 * fopen (MSVCRT.@)
2693 */
2694 MSVCRT_FILE * CDECL MSVCRT_fopen(const char *path, const char *mode)
2695 {
2696 return MSVCRT__fsopen( path, mode, MSVCRT__SH_DENYNO );
2697 }
2698
2699 /*********************************************************************
2700 * fopen_s (MSVCRT.@)
2701 */
2702 int CDECL MSVCRT_fopen_s(MSVCRT_FILE** pFile,
2703 const char *filename, const char *mode)
2704 {
2705 if (!MSVCRT_CHECK_PMT(pFile != NULL) || !MSVCRT_CHECK_PMT(filename != NULL) ||
2706 MSVCRT_CHECK_PMT(mode != NULL)) {
2707 *MSVCRT__errno() = MSVCRT_EINVAL;
2708 return MSVCRT_EINVAL;
2709 }
2710
2711 *pFile = MSVCRT_fopen(filename, mode);
2712
2713 if(!*pFile)
2714 return *MSVCRT__errno();
2715 return 0;
2716 }
2717
2718 /*********************************************************************
2719 * _wfopen (MSVCRT.@)
2720 */
2721 MSVCRT_FILE * CDECL MSVCRT__wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
2722 {
2723 return MSVCRT__wfsopen( path, mode, MSVCRT__SH_DENYNO );
2724 }
2725
2726 /*********************************************************************
2727 * _wfopen_s (MSVCRT.@)
2728 */
2729 int CDECL MSVCRT__wfopen_s(MSVCRT_FILE** pFile, const MSVCRT_wchar_t *filename,
2730 const MSVCRT_wchar_t *mode)
2731 {
2732 if (!MSVCRT_CHECK_PMT(pFile != NULL) || !MSVCRT_CHECK_PMT(filename != NULL) ||
2733 MSVCRT_CHECK_PMT(mode != NULL)) {
2734 *MSVCRT__errno() = MSVCRT_EINVAL;
2735 return MSVCRT_EINVAL;
2736 }
2737
2738 *pFile = MSVCRT__wfopen(filename, mode);
2739
2740 if(!*pFile)
2741 return *MSVCRT__errno();
2742 return 0;
2743 }
2744
2745 /* MSVCRT_fputc calls MSVCRT__flsbuf which calls MSVCRT_fputc */
2746 int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file);
2747
2748 /*********************************************************************
2749 * fputc (MSVCRT.@)
2750 */
2751 int CDECL MSVCRT_fputc(int c, MSVCRT_FILE* file)
2752 {
2753 if(file->_cnt>0) {
2754 *file->_ptr++=c;
2755 file->_cnt--;
2756 if (c == '\n')
2757 {
2758 int res = msvcrt_flush_buffer(file);
2759 return res ? res : c;
2760 }
2761 else
2762 return c & 0xff;
2763 } else {
2764 return MSVCRT__flsbuf(c, file);
2765 }
2766 }
2767
2768 /*********************************************************************
2769 * _flsbuf (MSVCRT.@)
2770 */
2771 int CDECL MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
2772 {
2773 /* Flush output buffer */
2774 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
2775 msvcrt_alloc_buffer(file);
2776 }
2777 if(!(file->_flag & MSVCRT__IOWRT)) {
2778 if(file->_flag & MSVCRT__IORW) {
2779 file->_flag |= MSVCRT__IOWRT;
2780 } else {
2781 return MSVCRT_EOF;
2782 }
2783 }
2784 if(file->_bufsiz) {
2785 int res=msvcrt_flush_buffer(file);
2786 return res?res : MSVCRT_fputc(c, file);
2787 } else {
2788 unsigned char cc=c;
2789 int len;
2790 /* set _cnt to 0 for unbuffered FILEs */
2791 file->_cnt = 0;
2792 len = MSVCRT__write(file->_file, &cc, 1);
2793 if (len == 1) return c & 0xff;
2794 file->_flag |= MSVCRT__IOERR;
2795 return MSVCRT_EOF;
2796 }
2797 }
2798
2799 /*********************************************************************
2800 * _fputchar (MSVCRT.@)
2801 */
2802 int CDECL _fputchar(int c)
2803 {
2804 return MSVCRT_fputc(c, MSVCRT_stdout);
2805 }
2806
2807 /*********************************************************************
2808 * fread (MSVCRT.@)
2809 */
2810 MSVCRT_size_t CDECL MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
2811 { MSVCRT_size_t rcnt=size * nmemb;
2812 MSVCRT_size_t read=0;
2813 int pread=0;
2814
2815 if(!rcnt)
2816 return 0;
2817
2818 /* first buffered data */
2819 if(file->_cnt>0) {
2820 int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
2821 memcpy(ptr, file->_ptr, pcnt);
2822 file->_cnt -= pcnt;
2823 file->_ptr += pcnt;
2824 read += pcnt ;
2825 rcnt -= pcnt ;
2826 ptr = (char*)ptr + pcnt;
2827 } else if(!(file->_flag & MSVCRT__IOREAD )) {
2828 if(file->_flag & MSVCRT__IORW) {
2829 file->_flag |= MSVCRT__IOREAD;
2830 } else
2831 return 0;
2832 }
2833 while(rcnt>0)
2834 {
2835 int i;
2836 /* Fill the buffer on small reads.
2837 * TODO: Use a better buffering strategy.
2838 */
2839 if (!file->_cnt && size*nmemb <= MSVCRT_BUFSIZ/2 && !(file->_flag & MSVCRT__IONBF)) {
2840 if (file->_bufsiz == 0) {
2841 msvcrt_alloc_buffer(file);
2842 }
2843 file->_cnt = MSVCRT__read(file->_file, file->_base, file->_bufsiz);
2844 file->_ptr = file->_base;
2845 i = (file->_cnt<rcnt) ? file->_cnt : rcnt;
2846 /* If the buffer fill reaches eof but fread wouldn't, clear eof. */
2847 if (i > 0 && i < file->_cnt) {
2848 MSVCRT_fdesc[file->_file].wxflag &= ~WX_ATEOF;
2849 file->_flag &= ~MSVCRT__IOEOF;
2850 }
2851 if (i > 0) {
2852 memcpy(ptr, file->_ptr, i);
2853 file->_cnt -= i;
2854 file->_ptr += i;
2855 }
2856 } else {
2857 i = MSVCRT__read(file->_file,ptr, rcnt);
2858 }
2859 pread += i;
2860 rcnt -= i;
2861 ptr = (char *)ptr+i;
2862 /* expose feof condition in the flags
2863 * MFC tests file->_flag for feof, and doesn't call feof())
2864 */
2865 if ( MSVCRT_fdesc[file->_file].wxflag & WX_ATEOF)
2866 file->_flag |= MSVCRT__IOEOF;
2867 else if (i == -1)
2868 {
2869 file->_flag |= MSVCRT__IOERR;
2870 pread = 0;
2871 rcnt = 0;
2872 }
2873 if (i < 1) break;
2874 }
2875 read+=pread;
2876 return read / size;
2877 }
2878
2879 /*********************************************************************
2880 * _wfreopen (MSVCRT.@)
2881 *
2882 */
2883 MSVCRT_FILE* CDECL MSVCRT__wfreopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, MSVCRT_FILE* file)
2884 {
2885 int open_flags, stream_flags, fd;
2886
2887 TRACE(":path (%p) mode (%s) file (%p) fd (%d)\n", debugstr_w(path), debugstr_w(mode), file, file->_file);
2888
2889 LOCK_FILES();
2890 if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
2891 file = NULL;
2892 else
2893 {
2894 MSVCRT_fclose(file);
2895 /* map mode string to open() flags. "man fopen" for possibilities. */
2896 if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
2897 file = NULL;
2898 else
2899 {
2900 fd = _wopen(path, open_flags, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
2901 if (fd < 0)
2902 file = NULL;
2903 else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
2904 {
2905 file->_flag = 0;
2906 WARN(":failed-last error (%d)\n",GetLastError());
2907 msvcrt_set_errno(GetLastError());
2908 file = NULL;
2909 }
2910 }
2911 }
2912 UNLOCK_FILES();
2913 return file;
2914 }
2915
2916 /*********************************************************************
2917 * freopen (MSVCRT.@)
2918 *
2919 */
2920 MSVCRT_FILE* CDECL MSVCRT_freopen(const char *path, const char *mode, MSVCRT_FILE* file)
2921 {
2922 MSVCRT_FILE *ret;
2923 MSVCRT_wchar_t *pathW = NULL, *modeW = NULL;
2924
2925 if (path && !(pathW = msvcrt_wstrdupa(path))) return NULL;
2926 if (mode && !(modeW = msvcrt_wstrdupa(mode)))
2927 {
2928 MSVCRT_free(pathW);
2929 return NULL;
2930 }
2931
2932 ret = MSVCRT__wfreopen(pathW, modeW, file);
2933
2934 MSVCRT_free(pathW);
2935 MSVCRT_free(modeW);
2936 return ret;
2937 }
2938
2939 /*********************************************************************
2940 * fsetpos (MSVCRT.@)
2941 */
2942 int CDECL MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
2943 {
2944 /* Note that all this has been lifted 'as is' from fseek */
2945 if(file->_flag & MSVCRT__IOWRT)
2946 msvcrt_flush_buffer(file);
2947
2948 /* Discard buffered input */
2949 file->_cnt = 0;
2950 file->_ptr = file->_base;
2951
2952 /* Reset direction of i/o */
2953 if(file->_flag & MSVCRT__IORW) {
2954 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
2955 }
2956
2957 return (MSVCRT__lseeki64(file->_file,*pos,SEEK_SET) == -1) ? -1 : 0;
2958 }
2959
2960 /*********************************************************************
2961 * ftell (MSVCRT.@)
2962 */
2963 LONG CDECL MSVCRT_ftell(MSVCRT_FILE* file)
2964 {
2965 /* TODO: just call fgetpos and return lower half of result */
2966 int off=0;
2967 MSVCRT_long pos;
2968 pos = MSVCRT__tell(file->_file);
2969 if(pos == -1) return -1;
2970 if(file->_bufsiz) {
2971 if( file->_flag & MSVCRT__IOWRT ) {
2972 off = file->_ptr - file->_base;
2973 } else {
2974 off = -file->_cnt;
2975 if (MSVCRT_fdesc[file->_file].wxflag & WX_TEXT) {
2976 /* Black magic correction for CR removal */
2977 int i;
2978 for (i=0; i<file->_cnt; i++) {
2979 if (file->_ptr[i] == '\n')
2980 off--;
2981 }
2982 /* Black magic when reading CR at buffer boundary*/
2983 if(MSVCRT_fdesc[file->_file].wxflag & WX_READCR)
2984 off--;
2985
2986 }
2987 }
2988 }
2989 return off + pos;
2990 }
2991
2992 /*********************************************************************
2993 * fgetpos (MSVCRT.@)
2994 */
2995 int CDECL MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
2996 {
2997 int off=0;
2998 *pos = MSVCRT__lseeki64(file->_file,0,SEEK_CUR);
2999 if(*pos == -1) return -1;
3000 if(file->_bufsiz) {
3001 if( file->_flag & MSVCRT__IOWRT ) {
3002 off = file->_ptr - file->_base;
3003 } else {
3004 off = -file->_cnt;
3005 if (MSVCRT_fdesc[file->_file].wxflag & WX_TEXT) {
3006 /* Black magic correction for CR removal */
3007 int i;
3008 for (i=0; i<file->_cnt; i++) {
3009 if (file->_ptr[i] == '\n')
3010 off--;
3011 }
3012 /* Black magic when reading CR at buffer boundary*/
3013 if(MSVCRT_fdesc[file->_file].wxflag & WX_READCR)
3014 off--;
3015 }
3016 }
3017 }
3018 *pos += off;
3019 return 0;
3020 }
3021
3022 /*********************************************************************
3023 * fputs (MSVCRT.@)
3024 */
3025 int CDECL MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
3026 {
3027 MSVCRT_size_t i, len = strlen(s);
3028 if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
3029 return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
3030 for (i=0; i<len; i++)
3031 if (MSVCRT_fputc(s[i], file) == MSVCRT_EOF)
3032 return MSVCRT_EOF;
3033 return 0;
3034 }
3035
3036 /*********************************************************************
3037 * fputws (MSVCRT.@)
3038 */
3039 int CDECL MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
3040 {
3041 MSVCRT_size_t i, len = strlenW(s);
3042 if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
3043 return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
3044 for (i=0; i<len; i++)
3045 {
3046 if ((s[i] == '\n') && (MSVCRT_fputc('\r', file) == MSVCRT_EOF))
3047 return MSVCRT_WEOF;
3048 if (MSVCRT_fputwc(s[i], file) == MSVCRT_WEOF)
3049 return MSVCRT_WEOF;
3050 }
3051 return 0;
3052 }
3053
3054 /*********************************************************************
3055 * getchar (MSVCRT.@)
3056 */
3057 int CDECL MSVCRT_getchar(void)
3058 {
3059 return MSVCRT_fgetc(MSVCRT_stdin);
3060 }
3061
3062 /*********************************************************************
3063 * getc (MSVCRT.@)
3064 */
3065 int CDECL MSVCRT_getc(MSVCRT_FILE* file)
3066 {
3067 return MSVCRT_fgetc(file);
3068 }
3069
3070 /*********************************************************************
3071 * gets (MSVCRT.@)
3072 */
3073 char * CDECL MSVCRT_gets(char *buf)
3074 {
3075 int cc;
3076 char * buf_start = buf;
3077
3078 for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
3079 cc = MSVCRT_fgetc(MSVCRT_stdin))
3080 if(cc != '\r') *buf++ = (char)cc;
3081
3082 *buf = '\0';
3083
3084 TRACE("got '%s'\n", buf_start);
3085 return buf_start;
3086 }
3087
3088 /*********************************************************************
3089 * _getws (MSVCRT.@)
3090 */
3091 MSVCRT_wchar_t* CDECL MSVCRT__getws(MSVCRT_wchar_t* buf)
3092 {
3093 MSVCRT_wint_t cc;
3094 MSVCRT_wchar_t* ws = buf;
3095
3096 for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
3097 cc = MSVCRT_fgetwc(MSVCRT_stdin))
3098 {
3099 if (cc != '\r')
3100 *buf++ = (MSVCRT_wchar_t)cc;
3101 }
3102 *buf = '\0';
3103
3104 TRACE("got %s\n", debugstr_w(ws));
3105 return ws;
3106 }
3107
3108 /*********************************************************************
3109 * putc (MSVCRT.@)
3110 */
3111 int CDECL MSVCRT_putc(int c, MSVCRT_FILE* file)
3112 {
3113 return MSVCRT_fputc(c, file);
3114 }
3115
3116 /*********************************************************************
3117 * putchar (MSVCRT.@)
3118 */
3119 int CDECL MSVCRT_putchar(int c)
3120 {
3121 return MSVCRT_fputc(c, MSVCRT_stdout);
3122 }
3123
3124 /*********************************************************************
3125 * puts (MSVCRT.@)
3126 */
3127 int CDECL MSVCRT_puts(const char *s)
3128 {
3129 MSVCRT_size_t len = strlen(s);
3130 if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
3131 return MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
3132 }
3133
3134 /*********************************************************************
3135 * _putws (MSVCRT.@)
3136 */
3137 int CDECL _putws(const MSVCRT_wchar_t *s)
3138 {
3139 static const MSVCRT_wchar_t nl = '\n';
3140 MSVCRT_size_t len = strlenW(s);
3141 if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
3142 return MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
3143 }
3144
3145 /*********************************************************************
3146 * remove (MSVCRT.@)
3147 */
3148 int CDECL MSVCRT_remove(const char *path)
3149 {
3150 TRACE("(%s)\n",path);
3151 if (DeleteFileA(path))
3152 return 0;
3153 TRACE(":failed (%d)\n",GetLastError());
3154 msvcrt_set_errno(GetLastError());
3155 return -1;
3156 }
3157
3158 /*********************************************************************
3159 * _wremove (MSVCRT.@)
3160 */
3161 int CDECL _wremove(const MSVCRT_wchar_t *path)
3162 {
3163 TRACE("(%s)\n",debugstr_w(path));
3164 if (DeleteFileW(path))
3165 return 0;
3166 TRACE(":failed (%d)\n",GetLastError());
3167 msvcrt_set_errno(GetLastError());
3168 return -1;
3169 }
3170
3171 /*********************************************************************
3172 * rename (MSVCRT.@)
3173 */
3174 int CDECL MSVCRT_rename(const char *oldpath,const char *newpath)
3175 {
3176 TRACE(":from %s to %s\n",oldpath,newpath);
3177 if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
3178 return 0;
3179 TRACE(":failed (%d)\n",GetLastError());
3180 msvcrt_set_errno(GetLastError());
3181 return -1;
3182 }
3183
3184 /*********************************************************************
3185 * _wrename (MSVCRT.@)
3186 */
3187 int CDECL _wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
3188 {
3189 TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
3190 if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
3191 return 0;
3192 TRACE(":failed (%d)\n",GetLastError());
3193 msvcrt_set_errno(GetLastError());
3194 return -1;
3195 }
3196
3197 /*********************************************************************
3198 * setvbuf (MSVCRT.@)
3199 */
3200 int CDECL MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
3201 {
3202 /* TODO: Check if file busy */
3203 if(file->_bufsiz) {
3204 MSVCRT_free(file->_base);
3205 file->_bufsiz = 0;
3206 file->_cnt = 0;
3207 }
3208 if(mode == MSVCRT__IOFBF) {
3209 file->_flag &= ~MSVCRT__IONBF;
3210 file->_base = file->_ptr = buf;
3211 if(buf) {
3212 file->_bufsiz = size;
3213 }
3214 } else {
3215 file->_flag |= MSVCRT__IONBF;
3216 }
3217 return 0;
3218 }
3219
3220 /*********************************************************************
3221 * setbuf (MSVCRT.@)
3222 */
3223 void CDECL MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
3224 {
3225 MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
3226 }
3227
3228 /*********************************************************************
3229 * tmpnam (MSVCRT.@)
3230 */
3231 char * CDECL MSVCRT_tmpnam(char *s)
3232 {
3233 static int unique;
3234 char tmpstr[16];
3235 char *p;
3236 int count;
3237 if (s == 0)
3238 s = MSVCRT_tmpname;
3239 msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
3240 p = s + sprintf(s, "\\s%s.", tmpstr);
3241 for (count = 0; count < MSVCRT_TMP_MAX; count++)
3242 {
3243 msvcrt_int_to_base32(unique++, tmpstr);
3244 strcpy(p, tmpstr);
3245 if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
3246 GetLastError() == ERROR_FILE_NOT_FOUND)
3247 break;
3248 }
3249 return s;
3250 }
3251
3252 /*********************************************************************
3253 * tmpfile (MSVCRT.@)
3254 */
3255 MSVCRT_FILE* CDECL MSVCRT_tmpfile(void)
3256 {
3257 char *filename = MSVCRT_tmpnam(NULL);
3258 int fd;
3259 MSVCRT_FILE* file = NULL;
3260
3261 LOCK_FILES();
3262 fd = MSVCRT__open(filename, MSVCRT__O_CREAT | MSVCRT__O_BINARY | MSVCRT__O_RDWR | MSVCRT__O_TEMPORARY);
3263 if (fd != -1 && (file = msvcrt_alloc_fp()))
3264 {
3265 if (msvcrt_init_fp(file, fd, MSVCRT__O_RDWR) == -1)
3266 {
3267 file->_flag = 0;
3268 file = NULL;
3269 }
3270 else file->_tmpfname = _strdup(filename);
3271 }
3272 UNLOCK_FILES();
3273 return file;
3274 }
3275
3276 /*********************************************************************
3277 * vfprintf (MSVCRT.@)
3278 */
3279 int CDECL MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, __ms_va_list valist)
3280 {
3281 char buf[2048], *mem = buf;
3282 int written, resize = sizeof(buf), retval;
3283 /* There are two conventions for vsnprintf failing:
3284 * Return -1 if we truncated, or
3285 * Return the number of bytes that would have been written
3286 * The code below handles both cases
3287 */
3288 while ((written = MSVCRT_vsnprintf(mem, resize, format, valist)) == -1 ||
3289 written > resize)
3290 {
3291 resize = (written == -1 ? resize * 2 : written + 1);
3292 if (mem != buf)
3293 MSVCRT_free (mem);
3294 if (!(mem = MSVCRT_malloc(resize)))
3295 return MSVCRT_EOF;
3296 }
3297 retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
3298 if (mem != buf)
3299 MSVCRT_free (mem);
3300 return retval;
3301 }
3302
3303 /*********************************************************************
3304 * vfwprintf (MSVCRT.@)
3305 * FIXME:
3306 * Is final char included in written (then resize is too big) or not
3307 * (then we must test for equality too)?
3308 */
3309 int CDECL MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, __ms_va_list valist)
3310 {
3311 MSVCRT_wchar_t buf[2048], *mem = buf;
3312 int written, resize = sizeof(buf) / sizeof(MSVCRT_wchar_t), retval;
3313 /* See vfprintf comments */
3314 while ((written = MSVCRT_vsnwprintf(mem, resize, format, valist)) == -1 ||
3315 written > resize)
3316 {
3317 resize = (written == -1 ? resize * 2 : written + sizeof(MSVCRT_wchar_t));
3318 if (mem != buf)
3319 MSVCRT_free (mem);
3320 if (!(mem = MSVCRT_malloc(resize*sizeof(*mem))))
3321 return MSVCRT_EOF;
3322 }
3323 retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
3324 if (mem != buf)
3325 MSVCRT_free (mem);
3326 return retval;
3327 }
3328
3329 /*********************************************************************
3330 * vprintf (MSVCRT.@)
3331 */
3332 int CDECL MSVCRT_vprintf(const char *format, __ms_va_list valist)
3333 {
3334 return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
3335 }
3336
3337 /*********************************************************************
3338 * vwprintf (MSVCRT.@)
3339 */
3340 int CDECL MSVCRT_vwprintf(const MSVCRT_wchar_t *format, __ms_va_list valist)
3341 {
3342 return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
3343 }
3344
3345 /*********************************************************************
3346 * fprintf (MSVCRT.@)
3347 */
3348 int CDECL MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
3349 {
3350 __ms_va_list valist;
3351 int res;
3352 __ms_va_start(valist, format);
3353 res = MSVCRT_vfprintf(file, format, valist);
3354 __ms_va_end(valist);
3355 return res;
3356 }
3357
3358 /*********************************************************************
3359 * fwprintf (MSVCRT.@)
3360 */
3361 int CDECL MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
3362 {
3363 __ms_va_list valist;
3364 int res;
3365 __ms_va_start(valist, format);
3366 res = MSVCRT_vfwprintf(file, format, valist);
3367 __ms_va_end(valist);
3368 return res;
3369 }
3370
3371 /*********************************************************************
3372 * printf (MSVCRT.@)
3373 */
3374 int CDECL MSVCRT_printf(const char *format, ...)
3375 {
3376 __ms_va_list valist;
3377 int res;
3378 __ms_va_start(valist, format);
3379 res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
3380 __ms_va_end(valist);
3381 return res;
3382 }
3383
3384 /*********************************************************************
3385 * ungetc (MSVCRT.@)
3386 */
3387 int CDECL MSVCRT_ungetc(int c, MSVCRT_FILE * file)
3388 {
3389 if (c == MSVCRT_EOF)
3390 return MSVCRT_EOF;
3391 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
3392 msvcrt_alloc_buffer(file);
3393 file->_ptr++;
3394 }
3395 if(file->_ptr>file->_base) {
3396 file->_ptr--;
3397 *file->_ptr=c;
3398 file->_cnt++;
3399 MSVCRT_clearerr(file);
3400 return c;
3401 }
3402 return MSVCRT_EOF;
3403 }
3404
3405 /*********************************************************************
3406 * ungetwc (MSVCRT.@)
3407 */
3408 MSVCRT_wint_t CDECL MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
3409 {
3410 MSVCRT_wchar_t mwc = wc;
3411 char * pp = (char *)&mwc;
3412 int i;
3413 for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
3414 if(pp[i] != MSVCRT_ungetc(pp[i],file))
3415 return MSVCRT_WEOF;
3416 }
3417 return mwc;
3418 }
3419
3420 /*********************************************************************
3421 * wprintf (MSVCRT.@)
3422 */
3423 int CDECL MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
3424 {
3425 __ms_va_list valist;
3426 int res;
3427 __ms_va_start(valist, format);
3428 res = MSVCRT_vwprintf(format, valist);
3429 __ms_va_end(valist);
3430 return res;
3431 }
3432
3433 /*********************************************************************
3434 * _getmaxstdio (MSVCRT.@)
3435 */
3436 int CDECL _getmaxstdio(void)
3437 {
3438 FIXME("stub, always returns 512\n");
3439 return 512;
3440 }
3441
3442 /*********************************************************************
3443 * _setmaxstdio_ (MSVCRT.@)
3444 */
3445 int CDECL _setmaxstdio(int newmax)
3446 {
3447 int res;
3448 if( newmax > 2048)
3449 res = -1;
3450 else
3451 res = newmax;
3452 FIXME("stub: setting new maximum for number of simultaneously open files not implemented,returning %d\n",res);
3453 return res;
3454 }
3455
3456 /*********************************************************************
3457 * __pioinfo (MSVCRT.@)
3458 * FIXME: see MSVCRT_MAX_FILES define.
3459 */
3460 ioinfo * MSVCRT___pioinfo[] = { /* array of pointers to ioinfo arrays [64] */
3461 &MSVCRT_fdesc[0 * 64], &MSVCRT_fdesc[1 * 64], &MSVCRT_fdesc[2 * 64],
3462 &MSVCRT_fdesc[3 * 64], &MSVCRT_fdesc[4 * 64], &MSVCRT_fdesc[5 * 64],
3463 &MSVCRT_fdesc[6 * 64], &MSVCRT_fdesc[7 * 64], &MSVCRT_fdesc[8 * 64],
3464 &MSVCRT_fdesc[9 * 64], &MSVCRT_fdesc[10 * 64], &MSVCRT_fdesc[11 * 64],
3465 &MSVCRT_fdesc[12 * 64], &MSVCRT_fdesc[13 * 64], &MSVCRT_fdesc[14 * 64],
3466 &MSVCRT_fdesc[15 * 64], &MSVCRT_fdesc[16 * 64], &MSVCRT_fdesc[17 * 64],
3467 &MSVCRT_fdesc[18 * 64], &MSVCRT_fdesc[19 * 64], &MSVCRT_fdesc[20 * 64],
3468 &MSVCRT_fdesc[21 * 64], &MSVCRT_fdesc[22 * 64], &MSVCRT_fdesc[23 * 64],
3469 &MSVCRT_fdesc[24 * 64], &MSVCRT_fdesc[25 * 64], &MSVCRT_fdesc[26 * 64],
3470 &MSVCRT_fdesc[27 * 64], &MSVCRT_fdesc[28 * 64], &MSVCRT_fdesc[29 * 64],
3471 &MSVCRT_fdesc[30 * 64], &MSVCRT_fdesc[31 * 64]
3472 } ;
3473
3474 /*********************************************************************
3475 * __badioinfo (MSVCRT.@)
3476 */
3477 ioinfo MSVCRT___badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };
Maarten's multimedia branch