git.oblomov.eu Git - wine/blob - files/file.c

   1 /*
   2  * File handling functions
   3  *
   4  * Copyright 1993 John Burton
   5  * Copyright 1996 Alexandre Julliard
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  * TODO:
  22  *    Fix the CopyFileEx methods to implement the "extended" functionality.
  23  *    Right now, they simply call the CopyFile method.
  24  */
  25
  26 #include "config.h"
  27 #include "wine/port.h"
  28
  29 #include <assert.h>
  30 #include <ctype.h>
  31 #include <errno.h>
  32 #include <fcntl.h>
  33 #include <stdlib.h>
  34 #include <stdarg.h>
  35 #include <stdio.h>
  36 #include <string.h>
  37 #ifdef HAVE_SYS_ERRNO_H
  38 #include <sys/errno.h>
  39 #endif
  40 #include <sys/types.h>
  41 #include <sys/stat.h>
  42 #ifdef HAVE_SYS_MMAN_H
  43 #include <sys/mman.h>
  44 #endif
  45 #ifdef HAVE_SYS_TIME_H
  46 # include <sys/time.h>
  47 #endif
  48 #ifdef HAVE_SYS_POLL_H
  49 # include <sys/poll.h>
  50 #endif
  51 #include <time.h>
  52 #ifdef HAVE_UNISTD_H
  53 # include <unistd.h>
  54 #endif
  55 #ifdef HAVE_UTIME_H
  56 # include <utime.h>
  57 #endif
  58 #ifdef HAVE_IO_H
  59 # include <io.h>
  60 #endif
  61
  62 #define NONAMELESSUNION
  63 #define NONAMELESSSTRUCT
  64 #include "winerror.h"
  65 #include "ntstatus.h"
  66 #include "windef.h"
  67 #include "winbase.h"
  68 #include "winreg.h"
  69 #include "winternl.h"
  70 #include "wine/winbase16.h"
  71 #include "wine/server.h"
  72
  73 #include "file.h"
  74 #include "wincon.h"
  75 #include "kernel_private.h"
  76
  77 #include "smb.h"
  78 #include "wine/unicode.h"
  79 #include "wine/debug.h"
  80
  81 WINE_DEFAULT_DEBUG_CHANNEL(file);
  82
  83
  84 /***********************************************************************
  85  *              FILE_ConvertOFMode
  86  *
  87  * Convert OF_* mode into flags for CreateFile.
  88  */
  89 void FILE_ConvertOFMode( INT mode, DWORD *access, DWORD *sharing )
  90 {
  91     switch(mode & 0x03)
  92     {
  93     case OF_READ:      *access = GENERIC_READ; break;
  94     case OF_WRITE:     *access = GENERIC_WRITE; break;
  95     case OF_READWRITE: *access = GENERIC_READ | GENERIC_WRITE; break;
  96     default:           *access = 0; break;
  97     }
  98     switch(mode & 0x70)
  99     {
 100     case OF_SHARE_EXCLUSIVE:  *sharing = 0; break;
 101     case OF_SHARE_DENY_WRITE: *sharing = FILE_SHARE_READ; break;
 102     case OF_SHARE_DENY_READ:  *sharing = FILE_SHARE_WRITE; break;
 103     case OF_SHARE_DENY_NONE:
 104     case OF_SHARE_COMPAT:
 105     default:                  *sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
 106     }
 107 }
 108
 109
 110 /***********************************************************************
 111  *           FILE_SetDosError
 112  *
 113  * Set the DOS error code from errno.
 114  */
 115 void FILE_SetDosError(void)
 116 {
 117     int save_errno = errno; /* errno gets overwritten by printf */
 118
 119     TRACE("errno = %d %s\n", errno, strerror(errno));
 120     switch (save_errno)
 121     {
 122     case EAGAIN:
 123         SetLastError( ERROR_SHARING_VIOLATION );
 124         break;
 125     case EBADF:
 126         SetLastError( ERROR_INVALID_HANDLE );
 127         break;
 128     case ENOSPC:
 129         SetLastError( ERROR_HANDLE_DISK_FULL );
 130         break;
 131     case EACCES:
 132     case EPERM:
 133     case EROFS:
 134         SetLastError( ERROR_ACCESS_DENIED );
 135         break;
 136     case EBUSY:
 137         SetLastError( ERROR_LOCK_VIOLATION );
 138         break;
 139     case ENOENT:
 140         SetLastError( ERROR_FILE_NOT_FOUND );
 141         break;
 142     case EISDIR:
 143         SetLastError( ERROR_CANNOT_MAKE );
 144         break;
 145     case ENFILE:
 146     case EMFILE:
 147         SetLastError( ERROR_TOO_MANY_OPEN_FILES );
 148         break;
 149     case EEXIST:
 150         SetLastError( ERROR_FILE_EXISTS );
 151         break;
 152     case EINVAL:
 153     case ESPIPE:
 154         SetLastError( ERROR_SEEK );
 155         break;
 156     case ENOTEMPTY:
 157         SetLastError( ERROR_DIR_NOT_EMPTY );
 158         break;
 159     case ENOEXEC:
 160         SetLastError( ERROR_BAD_FORMAT );
 161         break;
 162     case ENOTDIR:
 163         SetLastError( ERROR_PATH_NOT_FOUND );
 164         break;
 165     case EXDEV:
 166         SetLastError( ERROR_NOT_SAME_DEVICE );
 167         break;
 168     default:
 169         WARN("unknown file error: %s\n", strerror(save_errno) );
 170         SetLastError( ERROR_GEN_FAILURE );
 171         break;
 172     }
 173     errno = save_errno;
 174 }
 175
 176
 177 /*************************************************************************
 178  * CreateFileW [KERNEL32.@]  Creates or opens a file or other object
 179  *
 180  * Creates or opens an object, and returns a handle that can be used to
 181  * access that object.
 182  *
 183  * PARAMS
 184  *
 185  * filename     [in] pointer to filename to be accessed
 186  * access       [in] access mode requested
 187  * sharing      [in] share mode
 188  * sa           [in] pointer to security attributes
 189  * creation     [in] how to create the file
 190  * attributes   [in] attributes for newly created file
 191  * template     [in] handle to file with extended attributes to copy
 192  *
 193  * RETURNS
 194  *   Success: Open handle to specified file
 195  *   Failure: INVALID_HANDLE_VALUE
 196  *
 197  * NOTES
 198  *  Should call SetLastError() on failure.
 199  *
 200  * BUGS
 201  *
 202  * Doesn't support character devices, template files, or a
 203  * lot of the 'attributes' flags yet.
 204  */
 205 HANDLE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
 206                               LPSECURITY_ATTRIBUTES sa, DWORD creation,
 207                               DWORD attributes, HANDLE template )
 208 {
 209     NTSTATUS status;
 210     UINT options;
 211     OBJECT_ATTRIBUTES attr;
 212     UNICODE_STRING nameW;
 213     IO_STATUS_BLOCK io;
 214     HANDLE ret;
 215     DWORD dosdev;
 216     static const WCHAR bkslashes_with_dotW[] = {'\\','\\','.','\\',0};
 217     static const WCHAR coninW[] = {'C','O','N','I','N','$',0};
 218     static const WCHAR conoutW[] = {'C','O','N','O','U','T','$',0};
 219
 220     static const char * const creation_name[5] =
 221         { "CREATE_NEW", "CREATE_ALWAYS", "OPEN_EXISTING", "OPEN_ALWAYS", "TRUNCATE_EXISTING" };
 222
 223     static const UINT nt_disposition[5] =
 224     {
 225         FILE_CREATE,        /* CREATE_NEW */
 226         FILE_OVERWRITE_IF,  /* CREATE_ALWAYS */
 227         FILE_OPEN,          /* OPEN_EXISTING */
 228         FILE_OPEN_IF,       /* OPEN_ALWAYS */
 229         FILE_OVERWRITE      /* TRUNCATE_EXISTING */
 230     };
 231
 232
 233     /* sanity checks */
 234
 235     if (!filename || !filename[0])
 236     {
 237         SetLastError( ERROR_PATH_NOT_FOUND );
 238         return INVALID_HANDLE_VALUE;
 239     }
 240
 241     if (creation < CREATE_NEW || creation > TRUNCATE_EXISTING)
 242     {
 243         SetLastError( ERROR_INVALID_PARAMETER );
 244         return INVALID_HANDLE_VALUE;
 245     }
 246
 247     TRACE("%s %s%s%s%s%s%s%s attributes 0x%lx\n", debugstr_w(filename),
 248           (access & GENERIC_READ)?"GENERIC_READ ":"",
 249           (access & GENERIC_WRITE)?"GENERIC_WRITE ":"",
 250           (!access)?"QUERY_ACCESS ":"",
 251           (sharing & FILE_SHARE_READ)?"FILE_SHARE_READ ":"",
 252           (sharing & FILE_SHARE_WRITE)?"FILE_SHARE_WRITE ":"",
 253           (sharing & FILE_SHARE_DELETE)?"FILE_SHARE_DELETE ":"",
 254           creation_name[creation - CREATE_NEW], attributes);
 255
 256     /* Open a console for CONIN$ or CONOUT$ */
 257
 258     if (!strcmpiW(filename, coninW) || !strcmpiW(filename, conoutW))
 259     {
 260         ret = OpenConsoleW(filename, access, (sa && sa->bInheritHandle), creation);
 261         goto done;
 262     }
 263
 264     if (!strncmpW(filename, bkslashes_with_dotW, 4))
 265     {
 266         static const WCHAR pipeW[] = {'P','I','P','E','\\',0};
 267
 268         if ((isalphaW(filename[4]) && filename[5] == ':' && filename[6] == '\0') ||
 269             !strncmpiW( filename + 4, pipeW, 5 ))
 270         {
 271             dosdev = 0;
 272         }
 273         else if ((dosdev = RtlIsDosDeviceName_U( filename + 4 )))
 274         {
 275             dosdev += MAKELONG( 0, 4*sizeof(WCHAR) );  /* adjust position to start of filename */
 276         }
 277         else if (filename[4])
 278         {
 279             ret = VXD_Open( filename+4, access, sa );
 280             goto done;
 281         }
 282         else
 283         {
 284             SetLastError( ERROR_INVALID_NAME );
 285             return INVALID_HANDLE_VALUE;
 286         }
 287     }
 288     else dosdev = RtlIsDosDeviceName_U( filename );
 289
 290     if (dosdev)
 291     {
 292         static const WCHAR conW[] = {'C','O','N'};
 293
 294         if (LOWORD(dosdev) == sizeof(conW) &&
 295             !memicmpW( filename + HIWORD(dosdev)/sizeof(WCHAR), conW, sizeof(conW)))
 296         {
 297             switch (access & (GENERIC_READ|GENERIC_WRITE))
 298             {
 299             case GENERIC_READ:
 300                 ret = OpenConsoleW(coninW, access, (sa && sa->bInheritHandle), creation);
 301                 goto done;
 302             case GENERIC_WRITE:
 303                 ret = OpenConsoleW(conoutW, access, (sa && sa->bInheritHandle), creation);
 304                 goto done;
 305             default:
 306                 SetLastError( ERROR_FILE_NOT_FOUND );
 307                 return INVALID_HANDLE_VALUE;
 308             }
 309         }
 310     }
 311
 312     if (!RtlDosPathNameToNtPathName_U( filename, &nameW, NULL, NULL ))
 313     {
 314         SetLastError( ERROR_PATH_NOT_FOUND );
 315         return INVALID_HANDLE_VALUE;
 316     }
 317
 318     /* now call NtCreateFile */
 319
 320     options = 0;
 321     if (attributes & FILE_FLAG_BACKUP_SEMANTICS)
 322         options |= FILE_OPEN_FOR_BACKUP_INTENT;
 323     else
 324         options |= FILE_NON_DIRECTORY_FILE;
 325     if (attributes & FILE_FLAG_DELETE_ON_CLOSE)
 326         options |= FILE_DELETE_ON_CLOSE;
 327     if (!(attributes & FILE_FLAG_OVERLAPPED))
 328         options |= FILE_SYNCHRONOUS_IO_ALERT;
 329     if (attributes & FILE_FLAG_RANDOM_ACCESS)
 330         options |= FILE_RANDOM_ACCESS;
 331     attributes &= FILE_ATTRIBUTE_VALID_FLAGS;
 332
 333     attr.Length = sizeof(attr);
 334     attr.RootDirectory = 0;
 335     attr.Attributes = OBJ_CASE_INSENSITIVE;
 336     attr.ObjectName = &nameW;
 337     attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
 338     attr.SecurityQualityOfService = NULL;
 339
 340     if (sa && sa->bInheritHandle) attr.Attributes |= OBJ_INHERIT;
 341
 342     status = NtCreateFile( &ret, access, &attr, &io, NULL, attributes,
 343                            sharing, nt_disposition[creation - CREATE_NEW],
 344                            options, NULL, 0 );
 345     if (status)
 346     {
 347         WARN("Unable to create file %s (status %lx)\n", debugstr_w(filename), status);
 348         ret = INVALID_HANDLE_VALUE;
 349
 350         /* In the case file creation was rejected due to CREATE_NEW flag
 351          * was specified and file with that name already exists, correct
 352          * last error is ERROR_FILE_EXISTS and not ERROR_ALREADY_EXISTS.
 353          * Note: RtlNtStatusToDosError is not the subject to blame here.
 354          */
 355         if (status == STATUS_OBJECT_NAME_COLLISION)
 356             SetLastError( ERROR_FILE_EXISTS );
 357         else
 358             SetLastError( RtlNtStatusToDosError(status) );
 359     }
 360     else SetLastError(0);
 361     RtlFreeUnicodeString( &nameW );
 362
 363  done:
 364     if (!ret) ret = INVALID_HANDLE_VALUE;
 365     TRACE("returning %p\n", ret);
 366     return ret;
 367 }
 368
 369
 370
 371 /*************************************************************************
 372  *              CreateFileA              (KERNEL32.@)
 373  */
 374 HANDLE WINAPI CreateFileA( LPCSTR filename, DWORD access, DWORD sharing,
 375                               LPSECURITY_ATTRIBUTES sa, DWORD creation,
 376                               DWORD attributes, HANDLE template)
 377 {
 378     UNICODE_STRING filenameW;
 379     HANDLE ret = INVALID_HANDLE_VALUE;
 380
 381     if (!filename)
 382     {
 383         SetLastError( ERROR_INVALID_PARAMETER );
 384         return INVALID_HANDLE_VALUE;
 385     }
 386
 387     if (RtlCreateUnicodeStringFromAsciiz(&filenameW, filename))
 388     {
 389         ret = CreateFileW(filenameW.Buffer, access, sharing, sa, creation,
 390                           attributes, template);
 391         RtlFreeUnicodeString(&filenameW);
 392     }
 393     else
 394         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 395     return ret;
 396 }
 397
 398
 399 /***********************************************************************
 400  *           GetTempFileNameA   (KERNEL32.@)
 401  */
 402 UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique,
 403                                   LPSTR buffer)
 404 {
 405     UNICODE_STRING pathW, prefixW;
 406     WCHAR bufferW[MAX_PATH];
 407     UINT ret;
 408
 409     if ( !path || !prefix || !buffer )
 410     {
 411         SetLastError( ERROR_INVALID_PARAMETER );
 412         return 0;
 413     }
 414
 415     RtlCreateUnicodeStringFromAsciiz(&pathW, path);
 416     RtlCreateUnicodeStringFromAsciiz(&prefixW, prefix);
 417
 418     ret = GetTempFileNameW(pathW.Buffer, prefixW.Buffer, unique, bufferW);
 419     if (ret)
 420         WideCharToMultiByte(CP_ACP, 0, bufferW, -1, buffer, MAX_PATH, NULL, NULL);
 421
 422     RtlFreeUnicodeString(&pathW);
 423     RtlFreeUnicodeString(&prefixW);
 424     return ret;
 425 }
 426
 427 /***********************************************************************
 428  *           GetTempFileNameW   (KERNEL32.@)
 429  */
 430 UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique,
 431                                   LPWSTR buffer )
 432 {
 433     static const WCHAR formatW[] = {'%','x','.','t','m','p',0};
 434
 435     int i;
 436     LPWSTR p;
 437
 438     if ( !path || !prefix || !buffer )
 439     {
 440         SetLastError( ERROR_INVALID_PARAMETER );
 441         return 0;
 442     }
 443
 444     strcpyW( buffer, path );
 445     p = buffer + strlenW(buffer);
 446
 447     /* add a \, if there isn't one  */
 448     if ((p == buffer) || (p[-1] != '\\')) *p++ = '\\';
 449
 450     for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
 451
 452     unique &= 0xffff;
 453
 454     if (unique) sprintfW( p, formatW, unique );
 455     else
 456     {
 457         /* get a "random" unique number and try to create the file */
 458         HANDLE handle;
 459         UINT num = GetTickCount() & 0xffff;
 460
 461         if (!num) num = 1;
 462         unique = num;
 463         do
 464         {
 465             sprintfW( p, formatW, unique );
 466             handle = CreateFileW( buffer, GENERIC_WRITE, 0, NULL,
 467                                   CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
 468             if (handle != INVALID_HANDLE_VALUE)
 469             {  /* We created it */
 470                 TRACE("created %s\n", debugstr_w(buffer) );
 471                 CloseHandle( handle );
 472                 break;
 473             }
 474             if (GetLastError() != ERROR_FILE_EXISTS &&
 475                 GetLastError() != ERROR_SHARING_VIOLATION)
 476                 break;  /* No need to go on */
 477             if (!(++unique & 0xffff)) unique = 1;
 478         } while (unique != num);
 479     }
 480
 481     TRACE("returning %s\n", debugstr_w(buffer) );
 482     return unique;
 483 }
 484
 485
 486 /******************************************************************
 487  *              FILE_ReadWriteApc (internal)
 488  *
 489  *
 490  */
 491 static void WINAPI      FILE_ReadWriteApc(void* apc_user, PIO_STATUS_BLOCK io_status, ULONG len)
 492 {
 493     LPOVERLAPPED_COMPLETION_ROUTINE  cr = (LPOVERLAPPED_COMPLETION_ROUTINE)apc_user;
 494
 495     cr(RtlNtStatusToDosError(io_status->u.Status), len, (LPOVERLAPPED)io_status);
 496 }
 497
 498 /***********************************************************************
 499  *              ReadFileEx                (KERNEL32.@)
 500  */
 501 BOOL WINAPI ReadFileEx(HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
 502                        LPOVERLAPPED overlapped,
 503                        LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 504 {
 505     LARGE_INTEGER       offset;
 506     NTSTATUS            status;
 507     PIO_STATUS_BLOCK    io_status;
 508
 509     if (!overlapped)
 510     {
 511         SetLastError(ERROR_INVALID_PARAMETER);
 512         return FALSE;
 513     }
 514
 515     offset.u.LowPart = overlapped->Offset;
 516     offset.u.HighPart = overlapped->OffsetHigh;
 517     io_status = (PIO_STATUS_BLOCK)overlapped;
 518     io_status->u.Status = STATUS_PENDING;
 519
 520     status = NtReadFile(hFile, NULL, FILE_ReadWriteApc, lpCompletionRoutine,
 521                         io_status, buffer, bytesToRead, &offset, NULL);
 522
 523     if (status)
 524     {
 525         SetLastError( RtlNtStatusToDosError(status) );
 526         return FALSE;
 527     }
 528     return TRUE;
 529 }
 530
 531 /***********************************************************************
 532  *              ReadFile                (KERNEL32.@)
 533  */
 534 BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
 535                       LPDWORD bytesRead, LPOVERLAPPED overlapped )
 536 {
 537     LARGE_INTEGER       offset;
 538     PLARGE_INTEGER      poffset = NULL;
 539     IO_STATUS_BLOCK     iosb;
 540     PIO_STATUS_BLOCK    io_status = &iosb;
 541     HANDLE              hEvent = 0;
 542     NTSTATUS            status;
 543
 544     TRACE("%p %p %ld %p %p\n", hFile, buffer, bytesToRead,
 545           bytesRead, overlapped );
 546
 547     if (bytesRead) *bytesRead = 0;  /* Do this before anything else */
 548     if (!bytesToRead) return TRUE;
 549
 550     if (IsBadReadPtr(buffer, bytesToRead))
 551     {
 552         SetLastError(ERROR_WRITE_FAULT); /* FIXME */
 553         return FALSE;
 554     }
 555     if (is_console_handle(hFile))
 556         return ReadConsoleA(hFile, buffer, bytesToRead, bytesRead, NULL);
 557
 558     if (overlapped != NULL)
 559     {
 560         offset.u.LowPart = overlapped->Offset;
 561         offset.u.HighPart = overlapped->OffsetHigh;
 562         poffset = &offset;
 563         hEvent = overlapped->hEvent;
 564         io_status = (PIO_STATUS_BLOCK)overlapped;
 565     }
 566     io_status->u.Status = STATUS_PENDING;
 567     io_status->Information = 0;
 568
 569     status = NtReadFile(hFile, hEvent, NULL, NULL, io_status, buffer, bytesToRead, poffset, NULL);
 570
 571     if (status != STATUS_PENDING && bytesRead)
 572         *bytesRead = io_status->Information;
 573
 574     if (status && status != STATUS_END_OF_FILE)
 575     {
 576         SetLastError( RtlNtStatusToDosError(status) );
 577         return FALSE;
 578     }
 579     return TRUE;
 580 }
 581
 582
 583 /***********************************************************************
 584  *              WriteFileEx                (KERNEL32.@)
 585  */
 586 BOOL WINAPI WriteFileEx(HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
 587                         LPOVERLAPPED overlapped,
 588                         LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
 589 {
 590     LARGE_INTEGER       offset;
 591     NTSTATUS            status;
 592     PIO_STATUS_BLOCK    io_status;
 593
 594     TRACE("%p %p %ld %p %p\n",
 595           hFile, buffer, bytesToWrite, overlapped, lpCompletionRoutine);
 596
 597     if (overlapped == NULL)
 598     {
 599         SetLastError(ERROR_INVALID_PARAMETER);
 600         return FALSE;
 601     }
 602     offset.u.LowPart = overlapped->Offset;
 603     offset.u.HighPart = overlapped->OffsetHigh;
 604
 605     io_status = (PIO_STATUS_BLOCK)overlapped;
 606     io_status->u.Status = STATUS_PENDING;
 607
 608     status = NtWriteFile(hFile, NULL, FILE_ReadWriteApc, lpCompletionRoutine,
 609                          io_status, buffer, bytesToWrite, &offset, NULL);
 610
 611     if (status) SetLastError( RtlNtStatusToDosError(status) );
 612     return !status;
 613 }
 614
 615 /***********************************************************************
 616  *             WriteFile               (KERNEL32.@)
 617  */
 618 BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
 619                        LPDWORD bytesWritten, LPOVERLAPPED overlapped )
 620 {
 621     HANDLE hEvent = NULL;
 622     LARGE_INTEGER offset;
 623     PLARGE_INTEGER poffset = NULL;
 624     NTSTATUS status;
 625     IO_STATUS_BLOCK iosb;
 626     PIO_STATUS_BLOCK piosb = &iosb;
 627
 628     TRACE("%p %p %ld %p %p\n",
 629           hFile, buffer, bytesToWrite, bytesWritten, overlapped );
 630
 631     if (is_console_handle(hFile))
 632         return WriteConsoleA(hFile, buffer, bytesToWrite, bytesWritten, NULL);
 633
 634     if (IsBadReadPtr(buffer, bytesToWrite))
 635     {
 636         SetLastError(ERROR_READ_FAULT); /* FIXME */
 637         return FALSE;
 638     }
 639
 640     if (overlapped)
 641     {
 642         offset.u.LowPart = overlapped->Offset;
 643         offset.u.HighPart = overlapped->OffsetHigh;
 644         poffset = &offset;
 645         hEvent = overlapped->hEvent;
 646         piosb = (PIO_STATUS_BLOCK)overlapped;
 647     }
 648     piosb->u.Status = STATUS_PENDING;
 649     piosb->Information = 0;
 650
 651     status = NtWriteFile(hFile, hEvent, NULL, NULL, piosb,
 652                          buffer, bytesToWrite, poffset, NULL);
 653     if (status)
 654     {
 655         SetLastError( RtlNtStatusToDosError(status) );
 656         return FALSE;
 657     }
 658     if (bytesWritten) *bytesWritten = piosb->Information;
 659
 660     return TRUE;
 661 }
 662
 663
 664 /***********************************************************************
 665  *           SetFilePointer   (KERNEL32.@)
 666  */
 667 DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
 668                              DWORD method )
 669 {
 670     static const int whence[3] = { SEEK_SET, SEEK_CUR, SEEK_END };
 671     DWORD ret = INVALID_SET_FILE_POINTER;
 672     NTSTATUS status;
 673     int fd;
 674
 675     TRACE("handle %p offset %ld high %ld origin %ld\n",
 676           hFile, distance, highword?*highword:0, method );
 677
 678     if (method > FILE_END)
 679     {
 680         SetLastError( ERROR_INVALID_PARAMETER );
 681         return ret;
 682     }
 683
 684     if (!(status = wine_server_handle_to_fd( hFile, 0, &fd, NULL, NULL )))
 685     {
 686         off_t pos, res;
 687
 688         if (highword) pos = ((off_t)*highword << 32) | (ULONG)distance;
 689         else pos = (off_t)distance;
 690         if ((res = lseek( fd, pos, whence[method] )) == (off_t)-1)
 691         {
 692             /* also check EPERM due to SuSE7 2.2.16 lseek() EPERM kernel bug */
 693             if (((errno == EINVAL) || (errno == EPERM)) && (method != FILE_BEGIN) && (pos < 0))
 694                 SetLastError( ERROR_NEGATIVE_SEEK );
 695             else
 696                 FILE_SetDosError();
 697         }
 698         else
 699         {
 700             ret = (DWORD)res;
 701             if (highword) *highword = (res >> 32);
 702             if (ret == INVALID_SET_FILE_POINTER) SetLastError( 0 );
 703         }
 704         wine_server_release_fd( hFile, fd );
 705     }
 706     else SetLastError( RtlNtStatusToDosError(status) );
 707
 708     return ret;
 709 }
 710
 711
 712 /*************************************************************************
 713  *           SetHandleCount   (KERNEL32.@)
 714  */
 715 UINT WINAPI SetHandleCount( UINT count )
 716 {
 717     return min( 256, count );
 718 }
 719
 720
 721 /**************************************************************************
 722  *           SetEndOfFile   (KERNEL32.@)
 723  */
 724 BOOL WINAPI SetEndOfFile( HANDLE hFile )
 725 {
 726     BOOL ret;
 727     SERVER_START_REQ( truncate_file )
 728     {
 729         req->handle = hFile;
 730         ret = !wine_server_call_err( req );
 731     }
 732     SERVER_END_REQ;
 733     return ret;
 734 }
 735
 736
 737 /***********************************************************************
 738  *           GetFileType   (KERNEL32.@)
 739  */
 740 DWORD WINAPI GetFileType( HANDLE hFile )
 741 {
 742     NTSTATUS status;
 743     int fd;
 744     DWORD ret = FILE_TYPE_UNKNOWN;
 745
 746     if (is_console_handle( hFile ))
 747         return FILE_TYPE_CHAR;
 748
 749     if (!(status = wine_server_handle_to_fd( hFile, 0, &fd, NULL, NULL )))
 750     {
 751         struct stat st;
 752
 753         if (fstat( fd, &st ) == -1)
 754             FILE_SetDosError();
 755         else if (S_ISFIFO(st.st_mode) || S_ISSOCK(st.st_mode))
 756             ret = FILE_TYPE_PIPE;
 757         else if (S_ISCHR(st.st_mode))
 758             ret = FILE_TYPE_CHAR;
 759         else
 760             ret = FILE_TYPE_DISK;
 761         wine_server_release_fd( hFile, fd );
 762     }
 763     else SetLastError( RtlNtStatusToDosError(status) );
 764
 765     return ret;
 766 }
 767
 768
 769 /**************************************************************************
 770  *           CopyFileW   (KERNEL32.@)
 771  */
 772 BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists )
 773 {
 774     HANDLE h1, h2;
 775     BY_HANDLE_FILE_INFORMATION info;
 776     DWORD count;
 777     BOOL ret = FALSE;
 778     char buffer[2048];
 779
 780     if (!source || !dest)
 781     {
 782         SetLastError(ERROR_INVALID_PARAMETER);
 783         return FALSE;
 784     }
 785
 786     TRACE("%s -> %s\n", debugstr_w(source), debugstr_w(dest));
 787
 788     if ((h1 = CreateFileW(source, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE,
 789                      NULL, OPEN_EXISTING, 0, 0)) == INVALID_HANDLE_VALUE)
 790     {
 791         WARN("Unable to open source %s\n", debugstr_w(source));
 792         return FALSE;
 793     }
 794
 795     if (!GetFileInformationByHandle( h1, &info ))
 796     {
 797         WARN("GetFileInformationByHandle returned error for %s\n", debugstr_w(source));
 798         CloseHandle( h1 );
 799         return FALSE;
 800     }
 801
 802     if ((h2 = CreateFileW( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
 803                              fail_if_exists ? CREATE_NEW : CREATE_ALWAYS,
 804                              info.dwFileAttributes, h1 )) == INVALID_HANDLE_VALUE)
 805     {
 806         WARN("Unable to open dest %s\n", debugstr_w(dest));
 807         CloseHandle( h1 );
 808         return FALSE;
 809     }
 810
 811     while (ReadFile( h1, buffer, sizeof(buffer), &count, NULL ) && count)
 812     {
 813         char *p = buffer;
 814         while (count != 0)
 815         {
 816             DWORD res;
 817             if (!WriteFile( h2, p, count, &res, NULL ) || !res) goto done;
 818             p += res;
 819             count -= res;
 820         }
 821     }
 822     ret =  TRUE;
 823 done:
 824     CloseHandle( h1 );
 825     CloseHandle( h2 );
 826     return ret;
 827 }
 828
 829
 830 /**************************************************************************
 831  *           CopyFileA   (KERNEL32.@)
 832  */
 833 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists)
 834 {
 835     UNICODE_STRING sourceW, destW;
 836     BOOL ret;
 837
 838     if (!source || !dest)
 839     {
 840         SetLastError(ERROR_INVALID_PARAMETER);
 841         return FALSE;
 842     }
 843
 844     RtlCreateUnicodeStringFromAsciiz(&sourceW, source);
 845     RtlCreateUnicodeStringFromAsciiz(&destW, dest);
 846
 847     ret = CopyFileW(sourceW.Buffer, destW.Buffer, fail_if_exists);
 848
 849     RtlFreeUnicodeString(&sourceW);
 850     RtlFreeUnicodeString(&destW);
 851     return ret;
 852 }
 853
 854
 855 /**************************************************************************
 856  *           CopyFileExW   (KERNEL32.@)
 857  *
 858  * This implementation ignores most of the extra parameters passed-in into
 859  * the "ex" version of the method and calls the CopyFile method.
 860  * It will have to be fixed eventually.
 861  */
 862 BOOL WINAPI CopyFileExW(LPCWSTR sourceFilename, LPCWSTR destFilename,
 863                         LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
 864                         LPBOOL cancelFlagPointer, DWORD copyFlags)
 865 {
 866     /*
 867      * Interpret the only flag that CopyFile can interpret.
 868      */
 869     return CopyFileW(sourceFilename, destFilename, (copyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0);
 870 }
 871
 872
 873 /**************************************************************************
 874  *           CopyFileExA   (KERNEL32.@)
 875  */
 876 BOOL WINAPI CopyFileExA(LPCSTR sourceFilename, LPCSTR destFilename,
 877                         LPPROGRESS_ROUTINE progressRoutine, LPVOID appData,
 878                         LPBOOL cancelFlagPointer, DWORD copyFlags)
 879 {
 880     UNICODE_STRING sourceW, destW;
 881     BOOL ret;
 882
 883     if (!sourceFilename || !destFilename)
 884     {
 885         SetLastError(ERROR_INVALID_PARAMETER);
 886         return FALSE;
 887     }
 888
 889     RtlCreateUnicodeStringFromAsciiz(&sourceW, sourceFilename);
 890     RtlCreateUnicodeStringFromAsciiz(&destW, destFilename);
 891
 892     ret = CopyFileExW(sourceW.Buffer, destW.Buffer, progressRoutine, appData,
 893                       cancelFlagPointer, copyFlags);
 894
 895     RtlFreeUnicodeString(&sourceW);
 896     RtlFreeUnicodeString(&destW);
 897     return ret;
 898 }