?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winegstreamer: Register stub ColorConvertDMO transform.
[wine.git] / dlls / kernelbase / file.c
blob8ae982294f6d8b9cab1e0b29ef7cf75bd69dc97c
1 /*
2 * File handling functions
3 *
4 * Copyright 1993 John Burton
5 * Copyright 1996, 2004 Alexandre Julliard
6 * Copyright 2008 Jeff Zaroyko
7 *
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.
12 *
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.
17 *
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
21 */
22
23 #include <stdarg.h>
24 #include <stdio.h>
25
26 #define NONAMELESSUNION
27 #define NONAMELESSSTRUCT
28 #include "winerror.h"
29 #include "ntstatus.h"
30 #define WIN32_NO_STATUS
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winnls.h"
34 #include "winternl.h"
35 #include "winioctl.h"
36 #include "wincon.h"
37 #include "fileapi.h"
38 #include "shlwapi.h"
39 #include "ddk/ntddk.h"
40 #include "ddk/ntddser.h"
41
42 #include "kernelbase.h"
43 #include "wine/exception.h"
44 #include "wine/debug.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(file);
47
48 /* info structure for FindFirstFile handle */
49 typedef struct
50 {
51 DWORD magic; /* magic number */
52 HANDLE handle; /* handle to directory */
53 CRITICAL_SECTION cs; /* crit section protecting this structure */
54 FINDEX_SEARCH_OPS search_op; /* Flags passed to FindFirst. */
55 FINDEX_INFO_LEVELS level; /* Level passed to FindFirst */
56 UNICODE_STRING path; /* NT path used to open the directory */
57 BOOL is_root; /* is directory the root of the drive? */
58 BOOL wildcard; /* did the mask contain wildcard characters? */
59 UINT data_pos; /* current position in dir data */
60 UINT data_len; /* length of dir data */
61 UINT data_size; /* size of data buffer, or 0 when everything has been read */
62 BYTE data[1]; /* directory data */
63 } FIND_FIRST_INFO;
64
65 #define FIND_FIRST_MAGIC 0xc0ffee11
66
67 static const UINT max_entry_size = offsetof( FILE_BOTH_DIRECTORY_INFORMATION, FileName[256] );
68
69 const WCHAR windows_dir[] = L"C:\\windows";
70 const WCHAR system_dir[] = L"C:\\windows\\system32";
71
72 static BOOL oem_file_apis;
73
74
75 static void WINAPI read_write_apc( void *apc_user, PIO_STATUS_BLOCK io, ULONG reserved )
76 {
77 LPOVERLAPPED_COMPLETION_ROUTINE func = apc_user;
78 func( RtlNtStatusToDosError( io->u.Status ), io->Information, (LPOVERLAPPED)io );
79 }
80
81 static const WCHAR *get_machine_wow64_dir( WORD machine )
82 {
83 switch (machine)
84 {
85 case IMAGE_FILE_MACHINE_TARGET_HOST: return system_dir;
86 case IMAGE_FILE_MACHINE_I386: return L"C:\\windows\\syswow64";
87 case IMAGE_FILE_MACHINE_ARMNT: return L"C:\\windows\\sysarm32";
88 case IMAGE_FILE_MACHINE_AMD64: return L"C:\\windows\\sysx8664";
89 case IMAGE_FILE_MACHINE_ARM64: return L"C:\\windows\\sysarm64";
90 default: return NULL;
91 }
92 }
93
94
95 /***********************************************************************
96 * Operations on file names
97 ***********************************************************************/
98
99
100 /***********************************************************************
101 * contains_path
102 *
103 * Check if the file name contains a path; helper for SearchPathW.
104 * A relative path is not considered a path unless it starts with ./ or ../
105 */
106 static inline BOOL contains_path( const WCHAR *name )
107 {
108 if (RtlDetermineDosPathNameType_U( name ) != RELATIVE_PATH) return TRUE;
109 if (name[0] != '.') return FALSE;
110 if (name[1] == '/' || name[1] == '\\') return TRUE;
111 return (name[1] == '.' && (name[2] == '/' || name[2] == '\\'));
112 }
113
114
115 /***********************************************************************
116 * add_boot_rename_entry
117 *
118 * Adds an entry to the registry that is loaded when windows boots and
119 * checks if there are some files to be removed or renamed/moved.
120 * <fn1> has to be valid and <fn2> may be NULL. If both pointers are
121 * non-NULL then the file is moved, otherwise it is deleted. The
122 * entry of the registry key is always appended with two zero
123 * terminated strings. If <fn2> is NULL then the second entry is
124 * simply a single 0-byte. Otherwise the second filename goes
125 * there. The entries are prepended with \??\ before the path and the
126 * second filename gets also a '!' as the first character if
127 * MOVEFILE_REPLACE_EXISTING is set. After the final string another
128 * 0-byte follows to indicate the end of the strings.
129 * i.e.:
130 * \??\D:\test\file1[0]
131 * !\??\D:\test\file1_renamed[0]
132 * \??\D:\Test|delete[0]
133 * [0] <- file is to be deleted, second string empty
134 * \??\D:\test\file2[0]
135 * !\??\D:\test\file2_renamed[0]
136 * [0] <- indicates end of strings
137 *
138 * or:
139 * \??\D:\test\file1[0]
140 * !\??\D:\test\file1_renamed[0]
141 * \??\D:\Test|delete[0]
142 * [0] <- file is to be deleted, second string empty
143 * [0] <- indicates end of strings
144 *
145 */
146 static BOOL add_boot_rename_entry( LPCWSTR source, LPCWSTR dest, DWORD flags )
147 {
148 static const int info_size = FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data );
149
150 OBJECT_ATTRIBUTES attr;
151 UNICODE_STRING nameW, source_name, dest_name;
152 KEY_VALUE_PARTIAL_INFORMATION *info;
153 BOOL rc = FALSE;
154 HANDLE key = 0;
155 DWORD len1, len2;
156 DWORD size = 0;
157 BYTE *buffer = NULL;
158 WCHAR *p;
159
160 if (!RtlDosPathNameToNtPathName_U( source, &source_name, NULL, NULL ))
161 {
162 SetLastError( ERROR_PATH_NOT_FOUND );
163 return FALSE;
164 }
165 dest_name.Buffer = NULL;
166 if (dest && !RtlDosPathNameToNtPathName_U( dest, &dest_name, NULL, NULL ))
167 {
168 RtlFreeUnicodeString( &source_name );
169 SetLastError( ERROR_PATH_NOT_FOUND );
170 return FALSE;
171 }
172
173 attr.Length = sizeof(attr);
174 attr.RootDirectory = 0;
175 attr.ObjectName = &nameW;
176 attr.Attributes = 0;
177 attr.SecurityDescriptor = NULL;
178 attr.SecurityQualityOfService = NULL;
179 RtlInitUnicodeString( &nameW, L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Session Manager" );
180
181 if (NtCreateKey( &key, KEY_ALL_ACCESS, &attr, 0, NULL, 0, NULL ) != STATUS_SUCCESS)
182 {
183 RtlFreeUnicodeString( &source_name );
184 RtlFreeUnicodeString( &dest_name );
185 return FALSE;
186 }
187
188 len1 = source_name.Length + sizeof(WCHAR);
189 if (dest)
190 {
191 len2 = dest_name.Length + sizeof(WCHAR);
192 if (flags & MOVEFILE_REPLACE_EXISTING)
193 len2 += sizeof(WCHAR); /* Plus 1 because of the leading '!' */
194 }
195 else len2 = sizeof(WCHAR); /* minimum is the 0 characters for the empty second string */
196
197 RtlInitUnicodeString( &nameW, L"PendingFileRenameOperations" );
198
199 /* First we check if the key exists and if so how many bytes it already contains. */
200 if (NtQueryValueKey( key, &nameW, KeyValuePartialInformation,
201 NULL, 0, &size ) == STATUS_BUFFER_TOO_SMALL)
202 {
203 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size + len1 + len2 + sizeof(WCHAR) ))) goto done;
204 if (NtQueryValueKey( key, &nameW, KeyValuePartialInformation, buffer, size, &size )) goto done;
205 info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
206 if (info->Type != REG_MULTI_SZ) goto done;
207 if (size > sizeof(info)) size -= sizeof(WCHAR); /* remove terminating null (will be added back later) */
208 }
209 else
210 {
211 size = info_size;
212 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, size + len1 + len2 + sizeof(WCHAR) ))) goto done;
213 }
214
215 memcpy( buffer + size, source_name.Buffer, len1 );
216 size += len1;
217 p = (WCHAR *)(buffer + size);
218 if (dest)
219 {
220 if (flags & MOVEFILE_REPLACE_EXISTING) *p++ = '!';
221 memcpy( p, dest_name.Buffer, len2 );
222 size += len2;
223 }
224 else
225 {
226 *p = 0;
227 size += sizeof(WCHAR);
228 }
229
230 /* add final null */
231 p = (WCHAR *)(buffer + size);
232 *p = 0;
233 size += sizeof(WCHAR);
234 rc = !NtSetValueKey( key, &nameW, 0, REG_MULTI_SZ, buffer + info_size, size - info_size );
235
236 done:
237 RtlFreeUnicodeString( &source_name );
238 RtlFreeUnicodeString( &dest_name );
239 if (key) NtClose(key);
240 HeapFree( GetProcessHeap(), 0, buffer );
241 return rc;
242 }
243
244
245 /***********************************************************************
246 * append_ext
247 */
248 static WCHAR *append_ext( const WCHAR *name, const WCHAR *ext )
249 {
250 const WCHAR *p;
251 WCHAR *ret;
252 DWORD len;
253
254 if (!ext) return NULL;
255 p = wcsrchr( name, '.' );
256 if (p && !wcschr( p, '/' ) && !wcschr( p, '\\' )) return NULL;
257
258 len = lstrlenW( name ) + lstrlenW( ext );
259 if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR) )))
260 {
261 lstrcpyW( ret, name );
262 lstrcatW( ret, ext );
263 }
264 return ret;
265 }
266
267
268 /***********************************************************************
269 * find_actctx_dllpath
270 *
271 * Find the path (if any) of the dll from the activation context.
272 * Returned path doesn't include a name.
273 */
274 static NTSTATUS find_actctx_dllpath( const WCHAR *name, WCHAR **path )
275 {
276 ACTIVATION_CONTEXT_ASSEMBLY_DETAILED_INFORMATION *info;
277 ACTCTX_SECTION_KEYED_DATA data;
278 UNICODE_STRING nameW;
279 NTSTATUS status;
280 SIZE_T needed, size = 1024;
281 WCHAR *p;
282
283 RtlInitUnicodeString( &nameW, name );
284 data.cbSize = sizeof(data);
285 status = RtlFindActivationContextSectionString( FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
286 ACTIVATION_CONTEXT_SECTION_DLL_REDIRECTION,
287 &nameW, &data );
288 if (status != STATUS_SUCCESS) return status;
289
290 for (;;)
291 {
292 if (!(info = RtlAllocateHeap( GetProcessHeap(), 0, size )))
293 {
294 status = STATUS_NO_MEMORY;
295 goto done;
296 }
297 status = RtlQueryInformationActivationContext( 0, data.hActCtx, &data.ulAssemblyRosterIndex,
298 AssemblyDetailedInformationInActivationContext,
299 info, size, &needed );
300 if (status == STATUS_SUCCESS) break;
301 if (status != STATUS_BUFFER_TOO_SMALL) goto done;
302 RtlFreeHeap( GetProcessHeap(), 0, info );
303 size = needed;
304 /* restart with larger buffer */
305 }
306
307 if (!info->lpAssemblyManifestPath)
308 {
309 status = STATUS_SXS_KEY_NOT_FOUND;
310 goto done;
311 }
312
313 if ((p = wcsrchr( info->lpAssemblyManifestPath, '\\' )))
314 {
315 DWORD dirlen = info->ulAssemblyDirectoryNameLength / sizeof(WCHAR);
316
317 p++;
318 if (!dirlen ||
319 CompareStringOrdinal( p, dirlen, info->lpAssemblyDirectoryName, dirlen, TRUE ) != CSTR_EQUAL ||
320 wcsicmp( p + dirlen, L".manifest" ))
321 {
322 /* manifest name does not match directory name, so it's not a global
323 * windows/winsxs manifest; use the manifest directory name instead */
324 dirlen = p - info->lpAssemblyManifestPath;
325 needed = (dirlen + 1) * sizeof(WCHAR);
326 if (!(*path = p = HeapAlloc( GetProcessHeap(), 0, needed )))
327 {
328 status = STATUS_NO_MEMORY;
329 goto done;
330 }
331 memcpy( p, info->lpAssemblyManifestPath, dirlen * sizeof(WCHAR) );
332 *(p + dirlen) = 0;
333 goto done;
334 }
335 }
336
337 if (!info->lpAssemblyDirectoryName)
338 {
339 status = STATUS_SXS_KEY_NOT_FOUND;
340 goto done;
341 }
342
343 needed = sizeof(L"C:\\windows\\winsxs\\") + info->ulAssemblyDirectoryNameLength + sizeof(WCHAR);
344
345 if (!(*path = p = RtlAllocateHeap( GetProcessHeap(), 0, needed )))
346 {
347 status = STATUS_NO_MEMORY;
348 goto done;
349 }
350 lstrcpyW( p, L"C:\\windows\\winsxs\\" );
351 p += lstrlenW(p);
352 memcpy( p, info->lpAssemblyDirectoryName, info->ulAssemblyDirectoryNameLength );
353 p += info->ulAssemblyDirectoryNameLength / sizeof(WCHAR);
354 *p++ = '\\';
355 *p = 0;
356 done:
357 RtlFreeHeap( GetProcessHeap(), 0, info );
358 RtlReleaseActivationContext( data.hActCtx );
359 return status;
360 }
361
362
363 /***********************************************************************
364 * copy_filename
365 */
366 static DWORD copy_filename( const WCHAR *name, WCHAR *buffer, DWORD len )
367 {
368 UINT ret = lstrlenW( name ) + 1;
369 if (buffer && len >= ret)
370 {
371 lstrcpyW( buffer, name );
372 ret--;
373 }
374 return ret;
375 }
376
377
378 /***********************************************************************
379 * copy_filename_WtoA
380 *
381 * copy a file name back to OEM/Ansi, but only if the buffer is large enough
382 */
383 static DWORD copy_filename_WtoA( LPCWSTR nameW, LPSTR buffer, DWORD len )
384 {
385 UNICODE_STRING strW;
386 DWORD ret;
387
388 RtlInitUnicodeString( &strW, nameW );
389
390 ret = oem_file_apis ? RtlUnicodeStringToOemSize( &strW ) : RtlUnicodeStringToAnsiSize( &strW );
391 if (buffer && ret <= len)
392 {
393 ANSI_STRING str;
394
395 str.Buffer = buffer;
396 str.MaximumLength = min( len, UNICODE_STRING_MAX_CHARS );
397 if (oem_file_apis)
398 RtlUnicodeStringToOemString( &str, &strW, FALSE );
399 else
400 RtlUnicodeStringToAnsiString( &str, &strW, FALSE );
401 ret = str.Length; /* length without terminating 0 */
402 }
403 return ret;
404 }
405
406
407 /***********************************************************************
408 * file_name_AtoW
409 *
410 * Convert a file name to Unicode, taking into account the OEM/Ansi API mode.
411 *
412 * If alloc is FALSE uses the TEB static buffer, so it can only be used when
413 * there is no possibility for the function to do that twice, taking into
414 * account any called function.
415 */
416 WCHAR *file_name_AtoW( LPCSTR name, BOOL alloc )
417 {
418 ANSI_STRING str;
419 UNICODE_STRING strW, *pstrW;
420 NTSTATUS status;
421
422 RtlInitAnsiString( &str, name );
423 pstrW = alloc ? &strW : &NtCurrentTeb()->StaticUnicodeString;
424 if (oem_file_apis)
425 status = RtlOemStringToUnicodeString( pstrW, &str, alloc );
426 else
427 status = RtlAnsiStringToUnicodeString( pstrW, &str, alloc );
428 if (status == STATUS_SUCCESS) return pstrW->Buffer;
429
430 if (status == STATUS_BUFFER_OVERFLOW)
431 SetLastError( ERROR_FILENAME_EXCED_RANGE );
432 else
433 SetLastError( RtlNtStatusToDosError(status) );
434 return NULL;
435 }
436
437
438 /***********************************************************************
439 * file_name_WtoA
440 *
441 * Convert a file name back to OEM/Ansi. Returns number of bytes copied.
442 */
443 DWORD file_name_WtoA( LPCWSTR src, INT srclen, LPSTR dest, INT destlen )
444 {
445 DWORD ret;
446
447 if (srclen < 0) srclen = lstrlenW( src ) + 1;
448 if (!destlen)
449 {
450 if (oem_file_apis)
451 {
452 UNICODE_STRING strW;
453 strW.Buffer = (WCHAR *)src;
454 strW.Length = srclen * sizeof(WCHAR);
455 ret = RtlUnicodeStringToOemSize( &strW ) - 1;
456 }
457 else
458 RtlUnicodeToMultiByteSize( &ret, src, srclen * sizeof(WCHAR) );
459 }
460 else
461 {
462 if (oem_file_apis)
463 RtlUnicodeToOemN( dest, destlen, &ret, src, srclen * sizeof(WCHAR) );
464 else
465 RtlUnicodeToMultiByteN( dest, destlen, &ret, src, srclen * sizeof(WCHAR) );
466 }
467 return ret;
468 }
469
470
471 /***********************************************************************
472 * is_same_file
473 */
474 static BOOL is_same_file( HANDLE h1, HANDLE h2 )
475 {
476 FILE_OBJECTID_BUFFER id1, id2;
477 IO_STATUS_BLOCK io;
478
479 return (!NtFsControlFile( h1, 0, NULL, NULL, &io, FSCTL_GET_OBJECT_ID, NULL, 0, &id1, sizeof(id1) ) &&
480 !NtFsControlFile( h2, 0, NULL, NULL, &io, FSCTL_GET_OBJECT_ID, NULL, 0, &id2, sizeof(id2) ) &&
481 !memcmp( &id1.ObjectId, &id2.ObjectId, sizeof(id1.ObjectId) ));
482 }
483
484
485 /******************************************************************************
486 * AreFileApisANSI (kernelbase.@)
487 */
488 BOOL WINAPI DECLSPEC_HOTPATCH AreFileApisANSI(void)
489 {
490 return !oem_file_apis;
491 }
492
493
494 /***********************************************************************
495 * CopyFileExW (kernelbase.@)
496 */
497 BOOL WINAPI CopyFileExW( const WCHAR *source, const WCHAR *dest, LPPROGRESS_ROUTINE progress,
498 void *param, BOOL *cancel_ptr, DWORD flags )
499 {
500 static const int buffer_size = 65536;
501 HANDLE h1, h2;
502 FILE_BASIC_INFORMATION info;
503 IO_STATUS_BLOCK io;
504 DWORD count;
505 BOOL ret = FALSE;
506 char *buffer;
507
508 if (!source || !dest)
509 {
510 SetLastError( ERROR_INVALID_PARAMETER );
511 return FALSE;
512 }
513 if (!(buffer = HeapAlloc( GetProcessHeap(), 0, buffer_size )))
514 {
515 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
516 return FALSE;
517 }
518
519 TRACE("%s -> %s, %lx\n", debugstr_w(source), debugstr_w(dest), flags);
520
521 if (flags & COPY_FILE_RESTARTABLE)
522 FIXME("COPY_FILE_RESTARTABLE is not supported\n");
523 if (flags & COPY_FILE_COPY_SYMLINK)
524 FIXME("COPY_FILE_COPY_SYMLINK is not supported\n");
525 if (flags & COPY_FILE_OPEN_SOURCE_FOR_WRITE)
526 FIXME("COPY_FILE_OPEN_SOURCE_FOR_WRITE is not supported\n");
527
528 if ((h1 = CreateFileW( source, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
529 NULL, OPEN_EXISTING, 0, 0 )) == INVALID_HANDLE_VALUE)
530 {
531 WARN("Unable to open source %s\n", debugstr_w(source));
532 HeapFree( GetProcessHeap(), 0, buffer );
533 return FALSE;
534 }
535
536 if (!set_ntstatus( NtQueryInformationFile( h1, &io, &info, sizeof(info), FileBasicInformation )))
537 {
538 WARN("GetFileInformationByHandle returned error for %s\n", debugstr_w(source));
539 HeapFree( GetProcessHeap(), 0, buffer );
540 CloseHandle( h1 );
541 return FALSE;
542 }
543
544 if (!(flags & COPY_FILE_FAIL_IF_EXISTS))
545 {
546 BOOL same_file = FALSE;
547 h2 = CreateFileW( dest, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0 );
548 if (h2 != INVALID_HANDLE_VALUE)
549 {
550 same_file = is_same_file( h1, h2 );
551 CloseHandle( h2 );
552 }
553 if (same_file)
554 {
555 HeapFree( GetProcessHeap(), 0, buffer );
556 CloseHandle( h1 );
557 SetLastError( ERROR_SHARING_VIOLATION );
558 return FALSE;
559 }
560 }
561
562 if ((h2 = CreateFileW( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
563 (flags & COPY_FILE_FAIL_IF_EXISTS) ? CREATE_NEW : CREATE_ALWAYS,
564 info.FileAttributes, h1 )) == INVALID_HANDLE_VALUE)
565 {
566 WARN("Unable to open dest %s\n", debugstr_w(dest));
567 HeapFree( GetProcessHeap(), 0, buffer );
568 CloseHandle( h1 );
569 return FALSE;
570 }
571
572 while (ReadFile( h1, buffer, buffer_size, &count, NULL ) && count)
573 {
574 char *p = buffer;
575 while (count != 0)
576 {
577 DWORD res;
578 if (!WriteFile( h2, p, count, &res, NULL ) || !res) goto done;
579 p += res;
580 count -= res;
581 }
582 }
583 ret = TRUE;
584 done:
585 /* Maintain the timestamp of source file to destination file */
586 info.FileAttributes = 0;
587 NtSetInformationFile( h2, &io, &info, sizeof(info), FileBasicInformation );
588 HeapFree( GetProcessHeap(), 0, buffer );
589 CloseHandle( h1 );
590 CloseHandle( h2 );
591 if (ret) SetLastError( 0 );
592 return ret;
593 }
594
595
596 /**************************************************************************
597 * CopyFileW (kernelbase.@)
598 */
599 BOOL WINAPI DECLSPEC_HOTPATCH CopyFileW( const WCHAR *source, const WCHAR *dest, BOOL fail_if_exists )
600 {
601 return CopyFileExW( source, dest, NULL, NULL, NULL, fail_if_exists ? COPY_FILE_FAIL_IF_EXISTS : 0 );
602 }
603
604
605 /***********************************************************************
606 * CreateDirectoryA (kernelbase.@)
607 */
608 BOOL WINAPI DECLSPEC_HOTPATCH CreateDirectoryA( LPCSTR path, LPSECURITY_ATTRIBUTES sa )
609 {
610 WCHAR *pathW;
611
612 if (!(pathW = file_name_AtoW( path, FALSE ))) return FALSE;
613 return CreateDirectoryW( pathW, sa );
614 }
615
616
617 /***********************************************************************
618 * CreateDirectoryW (kernelbase.@)
619 */
620 BOOL WINAPI DECLSPEC_HOTPATCH CreateDirectoryW( LPCWSTR path, LPSECURITY_ATTRIBUTES sa )
621 {
622 OBJECT_ATTRIBUTES attr;
623 UNICODE_STRING nt_name;
624 IO_STATUS_BLOCK io;
625 NTSTATUS status;
626 HANDLE handle;
627
628 TRACE( "%s\n", debugstr_w(path) );
629
630 if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL ))
631 {
632 SetLastError( ERROR_PATH_NOT_FOUND );
633 return FALSE;
634 }
635 attr.Length = sizeof(attr);
636 attr.RootDirectory = 0;
637 attr.Attributes = OBJ_CASE_INSENSITIVE;
638 attr.ObjectName = &nt_name;
639 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
640 attr.SecurityQualityOfService = NULL;
641
642 status = NtCreateFile( &handle, GENERIC_READ | SYNCHRONIZE, &attr, &io, NULL,
643 FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_CREATE,
644 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 );
645 if (status == STATUS_SUCCESS) NtClose( handle );
646
647 RtlFreeUnicodeString( &nt_name );
648 return set_ntstatus( status );
649 }
650
651
652 /***********************************************************************
653 * CreateDirectoryEx (kernelbase.@)
654 */
655 BOOL WINAPI DECLSPEC_HOTPATCH CreateDirectoryExW( LPCWSTR template, LPCWSTR path,
656 LPSECURITY_ATTRIBUTES sa )
657 {
658 return CreateDirectoryW( path, sa );
659 }
660
661
662 /*************************************************************************
663 * CreateFile2 (kernelbase.@)
664 */
665 HANDLE WINAPI DECLSPEC_HOTPATCH CreateFile2( LPCWSTR name, DWORD access, DWORD sharing, DWORD creation,
666 CREATEFILE2_EXTENDED_PARAMETERS *params )
667 {
668 static const DWORD attributes_mask = FILE_ATTRIBUTE_READONLY |
669 FILE_ATTRIBUTE_HIDDEN |
670 FILE_ATTRIBUTE_SYSTEM |
671 FILE_ATTRIBUTE_ARCHIVE |
672 FILE_ATTRIBUTE_NORMAL |
673 FILE_ATTRIBUTE_TEMPORARY |
674 FILE_ATTRIBUTE_OFFLINE |
675 FILE_ATTRIBUTE_ENCRYPTED |
676 FILE_ATTRIBUTE_INTEGRITY_STREAM;
677 static const DWORD flags_mask = FILE_FLAG_BACKUP_SEMANTICS |
678 FILE_FLAG_DELETE_ON_CLOSE |
679 FILE_FLAG_NO_BUFFERING |
680 FILE_FLAG_OPEN_NO_RECALL |
681 FILE_FLAG_OPEN_REPARSE_POINT |
682 FILE_FLAG_OVERLAPPED |
683 FILE_FLAG_POSIX_SEMANTICS |
684 FILE_FLAG_RANDOM_ACCESS |
685 FILE_FLAG_SEQUENTIAL_SCAN |
686 FILE_FLAG_WRITE_THROUGH;
687
688 LPSECURITY_ATTRIBUTES sa = params ? params->lpSecurityAttributes : NULL;
689 HANDLE template = params ? params->hTemplateFile : NULL;
690 DWORD attributes = params ? params->dwFileAttributes : 0;
691 DWORD flags = params ? params->dwFileFlags : 0;
692
693 FIXME( "(%s %lx %lx %lx %p), partial stub\n", debugstr_w(name), access, sharing, creation, params );
694
695 if (attributes & ~attributes_mask) FIXME( "unsupported attributes %#lx\n", attributes );
696 if (flags & ~flags_mask) FIXME( "unsupported flags %#lx\n", flags );
697 attributes &= attributes_mask;
698 flags &= flags_mask;
699
700 return CreateFileW( name, access, sharing, sa, creation, flags | attributes, template );
701 }
702
703
704 /*************************************************************************
705 * CreateFileA (kernelbase.@)
706 */
707 HANDLE WINAPI DECLSPEC_HOTPATCH CreateFileA( LPCSTR name, DWORD access, DWORD sharing,
708 LPSECURITY_ATTRIBUTES sa, DWORD creation,
709 DWORD attributes, HANDLE template)
710 {
711 WCHAR *nameW;
712
713 if ((GetVersion() & 0x80000000) && IsBadStringPtrA( name, -1 )) return INVALID_HANDLE_VALUE;
714 if (!(nameW = file_name_AtoW( name, FALSE ))) return INVALID_HANDLE_VALUE;
715 return CreateFileW( nameW, access, sharing, sa, creation, attributes, template );
716 }
717
718 static UINT get_nt_file_options( DWORD attributes )
719 {
720 UINT options = 0;
721
722 if (attributes & FILE_FLAG_BACKUP_SEMANTICS)
723 options |= FILE_OPEN_FOR_BACKUP_INTENT;
724 else
725 options |= FILE_NON_DIRECTORY_FILE;
726 if (attributes & FILE_FLAG_DELETE_ON_CLOSE)
727 options |= FILE_DELETE_ON_CLOSE;
728 if (attributes & FILE_FLAG_NO_BUFFERING)
729 options |= FILE_NO_INTERMEDIATE_BUFFERING;
730 if (!(attributes & FILE_FLAG_OVERLAPPED))
731 options |= FILE_SYNCHRONOUS_IO_NONALERT;
732 if (attributes & FILE_FLAG_RANDOM_ACCESS)
733 options |= FILE_RANDOM_ACCESS;
734 if (attributes & FILE_FLAG_SEQUENTIAL_SCAN)
735 options |= FILE_SEQUENTIAL_ONLY;
736 if (attributes & FILE_FLAG_WRITE_THROUGH)
737 options |= FILE_WRITE_THROUGH;
738 return options;
739 }
740
741 /*************************************************************************
742 * CreateFileW (kernelbase.@)
743 */
744 HANDLE WINAPI DECLSPEC_HOTPATCH CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
745 LPSECURITY_ATTRIBUTES sa, DWORD creation,
746 DWORD attributes, HANDLE template )
747 {
748 NTSTATUS status;
749 OBJECT_ATTRIBUTES attr;
750 UNICODE_STRING nameW;
751 IO_STATUS_BLOCK io;
752 HANDLE ret;
753 const WCHAR *vxd_name = NULL;
754 SECURITY_QUALITY_OF_SERVICE qos;
755
756 static const UINT nt_disposition[5] =
757 {
758 FILE_CREATE, /* CREATE_NEW */
759 FILE_OVERWRITE_IF, /* CREATE_ALWAYS */
760 FILE_OPEN, /* OPEN_EXISTING */
761 FILE_OPEN_IF, /* OPEN_ALWAYS */
762 FILE_OVERWRITE /* TRUNCATE_EXISTING */
763 };
764
765
766 /* sanity checks */
767
768 if (!filename || !filename[0])
769 {
770 SetLastError( ERROR_PATH_NOT_FOUND );
771 return INVALID_HANDLE_VALUE;
772 }
773
774 TRACE( "%s %s%s%s%s%s%s%s creation %ld attributes 0x%lx\n", debugstr_w(filename),
775 (access & GENERIC_READ) ? "GENERIC_READ " : "",
776 (access & GENERIC_WRITE) ? "GENERIC_WRITE " : "",
777 (access & GENERIC_EXECUTE) ? "GENERIC_EXECUTE " : "",
778 !access ? "QUERY_ACCESS " : "",
779 (sharing & FILE_SHARE_READ) ? "FILE_SHARE_READ " : "",
780 (sharing & FILE_SHARE_WRITE) ? "FILE_SHARE_WRITE " : "",
781 (sharing & FILE_SHARE_DELETE) ? "FILE_SHARE_DELETE " : "",
782 creation, attributes);
783
784 if ((GetVersion() & 0x80000000) && !wcsncmp( filename, L"\\\\.\\", 4 ) &&
785 !RtlIsDosDeviceName_U( filename + 4 ) &&
786 wcsnicmp( filename + 4, L"PIPE\\", 5 ) &&
787 wcsnicmp( filename + 4, L"MAILSLOT\\", 9 ))
788 {
789 vxd_name = filename + 4;
790 if (!creation) creation = OPEN_EXISTING;
791 }
792
793 if (creation < CREATE_NEW || creation > TRUNCATE_EXISTING)
794 {
795 SetLastError( ERROR_INVALID_PARAMETER );
796 return INVALID_HANDLE_VALUE;
797 }
798
799 if (!RtlDosPathNameToNtPathName_U( filename, &nameW, NULL, NULL ))
800 {
801 SetLastError( ERROR_PATH_NOT_FOUND );
802 return INVALID_HANDLE_VALUE;
803 }
804
805 /* now call NtCreateFile */
806
807 if (attributes & FILE_FLAG_DELETE_ON_CLOSE)
808 access |= DELETE;
809
810 attr.Length = sizeof(attr);
811 attr.RootDirectory = 0;
812 attr.Attributes = OBJ_CASE_INSENSITIVE;
813 attr.ObjectName = &nameW;
814 attr.SecurityDescriptor = sa ? sa->lpSecurityDescriptor : NULL;
815 if (attributes & SECURITY_SQOS_PRESENT)
816 {
817 qos.Length = sizeof(qos);
818 qos.ImpersonationLevel = (attributes >> 16) & 0x3;
819 qos.ContextTrackingMode = attributes & SECURITY_CONTEXT_TRACKING ? SECURITY_DYNAMIC_TRACKING : SECURITY_STATIC_TRACKING;
820 qos.EffectiveOnly = (attributes & SECURITY_EFFECTIVE_ONLY) != 0;
821 attr.SecurityQualityOfService = &qos;
822 }
823 else
824 attr.SecurityQualityOfService = NULL;
825
826 if (sa && sa->bInheritHandle) attr.Attributes |= OBJ_INHERIT;
827
828 status = NtCreateFile( &ret, access | SYNCHRONIZE | FILE_READ_ATTRIBUTES, &attr, &io,
829 NULL, attributes & FILE_ATTRIBUTE_VALID_FLAGS, sharing,
830 nt_disposition[creation - CREATE_NEW],
831 get_nt_file_options( attributes ), NULL, 0 );
832 if (status)
833 {
834 if (vxd_name && vxd_name[0])
835 {
836 static HANDLE (*vxd_open)(LPCWSTR,DWORD,SECURITY_ATTRIBUTES*);
837 if (!vxd_open) vxd_open = (void *)GetProcAddress( GetModuleHandleW(L"krnl386.exe16"),
838 "__wine_vxd_open" );
839 if (vxd_open && (ret = vxd_open( vxd_name, access, sa ))) goto done;
840 }
841
842 WARN("Unable to create file %s (status %lx)\n", debugstr_w(filename), status);
843 ret = INVALID_HANDLE_VALUE;
844
845 /* In the case file creation was rejected due to CREATE_NEW flag
846 * was specified and file with that name already exists, correct
847 * last error is ERROR_FILE_EXISTS and not ERROR_ALREADY_EXISTS.
848 * Note: RtlNtStatusToDosError is not the subject to blame here.
849 */
850 if (status == STATUS_OBJECT_NAME_COLLISION)
851 SetLastError( ERROR_FILE_EXISTS );
852 else
853 SetLastError( RtlNtStatusToDosError(status) );
854 }
855 else
856 {
857 if ((creation == CREATE_ALWAYS && io.Information == FILE_OVERWRITTEN) ||
858 (creation == OPEN_ALWAYS && io.Information == FILE_OPENED))
859 SetLastError( ERROR_ALREADY_EXISTS );
860 else
861 SetLastError( 0 );
862 }
863 RtlFreeUnicodeString( &nameW );
864
865 done:
866 if (!ret) ret = INVALID_HANDLE_VALUE;
867 TRACE("returning %p\n", ret);
868 return ret;
869 }
870
871
872 /*************************************************************************
873 * CreateHardLinkA (kernelbase.@)
874 */
875 BOOL WINAPI DECLSPEC_HOTPATCH CreateHardLinkA( const char *dest, const char *source,
876 SECURITY_ATTRIBUTES *attr )
877 {
878 WCHAR *sourceW, *destW;
879 BOOL res;
880
881 if (!(sourceW = file_name_AtoW( source, TRUE ))) return FALSE;
882 if (!(destW = file_name_AtoW( dest, TRUE )))
883 {
884 HeapFree( GetProcessHeap(), 0, sourceW );
885 return FALSE;
886 }
887 res = CreateHardLinkW( destW, sourceW, attr );
888 HeapFree( GetProcessHeap(), 0, sourceW );
889 HeapFree( GetProcessHeap(), 0, destW );
890 return res;
891 }
892
893
894 /*************************************************************************
895 * CreateHardLinkW (kernelbase.@)
896 */
897 BOOL WINAPI CreateHardLinkW( LPCWSTR dest, LPCWSTR source, SECURITY_ATTRIBUTES *sec_attr )
898 {
899 UNICODE_STRING ntDest, ntSource;
900 FILE_LINK_INFORMATION *info = NULL;
901 OBJECT_ATTRIBUTES attr;
902 IO_STATUS_BLOCK io;
903 BOOL ret = FALSE;
904 HANDLE file;
905 ULONG size;
906
907 TRACE( "(%s, %s, %p)\n", debugstr_w(dest), debugstr_w(source), sec_attr );
908
909 ntDest.Buffer = ntSource.Buffer = NULL;
910 if (!RtlDosPathNameToNtPathName_U( dest, &ntDest, NULL, NULL ) ||
911 !RtlDosPathNameToNtPathName_U( source, &ntSource, NULL, NULL ))
912 {
913 SetLastError( ERROR_PATH_NOT_FOUND );
914 goto done;
915 }
916
917 size = offsetof( FILE_LINK_INFORMATION, FileName ) + ntDest.Length;
918 if (!(info = HeapAlloc( GetProcessHeap(), 0, size )))
919 {
920 SetLastError( ERROR_OUTOFMEMORY );
921 goto done;
922 }
923
924 InitializeObjectAttributes( &attr, &ntSource, OBJ_CASE_INSENSITIVE, 0, NULL );
925 if (!(ret = set_ntstatus( NtOpenFile( &file, SYNCHRONIZE, &attr, &io, FILE_SHARE_READ | FILE_SHARE_WRITE,
926 FILE_SYNCHRONOUS_IO_NONALERT ) )))
927 goto done;
928
929 info->ReplaceIfExists = FALSE;
930 info->RootDirectory = NULL;
931 info->FileNameLength = ntDest.Length;
932 memcpy( info->FileName, ntDest.Buffer, ntDest.Length );
933 ret = set_ntstatus( NtSetInformationFile( file, &io, info, size, FileLinkInformation ) );
934 NtClose( file );
935
936 done:
937 RtlFreeUnicodeString( &ntSource );
938 RtlFreeUnicodeString( &ntDest );
939 HeapFree( GetProcessHeap(), 0, info );
940 return ret;
941 }
942
943
944 /*************************************************************************
945 * CreateSymbolicLinkW (kernelbase.@)
946 */
947 BOOLEAN WINAPI /* DECLSPEC_HOTPATCH */ CreateSymbolicLinkW( LPCWSTR link, LPCWSTR target, DWORD flags )
948 {
949 FIXME( "(%s %s %ld): stub\n", debugstr_w(link), debugstr_w(target), flags );
950 return TRUE;
951 }
952
953
954 /***********************************************************************
955 * DeleteFileA (kernelbase.@)
956 */
957 BOOL WINAPI DECLSPEC_HOTPATCH DeleteFileA( LPCSTR path )
958 {
959 WCHAR *pathW;
960
961 if (!(pathW = file_name_AtoW( path, FALSE ))) return FALSE;
962 return DeleteFileW( pathW );
963 }
964
965
966 /***********************************************************************
967 * DeleteFileW (kernelbase.@)
968 */
969 BOOL WINAPI DECLSPEC_HOTPATCH DeleteFileW( LPCWSTR path )
970 {
971 UNICODE_STRING nameW;
972 OBJECT_ATTRIBUTES attr;
973 NTSTATUS status;
974 HANDLE hFile;
975 IO_STATUS_BLOCK io;
976
977 TRACE( "%s\n", debugstr_w(path) );
978
979 if (!RtlDosPathNameToNtPathName_U( path, &nameW, NULL, NULL ))
980 {
981 SetLastError( ERROR_PATH_NOT_FOUND );
982 return FALSE;
983 }
984
985 attr.Length = sizeof(attr);
986 attr.RootDirectory = 0;
987 attr.Attributes = OBJ_CASE_INSENSITIVE;
988 attr.ObjectName = &nameW;
989 attr.SecurityDescriptor = NULL;
990 attr.SecurityQualityOfService = NULL;
991
992 status = NtCreateFile(&hFile, SYNCHRONIZE | DELETE, &attr, &io, NULL, 0,
993 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
994 FILE_OPEN, FILE_DELETE_ON_CLOSE | FILE_NON_DIRECTORY_FILE, NULL, 0);
995 if (status == STATUS_SUCCESS) status = NtClose(hFile);
996
997 RtlFreeUnicodeString( &nameW );
998 return set_ntstatus( status );
999 }
1000
1001
1002 /****************************************************************************
1003 * FindCloseChangeNotification (kernelbase.@)
1004 */
1005 BOOL WINAPI DECLSPEC_HOTPATCH FindCloseChangeNotification( HANDLE handle )
1006 {
1007 return CloseHandle( handle );
1008 }
1009
1010
1011 /****************************************************************************
1012 * FindFirstChangeNotificationA (kernelbase.@)
1013 */
1014 HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstChangeNotificationA( LPCSTR path, BOOL subtree, DWORD filter )
1015 {
1016 WCHAR *pathW;
1017
1018 if (!(pathW = file_name_AtoW( path, FALSE ))) return INVALID_HANDLE_VALUE;
1019 return FindFirstChangeNotificationW( pathW, subtree, filter );
1020 }
1021
1022
1023 /*
1024 * NtNotifyChangeDirectoryFile may write back to the IO_STATUS_BLOCK
1025 * asynchronously. We don't care about the contents, but it can't
1026 * be placed on the stack since it will go out of scope when we return.
1027 */
1028 static IO_STATUS_BLOCK dummy_iosb;
1029
1030 /****************************************************************************
1031 * FindFirstChangeNotificationW (kernelbase.@)
1032 */
1033 HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstChangeNotificationW( LPCWSTR path, BOOL subtree, DWORD filter )
1034 {
1035 UNICODE_STRING nt_name;
1036 OBJECT_ATTRIBUTES attr;
1037 NTSTATUS status;
1038 HANDLE handle = INVALID_HANDLE_VALUE;
1039
1040 TRACE( "%s %d %lx\n", debugstr_w(path), subtree, filter );
1041
1042 if (!RtlDosPathNameToNtPathName_U( path, &nt_name, NULL, NULL ))
1043 {
1044 SetLastError( ERROR_PATH_NOT_FOUND );
1045 return handle;
1046 }
1047
1048 attr.Length = sizeof(attr);
1049 attr.RootDirectory = 0;
1050 attr.Attributes = OBJ_CASE_INSENSITIVE;
1051 attr.ObjectName = &nt_name;
1052 attr.SecurityDescriptor = NULL;
1053 attr.SecurityQualityOfService = NULL;
1054
1055 status = NtOpenFile( &handle, FILE_LIST_DIRECTORY | SYNCHRONIZE, &attr, &dummy_iosb,
1056 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1057 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT );
1058 RtlFreeUnicodeString( &nt_name );
1059
1060 if (!set_ntstatus( status )) return INVALID_HANDLE_VALUE;
1061
1062 status = NtNotifyChangeDirectoryFile( handle, NULL, NULL, NULL, &dummy_iosb, NULL, 0, filter, subtree );
1063 if (status != STATUS_PENDING)
1064 {
1065 NtClose( handle );
1066 SetLastError( RtlNtStatusToDosError(status) );
1067 return INVALID_HANDLE_VALUE;
1068 }
1069 return handle;
1070 }
1071
1072
1073 /****************************************************************************
1074 * FindNextChangeNotification (kernelbase.@)
1075 */
1076 BOOL WINAPI DECLSPEC_HOTPATCH FindNextChangeNotification( HANDLE handle )
1077 {
1078 NTSTATUS status = NtNotifyChangeDirectoryFile( handle, NULL, NULL, NULL, &dummy_iosb,
1079 NULL, 0, FILE_NOTIFY_CHANGE_SIZE, 0 );
1080 if (status == STATUS_PENDING) return TRUE;
1081 return set_ntstatus( status );
1082 }
1083
1084
1085 /******************************************************************************
1086 * FindFirstFileExA (kernelbase.@)
1087 */
1088 HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstFileExA( const char *filename, FINDEX_INFO_LEVELS level,
1089 void *data, FINDEX_SEARCH_OPS search_op,
1090 void *filter, DWORD flags )
1091 {
1092 HANDLE handle;
1093 WIN32_FIND_DATAA *dataA = data;
1094 WIN32_FIND_DATAW dataW;
1095 WCHAR *nameW;
1096
1097 if (!(nameW = file_name_AtoW( filename, FALSE ))) return INVALID_HANDLE_VALUE;
1098
1099 handle = FindFirstFileExW( nameW, level, &dataW, search_op, filter, flags );
1100 if (handle == INVALID_HANDLE_VALUE) return handle;
1101
1102 dataA->dwFileAttributes = dataW.dwFileAttributes;
1103 dataA->ftCreationTime = dataW.ftCreationTime;
1104 dataA->ftLastAccessTime = dataW.ftLastAccessTime;
1105 dataA->ftLastWriteTime = dataW.ftLastWriteTime;
1106 dataA->nFileSizeHigh = dataW.nFileSizeHigh;
1107 dataA->nFileSizeLow = dataW.nFileSizeLow;
1108 file_name_WtoA( dataW.cFileName, -1, dataA->cFileName, sizeof(dataA->cFileName) );
1109 file_name_WtoA( dataW.cAlternateFileName, -1, dataA->cAlternateFileName,
1110 sizeof(dataA->cAlternateFileName) );
1111 return handle;
1112 }
1113
1114
1115 /******************************************************************************
1116 * FindFirstFileExW (kernelbase.@)
1117 */
1118 HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstFileExW( LPCWSTR filename, FINDEX_INFO_LEVELS level,
1119 LPVOID data, FINDEX_SEARCH_OPS search_op,
1120 LPVOID filter, DWORD flags )
1121 {
1122 WCHAR *mask;
1123 BOOL has_wildcard = FALSE;
1124 FIND_FIRST_INFO *info = NULL;
1125 UNICODE_STRING nt_name;
1126 OBJECT_ATTRIBUTES attr;
1127 IO_STATUS_BLOCK io;
1128 NTSTATUS status;
1129 DWORD size, device = 0;
1130
1131 TRACE( "%s %d %p %d %p %lx\n", debugstr_w(filename), level, data, search_op, filter, flags );
1132
1133 if (flags & ~FIND_FIRST_EX_LARGE_FETCH)
1134 {
1135 FIXME("flags not implemented 0x%08lx\n", flags );
1136 }
1137 if (search_op != FindExSearchNameMatch && search_op != FindExSearchLimitToDirectories)
1138 {
1139 FIXME( "search_op not implemented 0x%08x\n", search_op );
1140 SetLastError( ERROR_INVALID_PARAMETER );
1141 return INVALID_HANDLE_VALUE;
1142 }
1143 if (level != FindExInfoStandard && level != FindExInfoBasic)
1144 {
1145 FIXME("info level %d not implemented\n", level );
1146 SetLastError( ERROR_INVALID_PARAMETER );
1147 return INVALID_HANDLE_VALUE;
1148 }
1149
1150 if (!RtlDosPathNameToNtPathName_U( filename, &nt_name, &mask, NULL ))
1151 {
1152 SetLastError( ERROR_PATH_NOT_FOUND );
1153 return INVALID_HANDLE_VALUE;
1154 }
1155
1156 if (!mask && (device = RtlIsDosDeviceName_U( filename )))
1157 {
1158 WCHAR *dir = NULL;
1159
1160 /* we still need to check that the directory can be opened */
1161
1162 if (HIWORD(device))
1163 {
1164 if (!(dir = HeapAlloc( GetProcessHeap(), 0, HIWORD(device) + sizeof(WCHAR) )))
1165 {
1166 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1167 goto error;
1168 }
1169 memcpy( dir, filename, HIWORD(device) );
1170 dir[HIWORD(device)/sizeof(WCHAR)] = 0;
1171 }
1172 RtlFreeUnicodeString( &nt_name );
1173 if (!RtlDosPathNameToNtPathName_U( dir ? dir : L".", &nt_name, &mask, NULL ))
1174 {
1175 HeapFree( GetProcessHeap(), 0, dir );
1176 SetLastError( ERROR_PATH_NOT_FOUND );
1177 goto error;
1178 }
1179 HeapFree( GetProcessHeap(), 0, dir );
1180 size = 0;
1181 }
1182 else if (!mask || !*mask)
1183 {
1184 SetLastError( ERROR_FILE_NOT_FOUND );
1185 goto error;
1186 }
1187 else
1188 {
1189 nt_name.Length = (mask - nt_name.Buffer) * sizeof(WCHAR);
1190 has_wildcard = wcspbrk( mask, L"*?" ) != NULL;
1191 size = has_wildcard ? 8192 : max_entry_size;
1192 }
1193
1194 if (!(info = HeapAlloc( GetProcessHeap(), 0, offsetof( FIND_FIRST_INFO, data[size] ))))
1195 {
1196 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1197 goto error;
1198 }
1199
1200 /* check if path is the root of the drive, skipping the \??\ prefix */
1201 info->is_root = FALSE;
1202 if (nt_name.Length >= 6 * sizeof(WCHAR) && nt_name.Buffer[5] == ':')
1203 {
1204 DWORD pos = 6;
1205 while (pos * sizeof(WCHAR) < nt_name.Length && nt_name.Buffer[pos] == '\\') pos++;
1206 info->is_root = (pos * sizeof(WCHAR) >= nt_name.Length);
1207 }
1208
1209 attr.Length = sizeof(attr);
1210 attr.RootDirectory = 0;
1211 attr.Attributes = OBJ_CASE_INSENSITIVE;
1212 attr.ObjectName = &nt_name;
1213 attr.SecurityDescriptor = NULL;
1214 attr.SecurityQualityOfService = NULL;
1215
1216 status = NtOpenFile( &info->handle, FILE_LIST_DIRECTORY | SYNCHRONIZE, &attr, &io,
1217 FILE_SHARE_READ | FILE_SHARE_WRITE,
1218 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT );
1219 if (status != STATUS_SUCCESS)
1220 {
1221 if (status == STATUS_OBJECT_NAME_NOT_FOUND)
1222 SetLastError( ERROR_PATH_NOT_FOUND );
1223 else
1224 SetLastError( RtlNtStatusToDosError(status) );
1225 goto error;
1226 }
1227
1228 RtlInitializeCriticalSection( &info->cs );
1229 info->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": FIND_FIRST_INFO.cs");
1230 info->path = nt_name;
1231 info->magic = FIND_FIRST_MAGIC;
1232 info->wildcard = has_wildcard;
1233 info->data_pos = 0;
1234 info->data_len = 0;
1235 info->data_size = size;
1236 info->search_op = search_op;
1237 info->level = level;
1238
1239 if (device)
1240 {
1241 WIN32_FIND_DATAW *wfd = data;
1242
1243 memset( wfd, 0, sizeof(*wfd) );
1244 memcpy( wfd->cFileName, filename + HIWORD(device)/sizeof(WCHAR), LOWORD(device) );
1245 wfd->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE;
1246 CloseHandle( info->handle );
1247 info->handle = 0;
1248 }
1249 else
1250 {
1251 UNICODE_STRING mask_str;
1252
1253 RtlInitUnicodeString( &mask_str, mask );
1254 status = NtQueryDirectoryFile( info->handle, 0, NULL, NULL, &io, info->data, info->data_size,
1255 FileBothDirectoryInformation, FALSE, &mask_str, TRUE );
1256 if (status)
1257 {
1258 FindClose( info );
1259 SetLastError( RtlNtStatusToDosError( status ) );
1260 return INVALID_HANDLE_VALUE;
1261 }
1262
1263 info->data_len = io.Information;
1264 if (!has_wildcard) info->data_size = 0; /* we read everything */
1265
1266 if (!FindNextFileW( info, data ))
1267 {
1268 TRACE( "%s not found\n", debugstr_w(filename) );
1269 FindClose( info );
1270 SetLastError( ERROR_FILE_NOT_FOUND );
1271 return INVALID_HANDLE_VALUE;
1272 }
1273 if (!has_wildcard) /* we can't find two files with the same name */
1274 {
1275 CloseHandle( info->handle );
1276 info->handle = 0;
1277 }
1278 }
1279 return info;
1280
1281 error:
1282 HeapFree( GetProcessHeap(), 0, info );
1283 RtlFreeUnicodeString( &nt_name );
1284 return INVALID_HANDLE_VALUE;
1285 }
1286
1287
1288 /******************************************************************************
1289 * FindFirstFileA (kernelbase.@)
1290 */
1291 HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstFileA( const char *filename, WIN32_FIND_DATAA *data )
1292 {
1293 return FindFirstFileExA( filename, FindExInfoStandard, data, FindExSearchNameMatch, NULL, 0 );
1294 }
1295
1296
1297 /******************************************************************************
1298 * FindFirstFileW (kernelbase.@)
1299 */
1300 HANDLE WINAPI DECLSPEC_HOTPATCH FindFirstFileW( const WCHAR *filename, WIN32_FIND_DATAW *data )
1301 {
1302 return FindFirstFileExW( filename, FindExInfoStandard, data, FindExSearchNameMatch, NULL, 0 );
1303 }
1304
1305
1306 /**************************************************************************
1307 * FindFirstStreamW (kernelbase.@)
1308 */
1309 HANDLE WINAPI FindFirstStreamW( const WCHAR *filename, STREAM_INFO_LEVELS level, void *data, DWORD flags )
1310 {
1311 FIXME("(%s, %d, %p, %lx): stub!\n", debugstr_w(filename), level, data, flags);
1312 SetLastError( ERROR_HANDLE_EOF );
1313 return INVALID_HANDLE_VALUE;
1314 }
1315
1316
1317 /******************************************************************************
1318 * FindNextFileA (kernelbase.@)
1319 */
1320 BOOL WINAPI DECLSPEC_HOTPATCH FindNextFileA( HANDLE handle, WIN32_FIND_DATAA *data )
1321 {
1322 WIN32_FIND_DATAW dataW;
1323
1324 if (!FindNextFileW( handle, &dataW )) return FALSE;
1325 data->dwFileAttributes = dataW.dwFileAttributes;
1326 data->ftCreationTime = dataW.ftCreationTime;
1327 data->ftLastAccessTime = dataW.ftLastAccessTime;
1328 data->ftLastWriteTime = dataW.ftLastWriteTime;
1329 data->nFileSizeHigh = dataW.nFileSizeHigh;
1330 data->nFileSizeLow = dataW.nFileSizeLow;
1331 file_name_WtoA( dataW.cFileName, -1, data->cFileName, sizeof(data->cFileName) );
1332 file_name_WtoA( dataW.cAlternateFileName, -1, data->cAlternateFileName,
1333 sizeof(data->cAlternateFileName) );
1334 return TRUE;
1335 }
1336
1337
1338 /******************************************************************************
1339 * FindNextFileW (kernelbase.@)
1340 */
1341 BOOL WINAPI DECLSPEC_HOTPATCH FindNextFileW( HANDLE handle, WIN32_FIND_DATAW *data )
1342 {
1343 FIND_FIRST_INFO *info = handle;
1344 FILE_BOTH_DIR_INFORMATION *dir_info;
1345 BOOL ret = FALSE;
1346 NTSTATUS status;
1347
1348 TRACE( "%p %p\n", handle, data );
1349
1350 if (!handle || handle == INVALID_HANDLE_VALUE || info->magic != FIND_FIRST_MAGIC)
1351 {
1352 SetLastError( ERROR_INVALID_HANDLE );
1353 return ret;
1354 }
1355
1356 RtlEnterCriticalSection( &info->cs );
1357
1358 if (!info->handle) SetLastError( ERROR_NO_MORE_FILES );
1359 else for (;;)
1360 {
1361 if (info->data_pos >= info->data_len) /* need to read some more data */
1362 {
1363 IO_STATUS_BLOCK io;
1364
1365 if (info->data_size)
1366 status = NtQueryDirectoryFile( info->handle, 0, NULL, NULL, &io, info->data, info->data_size,
1367 FileBothDirectoryInformation, FALSE, NULL, FALSE );
1368 else
1369 status = STATUS_NO_MORE_FILES;
1370
1371 if (!set_ntstatus( status ))
1372 {
1373 if (status == STATUS_NO_MORE_FILES)
1374 {
1375 CloseHandle( info->handle );
1376 info->handle = 0;
1377 }
1378 break;
1379 }
1380 info->data_len = io.Information;
1381 info->data_pos = 0;
1382 }
1383
1384 dir_info = (FILE_BOTH_DIR_INFORMATION *)(info->data + info->data_pos);
1385
1386 if (dir_info->NextEntryOffset) info->data_pos += dir_info->NextEntryOffset;
1387 else info->data_pos = info->data_len;
1388
1389 /* don't return '.' and '..' in the root of the drive */
1390 if (info->is_root)
1391 {
1392 if (dir_info->FileNameLength == sizeof(WCHAR) && dir_info->FileName[0] == '.') continue;
1393 if (dir_info->FileNameLength == 2 * sizeof(WCHAR) &&
1394 dir_info->FileName[0] == '.' && dir_info->FileName[1] == '.') continue;
1395 }
1396
1397 data->dwFileAttributes = dir_info->FileAttributes;
1398 data->ftCreationTime = *(FILETIME *)&dir_info->CreationTime;
1399 data->ftLastAccessTime = *(FILETIME *)&dir_info->LastAccessTime;
1400 data->ftLastWriteTime = *(FILETIME *)&dir_info->LastWriteTime;
1401 data->nFileSizeHigh = dir_info->EndOfFile.QuadPart >> 32;
1402 data->nFileSizeLow = (DWORD)dir_info->EndOfFile.QuadPart;
1403 data->dwReserved0 = 0;
1404 data->dwReserved1 = 0;
1405
1406 memcpy( data->cFileName, dir_info->FileName, dir_info->FileNameLength );
1407 data->cFileName[dir_info->FileNameLength/sizeof(WCHAR)] = 0;
1408
1409 if (info->level != FindExInfoBasic)
1410 {
1411 memcpy( data->cAlternateFileName, dir_info->ShortName, dir_info->ShortNameLength );
1412 data->cAlternateFileName[dir_info->ShortNameLength/sizeof(WCHAR)] = 0;
1413 }
1414 else
1415 data->cAlternateFileName[0] = 0;
1416
1417 TRACE( "returning %s (%s)\n",
1418 debugstr_w(data->cFileName), debugstr_w(data->cAlternateFileName) );
1419
1420 ret = TRUE;
1421 break;
1422 }
1423
1424 RtlLeaveCriticalSection( &info->cs );
1425 return ret;
1426 }
1427
1428
1429 /**************************************************************************
1430 * FindNextStreamW (kernelbase.@)
1431 */
1432 BOOL WINAPI FindNextStreamW( HANDLE handle, void *data )
1433 {
1434 FIXME( "(%p, %p): stub!\n", handle, data );
1435 SetLastError( ERROR_HANDLE_EOF );
1436 return FALSE;
1437 }
1438
1439
1440 /******************************************************************************
1441 * FindClose (kernelbase.@)
1442 */
1443 BOOL WINAPI DECLSPEC_HOTPATCH FindClose( HANDLE handle )
1444 {
1445 FIND_FIRST_INFO *info = handle;
1446
1447 if (!handle || handle == INVALID_HANDLE_VALUE)
1448 {
1449 SetLastError( ERROR_INVALID_HANDLE );
1450 return FALSE;
1451 }
1452
1453 __TRY
1454 {
1455 if (info->magic == FIND_FIRST_MAGIC)
1456 {
1457 RtlEnterCriticalSection( &info->cs );
1458 if (info->magic == FIND_FIRST_MAGIC) /* in case someone else freed it in the meantime */
1459 {
1460 info->magic = 0;
1461 if (info->handle) CloseHandle( info->handle );
1462 info->handle = 0;
1463 RtlFreeUnicodeString( &info->path );
1464 info->data_pos = 0;
1465 info->data_len = 0;
1466 RtlLeaveCriticalSection( &info->cs );
1467 info->cs.DebugInfo->Spare[0] = 0;
1468 RtlDeleteCriticalSection( &info->cs );
1469 HeapFree( GetProcessHeap(), 0, info );
1470 }
1471 }
1472 }
1473 __EXCEPT_PAGE_FAULT
1474 {
1475 WARN( "illegal handle %p\n", handle );
1476 SetLastError( ERROR_INVALID_HANDLE );
1477 return FALSE;
1478 }
1479 __ENDTRY
1480
1481 return TRUE;
1482 }
1483
1484
1485 /******************************************************************************
1486 * GetCompressedFileSizeA (kernelbase.@)
1487 */
1488 DWORD WINAPI DECLSPEC_HOTPATCH GetCompressedFileSizeA( LPCSTR name, LPDWORD size_high )
1489 {
1490 WCHAR *nameW;
1491
1492 if (!(nameW = file_name_AtoW( name, FALSE ))) return INVALID_FILE_SIZE;
1493 return GetCompressedFileSizeW( nameW, size_high );
1494 }
1495
1496
1497 /******************************************************************************
1498 * GetCompressedFileSizeW (kernelbase.@)
1499 */
1500 DWORD WINAPI DECLSPEC_HOTPATCH GetCompressedFileSizeW( LPCWSTR name, LPDWORD size_high )
1501 {
1502 UNICODE_STRING nt_name;
1503 OBJECT_ATTRIBUTES attr;
1504 IO_STATUS_BLOCK io;
1505 NTSTATUS status;
1506 HANDLE handle;
1507 DWORD ret;
1508
1509 TRACE("%s %p\n", debugstr_w(name), size_high);
1510
1511 if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1512 {
1513 SetLastError( ERROR_PATH_NOT_FOUND );
1514 return INVALID_FILE_SIZE;
1515 }
1516
1517 attr.Length = sizeof(attr);
1518 attr.RootDirectory = 0;
1519 attr.Attributes = OBJ_CASE_INSENSITIVE;
1520 attr.ObjectName = &nt_name;
1521 attr.SecurityDescriptor = NULL;
1522 attr.SecurityQualityOfService = NULL;
1523
1524 status = NtOpenFile( &handle, SYNCHRONIZE, &attr, &io, 0, FILE_SYNCHRONOUS_IO_NONALERT );
1525 RtlFreeUnicodeString( &nt_name );
1526 if (!set_ntstatus( status )) return INVALID_FILE_SIZE;
1527
1528 /* we don't support compressed files, simply return the file size */
1529 ret = GetFileSize( handle, size_high );
1530 NtClose( handle );
1531 return ret;
1532 }
1533
1534
1535 /***********************************************************************
1536 * GetCurrentDirectoryA (kernelbase.@)
1537 */
1538 UINT WINAPI DECLSPEC_HOTPATCH GetCurrentDirectoryA( UINT buflen, LPSTR buf )
1539 {
1540 WCHAR bufferW[MAX_PATH];
1541 DWORD ret;
1542
1543 if (buflen && buf && ((ULONG_PTR)buf >> 16) == 0)
1544 {
1545 /* Win9x catches access violations here, returning zero.
1546 * This behaviour resulted in some people not noticing
1547 * that they got the argument order wrong. So let's be
1548 * nice and fail gracefully if buf is invalid and looks
1549 * more like a buflen. */
1550 SetLastError( ERROR_INVALID_PARAMETER );
1551 return 0;
1552 }
1553
1554 ret = RtlGetCurrentDirectory_U( sizeof(bufferW), bufferW );
1555 if (!ret) return 0;
1556 if (ret > sizeof(bufferW))
1557 {
1558 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1559 return 0;
1560 }
1561 return copy_filename_WtoA( bufferW, buf, buflen );
1562 }
1563
1564
1565 /***********************************************************************
1566 * GetCurrentDirectoryW (kernelbase.@)
1567 */
1568 UINT WINAPI DECLSPEC_HOTPATCH GetCurrentDirectoryW( UINT buflen, LPWSTR buf )
1569 {
1570 return RtlGetCurrentDirectory_U( buflen * sizeof(WCHAR), buf ) / sizeof(WCHAR);
1571 }
1572
1573
1574 /**************************************************************************
1575 * GetFileAttributesA (kernelbase.@)
1576 */
1577 DWORD WINAPI DECLSPEC_HOTPATCH GetFileAttributesA( LPCSTR name )
1578 {
1579 WCHAR *nameW;
1580
1581 if (!(nameW = file_name_AtoW( name, FALSE ))) return INVALID_FILE_ATTRIBUTES;
1582 return GetFileAttributesW( nameW );
1583 }
1584
1585
1586 /**************************************************************************
1587 * GetFileAttributesW (kernelbase.@)
1588 */
1589 DWORD WINAPI DECLSPEC_HOTPATCH GetFileAttributesW( LPCWSTR name )
1590 {
1591 FILE_BASIC_INFORMATION info;
1592 UNICODE_STRING nt_name;
1593 OBJECT_ATTRIBUTES attr;
1594 NTSTATUS status;
1595
1596 TRACE( "%s\n", debugstr_w(name) );
1597
1598 if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1599 {
1600 SetLastError( ERROR_PATH_NOT_FOUND );
1601 return INVALID_FILE_ATTRIBUTES;
1602 }
1603
1604 attr.Length = sizeof(attr);
1605 attr.RootDirectory = 0;
1606 attr.Attributes = OBJ_CASE_INSENSITIVE;
1607 attr.ObjectName = &nt_name;
1608 attr.SecurityDescriptor = NULL;
1609 attr.SecurityQualityOfService = NULL;
1610
1611 status = NtQueryAttributesFile( &attr, &info );
1612 RtlFreeUnicodeString( &nt_name );
1613
1614 if (status == STATUS_SUCCESS) return info.FileAttributes;
1615
1616 /* NtQueryAttributesFile fails on devices, but GetFileAttributesW succeeds */
1617 if (RtlIsDosDeviceName_U( name )) return FILE_ATTRIBUTE_ARCHIVE;
1618
1619 SetLastError( RtlNtStatusToDosError(status) );
1620 return INVALID_FILE_ATTRIBUTES;
1621 }
1622
1623
1624 /**************************************************************************
1625 * GetFileAttributesExA (kernelbase.@)
1626 */
1627 BOOL WINAPI DECLSPEC_HOTPATCH GetFileAttributesExA( LPCSTR name, GET_FILEEX_INFO_LEVELS level, void *ptr )
1628 {
1629 WCHAR *nameW;
1630
1631 if (!(nameW = file_name_AtoW( name, FALSE ))) return FALSE;
1632 return GetFileAttributesExW( nameW, level, ptr );
1633 }
1634
1635
1636 /**************************************************************************
1637 * GetFileAttributesExW (kernelbase.@)
1638 */
1639 BOOL WINAPI DECLSPEC_HOTPATCH GetFileAttributesExW( LPCWSTR name, GET_FILEEX_INFO_LEVELS level, void *ptr )
1640 {
1641 FILE_NETWORK_OPEN_INFORMATION info;
1642 WIN32_FILE_ATTRIBUTE_DATA *data = ptr;
1643 UNICODE_STRING nt_name;
1644 OBJECT_ATTRIBUTES attr;
1645 NTSTATUS status;
1646
1647 TRACE("%s %d %p\n", debugstr_w(name), level, ptr);
1648
1649 if (level != GetFileExInfoStandard)
1650 {
1651 SetLastError( ERROR_INVALID_PARAMETER );
1652 return FALSE;
1653 }
1654
1655 if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
1656 {
1657 SetLastError( ERROR_PATH_NOT_FOUND );
1658 return FALSE;
1659 }
1660
1661 attr.Length = sizeof(attr);
1662 attr.RootDirectory = 0;
1663 attr.Attributes = OBJ_CASE_INSENSITIVE;
1664 attr.ObjectName = &nt_name;
1665 attr.SecurityDescriptor = NULL;
1666 attr.SecurityQualityOfService = NULL;
1667
1668 status = NtQueryFullAttributesFile( &attr, &info );
1669 RtlFreeUnicodeString( &nt_name );
1670 if (!set_ntstatus( status )) return FALSE;
1671
1672 data->dwFileAttributes = info.FileAttributes;
1673 data->ftCreationTime.dwLowDateTime = info.CreationTime.u.LowPart;
1674 data->ftCreationTime.dwHighDateTime = info.CreationTime.u.HighPart;
1675 data->ftLastAccessTime.dwLowDateTime = info.LastAccessTime.u.LowPart;
1676 data->ftLastAccessTime.dwHighDateTime = info.LastAccessTime.u.HighPart;
1677 data->ftLastWriteTime.dwLowDateTime = info.LastWriteTime.u.LowPart;
1678 data->ftLastWriteTime.dwHighDateTime = info.LastWriteTime.u.HighPart;
1679 data->nFileSizeLow = info.EndOfFile.u.LowPart;
1680 data->nFileSizeHigh = info.EndOfFile.u.HighPart;
1681 return TRUE;
1682 }
1683
1684
1685 /***********************************************************************
1686 * GetFinalPathNameByHandleA (kernelbase.@)
1687 */
1688 DWORD WINAPI DECLSPEC_HOTPATCH GetFinalPathNameByHandleA( HANDLE file, LPSTR path,
1689 DWORD count, DWORD flags )
1690 {
1691 WCHAR *str;
1692 DWORD result, len;
1693
1694 TRACE( "(%p,%p,%ld,%lx)\n", file, path, count, flags);
1695
1696 len = GetFinalPathNameByHandleW(file, NULL, 0, flags);
1697 if (len == 0) return 0;
1698
1699 str = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1700 if (!str)
1701 {
1702 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1703 return 0;
1704 }
1705
1706 result = GetFinalPathNameByHandleW(file, str, len, flags);
1707 if (result != len - 1)
1708 {
1709 HeapFree(GetProcessHeap(), 0, str);
1710 return 0;
1711 }
1712
1713 len = file_name_WtoA( str, -1, NULL, 0 );
1714 if (count < len)
1715 {
1716 HeapFree(GetProcessHeap(), 0, str);
1717 return len - 1;
1718 }
1719 file_name_WtoA( str, -1, path, count );
1720 HeapFree(GetProcessHeap(), 0, str);
1721 return len - 1;
1722 }
1723
1724
1725 /***********************************************************************
1726 * GetFinalPathNameByHandleW (kernelbase.@)
1727 */
1728 DWORD WINAPI DECLSPEC_HOTPATCH GetFinalPathNameByHandleW( HANDLE file, LPWSTR path,
1729 DWORD count, DWORD flags )
1730 {
1731 WCHAR buffer[sizeof(OBJECT_NAME_INFORMATION) + MAX_PATH + 1];
1732 OBJECT_NAME_INFORMATION *info = (OBJECT_NAME_INFORMATION*)&buffer;
1733 WCHAR drive_part[MAX_PATH];
1734 DWORD drive_part_len = 0;
1735 NTSTATUS status;
1736 DWORD result = 0;
1737 ULONG dummy;
1738 WCHAR *ptr;
1739
1740 TRACE( "(%p,%p,%ld,%lx)\n", file, path, count, flags );
1741
1742 if (flags & ~(FILE_NAME_OPENED | VOLUME_NAME_GUID | VOLUME_NAME_NONE | VOLUME_NAME_NT))
1743 {
1744 WARN("Unknown flags: %lx\n", flags);
1745 SetLastError( ERROR_INVALID_PARAMETER );
1746 return 0;
1747 }
1748
1749 /* get object name */
1750 status = NtQueryObject( file, ObjectNameInformation, &buffer, sizeof(buffer) - sizeof(WCHAR), &dummy );
1751 if (!set_ntstatus( status )) return 0;
1752
1753 if (!info->Name.Buffer)
1754 {
1755 SetLastError( ERROR_INVALID_HANDLE );
1756 return 0;
1757 }
1758 if (info->Name.Length < 4 * sizeof(WCHAR) || info->Name.Buffer[0] != '\\' ||
1759 info->Name.Buffer[1] != '?' || info->Name.Buffer[2] != '?' || info->Name.Buffer[3] != '\\' )
1760 {
1761 FIXME("Unexpected object name: %s\n", debugstr_wn(info->Name.Buffer, info->Name.Length / sizeof(WCHAR)));
1762 SetLastError( ERROR_GEN_FAILURE );
1763 return 0;
1764 }
1765
1766 /* add terminating null character, remove "\\??\\" */
1767 info->Name.Buffer[info->Name.Length / sizeof(WCHAR)] = 0;
1768 info->Name.Length -= 4 * sizeof(WCHAR);
1769 info->Name.Buffer += 4;
1770
1771 /* FILE_NAME_OPENED is not supported yet, and would require Wineserver changes */
1772 if (flags & FILE_NAME_OPENED)
1773 {
1774 FIXME("FILE_NAME_OPENED not supported\n");
1775 flags &= ~FILE_NAME_OPENED;
1776 }
1777
1778 /* Get information required for VOLUME_NAME_NONE, VOLUME_NAME_GUID and VOLUME_NAME_NT */
1779 if (flags == VOLUME_NAME_NONE || flags == VOLUME_NAME_GUID || flags == VOLUME_NAME_NT)
1780 {
1781 if (!GetVolumePathNameW( info->Name.Buffer, drive_part, MAX_PATH )) return 0;
1782 drive_part_len = lstrlenW(drive_part);
1783 if (!drive_part_len || drive_part_len > lstrlenW(info->Name.Buffer) ||
1784 drive_part[drive_part_len-1] != '\\' ||
1785 CompareStringOrdinal( info->Name.Buffer, drive_part_len, drive_part, drive_part_len, TRUE ) != CSTR_EQUAL)
1786 {
1787 FIXME( "Path %s returned by GetVolumePathNameW does not match file path %s\n",
1788 debugstr_w(drive_part), debugstr_w(info->Name.Buffer) );
1789 SetLastError( ERROR_GEN_FAILURE );
1790 return 0;
1791 }
1792 }
1793
1794 if (flags == VOLUME_NAME_NONE)
1795 {
1796 ptr = info->Name.Buffer + drive_part_len - 1;
1797 result = lstrlenW(ptr);
1798 if (result < count) memcpy(path, ptr, (result + 1) * sizeof(WCHAR));
1799 else result++;
1800 }
1801 else if (flags == VOLUME_NAME_GUID)
1802 {
1803 WCHAR volume_prefix[51];
1804
1805 /* GetVolumeNameForVolumeMountPointW sets error code on failure */
1806 if (!GetVolumeNameForVolumeMountPointW( drive_part, volume_prefix, 50 )) return 0;
1807 ptr = info->Name.Buffer + drive_part_len;
1808 result = lstrlenW(volume_prefix) + lstrlenW(ptr);
1809 if (result < count)
1810 {
1811 lstrcpyW(path, volume_prefix);
1812 lstrcatW(path, ptr);
1813 }
1814 else
1815 {
1816 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1817 result++;
1818 }
1819 }
1820 else if (flags == VOLUME_NAME_NT)
1821 {
1822 WCHAR nt_prefix[MAX_PATH];
1823
1824 /* QueryDosDeviceW sets error code on failure */
1825 drive_part[drive_part_len - 1] = 0;
1826 if (!QueryDosDeviceW( drive_part, nt_prefix, MAX_PATH )) return 0;
1827 ptr = info->Name.Buffer + drive_part_len - 1;
1828 result = lstrlenW(nt_prefix) + lstrlenW(ptr);
1829 if (result < count)
1830 {
1831 lstrcpyW(path, nt_prefix);
1832 lstrcatW(path, ptr);
1833 }
1834 else
1835 {
1836 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1837 result++;
1838 }
1839 }
1840 else if (flags == VOLUME_NAME_DOS)
1841 {
1842 result = 4 + lstrlenW(info->Name.Buffer);
1843 if (result < count)
1844 {
1845 lstrcpyW(path, L"\\\\?\\");
1846 lstrcatW(path, info->Name.Buffer);
1847 }
1848 else
1849 {
1850 SetLastError(ERROR_NOT_ENOUGH_MEMORY);
1851 result++;
1852 }
1853 }
1854 else
1855 {
1856 /* Windows crashes here, but we prefer returning ERROR_INVALID_PARAMETER */
1857 WARN("Invalid combination of flags: %lx\n", flags);
1858 SetLastError( ERROR_INVALID_PARAMETER );
1859 }
1860 return result;
1861 }
1862
1863
1864 /***********************************************************************
1865 * GetFullPathNameA (kernelbase.@)
1866 */
1867 DWORD WINAPI DECLSPEC_HOTPATCH GetFullPathNameA( LPCSTR name, DWORD len, LPSTR buffer, LPSTR *lastpart )
1868 {
1869 WCHAR *nameW;
1870 WCHAR bufferW[MAX_PATH], *lastpartW = NULL;
1871 DWORD ret;
1872
1873 if (!(nameW = file_name_AtoW( name, FALSE ))) return 0;
1874
1875 ret = GetFullPathNameW( nameW, MAX_PATH, bufferW, &lastpartW );
1876
1877 if (!ret) return 0;
1878 if (ret > MAX_PATH)
1879 {
1880 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1881 return 0;
1882 }
1883 ret = copy_filename_WtoA( bufferW, buffer, len );
1884 if (ret < len && lastpart)
1885 {
1886 if (lastpartW)
1887 *lastpart = buffer + file_name_WtoA( bufferW, lastpartW - bufferW, NULL, 0 );
1888 else
1889 *lastpart = NULL;
1890 }
1891 return ret;
1892 }
1893
1894
1895 /***********************************************************************
1896 * GetFullPathNameW (kernelbase.@)
1897 */
1898 DWORD WINAPI DECLSPEC_HOTPATCH GetFullPathNameW( LPCWSTR name, DWORD len, LPWSTR buffer, LPWSTR *lastpart )
1899 {
1900 return RtlGetFullPathName_U( name, len * sizeof(WCHAR), buffer, lastpart ) / sizeof(WCHAR);
1901 }
1902
1903
1904 /***********************************************************************
1905 * GetLongPathNameA (kernelbase.@)
1906 */
1907 DWORD WINAPI DECLSPEC_HOTPATCH GetLongPathNameA( LPCSTR shortpath, LPSTR longpath, DWORD longlen )
1908 {
1909 WCHAR *shortpathW;
1910 WCHAR longpathW[MAX_PATH];
1911 DWORD ret;
1912
1913 TRACE( "%s\n", debugstr_a( shortpath ));
1914
1915 if (!(shortpathW = file_name_AtoW( shortpath, FALSE ))) return 0;
1916
1917 ret = GetLongPathNameW( shortpathW, longpathW, MAX_PATH );
1918
1919 if (!ret) return 0;
1920 if (ret > MAX_PATH)
1921 {
1922 SetLastError( ERROR_FILENAME_EXCED_RANGE );
1923 return 0;
1924 }
1925 return copy_filename_WtoA( longpathW, longpath, longlen );
1926 }
1927
1928
1929 /***********************************************************************
1930 * GetLongPathNameW (kernelbase.@)
1931 */
1932 DWORD WINAPI DECLSPEC_HOTPATCH GetLongPathNameW( LPCWSTR shortpath, LPWSTR longpath, DWORD longlen )
1933 {
1934 WCHAR tmplongpath[1024];
1935 DWORD sp = 0, lp = 0, tmplen;
1936 WIN32_FIND_DATAW wfd;
1937 UNICODE_STRING nameW;
1938 LPCWSTR p;
1939 HANDLE handle;
1940
1941 TRACE("%s,%p,%lu\n", debugstr_w(shortpath), longpath, longlen);
1942
1943 if (!shortpath)
1944 {
1945 SetLastError( ERROR_INVALID_PARAMETER );
1946 return 0;
1947 }
1948 if (!shortpath[0])
1949 {
1950 SetLastError( ERROR_PATH_NOT_FOUND );
1951 return 0;
1952 }
1953
1954 if (shortpath[0] == '\\' && shortpath[1] == '\\')
1955 {
1956 FIXME( "UNC pathname %s\n", debugstr_w(shortpath) );
1957 tmplen = lstrlenW( shortpath );
1958 if (tmplen < longlen)
1959 {
1960 if (longpath != shortpath) lstrcpyW( longpath, shortpath );
1961 return tmplen;
1962 }
1963 return tmplen + 1;
1964 }
1965
1966 /* check for drive letter */
1967 if (shortpath[0] != '/' && shortpath[1] == ':' )
1968 {
1969 tmplongpath[0] = shortpath[0];
1970 tmplongpath[1] = ':';
1971 lp = sp = 2;
1972 }
1973
1974 if (wcspbrk( shortpath + sp, L"*?" ))
1975 {
1976 SetLastError( ERROR_INVALID_NAME );
1977 return 0;
1978 }
1979
1980 while (shortpath[sp])
1981 {
1982 /* check for path delimiters and reproduce them */
1983 if (shortpath[sp] == '\\' || shortpath[sp] == '/')
1984 {
1985 tmplongpath[lp++] = shortpath[sp++];
1986 tmplongpath[lp] = 0; /* terminate string */
1987 continue;
1988 }
1989
1990 for (p = shortpath + sp; *p && *p != '/' && *p != '\\'; p++);
1991 tmplen = p - (shortpath + sp);
1992 lstrcpynW( tmplongpath + lp, shortpath + sp, tmplen + 1 );
1993
1994 if (tmplongpath[lp] == '.')
1995 {
1996 if (tmplen == 1 || (tmplen == 2 && tmplongpath[lp + 1] == '.'))
1997 {
1998 lp += tmplen;
1999 sp += tmplen;
2000 continue;
2001 }
2002 }
2003
2004 /* Check if the file exists */
2005 handle = FindFirstFileW( tmplongpath, &wfd );
2006 if (handle == INVALID_HANDLE_VALUE)
2007 {
2008 TRACE( "not found %s\n", debugstr_w( tmplongpath ));
2009 SetLastError ( ERROR_FILE_NOT_FOUND );
2010 return 0;
2011 }
2012 FindClose( handle );
2013
2014 /* Use the existing file name if it's a short name */
2015 RtlInitUnicodeString( &nameW, tmplongpath + lp );
2016 if (RtlIsNameLegalDOS8Dot3( &nameW, NULL, NULL )) lstrcpyW( tmplongpath + lp, wfd.cFileName );
2017 lp += lstrlenW( tmplongpath + lp );
2018 sp += tmplen;
2019 }
2020 tmplen = lstrlenW( shortpath ) - 1;
2021 if ((shortpath[tmplen] == '/' || shortpath[tmplen] == '\\') &&
2022 (tmplongpath[lp - 1] != '/' && tmplongpath[lp - 1] != '\\'))
2023 tmplongpath[lp++] = shortpath[tmplen];
2024 tmplongpath[lp] = 0;
2025
2026 tmplen = lstrlenW( tmplongpath ) + 1;
2027 if (tmplen <= longlen)
2028 {
2029 lstrcpyW( longpath, tmplongpath );
2030 TRACE("returning %s\n", debugstr_w( longpath ));
2031 tmplen--; /* length without 0 */
2032 }
2033 return tmplen;
2034 }
2035
2036
2037 /***********************************************************************
2038 * GetShortPathNameW (kernelbase.@)
2039 */
2040 DWORD WINAPI DECLSPEC_HOTPATCH GetShortPathNameW( LPCWSTR longpath, LPWSTR shortpath, DWORD shortlen )
2041 {
2042 WIN32_FIND_DATAW wfd;
2043 WCHAR *tmpshortpath;
2044 HANDLE handle;
2045 LPCWSTR p;
2046 DWORD sp = 0, lp = 0, tmplen, buf_len;
2047
2048 TRACE( "%s,%p,%lu\n", debugstr_w(longpath), shortpath, shortlen );
2049
2050 if (!longpath)
2051 {
2052 SetLastError( ERROR_INVALID_PARAMETER );
2053 return 0;
2054 }
2055 if (!longpath[0])
2056 {
2057 SetLastError( ERROR_BAD_PATHNAME );
2058 return 0;
2059 }
2060
2061 /* code below only removes characters from string, never adds, so this is
2062 * the largest buffer that tmpshortpath will need to have */
2063 buf_len = lstrlenW(longpath) + 1;
2064 tmpshortpath = HeapAlloc( GetProcessHeap(), 0, buf_len * sizeof(WCHAR) );
2065 if (!tmpshortpath)
2066 {
2067 SetLastError( ERROR_OUTOFMEMORY );
2068 return 0;
2069 }
2070
2071 if (longpath[0] == '\\' && longpath[1] == '\\' && longpath[2] == '?' && longpath[3] == '\\')
2072 {
2073 memcpy( tmpshortpath, longpath, 4 * sizeof(WCHAR) );
2074 sp = lp = 4;
2075 }
2076
2077 if (wcspbrk( longpath + lp, L"*?" ))
2078 {
2079 HeapFree( GetProcessHeap(), 0, tmpshortpath );
2080 SetLastError( ERROR_INVALID_NAME );
2081 return 0;
2082 }
2083
2084 /* check for drive letter */
2085 if (longpath[lp] != '/' && longpath[lp + 1] == ':' )
2086 {
2087 tmpshortpath[sp] = longpath[lp];
2088 tmpshortpath[sp + 1] = ':';
2089 sp += 2;
2090 lp += 2;
2091 }
2092
2093 while (longpath[lp])
2094 {
2095 /* check for path delimiters and reproduce them */
2096 if (longpath[lp] == '\\' || longpath[lp] == '/')
2097 {
2098 tmpshortpath[sp++] = longpath[lp++];
2099 tmpshortpath[sp] = 0; /* terminate string */
2100 continue;
2101 }
2102
2103 p = longpath + lp;
2104 for (; *p && *p != '/' && *p != '\\'; p++);
2105 tmplen = p - (longpath + lp);
2106 lstrcpynW( tmpshortpath + sp, longpath + lp, tmplen + 1 );
2107
2108 if (tmpshortpath[sp] == '.')
2109 {
2110 if (tmplen == 1 || (tmplen == 2 && tmpshortpath[sp + 1] == '.'))
2111 {
2112 sp += tmplen;
2113 lp += tmplen;
2114 continue;
2115 }
2116 }
2117
2118 /* Check if the file exists and use the existing short file name */
2119 handle = FindFirstFileW( tmpshortpath, &wfd );
2120 if (handle == INVALID_HANDLE_VALUE) goto notfound;
2121 FindClose( handle );
2122
2123 /* In rare cases (like "a.abcd") short path may be longer than original path.
2124 * Make sure we have enough space in temp buffer. */
2125 if (wfd.cAlternateFileName[0] && tmplen < lstrlenW(wfd.cAlternateFileName))
2126 {
2127 WCHAR *new_buf;
2128 buf_len += lstrlenW( wfd.cAlternateFileName ) - tmplen;
2129 new_buf = HeapReAlloc( GetProcessHeap(), 0, tmpshortpath, buf_len * sizeof(WCHAR) );
2130 if(!new_buf)
2131 {
2132 HeapFree( GetProcessHeap(), 0, tmpshortpath );
2133 SetLastError( ERROR_OUTOFMEMORY );
2134 return 0;
2135 }
2136 tmpshortpath = new_buf;
2137 }
2138
2139 lstrcpyW( tmpshortpath + sp, wfd.cAlternateFileName[0] ? wfd.cAlternateFileName : wfd.cFileName );
2140 sp += lstrlenW( tmpshortpath + sp );
2141 lp += tmplen;
2142 }
2143 tmpshortpath[sp] = 0;
2144
2145 tmplen = lstrlenW( tmpshortpath ) + 1;
2146 if (tmplen <= shortlen)
2147 {
2148 lstrcpyW( shortpath, tmpshortpath );
2149 TRACE( "returning %s\n", debugstr_w( shortpath ));
2150 tmplen--; /* length without 0 */
2151 }
2152
2153 HeapFree( GetProcessHeap(), 0, tmpshortpath );
2154 return tmplen;
2155
2156 notfound:
2157 HeapFree( GetProcessHeap(), 0, tmpshortpath );
2158 TRACE( "not found\n" );
2159 SetLastError( ERROR_FILE_NOT_FOUND );
2160 return 0;
2161 }
2162
2163
2164 /***********************************************************************
2165 * GetSystemDirectoryA (kernelbase.@)
2166 */
2167 UINT WINAPI DECLSPEC_HOTPATCH GetSystemDirectoryA( LPSTR path, UINT count )
2168 {
2169 return copy_filename_WtoA( system_dir, path, count );
2170 }
2171
2172
2173 /***********************************************************************
2174 * GetSystemDirectoryW (kernelbase.@)
2175 */
2176 UINT WINAPI DECLSPEC_HOTPATCH GetSystemDirectoryW( LPWSTR path, UINT count )
2177 {
2178 return copy_filename( system_dir, path, count );
2179 }
2180
2181
2182 /***********************************************************************
2183 * GetSystemWindowsDirectoryA (kernelbase.@)
2184 */
2185 UINT WINAPI DECLSPEC_HOTPATCH GetSystemWindowsDirectoryA( LPSTR path, UINT count )
2186 {
2187 return GetWindowsDirectoryA( path, count );
2188 }
2189
2190
2191 /***********************************************************************
2192 * GetSystemWindowsDirectoryW (kernelbase.@)
2193 */
2194 UINT WINAPI DECLSPEC_HOTPATCH GetSystemWindowsDirectoryW( LPWSTR path, UINT count )
2195 {
2196 return GetWindowsDirectoryW( path, count );
2197 }
2198
2199
2200 /***********************************************************************
2201 * GetSystemWow64DirectoryA (kernelbase.@)
2202 */
2203 UINT WINAPI /* DECLSPEC_HOTPATCH */ GetSystemWow64DirectoryA( LPSTR path, UINT count )
2204 {
2205 if (!is_win64 && !is_wow64)
2206 {
2207 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
2208 return 0;
2209 }
2210 return copy_filename_WtoA( get_machine_wow64_dir( IMAGE_FILE_MACHINE_I386 ), path, count );
2211 }
2212
2213
2214 /***********************************************************************
2215 * GetSystemWow64DirectoryW (kernelbase.@)
2216 */
2217 UINT WINAPI /* DECLSPEC_HOTPATCH */ GetSystemWow64DirectoryW( LPWSTR path, UINT count )
2218 {
2219 if (!is_win64 && !is_wow64)
2220 {
2221 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
2222 return 0;
2223 }
2224 return copy_filename( get_machine_wow64_dir( IMAGE_FILE_MACHINE_I386 ), path, count );
2225 }
2226
2227
2228 /***********************************************************************
2229 * GetSystemWow64Directory2A (kernelbase.@)
2230 */
2231 UINT WINAPI DECLSPEC_HOTPATCH GetSystemWow64Directory2A( LPSTR path, UINT count, WORD machine )
2232 {
2233 const WCHAR *dir = get_machine_wow64_dir( machine );
2234
2235 return dir ? copy_filename_WtoA( dir, path, count ) : 0;
2236 }
2237
2238
2239 /***********************************************************************
2240 * GetSystemWow64Directory2W (kernelbase.@)
2241 */
2242 UINT WINAPI DECLSPEC_HOTPATCH GetSystemWow64Directory2W( LPWSTR path, UINT count, WORD machine )
2243 {
2244 const WCHAR *dir = get_machine_wow64_dir( machine );
2245
2246 return dir ? copy_filename( dir, path, count ) : 0;
2247 }
2248
2249
2250 /***********************************************************************
2251 * GetTempFileNameA (kernelbase.@)
2252 */
2253 UINT WINAPI DECLSPEC_HOTPATCH GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique, LPSTR buffer )
2254 {
2255 WCHAR *pathW, *prefixW = NULL;
2256 WCHAR bufferW[MAX_PATH];
2257 UINT ret;
2258
2259 if (!(pathW = file_name_AtoW( path, FALSE ))) return 0;
2260 if (prefix && !(prefixW = file_name_AtoW( prefix, TRUE ))) return 0;
2261
2262 ret = GetTempFileNameW( pathW, prefixW, unique, bufferW );
2263 if (ret) file_name_WtoA( bufferW, -1, buffer, MAX_PATH );
2264
2265 HeapFree( GetProcessHeap(), 0, prefixW );
2266 return ret;
2267 }
2268
2269
2270 /***********************************************************************
2271 * GetTempFileNameW (kernelbase.@)
2272 */
2273 UINT WINAPI DECLSPEC_HOTPATCH GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique, LPWSTR buffer )
2274 {
2275 int i;
2276 LPWSTR p;
2277 DWORD attr;
2278
2279 if (!path || !buffer)
2280 {
2281 SetLastError( ERROR_INVALID_PARAMETER );
2282 return 0;
2283 }
2284
2285 /* ensure that the provided directory exists */
2286 attr = GetFileAttributesW( path );
2287 if (attr == INVALID_FILE_ATTRIBUTES || !(attr & FILE_ATTRIBUTE_DIRECTORY))
2288 {
2289 TRACE( "path not found %s\n", debugstr_w( path ));
2290 SetLastError( ERROR_DIRECTORY );
2291 return 0;
2292 }
2293
2294 lstrcpyW( buffer, path );
2295 p = buffer + lstrlenW(buffer);
2296
2297 /* add a \, if there isn't one */
2298 if ((p == buffer) || (p[-1] != '\\')) *p++ = '\\';
2299
2300 if (prefix) for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
2301
2302 unique &= 0xffff;
2303 if (unique) swprintf( p, MAX_PATH - (p - buffer), L"%x.tmp", unique );
2304 else
2305 {
2306 /* get a "random" unique number and try to create the file */
2307 HANDLE handle;
2308 UINT num = NtGetTickCount() & 0xffff;
2309 static UINT last;
2310
2311 /* avoid using the same name twice in a short interval */
2312 if (last - num < 10) num = last + 1;
2313 if (!num) num = 1;
2314 unique = num;
2315 do
2316 {
2317 swprintf( p, MAX_PATH - (p - buffer), L"%x.tmp", unique );
2318 handle = CreateFileW( buffer, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
2319 if (handle != INVALID_HANDLE_VALUE)
2320 { /* We created it */
2321 CloseHandle( handle );
2322 last = unique;
2323 break;
2324 }
2325 if (GetLastError() != ERROR_FILE_EXISTS && GetLastError() != ERROR_SHARING_VIOLATION)
2326 break; /* No need to go on */
2327 if (!(++unique & 0xffff)) unique = 1;
2328 } while (unique != num);
2329 }
2330 TRACE( "returning %s\n", debugstr_w( buffer ));
2331 return unique;
2332 }
2333
2334
2335 /***********************************************************************
2336 * GetTempPathA (kernelbase.@)
2337 */
2338 DWORD WINAPI DECLSPEC_HOTPATCH GetTempPathA( DWORD count, LPSTR path )
2339 {
2340 WCHAR pathW[MAX_PATH];
2341 UINT ret;
2342
2343 if (!(ret = GetTempPathW( MAX_PATH, pathW ))) return 0;
2344 if (ret > MAX_PATH)
2345 {
2346 SetLastError( ERROR_FILENAME_EXCED_RANGE );
2347 return 0;
2348 }
2349 return copy_filename_WtoA( pathW, path, count );
2350 }
2351
2352
2353 /***********************************************************************
2354 * GetTempPathW (kernelbase.@)
2355 */
2356 DWORD WINAPI DECLSPEC_HOTPATCH GetTempPathW( DWORD count, LPWSTR path )
2357 {
2358 WCHAR tmp_path[MAX_PATH];
2359 UINT ret;
2360
2361 if (!(ret = GetEnvironmentVariableW( L"TMP", tmp_path, MAX_PATH )) &&
2362 !(ret = GetEnvironmentVariableW( L"TEMP", tmp_path, MAX_PATH )) &&
2363 !(ret = GetEnvironmentVariableW( L"USERPROFILE", tmp_path, MAX_PATH )) &&
2364 !(ret = GetWindowsDirectoryW( tmp_path, MAX_PATH )))
2365 return 0;
2366
2367 if (ret > MAX_PATH)
2368 {
2369 SetLastError( ERROR_FILENAME_EXCED_RANGE );
2370 return 0;
2371 }
2372 ret = GetFullPathNameW( tmp_path, MAX_PATH, tmp_path, NULL );
2373 if (!ret) return 0;
2374
2375 if (ret > MAX_PATH - 2)
2376 {
2377 SetLastError( ERROR_FILENAME_EXCED_RANGE );
2378 return 0;
2379 }
2380 if (tmp_path[ret-1] != '\\')
2381 {
2382 tmp_path[ret++] = '\\';
2383 tmp_path[ret] = '\0';
2384 }
2385
2386 ret++; /* add space for terminating 0 */
2387 if (count >= ret)
2388 {
2389 lstrcpynW( path, tmp_path, count );
2390 /* the remaining buffer must be zeroed up to 32766 bytes in XP or 32767
2391 * bytes after it, we will assume the > XP behavior for now */
2392 memset( path + ret, 0, (min(count, 32767) - ret) * sizeof(WCHAR) );
2393 ret--; /* return length without 0 */
2394 }
2395 else if (count)
2396 {
2397 /* the buffer must be cleared if contents will not fit */
2398 memset( path, 0, count * sizeof(WCHAR) );
2399 }
2400
2401 TRACE( "returning %u, %s\n", ret, debugstr_w( path ));
2402 return ret;
2403 }
2404
2405
2406 /***********************************************************************
2407 * GetWindowsDirectoryA (kernelbase.@)
2408 */
2409 UINT WINAPI DECLSPEC_HOTPATCH GetWindowsDirectoryA( LPSTR path, UINT count )
2410 {
2411 return copy_filename_WtoA( windows_dir, path, count );
2412 }
2413
2414
2415 /***********************************************************************
2416 * GetWindowsDirectoryW (kernelbase.@)
2417 */
2418 UINT WINAPI DECLSPEC_HOTPATCH GetWindowsDirectoryW( LPWSTR path, UINT count )
2419 {
2420 return copy_filename( windows_dir, path, count );
2421 }
2422
2423
2424 /**************************************************************************
2425 * MoveFileExW (kernelbase.@)
2426 */
2427 BOOL WINAPI MoveFileExW( const WCHAR *source, const WCHAR *dest, DWORD flag )
2428 {
2429 return MoveFileWithProgressW( source, dest, NULL, NULL, flag );
2430 }
2431
2432
2433 /**************************************************************************
2434 * MoveFileWithProgressW (kernelbase.@)
2435 */
2436 BOOL WINAPI DECLSPEC_HOTPATCH MoveFileWithProgressW( const WCHAR *source, const WCHAR *dest,
2437 LPPROGRESS_ROUTINE progress,
2438 void *param, DWORD flag )
2439 {
2440 FILE_RENAME_INFORMATION *rename_info;
2441 FILE_BASIC_INFORMATION info;
2442 UNICODE_STRING nt_name;
2443 OBJECT_ATTRIBUTES attr;
2444 IO_STATUS_BLOCK io;
2445 NTSTATUS status;
2446 HANDLE source_handle = 0;
2447 ULONG size;
2448
2449 TRACE( "(%s,%s,%p,%p,%04lx)\n", debugstr_w(source), debugstr_w(dest), progress, param, flag );
2450
2451 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT) return add_boot_rename_entry( source, dest, flag );
2452
2453 if (!dest) return DeleteFileW( source );
2454
2455 /* check if we are allowed to rename the source */
2456
2457 if (!RtlDosPathNameToNtPathName_U( source, &nt_name, NULL, NULL ))
2458 {
2459 SetLastError( ERROR_PATH_NOT_FOUND );
2460 return FALSE;
2461 }
2462 attr.Length = sizeof(attr);
2463 attr.RootDirectory = 0;
2464 attr.Attributes = OBJ_CASE_INSENSITIVE;
2465 attr.ObjectName = &nt_name;
2466 attr.SecurityDescriptor = NULL;
2467 attr.SecurityQualityOfService = NULL;
2468
2469 status = NtOpenFile( &source_handle, DELETE | SYNCHRONIZE, &attr, &io,
2470 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
2471 FILE_SYNCHRONOUS_IO_NONALERT );
2472 RtlFreeUnicodeString( &nt_name );
2473 if (!set_ntstatus( status )) goto error;
2474
2475 status = NtQueryInformationFile( source_handle, &io, &info, sizeof(info), FileBasicInformation );
2476 if (!set_ntstatus( status )) goto error;
2477
2478 if (!RtlDosPathNameToNtPathName_U( dest, &nt_name, NULL, NULL ))
2479 {
2480 SetLastError( ERROR_PATH_NOT_FOUND );
2481 goto error;
2482 }
2483
2484 size = offsetof( FILE_RENAME_INFORMATION, FileName ) + nt_name.Length;
2485 if (!(rename_info = HeapAlloc( GetProcessHeap(), 0, size ))) goto error;
2486
2487 rename_info->ReplaceIfExists = !!(flag & MOVEFILE_REPLACE_EXISTING);
2488 rename_info->RootDirectory = NULL;
2489 rename_info->FileNameLength = nt_name.Length;
2490 memcpy( rename_info->FileName, nt_name.Buffer, nt_name.Length );
2491 RtlFreeUnicodeString( &nt_name );
2492 status = NtSetInformationFile( source_handle, &io, rename_info, size, FileRenameInformation );
2493 HeapFree( GetProcessHeap(), 0, rename_info );
2494 if (status == STATUS_NOT_SAME_DEVICE && (flag & MOVEFILE_COPY_ALLOWED))
2495 {
2496 NtClose( source_handle );
2497 if (!CopyFileExW( source, dest, progress, param, NULL,
2498 flag & MOVEFILE_REPLACE_EXISTING ? 0 : COPY_FILE_FAIL_IF_EXISTS ))
2499 return FALSE;
2500 return DeleteFileW( source );
2501 }
2502
2503 NtClose( source_handle );
2504 return set_ntstatus( status );
2505
2506 error:
2507 if (source_handle) NtClose( source_handle );
2508 return FALSE;
2509 }
2510
2511
2512 /***********************************************************************
2513 * NeedCurrentDirectoryForExePathA (kernelbase.@)
2514 */
2515 BOOL WINAPI DECLSPEC_HOTPATCH NeedCurrentDirectoryForExePathA( LPCSTR name )
2516 {
2517 WCHAR *nameW;
2518
2519 if (!(nameW = file_name_AtoW( name, FALSE ))) return TRUE;
2520 return NeedCurrentDirectoryForExePathW( nameW );
2521 }
2522
2523
2524 /***********************************************************************
2525 * NeedCurrentDirectoryForExePathW (kernelbase.@)
2526 */
2527 BOOL WINAPI DECLSPEC_HOTPATCH NeedCurrentDirectoryForExePathW( LPCWSTR name )
2528 {
2529 WCHAR env_val;
2530
2531 if (wcschr( name, '\\' )) return TRUE;
2532 /* check the existence of the variable, not value */
2533 return !GetEnvironmentVariableW( L"NoDefaultCurrentDirectoryInExePath", &env_val, 1 );
2534 }
2535
2536
2537 /***********************************************************************
2538 * ReplaceFileW (kernelbase.@)
2539 */
2540 BOOL WINAPI DECLSPEC_HOTPATCH ReplaceFileW( const WCHAR *replaced, const WCHAR *replacement,
2541 const WCHAR *backup, DWORD flags,
2542 void *exclude, void *reserved )
2543 {
2544 UNICODE_STRING nt_replaced_name, nt_replacement_name;
2545 HANDLE hReplacement = NULL;
2546 NTSTATUS status;
2547 IO_STATUS_BLOCK io;
2548 OBJECT_ATTRIBUTES attr;
2549 FILE_BASIC_INFORMATION info;
2550
2551 TRACE( "%s %s %s 0x%08lx %p %p\n", debugstr_w(replaced), debugstr_w(replacement), debugstr_w(backup),
2552 flags, exclude, reserved );
2553
2554 if (flags) FIXME("Ignoring flags %lx\n", flags);
2555
2556 /* First two arguments are mandatory */
2557 if (!replaced || !replacement)
2558 {
2559 SetLastError(ERROR_INVALID_PARAMETER);
2560 return FALSE;
2561 }
2562
2563 attr.Length = sizeof(attr);
2564 attr.RootDirectory = 0;
2565 attr.Attributes = OBJ_CASE_INSENSITIVE;
2566 attr.ObjectName = NULL;
2567 attr.SecurityDescriptor = NULL;
2568 attr.SecurityQualityOfService = NULL;
2569
2570 /* Open the "replaced" file for reading */
2571 if (!RtlDosPathNameToNtPathName_U( replaced, &nt_replaced_name, NULL, NULL ))
2572 {
2573 SetLastError( ERROR_PATH_NOT_FOUND );
2574 return FALSE;
2575 }
2576 attr.ObjectName = &nt_replaced_name;
2577
2578 /* Replacement should fail if replaced is READ_ONLY */
2579 status = NtQueryAttributesFile(&attr, &info);
2580 RtlFreeUnicodeString(&nt_replaced_name);
2581 if (!set_ntstatus( status )) return FALSE;
2582
2583 if (info.FileAttributes & FILE_ATTRIBUTE_READONLY)
2584 {
2585 SetLastError( ERROR_ACCESS_DENIED );
2586 return FALSE;
2587 }
2588
2589 /*
2590 * Open the replacement file for reading, writing, and deleting
2591 * (writing and deleting are needed when finished)
2592 */
2593 if (!RtlDosPathNameToNtPathName_U( replacement, &nt_replacement_name, NULL, NULL ))
2594 {
2595 SetLastError( ERROR_PATH_NOT_FOUND );
2596 return FALSE;
2597 }
2598 attr.ObjectName = &nt_replacement_name;
2599 status = NtOpenFile( &hReplacement, GENERIC_READ | GENERIC_WRITE | DELETE | WRITE_DAC | SYNCHRONIZE,
2600 &attr, &io, 0, FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE );
2601 RtlFreeUnicodeString(&nt_replacement_name);
2602 if (!set_ntstatus( status )) return FALSE;
2603 NtClose( hReplacement );
2604
2605 /* If the user wants a backup then that needs to be performed first */
2606 if (backup)
2607 {
2608 if (!MoveFileExW( replaced, backup, MOVEFILE_REPLACE_EXISTING )) return FALSE;
2609 }
2610 else
2611 {
2612 /* ReplaceFile() can replace an open target. To do this, we need to move
2613 * it out of the way first. */
2614 WCHAR temp_path[MAX_PATH], temp_file[MAX_PATH];
2615
2616 lstrcpynW( temp_path, replaced, ARRAY_SIZE( temp_path ) );
2617 PathRemoveFileSpecW( temp_path );
2618 if (!GetTempFileNameW( temp_path, L"rf", 0, temp_file ) ||
2619 !MoveFileExW( replaced, temp_file, MOVEFILE_REPLACE_EXISTING ))
2620 return FALSE;
2621
2622 DeleteFileW( temp_file );
2623 }
2624
2625 /*
2626 * Now that the backup has been performed (if requested), copy the replacement
2627 * into place
2628 */
2629 if (!MoveFileExW( replacement, replaced, 0 ))
2630 {
2631 /* on failure we need to indicate whether a backup was made */
2632 if (!backup)
2633 SetLastError( ERROR_UNABLE_TO_MOVE_REPLACEMENT );
2634 else
2635 SetLastError( ERROR_UNABLE_TO_MOVE_REPLACEMENT_2 );
2636 return FALSE;
2637 }
2638 return TRUE;
2639 }
2640
2641
2642 /***********************************************************************
2643 * SearchPathA (kernelbase.@)
2644 */
2645 DWORD WINAPI DECLSPEC_HOTPATCH SearchPathA( LPCSTR path, LPCSTR name, LPCSTR ext,
2646 DWORD buflen, LPSTR buffer, LPSTR *lastpart )
2647 {
2648 WCHAR *pathW = NULL, *nameW, *extW = NULL;
2649 WCHAR bufferW[MAX_PATH];
2650 DWORD ret;
2651
2652 if (!name)
2653 {
2654 SetLastError( ERROR_INVALID_PARAMETER );
2655 return 0;
2656 }
2657
2658 if (!(nameW = file_name_AtoW( name, FALSE ))) return 0;
2659 if (path && !(pathW = file_name_AtoW( path, TRUE ))) return 0;
2660 if (ext && !(extW = file_name_AtoW( ext, TRUE )))
2661 {
2662 RtlFreeHeap( GetProcessHeap(), 0, pathW );
2663 return 0;
2664 }
2665
2666 ret = SearchPathW( pathW, nameW, extW, MAX_PATH, bufferW, NULL );
2667
2668 RtlFreeHeap( GetProcessHeap(), 0, pathW );
2669 RtlFreeHeap( GetProcessHeap(), 0, extW );
2670
2671 if (!ret) return 0;
2672 if (ret > MAX_PATH)
2673 {
2674 SetLastError( ERROR_FILENAME_EXCED_RANGE );
2675 return 0;
2676 }
2677 ret = copy_filename_WtoA( bufferW, buffer, buflen );
2678 if (buflen > ret && lastpart) *lastpart = strrchr(buffer, '\\') + 1;
2679 return ret;
2680 }
2681
2682
2683 /***********************************************************************
2684 * SearchPathW (kernelbase.@)
2685 */
2686 DWORD WINAPI DECLSPEC_HOTPATCH SearchPathW( LPCWSTR path, LPCWSTR name, LPCWSTR ext, DWORD buflen,
2687 LPWSTR buffer, LPWSTR *lastpart )
2688 {
2689 DWORD ret = 0;
2690 WCHAR *name_ext;
2691
2692 if (!name || !name[0])
2693 {
2694 SetLastError( ERROR_INVALID_PARAMETER );
2695 return 0;
2696 }
2697
2698 /* If the name contains an explicit path, ignore the path */
2699
2700 if (contains_path( name ))
2701 {
2702 /* try first without extension */
2703 if (RtlDoesFileExists_U( name )) return GetFullPathNameW( name, buflen, buffer, lastpart );
2704
2705 if ((name_ext = append_ext( name, ext )))
2706 {
2707 if (RtlDoesFileExists_U( name_ext ))
2708 ret = GetFullPathNameW( name_ext, buflen, buffer, lastpart );
2709 RtlFreeHeap( GetProcessHeap(), 0, name_ext );
2710 }
2711 }
2712 else if (path && path[0]) /* search in the specified path */
2713 {
2714 ret = RtlDosSearchPath_U( path, name, ext, buflen * sizeof(WCHAR),
2715 buffer, lastpart ) / sizeof(WCHAR);
2716 }
2717 else /* search in active context and default path */
2718 {
2719 WCHAR *dll_path = NULL, *name_ext = append_ext( name, ext );
2720
2721 if (name_ext) name = name_ext;
2722
2723 /* When file is found with activation context no attempt is made
2724 to check if it's really exist, path is returned only basing on context info. */
2725 if (find_actctx_dllpath( name, &dll_path ) == STATUS_SUCCESS)
2726 {
2727 ret = lstrlenW( dll_path ) + lstrlenW( name ) + 1;
2728
2729 /* count null termination char too */
2730 if (ret <= buflen)
2731 {
2732 lstrcpyW( buffer, dll_path );
2733 lstrcatW( buffer, name );
2734 if (lastpart) *lastpart = buffer + lstrlenW( dll_path );
2735 ret--;
2736 }
2737 else if (lastpart) *lastpart = NULL;
2738 RtlFreeHeap( GetProcessHeap(), 0, dll_path );
2739 }
2740 else if (!RtlGetSearchPath( &dll_path ))
2741 {
2742 ret = RtlDosSearchPath_U( dll_path, name, NULL, buflen * sizeof(WCHAR),
2743 buffer, lastpart ) / sizeof(WCHAR);
2744 RtlReleasePath( dll_path );
2745 }
2746 RtlFreeHeap( GetProcessHeap(), 0, name_ext );
2747 }
2748
2749 if (!ret) SetLastError( ERROR_FILE_NOT_FOUND );
2750 else TRACE( "found %s\n", debugstr_w(buffer) );
2751 return ret;
2752 }
2753
2754
2755 /***********************************************************************
2756 * SetCurrentDirectoryA (kernelbase.@)
2757 */
2758 BOOL WINAPI DECLSPEC_HOTPATCH SetCurrentDirectoryA( LPCSTR dir )
2759 {
2760 WCHAR *dirW;
2761 UNICODE_STRING strW;
2762
2763 if (!(dirW = file_name_AtoW( dir, FALSE ))) return FALSE;
2764 RtlInitUnicodeString( &strW, dirW );
2765 return set_ntstatus( RtlSetCurrentDirectory_U( &strW ));
2766 }
2767
2768
2769 /***********************************************************************
2770 * SetCurrentDirectoryW (kernelbase.@)
2771 */
2772 BOOL WINAPI DECLSPEC_HOTPATCH SetCurrentDirectoryW( LPCWSTR dir )
2773 {
2774 UNICODE_STRING dirW;
2775
2776 RtlInitUnicodeString( &dirW, dir );
2777 return set_ntstatus( RtlSetCurrentDirectory_U( &dirW ));
2778 }
2779
2780
2781 /**************************************************************************
2782 * SetFileApisToANSI (kernelbase.@)
2783 */
2784 void WINAPI DECLSPEC_HOTPATCH SetFileApisToANSI(void)
2785 {
2786 oem_file_apis = FALSE;
2787 }
2788
2789
2790 /**************************************************************************
2791 * SetFileApisToOEM (kernelbase.@)
2792 */
2793 void WINAPI DECLSPEC_HOTPATCH SetFileApisToOEM(void)
2794 {
2795 oem_file_apis = TRUE;
2796 }
2797
2798
2799 /**************************************************************************
2800 * SetFileAttributesA (kernelbase.@)
2801 */
2802 BOOL WINAPI DECLSPEC_HOTPATCH SetFileAttributesA( LPCSTR name, DWORD attributes )
2803 {
2804 WCHAR *nameW;
2805
2806 if (!(nameW = file_name_AtoW( name, FALSE ))) return FALSE;
2807 return SetFileAttributesW( nameW, attributes );
2808 }
2809
2810
2811 /**************************************************************************
2812 * SetFileAttributesW (kernelbase.@)
2813 */
2814 BOOL WINAPI DECLSPEC_HOTPATCH SetFileAttributesW( LPCWSTR name, DWORD attributes )
2815 {
2816 UNICODE_STRING nt_name;
2817 OBJECT_ATTRIBUTES attr;
2818 IO_STATUS_BLOCK io;
2819 NTSTATUS status;
2820 HANDLE handle;
2821
2822 TRACE( "%s %lx\n", debugstr_w(name), attributes );
2823
2824 if (!RtlDosPathNameToNtPathName_U( name, &nt_name, NULL, NULL ))
2825 {
2826 SetLastError( ERROR_PATH_NOT_FOUND );
2827 return FALSE;
2828 }
2829
2830 attr.Length = sizeof(attr);
2831 attr.RootDirectory = 0;
2832 attr.Attributes = OBJ_CASE_INSENSITIVE;
2833 attr.ObjectName = &nt_name;
2834 attr.SecurityDescriptor = NULL;
2835 attr.SecurityQualityOfService = NULL;
2836
2837 status = NtOpenFile( &handle, SYNCHRONIZE, &attr, &io, 0, FILE_SYNCHRONOUS_IO_NONALERT );
2838 RtlFreeUnicodeString( &nt_name );
2839
2840 if (status == STATUS_SUCCESS)
2841 {
2842 FILE_BASIC_INFORMATION info;
2843
2844 memset( &info, 0, sizeof(info) );
2845 info.FileAttributes = attributes | FILE_ATTRIBUTE_NORMAL; /* make sure it's not zero */
2846 status = NtSetInformationFile( handle, &io, &info, sizeof(info), FileBasicInformation );
2847 NtClose( handle );
2848 }
2849 return set_ntstatus( status );
2850 }
2851
2852
2853 /***********************************************************************
2854 * Wow64DisableWow64FsRedirection (kernelbase.@)
2855 */
2856 BOOL WINAPI DECLSPEC_HOTPATCH Wow64DisableWow64FsRedirection( PVOID *old_value )
2857 {
2858 return set_ntstatus( RtlWow64EnableFsRedirectionEx( TRUE, (ULONG *)old_value ));
2859 }
2860
2861
2862 /***********************************************************************
2863 * Wow64RevertWow64FsRedirection (kernelbase.@)
2864 */
2865 BOOL WINAPI DECLSPEC_HOTPATCH Wow64RevertWow64FsRedirection( PVOID old_value )
2866 {
2867 return set_ntstatus( RtlWow64EnableFsRedirection( !old_value ));
2868 }
2869
2870
2871 /***********************************************************************
2872 * Operations on file handles
2873 ***********************************************************************/
2874
2875
2876 /***********************************************************************
2877 * CancelIo (kernelbase.@)
2878 */
2879 BOOL WINAPI DECLSPEC_HOTPATCH CancelIo( HANDLE handle )
2880 {
2881 IO_STATUS_BLOCK io;
2882
2883 return set_ntstatus( NtCancelIoFile( handle, &io ) );
2884 }
2885
2886
2887 /***********************************************************************
2888 * CancelIoEx (kernelbase.@)
2889 */
2890 BOOL WINAPI DECLSPEC_HOTPATCH CancelIoEx( HANDLE handle, LPOVERLAPPED overlapped )
2891 {
2892 IO_STATUS_BLOCK io;
2893
2894 return set_ntstatus( NtCancelIoFileEx( handle, (PIO_STATUS_BLOCK)overlapped, &io ) );
2895 }
2896
2897
2898 /***********************************************************************
2899 * CancelSynchronousIo (kernelbase.@)
2900 */
2901 BOOL WINAPI DECLSPEC_HOTPATCH CancelSynchronousIo( HANDLE thread )
2902 {
2903 FIXME( "(%p): stub\n", thread );
2904 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
2905 return FALSE;
2906 }
2907
2908
2909 /***********************************************************************
2910 * FlushFileBuffers (kernelbase.@)
2911 */
2912 BOOL WINAPI DECLSPEC_HOTPATCH FlushFileBuffers( HANDLE file )
2913 {
2914 IO_STATUS_BLOCK iosb;
2915
2916 return set_ntstatus( NtFlushBuffersFile( file, &iosb ));
2917 }
2918
2919
2920 /***********************************************************************
2921 * GetFileInformationByHandle (kernelbase.@)
2922 */
2923 BOOL WINAPI DECLSPEC_HOTPATCH GetFileInformationByHandle( HANDLE file, BY_HANDLE_FILE_INFORMATION *info )
2924 {
2925 FILE_FS_VOLUME_INFORMATION volume_info;
2926 FILE_ALL_INFORMATION all_info;
2927 IO_STATUS_BLOCK io;
2928 NTSTATUS status;
2929
2930 status = NtQueryInformationFile( file, &io, &all_info, sizeof(all_info), FileAllInformation );
2931 if (status == STATUS_BUFFER_OVERFLOW) status = STATUS_SUCCESS;
2932 if (!set_ntstatus( status )) return FALSE;
2933
2934 info->dwFileAttributes = all_info.BasicInformation.FileAttributes;
2935 info->ftCreationTime.dwHighDateTime = all_info.BasicInformation.CreationTime.u.HighPart;
2936 info->ftCreationTime.dwLowDateTime = all_info.BasicInformation.CreationTime.u.LowPart;
2937 info->ftLastAccessTime.dwHighDateTime = all_info.BasicInformation.LastAccessTime.u.HighPart;
2938 info->ftLastAccessTime.dwLowDateTime = all_info.BasicInformation.LastAccessTime.u.LowPart;
2939 info->ftLastWriteTime.dwHighDateTime = all_info.BasicInformation.LastWriteTime.u.HighPart;
2940 info->ftLastWriteTime.dwLowDateTime = all_info.BasicInformation.LastWriteTime.u.LowPart;
2941 info->dwVolumeSerialNumber = 0;
2942 info->nFileSizeHigh = all_info.StandardInformation.EndOfFile.u.HighPart;
2943 info->nFileSizeLow = all_info.StandardInformation.EndOfFile.u.LowPart;
2944 info->nNumberOfLinks = all_info.StandardInformation.NumberOfLinks;
2945 info->nFileIndexHigh = all_info.InternalInformation.IndexNumber.u.HighPart;
2946 info->nFileIndexLow = all_info.InternalInformation.IndexNumber.u.LowPart;
2947
2948 status = NtQueryVolumeInformationFile( file, &io, &volume_info, sizeof(volume_info), FileFsVolumeInformation );
2949 if (status == STATUS_SUCCESS || status == STATUS_BUFFER_OVERFLOW)
2950 info->dwVolumeSerialNumber = volume_info.VolumeSerialNumber;
2951
2952 return TRUE;
2953 }
2954
2955
2956 /***********************************************************************
2957 * GetFileInformationByHandleEx (kernelbase.@)
2958 */
2959 BOOL WINAPI DECLSPEC_HOTPATCH GetFileInformationByHandleEx( HANDLE handle, FILE_INFO_BY_HANDLE_CLASS class,
2960 LPVOID info, DWORD size )
2961 {
2962 NTSTATUS status;
2963 IO_STATUS_BLOCK io;
2964
2965 switch (class)
2966 {
2967 case FileStreamInfo:
2968 case FileCompressionInfo:
2969 case FileRemoteProtocolInfo:
2970 case FileFullDirectoryInfo:
2971 case FileFullDirectoryRestartInfo:
2972 case FileStorageInfo:
2973 case FileAlignmentInfo:
2974 case FileIdExtdDirectoryInfo:
2975 case FileIdExtdDirectoryRestartInfo:
2976 FIXME( "%p, %u, %p, %lu\n", handle, class, info, size );
2977 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
2978 return FALSE;
2979
2980 case FileAttributeTagInfo:
2981 status = NtQueryInformationFile( handle, &io, info, size, FileAttributeTagInformation );
2982 break;
2983
2984 case FileBasicInfo:
2985 status = NtQueryInformationFile( handle, &io, info, size, FileBasicInformation );
2986 break;
2987
2988 case FileStandardInfo:
2989 status = NtQueryInformationFile( handle, &io, info, size, FileStandardInformation );
2990 break;
2991
2992 case FileNameInfo:
2993 status = NtQueryInformationFile( handle, &io, info, size, FileNameInformation );
2994 break;
2995
2996 case FileIdInfo:
2997 status = NtQueryInformationFile( handle, &io, info, size, FileIdInformation );
2998 break;
2999
3000 case FileIdBothDirectoryRestartInfo:
3001 case FileIdBothDirectoryInfo:
3002 status = NtQueryDirectoryFile( handle, NULL, NULL, NULL, &io, info, size,
3003 FileIdBothDirectoryInformation, FALSE, NULL,
3004 (class == FileIdBothDirectoryRestartInfo) );
3005 break;
3006
3007 case FileRenameInfo:
3008 case FileDispositionInfo:
3009 case FileAllocationInfo:
3010 case FileIoPriorityHintInfo:
3011 case FileEndOfFileInfo:
3012 default:
3013 SetLastError( ERROR_INVALID_PARAMETER );
3014 return FALSE;
3015 }
3016 return set_ntstatus( status );
3017 }
3018
3019
3020 /***********************************************************************
3021 * GetFileSize (kernelbase.@)
3022 */
3023 DWORD WINAPI DECLSPEC_HOTPATCH GetFileSize( HANDLE file, LPDWORD size_high )
3024 {
3025 LARGE_INTEGER size;
3026
3027 if (!GetFileSizeEx( file, &size )) return INVALID_FILE_SIZE;
3028 if (size_high) *size_high = size.u.HighPart;
3029 if (size.u.LowPart == INVALID_FILE_SIZE) SetLastError( 0 );
3030 return size.u.LowPart;
3031 }
3032
3033
3034 /***********************************************************************
3035 * GetFileSizeEx (kernelbase.@)
3036 */
3037 BOOL WINAPI DECLSPEC_HOTPATCH GetFileSizeEx( HANDLE file, PLARGE_INTEGER size )
3038 {
3039 FILE_STANDARD_INFORMATION info;
3040 IO_STATUS_BLOCK io;
3041
3042 if (!set_ntstatus( NtQueryInformationFile( file, &io, &info, sizeof(info), FileStandardInformation )))
3043 return FALSE;
3044
3045 *size = info.EndOfFile;
3046 return TRUE;
3047 }
3048
3049
3050 /***********************************************************************
3051 * GetFileTime (kernelbase.@)
3052 */
3053 BOOL WINAPI DECLSPEC_HOTPATCH GetFileTime( HANDLE file, FILETIME *creation,
3054 FILETIME *access, FILETIME *write )
3055 {
3056 FILE_BASIC_INFORMATION info;
3057 IO_STATUS_BLOCK io;
3058
3059 if (!set_ntstatus( NtQueryInformationFile( file, &io, &info, sizeof(info), FileBasicInformation )))
3060 return FALSE;
3061
3062 if (creation)
3063 {
3064 creation->dwHighDateTime = info.CreationTime.u.HighPart;
3065 creation->dwLowDateTime = info.CreationTime.u.LowPart;
3066 }
3067 if (access)
3068 {
3069 access->dwHighDateTime = info.LastAccessTime.u.HighPart;
3070 access->dwLowDateTime = info.LastAccessTime.u.LowPart;
3071 }
3072 if (write)
3073 {
3074 write->dwHighDateTime = info.LastWriteTime.u.HighPart;
3075 write->dwLowDateTime = info.LastWriteTime.u.LowPart;
3076 }
3077 return TRUE;
3078 }
3079
3080
3081 /***********************************************************************
3082 * GetFileType (kernelbase.@)
3083 */
3084 DWORD WINAPI DECLSPEC_HOTPATCH GetFileType( HANDLE file )
3085 {
3086 FILE_FS_DEVICE_INFORMATION info;
3087 IO_STATUS_BLOCK io;
3088
3089 if (file == (HANDLE)STD_INPUT_HANDLE ||
3090 file == (HANDLE)STD_OUTPUT_HANDLE ||
3091 file == (HANDLE)STD_ERROR_HANDLE)
3092 file = GetStdHandle( (DWORD_PTR)file );
3093
3094 if (!set_ntstatus( NtQueryVolumeInformationFile( file, &io, &info, sizeof(info),
3095 FileFsDeviceInformation )))
3096 return FILE_TYPE_UNKNOWN;
3097
3098 switch (info.DeviceType)
3099 {
3100 case FILE_DEVICE_NULL:
3101 case FILE_DEVICE_CONSOLE:
3102 case FILE_DEVICE_SERIAL_PORT:
3103 case FILE_DEVICE_PARALLEL_PORT:
3104 case FILE_DEVICE_TAPE:
3105 case FILE_DEVICE_UNKNOWN:
3106 return FILE_TYPE_CHAR;
3107 case FILE_DEVICE_NAMED_PIPE:
3108 return FILE_TYPE_PIPE;
3109 default:
3110 return FILE_TYPE_DISK;
3111 }
3112 }
3113
3114
3115 /***********************************************************************
3116 * GetOverlappedResult (kernelbase.@)
3117 */
3118 BOOL WINAPI DECLSPEC_HOTPATCH GetOverlappedResult( HANDLE file, LPOVERLAPPED overlapped,
3119 LPDWORD result, BOOL wait )
3120 {
3121 return GetOverlappedResultEx( file, overlapped, result, wait ? INFINITE : 0, FALSE );
3122 }
3123
3124
3125 /***********************************************************************
3126 * GetOverlappedResultEx (kernelbase.@)
3127 */
3128 BOOL WINAPI DECLSPEC_HOTPATCH GetOverlappedResultEx( HANDLE file, OVERLAPPED *overlapped,
3129 DWORD *result, DWORD timeout, BOOL alertable )
3130 {
3131 NTSTATUS status;
3132 DWORD ret;
3133
3134 TRACE( "(%p %p %p %lu %d)\n", file, overlapped, result, timeout, alertable );
3135
3136 status = overlapped->Internal;
3137 if (status == STATUS_PENDING)
3138 {
3139 if (!timeout)
3140 {
3141 SetLastError( ERROR_IO_INCOMPLETE );
3142 return FALSE;
3143 }
3144 ret = WaitForSingleObjectEx( overlapped->hEvent ? overlapped->hEvent : file, timeout, alertable );
3145 if (ret == WAIT_FAILED)
3146 return FALSE;
3147 else if (ret)
3148 {
3149 SetLastError( ret );
3150 return FALSE;
3151 }
3152
3153 status = overlapped->Internal;
3154 if (status == STATUS_PENDING) status = STATUS_SUCCESS;
3155 }
3156
3157 *result = overlapped->InternalHigh;
3158 return set_ntstatus( status );
3159 }
3160
3161
3162 /**************************************************************************
3163 * LockFile (kernelbase.@)
3164 */
3165 BOOL WINAPI DECLSPEC_HOTPATCH LockFile( HANDLE file, DWORD offset_low, DWORD offset_high,
3166 DWORD count_low, DWORD count_high )
3167 {
3168 LARGE_INTEGER count, offset;
3169
3170 TRACE( "%p %lx%08lx %lx%08lx\n", file, offset_high, offset_low, count_high, count_low );
3171
3172 count.u.LowPart = count_low;
3173 count.u.HighPart = count_high;
3174 offset.u.LowPart = offset_low;
3175 offset.u.HighPart = offset_high;
3176 return set_ntstatus( NtLockFile( file, 0, NULL, NULL, NULL, &offset, &count, NULL, TRUE, TRUE ));
3177 }
3178
3179
3180 /**************************************************************************
3181 * LockFileEx (kernelbase.@)
3182 */
3183 BOOL WINAPI DECLSPEC_HOTPATCH LockFileEx( HANDLE file, DWORD flags, DWORD reserved,
3184 DWORD count_low, DWORD count_high, LPOVERLAPPED overlapped )
3185 {
3186 LARGE_INTEGER count, offset;
3187 LPVOID cvalue = NULL;
3188
3189 if (reserved)
3190 {
3191 SetLastError( ERROR_INVALID_PARAMETER );
3192 return FALSE;
3193 }
3194
3195 TRACE( "%p %lx%08lx %lx%08lx flags %lx\n",
3196 file, overlapped->u.s.OffsetHigh, overlapped->u.s.Offset, count_high, count_low, flags );
3197
3198 count.u.LowPart = count_low;
3199 count.u.HighPart = count_high;
3200 offset.u.LowPart = overlapped->u.s.Offset;
3201 offset.u.HighPart = overlapped->u.s.OffsetHigh;
3202
3203 if (((ULONG_PTR)overlapped->hEvent & 1) == 0) cvalue = overlapped;
3204
3205 return set_ntstatus( NtLockFile( file, overlapped->hEvent, NULL, cvalue,
3206 NULL, &offset, &count, NULL,
3207 flags & LOCKFILE_FAIL_IMMEDIATELY,
3208 flags & LOCKFILE_EXCLUSIVE_LOCK ));
3209 }
3210
3211
3212 /***********************************************************************
3213 * OpenFileById (kernelbase.@)
3214 */
3215 HANDLE WINAPI DECLSPEC_HOTPATCH OpenFileById( HANDLE handle, LPFILE_ID_DESCRIPTOR id, DWORD access,
3216 DWORD share, LPSECURITY_ATTRIBUTES sec_attr, DWORD flags )
3217 {
3218 UINT options;
3219 HANDLE result;
3220 OBJECT_ATTRIBUTES attr;
3221 IO_STATUS_BLOCK io;
3222 UNICODE_STRING objectName;
3223
3224 if (!id)
3225 {
3226 SetLastError( ERROR_INVALID_PARAMETER );
3227 return INVALID_HANDLE_VALUE;
3228 }
3229
3230 options = FILE_OPEN_BY_FILE_ID;
3231 if (flags & FILE_FLAG_BACKUP_SEMANTICS)
3232 options |= FILE_OPEN_FOR_BACKUP_INTENT;
3233 else
3234 options |= FILE_NON_DIRECTORY_FILE;
3235 if (flags & FILE_FLAG_NO_BUFFERING) options |= FILE_NO_INTERMEDIATE_BUFFERING;
3236 if (!(flags & FILE_FLAG_OVERLAPPED)) options |= FILE_SYNCHRONOUS_IO_NONALERT;
3237 if (flags & FILE_FLAG_RANDOM_ACCESS) options |= FILE_RANDOM_ACCESS;
3238 if (flags & FILE_FLAG_SEQUENTIAL_SCAN) options |= FILE_SEQUENTIAL_ONLY;
3239 flags &= FILE_ATTRIBUTE_VALID_FLAGS;
3240
3241 objectName.Length = sizeof(ULONGLONG);
3242 objectName.Buffer = (WCHAR *)&id->u.FileId;
3243 attr.Length = sizeof(attr);
3244 attr.RootDirectory = handle;
3245 attr.Attributes = 0;
3246 attr.ObjectName = &objectName;
3247 attr.SecurityDescriptor = sec_attr ? sec_attr->lpSecurityDescriptor : NULL;
3248 attr.SecurityQualityOfService = NULL;
3249 if (sec_attr && sec_attr->bInheritHandle) attr.Attributes |= OBJ_INHERIT;
3250
3251 if (!set_ntstatus( NtCreateFile( &result, access | SYNCHRONIZE, &attr, &io, NULL, flags,
3252 share, OPEN_EXISTING, options, NULL, 0 )))
3253 return INVALID_HANDLE_VALUE;
3254 return result;
3255 }
3256
3257
3258 /***********************************************************************
3259 * ReOpenFile (kernelbase.@)
3260 */
3261 HANDLE WINAPI DECLSPEC_HOTPATCH ReOpenFile( HANDLE handle, DWORD access, DWORD sharing, DWORD attributes )
3262 {
3263 SECURITY_QUALITY_OF_SERVICE qos;
3264 OBJECT_ATTRIBUTES attr;
3265 UNICODE_STRING empty = { 0 };
3266 IO_STATUS_BLOCK io;
3267 NTSTATUS status;
3268 HANDLE file;
3269
3270 TRACE("handle %p, access %#lx, sharing %#lx, attributes %#lx.\n", handle, access, sharing, attributes);
3271
3272 if (attributes & 0x7ffff) /* FILE_ATTRIBUTE_* flags are invalid */
3273 {
3274 SetLastError(ERROR_INVALID_PARAMETER);
3275 return INVALID_HANDLE_VALUE;
3276 }
3277
3278 if (attributes & FILE_FLAG_DELETE_ON_CLOSE)
3279 access |= DELETE;
3280
3281 InitializeObjectAttributes( &attr, &empty, OBJ_CASE_INSENSITIVE, handle, NULL );
3282 if (attributes & SECURITY_SQOS_PRESENT)
3283 {
3284 qos.Length = sizeof(qos);
3285 qos.ImpersonationLevel = (attributes >> 16) & 0x3;
3286 qos.ContextTrackingMode = attributes & SECURITY_CONTEXT_TRACKING ? SECURITY_DYNAMIC_TRACKING : SECURITY_STATIC_TRACKING;
3287 qos.EffectiveOnly = (attributes & SECURITY_EFFECTIVE_ONLY) != 0;
3288 attr.SecurityQualityOfService = &qos;
3289 }
3290
3291 status = NtCreateFile( &file, access | SYNCHRONIZE | FILE_READ_ATTRIBUTES, &attr, &io, NULL,
3292 0, sharing, FILE_OPEN, get_nt_file_options( attributes ), NULL, 0 );
3293 if (!set_ntstatus( status ))
3294 return INVALID_HANDLE_VALUE;
3295 return file;
3296 }
3297
3298
3299 static void WINAPI invoke_completion( void *context, IO_STATUS_BLOCK *io, ULONG res )
3300 {
3301 LPOVERLAPPED_COMPLETION_ROUTINE completion = context;
3302 completion( io->u.Status, io->Information, (LPOVERLAPPED)io );
3303 }
3304
3305 /****************************************************************************
3306 * ReadDirectoryChangesW (kernelbase.@)
3307 */
3308 BOOL WINAPI DECLSPEC_HOTPATCH ReadDirectoryChangesW( HANDLE handle, LPVOID buffer, DWORD len,
3309 BOOL subtree, DWORD filter, LPDWORD returned,
3310 LPOVERLAPPED overlapped,
3311 LPOVERLAPPED_COMPLETION_ROUTINE completion )
3312 {
3313 OVERLAPPED ov, *pov;
3314 IO_STATUS_BLOCK *ios;
3315 NTSTATUS status;
3316 LPVOID cvalue = NULL;
3317
3318 TRACE( "%p %p %08lx %d %08lx %p %p %p\n",
3319 handle, buffer, len, subtree, filter, returned, overlapped, completion );
3320
3321 if (!overlapped)
3322 {
3323 memset( &ov, 0, sizeof ov );
3324 ov.hEvent = CreateEventW( NULL, 0, 0, NULL );
3325 pov = &ov;
3326 }
3327 else
3328 {
3329 pov = overlapped;
3330 if (completion) cvalue = completion;
3331 else if (((ULONG_PTR)overlapped->hEvent & 1) == 0) cvalue = overlapped;
3332 }
3333
3334 ios = (PIO_STATUS_BLOCK)pov;
3335 ios->u.Status = STATUS_PENDING;
3336
3337 status = NtNotifyChangeDirectoryFile( handle, completion && overlapped ? NULL : pov->hEvent,
3338 completion && overlapped ? invoke_completion : NULL,
3339 cvalue, ios, buffer, len, filter, subtree );
3340 if (status == STATUS_PENDING)
3341 {
3342 if (overlapped) return TRUE;
3343 WaitForSingleObjectEx( ov.hEvent, INFINITE, TRUE );
3344 if (returned) *returned = ios->Information;
3345 status = ios->u.Status;
3346 }
3347 if (!overlapped) CloseHandle( ov.hEvent );
3348 return set_ntstatus( status );
3349 }
3350
3351
3352 /***********************************************************************
3353 * ReadFile (kernelbase.@)
3354 */
3355 BOOL WINAPI DECLSPEC_HOTPATCH ReadFile( HANDLE file, LPVOID buffer, DWORD count,
3356 LPDWORD result, LPOVERLAPPED overlapped )
3357 {
3358 LARGE_INTEGER offset;
3359 PLARGE_INTEGER poffset = NULL;
3360 IO_STATUS_BLOCK iosb;
3361 PIO_STATUS_BLOCK io_status = &iosb;
3362 HANDLE event = 0;
3363 NTSTATUS status;
3364 LPVOID cvalue = NULL;
3365
3366 TRACE( "%p %p %ld %p %p\n", file, buffer, count, result, overlapped );
3367
3368 if (result) *result = 0;
3369
3370 if (overlapped)
3371 {
3372 offset.u.LowPart = overlapped->u.s.Offset;
3373 offset.u.HighPart = overlapped->u.s.OffsetHigh;
3374 poffset = &offset;
3375 event = overlapped->hEvent;
3376 io_status = (PIO_STATUS_BLOCK)overlapped;
3377 if (((ULONG_PTR)event & 1) == 0) cvalue = overlapped;
3378 }
3379 else io_status->Information = 0;
3380 io_status->u.Status = STATUS_PENDING;
3381
3382 status = NtReadFile( file, event, NULL, cvalue, io_status, buffer, count, poffset, NULL);
3383
3384 if (status == STATUS_PENDING && !overlapped)
3385 {
3386 WaitForSingleObject( file, INFINITE );
3387 status = io_status->u.Status;
3388 }
3389
3390 if (result) *result = overlapped && status ? 0 : io_status->Information;
3391
3392 if (status == STATUS_END_OF_FILE)
3393 {
3394 if (overlapped != NULL)
3395 {
3396 SetLastError( RtlNtStatusToDosError(status) );
3397 return FALSE;
3398 }
3399 }
3400 else if (status && status != STATUS_TIMEOUT)
3401 {
3402 SetLastError( RtlNtStatusToDosError(status) );
3403 return FALSE;
3404 }
3405 return TRUE;
3406 }
3407
3408
3409 /***********************************************************************
3410 * ReadFileEx (kernelbase.@)
3411 */
3412 BOOL WINAPI DECLSPEC_HOTPATCH ReadFileEx( HANDLE file, LPVOID buffer, DWORD count, LPOVERLAPPED overlapped,
3413 LPOVERLAPPED_COMPLETION_ROUTINE completion )
3414 {
3415 PIO_STATUS_BLOCK io;
3416 LARGE_INTEGER offset;
3417 NTSTATUS status;
3418
3419 TRACE( "(file=%p, buffer=%p, bytes=%lu, ovl=%p, ovl_fn=%p)\n",
3420 file, buffer, count, overlapped, completion );
3421
3422 if (!overlapped)
3423 {
3424 SetLastError( ERROR_INVALID_PARAMETER );
3425 return FALSE;
3426 }
3427 offset.u.LowPart = overlapped->u.s.Offset;
3428 offset.u.HighPart = overlapped->u.s.OffsetHigh;
3429 io = (PIO_STATUS_BLOCK)overlapped;
3430 io->u.Status = STATUS_PENDING;
3431 io->Information = 0;
3432
3433 status = NtReadFile( file, NULL, read_write_apc, completion, io, buffer, count, &offset, NULL);
3434 if (status == STATUS_PENDING) return TRUE;
3435 return set_ntstatus( status );
3436 }
3437
3438
3439 /***********************************************************************
3440 * ReadFileScatter (kernelbase.@)
3441 */
3442 BOOL WINAPI DECLSPEC_HOTPATCH ReadFileScatter( HANDLE file, FILE_SEGMENT_ELEMENT *segments, DWORD count,
3443 LPDWORD reserved, LPOVERLAPPED overlapped )
3444 {
3445 PIO_STATUS_BLOCK io;
3446 LARGE_INTEGER offset;
3447 void *cvalue = NULL;
3448
3449 TRACE( "(%p %p %lu %p)\n", file, segments, count, overlapped );
3450
3451 offset.u.LowPart = overlapped->u.s.Offset;
3452 offset.u.HighPart = overlapped->u.s.OffsetHigh;
3453 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
3454 io = (PIO_STATUS_BLOCK)overlapped;
3455 io->u.Status = STATUS_PENDING;
3456 io->Information = 0;
3457
3458 return set_ntstatus( NtReadFileScatter( file, overlapped->hEvent, NULL, cvalue, io,
3459 segments, count, &offset, NULL ));
3460 }
3461
3462
3463 /***********************************************************************
3464 * RemoveDirectoryA (kernelbase.@)
3465 */
3466 BOOL WINAPI DECLSPEC_HOTPATCH RemoveDirectoryA( LPCSTR path )
3467 {
3468 WCHAR *pathW;
3469
3470 if (!(pathW = file_name_AtoW( path, FALSE ))) return FALSE;
3471 return RemoveDirectoryW( pathW );
3472 }
3473
3474
3475 /***********************************************************************
3476 * RemoveDirectoryW (kernelbase.@)
3477 */
3478 BOOL WINAPI DECLSPEC_HOTPATCH RemoveDirectoryW( LPCWSTR path )
3479 {
3480 OBJECT_ATTRIBUTES attr;
3481 UNICODE_STRING nt_name;
3482 IO_STATUS_BLOCK io;
3483 NTSTATUS status;
3484 HANDLE handle;
3485
3486 TRACE( "%s\n", debugstr_w(path) );
3487
3488 status = RtlDosPathNameToNtPathName_U_WithStatus( path, &nt_name, NULL, NULL );
3489 if (!set_ntstatus( status )) return FALSE;
3490
3491 InitializeObjectAttributes( &attr, &nt_name, OBJ_CASE_INSENSITIVE, 0, NULL );
3492 status = NtOpenFile( &handle, DELETE | SYNCHRONIZE, &attr, &io,
3493 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
3494 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT );
3495 RtlFreeUnicodeString( &nt_name );
3496
3497 if (!status)
3498 {
3499 FILE_DISPOSITION_INFORMATION info = { TRUE };
3500 status = NtSetInformationFile( handle, &io, &info, sizeof(info), FileDispositionInformation );
3501 NtClose( handle );
3502 }
3503 return set_ntstatus( status );
3504 }
3505
3506
3507 /**************************************************************************
3508 * SetEndOfFile (kernelbase.@)
3509 */
3510 BOOL WINAPI DECLSPEC_HOTPATCH SetEndOfFile( HANDLE file )
3511 {
3512 FILE_POSITION_INFORMATION pos;
3513 FILE_END_OF_FILE_INFORMATION eof;
3514 IO_STATUS_BLOCK io;
3515 NTSTATUS status;
3516
3517 if (!(status = NtQueryInformationFile( file, &io, &pos, sizeof(pos), FilePositionInformation )))
3518 {
3519 eof.EndOfFile = pos.CurrentByteOffset;
3520 status = NtSetInformationFile( file, &io, &eof, sizeof(eof), FileEndOfFileInformation );
3521 }
3522 return set_ntstatus( status );
3523 }
3524
3525
3526 /***********************************************************************
3527 * SetFileInformationByHandle (kernelbase.@)
3528 */
3529 BOOL WINAPI DECLSPEC_HOTPATCH SetFileInformationByHandle( HANDLE file, FILE_INFO_BY_HANDLE_CLASS class,
3530 void *info, DWORD size )
3531 {
3532 NTSTATUS status;
3533 IO_STATUS_BLOCK io;
3534
3535 TRACE( "%p %u %p %lu\n", file, class, info, size );
3536
3537 switch (class)
3538 {
3539 case FileNameInfo:
3540 case FileAllocationInfo:
3541 case FileStreamInfo:
3542 case FileIdBothDirectoryInfo:
3543 case FileIdBothDirectoryRestartInfo:
3544 case FileFullDirectoryInfo:
3545 case FileFullDirectoryRestartInfo:
3546 case FileStorageInfo:
3547 case FileAlignmentInfo:
3548 case FileIdInfo:
3549 case FileIdExtdDirectoryInfo:
3550 case FileIdExtdDirectoryRestartInfo:
3551 FIXME( "%p, %u, %p, %lu\n", file, class, info, size );
3552 SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
3553 return FALSE;
3554
3555 case FileEndOfFileInfo:
3556 status = NtSetInformationFile( file, &io, info, size, FileEndOfFileInformation );
3557 break;
3558 case FileBasicInfo:
3559 status = NtSetInformationFile( file, &io, info, size, FileBasicInformation );
3560 break;
3561 case FileDispositionInfo:
3562 status = NtSetInformationFile( file, &io, info, size, FileDispositionInformation );
3563 break;
3564 case FileIoPriorityHintInfo:
3565 status = NtSetInformationFile( file, &io, info, size, FileIoPriorityHintInformation );
3566 break;
3567 case FileRenameInfo:
3568 {
3569 FILE_RENAME_INFORMATION *rename_info;
3570 UNICODE_STRING nt_name;
3571 ULONG size;
3572
3573 if ((status = RtlDosPathNameToNtPathName_U_WithStatus( ((FILE_RENAME_INFORMATION *)info)->FileName,
3574 &nt_name, NULL, NULL )))
3575 break;
3576
3577 size = sizeof(*rename_info) + nt_name.Length;
3578 if ((rename_info = HeapAlloc( GetProcessHeap(), 0, size )))
3579 {
3580 memcpy( rename_info, info, sizeof(*rename_info) );
3581 memcpy( rename_info->FileName, nt_name.Buffer, nt_name.Length + sizeof(WCHAR) );
3582 rename_info->FileNameLength = nt_name.Length;
3583 status = NtSetInformationFile( file, &io, rename_info, size, FileRenameInformation );
3584 HeapFree( GetProcessHeap(), 0, rename_info );
3585 }
3586 RtlFreeUnicodeString( &nt_name );
3587 break;
3588 }
3589 case FileStandardInfo:
3590 case FileCompressionInfo:
3591 case FileAttributeTagInfo:
3592 case FileRemoteProtocolInfo:
3593 default:
3594 SetLastError( ERROR_INVALID_PARAMETER );
3595 return FALSE;
3596 }
3597 return set_ntstatus( status );
3598 }
3599
3600
3601 /***********************************************************************
3602 * SetFilePointer (kernelbase.@)
3603 */
3604 DWORD WINAPI DECLSPEC_HOTPATCH SetFilePointer( HANDLE file, LONG distance, LONG *highword, DWORD method )
3605 {
3606 LARGE_INTEGER dist, newpos;
3607
3608 if (highword)
3609 {
3610 dist.u.LowPart = distance;
3611 dist.u.HighPart = *highword;
3612 }
3613 else dist.QuadPart = distance;
3614
3615 if (!SetFilePointerEx( file, dist, &newpos, method )) return INVALID_SET_FILE_POINTER;
3616
3617 if (highword) *highword = newpos.u.HighPart;
3618 if (newpos.u.LowPart == INVALID_SET_FILE_POINTER) SetLastError( 0 );
3619 return newpos.u.LowPart;
3620 }
3621
3622
3623 /***********************************************************************
3624 * SetFilePointerEx (kernelbase.@)
3625 */
3626 BOOL WINAPI DECLSPEC_HOTPATCH SetFilePointerEx( HANDLE file, LARGE_INTEGER distance,
3627 LARGE_INTEGER *newpos, DWORD method )
3628 {
3629 LONGLONG pos;
3630 IO_STATUS_BLOCK io;
3631 FILE_POSITION_INFORMATION info;
3632 FILE_STANDARD_INFORMATION eof;
3633
3634 switch(method)
3635 {
3636 case FILE_BEGIN:
3637 pos = distance.QuadPart;
3638 break;
3639 case FILE_CURRENT:
3640 if (NtQueryInformationFile( file, &io, &info, sizeof(info), FilePositionInformation ))
3641 goto error;
3642 pos = info.CurrentByteOffset.QuadPart + distance.QuadPart;
3643 break;
3644 case FILE_END:
3645 if (NtQueryInformationFile( file, &io, &eof, sizeof(eof), FileStandardInformation ))
3646 goto error;
3647 pos = eof.EndOfFile.QuadPart + distance.QuadPart;
3648 break;
3649 default:
3650 SetLastError( ERROR_INVALID_PARAMETER );
3651 return FALSE;
3652 }
3653
3654 if (pos < 0)
3655 {
3656 SetLastError( ERROR_NEGATIVE_SEEK );
3657 return FALSE;
3658 }
3659
3660 info.CurrentByteOffset.QuadPart = pos;
3661 if (!NtSetInformationFile( file, &io, &info, sizeof(info), FilePositionInformation ))
3662 {
3663 if (newpos) newpos->QuadPart = pos;
3664 return TRUE;
3665 }
3666
3667 error:
3668 return set_ntstatus( io.u.Status );
3669 }
3670
3671
3672 /***********************************************************************
3673 * SetFileTime (kernelbase.@)
3674 */
3675 BOOL WINAPI DECLSPEC_HOTPATCH SetFileTime( HANDLE file, const FILETIME *ctime,
3676 const FILETIME *atime, const FILETIME *mtime )
3677 {
3678 FILE_BASIC_INFORMATION info;
3679 IO_STATUS_BLOCK io;
3680
3681 memset( &info, 0, sizeof(info) );
3682 if (ctime)
3683 {
3684 info.CreationTime.u.HighPart = ctime->dwHighDateTime;
3685 info.CreationTime.u.LowPart = ctime->dwLowDateTime;
3686 }
3687 if (atime)
3688 {
3689 info.LastAccessTime.u.HighPart = atime->dwHighDateTime;
3690 info.LastAccessTime.u.LowPart = atime->dwLowDateTime;
3691 }
3692 if (mtime)
3693 {
3694 info.LastWriteTime.u.HighPart = mtime->dwHighDateTime;
3695 info.LastWriteTime.u.LowPart = mtime->dwLowDateTime;
3696 }
3697
3698 return set_ntstatus( NtSetInformationFile( file, &io, &info, sizeof(info), FileBasicInformation ));
3699 }
3700
3701
3702 /***********************************************************************
3703 * SetFileValidData (kernelbase.@)
3704 */
3705 BOOL WINAPI DECLSPEC_HOTPATCH SetFileValidData( HANDLE file, LONGLONG length )
3706 {
3707 FILE_VALID_DATA_LENGTH_INFORMATION info;
3708 IO_STATUS_BLOCK io;
3709
3710 info.ValidDataLength.QuadPart = length;
3711 return set_ntstatus( NtSetInformationFile( file, &io, &info, sizeof(info),
3712 FileValidDataLengthInformation ));
3713 }
3714
3715
3716 /**************************************************************************
3717 * UnlockFile (kernelbase.@)
3718 */
3719 BOOL WINAPI DECLSPEC_HOTPATCH UnlockFile( HANDLE file, DWORD offset_low, DWORD offset_high,
3720 DWORD count_low, DWORD count_high )
3721 {
3722 LARGE_INTEGER count, offset;
3723
3724 count.u.LowPart = count_low;
3725 count.u.HighPart = count_high;
3726 offset.u.LowPart = offset_low;
3727 offset.u.HighPart = offset_high;
3728 return set_ntstatus( NtUnlockFile( file, NULL, &offset, &count, NULL ));
3729 }
3730
3731
3732 /**************************************************************************
3733 * UnlockFileEx (kernelbase.@)
3734 */
3735 BOOL WINAPI DECLSPEC_HOTPATCH UnlockFileEx( HANDLE file, DWORD reserved,
3736 DWORD count_low, DWORD count_high, LPOVERLAPPED overlapped )
3737 {
3738 if (reserved)
3739 {
3740 SetLastError( ERROR_INVALID_PARAMETER );
3741 return FALSE;
3742 }
3743 if (overlapped->hEvent) FIXME("Unimplemented overlapped operation\n");
3744
3745 return UnlockFile( file, overlapped->u.s.Offset, overlapped->u.s.OffsetHigh, count_low, count_high );
3746 }
3747
3748
3749 /***********************************************************************
3750 * WriteFile (kernelbase.@)
3751 */
3752 BOOL WINAPI DECLSPEC_HOTPATCH WriteFile( HANDLE file, LPCVOID buffer, DWORD count,
3753 LPDWORD result, LPOVERLAPPED overlapped )
3754 {
3755 HANDLE event = NULL;
3756 LARGE_INTEGER offset;
3757 PLARGE_INTEGER poffset = NULL;
3758 NTSTATUS status;
3759 IO_STATUS_BLOCK iosb;
3760 PIO_STATUS_BLOCK piosb = &iosb;
3761 LPVOID cvalue = NULL;
3762
3763 TRACE( "%p %p %ld %p %p\n", file, buffer, count, result, overlapped );
3764
3765 if (overlapped)
3766 {
3767 offset.u.LowPart = overlapped->u.s.Offset;
3768 offset.u.HighPart = overlapped->u.s.OffsetHigh;
3769 poffset = &offset;
3770 event = overlapped->hEvent;
3771 piosb = (PIO_STATUS_BLOCK)overlapped;
3772 if (((ULONG_PTR)event & 1) == 0) cvalue = overlapped;
3773 }
3774 else piosb->Information = 0;
3775 piosb->u.Status = STATUS_PENDING;
3776
3777 status = NtWriteFile( file, event, NULL, cvalue, piosb, buffer, count, poffset, NULL );
3778
3779 if (status == STATUS_PENDING && !overlapped)
3780 {
3781 WaitForSingleObject( file, INFINITE );
3782 status = piosb->u.Status;
3783 }
3784
3785 if (result) *result = overlapped && status ? 0 : piosb->Information;
3786
3787 if (status && status != STATUS_TIMEOUT)
3788 {
3789 SetLastError( RtlNtStatusToDosError(status) );
3790 return FALSE;
3791 }
3792 return TRUE;
3793 }
3794
3795
3796 /***********************************************************************
3797 * WriteFileEx (kernelbase.@)
3798 */
3799 BOOL WINAPI DECLSPEC_HOTPATCH WriteFileEx( HANDLE file, LPCVOID buffer,
3800 DWORD count, LPOVERLAPPED overlapped,
3801 LPOVERLAPPED_COMPLETION_ROUTINE completion )
3802 {
3803 LARGE_INTEGER offset;
3804 NTSTATUS status;
3805 PIO_STATUS_BLOCK io;
3806
3807 TRACE( "%p %p %ld %p %p\n", file, buffer, count, overlapped, completion );
3808
3809 if (!overlapped)
3810 {
3811 SetLastError( ERROR_INVALID_PARAMETER );
3812 return FALSE;
3813 }
3814 offset.u.LowPart = overlapped->u.s.Offset;
3815 offset.u.HighPart = overlapped->u.s.OffsetHigh;
3816
3817 io = (PIO_STATUS_BLOCK)overlapped;
3818 io->u.Status = STATUS_PENDING;
3819 io->Information = 0;
3820
3821 status = NtWriteFile( file, NULL, read_write_apc, completion, io, buffer, count, &offset, NULL );
3822 if (status == STATUS_PENDING) return TRUE;
3823 return set_ntstatus( status );
3824 }
3825
3826
3827 /***********************************************************************
3828 * WriteFileGather (kernelbase.@)
3829 */
3830 BOOL WINAPI DECLSPEC_HOTPATCH WriteFileGather( HANDLE file, FILE_SEGMENT_ELEMENT *segments, DWORD count,
3831 LPDWORD reserved, LPOVERLAPPED overlapped )
3832 {
3833 PIO_STATUS_BLOCK io;
3834 LARGE_INTEGER offset;
3835 void *cvalue = NULL;
3836
3837 TRACE( "%p %p %lu %p\n", file, segments, count, overlapped );
3838
3839 offset.u.LowPart = overlapped->u.s.Offset;
3840 offset.u.HighPart = overlapped->u.s.OffsetHigh;
3841 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
3842 io = (PIO_STATUS_BLOCK)overlapped;
3843 io->u.Status = STATUS_PENDING;
3844 io->Information = 0;
3845
3846 return set_ntstatus( NtWriteFileGather( file, overlapped->hEvent, NULL, cvalue,
3847 io, segments, count, &offset, NULL ));
3848 }
3849
3850
3851 /***********************************************************************
3852 * Operations on file times
3853 ***********************************************************************/
3854
3855
3856 /*********************************************************************
3857 * CompareFileTime (kernelbase.@)
3858 */
3859 INT WINAPI DECLSPEC_HOTPATCH CompareFileTime( const FILETIME *x, const FILETIME *y )
3860 {
3861 if (!x || !y) return -1;
3862 if (x->dwHighDateTime > y->dwHighDateTime) return 1;
3863 if (x->dwHighDateTime < y->dwHighDateTime) return -1;
3864 if (x->dwLowDateTime > y->dwLowDateTime) return 1;
3865 if (x->dwLowDateTime < y->dwLowDateTime) return -1;
3866 return 0;
3867 }
3868
3869
3870 /*********************************************************************
3871 * FileTimeToLocalFileTime (kernelbase.@)
3872 */
3873 BOOL WINAPI DECLSPEC_HOTPATCH FileTimeToLocalFileTime( const FILETIME *utc, FILETIME *local )
3874 {
3875 return set_ntstatus( RtlSystemTimeToLocalTime( (const LARGE_INTEGER *)utc, (LARGE_INTEGER *)local ));
3876 }
3877
3878
3879 /*********************************************************************
3880 * FileTimeToSystemTime (kernelbase.@)
3881 */
3882 BOOL WINAPI DECLSPEC_HOTPATCH FileTimeToSystemTime( const FILETIME *ft, SYSTEMTIME *systime )
3883 {
3884 TIME_FIELDS tf;
3885 const LARGE_INTEGER *li = (const LARGE_INTEGER *)ft;
3886
3887 if (li->QuadPart < 0)
3888 {
3889 SetLastError( ERROR_INVALID_PARAMETER );
3890 return FALSE;
3891 }
3892 RtlTimeToTimeFields( li, &tf );
3893 systime->wYear = tf.Year;
3894 systime->wMonth = tf.Month;
3895 systime->wDay = tf.Day;
3896 systime->wHour = tf.Hour;
3897 systime->wMinute = tf.Minute;
3898 systime->wSecond = tf.Second;
3899 systime->wMilliseconds = tf.Milliseconds;
3900 systime->wDayOfWeek = tf.Weekday;
3901 return TRUE;
3902 }
3903
3904
3905 /*********************************************************************
3906 * GetLocalTime (kernelbase.@)
3907 */
3908 void WINAPI DECLSPEC_HOTPATCH GetLocalTime( SYSTEMTIME *systime )
3909 {
3910 LARGE_INTEGER ft, ft2;
3911
3912 NtQuerySystemTime( &ft );
3913 RtlSystemTimeToLocalTime( &ft, &ft2 );
3914 FileTimeToSystemTime( (FILETIME *)&ft2, systime );
3915 }
3916
3917
3918 /*********************************************************************
3919 * GetSystemTime (kernelbase.@)
3920 */
3921 void WINAPI DECLSPEC_HOTPATCH GetSystemTime( SYSTEMTIME *systime )
3922 {
3923 LARGE_INTEGER ft;
3924
3925 NtQuerySystemTime( &ft );
3926 FileTimeToSystemTime( (FILETIME *)&ft, systime );
3927 }
3928
3929
3930 /***********************************************************************
3931 * GetSystemTimeAdjustment (kernelbase.@)
3932 */
3933 BOOL WINAPI DECLSPEC_HOTPATCH GetSystemTimeAdjustment( DWORD *adjust, DWORD *increment, BOOL *disabled )
3934 {
3935 SYSTEM_TIME_ADJUSTMENT_QUERY st;
3936 ULONG len;
3937
3938 if (!set_ntstatus( NtQuerySystemInformation( SystemTimeAdjustmentInformation, &st, sizeof(st), &len )))
3939 return FALSE;
3940 *adjust = st.TimeAdjustment;
3941 *increment = st.TimeIncrement;
3942 *disabled = st.TimeAdjustmentDisabled;
3943 return TRUE;
3944 }
3945
3946
3947 /***********************************************************************
3948 * GetSystemTimeAsFileTime (kernelbase.@)
3949 */
3950 void WINAPI DECLSPEC_HOTPATCH GetSystemTimeAsFileTime( FILETIME *time )
3951 {
3952 NtQuerySystemTime( (LARGE_INTEGER *)time );
3953 }
3954
3955
3956 /***********************************************************************
3957 * GetSystemTimePreciseAsFileTime (kernelbase.@)
3958 */
3959 void WINAPI DECLSPEC_HOTPATCH GetSystemTimePreciseAsFileTime( FILETIME *time )
3960 {
3961 LARGE_INTEGER t;
3962
3963 t.QuadPart = RtlGetSystemTimePrecise();
3964 time->dwLowDateTime = t.u.LowPart;
3965 time->dwHighDateTime = t.u.HighPart;
3966 }
3967
3968
3969 /*********************************************************************
3970 * LocalFileTimeToFileTime (kernelbase.@)
3971 */
3972 BOOL WINAPI DECLSPEC_HOTPATCH LocalFileTimeToFileTime( const FILETIME *local, FILETIME *utc )
3973 {
3974 return set_ntstatus( RtlLocalTimeToSystemTime( (const LARGE_INTEGER *)local, (LARGE_INTEGER *)utc ));
3975 }
3976
3977
3978 /***********************************************************************
3979 * SetLocalTime (kernelbase.@)
3980 */
3981 BOOL WINAPI DECLSPEC_HOTPATCH SetLocalTime( const SYSTEMTIME *systime )
3982 {
3983 FILETIME ft;
3984 LARGE_INTEGER st;
3985
3986 if (!SystemTimeToFileTime( systime, &ft )) return FALSE;
3987 RtlLocalTimeToSystemTime( (LARGE_INTEGER *)&ft, &st );
3988 return set_ntstatus( NtSetSystemTime( &st, NULL ));
3989 }
3990
3991
3992 /***********************************************************************
3993 * SetSystemTime (kernelbase.@)
3994 */
3995 BOOL WINAPI DECLSPEC_HOTPATCH SetSystemTime( const SYSTEMTIME *systime )
3996 {
3997 FILETIME ft;
3998
3999 if (!SystemTimeToFileTime( systime, &ft )) return FALSE;
4000 return set_ntstatus( NtSetSystemTime( (LARGE_INTEGER *)&ft, NULL ));
4001 }
4002
4003
4004 /***********************************************************************
4005 * SetSystemTimeAdjustment (kernelbase.@)
4006 */
4007 BOOL WINAPI DECLSPEC_HOTPATCH SetSystemTimeAdjustment( DWORD adjust, BOOL disabled )
4008 {
4009 SYSTEM_TIME_ADJUSTMENT st;
4010
4011 st.TimeAdjustment = adjust;
4012 st.TimeAdjustmentDisabled = disabled;
4013 return set_ntstatus( NtSetSystemInformation( SystemTimeAdjustmentInformation, &st, sizeof(st) ));
4014 }
4015
4016
4017 /*********************************************************************
4018 * SystemTimeToFileTime (kernelbase.@)
4019 */
4020 BOOL WINAPI DECLSPEC_HOTPATCH SystemTimeToFileTime( const SYSTEMTIME *systime, FILETIME *ft )
4021 {
4022 TIME_FIELDS tf;
4023
4024 tf.Year = systime->wYear;
4025 tf.Month = systime->wMonth;
4026 tf.Day = systime->wDay;
4027 tf.Hour = systime->wHour;
4028 tf.Minute = systime->wMinute;
4029 tf.Second = systime->wSecond;
4030 tf.Milliseconds = systime->wMilliseconds;
4031 if (RtlTimeFieldsToTime( &tf, (LARGE_INTEGER *)ft )) return TRUE;
4032 SetLastError( ERROR_INVALID_PARAMETER );
4033 return FALSE;
4034 }
4035
4036
4037 /***********************************************************************
4038 * I/O controls
4039 ***********************************************************************/
4040
4041
4042 static void dump_dcb( const DCB *dcb )
4043 {
4044 TRACE( "size=%d rate=%ld fParity=%d Parity=%d stopbits=%d %sIXON %sIXOFF CTS=%d RTS=%d DSR=%d DTR=%d %sCRTSCTS\n",
4045 dcb->ByteSize, dcb->BaudRate, dcb->fParity, dcb->Parity,
4046 (dcb->StopBits == ONESTOPBIT) ? 1 : (dcb->StopBits == TWOSTOPBITS) ? 2 : 0,
4047 dcb->fOutX ? "" : "~", dcb->fInX ? "" : "~",
4048 dcb->fOutxCtsFlow, dcb->fRtsControl, dcb->fOutxDsrFlow, dcb->fDtrControl,
4049 (dcb->fOutxCtsFlow || dcb->fRtsControl == RTS_CONTROL_HANDSHAKE) ? "" : "~" );
4050 }
4051
4052 /*****************************************************************************
4053 * ClearCommBreak (kernelbase.@)
4054 */
4055 BOOL WINAPI DECLSPEC_HOTPATCH ClearCommBreak( HANDLE handle )
4056 {
4057 return EscapeCommFunction( handle, CLRBREAK );
4058 }
4059
4060
4061 /*****************************************************************************
4062 * ClearCommError (kernelbase.@)
4063 */
4064 BOOL WINAPI DECLSPEC_HOTPATCH ClearCommError( HANDLE handle, DWORD *errors, COMSTAT *stat )
4065 {
4066 SERIAL_STATUS ss;
4067
4068 if (!DeviceIoControl( handle, IOCTL_SERIAL_GET_COMMSTATUS, NULL, 0, &ss, sizeof(ss), NULL, NULL ))
4069 return FALSE;
4070
4071 TRACE( "status %#lx,%#lx, in %lu, out %lu, eof %d, wait %d\n", ss.Errors, ss.HoldReasons,
4072 ss.AmountInInQueue, ss.AmountInOutQueue, ss.EofReceived, ss.WaitForImmediate );
4073
4074 if (errors)
4075 {
4076 *errors = 0;
4077 if (ss.Errors & SERIAL_ERROR_BREAK) *errors |= CE_BREAK;
4078 if (ss.Errors & SERIAL_ERROR_FRAMING) *errors |= CE_FRAME;
4079 if (ss.Errors & SERIAL_ERROR_OVERRUN) *errors |= CE_OVERRUN;
4080 if (ss.Errors & SERIAL_ERROR_QUEUEOVERRUN) *errors |= CE_RXOVER;
4081 if (ss.Errors & SERIAL_ERROR_PARITY) *errors |= CE_RXPARITY;
4082 }
4083 if (stat)
4084 {
4085 stat->fCtsHold = !!(ss.HoldReasons & SERIAL_TX_WAITING_FOR_CTS);
4086 stat->fDsrHold = !!(ss.HoldReasons & SERIAL_TX_WAITING_FOR_DSR);
4087 stat->fRlsdHold = !!(ss.HoldReasons & SERIAL_TX_WAITING_FOR_DCD);
4088 stat->fXoffHold = !!(ss.HoldReasons & SERIAL_TX_WAITING_FOR_XON);
4089 stat->fXoffSent = !!(ss.HoldReasons & SERIAL_TX_WAITING_XOFF_SENT);
4090 stat->fEof = !!ss.EofReceived;
4091 stat->fTxim = !!ss.WaitForImmediate;
4092 stat->cbInQue = ss.AmountInInQueue;
4093 stat->cbOutQue = ss.AmountInOutQueue;
4094 }
4095 return TRUE;
4096 }
4097
4098
4099 /****************************************************************************
4100 * DeviceIoControl (kernelbase.@)
4101 */
4102 BOOL WINAPI DECLSPEC_HOTPATCH DeviceIoControl( HANDLE handle, DWORD code, void *in_buff, DWORD in_count,
4103 void *out_buff, DWORD out_count, DWORD *returned,
4104 OVERLAPPED *overlapped )
4105 {
4106 IO_STATUS_BLOCK iosb, *piosb = &iosb;
4107 void *cvalue = NULL;
4108 HANDLE event = 0;
4109 NTSTATUS status;
4110
4111 TRACE( "(%p,%lx,%p,%ld,%p,%ld,%p,%p)\n",
4112 handle, code, in_buff, in_count, out_buff, out_count, returned, overlapped );
4113
4114 if (overlapped)
4115 {
4116 piosb = (IO_STATUS_BLOCK *)overlapped;
4117 if (!((ULONG_PTR)overlapped->hEvent & 1)) cvalue = overlapped;
4118 event = overlapped->hEvent;
4119 overlapped->Internal = STATUS_PENDING;
4120 overlapped->InternalHigh = 0;
4121 }
4122
4123 if (HIWORD(code) == FILE_DEVICE_FILE_SYSTEM)
4124 status = NtFsControlFile( handle, event, NULL, cvalue, piosb, code,
4125 in_buff, in_count, out_buff, out_count );
4126 else
4127 status = NtDeviceIoControlFile( handle, event, NULL, cvalue, piosb, code,
4128 in_buff, in_count, out_buff, out_count );
4129
4130 if (returned && !NT_ERROR(status)) *returned = piosb->Information;
4131 if (status == STATUS_PENDING || !NT_SUCCESS( status )) return set_ntstatus( status );
4132 return TRUE;
4133 }
4134
4135
4136 /*****************************************************************************
4137 * EscapeCommFunction (kernelbase.@)
4138 */
4139 BOOL WINAPI DECLSPEC_HOTPATCH EscapeCommFunction( HANDLE handle, DWORD func )
4140 {
4141 static const DWORD ioctls[] =
4142 {
4143 0,
4144 IOCTL_SERIAL_SET_XOFF, /* SETXOFF */
4145 IOCTL_SERIAL_SET_XON, /* SETXON */
4146 IOCTL_SERIAL_SET_RTS, /* SETRTS */
4147 IOCTL_SERIAL_CLR_RTS, /* CLRRTS */
4148 IOCTL_SERIAL_SET_DTR, /* SETDTR */
4149 IOCTL_SERIAL_CLR_DTR, /* CLRDTR */
4150 IOCTL_SERIAL_RESET_DEVICE, /* RESETDEV */
4151 IOCTL_SERIAL_SET_BREAK_ON, /* SETBREAK */
4152 IOCTL_SERIAL_SET_BREAK_OFF /* CLRBREAK */
4153 };
4154
4155 if (func >= ARRAY_SIZE(ioctls) || !ioctls[func])
4156 {
4157 SetLastError( ERROR_INVALID_PARAMETER );
4158 return FALSE;
4159 }
4160 return DeviceIoControl( handle, ioctls[func], NULL, 0, NULL, 0, NULL, NULL );
4161 }
4162
4163
4164 /***********************************************************************
4165 * GetCommConfig (kernelbase.@)
4166 */
4167 BOOL WINAPI DECLSPEC_HOTPATCH GetCommConfig( HANDLE handle, COMMCONFIG *config, DWORD *size )
4168 {
4169 if (!config) return FALSE;
4170
4171 TRACE( "(%p, %p, %p %lu)\n", handle, config, size, *size );
4172
4173 if (*size < sizeof(COMMCONFIG))
4174 {
4175 *size = sizeof(COMMCONFIG);
4176 return FALSE;
4177 }
4178 *size = sizeof(COMMCONFIG);
4179 config->dwSize = sizeof(COMMCONFIG);
4180 config->wVersion = 1;
4181 config->wReserved = 0;
4182 config->dwProviderSubType = PST_RS232;
4183 config->dwProviderOffset = 0;
4184 config->dwProviderSize = 0;
4185 return GetCommState( handle, &config->dcb );
4186 }
4187
4188
4189 /*****************************************************************************
4190 * GetCommMask (kernelbase.@)
4191 */
4192 BOOL WINAPI DECLSPEC_HOTPATCH GetCommMask( HANDLE handle, DWORD *mask )
4193 {
4194 return DeviceIoControl( handle, IOCTL_SERIAL_GET_WAIT_MASK, NULL, 0, mask, sizeof(*mask),
4195 NULL, NULL );
4196 }
4197
4198
4199 /***********************************************************************
4200 * GetCommModemStatus (kernelbase.@)
4201 */
4202 BOOL WINAPI DECLSPEC_HOTPATCH GetCommModemStatus( HANDLE handle, DWORD *status )
4203 {
4204 return DeviceIoControl( handle, IOCTL_SERIAL_GET_MODEMSTATUS, NULL, 0, status, sizeof(*status),
4205 NULL, NULL );
4206 }
4207
4208
4209 /***********************************************************************
4210 * GetCommProperties (kernelbase.@)
4211 */
4212 BOOL WINAPI DECLSPEC_HOTPATCH GetCommProperties( HANDLE handle, COMMPROP *prop )
4213 {
4214 return DeviceIoControl( handle, IOCTL_SERIAL_GET_PROPERTIES, NULL, 0, prop, sizeof(*prop), NULL, NULL );
4215 }
4216
4217
4218 /*****************************************************************************
4219 * GetCommState (kernelbase.@)
4220 */
4221 BOOL WINAPI DECLSPEC_HOTPATCH GetCommState( HANDLE handle, DCB *dcb )
4222 {
4223 SERIAL_BAUD_RATE sbr;
4224 SERIAL_LINE_CONTROL slc;
4225 SERIAL_HANDFLOW shf;
4226 SERIAL_CHARS sc;
4227
4228 if (!dcb)
4229 {
4230 SetLastError( ERROR_INVALID_PARAMETER );
4231 return FALSE;
4232 }
4233 if (!DeviceIoControl(handle, IOCTL_SERIAL_GET_BAUD_RATE, NULL, 0, &sbr, sizeof(sbr), NULL, NULL) ||
4234 !DeviceIoControl(handle, IOCTL_SERIAL_GET_LINE_CONTROL, NULL, 0, &slc, sizeof(slc), NULL, NULL) ||
4235 !DeviceIoControl(handle, IOCTL_SERIAL_GET_HANDFLOW, NULL, 0, &shf, sizeof(shf), NULL, NULL) ||
4236 !DeviceIoControl(handle, IOCTL_SERIAL_GET_CHARS, NULL, 0, &sc, sizeof(sc), NULL, NULL))
4237 return FALSE;
4238
4239 dcb->DCBlength = sizeof(*dcb);
4240 dcb->BaudRate = sbr.BaudRate;
4241 /* yes, they seem no never be (re)set on NT */
4242 dcb->fBinary = 1;
4243 dcb->fParity = 0;
4244 dcb->fOutxCtsFlow = !!(shf.ControlHandShake & SERIAL_CTS_HANDSHAKE);
4245 dcb->fOutxDsrFlow = !!(shf.ControlHandShake & SERIAL_DSR_HANDSHAKE);
4246 dcb->fDsrSensitivity = !!(shf.ControlHandShake & SERIAL_DSR_SENSITIVITY);
4247 dcb->fTXContinueOnXoff = !!(shf.FlowReplace & SERIAL_XOFF_CONTINUE);
4248 dcb->fOutX = !!(shf.FlowReplace & SERIAL_AUTO_TRANSMIT);
4249 dcb->fInX = !!(shf.FlowReplace & SERIAL_AUTO_RECEIVE);
4250 dcb->fErrorChar = !!(shf.FlowReplace & SERIAL_ERROR_CHAR);
4251 dcb->fNull = !!(shf.FlowReplace & SERIAL_NULL_STRIPPING);
4252 dcb->fAbortOnError = !!(shf.ControlHandShake & SERIAL_ERROR_ABORT);
4253 dcb->XonLim = shf.XonLimit;
4254 dcb->XoffLim = shf.XoffLimit;
4255 dcb->ByteSize = slc.WordLength;
4256 dcb->Parity = slc.Parity;
4257 dcb->StopBits = slc.StopBits;
4258 dcb->XonChar = sc.XonChar;
4259 dcb->XoffChar = sc.XoffChar;
4260 dcb->ErrorChar = sc.ErrorChar;
4261 dcb->EofChar = sc.EofChar;
4262 dcb->EvtChar = sc.EventChar;
4263
4264 switch (shf.ControlHandShake & (SERIAL_DTR_CONTROL | SERIAL_DTR_HANDSHAKE))
4265 {
4266 case SERIAL_DTR_CONTROL: dcb->fDtrControl = DTR_CONTROL_ENABLE; break;
4267 case SERIAL_DTR_HANDSHAKE: dcb->fDtrControl = DTR_CONTROL_HANDSHAKE; break;
4268 default: dcb->fDtrControl = DTR_CONTROL_DISABLE; break;
4269 }
4270 switch (shf.FlowReplace & (SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE))
4271 {
4272 case SERIAL_RTS_CONTROL: dcb->fRtsControl = RTS_CONTROL_ENABLE; break;
4273 case SERIAL_RTS_HANDSHAKE: dcb->fRtsControl = RTS_CONTROL_HANDSHAKE; break;
4274 case SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE:
4275 dcb->fRtsControl = RTS_CONTROL_TOGGLE; break;
4276 default: dcb->fRtsControl = RTS_CONTROL_DISABLE; break;
4277 }
4278 dump_dcb( dcb );
4279 return TRUE;
4280 }
4281
4282
4283 /*****************************************************************************
4284 * GetCommTimeouts (kernelbase.@)
4285 */
4286 BOOL WINAPI DECLSPEC_HOTPATCH GetCommTimeouts( HANDLE handle, COMMTIMEOUTS *timeouts )
4287 {
4288 if (!timeouts)
4289 {
4290 SetLastError( ERROR_INVALID_PARAMETER );
4291 return FALSE;
4292 }
4293 return DeviceIoControl( handle, IOCTL_SERIAL_GET_TIMEOUTS, NULL, 0, timeouts, sizeof(*timeouts),
4294 NULL, NULL );
4295 }
4296
4297 /********************************************************************
4298 * PurgeComm (kernelbase.@)
4299 */
4300 BOOL WINAPI DECLSPEC_HOTPATCH PurgeComm(HANDLE handle, DWORD flags)
4301 {
4302 return DeviceIoControl( handle, IOCTL_SERIAL_PURGE, &flags, sizeof(flags),
4303 NULL, 0, NULL, NULL );
4304 }
4305
4306
4307 /*****************************************************************************
4308 * SetCommBreak (kernelbase.@)
4309 */
4310 BOOL WINAPI DECLSPEC_HOTPATCH SetCommBreak( HANDLE handle )
4311 {
4312 return EscapeCommFunction( handle, SETBREAK );
4313 }
4314
4315
4316 /***********************************************************************
4317 * SetCommConfig (kernelbase.@)
4318 */
4319 BOOL WINAPI DECLSPEC_HOTPATCH SetCommConfig( HANDLE handle, COMMCONFIG *config, DWORD size )
4320 {
4321 TRACE( "(%p, %p, %lu)\n", handle, config, size );
4322 return SetCommState( handle, &config->dcb );
4323 }
4324
4325
4326 /*****************************************************************************
4327 * SetCommMask (kernelbase.@)
4328 */
4329 BOOL WINAPI DECLSPEC_HOTPATCH SetCommMask( HANDLE handle, DWORD mask )
4330 {
4331 return DeviceIoControl( handle, IOCTL_SERIAL_SET_WAIT_MASK, &mask, sizeof(mask),
4332 NULL, 0, NULL, NULL );
4333 }
4334
4335
4336 /*****************************************************************************
4337 * SetCommState (kernelbase.@)
4338 */
4339 BOOL WINAPI DECLSPEC_HOTPATCH SetCommState( HANDLE handle, DCB *dcb )
4340 {
4341 SERIAL_BAUD_RATE sbr;
4342 SERIAL_LINE_CONTROL slc;
4343 SERIAL_HANDFLOW shf;
4344 SERIAL_CHARS sc;
4345
4346 if (!dcb)
4347 {
4348 SetLastError( ERROR_INVALID_PARAMETER );
4349 return FALSE;
4350 }
4351 dump_dcb( dcb );
4352
4353 sbr.BaudRate = dcb->BaudRate;
4354 slc.StopBits = dcb->StopBits;
4355 slc.Parity = dcb->Parity;
4356 slc.WordLength = dcb->ByteSize;
4357 shf.ControlHandShake = 0;
4358 shf.FlowReplace = 0;
4359 if (dcb->fOutxCtsFlow) shf.ControlHandShake |= SERIAL_CTS_HANDSHAKE;
4360 if (dcb->fOutxDsrFlow) shf.ControlHandShake |= SERIAL_DSR_HANDSHAKE;
4361 switch (dcb->fDtrControl)
4362 {
4363 case DTR_CONTROL_DISABLE: break;
4364 case DTR_CONTROL_ENABLE: shf.ControlHandShake |= SERIAL_DTR_CONTROL; break;
4365 case DTR_CONTROL_HANDSHAKE: shf.ControlHandShake |= SERIAL_DTR_HANDSHAKE; break;
4366 default:
4367 SetLastError( ERROR_INVALID_PARAMETER );
4368 return FALSE;
4369 }
4370 switch (dcb->fRtsControl)
4371 {
4372 case RTS_CONTROL_DISABLE: break;
4373 case RTS_CONTROL_ENABLE: shf.FlowReplace |= SERIAL_RTS_CONTROL; break;
4374 case RTS_CONTROL_HANDSHAKE: shf.FlowReplace |= SERIAL_RTS_HANDSHAKE; break;
4375 case RTS_CONTROL_TOGGLE: shf.FlowReplace |= SERIAL_RTS_CONTROL | SERIAL_RTS_HANDSHAKE; break;
4376 default:
4377 SetLastError( ERROR_INVALID_PARAMETER );
4378 return FALSE;
4379 }
4380 if (dcb->fDsrSensitivity) shf.ControlHandShake |= SERIAL_DSR_SENSITIVITY;
4381 if (dcb->fAbortOnError) shf.ControlHandShake |= SERIAL_ERROR_ABORT;
4382 if (dcb->fErrorChar) shf.FlowReplace |= SERIAL_ERROR_CHAR;
4383 if (dcb->fNull) shf.FlowReplace |= SERIAL_NULL_STRIPPING;
4384 if (dcb->fTXContinueOnXoff) shf.FlowReplace |= SERIAL_XOFF_CONTINUE;
4385 if (dcb->fOutX) shf.FlowReplace |= SERIAL_AUTO_TRANSMIT;
4386 if (dcb->fInX) shf.FlowReplace |= SERIAL_AUTO_RECEIVE;
4387 shf.XonLimit = dcb->XonLim;
4388 shf.XoffLimit = dcb->XoffLim;
4389 sc.EofChar = dcb->EofChar;
4390 sc.ErrorChar = dcb->ErrorChar;
4391 sc.BreakChar = 0;
4392 sc.EventChar = dcb->EvtChar;
4393 sc.XonChar = dcb->XonChar;
4394 sc.XoffChar = dcb->XoffChar;
4395
4396 /* note: change DTR/RTS lines after setting the comm attributes,
4397 * so flow control does not interfere.
4398 */
4399 return (DeviceIoControl( handle, IOCTL_SERIAL_SET_BAUD_RATE, &sbr, sizeof(sbr), NULL, 0, NULL, NULL ) &&
4400 DeviceIoControl( handle, IOCTL_SERIAL_SET_LINE_CONTROL, &slc, sizeof(slc), NULL, 0, NULL, NULL ) &&
4401 DeviceIoControl( handle, IOCTL_SERIAL_SET_HANDFLOW, &shf, sizeof(shf), NULL, 0, NULL, NULL ) &&
4402 DeviceIoControl( handle, IOCTL_SERIAL_SET_CHARS, &sc, sizeof(sc), NULL, 0, NULL, NULL ));
4403 }
4404
4405
4406 /*****************************************************************************
4407 * SetCommTimeouts (kernelbase.@)
4408 */
4409 BOOL WINAPI DECLSPEC_HOTPATCH SetCommTimeouts( HANDLE handle, COMMTIMEOUTS *timeouts )
4410 {
4411 if (!timeouts)
4412 {
4413 SetLastError( ERROR_INVALID_PARAMETER );
4414 return FALSE;
4415 }
4416 return DeviceIoControl( handle, IOCTL_SERIAL_SET_TIMEOUTS, timeouts, sizeof(*timeouts),
4417 NULL, 0, NULL, NULL );
4418 }
4419
4420
4421 /*****************************************************************************
4422 * SetupComm (kernelbase.@)
4423 */
4424 BOOL WINAPI DECLSPEC_HOTPATCH SetupComm( HANDLE handle, DWORD in_size, DWORD out_size )
4425 {
4426 SERIAL_QUEUE_SIZE sqs;
4427
4428 sqs.InSize = in_size;
4429 sqs.OutSize = out_size;
4430 return DeviceIoControl( handle, IOCTL_SERIAL_SET_QUEUE_SIZE, &sqs, sizeof(sqs), NULL, 0, NULL, NULL );
4431 }
4432
4433
4434 /*****************************************************************************
4435 * TransmitCommChar (kernelbase.@)
4436 */
4437 BOOL WINAPI DECLSPEC_HOTPATCH TransmitCommChar( HANDLE handle, CHAR ch )
4438 {
4439 return DeviceIoControl( handle, IOCTL_SERIAL_IMMEDIATE_CHAR, &ch, sizeof(ch), NULL, 0, NULL, NULL );
4440 }
4441
4442
4443 /***********************************************************************
4444 * WaitCommEvent (kernelbase.@)
4445 */
4446 BOOL WINAPI DECLSPEC_HOTPATCH WaitCommEvent( HANDLE handle, DWORD *events, OVERLAPPED *overlapped )
4447 {
4448 return DeviceIoControl( handle, IOCTL_SERIAL_WAIT_ON_MASK, NULL, 0, events, sizeof(*events),
4449 NULL, overlapped );
4450 }
Windows API implementation