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)
93 /**************************************************************************
94 * NtOpenFile [NTDLL.@]
95 * ZwOpenFile [NTDLL.@]
100 * handle [O] Variable that receives the file handle on return
101 * access [I] Access desired by the caller to the file
102 * attr [I] Structure describing the file to be opened
103 * io [O] Receives details about the result of the operation
104 * sharing [I] Type of shared access the caller requires
105 * options [I] Options for the file open
108 * Success: 0. FileHandle and IoStatusBlock are updated.
109 * Failure: An NTSTATUS error code describing the error.
111 NTSTATUS WINAPI
NtOpenFile( PHANDLE handle
, ACCESS_MASK access
,
112 POBJECT_ATTRIBUTES attr
, PIO_STATUS_BLOCK io
,
113 ULONG sharing
, ULONG options
)
115 return NtCreateFile( handle
, access
, attr
, io
, NULL
, 0,
116 sharing
, FILE_OPEN
, options
, NULL
, 0 );
119 /**************************************************************************
120 * NtCreateFile [NTDLL.@]
121 * ZwCreateFile [NTDLL.@]
123 * Either create a new file or directory, or open an existing file, device,
124 * directory or volume.
127 * handle [O] Points to a variable which receives the file handle on return
128 * access [I] Desired access to the file
129 * attr [I] Structure describing the file
130 * io [O] Receives information about the operation on return
131 * alloc_size [I] Initial size of the file in bytes
132 * attributes [I] Attributes to create the file with
133 * sharing [I] Type of shared access the caller would like to the file
134 * disposition [I] Specifies what to do, depending on whether the file already exists
135 * options [I] Options for creating a new file
136 * ea_buffer [I] Pointer to an extended attributes buffer
137 * ea_length [I] Length of ea_buffer
140 * Success: 0. handle and io are updated.
141 * Failure: An NTSTATUS error code describing the error.
143 NTSTATUS WINAPI
NtCreateFile( PHANDLE handle
, ACCESS_MASK access
, POBJECT_ATTRIBUTES attr
,
144 PIO_STATUS_BLOCK io
, PLARGE_INTEGER alloc_size
,
145 ULONG attributes
, ULONG sharing
, ULONG disposition
,
146 ULONG options
, PVOID ea_buffer
, ULONG ea_length
)
148 ANSI_STRING unix_name
;
151 TRACE("handle=%p access=%08x name=%s objattr=%08x root=%p sec=%p io=%p alloc_size=%p\n"
152 "attr=%08x sharing=%08x disp=%d options=%08x ea=%p.0x%08x\n",
153 handle
, access
, debugstr_us(attr
->ObjectName
), attr
->Attributes
,
154 attr
->RootDirectory
, attr
->SecurityDescriptor
, io
, alloc_size
,
155 attributes
, sharing
, disposition
, options
, ea_buffer
, ea_length
);
157 if (!attr
|| !attr
->ObjectName
) return STATUS_INVALID_PARAMETER
;
159 if (alloc_size
) FIXME( "alloc_size not supported\n" );
161 if (attr
->RootDirectory
||
162 (io
->u
.Status
= wine_nt_to_unix_file_name( attr
->ObjectName
, &unix_name
, disposition
,
163 !(attr
->Attributes
& OBJ_CASE_INSENSITIVE
) )) == STATUS_BAD_DEVICE_TYPE
)
165 SERVER_START_REQ( open_file_object
)
167 req
->access
= access
;
168 req
->attributes
= attr
->Attributes
;
169 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
170 req
->sharing
= sharing
;
171 req
->options
= options
;
172 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
173 io
->u
.Status
= wine_server_call( req
);
174 *handle
= wine_server_ptr_handle( reply
->handle
);
177 if (io
->u
.Status
== STATUS_SUCCESS
) io
->Information
= FILE_OPENED
;
181 if (io
->u
.Status
== STATUS_NO_SUCH_FILE
&&
182 disposition
!= FILE_OPEN
&& disposition
!= FILE_OVERWRITE
)
185 io
->u
.Status
= STATUS_SUCCESS
;
188 if (io
->u
.Status
== STATUS_SUCCESS
)
190 struct security_descriptor
*sd
= NULL
;
191 struct object_attributes objattr
;
195 objattr
.name_len
= 0;
198 io
->u
.Status
= NTDLL_create_struct_sd( attr
->SecurityDescriptor
, &sd
, &objattr
.sd_len
);
199 if (io
->u
.Status
!= STATUS_SUCCESS
)
201 RtlFreeAnsiString( &unix_name
);
206 SERVER_START_REQ( create_file
)
208 req
->access
= access
;
209 req
->attributes
= attr
->Attributes
;
210 req
->sharing
= sharing
;
211 req
->create
= disposition
;
212 req
->options
= options
;
213 req
->attrs
= attributes
;
214 wine_server_add_data( req
, &objattr
, sizeof(objattr
) );
215 if (objattr
.sd_len
) wine_server_add_data( req
, sd
, objattr
.sd_len
);
216 wine_server_add_data( req
, unix_name
.Buffer
, unix_name
.Length
);
217 io
->u
.Status
= wine_server_call( req
);
218 *handle
= wine_server_ptr_handle( reply
->handle
);
221 NTDLL_free_struct_sd( sd
);
222 RtlFreeAnsiString( &unix_name
);
224 else WARN("%s not found (%x)\n", debugstr_us(attr
->ObjectName
), io
->u
.Status
);
226 if (io
->u
.Status
== STATUS_SUCCESS
)
228 if (created
) io
->Information
= FILE_CREATED
;
229 else switch(disposition
)
232 io
->Information
= FILE_SUPERSEDED
;
235 io
->Information
= FILE_CREATED
;
239 io
->Information
= FILE_OPENED
;
242 case FILE_OVERWRITE_IF
:
243 io
->Information
= FILE_OVERWRITTEN
;
251 /***********************************************************************
252 * Asynchronous file I/O *
264 struct async_fileio io
;
266 unsigned int already
;
273 struct async_fileio io
;
275 unsigned int already
;
277 } async_fileio_write
;
280 /* callback for file I/O user APC */
281 static void WINAPI
fileio_apc( void *arg
, IO_STATUS_BLOCK
*io
, ULONG reserved
)
283 struct async_fileio
*async
= arg
;
284 if (async
->apc
) async
->apc( async
->apc_arg
, io
, reserved
);
285 RtlFreeHeap( GetProcessHeap(), 0, async
);
288 /***********************************************************************
289 * FILE_GetNtStatus(void)
291 * Retrieve the Nt Status code from errno.
292 * Try to be consistent with FILE_SetDosError().
294 NTSTATUS
FILE_GetNtStatus(void)
298 TRACE( "errno = %d\n", errno
);
301 case EAGAIN
: return STATUS_SHARING_VIOLATION
;
302 case EBADF
: return STATUS_INVALID_HANDLE
;
303 case EBUSY
: return STATUS_DEVICE_BUSY
;
304 case ENOSPC
: return STATUS_DISK_FULL
;
307 case EACCES
: return STATUS_ACCESS_DENIED
;
308 case ENOTDIR
: return STATUS_OBJECT_PATH_NOT_FOUND
;
309 case ENOENT
: return STATUS_OBJECT_NAME_NOT_FOUND
;
310 case EISDIR
: return STATUS_FILE_IS_A_DIRECTORY
;
312 case ENFILE
: return STATUS_TOO_MANY_OPENED_FILES
;
313 case EINVAL
: return STATUS_INVALID_PARAMETER
;
314 case ENOTEMPTY
: return STATUS_DIRECTORY_NOT_EMPTY
;
315 case EPIPE
: return STATUS_PIPE_DISCONNECTED
;
316 case EIO
: return STATUS_DEVICE_NOT_READY
;
318 case ENOMEDIUM
: return STATUS_NO_MEDIA_IN_DEVICE
;
320 case ENXIO
: return STATUS_NO_SUCH_DEVICE
;
322 case EOPNOTSUPP
:return STATUS_NOT_SUPPORTED
;
323 case ECONNRESET
:return STATUS_PIPE_DISCONNECTED
;
324 case EFAULT
: return STATUS_ACCESS_VIOLATION
;
325 case ESPIPE
: return STATUS_ILLEGAL_FUNCTION
;
326 case ENOEXEC
: /* ?? */
327 case EEXIST
: /* ?? */
329 FIXME( "Converting errno %d to STATUS_UNSUCCESSFUL\n", err
);
330 return STATUS_UNSUCCESSFUL
;
334 /***********************************************************************
335 * FILE_AsyncReadService (INTERNAL)
337 static NTSTATUS
FILE_AsyncReadService(void *user
, PIO_STATUS_BLOCK iosb
, NTSTATUS status
, ULONG
*total
)
339 async_fileio_read
*fileio
= user
;
340 int fd
, needs_close
, result
;
344 case STATUS_ALERTED
: /* got some new data */
345 /* check to see if the data is ready (non-blocking) */
346 if ((status
= server_get_unix_fd( fileio
->io
.handle
, FILE_READ_DATA
, &fd
,
347 &needs_close
, NULL
, NULL
)))
350 result
= read(fd
, &fileio
->buffer
[fileio
->already
], fileio
->count
- fileio
->already
);
351 if (needs_close
) close( fd
);
355 if (errno
== EAGAIN
|| errno
== EINTR
)
356 status
= STATUS_PENDING
;
357 else /* check to see if the transfer is complete */
358 status
= FILE_GetNtStatus();
360 else if (result
== 0)
362 status
= fileio
->already
? STATUS_SUCCESS
: STATUS_PIPE_BROKEN
;
366 fileio
->already
+= result
;
367 if (fileio
->already
>= fileio
->count
|| fileio
->avail_mode
)
368 status
= STATUS_SUCCESS
;
371 /* if we only have to read the available data, and none is available,
372 * simply cancel the request. If data was available, it has been read
373 * while in by previous call (NtDelayExecution)
375 status
= (fileio
->avail_mode
) ? STATUS_SUCCESS
: STATUS_PENDING
;
381 case STATUS_IO_TIMEOUT
:
382 if (fileio
->already
) status
= STATUS_SUCCESS
;
385 if (status
!= STATUS_PENDING
)
387 iosb
->u
.Status
= status
;
388 iosb
->Information
= *total
= fileio
->already
;
395 int interval
; /* max interval between two bytes */
396 int total
; /* total timeout for the whole operation */
397 int end_time
; /* absolute time of end of operation */
400 /* retrieve the I/O timeouts to use for a given handle */
401 static NTSTATUS
get_io_timeouts( HANDLE handle
, enum server_fd_type type
, ULONG count
, BOOL is_read
,
402 struct io_timeouts
*timeouts
)
404 NTSTATUS status
= STATUS_SUCCESS
;
406 timeouts
->interval
= timeouts
->total
= -1;
412 /* GetCommTimeouts */
416 status
= NtDeviceIoControlFile( handle
, NULL
, NULL
, NULL
, &io
,
417 IOCTL_SERIAL_GET_TIMEOUTS
, NULL
, 0, &st
, sizeof(st
) );
422 if (st
.ReadIntervalTimeout
)
423 timeouts
->interval
= st
.ReadIntervalTimeout
;
425 if (st
.ReadTotalTimeoutMultiplier
|| st
.ReadTotalTimeoutConstant
)
427 timeouts
->total
= st
.ReadTotalTimeoutConstant
;
428 if (st
.ReadTotalTimeoutMultiplier
!= MAXDWORD
)
429 timeouts
->total
+= count
* st
.ReadTotalTimeoutMultiplier
;
431 else if (st
.ReadIntervalTimeout
== MAXDWORD
)
432 timeouts
->interval
= timeouts
->total
= 0;
436 if (st
.WriteTotalTimeoutMultiplier
|| st
.WriteTotalTimeoutConstant
)
438 timeouts
->total
= st
.WriteTotalTimeoutConstant
;
439 if (st
.WriteTotalTimeoutMultiplier
!= MAXDWORD
)
440 timeouts
->total
+= count
* st
.WriteTotalTimeoutMultiplier
;
445 case FD_TYPE_MAILSLOT
:
448 timeouts
->interval
= 0; /* return as soon as we got something */
449 SERVER_START_REQ( set_mailslot_info
)
451 req
->handle
= wine_server_obj_handle( handle
);
453 if (!(status
= wine_server_call( req
)) &&
454 reply
->read_timeout
!= TIMEOUT_INFINITE
)
455 timeouts
->total
= reply
->read_timeout
/ -10000;
463 if (is_read
) timeouts
->interval
= 0; /* return as soon as we got something */
468 if (timeouts
->total
!= -1) timeouts
->end_time
= NtGetTickCount() + timeouts
->total
;
469 return STATUS_SUCCESS
;
473 /* retrieve the timeout for the next wait, in milliseconds */
474 static inline int get_next_io_timeout( const struct io_timeouts
*timeouts
, ULONG already
)
478 if (timeouts
->total
!= -1)
480 ret
= timeouts
->end_time
- NtGetTickCount();
481 if (ret
< 0) ret
= 0;
483 if (already
&& timeouts
->interval
!= -1)
485 if (ret
== -1 || ret
> timeouts
->interval
) ret
= timeouts
->interval
;
491 /* retrieve the avail_mode flag for async reads */
492 static NTSTATUS
get_io_avail_mode( HANDLE handle
, enum server_fd_type type
, BOOL
*avail_mode
)
494 NTSTATUS status
= STATUS_SUCCESS
;
500 /* GetCommTimeouts */
504 status
= NtDeviceIoControlFile( handle
, NULL
, NULL
, NULL
, &io
,
505 IOCTL_SERIAL_GET_TIMEOUTS
, NULL
, 0, &st
, sizeof(st
) );
507 *avail_mode
= (!st
.ReadTotalTimeoutMultiplier
&&
508 !st
.ReadTotalTimeoutConstant
&&
509 st
.ReadIntervalTimeout
== MAXDWORD
);
512 case FD_TYPE_MAILSLOT
:
526 /******************************************************************************
527 * NtReadFile [NTDLL.@]
528 * ZwReadFile [NTDLL.@]
530 * Read from an open file handle.
533 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
534 * Event [I] Event to signal upon completion (or NULL)
535 * ApcRoutine [I] Callback to call upon completion (or NULL)
536 * ApcContext [I] Context for ApcRoutine (or NULL)
537 * IoStatusBlock [O] Receives information about the operation on return
538 * Buffer [O] Destination for the data read
539 * Length [I] Size of Buffer
540 * ByteOffset [O] Destination for the new file pointer position (or NULL)
541 * Key [O] Function unknown (may be NULL)
544 * Success: 0. IoStatusBlock is updated, and the Information member contains
545 * The number of bytes read.
546 * Failure: An NTSTATUS error code describing the error.
548 NTSTATUS WINAPI
NtReadFile(HANDLE hFile
, HANDLE hEvent
,
549 PIO_APC_ROUTINE apc
, void* apc_user
,
550 PIO_STATUS_BLOCK io_status
, void* buffer
, ULONG length
,
551 PLARGE_INTEGER offset
, PULONG key
)
553 int result
, unix_handle
, needs_close
, timeout_init_done
= 0;
554 unsigned int options
;
555 struct io_timeouts timeouts
;
558 enum server_fd_type type
;
559 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_user
;
561 TRACE("(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p),partial stub!\n",
562 hFile
,hEvent
,apc
,apc_user
,io_status
,buffer
,length
,offset
,key
);
564 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
566 status
= server_get_unix_fd( hFile
, FILE_READ_DATA
, &unix_handle
,
567 &needs_close
, &type
, &options
);
568 if (status
) return status
;
570 if (type
== FD_TYPE_FILE
&& offset
&& offset
->QuadPart
!= (LONGLONG
)-2 /* FILE_USE_FILE_POINTER_POSITION */ )
572 /* async I/O doesn't make sense on regular files */
573 while ((result
= pread( unix_handle
, buffer
, length
, offset
->QuadPart
)) == -1)
577 status
= FILE_GetNtStatus();
581 if (options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
))
582 /* update file pointer position */
583 lseek( unix_handle
, offset
->QuadPart
+ result
, SEEK_SET
);
586 status
= total
? STATUS_SUCCESS
: STATUS_END_OF_FILE
;
592 if ((result
= read( unix_handle
, (char *)buffer
+ total
, length
- total
)) >= 0)
595 if (!result
|| total
== length
)
599 status
= STATUS_SUCCESS
;
606 status
= STATUS_END_OF_FILE
;
611 status
= STATUS_PIPE_BROKEN
;
615 else if (type
== FD_TYPE_FILE
) continue; /* no async I/O on regular files */
619 if (errno
== EINTR
) continue;
622 status
= FILE_GetNtStatus();
627 if (!(options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
)))
629 async_fileio_read
*fileio
;
632 if ((status
= get_io_avail_mode( hFile
, type
, &avail_mode
)))
634 if (total
&& avail_mode
)
636 status
= STATUS_SUCCESS
;
640 if (!(fileio
= RtlAllocateHeap(GetProcessHeap(), 0, sizeof(*fileio
))))
642 status
= STATUS_NO_MEMORY
;
645 fileio
->io
.handle
= hFile
;
646 fileio
->io
.apc
= apc
;
647 fileio
->io
.apc_arg
= apc_user
;
648 fileio
->already
= total
;
649 fileio
->count
= length
;
650 fileio
->buffer
= buffer
;
651 fileio
->avail_mode
= avail_mode
;
653 SERVER_START_REQ( register_async
)
655 req
->type
= ASYNC_TYPE_READ
;
657 req
->async
.handle
= wine_server_obj_handle( hFile
);
658 req
->async
.event
= wine_server_obj_handle( hEvent
);
659 req
->async
.callback
= FILE_AsyncReadService
;
660 req
->async
.iosb
= io_status
;
661 req
->async
.arg
= fileio
;
662 req
->async
.apc
= fileio_apc
;
663 req
->async
.cvalue
= cvalue
;
664 status
= wine_server_call( req
);
668 if (status
!= STATUS_PENDING
) RtlFreeHeap( GetProcessHeap(), 0, fileio
);
671 else /* synchronous read, wait for the fd to become ready */
676 if (!timeout_init_done
)
678 timeout_init_done
= 1;
679 if ((status
= get_io_timeouts( hFile
, type
, length
, TRUE
, &timeouts
)))
681 if (hEvent
) NtResetEvent( hEvent
, NULL
);
683 timeout
= get_next_io_timeout( &timeouts
, total
);
685 pfd
.fd
= unix_handle
;
688 if (!timeout
|| !(ret
= poll( &pfd
, 1, timeout
)))
690 if (total
) /* return with what we got so far */
691 status
= STATUS_SUCCESS
;
693 status
= (type
== FD_TYPE_MAILSLOT
) ? STATUS_IO_TIMEOUT
: STATUS_TIMEOUT
;
696 if (ret
== -1 && errno
!= EINTR
)
698 status
= FILE_GetNtStatus();
701 /* will now restart the read */
706 if (cvalue
) NTDLL_AddCompletion( hFile
, cvalue
, status
, total
);
709 if (needs_close
) close( unix_handle
);
710 if (status
== STATUS_SUCCESS
)
712 io_status
->u
.Status
= status
;
713 io_status
->Information
= total
;
714 TRACE("= SUCCESS (%u)\n", total
);
715 if (hEvent
) NtSetEvent( hEvent
, NULL
);
716 if (apc
) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC
)apc
,
717 (ULONG_PTR
)apc_user
, (ULONG_PTR
)io_status
, 0 );
721 TRACE("= 0x%08x\n", status
);
722 if (status
!= STATUS_PENDING
&& hEvent
) NtResetEvent( hEvent
, NULL
);
728 /******************************************************************************
729 * NtReadFileScatter [NTDLL.@]
730 * ZwReadFileScatter [NTDLL.@]
732 NTSTATUS WINAPI
NtReadFileScatter( HANDLE file
, HANDLE event
, PIO_APC_ROUTINE apc
, void *apc_user
,
733 PIO_STATUS_BLOCK io_status
, FILE_SEGMENT_ELEMENT
*segments
,
734 ULONG length
, PLARGE_INTEGER offset
, PULONG key
)
736 size_t page_size
= getpagesize();
737 int result
, unix_handle
, needs_close
;
738 unsigned int options
;
740 ULONG pos
= 0, total
= 0;
741 enum server_fd_type type
;
742 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_user
;
744 TRACE( "(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p),partial stub!\n",
745 file
, event
, apc
, apc_user
, io_status
, segments
, length
, offset
, key
);
747 if (length
% page_size
) return STATUS_INVALID_PARAMETER
;
748 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
750 status
= server_get_unix_fd( file
, FILE_READ_DATA
, &unix_handle
,
751 &needs_close
, &type
, &options
);
752 if (status
) return status
;
754 if ((type
!= FD_TYPE_FILE
) ||
755 (options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
)) ||
756 !(options
& FILE_NO_INTERMEDIATE_BUFFERING
))
758 status
= STATUS_INVALID_PARAMETER
;
764 if (offset
&& offset
->QuadPart
!= (LONGLONG
)-2 /* FILE_USE_FILE_POINTER_POSITION */)
765 result
= pread( unix_handle
, (char *)segments
->Buffer
+ pos
,
766 page_size
- pos
, offset
->QuadPart
+ total
);
768 result
= read( unix_handle
, (char *)segments
->Buffer
+ pos
, page_size
- pos
);
772 if (errno
== EINTR
) continue;
773 status
= FILE_GetNtStatus();
778 status
= STATUS_END_OF_FILE
;
783 if ((pos
+= result
) == page_size
)
790 if (cvalue
) NTDLL_AddCompletion( file
, cvalue
, status
, total
);
793 if (needs_close
) close( unix_handle
);
794 if (status
== STATUS_SUCCESS
)
796 io_status
->u
.Status
= status
;
797 io_status
->Information
= total
;
798 TRACE("= SUCCESS (%u)\n", total
);
799 if (event
) NtSetEvent( event
, NULL
);
800 if (apc
) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC
)apc
,
801 (ULONG_PTR
)apc_user
, (ULONG_PTR
)io_status
, 0 );
805 TRACE("= 0x%08x\n", status
);
806 if (status
!= STATUS_PENDING
&& event
) NtResetEvent( event
, NULL
);
812 /***********************************************************************
813 * FILE_AsyncWriteService (INTERNAL)
815 static NTSTATUS
FILE_AsyncWriteService(void *user
, IO_STATUS_BLOCK
*iosb
, NTSTATUS status
, ULONG
*total
)
817 async_fileio_write
*fileio
= user
;
818 int result
, fd
, needs_close
;
819 enum server_fd_type type
;
824 /* write some data (non-blocking) */
825 if ((status
= server_get_unix_fd( fileio
->io
.handle
, FILE_WRITE_DATA
, &fd
,
826 &needs_close
, &type
, NULL
)))
829 if (!fileio
->count
&& (type
== FD_TYPE_MAILSLOT
|| type
== FD_TYPE_PIPE
|| type
== FD_TYPE_SOCKET
))
830 result
= send( fd
, fileio
->buffer
, 0, 0 );
832 result
= write( fd
, &fileio
->buffer
[fileio
->already
], fileio
->count
- fileio
->already
);
834 if (needs_close
) close( fd
);
838 if (errno
== EAGAIN
|| errno
== EINTR
) status
= STATUS_PENDING
;
839 else status
= FILE_GetNtStatus();
843 fileio
->already
+= result
;
844 status
= (fileio
->already
< fileio
->count
) ? STATUS_PENDING
: STATUS_SUCCESS
;
849 case STATUS_IO_TIMEOUT
:
850 if (fileio
->already
) status
= STATUS_SUCCESS
;
853 if (status
!= STATUS_PENDING
)
855 iosb
->u
.Status
= status
;
856 iosb
->Information
= *total
= fileio
->already
;
861 /******************************************************************************
862 * NtWriteFile [NTDLL.@]
863 * ZwWriteFile [NTDLL.@]
865 * Write to an open file handle.
868 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
869 * Event [I] Event to signal upon completion (or NULL)
870 * ApcRoutine [I] Callback to call upon completion (or NULL)
871 * ApcContext [I] Context for ApcRoutine (or NULL)
872 * IoStatusBlock [O] Receives information about the operation on return
873 * Buffer [I] Source for the data to write
874 * Length [I] Size of Buffer
875 * ByteOffset [O] Destination for the new file pointer position (or NULL)
876 * Key [O] Function unknown (may be NULL)
879 * Success: 0. IoStatusBlock is updated, and the Information member contains
880 * The number of bytes written.
881 * Failure: An NTSTATUS error code describing the error.
883 NTSTATUS WINAPI
NtWriteFile(HANDLE hFile
, HANDLE hEvent
,
884 PIO_APC_ROUTINE apc
, void* apc_user
,
885 PIO_STATUS_BLOCK io_status
,
886 const void* buffer
, ULONG length
,
887 PLARGE_INTEGER offset
, PULONG key
)
889 int result
, unix_handle
, needs_close
, timeout_init_done
= 0;
890 unsigned int options
;
891 struct io_timeouts timeouts
;
894 enum server_fd_type type
;
895 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_user
;
897 TRACE("(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p)!\n",
898 hFile
,hEvent
,apc
,apc_user
,io_status
,buffer
,length
,offset
,key
);
900 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
902 status
= server_get_unix_fd( hFile
, FILE_WRITE_DATA
, &unix_handle
,
903 &needs_close
, &type
, &options
);
904 if (status
) return status
;
906 if (type
== FD_TYPE_FILE
&& offset
&& offset
->QuadPart
!= (LONGLONG
)-2 /* FILE_USE_FILE_POINTER_POSITION */ )
908 /* async I/O doesn't make sense on regular files */
909 while ((result
= pwrite( unix_handle
, buffer
, length
, offset
->QuadPart
)) == -1)
913 if (errno
== EFAULT
) status
= STATUS_INVALID_USER_BUFFER
;
914 else status
= FILE_GetNtStatus();
919 if (options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
))
920 /* update file pointer position */
921 lseek( unix_handle
, offset
->QuadPart
+ result
, SEEK_SET
);
924 status
= STATUS_SUCCESS
;
930 /* zero-length writes on sockets may not work with plain write(2) */
931 if (!length
&& (type
== FD_TYPE_MAILSLOT
|| type
== FD_TYPE_PIPE
|| type
== FD_TYPE_SOCKET
))
932 result
= send( unix_handle
, buffer
, 0, 0 );
934 result
= write( unix_handle
, (const char *)buffer
+ total
, length
- total
);
941 status
= STATUS_SUCCESS
;
944 if (type
== FD_TYPE_FILE
) continue; /* no async I/O on regular files */
948 if (errno
== EINTR
) continue;
953 status
= STATUS_INVALID_USER_BUFFER
;
956 status
= FILE_GetNtStatus();
961 if (!(options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
)))
963 async_fileio_write
*fileio
;
965 if (!(fileio
= RtlAllocateHeap(GetProcessHeap(), 0, sizeof(*fileio
))))
967 status
= STATUS_NO_MEMORY
;
970 fileio
->io
.handle
= hFile
;
971 fileio
->io
.apc
= apc
;
972 fileio
->io
.apc_arg
= apc_user
;
973 fileio
->already
= total
;
974 fileio
->count
= length
;
975 fileio
->buffer
= buffer
;
977 SERVER_START_REQ( register_async
)
979 req
->type
= ASYNC_TYPE_WRITE
;
981 req
->async
.handle
= wine_server_obj_handle( hFile
);
982 req
->async
.event
= wine_server_obj_handle( hEvent
);
983 req
->async
.callback
= FILE_AsyncWriteService
;
984 req
->async
.iosb
= io_status
;
985 req
->async
.arg
= fileio
;
986 req
->async
.apc
= fileio_apc
;
987 req
->async
.cvalue
= cvalue
;
988 status
= wine_server_call( req
);
992 if (status
!= STATUS_PENDING
) RtlFreeHeap( GetProcessHeap(), 0, fileio
);
995 else /* synchronous write, wait for the fd to become ready */
1000 if (!timeout_init_done
)
1002 timeout_init_done
= 1;
1003 if ((status
= get_io_timeouts( hFile
, type
, length
, FALSE
, &timeouts
)))
1005 if (hEvent
) NtResetEvent( hEvent
, NULL
);
1007 timeout
= get_next_io_timeout( &timeouts
, total
);
1009 pfd
.fd
= unix_handle
;
1010 pfd
.events
= POLLOUT
;
1012 if (!timeout
|| !(ret
= poll( &pfd
, 1, timeout
)))
1014 /* return with what we got so far */
1015 status
= total
? STATUS_SUCCESS
: STATUS_TIMEOUT
;
1018 if (ret
== -1 && errno
!= EINTR
)
1020 status
= FILE_GetNtStatus();
1023 /* will now restart the write */
1028 if (cvalue
) NTDLL_AddCompletion( hFile
, cvalue
, status
, total
);
1031 if (needs_close
) close( unix_handle
);
1032 if (status
== STATUS_SUCCESS
)
1034 io_status
->u
.Status
= status
;
1035 io_status
->Information
= total
;
1036 TRACE("= SUCCESS (%u)\n", total
);
1037 if (hEvent
) NtSetEvent( hEvent
, NULL
);
1038 if (apc
) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC
)apc
,
1039 (ULONG_PTR
)apc_user
, (ULONG_PTR
)io_status
, 0 );
1043 TRACE("= 0x%08x\n", status
);
1044 if (status
!= STATUS_PENDING
&& hEvent
) NtResetEvent( hEvent
, NULL
);
1050 /******************************************************************************
1051 * NtWriteFileGather [NTDLL.@]
1052 * ZwWriteFileGather [NTDLL.@]
1054 NTSTATUS WINAPI
NtWriteFileGather( HANDLE file
, HANDLE event
, PIO_APC_ROUTINE apc
, void *apc_user
,
1055 PIO_STATUS_BLOCK io_status
, FILE_SEGMENT_ELEMENT
*segments
,
1056 ULONG length
, PLARGE_INTEGER offset
, PULONG key
)
1058 size_t page_size
= getpagesize();
1059 int result
, unix_handle
, needs_close
;
1060 unsigned int options
;
1062 ULONG pos
= 0, total
= 0;
1063 enum server_fd_type type
;
1064 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_user
;
1066 TRACE( "(%p,%p,%p,%p,%p,%p,0x%08x,%p,%p),partial stub!\n",
1067 file
, event
, apc
, apc_user
, io_status
, segments
, length
, offset
, key
);
1069 if (length
% page_size
) return STATUS_INVALID_PARAMETER
;
1070 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
1072 status
= server_get_unix_fd( file
, FILE_WRITE_DATA
, &unix_handle
,
1073 &needs_close
, &type
, &options
);
1074 if (status
) return status
;
1076 if ((type
!= FD_TYPE_FILE
) ||
1077 (options
& (FILE_SYNCHRONOUS_IO_ALERT
| FILE_SYNCHRONOUS_IO_NONALERT
)) ||
1078 !(options
& FILE_NO_INTERMEDIATE_BUFFERING
))
1080 status
= STATUS_INVALID_PARAMETER
;
1086 if (offset
&& offset
->QuadPart
!= (LONGLONG
)-2 /* FILE_USE_FILE_POINTER_POSITION */)
1087 result
= pwrite( unix_handle
, (char *)segments
->Buffer
+ pos
,
1088 page_size
- pos
, offset
->QuadPart
+ total
);
1090 result
= write( unix_handle
, (char *)segments
->Buffer
+ pos
, page_size
- pos
);
1094 if (errno
== EINTR
) continue;
1095 if (errno
== EFAULT
)
1097 status
= STATUS_INVALID_USER_BUFFER
;
1100 status
= FILE_GetNtStatus();
1105 status
= STATUS_DISK_FULL
;
1110 if ((pos
+= result
) == page_size
)
1117 if (cvalue
) NTDLL_AddCompletion( file
, cvalue
, status
, total
);
1120 if (needs_close
) close( unix_handle
);
1121 if (status
== STATUS_SUCCESS
)
1123 io_status
->u
.Status
= status
;
1124 io_status
->Information
= total
;
1125 TRACE("= SUCCESS (%u)\n", total
);
1126 if (event
) NtSetEvent( event
, NULL
);
1127 if (apc
) NtQueueApcThread( GetCurrentThread(), (PNTAPCFUNC
)apc
,
1128 (ULONG_PTR
)apc_user
, (ULONG_PTR
)io_status
, 0 );
1132 TRACE("= 0x%08x\n", status
);
1133 if (status
!= STATUS_PENDING
&& event
) NtResetEvent( event
, NULL
);
1141 HANDLE handle
; /* handle to the device */
1142 void *buffer
; /* buffer for output */
1143 ULONG size
; /* size of buffer */
1144 PIO_APC_ROUTINE apc
; /* user apc params */
1148 /* callback for ioctl async I/O completion */
1149 static NTSTATUS
ioctl_completion( void *arg
, IO_STATUS_BLOCK
*io
, NTSTATUS status
, ULONG
*total
)
1151 struct async_ioctl
*async
= arg
;
1153 if (status
== STATUS_ALERTED
)
1155 SERVER_START_REQ( get_ioctl_result
)
1157 req
->handle
= wine_server_obj_handle( async
->handle
);
1158 req
->user_arg
= async
;
1159 wine_server_set_reply( req
, async
->buffer
, async
->size
);
1160 if (!(status
= wine_server_call( req
)))
1161 io
->Information
= *total
= wine_server_reply_size( reply
);
1165 if (status
!= STATUS_PENDING
) io
->u
.Status
= status
;
1169 /* callback for ioctl user APC */
1170 static void WINAPI
ioctl_apc( void *arg
, IO_STATUS_BLOCK
*io
, ULONG reserved
)
1172 struct async_ioctl
*async
= arg
;
1173 if (async
->apc
) async
->apc( async
->apc_arg
, io
, reserved
);
1174 RtlFreeHeap( GetProcessHeap(), 0, async
);
1177 /* do a ioctl call through the server */
1178 static NTSTATUS
server_ioctl_file( HANDLE handle
, HANDLE event
,
1179 PIO_APC_ROUTINE apc
, PVOID apc_context
,
1180 IO_STATUS_BLOCK
*io
, ULONG code
,
1181 const void *in_buffer
, ULONG in_size
,
1182 PVOID out_buffer
, ULONG out_size
)
1184 struct async_ioctl
*async
;
1188 ULONG_PTR cvalue
= apc
? 0 : (ULONG_PTR
)apc_context
;
1190 if (!(async
= RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*async
) )))
1191 return STATUS_NO_MEMORY
;
1192 async
->handle
= handle
;
1193 async
->buffer
= out_buffer
;
1194 async
->size
= out_size
;
1196 async
->apc_arg
= apc_context
;
1198 SERVER_START_REQ( ioctl
)
1201 req
->async
.handle
= wine_server_obj_handle( handle
);
1202 req
->async
.callback
= ioctl_completion
;
1203 req
->async
.iosb
= io
;
1204 req
->async
.arg
= async
;
1205 req
->async
.apc
= (apc
|| event
) ? ioctl_apc
: NULL
;
1206 req
->async
.event
= wine_server_obj_handle( event
);
1207 req
->async
.cvalue
= cvalue
;
1208 wine_server_add_data( req
, in_buffer
, in_size
);
1209 wine_server_set_reply( req
, out_buffer
, out_size
);
1210 if (!(status
= wine_server_call( req
)))
1211 io
->Information
= wine_server_reply_size( reply
);
1212 wait_handle
= wine_server_ptr_handle( reply
->wait
);
1213 options
= reply
->options
;
1217 if (status
== STATUS_NOT_SUPPORTED
)
1218 FIXME("Unsupported ioctl %x (device=%x access=%x func=%x method=%x)\n",
1219 code
, code
>> 16, (code
>> 14) & 3, (code
>> 2) & 0xfff, code
& 3);
1221 if (status
!= STATUS_PENDING
) RtlFreeHeap( GetProcessHeap(), 0, async
);
1225 NtWaitForSingleObject( wait_handle
, (options
& FILE_SYNCHRONOUS_IO_ALERT
), NULL
);
1226 status
= io
->u
.Status
;
1227 NtClose( wait_handle
);
1228 RtlFreeHeap( GetProcessHeap(), 0, async
);
1235 /**************************************************************************
1236 * NtDeviceIoControlFile [NTDLL.@]
1237 * ZwDeviceIoControlFile [NTDLL.@]
1239 * Perform an I/O control operation on an open file handle.
1242 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1243 * event [I] Event to signal upon completion (or NULL)
1244 * apc [I] Callback to call upon completion (or NULL)
1245 * apc_context [I] Context for ApcRoutine (or NULL)
1246 * io [O] Receives information about the operation on return
1247 * code [I] Control code for the operation to perform
1248 * in_buffer [I] Source for any input data required (or NULL)
1249 * in_size [I] Size of InputBuffer
1250 * out_buffer [O] Source for any output data returned (or NULL)
1251 * out_size [I] Size of OutputBuffer
1254 * Success: 0. IoStatusBlock is updated.
1255 * Failure: An NTSTATUS error code describing the error.
1257 NTSTATUS WINAPI
NtDeviceIoControlFile(HANDLE handle
, HANDLE event
,
1258 PIO_APC_ROUTINE apc
, PVOID apc_context
,
1259 PIO_STATUS_BLOCK io
, ULONG code
,
1260 PVOID in_buffer
, ULONG in_size
,
1261 PVOID out_buffer
, ULONG out_size
)
1263 ULONG device
= (code
>> 16);
1264 NTSTATUS status
= STATUS_NOT_SUPPORTED
;
1266 TRACE("(%p,%p,%p,%p,%p,0x%08x,%p,0x%08x,%p,0x%08x)\n",
1267 handle
, event
, apc
, apc_context
, io
, code
,
1268 in_buffer
, in_size
, out_buffer
, out_size
);
1272 case FILE_DEVICE_DISK
:
1273 case FILE_DEVICE_CD_ROM
:
1274 case FILE_DEVICE_DVD
:
1275 case FILE_DEVICE_CONTROLLER
:
1276 case FILE_DEVICE_MASS_STORAGE
:
1277 status
= CDROM_DeviceIoControl(handle
, event
, apc
, apc_context
, io
, code
,
1278 in_buffer
, in_size
, out_buffer
, out_size
);
1280 case FILE_DEVICE_SERIAL_PORT
:
1281 status
= COMM_DeviceIoControl(handle
, event
, apc
, apc_context
, io
, code
,
1282 in_buffer
, in_size
, out_buffer
, out_size
);
1284 case FILE_DEVICE_TAPE
:
1285 status
= TAPE_DeviceIoControl(handle
, event
, apc
, apc_context
, io
, code
,
1286 in_buffer
, in_size
, out_buffer
, out_size
);
1290 if (status
== STATUS_NOT_SUPPORTED
|| status
== STATUS_BAD_DEVICE_TYPE
)
1291 status
= server_ioctl_file( handle
, event
, apc
, apc_context
, io
, code
,
1292 in_buffer
, in_size
, out_buffer
, out_size
);
1294 if (status
!= STATUS_PENDING
) io
->u
.Status
= status
;
1299 /**************************************************************************
1300 * NtFsControlFile [NTDLL.@]
1301 * ZwFsControlFile [NTDLL.@]
1303 * Perform a file system control operation on an open file handle.
1306 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1307 * event [I] Event to signal upon completion (or NULL)
1308 * apc [I] Callback to call upon completion (or NULL)
1309 * apc_context [I] Context for ApcRoutine (or NULL)
1310 * io [O] Receives information about the operation on return
1311 * code [I] Control code for the operation to perform
1312 * in_buffer [I] Source for any input data required (or NULL)
1313 * in_size [I] Size of InputBuffer
1314 * out_buffer [O] Source for any output data returned (or NULL)
1315 * out_size [I] Size of OutputBuffer
1318 * Success: 0. IoStatusBlock is updated.
1319 * Failure: An NTSTATUS error code describing the error.
1321 NTSTATUS WINAPI
NtFsControlFile(HANDLE handle
, HANDLE event
, PIO_APC_ROUTINE apc
,
1322 PVOID apc_context
, PIO_STATUS_BLOCK io
, ULONG code
,
1323 PVOID in_buffer
, ULONG in_size
, PVOID out_buffer
, ULONG out_size
)
1327 TRACE("(%p,%p,%p,%p,%p,0x%08x,%p,0x%08x,%p,0x%08x)\n",
1328 handle
, event
, apc
, apc_context
, io
, code
,
1329 in_buffer
, in_size
, out_buffer
, out_size
);
1331 if (!io
) return STATUS_INVALID_PARAMETER
;
1335 case FSCTL_DISMOUNT_VOLUME
:
1336 status
= server_ioctl_file( handle
, event
, apc
, apc_context
, io
, code
,
1337 in_buffer
, in_size
, out_buffer
, out_size
);
1338 if (!status
) status
= DIR_unmount_device( handle
);
1341 case FSCTL_PIPE_PEEK
:
1343 FILE_PIPE_PEEK_BUFFER
*buffer
= out_buffer
;
1344 int avail
= 0, fd
, needs_close
;
1346 if (out_size
< FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER
, Data
))
1348 status
= STATUS_INFO_LENGTH_MISMATCH
;
1352 if ((status
= server_get_unix_fd( handle
, FILE_READ_DATA
, &fd
, &needs_close
, NULL
, NULL
)))
1356 if (ioctl( fd
, FIONREAD
, &avail
) != 0)
1358 TRACE("FIONREAD failed reason: %s\n",strerror(errno
));
1359 if (needs_close
) close( fd
);
1360 status
= FILE_GetNtStatus();
1364 if (!avail
) /* check for closed pipe */
1366 struct pollfd pollfd
;
1370 pollfd
.events
= POLLIN
;
1372 ret
= poll( &pollfd
, 1, 0 );
1373 if (ret
== -1 || (ret
== 1 && (pollfd
.revents
& (POLLHUP
|POLLERR
))))
1375 if (needs_close
) close( fd
);
1376 status
= STATUS_PIPE_BROKEN
;
1380 buffer
->NamedPipeState
= 0; /* FIXME */
1381 buffer
->ReadDataAvailable
= avail
;
1382 buffer
->NumberOfMessages
= 0; /* FIXME */
1383 buffer
->MessageLength
= 0; /* FIXME */
1384 io
->Information
= FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER
, Data
);
1385 status
= STATUS_SUCCESS
;
1388 ULONG data_size
= out_size
- FIELD_OFFSET( FILE_PIPE_PEEK_BUFFER
, Data
);
1391 int res
= recv( fd
, buffer
->Data
, data_size
, MSG_PEEK
);
1392 if (res
>= 0) io
->Information
+= res
;
1395 if (needs_close
) close( fd
);
1399 case FSCTL_PIPE_DISCONNECT
:
1400 status
= server_ioctl_file( handle
, event
, apc
, apc_context
, io
, code
,
1401 in_buffer
, in_size
, out_buffer
, out_size
);
1404 int fd
= server_remove_fd_from_cache( handle
);
1405 if (fd
!= -1) close( fd
);
1409 case FSCTL_PIPE_IMPERSONATE
:
1410 FIXME("FSCTL_PIPE_IMPERSONATE: impersonating self\n");
1411 status
= RtlImpersonateSelf( SecurityImpersonation
);
1414 case FSCTL_LOCK_VOLUME
:
1415 case FSCTL_UNLOCK_VOLUME
:
1416 FIXME("stub! return success - Unsupported fsctl %x (device=%x access=%x func=%x method=%x)\n",
1417 code
, code
>> 16, (code
>> 14) & 3, (code
>> 2) & 0xfff, code
& 3);
1418 status
= STATUS_SUCCESS
;
1421 case FSCTL_PIPE_LISTEN
:
1422 case FSCTL_PIPE_WAIT
:
1424 status
= server_ioctl_file( handle
, event
, apc
, apc_context
, io
, code
,
1425 in_buffer
, in_size
, out_buffer
, out_size
);
1429 if (status
!= STATUS_PENDING
) io
->u
.Status
= status
;
1433 /******************************************************************************
1434 * NtSetVolumeInformationFile [NTDLL.@]
1435 * ZwSetVolumeInformationFile [NTDLL.@]
1437 * Set volume information for an open file handle.
1440 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1441 * IoStatusBlock [O] Receives information about the operation on return
1442 * FsInformation [I] Source for volume information
1443 * Length [I] Size of FsInformation
1444 * FsInformationClass [I] Type of volume information to set
1447 * Success: 0. IoStatusBlock is updated.
1448 * Failure: An NTSTATUS error code describing the error.
1450 NTSTATUS WINAPI
NtSetVolumeInformationFile(
1451 IN HANDLE FileHandle
,
1452 PIO_STATUS_BLOCK IoStatusBlock
,
1453 PVOID FsInformation
,
1455 FS_INFORMATION_CLASS FsInformationClass
)
1457 FIXME("(%p,%p,%p,0x%08x,0x%08x) stub\n",
1458 FileHandle
,IoStatusBlock
,FsInformation
,Length
,FsInformationClass
);
1462 /******************************************************************************
1463 * NtQueryInformationFile [NTDLL.@]
1464 * ZwQueryInformationFile [NTDLL.@]
1466 * Get information about an open file handle.
1469 * hFile [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1470 * io [O] Receives information about the operation on return
1471 * ptr [O] Destination for file information
1472 * len [I] Size of FileInformation
1473 * class [I] Type of file information to get
1476 * Success: 0. IoStatusBlock and FileInformation are updated.
1477 * Failure: An NTSTATUS error code describing the error.
1479 NTSTATUS WINAPI
NtQueryInformationFile( HANDLE hFile
, PIO_STATUS_BLOCK io
,
1480 PVOID ptr
, LONG len
, FILE_INFORMATION_CLASS
class )
1482 static const size_t info_sizes
[] =
1485 sizeof(FILE_DIRECTORY_INFORMATION
), /* FileDirectoryInformation */
1486 sizeof(FILE_FULL_DIRECTORY_INFORMATION
), /* FileFullDirectoryInformation */
1487 sizeof(FILE_BOTH_DIRECTORY_INFORMATION
), /* FileBothDirectoryInformation */
1488 sizeof(FILE_BASIC_INFORMATION
), /* FileBasicInformation */
1489 sizeof(FILE_STANDARD_INFORMATION
), /* FileStandardInformation */
1490 sizeof(FILE_INTERNAL_INFORMATION
), /* FileInternalInformation */
1491 sizeof(FILE_EA_INFORMATION
), /* FileEaInformation */
1492 sizeof(FILE_ACCESS_INFORMATION
), /* FileAccessInformation */
1493 sizeof(FILE_NAME_INFORMATION
)-sizeof(WCHAR
), /* FileNameInformation */
1494 sizeof(FILE_RENAME_INFORMATION
)-sizeof(WCHAR
), /* FileRenameInformation */
1495 0, /* FileLinkInformation */
1496 sizeof(FILE_NAMES_INFORMATION
)-sizeof(WCHAR
), /* FileNamesInformation */
1497 sizeof(FILE_DISPOSITION_INFORMATION
), /* FileDispositionInformation */
1498 sizeof(FILE_POSITION_INFORMATION
), /* FilePositionInformation */
1499 sizeof(FILE_FULL_EA_INFORMATION
), /* FileFullEaInformation */
1500 sizeof(FILE_MODE_INFORMATION
), /* FileModeInformation */
1501 sizeof(FILE_ALIGNMENT_INFORMATION
), /* FileAlignmentInformation */
1502 sizeof(FILE_ALL_INFORMATION
)-sizeof(WCHAR
), /* FileAllInformation */
1503 sizeof(FILE_ALLOCATION_INFORMATION
), /* FileAllocationInformation */
1504 sizeof(FILE_END_OF_FILE_INFORMATION
), /* FileEndOfFileInformation */
1505 0, /* FileAlternateNameInformation */
1506 sizeof(FILE_STREAM_INFORMATION
)-sizeof(WCHAR
), /* FileStreamInformation */
1507 0, /* FilePipeInformation */
1508 sizeof(FILE_PIPE_LOCAL_INFORMATION
), /* FilePipeLocalInformation */
1509 0, /* FilePipeRemoteInformation */
1510 sizeof(FILE_MAILSLOT_QUERY_INFORMATION
), /* FileMailslotQueryInformation */
1511 0, /* FileMailslotSetInformation */
1512 0, /* FileCompressionInformation */
1513 0, /* FileObjectIdInformation */
1514 0, /* FileCompletionInformation */
1515 0, /* FileMoveClusterInformation */
1516 0, /* FileQuotaInformation */
1517 0, /* FileReparsePointInformation */
1518 0, /* FileNetworkOpenInformation */
1519 0, /* FileAttributeTagInformation */
1520 0 /* FileTrackingInformation */
1524 int fd
, needs_close
= FALSE
;
1526 TRACE("(%p,%p,%p,0x%08x,0x%08x)\n", hFile
, io
, ptr
, len
, class);
1528 io
->Information
= 0;
1530 if (class <= 0 || class >= FileMaximumInformation
)
1531 return io
->u
.Status
= STATUS_INVALID_INFO_CLASS
;
1532 if (!info_sizes
[class])
1534 FIXME("Unsupported class (%d)\n", class);
1535 return io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1537 if (len
< info_sizes
[class])
1538 return io
->u
.Status
= STATUS_INFO_LENGTH_MISMATCH
;
1540 if (class != FilePipeLocalInformation
)
1542 if ((io
->u
.Status
= server_get_unix_fd( hFile
, 0, &fd
, &needs_close
, NULL
, NULL
)))
1543 return io
->u
.Status
;
1548 case FileBasicInformation
:
1550 FILE_BASIC_INFORMATION
*info
= ptr
;
1552 if (fstat( fd
, &st
) == -1)
1553 io
->u
.Status
= FILE_GetNtStatus();
1554 else if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1555 io
->u
.Status
= STATUS_INVALID_INFO_CLASS
;
1558 if (S_ISDIR(st
.st_mode
)) info
->FileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1559 else info
->FileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1560 if (!(st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)))
1561 info
->FileAttributes
|= FILE_ATTRIBUTE_READONLY
;
1562 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->CreationTime
);
1563 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->LastWriteTime
);
1564 RtlSecondsSince1970ToTime( st
.st_ctime
, &info
->ChangeTime
);
1565 RtlSecondsSince1970ToTime( st
.st_atime
, &info
->LastAccessTime
);
1566 #ifdef HAVE_STRUCT_STAT_ST_MTIM
1567 info
->CreationTime
.QuadPart
+= st
.st_mtim
.tv_nsec
/ 100;
1568 info
->LastWriteTime
.QuadPart
+= st
.st_mtim
.tv_nsec
/ 100;
1570 #ifdef HAVE_STRUCT_STAT_ST_CTIM
1571 info
->ChangeTime
.QuadPart
+= st
.st_ctim
.tv_nsec
/ 100;
1573 #ifdef HAVE_STRUCT_STAT_ST_ATIM
1574 info
->LastAccessTime
.QuadPart
+= st
.st_atim
.tv_nsec
/ 100;
1579 case FileStandardInformation
:
1581 FILE_STANDARD_INFORMATION
*info
= ptr
;
1583 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1586 if ((info
->Directory
= S_ISDIR(st
.st_mode
)))
1588 info
->AllocationSize
.QuadPart
= 0;
1589 info
->EndOfFile
.QuadPart
= 0;
1590 info
->NumberOfLinks
= 1;
1591 info
->DeletePending
= FALSE
;
1595 info
->AllocationSize
.QuadPart
= (ULONGLONG
)st
.st_blocks
* 512;
1596 info
->EndOfFile
.QuadPart
= st
.st_size
;
1597 info
->NumberOfLinks
= st
.st_nlink
;
1598 info
->DeletePending
= FALSE
; /* FIXME */
1603 case FilePositionInformation
:
1605 FILE_POSITION_INFORMATION
*info
= ptr
;
1606 off_t res
= lseek( fd
, 0, SEEK_CUR
);
1607 if (res
== (off_t
)-1) io
->u
.Status
= FILE_GetNtStatus();
1608 else info
->CurrentByteOffset
.QuadPart
= res
;
1611 case FileInternalInformation
:
1613 FILE_INTERNAL_INFORMATION
*info
= ptr
;
1615 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1616 else info
->IndexNumber
.QuadPart
= st
.st_ino
;
1619 case FileEaInformation
:
1621 FILE_EA_INFORMATION
*info
= ptr
;
1625 case FileEndOfFileInformation
:
1627 FILE_END_OF_FILE_INFORMATION
*info
= ptr
;
1629 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1630 else info
->EndOfFile
.QuadPart
= S_ISDIR(st
.st_mode
) ? 0 : st
.st_size
;
1633 case FileAllInformation
:
1635 FILE_ALL_INFORMATION
*info
= ptr
;
1637 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1638 else if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1639 io
->u
.Status
= STATUS_INVALID_INFO_CLASS
;
1642 if ((info
->StandardInformation
.Directory
= S_ISDIR(st
.st_mode
)))
1644 info
->BasicInformation
.FileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1645 info
->StandardInformation
.AllocationSize
.QuadPart
= 0;
1646 info
->StandardInformation
.EndOfFile
.QuadPart
= 0;
1647 info
->StandardInformation
.NumberOfLinks
= 1;
1648 info
->StandardInformation
.DeletePending
= FALSE
;
1652 info
->BasicInformation
.FileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1653 info
->StandardInformation
.AllocationSize
.QuadPart
= (ULONGLONG
)st
.st_blocks
* 512;
1654 info
->StandardInformation
.EndOfFile
.QuadPart
= st
.st_size
;
1655 info
->StandardInformation
.NumberOfLinks
= st
.st_nlink
;
1656 info
->StandardInformation
.DeletePending
= FALSE
; /* FIXME */
1658 if (!(st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)))
1659 info
->BasicInformation
.FileAttributes
|= FILE_ATTRIBUTE_READONLY
;
1660 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->BasicInformation
.CreationTime
);
1661 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->BasicInformation
.LastWriteTime
);
1662 RtlSecondsSince1970ToTime( st
.st_ctime
, &info
->BasicInformation
.ChangeTime
);
1663 RtlSecondsSince1970ToTime( st
.st_atime
, &info
->BasicInformation
.LastAccessTime
);
1664 #ifdef HAVE_STRUCT_STAT_ST_MTIM
1665 info
->BasicInformation
.CreationTime
.QuadPart
+= st
.st_mtim
.tv_nsec
/ 100;
1666 info
->BasicInformation
.LastWriteTime
.QuadPart
+= st
.st_mtim
.tv_nsec
/ 100;
1668 #ifdef HAVE_STRUCT_STAT_ST_CTIM
1669 info
->BasicInformation
.ChangeTime
.QuadPart
+= st
.st_ctim
.tv_nsec
/ 100;
1671 #ifdef HAVE_STRUCT_STAT_ST_ATIM
1672 info
->BasicInformation
.LastAccessTime
.QuadPart
+= st
.st_atim
.tv_nsec
/ 100;
1674 info
->InternalInformation
.IndexNumber
.QuadPart
= st
.st_ino
;
1675 info
->EaInformation
.EaSize
= 0;
1676 info
->AccessInformation
.AccessFlags
= 0; /* FIXME */
1677 info
->PositionInformation
.CurrentByteOffset
.QuadPart
= lseek( fd
, 0, SEEK_CUR
);
1678 info
->ModeInformation
.Mode
= 0; /* FIXME */
1679 info
->AlignmentInformation
.AlignmentRequirement
= 1; /* FIXME */
1680 info
->NameInformation
.FileNameLength
= 0;
1681 io
->Information
= sizeof(*info
) - sizeof(WCHAR
);
1685 case FileMailslotQueryInformation
:
1687 FILE_MAILSLOT_QUERY_INFORMATION
*info
= ptr
;
1689 SERVER_START_REQ( set_mailslot_info
)
1691 req
->handle
= wine_server_obj_handle( hFile
);
1693 io
->u
.Status
= wine_server_call( req
);
1694 if( io
->u
.Status
== STATUS_SUCCESS
)
1696 info
->MaximumMessageSize
= reply
->max_msgsize
;
1697 info
->MailslotQuota
= 0;
1698 info
->NextMessageSize
= 0;
1699 info
->MessagesAvailable
= 0;
1700 info
->ReadTimeout
.QuadPart
= reply
->read_timeout
;
1707 ULONG size
= info
->MaximumMessageSize
? info
->MaximumMessageSize
: 0x10000;
1708 if (size
> 0x10000) size
= 0x10000;
1709 if ((tmpbuf
= RtlAllocateHeap( GetProcessHeap(), 0, size
)))
1711 int fd
, needs_close
;
1712 if (!server_get_unix_fd( hFile
, FILE_READ_DATA
, &fd
, &needs_close
, NULL
, NULL
))
1714 int res
= recv( fd
, tmpbuf
, size
, MSG_PEEK
);
1715 info
->MessagesAvailable
= (res
> 0);
1716 info
->NextMessageSize
= (res
>= 0) ? res
: MAILSLOT_NO_MESSAGE
;
1717 if (needs_close
) close( fd
);
1719 RtlFreeHeap( GetProcessHeap(), 0, tmpbuf
);
1724 case FilePipeLocalInformation
:
1726 FILE_PIPE_LOCAL_INFORMATION
* pli
= ptr
;
1728 SERVER_START_REQ( get_named_pipe_info
)
1730 req
->handle
= wine_server_obj_handle( hFile
);
1731 if (!(io
->u
.Status
= wine_server_call( req
)))
1733 pli
->NamedPipeType
= (reply
->flags
& NAMED_PIPE_MESSAGE_STREAM_WRITE
) ?
1734 FILE_PIPE_TYPE_MESSAGE
: FILE_PIPE_TYPE_BYTE
;
1735 pli
->NamedPipeConfiguration
= 0; /* FIXME */
1736 pli
->MaximumInstances
= reply
->maxinstances
;
1737 pli
->CurrentInstances
= reply
->instances
;
1738 pli
->InboundQuota
= reply
->insize
;
1739 pli
->ReadDataAvailable
= 0; /* FIXME */
1740 pli
->OutboundQuota
= reply
->outsize
;
1741 pli
->WriteQuotaAvailable
= 0; /* FIXME */
1742 pli
->NamedPipeState
= 0; /* FIXME */
1743 pli
->NamedPipeEnd
= (reply
->flags
& NAMED_PIPE_SERVER_END
) ?
1744 FILE_PIPE_SERVER_END
: FILE_PIPE_CLIENT_END
;
1751 FIXME("Unsupported class (%d)\n", class);
1752 io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1755 if (needs_close
) close( fd
);
1756 if (io
->u
.Status
== STATUS_SUCCESS
&& !io
->Information
) io
->Information
= info_sizes
[class];
1757 return io
->u
.Status
;
1760 /******************************************************************************
1761 * NtSetInformationFile [NTDLL.@]
1762 * ZwSetInformationFile [NTDLL.@]
1764 * Set information about an open file handle.
1767 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1768 * io [O] Receives information about the operation on return
1769 * ptr [I] Source for file information
1770 * len [I] Size of FileInformation
1771 * class [I] Type of file information to set
1774 * Success: 0. io is updated.
1775 * Failure: An NTSTATUS error code describing the error.
1777 NTSTATUS WINAPI
NtSetInformationFile(HANDLE handle
, PIO_STATUS_BLOCK io
,
1778 PVOID ptr
, ULONG len
, FILE_INFORMATION_CLASS
class)
1780 int fd
, needs_close
;
1782 TRACE("(%p,%p,%p,0x%08x,0x%08x)\n", handle
, io
, ptr
, len
, class);
1784 io
->u
.Status
= STATUS_SUCCESS
;
1787 case FileBasicInformation
:
1788 if (len
>= sizeof(FILE_BASIC_INFORMATION
))
1791 const FILE_BASIC_INFORMATION
*info
= ptr
;
1793 if ((io
->u
.Status
= server_get_unix_fd( handle
, 0, &fd
, &needs_close
, NULL
, NULL
)))
1794 return io
->u
.Status
;
1796 if (info
->LastAccessTime
.QuadPart
|| info
->LastWriteTime
.QuadPart
)
1798 ULONGLONG sec
, nsec
;
1799 struct timeval tv
[2];
1801 if (!info
->LastAccessTime
.QuadPart
|| !info
->LastWriteTime
.QuadPart
)
1804 tv
[0].tv_sec
= tv
[0].tv_usec
= 0;
1805 tv
[1].tv_sec
= tv
[1].tv_usec
= 0;
1806 if (!fstat( fd
, &st
))
1808 tv
[0].tv_sec
= st
.st_atime
;
1809 tv
[1].tv_sec
= st
.st_mtime
;
1812 if (info
->LastAccessTime
.QuadPart
)
1814 sec
= RtlLargeIntegerDivide( info
->LastAccessTime
.QuadPart
, 10000000, &nsec
);
1815 tv
[0].tv_sec
= sec
- SECS_1601_TO_1970
;
1816 tv
[0].tv_usec
= (UINT
)nsec
/ 10;
1818 if (info
->LastWriteTime
.QuadPart
)
1820 sec
= RtlLargeIntegerDivide( info
->LastWriteTime
.QuadPart
, 10000000, &nsec
);
1821 tv
[1].tv_sec
= sec
- SECS_1601_TO_1970
;
1822 tv
[1].tv_usec
= (UINT
)nsec
/ 10;
1824 if (futimes( fd
, tv
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1827 if (io
->u
.Status
== STATUS_SUCCESS
&& info
->FileAttributes
)
1829 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1832 if (info
->FileAttributes
& FILE_ATTRIBUTE_READONLY
)
1834 if (S_ISDIR( st
.st_mode
))
1835 WARN("FILE_ATTRIBUTE_READONLY ignored for directory.\n");
1837 st
.st_mode
&= ~0222; /* clear write permission bits */
1841 /* add write permission only where we already have read permission */
1842 st
.st_mode
|= (0600 | ((st
.st_mode
& 044) >> 1)) & (~FILE_umask
);
1844 if (fchmod( fd
, st
.st_mode
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1848 if (needs_close
) close( fd
);
1850 else io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1853 case FilePositionInformation
:
1854 if (len
>= sizeof(FILE_POSITION_INFORMATION
))
1856 const FILE_POSITION_INFORMATION
*info
= ptr
;
1858 if ((io
->u
.Status
= server_get_unix_fd( handle
, 0, &fd
, &needs_close
, NULL
, NULL
)))
1859 return io
->u
.Status
;
1861 if (lseek( fd
, info
->CurrentByteOffset
.QuadPart
, SEEK_SET
) == (off_t
)-1)
1862 io
->u
.Status
= FILE_GetNtStatus();
1864 if (needs_close
) close( fd
);
1866 else io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1869 case FileEndOfFileInformation
:
1870 if (len
>= sizeof(FILE_END_OF_FILE_INFORMATION
))
1873 const FILE_END_OF_FILE_INFORMATION
*info
= ptr
;
1875 if ((io
->u
.Status
= server_get_unix_fd( handle
, 0, &fd
, &needs_close
, NULL
, NULL
)))
1876 return io
->u
.Status
;
1878 /* first try normal truncate */
1879 if (ftruncate( fd
, (off_t
)info
->EndOfFile
.QuadPart
) != -1) break;
1881 /* now check for the need to extend the file */
1882 if (fstat( fd
, &st
) != -1 && (off_t
)info
->EndOfFile
.QuadPart
> st
.st_size
)
1884 static const char zero
;
1886 /* extend the file one byte beyond the requested size and then truncate it */
1887 /* this should work around ftruncate implementations that can't extend files */
1888 if (pwrite( fd
, &zero
, 1, (off_t
)info
->EndOfFile
.QuadPart
) != -1 &&
1889 ftruncate( fd
, (off_t
)info
->EndOfFile
.QuadPart
) != -1) break;
1891 io
->u
.Status
= FILE_GetNtStatus();
1893 if (needs_close
) close( fd
);
1895 else io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1898 case FileMailslotSetInformation
:
1900 FILE_MAILSLOT_SET_INFORMATION
*info
= ptr
;
1902 SERVER_START_REQ( set_mailslot_info
)
1904 req
->handle
= wine_server_obj_handle( handle
);
1905 req
->flags
= MAILSLOT_SET_READ_TIMEOUT
;
1906 req
->read_timeout
= info
->ReadTimeout
.QuadPart
;
1907 io
->u
.Status
= wine_server_call( req
);
1913 case FileCompletionInformation
:
1914 if (len
>= sizeof(FILE_COMPLETION_INFORMATION
))
1916 FILE_COMPLETION_INFORMATION
*info
= (FILE_COMPLETION_INFORMATION
*)ptr
;
1918 SERVER_START_REQ( set_completion_info
)
1920 req
->handle
= wine_server_obj_handle( handle
);
1921 req
->chandle
= wine_server_obj_handle( info
->CompletionPort
);
1922 req
->ckey
= info
->CompletionKey
;
1923 io
->u
.Status
= wine_server_call( req
);
1927 io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1931 FIXME("Unsupported class (%d)\n", class);
1932 io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1935 io
->Information
= 0;
1936 return io
->u
.Status
;
1940 /******************************************************************************
1941 * NtQueryFullAttributesFile (NTDLL.@)
1943 NTSTATUS WINAPI
NtQueryFullAttributesFile( const OBJECT_ATTRIBUTES
*attr
,
1944 FILE_NETWORK_OPEN_INFORMATION
*info
)
1946 ANSI_STRING unix_name
;
1949 if (!(status
= wine_nt_to_unix_file_name( attr
->ObjectName
, &unix_name
, FILE_OPEN
,
1950 !(attr
->Attributes
& OBJ_CASE_INSENSITIVE
) )))
1954 if (stat( unix_name
.Buffer
, &st
) == -1)
1955 status
= FILE_GetNtStatus();
1956 else if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1957 status
= STATUS_INVALID_INFO_CLASS
;
1960 if (S_ISDIR(st
.st_mode
))
1962 info
->FileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1963 info
->AllocationSize
.QuadPart
= 0;
1964 info
->EndOfFile
.QuadPart
= 0;
1968 info
->FileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1969 info
->AllocationSize
.QuadPart
= (ULONGLONG
)st
.st_blocks
* 512;
1970 info
->EndOfFile
.QuadPart
= st
.st_size
;
1972 if (!(st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)))
1973 info
->FileAttributes
|= FILE_ATTRIBUTE_READONLY
;
1974 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->CreationTime
);
1975 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->LastWriteTime
);
1976 RtlSecondsSince1970ToTime( st
.st_ctime
, &info
->ChangeTime
);
1977 RtlSecondsSince1970ToTime( st
.st_atime
, &info
->LastAccessTime
);
1978 if (DIR_is_hidden_file( attr
->ObjectName
))
1979 info
->FileAttributes
|= FILE_ATTRIBUTE_HIDDEN
;
1981 RtlFreeAnsiString( &unix_name
);
1983 else WARN("%s not found (%x)\n", debugstr_us(attr
->ObjectName
), status
);
1988 /******************************************************************************
1989 * NtQueryAttributesFile (NTDLL.@)
1990 * ZwQueryAttributesFile (NTDLL.@)
1992 NTSTATUS WINAPI
NtQueryAttributesFile( const OBJECT_ATTRIBUTES
*attr
, FILE_BASIC_INFORMATION
*info
)
1994 FILE_NETWORK_OPEN_INFORMATION full_info
;
1997 if (!(status
= NtQueryFullAttributesFile( attr
, &full_info
)))
1999 info
->CreationTime
.QuadPart
= full_info
.CreationTime
.QuadPart
;
2000 info
->LastAccessTime
.QuadPart
= full_info
.LastAccessTime
.QuadPart
;
2001 info
->LastWriteTime
.QuadPart
= full_info
.LastWriteTime
.QuadPart
;
2002 info
->ChangeTime
.QuadPart
= full_info
.ChangeTime
.QuadPart
;
2003 info
->FileAttributes
= full_info
.FileAttributes
;
2009 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__APPLE__)
2010 /* helper for FILE_GetDeviceInfo to hide some platform differences in fstatfs */
2011 static inline void get_device_info_fstatfs( FILE_FS_DEVICE_INFORMATION
*info
, const char *fstypename
,
2012 unsigned int flags
)
2014 if (!strcmp("cd9660", fstypename
) || !strcmp("udf", fstypename
))
2016 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
2017 /* Don't assume read-only, let the mount options set it below */
2018 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
2020 else if (!strcmp("nfs", fstypename
) || !strcmp("nwfs", fstypename
) ||
2021 !strcmp("smbfs", fstypename
) || !strcmp("afpfs", fstypename
))
2023 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
2024 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
2026 else if (!strcmp("procfs", fstypename
))
2027 info
->DeviceType
= FILE_DEVICE_VIRTUAL_DISK
;
2029 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2031 if (flags
& MNT_RDONLY
)
2032 info
->Characteristics
|= FILE_READ_ONLY_DEVICE
;
2034 if (!(flags
& MNT_LOCAL
))
2036 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
2037 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
2042 static inline int is_device_placeholder( int fd
)
2044 static const char wine_placeholder
[] = "Wine device placeholder";
2045 char buffer
[sizeof(wine_placeholder
)-1];
2047 if (pread( fd
, buffer
, sizeof(wine_placeholder
) - 1, 0 ) != sizeof(wine_placeholder
) - 1)
2049 return !memcmp( buffer
, wine_placeholder
, sizeof(wine_placeholder
) - 1 );
2052 /******************************************************************************
2055 * Implementation of the FileFsDeviceInformation query for NtQueryVolumeInformationFile.
2057 static NTSTATUS
get_device_info( int fd
, FILE_FS_DEVICE_INFORMATION
*info
)
2061 info
->Characteristics
= 0;
2062 if (fstat( fd
, &st
) < 0) return FILE_GetNtStatus();
2063 if (S_ISCHR( st
.st_mode
))
2065 info
->DeviceType
= FILE_DEVICE_UNKNOWN
;
2067 switch(major(st
.st_rdev
))
2070 info
->DeviceType
= FILE_DEVICE_NULL
;
2073 info
->DeviceType
= FILE_DEVICE_SERIAL_PORT
;
2076 info
->DeviceType
= FILE_DEVICE_PARALLEL_PORT
;
2078 case SCSI_TAPE_MAJOR
:
2079 info
->DeviceType
= FILE_DEVICE_TAPE
;
2084 else if (S_ISBLK( st
.st_mode
))
2086 info
->DeviceType
= FILE_DEVICE_DISK
;
2088 else if (S_ISFIFO( st
.st_mode
) || S_ISSOCK( st
.st_mode
))
2090 info
->DeviceType
= FILE_DEVICE_NAMED_PIPE
;
2092 else if (is_device_placeholder( fd
))
2094 info
->DeviceType
= FILE_DEVICE_DISK
;
2096 else /* regular file or directory */
2098 #if defined(linux) && defined(HAVE_FSTATFS)
2101 /* check for floppy disk */
2102 if (major(st
.st_dev
) == FLOPPY_MAJOR
)
2103 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
2105 if (fstatfs( fd
, &stfs
) < 0) stfs
.f_type
= 0;
2106 switch (stfs
.f_type
)
2108 case 0x9660: /* iso9660 */
2109 case 0x9fa1: /* supermount */
2110 case 0x15013346: /* udf */
2111 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
2112 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
|FILE_READ_ONLY_DEVICE
;
2114 case 0x6969: /* nfs */
2115 case 0x517B: /* smbfs */
2116 case 0x564c: /* ncpfs */
2117 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
2118 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
2120 case 0x01021994: /* tmpfs */
2121 case 0x28cd3d45: /* cramfs */
2122 case 0x1373: /* devfs */
2123 case 0x9fa0: /* procfs */
2124 info
->DeviceType
= FILE_DEVICE_VIRTUAL_DISK
;
2127 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2130 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__APPLE__)
2133 if (fstatfs( fd
, &stfs
) < 0)
2134 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2136 get_device_info_fstatfs( info
, stfs
.f_fstypename
, stfs
.f_flags
);
2137 #elif defined(__NetBSD__)
2138 struct statvfs stfs
;
2140 if (fstatvfs( fd
, &stfs
) < 0)
2141 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2143 get_device_info_fstatfs( info
, stfs
.f_fstypename
, stfs
.f_flag
);
2145 /* Use dkio to work out device types */
2147 # include <sys/dkio.h>
2148 # include <sys/vtoc.h>
2149 struct dk_cinfo dkinf
;
2150 int retval
= ioctl(fd
, DKIOCINFO
, &dkinf
);
2152 WARN("Unable to get disk device type information - assuming a disk like device\n");
2153 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2155 switch (dkinf
.dki_ctype
)
2158 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
2159 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
|FILE_READ_ONLY_DEVICE
;
2163 case DKC_INTEL82072
:
2164 case DKC_INTEL82077
:
2165 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2166 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
2169 info
->DeviceType
= FILE_DEVICE_VIRTUAL_DISK
;
2172 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2177 if (!warned
++) FIXME( "device info not properly supported on this platform\n" );
2178 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
2180 info
->Characteristics
|= FILE_DEVICE_IS_MOUNTED
;
2182 return STATUS_SUCCESS
;
2186 /******************************************************************************
2187 * NtQueryVolumeInformationFile [NTDLL.@]
2188 * ZwQueryVolumeInformationFile [NTDLL.@]
2190 * Get volume information for an open file handle.
2193 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
2194 * io [O] Receives information about the operation on return
2195 * buffer [O] Destination for volume information
2196 * length [I] Size of FsInformation
2197 * info_class [I] Type of volume information to set
2200 * Success: 0. io and buffer are updated.
2201 * Failure: An NTSTATUS error code describing the error.
2203 NTSTATUS WINAPI
NtQueryVolumeInformationFile( HANDLE handle
, PIO_STATUS_BLOCK io
,
2204 PVOID buffer
, ULONG length
,
2205 FS_INFORMATION_CLASS info_class
)
2207 int fd
, needs_close
;
2210 if ((io
->u
.Status
= server_get_unix_fd( handle
, 0, &fd
, &needs_close
, NULL
, NULL
)) != STATUS_SUCCESS
)
2211 return io
->u
.Status
;
2213 io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
2214 io
->Information
= 0;
2216 switch( info_class
)
2218 case FileFsVolumeInformation
:
2219 FIXME( "%p: volume info not supported\n", handle
);
2221 case FileFsLabelInformation
:
2222 FIXME( "%p: label info not supported\n", handle
);
2224 case FileFsSizeInformation
:
2225 if (length
< sizeof(FILE_FS_SIZE_INFORMATION
))
2226 io
->u
.Status
= STATUS_BUFFER_TOO_SMALL
;
2229 FILE_FS_SIZE_INFORMATION
*info
= buffer
;
2231 if (fstat( fd
, &st
) < 0)
2233 io
->u
.Status
= FILE_GetNtStatus();
2236 if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
2238 io
->u
.Status
= STATUS_INVALID_DEVICE_REQUEST
;
2243 /* Linux's fstatvfs is buggy */
2244 #if !defined(linux) || !defined(HAVE_FSTATFS)
2245 struct statvfs stfs
;
2247 if (fstatvfs( fd
, &stfs
) < 0)
2249 io
->u
.Status
= FILE_GetNtStatus();
2252 bsize
= stfs
.f_frsize
;
2255 if (fstatfs( fd
, &stfs
) < 0)
2257 io
->u
.Status
= FILE_GetNtStatus();
2260 bsize
= stfs
.f_bsize
;
2262 if (bsize
== 2048) /* assume CD-ROM */
2264 info
->BytesPerSector
= 2048;
2265 info
->SectorsPerAllocationUnit
= 1;
2269 info
->BytesPerSector
= 512;
2270 info
->SectorsPerAllocationUnit
= 8;
2272 info
->TotalAllocationUnits
.QuadPart
= bsize
* stfs
.f_blocks
/ (info
->BytesPerSector
* info
->SectorsPerAllocationUnit
);
2273 info
->AvailableAllocationUnits
.QuadPart
= bsize
* stfs
.f_bavail
/ (info
->BytesPerSector
* info
->SectorsPerAllocationUnit
);
2274 io
->Information
= sizeof(*info
);
2275 io
->u
.Status
= STATUS_SUCCESS
;
2279 case FileFsDeviceInformation
:
2280 if (length
< sizeof(FILE_FS_DEVICE_INFORMATION
))
2281 io
->u
.Status
= STATUS_BUFFER_TOO_SMALL
;
2284 FILE_FS_DEVICE_INFORMATION
*info
= buffer
;
2286 if ((io
->u
.Status
= get_device_info( fd
, info
)) == STATUS_SUCCESS
)
2287 io
->Information
= sizeof(*info
);
2290 case FileFsAttributeInformation
:
2291 FIXME( "%p: attribute info not supported\n", handle
);
2293 case FileFsControlInformation
:
2294 FIXME( "%p: control info not supported\n", handle
);
2296 case FileFsFullSizeInformation
:
2297 FIXME( "%p: full size info not supported\n", handle
);
2299 case FileFsObjectIdInformation
:
2300 FIXME( "%p: object id info not supported\n", handle
);
2302 case FileFsMaximumInformation
:
2303 FIXME( "%p: maximum info not supported\n", handle
);
2306 io
->u
.Status
= STATUS_INVALID_PARAMETER
;
2309 if (needs_close
) close( fd
);
2310 return io
->u
.Status
;
2314 /******************************************************************
2315 * NtQueryEaFile (NTDLL.@)
2317 * Read extended attributes from NTFS files.
2320 * hFile [I] File handle, must be opened with FILE_READ_EA access
2321 * iosb [O] Receives information about the operation on return
2322 * buffer [O] Output buffer
2323 * length [I] Length of output buffer
2324 * single_entry [I] Only read and return one entry
2325 * ea_list [I] Optional list with names of EAs to return
2326 * ea_list_len [I] Length of ea_list in bytes
2327 * ea_index [I] Optional pointer to 1-based index of attribute to return
2328 * restart [I] restart EA scan
2331 * Success: 0. Atrributes read into buffer
2332 * Failure: An NTSTATUS error code describing the error.
2334 NTSTATUS WINAPI
NtQueryEaFile( HANDLE hFile
, PIO_STATUS_BLOCK iosb
, PVOID buffer
, ULONG length
,
2335 BOOLEAN single_entry
, PVOID ea_list
, ULONG ea_list_len
,
2336 PULONG ea_index
, BOOLEAN restart
)
2338 FIXME("(%p,%p,%p,%d,%d,%p,%d,%p,%d) stub\n",
2339 hFile
, iosb
, buffer
, length
, single_entry
, ea_list
,
2340 ea_list_len
, ea_index
, restart
);
2341 return STATUS_ACCESS_DENIED
;
2345 /******************************************************************
2346 * NtSetEaFile (NTDLL.@)
2348 * Update extended attributes for NTFS files.
2351 * hFile [I] File handle, must be opened with FILE_READ_EA access
2352 * iosb [O] Receives information about the operation on return
2353 * buffer [I] Buffer with EA information
2354 * length [I] Length of buffer
2357 * Success: 0. Attributes are updated
2358 * Failure: An NTSTATUS error code describing the error.
2360 NTSTATUS WINAPI
NtSetEaFile( HANDLE hFile
, PIO_STATUS_BLOCK iosb
, PVOID buffer
, ULONG length
)
2362 FIXME("(%p,%p,%p,%d) stub\n", hFile
, iosb
, buffer
, length
);
2363 return STATUS_ACCESS_DENIED
;
2367 /******************************************************************
2368 * NtFlushBuffersFile (NTDLL.@)
2370 * Flush any buffered data on an open file handle.
2373 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
2374 * IoStatusBlock [O] Receives information about the operation on return
2377 * Success: 0. IoStatusBlock is updated.
2378 * Failure: An NTSTATUS error code describing the error.
2380 NTSTATUS WINAPI
NtFlushBuffersFile( HANDLE hFile
, IO_STATUS_BLOCK
* IoStatusBlock
)
2383 HANDLE hEvent
= NULL
;
2385 SERVER_START_REQ( flush_file
)
2387 req
->handle
= wine_server_obj_handle( hFile
);
2388 ret
= wine_server_call( req
);
2389 hEvent
= wine_server_ptr_handle( reply
->event
);
2394 ret
= NtWaitForSingleObject( hEvent
, FALSE
, NULL
);
2400 /******************************************************************
2401 * NtLockFile (NTDLL.@)
2405 NTSTATUS WINAPI
NtLockFile( HANDLE hFile
, HANDLE lock_granted_event
,
2406 PIO_APC_ROUTINE apc
, void* apc_user
,
2407 PIO_STATUS_BLOCK io_status
, PLARGE_INTEGER offset
,
2408 PLARGE_INTEGER count
, ULONG
* key
, BOOLEAN dont_wait
,
2414 static BOOLEAN warn
= TRUE
;
2416 if (apc
|| io_status
|| key
)
2418 FIXME("Unimplemented yet parameter\n");
2419 return STATUS_NOT_IMPLEMENTED
;
2422 if (apc_user
&& warn
)
2424 FIXME("I/O completion on lock not implemented yet\n");
2430 SERVER_START_REQ( lock_file
)
2432 req
->handle
= wine_server_obj_handle( hFile
);
2433 req
->offset
= offset
->QuadPart
;
2434 req
->count
= count
->QuadPart
;
2435 req
->shared
= !exclusive
;
2436 req
->wait
= !dont_wait
;
2437 ret
= wine_server_call( req
);
2438 handle
= wine_server_ptr_handle( reply
->handle
);
2439 async
= reply
->overlapped
;
2442 if (ret
!= STATUS_PENDING
)
2444 if (!ret
&& lock_granted_event
) NtSetEvent(lock_granted_event
, NULL
);
2450 FIXME( "Async I/O lock wait not implemented, might deadlock\n" );
2451 if (handle
) NtClose( handle
);
2452 return STATUS_PENDING
;
2456 NtWaitForSingleObject( handle
, FALSE
, NULL
);
2463 /* Unix lock conflict, sleep a bit and retry */
2464 time
.QuadPart
= 100 * (ULONGLONG
)10000;
2465 time
.QuadPart
= -time
.QuadPart
;
2466 NtDelayExecution( FALSE
, &time
);
2472 /******************************************************************
2473 * NtUnlockFile (NTDLL.@)
2477 NTSTATUS WINAPI
NtUnlockFile( HANDLE hFile
, PIO_STATUS_BLOCK io_status
,
2478 PLARGE_INTEGER offset
, PLARGE_INTEGER count
,
2483 TRACE( "%p %x%08x %x%08x\n",
2484 hFile
, offset
->u
.HighPart
, offset
->u
.LowPart
, count
->u
.HighPart
, count
->u
.LowPart
);
2486 if (io_status
|| key
)
2488 FIXME("Unimplemented yet parameter\n");
2489 return STATUS_NOT_IMPLEMENTED
;
2492 SERVER_START_REQ( unlock_file
)
2494 req
->handle
= wine_server_obj_handle( hFile
);
2495 req
->offset
= offset
->QuadPart
;
2496 req
->count
= count
->QuadPart
;
2497 status
= wine_server_call( req
);
2503 /******************************************************************
2504 * NtCreateNamedPipeFile (NTDLL.@)
2508 NTSTATUS WINAPI
NtCreateNamedPipeFile( PHANDLE handle
, ULONG access
,
2509 POBJECT_ATTRIBUTES attr
, PIO_STATUS_BLOCK iosb
,
2510 ULONG sharing
, ULONG dispo
, ULONG options
,
2511 ULONG pipe_type
, ULONG read_mode
,
2512 ULONG completion_mode
, ULONG max_inst
,
2513 ULONG inbound_quota
, ULONG outbound_quota
,
2514 PLARGE_INTEGER timeout
)
2518 TRACE("(%p %x %s %p %x %d %x %d %d %d %d %d %d %p)\n",
2519 handle
, access
, debugstr_w(attr
->ObjectName
->Buffer
), iosb
, sharing
, dispo
,
2520 options
, pipe_type
, read_mode
, completion_mode
, max_inst
, inbound_quota
,
2521 outbound_quota
, timeout
);
2523 /* assume we only get relative timeout */
2524 if (timeout
->QuadPart
> 0)
2525 FIXME("Wrong time %s\n", wine_dbgstr_longlong(timeout
->QuadPart
));
2527 SERVER_START_REQ( create_named_pipe
)
2529 req
->access
= access
;
2530 req
->attributes
= attr
->Attributes
;
2531 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
2532 req
->options
= options
;
2534 (pipe_type
) ? NAMED_PIPE_MESSAGE_STREAM_WRITE
: 0 |
2535 (read_mode
) ? NAMED_PIPE_MESSAGE_STREAM_READ
: 0 |
2536 (completion_mode
) ? NAMED_PIPE_NONBLOCKING_MODE
: 0;
2537 req
->maxinstances
= max_inst
;
2538 req
->outsize
= outbound_quota
;
2539 req
->insize
= inbound_quota
;
2540 req
->timeout
= timeout
->QuadPart
;
2541 wine_server_add_data( req
, attr
->ObjectName
->Buffer
,
2542 attr
->ObjectName
->Length
);
2543 status
= wine_server_call( req
);
2544 if (!status
) *handle
= wine_server_ptr_handle( reply
->handle
);
2550 /******************************************************************
2551 * NtDeleteFile (NTDLL.@)
2555 NTSTATUS WINAPI
NtDeleteFile( POBJECT_ATTRIBUTES ObjectAttributes
)
2561 TRACE("%p\n", ObjectAttributes
);
2562 status
= NtCreateFile( &hFile
, GENERIC_READ
| GENERIC_WRITE
| DELETE
,
2563 ObjectAttributes
, &io
, NULL
, 0,
2564 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
2565 FILE_OPEN
, FILE_DELETE_ON_CLOSE
, NULL
, 0 );
2566 if (status
== STATUS_SUCCESS
) status
= NtClose(hFile
);
2570 /******************************************************************
2571 * NtCancelIoFile (NTDLL.@)
2575 NTSTATUS WINAPI
NtCancelIoFile( HANDLE hFile
, PIO_STATUS_BLOCK io_status
)
2577 LARGE_INTEGER timeout
;
2579 TRACE("%p %p\n", hFile
, io_status
);
2581 SERVER_START_REQ( cancel_async
)
2583 req
->handle
= wine_server_obj_handle( hFile
);
2584 wine_server_call( req
);
2587 /* Let some APC be run, so that we can run the remaining APCs on hFile
2588 * either the cancelation of the pending one, but also the execution
2589 * of the queued APC, but not yet run. This is needed to ensure proper
2590 * clean-up of allocated data.
2592 timeout
.u
.LowPart
= timeout
.u
.HighPart
= 0;
2593 return io_status
->u
.Status
= NtDelayExecution( TRUE
, &timeout
);
2596 /******************************************************************************
2597 * NtCreateMailslotFile [NTDLL.@]
2598 * ZwCreateMailslotFile [NTDLL.@]
2601 * pHandle [O] pointer to receive the handle created
2602 * DesiredAccess [I] access mode (read, write, etc)
2603 * ObjectAttributes [I] fully qualified NT path of the mailslot
2604 * IoStatusBlock [O] receives completion status and other info
2607 * MaxMessageSize [I]
2613 NTSTATUS WINAPI
NtCreateMailslotFile(PHANDLE pHandle
, ULONG DesiredAccess
,
2614 POBJECT_ATTRIBUTES attr
, PIO_STATUS_BLOCK IoStatusBlock
,
2615 ULONG CreateOptions
, ULONG MailslotQuota
, ULONG MaxMessageSize
,
2616 PLARGE_INTEGER TimeOut
)
2618 LARGE_INTEGER timeout
;
2621 TRACE("%p %08x %p %p %08x %08x %08x %p\n",
2622 pHandle
, DesiredAccess
, attr
, IoStatusBlock
,
2623 CreateOptions
, MailslotQuota
, MaxMessageSize
, TimeOut
);
2625 if (!pHandle
) return STATUS_ACCESS_VIOLATION
;
2626 if (!attr
) return STATUS_INVALID_PARAMETER
;
2627 if (!attr
->ObjectName
) return STATUS_OBJECT_PATH_SYNTAX_BAD
;
2630 * For a NULL TimeOut pointer set the default timeout value
2633 timeout
.QuadPart
= -1;
2635 timeout
.QuadPart
= TimeOut
->QuadPart
;
2637 SERVER_START_REQ( create_mailslot
)
2639 req
->access
= DesiredAccess
;
2640 req
->attributes
= attr
->Attributes
;
2641 req
->rootdir
= wine_server_obj_handle( attr
->RootDirectory
);
2642 req
->max_msgsize
= MaxMessageSize
;
2643 req
->read_timeout
= timeout
.QuadPart
;
2644 wine_server_add_data( req
, attr
->ObjectName
->Buffer
,
2645 attr
->ObjectName
->Length
);
2646 ret
= wine_server_call( req
);
2647 if( ret
== STATUS_SUCCESS
)
2648 *pHandle
= wine_server_ptr_handle( reply
->handle
);