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