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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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>
48 #ifdef STATFS_DEFINED_BY_SYS_VFS
51 # ifdef STATFS_DEFINED_BY_SYS_MOUNT
52 # include <sys/mount.h>
54 # ifdef STATFS_DEFINED_BY_SYS_STATFS
55 # include <sys/statfs.h>
60 #ifdef HAVE_IOKIT_IOKITLIB_H
61 # include <IOKit/IOKitLib.h>
62 # include <CoreFoundation/CFNumber.h> /* for kCFBooleanTrue, kCFBooleanFalse */
66 #define NONAMELESSUNION
67 #define NONAMELESSSTRUCT
69 #define WIN32_NO_STATUS
70 #include "wine/unicode.h"
71 #include "wine/debug.h"
73 #include "wine/server.h"
74 #include "ntdll_misc.h"
79 WINE_DEFAULT_DEBUG_CHANNEL(ntdll
);
81 mode_t FILE_umask
= 0;
83 #define SECSPERDAY 86400
84 #define SECS_1601_TO_1970 ((369 * 365 + 89) * (ULONGLONG)SECSPERDAY)
86 /**************************************************************************
87 * NtOpenFile [NTDLL.@]
88 * ZwOpenFile [NTDLL.@]
93 * handle [O] Variable that receives the file handle on return
94 * access [I] Access desired by the caller to the file
95 * attr [I] Structure describing the file to be opened
96 * io [O] Receives details about the result of the operation
97 * sharing [I] Type of shared access the caller requires
98 * options [I] Options for the file open
101 * Success: 0. FileHandle and IoStatusBlock are updated.
102 * Failure: An NTSTATUS error code describing the error.
104 NTSTATUS WINAPI
NtOpenFile( PHANDLE handle
, ACCESS_MASK access
,
105 POBJECT_ATTRIBUTES attr
, PIO_STATUS_BLOCK io
,
106 ULONG sharing
, ULONG options
)
108 return NtCreateFile( handle
, access
, attr
, io
, NULL
, 0,
109 sharing
, FILE_OPEN
, options
, NULL
, 0 );
112 /**************************************************************************
113 * NtCreateFile [NTDLL.@]
114 * ZwCreateFile [NTDLL.@]
116 * Either create a new file or directory, or open an existing file, device,
117 * directory or volume.
120 * handle [O] Points to a variable which receives the file handle on return
121 * access [I] Desired access to the file
122 * attr [I] Structure describing the file
123 * io [O] Receives information about the operation on return
124 * alloc_size [I] Initial size of the file in bytes
125 * attributes [I] Attributes to create the file with
126 * sharing [I] Type of shared access the caller would like to the file
127 * disposition [I] Specifies what to do, depending on whether the file already exists
128 * options [I] Options for creating a new file
129 * ea_buffer [I] Pointer to an extended attributes buffer
130 * ea_length [I] Length of ea_buffer
133 * Success: 0. handle and io are updated.
134 * Failure: An NTSTATUS error code describing the error.
136 NTSTATUS WINAPI
NtCreateFile( PHANDLE handle
, ACCESS_MASK access
, POBJECT_ATTRIBUTES attr
,
137 PIO_STATUS_BLOCK io
, PLARGE_INTEGER alloc_size
,
138 ULONG attributes
, ULONG sharing
, ULONG disposition
,
139 ULONG options
, PVOID ea_buffer
, ULONG ea_length
)
141 static const WCHAR pipeW
[] = {'\\','?','?','\\','p','i','p','e','\\'};
142 static const WCHAR mailslotW
[] = {'\\','?','?','\\','M','A','I','L','S','L','O','T','\\'};
143 ANSI_STRING unix_name
;
146 TRACE("handle=%p access=%08lx name=%s objattr=%08lx root=%p sec=%p io=%p alloc_size=%p\n"
147 "attr=%08lx sharing=%08lx disp=%ld options=%08lx ea=%p.0x%08lx\n",
148 handle
, access
, debugstr_us(attr
->ObjectName
), attr
->Attributes
,
149 attr
->RootDirectory
, attr
->SecurityDescriptor
, io
, alloc_size
,
150 attributes
, sharing
, disposition
, options
, ea_buffer
, ea_length
);
152 if (!attr
|| !attr
->ObjectName
) return STATUS_INVALID_PARAMETER
;
154 if (alloc_size
) FIXME( "alloc_size not supported\n" );
156 /* check for named pipe */
158 if (attr
->ObjectName
->Length
> sizeof(pipeW
) &&
159 !memicmpW( attr
->ObjectName
->Buffer
, pipeW
, sizeof(pipeW
)/sizeof(WCHAR
) ))
161 SERVER_START_REQ( open_named_pipe
)
163 req
->access
= access
;
164 req
->attributes
= (attr
) ? attr
->Attributes
: 0;
165 req
->rootdir
= attr
? attr
->RootDirectory
: 0;
166 req
->flags
= options
;
167 wine_server_add_data( req
, attr
->ObjectName
->Buffer
,
168 attr
->ObjectName
->Length
);
169 io
->u
.Status
= wine_server_call( req
);
170 *handle
= reply
->handle
;
176 /* check for mailslot */
178 if (attr
->ObjectName
->Length
> sizeof(mailslotW
) &&
179 !memicmpW( attr
->ObjectName
->Buffer
, mailslotW
, sizeof(mailslotW
)/sizeof(WCHAR
) ))
181 SERVER_START_REQ( open_mailslot
)
183 req
->access
= access
& GENERIC_WRITE
;
184 req
->attributes
= (attr
) ? attr
->Attributes
: 0;
185 req
->rootdir
= attr
? attr
->RootDirectory
: 0;
186 req
->sharing
= sharing
;
187 wine_server_add_data( req
, attr
->ObjectName
->Buffer
,
188 attr
->ObjectName
->Length
);
189 io
->u
.Status
= wine_server_call( req
);
190 *handle
= reply
->handle
;
196 if (attr
->RootDirectory
)
198 FIXME( "RootDirectory %p not supported\n", attr
->RootDirectory
);
199 return STATUS_OBJECT_NAME_NOT_FOUND
;
202 io
->u
.Status
= wine_nt_to_unix_file_name( attr
->ObjectName
, &unix_name
, disposition
,
203 !(attr
->Attributes
& OBJ_CASE_INSENSITIVE
) );
205 if (io
->u
.Status
== STATUS_BAD_DEVICE_TYPE
)
207 SERVER_START_REQ( open_file_object
)
209 req
->access
= access
;
210 req
->attributes
= attr
->Attributes
;
211 req
->rootdir
= attr
->RootDirectory
;
212 req
->sharing
= sharing
;
213 wine_server_add_data( req
, attr
->ObjectName
->Buffer
, attr
->ObjectName
->Length
);
214 io
->u
.Status
= wine_server_call( req
);
215 *handle
= reply
->handle
;
221 if (io
->u
.Status
== STATUS_NO_SUCH_FILE
&&
222 disposition
!= FILE_OPEN
&& disposition
!= FILE_OVERWRITE
)
225 io
->u
.Status
= STATUS_SUCCESS
;
228 if (io
->u
.Status
== STATUS_SUCCESS
)
230 SERVER_START_REQ( create_file
)
232 req
->access
= access
;
233 req
->attributes
= attr
->Attributes
;
234 req
->sharing
= sharing
;
235 req
->create
= disposition
;
236 req
->options
= options
;
237 req
->attrs
= attributes
;
238 wine_server_add_data( req
, unix_name
.Buffer
, unix_name
.Length
);
239 io
->u
.Status
= wine_server_call( req
);
240 *handle
= reply
->handle
;
243 RtlFreeAnsiString( &unix_name
);
245 else WARN("%s not found (%lx)\n", debugstr_us(attr
->ObjectName
), io
->u
.Status
);
247 if (io
->u
.Status
== STATUS_SUCCESS
)
249 if (created
) io
->Information
= FILE_CREATED
;
250 else switch(disposition
)
253 io
->Information
= FILE_SUPERSEDED
;
256 io
->Information
= FILE_CREATED
;
260 io
->Information
= FILE_OPENED
;
263 case FILE_OVERWRITE_IF
:
264 io
->Information
= FILE_OVERWRITTEN
;
272 /***********************************************************************
273 * Asynchronous file I/O *
275 static void WINAPI
FILE_AsyncReadService(void*, PIO_STATUS_BLOCK
, ULONG
);
276 static void WINAPI
FILE_AsyncWriteService(void*, PIO_STATUS_BLOCK
, ULONG
);
278 typedef struct async_fileio
286 int queue_apc_on_error
;
292 static void fileio_terminate(async_fileio
*fileio
, IO_STATUS_BLOCK
* iosb
)
294 TRACE("data: %p\n", fileio
);
296 wine_server_release_fd( fileio
->handle
, fileio
->fd
);
297 if ( fileio
->event
!= INVALID_HANDLE_VALUE
)
298 NtSetEvent( fileio
->event
, NULL
);
301 (iosb
->u
.Status
== STATUS_SUCCESS
|| fileio
->queue_apc_on_error
))
302 fileio
->apc( fileio
->apc_user
, iosb
, iosb
->Information
);
304 RtlFreeHeap( GetProcessHeap(), 0, fileio
);
308 static ULONG
fileio_queue_async(async_fileio
* fileio
, IO_STATUS_BLOCK
* iosb
,
311 PIO_APC_ROUTINE apc
= do_read
? FILE_AsyncReadService
: FILE_AsyncWriteService
;
314 SERVER_START_REQ( register_async
)
316 req
->handle
= fileio
->handle
;
319 req
->io_user
= fileio
;
320 req
->type
= do_read
? ASYNC_TYPE_READ
: ASYNC_TYPE_WRITE
;
321 req
->count
= (fileio
->count
< iosb
->Information
) ?
322 0 : fileio
->count
- iosb
->Information
;
323 status
= wine_server_call( req
);
327 if ( status
) iosb
->u
.Status
= status
;
328 if ( iosb
->u
.Status
!= STATUS_PENDING
)
330 (apc
)( fileio
, iosb
, iosb
->u
.Status
);
331 return iosb
->u
.Status
;
333 NtCurrentTeb()->num_async_io
++;
334 return STATUS_SUCCESS
;
337 /***********************************************************************
338 * FILE_GetNtStatus(void)
340 * Retrieve the Nt Status code from errno.
341 * Try to be consistent with FILE_SetDosError().
343 NTSTATUS
FILE_GetNtStatus(void)
347 TRACE( "errno = %d\n", errno
);
350 case EAGAIN
: return STATUS_SHARING_VIOLATION
;
351 case EBADF
: return STATUS_INVALID_HANDLE
;
352 case EBUSY
: return STATUS_DEVICE_BUSY
;
353 case ENOSPC
: return STATUS_DISK_FULL
;
356 case EACCES
: return STATUS_ACCESS_DENIED
;
357 case ENOTDIR
: return STATUS_OBJECT_PATH_NOT_FOUND
;
358 case ENOENT
: return STATUS_OBJECT_NAME_NOT_FOUND
;
359 case EISDIR
: return STATUS_FILE_IS_A_DIRECTORY
;
361 case ENFILE
: return STATUS_TOO_MANY_OPENED_FILES
;
362 case EINVAL
: return STATUS_INVALID_PARAMETER
;
363 case ENOTEMPTY
: return STATUS_DIRECTORY_NOT_EMPTY
;
364 case EPIPE
: return STATUS_PIPE_BROKEN
;
365 case EIO
: return STATUS_DEVICE_NOT_READY
;
367 case ENOMEDIUM
: return STATUS_NO_MEDIA_IN_DEVICE
;
370 case EOPNOTSUPP
:return STATUS_NOT_SUPPORTED
;
371 case ECONNRESET
:return STATUS_PIPE_DISCONNECTED
;
372 case ENOEXEC
: /* ?? */
373 case ESPIPE
: /* ?? */
374 case EEXIST
: /* ?? */
376 FIXME( "Converting errno %d to STATUS_UNSUCCESSFUL\n", err
);
377 return STATUS_UNSUCCESSFUL
;
381 /***********************************************************************
382 * FILE_AsyncReadService (INTERNAL)
384 * This function is called while the client is waiting on the
385 * server, so we can't make any server calls here.
387 static void WINAPI
FILE_AsyncReadService(void *user
, PIO_STATUS_BLOCK iosb
, ULONG status
)
389 async_fileio
*fileio
= (async_fileio
*)user
;
391 int already
= iosb
->Information
;
393 TRACE("%p %p 0x%lx\n", iosb
, fileio
->buffer
, status
);
397 case STATUS_ALERTED
: /* got some new data */
398 if (iosb
->u
.Status
!= STATUS_PENDING
) FIXME("unexpected status %08lx\n", iosb
->u
.Status
);
399 /* check to see if the data is ready (non-blocking) */
400 if ( fileio
->avail_mode
)
401 result
= read(fileio
->fd
, &fileio
->buffer
[already
],
402 fileio
->count
- already
);
405 result
= pread(fileio
->fd
, &fileio
->buffer
[already
],
406 fileio
->count
- already
,
407 fileio
->offset
+ already
);
408 if ((result
< 0) && (errno
== ESPIPE
))
409 result
= read(fileio
->fd
, &fileio
->buffer
[already
],
410 fileio
->count
- already
);
415 if (errno
== EAGAIN
|| errno
== EINTR
)
417 TRACE("Deferred read %d\n", errno
);
418 iosb
->u
.Status
= STATUS_PENDING
;
420 else /* check to see if the transfer is complete */
421 iosb
->u
.Status
= FILE_GetNtStatus();
423 else if (result
== 0)
425 iosb
->u
.Status
= iosb
->Information
? STATUS_SUCCESS
: STATUS_END_OF_FILE
;
429 iosb
->Information
+= result
;
430 if (iosb
->Information
>= fileio
->count
|| fileio
->avail_mode
)
431 iosb
->u
.Status
= STATUS_SUCCESS
;
434 /* if we only have to read the available data, and none is available,
435 * simply cancel the request. If data was available, it has been read
436 * while in by previous call (NtDelayExecution)
438 iosb
->u
.Status
= (fileio
->avail_mode
) ? STATUS_SUCCESS
: STATUS_PENDING
;
441 TRACE("read %d more bytes %ld/%d so far (%s)\n",
442 result
, iosb
->Information
, fileio
->count
,
443 (iosb
->u
.Status
== STATUS_SUCCESS
) ? "success" : "pending");
445 /* queue another async operation ? */
446 if (iosb
->u
.Status
== STATUS_PENDING
)
447 fileio_queue_async(fileio
, iosb
, TRUE
);
449 fileio_terminate(fileio
, iosb
);
452 iosb
->u
.Status
= status
;
453 fileio_terminate(fileio
, iosb
);
459 /******************************************************************************
460 * NtReadFile [NTDLL.@]
461 * ZwReadFile [NTDLL.@]
463 * Read from an open file handle.
466 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
467 * Event [I] Event to signal upon completion (or NULL)
468 * ApcRoutine [I] Callback to call upon completion (or NULL)
469 * ApcContext [I] Context for ApcRoutine (or NULL)
470 * IoStatusBlock [O] Receives information about the operation on return
471 * Buffer [O] Destination for the data read
472 * Length [I] Size of Buffer
473 * ByteOffset [O] Destination for the new file pointer position (or NULL)
474 * Key [O] Function unknown (may be NULL)
477 * Success: 0. IoStatusBlock is updated, and the Information member contains
478 * The number of bytes read.
479 * Failure: An NTSTATUS error code describing the error.
481 NTSTATUS WINAPI
NtReadFile(HANDLE hFile
, HANDLE hEvent
,
482 PIO_APC_ROUTINE apc
, void* apc_user
,
483 PIO_STATUS_BLOCK io_status
, void* buffer
, ULONG length
,
484 PLARGE_INTEGER offset
, PULONG key
)
486 int unix_handle
, flags
;
488 TRACE("(%p,%p,%p,%p,%p,%p,0x%08lx,%p,%p),partial stub!\n",
489 hFile
,hEvent
,apc
,apc_user
,io_status
,buffer
,length
,offset
,key
);
491 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
493 io_status
->Information
= 0;
494 io_status
->u
.Status
= wine_server_handle_to_fd( hFile
, FILE_READ_DATA
, &unix_handle
, &flags
);
495 if (io_status
->u
.Status
) return io_status
->u
.Status
;
497 if (flags
& FD_FLAG_RECV_SHUTDOWN
)
499 wine_server_release_fd( hFile
, unix_handle
);
500 return STATUS_PIPE_DISCONNECTED
;
503 if (flags
& FD_FLAG_TIMEOUT
)
507 /* this shouldn't happen, but check it */
508 FIXME("NIY-hEvent\n");
509 wine_server_release_fd( hFile
, unix_handle
);
510 return STATUS_NOT_IMPLEMENTED
;
512 io_status
->u
.Status
= NtCreateEvent(&hEvent
, EVENT_ALL_ACCESS
, NULL
, 0, 0);
513 if (io_status
->u
.Status
)
515 wine_server_release_fd( hFile
, unix_handle
);
516 return io_status
->u
.Status
;
520 if (flags
& (FD_FLAG_OVERLAPPED
|FD_FLAG_TIMEOUT
))
522 async_fileio
* fileio
;
525 if (!(fileio
= RtlAllocateHeap(GetProcessHeap(), 0, sizeof(async_fileio
))))
527 wine_server_release_fd( hFile
, unix_handle
);
528 if (flags
& FD_FLAG_TIMEOUT
) NtClose(hEvent
);
529 return STATUS_NO_MEMORY
;
531 fileio
->handle
= hFile
;
532 fileio
->count
= length
;
533 if ( offset
== NULL
)
537 fileio
->offset
= offset
->QuadPart
;
538 if (offset
->u
.HighPart
&& fileio
->offset
== offset
->u
.LowPart
)
539 FIXME("High part of offset is lost\n");
542 fileio
->apc_user
= apc_user
;
543 fileio
->buffer
= buffer
;
544 fileio
->queue_apc_on_error
= 0;
545 fileio
->avail_mode
= (flags
& FD_FLAG_AVAILABLE
);
546 fileio
->fd
= unix_handle
; /* FIXME */
547 fileio
->event
= hEvent
;
548 NtResetEvent(hEvent
, NULL
);
550 io_status
->u
.Status
= STATUS_PENDING
;
551 ret
= fileio_queue_async(fileio
, io_status
, TRUE
);
552 if (ret
!= STATUS_SUCCESS
)
554 wine_server_release_fd( hFile
, unix_handle
);
555 if (flags
& FD_FLAG_TIMEOUT
) NtClose(hEvent
);
558 if (flags
& FD_FLAG_TIMEOUT
)
562 ret
= NtWaitForSingleObject(hEvent
, TRUE
, NULL
);
564 while (ret
== STATUS_USER_APC
&& io_status
->u
.Status
== STATUS_PENDING
);
566 if (ret
!= STATUS_USER_APC
)
567 fileio
->queue_apc_on_error
= 1;
571 LARGE_INTEGER timeout
;
573 /* let some APC be run, this will read some already pending data */
574 timeout
.u
.LowPart
= timeout
.u
.HighPart
= 0;
575 ret
= NtDelayExecution( TRUE
, &timeout
);
576 /* the apc didn't run and therefore the completion routine now
577 * needs to be sent errors.
578 * Note that there is no race between setting this flag and
579 * returning errors because apc's are run only during alertable
581 if (ret
!= STATUS_USER_APC
)
582 fileio
->queue_apc_on_error
= 1;
584 TRACE("= 0x%08lx\n", io_status
->u
.Status
);
585 return io_status
->u
.Status
;
590 FILE_POSITION_INFORMATION fpi
;
592 fpi
.CurrentByteOffset
= *offset
;
593 io_status
->u
.Status
= NtSetInformationFile(hFile
, io_status
, &fpi
, sizeof(fpi
),
594 FilePositionInformation
);
595 if (io_status
->u
.Status
)
597 wine_server_release_fd( hFile
, unix_handle
);
598 return io_status
->u
.Status
;
601 /* code for synchronous reads */
602 while ((io_status
->Information
= read( unix_handle
, buffer
, length
)) == -1)
604 if ((errno
== EAGAIN
) || (errno
== EINTR
)) continue;
607 io_status
->Information
= 0;
608 io_status
->u
.Status
= STATUS_ACCESS_VIOLATION
;
610 else io_status
->u
.Status
= FILE_GetNtStatus();
613 if (io_status
->u
.Status
== STATUS_SUCCESS
&& io_status
->Information
== 0)
616 if (fstat( unix_handle
, &st
) != -1 && S_ISSOCK( st
.st_mode
))
617 io_status
->u
.Status
= STATUS_PIPE_BROKEN
;
619 io_status
->u
.Status
= STATUS_END_OF_FILE
;
621 wine_server_release_fd( hFile
, unix_handle
);
622 TRACE("= 0x%08lx (%lu)\n", io_status
->u
.Status
, io_status
->Information
);
623 return io_status
->u
.Status
;
626 /***********************************************************************
627 * FILE_AsyncWriteService (INTERNAL)
629 * This function is called while the client is waiting on the
630 * server, so we can't make any server calls here.
632 static void WINAPI
FILE_AsyncWriteService(void *ovp
, IO_STATUS_BLOCK
*iosb
, ULONG status
)
634 async_fileio
*fileio
= (async_fileio
*) ovp
;
636 int already
= iosb
->Information
;
638 TRACE("(%p %p 0x%lx)\n",iosb
, fileio
->buffer
, status
);
643 /* write some data (non-blocking) */
644 if ( fileio
->avail_mode
)
645 result
= write(fileio
->fd
, &fileio
->buffer
[already
],
646 fileio
->count
- already
);
649 result
= pwrite(fileio
->fd
, &fileio
->buffer
[already
],
650 fileio
->count
- already
, fileio
->offset
+ already
);
651 if ((result
< 0) && (errno
== ESPIPE
))
652 result
= write(fileio
->fd
, &fileio
->buffer
[already
],
653 fileio
->count
- already
);
658 if (errno
== EAGAIN
|| errno
== EINTR
) iosb
->u
.Status
= STATUS_PENDING
;
659 else iosb
->u
.Status
= FILE_GetNtStatus();
663 iosb
->Information
+= result
;
664 iosb
->u
.Status
= (iosb
->Information
< fileio
->count
) ? STATUS_PENDING
: STATUS_SUCCESS
;
665 TRACE("wrote %d more bytes %ld/%d so far\n",
666 result
, iosb
->Information
, fileio
->count
);
668 if (iosb
->u
.Status
== STATUS_PENDING
)
669 fileio_queue_async(fileio
, iosb
, FALSE
);
671 fileio_terminate(fileio
, iosb
);
674 iosb
->u
.Status
= status
;
675 fileio_terminate(fileio
, iosb
);
680 /******************************************************************************
681 * NtWriteFile [NTDLL.@]
682 * ZwWriteFile [NTDLL.@]
684 * Write to an open file handle.
687 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
688 * Event [I] Event to signal upon completion (or NULL)
689 * ApcRoutine [I] Callback to call upon completion (or NULL)
690 * ApcContext [I] Context for ApcRoutine (or NULL)
691 * IoStatusBlock [O] Receives information about the operation on return
692 * Buffer [I] Source for the data to write
693 * Length [I] Size of Buffer
694 * ByteOffset [O] Destination for the new file pointer position (or NULL)
695 * Key [O] Function unknown (may be NULL)
698 * Success: 0. IoStatusBlock is updated, and the Information member contains
699 * The number of bytes written.
700 * Failure: An NTSTATUS error code describing the error.
702 NTSTATUS WINAPI
NtWriteFile(HANDLE hFile
, HANDLE hEvent
,
703 PIO_APC_ROUTINE apc
, void* apc_user
,
704 PIO_STATUS_BLOCK io_status
,
705 const void* buffer
, ULONG length
,
706 PLARGE_INTEGER offset
, PULONG key
)
708 int unix_handle
, flags
;
710 TRACE("(%p,%p,%p,%p,%p,%p,0x%08lx,%p,%p)!\n",
711 hFile
,hEvent
,apc
,apc_user
,io_status
,buffer
,length
,offset
,key
);
713 if (!io_status
) return STATUS_ACCESS_VIOLATION
;
715 io_status
->Information
= 0;
716 io_status
->u
.Status
= wine_server_handle_to_fd( hFile
, FILE_WRITE_DATA
, &unix_handle
, &flags
);
717 if (io_status
->u
.Status
) return io_status
->u
.Status
;
719 if (flags
& FD_FLAG_SEND_SHUTDOWN
)
721 wine_server_release_fd( hFile
, unix_handle
);
722 return STATUS_PIPE_DISCONNECTED
;
725 if (flags
& FD_FLAG_TIMEOUT
)
729 /* this shouldn't happen, but check it */
730 FIXME("NIY-hEvent\n");
731 wine_server_release_fd( hFile
, unix_handle
);
732 return STATUS_NOT_IMPLEMENTED
;
734 io_status
->u
.Status
= NtCreateEvent(&hEvent
, EVENT_ALL_ACCESS
, NULL
, 0, 0);
735 if (io_status
->u
.Status
)
737 wine_server_release_fd( hFile
, unix_handle
);
738 return io_status
->u
.Status
;
742 if (flags
& (FD_FLAG_OVERLAPPED
|FD_FLAG_TIMEOUT
))
744 async_fileio
* fileio
;
747 if (!(fileio
= RtlAllocateHeap(GetProcessHeap(), 0, sizeof(async_fileio
))))
749 wine_server_release_fd( hFile
, unix_handle
);
750 if (flags
& FD_FLAG_TIMEOUT
) NtClose(hEvent
);
751 return STATUS_NO_MEMORY
;
753 fileio
->handle
= hFile
;
754 fileio
->count
= length
;
757 fileio
->offset
= offset
->QuadPart
;
758 if (offset
->u
.HighPart
&& fileio
->offset
== offset
->u
.LowPart
)
759 FIXME("High part of offset is lost\n");
766 fileio
->apc_user
= apc_user
;
767 fileio
->buffer
= (void*)buffer
;
768 fileio
->queue_apc_on_error
= 0;
769 fileio
->avail_mode
= (flags
& FD_FLAG_AVAILABLE
);
770 fileio
->fd
= unix_handle
; /* FIXME */
771 fileio
->event
= hEvent
;
772 NtResetEvent(hEvent
, NULL
);
774 io_status
->Information
= 0;
775 io_status
->u
.Status
= STATUS_PENDING
;
776 ret
= fileio_queue_async(fileio
, io_status
, FALSE
);
777 if (ret
!= STATUS_SUCCESS
)
779 wine_server_release_fd( hFile
, unix_handle
);
780 if (flags
& FD_FLAG_TIMEOUT
) NtClose(hEvent
);
783 if (flags
& FD_FLAG_TIMEOUT
)
787 ret
= NtWaitForSingleObject(hEvent
, TRUE
, NULL
);
789 while (ret
== STATUS_USER_APC
&& io_status
->u
.Status
== STATUS_PENDING
);
791 if (ret
!= STATUS_USER_APC
)
792 fileio
->queue_apc_on_error
= 1;
796 LARGE_INTEGER timeout
;
798 /* let some APC be run, this will write as much data as possible */
799 timeout
.u
.LowPart
= timeout
.u
.HighPart
= 0;
800 ret
= NtDelayExecution( TRUE
, &timeout
);
801 /* the apc didn't run and therefore the completion routine now
802 * needs to be sent errors.
803 * Note that there is no race between setting this flag and
804 * returning errors because apc's are run only during alertable
806 if (ret
!= STATUS_USER_APC
)
807 fileio
->queue_apc_on_error
= 1;
809 return io_status
->u
.Status
;
814 FILE_POSITION_INFORMATION fpi
;
816 fpi
.CurrentByteOffset
= *offset
;
817 io_status
->u
.Status
= NtSetInformationFile(hFile
, io_status
, &fpi
, sizeof(fpi
),
818 FilePositionInformation
);
819 if (io_status
->u
.Status
)
821 wine_server_release_fd( hFile
, unix_handle
);
822 return io_status
->u
.Status
;
826 /* synchronous file write */
827 while ((io_status
->Information
= write( unix_handle
, buffer
, length
)) == -1)
829 if ((errno
== EAGAIN
) || (errno
== EINTR
)) continue;
832 io_status
->Information
= 0;
833 io_status
->u
.Status
= STATUS_INVALID_USER_BUFFER
;
835 else if (errno
== ENOSPC
) io_status
->u
.Status
= STATUS_DISK_FULL
;
836 else io_status
->u
.Status
= FILE_GetNtStatus();
839 wine_server_release_fd( hFile
, unix_handle
);
840 return io_status
->u
.Status
;
843 /**************************************************************************
844 * NtDeviceIoControlFile [NTDLL.@]
845 * ZwDeviceIoControlFile [NTDLL.@]
847 * Perform an I/O control operation on an open file handle.
850 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
851 * event [I] Event to signal upon completion (or NULL)
852 * apc [I] Callback to call upon completion (or NULL)
853 * apc_context [I] Context for ApcRoutine (or NULL)
854 * io [O] Receives information about the operation on return
855 * code [I] Control code for the operation to perform
856 * in_buffer [I] Source for any input data required (or NULL)
857 * in_size [I] Size of InputBuffer
858 * out_buffer [O] Source for any output data returned (or NULL)
859 * out_size [I] Size of OutputBuffer
862 * Success: 0. IoStatusBlock is updated.
863 * Failure: An NTSTATUS error code describing the error.
865 NTSTATUS WINAPI
NtDeviceIoControlFile(HANDLE handle
, HANDLE event
,
866 PIO_APC_ROUTINE apc
, PVOID apc_context
,
867 PIO_STATUS_BLOCK io
, ULONG code
,
868 PVOID in_buffer
, ULONG in_size
,
869 PVOID out_buffer
, ULONG out_size
)
871 ULONG device
= (code
>> 16);
873 TRACE("(%p,%p,%p,%p,%p,0x%08lx,%p,0x%08lx,%p,0x%08lx)\n",
874 handle
, event
, apc
, apc_context
, io
, code
,
875 in_buffer
, in_size
, out_buffer
, out_size
);
879 case FILE_DEVICE_DISK
:
880 case FILE_DEVICE_CD_ROM
:
881 case FILE_DEVICE_DVD
:
882 case FILE_DEVICE_CONTROLLER
:
883 case FILE_DEVICE_MASS_STORAGE
:
884 io
->u
.Status
= CDROM_DeviceIoControl(handle
, event
, apc
, apc_context
, io
, code
,
885 in_buffer
, in_size
, out_buffer
, out_size
);
887 case FILE_DEVICE_SERIAL_PORT
:
888 io
->u
.Status
= COMM_DeviceIoControl(handle
, event
, apc
, apc_context
, io
, code
,
889 in_buffer
, in_size
, out_buffer
, out_size
);
892 FIXME("Unsupported ioctl %lx (device=%lx access=%lx func=%lx method=%lx)\n",
893 code
, device
, (code
>> 14) & 3, (code
>> 2) & 0xfff, code
& 3);
894 io
->u
.Status
= STATUS_NOT_SUPPORTED
;
900 /***********************************************************************
901 * pipe_completion_wait (Internal)
903 static void CALLBACK
pipe_completion_wait(HANDLE event
, PIO_STATUS_BLOCK iosb
, ULONG status
)
905 TRACE("for %p/%p, status=%08lx\n", event
, iosb
, status
);
908 iosb
->u
.Status
= status
;
909 NtSetEvent(event
, NULL
);
913 /**************************************************************************
914 * NtFsControlFile [NTDLL.@]
915 * ZwFsControlFile [NTDLL.@]
917 * Perform a file system control operation on an open file handle.
920 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
921 * event [I] Event to signal upon completion (or NULL)
922 * apc [I] Callback to call upon completion (or NULL)
923 * apc_context [I] Context for ApcRoutine (or NULL)
924 * io [O] Receives information about the operation on return
925 * code [I] Control code for the operation to perform
926 * in_buffer [I] Source for any input data required (or NULL)
927 * in_size [I] Size of InputBuffer
928 * out_buffer [O] Source for any output data returned (or NULL)
929 * out_size [I] Size of OutputBuffer
932 * Success: 0. IoStatusBlock is updated.
933 * Failure: An NTSTATUS error code describing the error.
935 NTSTATUS WINAPI
NtFsControlFile(HANDLE handle
, HANDLE event
, PIO_APC_ROUTINE apc
,
936 PVOID apc_context
, PIO_STATUS_BLOCK io
, ULONG code
,
937 PVOID in_buffer
, ULONG in_size
, PVOID out_buffer
, ULONG out_size
)
939 TRACE("(%p,%p,%p,%p,%p,0x%08lx,%p,0x%08lx,%p,0x%08lx)\n",
940 handle
, event
, apc
, apc_context
, io
, code
,
941 in_buffer
, in_size
, out_buffer
, out_size
);
943 if (!io
) return STATUS_INVALID_PARAMETER
;
947 case FSCTL_DISMOUNT_VOLUME
:
948 io
->u
.Status
= DIR_unmount_device( handle
);
951 case FSCTL_PIPE_LISTEN
:
953 HANDLE internal_event
= 0;
957 io
->u
.Status
= NtCreateEvent(&internal_event
, EVENT_ALL_ACCESS
, NULL
, FALSE
, FALSE
);
958 if (io
->u
.Status
!= STATUS_SUCCESS
) return io
->u
.Status
;
960 SERVER_START_REQ(connect_named_pipe
)
962 req
->handle
= handle
;
963 req
->event
= event
? event
: internal_event
;
964 req
->func
= pipe_completion_wait
;
965 io
->u
.Status
= wine_server_call(req
);
969 if(io
->u
.Status
== STATUS_SUCCESS
)
971 if(event
) io
->u
.Status
= STATUS_PENDING
;
975 io
->u
.Status
= NtWaitForSingleObject(internal_event
, TRUE
, NULL
);
976 while(io
->u
.Status
== STATUS_USER_APC
);
979 if (internal_event
) NtClose(internal_event
);
983 case FSCTL_PIPE_WAIT
:
985 HANDLE internal_event
= 0;
986 FILE_PIPE_WAIT_FOR_BUFFER
*buff
= in_buffer
;
990 io
->u
.Status
= NtCreateEvent(&internal_event
, EVENT_ALL_ACCESS
, NULL
, FALSE
, FALSE
);
991 if (io
->u
.Status
!= STATUS_SUCCESS
) return io
->u
.Status
;
993 SERVER_START_REQ(wait_named_pipe
)
995 req
->handle
= handle
;
996 req
->timeout
= buff
->TimeoutSpecified
? buff
->Timeout
.QuadPart
/ -10000L
997 : NMPWAIT_USE_DEFAULT_WAIT
;
998 req
->event
= event
? event
: internal_event
;
999 req
->func
= pipe_completion_wait
;
1000 wine_server_add_data( req
, buff
->Name
, buff
->NameLength
);
1001 io
->u
.Status
= wine_server_call( req
);
1005 if(io
->u
.Status
== STATUS_SUCCESS
)
1008 io
->u
.Status
= STATUS_PENDING
;
1012 io
->u
.Status
= NtWaitForSingleObject(internal_event
, TRUE
, NULL
);
1013 while(io
->u
.Status
== STATUS_USER_APC
);
1016 if (internal_event
) NtClose(internal_event
);
1020 case FSCTL_PIPE_DISCONNECT
:
1021 SERVER_START_REQ(disconnect_named_pipe
)
1023 req
->handle
= handle
;
1024 io
->u
.Status
= wine_server_call(req
);
1025 if (!io
->u
.Status
&& reply
->fd
!= -1) close(reply
->fd
);
1031 FIXME("Unsupported fsctl %lx (device=%lx access=%lx func=%lx method=%lx)\n",
1032 code
, code
>> 16, (code
>> 14) & 3, (code
>> 2) & 0xfff, code
& 3);
1033 io
->u
.Status
= STATUS_NOT_SUPPORTED
;
1036 return io
->u
.Status
;
1039 /******************************************************************************
1040 * NtSetVolumeInformationFile [NTDLL.@]
1041 * ZwSetVolumeInformationFile [NTDLL.@]
1043 * Set volume information for an open file handle.
1046 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1047 * IoStatusBlock [O] Receives information about the operation on return
1048 * FsInformation [I] Source for volume information
1049 * Length [I] Size of FsInformation
1050 * FsInformationClass [I] Type of volume information to set
1053 * Success: 0. IoStatusBlock is updated.
1054 * Failure: An NTSTATUS error code describing the error.
1056 NTSTATUS WINAPI
NtSetVolumeInformationFile(
1057 IN HANDLE FileHandle
,
1058 PIO_STATUS_BLOCK IoStatusBlock
,
1059 PVOID FsInformation
,
1061 FS_INFORMATION_CLASS FsInformationClass
)
1063 FIXME("(%p,%p,%p,0x%08lx,0x%08x) stub\n",
1064 FileHandle
,IoStatusBlock
,FsInformation
,Length
,FsInformationClass
);
1068 /******************************************************************************
1069 * NtQueryInformationFile [NTDLL.@]
1070 * ZwQueryInformationFile [NTDLL.@]
1072 * Get information about an open file handle.
1075 * hFile [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1076 * io [O] Receives information about the operation on return
1077 * ptr [O] Destination for file information
1078 * len [I] Size of FileInformation
1079 * class [I] Type of file information to get
1082 * Success: 0. IoStatusBlock and FileInformation are updated.
1083 * Failure: An NTSTATUS error code describing the error.
1085 NTSTATUS WINAPI
NtQueryInformationFile( HANDLE hFile
, PIO_STATUS_BLOCK io
,
1086 PVOID ptr
, LONG len
, FILE_INFORMATION_CLASS
class )
1088 static const size_t info_sizes
[] =
1091 sizeof(FILE_DIRECTORY_INFORMATION
), /* FileDirectoryInformation */
1092 sizeof(FILE_FULL_DIRECTORY_INFORMATION
), /* FileFullDirectoryInformation */
1093 sizeof(FILE_BOTH_DIRECTORY_INFORMATION
), /* FileBothDirectoryInformation */
1094 sizeof(FILE_BASIC_INFORMATION
), /* FileBasicInformation */
1095 sizeof(FILE_STANDARD_INFORMATION
), /* FileStandardInformation */
1096 sizeof(FILE_INTERNAL_INFORMATION
), /* FileInternalInformation */
1097 sizeof(FILE_EA_INFORMATION
), /* FileEaInformation */
1098 sizeof(FILE_ACCESS_INFORMATION
), /* FileAccessInformation */
1099 sizeof(FILE_NAME_INFORMATION
)-sizeof(WCHAR
), /* FileNameInformation */
1100 sizeof(FILE_RENAME_INFORMATION
)-sizeof(WCHAR
), /* FileRenameInformation */
1101 0, /* FileLinkInformation */
1102 sizeof(FILE_NAMES_INFORMATION
)-sizeof(WCHAR
), /* FileNamesInformation */
1103 sizeof(FILE_DISPOSITION_INFORMATION
), /* FileDispositionInformation */
1104 sizeof(FILE_POSITION_INFORMATION
), /* FilePositionInformation */
1105 sizeof(FILE_FULL_EA_INFORMATION
), /* FileFullEaInformation */
1106 sizeof(FILE_MODE_INFORMATION
), /* FileModeInformation */
1107 sizeof(FILE_ALIGNMENT_INFORMATION
), /* FileAlignmentInformation */
1108 sizeof(FILE_ALL_INFORMATION
)-sizeof(WCHAR
), /* FileAllInformation */
1109 sizeof(FILE_ALLOCATION_INFORMATION
), /* FileAllocationInformation */
1110 sizeof(FILE_END_OF_FILE_INFORMATION
), /* FileEndOfFileInformation */
1111 0, /* FileAlternateNameInformation */
1112 sizeof(FILE_STREAM_INFORMATION
)-sizeof(WCHAR
), /* FileStreamInformation */
1113 0, /* FilePipeInformation */
1114 0, /* FilePipeLocalInformation */
1115 0, /* FilePipeRemoteInformation */
1116 sizeof(FILE_MAILSLOT_QUERY_INFORMATION
), /* FileMailslotQueryInformation */
1117 0, /* FileMailslotSetInformation */
1118 0, /* FileCompressionInformation */
1119 0, /* FileObjectIdInformation */
1120 0, /* FileCompletionInformation */
1121 0, /* FileMoveClusterInformation */
1122 0, /* FileQuotaInformation */
1123 0, /* FileReparsePointInformation */
1124 0, /* FileNetworkOpenInformation */
1125 0, /* FileAttributeTagInformation */
1126 0 /* FileTrackingInformation */
1132 TRACE("(%p,%p,%p,0x%08lx,0x%08x)\n", hFile
, io
, ptr
, len
, class);
1134 io
->Information
= 0;
1136 if (class <= 0 || class >= FileMaximumInformation
)
1137 return io
->u
.Status
= STATUS_INVALID_INFO_CLASS
;
1138 if (!info_sizes
[class])
1140 FIXME("Unsupported class (%d)\n", class);
1141 return io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1143 if (len
< info_sizes
[class])
1144 return io
->u
.Status
= STATUS_INFO_LENGTH_MISMATCH
;
1146 if ((io
->u
.Status
= wine_server_handle_to_fd( hFile
, 0, &fd
, NULL
)))
1147 return io
->u
.Status
;
1151 case FileBasicInformation
:
1153 FILE_BASIC_INFORMATION
*info
= ptr
;
1155 if (fstat( fd
, &st
) == -1)
1156 io
->u
.Status
= FILE_GetNtStatus();
1157 else if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1158 io
->u
.Status
= STATUS_INVALID_INFO_CLASS
;
1161 if (S_ISDIR(st
.st_mode
)) info
->FileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1162 else info
->FileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1163 if (!(st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)))
1164 info
->FileAttributes
|= FILE_ATTRIBUTE_READONLY
;
1165 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->CreationTime
);
1166 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->LastWriteTime
);
1167 RtlSecondsSince1970ToTime( st
.st_ctime
, &info
->ChangeTime
);
1168 RtlSecondsSince1970ToTime( st
.st_atime
, &info
->LastAccessTime
);
1172 case FileStandardInformation
:
1174 FILE_STANDARD_INFORMATION
*info
= ptr
;
1176 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1179 if ((info
->Directory
= S_ISDIR(st
.st_mode
)))
1181 info
->AllocationSize
.QuadPart
= 0;
1182 info
->EndOfFile
.QuadPart
= 0;
1183 info
->NumberOfLinks
= 1;
1184 info
->DeletePending
= FALSE
;
1188 info
->AllocationSize
.QuadPart
= (ULONGLONG
)st
.st_blocks
* 512;
1189 info
->EndOfFile
.QuadPart
= st
.st_size
;
1190 info
->NumberOfLinks
= st
.st_nlink
;
1191 info
->DeletePending
= FALSE
; /* FIXME */
1196 case FilePositionInformation
:
1198 FILE_POSITION_INFORMATION
*info
= ptr
;
1199 off_t res
= lseek( fd
, 0, SEEK_CUR
);
1200 if (res
== (off_t
)-1) io
->u
.Status
= FILE_GetNtStatus();
1201 else info
->CurrentByteOffset
.QuadPart
= res
;
1204 case FileInternalInformation
:
1206 FILE_INTERNAL_INFORMATION
*info
= ptr
;
1208 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1209 else info
->IndexNumber
.QuadPart
= st
.st_ino
;
1212 case FileEaInformation
:
1214 FILE_EA_INFORMATION
*info
= ptr
;
1218 case FileEndOfFileInformation
:
1220 FILE_END_OF_FILE_INFORMATION
*info
= ptr
;
1222 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1223 else info
->EndOfFile
.QuadPart
= S_ISDIR(st
.st_mode
) ? 0 : st
.st_size
;
1226 case FileAllInformation
:
1228 FILE_ALL_INFORMATION
*info
= ptr
;
1230 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1231 else if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1232 io
->u
.Status
= STATUS_INVALID_INFO_CLASS
;
1235 if ((info
->StandardInformation
.Directory
= S_ISDIR(st
.st_mode
)))
1237 info
->BasicInformation
.FileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1238 info
->StandardInformation
.AllocationSize
.QuadPart
= 0;
1239 info
->StandardInformation
.EndOfFile
.QuadPart
= 0;
1240 info
->StandardInformation
.NumberOfLinks
= 1;
1241 info
->StandardInformation
.DeletePending
= FALSE
;
1245 info
->BasicInformation
.FileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1246 info
->StandardInformation
.AllocationSize
.QuadPart
= (ULONGLONG
)st
.st_blocks
* 512;
1247 info
->StandardInformation
.EndOfFile
.QuadPart
= st
.st_size
;
1248 info
->StandardInformation
.NumberOfLinks
= st
.st_nlink
;
1249 info
->StandardInformation
.DeletePending
= FALSE
; /* FIXME */
1251 if (!(st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)))
1252 info
->BasicInformation
.FileAttributes
|= FILE_ATTRIBUTE_READONLY
;
1253 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->BasicInformation
.CreationTime
);
1254 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->BasicInformation
.LastWriteTime
);
1255 RtlSecondsSince1970ToTime( st
.st_ctime
, &info
->BasicInformation
.ChangeTime
);
1256 RtlSecondsSince1970ToTime( st
.st_atime
, &info
->BasicInformation
.LastAccessTime
);
1257 info
->InternalInformation
.IndexNumber
.QuadPart
= st
.st_ino
;
1258 info
->EaInformation
.EaSize
= 0;
1259 info
->AccessInformation
.AccessFlags
= 0; /* FIXME */
1260 info
->PositionInformation
.CurrentByteOffset
.QuadPart
= lseek( fd
, 0, SEEK_CUR
);
1261 info
->ModeInformation
.Mode
= 0; /* FIXME */
1262 info
->AlignmentInformation
.AlignmentRequirement
= 1; /* FIXME */
1263 info
->NameInformation
.FileNameLength
= 0;
1264 io
->Information
= sizeof(*info
) - sizeof(WCHAR
);
1268 case FileMailslotQueryInformation
:
1270 FILE_MAILSLOT_QUERY_INFORMATION
*info
= ptr
;
1272 SERVER_START_REQ( set_mailslot_info
)
1274 req
->handle
= hFile
;
1276 io
->u
.Status
= wine_server_call( req
);
1277 if( io
->u
.Status
== STATUS_SUCCESS
)
1279 info
->MaximumMessageSize
= reply
->max_msgsize
;
1280 info
->MailslotQuota
= 0;
1281 info
->NextMessageSize
= reply
->next_msgsize
;
1282 info
->MessagesAvailable
= reply
->msg_count
;
1283 info
->ReadTimeout
.QuadPart
= reply
->read_timeout
* -10000;
1290 FIXME("Unsupported class (%d)\n", class);
1291 io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1294 wine_server_release_fd( hFile
, fd
);
1295 if (io
->u
.Status
== STATUS_SUCCESS
&& !io
->Information
) io
->Information
= info_sizes
[class];
1296 return io
->u
.Status
;
1299 /******************************************************************************
1300 * NtSetInformationFile [NTDLL.@]
1301 * ZwSetInformationFile [NTDLL.@]
1303 * Set information about an open file handle.
1306 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1307 * io [O] Receives information about the operation on return
1308 * ptr [I] Source for file information
1309 * len [I] Size of FileInformation
1310 * class [I] Type of file information to set
1313 * Success: 0. io is updated.
1314 * Failure: An NTSTATUS error code describing the error.
1316 NTSTATUS WINAPI
NtSetInformationFile(HANDLE handle
, PIO_STATUS_BLOCK io
,
1317 PVOID ptr
, ULONG len
, FILE_INFORMATION_CLASS
class)
1321 TRACE("(%p,%p,%p,0x%08lx,0x%08x)\n", handle
, io
, ptr
, len
, class);
1323 if ((io
->u
.Status
= wine_server_handle_to_fd( handle
, 0, &fd
, NULL
)))
1324 return io
->u
.Status
;
1326 io
->u
.Status
= STATUS_SUCCESS
;
1329 case FileBasicInformation
:
1330 if (len
>= sizeof(FILE_BASIC_INFORMATION
))
1333 const FILE_BASIC_INFORMATION
*info
= ptr
;
1335 if (info
->LastAccessTime
.QuadPart
|| info
->LastWriteTime
.QuadPart
)
1337 ULONGLONG sec
, nsec
;
1338 struct timeval tv
[2];
1340 if (!info
->LastAccessTime
.QuadPart
|| !info
->LastWriteTime
.QuadPart
)
1343 tv
[0].tv_sec
= tv
[0].tv_usec
= 0;
1344 tv
[1].tv_sec
= tv
[1].tv_usec
= 0;
1345 if (!fstat( fd
, &st
))
1347 tv
[0].tv_sec
= st
.st_atime
;
1348 tv
[1].tv_sec
= st
.st_mtime
;
1351 if (info
->LastAccessTime
.QuadPart
)
1353 sec
= RtlLargeIntegerDivide( info
->LastAccessTime
.QuadPart
, 10000000, &nsec
);
1354 tv
[0].tv_sec
= sec
- SECS_1601_TO_1970
;
1355 tv
[0].tv_usec
= (UINT
)nsec
/ 10;
1357 if (info
->LastWriteTime
.QuadPart
)
1359 sec
= RtlLargeIntegerDivide( info
->LastWriteTime
.QuadPart
, 10000000, &nsec
);
1360 tv
[1].tv_sec
= sec
- SECS_1601_TO_1970
;
1361 tv
[1].tv_usec
= (UINT
)nsec
/ 10;
1363 if (futimes( fd
, tv
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1366 if (io
->u
.Status
== STATUS_SUCCESS
&& info
->FileAttributes
)
1368 if (fstat( fd
, &st
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1371 if (info
->FileAttributes
& FILE_ATTRIBUTE_READONLY
)
1373 if (S_ISDIR( st
.st_mode
))
1374 WARN("FILE_ATTRIBUTE_READONLY ignored for directory.\n");
1376 st
.st_mode
&= ~0222; /* clear write permission bits */
1380 /* add write permission only where we already have read permission */
1381 st
.st_mode
|= (0600 | ((st
.st_mode
& 044) >> 1)) & (~FILE_umask
);
1383 if (fchmod( fd
, st
.st_mode
) == -1) io
->u
.Status
= FILE_GetNtStatus();
1387 else io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1390 case FilePositionInformation
:
1391 if (len
>= sizeof(FILE_POSITION_INFORMATION
))
1393 const FILE_POSITION_INFORMATION
*info
= ptr
;
1395 if (lseek( fd
, info
->CurrentByteOffset
.QuadPart
, SEEK_SET
) == (off_t
)-1)
1396 io
->u
.Status
= FILE_GetNtStatus();
1398 else io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1401 case FileEndOfFileInformation
:
1402 if (len
>= sizeof(FILE_END_OF_FILE_INFORMATION
))
1405 const FILE_END_OF_FILE_INFORMATION
*info
= ptr
;
1407 /* first try normal truncate */
1408 if (ftruncate( fd
, (off_t
)info
->EndOfFile
.QuadPart
) != -1) break;
1410 /* now check for the need to extend the file */
1411 if (fstat( fd
, &st
) != -1 && (off_t
)info
->EndOfFile
.QuadPart
> st
.st_size
)
1413 static const char zero
;
1415 /* extend the file one byte beyond the requested size and then truncate it */
1416 /* this should work around ftruncate implementations that can't extend files */
1417 if (pwrite( fd
, &zero
, 1, (off_t
)info
->EndOfFile
.QuadPart
) != -1 &&
1418 ftruncate( fd
, (off_t
)info
->EndOfFile
.QuadPart
) != -1) break;
1420 io
->u
.Status
= FILE_GetNtStatus();
1422 else io
->u
.Status
= STATUS_INVALID_PARAMETER_3
;
1425 case FileMailslotSetInformation
:
1427 FILE_MAILSLOT_SET_INFORMATION
*info
= ptr
;
1429 SERVER_START_REQ( set_mailslot_info
)
1431 req
->handle
= handle
;
1432 req
->flags
= MAILSLOT_SET_READ_TIMEOUT
;
1433 req
->read_timeout
= info
->ReadTimeout
.QuadPart
/ -10000;
1434 io
->u
.Status
= wine_server_call( req
);
1441 FIXME("Unsupported class (%d)\n", class);
1442 io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1445 wine_server_release_fd( handle
, fd
);
1446 io
->Information
= 0;
1447 return io
->u
.Status
;
1451 /******************************************************************************
1452 * NtQueryFullAttributesFile (NTDLL.@)
1454 NTSTATUS WINAPI
NtQueryFullAttributesFile( const OBJECT_ATTRIBUTES
*attr
,
1455 FILE_NETWORK_OPEN_INFORMATION
*info
)
1457 ANSI_STRING unix_name
;
1460 if (!(status
= wine_nt_to_unix_file_name( attr
->ObjectName
, &unix_name
, FILE_OPEN
,
1461 !(attr
->Attributes
& OBJ_CASE_INSENSITIVE
) )))
1465 if (stat( unix_name
.Buffer
, &st
) == -1)
1466 status
= FILE_GetNtStatus();
1467 else if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1468 status
= STATUS_INVALID_INFO_CLASS
;
1471 if (S_ISDIR(st
.st_mode
))
1473 info
->FileAttributes
= FILE_ATTRIBUTE_DIRECTORY
;
1474 info
->AllocationSize
.QuadPart
= 0;
1475 info
->EndOfFile
.QuadPart
= 0;
1479 info
->FileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1480 info
->AllocationSize
.QuadPart
= (ULONGLONG
)st
.st_blocks
* 512;
1481 info
->EndOfFile
.QuadPart
= st
.st_size
;
1483 if (!(st
.st_mode
& (S_IWUSR
| S_IWGRP
| S_IWOTH
)))
1484 info
->FileAttributes
|= FILE_ATTRIBUTE_READONLY
;
1485 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->CreationTime
);
1486 RtlSecondsSince1970ToTime( st
.st_mtime
, &info
->LastWriteTime
);
1487 RtlSecondsSince1970ToTime( st
.st_ctime
, &info
->ChangeTime
);
1488 RtlSecondsSince1970ToTime( st
.st_atime
, &info
->LastAccessTime
);
1489 if (DIR_is_hidden_file( attr
->ObjectName
))
1490 info
->FileAttributes
|= FILE_ATTRIBUTE_HIDDEN
;
1492 RtlFreeAnsiString( &unix_name
);
1494 else WARN("%s not found (%lx)\n", debugstr_us(attr
->ObjectName
), status
);
1499 /******************************************************************************
1500 * NtQueryAttributesFile (NTDLL.@)
1501 * ZwQueryAttributesFile (NTDLL.@)
1503 NTSTATUS WINAPI
NtQueryAttributesFile( const OBJECT_ATTRIBUTES
*attr
, FILE_BASIC_INFORMATION
*info
)
1505 FILE_NETWORK_OPEN_INFORMATION full_info
;
1508 if (!(status
= NtQueryFullAttributesFile( attr
, &full_info
)))
1510 info
->CreationTime
.QuadPart
= full_info
.CreationTime
.QuadPart
;
1511 info
->LastAccessTime
.QuadPart
= full_info
.LastAccessTime
.QuadPart
;
1512 info
->LastWriteTime
.QuadPart
= full_info
.LastWriteTime
.QuadPart
;
1513 info
->ChangeTime
.QuadPart
= full_info
.ChangeTime
.QuadPart
;
1514 info
->FileAttributes
= full_info
.FileAttributes
;
1520 /******************************************************************************
1521 * FILE_GetDeviceInfo
1523 * Implementation of the FileFsDeviceInformation query for NtQueryVolumeInformationFile.
1525 NTSTATUS
FILE_GetDeviceInfo( int fd
, FILE_FS_DEVICE_INFORMATION
*info
)
1529 info
->Characteristics
= 0;
1530 if (fstat( fd
, &st
) < 0) return FILE_GetNtStatus();
1531 if (S_ISCHR( st
.st_mode
))
1533 info
->DeviceType
= FILE_DEVICE_UNKNOWN
;
1535 switch(major(st
.st_rdev
))
1538 info
->DeviceType
= FILE_DEVICE_NULL
;
1541 info
->DeviceType
= FILE_DEVICE_SERIAL_PORT
;
1544 info
->DeviceType
= FILE_DEVICE_PARALLEL_PORT
;
1549 else if (S_ISBLK( st
.st_mode
))
1551 info
->DeviceType
= FILE_DEVICE_DISK
;
1553 else if (S_ISFIFO( st
.st_mode
) || S_ISSOCK( st
.st_mode
))
1555 info
->DeviceType
= FILE_DEVICE_NAMED_PIPE
;
1557 else /* regular file or directory */
1559 #if defined(linux) && defined(HAVE_FSTATFS)
1562 /* check for floppy disk */
1563 if (major(st
.st_dev
) == FLOPPY_MAJOR
)
1564 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
1566 if (fstatfs( fd
, &stfs
) < 0) stfs
.f_type
= 0;
1567 switch (stfs
.f_type
)
1569 case 0x9660: /* iso9660 */
1570 case 0x15013346: /* udf */
1571 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
1572 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
|FILE_READ_ONLY_DEVICE
;
1574 case 0x6969: /* nfs */
1575 case 0x517B: /* smbfs */
1576 case 0x564c: /* ncpfs */
1577 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
1578 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
1580 case 0x01021994: /* tmpfs */
1581 case 0x28cd3d45: /* cramfs */
1582 case 0x1373: /* devfs */
1583 case 0x9fa0: /* procfs */
1584 info
->DeviceType
= FILE_DEVICE_VIRTUAL_DISK
;
1587 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
1590 #elif defined(__FreeBSD__)
1593 /* The proper way to do this in FreeBSD seems to be with the
1594 * name rather than the type, since their linux-compatible
1595 * fstatfs call converts the name to one of the Linux types.
1597 if (fstatfs( fd
, &stfs
) < 0)
1598 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
1599 else if (!strncmp("cd9660", stfs
.f_fstypename
,
1600 sizeof(stfs
.f_fstypename
)))
1602 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
1603 /* Don't assume read-only, let the mount options set it
1606 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
1608 else if (!strncmp("nfs", stfs
.f_fstypename
,
1609 sizeof(stfs
.f_fstypename
)))
1611 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
1612 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
1614 else if (!strncmp("nwfs", stfs
.f_fstypename
,
1615 sizeof(stfs
.f_fstypename
)))
1617 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
1618 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
1620 else if (!strncmp("procfs", stfs
.f_fstypename
,
1621 sizeof(stfs
.f_fstypename
)))
1622 info
->DeviceType
= FILE_DEVICE_VIRTUAL_DISK
;
1624 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
1625 if (stfs
.f_flags
& MNT_RDONLY
)
1626 info
->Characteristics
|= FILE_READ_ONLY_DEVICE
;
1627 if (!(stfs
.f_flags
& MNT_LOCAL
))
1629 info
->DeviceType
= FILE_DEVICE_NETWORK_FILE_SYSTEM
;
1630 info
->Characteristics
|= FILE_REMOTE_DEVICE
;
1632 #elif defined (__APPLE__)
1634 kern_return_t kernResult
= KERN_FAILURE
;
1635 mach_port_t masterPort
;
1636 char bsdName
[6]; /* disk#\0 */
1639 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
1641 if (fstatfs( fd
, &stfs
) < 0) return FILE_GetNtStatus();
1643 /* stfs.f_type is reserved (always set to 0) so use IOKit */
1644 name
= stfs
.f_mntfromname
+ strlen(_PATH_DEV
);
1645 memcpy( bsdName
, name
, min(strlen(name
)+1,sizeof(bsdName
)) );
1646 bsdName
[sizeof(bsdName
)-1] = 0;
1648 kernResult
= IOMasterPort(MACH_PORT_NULL
, &masterPort
);
1650 if (kernResult
== KERN_SUCCESS
)
1652 CFMutableDictionaryRef matching
= IOBSDNameMatching(masterPort
, 0, bsdName
);
1657 CFMutableDictionaryRef properties
;
1658 io_service_t devService
= IOServiceGetMatchingService(masterPort
, matching
);
1660 if (IORegistryEntryCreateCFProperties(devService
,
1662 kCFAllocatorDefault
, 0) != KERN_SUCCESS
)
1663 return FILE_GetNtStatus(); /* FIXME */
1665 CFDictionaryGetValue(properties
, CFSTR("Removable")),
1667 ) info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
1670 CFDictionaryGetValue(properties
, CFSTR("Writable")),
1672 ) info
->Characteristics
|= FILE_READ_ONLY_DEVICE
;
1675 NB : mounted disk image (.img/.dmg) don't provide specific type
1677 if ( (type
= CFDictionaryGetValue(properties
, CFSTR("Type"))) )
1679 if ( CFStringCompare(type
, CFSTR("CD-ROM"), 0) == kCFCompareEqualTo
1680 || CFStringCompare(type
, CFSTR("DVD-ROM"), 0) == kCFCompareEqualTo
1683 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
1688 CFRelease(properties
);
1692 /* Use dkio to work out device types */
1694 # include <sys/dkio.h>
1695 # include <sys/vtoc.h>
1696 struct dk_cinfo dkinf
;
1697 int retval
= ioctl(fd
, DKIOCINFO
, &dkinf
);
1699 WARN("Unable to get disk device type information - assuming a disk like device\n");
1700 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
1702 switch (dkinf
.dki_ctype
)
1705 info
->DeviceType
= FILE_DEVICE_CD_ROM_FILE_SYSTEM
;
1706 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
|FILE_READ_ONLY_DEVICE
;
1710 case DKC_INTEL82072
:
1711 case DKC_INTEL82077
:
1712 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
1713 info
->Characteristics
|= FILE_REMOVABLE_MEDIA
;
1716 info
->DeviceType
= FILE_DEVICE_VIRTUAL_DISK
;
1719 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
1724 if (!warned
++) FIXME( "device info not properly supported on this platform\n" );
1725 info
->DeviceType
= FILE_DEVICE_DISK_FILE_SYSTEM
;
1727 info
->Characteristics
|= FILE_DEVICE_IS_MOUNTED
;
1729 return STATUS_SUCCESS
;
1733 /******************************************************************************
1734 * NtQueryVolumeInformationFile [NTDLL.@]
1735 * ZwQueryVolumeInformationFile [NTDLL.@]
1737 * Get volume information for an open file handle.
1740 * handle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1741 * io [O] Receives information about the operation on return
1742 * buffer [O] Destination for volume information
1743 * length [I] Size of FsInformation
1744 * info_class [I] Type of volume information to set
1747 * Success: 0. io and buffer are updated.
1748 * Failure: An NTSTATUS error code describing the error.
1750 NTSTATUS WINAPI
NtQueryVolumeInformationFile( HANDLE handle
, PIO_STATUS_BLOCK io
,
1751 PVOID buffer
, ULONG length
,
1752 FS_INFORMATION_CLASS info_class
)
1757 if ((io
->u
.Status
= wine_server_handle_to_fd( handle
, 0, &fd
, NULL
)) != STATUS_SUCCESS
)
1758 return io
->u
.Status
;
1760 io
->u
.Status
= STATUS_NOT_IMPLEMENTED
;
1761 io
->Information
= 0;
1763 switch( info_class
)
1765 case FileFsVolumeInformation
:
1766 FIXME( "%p: volume info not supported\n", handle
);
1768 case FileFsLabelInformation
:
1769 FIXME( "%p: label info not supported\n", handle
);
1771 case FileFsSizeInformation
:
1772 if (length
< sizeof(FILE_FS_SIZE_INFORMATION
))
1773 io
->u
.Status
= STATUS_BUFFER_TOO_SMALL
;
1776 FILE_FS_SIZE_INFORMATION
*info
= buffer
;
1778 if (fstat( fd
, &st
) < 0)
1780 io
->u
.Status
= FILE_GetNtStatus();
1783 if (!S_ISREG(st
.st_mode
) && !S_ISDIR(st
.st_mode
))
1785 io
->u
.Status
= STATUS_INVALID_DEVICE_REQUEST
;
1789 /* Linux's fstatvfs is buggy */
1790 #if !defined(linux) || !defined(HAVE_FSTATFS)
1791 struct statvfs stfs
;
1793 if (fstatvfs( fd
, &stfs
) < 0)
1795 io
->u
.Status
= FILE_GetNtStatus();
1798 info
->BytesPerSector
= stfs
.f_frsize
;
1801 if (fstatfs( fd
, &stfs
) < 0)
1803 io
->u
.Status
= FILE_GetNtStatus();
1806 info
->BytesPerSector
= stfs
.f_bsize
;
1808 info
->TotalAllocationUnits
.QuadPart
= stfs
.f_blocks
;
1809 info
->AvailableAllocationUnits
.QuadPart
= stfs
.f_bavail
;
1810 info
->SectorsPerAllocationUnit
= 1;
1811 io
->Information
= sizeof(*info
);
1812 io
->u
.Status
= STATUS_SUCCESS
;
1816 case FileFsDeviceInformation
:
1817 if (length
< sizeof(FILE_FS_DEVICE_INFORMATION
))
1818 io
->u
.Status
= STATUS_BUFFER_TOO_SMALL
;
1821 FILE_FS_DEVICE_INFORMATION
*info
= buffer
;
1823 if ((io
->u
.Status
= FILE_GetDeviceInfo( fd
, info
)) == STATUS_SUCCESS
)
1824 io
->Information
= sizeof(*info
);
1827 case FileFsAttributeInformation
:
1828 FIXME( "%p: attribute info not supported\n", handle
);
1830 case FileFsControlInformation
:
1831 FIXME( "%p: control info not supported\n", handle
);
1833 case FileFsFullSizeInformation
:
1834 FIXME( "%p: full size info not supported\n", handle
);
1836 case FileFsObjectIdInformation
:
1837 FIXME( "%p: object id info not supported\n", handle
);
1839 case FileFsMaximumInformation
:
1840 FIXME( "%p: maximum info not supported\n", handle
);
1843 io
->u
.Status
= STATUS_INVALID_PARAMETER
;
1846 wine_server_release_fd( handle
, fd
);
1847 return io
->u
.Status
;
1851 /******************************************************************
1852 * NtFlushBuffersFile (NTDLL.@)
1854 * Flush any buffered data on an open file handle.
1857 * FileHandle [I] Handle returned from ZwOpenFile() or ZwCreateFile()
1858 * IoStatusBlock [O] Receives information about the operation on return
1861 * Success: 0. IoStatusBlock is updated.
1862 * Failure: An NTSTATUS error code describing the error.
1864 NTSTATUS WINAPI
NtFlushBuffersFile( HANDLE hFile
, IO_STATUS_BLOCK
* IoStatusBlock
)
1867 HANDLE hEvent
= NULL
;
1869 SERVER_START_REQ( flush_file
)
1871 req
->handle
= hFile
;
1872 ret
= wine_server_call( req
);
1873 hEvent
= reply
->event
;
1878 ret
= NtWaitForSingleObject( hEvent
, FALSE
, NULL
);
1884 /******************************************************************
1885 * NtLockFile (NTDLL.@)
1889 NTSTATUS WINAPI
NtLockFile( HANDLE hFile
, HANDLE lock_granted_event
,
1890 PIO_APC_ROUTINE apc
, void* apc_user
,
1891 PIO_STATUS_BLOCK io_status
, PLARGE_INTEGER offset
,
1892 PLARGE_INTEGER count
, ULONG
* key
, BOOLEAN dont_wait
,
1899 if (apc
|| io_status
|| key
)
1901 FIXME("Unimplemented yet parameter\n");
1902 return STATUS_NOT_IMPLEMENTED
;
1907 SERVER_START_REQ( lock_file
)
1909 req
->handle
= hFile
;
1910 req
->offset_low
= offset
->u
.LowPart
;
1911 req
->offset_high
= offset
->u
.HighPart
;
1912 req
->count_low
= count
->u
.LowPart
;
1913 req
->count_high
= count
->u
.HighPart
;
1914 req
->shared
= !exclusive
;
1915 req
->wait
= !dont_wait
;
1916 ret
= wine_server_call( req
);
1917 handle
= reply
->handle
;
1918 async
= reply
->overlapped
;
1921 if (ret
!= STATUS_PENDING
)
1923 if (!ret
&& lock_granted_event
) NtSetEvent(lock_granted_event
, NULL
);
1929 FIXME( "Async I/O lock wait not implemented, might deadlock\n" );
1930 if (handle
) NtClose( handle
);
1931 return STATUS_PENDING
;
1935 NtWaitForSingleObject( handle
, FALSE
, NULL
);
1942 /* Unix lock conflict, sleep a bit and retry */
1943 time
.QuadPart
= 100 * (ULONGLONG
)10000;
1944 time
.QuadPart
= -time
.QuadPart
;
1945 NtDelayExecution( FALSE
, &time
);
1951 /******************************************************************
1952 * NtUnlockFile (NTDLL.@)
1956 NTSTATUS WINAPI
NtUnlockFile( HANDLE hFile
, PIO_STATUS_BLOCK io_status
,
1957 PLARGE_INTEGER offset
, PLARGE_INTEGER count
,
1962 TRACE( "%p %lx%08lx %lx%08lx\n",
1963 hFile
, offset
->u
.HighPart
, offset
->u
.LowPart
, count
->u
.HighPart
, count
->u
.LowPart
);
1965 if (io_status
|| key
)
1967 FIXME("Unimplemented yet parameter\n");
1968 return STATUS_NOT_IMPLEMENTED
;
1971 SERVER_START_REQ( unlock_file
)
1973 req
->handle
= hFile
;
1974 req
->offset_low
= offset
->u
.LowPart
;
1975 req
->offset_high
= offset
->u
.HighPart
;
1976 req
->count_low
= count
->u
.LowPart
;
1977 req
->count_high
= count
->u
.HighPart
;
1978 status
= wine_server_call( req
);
1984 /******************************************************************
1985 * NtCreateNamedPipeFile (NTDLL.@)
1989 NTSTATUS WINAPI
NtCreateNamedPipeFile( PHANDLE handle
, ULONG access
,
1990 POBJECT_ATTRIBUTES attr
, PIO_STATUS_BLOCK iosb
,
1991 ULONG sharing
, ULONG dispo
, ULONG options
,
1992 ULONG pipe_type
, ULONG read_mode
,
1993 ULONG completion_mode
, ULONG max_inst
,
1994 ULONG inbound_quota
, ULONG outbound_quota
,
1995 PLARGE_INTEGER timeout
)
1998 static const WCHAR leadin
[] = {'\\','?','?','\\','P','I','P','E','\\'};
2000 TRACE("(%p %lx %s %p %lx %ld %lx %ld %ld %ld %ld %ld %ld %p)\n",
2001 handle
, access
, debugstr_w(attr
->ObjectName
->Buffer
), iosb
, sharing
, dispo
,
2002 options
, pipe_type
, read_mode
, completion_mode
, max_inst
, inbound_quota
,
2003 outbound_quota
, timeout
);
2005 if (attr
->ObjectName
->Length
< sizeof(leadin
) ||
2006 strncmpiW( attr
->ObjectName
->Buffer
,
2007 leadin
, sizeof(leadin
)/sizeof(leadin
[0]) ))
2008 return STATUS_OBJECT_NAME_INVALID
;
2009 /* assume we only get relative timeout, and storable in a DWORD as ms */
2010 if (timeout
->QuadPart
> 0 || (timeout
->QuadPart
/ -10000) >> 32)
2011 FIXME("Wrong time %s\n", wine_dbgstr_longlong(timeout
->QuadPart
));
2013 SERVER_START_REQ( create_named_pipe
)
2015 req
->access
= access
;
2016 req
->attributes
= (attr
) ? attr
->Attributes
: 0;
2017 req
->rootdir
= attr
? attr
->RootDirectory
: 0;
2018 req
->options
= options
;
2020 (pipe_type
) ? NAMED_PIPE_MESSAGE_STREAM_WRITE
: 0 |
2021 (read_mode
) ? NAMED_PIPE_MESSAGE_STREAM_READ
: 0 |
2022 (completion_mode
) ? NAMED_PIPE_NONBLOCKING_MODE
: 0;
2023 req
->maxinstances
= max_inst
;
2024 req
->outsize
= outbound_quota
;
2025 req
->insize
= inbound_quota
;
2026 req
->timeout
= timeout
->QuadPart
/ -10000;
2027 wine_server_add_data( req
, attr
->ObjectName
->Buffer
,
2028 attr
->ObjectName
->Length
);
2029 status
= wine_server_call( req
);
2030 if (!status
) *handle
= reply
->handle
;
2036 /******************************************************************
2037 * NtDeleteFile (NTDLL.@)
2041 NTSTATUS WINAPI
NtDeleteFile( POBJECT_ATTRIBUTES ObjectAttributes
)
2047 TRACE("%p\n", ObjectAttributes
);
2048 status
= NtCreateFile( &hFile
, GENERIC_READ
| GENERIC_WRITE
, ObjectAttributes
,
2050 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
2051 FILE_OPEN
, FILE_DELETE_ON_CLOSE
, NULL
, 0 );
2052 if (status
== STATUS_SUCCESS
) status
= NtClose(hFile
);
2056 /******************************************************************
2057 * NtCancelIoFile (NTDLL.@)
2061 NTSTATUS WINAPI
NtCancelIoFile( HANDLE hFile
, PIO_STATUS_BLOCK io_status
)
2063 LARGE_INTEGER timeout
;
2065 TRACE("%p %p\n", hFile
, io_status
);
2067 SERVER_START_REQ( cancel_async
)
2069 req
->handle
= hFile
;
2070 wine_server_call( req
);
2073 /* Let some APC be run, so that we can run the remaining APCs on hFile
2074 * either the cancelation of the pending one, but also the execution
2075 * of the queued APC, but not yet run. This is needed to ensure proper
2076 * clean-up of allocated data.
2078 timeout
.u
.LowPart
= timeout
.u
.HighPart
= 0;
2079 return io_status
->u
.Status
= NtDelayExecution( TRUE
, &timeout
);
2082 /******************************************************************************
2083 * NtCreateMailslotFile [NTDLL.@]
2084 * ZwCreateMailslotFile [NTDLL.@]
2087 * pHandle [O] pointer to receive the handle created
2088 * DesiredAccess [I] access mode (read, write, etc)
2089 * ObjectAttributes [I] fully qualified NT path of the mailslot
2090 * IoStatusBlock [O] receives completion status and other info
2093 * MaxMessageSize [I]
2099 NTSTATUS WINAPI
NtCreateMailslotFile(PHANDLE pHandle
, ULONG DesiredAccess
,
2100 POBJECT_ATTRIBUTES attr
, PIO_STATUS_BLOCK IoStatusBlock
,
2101 ULONG CreateOptions
, ULONG MailslotQuota
, ULONG MaxMessageSize
,
2102 PLARGE_INTEGER TimeOut
)
2104 static const WCHAR leadin
[] = {
2105 '\\','?','?','\\','M','A','I','L','S','L','O','T','\\'};
2108 TRACE("%p %08lx %p %p %08lx %08lx %08lx %p\n",
2109 pHandle
, DesiredAccess
, attr
, IoStatusBlock
,
2110 CreateOptions
, MailslotQuota
, MaxMessageSize
, TimeOut
);
2112 if (attr
->ObjectName
->Length
< sizeof(leadin
) ||
2113 strncmpiW( attr
->ObjectName
->Buffer
,
2114 leadin
, sizeof(leadin
)/sizeof(leadin
[0]) ))
2116 return STATUS_OBJECT_NAME_INVALID
;
2119 SERVER_START_REQ( create_mailslot
)
2121 req
->access
= DesiredAccess
;
2122 req
->attributes
= (attr
) ? attr
->Attributes
: 0;
2123 req
->rootdir
= attr
? attr
->RootDirectory
: 0;
2124 req
->max_msgsize
= MaxMessageSize
;
2125 req
->read_timeout
= (TimeOut
->QuadPart
<= 0) ? TimeOut
->QuadPart
/ -10000 : -1;
2126 wine_server_add_data( req
, attr
->ObjectName
->Buffer
,
2127 attr
->ObjectName
->Length
);
2128 ret
= wine_server_call( req
);
2129 if( ret
== STATUS_SUCCESS
)
2130 *pHandle
= reply
->handle
;