2 * File handling functions
4 * Copyright 1993 John Burton
5 * Copyright 1996, 2004 Alexandre Julliard
6 * Copyright 2008 Jeff Zaroyko
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
28 #define WIN32_NO_STATUS
37 #include "ddk/ntddk.h"
38 #include "ddk/ntddser.h"
40 #include "kernelbase.h"
41 #include "wine/exception.h"
42 #include "wine/debug.h"
44 WINE_DEFAULT_DEBUG_CHANNEL(file
);
46 /* info structure for FindFirstFile handle */
49 DWORD magic
; /* magic number */
50 HANDLE handle
; /* handle to directory */
51 CRITICAL_SECTION cs
; /* crit section protecting this structure */
52 FINDEX_SEARCH_OPS search_op
; /* Flags passed to FindFirst. */
53 FINDEX_INFO_LEVELS level
; /* Level passed to FindFirst */
54 UNICODE_STRING path
; /* NT path used to open the directory */
55 BOOL is_root
; /* is directory the root of the drive? */
56 BOOL wildcard
; /* did the mask contain wildcard characters? */
57 UINT data_pos
; /* current position in dir data */
58 UINT data_len
; /* length of dir data */
59 UINT data_size
; /* size of data buffer, or 0 when everything has been read */
60 BYTE data
[1]; /* directory data */
63 #define FIND_FIRST_MAGIC 0xc0ffee11
65 static const UINT max_entry_size
= offsetof( FILE_BOTH_DIRECTORY_INFORMATION
, FileName
[256] );
67 const WCHAR windows_dir
[] = L
"C:\\windows";
68 const WCHAR system_dir
[] = L
"C:\\windows\\system32";
70 static BOOL oem_file_apis
;
73 static void WINAPI
read_write_apc( void *apc_user
, PIO_STATUS_BLOCK io
, ULONG reserved
)
75 LPOVERLAPPED_COMPLETION_ROUTINE func
= apc_user
;
76 func( RtlNtStatusToDosError( io
->Status
), io
->Information
, (LPOVERLAPPED
)io
);
79 static const WCHAR
*get_machine_wow64_dir( WORD machine
)
83 case IMAGE_FILE_MACHINE_TARGET_HOST
: return system_dir
;
84 case IMAGE_FILE_MACHINE_I386
: return L
"C:\\windows\\syswow64";
85 case IMAGE_FILE_MACHINE_ARMNT
: return L
"C:\\windows\\sysarm32";
86 case IMAGE_FILE_MACHINE_AMD64
: return L
"C:\\windows\\sysx8664";
87 case IMAGE_FILE_MACHINE_ARM64
: return L
"C:\\windows\\sysarm64";
93 /***********************************************************************
94 * Operations on file names
95 ***********************************************************************/
98 /***********************************************************************
101 * Check if the file name contains a path; helper for SearchPathW.
102 * A relative path is not considered a path unless it starts with ./ or ../
104 static inline BOOL
contains_path( const WCHAR
*name
)
106 if (RtlDetermineDosPathNameType_U( name
) != RELATIVE_PATH
) return TRUE
;
107 if (name
[0] != '.') return FALSE
;
108 if (name
[1] == '/' || name
[1] == '\\') return TRUE
;
109 return (name
[1] == '.' && (name
[2] == '/' || name
[2] == '\\'));
113 /***********************************************************************
114 * add_boot_rename_entry
116 * Adds an entry to the registry that is loaded when windows boots and
117 * checks if there are some files to be removed or renamed/moved.
118 * <fn1> has to be valid and <fn2> may be NULL. If both pointers are
119 * non-NULL then the file is moved, otherwise it is deleted. The
120 * entry of the registry key is always appended with two zero
121 * terminated strings. If <fn2> is NULL then the second entry is
122 * simply a single 0-byte. Otherwise the second filename goes
123 * there. The entries are prepended with \??\ before the path and the
124 * second filename gets also a '!' as the first character if
125 * MOVEFILE_REPLACE_EXISTING is set. After the final string another
126 * 0-byte follows to indicate the end of the strings.
128 * \??\D:\test\file1[0]
129 * !\??\D:\test\file1_renamed[0]
130 * \??\D:\Test|delete[0]
131 * [0] <- file is to be deleted, second string empty
132 * \??\D:\test\file2[0]
133 * !\??\D:\test\file2_renamed[0]
134 * [0] <- indicates end of strings
137 * \??\D:\test\file1[0]
138 * !\??\D:\test\file1_renamed[0]
139 * \??\D:\Test|delete[0]
140 * [0] <- file is to be deleted, second string empty
141 * [0] <- indicates end of strings
144 static BOOL
add_boot_rename_entry( LPCWSTR source
, LPCWSTR dest
, DWORD flags
)
146 static const int info_size
= FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION
, Data
);
148 OBJECT_ATTRIBUTES attr
;
149 UNICODE_STRING session_manager
= RTL_CONSTANT_STRING( L
"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Session Manager" );
150 UNICODE_STRING pending_file_rename_operations
= RTL_CONSTANT_STRING( L
"PendingFileRenameOperations" );
151 UNICODE_STRING source_name
, dest_name
;
152 KEY_VALUE_PARTIAL_INFORMATION
*info
;
160 if (!RtlDosPathNameToNtPathName_U( source
, &source_name
, NULL
, NULL
))
162 SetLastError( ERROR_PATH_NOT_FOUND
);
165 dest_name
.Buffer
= NULL
;
166 if (dest
&& !RtlDosPathNameToNtPathName_U( dest
, &dest_name
, NULL
, NULL
))
168 RtlFreeUnicodeString( &source_name
);
169 SetLastError( ERROR_PATH_NOT_FOUND
);
173 attr
.Length
= sizeof(attr
);
174 attr
.RootDirectory
= 0;
175 attr
.ObjectName
= &session_manager
;
177 attr
.SecurityDescriptor
= NULL
;
178 attr
.SecurityQualityOfService
= NULL
;
180 if (NtCreateKey( &key
, KEY_ALL_ACCESS
, &attr
, 0, NULL
, 0, NULL
) != STATUS_SUCCESS
)
182 RtlFreeUnicodeString( &source_name
);
183 RtlFreeUnicodeString( &dest_name
);
187 len1
= source_name
.Length
+ sizeof(WCHAR
);
190 len2
= dest_name
.Length
+ sizeof(WCHAR
);
191 if (flags
& MOVEFILE_REPLACE_EXISTING
)
192 len2
+= sizeof(WCHAR
); /* Plus 1 because of the leading '!' */
194 else len2
= sizeof(WCHAR
); /* minimum is the 0 characters for the empty second string */
196 /* First we check if the key exists and if so how many bytes it already contains. */
197 if (NtQueryValueKey( key
, &pending_file_rename_operations
, KeyValuePartialInformation
,
198 NULL
, 0, &size
) == STATUS_BUFFER_TOO_SMALL
)
200 if (!(buffer
= HeapAlloc( GetProcessHeap(), 0, size
+ len1
+ len2
+ sizeof(WCHAR
) ))) goto done
;
201 if (NtQueryValueKey( key
, &pending_file_rename_operations
, KeyValuePartialInformation
, buffer
, size
, &size
)) goto done
;
202 info
= (KEY_VALUE_PARTIAL_INFORMATION
*)buffer
;
203 if (info
->Type
!= REG_MULTI_SZ
) goto done
;
204 if (size
> sizeof(info
)) size
-= sizeof(WCHAR
); /* remove terminating null (will be added back later) */
209 if (!(buffer
= HeapAlloc( GetProcessHeap(), 0, size
+ len1
+ len2
+ sizeof(WCHAR
) ))) goto done
;
212 memcpy( buffer
+ size
, source_name
.Buffer
, len1
);
214 p
= (WCHAR
*)(buffer
+ size
);
217 if (flags
& MOVEFILE_REPLACE_EXISTING
) *p
++ = '!';
218 memcpy( p
, dest_name
.Buffer
, len2
);
224 size
+= sizeof(WCHAR
);
228 p
= (WCHAR
*)(buffer
+ size
);
230 size
+= sizeof(WCHAR
);
231 rc
= !NtSetValueKey( key
, &pending_file_rename_operations
, 0, REG_MULTI_SZ
, buffer
+ info_size
, size
- info_size
);
234 RtlFreeUnicodeString( &source_name
);
235 RtlFreeUnicodeString( &dest_name
);
236 if (key
) NtClose(key
);
237 HeapFree( GetProcessHeap(), 0, buffer
);
242 /***********************************************************************
245 static WCHAR
*append_ext( const WCHAR
*name
, const WCHAR
*ext
)
251 if (!ext
) return NULL
;
252 p
= wcsrchr( name
, '.' );
253 if (p
&& !wcschr( p
, '/' ) && !wcschr( p
, '\\' )) return NULL
;
255 len
= lstrlenW( name
) + lstrlenW( ext
);
256 if ((ret
= RtlAllocateHeap( GetProcessHeap(), 0, (len
+ 1) * sizeof(WCHAR
) )))
258 lstrcpyW( ret
, name
);
259 lstrcatW( ret
, ext
);
265 /***********************************************************************
266 * find_actctx_dllpath
268 * Find the path (if any) of the dll from the activation context.
269 * Returned path doesn't include a name.
271 static NTSTATUS
find_actctx_dllpath( const WCHAR
*name
, WCHAR
**path
)
273 ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION
*info
;
274 ACTCTX_SECTION_KEYED_DATA data
;
275 UNICODE_STRING nameW
;
277 SIZE_T needed
, size
= 1024;
280 RtlInitUnicodeString( &nameW
, name
);
281 data
.cbSize
= sizeof(data
);
282 status
= RtlFindActivationContextSectionString( FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX
, NULL
,
283 ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION
,
285 if (status
!= STATUS_SUCCESS
) return status
;
289 if (!(info
= RtlAllocateHeap( GetProcessHeap(), 0, size
)))
291 status
= STATUS_NO_MEMORY
;
294 status
= RtlQueryInformationActivationContext( 0, data
.hActCtx
, &data
.ulAssemblyRosterIndex
,
295 AssemblyDetailedInformationInActivationContext
,
296 info
, size
, &needed
);
297 if (status
== STATUS_SUCCESS
) break;
298 if (status
!= STATUS_BUFFER_TOO_SMALL
) goto done
;
299 RtlFreeHeap( GetProcessHeap(), 0, info
);
301 /* restart with larger buffer */
304 if (!info
->lpAssemblyManifestPath
)
306 status
= STATUS_SXS_KEY_NOT_FOUND
;
310 if ((p
= wcsrchr( info
->lpAssemblyManifestPath
, '\\' )))
312 DWORD dirlen
= info
->ulAssemblyDirectoryNameLength
/ sizeof(WCHAR
);
316 CompareStringOrdinal( p
, dirlen
, info
->lpAssemblyDirectoryName
, dirlen
, TRUE
) != CSTR_EQUAL
||
317 wcsicmp( p
+ dirlen
, L
".manifest" ))
319 /* manifest name does not match directory name, so it's not a global
320 * windows/winsxs manifest; use the manifest directory name instead */
321 dirlen
= p
- info
->lpAssemblyManifestPath
;
322 needed
= (dirlen
+ 1) * sizeof(WCHAR
);
323 if (!(*path
= p
= HeapAlloc( GetProcessHeap(), 0, needed
)))
325 status
= STATUS_NO_MEMORY
;
328 memcpy( p
, info
->lpAssemblyManifestPath
, dirlen
* sizeof(WCHAR
) );
334 if (!info
->lpAssemblyDirectoryName
)
336 status
= STATUS_SXS_KEY_NOT_FOUND
;
340 needed
= sizeof(L
"C:\\windows\\winsxs\\") + info
->ulAssemblyDirectoryNameLength
+ sizeof(WCHAR
);
342 if (!(*path
= p
= RtlAllocateHeap( GetProcessHeap(), 0, needed
)))
344 status
= STATUS_NO_MEMORY
;
347 lstrcpyW( p
, L
"C:\\windows\\winsxs\\" );
349 memcpy( p
, info
->lpAssemblyDirectoryName
, info
->ulAssemblyDirectoryNameLength
);
350 p
+= info
->ulAssemblyDirectoryNameLength
/ sizeof(WCHAR
);
354 RtlFreeHeap( GetProcessHeap(), 0, info
);
355 RtlReleaseActivationContext( data
.hActCtx
);
360 /***********************************************************************
363 static DWORD
copy_filename( const WCHAR
*name
, WCHAR
*buffer
, DWORD len
)
365 UINT ret
= lstrlenW( name
) + 1;
366 if (buffer
&& len
>= ret
)
368 lstrcpyW( buffer
, name
);
375 /***********************************************************************
378 * copy a file name back to OEM/Ansi, but only if the buffer is large enough
380 static DWORD
copy_filename_WtoA( LPCWSTR nameW
, LPSTR buffer
, DWORD len
)
385 RtlInitUnicodeString( &strW
, nameW
);
387 ret
= oem_file_apis
? RtlUnicodeStringToOemSize( &strW
) : RtlUnicodeStringToAnsiSize( &strW
);
388 if (buffer
&& ret
<= len
)
393 str
.MaximumLength
= min( len
, UNICODE_STRING_MAX_CHARS
);
395 RtlUnicodeStringToOemString( &str
, &strW
, FALSE
);
397 RtlUnicodeStringToAnsiString( &str
, &strW
, FALSE
);
398 ret
= str
.Length
; /* length without terminating 0 */
404 /***********************************************************************
407 * Convert a file name to Unicode, taking into account the OEM/Ansi API mode.
409 * If alloc is FALSE uses the TEB static buffer, so it can only be used when
410 * there is no possibility for the function to do that twice, taking into
411 * account any called function.
413 WCHAR
*file_name_AtoW( LPCSTR name
, BOOL alloc
)
416 UNICODE_STRING strW
, *pstrW
;
419 RtlInitAnsiString( &str
, name
);
420 pstrW
= alloc
? &strW
: &NtCurrentTeb()->StaticUnicodeString
;
422 status
= RtlOemStringToUnicodeString( pstrW
, &str
, alloc
);
424 status
= RtlAnsiStringToUnicodeString( pstrW
, &str
, alloc
);
425 if (status
== STATUS_SUCCESS
) return pstrW
->Buffer
;
427 if (status
== STATUS_BUFFER_OVERFLOW
)
428 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
430 SetLastError( RtlNtStatusToDosError(status
) );
435 /***********************************************************************
438 * Convert a file name back to OEM/Ansi. Returns number of bytes copied.
440 DWORD
file_name_WtoA( LPCWSTR src
, INT srclen
, LPSTR dest
, INT destlen
)
444 if (srclen
< 0) srclen
= lstrlenW( src
) + 1;
450 strW
.Buffer
= (WCHAR
*)src
;
451 strW
.Length
= srclen
* sizeof(WCHAR
);
452 ret
= RtlUnicodeStringToOemSize( &strW
) - 1;
455 RtlUnicodeToMultiByteSize( &ret
, src
, srclen
* sizeof(WCHAR
) );
460 RtlUnicodeToOemN( dest
, destlen
, &ret
, src
, srclen
* sizeof(WCHAR
) );
462 RtlUnicodeToMultiByteN( dest
, destlen
, &ret
, src
, srclen
* sizeof(WCHAR
) );
468 /***********************************************************************
471 static BOOL
is_same_file( HANDLE h1
, HANDLE h2
)
473 FILE_OBJECTID_BUFFER id1
, id2
;
476 return (!NtFsControlFile( h1
, 0, NULL
, NULL
, &io
, FSCTL_GET_OBJECT_ID
, NULL
, 0, &id1
, sizeof(id1
) ) &&
477 !NtFsControlFile( h2
, 0, NULL
, NULL
, &io
, FSCTL_GET_OBJECT_ID
, NULL
, 0, &id2
, sizeof(id2
) ) &&
478 !memcmp( &id1
.ObjectId
, &id2
.ObjectId
, sizeof(id1
.ObjectId
) ));
482 /******************************************************************************
483 * AreFileApisANSI (kernelbase.@)
485 BOOL WINAPI DECLSPEC_HOTPATCH
AreFileApisANSI(void)
487 return !oem_file_apis
;
491 /***********************************************************************
492 * CopyFileExW (kernelbase.@)
494 BOOL WINAPI
CopyFileExW( const WCHAR
*source
, const WCHAR
*dest
, LPPROGRESS_ROUTINE progress
,
495 void *param
, BOOL
*cancel_ptr
, DWORD flags
)
497 static const int buffer_size
= 65536;
499 FILE_BASIC_INFORMATION info
;
505 if (!source
|| !dest
)
507 SetLastError( ERROR_INVALID_PARAMETER
);
510 if (!(buffer
= HeapAlloc( GetProcessHeap(), 0, buffer_size
)))
512 SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
516 TRACE("%s -> %s, %lx\n", debugstr_w(source
), debugstr_w(dest
), flags
);
518 if (flags
& COPY_FILE_RESTARTABLE
)
519 FIXME("COPY_FILE_RESTARTABLE is not supported\n");
520 if (flags
& COPY_FILE_COPY_SYMLINK
)
521 FIXME("COPY_FILE_COPY_SYMLINK is not supported\n");
522 if (flags
& COPY_FILE_OPEN_SOURCE_FOR_WRITE
)
523 FIXME("COPY_FILE_OPEN_SOURCE_FOR_WRITE is not supported\n");
525 if ((h1
= CreateFileW( source
, GENERIC_READ
, FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
526 NULL
, OPEN_EXISTING
, 0, 0 )) == INVALID_HANDLE_VALUE
)
528 WARN("Unable to open source %s\n", debugstr_w(source
));
529 HeapFree( GetProcessHeap(), 0, buffer
);
533 if (!set_ntstatus( NtQueryInformationFile( h1
, &io
, &info
, sizeof(info
), FileBasicInformation
)))
535 WARN("GetFileInformationByHandle returned error for %s\n", debugstr_w(source
));
536 HeapFree( GetProcessHeap(), 0, buffer
);
541 if (!(flags
& COPY_FILE_FAIL_IF_EXISTS
))
543 BOOL same_file
= FALSE
;
544 h2
= CreateFileW( dest
, 0, FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
, OPEN_EXISTING
, 0, 0 );
545 if (h2
!= INVALID_HANDLE_VALUE
)
547 same_file
= is_same_file( h1
, h2
);
552 HeapFree( GetProcessHeap(), 0, buffer
);
554 SetLastError( ERROR_SHARING_VIOLATION
);
559 if ((h2
= CreateFileW( dest
, GENERIC_WRITE
, FILE_SHARE_READ
| FILE_SHARE_WRITE
, NULL
,
560 (flags
& COPY_FILE_FAIL_IF_EXISTS
) ? CREATE_NEW
: CREATE_ALWAYS
,
561 info
.FileAttributes
, h1
)) == INVALID_HANDLE_VALUE
)
563 WARN("Unable to open dest %s\n", debugstr_w(dest
));
564 HeapFree( GetProcessHeap(), 0, buffer
);
569 while (ReadFile( h1
, buffer
, buffer_size
, &count
, NULL
) && count
)
575 if (!WriteFile( h2
, p
, count
, &res
, NULL
) || !res
) goto done
;
582 /* Maintain the timestamp of source file to destination file */
583 info
.FileAttributes
= 0;
584 NtSetInformationFile( h2
, &io
, &info
, sizeof(info
), FileBasicInformation
);
585 HeapFree( GetProcessHeap(), 0, buffer
);
588 if (ret
) SetLastError( 0 );
593 /**************************************************************************
594 * CopyFileW (kernelbase.@)
596 BOOL WINAPI DECLSPEC_HOTPATCH
CopyFileW( const WCHAR
*source
, const WCHAR
*dest
, BOOL fail_if_exists
)
598 return CopyFileExW( source
, dest
, NULL
, NULL
, NULL
, fail_if_exists
? COPY_FILE_FAIL_IF_EXISTS
: 0 );
602 /***********************************************************************
603 * CreateDirectoryA (kernelbase.@)
605 BOOL WINAPI DECLSPEC_HOTPATCH
CreateDirectoryA( LPCSTR path
, LPSECURITY_ATTRIBUTES sa
)
609 if (!(pathW
= file_name_AtoW( path
, FALSE
))) return FALSE
;
610 return CreateDirectoryW( pathW
, sa
);
614 /***********************************************************************
615 * CreateDirectoryW (kernelbase.@)
617 BOOL WINAPI DECLSPEC_HOTPATCH
CreateDirectoryW( LPCWSTR path
, LPSECURITY_ATTRIBUTES sa
)
619 OBJECT_ATTRIBUTES attr
;
620 UNICODE_STRING nt_name
;
625 TRACE( "%s\n", debugstr_w(path
) );
627 if (!RtlDosPathNameToNtPathName_U( path
, &nt_name
, NULL
, NULL
))
629 SetLastError( ERROR_PATH_NOT_FOUND
);
632 attr
.Length
= sizeof(attr
);
633 attr
.RootDirectory
= 0;
634 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
635 attr
.ObjectName
= &nt_name
;
636 attr
.SecurityDescriptor
= sa
? sa
->lpSecurityDescriptor
: NULL
;
637 attr
.SecurityQualityOfService
= NULL
;
639 status
= NtCreateFile( &handle
, GENERIC_READ
| SYNCHRONIZE
, &attr
, &io
, NULL
,
640 FILE_ATTRIBUTE_NORMAL
, FILE_SHARE_READ
, FILE_CREATE
,
641 FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
, NULL
, 0 );
642 if (status
== STATUS_SUCCESS
) NtClose( handle
);
644 RtlFreeUnicodeString( &nt_name
);
645 return set_ntstatus( status
);
649 /***********************************************************************
650 * CreateDirectoryEx (kernelbase.@)
652 BOOL WINAPI DECLSPEC_HOTPATCH
CreateDirectoryExW( LPCWSTR
template, LPCWSTR path
,
653 LPSECURITY_ATTRIBUTES sa
)
655 return CreateDirectoryW( path
, sa
);
659 /*************************************************************************
660 * CreateFile2 (kernelbase.@)
662 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateFile2( LPCWSTR name
, DWORD access
, DWORD sharing
, DWORD creation
,
663 CREATEFILE2_EXTENDED_PARAMETERS
*params
)
665 static const DWORD attributes_mask
= FILE_ATTRIBUTE_READONLY
|
666 FILE_ATTRIBUTE_HIDDEN
|
667 FILE_ATTRIBUTE_SYSTEM
|
668 FILE_ATTRIBUTE_ARCHIVE
|
669 FILE_ATTRIBUTE_NORMAL
|
670 FILE_ATTRIBUTE_TEMPORARY
|
671 FILE_ATTRIBUTE_OFFLINE
|
672 FILE_ATTRIBUTE_ENCRYPTED
|
673 FILE_ATTRIBUTE_INTEGRITY_STREAM
;
674 static const DWORD flags_mask
= FILE_FLAG_BACKUP_SEMANTICS
|
675 FILE_FLAG_DELETE_ON_CLOSE
|
676 FILE_FLAG_NO_BUFFERING
|
677 FILE_FLAG_OPEN_NO_RECALL
|
678 FILE_FLAG_OPEN_REPARSE_POINT
|
679 FILE_FLAG_OVERLAPPED
|
680 FILE_FLAG_POSIX_SEMANTICS
|
681 FILE_FLAG_RANDOM_ACCESS
|
682 FILE_FLAG_SEQUENTIAL_SCAN
|
683 FILE_FLAG_WRITE_THROUGH
;
685 LPSECURITY_ATTRIBUTES sa
= params
? params
->lpSecurityAttributes
: NULL
;
686 HANDLE
template = params
? params
->hTemplateFile
: NULL
;
687 DWORD attributes
= params
? params
->dwFileAttributes
: 0;
688 DWORD flags
= params
? params
->dwFileFlags
: 0;
690 FIXME( "(%s %lx %lx %lx %p), partial stub\n", debugstr_w(name
), access
, sharing
, creation
, params
);
692 if (attributes
& ~attributes_mask
) FIXME( "unsupported attributes %#lx\n", attributes
);
693 if (flags
& ~flags_mask
) FIXME( "unsupported flags %#lx\n", flags
);
694 attributes
&= attributes_mask
;
697 return CreateFileW( name
, access
, sharing
, sa
, creation
, flags
| attributes
, template );
701 /*************************************************************************
702 * CreateFileA (kernelbase.@)
704 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateFileA( LPCSTR name
, DWORD access
, DWORD sharing
,
705 LPSECURITY_ATTRIBUTES sa
, DWORD creation
,
706 DWORD attributes
, HANDLE
template)
710 if ((GetVersion() & 0x80000000) && IsBadStringPtrA( name
, -1 )) return INVALID_HANDLE_VALUE
;
711 if (!(nameW
= file_name_AtoW( name
, FALSE
))) return INVALID_HANDLE_VALUE
;
712 return CreateFileW( nameW
, access
, sharing
, sa
, creation
, attributes
, template );
715 static UINT
get_nt_file_options( DWORD attributes
)
719 if (attributes
& FILE_FLAG_BACKUP_SEMANTICS
)
720 options
|= FILE_OPEN_FOR_BACKUP_INTENT
;
722 options
|= FILE_NON_DIRECTORY_FILE
;
723 if (attributes
& FILE_FLAG_DELETE_ON_CLOSE
)
724 options
|= FILE_DELETE_ON_CLOSE
;
725 if (attributes
& FILE_FLAG_NO_BUFFERING
)
726 options
|= FILE_NO_INTERMEDIATE_BUFFERING
;
727 if (!(attributes
& FILE_FLAG_OVERLAPPED
))
728 options
|= FILE_SYNCHRONOUS_IO_NONALERT
;
729 if (attributes
& FILE_FLAG_RANDOM_ACCESS
)
730 options
|= FILE_RANDOM_ACCESS
;
731 if (attributes
& FILE_FLAG_SEQUENTIAL_SCAN
)
732 options
|= FILE_SEQUENTIAL_ONLY
;
733 if (attributes
& FILE_FLAG_WRITE_THROUGH
)
734 options
|= FILE_WRITE_THROUGH
;
738 /*************************************************************************
739 * CreateFileW (kernelbase.@)
741 HANDLE WINAPI DECLSPEC_HOTPATCH
CreateFileW( LPCWSTR filename
, DWORD access
, DWORD sharing
,
742 LPSECURITY_ATTRIBUTES sa
, DWORD creation
,
743 DWORD attributes
, HANDLE
template )
746 OBJECT_ATTRIBUTES attr
;
747 UNICODE_STRING nameW
;
750 const WCHAR
*vxd_name
= NULL
;
751 SECURITY_QUALITY_OF_SERVICE qos
;
753 static const UINT nt_disposition
[5] =
755 FILE_CREATE
, /* CREATE_NEW */
756 FILE_OVERWRITE_IF
, /* CREATE_ALWAYS */
757 FILE_OPEN
, /* OPEN_EXISTING */
758 FILE_OPEN_IF
, /* OPEN_ALWAYS */
759 FILE_OVERWRITE
/* TRUNCATE_EXISTING */
765 if (!filename
|| !filename
[0])
767 SetLastError( ERROR_PATH_NOT_FOUND
);
768 return INVALID_HANDLE_VALUE
;
771 TRACE( "%s %s%s%s%s%s%s%s creation %ld attributes 0x%lx\n", debugstr_w(filename
),
772 (access
& GENERIC_READ
) ? "GENERIC_READ " : "",
773 (access
& GENERIC_WRITE
) ? "GENERIC_WRITE " : "",
774 (access
& GENERIC_EXECUTE
) ? "GENERIC_EXECUTE " : "",
775 !access
? "QUERY_ACCESS " : "",
776 (sharing
& FILE_SHARE_READ
) ? "FILE_SHARE_READ " : "",
777 (sharing
& FILE_SHARE_WRITE
) ? "FILE_SHARE_WRITE " : "",
778 (sharing
& FILE_SHARE_DELETE
) ? "FILE_SHARE_DELETE " : "",
779 creation
, attributes
);
781 if ((GetVersion() & 0x80000000) && !wcsncmp( filename
, L
"\\\\.\\", 4 ) &&
782 !RtlIsDosDeviceName_U( filename
+ 4 ) &&
783 wcsnicmp( filename
+ 4, L
"PIPE\\", 5 ) &&
784 wcsnicmp( filename
+ 4, L
"MAILSLOT\\", 9 ))
786 vxd_name
= filename
+ 4;
787 if (!creation
) creation
= OPEN_EXISTING
;
790 if (creation
< CREATE_NEW
|| creation
> TRUNCATE_EXISTING
)
792 SetLastError( ERROR_INVALID_PARAMETER
);
793 return INVALID_HANDLE_VALUE
;
796 if (!RtlDosPathNameToNtPathName_U( filename
, &nameW
, NULL
, NULL
))
798 SetLastError( ERROR_PATH_NOT_FOUND
);
799 return INVALID_HANDLE_VALUE
;
802 /* now call NtCreateFile */
804 if (attributes
& FILE_FLAG_DELETE_ON_CLOSE
)
807 attr
.Length
= sizeof(attr
);
808 attr
.RootDirectory
= 0;
809 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
810 attr
.ObjectName
= &nameW
;
811 attr
.SecurityDescriptor
= sa
? sa
->lpSecurityDescriptor
: NULL
;
812 if (attributes
& SECURITY_SQOS_PRESENT
)
814 qos
.Length
= sizeof(qos
);
815 qos
.ImpersonationLevel
= (attributes
>> 16) & 0x3;
816 qos
.ContextTrackingMode
= attributes
& SECURITY_CONTEXT_TRACKING
? SECURITY_DYNAMIC_TRACKING
: SECURITY_STATIC_TRACKING
;
817 qos
.EffectiveOnly
= (attributes
& SECURITY_EFFECTIVE_ONLY
) != 0;
818 attr
.SecurityQualityOfService
= &qos
;
821 attr
.SecurityQualityOfService
= NULL
;
823 if (sa
&& sa
->bInheritHandle
) attr
.Attributes
|= OBJ_INHERIT
;
825 status
= NtCreateFile( &ret
, access
| SYNCHRONIZE
| FILE_READ_ATTRIBUTES
, &attr
, &io
,
826 NULL
, attributes
& FILE_ATTRIBUTE_VALID_FLAGS
, sharing
,
827 nt_disposition
[creation
- CREATE_NEW
],
828 get_nt_file_options( attributes
), NULL
, 0 );
831 if (vxd_name
&& vxd_name
[0])
833 static HANDLE (*vxd_open
)(LPCWSTR
,DWORD
,SECURITY_ATTRIBUTES
*);
834 if (!vxd_open
) vxd_open
= (void *)GetProcAddress( GetModuleHandleW(L
"krnl386.exe16"),
836 if (vxd_open
&& (ret
= vxd_open( vxd_name
, access
, sa
))) goto done
;
839 WARN("Unable to create file %s (status %lx)\n", debugstr_w(filename
), status
);
840 ret
= INVALID_HANDLE_VALUE
;
842 /* In the case file creation was rejected due to CREATE_NEW flag
843 * was specified and file with that name already exists, correct
844 * last error is ERROR_FILE_EXISTS and not ERROR_ALREADY_EXISTS.
845 * Note: RtlNtStatusToDosError is not the subject to blame here.
847 if (status
== STATUS_OBJECT_NAME_COLLISION
)
848 SetLastError( ERROR_FILE_EXISTS
);
850 SetLastError( RtlNtStatusToDosError(status
) );
854 if ((creation
== CREATE_ALWAYS
&& io
.Information
== FILE_OVERWRITTEN
) ||
855 (creation
== OPEN_ALWAYS
&& io
.Information
== FILE_OPENED
))
856 SetLastError( ERROR_ALREADY_EXISTS
);
860 RtlFreeUnicodeString( &nameW
);
863 if (!ret
) ret
= INVALID_HANDLE_VALUE
;
864 TRACE("returning %p\n", ret
);
869 /*************************************************************************
870 * CreateHardLinkA (kernelbase.@)
872 BOOL WINAPI DECLSPEC_HOTPATCH
CreateHardLinkA( const char *dest
, const char *source
,
873 SECURITY_ATTRIBUTES
*attr
)
875 WCHAR
*sourceW
, *destW
;
878 if (!(sourceW
= file_name_AtoW( source
, TRUE
))) return FALSE
;
879 if (!(destW
= file_name_AtoW( dest
, TRUE
)))
881 HeapFree( GetProcessHeap(), 0, sourceW
);
884 res
= CreateHardLinkW( destW
, sourceW
, attr
);
885 HeapFree( GetProcessHeap(), 0, sourceW
);
886 HeapFree( GetProcessHeap(), 0, destW
);
891 /*************************************************************************
892 * CreateHardLinkW (kernelbase.@)
894 BOOL WINAPI
CreateHardLinkW( LPCWSTR dest
, LPCWSTR source
, SECURITY_ATTRIBUTES
*sec_attr
)
896 UNICODE_STRING ntDest
, ntSource
;
897 FILE_LINK_INFORMATION
*info
= NULL
;
898 OBJECT_ATTRIBUTES attr
;
904 TRACE( "(%s, %s, %p)\n", debugstr_w(dest
), debugstr_w(source
), sec_attr
);
906 ntDest
.Buffer
= ntSource
.Buffer
= NULL
;
907 if (!RtlDosPathNameToNtPathName_U( dest
, &ntDest
, NULL
, NULL
) ||
908 !RtlDosPathNameToNtPathName_U( source
, &ntSource
, NULL
, NULL
))
910 SetLastError( ERROR_PATH_NOT_FOUND
);
914 size
= offsetof( FILE_LINK_INFORMATION
, FileName
) + ntDest
.Length
;
915 if (!(info
= HeapAlloc( GetProcessHeap(), 0, size
)))
917 SetLastError( ERROR_OUTOFMEMORY
);
921 InitializeObjectAttributes( &attr
, &ntSource
, OBJ_CASE_INSENSITIVE
, 0, NULL
);
922 if (!(ret
= set_ntstatus( NtOpenFile( &file
, SYNCHRONIZE
, &attr
, &io
, FILE_SHARE_READ
| FILE_SHARE_WRITE
,
923 FILE_SYNCHRONOUS_IO_NONALERT
) )))
926 info
->ReplaceIfExists
= FALSE
;
927 info
->RootDirectory
= NULL
;
928 info
->FileNameLength
= ntDest
.Length
;
929 memcpy( info
->FileName
, ntDest
.Buffer
, ntDest
.Length
);
930 ret
= set_ntstatus( NtSetInformationFile( file
, &io
, info
, size
, FileLinkInformation
) );
934 RtlFreeUnicodeString( &ntSource
);
935 RtlFreeUnicodeString( &ntDest
);
936 HeapFree( GetProcessHeap(), 0, info
);
941 /*************************************************************************
942 * CreateSymbolicLinkW (kernelbase.@)
944 BOOLEAN WINAPI
/* DECLSPEC_HOTPATCH */ CreateSymbolicLinkW( LPCWSTR link
, LPCWSTR target
, DWORD flags
)
946 FIXME( "(%s %s %ld): stub\n", debugstr_w(link
), debugstr_w(target
), flags
);
951 /***********************************************************************
952 * DeleteFileA (kernelbase.@)
954 BOOL WINAPI DECLSPEC_HOTPATCH
DeleteFileA( LPCSTR path
)
958 if (!(pathW
= file_name_AtoW( path
, FALSE
))) return FALSE
;
959 return DeleteFileW( pathW
);
963 /***********************************************************************
964 * DeleteFileW (kernelbase.@)
966 BOOL WINAPI DECLSPEC_HOTPATCH
DeleteFileW( LPCWSTR path
)
968 UNICODE_STRING nameW
;
969 OBJECT_ATTRIBUTES attr
;
974 TRACE( "%s\n", debugstr_w(path
) );
976 if (!RtlDosPathNameToNtPathName_U( path
, &nameW
, NULL
, NULL
))
978 SetLastError( ERROR_PATH_NOT_FOUND
);
982 attr
.Length
= sizeof(attr
);
983 attr
.RootDirectory
= 0;
984 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
985 attr
.ObjectName
= &nameW
;
986 attr
.SecurityDescriptor
= NULL
;
987 attr
.SecurityQualityOfService
= NULL
;
989 status
= NtCreateFile(&hFile
, SYNCHRONIZE
| DELETE
, &attr
, &io
, NULL
, 0,
990 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
991 FILE_OPEN
, FILE_DELETE_ON_CLOSE
| FILE_NON_DIRECTORY_FILE
, NULL
, 0);
992 if (status
== STATUS_SUCCESS
) status
= NtClose(hFile
);
994 RtlFreeUnicodeString( &nameW
);
995 return set_ntstatus( status
);
999 /****************************************************************************
1000 * FindCloseChangeNotification (kernelbase.@)
1002 BOOL WINAPI DECLSPEC_HOTPATCH
FindCloseChangeNotification( HANDLE handle
)
1004 return CloseHandle( handle
);
1008 /****************************************************************************
1009 * FindFirstChangeNotificationA (kernelbase.@)
1011 HANDLE WINAPI DECLSPEC_HOTPATCH
FindFirstChangeNotificationA( LPCSTR path
, BOOL subtree
, DWORD filter
)
1015 if (!(pathW
= file_name_AtoW( path
, FALSE
))) return INVALID_HANDLE_VALUE
;
1016 return FindFirstChangeNotificationW( pathW
, subtree
, filter
);
1021 * NtNotifyChangeDirectoryFile may write back to the IO_STATUS_BLOCK
1022 * asynchronously. We don't care about the contents, but it can't
1023 * be placed on the stack since it will go out of scope when we return.
1025 static IO_STATUS_BLOCK dummy_iosb
;
1027 /****************************************************************************
1028 * FindFirstChangeNotificationW (kernelbase.@)
1030 HANDLE WINAPI DECLSPEC_HOTPATCH
FindFirstChangeNotificationW( LPCWSTR path
, BOOL subtree
, DWORD filter
)
1032 UNICODE_STRING nt_name
;
1033 OBJECT_ATTRIBUTES attr
;
1035 HANDLE handle
= INVALID_HANDLE_VALUE
;
1037 TRACE( "%s %d %lx\n", debugstr_w(path
), subtree
, filter
);
1039 if (!RtlDosPathNameToNtPathName_U( path
, &nt_name
, NULL
, NULL
))
1041 SetLastError( ERROR_PATH_NOT_FOUND
);
1045 attr
.Length
= sizeof(attr
);
1046 attr
.RootDirectory
= 0;
1047 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1048 attr
.ObjectName
= &nt_name
;
1049 attr
.SecurityDescriptor
= NULL
;
1050 attr
.SecurityQualityOfService
= NULL
;
1052 status
= NtOpenFile( &handle
, FILE_LIST_DIRECTORY
| SYNCHRONIZE
, &attr
, &dummy_iosb
,
1053 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
1054 FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
);
1055 RtlFreeUnicodeString( &nt_name
);
1057 if (!set_ntstatus( status
)) return INVALID_HANDLE_VALUE
;
1059 status
= NtNotifyChangeDirectoryFile( handle
, NULL
, NULL
, NULL
, &dummy_iosb
, NULL
, 0, filter
, subtree
);
1060 if (status
!= STATUS_PENDING
)
1063 SetLastError( RtlNtStatusToDosError(status
) );
1064 return INVALID_HANDLE_VALUE
;
1070 /****************************************************************************
1071 * FindNextChangeNotification (kernelbase.@)
1073 BOOL WINAPI DECLSPEC_HOTPATCH
FindNextChangeNotification( HANDLE handle
)
1075 NTSTATUS status
= NtNotifyChangeDirectoryFile( handle
, NULL
, NULL
, NULL
, &dummy_iosb
,
1076 NULL
, 0, FILE_NOTIFY_CHANGE_SIZE
, 0 );
1077 if (status
== STATUS_PENDING
) return TRUE
;
1078 return set_ntstatus( status
);
1082 /******************************************************************************
1083 * FindFirstFileExA (kernelbase.@)
1085 HANDLE WINAPI DECLSPEC_HOTPATCH
FindFirstFileExA( const char *filename
, FINDEX_INFO_LEVELS level
,
1086 void *data
, FINDEX_SEARCH_OPS search_op
,
1087 void *filter
, DWORD flags
)
1090 WIN32_FIND_DATAA
*dataA
= data
;
1091 WIN32_FIND_DATAW dataW
;
1094 if (!(nameW
= file_name_AtoW( filename
, FALSE
))) return INVALID_HANDLE_VALUE
;
1096 handle
= FindFirstFileExW( nameW
, level
, &dataW
, search_op
, filter
, flags
);
1097 if (handle
== INVALID_HANDLE_VALUE
) return handle
;
1099 dataA
->dwFileAttributes
= dataW
.dwFileAttributes
;
1100 dataA
->ftCreationTime
= dataW
.ftCreationTime
;
1101 dataA
->ftLastAccessTime
= dataW
.ftLastAccessTime
;
1102 dataA
->ftLastWriteTime
= dataW
.ftLastWriteTime
;
1103 dataA
->nFileSizeHigh
= dataW
.nFileSizeHigh
;
1104 dataA
->nFileSizeLow
= dataW
.nFileSizeLow
;
1105 file_name_WtoA( dataW
.cFileName
, -1, dataA
->cFileName
, sizeof(dataA
->cFileName
) );
1106 file_name_WtoA( dataW
.cAlternateFileName
, -1, dataA
->cAlternateFileName
,
1107 sizeof(dataA
->cAlternateFileName
) );
1112 /******************************************************************************
1113 * FindFirstFileExW (kernelbase.@)
1115 HANDLE WINAPI DECLSPEC_HOTPATCH
FindFirstFileExW( LPCWSTR filename
, FINDEX_INFO_LEVELS level
,
1116 LPVOID data
, FINDEX_SEARCH_OPS search_op
,
1117 LPVOID filter
, DWORD flags
)
1120 BOOL has_wildcard
= FALSE
;
1121 FIND_FIRST_INFO
*info
= NULL
;
1122 UNICODE_STRING nt_name
;
1123 OBJECT_ATTRIBUTES attr
;
1126 DWORD size
, device
= 0;
1128 TRACE( "%s %d %p %d %p %lx\n", debugstr_w(filename
), level
, data
, search_op
, filter
, flags
);
1130 if (flags
& ~FIND_FIRST_EX_LARGE_FETCH
)
1132 FIXME("flags not implemented 0x%08lx\n", flags
);
1134 if (search_op
!= FindExSearchNameMatch
&& search_op
!= FindExSearchLimitToDirectories
)
1136 FIXME( "search_op not implemented 0x%08x\n", search_op
);
1137 SetLastError( ERROR_INVALID_PARAMETER
);
1138 return INVALID_HANDLE_VALUE
;
1140 if (level
!= FindExInfoStandard
&& level
!= FindExInfoBasic
)
1142 FIXME("info level %d not implemented\n", level
);
1143 SetLastError( ERROR_INVALID_PARAMETER
);
1144 return INVALID_HANDLE_VALUE
;
1147 if (!RtlDosPathNameToNtPathName_U( filename
, &nt_name
, &mask
, NULL
))
1149 SetLastError( ERROR_PATH_NOT_FOUND
);
1150 return INVALID_HANDLE_VALUE
;
1153 if (!mask
&& (device
= RtlIsDosDeviceName_U( filename
)))
1157 /* we still need to check that the directory can be opened */
1161 if (!(dir
= HeapAlloc( GetProcessHeap(), 0, HIWORD(device
) + sizeof(WCHAR
) )))
1163 SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
1166 memcpy( dir
, filename
, HIWORD(device
) );
1167 dir
[HIWORD(device
)/sizeof(WCHAR
)] = 0;
1169 RtlFreeUnicodeString( &nt_name
);
1170 if (!RtlDosPathNameToNtPathName_U( dir
? dir
: L
".", &nt_name
, &mask
, NULL
))
1172 HeapFree( GetProcessHeap(), 0, dir
);
1173 SetLastError( ERROR_PATH_NOT_FOUND
);
1176 HeapFree( GetProcessHeap(), 0, dir
);
1179 else if (!mask
|| !*mask
)
1181 SetLastError( ERROR_FILE_NOT_FOUND
);
1186 nt_name
.Length
= (mask
- nt_name
.Buffer
) * sizeof(WCHAR
);
1187 has_wildcard
= wcspbrk( mask
, L
"*?" ) != NULL
;
1188 size
= has_wildcard
? 8192 : max_entry_size
;
1191 if (!(info
= HeapAlloc( GetProcessHeap(), 0, offsetof( FIND_FIRST_INFO
, data
[size
] ))))
1193 SetLastError( ERROR_NOT_ENOUGH_MEMORY
);
1197 /* check if path is the root of the drive, skipping the \??\ prefix */
1198 info
->is_root
= FALSE
;
1199 if (nt_name
.Length
>= 6 * sizeof(WCHAR
) && nt_name
.Buffer
[5] == ':')
1202 while (pos
* sizeof(WCHAR
) < nt_name
.Length
&& nt_name
.Buffer
[pos
] == '\\') pos
++;
1203 info
->is_root
= (pos
* sizeof(WCHAR
) >= nt_name
.Length
);
1206 attr
.Length
= sizeof(attr
);
1207 attr
.RootDirectory
= 0;
1208 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1209 attr
.ObjectName
= &nt_name
;
1210 attr
.SecurityDescriptor
= NULL
;
1211 attr
.SecurityQualityOfService
= NULL
;
1213 status
= NtOpenFile( &info
->handle
, FILE_LIST_DIRECTORY
| SYNCHRONIZE
, &attr
, &io
,
1214 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
1215 FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
| FILE_OPEN_FOR_BACKUP_INTENT
);
1216 if (status
!= STATUS_SUCCESS
)
1218 if (status
== STATUS_OBJECT_NAME_NOT_FOUND
)
1219 SetLastError( ERROR_PATH_NOT_FOUND
);
1221 SetLastError( RtlNtStatusToDosError(status
) );
1225 RtlInitializeCriticalSection( &info
->cs
);
1226 info
->cs
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": FIND_FIRST_INFO.cs");
1227 info
->path
= nt_name
;
1228 info
->magic
= FIND_FIRST_MAGIC
;
1229 info
->wildcard
= has_wildcard
;
1232 info
->data_size
= size
;
1233 info
->search_op
= search_op
;
1234 info
->level
= level
;
1238 WIN32_FIND_DATAW
*wfd
= data
;
1240 memset( wfd
, 0, sizeof(*wfd
) );
1241 memcpy( wfd
->cFileName
, filename
+ HIWORD(device
)/sizeof(WCHAR
), LOWORD(device
) );
1242 wfd
->dwFileAttributes
= FILE_ATTRIBUTE_ARCHIVE
;
1243 CloseHandle( info
->handle
);
1248 UNICODE_STRING mask_str
;
1250 RtlInitUnicodeString( &mask_str
, mask
);
1251 status
= NtQueryDirectoryFile( info
->handle
, 0, NULL
, NULL
, &io
, info
->data
, info
->data_size
,
1252 FileBothDirectoryInformation
, FALSE
, &mask_str
, TRUE
);
1256 SetLastError( RtlNtStatusToDosError( status
) );
1257 return INVALID_HANDLE_VALUE
;
1260 info
->data_len
= io
.Information
;
1261 if (!has_wildcard
) info
->data_size
= 0; /* we read everything */
1263 if (!FindNextFileW( info
, data
))
1265 TRACE( "%s not found\n", debugstr_w(filename
) );
1267 SetLastError( ERROR_FILE_NOT_FOUND
);
1268 return INVALID_HANDLE_VALUE
;
1270 if (!has_wildcard
) /* we can't find two files with the same name */
1272 CloseHandle( info
->handle
);
1279 HeapFree( GetProcessHeap(), 0, info
);
1280 RtlFreeUnicodeString( &nt_name
);
1281 return INVALID_HANDLE_VALUE
;
1285 /******************************************************************************
1286 * FindFirstFileA (kernelbase.@)
1288 HANDLE WINAPI DECLSPEC_HOTPATCH
FindFirstFileA( const char *filename
, WIN32_FIND_DATAA
*data
)
1290 return FindFirstFileExA( filename
, FindExInfoStandard
, data
, FindExSearchNameMatch
, NULL
, 0 );
1294 /******************************************************************************
1295 * FindFirstFileW (kernelbase.@)
1297 HANDLE WINAPI DECLSPEC_HOTPATCH
FindFirstFileW( const WCHAR
*filename
, WIN32_FIND_DATAW
*data
)
1299 return FindFirstFileExW( filename
, FindExInfoStandard
, data
, FindExSearchNameMatch
, NULL
, 0 );
1303 /**************************************************************************
1304 * FindFirstStreamW (kernelbase.@)
1306 HANDLE WINAPI
FindFirstStreamW( const WCHAR
*filename
, STREAM_INFO_LEVELS level
, void *data
, DWORD flags
)
1308 FIXME("(%s, %d, %p, %lx): stub!\n", debugstr_w(filename
), level
, data
, flags
);
1309 SetLastError( ERROR_HANDLE_EOF
);
1310 return INVALID_HANDLE_VALUE
;
1314 /******************************************************************************
1315 * FindNextFileA (kernelbase.@)
1317 BOOL WINAPI DECLSPEC_HOTPATCH
FindNextFileA( HANDLE handle
, WIN32_FIND_DATAA
*data
)
1319 WIN32_FIND_DATAW dataW
;
1321 if (!FindNextFileW( handle
, &dataW
)) return FALSE
;
1322 data
->dwFileAttributes
= dataW
.dwFileAttributes
;
1323 data
->ftCreationTime
= dataW
.ftCreationTime
;
1324 data
->ftLastAccessTime
= dataW
.ftLastAccessTime
;
1325 data
->ftLastWriteTime
= dataW
.ftLastWriteTime
;
1326 data
->nFileSizeHigh
= dataW
.nFileSizeHigh
;
1327 data
->nFileSizeLow
= dataW
.nFileSizeLow
;
1328 file_name_WtoA( dataW
.cFileName
, -1, data
->cFileName
, sizeof(data
->cFileName
) );
1329 file_name_WtoA( dataW
.cAlternateFileName
, -1, data
->cAlternateFileName
,
1330 sizeof(data
->cAlternateFileName
) );
1335 /******************************************************************************
1336 * FindNextFileW (kernelbase.@)
1338 BOOL WINAPI DECLSPEC_HOTPATCH
FindNextFileW( HANDLE handle
, WIN32_FIND_DATAW
*data
)
1340 FIND_FIRST_INFO
*info
= handle
;
1341 FILE_BOTH_DIR_INFORMATION
*dir_info
;
1345 TRACE( "%p %p\n", handle
, data
);
1347 if (!handle
|| handle
== INVALID_HANDLE_VALUE
|| info
->magic
!= FIND_FIRST_MAGIC
)
1349 SetLastError( ERROR_INVALID_HANDLE
);
1353 RtlEnterCriticalSection( &info
->cs
);
1355 if (!info
->handle
) SetLastError( ERROR_NO_MORE_FILES
);
1358 if (info
->data_pos
>= info
->data_len
) /* need to read some more data */
1362 if (info
->data_size
)
1363 status
= NtQueryDirectoryFile( info
->handle
, 0, NULL
, NULL
, &io
, info
->data
, info
->data_size
,
1364 FileBothDirectoryInformation
, FALSE
, NULL
, FALSE
);
1366 status
= STATUS_NO_MORE_FILES
;
1368 if (!set_ntstatus( status
))
1370 if (status
== STATUS_NO_MORE_FILES
)
1372 CloseHandle( info
->handle
);
1377 info
->data_len
= io
.Information
;
1381 dir_info
= (FILE_BOTH_DIR_INFORMATION
*)(info
->data
+ info
->data_pos
);
1383 if (dir_info
->NextEntryOffset
) info
->data_pos
+= dir_info
->NextEntryOffset
;
1384 else info
->data_pos
= info
->data_len
;
1386 /* don't return '.' and '..' in the root of the drive */
1389 if (dir_info
->FileNameLength
== sizeof(WCHAR
) && dir_info
->FileName
[0] == '.') continue;
1390 if (dir_info
->FileNameLength
== 2 * sizeof(WCHAR
) &&
1391 dir_info
->FileName
[0] == '.' && dir_info
->FileName
[1] == '.') continue;
1394 data
->dwFileAttributes
= dir_info
->FileAttributes
;
1395 data
->ftCreationTime
= *(FILETIME
*)&dir_info
->CreationTime
;
1396 data
->ftLastAccessTime
= *(FILETIME
*)&dir_info
->LastAccessTime
;
1397 data
->ftLastWriteTime
= *(FILETIME
*)&dir_info
->LastWriteTime
;
1398 data
->nFileSizeHigh
= dir_info
->EndOfFile
.QuadPart
>> 32;
1399 data
->nFileSizeLow
= (DWORD
)dir_info
->EndOfFile
.QuadPart
;
1400 data
->dwReserved0
= 0;
1401 data
->dwReserved1
= 0;
1403 memcpy( data
->cFileName
, dir_info
->FileName
, dir_info
->FileNameLength
);
1404 data
->cFileName
[dir_info
->FileNameLength
/sizeof(WCHAR
)] = 0;
1406 if (info
->level
!= FindExInfoBasic
)
1408 memcpy( data
->cAlternateFileName
, dir_info
->ShortName
, dir_info
->ShortNameLength
);
1409 data
->cAlternateFileName
[dir_info
->ShortNameLength
/sizeof(WCHAR
)] = 0;
1412 data
->cAlternateFileName
[0] = 0;
1414 TRACE( "returning %s (%s)\n",
1415 debugstr_w(data
->cFileName
), debugstr_w(data
->cAlternateFileName
) );
1421 RtlLeaveCriticalSection( &info
->cs
);
1426 /**************************************************************************
1427 * FindNextStreamW (kernelbase.@)
1429 BOOL WINAPI
FindNextStreamW( HANDLE handle
, void *data
)
1431 FIXME( "(%p, %p): stub!\n", handle
, data
);
1432 SetLastError( ERROR_HANDLE_EOF
);
1437 /******************************************************************************
1438 * FindClose (kernelbase.@)
1440 BOOL WINAPI DECLSPEC_HOTPATCH
FindClose( HANDLE handle
)
1442 FIND_FIRST_INFO
*info
= handle
;
1444 if (!handle
|| handle
== INVALID_HANDLE_VALUE
)
1446 SetLastError( ERROR_INVALID_HANDLE
);
1452 if (info
->magic
== FIND_FIRST_MAGIC
)
1454 RtlEnterCriticalSection( &info
->cs
);
1455 if (info
->magic
== FIND_FIRST_MAGIC
) /* in case someone else freed it in the meantime */
1458 if (info
->handle
) CloseHandle( info
->handle
);
1460 RtlFreeUnicodeString( &info
->path
);
1463 RtlLeaveCriticalSection( &info
->cs
);
1464 info
->cs
.DebugInfo
->Spare
[0] = 0;
1465 RtlDeleteCriticalSection( &info
->cs
);
1466 HeapFree( GetProcessHeap(), 0, info
);
1472 WARN( "illegal handle %p\n", handle
);
1473 SetLastError( ERROR_INVALID_HANDLE
);
1482 /******************************************************************************
1483 * GetCompressedFileSizeA (kernelbase.@)
1485 DWORD WINAPI DECLSPEC_HOTPATCH
GetCompressedFileSizeA( LPCSTR name
, LPDWORD size_high
)
1489 if (!(nameW
= file_name_AtoW( name
, FALSE
))) return INVALID_FILE_SIZE
;
1490 return GetCompressedFileSizeW( nameW
, size_high
);
1494 /******************************************************************************
1495 * GetCompressedFileSizeW (kernelbase.@)
1497 DWORD WINAPI DECLSPEC_HOTPATCH
GetCompressedFileSizeW( LPCWSTR name
, LPDWORD size_high
)
1499 UNICODE_STRING nt_name
;
1500 OBJECT_ATTRIBUTES attr
;
1506 TRACE("%s %p\n", debugstr_w(name
), size_high
);
1508 if (!RtlDosPathNameToNtPathName_U( name
, &nt_name
, NULL
, NULL
))
1510 SetLastError( ERROR_PATH_NOT_FOUND
);
1511 return INVALID_FILE_SIZE
;
1514 attr
.Length
= sizeof(attr
);
1515 attr
.RootDirectory
= 0;
1516 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1517 attr
.ObjectName
= &nt_name
;
1518 attr
.SecurityDescriptor
= NULL
;
1519 attr
.SecurityQualityOfService
= NULL
;
1521 status
= NtOpenFile( &handle
, SYNCHRONIZE
, &attr
, &io
, 0, FILE_SYNCHRONOUS_IO_NONALERT
);
1522 RtlFreeUnicodeString( &nt_name
);
1523 if (!set_ntstatus( status
)) return INVALID_FILE_SIZE
;
1525 /* we don't support compressed files, simply return the file size */
1526 ret
= GetFileSize( handle
, size_high
);
1532 /***********************************************************************
1533 * GetCurrentDirectoryA (kernelbase.@)
1535 UINT WINAPI DECLSPEC_HOTPATCH
GetCurrentDirectoryA( UINT buflen
, LPSTR buf
)
1537 WCHAR bufferW
[MAX_PATH
];
1540 if (buflen
&& buf
&& ((ULONG_PTR
)buf
>> 16) == 0)
1542 /* Win9x catches access violations here, returning zero.
1543 * This behaviour resulted in some people not noticing
1544 * that they got the argument order wrong. So let's be
1545 * nice and fail gracefully if buf is invalid and looks
1546 * more like a buflen. */
1547 SetLastError( ERROR_INVALID_PARAMETER
);
1551 ret
= RtlGetCurrentDirectory_U( sizeof(bufferW
), bufferW
);
1553 if (ret
> sizeof(bufferW
))
1555 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1558 return copy_filename_WtoA( bufferW
, buf
, buflen
);
1562 /***********************************************************************
1563 * GetCurrentDirectoryW (kernelbase.@)
1565 UINT WINAPI DECLSPEC_HOTPATCH
GetCurrentDirectoryW( UINT buflen
, LPWSTR buf
)
1567 return RtlGetCurrentDirectory_U( buflen
* sizeof(WCHAR
), buf
) / sizeof(WCHAR
);
1571 /**************************************************************************
1572 * GetFileAttributesA (kernelbase.@)
1574 DWORD WINAPI DECLSPEC_HOTPATCH
GetFileAttributesA( LPCSTR name
)
1578 if (!(nameW
= file_name_AtoW( name
, FALSE
))) return INVALID_FILE_ATTRIBUTES
;
1579 return GetFileAttributesW( nameW
);
1583 /**************************************************************************
1584 * GetFileAttributesW (kernelbase.@)
1586 DWORD WINAPI DECLSPEC_HOTPATCH
GetFileAttributesW( LPCWSTR name
)
1588 FILE_BASIC_INFORMATION info
;
1589 UNICODE_STRING nt_name
;
1590 OBJECT_ATTRIBUTES attr
;
1593 TRACE( "%s\n", debugstr_w(name
) );
1595 if (!RtlDosPathNameToNtPathName_U( name
, &nt_name
, NULL
, NULL
))
1597 SetLastError( ERROR_PATH_NOT_FOUND
);
1598 return INVALID_FILE_ATTRIBUTES
;
1601 attr
.Length
= sizeof(attr
);
1602 attr
.RootDirectory
= 0;
1603 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1604 attr
.ObjectName
= &nt_name
;
1605 attr
.SecurityDescriptor
= NULL
;
1606 attr
.SecurityQualityOfService
= NULL
;
1608 status
= NtQueryAttributesFile( &attr
, &info
);
1609 RtlFreeUnicodeString( &nt_name
);
1611 if (status
== STATUS_SUCCESS
) return info
.FileAttributes
;
1613 /* NtQueryAttributesFile fails on devices, but GetFileAttributesW succeeds */
1614 if (RtlIsDosDeviceName_U( name
)) return FILE_ATTRIBUTE_ARCHIVE
;
1616 SetLastError( RtlNtStatusToDosError(status
) );
1617 return INVALID_FILE_ATTRIBUTES
;
1621 /**************************************************************************
1622 * GetFileAttributesExA (kernelbase.@)
1624 BOOL WINAPI DECLSPEC_HOTPATCH
GetFileAttributesExA( LPCSTR name
, GET_FILEEX_INFO_LEVELS level
, void *ptr
)
1628 if (!(nameW
= file_name_AtoW( name
, FALSE
))) return FALSE
;
1629 return GetFileAttributesExW( nameW
, level
, ptr
);
1633 /**************************************************************************
1634 * GetFileAttributesExW (kernelbase.@)
1636 BOOL WINAPI DECLSPEC_HOTPATCH
GetFileAttributesExW( LPCWSTR name
, GET_FILEEX_INFO_LEVELS level
, void *ptr
)
1638 FILE_NETWORK_OPEN_INFORMATION info
;
1639 WIN32_FILE_ATTRIBUTE_DATA
*data
= ptr
;
1640 UNICODE_STRING nt_name
;
1641 OBJECT_ATTRIBUTES attr
;
1644 TRACE("%s %d %p\n", debugstr_w(name
), level
, ptr
);
1646 if (level
!= GetFileExInfoStandard
)
1648 SetLastError( ERROR_INVALID_PARAMETER
);
1652 if (!RtlDosPathNameToNtPathName_U( name
, &nt_name
, NULL
, NULL
))
1654 SetLastError( ERROR_PATH_NOT_FOUND
);
1658 attr
.Length
= sizeof(attr
);
1659 attr
.RootDirectory
= 0;
1660 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
1661 attr
.ObjectName
= &nt_name
;
1662 attr
.SecurityDescriptor
= NULL
;
1663 attr
.SecurityQualityOfService
= NULL
;
1665 status
= NtQueryFullAttributesFile( &attr
, &info
);
1666 RtlFreeUnicodeString( &nt_name
);
1667 if (!set_ntstatus( status
)) return FALSE
;
1669 data
->dwFileAttributes
= info
.FileAttributes
;
1670 data
->ftCreationTime
.dwLowDateTime
= info
.CreationTime
.u
.LowPart
;
1671 data
->ftCreationTime
.dwHighDateTime
= info
.CreationTime
.u
.HighPart
;
1672 data
->ftLastAccessTime
.dwLowDateTime
= info
.LastAccessTime
.u
.LowPart
;
1673 data
->ftLastAccessTime
.dwHighDateTime
= info
.LastAccessTime
.u
.HighPart
;
1674 data
->ftLastWriteTime
.dwLowDateTime
= info
.LastWriteTime
.u
.LowPart
;
1675 data
->ftLastWriteTime
.dwHighDateTime
= info
.LastWriteTime
.u
.HighPart
;
1676 data
->nFileSizeLow
= info
.EndOfFile
.u
.LowPart
;
1677 data
->nFileSizeHigh
= info
.EndOfFile
.u
.HighPart
;
1682 /***********************************************************************
1683 * GetFinalPathNameByHandleA (kernelbase.@)
1685 DWORD WINAPI DECLSPEC_HOTPATCH
GetFinalPathNameByHandleA( HANDLE file
, LPSTR path
,
1686 DWORD count
, DWORD flags
)
1691 TRACE( "(%p,%p,%ld,%lx)\n", file
, path
, count
, flags
);
1693 len
= GetFinalPathNameByHandleW(file
, NULL
, 0, flags
);
1694 if (len
== 0) return 0;
1696 str
= HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
1699 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1703 result
= GetFinalPathNameByHandleW(file
, str
, len
, flags
);
1704 if (result
!= len
- 1)
1706 HeapFree(GetProcessHeap(), 0, str
);
1710 len
= file_name_WtoA( str
, -1, NULL
, 0 );
1713 HeapFree(GetProcessHeap(), 0, str
);
1716 file_name_WtoA( str
, -1, path
, count
);
1717 HeapFree(GetProcessHeap(), 0, str
);
1722 /***********************************************************************
1723 * GetFinalPathNameByHandleW (kernelbase.@)
1725 DWORD WINAPI DECLSPEC_HOTPATCH
GetFinalPathNameByHandleW( HANDLE file
, LPWSTR path
,
1726 DWORD count
, DWORD flags
)
1728 WCHAR buffer
[sizeof(OBJECT_NAME_INFORMATION
) + MAX_PATH
+ 1];
1729 OBJECT_NAME_INFORMATION
*info
= (OBJECT_NAME_INFORMATION
*)&buffer
;
1730 WCHAR drive_part
[MAX_PATH
];
1731 DWORD drive_part_len
= 0;
1737 TRACE( "(%p,%p,%ld,%lx)\n", file
, path
, count
, flags
);
1739 if (flags
& ~(FILE_NAME_OPENED
| VOLUME_NAME_GUID
| VOLUME_NAME_NONE
| VOLUME_NAME_NT
))
1741 WARN("Unknown flags: %lx\n", flags
);
1742 SetLastError( ERROR_INVALID_PARAMETER
);
1746 /* get object name */
1747 status
= NtQueryObject( file
, ObjectNameInformation
, &buffer
, sizeof(buffer
) - sizeof(WCHAR
), &dummy
);
1748 if (!set_ntstatus( status
)) return 0;
1750 if (!info
->Name
.Buffer
)
1752 SetLastError( ERROR_INVALID_HANDLE
);
1755 if (info
->Name
.Length
< 4 * sizeof(WCHAR
) || info
->Name
.Buffer
[0] != '\\' ||
1756 info
->Name
.Buffer
[1] != '?' || info
->Name
.Buffer
[2] != '?' || info
->Name
.Buffer
[3] != '\\' )
1758 FIXME("Unexpected object name: %s\n", debugstr_wn(info
->Name
.Buffer
, info
->Name
.Length
/ sizeof(WCHAR
)));
1759 SetLastError( ERROR_GEN_FAILURE
);
1763 /* add terminating null character, remove "\\??\\" */
1764 info
->Name
.Buffer
[info
->Name
.Length
/ sizeof(WCHAR
)] = 0;
1765 info
->Name
.Length
-= 4 * sizeof(WCHAR
);
1766 info
->Name
.Buffer
+= 4;
1768 /* FILE_NAME_OPENED is not supported yet, and would require Wineserver changes */
1769 if (flags
& FILE_NAME_OPENED
)
1771 FIXME("FILE_NAME_OPENED not supported\n");
1772 flags
&= ~FILE_NAME_OPENED
;
1775 /* Get information required for VOLUME_NAME_NONE, VOLUME_NAME_GUID and VOLUME_NAME_NT */
1776 if (flags
== VOLUME_NAME_NONE
|| flags
== VOLUME_NAME_GUID
|| flags
== VOLUME_NAME_NT
)
1778 if (!GetVolumePathNameW( info
->Name
.Buffer
, drive_part
, MAX_PATH
)) return 0;
1779 drive_part_len
= lstrlenW(drive_part
);
1780 if (!drive_part_len
|| drive_part_len
> lstrlenW(info
->Name
.Buffer
) ||
1781 drive_part
[drive_part_len
-1] != '\\' ||
1782 CompareStringOrdinal( info
->Name
.Buffer
, drive_part_len
, drive_part
, drive_part_len
, TRUE
) != CSTR_EQUAL
)
1784 FIXME( "Path %s returned by GetVolumePathNameW does not match file path %s\n",
1785 debugstr_w(drive_part
), debugstr_w(info
->Name
.Buffer
) );
1786 SetLastError( ERROR_GEN_FAILURE
);
1791 if (flags
== VOLUME_NAME_NONE
)
1793 ptr
= info
->Name
.Buffer
+ drive_part_len
- 1;
1794 result
= lstrlenW(ptr
);
1795 if (result
< count
) memcpy(path
, ptr
, (result
+ 1) * sizeof(WCHAR
));
1798 else if (flags
== VOLUME_NAME_GUID
)
1800 WCHAR volume_prefix
[51];
1802 /* GetVolumeNameForVolumeMountPointW sets error code on failure */
1803 if (!GetVolumeNameForVolumeMountPointW( drive_part
, volume_prefix
, 50 )) return 0;
1804 ptr
= info
->Name
.Buffer
+ drive_part_len
;
1805 result
= lstrlenW(volume_prefix
) + lstrlenW(ptr
);
1808 lstrcpyW(path
, volume_prefix
);
1809 lstrcatW(path
, ptr
);
1813 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1817 else if (flags
== VOLUME_NAME_NT
)
1819 WCHAR nt_prefix
[MAX_PATH
];
1821 /* QueryDosDeviceW sets error code on failure */
1822 drive_part
[drive_part_len
- 1] = 0;
1823 if (!QueryDosDeviceW( drive_part
, nt_prefix
, MAX_PATH
)) return 0;
1824 ptr
= info
->Name
.Buffer
+ drive_part_len
- 1;
1825 result
= lstrlenW(nt_prefix
) + lstrlenW(ptr
);
1828 lstrcpyW(path
, nt_prefix
);
1829 lstrcatW(path
, ptr
);
1833 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1837 else if (flags
== VOLUME_NAME_DOS
)
1839 result
= 4 + lstrlenW(info
->Name
.Buffer
);
1842 lstrcpyW(path
, L
"\\\\?\\");
1843 lstrcatW(path
, info
->Name
.Buffer
);
1847 SetLastError(ERROR_NOT_ENOUGH_MEMORY
);
1853 /* Windows crashes here, but we prefer returning ERROR_INVALID_PARAMETER */
1854 WARN("Invalid combination of flags: %lx\n", flags
);
1855 SetLastError( ERROR_INVALID_PARAMETER
);
1861 /***********************************************************************
1862 * GetFullPathNameA (kernelbase.@)
1864 DWORD WINAPI DECLSPEC_HOTPATCH
GetFullPathNameA( LPCSTR name
, DWORD len
, LPSTR buffer
, LPSTR
*lastpart
)
1867 WCHAR bufferW
[MAX_PATH
], *lastpartW
= NULL
;
1870 if (!(nameW
= file_name_AtoW( name
, FALSE
))) return 0;
1872 ret
= GetFullPathNameW( nameW
, MAX_PATH
, bufferW
, &lastpartW
);
1877 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1880 ret
= copy_filename_WtoA( bufferW
, buffer
, len
);
1881 if (ret
< len
&& lastpart
)
1884 *lastpart
= buffer
+ file_name_WtoA( bufferW
, lastpartW
- bufferW
, NULL
, 0 );
1892 /***********************************************************************
1893 * GetFullPathNameW (kernelbase.@)
1895 DWORD WINAPI DECLSPEC_HOTPATCH
GetFullPathNameW( LPCWSTR name
, DWORD len
, LPWSTR buffer
, LPWSTR
*lastpart
)
1897 return RtlGetFullPathName_U( name
, len
* sizeof(WCHAR
), buffer
, lastpart
) / sizeof(WCHAR
);
1901 /***********************************************************************
1902 * GetLongPathNameA (kernelbase.@)
1904 DWORD WINAPI DECLSPEC_HOTPATCH
GetLongPathNameA( LPCSTR shortpath
, LPSTR longpath
, DWORD longlen
)
1907 WCHAR longpathW
[MAX_PATH
];
1910 TRACE( "%s\n", debugstr_a( shortpath
));
1912 if (!(shortpathW
= file_name_AtoW( shortpath
, FALSE
))) return 0;
1914 ret
= GetLongPathNameW( shortpathW
, longpathW
, MAX_PATH
);
1919 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
1922 return copy_filename_WtoA( longpathW
, longpath
, longlen
);
1926 /***********************************************************************
1927 * GetLongPathNameW (kernelbase.@)
1929 DWORD WINAPI DECLSPEC_HOTPATCH
GetLongPathNameW( LPCWSTR shortpath
, LPWSTR longpath
, DWORD longlen
)
1931 WCHAR tmplongpath
[1024];
1932 DWORD sp
= 0, lp
= 0, tmplen
;
1933 WIN32_FIND_DATAW wfd
;
1934 UNICODE_STRING nameW
;
1938 TRACE("%s,%p,%lu\n", debugstr_w(shortpath
), longpath
, longlen
);
1942 SetLastError( ERROR_INVALID_PARAMETER
);
1947 SetLastError( ERROR_PATH_NOT_FOUND
);
1951 if (shortpath
[0] == '\\' && shortpath
[1] == '\\')
1953 FIXME( "UNC pathname %s\n", debugstr_w(shortpath
) );
1954 tmplen
= lstrlenW( shortpath
);
1955 if (tmplen
< longlen
)
1957 if (longpath
!= shortpath
) lstrcpyW( longpath
, shortpath
);
1963 /* check for drive letter */
1964 if (shortpath
[0] != '/' && shortpath
[1] == ':' )
1966 tmplongpath
[0] = shortpath
[0];
1967 tmplongpath
[1] = ':';
1971 if (wcspbrk( shortpath
+ sp
, L
"*?" ))
1973 SetLastError( ERROR_INVALID_NAME
);
1977 while (shortpath
[sp
])
1979 /* check for path delimiters and reproduce them */
1980 if (shortpath
[sp
] == '\\' || shortpath
[sp
] == '/')
1982 tmplongpath
[lp
++] = shortpath
[sp
++];
1983 tmplongpath
[lp
] = 0; /* terminate string */
1987 for (p
= shortpath
+ sp
; *p
&& *p
!= '/' && *p
!= '\\'; p
++);
1988 tmplen
= p
- (shortpath
+ sp
);
1989 lstrcpynW( tmplongpath
+ lp
, shortpath
+ sp
, tmplen
+ 1 );
1991 if (tmplongpath
[lp
] == '.')
1993 if (tmplen
== 1 || (tmplen
== 2 && tmplongpath
[lp
+ 1] == '.'))
2001 /* Check if the file exists */
2002 handle
= FindFirstFileW( tmplongpath
, &wfd
);
2003 if (handle
== INVALID_HANDLE_VALUE
)
2005 TRACE( "not found %s\n", debugstr_w( tmplongpath
));
2006 SetLastError ( ERROR_FILE_NOT_FOUND
);
2009 FindClose( handle
);
2011 /* Use the existing file name if it's a short name */
2012 RtlInitUnicodeString( &nameW
, tmplongpath
+ lp
);
2013 if (RtlIsNameLegalDOS8Dot3( &nameW
, NULL
, NULL
)) lstrcpyW( tmplongpath
+ lp
, wfd
.cFileName
);
2014 lp
+= lstrlenW( tmplongpath
+ lp
);
2017 tmplen
= lstrlenW( shortpath
) - 1;
2018 if ((shortpath
[tmplen
] == '/' || shortpath
[tmplen
] == '\\') &&
2019 (tmplongpath
[lp
- 1] != '/' && tmplongpath
[lp
- 1] != '\\'))
2020 tmplongpath
[lp
++] = shortpath
[tmplen
];
2021 tmplongpath
[lp
] = 0;
2023 tmplen
= lstrlenW( tmplongpath
) + 1;
2024 if (tmplen
<= longlen
)
2026 lstrcpyW( longpath
, tmplongpath
);
2027 TRACE("returning %s\n", debugstr_w( longpath
));
2028 tmplen
--; /* length without 0 */
2034 /***********************************************************************
2035 * GetShortPathNameW (kernelbase.@)
2037 DWORD WINAPI DECLSPEC_HOTPATCH
GetShortPathNameW( LPCWSTR longpath
, LPWSTR shortpath
, DWORD shortlen
)
2039 WIN32_FIND_DATAW wfd
;
2040 WCHAR
*tmpshortpath
;
2043 DWORD sp
= 0, lp
= 0, tmplen
, buf_len
;
2045 TRACE( "%s,%p,%lu\n", debugstr_w(longpath
), shortpath
, shortlen
);
2049 SetLastError( ERROR_INVALID_PARAMETER
);
2054 SetLastError( ERROR_BAD_PATHNAME
);
2058 /* code below only removes characters from string, never adds, so this is
2059 * the largest buffer that tmpshortpath will need to have */
2060 buf_len
= lstrlenW(longpath
) + 1;
2061 tmpshortpath
= HeapAlloc( GetProcessHeap(), 0, buf_len
* sizeof(WCHAR
) );
2064 SetLastError( ERROR_OUTOFMEMORY
);
2068 if (longpath
[0] == '\\' && longpath
[1] == '\\' && longpath
[2] == '?' && longpath
[3] == '\\')
2070 memcpy( tmpshortpath
, longpath
, 4 * sizeof(WCHAR
) );
2074 if (wcspbrk( longpath
+ lp
, L
"*?" ))
2076 HeapFree( GetProcessHeap(), 0, tmpshortpath
);
2077 SetLastError( ERROR_INVALID_NAME
);
2081 /* check for drive letter */
2082 if (longpath
[lp
] != '/' && longpath
[lp
+ 1] == ':' )
2084 tmpshortpath
[sp
] = longpath
[lp
];
2085 tmpshortpath
[sp
+ 1] = ':';
2090 while (longpath
[lp
])
2092 /* check for path delimiters and reproduce them */
2093 if (longpath
[lp
] == '\\' || longpath
[lp
] == '/')
2095 tmpshortpath
[sp
++] = longpath
[lp
++];
2096 tmpshortpath
[sp
] = 0; /* terminate string */
2101 for (; *p
&& *p
!= '/' && *p
!= '\\'; p
++);
2102 tmplen
= p
- (longpath
+ lp
);
2103 lstrcpynW( tmpshortpath
+ sp
, longpath
+ lp
, tmplen
+ 1 );
2105 if (tmpshortpath
[sp
] == '.')
2107 if (tmplen
== 1 || (tmplen
== 2 && tmpshortpath
[sp
+ 1] == '.'))
2115 /* Check if the file exists and use the existing short file name */
2116 handle
= FindFirstFileW( tmpshortpath
, &wfd
);
2117 if (handle
== INVALID_HANDLE_VALUE
) goto notfound
;
2118 FindClose( handle
);
2120 /* In rare cases (like "a.abcd") short path may be longer than original path.
2121 * Make sure we have enough space in temp buffer. */
2122 if (wfd
.cAlternateFileName
[0] && tmplen
< lstrlenW(wfd
.cAlternateFileName
))
2125 buf_len
+= lstrlenW( wfd
.cAlternateFileName
) - tmplen
;
2126 new_buf
= HeapReAlloc( GetProcessHeap(), 0, tmpshortpath
, buf_len
* sizeof(WCHAR
) );
2129 HeapFree( GetProcessHeap(), 0, tmpshortpath
);
2130 SetLastError( ERROR_OUTOFMEMORY
);
2133 tmpshortpath
= new_buf
;
2136 lstrcpyW( tmpshortpath
+ sp
, wfd
.cAlternateFileName
[0] ? wfd
.cAlternateFileName
: wfd
.cFileName
);
2137 sp
+= lstrlenW( tmpshortpath
+ sp
);
2140 tmpshortpath
[sp
] = 0;
2142 tmplen
= lstrlenW( tmpshortpath
) + 1;
2143 if (tmplen
<= shortlen
)
2145 lstrcpyW( shortpath
, tmpshortpath
);
2146 TRACE( "returning %s\n", debugstr_w( shortpath
));
2147 tmplen
--; /* length without 0 */
2150 HeapFree( GetProcessHeap(), 0, tmpshortpath
);
2154 HeapFree( GetProcessHeap(), 0, tmpshortpath
);
2155 TRACE( "not found\n" );
2156 SetLastError( ERROR_FILE_NOT_FOUND
);
2161 /***********************************************************************
2162 * GetSystemDirectoryA (kernelbase.@)
2164 UINT WINAPI DECLSPEC_HOTPATCH
GetSystemDirectoryA( LPSTR path
, UINT count
)
2166 return copy_filename_WtoA( system_dir
, path
, count
);
2170 /***********************************************************************
2171 * GetSystemDirectoryW (kernelbase.@)
2173 UINT WINAPI DECLSPEC_HOTPATCH
GetSystemDirectoryW( LPWSTR path
, UINT count
)
2175 return copy_filename( system_dir
, path
, count
);
2179 /***********************************************************************
2180 * GetSystemWindowsDirectoryA (kernelbase.@)
2182 UINT WINAPI DECLSPEC_HOTPATCH
GetSystemWindowsDirectoryA( LPSTR path
, UINT count
)
2184 return GetWindowsDirectoryA( path
, count
);
2188 /***********************************************************************
2189 * GetSystemWindowsDirectoryW (kernelbase.@)
2191 UINT WINAPI DECLSPEC_HOTPATCH
GetSystemWindowsDirectoryW( LPWSTR path
, UINT count
)
2193 return GetWindowsDirectoryW( path
, count
);
2197 /***********************************************************************
2198 * GetSystemWow64DirectoryA (kernelbase.@)
2200 UINT WINAPI
/* DECLSPEC_HOTPATCH */ GetSystemWow64DirectoryA( LPSTR path
, UINT count
)
2202 if (!is_win64
&& !is_wow64
)
2204 SetLastError( ERROR_CALL_NOT_IMPLEMENTED
);
2207 return copy_filename_WtoA( get_machine_wow64_dir( IMAGE_FILE_MACHINE_I386
), path
, count
);
2211 /***********************************************************************
2212 * GetSystemWow64DirectoryW (kernelbase.@)
2214 UINT WINAPI
/* DECLSPEC_HOTPATCH */ GetSystemWow64DirectoryW( LPWSTR path
, UINT count
)
2216 if (!is_win64
&& !is_wow64
)
2218 SetLastError( ERROR_CALL_NOT_IMPLEMENTED
);
2221 return copy_filename( get_machine_wow64_dir( IMAGE_FILE_MACHINE_I386
), path
, count
);
2225 /***********************************************************************
2226 * GetSystemWow64Directory2A (kernelbase.@)
2228 UINT WINAPI DECLSPEC_HOTPATCH
GetSystemWow64Directory2A( LPSTR path
, UINT count
, WORD machine
)
2230 const WCHAR
*dir
= get_machine_wow64_dir( machine
);
2232 return dir
? copy_filename_WtoA( dir
, path
, count
) : 0;
2236 /***********************************************************************
2237 * GetSystemWow64Directory2W (kernelbase.@)
2239 UINT WINAPI DECLSPEC_HOTPATCH
GetSystemWow64Directory2W( LPWSTR path
, UINT count
, WORD machine
)
2241 const WCHAR
*dir
= get_machine_wow64_dir( machine
);
2243 return dir
? copy_filename( dir
, path
, count
) : 0;
2247 /***********************************************************************
2248 * GetTempFileNameA (kernelbase.@)
2250 UINT WINAPI DECLSPEC_HOTPATCH
GetTempFileNameA( LPCSTR path
, LPCSTR prefix
, UINT unique
, LPSTR buffer
)
2252 WCHAR
*pathW
, *prefixW
= NULL
;
2253 WCHAR bufferW
[MAX_PATH
];
2256 if (!(pathW
= file_name_AtoW( path
, FALSE
))) return 0;
2257 if (prefix
&& !(prefixW
= file_name_AtoW( prefix
, TRUE
))) return 0;
2259 ret
= GetTempFileNameW( pathW
, prefixW
, unique
, bufferW
);
2260 if (ret
) file_name_WtoA( bufferW
, -1, buffer
, MAX_PATH
);
2262 HeapFree( GetProcessHeap(), 0, prefixW
);
2267 /***********************************************************************
2268 * GetTempFileNameW (kernelbase.@)
2270 UINT WINAPI DECLSPEC_HOTPATCH
GetTempFileNameW( LPCWSTR path
, LPCWSTR prefix
, UINT unique
, LPWSTR buffer
)
2276 if (!path
|| !buffer
)
2278 SetLastError( ERROR_INVALID_PARAMETER
);
2282 /* ensure that the provided directory exists */
2283 attr
= GetFileAttributesW( path
);
2284 if (attr
== INVALID_FILE_ATTRIBUTES
|| !(attr
& FILE_ATTRIBUTE_DIRECTORY
))
2286 TRACE( "path not found %s\n", debugstr_w( path
));
2287 SetLastError( ERROR_DIRECTORY
);
2291 lstrcpyW( buffer
, path
);
2292 p
= buffer
+ lstrlenW(buffer
);
2294 /* add a \, if there isn't one */
2295 if ((p
== buffer
) || (p
[-1] != '\\')) *p
++ = '\\';
2297 if (prefix
) for (i
= 3; (i
> 0) && (*prefix
); i
--) *p
++ = *prefix
++;
2300 if (unique
) swprintf( p
, MAX_PATH
- (p
- buffer
), L
"%x.tmp", unique
);
2303 /* get a "random" unique number and try to create the file */
2305 UINT num
= NtGetTickCount() & 0xffff;
2308 /* avoid using the same name twice in a short interval */
2309 if (last
- num
< 10) num
= last
+ 1;
2314 swprintf( p
, MAX_PATH
- (p
- buffer
), L
"%x.tmp", unique
);
2315 handle
= CreateFileW( buffer
, GENERIC_WRITE
, 0, NULL
, CREATE_NEW
, FILE_ATTRIBUTE_NORMAL
, 0 );
2316 if (handle
!= INVALID_HANDLE_VALUE
)
2317 { /* We created it */
2318 CloseHandle( handle
);
2322 if (GetLastError() != ERROR_FILE_EXISTS
&& GetLastError() != ERROR_SHARING_VIOLATION
)
2323 break; /* No need to go on */
2324 if (!(++unique
& 0xffff)) unique
= 1;
2325 } while (unique
!= num
);
2327 TRACE( "returning %s\n", debugstr_w( buffer
));
2332 /***********************************************************************
2333 * GetTempPathA (kernelbase.@)
2335 DWORD WINAPI DECLSPEC_HOTPATCH
GetTempPathA( DWORD count
, LPSTR path
)
2337 WCHAR pathW
[MAX_PATH
];
2340 if (!(ret
= GetTempPathW( MAX_PATH
, pathW
))) return 0;
2343 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
2346 return copy_filename_WtoA( pathW
, path
, count
);
2350 /***********************************************************************
2351 * GetTempPathW (kernelbase.@)
2353 DWORD WINAPI DECLSPEC_HOTPATCH
GetTempPathW( DWORD count
, LPWSTR path
)
2355 WCHAR tmp_path
[MAX_PATH
];
2358 if (!(ret
= GetEnvironmentVariableW( L
"TMP", tmp_path
, MAX_PATH
)) &&
2359 !(ret
= GetEnvironmentVariableW( L
"TEMP", tmp_path
, MAX_PATH
)) &&
2360 !(ret
= GetEnvironmentVariableW( L
"USERPROFILE", tmp_path
, MAX_PATH
)) &&
2361 !(ret
= GetWindowsDirectoryW( tmp_path
, MAX_PATH
)))
2366 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
2369 ret
= GetFullPathNameW( tmp_path
, MAX_PATH
, tmp_path
, NULL
);
2372 if (ret
> MAX_PATH
- 2)
2374 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
2377 if (tmp_path
[ret
-1] != '\\')
2379 tmp_path
[ret
++] = '\\';
2380 tmp_path
[ret
] = '\0';
2383 ret
++; /* add space for terminating 0 */
2386 lstrcpynW( path
, tmp_path
, count
);
2387 /* the remaining buffer must be zeroed up to 32766 bytes in XP or 32767
2388 * bytes after it, we will assume the > XP behavior for now */
2389 memset( path
+ ret
, 0, (min(count
, 32767) - ret
) * sizeof(WCHAR
) );
2390 ret
--; /* return length without 0 */
2394 /* the buffer must be cleared if contents will not fit */
2395 memset( path
, 0, count
* sizeof(WCHAR
) );
2398 TRACE( "returning %u, %s\n", ret
, debugstr_w( path
));
2403 /***********************************************************************
2404 * GetWindowsDirectoryA (kernelbase.@)
2406 UINT WINAPI DECLSPEC_HOTPATCH
GetWindowsDirectoryA( LPSTR path
, UINT count
)
2408 return copy_filename_WtoA( windows_dir
, path
, count
);
2412 /***********************************************************************
2413 * GetWindowsDirectoryW (kernelbase.@)
2415 UINT WINAPI DECLSPEC_HOTPATCH
GetWindowsDirectoryW( LPWSTR path
, UINT count
)
2417 return copy_filename( windows_dir
, path
, count
);
2421 /**************************************************************************
2422 * MoveFileExW (kernelbase.@)
2424 BOOL WINAPI
MoveFileExW( const WCHAR
*source
, const WCHAR
*dest
, DWORD flag
)
2426 return MoveFileWithProgressW( source
, dest
, NULL
, NULL
, flag
);
2430 /**************************************************************************
2431 * MoveFileWithProgressW (kernelbase.@)
2433 BOOL WINAPI DECLSPEC_HOTPATCH
MoveFileWithProgressW( const WCHAR
*source
, const WCHAR
*dest
,
2434 LPPROGRESS_ROUTINE progress
,
2435 void *param
, DWORD flag
)
2437 FILE_RENAME_INFORMATION
*rename_info
;
2438 FILE_BASIC_INFORMATION info
;
2439 UNICODE_STRING nt_name
;
2440 OBJECT_ATTRIBUTES attr
;
2443 HANDLE source_handle
= 0;
2446 TRACE( "(%s,%s,%p,%p,%04lx)\n", debugstr_w(source
), debugstr_w(dest
), progress
, param
, flag
);
2448 if (flag
& MOVEFILE_DELAY_UNTIL_REBOOT
) return add_boot_rename_entry( source
, dest
, flag
);
2450 if (!dest
) return DeleteFileW( source
);
2452 /* check if we are allowed to rename the source */
2454 if (!RtlDosPathNameToNtPathName_U( source
, &nt_name
, NULL
, NULL
))
2456 SetLastError( ERROR_PATH_NOT_FOUND
);
2459 attr
.Length
= sizeof(attr
);
2460 attr
.RootDirectory
= 0;
2461 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
2462 attr
.ObjectName
= &nt_name
;
2463 attr
.SecurityDescriptor
= NULL
;
2464 attr
.SecurityQualityOfService
= NULL
;
2466 status
= NtOpenFile( &source_handle
, DELETE
| SYNCHRONIZE
, &attr
, &io
,
2467 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
2468 FILE_SYNCHRONOUS_IO_NONALERT
);
2469 RtlFreeUnicodeString( &nt_name
);
2470 if (!set_ntstatus( status
)) goto error
;
2472 status
= NtQueryInformationFile( source_handle
, &io
, &info
, sizeof(info
), FileBasicInformation
);
2473 if (!set_ntstatus( status
)) goto error
;
2475 if (!RtlDosPathNameToNtPathName_U( dest
, &nt_name
, NULL
, NULL
))
2477 SetLastError( ERROR_PATH_NOT_FOUND
);
2481 size
= offsetof( FILE_RENAME_INFORMATION
, FileName
) + nt_name
.Length
;
2482 if (!(rename_info
= HeapAlloc( GetProcessHeap(), 0, size
))) goto error
;
2484 rename_info
->ReplaceIfExists
= !!(flag
& MOVEFILE_REPLACE_EXISTING
);
2485 rename_info
->RootDirectory
= NULL
;
2486 rename_info
->FileNameLength
= nt_name
.Length
;
2487 memcpy( rename_info
->FileName
, nt_name
.Buffer
, nt_name
.Length
);
2488 RtlFreeUnicodeString( &nt_name
);
2489 status
= NtSetInformationFile( source_handle
, &io
, rename_info
, size
, FileRenameInformation
);
2490 HeapFree( GetProcessHeap(), 0, rename_info
);
2491 if (status
== STATUS_NOT_SAME_DEVICE
&& (flag
& MOVEFILE_COPY_ALLOWED
))
2493 NtClose( source_handle
);
2494 if (!CopyFileExW( source
, dest
, progress
, param
, NULL
,
2495 flag
& MOVEFILE_REPLACE_EXISTING
? 0 : COPY_FILE_FAIL_IF_EXISTS
))
2497 return DeleteFileW( source
);
2500 NtClose( source_handle
);
2501 return set_ntstatus( status
);
2504 if (source_handle
) NtClose( source_handle
);
2509 /***********************************************************************
2510 * NeedCurrentDirectoryForExePathA (kernelbase.@)
2512 BOOL WINAPI DECLSPEC_HOTPATCH
NeedCurrentDirectoryForExePathA( LPCSTR name
)
2516 if (!(nameW
= file_name_AtoW( name
, FALSE
))) return TRUE
;
2517 return NeedCurrentDirectoryForExePathW( nameW
);
2521 /***********************************************************************
2522 * NeedCurrentDirectoryForExePathW (kernelbase.@)
2524 BOOL WINAPI DECLSPEC_HOTPATCH
NeedCurrentDirectoryForExePathW( LPCWSTR name
)
2528 if (wcschr( name
, '\\' )) return TRUE
;
2529 /* check the existence of the variable, not value */
2530 return !GetEnvironmentVariableW( L
"NoDefaultCurrentDirectoryInExePath", &env_val
, 1 );
2534 /***********************************************************************
2535 * ReplaceFileW (kernelbase.@)
2537 BOOL WINAPI DECLSPEC_HOTPATCH
ReplaceFileW( const WCHAR
*replaced
, const WCHAR
*replacement
,
2538 const WCHAR
*backup
, DWORD flags
,
2539 void *exclude
, void *reserved
)
2541 UNICODE_STRING nt_replaced_name
, nt_replacement_name
;
2542 HANDLE hReplacement
= NULL
;
2545 OBJECT_ATTRIBUTES attr
;
2546 FILE_BASIC_INFORMATION info
;
2548 TRACE( "%s %s %s 0x%08lx %p %p\n", debugstr_w(replaced
), debugstr_w(replacement
), debugstr_w(backup
),
2549 flags
, exclude
, reserved
);
2551 if (flags
) FIXME("Ignoring flags %lx\n", flags
);
2553 /* First two arguments are mandatory */
2554 if (!replaced
|| !replacement
)
2556 SetLastError(ERROR_INVALID_PARAMETER
);
2560 attr
.Length
= sizeof(attr
);
2561 attr
.RootDirectory
= 0;
2562 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
2563 attr
.ObjectName
= NULL
;
2564 attr
.SecurityDescriptor
= NULL
;
2565 attr
.SecurityQualityOfService
= NULL
;
2567 /* Open the "replaced" file for reading */
2568 if (!RtlDosPathNameToNtPathName_U( replaced
, &nt_replaced_name
, NULL
, NULL
))
2570 SetLastError( ERROR_PATH_NOT_FOUND
);
2573 attr
.ObjectName
= &nt_replaced_name
;
2575 /* Replacement should fail if replaced is READ_ONLY */
2576 status
= NtQueryAttributesFile(&attr
, &info
);
2577 RtlFreeUnicodeString(&nt_replaced_name
);
2578 if (!set_ntstatus( status
)) return FALSE
;
2580 if (info
.FileAttributes
& FILE_ATTRIBUTE_READONLY
)
2582 SetLastError( ERROR_ACCESS_DENIED
);
2587 * Open the replacement file for reading, writing, and deleting
2588 * (writing and deleting are needed when finished)
2590 if (!RtlDosPathNameToNtPathName_U( replacement
, &nt_replacement_name
, NULL
, NULL
))
2592 SetLastError( ERROR_PATH_NOT_FOUND
);
2595 attr
.ObjectName
= &nt_replacement_name
;
2596 status
= NtOpenFile( &hReplacement
, GENERIC_READ
| GENERIC_WRITE
| DELETE
| WRITE_DAC
| SYNCHRONIZE
,
2597 &attr
, &io
, 0, FILE_SYNCHRONOUS_IO_NONALERT
| FILE_NON_DIRECTORY_FILE
);
2598 RtlFreeUnicodeString(&nt_replacement_name
);
2599 if (!set_ntstatus( status
)) return FALSE
;
2600 NtClose( hReplacement
);
2602 /* If the user wants a backup then that needs to be performed first */
2605 if (!MoveFileExW( replaced
, backup
, MOVEFILE_REPLACE_EXISTING
)) return FALSE
;
2609 /* ReplaceFile() can replace an open target. To do this, we need to move
2610 * it out of the way first. */
2611 WCHAR temp_path
[MAX_PATH
], temp_file
[MAX_PATH
];
2613 lstrcpynW( temp_path
, replaced
, ARRAY_SIZE( temp_path
) );
2614 PathRemoveFileSpecW( temp_path
);
2615 if (!GetTempFileNameW( temp_path
, L
"rf", 0, temp_file
) ||
2616 !MoveFileExW( replaced
, temp_file
, MOVEFILE_REPLACE_EXISTING
))
2619 DeleteFileW( temp_file
);
2623 * Now that the backup has been performed (if requested), copy the replacement
2626 if (!MoveFileExW( replacement
, replaced
, 0 ))
2628 /* on failure we need to indicate whether a backup was made */
2630 SetLastError( ERROR_UNABLE_TO_MOVE_REPLACEMENT
);
2632 SetLastError( ERROR_UNABLE_TO_MOVE_REPLACEMENT_2
);
2639 /***********************************************************************
2640 * SearchPathA (kernelbase.@)
2642 DWORD WINAPI DECLSPEC_HOTPATCH
SearchPathA( LPCSTR path
, LPCSTR name
, LPCSTR ext
,
2643 DWORD buflen
, LPSTR buffer
, LPSTR
*lastpart
)
2645 WCHAR
*pathW
= NULL
, *nameW
, *extW
= NULL
;
2646 WCHAR bufferW
[MAX_PATH
];
2651 SetLastError( ERROR_INVALID_PARAMETER
);
2655 if (!(nameW
= file_name_AtoW( name
, FALSE
))) return 0;
2656 if (path
&& !(pathW
= file_name_AtoW( path
, TRUE
))) return 0;
2657 if (ext
&& !(extW
= file_name_AtoW( ext
, TRUE
)))
2659 RtlFreeHeap( GetProcessHeap(), 0, pathW
);
2663 ret
= SearchPathW( pathW
, nameW
, extW
, MAX_PATH
, bufferW
, NULL
);
2665 RtlFreeHeap( GetProcessHeap(), 0, pathW
);
2666 RtlFreeHeap( GetProcessHeap(), 0, extW
);
2671 SetLastError( ERROR_FILENAME_EXCED_RANGE
);
2674 ret
= copy_filename_WtoA( bufferW
, buffer
, buflen
);
2675 if (buflen
> ret
&& lastpart
) *lastpart
= strrchr(buffer
, '\\') + 1;
2680 /***********************************************************************
2681 * SearchPathW (kernelbase.@)
2683 DWORD WINAPI DECLSPEC_HOTPATCH
SearchPathW( LPCWSTR path
, LPCWSTR name
, LPCWSTR ext
, DWORD buflen
,
2684 LPWSTR buffer
, LPWSTR
*lastpart
)
2689 if (!name
|| !name
[0])
2691 SetLastError( ERROR_INVALID_PARAMETER
);
2695 /* If the name contains an explicit path, ignore the path */
2697 if (contains_path( name
))
2699 /* try first without extension */
2700 if (RtlDoesFileExists_U( name
)) return GetFullPathNameW( name
, buflen
, buffer
, lastpart
);
2702 if ((name_ext
= append_ext( name
, ext
)))
2704 if (RtlDoesFileExists_U( name_ext
))
2705 ret
= GetFullPathNameW( name_ext
, buflen
, buffer
, lastpart
);
2706 RtlFreeHeap( GetProcessHeap(), 0, name_ext
);
2709 else if (path
&& path
[0]) /* search in the specified path */
2711 ret
= RtlDosSearchPath_U( path
, name
, ext
, buflen
* sizeof(WCHAR
),
2712 buffer
, lastpart
) / sizeof(WCHAR
);
2714 else /* search in active context and default path */
2716 WCHAR
*dll_path
= NULL
, *name_ext
= append_ext( name
, ext
);
2718 if (name_ext
) name
= name_ext
;
2720 /* When file is found with activation context no attempt is made
2721 to check if it's really exist, path is returned only basing on context info. */
2722 if (find_actctx_dllpath( name
, &dll_path
) == STATUS_SUCCESS
)
2724 ret
= lstrlenW( dll_path
) + lstrlenW( name
) + 1;
2726 /* count null termination char too */
2729 lstrcpyW( buffer
, dll_path
);
2730 lstrcatW( buffer
, name
);
2731 if (lastpart
) *lastpart
= buffer
+ lstrlenW( dll_path
);
2734 else if (lastpart
) *lastpart
= NULL
;
2735 RtlFreeHeap( GetProcessHeap(), 0, dll_path
);
2737 else if (!RtlGetSearchPath( &dll_path
))
2739 ret
= RtlDosSearchPath_U( dll_path
, name
, NULL
, buflen
* sizeof(WCHAR
),
2740 buffer
, lastpart
) / sizeof(WCHAR
);
2741 RtlReleasePath( dll_path
);
2743 RtlFreeHeap( GetProcessHeap(), 0, name_ext
);
2746 if (!ret
) SetLastError( ERROR_FILE_NOT_FOUND
);
2747 else TRACE( "found %s\n", debugstr_w(buffer
) );
2752 /***********************************************************************
2753 * SetCurrentDirectoryA (kernelbase.@)
2755 BOOL WINAPI DECLSPEC_HOTPATCH
SetCurrentDirectoryA( LPCSTR dir
)
2758 UNICODE_STRING strW
;
2760 if (!(dirW
= file_name_AtoW( dir
, FALSE
))) return FALSE
;
2761 RtlInitUnicodeString( &strW
, dirW
);
2762 return set_ntstatus( RtlSetCurrentDirectory_U( &strW
));
2766 /***********************************************************************
2767 * SetCurrentDirectoryW (kernelbase.@)
2769 BOOL WINAPI DECLSPEC_HOTPATCH
SetCurrentDirectoryW( LPCWSTR dir
)
2771 UNICODE_STRING dirW
;
2773 RtlInitUnicodeString( &dirW
, dir
);
2774 return set_ntstatus( RtlSetCurrentDirectory_U( &dirW
));
2778 /**************************************************************************
2779 * SetFileApisToANSI (kernelbase.@)
2781 void WINAPI DECLSPEC_HOTPATCH
SetFileApisToANSI(void)
2783 oem_file_apis
= FALSE
;
2787 /**************************************************************************
2788 * SetFileApisToOEM (kernelbase.@)
2790 void WINAPI DECLSPEC_HOTPATCH
SetFileApisToOEM(void)
2792 oem_file_apis
= TRUE
;
2796 /**************************************************************************
2797 * SetFileAttributesA (kernelbase.@)
2799 BOOL WINAPI DECLSPEC_HOTPATCH
SetFileAttributesA( LPCSTR name
, DWORD attributes
)
2803 if (!(nameW
= file_name_AtoW( name
, FALSE
))) return FALSE
;
2804 return SetFileAttributesW( nameW
, attributes
);
2808 /**************************************************************************
2809 * SetFileAttributesW (kernelbase.@)
2811 BOOL WINAPI DECLSPEC_HOTPATCH
SetFileAttributesW( LPCWSTR name
, DWORD attributes
)
2813 UNICODE_STRING nt_name
;
2814 OBJECT_ATTRIBUTES attr
;
2819 TRACE( "%s %lx\n", debugstr_w(name
), attributes
);
2821 if (!RtlDosPathNameToNtPathName_U( name
, &nt_name
, NULL
, NULL
))
2823 SetLastError( ERROR_PATH_NOT_FOUND
);
2827 attr
.Length
= sizeof(attr
);
2828 attr
.RootDirectory
= 0;
2829 attr
.Attributes
= OBJ_CASE_INSENSITIVE
;
2830 attr
.ObjectName
= &nt_name
;
2831 attr
.SecurityDescriptor
= NULL
;
2832 attr
.SecurityQualityOfService
= NULL
;
2834 status
= NtOpenFile( &handle
, SYNCHRONIZE
, &attr
, &io
, 0, FILE_SYNCHRONOUS_IO_NONALERT
);
2835 RtlFreeUnicodeString( &nt_name
);
2837 if (status
== STATUS_SUCCESS
)
2839 FILE_BASIC_INFORMATION info
;
2841 memset( &info
, 0, sizeof(info
) );
2842 info
.FileAttributes
= attributes
| FILE_ATTRIBUTE_NORMAL
; /* make sure it's not zero */
2843 status
= NtSetInformationFile( handle
, &io
, &info
, sizeof(info
), FileBasicInformation
);
2846 return set_ntstatus( status
);
2850 /***********************************************************************
2851 * Wow64DisableWow64FsRedirection (kernelbase.@)
2853 BOOL WINAPI DECLSPEC_HOTPATCH
Wow64DisableWow64FsRedirection( PVOID
*old_value
)
2855 return set_ntstatus( RtlWow64EnableFsRedirectionEx( TRUE
, (ULONG
*)old_value
));
2859 /***********************************************************************
2860 * Wow64EnableWow64FsRedirection (kernelbase.@)
2862 * Microsoft C++ Redistributable installers are depending on all %eax bits being set.
2864 DWORD
/*BOOLEAN*/ WINAPI
kernelbase_Wow64EnableWow64FsRedirection( BOOLEAN enable
)
2866 return set_ntstatus( RtlWow64EnableFsRedirection( enable
));
2870 /***********************************************************************
2871 * Wow64RevertWow64FsRedirection (kernelbase.@)
2873 BOOL WINAPI DECLSPEC_HOTPATCH
Wow64RevertWow64FsRedirection( PVOID old_value
)
2875 return set_ntstatus( RtlWow64EnableFsRedirection( !old_value
));
2879 /***********************************************************************
2880 * Operations on file handles
2881 ***********************************************************************/
2884 /***********************************************************************
2885 * CancelIo (kernelbase.@)
2887 BOOL WINAPI DECLSPEC_HOTPATCH
CancelIo( HANDLE handle
)
2891 return set_ntstatus( NtCancelIoFile( handle
, &io
) );
2895 /***********************************************************************
2896 * CancelIoEx (kernelbase.@)
2898 BOOL WINAPI DECLSPEC_HOTPATCH
CancelIoEx( HANDLE handle
, LPOVERLAPPED overlapped
)
2902 return set_ntstatus( NtCancelIoFileEx( handle
, (PIO_STATUS_BLOCK
)overlapped
, &io
) );
2906 /***********************************************************************
2907 * CancelSynchronousIo (kernelbase.@)
2909 BOOL WINAPI DECLSPEC_HOTPATCH
CancelSynchronousIo( HANDLE thread
)
2913 return set_ntstatus( NtCancelSynchronousIoFile( thread
, NULL
, &io
));
2917 /***********************************************************************
2918 * FlushFileBuffers (kernelbase.@)
2920 BOOL WINAPI DECLSPEC_HOTPATCH
FlushFileBuffers( HANDLE file
)
2922 IO_STATUS_BLOCK iosb
;
2924 return set_ntstatus( NtFlushBuffersFile( file
, &iosb
));
2928 /***********************************************************************
2929 * GetFileInformationByHandle (kernelbase.@)
2931 BOOL WINAPI DECLSPEC_HOTPATCH
GetFileInformationByHandle( HANDLE file
, BY_HANDLE_FILE_INFORMATION
*info
)
2933 FILE_FS_VOLUME_INFORMATION volume_info
;
2934 FILE_ALL_INFORMATION all_info
;
2938 status
= NtQueryInformationFile( file
, &io
, &all_info
, sizeof(all_info
), FileAllInformation
);
2939 if (status
== STATUS_BUFFER_OVERFLOW
) status
= STATUS_SUCCESS
;
2940 if (!set_ntstatus( status
)) return FALSE
;
2942 info
->dwFileAttributes
= all_info
.BasicInformation
.FileAttributes
;
2943 info
->ftCreationTime
.dwHighDateTime
= all_info
.BasicInformation
.CreationTime
.u
.HighPart
;
2944 info
->ftCreationTime
.dwLowDateTime
= all_info
.BasicInformation
.CreationTime
.u
.LowPart
;
2945 info
->ftLastAccessTime
.dwHighDateTime
= all_info
.BasicInformation
.LastAccessTime
.u
.HighPart
;
2946 info
->ftLastAccessTime
.dwLowDateTime
= all_info
.BasicInformation
.LastAccessTime
.u
.LowPart
;
2947 info
->ftLastWriteTime
.dwHighDateTime
= all_info
.BasicInformation
.LastWriteTime
.u
.HighPart
;
2948 info
->ftLastWriteTime
.dwLowDateTime
= all_info
.BasicInformation
.LastWriteTime
.u
.LowPart
;
2949 info
->dwVolumeSerialNumber
= 0;
2950 info
->nFileSizeHigh
= all_info
.StandardInformation
.EndOfFile
.u
.HighPart
;
2951 info
->nFileSizeLow
= all_info
.StandardInformation
.EndOfFile
.u
.LowPart
;
2952 info
->nNumberOfLinks
= all_info
.StandardInformation
.NumberOfLinks
;
2953 info
->nFileIndexHigh
= all_info
.InternalInformation
.IndexNumber
.u
.HighPart
;
2954 info
->nFileIndexLow
= all_info
.InternalInformation
.IndexNumber
.u
.LowPart
;
2956 status
= NtQueryVolumeInformationFile( file
, &io
, &volume_info
, sizeof(volume_info
), FileFsVolumeInformation
);
2957 if (status
== STATUS_SUCCESS
|| status
== STATUS_BUFFER_OVERFLOW
)
2958 info
->dwVolumeSerialNumber
= volume_info
.VolumeSerialNumber
;
2964 /***********************************************************************
2965 * GetFileInformationByHandleEx (kernelbase.@)
2967 BOOL WINAPI DECLSPEC_HOTPATCH
GetFileInformationByHandleEx( HANDLE handle
, FILE_INFO_BY_HANDLE_CLASS
class,
2968 LPVOID info
, DWORD size
)
2975 case FileRemoteProtocolInfo
:
2976 case FileStorageInfo
:
2977 case FileDispositionInfoEx
:
2978 case FileRenameInfoEx
:
2979 case FileCaseSensitiveInfo
:
2980 case FileNormalizedNameInfo
:
2981 FIXME( "%p, %u, %p, %lu\n", handle
, class, info
, size
);
2982 SetLastError( ERROR_CALL_NOT_IMPLEMENTED
);
2985 case FileStreamInfo
:
2986 status
= NtQueryInformationFile( handle
, &io
, info
, size
, FileStreamInformation
);
2989 case FileCompressionInfo
:
2990 status
= NtQueryInformationFile( handle
, &io
, info
, size
, FileCompressionInformation
);
2993 case FileAlignmentInfo
:
2994 status
= NtQueryInformationFile( handle
, &io
, info
, size
, FileAlignmentInformation
);
2997 case FileAttributeTagInfo
:
2998 status
= NtQueryInformationFile( handle
, &io
, info
, size
, FileAttributeTagInformation
);
3002 status
= NtQueryInformationFile( handle
, &io
, info
, size
, FileBasicInformation
);
3005 case FileStandardInfo
:
3006 status
= NtQueryInformationFile( handle
, &io
, info
, size
, FileStandardInformation
);
3010 status
= NtQueryInformationFile( handle
, &io
, info
, size
, FileNameInformation
);
3014 status
= NtQueryInformationFile( handle
, &io
, info
, size
, FileIdInformation
);
3017 case FileIdBothDirectoryRestartInfo
:
3018 case FileIdBothDirectoryInfo
:
3019 status
= NtQueryDirectoryFile( handle
, NULL
, NULL
, NULL
, &io
, info
, size
,
3020 FileIdBothDirectoryInformation
, FALSE
, NULL
,
3021 (class == FileIdBothDirectoryRestartInfo
) );
3024 case FileFullDirectoryInfo
:
3025 case FileFullDirectoryRestartInfo
:
3026 status
= NtQueryDirectoryFile( handle
, NULL
, NULL
, NULL
, &io
, info
, size
,
3027 FileFullDirectoryInformation
, FALSE
, NULL
,
3028 (class == FileFullDirectoryRestartInfo
) );
3031 case FileIdExtdDirectoryInfo
:
3032 case FileIdExtdDirectoryRestartInfo
:
3033 status
= NtQueryDirectoryFile( handle
, NULL
, NULL
, NULL
, &io
, info
, size
,
3034 FileIdExtdDirectoryInformation
, FALSE
, NULL
,
3035 (class == FileIdExtdDirectoryRestartInfo
) );
3038 case FileRenameInfo
:
3039 case FileDispositionInfo
:
3040 case FileAllocationInfo
:
3041 case FileIoPriorityHintInfo
:
3042 case FileEndOfFileInfo
:
3044 SetLastError( ERROR_INVALID_PARAMETER
);
3047 return set_ntstatus( status
);
3051 /***********************************************************************
3052 * GetFileSize (kernelbase.@)
3054 DWORD WINAPI DECLSPEC_HOTPATCH
GetFileSize( HANDLE file
, LPDWORD size_high
)
3058 if (!GetFileSizeEx( file
, &size
)) return INVALID_FILE_SIZE
;
3059 if (size_high
) *size_high
= size
.u
.HighPart
;
3060 if (size
.u
.LowPart
== INVALID_FILE_SIZE
) SetLastError( 0 );
3061 return size
.u
.LowPart
;
3065 /***********************************************************************
3066 * GetFileSizeEx (kernelbase.@)
3068 BOOL WINAPI DECLSPEC_HOTPATCH
GetFileSizeEx( HANDLE file
, PLARGE_INTEGER size
)
3070 FILE_STANDARD_INFORMATION info
;
3073 if (!set_ntstatus( NtQueryInformationFile( file
, &io
, &info
, sizeof(info
), FileStandardInformation
)))
3076 *size
= info
.EndOfFile
;
3081 /***********************************************************************
3082 * GetFileTime (kernelbase.@)
3084 BOOL WINAPI DECLSPEC_HOTPATCH
GetFileTime( HANDLE file
, FILETIME
*creation
,
3085 FILETIME
*access
, FILETIME
*write
)
3087 FILE_BASIC_INFORMATION info
;
3090 if (!set_ntstatus( NtQueryInformationFile( file
, &io
, &info
, sizeof(info
), FileBasicInformation
)))
3095 creation
->dwHighDateTime
= info
.CreationTime
.u
.HighPart
;
3096 creation
->dwLowDateTime
= info
.CreationTime
.u
.LowPart
;
3100 access
->dwHighDateTime
= info
.LastAccessTime
.u
.HighPart
;
3101 access
->dwLowDateTime
= info
.LastAccessTime
.u
.LowPart
;
3105 write
->dwHighDateTime
= info
.LastWriteTime
.u
.HighPart
;
3106 write
->dwLowDateTime
= info
.LastWriteTime
.u
.LowPart
;
3112 /***********************************************************************
3113 * GetFileType (kernelbase.@)
3115 DWORD WINAPI DECLSPEC_HOTPATCH
GetFileType( HANDLE file
)
3117 FILE_FS_DEVICE_INFORMATION info
;
3120 if (file
== (HANDLE
)STD_INPUT_HANDLE
||
3121 file
== (HANDLE
)STD_OUTPUT_HANDLE
||
3122 file
== (HANDLE
)STD_ERROR_HANDLE
)
3123 file
= GetStdHandle( (DWORD_PTR
)file
);
3125 if (!set_ntstatus( NtQueryVolumeInformationFile( file
, &io
, &info
, sizeof(info
),
3126 FileFsDeviceInformation
)))
3127 return FILE_TYPE_UNKNOWN
;
3129 switch (info
.DeviceType
)
3131 case FILE_DEVICE_NULL
:
3132 case FILE_DEVICE_CONSOLE
:
3133 case FILE_DEVICE_SERIAL_PORT
:
3134 case FILE_DEVICE_PARALLEL_PORT
:
3135 case FILE_DEVICE_TAPE
:
3136 case FILE_DEVICE_UNKNOWN
:
3137 return FILE_TYPE_CHAR
;
3138 case FILE_DEVICE_NAMED_PIPE
:
3139 return FILE_TYPE_PIPE
;
3141 return FILE_TYPE_DISK
;
3146 /***********************************************************************
3147 * GetOverlappedResult (kernelbase.@)
3149 BOOL WINAPI DECLSPEC_HOTPATCH
GetOverlappedResult( HANDLE file
, LPOVERLAPPED overlapped
,
3150 LPDWORD result
, BOOL wait
)
3152 return GetOverlappedResultEx( file
, overlapped
, result
, wait
? INFINITE
: 0, FALSE
);
3156 /***********************************************************************
3157 * GetOverlappedResultEx (kernelbase.@)
3159 BOOL WINAPI DECLSPEC_HOTPATCH
GetOverlappedResultEx( HANDLE file
, OVERLAPPED
*overlapped
,
3160 DWORD
*result
, DWORD timeout
, BOOL alertable
)
3165 TRACE( "(%p %p %p %lu %d)\n", file
, overlapped
, result
, timeout
, alertable
);
3167 /* Paired with the write-release in set_async_iosb() in ntdll; see the
3168 * latter for details. */
3169 status
= ReadAcquire( (LONG
*)&overlapped
->Internal
);
3170 if (status
== STATUS_PENDING
)
3174 SetLastError( ERROR_IO_INCOMPLETE
);
3177 ret
= WaitForSingleObjectEx( overlapped
->hEvent
? overlapped
->hEvent
: file
, timeout
, alertable
);
3178 if (ret
== WAIT_FAILED
)
3182 SetLastError( ret
);
3186 /* We don't need to give this load acquire semantics; the wait above
3187 * already guarantees that the IOSB and output buffer are filled. */
3188 status
= overlapped
->Internal
;
3189 if (status
== STATUS_PENDING
) status
= STATUS_SUCCESS
;
3192 *result
= overlapped
->InternalHigh
;
3193 return set_ntstatus( status
);
3197 /**************************************************************************
3198 * LockFile (kernelbase.@)
3200 BOOL WINAPI DECLSPEC_HOTPATCH
LockFile( HANDLE file
, DWORD offset_low
, DWORD offset_high
,
3201 DWORD count_low
, DWORD count_high
)
3203 LARGE_INTEGER count
, offset
;
3205 TRACE( "%p %lx%08lx %lx%08lx\n", file
, offset_high
, offset_low
, count_high
, count_low
);
3207 count
.u
.LowPart
= count_low
;
3208 count
.u
.HighPart
= count_high
;
3209 offset
.u
.LowPart
= offset_low
;
3210 offset
.u
.HighPart
= offset_high
;
3211 return set_ntstatus( NtLockFile( file
, 0, NULL
, NULL
, NULL
, &offset
, &count
, NULL
, TRUE
, TRUE
));
3215 /**************************************************************************
3216 * LockFileEx (kernelbase.@)
3218 BOOL WINAPI DECLSPEC_HOTPATCH
LockFileEx( HANDLE file
, DWORD flags
, DWORD reserved
,
3219 DWORD count_low
, DWORD count_high
, LPOVERLAPPED overlapped
)
3221 LARGE_INTEGER count
, offset
;
3222 LPVOID cvalue
= NULL
;
3226 SetLastError( ERROR_INVALID_PARAMETER
);
3230 TRACE( "%p %lx%08lx %lx%08lx flags %lx\n",
3231 file
, overlapped
->OffsetHigh
, overlapped
->Offset
, count_high
, count_low
, flags
);
3233 count
.u
.LowPart
= count_low
;
3234 count
.u
.HighPart
= count_high
;
3235 offset
.u
.LowPart
= overlapped
->Offset
;
3236 offset
.u
.HighPart
= overlapped
->OffsetHigh
;
3238 if (((ULONG_PTR
)overlapped
->hEvent
& 1) == 0) cvalue
= overlapped
;
3240 return set_ntstatus( NtLockFile( file
, overlapped
->hEvent
, NULL
, cvalue
,
3241 NULL
, &offset
, &count
, NULL
,
3242 flags
& LOCKFILE_FAIL_IMMEDIATELY
,
3243 flags
& LOCKFILE_EXCLUSIVE_LOCK
));
3247 /***********************************************************************
3248 * OpenFileById (kernelbase.@)
3250 HANDLE WINAPI DECLSPEC_HOTPATCH
OpenFileById( HANDLE handle
, LPFILE_ID_DESCRIPTOR id
, DWORD access
,
3251 DWORD share
, LPSECURITY_ATTRIBUTES sec_attr
, DWORD flags
)
3255 OBJECT_ATTRIBUTES attr
;
3257 UNICODE_STRING objectName
;
3261 SetLastError( ERROR_INVALID_PARAMETER
);
3262 return INVALID_HANDLE_VALUE
;
3265 options
= FILE_OPEN_BY_FILE_ID
;
3266 if (flags
& FILE_FLAG_BACKUP_SEMANTICS
)
3267 options
|= FILE_OPEN_FOR_BACKUP_INTENT
;
3269 options
|= FILE_NON_DIRECTORY_FILE
;
3270 if (flags
& FILE_FLAG_NO_BUFFERING
) options
|= FILE_NO_INTERMEDIATE_BUFFERING
;
3271 if (!(flags
& FILE_FLAG_OVERLAPPED
)) options
|= FILE_SYNCHRONOUS_IO_NONALERT
;
3272 if (flags
& FILE_FLAG_RANDOM_ACCESS
) options
|= FILE_RANDOM_ACCESS
;
3273 if (flags
& FILE_FLAG_SEQUENTIAL_SCAN
) options
|= FILE_SEQUENTIAL_ONLY
;
3274 flags
&= FILE_ATTRIBUTE_VALID_FLAGS
;
3276 objectName
.Length
= sizeof(ULONGLONG
);
3277 objectName
.Buffer
= (WCHAR
*)&id
->FileId
;
3278 attr
.Length
= sizeof(attr
);
3279 attr
.RootDirectory
= handle
;
3280 attr
.Attributes
= 0;
3281 attr
.ObjectName
= &objectName
;
3282 attr
.SecurityDescriptor
= sec_attr
? sec_attr
->lpSecurityDescriptor
: NULL
;
3283 attr
.SecurityQualityOfService
= NULL
;
3284 if (sec_attr
&& sec_attr
->bInheritHandle
) attr
.Attributes
|= OBJ_INHERIT
;
3286 if (!set_ntstatus( NtCreateFile( &result
, access
| SYNCHRONIZE
, &attr
, &io
, NULL
, flags
,
3287 share
, OPEN_EXISTING
, options
, NULL
, 0 )))
3288 return INVALID_HANDLE_VALUE
;
3293 /***********************************************************************
3294 * ReOpenFile (kernelbase.@)
3296 HANDLE WINAPI DECLSPEC_HOTPATCH
ReOpenFile( HANDLE handle
, DWORD access
, DWORD sharing
, DWORD attributes
)
3298 SECURITY_QUALITY_OF_SERVICE qos
;
3299 OBJECT_ATTRIBUTES attr
;
3300 UNICODE_STRING empty
= { 0 };
3305 TRACE("handle %p, access %#lx, sharing %#lx, attributes %#lx.\n", handle
, access
, sharing
, attributes
);
3307 if (attributes
& 0x7ffff) /* FILE_ATTRIBUTE_* flags are invalid */
3309 SetLastError(ERROR_INVALID_PARAMETER
);
3310 return INVALID_HANDLE_VALUE
;
3313 if (attributes
& FILE_FLAG_DELETE_ON_CLOSE
)
3316 InitializeObjectAttributes( &attr
, &empty
, OBJ_CASE_INSENSITIVE
, handle
, NULL
);
3317 if (attributes
& SECURITY_SQOS_PRESENT
)
3319 qos
.Length
= sizeof(qos
);
3320 qos
.ImpersonationLevel
= (attributes
>> 16) & 0x3;
3321 qos
.ContextTrackingMode
= attributes
& SECURITY_CONTEXT_TRACKING
? SECURITY_DYNAMIC_TRACKING
: SECURITY_STATIC_TRACKING
;
3322 qos
.EffectiveOnly
= (attributes
& SECURITY_EFFECTIVE_ONLY
) != 0;
3323 attr
.SecurityQualityOfService
= &qos
;
3326 status
= NtCreateFile( &file
, access
| SYNCHRONIZE
| FILE_READ_ATTRIBUTES
, &attr
, &io
, NULL
,
3327 0, sharing
, FILE_OPEN
, get_nt_file_options( attributes
), NULL
, 0 );
3328 if (!set_ntstatus( status
))
3329 return INVALID_HANDLE_VALUE
;
3334 static void WINAPI
invoke_completion( void *context
, IO_STATUS_BLOCK
*io
, ULONG res
)
3336 LPOVERLAPPED_COMPLETION_ROUTINE completion
= context
;
3337 completion( RtlNtStatusToDosError( io
->Status
), io
->Information
, (LPOVERLAPPED
)io
);
3340 /****************************************************************************
3341 * ReadDirectoryChangesW (kernelbase.@)
3343 BOOL WINAPI DECLSPEC_HOTPATCH
ReadDirectoryChangesW( HANDLE handle
, LPVOID buffer
, DWORD len
,
3344 BOOL subtree
, DWORD filter
, LPDWORD returned
,
3345 LPOVERLAPPED overlapped
,
3346 LPOVERLAPPED_COMPLETION_ROUTINE completion
)
3348 OVERLAPPED ov
, *pov
;
3349 IO_STATUS_BLOCK
*ios
;
3351 LPVOID cvalue
= NULL
;
3353 TRACE( "%p %p %08lx %d %08lx %p %p %p\n",
3354 handle
, buffer
, len
, subtree
, filter
, returned
, overlapped
, completion
);
3358 memset( &ov
, 0, sizeof ov
);
3359 ov
.hEvent
= CreateEventW( NULL
, 0, 0, NULL
);
3365 if (completion
) cvalue
= completion
;
3366 else if (((ULONG_PTR
)overlapped
->hEvent
& 1) == 0) cvalue
= overlapped
;
3369 ios
= (PIO_STATUS_BLOCK
)pov
;
3370 ios
->Status
= STATUS_PENDING
;
3372 status
= NtNotifyChangeDirectoryFile( handle
, completion
&& overlapped
? NULL
: pov
->hEvent
,
3373 completion
&& overlapped
? invoke_completion
: NULL
,
3374 cvalue
, ios
, buffer
, len
, filter
, subtree
);
3375 if (status
== STATUS_PENDING
)
3377 if (overlapped
) return TRUE
;
3378 WaitForSingleObjectEx( ov
.hEvent
, INFINITE
, TRUE
);
3379 if (returned
) *returned
= ios
->Information
;
3380 status
= ios
->Status
;
3382 if (!overlapped
) CloseHandle( ov
.hEvent
);
3383 return set_ntstatus( status
);
3387 /***********************************************************************
3388 * ReadFile (kernelbase.@)
3390 BOOL WINAPI DECLSPEC_HOTPATCH
ReadFile( HANDLE file
, LPVOID buffer
, DWORD count
,
3391 LPDWORD result
, LPOVERLAPPED overlapped
)
3393 LARGE_INTEGER offset
;
3394 PLARGE_INTEGER poffset
= NULL
;
3395 IO_STATUS_BLOCK iosb
;
3396 PIO_STATUS_BLOCK io_status
= &iosb
;
3399 LPVOID cvalue
= NULL
;
3401 TRACE( "%p %p %ld %p %p\n", file
, buffer
, count
, result
, overlapped
);
3403 if (result
) *result
= 0;
3407 offset
.u
.LowPart
= overlapped
->Offset
;
3408 offset
.u
.HighPart
= overlapped
->OffsetHigh
;
3410 event
= overlapped
->hEvent
;
3411 io_status
= (PIO_STATUS_BLOCK
)overlapped
;
3412 if (((ULONG_PTR
)event
& 1) == 0) cvalue
= overlapped
;
3414 else io_status
->Information
= 0;
3415 io_status
->Status
= STATUS_PENDING
;
3417 status
= NtReadFile( file
, event
, NULL
, cvalue
, io_status
, buffer
, count
, poffset
, NULL
);
3419 if (status
== STATUS_PENDING
&& !overlapped
)
3421 WaitForSingleObject( file
, INFINITE
);
3422 status
= io_status
->Status
;
3425 if (result
) *result
= overlapped
&& status
? 0 : io_status
->Information
;
3427 if (status
== STATUS_END_OF_FILE
)
3429 if (overlapped
!= NULL
)
3431 SetLastError( RtlNtStatusToDosError(status
) );
3435 else if (status
&& status
!= STATUS_TIMEOUT
)
3437 SetLastError( RtlNtStatusToDosError(status
) );
3444 /***********************************************************************
3445 * ReadFileEx (kernelbase.@)
3447 BOOL WINAPI DECLSPEC_HOTPATCH
ReadFileEx( HANDLE file
, LPVOID buffer
, DWORD count
, LPOVERLAPPED overlapped
,
3448 LPOVERLAPPED_COMPLETION_ROUTINE completion
)
3450 PIO_STATUS_BLOCK io
;
3451 LARGE_INTEGER offset
;
3454 TRACE( "(file=%p, buffer=%p, bytes=%lu, ovl=%p, ovl_fn=%p)\n",
3455 file
, buffer
, count
, overlapped
, completion
);
3459 SetLastError( ERROR_INVALID_PARAMETER
);
3462 offset
.u
.LowPart
= overlapped
->Offset
;
3463 offset
.u
.HighPart
= overlapped
->OffsetHigh
;
3464 io
= (PIO_STATUS_BLOCK
)overlapped
;
3465 io
->Status
= STATUS_PENDING
;
3466 io
->Information
= 0;
3468 status
= NtReadFile( file
, NULL
, read_write_apc
, completion
, io
, buffer
, count
, &offset
, NULL
);
3469 if (status
== STATUS_PENDING
) return TRUE
;
3470 return set_ntstatus( status
);
3474 /***********************************************************************
3475 * ReadFileScatter (kernelbase.@)
3477 BOOL WINAPI DECLSPEC_HOTPATCH
ReadFileScatter( HANDLE file
, FILE_SEGMENT_ELEMENT
*segments
, DWORD count
,
3478 LPDWORD reserved
, LPOVERLAPPED overlapped
)
3480 PIO_STATUS_BLOCK io
;
3481 LARGE_INTEGER offset
;
3482 void *cvalue
= NULL
;
3484 TRACE( "(%p %p %lu %p)\n", file
, segments
, count
, overlapped
);
3486 offset
.u
.LowPart
= overlapped
->Offset
;
3487 offset
.u
.HighPart
= overlapped
->OffsetHigh
;
3488 if (!((ULONG_PTR
)overlapped
->hEvent
& 1)) cvalue
= overlapped
;
3489 io
= (PIO_STATUS_BLOCK
)overlapped
;
3490 io
->Status
= STATUS_PENDING
;
3491 io
->Information
= 0;
3493 return set_ntstatus( NtReadFileScatter( file
, overlapped
->hEvent
, NULL
, cvalue
, io
,
3494 segments
, count
, &offset
, NULL
));
3498 /***********************************************************************
3499 * RemoveDirectoryA (kernelbase.@)
3501 BOOL WINAPI DECLSPEC_HOTPATCH
RemoveDirectoryA( LPCSTR path
)
3505 if (!(pathW
= file_name_AtoW( path
, FALSE
))) return FALSE
;
3506 return RemoveDirectoryW( pathW
);
3510 /***********************************************************************
3511 * RemoveDirectoryW (kernelbase.@)
3513 BOOL WINAPI DECLSPEC_HOTPATCH
RemoveDirectoryW( LPCWSTR path
)
3515 OBJECT_ATTRIBUTES attr
;
3516 UNICODE_STRING nt_name
;
3521 TRACE( "%s\n", debugstr_w(path
) );
3523 status
= RtlDosPathNameToNtPathName_U_WithStatus( path
, &nt_name
, NULL
, NULL
);
3524 if (!set_ntstatus( status
)) return FALSE
;
3526 InitializeObjectAttributes( &attr
, &nt_name
, OBJ_CASE_INSENSITIVE
, 0, NULL
);
3527 status
= NtOpenFile( &handle
, DELETE
| SYNCHRONIZE
, &attr
, &io
,
3528 FILE_SHARE_READ
| FILE_SHARE_WRITE
| FILE_SHARE_DELETE
,
3529 FILE_DIRECTORY_FILE
| FILE_SYNCHRONOUS_IO_NONALERT
);
3530 RtlFreeUnicodeString( &nt_name
);
3534 FILE_DISPOSITION_INFORMATION info
= { TRUE
};
3535 status
= NtSetInformationFile( handle
, &io
, &info
, sizeof(info
), FileDispositionInformation
);
3538 return set_ntstatus( status
);
3542 /**************************************************************************
3543 * SetEndOfFile (kernelbase.@)
3545 BOOL WINAPI DECLSPEC_HOTPATCH
SetEndOfFile( HANDLE file
)
3547 FILE_POSITION_INFORMATION pos
;
3548 FILE_END_OF_FILE_INFORMATION eof
;
3552 if (!(status
= NtQueryInformationFile( file
, &io
, &pos
, sizeof(pos
), FilePositionInformation
)))
3554 eof
.EndOfFile
= pos
.CurrentByteOffset
;
3555 status
= NtSetInformationFile( file
, &io
, &eof
, sizeof(eof
), FileEndOfFileInformation
);
3557 return set_ntstatus( status
);
3561 /***********************************************************************
3562 * SetFileInformationByHandle (kernelbase.@)
3564 BOOL WINAPI DECLSPEC_HOTPATCH
SetFileInformationByHandle( HANDLE file
, FILE_INFO_BY_HANDLE_CLASS
class,
3565 void *info
, DWORD size
)
3570 TRACE( "%p %u %p %lu\n", file
, class, info
, size
);
3575 case FileAllocationInfo
:
3576 case FileStreamInfo
:
3577 case FileIdBothDirectoryInfo
:
3578 case FileIdBothDirectoryRestartInfo
:
3579 case FileFullDirectoryInfo
:
3580 case FileFullDirectoryRestartInfo
:
3581 case FileStorageInfo
:
3582 case FileAlignmentInfo
:
3584 case FileIdExtdDirectoryInfo
:
3585 case FileIdExtdDirectoryRestartInfo
:
3586 FIXME( "%p, %u, %p, %lu\n", file
, class, info
, size
);
3587 SetLastError( ERROR_CALL_NOT_IMPLEMENTED
);
3590 case FileEndOfFileInfo
:
3591 status
= NtSetInformationFile( file
, &io
, info
, size
, FileEndOfFileInformation
);
3594 status
= NtSetInformationFile( file
, &io
, info
, size
, FileBasicInformation
);
3596 case FileDispositionInfo
:
3597 status
= NtSetInformationFile( file
, &io
, info
, size
, FileDispositionInformation
);
3599 case FileIoPriorityHintInfo
:
3600 status
= NtSetInformationFile( file
, &io
, info
, size
, FileIoPriorityHintInformation
);
3602 case FileRenameInfo
:
3604 FILE_RENAME_INFORMATION
*rename_info
;
3605 UNICODE_STRING nt_name
;
3608 if ((status
= RtlDosPathNameToNtPathName_U_WithStatus( ((FILE_RENAME_INFORMATION
*)info
)->FileName
,
3609 &nt_name
, NULL
, NULL
)))
3612 size
= sizeof(*rename_info
) + nt_name
.Length
;
3613 if ((rename_info
= HeapAlloc( GetProcessHeap(), 0, size
)))
3615 memcpy( rename_info
, info
, sizeof(*rename_info
) );
3616 memcpy( rename_info
->FileName
, nt_name
.Buffer
, nt_name
.Length
+ sizeof(WCHAR
) );
3617 rename_info
->FileNameLength
= nt_name
.Length
;
3618 status
= NtSetInformationFile( file
, &io
, rename_info
, size
, FileRenameInformation
);
3619 HeapFree( GetProcessHeap(), 0, rename_info
);
3621 RtlFreeUnicodeString( &nt_name
);
3624 case FileStandardInfo
:
3625 case FileCompressionInfo
:
3626 case FileAttributeTagInfo
:
3627 case FileRemoteProtocolInfo
:
3629 SetLastError( ERROR_INVALID_PARAMETER
);
3632 return set_ntstatus( status
);
3636 /***********************************************************************
3637 * SetFilePointer (kernelbase.@)
3639 DWORD WINAPI DECLSPEC_HOTPATCH
SetFilePointer( HANDLE file
, LONG distance
, LONG
*highword
, DWORD method
)
3641 LARGE_INTEGER dist
, newpos
;
3645 dist
.u
.LowPart
= distance
;
3646 dist
.u
.HighPart
= *highword
;
3648 else dist
.QuadPart
= distance
;
3650 if (!SetFilePointerEx( file
, dist
, &newpos
, method
)) return INVALID_SET_FILE_POINTER
;
3652 if (highword
) *highword
= newpos
.u
.HighPart
;
3653 if (newpos
.u
.LowPart
== INVALID_SET_FILE_POINTER
) SetLastError( 0 );
3654 return newpos
.u
.LowPart
;
3658 /***********************************************************************
3659 * SetFilePointerEx (kernelbase.@)
3661 BOOL WINAPI DECLSPEC_HOTPATCH
SetFilePointerEx( HANDLE file
, LARGE_INTEGER distance
,
3662 LARGE_INTEGER
*newpos
, DWORD method
)
3666 FILE_POSITION_INFORMATION info
;
3667 FILE_STANDARD_INFORMATION eof
;
3672 pos
= distance
.QuadPart
;
3675 if (NtQueryInformationFile( file
, &io
, &info
, sizeof(info
), FilePositionInformation
))
3677 pos
= info
.CurrentByteOffset
.QuadPart
+ distance
.QuadPart
;
3680 if (NtQueryInformationFile( file
, &io
, &eof
, sizeof(eof
), FileStandardInformation
))
3682 pos
= eof
.EndOfFile
.QuadPart
+ distance
.QuadPart
;
3685 SetLastError( ERROR_INVALID_PARAMETER
);
3691 SetLastError( ERROR_NEGATIVE_SEEK
);
3695 info
.CurrentByteOffset
.QuadPart
= pos
;
3696 if (!NtSetInformationFile( file
, &io
, &info
, sizeof(info
), FilePositionInformation
))
3698 if (newpos
) newpos
->QuadPart
= pos
;
3703 return set_ntstatus( io
.Status
);
3707 /***********************************************************************
3708 * SetFileTime (kernelbase.@)
3710 BOOL WINAPI DECLSPEC_HOTPATCH
SetFileTime( HANDLE file
, const FILETIME
*ctime
,
3711 const FILETIME
*atime
, const FILETIME
*mtime
)
3713 FILE_BASIC_INFORMATION info
;
3716 memset( &info
, 0, sizeof(info
) );
3719 info
.CreationTime
.u
.HighPart
= ctime
->dwHighDateTime
;
3720 info
.CreationTime
.u
.LowPart
= ctime
->dwLowDateTime
;
3724 info
.LastAccessTime
.u
.HighPart
= atime
->dwHighDateTime
;
3725 info
.LastAccessTime
.u
.LowPart
= atime
->dwLowDateTime
;
3729 info
.LastWriteTime
.u
.HighPart
= mtime
->dwHighDateTime
;
3730 info
.LastWriteTime
.u
.LowPart
= mtime
->dwLowDateTime
;
3733 return set_ntstatus( NtSetInformationFile( file
, &io
, &info
, sizeof(info
), FileBasicInformation
));
3737 /***********************************************************************
3738 * SetFileValidData (kernelbase.@)
3740 BOOL WINAPI DECLSPEC_HOTPATCH
SetFileValidData( HANDLE file
, LONGLONG length
)
3742 FILE_VALID_DATA_LENGTH_INFORMATION info
;
3745 info
.ValidDataLength
.QuadPart
= length
;
3746 return set_ntstatus( NtSetInformationFile( file
, &io
, &info
, sizeof(info
),
3747 FileValidDataLengthInformation
));
3751 /**************************************************************************
3752 * UnlockFile (kernelbase.@)
3754 BOOL WINAPI DECLSPEC_HOTPATCH
UnlockFile( HANDLE file
, DWORD offset_low
, DWORD offset_high
,
3755 DWORD count_low
, DWORD count_high
)
3757 LARGE_INTEGER count
, offset
;
3759 count
.u
.LowPart
= count_low
;
3760 count
.u
.HighPart
= count_high
;
3761 offset
.u
.LowPart
= offset_low
;
3762 offset
.u
.HighPart
= offset_high
;
3763 return set_ntstatus( NtUnlockFile( file
, NULL
, &offset
, &count
, NULL
));
3767 /**************************************************************************
3768 * UnlockFileEx (kernelbase.@)
3770 BOOL WINAPI DECLSPEC_HOTPATCH
UnlockFileEx( HANDLE file
, DWORD reserved
,
3771 DWORD count_low
, DWORD count_high
, LPOVERLAPPED overlapped
)
3775 SetLastError( ERROR_INVALID_PARAMETER
);
3778 if (overlapped
->hEvent
) FIXME("Unimplemented overlapped operation\n");
3780 return UnlockFile( file
, overlapped
->Offset
, overlapped
->OffsetHigh
, count_low
, count_high
);
3784 /***********************************************************************
3785 * WriteFile (kernelbase.@)
3787 BOOL WINAPI DECLSPEC_HOTPATCH
WriteFile( HANDLE file
, LPCVOID buffer
, DWORD count
,
3788 LPDWORD result
, LPOVERLAPPED overlapped
)
3790 HANDLE event
= NULL
;
3791 LARGE_INTEGER offset
;
3792 PLARGE_INTEGER poffset
= NULL
;
3794 IO_STATUS_BLOCK iosb
;
3795 PIO_STATUS_BLOCK piosb
= &iosb
;
3796 LPVOID cvalue
= NULL
;
3798 TRACE( "%p %p %ld %p %p\n", file
, buffer
, count
, result
, overlapped
);
3802 offset
.u
.LowPart
= overlapped
->Offset
;
3803 offset
.u
.HighPart
= overlapped
->OffsetHigh
;
3805 event
= overlapped
->hEvent
;
3806 piosb
= (PIO_STATUS_BLOCK
)overlapped
;
3807 if (((ULONG_PTR
)event
& 1) == 0) cvalue
= overlapped
;
3809 else piosb
->Information
= 0;
3810 piosb
->Status
= STATUS_PENDING
;
3812 status
= NtWriteFile( file
, event
, NULL
, cvalue
, piosb
, buffer
, count
, poffset
, NULL
);
3814 if (status
== STATUS_PENDING
&& !overlapped
)
3816 WaitForSingleObject( file
, INFINITE
);
3817 status
= piosb
->Status
;
3820 if (result
) *result
= overlapped
&& status
? 0 : piosb
->Information
;
3822 if (status
&& status
!= STATUS_TIMEOUT
)
3824 SetLastError( RtlNtStatusToDosError(status
) );
3831 /***********************************************************************
3832 * WriteFileEx (kernelbase.@)
3834 BOOL WINAPI DECLSPEC_HOTPATCH
WriteFileEx( HANDLE file
, LPCVOID buffer
,
3835 DWORD count
, LPOVERLAPPED overlapped
,
3836 LPOVERLAPPED_COMPLETION_ROUTINE completion
)
3838 LARGE_INTEGER offset
;
3840 PIO_STATUS_BLOCK io
;
3842 TRACE( "%p %p %ld %p %p\n", file
, buffer
, count
, overlapped
, completion
);
3846 SetLastError( ERROR_INVALID_PARAMETER
);
3849 offset
.u
.LowPart
= overlapped
->Offset
;
3850 offset
.u
.HighPart
= overlapped
->OffsetHigh
;
3852 io
= (PIO_STATUS_BLOCK
)overlapped
;
3853 io
->Status
= STATUS_PENDING
;
3854 io
->Information
= 0;
3856 status
= NtWriteFile( file
, NULL
, read_write_apc
, completion
, io
, buffer
, count
, &offset
, NULL
);
3857 if (status
== STATUS_PENDING
) return TRUE
;
3858 return set_ntstatus( status
);
3862 /***********************************************************************
3863 * WriteFileGather (kernelbase.@)
3865 BOOL WINAPI DECLSPEC_HOTPATCH
WriteFileGather( HANDLE file
, FILE_SEGMENT_ELEMENT
*segments
, DWORD count
,
3866 LPDWORD reserved
, LPOVERLAPPED overlapped
)
3868 PIO_STATUS_BLOCK io
;
3869 LARGE_INTEGER offset
;
3870 void *cvalue
= NULL
;
3872 TRACE( "%p %p %lu %p\n", file
, segments
, count
, overlapped
);
3874 offset
.u
.LowPart
= overlapped
->Offset
;
3875 offset
.u
.HighPart
= overlapped
->OffsetHigh
;
3876 if (!((ULONG_PTR
)overlapped
->hEvent
& 1)) cvalue
= overlapped
;
3877 io
= (PIO_STATUS_BLOCK
)overlapped
;
3878 io
->Status
= STATUS_PENDING
;
3879 io
->Information
= 0;
3881 return set_ntstatus( NtWriteFileGather( file
, overlapped
->hEvent
, NULL
, cvalue
,
3882 io
, segments
, count
, &offset
, NULL
));
3886 /***********************************************************************
3887 * Operations on file times
3888 ***********************************************************************/
3891 /*********************************************************************
3892 * CompareFileTime (kernelbase.@)
3894 INT WINAPI DECLSPEC_HOTPATCH
CompareFileTime( const FILETIME
*x
, const FILETIME
*y
)
3896 if (!x
|| !y
) return -1;
3897 if (x
->dwHighDateTime
> y
->dwHighDateTime
) return 1;
3898 if (x
->dwHighDateTime
< y
->dwHighDateTime
) return -1;
3899 if (x
->dwLowDateTime
> y
->dwLowDateTime
) return 1;
3900 if (x
->dwLowDateTime
< y
->dwLowDateTime
) return -1;
3905 /*********************************************************************
3906 * FileTimeToLocalFileTime (kernelbase.@)
3908 BOOL WINAPI DECLSPEC_HOTPATCH
FileTimeToLocalFileTime( const FILETIME
*utc
, FILETIME
*local
)
3910 return set_ntstatus( RtlSystemTimeToLocalTime( (const LARGE_INTEGER
*)utc
, (LARGE_INTEGER
*)local
));
3914 /*********************************************************************
3915 * FileTimeToSystemTime (kernelbase.@)
3917 BOOL WINAPI DECLSPEC_HOTPATCH
FileTimeToSystemTime( const FILETIME
*ft
, SYSTEMTIME
*systime
)
3920 const LARGE_INTEGER
*li
= (const LARGE_INTEGER
*)ft
;
3922 if (li
->QuadPart
< 0)
3924 SetLastError( ERROR_INVALID_PARAMETER
);
3927 RtlTimeToTimeFields( li
, &tf
);
3928 systime
->wYear
= tf
.Year
;
3929 systime
->wMonth
= tf
.Month
;
3930 systime
->wDay
= tf
.Day
;
3931 systime
->wHour
= tf
.Hour
;
3932 systime
->wMinute
= tf
.Minute
;
3933 systime
->wSecond
= tf
.Second
;
3934 systime
->wMilliseconds
= tf
.Milliseconds
;
3935 systime
->wDayOfWeek
= tf
.Weekday
;
3940 /*********************************************************************
3941 * GetLocalTime (kernelbase.@)
3943 void WINAPI DECLSPEC_HOTPATCH
GetLocalTime( SYSTEMTIME
*systime
)
3945 LARGE_INTEGER ft
, ft2
;
3947 NtQuerySystemTime( &ft
);
3948 RtlSystemTimeToLocalTime( &ft
, &ft2
);
3949 FileTimeToSystemTime( (FILETIME
*)&ft2
, systime
);
3953 /*********************************************************************
3954 * GetSystemTime (kernelbase.@)
3956 void WINAPI DECLSPEC_HOTPATCH
GetSystemTime( SYSTEMTIME
*systime
)
3960 NtQuerySystemTime( &ft
);
3961 FileTimeToSystemTime( (FILETIME
*)&ft
, systime
);
3965 /***********************************************************************
3966 * GetSystemTimeAdjustment (kernelbase.@)
3968 BOOL WINAPI DECLSPEC_HOTPATCH
GetSystemTimeAdjustment( DWORD
*adjust
, DWORD
*increment
, BOOL
*disabled
)
3970 SYSTEM_TIME_ADJUSTMENT_QUERY st
;
3973 if (!set_ntstatus( NtQuerySystemInformation( SystemTimeAdjustmentInformation
, &st
, sizeof(st
), &len
)))
3975 *adjust
= st
.TimeAdjustment
;
3976 *increment
= st
.TimeIncrement
;
3977 *disabled
= st
.TimeAdjustmentDisabled
;
3982 /***********************************************************************
3983 * GetSystemTimeAsFileTime (kernelbase.@)
3985 void WINAPI DECLSPEC_HOTPATCH
GetSystemTimeAsFileTime( FILETIME
*time
)
3987 NtQuerySystemTime( (LARGE_INTEGER
*)time
);
3991 /***********************************************************************
3992 * GetSystemTimePreciseAsFileTime (kernelbase.@)
3994 void WINAPI DECLSPEC_HOTPATCH
GetSystemTimePreciseAsFileTime( FILETIME
*time
)
3998 t
.QuadPart
= RtlGetSystemTimePrecise();
3999 time
->dwLowDateTime
= t
.u
.LowPart
;
4000 time
->dwHighDateTime
= t
.u
.HighPart
;
4004 /*********************************************************************
4005 * LocalFileTimeToFileTime (kernelbase.@)
4007 BOOL WINAPI DECLSPEC_HOTPATCH
LocalFileTimeToFileTime( const FILETIME
*local
, FILETIME
*utc
)
4009 return set_ntstatus( RtlLocalTimeToSystemTime( (const LARGE_INTEGER
*)local
, (LARGE_INTEGER
*)utc
));
4013 /***********************************************************************
4014 * SetLocalTime (kernelbase.@)
4016 BOOL WINAPI DECLSPEC_HOTPATCH
SetLocalTime( const SYSTEMTIME
*systime
)
4021 if (!SystemTimeToFileTime( systime
, &ft
)) return FALSE
;
4022 RtlLocalTimeToSystemTime( (LARGE_INTEGER
*)&ft
, &st
);
4023 return set_ntstatus( NtSetSystemTime( &st
, NULL
));
4027 /***********************************************************************
4028 * SetSystemTime (kernelbase.@)
4030 BOOL WINAPI DECLSPEC_HOTPATCH
SetSystemTime( const SYSTEMTIME
*systime
)
4034 if (!SystemTimeToFileTime( systime
, &ft
)) return FALSE
;
4035 return set_ntstatus( NtSetSystemTime( (LARGE_INTEGER
*)&ft
, NULL
));
4039 /***********************************************************************
4040 * SetSystemTimeAdjustment (kernelbase.@)
4042 BOOL WINAPI DECLSPEC_HOTPATCH
SetSystemTimeAdjustment( DWORD adjust
, BOOL disabled
)
4044 SYSTEM_TIME_ADJUSTMENT st
;
4046 st
.TimeAdjustment
= adjust
;
4047 st
.TimeAdjustmentDisabled
= disabled
;
4048 return set_ntstatus( NtSetSystemInformation( SystemTimeAdjustmentInformation
, &st
, sizeof(st
) ));
4052 /*********************************************************************
4053 * SystemTimeToFileTime (kernelbase.@)
4055 BOOL WINAPI DECLSPEC_HOTPATCH
SystemTimeToFileTime( const SYSTEMTIME
*systime
, FILETIME
*ft
)
4059 tf
.Year
= systime
->wYear
;
4060 tf
.Month
= systime
->wMonth
;
4061 tf
.Day
= systime
->wDay
;
4062 tf
.Hour
= systime
->wHour
;
4063 tf
.Minute
= systime
->wMinute
;
4064 tf
.Second
= systime
->wSecond
;
4065 tf
.Milliseconds
= systime
->wMilliseconds
;
4066 if (RtlTimeFieldsToTime( &tf
, (LARGE_INTEGER
*)ft
)) return TRUE
;
4067 SetLastError( ERROR_INVALID_PARAMETER
);
4072 /***********************************************************************
4074 ***********************************************************************/
4077 static void dump_dcb( const DCB
*dcb
)
4079 TRACE( "size=%d rate=%ld fParity=%d Parity=%d stopbits=%d %sIXON %sIXOFF CTS=%d RTS=%d DSR=%d DTR=%d %sCRTSCTS\n",
4080 dcb
->ByteSize
, dcb
->BaudRate
, dcb
->fParity
, dcb
->Parity
,
4081 (dcb
->StopBits
== ONESTOPBIT
) ? 1 : (dcb
->StopBits
== TWOSTOPBITS
) ? 2 : 0,
4082 dcb
->fOutX
? "" : "~", dcb
->fInX
? "" : "~",
4083 dcb
->fOutxCtsFlow
, dcb
->fRtsControl
, dcb
->fOutxDsrFlow
, dcb
->fDtrControl
,
4084 (dcb
->fOutxCtsFlow
|| dcb
->fRtsControl
== RTS_CONTROL_HANDSHAKE
) ? "" : "~" );
4087 /*****************************************************************************
4088 * ClearCommBreak (kernelbase.@)
4090 BOOL WINAPI DECLSPEC_HOTPATCH
ClearCommBreak( HANDLE handle
)
4092 return EscapeCommFunction( handle
, CLRBREAK
);
4096 /*****************************************************************************
4097 * ClearCommError (kernelbase.@)
4099 BOOL WINAPI DECLSPEC_HOTPATCH
ClearCommError( HANDLE handle
, DWORD
*errors
, COMSTAT
*stat
)
4103 if (!DeviceIoControl( handle
, IOCTL_SERIAL_GET_COMMSTATUS
, NULL
, 0, &ss
, sizeof(ss
), NULL
, NULL
))
4106 TRACE( "status %#lx,%#lx, in %lu, out %lu, eof %d, wait %d\n", ss
.Errors
, ss
.HoldReasons
,
4107 ss
.AmountInInQueue
, ss
.AmountInOutQueue
, ss
.EofReceived
, ss
.WaitForImmediate
);
4112 if (ss
.Errors
& SERIAL_ERROR_BREAK
) *errors
|= CE_BREAK
;
4113 if (ss
.Errors
& SERIAL_ERROR_FRAMING
) *errors
|= CE_FRAME
;
4114 if (ss
.Errors
& SERIAL_ERROR_OVERRUN
) *errors
|= CE_OVERRUN
;
4115 if (ss
.Errors
& SERIAL_ERROR_QUEUEOVERRUN
) *errors
|= CE_RXOVER
;
4116 if (ss
.Errors
& SERIAL_ERROR_PARITY
) *errors
|= CE_RXPARITY
;
4120 stat
->fCtsHold
= !!(ss
.HoldReasons
& SERIAL_TX_WAITING_FOR_CTS
);
4121 stat
->fDsrHold
= !!(ss
.HoldReasons
& SERIAL_TX_WAITING_FOR_DSR
);
4122 stat
->fRlsdHold
= !!(ss
.HoldReasons
& SERIAL_TX_WAITING_FOR_DCD
);
4123 stat
->fXoffHold
= !!(ss
.HoldReasons
& SERIAL_TX_WAITING_FOR_XON
);
4124 stat
->fXoffSent
= !!(ss
.HoldReasons
& SERIAL_TX_WAITING_XOFF_SENT
);
4125 stat
->fEof
= !!ss
.EofReceived
;
4126 stat
->fTxim
= !!ss
.WaitForImmediate
;
4127 stat
->cbInQue
= ss
.AmountInInQueue
;
4128 stat
->cbOutQue
= ss
.AmountInOutQueue
;
4134 /****************************************************************************
4135 * DeviceIoControl (kernelbase.@)
4137 BOOL WINAPI DECLSPEC_HOTPATCH
DeviceIoControl( HANDLE handle
, DWORD code
, void *in_buff
, DWORD in_count
,
4138 void *out_buff
, DWORD out_count
, DWORD
*returned
,
4139 OVERLAPPED
*overlapped
)
4141 IO_STATUS_BLOCK iosb
, *piosb
= &iosb
;
4142 void *cvalue
= NULL
;
4146 TRACE( "(%p,%lx,%p,%ld,%p,%ld,%p,%p)\n",
4147 handle
, code
, in_buff
, in_count
, out_buff
, out_count
, returned
, overlapped
);
4151 piosb
= (IO_STATUS_BLOCK
*)overlapped
;
4152 if (!((ULONG_PTR
)overlapped
->hEvent
& 1)) cvalue
= overlapped
;
4153 event
= overlapped
->hEvent
;
4154 overlapped
->Internal
= STATUS_PENDING
;
4155 overlapped
->InternalHigh
= 0;
4158 if (HIWORD(code
) == FILE_DEVICE_FILE_SYSTEM
)
4159 status
= NtFsControlFile( handle
, event
, NULL
, cvalue
, piosb
, code
,
4160 in_buff
, in_count
, out_buff
, out_count
);
4162 status
= NtDeviceIoControlFile( handle
, event
, NULL
, cvalue
, piosb
, code
,
4163 in_buff
, in_count
, out_buff
, out_count
);
4165 if (returned
&& !NT_ERROR(status
)) *returned
= piosb
->Information
;
4166 if (status
== STATUS_PENDING
|| !NT_SUCCESS( status
)) return set_ntstatus( status
);
4171 /*****************************************************************************
4172 * EscapeCommFunction (kernelbase.@)
4174 BOOL WINAPI DECLSPEC_HOTPATCH
EscapeCommFunction( HANDLE handle
, DWORD func
)
4176 static const DWORD ioctls
[] =
4179 IOCTL_SERIAL_SET_XOFF
, /* SETXOFF */
4180 IOCTL_SERIAL_SET_XON
, /* SETXON */
4181 IOCTL_SERIAL_SET_RTS
, /* SETRTS */
4182 IOCTL_SERIAL_CLR_RTS
, /* CLRRTS */
4183 IOCTL_SERIAL_SET_DTR
, /* SETDTR */
4184 IOCTL_SERIAL_CLR_DTR
, /* CLRDTR */
4185 IOCTL_SERIAL_RESET_DEVICE
, /* RESETDEV */
4186 IOCTL_SERIAL_SET_BREAK_ON
, /* SETBREAK */
4187 IOCTL_SERIAL_SET_BREAK_OFF
/* CLRBREAK */
4190 if (func
>= ARRAY_SIZE(ioctls
) || !ioctls
[func
])
4192 SetLastError( ERROR_INVALID_PARAMETER
);
4195 return DeviceIoControl( handle
, ioctls
[func
], NULL
, 0, NULL
, 0, NULL
, NULL
);
4199 /***********************************************************************
4200 * GetCommConfig (kernelbase.@)
4202 BOOL WINAPI DECLSPEC_HOTPATCH
GetCommConfig( HANDLE handle
, COMMCONFIG
*config
, DWORD
*size
)
4204 if (!config
) return FALSE
;
4206 TRACE( "(%p, %p, %p %lu)\n", handle
, config
, size
, *size
);
4208 if (*size
< sizeof(COMMCONFIG
))
4210 *size
= sizeof(COMMCONFIG
);
4213 *size
= sizeof(COMMCONFIG
);
4214 config
->dwSize
= sizeof(COMMCONFIG
);
4215 config
->wVersion
= 1;
4216 config
->wReserved
= 0;
4217 config
->dwProviderSubType
= PST_RS232
;
4218 config
->dwProviderOffset
= 0;
4219 config
->dwProviderSize
= 0;
4220 return GetCommState( handle
, &config
->dcb
);
4224 /*****************************************************************************
4225 * GetCommMask (kernelbase.@)
4227 BOOL WINAPI DECLSPEC_HOTPATCH
GetCommMask( HANDLE handle
, DWORD
*mask
)
4229 return DeviceIoControl( handle
, IOCTL_SERIAL_GET_WAIT_MASK
, NULL
, 0, mask
, sizeof(*mask
),
4234 /***********************************************************************
4235 * GetCommModemStatus (kernelbase.@)
4237 BOOL WINAPI DECLSPEC_HOTPATCH
GetCommModemStatus( HANDLE handle
, DWORD
*status
)
4239 return DeviceIoControl( handle
, IOCTL_SERIAL_GET_MODEMSTATUS
, NULL
, 0, status
, sizeof(*status
),
4244 /***********************************************************************
4245 * GetCommProperties (kernelbase.@)
4247 BOOL WINAPI DECLSPEC_HOTPATCH
GetCommProperties( HANDLE handle
, COMMPROP
*prop
)
4249 return DeviceIoControl( handle
, IOCTL_SERIAL_GET_PROPERTIES
, NULL
, 0, prop
, sizeof(*prop
), NULL
, NULL
);
4253 /*****************************************************************************
4254 * GetCommState (kernelbase.@)
4256 BOOL WINAPI DECLSPEC_HOTPATCH
GetCommState( HANDLE handle
, DCB
*dcb
)
4258 SERIAL_BAUD_RATE sbr
;
4259 SERIAL_LINE_CONTROL slc
;
4260 SERIAL_HANDFLOW shf
;
4265 SetLastError( ERROR_INVALID_PARAMETER
);
4268 if (!DeviceIoControl(handle
, IOCTL_SERIAL_GET_BAUD_RATE
, NULL
, 0, &sbr
, sizeof(sbr
), NULL
, NULL
) ||
4269 !DeviceIoControl(handle
, IOCTL_SERIAL_GET_LINE_CONTROL
, NULL
, 0, &slc
, sizeof(slc
), NULL
, NULL
) ||
4270 !DeviceIoControl(handle
, IOCTL_SERIAL_GET_HANDFLOW
, NULL
, 0, &shf
, sizeof(shf
), NULL
, NULL
) ||
4271 !DeviceIoControl(handle
, IOCTL_SERIAL_GET_CHARS
, NULL
, 0, &sc
, sizeof(sc
), NULL
, NULL
))
4274 dcb
->DCBlength
= sizeof(*dcb
);
4275 dcb
->BaudRate
= sbr
.BaudRate
;
4276 /* yes, they seem no never be (re)set on NT */
4279 dcb
->fOutxCtsFlow
= !!(shf
.ControlHandShake
& SERIAL_CTS_HANDSHAKE
);
4280 dcb
->fOutxDsrFlow
= !!(shf
.ControlHandShake
& SERIAL_DSR_HANDSHAKE
);
4281 dcb
->fDsrSensitivity
= !!(shf
.ControlHandShake
& SERIAL_DSR_SENSITIVITY
);
4282 dcb
->fTXContinueOnXoff
= !!(shf
.FlowReplace
& SERIAL_XOFF_CONTINUE
);
4283 dcb
->fOutX
= !!(shf
.FlowReplace
& SERIAL_AUTO_TRANSMIT
);
4284 dcb
->fInX
= !!(shf
.FlowReplace
& SERIAL_AUTO_RECEIVE
);
4285 dcb
->fErrorChar
= !!(shf
.FlowReplace
& SERIAL_ERROR_CHAR
);
4286 dcb
->fNull
= !!(shf
.FlowReplace
& SERIAL_NULL_STRIPPING
);
4287 dcb
->fAbortOnError
= !!(shf
.ControlHandShake
& SERIAL_ERROR_ABORT
);
4288 dcb
->XonLim
= shf
.XonLimit
;
4289 dcb
->XoffLim
= shf
.XoffLimit
;
4290 dcb
->ByteSize
= slc
.WordLength
;
4291 dcb
->Parity
= slc
.Parity
;
4292 dcb
->StopBits
= slc
.StopBits
;
4293 dcb
->XonChar
= sc
.XonChar
;
4294 dcb
->XoffChar
= sc
.XoffChar
;
4295 dcb
->ErrorChar
= sc
.ErrorChar
;
4296 dcb
->EofChar
= sc
.EofChar
;
4297 dcb
->EvtChar
= sc
.EventChar
;
4299 switch (shf
.ControlHandShake
& (SERIAL_DTR_CONTROL
| SERIAL_DTR_HANDSHAKE
))
4301 case SERIAL_DTR_CONTROL
: dcb
->fDtrControl
= DTR_CONTROL_ENABLE
; break;
4302 case SERIAL_DTR_HANDSHAKE
: dcb
->fDtrControl
= DTR_CONTROL_HANDSHAKE
; break;
4303 default: dcb
->fDtrControl
= DTR_CONTROL_DISABLE
; break;
4305 switch (shf
.FlowReplace
& (SERIAL_RTS_CONTROL
| SERIAL_RTS_HANDSHAKE
))
4307 case SERIAL_RTS_CONTROL
: dcb
->fRtsControl
= RTS_CONTROL_ENABLE
; break;
4308 case SERIAL_RTS_HANDSHAKE
: dcb
->fRtsControl
= RTS_CONTROL_HANDSHAKE
; break;
4309 case SERIAL_RTS_CONTROL
| SERIAL_RTS_HANDSHAKE
:
4310 dcb
->fRtsControl
= RTS_CONTROL_TOGGLE
; break;
4311 default: dcb
->fRtsControl
= RTS_CONTROL_DISABLE
; break;
4318 /*****************************************************************************
4319 * GetCommTimeouts (kernelbase.@)
4321 BOOL WINAPI DECLSPEC_HOTPATCH
GetCommTimeouts( HANDLE handle
, COMMTIMEOUTS
*timeouts
)
4325 SetLastError( ERROR_INVALID_PARAMETER
);
4328 return DeviceIoControl( handle
, IOCTL_SERIAL_GET_TIMEOUTS
, NULL
, 0, timeouts
, sizeof(*timeouts
),
4332 /********************************************************************
4333 * PurgeComm (kernelbase.@)
4335 BOOL WINAPI DECLSPEC_HOTPATCH
PurgeComm(HANDLE handle
, DWORD flags
)
4337 return DeviceIoControl( handle
, IOCTL_SERIAL_PURGE
, &flags
, sizeof(flags
),
4338 NULL
, 0, NULL
, NULL
);
4342 /*****************************************************************************
4343 * SetCommBreak (kernelbase.@)
4345 BOOL WINAPI DECLSPEC_HOTPATCH
SetCommBreak( HANDLE handle
)
4347 return EscapeCommFunction( handle
, SETBREAK
);
4351 /***********************************************************************
4352 * SetCommConfig (kernelbase.@)
4354 BOOL WINAPI DECLSPEC_HOTPATCH
SetCommConfig( HANDLE handle
, COMMCONFIG
*config
, DWORD size
)
4356 TRACE( "(%p, %p, %lu)\n", handle
, config
, size
);
4357 return SetCommState( handle
, &config
->dcb
);
4361 /*****************************************************************************
4362 * SetCommMask (kernelbase.@)
4364 BOOL WINAPI DECLSPEC_HOTPATCH
SetCommMask( HANDLE handle
, DWORD mask
)
4366 return DeviceIoControl( handle
, IOCTL_SERIAL_SET_WAIT_MASK
, &mask
, sizeof(mask
),
4367 NULL
, 0, NULL
, NULL
);
4371 /*****************************************************************************
4372 * SetCommState (kernelbase.@)
4374 BOOL WINAPI DECLSPEC_HOTPATCH
SetCommState( HANDLE handle
, DCB
*dcb
)
4376 SERIAL_BAUD_RATE sbr
;
4377 SERIAL_LINE_CONTROL slc
;
4378 SERIAL_HANDFLOW shf
;
4383 SetLastError( ERROR_INVALID_PARAMETER
);
4388 sbr
.BaudRate
= dcb
->BaudRate
;
4389 slc
.StopBits
= dcb
->StopBits
;
4390 slc
.Parity
= dcb
->Parity
;
4391 slc
.WordLength
= dcb
->ByteSize
;
4392 shf
.ControlHandShake
= 0;
4393 shf
.FlowReplace
= 0;
4394 if (dcb
->fOutxCtsFlow
) shf
.ControlHandShake
|= SERIAL_CTS_HANDSHAKE
;
4395 if (dcb
->fOutxDsrFlow
) shf
.ControlHandShake
|= SERIAL_DSR_HANDSHAKE
;
4396 switch (dcb
->fDtrControl
)
4398 case DTR_CONTROL_DISABLE
: break;
4399 case DTR_CONTROL_ENABLE
: shf
.ControlHandShake
|= SERIAL_DTR_CONTROL
; break;
4400 case DTR_CONTROL_HANDSHAKE
: shf
.ControlHandShake
|= SERIAL_DTR_HANDSHAKE
; break;
4402 SetLastError( ERROR_INVALID_PARAMETER
);
4405 switch (dcb
->fRtsControl
)
4407 case RTS_CONTROL_DISABLE
: break;
4408 case RTS_CONTROL_ENABLE
: shf
.FlowReplace
|= SERIAL_RTS_CONTROL
; break;
4409 case RTS_CONTROL_HANDSHAKE
: shf
.FlowReplace
|= SERIAL_RTS_HANDSHAKE
; break;
4410 case RTS_CONTROL_TOGGLE
: shf
.FlowReplace
|= SERIAL_RTS_CONTROL
| SERIAL_RTS_HANDSHAKE
; break;
4412 SetLastError( ERROR_INVALID_PARAMETER
);
4415 if (dcb
->fDsrSensitivity
) shf
.ControlHandShake
|= SERIAL_DSR_SENSITIVITY
;
4416 if (dcb
->fAbortOnError
) shf
.ControlHandShake
|= SERIAL_ERROR_ABORT
;
4417 if (dcb
->fErrorChar
) shf
.FlowReplace
|= SERIAL_ERROR_CHAR
;
4418 if (dcb
->fNull
) shf
.FlowReplace
|= SERIAL_NULL_STRIPPING
;
4419 if (dcb
->fTXContinueOnXoff
) shf
.FlowReplace
|= SERIAL_XOFF_CONTINUE
;
4420 if (dcb
->fOutX
) shf
.FlowReplace
|= SERIAL_AUTO_TRANSMIT
;
4421 if (dcb
->fInX
) shf
.FlowReplace
|= SERIAL_AUTO_RECEIVE
;
4422 shf
.XonLimit
= dcb
->XonLim
;
4423 shf
.XoffLimit
= dcb
->XoffLim
;
4424 sc
.EofChar
= dcb
->EofChar
;
4425 sc
.ErrorChar
= dcb
->ErrorChar
;
4427 sc
.EventChar
= dcb
->EvtChar
;
4428 sc
.XonChar
= dcb
->XonChar
;
4429 sc
.XoffChar
= dcb
->XoffChar
;
4431 /* note: change DTR/RTS lines after setting the comm attributes,
4432 * so flow control does not interfere.
4434 return (DeviceIoControl( handle
, IOCTL_SERIAL_SET_BAUD_RATE
, &sbr
, sizeof(sbr
), NULL
, 0, NULL
, NULL
) &&
4435 DeviceIoControl( handle
, IOCTL_SERIAL_SET_LINE_CONTROL
, &slc
, sizeof(slc
), NULL
, 0, NULL
, NULL
) &&
4436 DeviceIoControl( handle
, IOCTL_SERIAL_SET_HANDFLOW
, &shf
, sizeof(shf
), NULL
, 0, NULL
, NULL
) &&
4437 DeviceIoControl( handle
, IOCTL_SERIAL_SET_CHARS
, &sc
, sizeof(sc
), NULL
, 0, NULL
, NULL
));
4441 /*****************************************************************************
4442 * SetCommTimeouts (kernelbase.@)
4444 BOOL WINAPI DECLSPEC_HOTPATCH
SetCommTimeouts( HANDLE handle
, COMMTIMEOUTS
*timeouts
)
4448 SetLastError( ERROR_INVALID_PARAMETER
);
4451 return DeviceIoControl( handle
, IOCTL_SERIAL_SET_TIMEOUTS
, timeouts
, sizeof(*timeouts
),
4452 NULL
, 0, NULL
, NULL
);
4456 /*****************************************************************************
4457 * SetupComm (kernelbase.@)
4459 BOOL WINAPI DECLSPEC_HOTPATCH
SetupComm( HANDLE handle
, DWORD in_size
, DWORD out_size
)
4461 SERIAL_QUEUE_SIZE sqs
;
4463 sqs
.InSize
= in_size
;
4464 sqs
.OutSize
= out_size
;
4465 return DeviceIoControl( handle
, IOCTL_SERIAL_SET_QUEUE_SIZE
, &sqs
, sizeof(sqs
), NULL
, 0, NULL
, NULL
);
4469 /*****************************************************************************
4470 * TransmitCommChar (kernelbase.@)
4472 BOOL WINAPI DECLSPEC_HOTPATCH
TransmitCommChar( HANDLE handle
, CHAR ch
)
4474 return DeviceIoControl( handle
, IOCTL_SERIAL_IMMEDIATE_CHAR
, &ch
, sizeof(ch
), NULL
, 0, NULL
, NULL
);
4478 /***********************************************************************
4479 * WaitCommEvent (kernelbase.@)
4481 BOOL WINAPI DECLSPEC_HOTPATCH
WaitCommEvent( HANDLE handle
, DWORD
*events
, OVERLAPPED
*overlapped
)
4483 return DeviceIoControl( handle
, IOCTL_SERIAL_WAIT_ON_MASK
, NULL
, 0, events
, sizeof(*events
),