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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 "winreg.h"
  43 #include "winternl.h"
  44 #include "msvcrt.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
  60 /* values for wxflag in file descriptor */
  61 #define WX_OPEN           0x01
  62 #define WX_ATEOF          0x02
  63 #define WX_DONTINHERIT    0x10
  64 #define WX_APPEND         0x20
  65 #define WX_TEXT           0x80
  66
  67 /* FIXME: this should be allocated dynamically */
  68 #define MSVCRT_MAX_FILES 2048
  69
  70 typedef struct {
  71     HANDLE              handle;
  72     unsigned char       wxflag;
  73     DWORD               unkn[7]; /* critical section and init flag */
  74 } ioinfo;
  75
  76 static ioinfo MSVCRT_fdesc[MSVCRT_MAX_FILES];
  77
  78 MSVCRT_FILE MSVCRT__iob[3];
  79
  80 static int MSVCRT_fdstart = 3; /* first unallocated fd */
  81 static int MSVCRT_fdend = 3; /* highest allocated fd */
  82
  83 static MSVCRT_FILE* MSVCRT_fstreams[2048];
  84 static int   MSVCRT_stream_idx;
  85
  86 /* INTERNAL: process umask */
  87 static int MSVCRT_umask = 0;
  88
  89 /* INTERNAL: Static buffer for temp file name */
  90 static char MSVCRT_tmpname[MAX_PATH];
  91
  92 static const unsigned int EXE = 'e' << 16 | 'x' << 8 | 'e';
  93 static const unsigned int BAT = 'b' << 16 | 'a' << 8 | 't';
  94 static const unsigned int CMD = 'c' << 16 | 'm' << 8 | 'd';
  95 static const unsigned int COM = 'c' << 16 | 'o' << 8 | 'm';
  96
  97 #define TOUL(x) (ULONGLONG)(x)
  98 static const ULONGLONG WCEXE = TOUL('e') << 32 | TOUL('x') << 16 | TOUL('e');
  99 static const ULONGLONG WCBAT = TOUL('b') << 32 | TOUL('a') << 16 | TOUL('t');
 100 static const ULONGLONG WCCMD = TOUL('c') << 32 | TOUL('m') << 16 | TOUL('d');
 101 static const ULONGLONG WCCOM = TOUL('c') << 32 | TOUL('o') << 16 | TOUL('m');
 102
 103 /* This critical section protects the tables MSVCRT_fdesc and MSVCRT_fstreams,
 104  * and their related indexes, MSVCRT_fdstart, MSVCRT_fdend,
 105  * and MSVCRT_stream_idx, from race conditions.
 106  * It doesn't protect against race conditions manipulating the underlying files
 107  * or flags; doing so would probably be better accomplished with per-file
 108  * protection, rather than locking the whole table for every change.
 109  */
 110 static CRITICAL_SECTION MSVCRT_file_cs;
 111 #define LOCK_FILES()    do { EnterCriticalSection(&MSVCRT_file_cs); } while (0)
 112 #define UNLOCK_FILES()  do { LeaveCriticalSection(&MSVCRT_file_cs); } while (0)
 113
 114 static void msvcrt_cp_from_stati64(const struct MSVCRT__stati64 *bufi64, struct MSVCRT__stat *buf)
 115 {
 116     buf->st_dev   = bufi64->st_dev;
 117     buf->st_ino   = bufi64->st_ino;
 118     buf->st_mode  = bufi64->st_mode;
 119     buf->st_nlink = bufi64->st_nlink;
 120     buf->st_uid   = bufi64->st_uid;
 121     buf->st_gid   = bufi64->st_gid;
 122     buf->st_rdev  = bufi64->st_rdev;
 123     buf->st_size  = bufi64->st_size;
 124     buf->st_atime = bufi64->st_atime;
 125     buf->st_mtime = bufi64->st_mtime;
 126     buf->st_ctime = bufi64->st_ctime;
 127 }
 128
 129 static inline BOOL msvcrt_is_valid_fd(int fd)
 130 {
 131   return fd >= 0 && fd < MSVCRT_fdend && (MSVCRT_fdesc[fd].wxflag & WX_OPEN);
 132 }
 133
 134 /* INTERNAL: Get the HANDLE for a fd
 135  * This doesn't lock the table, because a failure will result in
 136  * INVALID_HANDLE_VALUE being returned, which should be handled correctly.  If
 137  * it returns a valid handle which is about to be closed, a subsequent call
 138  * will fail, most likely in a sane way.
 139  */
 140 static HANDLE msvcrt_fdtoh(int fd)
 141 {
 142   if (!msvcrt_is_valid_fd(fd))
 143   {
 144     WARN(":fd (%d) - no handle!\n",fd);
 145     *MSVCRT___doserrno() = 0;
 146     *MSVCRT__errno() = MSVCRT_EBADF;
 147     return INVALID_HANDLE_VALUE;
 148   }
 149   if (MSVCRT_fdesc[fd].handle == INVALID_HANDLE_VALUE) FIXME("wtf\n");
 150   return MSVCRT_fdesc[fd].handle;
 151 }
 152
 153 /* INTERNAL: free a file entry fd */
 154 static void msvcrt_free_fd(int fd)
 155 {
 156   LOCK_FILES();
 157   MSVCRT_fdesc[fd].handle = INVALID_HANDLE_VALUE;
 158   MSVCRT_fdesc[fd].wxflag = 0;
 159   TRACE(":fd (%d) freed\n",fd);
 160   if (fd < 3) /* don't use 0,1,2 for user files */
 161   {
 162     switch (fd)
 163     {
 164     case 0: SetStdHandle(STD_INPUT_HANDLE,  NULL); break;
 165     case 1: SetStdHandle(STD_OUTPUT_HANDLE, NULL); break;
 166     case 2: SetStdHandle(STD_ERROR_HANDLE,  NULL); break;
 167     }
 168   }
 169   else
 170   {
 171     if (fd == MSVCRT_fdend - 1)
 172       MSVCRT_fdend--;
 173     if (fd < MSVCRT_fdstart)
 174       MSVCRT_fdstart = fd;
 175   }
 176   UNLOCK_FILES();
 177 }
 178
 179 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE, starting from fd */
 180 /* caller must hold the files lock */
 181 static int msvcrt_alloc_fd_from(HANDLE hand, int flag, int fd)
 182 {
 183   if (fd >= MSVCRT_MAX_FILES)
 184   {
 185     WARN(":files exhausted!\n");
 186     return -1;
 187   }
 188   MSVCRT_fdesc[fd].handle = hand;
 189   MSVCRT_fdesc[fd].wxflag = WX_OPEN | (flag & (WX_DONTINHERIT | WX_APPEND | WX_TEXT));
 190
 191   /* locate next free slot */
 192   if (fd == MSVCRT_fdstart && fd == MSVCRT_fdend)
 193     MSVCRT_fdstart = MSVCRT_fdend + 1;
 194   else
 195     while (MSVCRT_fdstart < MSVCRT_fdend &&
 196      MSVCRT_fdesc[MSVCRT_fdstart].handle != INVALID_HANDLE_VALUE)
 197       MSVCRT_fdstart++;
 198   /* update last fd in use */
 199   if (fd >= MSVCRT_fdend)
 200     MSVCRT_fdend = fd + 1;
 201   TRACE("fdstart is %d, fdend is %d\n", MSVCRT_fdstart, MSVCRT_fdend);
 202
 203   switch (fd)
 204   {
 205   case 0: SetStdHandle(STD_INPUT_HANDLE,  hand); break;
 206   case 1: SetStdHandle(STD_OUTPUT_HANDLE, hand); break;
 207   case 2: SetStdHandle(STD_ERROR_HANDLE,  hand); break;
 208   }
 209
 210   return fd;
 211 }
 212
 213 /* INTERNAL: Allocate an fd slot from a Win32 HANDLE */
 214 static int msvcrt_alloc_fd(HANDLE hand, int flag)
 215 {
 216   int ret;
 217
 218   LOCK_FILES();
 219   TRACE(":handle (%p) allocating fd (%d)\n",hand,MSVCRT_fdstart);
 220   ret = msvcrt_alloc_fd_from(hand, flag, MSVCRT_fdstart);
 221   UNLOCK_FILES();
 222   return ret;
 223 }
 224
 225 /* INTERNAL: Allocate a FILE* for an fd slot */
 226 /* caller must hold the files lock */
 227 static MSVCRT_FILE* msvcrt_alloc_fp(void)
 228 {
 229   unsigned int i;
 230
 231   for (i = 3; i < sizeof(MSVCRT_fstreams) / sizeof(MSVCRT_fstreams[0]); i++)
 232   {
 233     if (!MSVCRT_fstreams[i] || MSVCRT_fstreams[i]->_flag == 0)
 234     {
 235       if (!MSVCRT_fstreams[i])
 236       {
 237         if (!(MSVCRT_fstreams[i] = MSVCRT_calloc(sizeof(MSVCRT_FILE),1)))
 238           return NULL;
 239         if (i == MSVCRT_stream_idx) MSVCRT_stream_idx++;
 240       }
 241       return MSVCRT_fstreams[i];
 242     }
 243   }
 244   return NULL;
 245 }
 246
 247 /* INTERNAL: initialize a FILE* from an open fd */
 248 static int msvcrt_init_fp(MSVCRT_FILE* file, int fd, unsigned stream_flags)
 249 {
 250   TRACE(":fd (%d) allocating FILE*\n",fd);
 251   if (!msvcrt_is_valid_fd(fd))
 252   {
 253     WARN(":invalid fd %d\n",fd);
 254     *MSVCRT___doserrno() = 0;
 255     *MSVCRT__errno() = MSVCRT_EBADF;
 256     return -1;
 257   }
 258   memset(file, 0, sizeof(*file));
 259   file->_file = fd;
 260   file->_flag = stream_flags;
 261
 262   TRACE(":got FILE* (%p)\n",file);
 263   return 0;
 264 }
 265
 266 /* INTERNAL: Create an inheritance data block (for spawned process)
 267  * The inheritance block is made of:
 268  *      00      int     nb of file descriptor (NBFD)
 269  *      04      char    file flags (wxflag): repeated for each fd
 270  *      4+NBFD  HANDLE  file handle: repeated for each fd
 271  */
 272 unsigned msvcrt_create_io_inherit_block(STARTUPINFOA* si)
 273 {
 274   int         fd;
 275   char*       wxflag_ptr;
 276   HANDLE*     handle_ptr;
 277
 278   si->cbReserved2 = sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * MSVCRT_fdend;
 279   si->lpReserved2 = MSVCRT_calloc(si->cbReserved2, 1);
 280   if (!si->lpReserved2)
 281   {
 282     si->cbReserved2 = 0;
 283     return FALSE;
 284   }
 285   wxflag_ptr = (char*)si->lpReserved2 + sizeof(unsigned);
 286   handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
 287
 288   *(unsigned*)si->lpReserved2 = MSVCRT_fdend;
 289   for (fd = 0; fd < MSVCRT_fdend; fd++)
 290   {
 291     /* to be inherited, we need it to be open, and that DONTINHERIT isn't set */
 292     if ((MSVCRT_fdesc[fd].wxflag & (WX_OPEN | WX_DONTINHERIT)) == WX_OPEN)
 293     {
 294       *wxflag_ptr = MSVCRT_fdesc[fd].wxflag;
 295       *handle_ptr = MSVCRT_fdesc[fd].handle;
 296     }
 297     else
 298     {
 299       *wxflag_ptr = 0;
 300       *handle_ptr = INVALID_HANDLE_VALUE;
 301     }
 302     wxflag_ptr++; handle_ptr++;
 303   }
 304   return TRUE;
 305 }
 306
 307 /* INTERNAL: Set up all file descriptors,
 308  * as well as default streams (stdin, stderr and stdout)
 309  */
 310 void msvcrt_init_io(void)
 311 {
 312   STARTUPINFOA  si;
 313   int           i;
 314
 315   InitializeCriticalSection(&MSVCRT_file_cs);
 316   GetStartupInfoA(&si);
 317   if (si.cbReserved2 != 0 && si.lpReserved2 != NULL)
 318   {
 319     char*       wxflag_ptr;
 320     HANDLE*     handle_ptr;
 321
 322     MSVCRT_fdend = *(unsigned*)si.lpReserved2;
 323
 324     wxflag_ptr = (char*)(si.lpReserved2 + sizeof(unsigned));
 325     handle_ptr = (HANDLE*)(wxflag_ptr + MSVCRT_fdend * sizeof(char));
 326
 327     MSVCRT_fdend = min(MSVCRT_fdend, sizeof(MSVCRT_fdesc) / sizeof(MSVCRT_fdesc[0]));
 328     for (i = 0; i < MSVCRT_fdend; i++)
 329     {
 330       if ((*wxflag_ptr & WX_OPEN) && *handle_ptr != INVALID_HANDLE_VALUE)
 331       {
 332         MSVCRT_fdesc[i].wxflag  = *wxflag_ptr;
 333         MSVCRT_fdesc[i].handle = *handle_ptr;
 334       }
 335       else
 336       {
 337         MSVCRT_fdesc[i].wxflag  = 0;
 338         MSVCRT_fdesc[i].handle = INVALID_HANDLE_VALUE;
 339       }
 340       wxflag_ptr++; handle_ptr++;
 341     }
 342     for (MSVCRT_fdstart = 3; MSVCRT_fdstart < MSVCRT_fdend; MSVCRT_fdstart++)
 343         if (MSVCRT_fdesc[MSVCRT_fdstart].handle == INVALID_HANDLE_VALUE) break;
 344   }
 345
 346   if (!(MSVCRT_fdesc[0].wxflag & WX_OPEN) || MSVCRT_fdesc[0].handle == INVALID_HANDLE_VALUE)
 347   {
 348     DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE),
 349                     GetCurrentProcess(), &MSVCRT_fdesc[0].handle, 0, FALSE,
 350                     DUPLICATE_SAME_ACCESS);
 351     MSVCRT_fdesc[0].wxflag = WX_OPEN | WX_TEXT;
 352   }
 353   if (!(MSVCRT_fdesc[1].wxflag & WX_OPEN) || MSVCRT_fdesc[1].handle == INVALID_HANDLE_VALUE)
 354   {
 355     DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_OUTPUT_HANDLE),
 356                     GetCurrentProcess(), &MSVCRT_fdesc[1].handle, 0, FALSE,
 357                     DUPLICATE_SAME_ACCESS);
 358     MSVCRT_fdesc[1].wxflag = WX_OPEN | WX_TEXT;
 359   }
 360   if (!(MSVCRT_fdesc[2].wxflag & WX_OPEN) || MSVCRT_fdesc[2].handle == INVALID_HANDLE_VALUE)
 361   {
 362     DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_ERROR_HANDLE),
 363                     GetCurrentProcess(), &MSVCRT_fdesc[2].handle, 0, FALSE,
 364                     DUPLICATE_SAME_ACCESS);
 365     MSVCRT_fdesc[2].wxflag = WX_OPEN | WX_TEXT;
 366   }
 367
 368   TRACE(":handles (%p)(%p)(%p)\n",MSVCRT_fdesc[0].handle,
 369         MSVCRT_fdesc[1].handle,MSVCRT_fdesc[2].handle);
 370
 371   memset(MSVCRT__iob,0,3*sizeof(MSVCRT_FILE));
 372   for (i = 0; i < 3; i++)
 373   {
 374     /* FILE structs for stdin/out/err are static and never deleted */
 375     MSVCRT_fstreams[i] = &MSVCRT__iob[i];
 376     MSVCRT__iob[i]._file = i;
 377     MSVCRT__iob[i]._tmpfname = NULL;
 378     MSVCRT__iob[i]._flag = (i == 0) ? MSVCRT__IOREAD : MSVCRT__IOWRT;
 379   }
 380   MSVCRT_stream_idx = 3;
 381 }
 382
 383 /* INTERNAL: Flush stdio file buffer */
 384 static int msvcrt_flush_buffer(MSVCRT_FILE* file)
 385 {
 386   if(file->_bufsiz) {
 387         int cnt=file->_ptr-file->_base;
 388         if(cnt>0 && _write(file->_file, file->_base, cnt) != cnt) {
 389             file->_flag |= MSVCRT__IOERR;
 390             return MSVCRT_EOF;
 391         }
 392         file->_ptr=file->_base;
 393         file->_cnt=file->_bufsiz;
 394   }
 395   return 0;
 396 }
 397
 398 /* INTERNAL: Allocate stdio file buffer */
 399 static void msvcrt_alloc_buffer(MSVCRT_FILE* file)
 400 {
 401         file->_base = MSVCRT_calloc(MSVCRT_BUFSIZ,1);
 402         if(file->_base) {
 403                 file->_bufsiz = MSVCRT_BUFSIZ;
 404                 file->_flag |= MSVCRT__IOMYBUF;
 405         } else {
 406                 file->_base = (unsigned char *)(&file->_charbuf);
 407                 /* put here 2 ??? */
 408                 file->_bufsiz = sizeof(file->_charbuf);
 409         }
 410         file->_ptr = file->_base;
 411         file->_cnt = 0;
 412 }
 413
 414 /* INTERNAL: Convert integer to base32 string (0-9a-v), 0 becomes "" */
 415 static void msvcrt_int_to_base32(int num, char *str)
 416 {
 417   char *p;
 418   int n = num;
 419   int digits = 0;
 420
 421   while (n != 0)
 422   {
 423     n >>= 5;
 424     digits++;
 425   }
 426   p = str + digits;
 427   *p = 0;
 428   while (--p >= str)
 429   {
 430     *p = (num & 31) + '0';
 431     if (*p > '9')
 432       *p += ('a' - '0' - 10);
 433     num >>= 5;
 434   }
 435 }
 436
 437 /*********************************************************************
 438  *              __p__iob(MSVCRT.@)
 439  */
 440 MSVCRT_FILE *__p__iob(void)
 441 {
 442  return &MSVCRT__iob[0];
 443 }
 444
 445 /*********************************************************************
 446  *              _access (MSVCRT.@)
 447  */
 448 int _access(const char *filename, int mode)
 449 {
 450   DWORD attr = GetFileAttributesA(filename);
 451
 452   TRACE("(%s,%d) %ld\n",filename,mode,attr);
 453
 454   if (!filename || attr == INVALID_FILE_ATTRIBUTES)
 455   {
 456     msvcrt_set_errno(GetLastError());
 457     return -1;
 458   }
 459   if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
 460   {
 461     msvcrt_set_errno(ERROR_ACCESS_DENIED);
 462     return -1;
 463   }
 464   return 0;
 465 }
 466
 467 /*********************************************************************
 468  *              _waccess (MSVCRT.@)
 469  */
 470 int _waccess(const MSVCRT_wchar_t *filename, int mode)
 471 {
 472   DWORD attr = GetFileAttributesW(filename);
 473
 474   TRACE("(%s,%d) %ld\n",debugstr_w(filename),mode,attr);
 475
 476   if (!filename || attr == INVALID_FILE_ATTRIBUTES)
 477   {
 478     msvcrt_set_errno(GetLastError());
 479     return -1;
 480   }
 481   if ((attr & FILE_ATTRIBUTE_READONLY) && (mode & MSVCRT_W_OK))
 482   {
 483     msvcrt_set_errno(ERROR_ACCESS_DENIED);
 484     return -1;
 485   }
 486   return 0;
 487 }
 488
 489 /*********************************************************************
 490  *              _chmod (MSVCRT.@)
 491  */
 492 int _chmod(const char *path, int flags)
 493 {
 494   DWORD oldFlags = GetFileAttributesA(path);
 495
 496   if (oldFlags != INVALID_FILE_ATTRIBUTES)
 497   {
 498     DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
 499       oldFlags | FILE_ATTRIBUTE_READONLY;
 500
 501     if (newFlags == oldFlags || SetFileAttributesA(path, newFlags))
 502       return 0;
 503   }
 504   msvcrt_set_errno(GetLastError());
 505   return -1;
 506 }
 507
 508 /*********************************************************************
 509  *              _wchmod (MSVCRT.@)
 510  */
 511 int _wchmod(const MSVCRT_wchar_t *path, int flags)
 512 {
 513   DWORD oldFlags = GetFileAttributesW(path);
 514
 515   if (oldFlags != INVALID_FILE_ATTRIBUTES)
 516   {
 517     DWORD newFlags = (flags & MSVCRT__S_IWRITE)? oldFlags & ~FILE_ATTRIBUTE_READONLY:
 518       oldFlags | FILE_ATTRIBUTE_READONLY;
 519
 520     if (newFlags == oldFlags || SetFileAttributesW(path, newFlags))
 521       return 0;
 522   }
 523   msvcrt_set_errno(GetLastError());
 524   return -1;
 525 }
 526
 527 /*********************************************************************
 528  *              _chsize (MSVCRT.@)
 529  */
 530 int _chsize(int fd, long size)
 531 {
 532     FIXME("(fd=%d, size=%ld): stub\n", fd, size);
 533     return -1;
 534 }
 535
 536 /*********************************************************************
 537  *              _unlink (MSVCRT.@)
 538  */
 539 int _unlink(const char *path)
 540 {
 541   TRACE("(%s)\n",path);
 542   if(DeleteFileA(path))
 543     return 0;
 544   TRACE("failed (%ld)\n",GetLastError());
 545   msvcrt_set_errno(GetLastError());
 546   return -1;
 547 }
 548
 549 /*********************************************************************
 550  *              _wunlink (MSVCRT.@)
 551  */
 552 int _wunlink(const MSVCRT_wchar_t *path)
 553 {
 554   TRACE("(%s)\n",debugstr_w(path));
 555   if(DeleteFileW(path))
 556     return 0;
 557   TRACE("failed (%ld)\n",GetLastError());
 558   msvcrt_set_errno(GetLastError());
 559   return -1;
 560 }
 561
 562 /* _flushall calls MSVCRT_fflush which calls _flushall */
 563 int MSVCRT_fflush(MSVCRT_FILE* file);
 564
 565 /*********************************************************************
 566  *              _flushall (MSVCRT.@)
 567  */
 568 int _flushall(void)
 569 {
 570   int i, num_flushed = 0;
 571
 572   LOCK_FILES();
 573   for (i = 3; i < MSVCRT_stream_idx; i++)
 574     if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_flag)
 575     {
 576 #if 0
 577       /* FIXME: flush, do not commit */
 578       if (_commit(i) == -1)
 579         if (MSVCRT_fstreams[i])
 580           MSVCRT_fstreams[i]->_flag |= MSVCRT__IOERR;
 581 #endif
 582       if(MSVCRT_fstreams[i]->_flag & MSVCRT__IOWRT) {
 583         MSVCRT_fflush(MSVCRT_fstreams[i]);
 584         num_flushed++;
 585       }
 586     }
 587   UNLOCK_FILES();
 588
 589   TRACE(":flushed (%d) handles\n",num_flushed);
 590   return num_flushed;
 591 }
 592
 593 /*********************************************************************
 594  *              fflush (MSVCRT.@)
 595  */
 596 int MSVCRT_fflush(MSVCRT_FILE* file)
 597 {
 598   if(!file) {
 599         _flushall();
 600         return 0;
 601   } else {
 602         int res=msvcrt_flush_buffer(file);
 603         return res;
 604   }
 605 }
 606
 607 /*********************************************************************
 608  *              _close (MSVCRT.@)
 609  */
 610 int _close(int fd)
 611 {
 612   HANDLE hand;
 613   int ret;
 614
 615   LOCK_FILES();
 616   hand = msvcrt_fdtoh(fd);
 617   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 618   if (hand == INVALID_HANDLE_VALUE)
 619     ret = -1;
 620   else if (!CloseHandle(hand))
 621   {
 622     WARN(":failed-last error (%ld)\n",GetLastError());
 623     msvcrt_set_errno(GetLastError());
 624     ret = -1;
 625   }
 626   else
 627   {
 628     msvcrt_free_fd(fd);
 629     ret = 0;
 630   }
 631   UNLOCK_FILES();
 632   TRACE(":ok\n");
 633   return ret;
 634 }
 635
 636 /*********************************************************************
 637  *              _commit (MSVCRT.@)
 638  */
 639 int _commit(int fd)
 640 {
 641   HANDLE hand = msvcrt_fdtoh(fd);
 642
 643   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 644   if (hand == INVALID_HANDLE_VALUE)
 645     return -1;
 646
 647   if (!FlushFileBuffers(hand))
 648   {
 649     if (GetLastError() == ERROR_INVALID_HANDLE)
 650     {
 651       /* FlushFileBuffers fails for console handles
 652        * so we ignore this error.
 653        */
 654       return 0;
 655     }
 656     TRACE(":failed-last error (%ld)\n",GetLastError());
 657     msvcrt_set_errno(GetLastError());
 658     return -1;
 659   }
 660   TRACE(":ok\n");
 661   return 0;
 662 }
 663
 664 /*********************************************************************
 665  *              _dup2 (MSVCRT.@)
 666  * NOTES
 667  * MSDN isn't clear on this point, but the remarks for _pipe,
 668  * http://msdn.microsoft.com/library/default.asp?url=/library/en-us/vclib/html/_crt__pipe.asp
 669  * indicate file descriptors duplicated with _dup and _dup2 are always
 670  * inheritable.
 671  */
 672 int _dup2(int od, int nd)
 673 {
 674   int ret;
 675
 676   TRACE("(od=%d, nd=%d)\n", od, nd);
 677   LOCK_FILES();
 678   if (nd < MSVCRT_MAX_FILES && msvcrt_is_valid_fd(od))
 679   {
 680     HANDLE handle;
 681
 682     if (DuplicateHandle(GetCurrentProcess(), MSVCRT_fdesc[od].handle,
 683      GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS))
 684     {
 685       int wxflag = MSVCRT_fdesc[od].wxflag & ~MSVCRT__O_NOINHERIT;
 686
 687       if (msvcrt_is_valid_fd(nd))
 688         _close(nd);
 689       ret = msvcrt_alloc_fd_from(handle, wxflag, nd);
 690       if (ret == -1)
 691       {
 692         CloseHandle(handle);
 693         *MSVCRT__errno() = MSVCRT_EMFILE;
 694       }
 695       else
 696       {
 697         /* _dup2 returns 0, not nd, on success */
 698         ret = 0;
 699       }
 700     }
 701     else
 702     {
 703       ret = -1;
 704       msvcrt_set_errno(GetLastError());
 705     }
 706   }
 707   else
 708   {
 709     *MSVCRT__errno() = MSVCRT_EBADF;
 710     ret = -1;
 711   }
 712   UNLOCK_FILES();
 713   return ret;
 714 }
 715
 716 /*********************************************************************
 717  *              _dup (MSVCRT.@)
 718  */
 719 int _dup(int od)
 720 {
 721   int fd, ret;
 722
 723   LOCK_FILES();
 724   fd = MSVCRT_fdstart;
 725   if (_dup2(od, fd) == 0)
 726     ret = fd;
 727   else
 728     ret = -1;
 729   UNLOCK_FILES();
 730   return ret;
 731 }
 732
 733 /*********************************************************************
 734  *              _eof (MSVCRT.@)
 735  */
 736 int _eof(int fd)
 737 {
 738   DWORD curpos,endpos,hcurpos,hendpos;
 739   HANDLE hand = msvcrt_fdtoh(fd);
 740
 741   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 742
 743   if (hand == INVALID_HANDLE_VALUE)
 744     return -1;
 745
 746   if (MSVCRT_fdesc[fd].wxflag & WX_ATEOF) return TRUE;
 747
 748   /* Otherwise we do it the hard way */
 749   hcurpos = hendpos = 0;
 750   curpos = SetFilePointer(hand, 0, &hcurpos, SEEK_CUR);
 751   endpos = SetFilePointer(hand, 0, &hendpos, FILE_END);
 752
 753   if (curpos == endpos && hcurpos == hendpos)
 754   {
 755     /* FIXME: shouldn't WX_ATEOF be set here? */
 756     return TRUE;
 757   }
 758
 759   SetFilePointer(hand, curpos, &hcurpos, FILE_BEGIN);
 760   return FALSE;
 761 }
 762
 763 /*********************************************************************
 764  *              _fcloseall (MSVCRT.@)
 765  */
 766 int MSVCRT__fcloseall(void)
 767 {
 768   int num_closed = 0, i;
 769
 770   LOCK_FILES();
 771   for (i = 3; i < MSVCRT_stream_idx; i++)
 772     if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_flag &&
 773         MSVCRT_fclose(MSVCRT_fstreams[i]))
 774       num_closed++;
 775   UNLOCK_FILES();
 776
 777   TRACE(":closed (%d) handles\n",num_closed);
 778   return num_closed;
 779 }
 780
 781 /* free everything on process exit */
 782 void msvcrt_free_io(void)
 783 {
 784     MSVCRT__fcloseall();
 785     _close(0);
 786     _close(1);
 787     _close(2);
 788     DeleteCriticalSection(&MSVCRT_file_cs);
 789 }
 790
 791 /*********************************************************************
 792  *              _lseeki64 (MSVCRT.@)
 793  */
 794 __int64 _lseeki64(int fd, __int64 offset, int whence)
 795 {
 796   DWORD ret, hoffset = (DWORD) (offset >> 32);
 797   HANDLE hand = msvcrt_fdtoh(fd);
 798
 799   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 800   if (hand == INVALID_HANDLE_VALUE)
 801     return -1;
 802
 803   if (whence < 0 || whence > 2)
 804   {
 805     *MSVCRT__errno() = MSVCRT_EINVAL;
 806     return -1;
 807   }
 808
 809   TRACE(":fd (%d) to 0x%08lx%08lx pos %s\n",
 810         fd,hoffset,(long)offset,
 811         (whence==SEEK_SET)?"SEEK_SET":
 812         (whence==SEEK_CUR)?"SEEK_CUR":
 813         (whence==SEEK_END)?"SEEK_END":"UNKNOWN");
 814
 815   ret = SetFilePointer(hand, (long)offset, &hoffset, whence);
 816   if (ret != INVALID_SET_FILE_POINTER || !GetLastError())
 817   {
 818     MSVCRT_fdesc[fd].wxflag &= ~WX_ATEOF;
 819     /* FIXME: What if we seek _to_ EOF - is EOF set? */
 820
 821     return ((__int64)hoffset << 32) | ret;
 822   }
 823   TRACE(":error-last error (%ld)\n",GetLastError());
 824   msvcrt_set_errno(GetLastError());
 825   return -1;
 826 }
 827
 828 /*********************************************************************
 829  *              _lseek (MSVCRT.@)
 830  */
 831 LONG _lseek(int fd, LONG offset, int whence)
 832 {
 833     return _lseeki64(fd, offset, whence);
 834 }
 835
 836 /*********************************************************************
 837  *              _locking (MSVCRT.@)
 838  *
 839  * This is untested; the underlying LockFile doesn't work yet.
 840  */
 841 int _locking(int fd, int mode, LONG nbytes)
 842 {
 843   BOOL ret;
 844   DWORD cur_locn;
 845   HANDLE hand = msvcrt_fdtoh(fd);
 846
 847   TRACE(":fd (%d) handle (%p)\n",fd,hand);
 848   if (hand == INVALID_HANDLE_VALUE)
 849     return -1;
 850
 851   if (mode < 0 || mode > 4)
 852   {
 853     *MSVCRT__errno() = MSVCRT_EINVAL;
 854     return -1;
 855   }
 856
 857   TRACE(":fd (%d) by 0x%08lx mode %s\n",
 858         fd,nbytes,(mode==MSVCRT__LK_UNLCK)?"_LK_UNLCK":
 859         (mode==MSVCRT__LK_LOCK)?"_LK_LOCK":
 860         (mode==MSVCRT__LK_NBLCK)?"_LK_NBLCK":
 861         (mode==MSVCRT__LK_RLCK)?"_LK_RLCK":
 862         (mode==MSVCRT__LK_NBRLCK)?"_LK_NBRLCK":
 863                           "UNKNOWN");
 864
 865   if ((cur_locn = SetFilePointer(hand, 0L, NULL, SEEK_CUR)) == INVALID_SET_FILE_POINTER)
 866   {
 867     FIXME ("Seek failed\n");
 868     *MSVCRT__errno() = MSVCRT_EINVAL; /* FIXME */
 869     return -1;
 870   }
 871   if (mode == MSVCRT__LK_LOCK || mode == MSVCRT__LK_RLCK)
 872   {
 873     int nretry = 10;
 874     ret = 1; /* just to satisfy gcc */
 875     while (nretry--)
 876     {
 877       ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
 878       if (ret) break;
 879       Sleep(1);
 880     }
 881   }
 882   else if (mode == MSVCRT__LK_UNLCK)
 883     ret = UnlockFile(hand, cur_locn, 0L, nbytes, 0L);
 884   else
 885     ret = LockFile(hand, cur_locn, 0L, nbytes, 0L);
 886   /* FIXME - what about error settings? */
 887   return ret ? 0 : -1;
 888 }
 889
 890 /*********************************************************************
 891  *              fseek (MSVCRT.@)
 892  */
 893 int MSVCRT_fseek(MSVCRT_FILE* file, long offset, int whence)
 894 {
 895   /* Flush output if needed */
 896   if(file->_flag & MSVCRT__IOWRT)
 897         msvcrt_flush_buffer(file);
 898
 899   if(whence == SEEK_CUR && file->_flag & MSVCRT__IOREAD ) {
 900         offset -= file->_cnt;
 901   }
 902   /* Discard buffered input */
 903   file->_cnt = 0;
 904   file->_ptr = file->_base;
 905   /* Reset direction of i/o */
 906   if(file->_flag & MSVCRT__IORW) {
 907         file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
 908   }
 909   return (_lseek(file->_file,offset,whence) == -1)?-1:0;
 910 }
 911
 912 /*********************************************************************
 913  *              clearerr (MSVCRT.@)
 914  */
 915 void MSVCRT_clearerr(MSVCRT_FILE* file)
 916 {
 917   TRACE(":file (%p) fd (%d)\n",file,file->_file);
 918   file->_flag &= ~(MSVCRT__IOERR | MSVCRT__IOEOF);
 919 }
 920
 921 /*********************************************************************
 922  *              rewind (MSVCRT.@)
 923  */
 924 void MSVCRT_rewind(MSVCRT_FILE* file)
 925 {
 926   TRACE(":file (%p) fd (%d)\n",file,file->_file);
 927   MSVCRT_fseek(file, 0L, SEEK_SET);
 928   MSVCRT_clearerr(file);
 929 }
 930
 931 static int msvcrt_get_flags(const char* mode, int *open_flags, int* stream_flags)
 932 {
 933   int plus = strchr(mode, '+') != NULL;
 934
 935   switch(*mode++)
 936   {
 937   case 'R': case 'r':
 938     *open_flags = plus ? MSVCRT__O_RDWR : MSVCRT__O_RDONLY;
 939     *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOREAD;
 940     break;
 941   case 'W': case 'w':
 942     *open_flags = MSVCRT__O_CREAT | MSVCRT__O_TRUNC | (plus  ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
 943     *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
 944     break;
 945   case 'A': case 'a':
 946     *open_flags = MSVCRT__O_CREAT | MSVCRT__O_APPEND | (plus  ? MSVCRT__O_RDWR : MSVCRT__O_WRONLY);
 947     *stream_flags = plus ? MSVCRT__IORW : MSVCRT__IOWRT;
 948     break;
 949   default:
 950     return -1;
 951   }
 952
 953   while (*mode)
 954     switch (*mode++)
 955     {
 956     case 'B': case 'b':
 957       *open_flags |=  MSVCRT__O_BINARY;
 958       *open_flags &= ~MSVCRT__O_TEXT;
 959       break;
 960     case 'T': case 't':
 961       *open_flags |=  MSVCRT__O_TEXT;
 962       *open_flags &= ~MSVCRT__O_BINARY;
 963       break;
 964     case '+':
 965       break;
 966     default:
 967       FIXME(":unknown flag %c not supported\n",mode[-1]);
 968     }
 969   return 0;
 970 }
 971
 972 /*********************************************************************
 973  *              _fdopen (MSVCRT.@)
 974  */
 975 MSVCRT_FILE* MSVCRT__fdopen(int fd, const char *mode)
 976 {
 977   int open_flags, stream_flags;
 978   MSVCRT_FILE* file;
 979
 980   if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1) return NULL;
 981
 982   LOCK_FILES();
 983   if (!(file = msvcrt_alloc_fp()))
 984     file = NULL;
 985   else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
 986   {
 987     file->_flag = 0;
 988     file = NULL;
 989   }
 990   else TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,mode,file);
 991   UNLOCK_FILES();
 992
 993   return file;
 994 }
 995
 996 /*********************************************************************
 997  *              _wfdopen (MSVCRT.@)
 998  */
 999 MSVCRT_FILE* MSVCRT__wfdopen(int fd, const MSVCRT_wchar_t *mode)
1000 {
1001   unsigned mlen = strlenW(mode);
1002   char *modea = MSVCRT_calloc(mlen + 1, 1);
1003   MSVCRT_FILE* file = NULL;
1004   int open_flags, stream_flags;
1005
1006   if (modea &&
1007       WideCharToMultiByte(CP_ACP,0,mode,mlen,modea,mlen,NULL,NULL))
1008   {
1009       if (msvcrt_get_flags(modea, &open_flags, &stream_flags) == -1) return NULL;
1010       LOCK_FILES();
1011       if (!(file = msvcrt_alloc_fp()))
1012         file = NULL;
1013       else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
1014       {
1015         file->_flag = 0;
1016         file = NULL;
1017       }
1018       else
1019       {
1020         if (file)
1021           MSVCRT_rewind(file); /* FIXME: is this needed ??? */
1022         TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,debugstr_w(mode),file);
1023       }
1024       UNLOCK_FILES();
1025   }
1026   return file;
1027 }
1028
1029 /*********************************************************************
1030  *              _filelength (MSVCRT.@)
1031  */
1032 LONG _filelength(int fd)
1033 {
1034   LONG curPos = _lseek(fd, 0, SEEK_CUR);
1035   if (curPos != -1)
1036   {
1037     LONG endPos = _lseek(fd, 0, SEEK_END);
1038     if (endPos != -1)
1039     {
1040       if (endPos != curPos)
1041         _lseek(fd, curPos, SEEK_SET);
1042       return endPos;
1043     }
1044   }
1045   return -1;
1046 }
1047
1048 /*********************************************************************
1049  *              _filelengthi64 (MSVCRT.@)
1050  */
1051 __int64 _filelengthi64(int fd)
1052 {
1053   __int64 curPos = _lseeki64(fd, 0, SEEK_CUR);
1054   if (curPos != -1)
1055   {
1056     __int64 endPos = _lseeki64(fd, 0, SEEK_END);
1057     if (endPos != -1)
1058     {
1059       if (endPos != curPos)
1060         _lseeki64(fd, curPos, SEEK_SET);
1061       return endPos;
1062     }
1063   }
1064   return -1;
1065 }
1066
1067 /*********************************************************************
1068  *              _fileno (MSVCRT.@)
1069  */
1070 int MSVCRT__fileno(MSVCRT_FILE* file)
1071 {
1072   TRACE(":FILE* (%p) fd (%d)\n",file,file->_file);
1073   return file->_file;
1074 }
1075
1076 /*********************************************************************
1077  *              _fstati64 (MSVCRT.@)
1078  */
1079 int MSVCRT__fstati64(int fd, struct MSVCRT__stati64* buf)
1080 {
1081   DWORD dw;
1082   BY_HANDLE_FILE_INFORMATION hfi;
1083   HANDLE hand = msvcrt_fdtoh(fd);
1084
1085   TRACE(":fd (%d) stat (%p)\n",fd,buf);
1086   if (hand == INVALID_HANDLE_VALUE)
1087     return -1;
1088
1089   if (!buf)
1090   {
1091     WARN(":failed-NULL buf\n");
1092     msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1093     return -1;
1094   }
1095
1096   memset(&hfi, 0, sizeof(hfi));
1097   memset(buf, 0, sizeof(struct MSVCRT__stati64));
1098   if (!GetFileInformationByHandle(hand, &hfi))
1099   {
1100     WARN(":failed-last error (%ld)\n",GetLastError());
1101     msvcrt_set_errno(ERROR_INVALID_PARAMETER);
1102     return -1;
1103   }
1104   dw = GetFileType(hand);
1105   buf->st_mode = S_IREAD;
1106   if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1107     buf->st_mode |= S_IWRITE;
1108   /* interestingly, Windows never seems to set S_IFDIR */
1109   if (dw == FILE_TYPE_CHAR)
1110     buf->st_mode |= S_IFCHR;
1111   else if (dw == FILE_TYPE_PIPE)
1112     buf->st_mode |= S_IFIFO;
1113   else
1114     buf->st_mode |= S_IFREG;
1115   TRACE(":dwFileAttributes = 0x%lx, mode set to 0x%x\n",hfi.dwFileAttributes,
1116    buf->st_mode);
1117   buf->st_nlink = hfi.nNumberOfLinks;
1118   buf->st_size  = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1119   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1120   buf->st_atime = dw;
1121   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1122   buf->st_mtime = buf->st_ctime = dw;
1123   return 0;
1124 }
1125
1126 /*********************************************************************
1127  *              _fstat (MSVCRT.@)
1128  */
1129 int MSVCRT__fstat(int fd, struct MSVCRT__stat* buf)
1130 { int ret;
1131   struct MSVCRT__stati64 bufi64;
1132
1133   ret = MSVCRT__fstati64(fd, &bufi64);
1134   if (!ret)
1135       msvcrt_cp_from_stati64(&bufi64, buf);
1136   return ret;
1137 }
1138
1139 /*********************************************************************
1140  *              _futime (MSVCRT.@)
1141  */
1142 int _futime(int fd, struct MSVCRT__utimbuf *t)
1143 {
1144   HANDLE hand = msvcrt_fdtoh(fd);
1145   FILETIME at, wt;
1146
1147   if (!t)
1148   {
1149     MSVCRT_time_t currTime;
1150     MSVCRT_time(&currTime);
1151     RtlSecondsSince1970ToTime(currTime, (LARGE_INTEGER *)&at);
1152     memcpy(&wt, &at, sizeof(wt));
1153   }
1154   else
1155   {
1156     RtlSecondsSince1970ToTime(t->actime, (LARGE_INTEGER *)&at);
1157     if (t->actime == t->modtime)
1158       memcpy(&wt, &at, sizeof(wt));
1159     else
1160       RtlSecondsSince1970ToTime(t->modtime, (LARGE_INTEGER *)&wt);
1161   }
1162
1163   if (!SetFileTime(hand, NULL, &at, &wt))
1164   {
1165     msvcrt_set_errno(GetLastError());
1166     return -1 ;
1167   }
1168   return 0;
1169 }
1170
1171 /*********************************************************************
1172  *              _get_osfhandle (MSVCRT.@)
1173  */
1174 long _get_osfhandle(int fd)
1175 {
1176   HANDLE hand = msvcrt_fdtoh(fd);
1177   HANDLE newhand = hand;
1178   TRACE(":fd (%d) handle (%p)\n",fd,hand);
1179
1180   if (hand != INVALID_HANDLE_VALUE)
1181   {
1182     /* FIXME: I'm not convinced that I should be copying the
1183      * handle here - it may be leaked if the app doesn't
1184      * close it (and the API docs don't say that it should)
1185      * Not duplicating it means that it can't be inherited
1186      * and so lcc's wedit doesn't cope when it passes it to
1187      * child processes. I've an idea that it should either
1188      * be copied by CreateProcess, or marked as inheritable
1189      * when initialised, or maybe both? JG 21-9-00.
1190      */
1191     DuplicateHandle(GetCurrentProcess(),hand,GetCurrentProcess(),
1192                     &newhand,0,TRUE,DUPLICATE_SAME_ACCESS);
1193   }
1194   return (long)newhand;
1195 }
1196
1197 /*********************************************************************
1198  *              _isatty (MSVCRT.@)
1199  */
1200 int _isatty(int fd)
1201 {
1202   HANDLE hand = msvcrt_fdtoh(fd);
1203
1204   TRACE(":fd (%d) handle (%p)\n",fd,hand);
1205   if (hand == INVALID_HANDLE_VALUE)
1206     return 0;
1207
1208   return GetFileType(hand) == FILE_TYPE_CHAR? 1 : 0;
1209 }
1210
1211 /*********************************************************************
1212  *              _mktemp (MSVCRT.@)
1213  */
1214 char *_mktemp(char *pattern)
1215 {
1216   int numX = 0;
1217   char *retVal = pattern;
1218   int id;
1219   char letter = 'a';
1220
1221   while(*pattern)
1222     numX = (*pattern++ == 'X')? numX + 1 : 0;
1223   if (numX < 5)
1224     return NULL;
1225   pattern--;
1226   id = GetCurrentProcessId();
1227   numX = 6;
1228   while(numX--)
1229   {
1230     int tempNum = id / 10;
1231     *pattern-- = id - (tempNum * 10) + '0';
1232     id = tempNum;
1233   }
1234   pattern++;
1235   do
1236   {
1237     if (GetFileAttributesA(retVal) == INVALID_FILE_ATTRIBUTES &&
1238         GetLastError() == ERROR_FILE_NOT_FOUND)
1239       return retVal;
1240     *pattern = letter++;
1241   } while(letter != '|');
1242   return NULL;
1243 }
1244
1245 /*********************************************************************
1246  *              _wmktemp (MSVCRT.@)
1247  */
1248 MSVCRT_wchar_t *_wmktemp(MSVCRT_wchar_t *pattern)
1249 {
1250   int numX = 0;
1251   MSVCRT_wchar_t *retVal = pattern;
1252   int id;
1253   MSVCRT_wchar_t letter = 'a';
1254
1255   while(*pattern)
1256     numX = (*pattern++ == 'X')? numX + 1 : 0;
1257   if (numX < 5)
1258     return NULL;
1259   pattern--;
1260   id = GetCurrentProcessId();
1261   numX = 6;
1262   while(numX--)
1263   {
1264     int tempNum = id / 10;
1265     *pattern-- = id - (tempNum * 10) + '0';
1266     id = tempNum;
1267   }
1268   pattern++;
1269   do
1270   {
1271     if (GetFileAttributesW(retVal) == INVALID_FILE_ATTRIBUTES &&
1272         GetLastError() == ERROR_FILE_NOT_FOUND)
1273       return retVal;
1274     *pattern = letter++;
1275   } while(letter != '|');
1276   return NULL;
1277 }
1278
1279 static unsigned split_oflags(unsigned oflags)
1280 {
1281     int         wxflags = 0;
1282     unsigned unsupp; /* until we support everything */
1283
1284     if (oflags & MSVCRT__O_APPEND)              wxflags |= WX_APPEND;
1285     if (oflags & MSVCRT__O_BINARY)              ;
1286     else if (oflags & MSVCRT__O_TEXT)           wxflags |= WX_TEXT;
1287     else if (*__p__fmode() & MSVCRT__O_BINARY)  ;
1288     else                                        wxflags |= WX_TEXT; /* default to TEXT*/
1289     if (oflags & MSVCRT__O_NOINHERIT)           wxflags |= WX_DONTINHERIT;
1290
1291     if ((unsupp = oflags & ~(
1292                     MSVCRT__O_BINARY|MSVCRT__O_TEXT|MSVCRT__O_APPEND|
1293                     MSVCRT__O_TRUNC|MSVCRT__O_EXCL|MSVCRT__O_CREAT|
1294                     MSVCRT__O_RDWR|MSVCRT__O_WRONLY|MSVCRT__O_TEMPORARY|
1295                     MSVCRT__O_NOINHERIT|
1296                     MSVCRT__O_SEQUENTIAL|MSVCRT__O_RANDOM|MSVCRT__O_SHORT_LIVED
1297                     )))
1298         ERR(":unsupported oflags 0x%04x\n",unsupp);
1299
1300     return wxflags;
1301 }
1302
1303 /*********************************************************************
1304  *              _pipe (MSVCRT.@)
1305  */
1306 int _pipe(int *pfds, unsigned int psize, int textmode)
1307 {
1308   int ret = -1;
1309   SECURITY_ATTRIBUTES sa;
1310   HANDLE readHandle, writeHandle;
1311
1312   if (!pfds)
1313   {
1314     *MSVCRT__errno() = MSVCRT_EINVAL;
1315     return -1;
1316   }
1317
1318   sa.nLength = sizeof(SECURITY_ATTRIBUTES);
1319   sa.bInheritHandle = !(textmode & MSVCRT__O_NOINHERIT);
1320   sa.lpSecurityDescriptor = NULL;
1321   if (CreatePipe(&readHandle, &writeHandle, &sa, psize))
1322   {
1323     unsigned int wxflags = split_oflags(textmode);
1324     int fd;
1325
1326     LOCK_FILES();
1327     fd = msvcrt_alloc_fd(readHandle, wxflags);
1328     if (fd != -1)
1329     {
1330       pfds[0] = fd;
1331       fd = msvcrt_alloc_fd(writeHandle, wxflags);
1332       if (fd != -1)
1333       {
1334         pfds[1] = fd;
1335         ret = 0;
1336       }
1337       else
1338       {
1339         _close(pfds[0]);
1340         CloseHandle(writeHandle);
1341         *MSVCRT__errno() = MSVCRT_EMFILE;
1342       }
1343     }
1344     else
1345     {
1346       CloseHandle(readHandle);
1347       CloseHandle(writeHandle);
1348       *MSVCRT__errno() = MSVCRT_EMFILE;
1349     }
1350     UNLOCK_FILES();
1351   }
1352   else
1353     msvcrt_set_errno(GetLastError());
1354
1355   return ret;
1356 }
1357
1358 /*********************************************************************
1359  *              _sopen (MSVCRT.@)
1360  */
1361 int MSVCRT__sopen( const char *path, int oflags, int shflags, ... )
1362 {
1363   va_list ap;
1364   int pmode;
1365   DWORD access = 0, creation = 0, attrib;
1366   DWORD sharing;
1367   int wxflag = 0, fd;
1368   HANDLE hand;
1369   SECURITY_ATTRIBUTES sa;
1370
1371
1372   TRACE(":file (%s) oflags: 0x%04x shflags: 0x%04x\n",
1373         path, oflags, shflags);
1374
1375   wxflag = split_oflags(oflags);
1376   switch (oflags & (MSVCRT__O_RDONLY | MSVCRT__O_WRONLY | MSVCRT__O_RDWR))
1377   {
1378   case MSVCRT__O_RDONLY: access |= GENERIC_READ; break;
1379   case MSVCRT__O_WRONLY: access |= GENERIC_WRITE; break;
1380   case MSVCRT__O_RDWR:   access |= GENERIC_WRITE | GENERIC_READ; break;
1381   }
1382
1383   if (oflags & MSVCRT__O_CREAT)
1384   {
1385     va_start(ap, shflags);
1386       pmode = va_arg(ap, int);
1387     va_end(ap);
1388
1389     if(pmode & ~(MSVCRT__S_IREAD | MSVCRT__S_IWRITE))
1390       FIXME(": pmode 0x%04x ignored\n", pmode);
1391     else
1392       WARN(": pmode 0x%04x ignored\n", pmode);
1393
1394     if (oflags & MSVCRT__O_EXCL)
1395       creation = CREATE_NEW;
1396     else if (oflags & MSVCRT__O_TRUNC)
1397       creation = CREATE_ALWAYS;
1398     else
1399       creation = OPEN_ALWAYS;
1400   }
1401   else  /* no MSVCRT__O_CREAT */
1402   {
1403     if (oflags & MSVCRT__O_TRUNC)
1404       creation = TRUNCATE_EXISTING;
1405     else
1406       creation = OPEN_EXISTING;
1407   }
1408
1409   switch( shflags )
1410   {
1411     case MSVCRT__SH_DENYRW:
1412       sharing = 0L;
1413       break;
1414     case MSVCRT__SH_DENYWR:
1415       sharing = FILE_SHARE_READ;
1416       break;
1417     case MSVCRT__SH_DENYRD:
1418       sharing = FILE_SHARE_WRITE;
1419       break;
1420     case MSVCRT__SH_DENYNO:
1421       sharing = FILE_SHARE_READ | FILE_SHARE_WRITE;
1422       break;
1423     default:
1424       ERR( "Unhandled shflags 0x%x\n", shflags );
1425       return -1;
1426   }
1427   attrib = FILE_ATTRIBUTE_NORMAL;
1428
1429   if (oflags & MSVCRT__O_TEMPORARY)
1430   {
1431       attrib |= FILE_FLAG_DELETE_ON_CLOSE;
1432       access |= DELETE;
1433       sharing |= FILE_SHARE_DELETE;
1434   }
1435
1436   sa.nLength              = sizeof( SECURITY_ATTRIBUTES );
1437   sa.lpSecurityDescriptor = NULL;
1438   sa.bInheritHandle       = (oflags & MSVCRT__O_NOINHERIT) ? FALSE : TRUE;
1439
1440   hand = CreateFileA(path, access, sharing, &sa, creation, attrib, 0);
1441
1442   if (hand == INVALID_HANDLE_VALUE)  {
1443     WARN(":failed-last error (%ld)\n",GetLastError());
1444     msvcrt_set_errno(GetLastError());
1445     return -1;
1446   }
1447
1448   fd = msvcrt_alloc_fd(hand, wxflag);
1449
1450   TRACE(":fd (%d) handle (%p)\n",fd, hand);
1451
1452   if (fd > 0)
1453   {
1454     if (oflags & MSVCRT__O_APPEND)
1455       _lseek(fd, 0, FILE_END);
1456   }
1457
1458   return fd;
1459 }
1460
1461 /*********************************************************************
1462  *              _wsopen (MSVCRT.@)
1463  */
1464 int MSVCRT__wsopen( const MSVCRT_wchar_t* path, int oflags, int shflags, ... )
1465 {
1466   const unsigned int len = strlenW(path);
1467   char *patha = MSVCRT_calloc(len + 1,1);
1468   va_list ap;
1469   int pmode;
1470
1471   va_start(ap, shflags);
1472   pmode = va_arg(ap, int);
1473   va_end(ap);
1474
1475   if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
1476   {
1477     int retval = MSVCRT__sopen(patha,oflags,shflags,pmode);
1478     MSVCRT_free(patha);
1479     return retval;
1480   }
1481
1482   msvcrt_set_errno(GetLastError());
1483   return -1;
1484 }
1485
1486 /*********************************************************************
1487  *              _open (MSVCRT.@)
1488  */
1489 int _open( const char *path, int flags, ... )
1490 {
1491   va_list ap;
1492
1493   if (flags & MSVCRT__O_CREAT)
1494   {
1495     int pmode;
1496     va_start(ap, flags);
1497     pmode = va_arg(ap, int);
1498     va_end(ap);
1499     return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO, pmode );
1500   }
1501   else
1502     return MSVCRT__sopen( path, flags, MSVCRT__SH_DENYNO);
1503 }
1504
1505 /*********************************************************************
1506  *              _wopen (MSVCRT.@)
1507  */
1508 int _wopen(const MSVCRT_wchar_t *path,int flags,...)
1509 {
1510   const unsigned int len = strlenW(path);
1511   char *patha = MSVCRT_calloc(len + 1,1);
1512   va_list ap;
1513   int pmode;
1514
1515   va_start(ap, flags);
1516   pmode = va_arg(ap, int);
1517   va_end(ap);
1518
1519   if (patha && WideCharToMultiByte(CP_ACP,0,path,len,patha,len,NULL,NULL))
1520   {
1521     int retval = _open(patha,flags,pmode);
1522     MSVCRT_free(patha);
1523     return retval;
1524   }
1525
1526   msvcrt_set_errno(GetLastError());
1527   return -1;
1528 }
1529
1530 /*********************************************************************
1531  *              _creat (MSVCRT.@)
1532  */
1533 int _creat(const char *path, int flags)
1534 {
1535   int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
1536   return _open(path, usedFlags);
1537 }
1538
1539 /*********************************************************************
1540  *              _wcreat (MSVCRT.@)
1541  */
1542 int _wcreat(const MSVCRT_wchar_t *path, int flags)
1543 {
1544   int usedFlags = (flags & MSVCRT__O_TEXT)| MSVCRT__O_CREAT| MSVCRT__O_WRONLY| MSVCRT__O_TRUNC;
1545   return _wopen(path, usedFlags);
1546 }
1547
1548 /*********************************************************************
1549  *              _open_osfhandle (MSVCRT.@)
1550  */
1551 int _open_osfhandle(long handle, int oflags)
1552 {
1553   int fd;
1554
1555   /* MSVCRT__O_RDONLY (0) always matches, so set the read flag
1556    * MFC's CStdioFile clears O_RDONLY (0)! if it wants to write to the
1557    * file, so set the write flag. It also only sets MSVCRT__O_TEXT if it wants
1558    * text - it never sets MSVCRT__O_BINARY.
1559    */
1560   /* FIXME: handle more flags */
1561   if (!(oflags & (MSVCRT__O_BINARY | MSVCRT__O_TEXT)) && (*__p__fmode() & MSVCRT__O_BINARY))
1562       oflags |= MSVCRT__O_BINARY;
1563   else
1564       oflags |= MSVCRT__O_TEXT;
1565
1566   fd = msvcrt_alloc_fd((HANDLE)handle, split_oflags(oflags));
1567   TRACE(":handle (%ld) fd (%d) flags 0x%08x\n", handle, fd, oflags);
1568   return fd;
1569 }
1570
1571 /*********************************************************************
1572  *              _rmtmp (MSVCRT.@)
1573  */
1574 int _rmtmp(void)
1575 {
1576   int num_removed = 0, i;
1577
1578   LOCK_FILES();
1579   for (i = 3; i < MSVCRT_stream_idx; i++)
1580     if (MSVCRT_fstreams[i] && MSVCRT_fstreams[i]->_tmpfname)
1581     {
1582       MSVCRT_fclose(MSVCRT_fstreams[i]);
1583       num_removed++;
1584     }
1585   UNLOCK_FILES();
1586
1587   if (num_removed)
1588     TRACE(":removed (%d) temp files\n",num_removed);
1589   return num_removed;
1590 }
1591
1592 /*********************************************************************
1593  * (internal) remove_cr
1594  *
1595  *    Remove all \r inplace.
1596  * return the number of \r removed
1597  */
1598 static unsigned int remove_cr(char *buf, unsigned int count)
1599 {
1600     unsigned int i, j;
1601
1602     for (i = 0; i < count; i++) if (buf[i] == '\r') break;
1603     for (j = i + 1; j < count; j++) if (buf[j] != '\r') buf[i++] = buf[j];
1604     return count - i;
1605 }
1606
1607 /*********************************************************************
1608  *              _read (MSVCRT.@)
1609  */
1610 int _read(int fd, void *buf, unsigned int count)
1611 {
1612   DWORD num_read, all_read = 0;
1613   char *bufstart = buf;
1614   HANDLE hand = msvcrt_fdtoh(fd);
1615
1616   /* Don't trace small reads, it gets *very* annoying */
1617   if (count > 4)
1618     TRACE(":fd (%d) handle (%p) buf (%p) len (%d)\n",fd,hand,buf,count);
1619   if (hand == INVALID_HANDLE_VALUE)
1620     return -1;
1621
1622   /* Reading single bytes in O_TEXT mode makes things slow
1623    * So read big chunks, then remove the \r in memory and try reading
1624    * the rest until the request is satisfied or EOF is met
1625    */
1626   while (all_read < count)
1627   {
1628       if (ReadFile(hand, bufstart+all_read, count - all_read, &num_read, NULL))
1629       {
1630           if (num_read != (count - all_read))
1631           {
1632               TRACE(":EOF\n");
1633               MSVCRT_fdesc[fd].wxflag |= WX_ATEOF;
1634               if (MSVCRT_fdesc[fd].wxflag & WX_TEXT)
1635                   num_read -= remove_cr(bufstart+all_read,num_read);
1636               all_read += num_read;
1637               if (count > 4)
1638                   TRACE("%s\n",debugstr_an(buf,all_read));
1639               return all_read;
1640           }
1641           if (MSVCRT_fdesc[fd].wxflag & WX_TEXT)
1642           {
1643               num_read -= remove_cr(bufstart+all_read,num_read);
1644           }
1645           all_read += num_read;
1646       }
1647       else
1648       {
1649           TRACE(":failed-last error (%ld)\n",GetLastError());
1650           return -1;
1651       }
1652   }
1653
1654   if (count > 4)
1655       TRACE("(%lu), %s\n",all_read,debugstr_an(buf, all_read));
1656   return all_read;
1657 }
1658
1659 /*********************************************************************
1660  *              _getw (MSVCRT.@)
1661  */
1662 int MSVCRT__getw(MSVCRT_FILE* file)
1663 {
1664   int i;
1665   switch (_read(file->_file, &i, sizeof(int)))
1666   {
1667   case 1: return i;
1668   case 0: file->_flag |= MSVCRT__IOEOF; break;
1669   default: file->_flag |= MSVCRT__IOERR; break;
1670   }
1671   return EOF;
1672 }
1673
1674 /*********************************************************************
1675  *              _setmode (MSVCRT.@)
1676  */
1677 int _setmode(int fd,int mode)
1678 {
1679   int ret = MSVCRT_fdesc[fd].wxflag & WX_TEXT ? MSVCRT__O_TEXT : MSVCRT__O_BINARY;
1680   if (mode & (~(MSVCRT__O_TEXT|MSVCRT__O_BINARY)))
1681     FIXME("fd (%d) mode (0x%08x) unknown\n",fd,mode);
1682   if ((mode & MSVCRT__O_TEXT) == MSVCRT__O_TEXT)
1683     MSVCRT_fdesc[fd].wxflag |= WX_TEXT;
1684   else
1685     MSVCRT_fdesc[fd].wxflag &= ~WX_TEXT;
1686   return ret;
1687 }
1688
1689 /*********************************************************************
1690  *              _stati64 (MSVCRT.@)
1691  */
1692 int MSVCRT__stati64(const char* path, struct MSVCRT__stati64 * buf)
1693 {
1694   DWORD dw;
1695   WIN32_FILE_ATTRIBUTE_DATA hfi;
1696   unsigned short mode = ALL_S_IREAD;
1697   int plen;
1698
1699   TRACE(":file (%s) buf(%p)\n",path,buf);
1700
1701   if (!GetFileAttributesExA(path, GetFileExInfoStandard, &hfi))
1702   {
1703       TRACE("failed (%ld)\n",GetLastError());
1704       msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1705       return -1;
1706   }
1707
1708   memset(buf,0,sizeof(struct MSVCRT__stati64));
1709
1710   /* FIXME: rdev isn't drive num, despite what the docs say-what is it?
1711      Bon 011120: This FIXME seems incorrect
1712                  Also a letter as first char isn't enough to be classified
1713                  as a drive letter
1714   */
1715   if (isalpha(*path)&& (*(path+1)==':'))
1716     buf->st_dev = buf->st_rdev = toupper(*path) - 'A'; /* drive num */
1717   else
1718     buf->st_dev = buf->st_rdev = _getdrive() - 1;
1719
1720   plen = strlen(path);
1721
1722   /* Dir, or regular file? */
1723   if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1724       (path[plen-1] == '\\'))
1725     mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
1726   else
1727   {
1728     mode |= MSVCRT__S_IFREG;
1729     /* executable? */
1730     if (plen > 6 && path[plen-4] == '.')  /* shortest exe: "\x.exe" */
1731     {
1732       unsigned int ext = tolower(path[plen-1]) | (tolower(path[plen-2]) << 8) |
1733                                  (tolower(path[plen-3]) << 16);
1734       if (ext == EXE || ext == BAT || ext == CMD || ext == COM)
1735           mode |= ALL_S_IEXEC;
1736     }
1737   }
1738
1739   if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1740     mode |= ALL_S_IWRITE;
1741
1742   buf->st_mode  = mode;
1743   buf->st_nlink = 1;
1744   buf->st_size  = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1745   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1746   buf->st_atime = dw;
1747   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1748   buf->st_mtime = buf->st_ctime = dw;
1749   TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf->st_mode,buf->st_nlink,
1750         (long)(buf->st_size >> 32),(long)buf->st_size,
1751         buf->st_atime,buf->st_mtime, buf->st_ctime);
1752   return 0;
1753 }
1754
1755 /*********************************************************************
1756  *              _stat (MSVCRT.@)
1757  */
1758 int MSVCRT__stat(const char* path, struct MSVCRT__stat * buf)
1759 { int ret;
1760   struct MSVCRT__stati64 bufi64;
1761
1762   ret = MSVCRT__stati64( path, &bufi64);
1763   if (!ret)
1764       msvcrt_cp_from_stati64(&bufi64, buf);
1765   return ret;
1766 }
1767
1768 /*********************************************************************
1769  *              _wstati64 (MSVCRT.@)
1770  */
1771 int MSVCRT__wstati64(const MSVCRT_wchar_t* path, struct MSVCRT__stati64 * buf)
1772 {
1773   DWORD dw;
1774   WIN32_FILE_ATTRIBUTE_DATA hfi;
1775   unsigned short mode = ALL_S_IREAD;
1776   int plen;
1777
1778   TRACE(":file (%s) buf(%p)\n",debugstr_w(path),buf);
1779
1780   if (!GetFileAttributesExW(path, GetFileExInfoStandard, &hfi))
1781   {
1782       TRACE("failed (%ld)\n",GetLastError());
1783       msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
1784       return -1;
1785   }
1786
1787   memset(buf,0,sizeof(struct MSVCRT__stat));
1788
1789   /* FIXME: rdev isn't drive num, despite what the docs says-what is it? */
1790   if (MSVCRT_iswalpha(*path))
1791     buf->st_dev = buf->st_rdev = toupperW(*path - 'A'); /* drive num */
1792   else
1793     buf->st_dev = buf->st_rdev = _getdrive() - 1;
1794
1795   plen = strlenW(path);
1796
1797   /* Dir, or regular file? */
1798   if ((hfi.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ||
1799       (path[plen-1] == '\\'))
1800     mode |= (MSVCRT__S_IFDIR | ALL_S_IEXEC);
1801   else
1802   {
1803     mode |= MSVCRT__S_IFREG;
1804     /* executable? */
1805     if (plen > 6 && path[plen-4] == '.')  /* shortest exe: "\x.exe" */
1806     {
1807       ULONGLONG ext = tolowerW(path[plen-1]) | (tolowerW(path[plen-2]) << 16) |
1808                                ((ULONGLONG)tolowerW(path[plen-3]) << 32);
1809       if (ext == WCEXE || ext == WCBAT || ext == WCCMD || ext == WCCOM)
1810         mode |= ALL_S_IEXEC;
1811     }
1812   }
1813
1814   if (!(hfi.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
1815     mode |= ALL_S_IWRITE;
1816
1817   buf->st_mode  = mode;
1818   buf->st_nlink = 1;
1819   buf->st_size  = ((__int64)hfi.nFileSizeHigh << 32) + hfi.nFileSizeLow;
1820   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastAccessTime, &dw);
1821   buf->st_atime = dw;
1822   RtlTimeToSecondsSince1970((LARGE_INTEGER *)&hfi.ftLastWriteTime, &dw);
1823   buf->st_mtime = buf->st_ctime = dw;
1824   TRACE("%d %d 0x%08lx%08lx %ld %ld %ld\n", buf->st_mode,buf->st_nlink,
1825         (long)(buf->st_size >> 32),(long)buf->st_size,
1826         buf->st_atime,buf->st_mtime, buf->st_ctime);
1827   return 0;
1828 }
1829
1830 /*********************************************************************
1831  *              _wstat (MSVCRT.@)
1832  */
1833 int MSVCRT__wstat(const MSVCRT_wchar_t* path, struct MSVCRT__stat * buf)
1834 {
1835   int ret;
1836   struct MSVCRT__stati64 bufi64;
1837
1838   ret = MSVCRT__wstati64( path, &bufi64 );
1839   if (!ret) msvcrt_cp_from_stati64(&bufi64, buf);
1840   return ret;
1841 }
1842
1843 /*********************************************************************
1844  *              _tell (MSVCRT.@)
1845  */
1846 long _tell(int fd)
1847 {
1848   return _lseek(fd, 0, SEEK_CUR);
1849 }
1850
1851 /*********************************************************************
1852  *              _telli64 (MSVCRT.@)
1853  */
1854 __int64 _telli64(int fd)
1855 {
1856   return _lseeki64(fd, 0, SEEK_CUR);
1857 }
1858
1859 /*********************************************************************
1860  *              _tempnam (MSVCRT.@)
1861  */
1862 char *_tempnam(const char *dir, const char *prefix)
1863 {
1864   char tmpbuf[MAX_PATH];
1865
1866   TRACE("dir (%s) prefix (%s)\n",dir,prefix);
1867   if (GetTempFileNameA(dir,prefix,0,tmpbuf))
1868   {
1869     TRACE("got name (%s)\n",tmpbuf);
1870     DeleteFileA(tmpbuf);
1871     return _strdup(tmpbuf);
1872   }
1873   TRACE("failed (%ld)\n",GetLastError());
1874   return NULL;
1875 }
1876
1877 /*********************************************************************
1878  *              _wtempnam (MSVCRT.@)
1879  */
1880 MSVCRT_wchar_t *_wtempnam(const MSVCRT_wchar_t *dir, const MSVCRT_wchar_t *prefix)
1881 {
1882   MSVCRT_wchar_t tmpbuf[MAX_PATH];
1883
1884   TRACE("dir (%s) prefix (%s)\n",debugstr_w(dir),debugstr_w(prefix));
1885   if (GetTempFileNameW(dir,prefix,0,tmpbuf))
1886   {
1887     TRACE("got name (%s)\n",debugstr_w(tmpbuf));
1888     DeleteFileW(tmpbuf);
1889     return _wcsdup(tmpbuf);
1890   }
1891   TRACE("failed (%ld)\n",GetLastError());
1892   return NULL;
1893 }
1894
1895 /*********************************************************************
1896  *              _umask (MSVCRT.@)
1897  */
1898 int _umask(int umask)
1899 {
1900   int old_umask = MSVCRT_umask;
1901   TRACE("(%d)\n",umask);
1902   MSVCRT_umask = umask;
1903   return old_umask;
1904 }
1905
1906 /*********************************************************************
1907  *              _utime (MSVCRT.@)
1908  */
1909 int _utime(const char* path, struct MSVCRT__utimbuf *t)
1910 {
1911   int fd = _open(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
1912
1913   if (fd > 0)
1914   {
1915     int retVal = _futime(fd, t);
1916     _close(fd);
1917     return retVal;
1918   }
1919   return -1;
1920 }
1921
1922 /*********************************************************************
1923  *              _wutime (MSVCRT.@)
1924  */
1925 int _wutime(const MSVCRT_wchar_t* path, struct MSVCRT__utimbuf *t)
1926 {
1927   int fd = _wopen(path, MSVCRT__O_WRONLY | MSVCRT__O_BINARY);
1928
1929   if (fd > 0)
1930   {
1931     int retVal = _futime(fd, t);
1932     _close(fd);
1933     return retVal;
1934   }
1935   return -1;
1936 }
1937
1938 /*********************************************************************
1939  *              _write (MSVCRT.@)
1940  */
1941 int _write(int fd, const void* buf, unsigned int count)
1942 {
1943   DWORD num_written;
1944   HANDLE hand = msvcrt_fdtoh(fd);
1945
1946   /* Don't trace small writes, it gets *very* annoying */
1947 #if 0
1948   if (count > 32)
1949     TRACE(":fd (%d) handle (%d) buf (%p) len (%d)\n",fd,hand,buf,count);
1950 #endif
1951   if (hand == INVALID_HANDLE_VALUE)
1952     {
1953       *MSVCRT__errno() = MSVCRT_EBADF;
1954       return -1;
1955     }
1956
1957   /* If appending, go to EOF */
1958   if (MSVCRT_fdesc[fd].wxflag & WX_APPEND)
1959     _lseek(fd, 0, FILE_END);
1960
1961   if (!(MSVCRT_fdesc[fd].wxflag & WX_TEXT))
1962     {
1963       if (WriteFile(hand, buf, count, &num_written, NULL)
1964           &&  (num_written == count))
1965         return num_written;
1966       TRACE("WriteFile (fd %d, hand %p) failed-last error (%ld)\n", fd,
1967        hand, GetLastError());
1968       *MSVCRT__errno() = MSVCRT_ENOSPC;
1969     }
1970   else
1971   {
1972       unsigned int i, j, nr_lf;
1973       char *s =(char*)buf, *buf_start=(char*)buf, *p;
1974       /* find number of \n ( without preceeding \r */
1975       for ( nr_lf=0,i = 0; i <count; i++)
1976       {
1977           if (s[i]== '\n')
1978           {
1979               nr_lf++;
1980               /*if ((i >1) && (s[i-1] == '\r')) nr_lf--; */
1981           }
1982       }
1983       if (nr_lf)
1984       {
1985           if ((p = MSVCRT_malloc(count + nr_lf)))
1986           {
1987               for(s=(char*)buf, i=0, j=0; i<count; i++)
1988               {
1989                   if (s[i]== '\n')
1990                   {
1991                       p[j++] = '\r';
1992                       /*if ((i >1) && (s[i-1] == '\r'))j--;*/
1993                   }
1994                   p[j++] = s[i];
1995               }
1996           }
1997           else
1998           {
1999               FIXME("Malloc failed\n");
2000               nr_lf =0;
2001               p = (char*)buf;
2002           }
2003       }
2004       else
2005           p = (char*)buf;
2006
2007       if ((WriteFile(hand, p, count+nr_lf, &num_written, NULL) == 0 ) || (num_written != count+nr_lf))
2008       {
2009           TRACE("WriteFile (fd %d, hand %p) failed-last error (%ld), num_written %ld\n",
2010            fd, hand, GetLastError(), num_written);
2011           *MSVCRT__errno() = MSVCRT_ENOSPC;
2012           if(nr_lf)
2013               MSVCRT_free(p);
2014           return s - buf_start;
2015       }
2016       else
2017       {
2018           if(nr_lf)
2019               MSVCRT_free(p);
2020           return count;
2021       }
2022   }
2023   return -1;
2024 }
2025
2026 /*********************************************************************
2027  *              _putw (MSVCRT.@)
2028  */
2029 int MSVCRT__putw(int val, MSVCRT_FILE* file)
2030 {
2031   int len;
2032   len = _write(file->_file, &val, sizeof(val));
2033   if (len == sizeof(val)) return val;
2034   file->_flag |= MSVCRT__IOERR;
2035   return MSVCRT_EOF;
2036 }
2037
2038 /*********************************************************************
2039  *              fclose (MSVCRT.@)
2040  */
2041 int MSVCRT_fclose(MSVCRT_FILE* file)
2042 {
2043   int r, flag;
2044
2045   flag = file->_flag;
2046   if (file->_tmpfname)
2047   {
2048     MSVCRT_free(file->_tmpfname);
2049     file->_tmpfname = NULL;
2050   }
2051   /* flush stdio buffers */
2052   if(file->_flag & MSVCRT__IOWRT)
2053       MSVCRT_fflush(file);
2054   if(file->_flag & MSVCRT__IOMYBUF)
2055       MSVCRT_free(file->_base);
2056
2057   r=_close(file->_file);
2058
2059   file->_flag = 0;
2060
2061   return ((r==MSVCRT_EOF) || (flag & MSVCRT__IOERR) ? MSVCRT_EOF : 0);
2062 }
2063
2064 /*********************************************************************
2065  *              feof (MSVCRT.@)
2066  */
2067 int MSVCRT_feof(MSVCRT_FILE* file)
2068 {
2069   return file->_flag & MSVCRT__IOEOF;
2070 }
2071
2072 /*********************************************************************
2073  *              ferror (MSVCRT.@)
2074  */
2075 int MSVCRT_ferror(MSVCRT_FILE* file)
2076 {
2077   return file->_flag & MSVCRT__IOERR;
2078 }
2079
2080 /*********************************************************************
2081  *              _filbuf (MSVCRT.@)
2082  */
2083 int MSVCRT__filbuf(MSVCRT_FILE* file)
2084 {
2085   /* Allocate buffer if needed */
2086   if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF) ) {
2087         msvcrt_alloc_buffer(file);
2088   }
2089   if(!(file->_flag & MSVCRT__IOREAD)) {
2090         if(file->_flag & MSVCRT__IORW) {
2091                 file->_flag |= MSVCRT__IOREAD;
2092         } else {
2093                 return MSVCRT_EOF;
2094         }
2095   }
2096   if(file->_flag & MSVCRT__IONBF) {
2097         unsigned char c;
2098         int r;
2099         if ((r = _read(file->_file,&c,1)) != 1) {
2100             file->_flag |= (r == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
2101             return MSVCRT_EOF;
2102         }
2103         return c;
2104   } else {
2105         file->_cnt = _read(file->_file, file->_base, file->_bufsiz);
2106         if(file->_cnt<=0) {
2107             file->_flag |= (file->_cnt == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
2108             file->_cnt = 0;
2109             return MSVCRT_EOF;
2110         }
2111         file->_cnt--;
2112         file->_ptr = file->_base+1;
2113         return *(unsigned char *)file->_base;
2114   }
2115 }
2116
2117 /*********************************************************************
2118  *              fgetc (MSVCRT.@)
2119  */
2120 int MSVCRT_fgetc(MSVCRT_FILE* file)
2121 {
2122   if (file->_cnt>0) {
2123         file->_cnt--;
2124         return *(unsigned char *)file->_ptr++;
2125   } else {
2126         return MSVCRT__filbuf(file);
2127   }
2128 }
2129
2130 /*********************************************************************
2131  *              _fgetchar (MSVCRT.@)
2132  */
2133 int _fgetchar(void)
2134 {
2135   return MSVCRT_fgetc(MSVCRT_stdin);
2136 }
2137
2138 /*********************************************************************
2139  *              fgets (MSVCRT.@)
2140  */
2141 char *MSVCRT_fgets(char *s, int size, MSVCRT_FILE* file)
2142 {
2143   int    cc = MSVCRT_EOF;
2144   char * buf_start = s;
2145
2146   TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
2147         file,file->_file,s,size);
2148
2149   while ((size >1) && (cc = MSVCRT_fgetc(file)) != MSVCRT_EOF && cc != '\n')
2150     {
2151       *s++ = (char)cc;
2152       size --;
2153     }
2154   if ((cc == MSVCRT_EOF) && (s == buf_start)) /* If nothing read, return 0*/
2155   {
2156     TRACE(":nothing read\n");
2157     return NULL;
2158   }
2159   if ((cc != MSVCRT_EOF) && (size > 1))
2160     *s++ = cc;
2161   *s = '\0';
2162   TRACE(":got '%s'\n", debugstr_a(buf_start));
2163   return buf_start;
2164 }
2165
2166 /*********************************************************************
2167  *              fgetwc (MSVCRT.@)
2168  *
2169  * In MSVCRT__O_TEXT mode, multibyte characters are read from the file, dropping
2170  * the CR from CR/LF combinations
2171  */
2172 MSVCRT_wint_t MSVCRT_fgetwc(MSVCRT_FILE* file)
2173 {
2174   char c;
2175
2176   if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
2177     {
2178       MSVCRT_wchar_t wc;
2179       int r;
2180       if ((r = _read(file->_file, &wc, sizeof(wc))) != sizeof(wc))
2181       {
2182           file->_flag |= (r == 0) ? MSVCRT__IOEOF : MSVCRT__IOERR;
2183           return MSVCRT_WEOF;
2184       }
2185       return wc;
2186     }
2187   c = MSVCRT_fgetc(file);
2188   if ((*__p___mb_cur_max() > 1) && MSVCRT_isleadbyte(c))
2189     {
2190       FIXME("Treat Multibyte characters\n");
2191     }
2192   if (c == MSVCRT_EOF)
2193     return MSVCRT_WEOF;
2194   else
2195     return (MSVCRT_wint_t)c;
2196 }
2197
2198 /*********************************************************************
2199  *              getwc (MSVCRT.@)
2200  */
2201 MSVCRT_wint_t MSVCRT_getwc(MSVCRT_FILE* file)
2202 {
2203   return MSVCRT_fgetwc(file);
2204 }
2205
2206 /*********************************************************************
2207  *              _fgetwchar (MSVCRT.@)
2208  */
2209 MSVCRT_wint_t _fgetwchar(void)
2210 {
2211   return MSVCRT_fgetwc(MSVCRT_stdin);
2212 }
2213
2214 /*********************************************************************
2215  *              getwchar (MSVCRT.@)
2216  */
2217 MSVCRT_wint_t MSVCRT_getwchar(void)
2218 {
2219   return _fgetwchar();
2220 }
2221
2222 /*********************************************************************
2223  *              fgetws (MSVCRT.@)
2224  */
2225 MSVCRT_wchar_t *MSVCRT_fgetws(MSVCRT_wchar_t *s, int size, MSVCRT_FILE* file)
2226 {
2227   int    cc = MSVCRT_WEOF;
2228   MSVCRT_wchar_t * buf_start = s;
2229
2230   TRACE(":file(%p) fd (%d) str (%p) len (%d)\n",
2231         file,file->_file,s,size);
2232
2233   while ((size >1) && (cc = MSVCRT_fgetwc(file)) != MSVCRT_WEOF && cc != '\n')
2234     {
2235       *s++ = (char)cc;
2236       size --;
2237     }
2238   if ((cc == MSVCRT_WEOF) && (s == buf_start)) /* If nothing read, return 0*/
2239   {
2240     TRACE(":nothing read\n");
2241     return NULL;
2242   }
2243   if ((cc != MSVCRT_WEOF) && (size > 1))
2244     *s++ = cc;
2245   *s = 0;
2246   TRACE(":got %s\n", debugstr_w(buf_start));
2247   return buf_start;
2248 }
2249
2250 /*********************************************************************
2251  *              fwrite (MSVCRT.@)
2252  */
2253 MSVCRT_size_t MSVCRT_fwrite(const void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
2254 {
2255   MSVCRT_size_t wrcnt=size * nmemb;
2256   int written = 0;
2257   if (size == 0)
2258       return 0;
2259   if(file->_cnt) {
2260         int pcnt=(file->_cnt>wrcnt)? wrcnt: file->_cnt;
2261         memcpy(file->_ptr, ptr, pcnt);
2262         file->_cnt -= pcnt;
2263         file->_ptr += pcnt;
2264         written = pcnt;
2265         wrcnt -= pcnt;
2266         ptr = (const char*)ptr + pcnt;
2267   } else if(!(file->_flag & MSVCRT__IOWRT)) {
2268         if(file->_flag & MSVCRT__IORW) {
2269                 file->_flag |= MSVCRT__IOWRT;
2270         } else
2271                 return 0;
2272   }
2273   if(wrcnt) {
2274         /* Flush buffer */
2275         int res=msvcrt_flush_buffer(file);
2276         if(!res) {
2277                 int pwritten = _write(file->_file, ptr, wrcnt);
2278                 if (pwritten <= 0)
2279                 {
2280                     file->_flag |= MSVCRT__IOERR;
2281                     pwritten=0;
2282                 }
2283                 written += pwritten;
2284         }
2285   }
2286   return written / size;
2287 }
2288
2289 /*********************************************************************
2290  *              fputwc (MSVCRT.@)
2291  */
2292 MSVCRT_wint_t MSVCRT_fputwc(MSVCRT_wint_t wc, MSVCRT_FILE* file)
2293 {
2294   MSVCRT_wchar_t mwc=wc;
2295   if (MSVCRT_fwrite( &mwc, sizeof(mwc), 1, file) != 1)
2296     return MSVCRT_WEOF;
2297   return wc;
2298 }
2299
2300 /*********************************************************************
2301  *              _fputwchar (MSVCRT.@)
2302  */
2303 MSVCRT_wint_t _fputwchar(MSVCRT_wint_t wc)
2304 {
2305   return MSVCRT_fputwc(wc, MSVCRT_stdout);
2306 }
2307
2308 /*********************************************************************
2309  *              fopen (MSVCRT.@)
2310  */
2311 MSVCRT_FILE* MSVCRT_fopen(const char *path, const char *mode)
2312 {
2313   MSVCRT_FILE* file;
2314   int open_flags, stream_flags, fd;
2315
2316   TRACE("(%s,%s)\n",path,mode);
2317
2318   /* map mode string to open() flags. "man fopen" for possibilities. */
2319   if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
2320       return NULL;
2321
2322   LOCK_FILES();
2323   fd = _open(path, open_flags, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
2324   if (fd < 0)
2325     file = NULL;
2326   else if ((file = msvcrt_alloc_fp()) && msvcrt_init_fp(file, fd, stream_flags)
2327    != -1)
2328     TRACE(":fd (%d) mode (%s) FILE* (%p)\n",fd,mode,file);
2329   else if (file)
2330   {
2331     file->_flag = 0;
2332     file = NULL;
2333   }
2334
2335   TRACE(":got (%p)\n",file);
2336   if (!file)
2337     _close(fd);
2338   UNLOCK_FILES();
2339   return file;
2340 }
2341
2342 /*********************************************************************
2343  *              _wfopen (MSVCRT.@)
2344  */
2345 MSVCRT_FILE *MSVCRT__wfopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode)
2346 {
2347   const unsigned int plen = strlenW(path), mlen = strlenW(mode);
2348   char *patha = MSVCRT_calloc(plen + 1, 1);
2349   char *modea = MSVCRT_calloc(mlen + 1, 1);
2350
2351   TRACE("(%s,%s)\n",debugstr_w(path),debugstr_w(mode));
2352
2353   if (patha && modea &&
2354       WideCharToMultiByte(CP_ACP,0,path,plen,patha,plen,NULL,NULL) &&
2355       WideCharToMultiByte(CP_ACP,0,mode,mlen,modea,mlen,NULL,NULL))
2356   {
2357     MSVCRT_FILE *retval = MSVCRT_fopen(patha,modea);
2358     MSVCRT_free(patha);
2359     MSVCRT_free(modea);
2360     return retval;
2361   }
2362
2363   msvcrt_set_errno(GetLastError());
2364   return NULL;
2365 }
2366
2367 /*********************************************************************
2368  *              _fsopen (MSVCRT.@)
2369  */
2370 MSVCRT_FILE*  MSVCRT__fsopen(const char *path, const char *mode, int share)
2371 {
2372   FIXME(":(%s,%s,%d),ignoring share mode!\n",path,mode,share);
2373   return MSVCRT_fopen(path,mode);
2374 }
2375
2376 /*********************************************************************
2377  *              _wfsopen (MSVCRT.@)
2378  */
2379 MSVCRT_FILE*  MSVCRT__wfsopen(const MSVCRT_wchar_t *path, const MSVCRT_wchar_t *mode, int share)
2380 {
2381   FIXME(":(%s,%s,%d),ignoring share mode!\n",
2382         debugstr_w(path),debugstr_w(mode),share);
2383   return MSVCRT__wfopen(path,mode);
2384 }
2385
2386 /* MSVCRT_fputc calls MSVCRT__flsbuf which calls MSVCRT_fputc */
2387 int MSVCRT__flsbuf(int c, MSVCRT_FILE* file);
2388
2389 /*********************************************************************
2390  *              fputc (MSVCRT.@)
2391  */
2392 int MSVCRT_fputc(int c, MSVCRT_FILE* file)
2393 {
2394   if(file->_cnt>0) {
2395     *file->_ptr++=c;
2396     file->_cnt--;
2397     if (c == '\n')
2398     {
2399       int res = msvcrt_flush_buffer(file);
2400       return res ? res : c;
2401     }
2402     else
2403       return c;
2404   } else {
2405     return MSVCRT__flsbuf(c, file);
2406   }
2407 }
2408
2409 /*********************************************************************
2410  *              _flsbuf (MSVCRT.@)
2411  */
2412 int MSVCRT__flsbuf(int c, MSVCRT_FILE* file)
2413 {
2414   /* Flush output buffer */
2415   if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
2416         msvcrt_alloc_buffer(file);
2417   }
2418   if(!(file->_flag & MSVCRT__IOWRT)) {
2419         if(file->_flag & MSVCRT__IORW) {
2420                 file->_flag |= MSVCRT__IOWRT;
2421         } else {
2422                 return MSVCRT_EOF;
2423         }
2424   }
2425   if(file->_bufsiz) {
2426         int res=msvcrt_flush_buffer(file);
2427         return res?res : MSVCRT_fputc(c, file);
2428   } else {
2429         unsigned char cc=c;
2430         int len;
2431         len = _write(file->_file, &cc, 1);
2432         if (len == 1) return c;
2433         file->_flag |= MSVCRT__IOERR;
2434         return MSVCRT_EOF;
2435   }
2436 }
2437
2438 /*********************************************************************
2439  *              _fputchar (MSVCRT.@)
2440  */
2441 int _fputchar(int c)
2442 {
2443   return MSVCRT_fputc(c, MSVCRT_stdout);
2444 }
2445
2446 /*********************************************************************
2447  *              fread (MSVCRT.@)
2448  */
2449 MSVCRT_size_t MSVCRT_fread(void *ptr, MSVCRT_size_t size, MSVCRT_size_t nmemb, MSVCRT_FILE* file)
2450 { MSVCRT_size_t rcnt=size * nmemb;
2451   MSVCRT_size_t read=0;
2452   int pread=0;
2453
2454   /* first buffered data */
2455   if(file->_cnt>0) {
2456         int pcnt= (rcnt>file->_cnt)? file->_cnt:rcnt;
2457         memcpy(ptr, file->_ptr, pcnt);
2458         file->_cnt -= pcnt;
2459         file->_ptr += pcnt;
2460         read += pcnt ;
2461         rcnt -= pcnt ;
2462         ptr = (char*)ptr + pcnt;
2463   } else if(!(file->_flag & MSVCRT__IOREAD )) {
2464         if(file->_flag & MSVCRT__IORW) {
2465                 file->_flag |= MSVCRT__IOREAD;
2466         } else
2467             return 0;
2468   }
2469   if(rcnt)
2470   {
2471     pread = _read(file->_file,ptr, rcnt);
2472     /* expose feof condition in the flags
2473      * MFC tests file->_flag for feof, and doesn't not call feof())
2474      */
2475     if (pread == 0)
2476         file->_flag |= MSVCRT__IOEOF;
2477     else if (pread == -1)
2478     {
2479         file->_flag |= MSVCRT__IOERR;
2480         pread = 0;
2481     }
2482   }
2483   read+=pread;
2484   return read / size;
2485 }
2486
2487 /*********************************************************************
2488  *              freopen (MSVCRT.@)
2489  *
2490  */
2491 MSVCRT_FILE* MSVCRT_freopen(const char *path, const char *mode,MSVCRT_FILE* file)
2492 {
2493   int open_flags, stream_flags, fd;
2494
2495   TRACE(":path (%p) mode (%s) file (%p) fd (%d)\n",path,mode,file,file->_file);
2496
2497   LOCK_FILES();
2498   if (!file || ((fd = file->_file) < 0) || fd > MSVCRT_fdend)
2499     file = NULL;
2500   else
2501   {
2502     MSVCRT_fclose(file);
2503     /* map mode string to open() flags. "man fopen" for possibilities. */
2504     if (msvcrt_get_flags(mode, &open_flags, &stream_flags) == -1)
2505       file = NULL;
2506     else
2507     {
2508       fd = _open(path, open_flags, MSVCRT__S_IREAD | MSVCRT__S_IWRITE);
2509       if (fd < 0)
2510         file = NULL;
2511       else if (msvcrt_init_fp(file, fd, stream_flags) == -1)
2512       {
2513           file->_flag = 0;
2514           WARN(":failed-last error (%ld)\n",GetLastError());
2515           msvcrt_set_errno(GetLastError());
2516           file = NULL;
2517       }
2518     }
2519   }
2520   UNLOCK_FILES();
2521   return file;
2522 }
2523
2524 /*********************************************************************
2525  *              fsetpos (MSVCRT.@)
2526  */
2527 int MSVCRT_fsetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
2528 {
2529   /* Note that all this has been lifted 'as is' from fseek */
2530   if(file->_flag & MSVCRT__IOWRT)
2531         msvcrt_flush_buffer(file);
2532
2533   /* Discard buffered input */
2534   file->_cnt = 0;
2535   file->_ptr = file->_base;
2536
2537   /* Reset direction of i/o */
2538   if(file->_flag & MSVCRT__IORW) {
2539         file->_flag &= ~(MSVCRT__IOREAD|MSVCRT__IOWRT);
2540   }
2541
2542   return _lseeki64(file->_file,*pos,SEEK_SET);
2543 }
2544
2545 /*********************************************************************
2546  *              ftell (MSVCRT.@)
2547  */
2548 LONG MSVCRT_ftell(MSVCRT_FILE* file)
2549 {
2550   int off=0;
2551   long pos;
2552   if(file->_bufsiz)  {
2553         if( file->_flag & MSVCRT__IOWRT ) {
2554                 off = file->_ptr - file->_base;
2555         } else {
2556                 off = -file->_cnt;
2557         }
2558   }
2559   pos = _tell(file->_file);
2560   if(pos == -1) return pos;
2561   return off + pos;
2562 }
2563
2564 /*********************************************************************
2565  *              fgetpos (MSVCRT.@)
2566  */
2567 int MSVCRT_fgetpos(MSVCRT_FILE* file, MSVCRT_fpos_t *pos)
2568 {
2569   /* This code has been lifted form the MSVCRT_ftell function */
2570   int off=0;
2571
2572   *pos = _lseeki64(file->_file,0,SEEK_CUR);
2573
2574   if (*pos == -1) return -1;
2575
2576   if(file->_bufsiz)  {
2577         if( file->_flag & MSVCRT__IOWRT ) {
2578                 off = file->_ptr - file->_base;
2579         } else {
2580                 off = -file->_cnt;
2581         }
2582   }
2583   *pos += off;
2584
2585   return 0;
2586 }
2587
2588 /*********************************************************************
2589  *              fputs (MSVCRT.@)
2590  */
2591 int MSVCRT_fputs(const char *s, MSVCRT_FILE* file)
2592 {
2593     size_t i, len = strlen(s);
2594     if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
2595       return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
2596     for (i=0; i<len; i++)
2597       if (MSVCRT_fputc(s[i], file) == MSVCRT_EOF)
2598         return MSVCRT_EOF;
2599     return 0;
2600 }
2601
2602 /*********************************************************************
2603  *              fputws (MSVCRT.@)
2604  */
2605 int MSVCRT_fputws(const MSVCRT_wchar_t *s, MSVCRT_FILE* file)
2606 {
2607     size_t i, len = strlenW(s);
2608     if (!(MSVCRT_fdesc[file->_file].wxflag & WX_TEXT))
2609       return MSVCRT_fwrite(s,sizeof(*s),len,file) == len ? 0 : MSVCRT_EOF;
2610     for (i=0; i<len; i++)
2611       {
2612         if ((s[i] == L'\n') && (MSVCRT_fputc('\r', file) == MSVCRT_EOF))
2613           return MSVCRT_WEOF;
2614         if (MSVCRT_fputwc(s[i], file) == MSVCRT_WEOF)
2615           return MSVCRT_WEOF;
2616       }
2617     return 0;
2618 }
2619
2620 /*********************************************************************
2621  *              getchar (MSVCRT.@)
2622  */
2623 int MSVCRT_getchar(void)
2624 {
2625   return MSVCRT_fgetc(MSVCRT_stdin);
2626 }
2627
2628 /*********************************************************************
2629  *              getc (MSVCRT.@)
2630  */
2631 int MSVCRT_getc(MSVCRT_FILE* file)
2632 {
2633   return MSVCRT_fgetc(file);
2634 }
2635
2636 /*********************************************************************
2637  *              gets (MSVCRT.@)
2638  */
2639 char *MSVCRT_gets(char *buf)
2640 {
2641   int    cc;
2642   char * buf_start = buf;
2643
2644   for(cc = MSVCRT_fgetc(MSVCRT_stdin); cc != MSVCRT_EOF && cc != '\n';
2645       cc = MSVCRT_fgetc(MSVCRT_stdin))
2646   if(cc != '\r') *buf++ = (char)cc;
2647
2648   *buf = '\0';
2649
2650   TRACE("got '%s'\n", buf_start);
2651   return buf_start;
2652 }
2653
2654 /*********************************************************************
2655  *              _getws (MSVCRT.@)
2656  */
2657 MSVCRT_wchar_t* MSVCRT__getws(MSVCRT_wchar_t* buf)
2658 {
2659     MSVCRT_wint_t cc;
2660     MSVCRT_wchar_t* ws = buf;
2661
2662     for (cc = MSVCRT_fgetwc(MSVCRT_stdin); cc != MSVCRT_WEOF && cc != '\n';
2663          cc = MSVCRT_fgetwc(MSVCRT_stdin))
2664     {
2665         if (cc != '\r')
2666             *buf++ = (MSVCRT_wchar_t)cc;
2667     }
2668     *buf = '\0';
2669
2670     TRACE("got '%s'\n", debugstr_w(ws));
2671     return ws;
2672 }
2673
2674 /*********************************************************************
2675  *              putc (MSVCRT.@)
2676  */
2677 int MSVCRT_putc(int c, MSVCRT_FILE* file)
2678 {
2679   return MSVCRT_fputc(c, file);
2680 }
2681
2682 /*********************************************************************
2683  *              putchar (MSVCRT.@)
2684  */
2685 int MSVCRT_putchar(int c)
2686 {
2687   return MSVCRT_fputc(c, MSVCRT_stdout);
2688 }
2689
2690 /*********************************************************************
2691  *              puts (MSVCRT.@)
2692  */
2693 int MSVCRT_puts(const char *s)
2694 {
2695     size_t len = strlen(s);
2696     if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
2697     return MSVCRT_fwrite("\n",1,1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
2698 }
2699
2700 /*********************************************************************
2701  *              _putws (MSVCRT.@)
2702  */
2703 int _putws(const MSVCRT_wchar_t *s)
2704 {
2705     static const MSVCRT_wchar_t nl = '\n';
2706     size_t len = strlenW(s);
2707     if (MSVCRT_fwrite(s,sizeof(*s),len,MSVCRT_stdout) != len) return MSVCRT_EOF;
2708     return MSVCRT_fwrite(&nl,sizeof(nl),1,MSVCRT_stdout) == 1 ? 0 : MSVCRT_EOF;
2709 }
2710
2711 /*********************************************************************
2712  *              remove (MSVCRT.@)
2713  */
2714 int MSVCRT_remove(const char *path)
2715 {
2716   TRACE("(%s)\n",path);
2717   if (DeleteFileA(path))
2718     return 0;
2719   TRACE(":failed (%ld)\n",GetLastError());
2720   msvcrt_set_errno(GetLastError());
2721   return -1;
2722 }
2723
2724 /*********************************************************************
2725  *              _wremove (MSVCRT.@)
2726  */
2727 int _wremove(const MSVCRT_wchar_t *path)
2728 {
2729   TRACE("(%s)\n",debugstr_w(path));
2730   if (DeleteFileW(path))
2731     return 0;
2732   TRACE(":failed (%ld)\n",GetLastError());
2733   msvcrt_set_errno(GetLastError());
2734   return -1;
2735 }
2736
2737 /*********************************************************************
2738  *              rename (MSVCRT.@)
2739  */
2740 int MSVCRT_rename(const char *oldpath,const char *newpath)
2741 {
2742   TRACE(":from %s to %s\n",oldpath,newpath);
2743   if (MoveFileExA(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
2744     return 0;
2745   TRACE(":failed (%ld)\n",GetLastError());
2746   msvcrt_set_errno(GetLastError());
2747   return -1;
2748 }
2749
2750 /*********************************************************************
2751  *              _wrename (MSVCRT.@)
2752  */
2753 int _wrename(const MSVCRT_wchar_t *oldpath,const MSVCRT_wchar_t *newpath)
2754 {
2755   TRACE(":from %s to %s\n",debugstr_w(oldpath),debugstr_w(newpath));
2756   if (MoveFileExW(oldpath, newpath, MOVEFILE_COPY_ALLOWED))
2757     return 0;
2758   TRACE(":failed (%ld)\n",GetLastError());
2759   msvcrt_set_errno(GetLastError());
2760   return -1;
2761 }
2762
2763 /*********************************************************************
2764  *              setvbuf (MSVCRT.@)
2765  */
2766 int MSVCRT_setvbuf(MSVCRT_FILE* file, char *buf, int mode, MSVCRT_size_t size)
2767 {
2768   /* TODO: Check if file busy */
2769   if(file->_bufsiz) {
2770         MSVCRT_free(file->_base);
2771         file->_bufsiz = 0;
2772         file->_cnt = 0;
2773   }
2774   if(mode == MSVCRT__IOFBF) {
2775         file->_flag &= ~MSVCRT__IONBF;
2776         file->_base = file->_ptr = buf;
2777         if(buf) {
2778                 file->_bufsiz = size;
2779         }
2780   } else {
2781         file->_flag |= MSVCRT__IONBF;
2782   }
2783   return 0;
2784 }
2785
2786 /*********************************************************************
2787  *              setbuf (MSVCRT.@)
2788  */
2789 void MSVCRT_setbuf(MSVCRT_FILE* file, char *buf)
2790 {
2791   MSVCRT_setvbuf(file, buf, buf ? MSVCRT__IOFBF : MSVCRT__IONBF, MSVCRT_BUFSIZ);
2792 }
2793
2794 /*********************************************************************
2795  *              tmpnam (MSVCRT.@)
2796  */
2797 char *MSVCRT_tmpnam(char *s)
2798 {
2799   static int unique;
2800   char tmpstr[16];
2801   char *p;
2802   int count;
2803   if (s == 0)
2804     s = MSVCRT_tmpname;
2805   msvcrt_int_to_base32(GetCurrentProcessId(), tmpstr);
2806   p = s + sprintf(s, "\\s%s.", tmpstr);
2807   for (count = 0; count < MSVCRT_TMP_MAX; count++)
2808   {
2809     msvcrt_int_to_base32(unique++, tmpstr);
2810     strcpy(p, tmpstr);
2811     if (GetFileAttributesA(s) == INVALID_FILE_ATTRIBUTES &&
2812         GetLastError() == ERROR_FILE_NOT_FOUND)
2813       break;
2814   }
2815   return s;
2816 }
2817
2818 /*********************************************************************
2819  *              tmpfile (MSVCRT.@)
2820  */
2821 MSVCRT_FILE* MSVCRT_tmpfile(void)
2822 {
2823   char *filename = MSVCRT_tmpnam(NULL);
2824   int fd;
2825   MSVCRT_FILE* file = NULL;
2826
2827   LOCK_FILES();
2828   fd = _open(filename, MSVCRT__O_CREAT | MSVCRT__O_BINARY | MSVCRT__O_RDWR | MSVCRT__O_TEMPORARY);
2829   if (fd != -1 && (file = msvcrt_alloc_fp()))
2830   {
2831     if (msvcrt_init_fp(file, fd, MSVCRT__O_RDWR) == -1)
2832     {
2833         file->_flag = 0;
2834         file = NULL;
2835     }
2836     else file->_tmpfname = _strdup(filename);
2837   }
2838   UNLOCK_FILES();
2839   return file;
2840 }
2841
2842 /*********************************************************************
2843  *              vfprintf (MSVCRT.@)
2844  */
2845 int MSVCRT_vfprintf(MSVCRT_FILE* file, const char *format, va_list valist)
2846 {
2847   char buf[2048], *mem = buf;
2848   int written, resize = sizeof(buf), retval;
2849   /* There are two conventions for vsnprintf failing:
2850    * Return -1 if we truncated, or
2851    * Return the number of bytes that would have been written
2852    * The code below handles both cases
2853    */
2854   while ((written = vsnprintf(mem, resize, format, valist)) == -1 ||
2855           written > resize)
2856   {
2857     resize = (written == -1 ? resize * 2 : written + 1);
2858     if (mem != buf)
2859       MSVCRT_free (mem);
2860     if (!(mem = (char *)MSVCRT_malloc(resize)))
2861       return MSVCRT_EOF;
2862   }
2863   retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
2864   if (mem != buf)
2865     MSVCRT_free (mem);
2866   return retval;
2867 }
2868
2869 /*********************************************************************
2870  *              vfwprintf (MSVCRT.@)
2871  * FIXME:
2872  * Is final char included in written (then resize is too big) or not
2873  * (then we must test for equality too)?
2874  */
2875 int MSVCRT_vfwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, va_list valist)
2876 {
2877   MSVCRT_wchar_t buf[2048], *mem = buf;
2878   int written, resize = sizeof(buf) / sizeof(MSVCRT_wchar_t), retval;
2879   /* See vfprintf comments */
2880   while ((written = _vsnwprintf(mem, resize, format, valist)) == -1 ||
2881           written > resize)
2882   {
2883     resize = (written == -1 ? resize * 2 : written + sizeof(MSVCRT_wchar_t));
2884     if (mem != buf)
2885       MSVCRT_free (mem);
2886     if (!(mem = (MSVCRT_wchar_t *)MSVCRT_malloc(resize*sizeof(*mem))))
2887       return MSVCRT_EOF;
2888   }
2889   retval = MSVCRT_fwrite(mem, sizeof(*mem), written, file);
2890   if (mem != buf)
2891     MSVCRT_free (mem);
2892   return retval;
2893 }
2894
2895 /*********************************************************************
2896  *              vprintf (MSVCRT.@)
2897  */
2898 int MSVCRT_vprintf(const char *format, va_list valist)
2899 {
2900   return MSVCRT_vfprintf(MSVCRT_stdout,format,valist);
2901 }
2902
2903 /*********************************************************************
2904  *              vwprintf (MSVCRT.@)
2905  */
2906 int MSVCRT_vwprintf(const MSVCRT_wchar_t *format, va_list valist)
2907 {
2908   return MSVCRT_vfwprintf(MSVCRT_stdout,format,valist);
2909 }
2910
2911 /*********************************************************************
2912  *              fprintf (MSVCRT.@)
2913  */
2914 int MSVCRT_fprintf(MSVCRT_FILE* file, const char *format, ...)
2915 {
2916     va_list valist;
2917     int res;
2918     va_start(valist, format);
2919     res = MSVCRT_vfprintf(file, format, valist);
2920     va_end(valist);
2921     return res;
2922 }
2923
2924 /*********************************************************************
2925  *              fwprintf (MSVCRT.@)
2926  */
2927 int MSVCRT_fwprintf(MSVCRT_FILE* file, const MSVCRT_wchar_t *format, ...)
2928 {
2929     va_list valist;
2930     int res;
2931     va_start(valist, format);
2932     res = MSVCRT_vfwprintf(file, format, valist);
2933     va_end(valist);
2934     return res;
2935 }
2936
2937 /*********************************************************************
2938  *              printf (MSVCRT.@)
2939  */
2940 int MSVCRT_printf(const char *format, ...)
2941 {
2942     va_list valist;
2943     int res;
2944     va_start(valist, format);
2945     res = MSVCRT_vfprintf(MSVCRT_stdout, format, valist);
2946     va_end(valist);
2947     return res;
2948 }
2949
2950 /*********************************************************************
2951  *              ungetc (MSVCRT.@)
2952  */
2953 int MSVCRT_ungetc(int c, MSVCRT_FILE * file)
2954 {
2955         if(file->_bufsiz == 0 && !(file->_flag & MSVCRT__IONBF)) {
2956                 msvcrt_alloc_buffer(file);
2957                 file->_ptr++;
2958         }
2959         if(file->_ptr>file->_base) {
2960                 file->_ptr--;
2961                 *file->_ptr=c;
2962                 file->_cnt++;
2963                 return c;
2964         }
2965         return MSVCRT_EOF;
2966 }
2967
2968 /*********************************************************************
2969  *              ungetwc (MSVCRT.@)
2970  */
2971 MSVCRT_wint_t MSVCRT_ungetwc(MSVCRT_wint_t wc, MSVCRT_FILE * file)
2972 {
2973         MSVCRT_wchar_t mwc = wc;
2974         char * pp = (char *)&mwc;
2975         int i;
2976         for(i=sizeof(MSVCRT_wchar_t)-1;i>=0;i--) {
2977                 if(pp[i] != MSVCRT_ungetc(pp[i],file))
2978                         return MSVCRT_WEOF;
2979         }
2980         return mwc;
2981 }
2982
2983 /*********************************************************************
2984  *              wprintf (MSVCRT.@)
2985  */
2986 int MSVCRT_wprintf(const MSVCRT_wchar_t *format, ...)
2987 {
2988     va_list valist;
2989     int res;
2990     va_start(valist, format);
2991     res = MSVCRT_vwprintf(format, valist);
2992     va_end(valist);
2993     return res;
2994 }
2995
2996 /*********************************************************************
2997  *              __pioinfo (MSVCRT.@)
2998  * FIXME: see MSVCRT_MAX_FILES define.
2999  */
3000 ioinfo * MSVCRT___pioinfo[] = { /* array of pointers to ioinfo arrays [64] */
3001     &MSVCRT_fdesc[0 * 64], &MSVCRT_fdesc[1 * 64], &MSVCRT_fdesc[2 * 64],
3002     &MSVCRT_fdesc[3 * 64], &MSVCRT_fdesc[4 * 64], &MSVCRT_fdesc[5 * 64],
3003     &MSVCRT_fdesc[6 * 64], &MSVCRT_fdesc[7 * 64], &MSVCRT_fdesc[8 * 64],
3004     &MSVCRT_fdesc[9 * 64], &MSVCRT_fdesc[10 * 64], &MSVCRT_fdesc[11 * 64],
3005     &MSVCRT_fdesc[12 * 64], &MSVCRT_fdesc[13 * 64], &MSVCRT_fdesc[14 * 64],
3006     &MSVCRT_fdesc[15 * 64], &MSVCRT_fdesc[16 * 64], &MSVCRT_fdesc[17 * 64],
3007     &MSVCRT_fdesc[18 * 64], &MSVCRT_fdesc[19 * 64], &MSVCRT_fdesc[20 * 64],
3008     &MSVCRT_fdesc[21 * 64], &MSVCRT_fdesc[22 * 64], &MSVCRT_fdesc[23 * 64],
3009     &MSVCRT_fdesc[24 * 64], &MSVCRT_fdesc[25 * 64], &MSVCRT_fdesc[26 * 64],
3010     &MSVCRT_fdesc[27 * 64], &MSVCRT_fdesc[28 * 64], &MSVCRT_fdesc[29 * 64],
3011     &MSVCRT_fdesc[30 * 64], &MSVCRT_fdesc[31 * 64]
3012 } ;
3013
3014 /*********************************************************************
3015  *              __badioinfo (MSVCRT.@)
3016  */
3017 ioinfo MSVCRT___badioinfo = { INVALID_HANDLE_VALUE, WX_TEXT };