2 * Copyright 1999, 2000 Juergen Schmied
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.
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.
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
20 #include "wine/port.h"
30 #ifdef HAVE_SYS_ERRNO_H
31 #include <sys/errno.h>
33 #ifdef HAVE_LINUX_MAJOR_H
34 # include <linux/major.h>
36 #ifdef HAVE_SYS_STATVFS_H
37 # include <sys/statvfs.h>
39 #ifdef HAVE_SYS_PARAM_H
40 # include <sys/param.h>
42 #ifdef HAVE_SYS_TIME_H
43 # include <sys/time.h>
45 #ifdef HAVE_SYS_IOCTL_H
46 #include <sys/ioctl.h>
48 #ifdef HAVE_SYS_FILIO_H
49 # include <sys/filio.h>
54 #ifdef HAVE_SYS_POLL_H
57 #ifdef HAVE_SYS_SOCKET_H
58 #include <sys/socket.h>
66 #ifdef HAVE_SYS_MOUNT_H
67 # include <sys/mount.h>
69 #ifdef HAVE_SYS_STATFS_H
70 # include <sys/statfs.h>
73 #define NONAMELESSUNION
74 #define NONAMELESSSTRUCT
76 #define WIN32_NO_STATUS
77 #include "wine/unicode.h"
78 #include "wine/debug.h"
79 #include "wine/server.h"
80 #include "ntdll_misc.h"
84 #include "ddk/ntddser.h"
86 WINE_DEFAULT_DEBUG_CHANNEL(ntdll
);
88 mode_t FILE_umask
= 0;
90 #define SECSPERDAY 86400
91 #define SECS_1601_TO_1970 ((369 * 365 + 89) * (ULONGLONG)SECSPERDAY)
94 /**************************************************************************
95 * FILE_CreateFile (internal)
98 * Parameter set fully identical with NtCreateFile
100 static NTSTATUS
FILE_CreateFile( PHANDLE handle
, ACCESS_MASK access
, POBJECT_ATTRIBUTES attr
,
101 PIO_STATUS_BLOCK io
, PLARGE_INTEGER alloc_size
,
102 ULONG attributes
, ULONG sharing
, ULONG disposition
,
103 ULONG options
, PVOID ea_buffer
, ULONG ea_length
)
105 ANSI_STRING unix_name
;
108 TRACE("handle=%p access=%08x name=%s objattr=%08x root=%p sec=%p io=%p alloc_size=%p\n"
109 "attr=%08x sharing=%08x disp=%d options=%08x ea=%p.0x%08x\n",
110 handle
, access
, debugstr_us(attr
->ObjectName
), attr
->Attributes
,
111 attr
->RootDirectory
, attr
->SecurityDescriptor
, io
, alloc_size
,
112 attributes
, sharing
, disposition
, options
, ea_buffer
, ea_length
);
114 if (!attr
|| !attr
->ObjectName
) return STATUS_INVALID_PARAMETER
;
116 if (alloc_size
) FIXME( "alloc_size not supported\n" );
118 if (attr
->RootDirectory
||
119 (io
->u
.Status
= wine_nt_to_unix_file_name( attr
->ObjectName
, &unix_name
, disposition
,
120 !(attr
->Attributes
& OBJ_CASE_INSENSITIVE
) )) == STATUS_BAD_DEVICE_TYPE
)
122 SERVER_START_REQ( open_file_object
)
124 req
->access
= access
;
125 req
->attributes
= attr
->Attributes
;
126 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
127 req
->sharing
= sharing
;
128 req
->options
= options
;
129 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
130 io
->u
.Status
= wine_server_call( req
);
131 *handle
= wine_server_ptr_handle( reply
->handle
);
134 if (io
->u
.Status
== STATUS_SUCCESS
) io
->Information
= FILE_OPENED
;
138 if (io
->u
.Status
== STATUS_NO_SUCH_FILE
&&
139 disposition
!= FILE_OPEN
&& disposition
!= FILE_OVERWRITE
)
142 io
->u
.Status
= STATUS_SUCCESS
;
145 if (io
->u
.Status
== STATUS_SUCCESS
)
147 struct security_descriptor
*sd
= NULL
;
148 struct object_attributes objattr
;
152 objattr
.name_len
= 0;
155 io
->u
.Status
= NTDLL_create_struct_sd( attr
->SecurityDescriptor
, &sd
, &objattr
.sd_len
);
156 if (io
->u
.Status
!= STATUS_SUCCESS
)
158 RtlFreeAnsiString( &unix_name
);
163 SERVER_START_REQ( create_file
)
165 req
->access
= access
;
166 req
->attributes
= attr
->Attributes
;
167 req
->sharing
= sharing
;
168 req
->create
= disposition
;
169 req
->options
= options
;
170 req
->attrs
= attributes
;
171 wine_server_add_data( req
, &objattr
, sizeof(objattr
) );
172 if (objattr
.sd_len
) wine_server_add_data( req
, sd
, objattr
.sd_len
);
173 wine_server_add_data( req
, unix_name
.Buffer
, unix_name
.Length
);
174 io
->u
.Status
= wine_server_call( req
);
175 *handle
= wine_server_ptr_handle( reply
->handle
);
178 NTDLL_free_struct_sd( sd
);
179 RtlFreeAnsiString( &unix_name
);
181 else WARN("%s not found (%x)\n", debugstr_us(attr
->ObjectName
), io
->u
.Status
);
183 if (io
->u
.Status
== STATUS_SUCCESS
)
185 if (created
) io
->Information
= FILE_CREATED
;
186 else switch(disposition
)
189 io
->Information
= FILE_SUPERSEDED
;
192 io
->Information
= FILE_CREATED
;
196 io
->Information
= FILE_OPENED
;
199 case FILE_OVERWRITE_IF
:
200 io
->Information
= FILE_OVERWRITTEN
;
208 /**************************************************************************
209 * NtOpenFile [NTDLL.@]
210 * ZwOpenFile [NTDLL.@]
215 * handle [O] Variable that receives the file handle on return
216 * access [I] Access desired by the caller to the file
217 * attr [I] Structure describing the file to be opened
218 * io [O] Receives details about the result of the operation
219 * sharing [I] Type of shared access the caller requires
220 * options [I] Options for the file open
223 * Success: 0. FileHandle and IoStatusBlock are updated.
224 * Failure: An NTSTATUS error code describing the error.
226 NTSTATUS WINAPI
NtOpenFile( PHANDLE handle
, ACCESS_MASK access
,
227 POBJECT_ATTRIBUTES attr
, PIO_STATUS_BLOCK io
,
228 ULONG sharing
, ULONG options
)
230 return FILE_CreateFile( handle
, access
, attr
, io
, NULL
, 0,
231 sharing
, FILE_OPEN
, options
, NULL
, 0 );
234 /**************************************************************************
235 * NtCreateFile [NTDLL.@]
236 * ZwCreateFile [NTDLL.@]
238 * Either create a new file or directory, or open an existing file, device,
239 * directory or volume.
242 * handle [O] Points to a variable which receives the file handle on return
243 * access [I] Desired access to the file
244 * attr [I] Structure describing the file
245 * io [O] Receives information about the operation on return
246 * alloc_size [I] Initial size of the file in bytes
247 * attributes [I] Attributes to create the file with
248 * sharing [I] Type of shared access the caller would like to the file
249 * disposition [I] Specifies what to do, depending on whether the file already exists
250 * options [I] Options for creating a new file
251 * ea_buffer [I] Pointer to an extended attributes buffer
252 * ea_length [I] Length of ea_buffer
255 * Success: 0. handle and io are updated.
256 * Failure: An NTSTATUS error code describing the error.
258 NTSTATUS WINAPI
NtCreateFile( PHANDLE handle
, ACCESS_MASK access
, POBJECT_ATTRIBUTES attr
,
259 PIO_STATUS_BLOCK io
, PLARGE_INTEGER alloc_size
,
260 ULONG attributes
, ULONG sharing
, ULONG disposition
,
261 ULONG options
, PVOID ea_buffer
, ULONG ea_length
)
263 return FILE_CreateFile( handle
, access
, attr
, io
, alloc_size
, attributes
,
264 sharing
, disposition
, options
, ea_buffer
, ea_length
);
267 /***********************************************************************
268 * Asynchronous file I/O *
280 struct async_fileio io
;
282 unsigned int already
;
289 struct async_fileio io
;
291 unsigned int already
;
293 } async_fileio_write
;
296 /* callback for file I/O user APC */
297 static void WINAPI
fileio_apc( void *arg
, IO_STATUS_BLOCK
*io
, ULONG reserved
)
299 struct async_fileio
*async
= arg
;
300 if (async
->apc
) async
->apc( async
->apc_arg
, io
, reserved
);
301 RtlFreeHeap( GetProcessHeap(), 0, async
);
304 /***********************************************************************
305 * FILE_GetNtStatus(void)
307 * Retrieve the Nt Status code from errno.
308 * Try to be consistent with FILE_SetDosError().
310 NTSTATUS
FILE_GetNtStatus(void)
314 TRACE( "errno = %d\n", errno
);
317 case EAGAIN
: return STATUS_SHARING_VIOLATION
;
318 case EBADF
: return STATUS_INVALID_HANDLE
;
319 case EBUSY
: return STATUS_DEVICE_BUSY
;
320 case ENOSPC
: return STATUS_DISK_FULL
;
323 case EACCES
: return STATUS_ACCESS_DENIED
;
324 case ENOTDIR
: return STATUS_OBJECT_PATH_NOT_FOUND
;
325 case ENOENT
: return STATUS_OBJECT_NAME_NOT_FOUND
;
326 case EISDIR
: return STATUS_FILE_IS_A_DIRECTORY
;
328 case ENFILE
: return STATUS_TOO_MANY_OPENED_FILES
;
329 case EINVAL
: return STATUS_INVALID_PARAMETER
;
330 case ENOTEMPTY
: return STATUS_DIRECTORY_NOT_EMPTY
;
331 case EPIPE
: return STATUS_PIPE_DISCONNECTED
;
332 case EIO
: return STATUS_DEVICE_NOT_READY
;
334 case ENOMEDIUM
: return STATUS_NO_MEDIA_IN_DEVICE
;
336 case ENXIO
: return STATUS_NO_SUCH_DEVICE
;
338 case EOPNOTSUPP
:return STATUS_NOT_SUPPORTED
;
339 case ECONNRESET
:return STATUS_PIPE_DISCONNECTED
;
340 case EFAULT
: return STATUS_ACCESS_VIOLATION
;
341 case ESPIPE
: return STATUS_ILLEGAL_FUNCTION
;
342 case ENOEXEC
: /* ?? */
343 case EEXIST
: /* ?? */
345 FIXME( "Converting errno %d to STATUS_UNSUCCESSFUL\n", err
);
346 return STATUS_UNSUCCESSFUL
;
350 /***********************************************************************
351 * FILE_AsyncReadService (INTERNAL)
353 static NTSTATUS
FILE_AsyncReadService(void *user
, PIO_STATUS_BLOCK iosb
, NTSTATUS status
, void **apc
)
355 async_fileio_read
*fileio
= user
;
356 int fd
, needs_close
, result
;
360 case STATUS_ALERTED
: /* got some new data */
361 /* check to see if the data is ready (non-blocking) */
362 if ((status
= server_get_unix_fd( fileio
->io
.handle
, FILE_READ_DATA
, &fd
,
363 &needs_close
, NULL
, NULL
)))
366 result
= read(fd
, &fileio
->buffer
[fileio
->already
], fileio
->count
- fileio
->already
);
367 if (needs_close
) close( fd
);
371 if (errno
== EAGAIN
|| errno
== EINTR
)
372 status
= STATUS_PENDING
;
373 else /* check to see if the transfer is complete */
374 status
= FILE_GetNtStatus();
376 else if (result
== 0)
378 status
= fileio
->already
? STATUS_SUCCESS
: STATUS_PIPE_BROKEN
;
382 fileio
->already
+= result
;
383 if (fileio
->already
>= fileio
->count
|| fileio
->avail_mode
)
384 status
= STATUS_SUCCESS
;
387 /* if we only have to read the available data, and none is available,
388 * simply cancel the request. If data was available, it has been read
389 * while in by previous call (NtDelayExecution)
391 status
= (fileio
->avail_mode
) ? STATUS_SUCCESS
: STATUS_PENDING
;
397 case STATUS_IO_TIMEOUT
:
398 if (fileio
->already
) status
= STATUS_SUCCESS
;
401 if (status
!= STATUS_PENDING
)
403 iosb
->u
.Status
= status
;
404 iosb
->Information
= fileio
->already
;
412 int interval
; /* max interval between two bytes */
413 int total
; /* total timeout for the whole operation */
414 int end_time
; /* absolute time of end of operation */
417 /* retrieve the I/O timeouts to use for a given handle */
418 static NTSTATUS
get_io_timeouts( HANDLE handle
, enum server_fd_type type
, ULONG count
, BOOL is_read
,
419 struct io_timeouts
*timeouts
)
421 NTSTATUS status
= STATUS_SUCCESS
;
423 timeouts
->interval
= timeouts
->total
= -1;
429 /* GetCommTimeouts */
433 status
= NtDeviceIoControlFile( handle
, NULL
, NULL
, NULL
, &io
,
434 IOCTL_SERIAL_GET_TIMEOUTS
, NULL
, 0, &st
, sizeof(st
) );
439 if (st
.ReadIntervalTimeout
)
440 timeouts
->interval
= st
.ReadIntervalTimeout
;
442 if (st
.ReadTotalTimeoutMultiplier
|| st
.ReadTotalTimeoutConstant
)
444 timeouts
->total
= st
.ReadTotalTimeoutConstant
;
445 if (st
.ReadTotalTimeoutMultiplier
!= MAXDWORD
)
446 timeouts
->total
+= count
* st
.ReadTotalTimeoutMultiplier
;
448 else if (st
.ReadIntervalTimeout
== MAXDWORD
)
449 timeouts
->interval
= timeouts
->total
= 0;
453 if (st
.WriteTotalTimeoutMultiplier
|| st
.WriteTotalTimeoutConstant
)
455 timeouts
->total
= st
.WriteTotalTimeoutConstant
;
456 if (st
.WriteTotalTimeoutMultiplier
!= MAXDWORD
)
457 timeouts
->total
+= count
* st
.WriteTotalTimeoutMultiplier
;
462 case FD_TYPE_MAILSLOT
:
465 timeouts
->interval
= 0; /* return as soon as we got something */
466 SERVER_START_REQ( set_mailslot_info
)
468 req
->handle
= wine_server_obj_handle( handle
);
470 if (!(status
= wine_server_call( req
)) &&
471 reply
->read_timeout
!= TIMEOUT_INFINITE
)
472 timeouts
->total
= reply
->read_timeout
/ -10000;
480 if (is_read
) timeouts
->interval
= 0; /* return as soon as we got something */
485 if (timeouts
->total
!= -1) timeouts
->end_time
= NtGetTickCount() + timeouts
->total
;
486 return STATUS_SUCCESS
;
490 /* retrieve the timeout for the next wait, in milliseconds */
491 static inline int get_next_io_timeout( const struct io_timeouts
*timeouts
, ULONG already
)
495 if (timeouts
->total
!= -1)
497 ret
= timeouts
->end_time
- NtGetTickCount();
498 if (ret
< 0) ret
= 0;
500 if (already
&& timeouts
->interval
!= -1)
502 if (ret
== -1 || ret
> timeouts
->interval
) ret
= timeouts
->interval
;
508 /* retrieve the avail_mode flag for async reads */
509 static NTSTATUS
get_io_avail_mode( HANDLE handle
, enum server_fd_type type
, BOOL
*avail_mode
)
511 NTSTATUS status
= STATUS_SUCCESS
;
517 /* GetCommTimeouts */
521 status
= NtDeviceIoControlFile( handle
, NULL
, NULL
, NULL
, &io
,
522 IOCTL_SERIAL_GET_TIMEOUTS
, NULL
, 0, &st
, sizeof(st
) );
524 *avail_mode
= (!st
.ReadTotalTimeoutMultiplier
&&
525 !st
.ReadTotalTimeoutConstant
&&
526 st
.ReadIntervalTimeout
== MAXDWORD
);
529 case FD_TYPE_MAILSLOT
:
543 /******************************************************************************
544 * NtReadFile [NTDLL.@]
545 * ZwReadFile [NTDLL.@]
547 * Read from an open file handle.
550 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
551 * Event [I] Event to signal upon completion (or NULL)
552 * ApcRoutine [I] Callback to call upon completion (or NULL)
553 * ApcContext [I] Context for ApcRoutine (or NULL)
554 * IoStatusBlock [O] Receives information about the operation on return
555 * Buffer [O] Destination for the data read
556 * Length [I] Size of Buffer
557 * ByteOffset [O] Destination for the new file pointer position (or NULL)
558 * Key [O] Function unknown (may be NULL)
561 * Success: 0. IoStatusBlock is updated, and the Information member contains
562 * The number of bytes read.
563 * Failure: An NTSTATUS error code describing the error.
565 NTSTATUS WINAPI
NtReadFile(HANDLE hFile
, HANDLE hEvent
,
566 PIO_APC_ROUTINE apc
, void* apc_user
,
567 PIO_STATUS_BLOCK io_status
, void* buffer
, ULONG length
,
568 PLARGE_INTEGER offset
, PULONG key
)
570 int result
, unix_handle
, needs_close
, timeout_init_done
= 0;
571 unsigned int options
;
572 struct io_timeouts timeouts
;
575 enum server_fd_type type
;
576 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_user
;
578 TRACE("(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p),partial stub!\n",
579 hFile
,hEvent
,apc
,apc_user
,io_status
,buffer
,length
,offset
,key
);
581 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
583 status
= server_get_unix_fd( hFile
, FILE_READ_DATA
, &unix_handle
,
584 &needs_close
, &type
, &options
);
585 if (status
) return status
;
587 if (!virtual_check_buffer_for_write( buffer
, length
))
589 status
= STATUS_ACCESS_VIOLATION
;
593 if (type
== FD_TYPE_FILE
&& offset
&& offset
->QuadPart
!= (LONGLONG
)-2 /* FILE_USE_FILE_POINTER_POSITION */ )
595 /* async I/O doesn't make sense on regular files */
596 while ((result
= pread( unix_handle
, buffer
, length
, offset
->QuadPart
)) == -1)
600 status
= FILE_GetNtStatus();
604 if (options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
))
605 /* update file pointer position */
606 lseek( unix_handle
, offset
->QuadPart
+ result
, SEEK_SET
);
609 status
= total
? STATUS_SUCCESS
: STATUS_END_OF_FILE
;
615 if ((result
= read( unix_handle
, (char *)buffer
+ total
, length
- total
)) >= 0)
618 if (!result
|| total
== length
)
622 status
= STATUS_SUCCESS
;
629 status
= STATUS_END_OF_FILE
;
634 status
= STATUS_PIPE_BROKEN
;
638 else if (type
== FD_TYPE_FILE
) continue; /* no async I/O on regular files */
640 else if (errno
!= EAGAIN
)
642 if (errno
== EINTR
) continue;
643 if (!total
) status
= FILE_GetNtStatus();
647 if (!(options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
)))
649 async_fileio_read
*fileio
;
652 if ((status
= get_io_avail_mode( hFile
, type
, &avail_mode
)))
654 if (total
&& avail_mode
)
656 status
= STATUS_SUCCESS
;
660 if (!(fileio
= RtlAllocateHeap(GetProcessHeap(), 0, sizeof(*fileio
))))
662 status
= STATUS_NO_MEMORY
;
665 fileio
->io
.handle
= hFile
;
666 fileio
->io
.apc
= apc
;
667 fileio
->io
.apc_arg
= apc_user
;
668 fileio
->already
= total
;
669 fileio
->count
= length
;
670 fileio
->buffer
= buffer
;
671 fileio
->avail_mode
= avail_mode
;
673 SERVER_START_REQ( register_async
)
675 req
->type
= ASYNC_TYPE_READ
;
677 req
->async
.handle
= wine_server_obj_handle( hFile
);
678 req
->async
.event
= wine_server_obj_handle( hEvent
);
679 req
->async
.callback
= wine_server_client_ptr( FILE_AsyncReadService
);
680 req
->async
.iosb
= wine_server_client_ptr( io_status
);
681 req
->async
.arg
= wine_server_client_ptr( fileio
);
682 req
->async
.cvalue
= cvalue
;
683 status
= wine_server_call( req
);
687 if (status
!= STATUS_PENDING
) RtlFreeHeap( GetProcessHeap(), 0, fileio
);
690 else /* synchronous read, wait for the fd to become ready */
695 if (!timeout_init_done
)
697 timeout_init_done
= 1;
698 if ((status
= get_io_timeouts( hFile
, type
, length
, TRUE
, &timeouts
)))
700 if (hEvent
) NtResetEvent( hEvent
, NULL
);
702 timeout
= get_next_io_timeout( &timeouts
, total
);
704 pfd
.fd
= unix_handle
;
707 if (!timeout
|| !(ret
= poll( &pfd
, 1, timeout
)))
709 if (total
) /* return with what we got so far */
710 status
= STATUS_SUCCESS
;
712 status
= (type
== FD_TYPE_MAILSLOT
) ? STATUS_IO_TIMEOUT
: STATUS_TIMEOUT
;
715 if (ret
== -1 && errno
!= EINTR
)
717 status
= FILE_GetNtStatus();
720 /* will now restart the read */
725 if (cvalue
) NTDLL_AddCompletion( hFile
, cvalue
, status
, total
);
728 if (needs_close
) close( unix_handle
);
729 if (status
== STATUS_SUCCESS
)
731 io_status
->u
.Status
= status
;
732 io_status
->Information
= total
;
733 TRACE("= SUCCESS (%u)\n", total
);
734 if (hEvent
) NtSetEvent( hEvent
, NULL
);
735 if (apc
) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC
)apc
,
736 (ULONG_PTR
)apc_user
, (ULONG_PTR
)io_status
, 0 );
740 TRACE("= 0x%08x\n", status
);
741 if (status
!= STATUS_PENDING
&& hEvent
) NtResetEvent( hEvent
, NULL
);
747 /******************************************************************************
748 * NtReadFileScatter [NTDLL.@]
749 * ZwReadFileScatter [NTDLL.@]
751 NTSTATUS WINAPI
NtReadFileScatter( HANDLE file
, HANDLE event
, PIO_APC_ROUTINE apc
, void *apc_user
,
752 PIO_STATUS_BLOCK io_status
, FILE_SEGMENT_ELEMENT
*segments
,
753 ULONG length
, PLARGE_INTEGER offset
, PULONG key
)
755 size_t page_size
= getpagesize();
756 int result
, unix_handle
, needs_close
;
757 unsigned int options
;
759 ULONG pos
= 0, total
= 0;
760 enum server_fd_type type
;
761 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_user
;
763 TRACE( "(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p),partial stub!\n",
764 file
, event
, apc
, apc_user
, io_status
, segments
, length
, offset
, key
);
766 if (length
% page_size
) return STATUS_INVALID_PARAMETER
;
767 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
769 status
= server_get_unix_fd( file
, FILE_READ_DATA
, &unix_handle
,
770 &needs_close
, &type
, &options
);
771 if (status
) return status
;
773 if ((type
!= FD_TYPE_FILE
) ||
774 (options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
)) ||
775 !(options
& FILE_NO_INTERMEDIATE_BUFFERING
))
777 status
= STATUS_INVALID_PARAMETER
;
783 if (offset
&& offset
->QuadPart
!= (LONGLONG
)-2 /* FILE_USE_FILE_POINTER_POSITION */)
784 result
= pread( unix_handle
, (char *)segments
->Buffer
+ pos
,
785 page_size
- pos
, offset
->QuadPart
+ total
);
787 result
= read( unix_handle
, (char *)segments
->Buffer
+ pos
, page_size
- pos
);
791 if (errno
== EINTR
) continue;
792 status
= FILE_GetNtStatus();
797 status
= STATUS_END_OF_FILE
;
802 if ((pos
+= result
) == page_size
)
809 if (cvalue
) NTDLL_AddCompletion( file
, cvalue
, status
, total
);
812 if (needs_close
) close( unix_handle
);
813 if (status
== STATUS_SUCCESS
)
815 io_status
->u
.Status
= status
;
816 io_status
->Information
= total
;
817 TRACE("= SUCCESS (%u)\n", total
);
818 if (event
) NtSetEvent( event
, NULL
);
819 if (apc
) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC
)apc
,
820 (ULONG_PTR
)apc_user
, (ULONG_PTR
)io_status
, 0 );
824 TRACE("= 0x%08x\n", status
);
825 if (status
!= STATUS_PENDING
&& event
) NtResetEvent( event
, NULL
);
831 /***********************************************************************
832 * FILE_AsyncWriteService (INTERNAL)
834 static NTSTATUS
FILE_AsyncWriteService(void *user
, IO_STATUS_BLOCK
*iosb
, NTSTATUS status
, void **apc
)
836 async_fileio_write
*fileio
= user
;
837 int result
, fd
, needs_close
;
838 enum server_fd_type type
;
843 /* write some data (non-blocking) */
844 if ((status
= server_get_unix_fd( fileio
->io
.handle
, FILE_WRITE_DATA
, &fd
,
845 &needs_close
, &type
, NULL
)))
848 if (!fileio
->count
&& (type
== FD_TYPE_MAILSLOT
|| type
== FD_TYPE_PIPE
|| type
== FD_TYPE_SOCKET
))
849 result
= send( fd
, fileio
->buffer
, 0, 0 );
851 result
= write( fd
, &fileio
->buffer
[fileio
->already
], fileio
->count
- fileio
->already
);
853 if (needs_close
) close( fd
);
857 if (errno
== EAGAIN
|| errno
== EINTR
) status
= STATUS_PENDING
;
858 else status
= FILE_GetNtStatus();
862 fileio
->already
+= result
;
863 status
= (fileio
->already
< fileio
->count
) ? STATUS_PENDING
: STATUS_SUCCESS
;
868 case STATUS_IO_TIMEOUT
:
869 if (fileio
->already
) status
= STATUS_SUCCESS
;
872 if (status
!= STATUS_PENDING
)
874 iosb
->u
.Status
= status
;
875 iosb
->Information
= fileio
->already
;
881 /******************************************************************************
882 * NtWriteFile [NTDLL.@]
883 * ZwWriteFile [NTDLL.@]
885 * Write to an open file handle.
888 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
889 * Event [I] Event to signal upon completion (or NULL)
890 * ApcRoutine [I] Callback to call upon completion (or NULL)
891 * ApcContext [I] Context for ApcRoutine (or NULL)
892 * IoStatusBlock [O] Receives information about the operation on return
893 * Buffer [I] Source for the data to write
894 * Length [I] Size of Buffer
895 * ByteOffset [O] Destination for the new file pointer position (or NULL)
896 * Key [O] Function unknown (may be NULL)
899 * Success: 0. IoStatusBlock is updated, and the Information member contains
900 * The number of bytes written.
901 * Failure: An NTSTATUS error code describing the error.
903 NTSTATUS WINAPI
NtWriteFile(HANDLE hFile
, HANDLE hEvent
,
904 PIO_APC_ROUTINE apc
, void* apc_user
,
905 PIO_STATUS_BLOCK io_status
,
906 const void* buffer
, ULONG length
,
907 PLARGE_INTEGER offset
, PULONG key
)
909 int result
, unix_handle
, needs_close
, timeout_init_done
= 0;
910 unsigned int options
;
911 struct io_timeouts timeouts
;
914 enum server_fd_type type
;
915 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_user
;
917 TRACE("(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p)!\n",
918 hFile
,hEvent
,apc
,apc_user
,io_status
,buffer
,length
,offset
,key
);
920 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
922 status
= server_get_unix_fd( hFile
, FILE_WRITE_DATA
, &unix_handle
,
923 &needs_close
, &type
, &options
);
924 if (status
) return status
;
926 if (!virtual_check_buffer_for_read( buffer
, length
))
928 status
= STATUS_INVALID_USER_BUFFER
;
932 if (type
== FD_TYPE_FILE
&& offset
&& offset
->QuadPart
!= (LONGLONG
)-2 /* FILE_USE_FILE_POINTER_POSITION */ )
934 /* async I/O doesn't make sense on regular files */
935 while ((result
= pwrite( unix_handle
, buffer
, length
, offset
->QuadPart
)) == -1)
939 if (errno
== EFAULT
) status
= STATUS_INVALID_USER_BUFFER
;
940 else status
= FILE_GetNtStatus();
945 if (options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
))
946 /* update file pointer position */
947 lseek( unix_handle
, offset
->QuadPart
+ result
, SEEK_SET
);
950 status
= STATUS_SUCCESS
;
956 /* zero-length writes on sockets may not work with plain write(2) */
957 if (!length
&& (type
== FD_TYPE_MAILSLOT
|| type
== FD_TYPE_PIPE
|| type
== FD_TYPE_SOCKET
))
958 result
= send( unix_handle
, buffer
, 0, 0 );
960 result
= write( unix_handle
, (const char *)buffer
+ total
, length
- total
);
967 status
= STATUS_SUCCESS
;
970 if (type
== FD_TYPE_FILE
) continue; /* no async I/O on regular files */
972 else if (errno
!= EAGAIN
)
974 if (errno
== EINTR
) continue;
977 if (errno
== EFAULT
) status
= STATUS_INVALID_USER_BUFFER
;
978 else status
= FILE_GetNtStatus();
983 if (!(options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
)))
985 async_fileio_write
*fileio
;
987 if (!(fileio
= RtlAllocateHeap(GetProcessHeap(), 0, sizeof(*fileio
))))
989 status
= STATUS_NO_MEMORY
;
992 fileio
->io
.handle
= hFile
;
993 fileio
->io
.apc
= apc
;
994 fileio
->io
.apc_arg
= apc_user
;
995 fileio
->already
= total
;
996 fileio
->count
= length
;
997 fileio
->buffer
= buffer
;
999 SERVER_START_REQ( register_async
)
1001 req
->type
= ASYNC_TYPE_WRITE
;
1002 req
->count
= length
;
1003 req
->async
.handle
= wine_server_obj_handle( hFile
);
1004 req
->async
.event
= wine_server_obj_handle( hEvent
);
1005 req
->async
.callback
= wine_server_client_ptr( FILE_AsyncWriteService
);
1006 req
->async
.iosb
= wine_server_client_ptr( io_status
);
1007 req
->async
.arg
= wine_server_client_ptr( fileio
);
1008 req
->async
.cvalue
= cvalue
;
1009 status
= wine_server_call( req
);
1013 if (status
!= STATUS_PENDING
) RtlFreeHeap( GetProcessHeap(), 0, fileio
);
1016 else /* synchronous write, wait for the fd to become ready */
1021 if (!timeout_init_done
)
1023 timeout_init_done
= 1;
1024 if ((status
= get_io_timeouts( hFile
, type
, length
, FALSE
, &timeouts
)))
1026 if (hEvent
) NtResetEvent( hEvent
, NULL
);
1028 timeout
= get_next_io_timeout( &timeouts
, total
);
1030 pfd
.fd
= unix_handle
;
1031 pfd
.events
= POLLOUT
;
1033 if (!timeout
|| !(ret
= poll( &pfd
, 1, timeout
)))
1035 /* return with what we got so far */
1036 status
= total
? STATUS_SUCCESS
: STATUS_TIMEOUT
;
1039 if (ret
== -1 && errno
!= EINTR
)
1041 status
= FILE_GetNtStatus();
1044 /* will now restart the write */
1049 if (cvalue
) NTDLL_AddCompletion( hFile
, cvalue
, status
, total
);
1052 if (needs_close
) close( unix_handle
);
1053 if (status
== STATUS_SUCCESS
)
1055 io_status
->u
.Status
= status
;
1056 io_status
->Information
= total
;
1057 TRACE("= SUCCESS (%u)\n", total
);
1058 if (hEvent
) NtSetEvent( hEvent
, NULL
);
1059 if (apc
) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC
)apc
,
1060 (ULONG_PTR
)apc_user
, (ULONG_PTR
)io_status
, 0 );
1064 TRACE("= 0x%08x\n", status
);
1065 if (status
!= STATUS_PENDING
&& hEvent
) NtResetEvent( hEvent
, NULL
);
1071 /******************************************************************************
1072 * NtWriteFileGather [NTDLL.@]
1073 * ZwWriteFileGather [NTDLL.@]
1075 NTSTATUS WINAPI
NtWriteFileGather( HANDLE file
, HANDLE event
, PIO_APC_ROUTINE apc
, void *apc_user
,
1076 PIO_STATUS_BLOCK io_status
, FILE_SEGMENT_ELEMENT
*segments
,
1077 ULONG length
, PLARGE_INTEGER offset
, PULONG key
)
1079 size_t page_size
= getpagesize();
1080 int result
, unix_handle
, needs_close
;
1081 unsigned int options
;
1083 ULONG pos
= 0, total
= 0;
1084 enum server_fd_type type
;
1085 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_user
;
1087 TRACE( "(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p),partial stub!\n",
1088 file
, event
, apc
, apc_user
, io_status
, segments
, length
, offset
, key
);
1090 if (length
% page_size
) return STATUS_INVALID_PARAMETER
;
1091 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
1093 status
= server_get_unix_fd( file
, FILE_WRITE_DATA
, &unix_handle
,
1094 &needs_close
, &type
, &options
);
1095 if (status
) return status
;
1097 if ((type
!= FD_TYPE_FILE
) ||
1098 (options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
)) ||
1099 !(options
& FILE_NO_INTERMEDIATE_BUFFERING
))
1101 status
= STATUS_INVALID_PARAMETER
;
1107 if (offset
&& offset
->QuadPart
!= (LONGLONG
)-2 /* FILE_USE_FILE_POINTER_POSITION */)
1108 result
= pwrite( unix_handle
, (char *)segments
->Buffer
+ pos
,
1109 page_size
- pos
, offset
->QuadPart
+ total
);
1111 result
= write( unix_handle
, (char *)segments
->Buffer
+ pos
, page_size
- pos
);
1115 if (errno
== EINTR
) continue;
1116 if (errno
== EFAULT
)
1118 status
= STATUS_INVALID_USER_BUFFER
;
1121 status
= FILE_GetNtStatus();
1126 status
= STATUS_DISK_FULL
;
1131 if ((pos
+= result
) == page_size
)
1138 if (cvalue
) NTDLL_AddCompletion( file
, cvalue
, status
, total
);
1141 if (needs_close
) close( unix_handle
);
1142 if (status
== STATUS_SUCCESS
)
1144 io_status
->u
.Status
= status
;
1145 io_status
->Information
= total
;
1146 TRACE("= SUCCESS (%u)\n", total
);
1147 if (event
) NtSetEvent( event
, NULL
);
1148 if (apc
) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC
)apc
,
1149 (ULONG_PTR
)apc_user
, (ULONG_PTR
)io_status
, 0 );
1153 TRACE("= 0x%08x\n", status
);
1154 if (status
!= STATUS_PENDING
&& event
) NtResetEvent( event
, NULL
);
1162 HANDLE handle
; /* handle to the device */
1163 HANDLE event
; /* async event */
1164 void *buffer
; /* buffer for output */
1165 ULONG size
; /* size of buffer */
1166 PIO_APC_ROUTINE apc
; /* user apc params */
1170 /* callback for ioctl user APC */
1171 static void WINAPI
ioctl_apc( void *arg
, IO_STATUS_BLOCK
*io
, ULONG reserved
)
1173 struct async_ioctl
*async
= arg
;
1174 if (async
->apc
) async
->apc( async
->apc_arg
, io
, reserved
);
1175 RtlFreeHeap( GetProcessHeap(), 0, async
);
1178 /* callback for ioctl async I/O completion */
1179 static NTSTATUS
ioctl_completion( void *arg
, IO_STATUS_BLOCK
*io
, NTSTATUS status
, void **apc
)
1181 struct async_ioctl
*async
= arg
;
1183 if (status
== STATUS_ALERTED
)
1185 SERVER_START_REQ( get_ioctl_result
)
1187 req
->handle
= wine_server_obj_handle( async
->handle
);
1188 req
->user_arg
= wine_server_client_ptr( async
);
1189 wine_server_set_reply( req
, async
->buffer
, async
->size
);
1190 if (!(status
= wine_server_call( req
)))
1191 io
->Information
= wine_server_reply_size( reply
);
1195 if (status
!= STATUS_PENDING
)
1197 io
->u
.Status
= status
;
1198 if (async
->apc
|| async
->event
) *apc
= ioctl_apc
;
1203 /* do a ioctl call through the server */
1204 static NTSTATUS
server_ioctl_file( HANDLE handle
, HANDLE event
,
1205 PIO_APC_ROUTINE apc
, PVOID apc_context
,
1206 IO_STATUS_BLOCK
*io
, ULONG code
,
1207 const void *in_buffer
, ULONG in_size
,
1208 PVOID out_buffer
, ULONG out_size
)
1210 struct async_ioctl
*async
;
1214 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_context
;
1216 if (!(async
= RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*async
) )))
1217 return STATUS_NO_MEMORY
;
1218 async
->handle
= handle
;
1219 async
->event
= event
;
1220 async
->buffer
= out_buffer
;
1221 async
->size
= out_size
;
1223 async
->apc_arg
= apc_context
;
1225 SERVER_START_REQ( ioctl
)
1228 req
->blocking
= !apc
&& !event
;
1229 req
->async
.handle
= wine_server_obj_handle( handle
);
1230 req
->async
.callback
= wine_server_client_ptr( ioctl_completion
);
1231 req
->async
.iosb
= wine_server_client_ptr( io
);
1232 req
->async
.arg
= wine_server_client_ptr( async
);
1233 req
->async
.event
= wine_server_obj_handle( event
);
1234 req
->async
.cvalue
= cvalue
;
1235 wine_server_add_data( req
, in_buffer
, in_size
);
1236 wine_server_set_reply( req
, out_buffer
, out_size
);
1237 if (!(status
= wine_server_call( req
)))
1238 io
->Information
= wine_server_reply_size( reply
);
1239 wait_handle
= wine_server_ptr_handle( reply
->wait
);
1240 options
= reply
->options
;
1244 if (status
== STATUS_NOT_SUPPORTED
)
1245 FIXME("Unsupported ioctl %x (device=%x access=%x func=%x method=%x)\n",
1246 code
, code
>> 16, (code
>> 14) & 3, (code
>> 2) & 0xfff, code
& 3);
1248 if (status
!= STATUS_PENDING
) RtlFreeHeap( GetProcessHeap(), 0, async
);
1252 NtWaitForSingleObject( wait_handle
, (options
& FILE_SYNCHRONOUS_IO_ALERT
), NULL
);
1253 status
= io
->u
.Status
;
1254 NtClose( wait_handle
);
1255 RtlFreeHeap( GetProcessHeap(), 0, async
);
1262 /**************************************************************************
1263 * NtDeviceIoControlFile [NTDLL.@]
1264 * ZwDeviceIoControlFile [NTDLL.@]
1266 * Perform an I/O control operation on an open file handle.
1269 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1270 * event [I] Event to signal upon completion (or NULL)
1271 * apc [I] Callback to call upon completion (or NULL)
1272 * apc_context [I] Context for ApcRoutine (or NULL)
1273 * io [O] Receives information about the operation on return
1274 * code [I] Control code for the operation to perform
1275 * in_buffer [I] Source for any input data required (or NULL)
1276 * in_size [I] Size of InputBuffer
1277 * out_buffer [O] Source for any output data returned (or NULL)
1278 * out_size [I] Size of OutputBuffer
1281 * Success: 0. IoStatusBlock is updated.
1282 * Failure: An NTSTATUS error code describing the error.
1284 NTSTATUS WINAPI
NtDeviceIoControlFile(HANDLE handle
, HANDLE event
,
1285 PIO_APC_ROUTINE apc
, PVOID apc_context
,
1286 PIO_STATUS_BLOCK io
, ULONG code
,
1287 PVOID in_buffer
, ULONG in_size
,
1288 PVOID out_buffer
, ULONG out_size
)
1290 ULONG device
= (code
>> 16);
1291 NTSTATUS status
= STATUS_NOT_SUPPORTED
;
1293 TRACE("(%p,%p,%p,%p,%p,0x%08x,%p,0x%08x,%p,0x%08x)\n",
1294 handle
, event
, apc
, apc_context
, io
, code
,
1295 in_buffer
, in_size
, out_buffer
, out_size
);
1299 case FILE_DEVICE_DISK
:
1300 case FILE_DEVICE_CD_ROM
:
1301 case FILE_DEVICE_DVD
:
1302 case FILE_DEVICE_CONTROLLER
:
1303 case FILE_DEVICE_MASS_STORAGE
:
1304 status
= CDROM_DeviceIoControl(handle
, event
, apc
, apc_context
, io
, code
,
1305 in_buffer
, in_size
, out_buffer
, out_size
);
1307 case FILE_DEVICE_SERIAL_PORT
:
1308 status
= COMM_DeviceIoControl(handle
, event
, apc
, apc_context
, io
, code
,
1309 in_buffer
, in_size
, out_buffer
, out_size
);
1311 case FILE_DEVICE_TAPE
:
1312 status
= TAPE_DeviceIoControl(handle
, event
, apc
, apc_context
, io
, code
,
1313 in_buffer
, in_size
, out_buffer
, out_size
);
1317 if (status
== STATUS_NOT_SUPPORTED
|| status
== STATUS_BAD_DEVICE_TYPE
)
1318 status
= server_ioctl_file( handle
, event
, apc
, apc_context
, io
, code
,
1319 in_buffer
, in_size
, out_buffer
, out_size
);
1321 if (status
!= STATUS_PENDING
) io
->u
.Status
= status
;
1326 /**************************************************************************
1327 * NtFsControlFile [NTDLL.@]
1328 * ZwFsControlFile [NTDLL.@]
1330 * Perform a file system control operation on an open file handle.
1333 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1334 * event [I] Event to signal upon completion (or NULL)
1335 * apc [I] Callback to call upon completion (or NULL)
1336 * apc_context [I] Context for ApcRoutine (or NULL)
1337 * io [O] Receives information about the operation on return
1338 * code [I] Control code for the operation to perform
1339 * in_buffer [I] Source for any input data required (or NULL)
1340 * in_size [I] Size of InputBuffer
1341 * out_buffer [O] Source for any output data returned (or NULL)
1342 * out_size [I] Size of OutputBuffer
1345 * Success: 0. IoStatusBlock is updated.
1346 * Failure: An NTSTATUS error code describing the error.
1348 NTSTATUS WINAPI
NtFsControlFile(HANDLE handle
, HANDLE event
, PIO_APC_ROUTINE apc
,
1349 PVOID apc_context
, PIO_STATUS_BLOCK io
, ULONG code
,
1350 PVOID in_buffer
, ULONG in_size
, PVOID out_buffer
, ULONG out_size
)
1354 TRACE("(%p,%p,%p,%p,%p,0x%08x,%p,0x%08x,%p,0x%08x)\n",
1355 handle
, event
, apc
, apc_context
, io
, code
,
1356 in_buffer
, in_size
, out_buffer
, out_size
);
1358 if (!io
) return STATUS_INVALID_PARAMETER
;
1362 case FSCTL_DISMOUNT_VOLUME
:
1363 status
= server_ioctl_file( handle
, event
, apc
, apc_context
, io
, code
,
1364 in_buffer
, in_size
, out_buffer
, out_size
);
1365 if (!status
) status
= DIR_unmount_device( handle
);
1368 case FSCTL_PIPE_PEEK
:
1370 FILE_PIPE_PEEK_BUFFER
*buffer
= out_buffer
;
1371 int avail
= 0, fd
, needs_close
;
1373 if (out_size
< FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER
, Data
))
1375 status
= STATUS_INFO_LENGTH_MISMATCH
;
1379 if ((status
= server_get_unix_fd( handle
, FILE_READ_DATA
, &fd
, &needs_close
, NULL
, NULL
)))
1383 if (ioctl( fd
, FIONREAD
, &avail
) != 0)
1385 TRACE("FIONREAD failed reason: %s\n",strerror(errno
));
1386 if (needs_close
) close( fd
);
1387 status
= FILE_GetNtStatus();
1391 if (!avail
) /* check for closed pipe */
1393 struct pollfd pollfd
;
1397 pollfd
.events
= POLLIN
;
1399 ret
= poll( &pollfd
, 1, 0 );
1400 if (ret
== -1 || (ret
== 1 && (pollfd
.revents
& (POLLHUP
|POLLERR
))))
1402 if (needs_close
) close( fd
);
1403 status
= STATUS_PIPE_BROKEN
;
1407 buffer
->NamedPipeState
= 0; /* FIXME */
1408 buffer
->ReadDataAvailable
= avail
;
1409 buffer
->NumberOfMessages
= 0; /* FIXME */
1410 buffer
->MessageLength
= 0; /* FIXME */
1411 io
->Information
= FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER
, Data
);
1412 status
= STATUS_SUCCESS
;
1415 ULONG data_size
= out_size
- FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER
, Data
);
1418 int res
= recv( fd
, buffer
->Data
, data_size
, MSG_PEEK
);
1419 if (res
>= 0) io
->Information
+= res
;
1422 if (needs_close
) close( fd
);
1426 case FSCTL_PIPE_DISCONNECT
:
1427 status
= server_ioctl_file( handle
, event
, apc
, apc_context
, io
, code
,
1428 in_buffer
, in_size
, out_buffer
, out_size
);
1431 int fd
= server_remove_fd_from_cache( handle
);
1432 if (fd
!= -1) close( fd
);
1436 case FSCTL_PIPE_IMPERSONATE
:
1437 FIXME("FSCTL_PIPE_IMPERSONATE: impersonating self\n");
1438 status
= RtlImpersonateSelf( SecurityImpersonation
);
1441 case FSCTL_LOCK_VOLUME
:
1442 case FSCTL_UNLOCK_VOLUME
:
1443 FIXME("stub! return success - Unsupported fsctl %x (device=%x access=%x func=%x method=%x)\n",
1444 code
, code
>> 16, (code
>> 14) & 3, (code
>> 2) & 0xfff, code
& 3);
1445 status
= STATUS_SUCCESS
;
1448 case FSCTL_PIPE_LISTEN
:
1449 case FSCTL_PIPE_WAIT
:
1451 status
= server_ioctl_file( handle
, event
, apc
, apc_context
, io
, code
,
1452 in_buffer
, in_size
, out_buffer
, out_size
);
1456 if (status
!= STATUS_PENDING
) io
->u
.Status
= status
;
1460 /******************************************************************************
1461 * NtSetVolumeInformationFile [NTDLL.@]
1462 * ZwSetVolumeInformationFile [NTDLL.@]
1464 * Set volume information for an open file handle.
1467 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1468 * IoStatusBlock [O] Receives information about the operation on return
1469 * FsInformation [I] Source for volume information
1470 * Length [I] Size of FsInformation
1471 * FsInformationClass [I] Type of volume information to set
1474 * Success: 0. IoStatusBlock is updated.
1475 * Failure: An NTSTATUS error code describing the error.
1477 NTSTATUS WINAPI
NtSetVolumeInformationFile(
1478 IN HANDLE FileHandle
,
1479 PIO_STATUS_BLOCK IoStatusBlock
,
1480 PVOID FsInformation
,
1482 FS_INFORMATION_CLASS FsInformationClass
)
1484 FIXME("(%p,%p,%p,0x%08x,0x%08x) stub\n",
1485 FileHandle
,IoStatusBlock
,FsInformation
,Length
,FsInformationClass
);
1489 /******************************************************************************
1490 * NtQueryInformationFile [NTDLL.@]
1491 * ZwQueryInformationFile [NTDLL.@]
1493 * Get information about an open file handle.
1496 * hFile [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1497 * io [O] Receives information about the operation on return
1498 * ptr [O] Destination for file information
1499 * len [I] Size of FileInformation
1500 * class [I] Type of file information to get
1503 * Success: 0. IoStatusBlock and FileInformation are updated.
1504 * Failure: An NTSTATUS error code describing the error.
1506 NTSTATUS WINAPI
NtQueryInformationFile( HANDLE hFile
, PIO_STATUS_BLOCK io
,
1507 PVOID ptr
, LONG len
, FILE_INFORMATION_CLASS
class )
1509 static const size_t info_sizes
[] =
1512 sizeof(FILE_DIRECTORY_INFORMATION
), /* FileDirectoryInformation */
1513 sizeof(FILE_FULL_DIRECTORY_INFORMATION
), /* FileFullDirectoryInformation */
1514 sizeof(FILE_BOTH_DIRECTORY_INFORMATION
), /* FileBothDirectoryInformation */
1515 sizeof(FILE_BASIC_INFORMATION
), /* FileBasicInformation */
1516 sizeof(FILE_STANDARD_INFORMATION
), /* FileStandardInformation */
1517 sizeof(FILE_INTERNAL_INFORMATION
), /* FileInternalInformation */
1518 sizeof(FILE_EA_INFORMATION
), /* FileEaInformation */
1519 sizeof(FILE_ACCESS_INFORMATION
), /* FileAccessInformation */
1520 sizeof(FILE_NAME_INFORMATION
)-sizeof(WCHAR
), /* FileNameInformation */
1521 sizeof(FILE_RENAME_INFORMATION
)-sizeof(WCHAR
), /* FileRenameInformation */
1522 0, /* FileLinkInformation */
1523 sizeof(FILE_NAMES_INFORMATION
)-sizeof(WCHAR
), /* FileNamesInformation */
1524 sizeof(FILE_DISPOSITION_INFORMATION
), /* FileDispositionInformation */
1525 sizeof(FILE_POSITION_INFORMATION
), /* FilePositionInformation */
1526 sizeof(FILE_FULL_EA_INFORMATION
), /* FileFullEaInformation */
1527 sizeof(FILE_MODE_INFORMATION
), /* FileModeInformation */
1528 sizeof(FILE_ALIGNMENT_INFORMATION
), /* FileAlignmentInformation */
1529 sizeof(FILE_ALL_INFORMATION
)-sizeof(WCHAR
), /* FileAllInformation */
1530 sizeof(FILE_ALLOCATION_INFORMATION
), /* FileAllocationInformation */
1531 sizeof(FILE_END_OF_FILE_INFORMATION
), /* FileEndOfFileInformation */
1532 0, /* FileAlternateNameInformation */
1533 sizeof(FILE_STREAM_INFORMATION
)-sizeof(WCHAR
), /* FileStreamInformation */
1534 0, /* FilePipeInformation */
1535 sizeof(FILE_PIPE_LOCAL_INFORMATION
), /* FilePipeLocalInformation */
1536 0, /* FilePipeRemoteInformation */
1537 sizeof(FILE_MAILSLOT_QUERY_INFORMATION
), /* FileMailslotQueryInformation */
1538 0, /* FileMailslotSetInformation */
1539 0, /* FileCompressionInformation */
1540 0, /* FileObjectIdInformation */
1541 0, /* FileCompletionInformation */
1542 0, /* FileMoveClusterInformation */
1543 0, /* FileQuotaInformation */
1544 0, /* FileReparsePointInformation */
1545 0, /* FileNetworkOpenInformation */
1546 0, /* FileAttributeTagInformation */
1547 0 /* FileTrackingInformation */
1551 int fd
, needs_close
= FALSE
;
1553 TRACE("(%p,%p,%p,0x%08x,0x%08x)\n", hFile
, io
, ptr
, len
, class);
1555 io
->Information
= 0;
1557 if (class <= 0 || class >= FileMaximumInformation
)
1558 return io
->u
.Status
= STATUS_INVALID_INFO_CLASS
;
1559 if (!info_sizes
[class])
1561 FIXME("Unsupported class (%d)\n", class);
1562 return io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1564 if (len
< info_sizes
[class])
1565 return io
->u
.Status
= STATUS_INFO_LENGTH_MISMATCH
;
1567 if (class != FilePipeLocalInformation
)
1569 if ((io
->u
.Status
= server_get_unix_fd( hFile
, 0, &fd
, &needs_close
, NULL
, NULL
)))
1570 return io
->u
.Status
;
1575 case FileBasicInformation
:
1577 FILE_BASIC_INFORMATION
*info
= ptr
;
1579 if (fstat( fd
, &st
) == -1)
1580 io
->u
.Status
= FILE_GetNtStatus();
1581 else if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1582 io
->u
.Status
= STATUS_INVALID_INFO_CLASS
;
1585 if (S_ISDIR(st
.st_mode
)) info
->FileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1586 else info
->FileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1587 if (!(st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)))
1588 info
->FileAttributes
|= FILE_ATTRIBUTE_READONLY
;
1589 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->CreationTime
);
1590 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->LastWriteTime
);
1591 RtlSecondsSince1970ToTime( st
.st_ctime
, &info
->ChangeTime
);
1592 RtlSecondsSince1970ToTime( st
.st_atime
, &info
->LastAccessTime
);
1593 #ifdef HAVE_STRUCT_STAT_ST_MTIM
1594 info
->CreationTime
.QuadPart
+= st
.st_mtim
.tv_nsec
/ 100;
1595 info
->LastWriteTime
.QuadPart
+= st
.st_mtim
.tv_nsec
/ 100;
1597 #ifdef HAVE_STRUCT_STAT_ST_CTIM
1598 info
->ChangeTime
.QuadPart
+= st
.st_ctim
.tv_nsec
/ 100;
1600 #ifdef HAVE_STRUCT_STAT_ST_ATIM
1601 info
->LastAccessTime
.QuadPart
+= st
.st_atim
.tv_nsec
/ 100;
1606 case FileStandardInformation
:
1608 FILE_STANDARD_INFORMATION
*info
= ptr
;
1610 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1613 if ((info
->Directory
= S_ISDIR(st
.st_mode
)))
1615 info
->AllocationSize
.QuadPart
= 0;
1616 info
->EndOfFile
.QuadPart
= 0;
1617 info
->NumberOfLinks
= 1;
1618 info
->DeletePending
= FALSE
;
1622 info
->AllocationSize
.QuadPart
= (ULONGLONG
)st
.st_blocks
* 512;
1623 info
->EndOfFile
.QuadPart
= st
.st_size
;
1624 info
->NumberOfLinks
= st
.st_nlink
;
1625 info
->DeletePending
= FALSE
; /* FIXME */
1630 case FilePositionInformation
:
1632 FILE_POSITION_INFORMATION
*info
= ptr
;
1633 off_t res
= lseek( fd
, 0, SEEK_CUR
);
1634 if (res
== (off_t
)-1) io
->u
.Status
= FILE_GetNtStatus();
1635 else info
->CurrentByteOffset
.QuadPart
= res
;
1638 case FileInternalInformation
:
1640 FILE_INTERNAL_INFORMATION
*info
= ptr
;
1642 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1643 else info
->IndexNumber
.QuadPart
= st
.st_ino
;
1646 case FileEaInformation
:
1648 FILE_EA_INFORMATION
*info
= ptr
;
1652 case FileEndOfFileInformation
:
1654 FILE_END_OF_FILE_INFORMATION
*info
= ptr
;
1656 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1657 else info
->EndOfFile
.QuadPart
= S_ISDIR(st
.st_mode
) ? 0 : st
.st_size
;
1660 case FileAllInformation
:
1662 FILE_ALL_INFORMATION
*info
= ptr
;
1664 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1665 else if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1666 io
->u
.Status
= STATUS_INVALID_INFO_CLASS
;
1669 if ((info
->StandardInformation
.Directory
= S_ISDIR(st
.st_mode
)))
1671 info
->BasicInformation
.FileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1672 info
->StandardInformation
.AllocationSize
.QuadPart
= 0;
1673 info
->StandardInformation
.EndOfFile
.QuadPart
= 0;
1674 info
->StandardInformation
.NumberOfLinks
= 1;
1675 info
->StandardInformation
.DeletePending
= FALSE
;
1679 info
->BasicInformation
.FileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1680 info
->StandardInformation
.AllocationSize
.QuadPart
= (ULONGLONG
)st
.st_blocks
* 512;
1681 info
->StandardInformation
.EndOfFile
.QuadPart
= st
.st_size
;
1682 info
->StandardInformation
.NumberOfLinks
= st
.st_nlink
;
1683 info
->StandardInformation
.DeletePending
= FALSE
; /* FIXME */
1685 if (!(st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)))
1686 info
->BasicInformation
.FileAttributes
|= FILE_ATTRIBUTE_READONLY
;
1687 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->BasicInformation
.CreationTime
);
1688 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->BasicInformation
.LastWriteTime
);
1689 RtlSecondsSince1970ToTime( st
.st_ctime
, &info
->BasicInformation
.ChangeTime
);
1690 RtlSecondsSince1970ToTime( st
.st_atime
, &info
->BasicInformation
.LastAccessTime
);
1691 #ifdef HAVE_STRUCT_STAT_ST_MTIM
1692 info
->BasicInformation
.CreationTime
.QuadPart
+= st
.st_mtim
.tv_nsec
/ 100;
1693 info
->BasicInformation
.LastWriteTime
.QuadPart
+= st
.st_mtim
.tv_nsec
/ 100;
1695 #ifdef HAVE_STRUCT_STAT_ST_CTIM
1696 info
->BasicInformation
.ChangeTime
.QuadPart
+= st
.st_ctim
.tv_nsec
/ 100;
1698 #ifdef HAVE_STRUCT_STAT_ST_ATIM
1699 info
->BasicInformation
.LastAccessTime
.QuadPart
+= st
.st_atim
.tv_nsec
/ 100;
1701 info
->InternalInformation
.IndexNumber
.QuadPart
= st
.st_ino
;
1702 info
->EaInformation
.EaSize
= 0;
1703 info
->AccessInformation
.AccessFlags
= 0; /* FIXME */
1704 info
->PositionInformation
.CurrentByteOffset
.QuadPart
= lseek( fd
, 0, SEEK_CUR
);
1705 info
->ModeInformation
.Mode
= 0; /* FIXME */
1706 info
->AlignmentInformation
.AlignmentRequirement
= 1; /* FIXME */
1707 info
->NameInformation
.FileNameLength
= 0;
1708 io
->Information
= sizeof(*info
) - sizeof(WCHAR
);
1712 case FileMailslotQueryInformation
:
1714 FILE_MAILSLOT_QUERY_INFORMATION
*info
= ptr
;
1716 SERVER_START_REQ( set_mailslot_info
)
1718 req
->handle
= wine_server_obj_handle( hFile
);
1720 io
->u
.Status
= wine_server_call( req
);
1721 if( io
->u
.Status
== STATUS_SUCCESS
)
1723 info
->MaximumMessageSize
= reply
->max_msgsize
;
1724 info
->MailslotQuota
= 0;
1725 info
->NextMessageSize
= 0;
1726 info
->MessagesAvailable
= 0;
1727 info
->ReadTimeout
.QuadPart
= reply
->read_timeout
;
1734 ULONG size
= info
->MaximumMessageSize
? info
->MaximumMessageSize
: 0x10000;
1735 if (size
> 0x10000) size
= 0x10000;
1736 if ((tmpbuf
= RtlAllocateHeap( GetProcessHeap(), 0, size
)))
1738 int fd
, needs_close
;
1739 if (!server_get_unix_fd( hFile
, FILE_READ_DATA
, &fd
, &needs_close
, NULL
, NULL
))
1741 int res
= recv( fd
, tmpbuf
, size
, MSG_PEEK
);
1742 info
->MessagesAvailable
= (res
> 0);
1743 info
->NextMessageSize
= (res
>= 0) ? res
: MAILSLOT_NO_MESSAGE
;
1744 if (needs_close
) close( fd
);
1746 RtlFreeHeap( GetProcessHeap(), 0, tmpbuf
);
1751 case FilePipeLocalInformation
:
1753 FILE_PIPE_LOCAL_INFORMATION
* pli
= ptr
;
1755 SERVER_START_REQ( get_named_pipe_info
)
1757 req
->handle
= wine_server_obj_handle( hFile
);
1758 if (!(io
->u
.Status
= wine_server_call( req
)))
1760 pli
->NamedPipeType
= (reply
->flags
& NAMED_PIPE_MESSAGE_STREAM_WRITE
) ?
1761 FILE_PIPE_TYPE_MESSAGE
: FILE_PIPE_TYPE_BYTE
;
1762 pli
->NamedPipeConfiguration
= 0; /* FIXME */
1763 pli
->MaximumInstances
= reply
->maxinstances
;
1764 pli
->CurrentInstances
= reply
->instances
;
1765 pli
->InboundQuota
= reply
->insize
;
1766 pli
->ReadDataAvailable
= 0; /* FIXME */
1767 pli
->OutboundQuota
= reply
->outsize
;
1768 pli
->WriteQuotaAvailable
= 0; /* FIXME */
1769 pli
->NamedPipeState
= 0; /* FIXME */
1770 pli
->NamedPipeEnd
= (reply
->flags
& NAMED_PIPE_SERVER_END
) ?
1771 FILE_PIPE_SERVER_END
: FILE_PIPE_CLIENT_END
;
1778 FIXME("Unsupported class (%d)\n", class);
1779 io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1782 if (needs_close
) close( fd
);
1783 if (io
->u
.Status
== STATUS_SUCCESS
&& !io
->Information
) io
->Information
= info_sizes
[class];
1784 return io
->u
.Status
;
1787 /******************************************************************************
1788 * NtSetInformationFile [NTDLL.@]
1789 * ZwSetInformationFile [NTDLL.@]
1791 * Set information about an open file handle.
1794 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1795 * io [O] Receives information about the operation on return
1796 * ptr [I] Source for file information
1797 * len [I] Size of FileInformation
1798 * class [I] Type of file information to set
1801 * Success: 0. io is updated.
1802 * Failure: An NTSTATUS error code describing the error.
1804 NTSTATUS WINAPI
NtSetInformationFile(HANDLE handle
, PIO_STATUS_BLOCK io
,
1805 PVOID ptr
, ULONG len
, FILE_INFORMATION_CLASS
class)
1807 int fd
, needs_close
;
1809 TRACE("(%p,%p,%p,0x%08x,0x%08x)\n", handle
, io
, ptr
, len
, class);
1811 io
->u
.Status
= STATUS_SUCCESS
;
1814 case FileBasicInformation
:
1815 if (len
>= sizeof(FILE_BASIC_INFORMATION
))
1818 const FILE_BASIC_INFORMATION
*info
= ptr
;
1820 if ((io
->u
.Status
= server_get_unix_fd( handle
, 0, &fd
, &needs_close
, NULL
, NULL
)))
1821 return io
->u
.Status
;
1823 if (info
->LastAccessTime
.QuadPart
|| info
->LastWriteTime
.QuadPart
)
1825 struct timeval tv
[2];
1827 if (!info
->LastAccessTime
.QuadPart
|| !info
->LastWriteTime
.QuadPart
)
1830 tv
[0].tv_sec
= tv
[0].tv_usec
= 0;
1831 tv
[1].tv_sec
= tv
[1].tv_usec
= 0;
1832 if (!fstat( fd
, &st
))
1834 tv
[0].tv_sec
= st
.st_atime
;
1835 tv
[1].tv_sec
= st
.st_mtime
;
1838 if (info
->LastAccessTime
.QuadPart
)
1840 ULONGLONG sec
= info
->LastAccessTime
.QuadPart
/ 10000000;
1841 UINT nsec
= info
->LastAccessTime
.QuadPart
% 10000000;
1842 tv
[0].tv_sec
= sec
- SECS_1601_TO_1970
;
1843 tv
[0].tv_usec
= nsec
/ 10;
1845 if (info
->LastWriteTime
.QuadPart
)
1847 ULONGLONG sec
= info
->LastWriteTime
.QuadPart
/ 10000000;
1848 UINT nsec
= info
->LastWriteTime
.QuadPart
% 10000000;
1849 tv
[1].tv_sec
= sec
- SECS_1601_TO_1970
;
1850 tv
[1].tv_usec
= nsec
/ 10;
1852 if (futimes( fd
, tv
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1855 if (io
->u
.Status
== STATUS_SUCCESS
&& info
->FileAttributes
)
1857 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1860 if (info
->FileAttributes
& FILE_ATTRIBUTE_READONLY
)
1862 if (S_ISDIR( st
.st_mode
))
1863 WARN("FILE_ATTRIBUTE_READONLY ignored for directory.\n");
1865 st
.st_mode
&= ~0222; /* clear write permission bits */
1869 /* add write permission only where we already have read permission */
1870 st
.st_mode
|= (0600 | ((st
.st_mode
& 044) >> 1)) & (~FILE_umask
);
1872 if (fchmod( fd
, st
.st_mode
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1876 if (needs_close
) close( fd
);
1878 else io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1881 case FilePositionInformation
:
1882 if (len
>= sizeof(FILE_POSITION_INFORMATION
))
1884 const FILE_POSITION_INFORMATION
*info
= ptr
;
1886 if ((io
->u
.Status
= server_get_unix_fd( handle
, 0, &fd
, &needs_close
, NULL
, NULL
)))
1887 return io
->u
.Status
;
1889 if (lseek( fd
, info
->CurrentByteOffset
.QuadPart
, SEEK_SET
) == (off_t
)-1)
1890 io
->u
.Status
= FILE_GetNtStatus();
1892 if (needs_close
) close( fd
);
1894 else io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1897 case FileEndOfFileInformation
:
1898 if (len
>= sizeof(FILE_END_OF_FILE_INFORMATION
))
1901 const FILE_END_OF_FILE_INFORMATION
*info
= ptr
;
1903 if ((io
->u
.Status
= server_get_unix_fd( handle
, 0, &fd
, &needs_close
, NULL
, NULL
)))
1904 return io
->u
.Status
;
1906 /* first try normal truncate */
1907 if (ftruncate( fd
, (off_t
)info
->EndOfFile
.QuadPart
) != -1) break;
1909 /* now check for the need to extend the file */
1910 if (fstat( fd
, &st
) != -1 && (off_t
)info
->EndOfFile
.QuadPart
> st
.st_size
)
1912 static const char zero
;
1914 /* extend the file one byte beyond the requested size and then truncate it */
1915 /* this should work around ftruncate implementations that can't extend files */
1916 if (pwrite( fd
, &zero
, 1, (off_t
)info
->EndOfFile
.QuadPart
) != -1 &&
1917 ftruncate( fd
, (off_t
)info
->EndOfFile
.QuadPart
) != -1) break;
1919 io
->u
.Status
= FILE_GetNtStatus();
1921 if (needs_close
) close( fd
);
1923 else io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1926 case FileMailslotSetInformation
:
1928 FILE_MAILSLOT_SET_INFORMATION
*info
= ptr
;
1930 SERVER_START_REQ( set_mailslot_info
)
1932 req
->handle
= wine_server_obj_handle( handle
);
1933 req
->flags
= MAILSLOT_SET_READ_TIMEOUT
;
1934 req
->read_timeout
= info
->ReadTimeout
.QuadPart
;
1935 io
->u
.Status
= wine_server_call( req
);
1941 case FileCompletionInformation
:
1942 if (len
>= sizeof(FILE_COMPLETION_INFORMATION
))
1944 FILE_COMPLETION_INFORMATION
*info
= ptr
;
1946 SERVER_START_REQ( set_completion_info
)
1948 req
->handle
= wine_server_obj_handle( handle
);
1949 req
->chandle
= wine_server_obj_handle( info
->CompletionPort
);
1950 req
->ckey
= info
->CompletionKey
;
1951 io
->u
.Status
= wine_server_call( req
);
1955 io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1959 FIXME("Unsupported class (%d)\n", class);
1960 io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1963 io
->Information
= 0;
1964 return io
->u
.Status
;
1968 /******************************************************************************
1969 * FILE_QueryFullAttributesFile (internal)
1971 static NTSTATUS
FILE_QueryFullAttributesFile( const OBJECT_ATTRIBUTES
*attr
,
1972 FILE_NETWORK_OPEN_INFORMATION
*info
)
1974 ANSI_STRING unix_name
;
1977 if (!(status
= wine_nt_to_unix_file_name( attr
->ObjectName
, &unix_name
, FILE_OPEN
,
1978 !(attr
->Attributes
& OBJ_CASE_INSENSITIVE
) )))
1982 if (stat( unix_name
.Buffer
, &st
) == -1)
1983 status
= FILE_GetNtStatus();
1984 else if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1985 status
= STATUS_INVALID_INFO_CLASS
;
1988 if (S_ISDIR(st
.st_mode
))
1990 info
->FileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1991 info
->AllocationSize
.QuadPart
= 0;
1992 info
->EndOfFile
.QuadPart
= 0;
1996 info
->FileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1997 info
->AllocationSize
.QuadPart
= (ULONGLONG
)st
.st_blocks
* 512;
1998 info
->EndOfFile
.QuadPart
= st
.st_size
;
2000 if (!(st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)))
2001 info
->FileAttributes
|= FILE_ATTRIBUTE_READONLY
;
2002 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->CreationTime
);
2003 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->LastWriteTime
);
2004 RtlSecondsSince1970ToTime( st
.st_ctime
, &info
->ChangeTime
);
2005 RtlSecondsSince1970ToTime( st
.st_atime
, &info
->LastAccessTime
);
2006 if (DIR_is_hidden_file( attr
->ObjectName
))
2007 info
->FileAttributes
|= FILE_ATTRIBUTE_HIDDEN
;
2009 RtlFreeAnsiString( &unix_name
);
2011 else WARN("%s not found (%x)\n", debugstr_us(attr
->ObjectName
), status
);
2015 /******************************************************************************
2016 * NtQueryFullAttributesFile (NTDLL.@)
2018 NTSTATUS WINAPI
NtQueryFullAttributesFile( const OBJECT_ATTRIBUTES
*attr
,
2019 FILE_NETWORK_OPEN_INFORMATION
*info
)
2021 return FILE_QueryFullAttributesFile( attr
, info
);
2025 /******************************************************************************
2026 * NtQueryAttributesFile (NTDLL.@)
2027 * ZwQueryAttributesFile (NTDLL.@)
2029 NTSTATUS WINAPI
NtQueryAttributesFile( const OBJECT_ATTRIBUTES
*attr
, FILE_BASIC_INFORMATION
*info
)
2031 FILE_NETWORK_OPEN_INFORMATION full_info
;
2034 if (!(status
= FILE_QueryFullAttributesFile( attr
, &full_info
)))
2036 info
->CreationTime
.QuadPart
= full_info
.CreationTime
.QuadPart
;
2037 info
->LastAccessTime
.QuadPart
= full_info
.LastAccessTime
.QuadPart
;
2038 info
->LastWriteTime
.QuadPart
= full_info
.LastWriteTime
.QuadPart
;
2039 info
->ChangeTime
.QuadPart
= full_info
.ChangeTime
.QuadPart
;
2040 info
->FileAttributes
= full_info
.FileAttributes
;
2046 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__)
2047 /* helper for FILE_GetDeviceInfo to hide some platform differences in fstatfs */
2048 static inline void get_device_info_fstatfs( FILE_FS_DEVICE_INFORMATION
*info
, const char *fstypename
,
2049 unsigned int flags
)
2051 if (!strcmp("cd9660", fstypename
) || !strcmp("udf", fstypename
))
2053 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
2054 /* Don't assume read-only, let the mount options set it below */
2055 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
2057 else if (!strcmp("nfs", fstypename
) || !strcmp("nwfs", fstypename
) ||
2058 !strcmp("smbfs", fstypename
) || !strcmp("afpfs", fstypename
))
2060 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
2061 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
2063 else if (!strcmp("procfs", fstypename
))
2064 info
->DeviceType
= FILE_DEVICE_VIRTUAL_DISK
;
2066 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2068 if (flags
& MNT_RDONLY
)
2069 info
->Characteristics
|= FILE_READ_ONLY_DEVICE
;
2071 if (!(flags
& MNT_LOCAL
))
2073 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
2074 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
2079 static inline int is_device_placeholder( int fd
)
2081 static const char wine_placeholder
[] = "Wine device placeholder";
2082 char buffer
[sizeof(wine_placeholder
)-1];
2084 if (pread( fd
, buffer
, sizeof(wine_placeholder
) - 1, 0 ) != sizeof(wine_placeholder
) - 1)
2086 return !memcmp( buffer
, wine_placeholder
, sizeof(wine_placeholder
) - 1 );
2089 /******************************************************************************
2092 * Implementation of the FileFsDeviceInformation query for NtQueryVolumeInformationFile.
2094 static NTSTATUS
get_device_info( int fd
, FILE_FS_DEVICE_INFORMATION
*info
)
2098 info
->Characteristics
= 0;
2099 if (fstat( fd
, &st
) < 0) return FILE_GetNtStatus();
2100 if (S_ISCHR( st
.st_mode
))
2102 info
->DeviceType
= FILE_DEVICE_UNKNOWN
;
2104 switch(major(st
.st_rdev
))
2107 info
->DeviceType
= FILE_DEVICE_NULL
;
2110 info
->DeviceType
= FILE_DEVICE_SERIAL_PORT
;
2113 info
->DeviceType
= FILE_DEVICE_PARALLEL_PORT
;
2115 case SCSI_TAPE_MAJOR
:
2116 info
->DeviceType
= FILE_DEVICE_TAPE
;
2121 else if (S_ISBLK( st
.st_mode
))
2123 info
->DeviceType
= FILE_DEVICE_DISK
;
2125 else if (S_ISFIFO( st
.st_mode
) || S_ISSOCK( st
.st_mode
))
2127 info
->DeviceType
= FILE_DEVICE_NAMED_PIPE
;
2129 else if (is_device_placeholder( fd
))
2131 info
->DeviceType
= FILE_DEVICE_DISK
;
2133 else /* regular file or directory */
2135 #if defined(linux) && defined(HAVE_FSTATFS)
2138 /* check for floppy disk */
2139 if (major(st
.st_dev
) == FLOPPY_MAJOR
)
2140 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
2142 if (fstatfs( fd
, &stfs
) < 0) stfs
.f_type
= 0;
2143 switch (stfs
.f_type
)
2145 case 0x9660: /* iso9660 */
2146 case 0x9fa1: /* supermount */
2147 case 0x15013346: /* udf */
2148 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
2149 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
|FILE_READ_ONLY_DEVICE
;
2151 case 0x6969: /* nfs */
2152 case 0x517B: /* smbfs */
2153 case 0x564c: /* ncpfs */
2154 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
2155 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
2157 case 0x01021994: /* tmpfs */
2158 case 0x28cd3d45: /* cramfs */
2159 case 0x1373: /* devfs */
2160 case 0x9fa0: /* procfs */
2161 info
->DeviceType
= FILE_DEVICE_VIRTUAL_DISK
;
2164 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2167 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__OpenBSD__) || defined(__APPLE__)
2170 if (fstatfs( fd
, &stfs
) < 0)
2171 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2173 get_device_info_fstatfs( info
, stfs
.f_fstypename
, stfs
.f_flags
);
2174 #elif defined(__NetBSD__)
2175 struct statvfs stfs
;
2177 if (fstatvfs( fd
, &stfs
) < 0)
2178 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2180 get_device_info_fstatfs( info
, stfs
.f_fstypename
, stfs
.f_flag
);
2182 /* Use dkio to work out device types */
2184 # include <sys/dkio.h>
2185 # include <sys/vtoc.h>
2186 struct dk_cinfo dkinf
;
2187 int retval
= ioctl(fd
, DKIOCINFO
, &dkinf
);
2189 WARN("Unable to get disk device type information - assuming a disk like device\n");
2190 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2192 switch (dkinf
.dki_ctype
)
2195 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
2196 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
|FILE_READ_ONLY_DEVICE
;
2200 case DKC_INTEL82072
:
2201 case DKC_INTEL82077
:
2202 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2203 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
2206 info
->DeviceType
= FILE_DEVICE_VIRTUAL_DISK
;
2209 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2214 if (!warned
++) FIXME( "device info not properly supported on this platform\n" );
2215 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2217 info
->Characteristics
|= FILE_DEVICE_IS_MOUNTED
;
2219 return STATUS_SUCCESS
;
2223 /******************************************************************************
2224 * NtQueryVolumeInformationFile [NTDLL.@]
2225 * ZwQueryVolumeInformationFile [NTDLL.@]
2227 * Get volume information for an open file handle.
2230 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
2231 * io [O] Receives information about the operation on return
2232 * buffer [O] Destination for volume information
2233 * length [I] Size of FsInformation
2234 * info_class [I] Type of volume information to set
2237 * Success: 0. io and buffer are updated.
2238 * Failure: An NTSTATUS error code describing the error.
2240 NTSTATUS WINAPI
NtQueryVolumeInformationFile( HANDLE handle
, PIO_STATUS_BLOCK io
,
2241 PVOID buffer
, ULONG length
,
2242 FS_INFORMATION_CLASS info_class
)
2244 int fd
, needs_close
;
2247 if ((io
->u
.Status
= server_get_unix_fd( handle
, 0, &fd
, &needs_close
, NULL
, NULL
)) != STATUS_SUCCESS
)
2248 return io
->u
.Status
;
2250 io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
2251 io
->Information
= 0;
2253 switch( info_class
)
2255 case FileFsVolumeInformation
:
2256 FIXME( "%p: volume info not supported\n", handle
);
2258 case FileFsLabelInformation
:
2259 FIXME( "%p: label info not supported\n", handle
);
2261 case FileFsSizeInformation
:
2262 if (length
< sizeof(FILE_FS_SIZE_INFORMATION
))
2263 io
->u
.Status
= STATUS_BUFFER_TOO_SMALL
;
2266 FILE_FS_SIZE_INFORMATION
*info
= buffer
;
2268 if (fstat( fd
, &st
) < 0)
2270 io
->u
.Status
= FILE_GetNtStatus();
2273 if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
2275 io
->u
.Status
= STATUS_INVALID_DEVICE_REQUEST
;
2280 /* Linux's fstatvfs is buggy */
2281 #if !defined(linux) || !defined(HAVE_FSTATFS)
2282 struct statvfs stfs
;
2284 if (fstatvfs( fd
, &stfs
) < 0)
2286 io
->u
.Status
= FILE_GetNtStatus();
2289 bsize
= stfs
.f_frsize
;
2292 if (fstatfs( fd
, &stfs
) < 0)
2294 io
->u
.Status
= FILE_GetNtStatus();
2297 bsize
= stfs
.f_bsize
;
2299 if (bsize
== 2048) /* assume CD-ROM */
2301 info
->BytesPerSector
= 2048;
2302 info
->SectorsPerAllocationUnit
= 1;
2306 info
->BytesPerSector
= 512;
2307 info
->SectorsPerAllocationUnit
= 8;
2309 info
->TotalAllocationUnits
.QuadPart
= bsize
* stfs
.f_blocks
/ (info
->BytesPerSector
* info
->SectorsPerAllocationUnit
);
2310 info
->AvailableAllocationUnits
.QuadPart
= bsize
* stfs
.f_bavail
/ (info
->BytesPerSector
* info
->SectorsPerAllocationUnit
);
2311 io
->Information
= sizeof(*info
);
2312 io
->u
.Status
= STATUS_SUCCESS
;
2316 case FileFsDeviceInformation
:
2317 if (length
< sizeof(FILE_FS_DEVICE_INFORMATION
))
2318 io
->u
.Status
= STATUS_BUFFER_TOO_SMALL
;
2321 FILE_FS_DEVICE_INFORMATION
*info
= buffer
;
2323 if ((io
->u
.Status
= get_device_info( fd
, info
)) == STATUS_SUCCESS
)
2324 io
->Information
= sizeof(*info
);
2327 case FileFsAttributeInformation
:
2328 FIXME( "%p: attribute info not supported\n", handle
);
2330 case FileFsControlInformation
:
2331 FIXME( "%p: control info not supported\n", handle
);
2333 case FileFsFullSizeInformation
:
2334 FIXME( "%p: full size info not supported\n", handle
);
2336 case FileFsObjectIdInformation
:
2337 FIXME( "%p: object id info not supported\n", handle
);
2339 case FileFsMaximumInformation
:
2340 FIXME( "%p: maximum info not supported\n", handle
);
2343 io
->u
.Status
= STATUS_INVALID_PARAMETER
;
2346 if (needs_close
) close( fd
);
2347 return io
->u
.Status
;
2351 /******************************************************************
2352 * NtQueryEaFile (NTDLL.@)
2354 * Read extended attributes from NTFS files.
2357 * hFile [I] File handle, must be opened with FILE_READ_EA access
2358 * iosb [O] Receives information about the operation on return
2359 * buffer [O] Output buffer
2360 * length [I] Length of output buffer
2361 * single_entry [I] Only read and return one entry
2362 * ea_list [I] Optional list with names of EAs to return
2363 * ea_list_len [I] Length of ea_list in bytes
2364 * ea_index [I] Optional pointer to 1-based index of attribute to return
2365 * restart [I] restart EA scan
2368 * Success: 0. Atrributes read into buffer
2369 * Failure: An NTSTATUS error code describing the error.
2371 NTSTATUS WINAPI
NtQueryEaFile( HANDLE hFile
, PIO_STATUS_BLOCK iosb
, PVOID buffer
, ULONG length
,
2372 BOOLEAN single_entry
, PVOID ea_list
, ULONG ea_list_len
,
2373 PULONG ea_index
, BOOLEAN restart
)
2375 FIXME("(%p,%p,%p,%d,%d,%p,%d,%p,%d) stub\n",
2376 hFile
, iosb
, buffer
, length
, single_entry
, ea_list
,
2377 ea_list_len
, ea_index
, restart
);
2378 return STATUS_ACCESS_DENIED
;
2382 /******************************************************************
2383 * NtSetEaFile (NTDLL.@)
2385 * Update extended attributes for NTFS files.
2388 * hFile [I] File handle, must be opened with FILE_READ_EA access
2389 * iosb [O] Receives information about the operation on return
2390 * buffer [I] Buffer with EA information
2391 * length [I] Length of buffer
2394 * Success: 0. Attributes are updated
2395 * Failure: An NTSTATUS error code describing the error.
2397 NTSTATUS WINAPI
NtSetEaFile( HANDLE hFile
, PIO_STATUS_BLOCK iosb
, PVOID buffer
, ULONG length
)
2399 FIXME("(%p,%p,%p,%d) stub\n", hFile
, iosb
, buffer
, length
);
2400 return STATUS_ACCESS_DENIED
;
2404 /******************************************************************
2405 * NtFlushBuffersFile (NTDLL.@)
2407 * Flush any buffered data on an open file handle.
2410 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
2411 * IoStatusBlock [O] Receives information about the operation on return
2414 * Success: 0. IoStatusBlock is updated.
2415 * Failure: An NTSTATUS error code describing the error.
2417 NTSTATUS WINAPI
NtFlushBuffersFile( HANDLE hFile
, IO_STATUS_BLOCK
* IoStatusBlock
)
2420 HANDLE hEvent
= NULL
;
2422 SERVER_START_REQ( flush_file
)
2424 req
->handle
= wine_server_obj_handle( hFile
);
2425 ret
= wine_server_call( req
);
2426 hEvent
= wine_server_ptr_handle( reply
->event
);
2431 ret
= NtWaitForSingleObject( hEvent
, FALSE
, NULL
);
2437 /******************************************************************
2438 * NtLockFile (NTDLL.@)
2442 NTSTATUS WINAPI
NtLockFile( HANDLE hFile
, HANDLE lock_granted_event
,
2443 PIO_APC_ROUTINE apc
, void* apc_user
,
2444 PIO_STATUS_BLOCK io_status
, PLARGE_INTEGER offset
,
2445 PLARGE_INTEGER count
, ULONG
* key
, BOOLEAN dont_wait
,
2451 static BOOLEAN warn
= TRUE
;
2453 if (apc
|| io_status
|| key
)
2455 FIXME("Unimplemented yet parameter\n");
2456 return STATUS_NOT_IMPLEMENTED
;
2459 if (apc_user
&& warn
)
2461 FIXME("I/O completion on lock not implemented yet\n");
2467 SERVER_START_REQ( lock_file
)
2469 req
->handle
= wine_server_obj_handle( hFile
);
2470 req
->offset
= offset
->QuadPart
;
2471 req
->count
= count
->QuadPart
;
2472 req
->shared
= !exclusive
;
2473 req
->wait
= !dont_wait
;
2474 ret
= wine_server_call( req
);
2475 handle
= wine_server_ptr_handle( reply
->handle
);
2476 async
= reply
->overlapped
;
2479 if (ret
!= STATUS_PENDING
)
2481 if (!ret
&& lock_granted_event
) NtSetEvent(lock_granted_event
, NULL
);
2487 FIXME( "Async I/O lock wait not implemented, might deadlock\n" );
2488 if (handle
) NtClose( handle
);
2489 return STATUS_PENDING
;
2493 NtWaitForSingleObject( handle
, FALSE
, NULL
);
2500 /* Unix lock conflict, sleep a bit and retry */
2501 time
.QuadPart
= 100 * (ULONGLONG
)10000;
2502 time
.QuadPart
= -time
.QuadPart
;
2503 NtDelayExecution( FALSE
, &time
);
2509 /******************************************************************
2510 * NtUnlockFile (NTDLL.@)
2514 NTSTATUS WINAPI
NtUnlockFile( HANDLE hFile
, PIO_STATUS_BLOCK io_status
,
2515 PLARGE_INTEGER offset
, PLARGE_INTEGER count
,
2520 TRACE( "%p %x%08x %x%08x\n",
2521 hFile
, offset
->u
.HighPart
, offset
->u
.LowPart
, count
->u
.HighPart
, count
->u
.LowPart
);
2523 if (io_status
|| key
)
2525 FIXME("Unimplemented yet parameter\n");
2526 return STATUS_NOT_IMPLEMENTED
;
2529 SERVER_START_REQ( unlock_file
)
2531 req
->handle
= wine_server_obj_handle( hFile
);
2532 req
->offset
= offset
->QuadPart
;
2533 req
->count
= count
->QuadPart
;
2534 status
= wine_server_call( req
);
2540 /******************************************************************
2541 * NtCreateNamedPipeFile (NTDLL.@)
2545 NTSTATUS WINAPI
NtCreateNamedPipeFile( PHANDLE handle
, ULONG access
,
2546 POBJECT_ATTRIBUTES attr
, PIO_STATUS_BLOCK iosb
,
2547 ULONG sharing
, ULONG dispo
, ULONG options
,
2548 ULONG pipe_type
, ULONG read_mode
,
2549 ULONG completion_mode
, ULONG max_inst
,
2550 ULONG inbound_quota
, ULONG outbound_quota
,
2551 PLARGE_INTEGER timeout
)
2555 TRACE("(%p %x %s %p %x %d %x %d %d %d %d %d %d %p)\n",
2556 handle
, access
, debugstr_w(attr
->ObjectName
->Buffer
), iosb
, sharing
, dispo
,
2557 options
, pipe_type
, read_mode
, completion_mode
, max_inst
, inbound_quota
,
2558 outbound_quota
, timeout
);
2560 /* assume we only get relative timeout */
2561 if (timeout
->QuadPart
> 0)
2562 FIXME("Wrong time %s\n", wine_dbgstr_longlong(timeout
->QuadPart
));
2564 SERVER_START_REQ( create_named_pipe
)
2566 req
->access
= access
;
2567 req
->attributes
= attr
->Attributes
;
2568 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
2569 req
->options
= options
;
2571 (pipe_type
) ? NAMED_PIPE_MESSAGE_STREAM_WRITE
: 0 |
2572 (read_mode
) ? NAMED_PIPE_MESSAGE_STREAM_READ
: 0 |
2573 (completion_mode
) ? NAMED_PIPE_NONBLOCKING_MODE
: 0;
2574 req
->maxinstances
= max_inst
;
2575 req
->outsize
= outbound_quota
;
2576 req
->insize
= inbound_quota
;
2577 req
->timeout
= timeout
->QuadPart
;
2578 wine_server_add_data( req
, attr
->ObjectName
->Buffer
,
2579 attr
->ObjectName
->Length
);
2580 status
= wine_server_call( req
);
2581 if (!status
) *handle
= wine_server_ptr_handle( reply
->handle
);
2587 /******************************************************************
2588 * NtDeleteFile (NTDLL.@)
2592 NTSTATUS WINAPI
NtDeleteFile( POBJECT_ATTRIBUTES ObjectAttributes
)
2598 TRACE("%p\n", ObjectAttributes
);
2599 status
= NtCreateFile( &hFile
, GENERIC_READ
| GENERIC_WRITE
| DELETE
,
2600 ObjectAttributes
, &io
, NULL
, 0,
2601 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
2602 FILE_OPEN
, FILE_DELETE_ON_CLOSE
, NULL
, 0 );
2603 if (status
== STATUS_SUCCESS
) status
= NtClose(hFile
);
2607 /******************************************************************
2608 * NtCancelIoFileEx (NTDLL.@)
2612 NTSTATUS WINAPI
NtCancelIoFileEx( HANDLE hFile
, PIO_STATUS_BLOCK iosb
, PIO_STATUS_BLOCK io_status
)
2614 LARGE_INTEGER timeout
;
2616 TRACE("%p %p %p\n", hFile
, iosb
, io_status
);
2618 SERVER_START_REQ( cancel_async
)
2620 req
->handle
= wine_server_obj_handle( hFile
);
2621 req
->iosb
= wine_server_client_ptr( iosb
);
2622 req
->only_thread
= FALSE
;
2623 io_status
->u
.Status
= wine_server_call( req
);
2626 if (io_status
->u
.Status
)
2627 return io_status
->u
.Status
;
2629 /* Let some APC be run, so that we can run the remaining APCs on hFile
2630 * either the cancelation of the pending one, but also the execution
2631 * of the queued APC, but not yet run. This is needed to ensure proper
2632 * clean-up of allocated data.
2634 timeout
.u
.LowPart
= timeout
.u
.HighPart
= 0;
2635 NtDelayExecution( TRUE
, &timeout
);
2636 return io_status
->u
.Status
;
2639 /******************************************************************
2640 * NtCancelIoFile (NTDLL.@)
2644 NTSTATUS WINAPI
NtCancelIoFile( HANDLE hFile
, PIO_STATUS_BLOCK io_status
)
2646 LARGE_INTEGER timeout
;
2648 TRACE("%p %p\n", hFile
, io_status
);
2650 SERVER_START_REQ( cancel_async
)
2652 req
->handle
= wine_server_obj_handle( hFile
);
2654 req
->only_thread
= TRUE
;
2655 io_status
->u
.Status
= wine_server_call( req
);
2658 if (io_status
->u
.Status
)
2659 return io_status
->u
.Status
;
2661 /* Let some APC be run, so that we can run the remaining APCs on hFile
2662 * either the cancelation of the pending one, but also the execution
2663 * of the queued APC, but not yet run. This is needed to ensure proper
2664 * clean-up of allocated data.
2666 timeout
.u
.LowPart
= timeout
.u
.HighPart
= 0;
2667 NtDelayExecution( TRUE
, &timeout
);
2668 return io_status
->u
.Status
;
2671 /******************************************************************************
2672 * NtCreateMailslotFile [NTDLL.@]
2673 * ZwCreateMailslotFile [NTDLL.@]
2676 * pHandle [O] pointer to receive the handle created
2677 * DesiredAccess [I] access mode (read, write, etc)
2678 * ObjectAttributes [I] fully qualified NT path of the mailslot
2679 * IoStatusBlock [O] receives completion status and other info
2682 * MaxMessageSize [I]
2688 NTSTATUS WINAPI
NtCreateMailslotFile(PHANDLE pHandle
, ULONG DesiredAccess
,
2689 POBJECT_ATTRIBUTES attr
, PIO_STATUS_BLOCK IoStatusBlock
,
2690 ULONG CreateOptions
, ULONG MailslotQuota
, ULONG MaxMessageSize
,
2691 PLARGE_INTEGER TimeOut
)
2693 LARGE_INTEGER timeout
;
2696 TRACE("%p %08x %p %p %08x %08x %08x %p\n",
2697 pHandle
, DesiredAccess
, attr
, IoStatusBlock
,
2698 CreateOptions
, MailslotQuota
, MaxMessageSize
, TimeOut
);
2700 if (!pHandle
) return STATUS_ACCESS_VIOLATION
;
2701 if (!attr
) return STATUS_INVALID_PARAMETER
;
2702 if (!attr
->ObjectName
) return STATUS_OBJECT_PATH_SYNTAX_BAD
;
2705 * For a NULL TimeOut pointer set the default timeout value
2708 timeout
.QuadPart
= -1;
2710 timeout
.QuadPart
= TimeOut
->QuadPart
;
2712 SERVER_START_REQ( create_mailslot
)
2714 req
->access
= DesiredAccess
;
2715 req
->attributes
= attr
->Attributes
;
2716 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
2717 req
->max_msgsize
= MaxMessageSize
;
2718 req
->read_timeout
= timeout
.QuadPart
;
2719 wine_server_add_data( req
, attr
->ObjectName
->Buffer
,
2720 attr
->ObjectName
->Length
);
2721 ret
= wine_server_call( req
);
2722 if( ret
== STATUS_SUCCESS
)
2723 *pHandle
= wine_server_ptr_handle( reply
->handle
);