source: trunk/src/msvcrt/file.c@ 21916

Last change on this file since 21916 was 21916, checked in by dmik, 14 years ago

Merge branch gcc-kmk to trunk.
File size: 64.2 KB
Line 
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 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24#ifdef __WIN32OS2__
25#include <winbase.h>
26#include "emxheader.h"
27#else
28#include "config.h"
29#include "wine/port.h"
30#endif
31
32#include <stdlib.h>
33#include <stdio.h>
34#include <ctype.h>
35#include <string.h>
36#include <time.h>
37
38#ifndef __MINIVCRT__
39
40#include "winternl.h"
41#include "debugstr.h"
42#include "msvcrt.h"
43#include "msvcrt/errno.h"
44
45#include "wine/unicode.h"
46#include "msvcrt/direct.h"
47#include "msvcrt/fcntl.h"
48#include "msvcrt/io.h"
49#include "msvcrt/sys/locking.h"
50#include "msvcrt/stdio.h"
51#include "msvcrt/stdlib.h"
52#include "msvcrt/string.h"
53#include "msvcrt/sys/stat.h"
54#include "msvcrt/sys/utime.h"
55#include "msvcrt/time.h"
56#include "msvcrt/share.h"
57#include "msvcrt/wctype.h"
58
59#include "wine/debug.h"
60
61WINE_DEFAULT_DEBUG_CHANNEL(msvcrt);
62
63#else /* !__MINIVCRT__ */
64
65#include <fcntl.h>
66#include <sys/stat.h>
67#include <wctype.h>
68
69#include <winerror.h>
70
71#include "minivcrt.h"
72#include "minivcrt_internal.h"
73
74#include "winternl.h"
75#include "wine/unicode.h"
76
77#endif /* !__MINIVCRT__ */
78
79#ifndef __MINIVCRT__
80
81/* for stat mode, permissions apply to all,owner and group */
82#define MSVCRT_S_IREAD (_S_IREAD | (_S_IREAD >> 3) | (_S_IREAD >> 6))
83#define MSVCRT_S_IWRITE (_S_IWRITE | (_S_IWRITE >> 3) | (_S_IWRITE >> 6))
84#define MSVCRT_S_IEXEC (_S_IEXEC | (_S_IEXEC >> 3) | (_S_IEXEC >> 6))
85
86/* _access() bit flags FIXME: incomplete */
87#define MSVCRT_W_OK 0x02
88
89/* FIXME: Make this dynamic */
90#define MSVCRT_MAX_FILES 257
91
92HANDLE MSVCRT_handles[MSVCRT_MAX_FILES];
93MSVCRT_FILE* MSVCRT_files[MSVCRT_MAX_FILES];
94int MSVCRT_flags[MSVCRT_MAX_FILES];
95char *MSVCRT_tempfiles[MSVCRT_MAX_FILES];
96MSVCRT_FILE MSVCRT__iob[3];
97#define MSVCRT_stdin (MSVCRT__iob+STDIN_FILENO)
98#define MSVCRT_stdout (MSVCRT__iob+STDOUT_FILENO)
99#define MSVCRT_stderr (MSVCRT__iob+STDERR_FILENO)
100
101static int MSVCRT_fdstart = 3; /* first unallocated fd */
102static int MSVCRT_fdend = 3; /* highest allocated fd */
103
104/* INTERNAL: process umask */
105static int MSVCRT__umask = 0;
106
107/* INTERNAL: Static buffer for temp file name */
108static char MSVCRT_tmpname[MAX_PATH];
109
110static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
111static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
112static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
113static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
114
115#else /* !__MINIVCRT__ */
116
117/* for stat mode, permissions apply to all,owner and group */
118#define MSVCRT_S_IREAD (S_IRUSR | S_IRGRP | S_IROTH)
119#define MSVCRT_S_IWRITE (S_IWUSR | S_IWGRP | S_IWOTH)
120#define MSVCRT_S_IEXEC (S_IXUSR | S_IXGRP | S_IXOTH)
121
122#define MSVCRT_W_OK W_OK
123#define _S_IWRITE S_IWUSR
124#define _S_IFDIR S_IFDIR
125#define _S_IFREG S_IFREG
126
127#define MSVCRT_iswalpha iswalpha
128
129#endif /* !__MINIVCRT__ */
130
131#define TOUL(x) (ULONGLONG)(x)
132static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
133static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
134static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
135static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
136
137#ifndef __MINIVCRT__
138
139extern CRITICAL_SECTION MSVCRT_file_cs;
140#define LOCK_FILES EnterCriticalSection(&MSVCRT_file_cs)
141#define UNLOCK_FILES LeaveCriticalSection(&MSVCRT_file_cs)
142
143static void msvcrt_cp_from_stati64(const struct _stati64 *bufi64, struct _stat *buf)
144{
145 buf->st_dev = bufi64->st_dev;
146 buf->st_ino = bufi64->st_ino;
147 buf->st_mode = bufi64->st_mode;
148 buf->st_nlink = bufi64->st_nlink;
149 buf->st_uid = bufi64->st_uid;
150 buf->st_gid = bufi64->st_gid;
151 buf->st_rdev = bufi64->st_rdev;
152 buf->st_size = bufi64->st_size;
153 buf->st_atime = bufi64->st_atime;
154 buf->st_mtime = bufi64->st_mtime;
155 buf->st_ctime = bufi64->st_ctime;
156}
157
158/* INTERNAL: Get the HANDLE for a fd */
159static HANDLE msvcrt_fdtoh(int fd)
160{
161 if (fd < 0 || fd >= MSVCRT_fdend ||
162 MSVCRT_handles[fd] == INVALID_HANDLE_VALUE)
163 {
164 WARN(":fd (%d) - no handle!\n",fd);
165 *MSVCRT_doserrno() = 0;
166 *MSVCRT__errno() = MSVCRT_EBADF;
167 return INVALID_HANDLE_VALUE;
168 }
169 return MSVCRT_handles[fd];
170}
171
172/* INTERNAL: free a file entry fd */
173static void msvcrt_free_fd(int fd)
174{
175 MSVCRT_handles[fd] = INVALID_HANDLE_VALUE;
176 MSVCRT_files[fd] = 0;
177 MSVCRT_flags[fd] = 0;
178 TRACE(":fd (%d) freed\n",fd);
179 if (fd < 3)
180 return; /* dont use 0,1,2 for user files */
181 if (fd == MSVCRT_fdend - 1)
182 MSVCRT_fdend--;
183 if (fd < MSVCRT_fdstart)
184 MSVCRT_fdstart = fd;
185}
186
187/* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
188static int msvcrt_alloc_fd(HANDLE hand, int flag)
189{
190 int fd = MSVCRT_fdstart;
191
192 TRACE(":handle (%p) allocating fd (%d)\n",hand,fd);
193 if (fd >= MSVCRT_MAX_FILES)
194 {
195 WARN(":files exhausted!\n");
196 return -1;
197 }
198 MSVCRT_handles[fd] = hand;
199 MSVCRT_flags[fd] = flag;
200
201 /* locate next free slot */
202 if (fd == MSVCRT_fdend)
203 MSVCRT_fdstart = ++MSVCRT_fdend;
204 else
205 while(MSVCRT_fdstart < MSVCRT_fdend &&
206 MSVCRT_handles[MSVCRT_fdstart] != INVALID_HANDLE_VALUE)
207 MSVCRT_fdstart++;
208
209 return fd;
210}
211
212/* INTERNAL: Allocate a FILE* for an fd slot
213 * This is done lazily to avoid memory wastage for low level open/write
214 * usage when a FILE* is not requested (but may be later).
215 */
216static MSVCRT_FILE* msvcrt_alloc_fp(int fd)
217{
218 TRACE("MSVCRT: fd (%d) allocating FILE*\n",fd);
219 if (fd < 0 || fd >= MSVCRT_fdend ||
220 MSVCRT_handles[fd] == INVALID_HANDLE_VALUE)
221 {
222 WARN(":invalid fd %d\n",fd);
223 *MSVCRT_doserrno() = 0;
224 *MSVCRT__errno() = MSVCRT_EBADF;
225 return NULL;
226 }
227 if (!MSVCRT_files[fd])
228 {
229 if ((MSVCRT_files[fd] = MSVCRT_calloc(sizeof(MSVCRT_FILE),1)))
230 {
231 MSVCRT_files[fd]->_file = fd;
232 MSVCRT_files[fd]->_flag = MSVCRT_flags[fd];
233 MSVCRT_files[fd]->_flag &= ~MSVCRT__IOAPPEND; /* mask out, see above */
234 }
235 }
236 TRACE(":got FILE* (%p)\n",MSVCRT_files[fd]);
237 return MSVCRT_files[fd];
238}
239
240
241/* INTERNAL: Set up stdin, stderr and stdout */
242void msvcrt_init_io(void)
243{
244 int i;
245 memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
246 MSVCRT_handles[0] = GetStdHandle(STD_INPUT_HANDLE);
247 MSVCRT_flags[0] = MSVCRT__iob[0]._flag = MSVCRT__IOREAD;
248 MSVCRT_handles[1] = GetStdHandle(STD_OUTPUT_HANDLE);
249 MSVCRT_flags[1] = MSVCRT__iob[1]._flag = MSVCRT__IOWRT;
250 MSVCRT_handles[2] = GetStdHandle(STD_ERROR_HANDLE);
251 MSVCRT_flags[2] = MSVCRT__iob[2]._flag = MSVCRT__IOWRT;
252
253 TRACE(":handles (%p)(%p)(%p)\n",MSVCRT_handles[0],
254 MSVCRT_handles[1],MSVCRT_handles[2]);
255
256 for (i = 0; i < 3; i++)
257 {
258 /* FILE structs for stdin/out/err are static and never deleted */
259 MSVCRT_files[i] = &MSVCRT__iob[i];
260 MSVCRT__iob[i]._file = i;
261 MSVCRT_tempfiles[i] = NULL;
262 }
263}
264
265/* free everything on process exit */
266void msvcrt_free_io(void)
267{
268 MSVCRT__fcloseall();
269 MSVCRT__close(0);
270 MSVCRT__close(1);
271 MSVCRT__close(2);
272}
273
274/* INTERNAL: Flush stdio file buffer */
275static int msvcrt_flush_buffer(MSVCRT_FILE* file)
276{
277 if(file->_bufsiz) {
278 int cnt=file->_ptr-file->_base;
279 if(cnt>0 && MSVCRT__write(file->_file, file->_base, cnt) != cnt) {
280 return MSVCRT_EOF;
281 }
282 file->_ptr=file->_base;
283 file->_cnt=file->_bufsiz;
284 }
285 return 0;
286}
287
288/* INTERNAL: Allocate stdio file buffer */
289static void msvcrt_alloc_buffer(MSVCRT_FILE* file)
290{
291 file->_base = MSVCRT_calloc(MSVCRT_BUFSIZ,1);
292 if(file->_base) {
293 file->_bufsiz = MSVCRT_BUFSIZ;
294 file->_flag |= MSVCRT__IOMYBUF;
295 } else {
296 file->_base = (unsigned char *)(&file->_charbuf);
297 /* put here 2 ??? */
298 file->_bufsiz = sizeof(file->_charbuf);
299 }
300 file->_ptr = file->_base;
301 file->_cnt = 0;
302}
303
304/*********************************************************************
305 * __p__iob(MSVCRT.@)
306 */
307MSVCRT_FILE *__p__iob(void)
308{
309 dprintf(("MSVCRT: __p__iob request"));
310 return &MSVCRT__iob[0];
311}
312
313/*********************************************************************
314 * _access (MSVCRT.@)
315 */
316int MSVCRT__access(const char *filename, int mode)
317{
318 DWORD attr = GetFileAttributesA(filename);
319
320 TRACE("MSVCRT _access (%s,%d) %ld\n",filename,mode,attr);
321
322 if (!filename || attr == 0xffffffff)
323 {
324 MSVCRT__set_errno(GetLastError());
325 return -1;
326 }
327 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
328 {
329 MSVCRT__set_errno(ERROR_ACCESS_DENIED);
330 return -1;
331 }
332 return 0;
333}
334
335#endif /* !__MINIVCRT__ */
336
337/*********************************************************************
338 * _waccess (MSVCRT.@)
339 */
340int _waccess(const MSVCRT_wchar_t *filename, int mode)
341{
342 DWORD attr = GetFileAttributesW(filename);
343
344 TRACE("MSVCRT: _waccess (%s,%d) %ld\n",debugstr_w(filename),mode,attr);
345
346 if (!filename || attr == 0xffffffff)
347 {
348 MSVCRT__set_errno(GetLastError());
349 return -1;
350 }
351 if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
352 {
353 MSVCRT__set_errno(ERROR_ACCESS_DENIED);
354 return -1;
355 }
356 return 0;
357}
358
359#ifndef __MINIVCRT__
360
361/*********************************************************************
362 * _chmod (MSVCRT.@)
363 */
364int MSVCRT__chmod(const char *path, int flags)
365{
366 DWORD oldFlags = GetFileAttributesA(path);
367
368 dprintf(("MSVCRT: _chmod %s",path));
369
370 if (oldFlags != 0x0FFFFFFFF)
371 {
372 DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
373 oldFlags | FILE_ATTRIBUTE_READONLY;
374
375 if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
376 return 0;
377 }
378 MSVCRT__set_errno(GetLastError());
379 return -1;
380}
381
382#endif /* !__MINIVCRT__ */
383
384/*********************************************************************
385 * _wchmod (MSVCRT.@)
386 */
387int _wchmod(const MSVCRT_wchar_t *path, int flags)
388{
389 DWORD oldFlags = GetFileAttributesW(path);
390
391 dprintf(("MSVCRT: _wchmod %s",debugstr_w(path)));
392
393 if (oldFlags != 0x0FFFFFFFF)
394 {
395 DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
396 oldFlags | FILE_ATTRIBUTE_READONLY;
397
398 if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
399 return 0;
400 }
401 MSVCRT__set_errno(GetLastError());
402 return -1;
403}
404
405#ifndef __MINIVCRT__
406
407/*********************************************************************
408 * _unlink (MSVCRT.@)
409 */
410int MSVCRT__unlink(const char *path)
411{
412 TRACE("MSVCRT: _unlink (%s)\n",path);
413 if(DeleteFileA(path))
414 return 0;
415 TRACE("failed (%ld)\n",GetLastError());
416 MSVCRT__set_errno(GetLastError());
417 return -1;
418}
419
420#endif /* !__MINIVCRT__ */
421
422/*********************************************************************
423 * _wunlink (MSVCRT.@)
424 */
425int _wunlink(const MSVCRT_wchar_t *path)
426{
427 TRACE("(%s)\n",debugstr_w(path));
428 if(DeleteFileW(path))
429 return 0;
430 TRACE("failed (%ld)\n",GetLastError());
431 MSVCRT__set_errno(GetLastError());
432 return -1;
433}
434
435#ifndef __MINIVCRT__
436
437/*********************************************************************
438 * _close (MSVCRT.@)
439 */
440int MSVCRT__close(int fd)
441{
442 HANDLE hand = msvcrt_fdtoh(fd);
443
444 TRACE("MSVCRT: _close fd (%d) handle (%p)\n",fd,hand);
445 if (hand == INVALID_HANDLE_VALUE)
446 return -1;
447 /* flush stdio buffers */
448 if(MSVCRT_files[fd]) {
449 if(MSVCRT_files[fd]->_flag & MSVCRT__IOWRT)
450 MSVCRT_fflush(MSVCRT_files[fd]);
451
452 if(MSVCRT_files[fd]->_flag & MSVCRT__IOMYBUF)
453 MSVCRT_free(MSVCRT_files[fd]->_base);
454 }
455
456 /* Dont free std FILE*'s, they are not dynamic */
457 if (fd > 2 && MSVCRT_files[fd])
458 MSVCRT_free(MSVCRT_files[fd]);
459
460 msvcrt_free_fd(fd);
461
462 if (!CloseHandle(hand))
463 {
464 WARN(":failed-last error (%ld)\n",GetLastError());
465 MSVCRT__set_errno(GetLastError());
466 return -1;
467 }
468 if (MSVCRT_tempfiles[fd])
469 {
470 TRACE("deleting temporary file '%s'\n",MSVCRT_tempfiles[fd]);
471 MSVCRT__unlink(MSVCRT_tempfiles[fd]);
472 MSVCRT_free(MSVCRT_tempfiles[fd]);
473 MSVCRT_tempfiles[fd] = NULL;
474 }
475
476 TRACE("MSVCRT: _close ok\n");
477 return 0;
478}
479
480/*********************************************************************
481 * _commit (MSVCRT.@)
482 */
483int _commit(int fd)
484{
485 HANDLE hand = msvcrt_fdtoh(fd);
486
487 TRACE("MSVCRT: _commit fd (%d) handle (%p)\n",fd,hand);
488 if (hand == INVALID_HANDLE_VALUE)
489 return -1;
490
491 if (!FlushFileBuffers(hand))
492 {
493 if (GetLastError() == ERROR_INVALID_HANDLE)
494 {
495 /* FlushFileBuffers fails for console handles
496 * so we ignore this error.
497 */
498 return 0;
499 }
500 TRACE(":failed-last error (%ld)\n",GetLastError());
501 MSVCRT__set_errno(GetLastError());
502 return -1;
503 }
504 TRACE(":ok\n");
505 return 0;
506}
507
508/*********************************************************************
509 * _eof (MSVCRT.@)
510 */
511int _eof(int fd)
512{
513 DWORD curpos,endpos;
514 HANDLE hand = msvcrt_fdtoh(fd);
515
516 TRACE("MSVCRT: _eof fd (%d) handle (%p)\n",fd,hand);
517
518 if (hand == INVALID_HANDLE_VALUE)
519 return -1;
520
521 /* If we have a FILE* for this file, the EOF flag
522 * will be set by the read()/write() functions.
523 */
524 if (MSVCRT_files[fd])
525 return MSVCRT_flags[fd] & MSVCRT__IOEOF;
526
527 /* Otherwise we do it the hard way */
528 curpos = SetFilePointer(hand, 0, NULL, SEEK_CUR);
529 endpos = SetFilePointer(hand, 0, NULL, FILE_END);
530
531 if (curpos == endpos)
532 return TRUE;
533
534 SetFilePointer(hand, curpos, 0, FILE_BEGIN);
535 return FALSE;
536}
537
538/*********************************************************************
539 * _fcloseall (MSVCRT.@)
540 */
541int MSVCRT__fcloseall(void)
542{
543 int num_closed = 0, i;
544
545 dprintf(("MSVCRT: _fcloseall"));
546
547 for (i = 3; i < MSVCRT_fdend; i++)
548 if (MSVCRT_handles[i] != INVALID_HANDLE_VALUE)
549 {
550 MSVCRT__close(i);
551 num_closed++;
552 }
553
554 TRACE(":closed (%d) handles\n",num_closed);
555 return num_closed;
556}
557
558/*********************************************************************
559 * _lseek (MSVCRT.@)
560 */
561__int64 _lseeki64(int fd, __int64 offset, int whence)
562{
563 DWORD ret, hoffset = (DWORD) (offset >> 32);
564 HANDLE hand = msvcrt_fdtoh(fd);
565
566 TRACE("MSVCRT: _lseeki64 fd (%d) handle (%p)\n",fd,hand);
567 if (hand == INVALID_HANDLE_VALUE)
568 return -1;
569
570 if (whence < 0 || whence > 2)
571 {
572 *MSVCRT__errno() = MSVCRT_EINVAL;
573 return -1;
574 }
575
576 TRACE("MSVCRT: _lseek fd (%d) to 0x%08lx%08lx pos %s\n",
577 fd,hoffset,(long)offset,
578 (whence==SEEK_SET)?"SEEK_SET":
579 (whence==SEEK_CUR)?"SEEK_CUR":
580 (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
581
582 if (((ret = SetFilePointer(hand, (long)offset, &hoffset,
583 whence)) != INVALID_SET_FILE_POINTER) || !GetLastError())
584 {
585 if (MSVCRT_files[fd])
586 MSVCRT_files[fd]->_flag &= ~MSVCRT__IOEOF;
587 /* FIXME: What if we seek _to_ EOF - is EOF set? */
588
589 return ((__int64)hoffset << 32) | ret;
590 }
591 TRACE(":error-last error (%ld)\n",GetLastError());
592 if (MSVCRT_files[fd])
593 switch(GetLastError())
594 {
595 case ERROR_NEGATIVE_SEEK:
596 case ERROR_SEEK_ON_DEVICE:
597 MSVCRT__set_errno(GetLastError());
598 MSVCRT_files[fd]->_flag |= MSVCRT__IOERR;
599 break;
600 default:
601 break;
602 }
603 return -1;
604}
605
606/*********************************************************************
607 * _lseek (MSVCRT.@)
608 */
609LONG MSVCRT__lseek(int fd, LONG offset, int whence)
610{
611 return _lseeki64(fd, offset, whence);
612}
613
614/*********************************************************************
615 * _locking (MSVCRT.@)
616 *
617 * This is untested; the underlying LockFile doesn't work yet.
618 */
619int _locking(int fd, int mode, LONG nbytes)
620{
621 BOOL ret;
622 DWORD cur_locn;
623 HANDLE hand = msvcrt_fdtoh(fd);
624
625 TRACE("MSVCRT: _locking fd (%d) handle (%p)\n",fd,hand);
626 if (hand == INVALID_HANDLE_VALUE)
627 return -1;
628
629 if (mode < 0 || mode > 4)
630 {
631 *MSVCRT__errno() = MSVCRT_EINVAL;
632 return -1;
633 }
634
635 TRACE(":fd (%d) by 0x%08lx mode %s\n",
636 fd,nbytes,(mode==_LK_UNLCK)?"_LK_UNLCK":
637 (mode==_LK_LOCK)?"_LK_LOCK":
638 (mode==_LK_NBLCK)?"_LK_NBLCK":
639 (mode==_LK_RLCK)?"_LK_RLCK":
640 (mode==_LK_NBRLCK)?"_LK_NBRLCK":
641 "UNKNOWN");
642
643 if ((cur_locn = SetFilePointer(hand, 0L, NULL, SEEK_CUR)) == 0xffffffff)
644 {
645 FIXME ("Seek failed\n");
646 *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
647 return -1;
648 }
649 if (mode == _LK_LOCK || mode == _LK_RLCK)
650 {
651 int nretry = 10;
652 ret = 1; /* just to satisfy gcc */
653 while (nretry--)
654 {
655 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
656 if (ret) break;
657 Sleep (1);
658 }
659 }
660 else if (mode == _LK_UNLCK)
661 ret = UnlockFile(hand, cur_locn, 0L, nbytes, 0L);
662 else
663 ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
664 /* FIXME - what about error settings? */
665 return ret ? 0 : -1;
666}
667
668/*********************************************************************
669 * rewind (MSVCRT.@)
670 */
671void MSVCRT_rewind(MSVCRT_FILE* file)
672{
673 TRACE("MSVCRT: rewind file (%p) fd (%d)\n",file,file->_file);
674 MSVCRT_fseek(file, 0L, SEEK_SET);
675 MSVCRT_clearerr(file);
676}
677
678/*********************************************************************
679 * _fdopen (MSVCRT.@)
680 */
681MSVCRT_FILE* MSVCRT__fdopen(int fd, const char *mode)
682{
683 MSVCRT_FILE* file = msvcrt_alloc_fp(fd);
684
685 TRACE("MSVCRT: _fdopen fd (%d) mode (%s) FILE* (%p)\n",fd,mode,file);
686
687 return file;
688}
689
690/*********************************************************************
691 * _wfdopen (MSVCRT.@)
692 */
693MSVCRT_FILE* _wfdopen(int fd, const MSVCRT_wchar_t *mode)
694{
695 MSVCRT_FILE* file = msvcrt_alloc_fp(fd);
696
697 TRACE("MSVCRT: _wfdopen fd (%d) mode (%s) FILE* (%p)\n",fd,debugstr_w(mode),file);
698 if (file)
699 MSVCRT_rewind(file);
700
701 return file;
702}
703
704/*********************************************************************
705 * _filelength (MSVCRT.@)
706 */
707LONG MSVCRT__filelength(int fd)
708{
709 LONG curPos = MSVCRT__lseek(fd, 0, SEEK_CUR);
710
711 dprintf(("MSVCRT: _filelength"));
712
713 if (curPos != -1)
714 {
715 LONG endPos = MSVCRT__lseek(fd, 0, SEEK_END);
716 if (endPos != -1)
717 {
718 if (endPos != curPos)
719 MSVCRT__lseek(fd, curPos, SEEK_SET);
720 return endPos;
721 }
722 }
723 return -1;
724}
725
726/*********************************************************************
727 * _fileno (MSVCRT.@)
728 */
729int MSVCRT__fileno(MSVCRT_FILE* file)
730{
731 TRACE("MSVCRT: _fileno FILE* (%p) fd (%d)\n",file,file->_file);
732 return file->_file;
733}
734
735/*********************************************************************
736 * _flushall (MSVCRT.@)
737 */
738int MSVCRT__flushall(void)
739{
740 int num_flushed = 0, i = 3;
741
742 dprintf(("MSVCRT: _flushall"));
743
744 while(i < MSVCRT_fdend)
745 if (MSVCRT_handles[i] != INVALID_HANDLE_VALUE)
746 {
747#if 0
748 /* FIXME: flush, do not commit */
749 if (_commit(i) == -1)
750 if (MSVCRT_files[i])
751 MSVCRT_files[i]->_flag |= MSVCRT__IOERR;
752#endif
753 if(MSVCRT_files[i] && MSVCRT_files[i]->_flag & MSVCRT__IOWRT) {
754 MSVCRT_fflush(MSVCRT_files[i]);
755 num_flushed++;
756 }
757 }
758
759 TRACE(":flushed (%d) handles\n",num_flushed);
760 return num_flushed;
761}
762
763/*********************************************************************
764 * _fstati64 (MSVCRT.@)
765 */
766int _fstati64(int fd, struct _stati64* buf)
767{
768 DWORD dw;
769 BY_HANDLE_FILE_INFORMATION hfi;
770 HANDLE hand = msvcrt_fdtoh(fd);
771
772 TRACE("MSVCRT: _fstati64 fd (%d) stat (%p)\n",fd,buf);
773 if (hand == INVALID_HANDLE_VALUE)
774 return -1;
775
776 if (!buf)
777 {
778 WARN(":failed-NULL buf\n");
779 MSVCRT__set_errno(ERROR_INVALID_PARAMETER);
780 return -1;
781 }
782
783 memset(&hfi, 0, sizeof(hfi));
784 memset(buf, 0, sizeof(struct _stati64));
785 if (!GetFileInformationByHandle(hand, &hfi))
786 {
787 WARN("MSVCRT: _fstati64 failed-last error (%ld)\n",GetLastError());
788 MSVCRT__set_errno(ERROR_INVALID_PARAMETER);
789 return -1;
790 }
791 FIXME(":dwFileAttributes = %ld, mode set to 0\n",hfi.dwFileAttributes);
792 buf->st_nlink = hfi.nNumberOfLinks;
793 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
794 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
795 buf->st_atime = dw;
796 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
797 buf->st_mtime = buf->st_ctime = dw;
798 return 0;
799}
800
801
802/*********************************************************************
803 * _fstat (MSVCRT.@)
804 */
805int MSVCRT__fstat(int fd, struct _stat* buf)
806{ int ret;
807 struct _stati64 bufi64;
808
809 ret = _fstati64(fd, &bufi64);
810 if (!ret)
811 msvcrt_cp_from_stati64(&bufi64, buf);
812 return ret;
813}
814
815/*********************************************************************
816 * _futime (MSVCRT.@)
817 */
818int _futime(int fd, struct _utimbuf *t)
819{
820 HANDLE hand = msvcrt_fdtoh(fd);
821 FILETIME at, wt;
822
823 if (!t)
824 {
825 MSVCRT_time_t currTime;
826 MSVCRT_time(&currTime);
827 RtlSecondsSince1970ToTime(currTime, (LARGE_INTEGER *)&at);
828 memcpy(&wt, &at, sizeof(wt));
829 }
830 else
831 {
832 RtlSecondsSince1970ToTime(t->actime, (LARGE_INTEGER *)&at);
833 if (t->actime == t->modtime)
834 memcpy(&wt, &at, sizeof(wt));
835 else
836 RtlSecondsSince1970ToTime(t->modtime, (LARGE_INTEGER *)&wt);
837 }
838
839 if (!SetFileTime(hand, NULL, &at, &wt))
840 {
841 MSVCRT__set_errno(GetLastError());
842 return -1 ;
843 }
844 return 0;
845}
846
847/*********************************************************************
848 * _get_osfhandle (MSVCRT.@)
849 */
850long _get_osfhandle(int fd)
851{
852 HANDLE hand = msvcrt_fdtoh(fd);
853 HANDLE newhand = hand;
854 TRACE(":fd (%d) handle (%p)\n",fd,hand);
855
856 if (hand != INVALID_HANDLE_VALUE)
857 {
858 /* FIXME: I'm not convinced that I should be copying the
859 * handle here - it may be leaked if the app doesn't
860 * close it (and the API docs dont say that it should)
861 * Not duplicating it means that it can't be inherited
862 * and so lcc's wedit doesn't cope when it passes it to
863 * child processes. I've an idea that it should either
864 * be copied by CreateProcess, or marked as inheritable
865 * when initialised, or maybe both? JG 21-9-00.
866 */
867 DuplicateHandle(GetCurrentProcess(),hand,GetCurrentProcess(),
868 &newhand,0,TRUE,DUPLICATE_SAME_ACCESS);
869 }
870 return (long)newhand;
871}
872
873/*********************************************************************
874 * _isatty (MSVCRT.@)
875 */
876int MSVCRT__isatty(int fd)
877{
878 HANDLE hand = msvcrt_fdtoh(fd);
879
880 TRACE(":fd (%d) handle (%p)\n",fd,hand);
881 if (hand == INVALID_HANDLE_VALUE)
882 return 0;
883
884 return GetFileType(hand) == FILE_TYPE_CHAR? 1 : 0;
885}
886
887/*********************************************************************
888 * _mktemp (MSVCRT.@)
889 */
890char *_mktemp(char *pattern)
891{
892 int numX = 0;
893 char *retVal = pattern;
894 int id;
895 char letter = 'a';
896
897 while(*pattern)
898 numX = (*pattern++ == 'X')? numX + 1 : 0;
899 if (numX < 5)
900 return NULL;
901 pattern--;
902 id = GetCurrentProcessId();
903 numX = 6;
904 while(numX--)
905 {
906 int tempNum = id / 10;
907 *pattern-- = id - (tempNum * 10) + '0';
908 id = tempNum;
909 }
910 pattern++;
911 do
912 {
913 if (GetFileAttributesA(retVal) == 0xFFFFFFFF &&
914 GetLastError() == ERROR_FILE_NOT_FOUND)
915 return retVal;
916 *pattern = letter++;
917 } while(letter != '|');
918 return NULL;
919}
920
921#endif /* !__MINIVCRT__ */
922
923/*********************************************************************
924 * _wmktemp (MSVCRT.@)
925 */
926MSVCRT_wchar_t *_wmktemp(MSVCRT_wchar_t *pattern)
927{
928 int numX = 0;
929 MSVCRT_wchar_t *retVal = pattern;
930 int id;
931 MSVCRT_wchar_t letter = 'a';
932
933 while(*pattern)
934 numX = (*pattern++ == 'X')? numX + 1 : 0;
935 if (numX < 5)
936 return NULL;
937 pattern--;
938 id = GetCurrentProcessId();
939 numX = 6;
940 while(numX--)
941 {
942 int tempNum = id / 10;
943 *pattern-- = id - (tempNum * 10) + '0';
944 id = tempNum;
945 }
946 pattern++;
947 do
948 {
949 if (GetFileAttributesW(retVal) == 0xFFFFFFFF &&
950 GetLastError() == ERROR_FILE_NOT_FOUND)
951 return retVal;
952 *pattern = letter++;
953 } while(letter != '|');
954 return NULL;
955}
956
957#ifndef __MINIVCRT__
958
959/*********************************************************************
960 * _sopen (MSVCRT.@)
961 */
962int MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
963{
964 va_list ap;
965 int pmode;
966 DWORD access = 0, creation = 0;
967 DWORD sharing;
968 int ioflag = 0, fd;
969 HANDLE hand;
970 SECURITY_ATTRIBUTES sa;
971
972
973 TRACE(":file (%s) oflags: 0x%04x shflags: 0x%04x\n",
974 path, oflags, shflags);
975
976 switch(oflags & (_O_RDONLY | _O_WRONLY | _O_RDWR))
977 {
978 case _O_RDONLY:
979 access |= GENERIC_READ;
980 ioflag |= MSVCRT__IOREAD;
981 break;
982 case _O_WRONLY:
983 access |= GENERIC_WRITE;
984 ioflag |= MSVCRT__IOWRT;
985 break;
986 case _O_RDWR:
987 access |= GENERIC_WRITE | GENERIC_READ;
988 ioflag |= MSVCRT__IORW;
989 break;
990 }
991
992 if (oflags & _O_CREAT)
993 {
994 va_start(ap, shflags);
995 pmode = va_arg(ap, int);
996 va_end(ap);
997
998 FIXME(": pmode 0x%04x ignored\n", pmode);
999
1000 if (oflags & _O_EXCL)
1001 creation = CREATE_NEW;
1002 else if (oflags & _O_TRUNC)
1003 creation = CREATE_ALWAYS;
1004 else
1005 creation = OPEN_ALWAYS;
1006 }
1007 else /* no _O_CREAT */
1008 {
1009 if (oflags & _O_TRUNC)
1010 creation = TRUNCATE_EXISTING;
1011 else
1012 creation = OPEN_EXISTING;
1013 }
1014 if (oflags & _O_APPEND)
1015 ioflag |= MSVCRT__IOAPPEND;
1016
1017
1018 if (oflags & _O_BINARY)
1019 ioflag |= _O_BINARY;
1020 else if (oflags & _O_TEXT)
1021 ioflag |= _O_TEXT;
1022 else if (*__p__fmode() & _O_BINARY)
1023 ioflag |= _O_BINARY;
1024 else
1025 ioflag |= _O_TEXT; /* default to TEXT*/
1026
1027 switch( shflags )
1028 {
1029 case _SH_DENYRW:
1030 sharing = 0L;
1031 break;
1032 case _SH_DENYWR:
1033 sharing = FILE_SHARE_READ;
1034 break;
1035 case _SH_DENYRD:
1036 sharing = FILE_SHARE_WRITE;
1037 break;
1038 case _SH_DENYNO:
1039 sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1040 break;
1041 default:
1042 ERR( "Unhandled shflags 0x%x\n", shflags );
1043 return -1;
1044 }
1045
1046 if (oflags & ~(_O_BINARY|_O_TEXT|_O_APPEND|_O_TRUNC|_O_EXCL
1047 |_O_CREAT|_O_RDWR|_O_TEMPORARY|_O_NOINHERIT))
1048 TRACE(":unsupported oflags 0x%04x\n",oflags);
1049
1050 sa.nLength = sizeof( SECURITY_ATTRIBUTES );
1051 sa.lpSecurityDescriptor = NULL;
1052 sa.bInheritHandle = (oflags & _O_NOINHERIT) ? FALSE : TRUE;
1053
1054 hand = CreateFileA(path, access, sharing,
1055 &sa, creation, FILE_ATTRIBUTE_NORMAL, 0);
1056
1057 if (hand == INVALID_HANDLE_VALUE) {
1058 WARN(":failed-last error (%ld)\n",GetLastError());
1059 MSVCRT__set_errno(GetLastError());
1060 return -1;
1061 }
1062
1063 fd = msvcrt_alloc_fd(hand, ioflag);
1064
1065 TRACE(":fd (%d) handle (%p)\n",fd, hand);
1066
1067 if (fd > 0)
1068 {
1069 if (oflags & _O_TEMPORARY)
1070 MSVCRT_tempfiles[fd] = MSVCRT__strdup(path);
1071 if (ioflag & MSVCRT__IOAPPEND)
1072 MSVCRT__lseek(fd, 0, FILE_END);
1073 }
1074
1075 return fd;
1076}
1077
1078/*********************************************************************
1079 * _wsopen (MSVCRT.@)
1080 */
1081int MSVCRT__wsopen( const MSVCRT_wchar_t* path, int oflags, int shflags, ... )
1082{
1083 const unsigned int len = strlenW(path);
1084 char *patha = MSVCRT_calloc(len + 1,1);
1085 va_list ap;
1086 int pmode;
1087
1088 va_start(ap, shflags);
1089 pmode = va_arg(ap, int);
1090 va_end(ap);
1091
1092 if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
1093 {
1094 int retval = MSVCRT__sopen(patha,oflags,shflags,pmode);
1095 MSVCRT_free(patha);
1096 return retval;
1097 }
1098
1099 MSVCRT__set_errno(GetLastError());
1100 return -1;
1101}
1102
1103/*********************************************************************
1104 * _open (MSVCRT.@)
1105 */
1106int MSVCRT__open( const char *path, int flags, ... )
1107{
1108 va_list ap;
1109
1110 if (flags & _O_CREAT)
1111 {
1112 int pmode;
1113 va_start(ap, flags);
1114 pmode = va_arg(ap, int);
1115 va_end(ap);
1116 return MSVCRT__sopen( path, flags, _SH_DENYNO, pmode );
1117 }
1118 else
1119 return MSVCRT__sopen( path, flags, _SH_DENYNO);
1120}
1121
1122/*********************************************************************
1123 * _wopen (MSVCRT.@)
1124 */
1125int _wopen(const MSVCRT_wchar_t *path,int flags,...)
1126{
1127 const unsigned int len = strlenW(path);
1128 char *patha = MSVCRT_calloc(len + 1,1);
1129 va_list ap;
1130 int pmode;
1131
1132 va_start(ap, flags);
1133 pmode = va_arg(ap, int);
1134 va_end(ap);
1135
1136 if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
1137 {
1138 int retval = MSVCRT__open(patha,flags,pmode);
1139 MSVCRT_free(patha);
1140 return retval;
1141 }
1142
1143 MSVCRT__set_errno(GetLastError());
1144 return -1;
1145}
1146
1147/*********************************************************************
1148 * _creat (MSVCRT.@)
1149 */
1150int MSVCRT__creat(const char *path, int flags)
1151{
1152 int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
1153 return MSVCRT__open(path, usedFlags);
1154}
1155
1156/*********************************************************************
1157 * _wcreat (MSVCRT.@)
1158 */
1159int _wcreat(const MSVCRT_wchar_t *path, int flags)
1160{
1161 int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
1162 return _wopen(path, usedFlags);
1163}
1164
1165/*********************************************************************
1166 * _open_osfhandle (MSVCRT.@)
1167 */
1168int _open_osfhandle(long hand, int flags)
1169{
1170 /* _O_RDONLY (0) always matches, so set the read flag*/
1171 /* FIXME: handle more flags */
1172 int fd= msvcrt_alloc_fd((HANDLE)hand,flags|MSVCRT__IOREAD);
1173 TRACE(":handle (%ld) fd (%d) flags 0x%08x\n",hand,fd, flags |MSVCRT__IOREAD);
1174 return fd;
1175}
1176
1177/*********************************************************************
1178 * _rmtmp (MSVCRT.@)
1179 */
1180int MSVCRT__rmtmp(void)
1181{
1182 int num_removed = 0, i;
1183
1184 for (i = 3; i < MSVCRT_fdend; i++)
1185 if (MSVCRT_tempfiles[i])
1186 {
1187 MSVCRT__close(i);
1188 num_removed++;
1189 }
1190
1191 if (num_removed)
1192 TRACE(":removed (%d) temp files\n",num_removed);
1193 return num_removed;
1194}
1195
1196/*********************************************************************
1197 * _read (MSVCRT.@)
1198 */
1199int MSVCRT__read(int fd, void *buf, unsigned int count)
1200{
1201 DWORD num_read;
1202 HANDLE hand = msvcrt_fdtoh(fd);
1203
1204 /* Dont trace small reads, it gets *very* annoying */
1205 if (count > 4)
1206 TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n",fd,hand,buf,count);
1207 if (hand == INVALID_HANDLE_VALUE)
1208 return -1;
1209
1210 if (MSVCRT_flags[fd]& _O_BINARY)
1211 {
1212 if (ReadFile(hand, buf, count, &num_read, NULL))
1213 {
1214 if (num_read != count && MSVCRT_files[fd])
1215 {
1216 TRACE(":EOF\n");
1217 MSVCRT_flags[fd] |= MSVCRT__IOEOF;
1218 /*
1219 MSVCRT_files[fd]->_flag |= MSVCRT__IOEOF;
1220 */
1221 }
1222 dprintf(("%s\n",debugstr_an(buf,num_read)));
1223 return num_read;
1224 }
1225 TRACE(":failed-last error (%ld)\n",GetLastError());
1226 if (MSVCRT_files[fd])
1227 MSVCRT_files[fd]->_flag |= MSVCRT__IOERR;
1228 return -1;
1229 }
1230 else
1231 {
1232 char cc, *s=(char*)buf,* buf_start=(char*)buf;
1233 unsigned int i;
1234
1235 for (i = 0 , num_read = 1; i < count && (num_read == 1);)
1236 {
1237 if (ReadFile(hand, &cc, 1, &num_read, NULL))
1238 if (num_read == 1)
1239 if ((cc != '\r') || MSVCRT_flags[fd] & _O_BINARY)
1240 {
1241 *s++ = (char)cc;
1242 i++;
1243 }
1244 }
1245 if (num_read != 1)
1246 {
1247 TRACE(":EOF\n");
1248 if (MSVCRT_files[fd])
1249 MSVCRT_flags[fd] |= MSVCRT__IOEOF;
1250 /*
1251 MSVCRT_files[fd]->_flag |= MSVCRT__IOEOF;
1252 */
1253 }
1254
1255 if (count > 4)
1256 dprintf(("%s\n",debugstr_an(buf_start, s-buf_start)));
1257 return s-buf_start;
1258 }
1259 return 0;
1260}
1261
1262/*********************************************************************
1263 * _getw (MSVCRT.@)
1264 */
1265int MSVCRT__getw(MSVCRT_FILE* file)
1266{
1267 int i;
1268 if (MSVCRT__read(file->_file, &i, sizeof(int)) != 1)
1269 return MSVCRT_EOF;
1270 return i;
1271}
1272
1273/*********************************************************************
1274 * _setmode (MSVCRT.@)
1275 */
1276int MSVCRT__setmode(int fd,int mode)
1277{
1278 int ret = MSVCRT_flags[fd] & (_O_TEXT | _O_BINARY);
1279 if (mode & (~(_O_TEXT|_O_BINARY)))
1280 FIXME("fd (%d) mode (0x%08x) unknown\n",fd,mode);
1281 MSVCRT_flags[fd] &= ~(_O_TEXT|_O_BINARY);
1282 MSVCRT_flags[fd] |= mode & (_O_TEXT | _O_BINARY);
1283 return ret;
1284}
1285
1286/*********************************************************************
1287 * _stati64 (MSVCRT.@)
1288 */
1289int _stati64(const char* path, struct _stati64 * buf)
1290{
1291 DWORD dw;
1292 WIN32_FILE_ATTRIBUTE_DATA hfi;
1293 unsigned short mode = MSVCRT_S_IREAD;
1294 int plen;
1295
1296 TRACE(":file (%s) buf(%p)\n",path,buf);
1297
1298 if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
1299 {
1300 TRACE("failed (%ld)\n",GetLastError());
1301 MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
1302 return -1;
1303 }
1304
1305 memset(buf,0,sizeof(struct _stati64));
1306
1307 /* FIXME: rdev isnt drive num,despite what the docs say-what is it?
1308 Bon 011120: This FIXME seems incorrect
1309 Also a letter as first char isn't enough to be classify
1310 as drive letter
1311 */
1312 if (isalpha((int)*path) && (*(path+1)==':'))
1313 buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
1314 else
1315 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
1316
1317 plen = strlen(path);
1318
1319 /* Dir, or regular file? */
1320 if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1321 (path[plen-1] == '\\'))
1322 mode |= (_S_IFDIR | MSVCRT_S_IEXEC);
1323 else
1324 {
1325 mode |= _S_IFREG;
1326 /* executable? */
1327 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
1328 {
1329 unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
1330 (tolower(path[plen-3]) << 16);
1331 if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
1332 mode |= MSVCRT_S_IEXEC;
1333 }
1334 }
1335
1336 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1337 mode |= MSVCRT_S_IWRITE;
1338
1339 buf->st_mode = mode;
1340 buf->st_nlink = 1;
1341 buf->st_size = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1342 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1343 buf->st_atime = dw;
1344 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1345 buf->st_mtime = buf->st_ctime = dw;
1346 TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf->st_mode,buf->st_nlink,
1347 (long)(buf->st_size >> 32),(long)buf->st_size,
1348 buf->st_atime,buf->st_mtime, buf->st_ctime);
1349 return 0;
1350}
1351
1352/*********************************************************************
1353 * _stat (MSVCRT.@)
1354 */
1355int MSVCRT__stat(const char* path, struct _stat * buf)
1356{ int ret;
1357 struct _stati64 bufi64;
1358
1359 ret = _stati64( path, &bufi64);
1360 if (!ret)
1361 msvcrt_cp_from_stati64(&bufi64, buf);
1362 return ret;
1363}
1364
1365#endif /* !__MINIVCRT__ */
1366
1367/*********************************************************************
1368 * _wstat (MSVCRT.@)
1369 */
1370int _wstat(const MSVCRT_wchar_t* path, struct _stat * buf)
1371{
1372 DWORD dw;
1373 WIN32_FILE_ATTRIBUTE_DATA hfi;
1374 unsigned short mode = MSVCRT_S_IREAD;
1375 int plen;
1376
1377 TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
1378
1379 if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
1380 {
1381 TRACE("failed (%ld)\n",GetLastError());
1382 MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
1383 return -1;
1384 }
1385
1386 memset(buf,0,sizeof(struct _stat));
1387
1388 /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
1389 if (MSVCRT_iswalpha(*path))
1390 buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
1391 else
1392 buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
1393
1394 plen = strlenW(path);
1395
1396 /* Dir, or regular file? */
1397 if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1398 (path[plen-1] == '\\'))
1399 mode |= (_S_IFDIR | MSVCRT_S_IEXEC);
1400 else
1401 {
1402 mode |= _S_IFREG;
1403 /* executable? */
1404 if (plen > 6 && path[plen-4] == '.') /* shortest exe: "\x.exe" */
1405 {
1406 ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
1407 ((ULONGLONG)tolowerW(path[plen-3]) << 32);
1408 if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
1409 mode |= MSVCRT_S_IEXEC;
1410 }
1411 }
1412
1413 if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1414 mode |= MSVCRT_S_IWRITE;
1415
1416 buf->st_mode = mode;
1417 buf->st_nlink = 1;
1418 buf->st_size = hfi.nFileSizeLow;
1419 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1420 buf->st_atime = dw;
1421 RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1422 buf->st_mtime = buf->st_ctime = dw;
1423 TRACE("\n%d %d %d %ld %ld %ld\n", buf->st_mode,buf->st_nlink,buf->st_size,
1424 buf->st_atime,buf->st_mtime, buf->st_ctime);
1425 return 0;
1426}
1427
1428#ifndef __MINIVCRT__
1429
1430/*********************************************************************
1431 * _tell (MSVCRT.@)
1432 */
1433LONG MSVCRT__tell(int fd)
1434{
1435 return MSVCRT__lseek(fd, 0, SEEK_CUR);
1436}
1437
1438/*********************************************************************
1439 * _tempnam (MSVCRT.@)
1440 */
1441char *MSVCRT__tempnam(const char *dir, const char *prefix)
1442{
1443 char tmpbuf[MAX_PATH];
1444
1445 TRACE("dir (%s) prefix (%s)\n",dir,prefix);
1446 if (GetTempFileNameA(dir,prefix,0,tmpbuf))
1447 {
1448 TRACE("got name (%s)\n",tmpbuf);
1449 return MSVCRT__strdup(tmpbuf);
1450 }
1451 TRACE("failed (%ld)\n",GetLastError());
1452 return NULL;
1453}
1454
1455#endif /* !__MINIVCRT__ */
1456
1457/*********************************************************************
1458 * _wtempnam (MSVCRT.@)
1459 */
1460MSVCRT_wchar_t *_wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
1461{
1462 MSVCRT_wchar_t tmpbuf[MAX_PATH];
1463
1464 TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
1465 if (GetTempFileNameW(dir,prefix,0,tmpbuf))
1466 {
1467 TRACE("got name (%s)\n",debugstr_w(tmpbuf));
1468 return _wcsdup(tmpbuf);
1469 }
1470 TRACE("failed (%ld)\n",GetLastError());
1471 return NULL;
1472}
1473
1474#ifndef __MINIVCRT__
1475
1476/*********************************************************************
1477 * _umask (MSVCRT.@)
1478 */
1479int MSVCRT_umask(int umask)
1480{
1481 int old_umask = MSVCRT__umask;
1482 TRACE("MSVCRT: _umask (%d)\n",umask);
1483 MSVCRT__umask = umask;
1484 return old_umask;
1485}
1486
1487/*********************************************************************
1488 * _utime (MSVCRT.@)
1489 */
1490int MSVCRT_utime(const char* path, struct _utimbuf *t)
1491{
1492 int fd = MSVCRT__open(path, _O_WRONLY | _O_BINARY);
1493
1494 if (fd > 0)
1495 {
1496 int retVal = _futime(fd, t);
1497 MSVCRT__close(fd);
1498 return retVal;
1499 }
1500 return -1;
1501}
1502
1503/*********************************************************************
1504 * _wutime (MSVCRT.@)
1505 */
1506int _wutime(const MSVCRT_wchar_t* path, struct _utimbuf *t)
1507{
1508 int fd = _wopen(path, _O_WRONLY | _O_BINARY);
1509
1510 if (fd > 0)
1511 {
1512 int retVal = _futime(fd, t);
1513 MSVCRT__close(fd);
1514 return retVal;
1515 }
1516 return -1;
1517}
1518
1519/*********************************************************************
1520 * _write (MSVCRT.@)
1521 */
1522int MSVCRT__write(int fd, const void* buf, unsigned int count)
1523{
1524 DWORD num_written;
1525 HANDLE hand = msvcrt_fdtoh(fd);
1526
1527 /* Dont trace small writes, it gets *very* annoying */
1528#if 0
1529 if (count > 32)
1530 TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
1531#endif
1532 if (hand == INVALID_HANDLE_VALUE)
1533 {
1534 *MSVCRT__errno() = MSVCRT_EBADF;
1535 return -1;
1536 }
1537
1538 /* If appending, go to EOF */
1539 if (MSVCRT_flags[fd] & MSVCRT__IOAPPEND)
1540 MSVCRT__lseek(fd, 0, FILE_END);
1541
1542 if (MSVCRT_flags[fd] & _O_BINARY)
1543 {
1544 if (WriteFile(hand, buf, count, &num_written, NULL)
1545 && (num_written >= count))
1546 return num_written;
1547 TRACE(":failed-last error (%ld)\n",GetLastError());
1548 if (MSVCRT_files[fd])
1549 {
1550 MSVCRT_files[fd]->_flag |= MSVCRT__IOERR;
1551 *MSVCRT__errno() = MSVCRT_ENOSPC;
1552 }
1553 }
1554 else
1555 {
1556 char *s=(char*)buf, *buf_start=(char*)buf, *p;
1557 char crlf[]= {'\r','\n'};
1558 unsigned int i;
1559 DWORD num_to_write;
1560 for (i = 0; i< count && !(MSVCRT_flags[fd] & MSVCRT__IOERR);i++, s++)
1561 {
1562 if (*s == '\n')
1563 {
1564 p = crlf;
1565 num_to_write = 2;
1566 }
1567 else
1568 {
1569 p = s;
1570 num_to_write = 1;
1571 }
1572 if ((WriteFile(hand, p, num_to_write, &num_written, NULL) == 0 ) || (num_written != num_to_write))
1573 {
1574 TRACE(":failed-last error (%ld) num_written %ld\n",GetLastError(),num_written);
1575 if (MSVCRT_files[fd])
1576 {
1577 MSVCRT_files[fd]->_flag |= MSVCRT__IOERR;
1578 *MSVCRT__errno() = MSVCRT_ENOSPC;
1579 return s - buf_start;
1580 }
1581 }
1582 }
1583 return s - buf_start;
1584 }
1585 return -1;
1586}
1587
1588/*********************************************************************
1589 * _putw (MSVCRT.@)
1590 */
1591int MSVCRT__putw(int val, MSVCRT_FILE* file)
1592{
1593 return MSVCRT__write(file->_file, &val, sizeof(val)) == 1? val : MSVCRT_EOF;
1594}
1595
1596/*********************************************************************
1597 * clearerr (MSVCRT.@)
1598 */
1599void MSVCRT_clearerr(MSVCRT_FILE* file)
1600{
1601 TRACE(":file (%p) fd (%d)\n",file,file->_file);
1602 file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
1603}
1604
1605/*********************************************************************
1606 * fclose (MSVCRT.@)
1607 */
1608int MSVCRT_fclose(MSVCRT_FILE* file)
1609{
1610 int r;
1611 r=MSVCRT__close(file->_file);
1612 return ((r==MSVCRT_EOF) || (file->_flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
1613}
1614
1615/*********************************************************************
1616 * feof (MSVCRT.@)
1617 */
1618int MSVCRT_feof(MSVCRT_FILE* file)
1619{
1620 return file->_flag & MSVCRT__IOEOF;
1621}
1622
1623/*********************************************************************
1624 * ferror (MSVCRT.@)
1625 */
1626int MSVCRT_ferror(MSVCRT_FILE* file)
1627{
1628 return file->_flag & MSVCRT__IOERR;
1629}
1630
1631/*********************************************************************
1632 * fflush (MSVCRT.@)
1633 */
1634int MSVCRT_fflush(MSVCRT_FILE* file)
1635{
1636 if(!file) {
1637 MSVCRT__flushall();
1638 return 0;
1639 } else {
1640 int res=msvcrt_flush_buffer(file);
1641 return res;
1642 }
1643}
1644
1645/*********************************************************************
1646 * fgetc (MSVCRT.@)
1647 */
1648int MSVCRT_fgetc(MSVCRT_FILE* file)
1649{
1650 if (file->_cnt>0) {
1651 file->_cnt--;
1652 return *(unsigned char *)file->_ptr++;
1653 } else {
1654 return _filbuf(file);
1655 }
1656}
1657
1658/*********************************************************************
1659 * _fgetchar (MSVCRT.@)
1660 */
1661int MSVCRT__fgetchar(void)
1662{
1663 return MSVCRT_fgetc(MSVCRT_stdin);
1664}
1665
1666/*********************************************************************
1667 * _filbuf (MSVCRT.@)
1668 */
1669int _filbuf(MSVCRT_FILE* file)
1670{
1671
1672 /* Allocate buffer if needed */
1673 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF) ) {
1674 msvcrt_alloc_buffer(file);
1675 }
1676 if(!(file->_flag & MSVCRT__IOREAD)) {
1677 if(file->_flag & MSVCRT__IORW) {
1678 file->_flag |= MSVCRT__IOREAD;
1679 } else {
1680 return MSVCRT_EOF;
1681 }
1682 }
1683 if(file->_flag & MSVCRT__IONBF) {
1684 unsigned char c;
1685 if (MSVCRT__read(file->_file,&c,1) != 1) {
1686 file->_flag |= MSVCRT__IOEOF;
1687 return MSVCRT_EOF;
1688 }
1689 return c;
1690 } else {
1691 file->_cnt = MSVCRT__read(file->_file, file->_base, file->_bufsiz);
1692 if(file->_cnt<0) file->_cnt = 0;
1693 if(!file->_cnt) {
1694 file->_flag |= MSVCRT__IOEOF;
1695 return MSVCRT_EOF;
1696 }
1697 file->_cnt--;
1698 file->_ptr = file->_base+1;
1699 return *(unsigned char *)file->_base;
1700 }
1701}
1702
1703/*********************************************************************
1704 * fgetpos (MSVCRT.@)
1705 */
1706int MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
1707{
1708 *pos = MSVCRT_ftell(file);
1709 return (*pos == -1? -1 : 0);
1710}
1711
1712/*********************************************************************
1713 * fgets (MSVCRT.@)
1714 */
1715char *MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
1716{
1717 int cc;
1718 char * buf_start = s;
1719
1720 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
1721 file,file->_file,s,size);
1722
1723 for(cc = MSVCRT_fgetc(file); cc != MSVCRT_EOF && cc != '\n';
1724 cc = MSVCRT_fgetc(file))
1725 if (cc != '\r')
1726 {
1727 if (--size <= 0) break;
1728 *s++ = (char)cc;
1729 }
1730 if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
1731 {
1732 TRACE(":nothing read\n");
1733 return 0;
1734 }
1735 if (cc == '\n')
1736 if (--size > 0)
1737 *s++ = '\n';
1738 *s = '\0';
1739 TRACE(":got '%s'\n", buf_start);
1740 return buf_start;
1741}
1742
1743/*********************************************************************
1744 * fgetwc (MSVCRT.@)
1745 *
1746 * In _O_TEXT mode, bultibyte characters are read from the file, dropping
1747 * the CR from CR/LF combinations
1748 */
1749MSVCRT_wint_t MSVCRT_fgetwc(MSVCRT_FILE* file)
1750{
1751 char c;
1752
1753 if (file->_flag & _O_BINARY)
1754 {
1755 MSVCRT_wchar_t wc;
1756 if (MSVCRT__read(file->_file, &wc, sizeof(wc)) != sizeof(wc))
1757 return MSVCRT_WEOF;
1758 return wc;
1759 }
1760 c = MSVCRT_fgetc(file);
1761 if ((*__p___mb_cur_max() > 1) && MSVCRT_isleadbyte(c))
1762 {
1763 FIXME("Treat Multibyte characters\n");
1764 }
1765 if (c == MSVCRT_EOF)
1766 return MSVCRT_WEOF;
1767 else
1768 return (MSVCRT_wint_t)c;
1769}
1770
1771/*********************************************************************
1772 * getwc (MSVCRT.@)
1773 */
1774MSVCRT_wint_t MSVCRT_getwc(MSVCRT_FILE* file)
1775{
1776 return MSVCRT_fgetwc(file);
1777}
1778
1779/*********************************************************************
1780 * _fgetwchar (MSVCRT.@)
1781 */
1782MSVCRT_wint_t _fgetwchar(void)
1783{
1784 return MSVCRT_fgetwc(MSVCRT_stdin);
1785}
1786
1787/*********************************************************************
1788 * getwchar (MSVCRT.@)
1789 */
1790MSVCRT_wint_t MSVCRT_getwchar(void)
1791{
1792 return _fgetwchar();
1793}
1794
1795/*********************************************************************
1796 * fgetws (MSVCRT.@)
1797 */
1798MSVCRT_wchar_t *MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
1799{
1800 int cc;
1801 MSVCRT_wchar_t * buf_start = s;
1802
1803 TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
1804 file,file->_file,s,size);
1805
1806 for(cc = MSVCRT_fgetwc(file); cc != MSVCRT_WEOF && cc != L'\n';
1807 cc = MSVCRT_fgetwc(file))
1808 if (cc != L'\r')
1809 {
1810 if (--size <= 0) break;
1811 *s++ = cc;
1812 }
1813 if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
1814 {
1815 TRACE(":nothing read\n");
1816 return 0;
1817 }
1818 if (cc == L'\n')
1819 if (--size > 0)
1820 *s++ = '\n';
1821 *s = '\0';
1822/* TRACE(":got '%s'\n", buf_start); */
1823 return buf_start;
1824}
1825
1826
1827/*********************************************************************
1828 * fputwc (MSVCRT.@)
1829 */
1830MSVCRT_wint_t MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
1831{
1832 MSVCRT_wchar_t mwc=wc;
1833 if (MSVCRT_fwrite( &mwc, sizeof(mwc), 1, file) != 1)
1834 return MSVCRT_WEOF;
1835 return wc;
1836}
1837
1838/*********************************************************************
1839 * _fputwchar (MSVCRT.@)
1840 */
1841MSVCRT_wint_t _fputwchar(MSVCRT_wint_t wc)
1842{
1843 return MSVCRT_fputwc(wc, MSVCRT_stdout);
1844}
1845
1846/*********************************************************************
1847 * fopen (MSVCRT.@)
1848 */
1849MSVCRT_FILE* MSVCRT_fopen(const char *path, const char *mode)
1850{
1851 MSVCRT_FILE* file;
1852 int flags = 0, plus = 0, fd;
1853 const char* search = mode;
1854
1855 TRACE("(%s,%s)\n",path,mode);
1856
1857 while (*search)
1858 if (*search++ == '+')
1859 plus = 1;
1860
1861 /* map mode string to open() flags. "man fopen" for possibilities. */
1862 switch(*mode++)
1863 {
1864 case 'R': case 'r':
1865 flags = (plus ? _O_RDWR : _O_RDONLY);
1866 break;
1867 case 'W': case 'w':
1868 flags = _O_CREAT | _O_TRUNC | (plus ? _O_RDWR : _O_WRONLY);
1869 break;
1870 case 'A': case 'a':
1871 flags = _O_CREAT | _O_APPEND | (plus ? _O_RDWR : _O_WRONLY);
1872 break;
1873 default:
1874 return NULL;
1875 }
1876
1877 while (*mode)
1878 switch (*mode++)
1879 {
1880 case 'B': case 'b':
1881 flags |= _O_BINARY;
1882 flags &= ~_O_TEXT;
1883 break;
1884 case 'T': case 't':
1885 flags |= _O_TEXT;
1886 flags &= ~_O_BINARY;
1887 break;
1888 case '+':
1889 break;
1890 default:
1891 FIXME(":unknown flag %c not supported\n",mode[-1]);
1892 }
1893
1894 fd = MSVCRT__open(path, flags);
1895
1896 if (fd < 0)
1897 return NULL;
1898
1899 file = msvcrt_alloc_fp(fd);
1900 TRACE(":got (%p)\n",file);
1901 if (!file)
1902 MSVCRT__close(fd);
1903
1904 return file;
1905}
1906
1907/*********************************************************************
1908 * _wfopen (MSVCRT.@)
1909 */
1910MSVCRT_FILE *_wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
1911{
1912 const unsigned int plen = strlenW(path), mlen = strlenW(mode);
1913 char *patha = MSVCRT_calloc(plen + 1, 1);
1914 char *modea = MSVCRT_calloc(mlen + 1, 1);
1915
1916 TRACE("(%s,%s)\n",debugstr_w(path),debugstr_w(mode));
1917
1918 if (patha && modea &&
1919 WideCharToMultiByte(CP_ACP,0,path,plen,patha,plen,NULL,NULL) &&
1920 WideCharToMultiByte(CP_ACP,0,mode,mlen,modea,mlen,NULL,NULL))
1921 {
1922 MSVCRT_FILE *retval = MSVCRT_fopen(patha,modea);
1923 MSVCRT_free(patha);
1924 MSVCRT_free(modea);
1925 return retval;
1926 }
1927
1928 MSVCRT__set_errno(GetLastError());
1929 return NULL;
1930}
1931
1932/*********************************************************************
1933 * _fsopen (MSVCRT.@)
1934 */
1935MSVCRT_FILE* MSVCRT__fsopen(const char *path, const char *mode, int share)
1936{
1937 FIXME(":(%s,%s,%d),ignoring share mode!\n",path,mode,share);
1938 return MSVCRT_fopen(path,mode);
1939}
1940
1941/*********************************************************************
1942 * _wfsopen (MSVCRT.@)
1943 */
1944MSVCRT_FILE* _wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
1945{
1946 FIXME(":(%s,%s,%d),ignoring share mode!\n",
1947 debugstr_w(path),debugstr_w(mode),share);
1948 return _wfopen(path,mode);
1949}
1950
1951/*********************************************************************
1952 * fputc (MSVCRT.@)
1953 */
1954int MSVCRT_fputc(int c, MSVCRT_FILE* file)
1955{
1956 if(file->_cnt>0) {
1957 *file->_ptr++=c;
1958 file->_cnt--;
1959 return c;
1960 } else {
1961 return _flsbuf(c, file);
1962 }
1963}
1964
1965/*********************************************************************
1966 * _flsbuf (MSVCRT.@)
1967 */
1968int _flsbuf(int c, MSVCRT_FILE* file)
1969{
1970 /* Flush output buffer */
1971 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
1972 msvcrt_alloc_buffer(file);
1973 }
1974 if(!(file->_flag & MSVCRT__IOWRT)) {
1975 if(file->_flag & MSVCRT__IORW) {
1976 file->_flag |= MSVCRT__IOWRT;
1977 } else {
1978 return MSVCRT_EOF;
1979 }
1980 }
1981 if(file->_bufsiz) {
1982 int res=msvcrt_flush_buffer(file);
1983 return res?res : MSVCRT_fputc(c, file);
1984 } else {
1985 unsigned char cc=c;
1986 return MSVCRT__write(file->_file, &cc, 1) == 1? c : MSVCRT_EOF;
1987 }
1988}
1989
1990/*********************************************************************
1991 * _fputchar (MSVCRT.@)
1992 */
1993int MSVCRT__fputchar(int c)
1994{
1995 return MSVCRT_fputc(c, MSVCRT_stdout);
1996}
1997
1998/*********************************************************************
1999 * fread (MSVCRT.@)
2000 */
2001MSVCRT_size_t MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
2002{ MSVCRT_size_t rcnt=size * nmemb;
2003 MSVCRT_size_t read=0;
2004 int pread=0;
2005 /* first buffered data */
2006 if(file->_cnt>0) {
2007 int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
2008 memcpy(ptr, file->_ptr, pcnt);
2009 file->_cnt -= pcnt;
2010 file->_ptr += pcnt;
2011 read += pcnt ;
2012 rcnt -= pcnt ;
2013 ptr = (char*)ptr + pcnt;
2014 } else if(!(file->_flag & MSVCRT__IOREAD )) {
2015 if(file->_flag & MSVCRT__IORW) {
2016 file->_flag |= MSVCRT__IOREAD;
2017 } else
2018 return 0;
2019 }
2020 if(rcnt) pread = MSVCRT__read(file->_file,ptr, rcnt);
2021 if (MSVCRT_flags[file->_file] & MSVCRT__IOEOF)
2022 /* expose feof condition in the flags
2023 MFC tests file->_flag for feof, and doesn't not call feof())
2024 */
2025 file->_flag |= MSVCRT__IOEOF;
2026 if (pread <= 0)
2027 pread = 0;
2028 read+=pread;
2029 return read / size;
2030}
2031
2032/*********************************************************************
2033 * freopen (MSVCRT.@)
2034 *
2035 */
2036MSVCRT_FILE* MSVCRT_freopen(const char *path, const char *mode,MSVCRT_FILE* file)
2037{
2038 MSVCRT_FILE* newfile;
2039 int fd;
2040
2041 TRACE(":path (%p) mode (%s) file (%p) fd (%d)\n",path,mode,file,file->_file);
2042 if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
2043 return NULL;
2044
2045 if (fd > 2)
2046 {
2047#if 0
2048 FIXME(":reopen on user file not implemented!\n");
2049 MSVCRT__set_errno(ERROR_CALL_NOT_IMPLEMENTED);
2050 return NULL;
2051#endif
2052 if(MSVCRT_fclose(file))
2053 return NULL;
2054 return MSVCRT_fopen(path, mode);
2055 }
2056
2057 /* first, create the new file */
2058 if ((newfile = MSVCRT_fopen(path,mode)) == NULL)
2059 return NULL;
2060
2061 if (fd < 3 && SetStdHandle(fd == 0 ? STD_INPUT_HANDLE :
2062 (fd == 1? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE),
2063 MSVCRT_handles[newfile->_file]))
2064 {
2065 /* Redirecting std handle to file , copy over.. */
2066 MSVCRT_handles[fd] = MSVCRT_handles[newfile->_file];
2067 MSVCRT_flags[fd] = MSVCRT_flags[newfile->_file];
2068 memcpy(&MSVCRT__iob[fd], newfile, sizeof (MSVCRT_FILE));
2069 MSVCRT__iob[fd]._file = fd;
2070 /* And free up the resources allocated by fopen, but
2071 * not the HANDLE we copied. */
2072 MSVCRT_free(MSVCRT_files[fd]);
2073 msvcrt_free_fd(newfile->_file);
2074 return &MSVCRT__iob[fd];
2075 }
2076
2077 WARN(":failed-last error (%ld)\n",GetLastError());
2078 MSVCRT_fclose(newfile);
2079 MSVCRT__set_errno(GetLastError());
2080 return NULL;
2081}
2082
2083/*********************************************************************
2084 * fsetpos (MSVCRT.@)
2085 */
2086int MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
2087{
2088 return MSVCRT__lseek(file->_file,*pos,SEEK_SET);
2089}
2090
2091/*********************************************************************
2092 * fseek (MSVCRT.@)
2093 */
2094int MSVCRT_fseek(MSVCRT_FILE* file, long offset, int whence)
2095{
2096 /* Flush output if needed */
2097 if(file->_flag & MSVCRT__IOWRT)
2098 msvcrt_flush_buffer(file);
2099
2100 if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
2101 offset -= file->_cnt;
2102 }
2103 /* Discard buffered input */
2104 file->_cnt = 0;
2105 file->_ptr = file->_base;
2106 /* Reset direction of i/o */
2107 if(file->_flag & MSVCRT__IORW) {
2108 file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
2109 }
2110 return (MSVCRT__lseek(file->_file,offset,whence) == -1)?-1:0;
2111}
2112
2113/*********************************************************************
2114 * ftell (MSVCRT.@)
2115 */
2116LONG MSVCRT_ftell(MSVCRT_FILE* file)
2117{
2118 int off=0;
2119 long pos;
2120 if(file->_bufsiz) {
2121 if( file->_flag & MSVCRT__IOWRT ) {
2122 off = file->_ptr - file->_base;
2123 } else {
2124 off = -file->_cnt;
2125 }
2126 }
2127 pos = MSVCRT__tell(file->_file);
2128 if(pos == -1) return pos;
2129 return off + pos;
2130}
2131
2132/*********************************************************************
2133 * fwrite (MSVCRT.@)
2134 */
2135MSVCRT_size_t MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
2136{
2137 MSVCRT_size_t wrcnt=size * nmemb;
2138 int written = 0;
2139 if (size == 0)
2140 return 0;
2141 if(file->_cnt) {
2142 int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
2143 memcpy(file->_ptr, ptr, pcnt);
2144 file->_cnt -= pcnt;
2145 file->_ptr += pcnt;
2146 written = pcnt;
2147 wrcnt -= pcnt;
2148 ptr = (char*)ptr + pcnt;
2149 } else if(!(file->_flag & MSVCRT__IOWRT)) {
2150 if(file->_flag & MSVCRT__IORW) {
2151 file->_flag |= MSVCRT__IOWRT;
2152 } else
2153 return 0;
2154 }
2155 if(wrcnt) {
2156 /* Flush buffer */
2157 int res=msvcrt_flush_buffer(file);
2158 if(!res) {
2159 int pwritten = MSVCRT__write(file->_file, ptr, wrcnt);
2160 if (pwritten <= 0) pwritten=0;
2161 written += pwritten;
2162 }
2163 }
2164 return written / size;
2165}
2166
2167/*********************************************************************
2168 * fputs (MSVCRT.@)
2169 */
2170int MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
2171{
2172 size_t i, len = strlen(s);
2173 if (file->_flag & _O_BINARY)
2174 return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
2175 for (i=0; i<len; i++)
2176 if (MSVCRT_fputc(s[i], file) == MSVCRT_EOF)
2177 return MSVCRT_EOF;
2178 return 0;
2179}
2180
2181/*********************************************************************
2182 * fputws (MSVCRT.@)
2183 */
2184int MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
2185{
2186 size_t i, len = strlenW(s);
2187 if (file->_flag & _O_BINARY)
2188 return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
2189 for (i=0; i<len; i++)
2190 {
2191 if ((s[i] == L'\n') && (MSVCRT_fputc('\r', file) == MSVCRT_EOF))
2192 return MSVCRT_WEOF;
2193 if (MSVCRT_fputwc(s[i], file) == MSVCRT_WEOF)
2194 return MSVCRT_WEOF;
2195 }
2196 return 0;
2197}
2198
2199
2200/*********************************************************************
2201 * getchar (MSVCRT.@)
2202 */
2203int MSVCRT_getchar(void)
2204{
2205 return MSVCRT_fgetc(MSVCRT_stdin);
2206}
2207
2208/*********************************************************************
2209 * getc (MSVCRT.@)
2210 */
2211int MSVCRT_getc(MSVCRT_FILE* file)
2212{
2213 return MSVCRT_fgetc(file);
2214}
2215
2216/*********************************************************************
2217 * gets (MSVCRT.@)
2218 */
2219char *MSVCRT_gets(char *buf)
2220{
2221 int cc;
2222 char * buf_start = buf;
2223
2224 for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
2225 cc = MSVCRT_fgetc(MSVCRT_stdin))
2226 if(cc != '\r') *buf++ = (char)cc;
2227
2228 *buf = '\0';
2229
2230 TRACE("got '%s'\n", buf_start);
2231 return buf_start;
2232}
2233
2234/*********************************************************************
2235 * _getws (MSVCRT.@)
2236 */
2237MSVCRT_wchar_t* MSVCRT__getws(MSVCRT_wchar_t* buf)
2238{
2239 MSVCRT_wint_t cc;
2240 MSVCRT_wchar_t* ws = buf;
2241
2242 for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
2243 cc = MSVCRT_fgetwc(MSVCRT_stdin))
2244 {
2245 if (cc != '\r')
2246 *buf++ = (MSVCRT_wchar_t)cc;
2247 }
2248 *buf = '\0';
2249
2250 TRACE("got '%s'\n", debugstr_w(ws));
2251 return ws;
2252}
2253
2254/*********************************************************************
2255 * putc (MSVCRT.@)
2256 */
2257int MSVCRT_putc(int c, MSVCRT_FILE* file)
2258{
2259 return MSVCRT_fputc(c, file);
2260}
2261
2262/*********************************************************************
2263 * putchar (MSVCRT.@)
2264 */
2265int MSVCRT_putchar(int c)
2266{
2267 return MSVCRT_fputc(c, MSVCRT_stdout);
2268}
2269
2270/*********************************************************************
2271 * puts (MSVCRT.@)
2272 */
2273int MSVCRT_puts(const char *s)
2274{
2275 size_t len = strlen(s);
2276 if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
2277 return MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
2278}
2279
2280/*********************************************************************
2281 * _putws (MSVCRT.@)
2282 */
2283int _putws(const MSVCRT_wchar_t *s)
2284{
2285 static const MSVCRT_wchar_t nl = '\n';
2286 size_t len = strlenW(s);
2287 if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
2288 return MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
2289}
2290
2291/*********************************************************************
2292 * remove (MSVCRT.@)
2293 */
2294int MSVCRT_remove(const char *path)
2295{
2296 TRACE("(%s)\n",path);
2297 if (DeleteFileA(path))
2298 return 0;
2299 TRACE(":failed (%ld)\n",GetLastError());
2300 MSVCRT__set_errno(GetLastError());
2301 return -1;
2302}
2303
2304#endif /* !__MINIVCRT__ */
2305
2306/*********************************************************************
2307 * _wremove (MSVCRT.@)
2308 */
2309int _wremove(const MSVCRT_wchar_t *path)
2310{
2311 TRACE("(%s)\n",debugstr_w(path));
2312 if (DeleteFileW(path))
2313 return 0;
2314 TRACE(":failed (%ld)\n",GetLastError());
2315 MSVCRT__set_errno(GetLastError());
2316 return -1;
2317}
2318
2319#ifndef __MINIVCRT__
2320
2321/*********************************************************************
2322 * scanf (MSVCRT.@)
2323 */
2324int MSVCRT_scanf(const char *format, ...)
2325{
2326 va_list valist;
2327 int res;
2328
2329 va_start(valist, format);
2330 res = MSVCRT_fscanf(MSVCRT_stdin, format, valist);
2331 va_end(valist);
2332 return res;
2333}
2334
2335/*********************************************************************
2336 * wscanf (MSVCRT.@)
2337 */
2338int MSVCRT_wscanf(const MSVCRT_wchar_t *format, ...)
2339{
2340 va_list valist;
2341 int res;
2342
2343 va_start(valist, format);
2344 res = MSVCRT_fwscanf(MSVCRT_stdin, format, valist);
2345 va_end(valist);
2346 return res;
2347}
2348
2349/*********************************************************************
2350 * rename (MSVCRT.@)
2351 */
2352int MSVCRT_rename(const char *oldpath,const char *newpath)
2353{
2354 TRACE(":from %s to %s\n",oldpath,newpath);
2355 if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
2356 return 0;
2357 TRACE(":failed (%ld)\n",GetLastError());
2358 MSVCRT__set_errno(GetLastError());
2359 return -1;
2360}
2361
2362#endif /* !__MINIVCRT__ */
2363
2364/*********************************************************************
2365 * _wrename (MSVCRT.@)
2366 */
2367int _wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
2368{
2369 TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
2370 if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
2371 return 0;
2372 TRACE(":failed (%ld)\n",GetLastError());
2373 MSVCRT__set_errno(GetLastError());
2374 return -1;
2375}
2376
2377#ifndef __MINIVCRT__
2378
2379/*********************************************************************
2380 * setvbuf (MSVCRT.@)
2381 */
2382int MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
2383{
2384 /* TODO: Check if file busy */
2385 if(file->_bufsiz) {
2386 MSVCRT_free(file->_base);
2387 file->_bufsiz = 0;
2388 file->_cnt = 0;
2389 }
2390 if(mode == MSVCRT__IOFBF) {
2391 file->_flag &= ~MSVCRT__IONBF;
2392 file->_base = file->_ptr = buf;
2393 if(buf) {
2394 file->_bufsiz = size;
2395 }
2396 } else {
2397 file->_flag |= MSVCRT__IONBF;
2398 }
2399 return 0;
2400}
2401
2402/*********************************************************************
2403 * setbuf (MSVCRT.@)
2404 */
2405void MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
2406{
2407 MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
2408}
2409
2410/*********************************************************************
2411 * tmpnam (MSVCRT.@)
2412 */
2413char *MSVCRT_tmpnam(char *s)
2414{
2415 char tmpbuf[MAX_PATH];
2416 char* prefix = "TMP";
2417 if (!GetTempPathA(MAX_PATH,tmpbuf) ||
2418 !GetTempFileNameA(tmpbuf,prefix,0,MSVCRT_tmpname))
2419 {
2420 TRACE(":failed-last error (%ld)\n",GetLastError());
2421 return NULL;
2422 }
2423 TRACE(":got tmpnam %s\n",MSVCRT_tmpname);
2424 s = MSVCRT_tmpname;
2425 return s;
2426}
2427
2428/*********************************************************************
2429 * tmpfile (MSVCRT.@)
2430 */
2431MSVCRT_FILE* MSVCRT_tmpfile(void)
2432{
2433 char *filename = MSVCRT_tmpnam(NULL);
2434 int fd;
2435 fd = MSVCRT__open(filename, _O_CREAT | _O_BINARY | _O_RDWR | _O_TEMPORARY);
2436 if (fd != -1)
2437 return msvcrt_alloc_fp(fd);
2438 return NULL;
2439}
2440
2441/*********************************************************************
2442 * vfprintf (MSVCRT.@)
2443 */
2444int MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, va_list valist)
2445{
2446 char buf[2048], *mem = buf;
2447 int written, resize = sizeof(buf), retval;
2448 /* There are two conventions for vsnprintf failing:
2449 * Return -1 if we truncated, or
2450 * Return the number of bytes that would have been written
2451 * The code below handles both cases
2452 */
2453 dprintf(("MSVCRT: vfprintf %p %s",file,format));
2454 while ((written = _vsnprintf(mem, resize, format, valist)) == -1 ||
2455 written > resize)
2456 {
2457 resize = (written == -1 ? resize * 2 : written + 1);
2458 if (mem != buf)
2459 MSVCRT_free (mem);
2460 if (!(mem = (char *)MSVCRT_malloc(resize)))
2461 return MSVCRT_EOF;
2462 }
2463 retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
2464 if (mem != buf)
2465 MSVCRT_free (mem);
2466 return retval;
2467}
2468
2469#endif /* !__MINIVCRT__ */
2470
2471/*********************************************************************
2472 * vfwprintf (MSVCRT.@)
2473 * FIXME:
2474 * Is final char included in written (then resize is too big) or not
2475 * (then we must test for equality too)?
2476 */
2477int MSVCRT(vfwprintf)(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, va_list valist)
2478{
2479 MSVCRT_wchar_t buf[2048], *mem = buf;
2480 int written, resize = sizeof(buf) / sizeof(MSVCRT_wchar_t), retval;
2481 /* See vfprintf comments */
2482 while ((written = _vsnwprintf(mem, resize, format, valist)) == -1 ||
2483 written > resize)
2484 {
2485 resize = (written == -1 ? resize * 2 : written + sizeof(MSVCRT_wchar_t));
2486 if (mem != buf)
2487 MSVCRT_free (mem);
2488 if (!(mem = (MSVCRT_wchar_t *)MSVCRT_malloc(resize*sizeof(*mem))))
2489 return MSVCRT_EOF;
2490 }
2491 retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
2492 if (mem != buf)
2493 MSVCRT_free (mem);
2494 return retval;
2495}
2496
2497#ifndef __MINIVCRT__
2498
2499/*********************************************************************
2500 * vprintf (MSVCRT.@)
2501 */
2502int MSVCRT_vprintf(const char *format, va_list valist)
2503{
2504 return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
2505}
2506
2507#endif /* !__MINIVCRT__ */
2508
2509/*********************************************************************
2510 * vwprintf (MSVCRT.@)
2511 */
2512int MSVCRT(vwprintf)(const MSVCRT_wchar_t *format, va_list valist)
2513{
2514 return MSVCRT(vfwprintf)(MSVCRT_stdout,format,valist);
2515}
2516
2517#ifndef __MINIVCRT__
2518
2519/*********************************************************************
2520 * fprintf (MSVCRT.@)
2521 */
2522int MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
2523{
2524 va_list valist;
2525 int res;
2526 va_start(valist, format);
2527 res = MSVCRT_vfprintf(file, format, valist);
2528 va_end(valist);
2529 return res;
2530}
2531
2532#endif /* !__MINIVCRT__ */
2533
2534/*********************************************************************
2535 * fwprintf (MSVCRT.@)
2536 */
2537int MSVCRT(fwprintf)(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
2538{
2539 va_list valist;
2540 int res;
2541 va_start(valist, format);
2542 res = MSVCRT(vfwprintf)(file, format, valist);
2543 va_end(valist);
2544 return res;
2545}
2546
2547#ifndef __MINIVCRT__
2548
2549/*********************************************************************
2550 * printf (MSVCRT.@)
2551 */
2552int MSVCRT_printf(const char *format, ...)
2553{
2554 va_list valist;
2555 int res;
2556 va_start(valist, format);
2557 res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
2558 va_end(valist);
2559 return res;
2560}
2561
2562/*********************************************************************
2563 * ungetc (MSVCRT.@)
2564 */
2565int MSVCRT_ungetc(int c, MSVCRT_FILE * file)
2566{
2567 if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
2568 msvcrt_alloc_buffer(file);
2569 file->_ptr++;
2570 }
2571 if(file->_ptr>file->_base) {
2572 file->_ptr--;
2573 *file->_ptr=c;
2574 file->_cnt++;
2575 return c;
2576 }
2577 return MSVCRT_EOF;
2578}
2579
2580/*********************************************************************
2581 * ungetwc (MSVCRT.@)
2582 */
2583MSVCRT_wint_t MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
2584{
2585 MSVCRT_wchar_t mwc = wc;
2586 char * pp = (char *)&mwc;
2587 int i;
2588 for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
2589 if(pp[i] != MSVCRT_ungetc(pp[i],file))
2590 return MSVCRT_WEOF;
2591 }
2592 return mwc;
2593}
2594
2595/*********************************************************************
2596 * wprintf (MSVCRT.@)
2597 */
2598int MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
2599{
2600 va_list valist;
2601 int res;
2602 va_start(valist, format);
2603 res = MSVCRT_vwprintf(format, valist);
2604 va_end(valist);
2605 return res;
2606}
2607
2608/*********************************************************************
2609 * _wstati64 (MSVCRT.@)
2610 */
2611int _wstati64(const MSVCRT(wchar_t)* path, struct _stati64 * buf)
2612{
2613 LPSTR asciipath;
2614 int ret,len;
2615
2616 TRACE("MSVCRT: _wstati64 file (%s) %x buf(%p)\n",debugstr_w(path),sizeof(*buf),buf);
2617
2618 len = WideCharToMultiByte( CP_ACP, 0, path, -1, NULL, 0, 0, NULL);
2619 asciipath = (LPSTR)MSVCRT_malloc(len);
2620 WideCharToMultiByte(CP_ACP, 0, path, -1, asciipath, len, 0, NULL );
2621
2622 ret = _stati64(asciipath,buf);
2623
2624 MSVCRT_free(asciipath);
2625
2626 return 0;
2627}
2628
2629#endif /* !__MINIVCRT__ */
Note: See TracBrowser for help on using the repository browser.