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