dlls/msvcrt/file.c

   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 #include <time.h>
  10 #include "ntddk.h"
  11 #include "msvcrt.h"
  12 #include "ms_errno.h"
  13
  14 DEFAULT_DEBUG_CHANNEL(msvcrt);
  15
  16 /* stat() mode bits */
  17 #define _S_IFMT   0xF000
  18 #define _S_IFREG  0x8000
  19 #define _S_IFDIR  0x4000
  20 #define _S_IFCHR  0x2000
  21 #define _S_IFIFO  0x1000
  22 #define _S_IFBLK  0x3000
  23 #define _S_IREAD  0x0100
  24 #define _S_IWRITE 0x0080
  25 #define _S_IEXEC  0x0040
  26
  27 /* for stat mode, permissions apply to all,owner and group */
  28 #define MSVCRT_S_IREAD  (_S_IREAD  | (_S_IREAD  >> 3) | (_S_IREAD  >> 6))
  29 #define MSVCRT_S_IWRITE (_S_IWRITE | (_S_IWRITE >> 3) | (_S_IWRITE >> 6))
  30 #define MSVCRT_S_IEXEC  (_S_IEXEC  | (_S_IEXEC  >> 3) | (_S_IEXEC  >> 6))
  31
  32 /* _open modes */
  33 #define _O_RDONLY 0x0000
  34 #define _O_WRONLY 0x0001
  35 #define _O_RDWR   0x0002
  36 #define _O_APPEND 0x0008
  37 #define _O_CREAT  0x0100
  38 #define _O_TRUNC  0x0200
  39 #define _O_EXCL   0x0400
  40 #define _O_TEXT   0x4000
  41 #define _O_BINARY 0x8000
  42 #define _O_TEMPORARY 0x0040 /* Will be closed and deleted on exit */
  43
  44 /* _access() bit flags FIXME: incomplete */
  45 #define W_OK      2
  46
  47 typedef struct _crtfile
  48 {
  49   char* _ptr;
  50   int   _cnt;
  51   char* _base;
  52   int   _flag;
  53   int   _file; /* fd */
  54   int   _charbuf;
  55   int   _bufsiz;
  56   char *_tmpfname;
  57 } MSVCRT_FILE;
  58
  59 /* file._flag flags */
  60 #define _IOREAD   0x0001
  61 #define _IOWRT    0x0002
  62 #define _IOEOF    0x0010
  63 #define _IOERR    0x0020
  64 #define _IORW     0x0080
  65 #define _IOAPPEND 0x0200
  66
  67 #define SEEK_SET    0
  68 #define SEEK_CUR    1
  69 #define SEEK_END    2
  70
  71 #define _IOFBF 0
  72 #define _IOLBF 1
  73 #define _IONBF 2
  74
  75 #define BUFSIZ 512
  76
  77 #define MSVCRT_stdin  (&MSVCRT__iob[0])
  78 #define MSVCRT_stdout (&MSVCRT__iob[1])
  79 #define MSVCRT_stderr (&MSVCRT__iob[2])
  80
  81 struct _stat
  82 {
  83     unsigned short st_dev;
  84     unsigned short st_ino;
  85     unsigned short st_mode;
  86     short  st_nlink;
  87     short  st_uid;
  88     short  st_gid;
  89     unsigned int   st_rdev;
  90     int    st_size;
  91     int    st_atime;
  92     int    st_mtime;
  93     int    st_ctime;
  94 };
  95
  96 typedef long MSVCRT_fpos_t;
  97
  98 struct _utimbuf
  99 {
 100   time_t actime;
 101   time_t modtime;
 102 };
 103
 104 /* FIXME: Make this dynamic */
 105 #define MSVCRT_MAX_FILES 257
 106
 107 HANDLE MSVCRT_handles[MSVCRT_MAX_FILES];
 108 MSVCRT_FILE* MSVCRT_files[MSVCRT_MAX_FILES];
 109 int  MSVCRT_flags[MSVCRT_MAX_FILES];
 110 char *MSVCRT_tempfiles[MSVCRT_MAX_FILES];
 111 MSVCRT_FILE MSVCRT__iob[3];
 112
 113 static int MSVCRT_fdstart = 3; /* first unallocated fd */
 114 static int MSVCRT_fdend = 3; /* highest allocated fd */
 115
 116 /* INTERNAL: process umask */
 117 static int MSVCRT_umask = 0;
 118
 119 /* INTERNAL: Static buffer for temp file name */
 120 static char MSVCRT_tmpname[MAX_PATH];
 121
 122 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
 123 static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
 124 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
 125 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
 126
 127 #define TOUL(x) (ULONGLONG)((WCHAR)L##x)
 128 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
 129 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
 130 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
 131 static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
 132
 133 extern CRITICAL_SECTION MSVCRT_file_cs;
 134 #define LOCK_FILES     EnterCriticalSection(&MSVCRT_file_cs)
 135 #define UNLOCK_FILES   LeaveCriticalSection(&MSVCRT_file_cs)
 136
 137 time_t __cdecl MSVCRT_time(time_t *);
 138 int __cdecl MSVCRT__getdrive(void);
 139 WCHAR *__cdecl MSVCRT__wcsdup(const WCHAR *);
 140 unsigned int __cdecl wcslen(const WCHAR*);
 141 int __cdecl iswalpha(WCHAR);
 142 int __cdecl towupper(WCHAR);
 143 int __cdecl towlower(WCHAR);
 144 int __cdecl MSVCRT__vsnwprintf(WCHAR *,unsigned int,const WCHAR *,va_list);
 145
 146 /* INTERNAL: Get the HANDLE for a fd */
 147 static HANDLE MSVCRT__fdtoh(int fd)
 148 {
 149   if (fd < 0 || fd >= MSVCRT_fdend ||
 150       MSVCRT_handles[fd] == INVALID_HANDLE_VALUE)
 151   {
 152     WARN(":fd (%d) - no handle!\n",fd);
 153     SET_THREAD_VAR(doserrno,0);
 154     SET_THREAD_VAR(errno,MSVCRT_EBADF);
 155    return INVALID_HANDLE_VALUE;
 156   }
 157   return MSVCRT_handles[fd];
 158 }
 159
 160 /* INTERNAL: free a file entry fd */
 161 static void MSVCRT__free_fd(int fd)
 162 {
 163   MSVCRT_handles[fd] = INVALID_HANDLE_VALUE;
 164   MSVCRT_files[fd] = 0;
 165   MSVCRT_flags[fd] = 0;
 166   TRACE(":fd (%d) freed\n",fd);
 167   if (fd < 3)
 168     return; /* dont use 0,1,2 for user files */
 169   if (fd == MSVCRT_fdend - 1)
 170     MSVCRT_fdend--;
 171   if (fd < MSVCRT_fdstart)
 172     MSVCRT_fdstart = fd;
 173 }
 174
 175 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
 176 static int MSVCRT__alloc_fd(HANDLE hand, int flag)
 177 {
 178   int fd = MSVCRT_fdstart;
 179
 180   TRACE(":handle (%d) allocating fd (%d)\n",hand,fd);
 181   if (fd >= MSVCRT_MAX_FILES)
 182   {
 183     WARN(":files exhausted!\n");
 184     return -1;
 185   }
 186   MSVCRT_handles[fd] = hand;
 187   MSVCRT_flags[fd] = flag;
 188
 189   /* locate next free slot */
 190   if (fd == MSVCRT_fdend)
 191     MSVCRT_fdstart = ++MSVCRT_fdend;
 192   else
 193     while(MSVCRT_fdstart < MSVCRT_fdend &&
 194           MSVCRT_handles[MSVCRT_fdstart] != INVALID_HANDLE_VALUE)
 195       MSVCRT_fdstart++;
 196
 197   return fd;
 198 }
 199
 200 /* INTERNAL: Allocate a FILE* for an fd slot
 201  * This is done lazily to avoid memory wastage for low level open/write
 202  * usage when a FILE* is not requested (but may be later).
 203  */
 204 static MSVCRT_FILE* MSVCRT__alloc_fp(int fd)
 205 {
 206   TRACE(":fd (%d) allocating FILE*\n",fd);
 207   if (fd < 0 || fd >= MSVCRT_fdend ||
 208       MSVCRT_handles[fd] == INVALID_HANDLE_VALUE)
 209   {
 210     WARN(":invalid fd %d\n",fd);
 211     SET_THREAD_VAR(doserrno,0);
 212     SET_THREAD_VAR(errno,MSVCRT_EBADF);
 213     return NULL;
 214   }
 215   if (!MSVCRT_files[fd])
 216   {
 217     if ((MSVCRT_files[fd] = MSVCRT_calloc(sizeof(MSVCRT_FILE),1)))
 218     {
 219       MSVCRT_files[fd]->_file = fd;
 220       MSVCRT_files[fd]->_flag = MSVCRT_flags[fd];
 221       MSVCRT_files[fd]->_flag &= ~_IOAPPEND; /* mask out, see above */
 222     }
 223   }
 224   TRACE(":got FILE* (%p)\n",MSVCRT_files[fd]);
 225   return MSVCRT_files[fd];
 226 }
 227
 228
 229 /* INTERNAL: Set up stdin, stderr and stdout */
 230 void MSVCRT_init_io(void)
 231 {
 232   int i;
 233   memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
 234   MSVCRT_handles[0] = GetStdHandle(STD_INPUT_HANDLE);
 235   MSVCRT_flags[0] = MSVCRT__iob[0]._flag = _IOREAD;
 236   MSVCRT_handles[1] = GetStdHandle(STD_OUTPUT_HANDLE);
 237   MSVCRT_flags[1] = MSVCRT__iob[1]._flag = _IOWRT;
 238   MSVCRT_handles[2] = GetStdHandle(STD_ERROR_HANDLE);
 239   MSVCRT_flags[2] = MSVCRT__iob[2]._flag = _IOWRT;
 240
 241   TRACE(":handles (%d)(%d)(%d)\n",MSVCRT_handles[0],
 242         MSVCRT_handles[1],MSVCRT_handles[2]);
 243
 244   for (i = 0; i < 3; i++)
 245   {
 246     /* FILE structs for stdin/out/err are static and never deleted */
 247     MSVCRT_files[i] = &MSVCRT__iob[i];
 248     MSVCRT__iob[i]._file = i;
 249     MSVCRT_tempfiles[i] = NULL;
 250   }
 251 }
 252
 253 /*********************************************************************
 254  *              __p__iob(MSVCRT.@)
 255  */
 256 MSVCRT_FILE *MSVCRT___p__iob(void)
 257 {
 258  return &MSVCRT__iob[0];
 259 }
 260
 261 /*********************************************************************
 262  *              _access (MSVCRT.@)
 263  */
 264 int __cdecl MSVCRT__access(const char *filename, int mode)
 265 {
 266   DWORD attr = GetFileAttributesA(filename);
 267
 268   TRACE("(%s,%d) %ld\n",filename,mode,attr);
 269
 270   if (!filename || attr == 0xffffffff)
 271   {
 272     MSVCRT__set_errno(GetLastError());
 273     return -1;
 274   }
 275   if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & W_OK))
 276   {
 277     MSVCRT__set_errno(ERROR_ACCESS_DENIED);
 278     return -1;
 279   }
 280   return 0;
 281 }
 282
 283 /*********************************************************************
 284  *              _waccess (MSVCRT.@)
 285  */
 286 int __cdecl MSVCRT__waccess(const WCHAR *filename, int mode)
 287 {
 288   DWORD attr = GetFileAttributesW(filename);
 289
 290   TRACE("(%s,%d) %ld\n",debugstr_w(filename),mode,attr);
 291
 292   if (!filename || attr == 0xffffffff)
 293   {
 294     MSVCRT__set_errno(GetLastError());
 295     return -1;
 296   }
 297   if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & W_OK))
 298   {
 299     MSVCRT__set_errno(ERROR_ACCESS_DENIED);
 300     return -1;
 301   }
 302   return 0;
 303 }
 304
 305 /*********************************************************************
 306  *              _chmod (MSVCRT.@)
 307  */
 308 int __cdecl MSVCRT__chmod(const char *path, int flags)
 309 {
 310   DWORD oldFlags = GetFileAttributesA(path);
 311
 312   if (oldFlags != 0x0FFFFFFFF)
 313   {
 314     DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
 315       oldFlags | FILE_ATTRIBUTE_READONLY;
 316
 317     if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
 318       return 0;
 319   }
 320   MSVCRT__set_errno(GetLastError());
 321   return -1;
 322 }
 323
 324 /*********************************************************************
 325  *              _wchmod (MSVCRT.@)
 326  */
 327 int __cdecl MSVCRT__wchmod(const WCHAR *path, int flags)
 328 {
 329   DWORD oldFlags = GetFileAttributesW(path);
 330
 331   if (oldFlags != 0x0FFFFFFFF)
 332   {
 333     DWORD newFlags = (flags & _S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
 334       oldFlags | FILE_ATTRIBUTE_READONLY;
 335
 336     if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
 337       return 0;
 338   }
 339   MSVCRT__set_errno(GetLastError());
 340   return -1;
 341 }
 342
 343 /*********************************************************************
 344  *              _unlink (MSVCRT.@)
 345  */
 346 int __cdecl MSVCRT__unlink(const char *path)
 347 {
 348   TRACE("(%s)\n",path);
 349   if(DeleteFileA(path))
 350     return 0;
 351   TRACE("failed (%ld)\n",GetLastError());
 352   MSVCRT__set_errno(GetLastError());
 353   return -1;
 354 }
 355
 356 /*********************************************************************
 357  *              _wunlink (MSVCRT.@)
 358  */
 359 int __cdecl MSVCRT__wunlink(const WCHAR *path)
 360 {
 361   TRACE("(%s)\n",debugstr_w(path));
 362   if(DeleteFileW(path))
 363     return 0;
 364   TRACE("failed (%ld)\n",GetLastError());
 365   MSVCRT__set_errno(GetLastError());
 366   return -1;
 367 }
 368
 369 /*********************************************************************
 370  *              _close (MSVCRT.@)
 371  */
 372 int __cdecl MSVCRT__close(int fd)
 373 {
 374   HANDLE hand = MSVCRT__fdtoh(fd);
 375
 376   TRACE(":fd (%d) handle (%d)\n",fd,hand);
 377   if (hand == INVALID_HANDLE_VALUE)
 378     return -1;
 379
 380   /* Dont free std FILE*'s, they are not dynamic */
 381   if (fd > 2 && MSVCRT_files[fd])
 382     MSVCRT_free(MSVCRT_files[fd]);
 383
 384   MSVCRT__free_fd(fd);
 385
 386   if (!CloseHandle(hand))
 387   {
 388     WARN(":failed-last error (%ld)\n",GetLastError());
 389     MSVCRT__set_errno(GetLastError());
 390     return -1;
 391   }
 392   if (MSVCRT_tempfiles[fd])
 393   {
 394     TRACE("deleting temporary file '%s'\n",MSVCRT_tempfiles[fd]);
 395     MSVCRT__unlink(MSVCRT_tempfiles[fd]);
 396     MSVCRT_free(MSVCRT_tempfiles[fd]);
 397     MSVCRT_tempfiles[fd] = NULL;
 398   }
 399
 400   TRACE(":ok\n");
 401   return 0;
 402 }
 403
 404 /*********************************************************************
 405  *              _commit (MSVCRT.@)
 406  */
 407 int __cdecl MSVCRT__commit(int fd)
 408 {
 409   HANDLE hand = MSVCRT__fdtoh(fd);
 410
 411   TRACE(":fd (%d) handle (%d)\n",fd,hand);
 412   if (hand == INVALID_HANDLE_VALUE)
 413     return -1;
 414
 415   if (!FlushFileBuffers(hand))
 416   {
 417     if (GetLastError() == ERROR_INVALID_HANDLE)
 418     {
 419       /* FlushFileBuffers fails for console handles
 420        * so we ignore this error.
 421        */
 422       return 0;
 423     }
 424     TRACE(":failed-last error (%ld)\n",GetLastError());
 425     MSVCRT__set_errno(GetLastError());
 426     return -1;
 427   }
 428   TRACE(":ok\n");
 429   return 0;
 430 }
 431
 432 /*********************************************************************
 433  *              _eof (MSVCRT.@)
 434  */
 435 int __cdecl MSVCRT__eof(int fd)
 436 {
 437   DWORD curpos,endpos;
 438   HANDLE hand = MSVCRT__fdtoh(fd);
 439
 440   TRACE(":fd (%d) handle (%d)\n",fd,hand);
 441
 442   if (hand == INVALID_HANDLE_VALUE)
 443     return -1;
 444
 445   /* If we have a FILE* for this file, the EOF flag
 446    * will be set by the read()/write() functions.
 447    */
 448   if (MSVCRT_files[fd])
 449     return MSVCRT_files[fd]->_flag & _IOEOF;
 450
 451   /* Otherwise we do it the hard way */
 452   curpos = SetFilePointer(hand, 0, NULL, SEEK_CUR);
 453   endpos = SetFilePointer(hand, 0, NULL, FILE_END);
 454
 455   if (curpos == endpos)
 456     return TRUE;
 457
 458   SetFilePointer(hand, curpos, 0, FILE_BEGIN);
 459   return FALSE;
 460 }
 461
 462 /*********************************************************************
 463  *              _fcloseall (MSVCRT.@)
 464  */
 465 int __cdecl MSVCRT__fcloseall(void)
 466 {
 467   int num_closed = 0, i;
 468
 469   for (i = 3; i < MSVCRT_fdend; i++)
 470     if (MSVCRT_handles[i] != INVALID_HANDLE_VALUE)
 471     {
 472       MSVCRT__close(i);
 473       num_closed++;
 474     }
 475
 476   TRACE(":closed (%d) handles\n",num_closed);
 477   return num_closed;
 478 }
 479
 480 /*********************************************************************
 481  *              _lseek (MSVCRT.@)
 482  */
 483 LONG __cdecl MSVCRT__lseek(int fd, LONG offset, int whence)
 484 {
 485   DWORD ret;
 486   HANDLE hand = MSVCRT__fdtoh(fd);
 487
 488   TRACE(":fd (%d) handle (%d)\n",fd,hand);
 489   if (hand == INVALID_HANDLE_VALUE)
 490     return -1;
 491
 492   if (whence < 0 || whence > 2)
 493   {
 494     SET_THREAD_VAR(errno,MSVCRT_EINVAL);
 495     return -1;
 496   }
 497
 498   TRACE(":fd (%d) to 0x%08lx pos %s\n",
 499         fd,offset,(whence==SEEK_SET)?"SEEK_SET":
 500         (whence==SEEK_CUR)?"SEEK_CUR":
 501         (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
 502
 503   if ((ret = SetFilePointer(hand, offset, NULL, whence)) != 0xffffffff)
 504   {
 505     if (MSVCRT_files[fd])
 506       MSVCRT_files[fd]->_flag &= ~_IOEOF;
 507     /* FIXME: What if we seek _to_ EOF - is EOF set? */
 508     return ret;
 509   }
 510   TRACE(":error-last error (%ld)\n",GetLastError());
 511   if (MSVCRT_files[fd])
 512     switch(GetLastError())
 513     {
 514     case ERROR_NEGATIVE_SEEK:
 515     case ERROR_SEEK_ON_DEVICE:
 516       MSVCRT__set_errno(GetLastError());
 517       MSVCRT_files[fd]->_flag |= _IOERR;
 518       break;
 519     default:
 520       break;
 521     }
 522   return -1;
 523 }
 524
 525 /*********************************************************************
 526  *              rewind (MSVCRT.@)
 527  */
 528 void __cdecl MSVCRT_rewind(MSVCRT_FILE* file)
 529 {
 530   TRACE(":file (%p) fd (%d)\n",file,file->_file);
 531   MSVCRT__lseek(file->_file,0,SEEK_SET);
 532   file->_flag &= ~(_IOEOF | _IOERR);
 533 }
 534
 535 /*********************************************************************
 536  *              _fdopen (MSVCRT.@)
 537  */
 538 MSVCRT_FILE* __cdecl MSVCRT__fdopen(int fd, const char *mode)
 539 {
 540   MSVCRT_FILE* file = MSVCRT__alloc_fp(fd);
 541
 542   TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,mode,file);
 543   if (file)
 544     MSVCRT_rewind(file);
 545
 546   return file;
 547 }
 548
 549 /*********************************************************************
 550  *              _wfdopen (MSVCRT.@)
 551  */
 552 MSVCRT_FILE* __cdecl MSVCRT__wfdopen(int fd, const WCHAR *mode)
 553 {
 554   MSVCRT_FILE* file = MSVCRT__alloc_fp(fd);
 555
 556   TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,debugstr_w(mode),file);
 557   if (file)
 558     MSVCRT_rewind(file);
 559
 560   return file;
 561 }
 562
 563 /*********************************************************************
 564  *              _filelength (MSVCRT.@)
 565  */
 566 LONG __cdecl MSVCRT__filelength(int fd)
 567 {
 568   LONG curPos = MSVCRT__lseek(fd, 0, SEEK_CUR);
 569   if (curPos != -1)
 570   {
 571     LONG endPos = MSVCRT__lseek(fd, 0, SEEK_END);
 572     if (endPos != -1)
 573     {
 574       if (endPos != curPos)
 575         MSVCRT__lseek(fd, curPos, SEEK_SET);
 576       return endPos;
 577     }
 578   }
 579   return -1;
 580 }
 581
 582 /*********************************************************************
 583  *              _fileno (MSVCRT.@)
 584  */
 585 int __cdecl MSVCRT__fileno(MSVCRT_FILE* file)
 586 {
 587   TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
 588   return file->_file;
 589 }
 590
 591 /*********************************************************************
 592  *              _flushall (MSVCRT.@)
 593  */
 594 int __cdecl MSVCRT__flushall(void)
 595 {
 596   int num_flushed = 0, i = 3;
 597
 598   while(i < MSVCRT_fdend)
 599     if (MSVCRT_handles[i] != INVALID_HANDLE_VALUE)
 600     {
 601       if (MSVCRT__commit(i) == -1)
 602         if (MSVCRT_files[i])
 603           MSVCRT_files[i]->_flag |= _IOERR;
 604       num_flushed++;
 605     }
 606
 607   TRACE(":flushed (%d) handles\n",num_flushed);
 608   return num_flushed;
 609 }
 610
 611 /*********************************************************************
 612  *              _fstat (MSVCRT.@)
 613  */
 614 int __cdecl MSVCRT__fstat(int fd, struct _stat* buf)
 615 {
 616   DWORD dw;
 617   BY_HANDLE_FILE_INFORMATION hfi;
 618   HANDLE hand = MSVCRT__fdtoh(fd);
 619
 620   TRACE(":fd (%d) stat (%p)\n",fd,buf);
 621   if (hand == INVALID_HANDLE_VALUE)
 622     return -1;
 623
 624   if (!buf)
 625   {
 626     WARN(":failed-NULL buf\n");
 627     MSVCRT__set_errno(ERROR_INVALID_PARAMETER);
 628     return -1;
 629   }
 630
 631   memset(&hfi, 0, sizeof(hfi));
 632   memset(buf, 0, sizeof(struct _stat));
 633   if (!GetFileInformationByHandle(hand, &hfi))
 634   {
 635     WARN(":failed-last error (%ld)\n",GetLastError());
 636     MSVCRT__set_errno(ERROR_INVALID_PARAMETER);
 637     return -1;
 638   }
 639   FIXME(":dwFileAttributes = %d, mode set to 0",hfi.dwFileAttributes);
 640   buf->st_nlink = hfi.nNumberOfLinks;
 641   buf->st_size  = hfi.nFileSizeLow;
 642   RtlTimeToSecondsSince1970(&hfi.ftLastAccessTime, &dw);
 643   buf->st_atime = dw;
 644   RtlTimeToSecondsSince1970(&hfi.ftLastWriteTime, &dw);
 645   buf->st_mtime = buf->st_ctime = dw;
 646   return 0;
 647 }
 648
 649 /*********************************************************************
 650  *              _futime (MSVCRT.@)
 651  */
 652 int __cdecl MSVCRT__futime(int fd, struct _utimbuf *t)
 653 {
 654   HANDLE hand = MSVCRT__fdtoh(fd);
 655   FILETIME at, wt;
 656
 657   if (!t)
 658   {
 659     time_t currTime;
 660     MSVCRT_time(&currTime);
 661     RtlSecondsSince1970ToTime(currTime, &at);
 662     memcpy(&wt, &at, sizeof(wt));
 663   }
 664   else
 665   {
 666     RtlSecondsSince1970ToTime(t->actime, &at);
 667     if (t->actime == t->modtime)
 668       memcpy(&wt, &at, sizeof(wt));
 669     else
 670       RtlSecondsSince1970ToTime(t->modtime, &wt);
 671   }
 672
 673   if (!SetFileTime(hand, NULL, &at, &wt))
 674   {
 675     MSVCRT__set_errno(GetLastError());
 676     return -1 ;
 677   }
 678   return 0;
 679 }
 680
 681 /*********************************************************************
 682  *              _get_osfhandle (MSVCRT.@)
 683  */
 684 HANDLE MSVCRT__get_osfhandle(int fd)
 685 {
 686   HANDLE hand = MSVCRT__fdtoh(fd);
 687   HANDLE newhand = hand;
 688   TRACE(":fd (%d) handle (%d)\n",fd,hand);
 689
 690   if (hand != INVALID_HANDLE_VALUE)
 691   {
 692     /* FIXME: I'm not convinced that I should be copying the
 693      * handle here - it may be leaked if the app doesn't
 694      * close it (and the API docs dont say that it should)
 695      * Not duplicating it means that it can't be inherited
 696      * and so lcc's wedit doesn't cope when it passes it to
 697      * child processes. I've an idea that it should either
 698      * be copied by CreateProcess, or marked as inheritable
 699      * when initialised, or maybe both? JG 21-9-00.
 700      */
 701     DuplicateHandle(GetCurrentProcess(),hand,GetCurrentProcess(),
 702                     &newhand,0,TRUE,DUPLICATE_SAME_ACCESS);
 703   }
 704   return newhand;
 705 }
 706
 707 /*********************************************************************
 708  *              _isatty (MSVCRT.@)
 709  */
 710 int __cdecl MSVCRT__isatty(int fd)
 711 {
 712   HANDLE hand = MSVCRT__fdtoh(fd);
 713
 714   TRACE(":fd (%d) handle (%d)\n",fd,hand);
 715   if (hand == INVALID_HANDLE_VALUE)
 716     return 0;
 717
 718   return GetFileType(fd) == FILE_TYPE_CHAR? 1 : 0;
 719 }
 720
 721 /*********************************************************************
 722  *              _mktemp (MSVCRT.@)
 723  */
 724 char *__cdecl MSVCRT__mktemp(char *pattern)
 725 {
 726   int numX = 0;
 727   char *retVal = pattern;
 728   int id;
 729   char letter = 'a';
 730
 731   while(*pattern)
 732     numX = (*pattern++ == 'X')? numX + 1 : 0;
 733   if (numX < 5)
 734     return NULL;
 735   pattern--;
 736   id = GetCurrentProcessId();
 737   numX = 6;
 738   while(numX--)
 739   {
 740     int tempNum = id / 10;
 741     *pattern-- = id - (tempNum * 10) + '0';
 742     id = tempNum;
 743   }
 744   pattern++;
 745   do
 746   {
 747     if (GetFileAttributesA(retVal) == 0xFFFFFFFF &&
 748         GetLastError() == ERROR_FILE_NOT_FOUND)
 749       return retVal;
 750     *pattern = letter++;
 751   } while(letter != '|');
 752   return NULL;
 753 }
 754
 755 /*********************************************************************
 756  *              _wmktemp (MSVCRT.@)
 757  */
 758 WCHAR *__cdecl MSVCRT__wmktemp(WCHAR *pattern)
 759 {
 760   int numX = 0;
 761   WCHAR *retVal = pattern;
 762   int id;
 763   WCHAR letter = (WCHAR)L'a';
 764
 765   while(*pattern)
 766     numX = (*pattern++ == (WCHAR)L'X')? numX + 1 : 0;
 767   if (numX < 5)
 768     return NULL;
 769   pattern--;
 770   id = GetCurrentProcessId();
 771   numX = 6;
 772   while(numX--)
 773   {
 774     int tempNum = id / 10;
 775     *pattern-- = id - (tempNum * 10) + (WCHAR)L'0';
 776     id = tempNum;
 777   }
 778   pattern++;
 779   do
 780   {
 781     if (GetFileAttributesW(retVal) == 0xFFFFFFFF &&
 782         GetLastError() == ERROR_FILE_NOT_FOUND)
 783       return retVal;
 784     *pattern = letter++;
 785   } while(letter != (WCHAR)L'|');
 786   return NULL;
 787 }
 788
 789 /*********************************************************************
 790  *              _open (MSVCRT.@)
 791  */
 792 int __cdecl MSVCRT__open(const char *path,int flags)
 793 {
 794   DWORD access = 0, creation = 0;
 795   int ioflag = 0, fd;
 796   HANDLE hand;
 797
 798   TRACE(":file (%s) mode 0x%04x\n",path,flags);
 799
 800   switch(flags & (_O_RDONLY | _O_WRONLY | _O_RDWR))
 801   {
 802   case _O_RDONLY:
 803     access |= GENERIC_READ;
 804     ioflag |= _IOREAD;
 805     break;
 806   case _O_WRONLY:
 807     access |= GENERIC_WRITE;
 808     ioflag |= _IOWRT;
 809     break;
 810   case _O_RDWR:
 811     access |= GENERIC_WRITE | GENERIC_READ;
 812     ioflag |= _IORW;
 813     break;
 814   }
 815
 816   if (flags & _O_CREAT)
 817   {
 818     if (flags & _O_EXCL)
 819       creation = CREATE_NEW;
 820     else if (flags & _O_TRUNC)
 821       creation = CREATE_ALWAYS;
 822     else
 823       creation = OPEN_ALWAYS;
 824   }
 825   else  /* no _O_CREAT */
 826   {
 827     if (flags & _O_TRUNC)
 828       creation = TRUNCATE_EXISTING;
 829     else
 830       creation = OPEN_EXISTING;
 831   }
 832   if (flags & _O_APPEND)
 833     ioflag |= _IOAPPEND;
 834
 835
 836   flags |= _O_BINARY; /* FIXME: Default to text */
 837
 838   if (flags & _O_TEXT)
 839   {
 840     /* Dont warn when writing */
 841     if (ioflag & GENERIC_READ)
 842       FIXME(":TEXT node not implemented\n");
 843     flags &= ~_O_TEXT;
 844   }
 845
 846   if (flags & ~(_O_BINARY|_O_TEXT|_O_APPEND|_O_TRUNC|_O_EXCL
 847                 |_O_CREAT|_O_RDWR|_O_TEMPORARY))
 848     TRACE(":unsupported flags 0x%04x\n",flags);
 849
 850   hand = CreateFileA(path, access, FILE_SHARE_READ | FILE_SHARE_WRITE,
 851                       NULL, creation, FILE_ATTRIBUTE_NORMAL, 0);
 852
 853   if (hand == INVALID_HANDLE_VALUE)
 854   {
 855     WARN(":failed-last error (%ld)\n",GetLastError());
 856     MSVCRT__set_errno(GetLastError());
 857     return -1;
 858   }
 859
 860   fd = MSVCRT__alloc_fd(hand, ioflag);
 861
 862   TRACE(":fd (%d) handle (%d)\n",fd, hand);
 863
 864   if (fd > 0)
 865   {
 866     if (flags & _O_TEMPORARY)
 867       MSVCRT_tempfiles[fd] = MSVCRT__strdup(path);
 868     if (ioflag & _IOAPPEND)
 869       MSVCRT__lseek(fd, 0, FILE_END);
 870   }
 871
 872   return fd;
 873 }
 874
 875 /*********************************************************************
 876  *              _wopen (MSVCRT.@)
 877  */
 878 int __cdecl MSVCRT__wopen(const WCHAR *path,int flags)
 879 {
 880   const unsigned int len = wcslen(path);
 881   char *patha = MSVCRT_calloc(len + 1,1);
 882   if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
 883   {
 884     int retval = MSVCRT__open(patha,flags);
 885     MSVCRT_free(patha);
 886     return retval;
 887   }
 888
 889   MSVCRT__set_errno(GetLastError());
 890   return -1;
 891 }
 892
 893 /*********************************************************************
 894  *              _sopen (MSVCRT.@)
 895  */
 896 int __cdecl MSVCRT__sopen(const char *path,int oflags,int shflags)
 897 {
 898   return MSVCRT__open(path, oflags | shflags);
 899 }
 900
 901 /*********************************************************************
 902  *              _creat (MSVCRT.@)
 903  */
 904 int __cdecl MSVCRT__creat(const char *path, int flags)
 905 {
 906   int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
 907   return MSVCRT__open(path, usedFlags);
 908 }
 909
 910 /*********************************************************************
 911  *              _wcreat (MSVCRT.@)
 912  */
 913 int __cdecl MSVCRT__wcreat(const WCHAR *path, int flags)
 914 {
 915   int usedFlags = (flags & _O_TEXT)| _O_CREAT| _O_WRONLY| _O_TRUNC;
 916   return MSVCRT__wopen(path, usedFlags);
 917 }
 918
 919 /*********************************************************************
 920  *              _open_osfhandle (MSVCRT.@)
 921  */
 922 int __cdecl MSVCRT__open_osfhandle(HANDLE hand, int flags)
 923 {
 924   int fd = MSVCRT__alloc_fd(hand,flags);
 925   TRACE(":handle (%d) fd (%d)\n",hand,fd);
 926   return fd;
 927 }
 928
 929 /*********************************************************************
 930  *              _rmtmp (MSVCRT.@)
 931  */
 932 int __cdecl MSVCRT__rmtmp(void)
 933 {
 934   int num_removed = 0, i;
 935
 936   for (i = 3; i < MSVCRT_fdend; i++)
 937     if (MSVCRT_tempfiles[i])
 938     {
 939       MSVCRT__close(i);
 940       num_removed++;
 941     }
 942
 943   if (num_removed)
 944     TRACE(":removed (%d) temp files\n",num_removed);
 945   return num_removed;
 946 }
 947
 948 /*********************************************************************
 949  *              _read (MSVCRT.@)
 950  */
 951 int __cdecl MSVCRT__read(int fd, void *buf, unsigned int count)
 952 {
 953   DWORD num_read;
 954   HANDLE hand = MSVCRT__fdtoh(fd);
 955
 956   /* Dont trace small reads, it gets *very* annoying */
 957   if (count > 4)
 958     TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
 959   if (hand == INVALID_HANDLE_VALUE)
 960     return -1;
 961
 962   /* Set _cnt to 0 so optimised binaries will call our implementation
 963    * of putc/getc. See _filbuf/_flsbuf comments.
 964    */
 965   if (MSVCRT_files[fd])
 966     MSVCRT_files[fd]->_cnt = 0;
 967
 968   if (ReadFile(hand, buf, count, &num_read, NULL))
 969   {
 970     if (num_read != count && MSVCRT_files[fd])
 971     {
 972       TRACE(":EOF\n");
 973       MSVCRT_files[fd]->_flag |= _IOEOF;
 974     }
 975     return num_read;
 976   }
 977   TRACE(":failed-last error (%ld)\n",GetLastError());
 978   if (MSVCRT_files[fd])
 979      MSVCRT_files[fd]->_flag |= _IOERR;
 980   return -1;
 981 }
 982
 983 /*********************************************************************
 984  *              _getw (MSVCRT.@)
 985  */
 986 int __cdecl MSVCRT__getw(MSVCRT_FILE* file)
 987 {
 988   int i;
 989   if (MSVCRT__read(file->_file, &i, sizeof(int)) != 1)
 990     return MSVCRT_EOF;
 991   return i;
 992 }
 993
 994 /*********************************************************************
 995  *              _setmode (MSVCRT.@)
 996  */
 997 int __cdecl MSVCRT__setmode(int fd,int mode)
 998 {
 999   if (mode & _O_TEXT)
1000     FIXME("fd (%d) mode (%d) TEXT not implemented\n",fd,mode);
1001   return 0;
1002 }
1003
1004 /*********************************************************************
1005  *              _stat (MSVCRT.@)
1006  */
1007 int __cdecl MSVCRT__stat(const char* path, struct _stat * buf)
1008 {
1009   DWORD dw;
1010   WIN32_FILE_ATTRIBUTE_DATA hfi;
1011   unsigned short mode = MSVCRT_S_IREAD;
1012   int plen;
1013
1014   TRACE(":file (%s) buf(%p)\n",path,buf);
1015
1016   if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
1017   {
1018       TRACE("failed (%ld)\n",GetLastError());
1019       MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
1020       return -1;
1021   }
1022
1023   memset(buf,0,sizeof(struct _stat));
1024
1025   /* FIXME: rdev isnt drive num,despite what the docs say-what is it? */
1026   if (isalpha(*path))
1027     buf->st_dev = buf->st_rdev = toupper(*path - 'A'); /* drive num */
1028   else
1029     buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
1030
1031   plen = strlen(path);
1032
1033   /* Dir, or regular file? */
1034   if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1035       (path[plen-1] == '\\'))
1036     mode |= (_S_IFDIR | MSVCRT_S_IEXEC);
1037   else
1038   {
1039     mode |= _S_IFREG;
1040     /* executable? */
1041     if (plen > 6 && path[plen-4] == '.')  /* shortest exe: "\x.exe" */
1042     {
1043       unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
1044                                  (tolower(path[plen-3]) << 16);
1045       if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
1046           mode |= MSVCRT_S_IEXEC;
1047     }
1048   }
1049
1050   if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1051     mode |= MSVCRT_S_IWRITE;
1052
1053   buf->st_mode  = mode;
1054   buf->st_nlink = 1;
1055   buf->st_size  = hfi.nFileSizeLow;
1056   RtlTimeToSecondsSince1970(&hfi.ftLastAccessTime, &dw);
1057   buf->st_atime = dw;
1058   RtlTimeToSecondsSince1970(&hfi.ftLastWriteTime, &dw);
1059   buf->st_mtime = buf->st_ctime = dw;
1060   TRACE("\n%d %d %d %d %d %d\n", buf->st_mode,buf->st_nlink,buf->st_size,
1061     buf->st_atime,buf->st_mtime, buf->st_ctime);
1062   return 0;
1063 }
1064
1065 /*********************************************************************
1066  *              _wstat (MSVCRT.@)
1067  */
1068 int __cdecl MSVCRT__wstat(const WCHAR* path, struct _stat * buf)
1069 {
1070   DWORD dw;
1071   WIN32_FILE_ATTRIBUTE_DATA hfi;
1072   unsigned short mode = MSVCRT_S_IREAD;
1073   int plen;
1074
1075   TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
1076
1077   if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
1078   {
1079       TRACE("failed (%ld)\n",GetLastError());
1080       MSVCRT__set_errno(ERROR_FILE_NOT_FOUND);
1081       return -1;
1082   }
1083
1084   memset(buf,0,sizeof(struct _stat));
1085
1086   /* FIXME: rdev isnt drive num,despite what the docs say-what is it? */
1087   if (iswalpha(*path))
1088     buf->st_dev = buf->st_rdev = towupper(*path - (WCHAR)L'A'); /* drive num */
1089   else
1090     buf->st_dev = buf->st_rdev = MSVCRT__getdrive() - 1;
1091
1092   plen = wcslen(path);
1093
1094   /* Dir, or regular file? */
1095   if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1096       (path[plen-1] == (WCHAR)L'\\'))
1097     mode |= (_S_IFDIR | MSVCRT_S_IEXEC);
1098   else
1099   {
1100     mode |= _S_IFREG;
1101     /* executable? */
1102     if (plen > 6 && path[plen-4] == (WCHAR)L'.')  /* shortest exe: "\x.exe" */
1103     {
1104       ULONGLONG ext = towlower(path[plen-1]) | (towlower(path[plen-2]) << 16) |
1105                                ((ULONGLONG)towlower(path[plen-3]) << 32);
1106       if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
1107         mode |= MSVCRT_S_IEXEC;
1108     }
1109   }
1110
1111   if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1112     mode |= MSVCRT_S_IWRITE;
1113
1114   buf->st_mode  = mode;
1115   buf->st_nlink = 1;
1116   buf->st_size  = hfi.nFileSizeLow;
1117   RtlTimeToSecondsSince1970(&hfi.ftLastAccessTime, &dw);
1118   buf->st_atime = dw;
1119   RtlTimeToSecondsSince1970(&hfi.ftLastWriteTime, &dw);
1120   buf->st_mtime = buf->st_ctime = dw;
1121   TRACE("\n%d %d %d %d %d %d\n", buf->st_mode,buf->st_nlink,buf->st_size,
1122         buf->st_atime,buf->st_mtime, buf->st_ctime);
1123   return 0;
1124 }
1125
1126 /*********************************************************************
1127  *              _tell (MSVCRT.@)
1128  */
1129 LONG __cdecl MSVCRT__tell(int fd)
1130 {
1131   return MSVCRT__lseek(fd, 0, SEEK_CUR);
1132 }
1133
1134 /*********************************************************************
1135  *              _tempnam (MSVCRT.@)
1136  */
1137 char *__cdecl MSVCRT__tempnam(const char *dir, const char *prefix)
1138 {
1139   char tmpbuf[MAX_PATH];
1140
1141   TRACE("dir (%s) prefix (%s)\n",dir,prefix);
1142   if (GetTempFileNameA(dir,prefix,0,tmpbuf))
1143   {
1144     TRACE("got name (%s)\n",tmpbuf);
1145     return MSVCRT__strdup(tmpbuf);
1146   }
1147   TRACE("failed (%ld)\n",GetLastError());
1148   return NULL;
1149 }
1150
1151 /*********************************************************************
1152  *              _wtempnam (MSVCRT.@)
1153  */
1154 WCHAR *__cdecl MSVCRT__wtempnam(const WCHAR *dir, const WCHAR *prefix)
1155 {
1156   WCHAR tmpbuf[MAX_PATH];
1157
1158   TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
1159   if (GetTempFileNameW(dir,prefix,0,tmpbuf))
1160   {
1161     TRACE("got name (%s)\n",debugstr_w(tmpbuf));
1162     return MSVCRT__wcsdup(tmpbuf);
1163   }
1164   TRACE("failed (%ld)\n",GetLastError());
1165   return NULL;
1166 }
1167
1168 /*********************************************************************
1169  *              _umask (MSVCRT.@)
1170  */
1171 int __cdecl MSVCRT__umask(int umask)
1172 {
1173   int old_umask = MSVCRT_umask;
1174   TRACE("(%d)\n",umask);
1175   MSVCRT_umask = umask;
1176   return old_umask;
1177 }
1178
1179 /*********************************************************************
1180  *              _utime (MSVCRT.@)
1181  */
1182 int __cdecl MSVCRT__utime(const char *path, struct _utimbuf *t)
1183 {
1184   int fd = MSVCRT__open(path, _O_WRONLY | _O_BINARY);
1185
1186   if (fd > 0)
1187   {
1188     int retVal = MSVCRT__futime(fd, t);
1189     MSVCRT__close(fd);
1190     return retVal;
1191   }
1192   return -1;
1193 }
1194
1195 /*********************************************************************
1196  *              _wutime (MSVCRT.@)
1197  */
1198 int __cdecl MSVCRT__wutime(const WCHAR *path, struct _utimbuf *t)
1199 {
1200   int fd = MSVCRT__wopen(path, _O_WRONLY | _O_BINARY);
1201
1202   if (fd > 0)
1203   {
1204     int retVal = MSVCRT__futime(fd, t);
1205     MSVCRT__close(fd);
1206     return retVal;
1207   }
1208   return -1;
1209 }
1210
1211 /*********************************************************************
1212  *              _write (MSVCRT.@)
1213  */
1214 unsigned int __cdecl MSVCRT__write(int fd, const void *buf, unsigned int count)
1215 {
1216   DWORD num_written;
1217   HANDLE hand = MSVCRT__fdtoh(fd);
1218
1219   /* Dont trace small writes, it gets *very* annoying */
1220 //  if (count > 32)
1221 //    TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
1222   if (hand == INVALID_HANDLE_VALUE)
1223     return -1;
1224
1225   /* If appending, go to EOF */
1226   if (MSVCRT_flags[fd] & _IOAPPEND)
1227     MSVCRT__lseek(fd, 0, FILE_END);
1228
1229   /* Set _cnt to 0 so optimised binaries will call our implementation
1230    * of putc/getc.
1231    */
1232   if (MSVCRT_files[fd])
1233     MSVCRT_files[fd]->_cnt = 0;
1234
1235   if (WriteFile(hand, buf, count, &num_written, NULL)
1236       &&  (num_written == count))
1237     return num_written;
1238
1239   TRACE(":failed-last error (%ld)\n",GetLastError());
1240   if (MSVCRT_files[fd])
1241      MSVCRT_files[fd]->_flag |= _IOERR;
1242
1243   return -1;
1244 }
1245
1246 /*********************************************************************
1247  *              _putw (MSVCRT.@)
1248  */
1249 int __cdecl MSVCRT__putw(int val, MSVCRT_FILE* file)
1250 {
1251   return MSVCRT__write(file->_file, &val, sizeof(val)) == 1? val : MSVCRT_EOF;
1252 }
1253
1254 /*********************************************************************
1255  *              clearerr (MSVCRT.@)
1256  */
1257 void __cdecl MSVCRT_clearerr(MSVCRT_FILE* file)
1258 {
1259   TRACE(":file (%p) fd (%d)\n",file,file->_file);
1260   file->_flag &= ~(_IOERR | _IOEOF);
1261 }
1262
1263 /*********************************************************************
1264  *              fclose (MSVCRT.@)
1265  */
1266 int __cdecl MSVCRT_fclose(MSVCRT_FILE* file)
1267 {
1268   return MSVCRT__close(file->_file);
1269 }
1270
1271 /*********************************************************************
1272  *              feof (MSVCRT.@)
1273  */
1274 int __cdecl MSVCRT_feof(MSVCRT_FILE* file)
1275 {
1276   return file->_flag & _IOEOF;
1277 }
1278
1279 /*********************************************************************
1280  *              ferror (MSVCRT.@)
1281  */
1282 int __cdecl MSVCRT_ferror(MSVCRT_FILE* file)
1283 {
1284   return file->_flag & _IOERR;
1285 }
1286
1287 /*********************************************************************
1288  *              fflush (MSVCRT.@)
1289  */
1290 int __cdecl MSVCRT_fflush(MSVCRT_FILE* file)
1291 {
1292   return MSVCRT__commit(file->_file);
1293 }
1294
1295 /*********************************************************************
1296  *              fgetc (MSVCRT.@)
1297  */
1298 int __cdecl MSVCRT_fgetc(MSVCRT_FILE* file)
1299 {
1300   char c;
1301   if (MSVCRT__read(file->_file,&c,1) != 1)
1302     return MSVCRT_EOF;
1303   return c;
1304 }
1305
1306 /*********************************************************************
1307  *              _fgetchar (MSVCRT.@)
1308  */
1309 int __cdecl MSVCRT__fgetchar(void)
1310 {
1311   return MSVCRT_fgetc(MSVCRT_stdin);
1312 }
1313
1314 /*********************************************************************
1315  *              _filbuf (MSVCRT.@)
1316  */
1317 int __cdecl MSVCRT__filbuf(MSVCRT_FILE* file)
1318 {
1319   return MSVCRT_fgetc(file);
1320 }
1321
1322 /*********************************************************************
1323  *              fgetpos (MSVCRT.@)
1324  */
1325 int __cdecl MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
1326 {
1327   *pos = MSVCRT__tell(file->_file);
1328   return (*pos == -1? -1 : 0);
1329 }
1330
1331 /*********************************************************************
1332  *              fgets (MSVCRT.@)
1333  */
1334 char *__cdecl MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
1335 {
1336   int    cc;
1337   char * buf_start = s;
1338
1339   TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
1340         file,file->_file,s,size);
1341
1342   /* BAD, for the whole WINE process blocks... just done this way to test
1343    * windows95's ftp.exe.
1344    * JG - Is this true now we use ReadFile() on stdin too?
1345    */
1346   for(cc = MSVCRT_fgetc(file); cc != MSVCRT_EOF && cc != '\n';
1347       cc = MSVCRT_fgetc(file))
1348     if (cc != '\r')
1349     {
1350       if (--size <= 0) break;
1351       *s++ = (char)cc;
1352     }
1353   if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
1354   {
1355     TRACE(":nothing read\n");
1356     return 0;
1357   }
1358   if (cc == '\n')
1359     if (--size > 0)
1360       *s++ = '\n';
1361   *s = '\0';
1362   TRACE(":got '%s'\n", buf_start);
1363   return buf_start;
1364 }
1365
1366 /*********************************************************************
1367  *              fgetwc (MSVCRT.@)
1368  */
1369 WCHAR __cdecl MSVCRT_fgetwc(MSVCRT_FILE* file)
1370 {
1371   WCHAR wc;
1372   if (MSVCRT__read(file->_file, &wc, sizeof(wc)) != sizeof(wc))
1373     return MSVCRT_WEOF;
1374   return wc;
1375 }
1376
1377 /*********************************************************************
1378  *              getwc (MSVCRT.@)
1379  */
1380 WCHAR __cdecl MSVCRT_getwc(MSVCRT_FILE* file)
1381 {
1382   return MSVCRT_fgetwc(file);
1383 }
1384
1385 /*********************************************************************
1386  *              _fgetwchar (MSVCRT.@)
1387  */
1388 WCHAR __cdecl MSVCRT__fgetwchar(void)
1389 {
1390   return MSVCRT_fgetwc(MSVCRT_stdin);
1391 }
1392
1393 /*********************************************************************
1394  *              getwchar (MSVCRT.@)
1395  */
1396 WCHAR __cdecl MSVCRT_getwchar(void)
1397 {
1398   return MSVCRT__fgetwchar();
1399 }
1400
1401 /*********************************************************************
1402  *              fputwc (MSVCRT.@)
1403  */
1404 WCHAR __cdecl MSVCRT_fputwc(WCHAR wc, MSVCRT_FILE* file)
1405 {
1406   if (MSVCRT__write(file->_file, &wc, sizeof(wc)) != sizeof(wc))
1407     return MSVCRT_WEOF;
1408   return wc;
1409 }
1410
1411 /*********************************************************************
1412  *              _fputwchar (MSVCRT.@)
1413  */
1414 WCHAR __cdecl MSVCRT__fputwchar(WCHAR wc)
1415 {
1416   return MSVCRT_fputwc(wc, MSVCRT_stdout);
1417 }
1418
1419 /*********************************************************************
1420  *              fopen (MSVCRT.@)
1421  */
1422 MSVCRT_FILE* __cdecl MSVCRT_fopen(const char *path, const char *mode)
1423 {
1424   MSVCRT_FILE* file;
1425   int flags = 0, plus = 0, fd;
1426   const char* search = mode;
1427
1428   TRACE("(%s,%s)\n",path,mode);
1429
1430   while (*search)
1431     if (*search++ == '+')
1432       plus = 1;
1433
1434   /* map mode string to open() flags. "man fopen" for possibilities. */
1435   switch(*mode++)
1436   {
1437   case 'R': case 'r':
1438     flags = (plus ? _O_RDWR : _O_RDONLY);
1439     break;
1440   case 'W': case 'w':
1441     flags = _O_CREAT | _O_TRUNC | (plus  ? _O_RDWR : _O_WRONLY);
1442     break;
1443   case 'A': case 'a':
1444     flags = _O_CREAT | _O_APPEND | (plus  ? _O_RDWR : _O_WRONLY);
1445     break;
1446   default:
1447     return NULL;
1448   }
1449
1450   while (*mode)
1451     switch (*mode++)
1452     {
1453     case 'B': case 'b':
1454       flags |=  _O_BINARY;
1455       flags &= ~_O_TEXT;
1456       break;
1457     case 'T': case 't':
1458       flags |=  _O_TEXT;
1459       flags &= ~_O_BINARY;
1460       break;
1461     case '+':
1462       break;
1463     default:
1464       FIXME(":unknown flag %c not supported\n",mode[-1]);
1465     }
1466
1467   fd = MSVCRT__open(path, flags);
1468
1469   if (fd < 0)
1470     return NULL;
1471
1472   file = MSVCRT__alloc_fp(fd);
1473   TRACE(":got (%p)\n",file);
1474   if (!file)
1475     MSVCRT__close(fd);
1476
1477   return file;
1478 }
1479
1480 /*********************************************************************
1481  *              _wfopen (MSVCRT.@)
1482  */
1483 MSVCRT_FILE *__cdecl MSVCRT__wfopen(const WCHAR *path, const WCHAR *mode)
1484 {
1485   const unsigned int plen = wcslen(path), mlen = wcslen(mode);
1486   char *patha = MSVCRT_calloc(plen + 1, 1);
1487   char *modea = MSVCRT_calloc(mlen + 1, 1);
1488
1489   TRACE("(%s,%s)\n",debugstr_w(path),debugstr_w(mode));
1490
1491   if (patha && modea &&
1492       WideCharToMultiByte(CP_ACP,0,path,plen,patha,plen,NULL,NULL) &&
1493       WideCharToMultiByte(CP_ACP,0,mode,mlen,modea,mlen,NULL,NULL))
1494   {
1495     MSVCRT_FILE *retval = MSVCRT_fopen(patha,modea);
1496     MSVCRT_free(patha);
1497     MSVCRT_free(modea);
1498     return retval;
1499   }
1500
1501   MSVCRT__set_errno(GetLastError());
1502   return NULL;
1503 }
1504
1505 /*********************************************************************
1506  *              _fsopen (MSVCRT.@)
1507  */
1508 MSVCRT_FILE*  __cdecl MSVCRT__fsopen(const char *path, const char *mode, int share)
1509 {
1510   FIXME(":(%s,%s,%d),ignoring share mode!\n",path,mode,share);
1511   return MSVCRT_fopen(path,mode);
1512 }
1513
1514 /*********************************************************************
1515  *              _wfsopen (MSVCRT.@)
1516  */
1517 MSVCRT_FILE*  __cdecl MSVCRT__wfsopen(const WCHAR *path, const WCHAR *mode, int share)
1518 {
1519   FIXME(":(%s,%s,%d),ignoring share mode!\n",
1520         debugstr_w(path),debugstr_w(mode),share);
1521   return MSVCRT__wfopen(path,mode);
1522 }
1523
1524 /*********************************************************************
1525  *              fputc (MSVCRT.@)
1526  */
1527 int __cdecl MSVCRT_fputc(int c, MSVCRT_FILE* file)
1528 {
1529   return MSVCRT__write(file->_file, &c, 1) == 1? c : MSVCRT_EOF;
1530 }
1531
1532 /*********************************************************************
1533  *              _flsbuf (MSVCRT.@)
1534  */
1535 int __cdecl MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
1536 {
1537   return MSVCRT_fputc(c,file);
1538 }
1539
1540 /*********************************************************************
1541  *              _fputchar (MSVCRT.@)
1542  */
1543 int __cdecl MSVCRT__fputchar(int c)
1544 {
1545   return MSVCRT_fputc(c, MSVCRT_stdout);
1546 }
1547
1548 /*********************************************************************
1549  *              fread (MSVCRT.@)
1550  */
1551 DWORD __cdecl MSVCRT_fread(void *ptr, int size, int nmemb, MSVCRT_FILE* file)
1552 {
1553   DWORD read = MSVCRT__read(file->_file,ptr, size * nmemb);
1554   if (read <= 0)
1555     return 0;
1556   return read / size;
1557 }
1558
1559 /*********************************************************************
1560  *              freopen (MSVCRT.@)
1561  *
1562  */
1563 MSVCRT_FILE* __cdecl MSVCRT_freopen(const char *path, const char *mode,MSVCRT_FILE* file)
1564 {
1565   MSVCRT_FILE* newfile;
1566   int fd;
1567
1568   TRACE(":path (%p) mode (%s) file (%p) fd (%d)\n",path,mode,file,file->_file);
1569   if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
1570     return NULL;
1571
1572   if (fd > 2)
1573   {
1574     FIXME(":reopen on user file not implemented!\n");
1575     MSVCRT__set_errno(ERROR_CALL_NOT_IMPLEMENTED);
1576     return NULL;
1577   }
1578
1579   /* first, create the new file */
1580   if ((newfile = MSVCRT_fopen(path,mode)) == NULL)
1581     return NULL;
1582
1583   if (fd < 3 && SetStdHandle(fd == 0 ? STD_INPUT_HANDLE :
1584      (fd == 1? STD_OUTPUT_HANDLE : STD_ERROR_HANDLE),
1585       MSVCRT_handles[newfile->_file]))
1586   {
1587     /* Redirecting std handle to file , copy over.. */
1588     MSVCRT_handles[fd] = MSVCRT_handles[newfile->_file];
1589     MSVCRT_flags[fd] = MSVCRT_flags[newfile->_file];
1590     memcpy(&MSVCRT__iob[fd], newfile, sizeof (MSVCRT_FILE));
1591     MSVCRT__iob[fd]._file = fd;
1592     /* And free up the resources allocated by fopen, but
1593      * not the HANDLE we copied. */
1594     MSVCRT_free(MSVCRT_files[fd]);
1595     MSVCRT__free_fd(newfile->_file);
1596     return &MSVCRT__iob[fd];
1597   }
1598
1599   WARN(":failed-last error (%ld)\n",GetLastError());
1600   MSVCRT_fclose(newfile);
1601   MSVCRT__set_errno(GetLastError());
1602   return NULL;
1603 }
1604
1605 /*********************************************************************
1606  *              fsetpos (MSVCRT.@)
1607  */
1608 int __cdecl MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
1609 {
1610   return MSVCRT__lseek(file->_file,*pos,SEEK_SET);
1611 }
1612
1613 /*********************************************************************
1614  *              fscanf (MSVCRT.@)
1615  */
1616 int __cdecl MSVCRT_fscanf(MSVCRT_FILE* file, const char *format, ...)
1617 {
1618     /* NOTE: If you extend this function, extend MSVCRT__cscanf in console.c too */
1619     int rd = 0;
1620     int nch;
1621     va_list ap;
1622     if (!*format) return 0;
1623     WARN("%p (\"%s\"): semi-stub\n", file, format);
1624     nch = MSVCRT_fgetc(file);
1625     va_start(ap, format);
1626     while (*format) {
1627         if (*format == ' ') {
1628             /* skip whitespace */
1629             while ((nch!=MSVCRT_EOF) && isspace(nch))
1630                 nch = MSVCRT_fgetc(file);
1631         }
1632         else if (*format == '%') {
1633             int st = 0;
1634             format++;
1635             switch(*format) {
1636             case 'd': { /* read an integer */
1637                     int*val = va_arg(ap, int*);
1638                     int cur = 0;
1639                     /* skip initial whitespace */
1640                     while ((nch!=MSVCRT_EOF) && isspace(nch))
1641                         nch = MSVCRT_fgetc(file);
1642                     /* get sign and first digit */
1643                     if (nch == '-') {
1644                         nch = MSVCRT_fgetc(file);
1645                         if (isdigit(nch))
1646                             cur = -(nch - '0');
1647                         else break;
1648                     } else {
1649                         if (isdigit(nch))
1650                             cur = nch - '0';
1651                         else break;
1652                     }
1653                     nch = MSVCRT_fgetc(file);
1654                     /* read until no more digits */
1655                     while ((nch!=MSVCRT_EOF) && isdigit(nch)) {
1656                         cur = cur*10 + (nch - '0');
1657                         nch = MSVCRT_fgetc(file);
1658                     }
1659                     st = 1;
1660                     *val = cur;
1661                 }
1662                 break;
1663             case 'f': { /* read a float */
1664                     float*val = va_arg(ap, float*);
1665                     float cur = 0;
1666                     /* skip initial whitespace */
1667                     while ((nch!=MSVCRT_EOF) && isspace(nch))
1668                         nch = MSVCRT_fgetc(file);
1669                     /* get sign and first digit */
1670                     if (nch == '-') {
1671                         nch = MSVCRT_fgetc(file);
1672                         if (isdigit(nch))
1673                             cur = -(nch - '0');
1674                         else break;
1675                     } else {
1676                         if (isdigit(nch))
1677                             cur = nch - '0';
1678                         else break;
1679                     }
1680                     /* read until no more digits */
1681                     while ((nch!=MSVCRT_EOF) && isdigit(nch)) {
1682                         cur = cur*10 + (nch - '0');
1683                         nch = MSVCRT_fgetc(file);
1684                     }
1685                     if (nch == '.') {
1686                         /* handle decimals */
1687                         float dec = 1;
1688                         nch = MSVCRT_fgetc(file);
1689                         while ((nch!=MSVCRT_EOF) && isdigit(nch)) {
1690                             dec /= 10;
1691                             cur += dec * (nch - '0');
1692                             nch = MSVCRT_fgetc(file);
1693                         }
1694                     }
1695                     st = 1;
1696                     *val = cur;
1697                 }
1698                 break;
1699             case 's': { /* read a word */
1700                     char*str = va_arg(ap, char*);
1701                     char*sptr = str;
1702                     /* skip initial whitespace */
1703                     while ((nch!=MSVCRT_EOF) && isspace(nch))
1704                         nch = MSVCRT_fgetc(file);
1705                     /* read until whitespace */
1706                     while ((nch!=MSVCRT_EOF) && !isspace(nch)) {
1707                         *sptr++ = nch; st++;
1708                         nch = MSVCRT_fgetc(file);
1709                     }
1710                     /* terminate */
1711                     *sptr = 0;
1712                     TRACE("read word: %s\n", str);
1713                 }
1714                 break;
1715             default: FIXME("unhandled: %%%c\n", *format);
1716             }
1717             if (st) rd++;
1718             else break;
1719         }
1720         else {
1721             /* check for character match */
1722             if (nch == *format)
1723                nch = MSVCRT_fgetc(file);
1724             else break;
1725         }
1726         format++;
1727     }
1728     va_end(ap);
1729     if (nch!=MSVCRT_EOF) {
1730         WARN("need ungetch\n");
1731     }
1732     TRACE("returning %d\n", rd);
1733     return rd;
1734 }
1735
1736 /*********************************************************************
1737  *              fseek (MSVCRT.@)
1738  */
1739 LONG __cdecl MSVCRT_fseek(MSVCRT_FILE* file, LONG offset, int whence)
1740 {
1741   return MSVCRT__lseek(file->_file,offset,whence);
1742 }
1743
1744 /*********************************************************************
1745  *              ftell (MSVCRT.@)
1746  */
1747 LONG __cdecl MSVCRT_ftell(MSVCRT_FILE* file)
1748 {
1749   return MSVCRT__tell(file->_file);
1750 }
1751
1752 /*********************************************************************
1753  *              fwrite (MSVCRT.@)
1754  */
1755 unsigned int __cdecl MSVCRT_fwrite(const void *ptr, int size, int nmemb, MSVCRT_FILE* file)
1756 {
1757   unsigned int written = MSVCRT__write(file->_file, ptr, size * nmemb);
1758   if (written <= 0)
1759     return 0;
1760   return written / size;
1761 }
1762
1763 /*********************************************************************
1764  *              fputs (MSVCRT.@)
1765  */
1766 int __cdecl MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
1767 {
1768   return MSVCRT_fwrite(s,strlen(s),1,file) == 1 ? 0 : MSVCRT_EOF;
1769 }
1770
1771 /*********************************************************************
1772  *              fputws (MSVCRT.@)
1773  */
1774 int __cdecl MSVCRT_fputws(const WCHAR *s, MSVCRT_FILE* file)
1775 {
1776   return MSVCRT_fwrite(s,wcslen(s),1,file) == 1 ? 0 : MSVCRT_EOF;
1777 }
1778
1779 /*********************************************************************
1780  *              getchar (MSVCRT.@)
1781  */
1782 int __cdecl MSVCRT_getchar(void)
1783 {
1784   return MSVCRT_fgetc(MSVCRT_stdin);
1785 }
1786
1787 /*********************************************************************
1788  *              getc (MSVCRT.@)
1789  */
1790 int __cdecl MSVCRT_getc(MSVCRT_FILE* file)
1791 {
1792   return MSVCRT_fgetc(file);
1793 }
1794
1795 /*********************************************************************
1796  *              gets (MSVCRT.@)
1797  */
1798 char *__cdecl MSVCRT_gets(char *buf)
1799 {
1800   int    cc;
1801   char * buf_start = buf;
1802
1803   /* BAD, for the whole WINE process blocks... just done this way to test
1804    * windows95's ftp.exe.
1805    * JG 19/9/00: Is this still true, now we are using ReadFile?
1806    */
1807   for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
1808       cc = MSVCRT_fgetc(MSVCRT_stdin))
1809   if(cc != '\r') *buf++ = (char)cc;
1810
1811   *buf = '\0';
1812
1813   TRACE("got '%s'\n", buf_start);
1814   return buf_start;
1815 }
1816
1817 /*********************************************************************
1818  *              putc (MSVCRT.@)
1819  */
1820 int __cdecl MSVCRT_putc(int c, MSVCRT_FILE* file)
1821 {
1822   return MSVCRT_fputc(c, file);
1823 }
1824
1825 /*********************************************************************
1826  *              putchar (MSVCRT.@)
1827  */
1828 void __cdecl MSVCRT_putchar(int c)
1829 {
1830   MSVCRT_fputc(c, MSVCRT_stdout);
1831 }
1832
1833 /*********************************************************************
1834  *              puts (MSVCRT.@)
1835  */
1836 int __cdecl MSVCRT_puts(const char *s)
1837 {
1838   int retval = MSVCRT_EOF;
1839   if (MSVCRT_fwrite(s,strlen(s),1,MSVCRT_stdout) == 1)
1840     return MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
1841   return retval;
1842 }
1843
1844 /*********************************************************************
1845  *              _putws (MSVCRT.@)
1846  */
1847 int __cdecl MSVCRT__putws(const WCHAR *s)
1848 {
1849   static const WCHAR nl = (WCHAR)L'\n';
1850   if (MSVCRT_fwrite(s,wcslen(s),1,MSVCRT_stdout) == 1)
1851     return MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
1852   return MSVCRT_EOF;
1853 }
1854
1855 /*********************************************************************
1856  *              remove (MSVCRT.@)
1857  */
1858 int __cdecl MSVCRT_remove(const char *path)
1859 {
1860   TRACE("(%s)\n",path);
1861   if (DeleteFileA(path))
1862     return 0;
1863   TRACE(":failed (%ld)\n",GetLastError());
1864   MSVCRT__set_errno(GetLastError());
1865   return -1;
1866 }
1867
1868 /*********************************************************************
1869  *              _wremove (MSVCRT.@)
1870  */
1871 int __cdecl MSVCRT__wremove(const WCHAR *path)
1872 {
1873   TRACE("(%s)\n",debugstr_w(path));
1874   if (DeleteFileW(path))
1875     return 0;
1876   TRACE(":failed (%ld)\n",GetLastError());
1877   MSVCRT__set_errno(GetLastError());
1878   return -1;
1879 }
1880
1881 /*********************************************************************
1882  *              scanf (MSVCRT.@)
1883  */
1884 int __cdecl MSVCRT_scanf(const char *format, ...)
1885 {
1886   va_list valist;
1887   int res;
1888
1889   va_start(valist, format);
1890   res = MSVCRT_fscanf(MSVCRT_stdin, format, valist);
1891   va_end(valist);
1892   return res;
1893 }
1894
1895 /*********************************************************************
1896  *              rename (MSVCRT.@)
1897  */
1898 int __cdecl MSVCRT_rename(const char *oldpath,const char *newpath)
1899 {
1900   TRACE(":from %s to %s\n",oldpath,newpath);
1901   if (MoveFileExA(oldpath, newpath, MOVEFILE_REPLACE_EXISTING))
1902     return 0;
1903   TRACE(":failed (%ld)\n",GetLastError());
1904   MSVCRT__set_errno(GetLastError());
1905   return -1;
1906 }
1907
1908 /*********************************************************************
1909  *              _wrename (MSVCRT.@)
1910  */
1911 int __cdecl MSVCRT__wrename(const WCHAR *oldpath,const WCHAR *newpath)
1912 {
1913   TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
1914   if (MoveFileExW(oldpath, newpath, MOVEFILE_REPLACE_EXISTING))
1915     return 0;
1916   TRACE(":failed (%ld)\n",GetLastError());
1917   MSVCRT__set_errno(GetLastError());
1918   return -1;
1919 }
1920
1921 /*********************************************************************
1922  *              setvbuf (MSVCRT.@)
1923  */
1924 void MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, unsigned int size)
1925 {
1926   FIXME("(%p,%p,%d,%d)stub\n",file, buf, mode, size);
1927 }
1928
1929 /*********************************************************************
1930  *              setbuf (MSVCRT.@)
1931  */
1932 void __cdecl MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
1933 {
1934   MSVCRT_setvbuf(file, buf, buf ? _IOFBF : _IONBF, BUFSIZ);
1935 }
1936
1937 /*********************************************************************
1938  *              tmpnam (MSVCRT.@)
1939  */
1940 char *__cdecl MSVCRT_tmpnam(char *s)
1941 {
1942   char tmpbuf[MAX_PATH];
1943   char* prefix = "TMP";
1944   if (!GetTempPathA(MAX_PATH,tmpbuf) ||
1945       !GetTempFileNameA(tmpbuf,prefix,0,MSVCRT_tmpname))
1946   {
1947     TRACE(":failed-last error (%ld)\n",GetLastError());
1948     return NULL;
1949   }
1950   TRACE(":got tmpnam %s\n",MSVCRT_tmpname);
1951   s = MSVCRT_tmpname;
1952   return s;
1953 }
1954
1955 /*********************************************************************
1956  *              tmpfile (MSVCRT.@)
1957  */
1958 MSVCRT_FILE* __cdecl MSVCRT_tmpfile(void)
1959 {
1960   char *filename = MSVCRT_tmpnam(NULL);
1961   int fd;
1962   fd = MSVCRT__open(filename, _O_CREAT | _O_BINARY | _O_RDWR | _O_TEMPORARY);
1963   if (fd != -1)
1964     return MSVCRT__alloc_fp(fd);
1965   return NULL;
1966 }
1967 extern int vsnprintf(void *, unsigned int, const void*, va_list);
1968
1969 /*********************************************************************
1970  *              vfprintf (MSVCRT.@)
1971  */
1972 int __cdecl MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, va_list valist)
1973 {
1974   char buf[2048], *mem = buf;
1975   int written, resize = sizeof(buf), retval;
1976   /* There are two conventions for vsnprintf failing:
1977    * Return -1 if we truncated, or
1978    * Return the number of bytes that would have been written
1979    * The code below handles both cases
1980    */
1981   while ((written = vsnprintf(mem, resize, format, valist)) == -1 ||
1982           written > resize)
1983   {
1984     resize = (written == -1 ? resize * 2 : written + 1);
1985     if (mem != buf)
1986       MSVCRT_free (mem);
1987     if (!(mem = (char *)MSVCRT_malloc(resize)))
1988       return MSVCRT_EOF;
1989   }
1990   retval = MSVCRT_fwrite(mem, 1, written, file);
1991   if (mem != buf)
1992     MSVCRT_free (mem);
1993   return retval;
1994 }
1995
1996 /*********************************************************************
1997  *              vfwprintf (MSVCRT.@)
1998  */
1999 int __cdecl MSVCRT_vfwprintf(MSVCRT_FILE* file, const WCHAR *format, va_list valist)
2000 {
2001   WCHAR buf[2048], *mem = buf;
2002   int written, resize = sizeof(buf) / sizeof(WCHAR), retval;
2003   /* See vfprintf comments */
2004   while ((written = MSVCRT__vsnwprintf(mem, resize, format, valist)) == -1 ||
2005           written > resize)
2006   {
2007     resize = (written == -1 ? resize * 2 : written + sizeof(WCHAR));
2008     if (mem != buf)
2009       MSVCRT_free (mem);
2010     if (!(mem = (WCHAR *)MSVCRT_malloc(resize)))
2011       return MSVCRT_EOF;
2012   }
2013   retval = MSVCRT_fwrite(mem, 1, written * sizeof (WCHAR), file);
2014   if (mem != buf)
2015     MSVCRT_free (mem);
2016   return retval;
2017 }
2018
2019 /*********************************************************************
2020  *              vprintf (MSVCRT.@)
2021  */
2022 int __cdecl MSVCRT_vprintf(const char *format, va_list valist)
2023 {
2024   return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
2025 }
2026
2027 /*********************************************************************
2028  *              vwprintf (MSVCRT.@)
2029  */
2030 int __cdecl MSVCRT_vwprintf(const WCHAR *format, va_list valist)
2031 {
2032   return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
2033 }
2034
2035 /*********************************************************************
2036  *              fprintf (MSVCRT.@)
2037  */
2038 int __cdecl MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
2039 {
2040     va_list valist;
2041     int res;
2042     va_start(valist, format);
2043     res = MSVCRT_vfprintf(file, format, valist);
2044     va_end(valist);
2045     return res;
2046 }
2047
2048 /*********************************************************************
2049  *              fwprintf (MSVCRT.@)
2050  */
2051 int __cdecl MSVCRT_fwprintf(MSVCRT_FILE* file, const WCHAR *format, ...)
2052 {
2053     va_list valist;
2054     int res;
2055     va_start(valist, format);
2056     res = MSVCRT_vfwprintf(file, format, valist);
2057     va_end(valist);
2058     return res;
2059 }
2060
2061 /*********************************************************************
2062  *              printf (MSVCRT.@)
2063  */
2064 int __cdecl MSVCRT_printf(const char *format, ...)
2065 {
2066     va_list valist;
2067     int res;
2068     va_start(valist, format);
2069     res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
2070     va_end(valist);
2071     return res;
2072 }
2073
2074 /*********************************************************************
2075  *              wprintf (MSVCRT.@)
2076  */
2077 int __cdecl MSVCRT_wprintf(const WCHAR *format, ...)
2078 {
2079     va_list valist;
2080     int res;
2081     va_start(valist, format);
2082     res = MSVCRT_vwprintf(format, valist);
2083     va_end(valist);
2084     return res;
2085 }