ReactOS 0.4.15-dev-7934-g1dc8d80
Functions | Variables
IoCreateFile.c File Reference
#include <kmt_test.h>
Include dependency graph for IoCreateFile.c:

Go to the source code of this file.

Functions

static VOID NTAPI KernelModeTest (IN PVOID Context)
 
static VOID NTAPI TestSymlinks (VOID)
 
VOID NTAPI UserModeTest (VOID)
 
 START_TEST (IoCreateFile)
 

Variables

static UNICODE_STRING SystemRoot = RTL_CONSTANT_STRING(L"\\SystemRoot\\")
 
static UNICODE_STRING Regedit = RTL_CONSTANT_STRING(L"regedit.exe")
 
static UNICODE_STRING Foobar = RTL_CONSTANT_STRING(L"foobar.exe")
 
static UNICODE_STRING SystemRootRegedit = RTL_CONSTANT_STRING(L"\\SystemRoot\\regedit.exe")
 
static UNICODE_STRING SystemRootFoobar = RTL_CONSTANT_STRING(L"\\SystemRoot\\foobar.exe")
 
static UNICODE_STRING SystemRootFoobarFoobar = RTL_CONSTANT_STRING(L"\\SystemRoot\\foobar\\foobar.exe")
 
static UNICODE_STRING FoobarFoobar = RTL_CONSTANT_STRING(L"foobar\\foobar.exe")
 

Function Documentation

◆ KernelModeTest()

static VOID NTAPI KernelModeTest ( IN PVOID  Context)
static

Definition at line 21 of file IoCreateFile.c.

22{
23 NTSTATUS Status;
24 IO_STATUS_BLOCK IoStatusBlock;
25 OBJECT_ATTRIBUTES ObjectAttributes;
26 HANDLE ParentHandle, SystemRootHandle, TargetHandle;
27 PFILE_OBJECT ParentFileObject, TargetFileObject, SystemRootFileObject;
28
29 UNREFERENCED_PARAMETER(Context);
30
31 /* Kernelmode mandatory for IoCreateFile */
32 ok(ExGetPreviousMode() == KernelMode, "UserMode returned!\n");
33
34 /* First of all, open \\SystemRoot
35 * We're interested in 3 pieces of information about it:
36 * -> Its target (it's a symlink): \Windows or \ReactOS
37 * -> Its associated File Object
38 * -> Its associated FCB
39 */
40 TargetFileObject = NULL;
41 IoStatusBlock.Status = 0xFFFFFFFF;
42 TargetHandle = INVALID_HANDLE_VALUE;
43 IoStatusBlock.Information = 0xFFFFFFFF;
44 InitializeObjectAttributes(&ObjectAttributes,
45 &SystemRoot,
46 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
47 NULL, NULL);
48 Status = ZwOpenFile(&TargetHandle,
49 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
50 &ObjectAttributes,
51 &IoStatusBlock,
52 FILE_SHARE_READ | FILE_SHARE_WRITE,
53 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
54 ok_eq_hex(Status, STATUS_SUCCESS);
55 ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
56 if (Status == STATUS_SUCCESS)
57 {
58 Status = ObReferenceObjectByHandle(TargetHandle,
59 FILE_READ_DATA,
60 *IoFileObjectType,
61 KernelMode,
62 (PVOID *)&TargetFileObject,
63 NULL);
64 ok_eq_hex(Status, STATUS_SUCCESS);
65 }
66
67 ok(TargetFileObject != NULL, "Not target to continue!\n");
68 if (TargetFileObject == NULL)
69 {
70 if (TargetHandle != INVALID_HANDLE_VALUE)
71 {
72 ObCloseHandle(TargetHandle, KernelMode);
73 }
74 return;
75 }
76
77 /* Open target directory of \SystemRoot\Regedit.exe
78 * This must lead to \SystemRoot opening
79 */
80 IoStatusBlock.Status = 0xFFFFFFFF;
81 IoStatusBlock.Information = 0xFFFFFFFF;
82 InitializeObjectAttributes(&ObjectAttributes,
83 &SystemRootRegedit,
84 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
85 NULL, NULL);
86 Status = IoCreateFile(&ParentHandle,
87 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
88 &ObjectAttributes,
89 &IoStatusBlock,
90 NULL,
91 0,
92 FILE_SHARE_READ | FILE_SHARE_WRITE,
93 FILE_OPEN,
94 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
95 NULL,
96 0,
97 CreateFileTypeNone,
98 NULL,
99 IO_OPEN_TARGET_DIRECTORY);
100 ok_eq_hex(Status, STATUS_SUCCESS);
101 ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
102 if (Status == STATUS_SUCCESS)
103 {
104 Status = ObReferenceObjectByHandle(ParentHandle,
105 FILE_READ_DATA,
106 *IoFileObjectType,
107 KernelMode,
108 (PVOID *)&ParentFileObject,
109 NULL);
110 ok_eq_hex(Status, STATUS_SUCCESS);
111 if (Status == STATUS_SUCCESS)
112 {
113 /* At that point, file object must point to \SystemRoot
114 * But must not be the same FO than target (diverted file object)
115 * This means FCB & FileName are equal
116 * But CCB & FO are different
117 * CCB must be != NULL, otherwise it means open failed
118 */
119 ok(ParentFileObject != TargetFileObject, "Diverted file object must be different\n");
120 ok_eq_pointer(ParentFileObject->RelatedFileObject, NULL);
121 ok_eq_pointer(ParentFileObject->FsContext, TargetFileObject->FsContext);
122 ok(ParentFileObject->FsContext2 != 0x0, "Parent must be open!\n");
123 ok(ParentFileObject->FsContext2 != TargetFileObject->FsContext2, "Parent open must have its own context!\n");
124 ok_eq_long(RtlCompareUnicodeString(&ParentFileObject->FileName, &TargetFileObject->FileName, FALSE), 0);
125 ObDereferenceObject(ParentFileObject);
126 }
127 /* Because target exists FSD must signal it */
128 ok_eq_long(IoStatusBlock.Information, FILE_EXISTS);
129 ObCloseHandle(ParentHandle, KernelMode);
130 }
131
132 /* Do the same with relative open */
133 IoStatusBlock.Status = 0xFFFFFFFF;
134 IoStatusBlock.Information = 0xFFFFFFFF;
135 InitializeObjectAttributes(&ObjectAttributes,
136 &SystemRoot,
137 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
138 NULL, NULL);
139 Status = ZwOpenFile(&SystemRootHandle,
140 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
141 &ObjectAttributes,
142 &IoStatusBlock,
143 FILE_SHARE_READ | FILE_SHARE_WRITE,
144 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
145 ok_eq_hex(Status, STATUS_SUCCESS);
146 ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
147 if (Status == STATUS_SUCCESS)
148 {
149 IoStatusBlock.Status = 0xFFFFFFFF;
150 IoStatusBlock.Information = 0xFFFFFFFF;
151 InitializeObjectAttributes(&ObjectAttributes,
152 &Regedit,
153 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
154 SystemRootHandle,
155 NULL);
156 Status = IoCreateFile(&ParentHandle,
157 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
158 &ObjectAttributes,
159 &IoStatusBlock,
160 NULL,
161 0,
162 FILE_SHARE_READ | FILE_SHARE_WRITE,
163 FILE_OPEN,
164 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
165 NULL,
166 0,
167 CreateFileTypeNone,
168 NULL,
169 IO_OPEN_TARGET_DIRECTORY);
170 ok_eq_hex(Status, STATUS_SUCCESS);
171 ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
172 if (Status == STATUS_SUCCESS)
173 {
174 Status = ObReferenceObjectByHandle(ParentHandle,
175 FILE_READ_DATA,
176 *IoFileObjectType,
177 KernelMode,
178 (PVOID *)&ParentFileObject,
179 NULL);
180 ok_eq_hex(Status, STATUS_SUCCESS);
181 if (Status == STATUS_SUCCESS)
182 {
183 ok(ParentFileObject != TargetFileObject, "Diverted file object must be different\n");
184 ok_eq_pointer(ParentFileObject->FsContext, TargetFileObject->FsContext);
185 ok(ParentFileObject->FsContext2 != 0x0, "Parent must be open!\n");
186 ok(ParentFileObject->FsContext2 != TargetFileObject->FsContext2, "Parent open must have its own context!\n");
187 ok_eq_long(RtlCompareUnicodeString(&ParentFileObject->FileName, &TargetFileObject->FileName, FALSE), 0);
188 Status = ObReferenceObjectByHandle(SystemRootHandle,
189 FILE_READ_DATA,
190 *IoFileObjectType,
191 KernelMode,
192 (PVOID *)&SystemRootFileObject,
193 NULL);
194 ok_eq_hex(Status, STATUS_SUCCESS);
195 if (Status == STATUS_SUCCESS)
196 {
197 ok_eq_pointer(ParentFileObject->RelatedFileObject, SystemRootFileObject);
198 ok(ParentFileObject->RelatedFileObject != TargetFileObject, "File objects must be different\n");
199 ok(SystemRootFileObject != TargetFileObject, "File objects must be different\n");
200 ObDereferenceObject(SystemRootFileObject);
201 }
202 ObDereferenceObject(ParentFileObject);
203 }
204 ok_eq_long(IoStatusBlock.Information, FILE_EXISTS);
205 ObCloseHandle(ParentHandle, KernelMode);
206 }
207 ObCloseHandle(SystemRootHandle, KernelMode);
208 }
209
210 /* *** */
211
212 /* Now redo the same scheme, but using a target that doesn't exist
213 * The difference will be in IoStatusBlock.Information, the FSD will
214 * inform that the target doesn't exist.
215 * Clear for rename :-)
216 */
217 IoStatusBlock.Status = 0xFFFFFFFF;
218 IoStatusBlock.Information = 0xFFFFFFFF;
219 InitializeObjectAttributes(&ObjectAttributes,
220 &SystemRootFoobar,
221 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
222 NULL, NULL);
223 Status = IoCreateFile(&ParentHandle,
224 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
225 &ObjectAttributes,
226 &IoStatusBlock,
227 NULL,
228 0,
229 FILE_SHARE_READ | FILE_SHARE_WRITE,
230 FILE_OPEN,
231 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
232 NULL,
233 0,
234 CreateFileTypeNone,
235 NULL,
236 IO_OPEN_TARGET_DIRECTORY);
237 ok_eq_hex(Status, STATUS_SUCCESS);
238 ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
239 if (Status == STATUS_SUCCESS)
240 {
241 Status = ObReferenceObjectByHandle(ParentHandle,
242 FILE_READ_DATA,
243 *IoFileObjectType,
244 KernelMode,
245 (PVOID *)&ParentFileObject,
246 NULL);
247 ok_eq_hex(Status, STATUS_SUCCESS);
248 if (Status == STATUS_SUCCESS)
249 {
250 ok(ParentFileObject != TargetFileObject, "Diverted file object must be different\n");
251 ok_eq_pointer(ParentFileObject->RelatedFileObject, NULL);
252 ok_eq_pointer(ParentFileObject->FsContext, TargetFileObject->FsContext);
253 ok(ParentFileObject->FsContext2 != 0x0, "Parent must be open!\n");
254 ok(ParentFileObject->FsContext2 != TargetFileObject->FsContext2, "Parent open must have its own context!\n");
255 ok_eq_long(RtlCompareUnicodeString(&ParentFileObject->FileName, &TargetFileObject->FileName, FALSE), 0);
256 ObDereferenceObject(ParentFileObject);
257 }
258 ok_eq_long(IoStatusBlock.Information, FILE_DOES_NOT_EXIST);
259 ObCloseHandle(ParentHandle, KernelMode);
260 }
261
262 IoStatusBlock.Status = 0xFFFFFFFF;
263 IoStatusBlock.Information = 0xFFFFFFFF;
264 InitializeObjectAttributes(&ObjectAttributes,
265 &SystemRoot,
266 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
267 NULL, NULL);
268 Status = ZwOpenFile(&SystemRootHandle,
269 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
270 &ObjectAttributes,
271 &IoStatusBlock,
272 FILE_SHARE_READ | FILE_SHARE_WRITE,
273 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
274 ok_eq_hex(Status, STATUS_SUCCESS);
275 ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
276 if (Status == STATUS_SUCCESS)
277 {
278 IoStatusBlock.Status = 0xFFFFFFFF;
279 IoStatusBlock.Information = 0xFFFFFFFF;
280 InitializeObjectAttributes(&ObjectAttributes,
281 &Foobar,
282 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
283 SystemRootHandle,
284 NULL);
285 Status = IoCreateFile(&ParentHandle,
286 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
287 &ObjectAttributes,
288 &IoStatusBlock,
289 NULL,
290 0,
291 FILE_SHARE_READ | FILE_SHARE_WRITE,
292 FILE_OPEN,
293 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
294 NULL,
295 0,
296 CreateFileTypeNone,
297 NULL,
298 IO_OPEN_TARGET_DIRECTORY);
299 ok_eq_hex(Status, STATUS_SUCCESS);
300 ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
301 if (Status == STATUS_SUCCESS)
302 {
303 Status = ObReferenceObjectByHandle(ParentHandle,
304 FILE_READ_DATA,
305 *IoFileObjectType,
306 KernelMode,
307 (PVOID *)&ParentFileObject,
308 NULL);
309 ok_eq_hex(Status, STATUS_SUCCESS);
310 if (Status == STATUS_SUCCESS)
311 {
312 ok(ParentFileObject != TargetFileObject, "Diverted file object must be different\n");
313 ok_eq_pointer(ParentFileObject->FsContext, TargetFileObject->FsContext);
314 ok(ParentFileObject->FsContext2 != 0x0, "Parent must be open!\n");
315 ok(ParentFileObject->FsContext2 != TargetFileObject->FsContext2, "Parent open must have its own context!\n");
316 ok_eq_long(RtlCompareUnicodeString(&ParentFileObject->FileName, &TargetFileObject->FileName, FALSE), 0);
317 Status = ObReferenceObjectByHandle(SystemRootHandle,
318 FILE_READ_DATA,
319 *IoFileObjectType,
320 KernelMode,
321 (PVOID *)&SystemRootFileObject,
322 NULL);
323 ok_eq_hex(Status, STATUS_SUCCESS);
324 if (Status == STATUS_SUCCESS)
325 {
326 ok_eq_pointer(ParentFileObject->RelatedFileObject, SystemRootFileObject);
327 ok(ParentFileObject->RelatedFileObject != TargetFileObject, "File objects must be different\n");
328 ok(SystemRootFileObject != TargetFileObject, "File objects must be different\n");
329 ObDereferenceObject(SystemRootFileObject);
330 }
331 ObDereferenceObject(ParentFileObject);
332 }
333 ok_eq_long(IoStatusBlock.Information, FILE_DOES_NOT_EXIST);
334 ObCloseHandle(ParentHandle, KernelMode);
335 }
336 ObCloseHandle(SystemRootHandle, KernelMode);
337 }
338
339 ObDereferenceObject(TargetFileObject);
340 ObCloseHandle(TargetHandle, KernelMode);
341
342 /* *** */
343
344 /* Direct target open of something that doesn't exist */
345 IoStatusBlock.Status = 0xFFFFFFFF;
346 IoStatusBlock.Information = 0xFFFFFFFF;
347 InitializeObjectAttributes(&ObjectAttributes,
348 &SystemRootFoobarFoobar,
349 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
350 NULL, NULL);
351 Status = IoCreateFile(&ParentHandle,
352 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
353 &ObjectAttributes,
354 &IoStatusBlock,
355 NULL,
356 0,
357 FILE_SHARE_READ | FILE_SHARE_WRITE,
358 FILE_OPEN,
359 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
360 NULL,
361 0,
362 CreateFileTypeNone,
363 NULL,
364 IO_OPEN_TARGET_DIRECTORY);
365 ok_eq_hex(Status, STATUS_OBJECT_PATH_NOT_FOUND);
366 ok_eq_hex(IoStatusBlock.Status, 0xFFFFFFFF);
367 if (Status == STATUS_SUCCESS)
368 {
369 ObCloseHandle(ParentHandle, KernelMode);
370 }
371
372 /* Relative target open of something that doesn't exist */
373 IoStatusBlock.Status = 0xFFFFFFFF;
374 IoStatusBlock.Information = 0xFFFFFFFF;
375 InitializeObjectAttributes(&ObjectAttributes,
376 &SystemRoot,
377 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
378 NULL, NULL);
379 Status = ZwOpenFile(&SystemRootHandle,
380 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
381 &ObjectAttributes,
382 &IoStatusBlock,
383 FILE_SHARE_READ | FILE_SHARE_WRITE,
384 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
385 ok_eq_hex(Status, STATUS_SUCCESS);
386 ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
387 if (Status == STATUS_SUCCESS)
388 {
389 IoStatusBlock.Status = 0xFFFFFFFF;
390 IoStatusBlock.Information = 0xFFFFFFFF;
391 InitializeObjectAttributes(&ObjectAttributes,
392 &FoobarFoobar,
393 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
394 SystemRootHandle,
395 NULL);
396 Status = IoCreateFile(&ParentHandle,
397 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
398 &ObjectAttributes,
399 &IoStatusBlock,
400 NULL,
401 0,
402 FILE_SHARE_READ | FILE_SHARE_WRITE,
403 FILE_OPEN,
404 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
405 NULL,
406 0,
407 CreateFileTypeNone,
408 NULL,
409 IO_OPEN_TARGET_DIRECTORY);
410 ok_eq_hex(Status, STATUS_OBJECT_PATH_NOT_FOUND);
411 ok_eq_hex(IoStatusBlock.Status, 0xFFFFFFFF);
412 if (Status == STATUS_SUCCESS)
413 {
414 ObCloseHandle(ParentHandle, KernelMode);
415 }
416 ObCloseHandle(SystemRootHandle, KernelMode);
417 }
418}
Regedit
static UNICODE_STRING Regedit
Definition: IoCreateFile.c:11
Foobar
static UNICODE_STRING Foobar
Definition: IoCreateFile.c:12
SystemRootRegedit
static UNICODE_STRING SystemRootRegedit
Definition: IoCreateFile.c:13
SystemRootFoobar
static UNICODE_STRING SystemRootFoobar
Definition: IoCreateFile.c:14
SystemRoot
static UNICODE_STRING SystemRoot
Definition: IoCreateFile.c:10
SystemRootFoobarFoobar
static UNICODE_STRING SystemRootFoobarFoobar
Definition: IoCreateFile.c:15
FoobarFoobar
static UNICODE_STRING FoobarFoobar
Definition: IoCreateFile.c:16
ok_eq_pointer
#define ok_eq_pointer(value, expected)
Definition: apitest.h:59
ok_eq_hex
#define ok_eq_hex(value, expected)
Definition: apitest.h:77
ok_eq_long
#define ok_eq_long(value, expected)
Definition: apitest.h:62
ok
#define ok(value,...)
Definition: atltest.h:57
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
FILE_DIRECTORY_FILE
#define FILE_DIRECTORY_FILE
Definition: constants.h:491
ObjectAttributes
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
NULL
#define NULL
Definition: types.h:112
FALSE
#define FALSE
Definition: types.h:117
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135
FILE_SHARE_READ
#define FILE_SHARE_READ
Definition: compat.h:136
RtlCompareUnicodeString
ULONG RtlCompareUnicodeString(PUNICODE_STRING s1, PUNICODE_STRING s2, BOOLEAN UpCase)
Definition: string_lib.cpp:31
ExGetPreviousMode
#define ExGetPreviousMode
Definition: ex.h:140
FILE_OPEN
#define FILE_OPEN
Definition: from_kernel.h:54
FILE_SYNCHRONOUS_IO_NONALERT
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
Status
Status
Definition: gdiplustypes.h:25
OBJ_KERNEL_HANDLE
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
OBJ_CASE_INSENSITIVE
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
IoFileObjectType
POBJECT_TYPE IoFileObjectType
Definition: iomgr.c:36
IoStatusBlock
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
KernelMode
#define KernelMode
Definition: asm.h:34
ZwOpenFile
NTSYSAPI NTSTATUS NTAPI ZwOpenFile(_Out_ PHANDLE FileHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes, _Out_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG ShareAccess, _In_ ULONG OpenOptions)
TargetHandle
_In_ HANDLE _In_opt_ HANDLE _Out_opt_ PHANDLE TargetHandle
Definition: obfuncs.h:431
FILE_SHARE_WRITE
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
SYNCHRONIZE
#define SYNCHRONIZE
Definition: nt_native.h:61
FILE_DOES_NOT_EXIST
#define FILE_DOES_NOT_EXIST
Definition: nt_native.h:773
FILE_READ_DATA
#define FILE_READ_DATA
Definition: nt_native.h:628
FILE_EXISTS
#define FILE_EXISTS
Definition: nt_native.h:772
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:317
IoCreateFile
NTSTATUS NTAPI IoCreateFile(OUT PHANDLE FileHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER AllocationSize OPTIONAL, IN ULONG FileAttributes, IN ULONG ShareAccess, IN ULONG Disposition, IN ULONG CreateOptions, IN PVOID EaBuffer OPTIONAL, IN ULONG EaLength, IN CREATE_FILE_TYPE CreateFileType, IN PVOID ExtraCreateParameters OPTIONAL, IN ULONG Options)
Definition: file.c:3010
ObCloseHandle
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
ObReferenceObjectByHandle
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
_IO_STATUS_BLOCK::Status
ULONG Status
Definition: env_spec_w32.h:871
_IO_STATUS_BLOCK::Information
ULONG Information
Definition: env_spec_w32.h:872
_OBJECT_ATTRIBUTES
Definition: umtypes.h:182
STATUS_OBJECT_PATH_NOT_FOUND
#define STATUS_OBJECT_PATH_NOT_FOUND
Definition: udferr_usr.h:151
IO_OPEN_TARGET_DIRECTORY
#define IO_OPEN_TARGET_DIRECTORY
Definition: iotypes.h:7352
PFILE_OBJECT
* PFILE_OBJECT
Definition: iotypes.h:1998
CreateFileTypeNone
@ CreateFileTypeNone
Definition: iotypes.h:535
ObDereferenceObject
#define ObDereferenceObject
Definition: obfuncs.h:203

Referenced by START_TEST().

◆ START_TEST()

START_TEST ( IoCreateFile  )

Definition at line 872 of file IoCreateFile.c.

873{
874 PKTHREAD ThreadHandle;
875
876 TestSymlinks();
877
878 /* Justify the next comment/statement */
879 UserModeTest();
880
881 /* We've to be in kernel mode, so spawn a thread */
882 ThreadHandle = KmtStartThread(KernelModeTest, NULL);
883 KmtFinishThread(ThreadHandle, NULL);
884}
TestSymlinks
static VOID NTAPI TestSymlinks(VOID)
Definition: IoCreateFile.c:423
KernelModeTest
static VOID NTAPI KernelModeTest(IN PVOID Context)
Definition: IoCreateFile.c:21
UserModeTest
VOID NTAPI UserModeTest(VOID)
Definition: IoCreateFile.c:787
KmtStartThread
PKTHREAD KmtStartThread(IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext OPTIONAL)
Definition: kmt_test_kernel.h:136
KmtFinishThread
VOID KmtFinishThread(IN PKTHREAD Thread OPTIONAL, IN PKEVENT Event OPTIONAL)
Definition: kmt_test_kernel.h:171
_KTHREAD
Definition: ketypes.h:1660

◆ TestSymlinks()

static VOID NTAPI TestSymlinks ( VOID  )
static

Definition at line 423 of file IoCreateFile.c.

424{
425 HANDLE ReparseHandle;
426 NTSTATUS Status;
427 IO_STATUS_BLOCK IoStatusBlock;
428 OBJECT_ATTRIBUTES ObjectAttributes;
429 PREPARSE_DATA_BUFFER Reparse;
430 FILE_DISPOSITION_INFORMATION ToDelete;
431 PFILE_OBJECT FileObject;
432 UNICODE_STRING SysDir, Foobar, Regedit;
433 ULONG Size;
434
435 /* Get Windows/ReactOS directory */
436 InitializeObjectAttributes(&ObjectAttributes,
437 &SystemRoot,
438 OBJ_CASE_INSENSITIVE,
439 NULL,
440 NULL);
441 Status = ZwOpenFile(&ReparseHandle,
442 FILE_READ_DATA,
443 &ObjectAttributes,
444 &IoStatusBlock,
445 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
446 FILE_DIRECTORY_FILE);
447 if (skip(NT_SUCCESS(Status), "Opening \\SystemRoot failed: %lx\n", Status))
448 {
449 return;
450 }
451
452 Status = ObReferenceObjectByHandle(ReparseHandle,
453 FILE_READ_DATA,
454 *IoFileObjectType,
455 UserMode,
456 (PVOID *)&FileObject,
457 NULL);
458 if (skip(NT_SUCCESS(Status), "Querying name failed: %lx\n", Status))
459 {
460 ZwClose(ReparseHandle);
461 return;
462 }
463
464 SysDir.Buffer = ExAllocatePool(NonPagedPool, FileObject->FileName.Length + sizeof(L"\\??\\C:"));
465 if (skip(SysDir.Buffer != NULL, "Allocating memory failed\n"))
466 {
467 ObDereferenceObject(FileObject);
468 ZwClose(ReparseHandle);
469 return;
470 }
471
472 SysDir.Length = sizeof(L"\\??\\C:") - sizeof(UNICODE_NULL);
473 SysDir.MaximumLength = FileObject->FileName.Length + sizeof(L"\\??\\C:");
474 RtlCopyMemory(SysDir.Buffer, L"\\??\\C:", sizeof(L"\\??\\C:") - sizeof(UNICODE_NULL));
475 RtlAppendUnicodeStringToString(&SysDir, &FileObject->FileName);
476
477 Foobar.Buffer = ExAllocatePool(NonPagedPool, FileObject->FileName.Length + sizeof(L"\\foobar.exe"));
478 if (skip(Foobar.Buffer != NULL, "Allocating memory failed\n"))
479 {
480 ExFreePool(SysDir.Buffer);
481 ObDereferenceObject(FileObject);
482 ZwClose(ReparseHandle);
483 return;
484 }
485
486 Foobar.Length = 0;
487 Foobar.MaximumLength = FileObject->FileName.Length + sizeof(L"\\foobar.exe");
488 RtlCopyUnicodeString(&Foobar, &FileObject->FileName);
489 RtlCopyMemory(&Foobar.Buffer[Foobar.Length / sizeof(WCHAR)], L"\\foobar.exe", sizeof(L"\\foobar.exe") - sizeof(UNICODE_NULL));
490 Foobar.Length += (sizeof(L"\\foobar.exe") - sizeof(UNICODE_NULL));
491
492 Regedit.Buffer = ExAllocatePool(NonPagedPool, FileObject->FileName.Length + sizeof(L"\\regedit.exe"));
493 if (skip(Regedit.Buffer != NULL, "Allocating memory failed\n"))
494 {
495 ExFreePool(Foobar.Buffer);
496 ExFreePool(SysDir.Buffer);
497 ObDereferenceObject(FileObject);
498 ZwClose(ReparseHandle);
499 return;
500 }
501
502 Regedit.Length = 0;
503 Regedit.MaximumLength = FileObject->FileName.Length + sizeof(L"\\regedit.exe");
504 RtlCopyUnicodeString(&Regedit, &FileObject->FileName);
505 RtlCopyMemory(&Regedit.Buffer[Regedit.Length / sizeof(WCHAR)], L"\\regedit.exe", sizeof(L"\\regedit.exe") - sizeof(UNICODE_NULL));
506 Regedit.Length += (sizeof(L"\\regedit.exe") - sizeof(UNICODE_NULL));
507
508 ObDereferenceObject(FileObject);
509 ZwClose(ReparseHandle);
510
511 ToDelete.DeleteFile = TRUE;
512 Size = FIELD_OFFSET(REPARSE_DATA_BUFFER, SymbolicLinkReparseBuffer.PathBuffer) + SysDir.Length * 2 + sizeof(L"\\regedit.exe") * 2 - sizeof(L"\\??\\") - sizeof(UNICODE_NULL);
513
514 InitializeObjectAttributes(&ObjectAttributes,
515 &SystemRootFoobar,
516 OBJ_CASE_INSENSITIVE,
517 NULL,
518 NULL);
519 Status = ZwCreateFile(&ReparseHandle,
520 GENERIC_READ | GENERIC_WRITE | DELETE,
521 &ObjectAttributes,
522 &IoStatusBlock,
523 NULL,
524 FILE_ATTRIBUTE_NORMAL,
525 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
526 FILE_SUPERSEDE,
527 FILE_NON_DIRECTORY_FILE,
528 NULL,
529 0);
530 ok_eq_hex(Status, STATUS_SUCCESS);
531 if (skip(NT_SUCCESS(Status), "Creating file failed: %lx\n", Status))
532 {
533 ExFreePool(Regedit.Buffer);
534 ExFreePool(Foobar.Buffer);
535 ExFreePool(SysDir.Buffer);
536 return;
537 }
538
539 Reparse = ExAllocatePool(NonPagedPool, Size);
540 RtlZeroMemory(Reparse, Size);
541 Reparse->ReparseTag = IO_REPARSE_TAG_SYMLINK;
542 Reparse->ReparseDataLength = 12 + SysDir.Length * 2 + sizeof(L"\\regedit.exe") * 2 - sizeof(L"\\??\\") - sizeof(UNICODE_NULL);
543 Reparse->SymbolicLinkReparseBuffer.SubstituteNameLength = SysDir.Length + sizeof(L"\\regedit.exe") - sizeof(UNICODE_NULL);
544 Reparse->SymbolicLinkReparseBuffer.PrintNameLength = SysDir.Length + sizeof(L"\\regedit.exe") - sizeof(L"\\??\\");
545 Reparse->SymbolicLinkReparseBuffer.SubstituteNameOffset = Reparse->SymbolicLinkReparseBuffer.PrintNameLength;
546 RtlCopyMemory(Reparse->SymbolicLinkReparseBuffer.PathBuffer,
547 (WCHAR *)((ULONG_PTR)SysDir.Buffer + sizeof(L"\\??\\") - sizeof(UNICODE_NULL)),
548 SysDir.Length - sizeof(L"\\??\\") + sizeof(UNICODE_NULL));
549 RtlCopyMemory((WCHAR *)((ULONG_PTR)Reparse->SymbolicLinkReparseBuffer.PathBuffer + SysDir.Length - sizeof(L"\\??\\") + sizeof(UNICODE_NULL)),
550 L"\\regedit.exe", sizeof(L"\\regedit.exe") - sizeof(UNICODE_NULL));
551 RtlCopyMemory((WCHAR *)((ULONG_PTR)Reparse->SymbolicLinkReparseBuffer.PathBuffer + Reparse->SymbolicLinkReparseBuffer.SubstituteNameOffset),
552 SysDir.Buffer, SysDir.Length);
553 RtlCopyMemory((WCHAR *)((ULONG_PTR)Reparse->SymbolicLinkReparseBuffer.PathBuffer + Reparse->SymbolicLinkReparseBuffer.SubstituteNameOffset + SysDir.Length),
554 L"\\regedit.exe", sizeof(L"\\regedit.exe") - sizeof(UNICODE_NULL));
555
556 Status = ZwFsControlFile(ReparseHandle,
557 NULL,
558 NULL,
559 NULL,
560 &IoStatusBlock,
561 FSCTL_SET_REPARSE_POINT,
562 Reparse,
563 Size,
564 NULL,
565 0);
566 ok_eq_hex(Status, STATUS_SUCCESS);
567 if (!NT_SUCCESS(Status))
568 {
569 ZwClose(ReparseHandle);
570
571 Status = ZwCreateFile(&ReparseHandle,
572 FILE_WRITE_ATTRIBUTES | DELETE | SYNCHRONIZE,
573 &ObjectAttributes,
574 &IoStatusBlock,
575 NULL,
576 FILE_ATTRIBUTE_NORMAL,
577 0,
578 FILE_SUPERSEDE,
579 FILE_NON_DIRECTORY_FILE | FILE_OPEN_REPARSE_POINT | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT,
580 NULL,
581 0);
582 if (skip(NT_SUCCESS(Status), "Creating symlink failed: %lx\n", Status))
583 {
584 Status = ZwOpenFile(&ReparseHandle,
585 DELETE,
586 &ObjectAttributes,
587 &IoStatusBlock,
588 FILE_SHARE_DELETE,
589 FILE_NON_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE);
590 ok_eq_hex(Status, STATUS_SUCCESS);
591 ZwClose(ReparseHandle);
592 ExFreePool(Regedit.Buffer);
593 ExFreePool(Foobar.Buffer);
594 ExFreePool(SysDir.Buffer);
595 ExFreePool(Reparse);
596 return;
597 }
598
599 Status = ZwFsControlFile(ReparseHandle,
600 NULL,
601 NULL,
602 NULL,
603 &IoStatusBlock,
604 FSCTL_SET_REPARSE_POINT,
605 Reparse,
606 Size,
607 NULL,
608 0);
609 }
610
611 if (skip(NT_SUCCESS(Status), "Creating symlink failed: %lx\n", Status))
612 {
613 ZwSetInformationFile(ReparseHandle,
614 &IoStatusBlock,
615 &ToDelete,
616 sizeof(ToDelete),
617 FileDispositionInformation);
618 ZwClose(ReparseHandle);
619 ExFreePool(Regedit.Buffer);
620 ExFreePool(Foobar.Buffer);
621 ExFreePool(SysDir.Buffer);
622 ExFreePool(Reparse);
623 return;
624 }
625
626 ZwClose(ReparseHandle);
627
628 Status = ZwCreateFile(&ReparseHandle,
629 GENERIC_READ,
630 &ObjectAttributes,
631 &IoStatusBlock,
632 NULL,
633 FILE_ATTRIBUTE_NORMAL,
634 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
635 FILE_OPEN,
636 FILE_NON_DIRECTORY_FILE,
637 NULL,
638 0);
639 ok(Status == STATUS_SUCCESS || /* Windows Vista+ */
640 Status == STATUS_IO_REPARSE_TAG_NOT_HANDLED, /* Windows 2003 (SP1, SP2) */
641 "ZwCreateFile returned unexpected status: %lx\n", Status);
642 if (NT_SUCCESS(Status))
643 {
644 Status = ObReferenceObjectByHandle(ReparseHandle,
645 FILE_READ_DATA,
646 *IoFileObjectType,
647 UserMode,
648 (PVOID *)&FileObject,
649 NULL);
650 ok_eq_hex(Status, STATUS_SUCCESS);
651 if (NT_SUCCESS(Status))
652 {
653 ok(RtlCompareUnicodeString(&Regedit, &FileObject->FileName, TRUE) == 0,
654 "Expected: %wZ. Opened: %wZ\n", &Regedit, &FileObject->FileName);
655 ObDereferenceObject(FileObject);
656 }
657
658 ZwClose(ReparseHandle);
659 }
660
661 ExFreePool(Regedit.Buffer);
662
663 Status = IoCreateFile(&ReparseHandle,
664 GENERIC_READ,
665 &ObjectAttributes,
666 &IoStatusBlock,
667 NULL,
668 FILE_ATTRIBUTE_NORMAL,
669 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
670 FILE_OPEN,
671 FILE_NON_DIRECTORY_FILE,
672 NULL,
673 0,
674 CreateFileTypeNone,
675 NULL,
676 IO_NO_PARAMETER_CHECKING | IO_STOP_ON_SYMLINK);
677 ok(Status == STATUS_STOPPED_ON_SYMLINK || /* Windows Vista+ */
678 Status == STATUS_IO_REPARSE_TAG_NOT_HANDLED, /* Windows 2003 (SP1, SP2) */
679 "ZwCreateFile returned unexpected status: %lx\n", Status);
680 if (NT_SUCCESS(Status))
681 {
682 ZwClose(ReparseHandle);
683 }
684
685 Status = ZwCreateFile(&ReparseHandle,
686 GENERIC_READ | GENERIC_WRITE | DELETE,
687 &ObjectAttributes,
688 &IoStatusBlock,
689 NULL,
690 FILE_ATTRIBUTE_NORMAL,
691 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
692 FILE_OPEN,
693 FILE_NON_DIRECTORY_FILE | FILE_OPEN_REPARSE_POINT | FILE_OPEN_FOR_BACKUP_INTENT,
694 NULL,
695 0);
696 if (skip(NT_SUCCESS(Status), "Creating opening reparse point: %lx\n", Status))
697 {
698 Status = ZwOpenFile(&ReparseHandle,
699 DELETE,
700 &ObjectAttributes,
701 &IoStatusBlock,
702 FILE_SHARE_DELETE,
703 FILE_NON_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE);
704 ok_eq_hex(Status, STATUS_SUCCESS);
705 ZwClose(ReparseHandle);
706 ExFreePool(Foobar.Buffer);
707 ExFreePool(SysDir.Buffer);
708 ExFreePool(Reparse);
709 return;
710 }
711
712 Status = ObReferenceObjectByHandle(ReparseHandle,
713 FILE_READ_DATA,
714 *IoFileObjectType,
715 UserMode,
716 (PVOID *)&FileObject,
717 NULL);
718 ok_eq_hex(Status, STATUS_SUCCESS);
719 if (NT_SUCCESS(Status))
720 {
721 ok(RtlCompareUnicodeString(&Foobar, &FileObject->FileName, TRUE) == 0,
722 "Expected: %wZ. Opened: %wZ\n", &Foobar, &FileObject->FileName);
723 ObDereferenceObject(FileObject);
724 }
725
726 ExFreePool(Foobar.Buffer);
727
728 RtlZeroMemory(Reparse, Size);
729 Status = ZwFsControlFile(ReparseHandle,
730 NULL,
731 NULL,
732 NULL,
733 &IoStatusBlock,
734 FSCTL_GET_REPARSE_POINT,
735 NULL,
736 0,
737 Reparse,
738 Size);
739 ok_eq_hex(Status, STATUS_SUCCESS);
740 ok_eq_hex(IoStatusBlock.Information, Size);
741 if (NT_SUCCESS(Status))
742 {
743 PWSTR Buffer;
744 UNICODE_STRING ReparsePath, FullPath;
745
746 ok_eq_hex(Reparse->ReparseTag, IO_REPARSE_TAG_SYMLINK);
747 ok_eq_hex(Reparse->ReparseDataLength, 12 + SysDir.Length * 2 + sizeof(L"\\regedit.exe") * 2 - sizeof(L"\\??\\") - sizeof(UNICODE_NULL));
748 ok_eq_hex(Reparse->SymbolicLinkReparseBuffer.Flags, 0);
749
750 FullPath.Length = 0;
751 FullPath.MaximumLength = SysDir.Length + sizeof(L"\\regedit.exe") - sizeof(UNICODE_NULL);
752 Buffer = FullPath.Buffer = ExAllocatePool(NonPagedPool, FullPath.MaximumLength);
753 if (!skip(Buffer != NULL, "Memory allocation failed!\n"))
754 {
755 RtlCopyUnicodeString(&FullPath, &SysDir);
756 RtlCopyMemory(&FullPath.Buffer[FullPath.Length / sizeof(WCHAR)], L"\\regedit.exe", sizeof(L"\\regedit.exe") - sizeof(UNICODE_NULL));
757 FullPath.Length += (sizeof(L"\\regedit.exe") - sizeof(UNICODE_NULL));
758 ReparsePath.Buffer = (PWSTR)((ULONG_PTR)Reparse->SymbolicLinkReparseBuffer.PathBuffer + Reparse->SymbolicLinkReparseBuffer.SubstituteNameOffset);
759 ReparsePath.Length = ReparsePath.MaximumLength = Reparse->SymbolicLinkReparseBuffer.SubstituteNameLength;
760 ok(RtlCompareUnicodeString(&ReparsePath, &FullPath, TRUE) == 0, "Expected: %wZ. Got: %wZ\n", &ReparsePath, &FullPath);
761
762 FullPath.Length -= (sizeof(L"\\??\\") - sizeof(UNICODE_NULL));
763 FullPath.MaximumLength -= (sizeof(L"\\??\\") - sizeof(UNICODE_NULL));
764 FullPath.Buffer = (PWSTR)((ULONG_PTR)Buffer + sizeof(L"\\??\\") - sizeof(UNICODE_NULL));
765 ReparsePath.Buffer = (PWSTR)((ULONG_PTR)Reparse->SymbolicLinkReparseBuffer.PathBuffer + Reparse->SymbolicLinkReparseBuffer.PrintNameOffset);
766 ReparsePath.Length = ReparsePath.MaximumLength = Reparse->SymbolicLinkReparseBuffer.PrintNameLength;
767 ok(RtlCompareUnicodeString(&ReparsePath, &FullPath, TRUE) == 0, "Expected: %wZ. Got: %wZ\n", &ReparsePath, &FullPath);
768
769 ExFreePool(Buffer);
770 }
771 }
772
773 ExFreePool(SysDir.Buffer);
774 ExFreePool(Reparse);
775
776 ZwSetInformationFile(ReparseHandle,
777 &IoStatusBlock,
778 &ToDelete,
779 sizeof(ToDelete),
780 FileDispositionInformation);
781 ZwClose(ReparseHandle);
782}
skip
#define skip(...)
Definition: atltest.h:64
FILE_NON_DIRECTORY_FILE
#define FILE_NON_DIRECTORY_FILE
Definition: constants.h:492
FILE_DELETE_ON_CLOSE
#define FILE_DELETE_ON_CLOSE
Definition: constants.h:494
Buffer
Definition: bufpool.h:45
TRUE
#define TRUE
Definition: types.h:120
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
FILE_ATTRIBUTE_NORMAL
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
ExFreePool
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
NonPagedPool
#define NonPagedPool
Definition: env_spec_w32.h:307
ExAllocatePool
#define ExAllocatePool(type, size)
Definition: fbtusb.h:44
FileDispositionInformation
@ FileDispositionInformation
Definition: from_kernel.h:74
FILE_OPEN_REPARSE_POINT
#define FILE_OPEN_REPARSE_POINT
Definition: from_kernel.h:46
FILE_SUPERSEDE
#define FILE_SUPERSEDE
Definition: from_kernel.h:53
FILE_OPEN_FOR_BACKUP_INTENT
#define FILE_OPEN_FOR_BACKUP_INTENT
Definition: from_kernel.h:42
UserMode
#define UserMode
Definition: asm.h:35
ZwClose
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
RtlCopyUnicodeString
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
RtlAppendUnicodeStringToString
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
FILE_SHARE_DELETE
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
FILE_WRITE_ATTRIBUTES
#define FILE_WRITE_ATTRIBUTES
Definition: nt_native.h:649
DELETE
#define DELETE
Definition: nt_native.h:57
UNICODE_NULL
#define UNICODE_NULL
ZwFsControlFile
NTSYSAPI NTSTATUS NTAPI ZwFsControlFile(IN HANDLE DeviceHandle, IN HANDLE Event OPTIONAL, IN PIO_APC_ROUTINE ApcRoutine OPTIONAL, IN PVOID ApcContext OPTIONAL, OUT PIO_STATUS_BLOCK IoStatusBlock, IN ULONG IoControlCode, IN PVOID InputBuffer, IN ULONG InputBufferSize, OUT PVOID OutputBuffer, IN ULONG OutputBufferSize)
STATUS_IO_REPARSE_TAG_NOT_HANDLED
#define STATUS_IO_REPARSE_TAG_NOT_HANDLED
Definition: ntstatus.h:757
STATUS_STOPPED_ON_SYMLINK
#define STATUS_STOPPED_ON_SYMLINK
Definition: ntstatus.h:224
L
#define L(x)
Definition: ntvdm.h:50
FSCTL_GET_REPARSE_POINT
#define FSCTL_GET_REPARSE_POINT
Definition: winioctl.h:97
FSCTL_SET_REPARSE_POINT
#define FSCTL_SET_REPARSE_POINT
Definition: winioctl.h:98
_FILE_DISPOSITION_INFORMATION
Definition: nt_native.h:972
_FILE_DISPOSITION_INFORMATION::DeleteFile
BOOLEAN DeleteFile
Definition: nt_native.h:973
_REPARSE_DATA_BUFFER
Definition: shellext.h:164
_REPARSE_DATA_BUFFER::PathBuffer
WCHAR PathBuffer[1]
Definition: shellext.h:176
_REPARSE_DATA_BUFFER::ReparseTag
ULONG ReparseTag
Definition: shellext.h:165
_REPARSE_DATA_BUFFER::SymbolicLinkReparseBuffer
struct _REPARSE_DATA_BUFFER::@318::@320 SymbolicLinkReparseBuffer
_REPARSE_DATA_BUFFER::ReparseDataLength
USHORT ReparseDataLength
Definition: shellext.h:166
_UNICODE_STRING
Definition: env_spec_w32.h:368
_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369
_UNICODE_STRING::MaximumLength
USHORT MaximumLength
Definition: env_spec_w32.h:370
_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371
PWSTR
uint16_t * PWSTR
Definition: typedefs.h:56
FIELD_OFFSET
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
ULONG
uint32_t ULONG
Definition: typedefs.h:59
FileObject
_In_ WDFREQUEST _In_ WDFFILEOBJECT FileObject
Definition: wdfdevice.h:550
Size
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
IO_NO_PARAMETER_CHECKING
#define IO_NO_PARAMETER_CHECKING
Definition: iotypes.h:541
IO_STOP_ON_SYMLINK
#define IO_STOP_ON_SYMLINK
Definition: iotypes.h:7353
IO_REPARSE_TAG_SYMLINK
#define IO_REPARSE_TAG_SYMLINK
Definition: iotypes.h:7240
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by START_TEST().

◆ UserModeTest()

VOID NTAPI UserModeTest ( VOID  )

Definition at line 787 of file IoCreateFile.c.

788{
789 NTSTATUS Status;
790 IO_STATUS_BLOCK IoStatusBlock;
791 OBJECT_ATTRIBUTES ObjectAttributes;
792 HANDLE ParentHandle, SystemRootHandle;
793
794 ok(ExGetPreviousMode() == UserMode, "KernelMode returned!\n");
795
796 /* Attempt direct target open */
797 IoStatusBlock.Status = 0xFFFFFFFF;
798 IoStatusBlock.Information = 0xFFFFFFFF;
799 InitializeObjectAttributes(&ObjectAttributes,
800 &SystemRootRegedit,
801 OBJ_CASE_INSENSITIVE,
802 NULL, NULL);
803 Status = IoCreateFile(&ParentHandle,
804 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
805 &ObjectAttributes,
806 &IoStatusBlock,
807 NULL,
808 0,
809 FILE_SHARE_READ | FILE_SHARE_WRITE,
810 FILE_OPEN,
811 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
812 NULL,
813 0,
814 CreateFileTypeNone,
815 NULL,
816 IO_OPEN_TARGET_DIRECTORY);
817 ok_eq_hex(Status, STATUS_ACCESS_VIOLATION);
818 ok_eq_hex(IoStatusBlock.Status, 0xFFFFFFFF);
819 if (Status == STATUS_SUCCESS)
820 {
821 ObCloseHandle(ParentHandle, UserMode);
822 }
823
824 /* Attempt relative target open */
825 IoStatusBlock.Status = 0xFFFFFFFF;
826 IoStatusBlock.Information = 0xFFFFFFFF;
827 InitializeObjectAttributes(&ObjectAttributes,
828 &SystemRoot,
829 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
830 NULL, NULL);
831 Status = ZwOpenFile(&SystemRootHandle,
832 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
833 &ObjectAttributes,
834 &IoStatusBlock,
835 FILE_SHARE_READ | FILE_SHARE_WRITE,
836 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT);
837 ok_eq_hex(Status, STATUS_SUCCESS);
838 ok_eq_hex(IoStatusBlock.Status, STATUS_SUCCESS);
839 if (Status == STATUS_SUCCESS)
840 {
841 IoStatusBlock.Status = 0xFFFFFFFF;
842 IoStatusBlock.Information = 0xFFFFFFFF;
843 InitializeObjectAttributes(&ObjectAttributes,
844 &Regedit,
845 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
846 SystemRootHandle,
847 NULL);
848 Status = IoCreateFile(&ParentHandle,
849 GENERIC_WRITE | GENERIC_READ | SYNCHRONIZE,
850 &ObjectAttributes,
851 &IoStatusBlock,
852 NULL,
853 0,
854 FILE_SHARE_READ | FILE_SHARE_WRITE,
855 FILE_OPEN,
856 FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT,
857 NULL,
858 0,
859 CreateFileTypeNone,
860 NULL,
861 IO_OPEN_TARGET_DIRECTORY);
862 ok_eq_hex(Status, STATUS_ACCESS_VIOLATION);
863 ok_eq_hex(IoStatusBlock.Status, 0xFFFFFFFF);
864 if (Status == STATUS_SUCCESS)
865 {
866 ObCloseHandle(ParentHandle, KernelMode);
867 }
868 ObCloseHandle(SystemRootHandle, KernelMode);
869 }
870}
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242

Referenced by START_TEST().

Variable Documentation

◆ Foobar

UNICODE_STRING Foobar = RTL_CONSTANT_STRING(L"foobar.exe")
static

Definition at line 12 of file IoCreateFile.c.

Referenced by KernelModeTest(), and TestSymlinks().

◆ FoobarFoobar

UNICODE_STRING FoobarFoobar = RTL_CONSTANT_STRING(L"foobar\\foobar.exe")
static

Definition at line 16 of file IoCreateFile.c.

Referenced by KernelModeTest().

◆ Regedit

UNICODE_STRING Regedit = RTL_CONSTANT_STRING(L"regedit.exe")
static

Definition at line 11 of file IoCreateFile.c.

Referenced by KernelModeTest(), TestSymlinks(), and UserModeTest().

◆ SystemRoot

UNICODE_STRING SystemRoot = RTL_CONSTANT_STRING(L"\\SystemRoot\\")
static

Definition at line 10 of file IoCreateFile.c.

Referenced by KernelModeTest(), TestSymlinks(), and UserModeTest().

◆ SystemRootFoobar

UNICODE_STRING SystemRootFoobar = RTL_CONSTANT_STRING(L"\\SystemRoot\\foobar.exe")
static

Definition at line 14 of file IoCreateFile.c.

Referenced by KernelModeTest(), and TestSymlinks().

◆ SystemRootFoobarFoobar

UNICODE_STRING SystemRootFoobarFoobar = RTL_CONSTANT_STRING(L"\\SystemRoot\\foobar\\foobar.exe")
static

Definition at line 15 of file IoCreateFile.c.

Referenced by KernelModeTest().

◆ SystemRootRegedit

UNICODE_STRING SystemRootRegedit = RTL_CONSTANT_STRING(L"\\SystemRoot\\regedit.exe")
static

Definition at line 13 of file IoCreateFile.c.

Referenced by KernelModeTest(), and UserModeTest().