dlls/ntdll/file.c

   1 /*
   2  * Copyright 1999, 2000 Juergen Schmied
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <stdio.h>
  22 #include <assert.h>
  23
  24 #include "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26 #define NONAMELESSUNION
  27 #include "wine/debug.h"
  28 #include "wine/server.h"
  29 #include "ntdll_misc.h"
  30
  31 #include "winternl.h"
  32 #include "winioctl.h"
  33 #include "ddk/ntddk.h"
  34 #include "ddk/ntddser.h"
  35 #define WINE_MOUNTMGR_EXTENSIONS
  36 #include "ddk/mountmgr.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(ntdll);
  39
  40
  41 /******************************************************************************
  42  *  NtReadFile                                  [NTDLL.@]
  43  *  ZwReadFile                                  [NTDLL.@]
  44  *
  45  * Read from an open file handle.
  46  *
  47  * PARAMS
  48  *  FileHandle    [I] Handle returned from ZwOpenFile() or ZwCreateFile()
  49  *  Event         [I] Event to signal upon completion (or NULL)
  50  *  ApcRoutine    [I] Callback to call upon completion (or NULL)
  51  *  ApcContext    [I] Context for ApcRoutine (or NULL)
  52  *  IoStatusBlock [O] Receives information about the operation on return
  53  *  Buffer        [O] Destination for the data read
  54  *  Length        [I] Size of Buffer
  55  *  ByteOffset    [O] Destination for the new file pointer position (or NULL)
  56  *  Key           [O] Function unknown (may be NULL)
  57  *
  58  * RETURNS
  59  *  Success: 0. IoStatusBlock is updated, and the Information member contains
  60  *           The number of bytes read.
  61  *  Failure: An NTSTATUS error code describing the error.
  62  */
  63 NTSTATUS WINAPI NtReadFile(HANDLE hFile, HANDLE hEvent,
  64                            PIO_APC_ROUTINE apc, void* apc_user,
  65                            PIO_STATUS_BLOCK io_status, void* buffer, ULONG length,
  66                            PLARGE_INTEGER offset, PULONG key)
  67 {
  68     return unix_funcs->NtReadFile( hFile, hEvent, apc, apc_user, io_status, buffer, length, offset, key );
  69 }
  70
  71
  72 /******************************************************************************
  73  *  NtReadFileScatter   [NTDLL.@]
  74  *  ZwReadFileScatter   [NTDLL.@]
  75  */
  76 NTSTATUS WINAPI NtReadFileScatter( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
  77                                    PIO_STATUS_BLOCK io_status, FILE_SEGMENT_ELEMENT *segments,
  78                                    ULONG length, PLARGE_INTEGER offset, PULONG key )
  79 {
  80     return unix_funcs->NtReadFileScatter( file, event, apc, apc_user, io_status,
  81                                           segments, length, offset, key );
  82 }
  83
  84
  85
  86 /******************************************************************************
  87  *  NtWriteFile                                 [NTDLL.@]
  88  *  ZwWriteFile                                 [NTDLL.@]
  89  *
  90  * Write to an open file handle.
  91  *
  92  * PARAMS
  93  *  FileHandle    [I] Handle returned from ZwOpenFile() or ZwCreateFile()
  94  *  Event         [I] Event to signal upon completion (or NULL)
  95  *  ApcRoutine    [I] Callback to call upon completion (or NULL)
  96  *  ApcContext    [I] Context for ApcRoutine (or NULL)
  97  *  IoStatusBlock [O] Receives information about the operation on return
  98  *  Buffer        [I] Source for the data to write
  99  *  Length        [I] Size of Buffer
 100  *  ByteOffset    [O] Destination for the new file pointer position (or NULL)
 101  *  Key           [O] Function unknown (may be NULL)
 102  *
 103  * RETURNS
 104  *  Success: 0. IoStatusBlock is updated, and the Information member contains
 105  *           The number of bytes written.
 106  *  Failure: An NTSTATUS error code describing the error.
 107  */
 108 NTSTATUS WINAPI NtWriteFile(HANDLE hFile, HANDLE hEvent,
 109                             PIO_APC_ROUTINE apc, void* apc_user,
 110                             PIO_STATUS_BLOCK io_status,
 111                             const void* buffer, ULONG length,
 112                             PLARGE_INTEGER offset, PULONG key)
 113 {
 114     return unix_funcs->NtWriteFile( hFile, hEvent, apc, apc_user, io_status, buffer, length, offset, key );
 115 }
 116
 117
 118 /******************************************************************************
 119  *  NtWriteFileGather   [NTDLL.@]
 120  *  ZwWriteFileGather   [NTDLL.@]
 121  */
 122 NTSTATUS WINAPI NtWriteFileGather( HANDLE file, HANDLE event, PIO_APC_ROUTINE apc, void *apc_user,
 123                                    PIO_STATUS_BLOCK io_status, FILE_SEGMENT_ELEMENT *segments,
 124                                    ULONG length, PLARGE_INTEGER offset, PULONG key )
 125 {
 126     return unix_funcs->NtWriteFileGather( file, event, apc, apc_user, io_status,
 127                                           segments, length, offset, key );
 128 }
 129
 130
 131 /**************************************************************************
 132  *              NtDeviceIoControlFile                   [NTDLL.@]
 133  *              ZwDeviceIoControlFile                   [NTDLL.@]
 134  *
 135  * Perform an I/O control operation on an open file handle.
 136  *
 137  * PARAMS
 138  *  handle         [I] Handle returned from ZwOpenFile() or ZwCreateFile()
 139  *  event          [I] Event to signal upon completion (or NULL)
 140  *  apc            [I] Callback to call upon completion (or NULL)
 141  *  apc_context    [I] Context for ApcRoutine (or NULL)
 142  *  io             [O] Receives information about the operation on return
 143  *  code           [I] Control code for the operation to perform
 144  *  in_buffer      [I] Source for any input data required (or NULL)
 145  *  in_size        [I] Size of InputBuffer
 146  *  out_buffer     [O] Source for any output data returned (or NULL)
 147  *  out_size       [I] Size of OutputBuffer
 148  *
 149  * RETURNS
 150  *  Success: 0. IoStatusBlock is updated.
 151  *  Failure: An NTSTATUS error code describing the error.
 152  */
 153 NTSTATUS WINAPI NtDeviceIoControlFile(HANDLE handle, HANDLE event,
 154                                       PIO_APC_ROUTINE apc, PVOID apc_context,
 155                                       PIO_STATUS_BLOCK io, ULONG code,
 156                                       PVOID in_buffer, ULONG in_size,
 157                                       PVOID out_buffer, ULONG out_size)
 158 {
 159     return unix_funcs->NtDeviceIoControlFile( handle, event, apc, apc_context, io, code,
 160                                               in_buffer, in_size, out_buffer, out_size );
 161 }
 162
 163
 164 /**************************************************************************
 165  *              NtFsControlFile                 [NTDLL.@]
 166  *              ZwFsControlFile                 [NTDLL.@]
 167  *
 168  * Perform a file system control operation on an open file handle.
 169  *
 170  * PARAMS
 171  *  handle         [I] Handle returned from ZwOpenFile() or ZwCreateFile()
 172  *  event          [I] Event to signal upon completion (or NULL)
 173  *  apc            [I] Callback to call upon completion (or NULL)
 174  *  apc_context    [I] Context for ApcRoutine (or NULL)
 175  *  io             [O] Receives information about the operation on return
 176  *  code           [I] Control code for the operation to perform
 177  *  in_buffer      [I] Source for any input data required (or NULL)
 178  *  in_size        [I] Size of InputBuffer
 179  *  out_buffer     [O] Source for any output data returned (or NULL)
 180  *  out_size       [I] Size of OutputBuffer
 181  *
 182  * RETURNS
 183  *  Success: 0. IoStatusBlock is updated.
 184  *  Failure: An NTSTATUS error code describing the error.
 185  */
 186 NTSTATUS WINAPI NtFsControlFile(HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc,
 187                                 PVOID apc_context, PIO_STATUS_BLOCK io, ULONG code,
 188                                 PVOID in_buffer, ULONG in_size, PVOID out_buffer, ULONG out_size)
 189 {
 190     return unix_funcs->NtFsControlFile( handle, event, apc, apc_context, io, code,
 191                                         in_buffer, in_size, out_buffer, out_size );
 192 }
 193
 194
 195 /******************************************************************************
 196  *  NtNotifyChangeDirectoryFile [NTDLL.@]
 197  */
 198 NTSTATUS WINAPI NtNotifyChangeDirectoryFile( HANDLE handle, HANDLE event, PIO_APC_ROUTINE apc,
 199                                              void *apc_context, PIO_STATUS_BLOCK iosb, void *buffer,
 200                                              ULONG buffer_size, ULONG filter, BOOLEAN subtree )
 201 {
 202     return unix_funcs->NtNotifyChangeDirectoryFile( handle, event, apc, apc_context, iosb,
 203                                                     buffer, buffer_size, filter, subtree );
 204 }
 205
 206
 207 /******************************************************************************
 208  *  NtSetVolumeInformationFile          [NTDLL.@]
 209  *  ZwSetVolumeInformationFile          [NTDLL.@]
 210  */
 211 NTSTATUS WINAPI NtSetVolumeInformationFile( HANDLE handle, IO_STATUS_BLOCK *io, void *info,
 212                                             ULONG length, FS_INFORMATION_CLASS class )
 213 {
 214     return unix_funcs->NtSetVolumeInformationFile( handle, io, info, length, class );
 215 }
 216
 217 NTSTATUS server_get_unix_name( HANDLE handle, ANSI_STRING *unix_name )
 218 {
 219     data_size_t size = 1024;
 220     NTSTATUS ret;
 221     char *name;
 222
 223     for (;;)
 224     {
 225         name = RtlAllocateHeap( GetProcessHeap(), 0, size + 1 );
 226         if (!name) return STATUS_NO_MEMORY;
 227         unix_name->MaximumLength = size + 1;
 228
 229         SERVER_START_REQ( get_handle_unix_name )
 230         {
 231             req->handle = wine_server_obj_handle( handle );
 232             wine_server_set_reply( req, name, size );
 233             ret = wine_server_call( req );
 234             size = reply->name_len;
 235         }
 236         SERVER_END_REQ;
 237
 238         if (!ret)
 239         {
 240             name[size] = 0;
 241             unix_name->Buffer = name;
 242             unix_name->Length = size;
 243             break;
 244         }
 245         RtlFreeHeap( GetProcessHeap(), 0, name );
 246         if (ret != STATUS_BUFFER_OVERFLOW) break;
 247     }
 248     return ret;
 249 }
 250
 251
 252 /******************************************************************************
 253  *  NtQueryInformationFile              [NTDLL.@]
 254  *  ZwQueryInformationFile              [NTDLL.@]
 255  *
 256  * Get information about an open file handle.
 257  *
 258  * PARAMS
 259  *  hFile    [I] Handle returned from ZwOpenFile() or ZwCreateFile()
 260  *  io       [O] Receives information about the operation on return
 261  *  ptr      [O] Destination for file information
 262  *  len      [I] Size of FileInformation
 263  *  class    [I] Type of file information to get
 264  *
 265  * RETURNS
 266  *  Success: 0. IoStatusBlock and FileInformation are updated.
 267  *  Failure: An NTSTATUS error code describing the error.
 268  */
 269 NTSTATUS WINAPI NtQueryInformationFile( HANDLE hFile, PIO_STATUS_BLOCK io,
 270                                         PVOID ptr, LONG len, FILE_INFORMATION_CLASS class )
 271 {
 272     return unix_funcs->NtQueryInformationFile( hFile, io, ptr, len, class );
 273 }
 274
 275 /******************************************************************************
 276  *  NtSetInformationFile                [NTDLL.@]
 277  *  ZwSetInformationFile                [NTDLL.@]
 278  *
 279  * Set information about an open file handle.
 280  *
 281  * PARAMS
 282  *  handle  [I] Handle returned from ZwOpenFile() or ZwCreateFile()
 283  *  io      [O] Receives information about the operation on return
 284  *  ptr     [I] Source for file information
 285  *  len     [I] Size of FileInformation
 286  *  class   [I] Type of file information to set
 287  *
 288  * RETURNS
 289  *  Success: 0. io is updated.
 290  *  Failure: An NTSTATUS error code describing the error.
 291  */
 292 NTSTATUS WINAPI NtSetInformationFile(HANDLE handle, PIO_STATUS_BLOCK io,
 293                                      PVOID ptr, ULONG len, FILE_INFORMATION_CLASS class)
 294 {
 295     return unix_funcs->NtSetInformationFile( handle, io, ptr, len, class );
 296 }
 297
 298
 299 /******************************************************************************
 300  *              NtQueryFullAttributesFile   (NTDLL.@)
 301  */
 302 NTSTATUS WINAPI NtQueryFullAttributesFile( const OBJECT_ATTRIBUTES *attr,
 303                                            FILE_NETWORK_OPEN_INFORMATION *info )
 304 {
 305     return unix_funcs->NtQueryFullAttributesFile( attr, info );
 306 }
 307
 308
 309 /******************************************************************************
 310  *              NtQueryAttributesFile   (NTDLL.@)
 311  *              ZwQueryAttributesFile   (NTDLL.@)
 312  */
 313 NTSTATUS WINAPI NtQueryAttributesFile( const OBJECT_ATTRIBUTES *attr, FILE_BASIC_INFORMATION *info )
 314 {
 315     return unix_funcs->NtQueryAttributesFile( attr, info );
 316 }
 317
 318
 319 /******************************************************************************
 320  *  NtQueryVolumeInformationFile                [NTDLL.@]
 321  *  ZwQueryVolumeInformationFile                [NTDLL.@]
 322  *
 323  * Get volume information for an open file handle.
 324  *
 325  * PARAMS
 326  *  handle      [I] Handle returned from ZwOpenFile() or ZwCreateFile()
 327  *  io          [O] Receives information about the operation on return
 328  *  buffer      [O] Destination for volume information
 329  *  length      [I] Size of FsInformation
 330  *  info_class  [I] Type of volume information to set
 331  *
 332  * RETURNS
 333  *  Success: 0. io and buffer are updated.
 334  *  Failure: An NTSTATUS error code describing the error.
 335  */
 336 NTSTATUS WINAPI NtQueryVolumeInformationFile( HANDLE handle, PIO_STATUS_BLOCK io,
 337                                               PVOID buffer, ULONG length,
 338                                               FS_INFORMATION_CLASS info_class )
 339 {
 340     return unix_funcs->NtQueryVolumeInformationFile( handle, io, buffer, length, info_class );
 341 }
 342
 343
 344 /******************************************************************
 345  *              NtQueryEaFile  (NTDLL.@)
 346  *
 347  * Read extended attributes from NTFS files.
 348  *
 349  * PARAMS
 350  *  hFile         [I] File handle, must be opened with FILE_READ_EA access
 351  *  iosb          [O] Receives information about the operation on return
 352  *  buffer        [O] Output buffer
 353  *  length        [I] Length of output buffer
 354  *  single_entry  [I] Only read and return one entry
 355  *  ea_list       [I] Optional list with names of EAs to return
 356  *  ea_list_len   [I] Length of ea_list in bytes
 357  *  ea_index      [I] Optional pointer to 1-based index of attribute to return
 358  *  restart       [I] restart EA scan
 359  *
 360  * RETURNS
 361  *  Success: 0. Attributes read into buffer
 362  *  Failure: An NTSTATUS error code describing the error.
 363  */
 364 NTSTATUS WINAPI NtQueryEaFile( HANDLE hFile, PIO_STATUS_BLOCK iosb, PVOID buffer, ULONG length,
 365                                BOOLEAN single_entry, PVOID ea_list, ULONG ea_list_len,
 366                                PULONG ea_index, BOOLEAN restart )
 367 {
 368     FIXME("(%p,%p,%p,%d,%d,%p,%d,%p,%d) stub\n",
 369             hFile, iosb, buffer, length, single_entry, ea_list,
 370             ea_list_len, ea_index, restart);
 371     return STATUS_ACCESS_DENIED;
 372 }
 373
 374
 375 /******************************************************************
 376  *              NtSetEaFile  (NTDLL.@)
 377  *
 378  * Update extended attributes for NTFS files.
 379  *
 380  * PARAMS
 381  *  hFile         [I] File handle, must be opened with FILE_READ_EA access
 382  *  iosb          [O] Receives information about the operation on return
 383  *  buffer        [I] Buffer with EA information
 384  *  length        [I] Length of buffer
 385  *
 386  * RETURNS
 387  *  Success: 0. Attributes are updated
 388  *  Failure: An NTSTATUS error code describing the error.
 389  */
 390 NTSTATUS WINAPI NtSetEaFile( HANDLE hFile, PIO_STATUS_BLOCK iosb, PVOID buffer, ULONG length )
 391 {
 392     FIXME("(%p,%p,%p,%d) stub\n", hFile, iosb, buffer, length);
 393     return STATUS_ACCESS_DENIED;
 394 }
 395
 396
 397 /******************************************************************
 398  *              NtFlushBuffersFile  (NTDLL.@)
 399  *
 400  * Flush any buffered data on an open file handle.
 401  *
 402  * PARAMS
 403  *  FileHandle         [I] Handle returned from ZwOpenFile() or ZwCreateFile()
 404  *  IoStatusBlock      [O] Receives information about the operation on return
 405  *
 406  * RETURNS
 407  *  Success: 0. IoStatusBlock is updated.
 408  *  Failure: An NTSTATUS error code describing the error.
 409  */
 410 NTSTATUS WINAPI NtFlushBuffersFile( HANDLE hFile, IO_STATUS_BLOCK *io )
 411 {
 412     return unix_funcs->NtFlushBuffersFile( hFile, io );
 413 }
 414
 415 /******************************************************************
 416  *              NtLockFile       (NTDLL.@)
 417  *
 418  *
 419  */
 420 NTSTATUS WINAPI NtLockFile( HANDLE hFile, HANDLE lock_granted_event,
 421                             PIO_APC_ROUTINE apc, void* apc_user,
 422                             PIO_STATUS_BLOCK io_status, PLARGE_INTEGER offset,
 423                             PLARGE_INTEGER count, ULONG* key, BOOLEAN dont_wait,
 424                             BOOLEAN exclusive )
 425 {
 426     NTSTATUS    ret;
 427     HANDLE      handle;
 428     BOOLEAN     async;
 429     static BOOLEAN     warn = TRUE;
 430
 431     if (apc || io_status || key)
 432     {
 433         FIXME("Unimplemented yet parameter\n");
 434         return STATUS_NOT_IMPLEMENTED;
 435     }
 436
 437     if (apc_user && warn)
 438     {
 439         FIXME("I/O completion on lock not implemented yet\n");
 440         warn = FALSE;
 441     }
 442
 443     for (;;)
 444     {
 445         SERVER_START_REQ( lock_file )
 446         {
 447             req->handle      = wine_server_obj_handle( hFile );
 448             req->offset      = offset->QuadPart;
 449             req->count       = count->QuadPart;
 450             req->shared      = !exclusive;
 451             req->wait        = !dont_wait;
 452             ret = wine_server_call( req );
 453             handle = wine_server_ptr_handle( reply->handle );
 454             async  = reply->overlapped;
 455         }
 456         SERVER_END_REQ;
 457         if (ret != STATUS_PENDING)
 458         {
 459             if (!ret && lock_granted_event) NtSetEvent(lock_granted_event, NULL);
 460             return ret;
 461         }
 462
 463         if (async)
 464         {
 465             FIXME( "Async I/O lock wait not implemented, might deadlock\n" );
 466             if (handle) NtClose( handle );
 467             return STATUS_PENDING;
 468         }
 469         if (handle)
 470         {
 471             NtWaitForSingleObject( handle, FALSE, NULL );
 472             NtClose( handle );
 473         }
 474         else
 475         {
 476             LARGE_INTEGER time;
 477
 478             /* Unix lock conflict, sleep a bit and retry */
 479             time.QuadPart = 100 * (ULONGLONG)10000;
 480             time.QuadPart = -time.QuadPart;
 481             NtDelayExecution( FALSE, &time );
 482         }
 483     }
 484 }
 485
 486
 487 /******************************************************************
 488  *              NtUnlockFile    (NTDLL.@)
 489  *
 490  *
 491  */
 492 NTSTATUS WINAPI NtUnlockFile( HANDLE hFile, PIO_STATUS_BLOCK io_status,
 493                               PLARGE_INTEGER offset, PLARGE_INTEGER count,
 494                               PULONG key )
 495 {
 496     NTSTATUS status;
 497
 498     TRACE( "%p %x%08x %x%08x\n",
 499            hFile, offset->u.HighPart, offset->u.LowPart, count->u.HighPart, count->u.LowPart );
 500
 501     if (io_status || key)
 502     {
 503         FIXME("Unimplemented yet parameter\n");
 504         return STATUS_NOT_IMPLEMENTED;
 505     }
 506
 507     SERVER_START_REQ( unlock_file )
 508     {
 509         req->handle = wine_server_obj_handle( hFile );
 510         req->offset = offset->QuadPart;
 511         req->count  = count->QuadPart;
 512         status = wine_server_call( req );
 513     }
 514     SERVER_END_REQ;
 515     return status;
 516 }
 517
 518 /******************************************************************
 519  *              NtCreateNamedPipeFile    (NTDLL.@)
 520  */
 521 NTSTATUS WINAPI NtCreateNamedPipeFile( PHANDLE handle, ULONG access,
 522                                        POBJECT_ATTRIBUTES attr, PIO_STATUS_BLOCK iosb,
 523                                        ULONG sharing, ULONG dispo, ULONG options,
 524                                        ULONG pipe_type, ULONG read_mode,
 525                                        ULONG completion_mode, ULONG max_inst,
 526                                        ULONG inbound_quota, ULONG outbound_quota,
 527                                        PLARGE_INTEGER timeout)
 528 {
 529     return unix_funcs->NtCreateNamedPipeFile( handle, access, attr, iosb, sharing, dispo, options,
 530                                               pipe_type, read_mode, completion_mode, max_inst,
 531                                               inbound_quota, outbound_quota, timeout );
 532 }
 533
 534 /******************************************************************
 535  *              NtDeleteFile    (NTDLL.@)
 536  */
 537 NTSTATUS WINAPI NtDeleteFile( OBJECT_ATTRIBUTES *attr )
 538 {
 539     return unix_funcs->NtDeleteFile( attr );
 540 }
 541
 542 /******************************************************************
 543  *              NtCancelIoFileEx    (NTDLL.@)
 544  *
 545  *
 546  */
 547 NTSTATUS WINAPI NtCancelIoFileEx( HANDLE hFile, PIO_STATUS_BLOCK iosb, PIO_STATUS_BLOCK io_status )
 548 {
 549     TRACE("%p %p %p\n", hFile, iosb, io_status );
 550
 551     SERVER_START_REQ( cancel_async )
 552     {
 553         req->handle      = wine_server_obj_handle( hFile );
 554         req->iosb        = wine_server_client_ptr( iosb );
 555         req->only_thread = FALSE;
 556         io_status->u.Status = wine_server_call( req );
 557     }
 558     SERVER_END_REQ;
 559
 560     return io_status->u.Status;
 561 }
 562
 563 /******************************************************************
 564  *              NtCancelIoFile    (NTDLL.@)
 565  *
 566  *
 567  */
 568 NTSTATUS WINAPI NtCancelIoFile( HANDLE hFile, PIO_STATUS_BLOCK io_status )
 569 {
 570     TRACE("%p %p\n", hFile, io_status );
 571
 572     SERVER_START_REQ( cancel_async )
 573     {
 574         req->handle      = wine_server_obj_handle( hFile );
 575         req->iosb        = 0;
 576         req->only_thread = TRUE;
 577         io_status->u.Status = wine_server_call( req );
 578     }
 579     SERVER_END_REQ;
 580
 581     return io_status->u.Status;
 582 }
 583
 584 /******************************************************************************
 585  *  NtCreateMailslotFile        [NTDLL.@]
 586  *  ZwCreateMailslotFile        [NTDLL.@]
 587  */
 588 NTSTATUS WINAPI NtCreateMailslotFile( HANDLE *handle, ULONG access, OBJECT_ATTRIBUTES *attr,
 589                                       IO_STATUS_BLOCK *io, ULONG options, ULONG quota, ULONG msg_size,
 590                                       LARGE_INTEGER *timeout )
 591 {
 592     return unix_funcs->NtCreateMailslotFile( handle, access, attr, io, options, quota, msg_size, timeout );
 593 }