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