?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ntdll/tests: Fix some string leaks (Valgrind).
[wine.git] / dlls / ntdll / tests / om.c
blob64a16abb624c9e08871b96b9a8f165f6c13761c6
1 /*
2 * Unit test suite for object manager functions
3 *
4 * Copyright 2005 Robert Shearman
5 * Copyright 2005 Vitaliy Margolen
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "ntdll_test.h"
23 #include "winternl.h"
24 #include "stdio.h"
25 #include "winnt.h"
26 #include "stdlib.h"
27
28 static HANDLE (WINAPI *pCreateWaitableTimerA)(SECURITY_ATTRIBUTES*, BOOL, LPCSTR);
29 static BOOLEAN (WINAPI *pRtlCreateUnicodeStringFromAsciiz)(PUNICODE_STRING, LPCSTR);
30 static VOID (WINAPI *pRtlInitUnicodeString)( PUNICODE_STRING, LPCWSTR );
31 static VOID (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING);
32 static NTSTATUS (WINAPI *pNtCreateEvent) ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, BOOLEAN, BOOLEAN);
33 static NTSTATUS (WINAPI *pNtOpenEvent) ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES);
34 static NTSTATUS (WINAPI *pNtPulseEvent) ( HANDLE, PULONG );
35 static NTSTATUS (WINAPI *pNtQueryEvent) ( HANDLE, EVENT_INFORMATION_CLASS, PVOID, ULONG, PULONG );
36 static NTSTATUS (WINAPI *pNtCreateJobObject)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
37 static NTSTATUS (WINAPI *pNtOpenJobObject)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
38 static NTSTATUS (WINAPI *pNtCreateKey)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG,
39 const UNICODE_STRING *, ULONG, PULONG );
40 static NTSTATUS (WINAPI *pNtOpenKey)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
41 static NTSTATUS (WINAPI *pNtDeleteKey)( HANDLE );
42 static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
43 ULONG, ULONG, ULONG, PLARGE_INTEGER );
44 static NTSTATUS (WINAPI *pNtCreateMutant)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, BOOLEAN );
45 static NTSTATUS (WINAPI *pNtOpenMutant) ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES );
46 static NTSTATUS (WINAPI *pNtQueryMutant) ( HANDLE, MUTANT_INFORMATION_CLASS, PVOID, ULONG, PULONG );
47 static NTSTATUS (WINAPI *pNtReleaseMutant)( HANDLE, PLONG );
48 static NTSTATUS (WINAPI *pNtCreateSemaphore)( PHANDLE, ACCESS_MASK,const POBJECT_ATTRIBUTES,LONG,LONG );
49 static NTSTATUS (WINAPI *pNtOpenSemaphore)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES );
50 static NTSTATUS (WINAPI *pNtCreateTimer) ( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, TIMER_TYPE );
51 static NTSTATUS (WINAPI *pNtOpenTimer)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES );
52 static NTSTATUS (WINAPI *pNtCreateSection)( PHANDLE, ACCESS_MASK, const POBJECT_ATTRIBUTES, const PLARGE_INTEGER,
53 ULONG, ULONG, HANDLE );
54 static NTSTATUS (WINAPI *pNtOpenSection)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
55 static NTSTATUS (WINAPI *pNtOpenFile) ( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, ULONG, ULONG );
56 static NTSTATUS (WINAPI *pNtClose) ( HANDLE );
57 static NTSTATUS (WINAPI *pNtCreateNamedPipeFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
58 ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, ULONG, PLARGE_INTEGER );
59 static NTSTATUS (WINAPI *pNtOpenDirectoryObject)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
60 static NTSTATUS (WINAPI *pNtCreateDirectoryObject)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
61 static NTSTATUS (WINAPI *pNtOpenSymbolicLinkObject)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
62 static NTSTATUS (WINAPI *pNtCreateSymbolicLinkObject)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PUNICODE_STRING);
63 static NTSTATUS (WINAPI *pNtQuerySymbolicLinkObject)(HANDLE,PUNICODE_STRING,PULONG);
64 static NTSTATUS (WINAPI *pNtQueryObject)(HANDLE,OBJECT_INFORMATION_CLASS,PVOID,ULONG,PULONG);
65 static NTSTATUS (WINAPI *pNtReleaseSemaphore)(HANDLE, ULONG, PULONG);
66 static NTSTATUS (WINAPI *pNtCreateKeyedEvent)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES *, ULONG );
67 static NTSTATUS (WINAPI *pNtOpenKeyedEvent)( HANDLE *, ACCESS_MASK, const OBJECT_ATTRIBUTES * );
68 static NTSTATUS (WINAPI *pNtWaitForKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * );
69 static NTSTATUS (WINAPI *pNtReleaseKeyedEvent)( HANDLE, const void *, BOOLEAN, const LARGE_INTEGER * );
70 static NTSTATUS (WINAPI *pNtCreateIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG);
71 static NTSTATUS (WINAPI *pNtOpenIoCompletion)( PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES );
72
73 #define KEYEDEVENT_WAIT 0x0001
74 #define KEYEDEVENT_WAKE 0x0002
75 #define KEYEDEVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | 0x0003)
76
77 static void test_case_sensitive (void)
78 {
79 static const WCHAR buffer1[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s','\\','t','e','s','t',0};
80 static const WCHAR buffer2[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s','\\','T','e','s','t',0};
81 static const WCHAR buffer3[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s','\\','T','E','s','t',0};
82 static const WCHAR buffer4[] = {'\\','B','A','S','E','N','a','m','e','d','O','b','j','e','c','t','s','\\','t','e','s','t',0};
83 NTSTATUS status;
84 OBJECT_ATTRIBUTES attr;
85 UNICODE_STRING str;
86 HANDLE Event, Mutant, h;
87
88 pRtlInitUnicodeString(&str, buffer1);
89 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
90 status = pNtCreateMutant(&Mutant, GENERIC_ALL, &attr, FALSE);
91 ok(status == STATUS_SUCCESS, "Failed to create Mutant(%08x)\n", status);
92
93 status = pNtCreateEvent(&Event, GENERIC_ALL, &attr, FALSE, FALSE);
94 ok(status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_OBJECT_TYPE_MISMATCH,
95 "NtCreateEvent should have failed with STATUS_OBJECT_NAME_COLLISION or STATUS_OBJECT_TYPE_MISMATCH got (%08x)\n", status);
96
97 pRtlInitUnicodeString(&str, buffer2);
98 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
99 status = pNtCreateEvent(&Event, GENERIC_ALL, &attr, FALSE, FALSE);
100 ok(status == STATUS_SUCCESS, "Failed to create Event(%08x)\n", status);
101
102 pRtlInitUnicodeString(&str, buffer3);
103 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
104 status = pNtOpenMutant(&h, GENERIC_ALL, &attr);
105 ok(status == STATUS_OBJECT_TYPE_MISMATCH,
106 "NtOpenMutant should have failed with STATUS_OBJECT_TYPE_MISMATCH got(%08x)\n", status);
107
108 pNtClose(Mutant);
109
110 pRtlInitUnicodeString(&str, buffer4);
111 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
112 status = pNtCreateMutant(&Mutant, GENERIC_ALL, &attr, FALSE);
113 ok(status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_OBJECT_TYPE_MISMATCH,
114 "NtCreateMutant should have failed with STATUS_OBJECT_NAME_COLLISION or STATUS_OBJECT_TYPE_MISMATCH got (%08x)\n", status);
115
116 status = pNtCreateEvent(&h, GENERIC_ALL, &attr, FALSE, FALSE);
117 ok(status == STATUS_OBJECT_NAME_COLLISION,
118 "NtCreateEvent should have failed with STATUS_OBJECT_NAME_COLLISION got(%08x)\n", status);
119
120 attr.Attributes = 0;
121 status = pNtCreateMutant(&Mutant, GENERIC_ALL, &attr, FALSE);
122 ok(status == STATUS_OBJECT_PATH_NOT_FOUND,
123 "NtCreateMutant should have failed with STATUS_OBJECT_PATH_NOT_FOUND got(%08x)\n", status);
124
125 pNtClose(Event);
126 }
127
128 static void test_namespace_pipe(void)
129 {
130 static const WCHAR buffer1[] = {'\\','?','?','\\','P','I','P','E','\\','t','e','s','t','\\','p','i','p','e',0};
131 static const WCHAR buffer2[] = {'\\','?','?','\\','P','I','P','E','\\','T','E','S','T','\\','P','I','P','E',0};
132 static const WCHAR buffer3[] = {'\\','?','?','\\','p','i','p','e','\\','t','e','s','t','\\','p','i','p','e',0};
133 static const WCHAR buffer4[] = {'\\','?','?','\\','p','i','p','e','\\','t','e','s','t',0};
134 OBJECT_ATTRIBUTES attr;
135 UNICODE_STRING str;
136 IO_STATUS_BLOCK iosb;
137 NTSTATUS status;
138 LARGE_INTEGER timeout;
139 HANDLE pipe, h;
140
141 timeout.QuadPart = -10000;
142
143 pRtlInitUnicodeString(&str, buffer1);
144 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
145 status = pNtCreateNamedPipeFile(&pipe, GENERIC_READ|GENERIC_WRITE, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
146 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, FALSE, FALSE, FALSE, 1, 256, 256, &timeout);
147 ok(status == STATUS_SUCCESS, "Failed to create NamedPipe(%08x)\n", status);
148
149 status = pNtCreateNamedPipeFile(&pipe, GENERIC_READ|GENERIC_WRITE, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
150 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, FALSE, FALSE, FALSE, 1, 256, 256, &timeout);
151 ok(status == STATUS_INSTANCE_NOT_AVAILABLE,
152 "NtCreateNamedPipeFile should have failed with STATUS_INSTANCE_NOT_AVAILABLE got(%08x)\n", status);
153
154 pRtlInitUnicodeString(&str, buffer2);
155 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
156 status = pNtCreateNamedPipeFile(&pipe, GENERIC_READ|GENERIC_WRITE, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
157 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, FALSE, FALSE, FALSE, 1, 256, 256, &timeout);
158 ok(status == STATUS_INSTANCE_NOT_AVAILABLE,
159 "NtCreateNamedPipeFile should have failed with STATUS_INSTANCE_NOT_AVAILABLE got(%08x)\n", status);
160
161 h = CreateFileA("\\\\.\\pipe\\test\\pipe", GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
162 OPEN_EXISTING, 0, 0 );
163 ok(h != INVALID_HANDLE_VALUE, "Failed to open NamedPipe (%u)\n", GetLastError());
164 pNtClose(h);
165
166 pRtlInitUnicodeString(&str, buffer3);
167 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
168 status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
169 ok(status == STATUS_OBJECT_PATH_NOT_FOUND ||
170 status == STATUS_PIPE_NOT_AVAILABLE ||
171 status == STATUS_OBJECT_NAME_INVALID || /* vista */
172 status == STATUS_OBJECT_NAME_NOT_FOUND, /* win8 */
173 "NtOpenFile should have failed with STATUS_OBJECT_PATH_NOT_FOUND got(%08x)\n", status);
174
175 pRtlInitUnicodeString(&str, buffer4);
176 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
177 status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
178 ok(status == STATUS_OBJECT_NAME_NOT_FOUND ||
179 status == STATUS_OBJECT_NAME_INVALID, /* vista */
180 "NtOpenFile should have failed with STATUS_OBJECT_NAME_NOT_FOUND got(%08x)\n", status);
181
182 str.Length -= 4 * sizeof(WCHAR);
183 status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
184 ok(status == STATUS_SUCCESS, "NtOpenFile should have succeeded got %08x\n", status);
185 pNtClose( h );
186
187 str.Length -= sizeof(WCHAR);
188 status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
189 ok(status == STATUS_SUCCESS, "NtOpenFile should have succeeded got %08x\n", status);
190 pNtClose( h );
191
192 pNtClose(pipe);
193 }
194
195 #define DIRECTORY_QUERY (0x0001)
196 #define SYMBOLIC_LINK_QUERY 0x0001
197
198 #define DIR_TEST_CREATE_OPEN(n,e) \
199 do { \
200 HANDLE h; \
201 pRtlCreateUnicodeStringFromAsciiz(&str, n); \
202 status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr ); \
203 ok( status == e, "NtCreateDirectoryObject(%s) got %08x\n", n, status ); \
204 if (!status) pNtClose( h ); \
205 status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr ); \
206 ok( status == e, "NtOpenDirectoryObject(%s) got %08x\n", n, status ); \
207 if (!status) pNtClose( h ); \
208 pRtlFreeUnicodeString(&str); \
209 } while(0)
210
211 static BOOL is_correct_dir( HANDLE dir, const char *name )
212 {
213 NTSTATUS status;
214 UNICODE_STRING str;
215 OBJECT_ATTRIBUTES attr;
216 HANDLE h = 0;
217
218 pRtlCreateUnicodeStringFromAsciiz(&str, name);
219 InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, dir, NULL);
220 status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
221 pRtlFreeUnicodeString(&str);
222 if (h) pNtClose( h );
223 return (status == STATUS_OBJECT_NAME_EXISTS);
224 }
225
226 /* return a handle to the BaseNamedObjects dir where kernel32 objects get created */
227 static HANDLE get_base_dir(void)
228 {
229 static const char objname[] = "om.c_get_base_dir_obj";
230 NTSTATUS status;
231 UNICODE_STRING str;
232 OBJECT_ATTRIBUTES attr;
233 HANDLE dir, h;
234 unsigned int i;
235
236 h = CreateMutexA(NULL, FALSE, objname);
237 ok(h != 0, "CreateMutexA failed got ret=%p (%d)\n", h, GetLastError());
238 InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, 0, NULL);
239
240 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Local");
241 status = pNtOpenDirectoryObject(&dir, DIRECTORY_QUERY, &attr);
242 pRtlFreeUnicodeString(&str);
243 if (!status && is_correct_dir( dir, objname )) goto done;
244 if (!status) pNtClose( dir );
245
246 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects");
247 status = pNtOpenDirectoryObject(&dir, DIRECTORY_QUERY, &attr);
248 pRtlFreeUnicodeString(&str);
249 if (!status && is_correct_dir( dir, objname )) goto done;
250 if (!status) pNtClose( dir );
251
252 for (i = 0; i < 20; i++)
253 {
254 char name[40];
255 sprintf( name, "\\BaseNamedObjects\\Session\\%u", i );
256 pRtlCreateUnicodeStringFromAsciiz(&str, name );
257 status = pNtOpenDirectoryObject(&dir, DIRECTORY_QUERY, &attr);
258 pRtlFreeUnicodeString(&str);
259 if (!status && is_correct_dir( dir, objname )) goto done;
260 if (!status) pNtClose( dir );
261 }
262 dir = 0;
263
264 done:
265 pNtClose( h );
266 return dir;
267 }
268
269 static void test_name_collisions(void)
270 {
271 NTSTATUS status;
272 UNICODE_STRING str;
273 OBJECT_ATTRIBUTES attr;
274 HANDLE dir, h, h1, h2;
275 DWORD winerr;
276 LARGE_INTEGER size;
277
278 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
279 pRtlCreateUnicodeStringFromAsciiz(&str, "\\");
280 status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
281 ok( status == STATUS_OBJECT_NAME_COLLISION, "NtCreateDirectoryObject got %08x\n", status );
282 InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, 0, NULL);
283
284 status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
285 ok( status == STATUS_OBJECT_NAME_EXISTS, "NtCreateDirectoryObject got %08x\n", status );
286 pNtClose(h);
287 status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
288 ok(status == STATUS_OBJECT_TYPE_MISMATCH,
289 "NtCreateMutant should have failed with STATUS_OBJECT_TYPE_MISMATCH got(%08x)\n", status);
290 pRtlFreeUnicodeString(&str);
291
292 pRtlCreateUnicodeStringFromAsciiz(&str, "\\??\\PIPE\\om.c-mutant");
293 status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
294 ok(status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_OBJECT_PATH_NOT_FOUND,
295 "NtCreateMutant should have failed with STATUS_OBJECT_TYPE_MISMATCH got(%08x)\n", status);
296 pRtlFreeUnicodeString(&str);
297
298 if (!(dir = get_base_dir()))
299 {
300 win_skip( "couldn't find the BaseNamedObjects dir\n" );
301 return;
302 }
303 pRtlCreateUnicodeStringFromAsciiz(&str, "om.c-test");
304 InitializeObjectAttributes(&attr, &str, OBJ_OPENIF, dir, NULL);
305 h = CreateMutexA(NULL, FALSE, "om.c-test");
306 ok(h != 0, "CreateMutexA failed got ret=%p (%d)\n", h, GetLastError());
307 status = pNtCreateMutant(&h1, GENERIC_ALL, &attr, FALSE);
308 ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
309 "NtCreateMutant should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
310 h2 = CreateMutexA(NULL, FALSE, "om.c-test");
311 winerr = GetLastError();
312 ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
313 "CreateMutexA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
314 pNtClose(h);
315 pNtClose(h1);
316 pNtClose(h2);
317
318 h = CreateEventA(NULL, FALSE, FALSE, "om.c-test");
319 ok(h != 0, "CreateEventA failed got ret=%p (%d)\n", h, GetLastError());
320 status = pNtCreateEvent(&h1, GENERIC_ALL, &attr, FALSE, FALSE);
321 ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
322 "NtCreateEvent should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
323 h2 = CreateEventA(NULL, FALSE, FALSE, "om.c-test");
324 winerr = GetLastError();
325 ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
326 "CreateEventA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
327 pNtClose(h);
328 pNtClose(h1);
329 pNtClose(h2);
330
331 h = CreateSemaphoreA(NULL, 1, 2, "om.c-test");
332 ok(h != 0, "CreateSemaphoreA failed got ret=%p (%d)\n", h, GetLastError());
333 status = pNtCreateSemaphore(&h1, GENERIC_ALL, &attr, 1, 2);
334 ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
335 "NtCreateSemaphore should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
336 h2 = CreateSemaphoreA(NULL, 1, 2, "om.c-test");
337 winerr = GetLastError();
338 ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
339 "CreateSemaphoreA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
340 pNtClose(h);
341 pNtClose(h1);
342 pNtClose(h2);
343
344 h = pCreateWaitableTimerA(NULL, TRUE, "om.c-test");
345 ok(h != 0, "CreateWaitableTimerA failed got ret=%p (%d)\n", h, GetLastError());
346 status = pNtCreateTimer(&h1, GENERIC_ALL, &attr, NotificationTimer);
347 ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
348 "NtCreateTimer should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
349 h2 = pCreateWaitableTimerA(NULL, TRUE, "om.c-test");
350 winerr = GetLastError();
351 ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
352 "CreateWaitableTimerA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
353 pNtClose(h);
354 pNtClose(h1);
355 pNtClose(h2);
356
357 h = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 256, "om.c-test");
358 ok(h != 0, "CreateFileMappingA failed got ret=%p (%d)\n", h, GetLastError());
359 size.u.LowPart = 256;
360 size.u.HighPart = 0;
361 status = pNtCreateSection(&h1, SECTION_MAP_WRITE, &attr, &size, PAGE_READWRITE, SEC_COMMIT, 0);
362 ok(status == STATUS_OBJECT_NAME_EXISTS && h1 != NULL,
363 "NtCreateSection should have succeeded with STATUS_OBJECT_NAME_EXISTS got(%08x)\n", status);
364 h2 = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 256, "om.c-test");
365 winerr = GetLastError();
366 ok(h2 != 0 && winerr == ERROR_ALREADY_EXISTS,
367 "CreateFileMappingA should have succeeded with ERROR_ALREADY_EXISTS got ret=%p (%d)\n", h2, winerr);
368 pNtClose(h);
369 pNtClose(h1);
370 pNtClose(h2);
371
372 pRtlFreeUnicodeString(&str);
373 pNtClose(dir);
374 }
375
376 static void test_all_kernel_objects( UINT line, OBJECT_ATTRIBUTES *attr,
377 NTSTATUS create_expect, NTSTATUS open_expect )
378 {
379 UNICODE_STRING target;
380 LARGE_INTEGER size;
381 NTSTATUS status, status2;
382 HANDLE ret, ret2;
383
384 pRtlCreateUnicodeStringFromAsciiz( &target, "\\DosDevices" );
385 size.QuadPart = 4096;
386
387 status = pNtCreateMutant( &ret, GENERIC_ALL, attr, FALSE );
388 ok( status == create_expect, "%u: NtCreateMutant failed %x\n", line, status );
389 status2 = pNtOpenMutant( &ret2, GENERIC_ALL, attr );
390 ok( status2 == open_expect, "%u: NtOpenMutant failed %x\n", line, status2 );
391 if (!status) pNtClose( ret );
392 if (!status2) pNtClose( ret2 );
393 status = pNtCreateSemaphore( &ret, GENERIC_ALL, attr, 1, 2 );
394 ok( status == create_expect, "%u: NtCreateSemaphore failed %x\n", line, status );
395 status2 = pNtOpenSemaphore( &ret2, GENERIC_ALL, attr );
396 ok( status2 == open_expect, "%u: NtOpenSemaphore failed %x\n", line, status2 );
397 if (!status) pNtClose( ret );
398 if (!status2) pNtClose( ret2 );
399 status = pNtCreateEvent( &ret, GENERIC_ALL, attr, 1, 0 );
400 ok( status == create_expect, "%u: NtCreateEvent failed %x\n", line, status );
401 status2 = pNtOpenEvent( &ret2, GENERIC_ALL, attr );
402 ok( status2 == open_expect, "%u: NtOpenEvent failed %x\n", line, status2 );
403 if (!status) pNtClose( ret );
404 if (!status2) pNtClose( ret2 );
405 status = pNtCreateKeyedEvent( &ret, GENERIC_ALL, attr, 0 );
406 ok( status == create_expect, "%u: NtCreateKeyedEvent failed %x\n", line, status );
407 status2 = pNtOpenKeyedEvent( &ret2, GENERIC_ALL, attr );
408 ok( status2 == open_expect, "%u: NtOpenKeyedEvent failed %x\n", line, status2 );
409 if (!status) pNtClose( ret );
410 if (!status2) pNtClose( ret2 );
411 status = pNtCreateTimer( &ret, GENERIC_ALL, attr, NotificationTimer );
412 ok( status == create_expect, "%u: NtCreateTimer failed %x\n", line, status );
413 status2 = pNtOpenTimer( &ret2, GENERIC_ALL, attr );
414 ok( status2 == open_expect, "%u: NtOpenTimer failed %x\n", line, status2 );
415 if (!status) pNtClose( ret );
416 if (!status2) pNtClose( ret2 );
417 status = pNtCreateIoCompletion( &ret, GENERIC_ALL, attr, 0 );
418 ok( status == create_expect, "%u: NtCreateCompletion failed %x\n", line, status );
419 status2 = pNtOpenIoCompletion( &ret2, GENERIC_ALL, attr );
420 ok( status2 == open_expect, "%u: NtOpenCompletion failed %x\n", line, status2 );
421 if (!status) pNtClose( ret );
422 if (!status2) pNtClose( ret2 );
423 status = pNtCreateJobObject( &ret, GENERIC_ALL, attr );
424 ok( status == create_expect, "%u: NtCreateJobObject failed %x\n", line, status );
425 status2 = pNtOpenJobObject( &ret2, GENERIC_ALL, attr );
426 ok( status2 == open_expect, "%u: NtOpenJobObject failed %x\n", line, status2 );
427 if (!status) pNtClose( ret );
428 if (!status2) pNtClose( ret2 );
429 status = pNtCreateDirectoryObject( &ret, GENERIC_ALL, attr );
430 ok( status == create_expect, "%u: NtCreateDirectoryObject failed %x\n", line, status );
431 status2 = pNtOpenDirectoryObject( &ret2, GENERIC_ALL, attr );
432 ok( status2 == open_expect, "%u: NtOpenDirectoryObject failed %x\n", line, status2 );
433 if (!status) pNtClose( ret );
434 if (!status2) pNtClose( ret2 );
435 status = pNtCreateSymbolicLinkObject( &ret, GENERIC_ALL, attr, &target );
436 ok( status == create_expect, "%u: NtCreateSymbolicLinkObject failed %x\n", line, status );
437 status2 = pNtOpenSymbolicLinkObject( &ret2, GENERIC_ALL, attr );
438 ok( status2 == open_expect, "%u: NtOpenSymbolicLinkObject failed %x\n", line, status2 );
439 if (!status) pNtClose( ret );
440 if (!status2) pNtClose( ret2 );
441 status = pNtCreateSection( &ret, SECTION_MAP_WRITE, attr, &size, PAGE_READWRITE, SEC_COMMIT, 0 );
442 ok( status == create_expect, "%u: NtCreateSection failed %x\n", line, status );
443 status2 = pNtOpenSection( &ret2, SECTION_MAP_WRITE, attr );
444 ok( status2 == open_expect, "%u: NtOpenSection failed %x\n", line, status2 );
445 if (!status) pNtClose( ret );
446 if (!status2) pNtClose( ret2 );
447 pRtlFreeUnicodeString( &target );
448 }
449
450 static void test_name_limits(void)
451 {
452 static const WCHAR localW[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s','\\','L','o','c','a','l',0};
453 static const WCHAR pipeW[] = {'\\','D','e','v','i','c','e','\\','N','a','m','e','d','P','i','p','e','\\'};
454 static const WCHAR mailslotW[] = {'\\','D','e','v','i','c','e','\\','M','a','i','l','S','l','o','t','\\'};
455 static const WCHAR registryW[] = {'\\','R','E','G','I','S','T','R','Y','\\','M','a','c','h','i','n','e','\\','S','O','F','T','W','A','R','E','\\','M','i','c','r','o','s','o','f','t','\\'};
456 OBJECT_ATTRIBUTES attr, attr2, attr3;
457 IO_STATUS_BLOCK iosb;
458 LARGE_INTEGER size, timeout;
459 UNICODE_STRING str, str2, target;
460 NTSTATUS status;
461 HANDLE ret, ret2;
462 DWORD i;
463
464 InitializeObjectAttributes( &attr, &str, 0, 0, NULL );
465 InitializeObjectAttributes( &attr2, &str, 0, (HANDLE)0xdeadbeef, NULL );
466 InitializeObjectAttributes( &attr3, &str, 0, 0, NULL );
467 str.Buffer = HeapAlloc( GetProcessHeap(), 0, 65536 + sizeof(registryW));
468 str.MaximumLength = 65534;
469 for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i] = 'a';
470 size.QuadPart = 4096;
471 pRtlCreateUnicodeStringFromAsciiz( &target, "\\DosDevices" );
472
473 if (!(attr.RootDirectory = get_base_dir()))
474 {
475 win_skip( "couldn't find the BaseNamedObjects dir\n" );
476 return;
477 }
478
479 str.Length = 0;
480 status = pNtCreateMutant( &ret, GENERIC_ALL, &attr2, FALSE );
481 ok( status == STATUS_SUCCESS, "%u: NtCreateMutant failed %x\n", str.Length, status );
482 attr3.RootDirectory = ret;
483 status = pNtOpenMutant( &ret2, GENERIC_ALL, &attr );
484 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenMutant failed %x\n", str.Length, status );
485 status = pNtOpenMutant( &ret2, GENERIC_ALL, &attr3 );
486 ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE,
487 "%u: NtOpenMutant failed %x\n", str.Length, status );
488 pNtClose( ret );
489 status = pNtCreateSemaphore( &ret, GENERIC_ALL, &attr2, 1, 2 );
490 ok( status == STATUS_SUCCESS, "%u: NtCreateSemaphore failed %x\n", str.Length, status );
491 attr3.RootDirectory = ret;
492 status = pNtOpenSemaphore( &ret2, GENERIC_ALL, &attr );
493 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenSemaphore failed %x\n", str.Length, status );
494 status = pNtOpenSemaphore( &ret2, GENERIC_ALL, &attr3 );
495 ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE,
496 "%u: NtOpenSemaphore failed %x\n", str.Length, status );
497 pNtClose( ret );
498 status = pNtCreateEvent( &ret, GENERIC_ALL, &attr2, 1, 0 );
499 ok( status == STATUS_SUCCESS, "%u: NtCreateEvent failed %x\n", str.Length, status );
500 attr3.RootDirectory = ret;
501 status = pNtOpenEvent( &ret2, GENERIC_ALL, &attr );
502 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenEvent failed %x\n", str.Length, status );
503 status = pNtOpenEvent( &ret2, GENERIC_ALL, &attr3 );
504 ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE,
505 "%u: NtOpenEvent failed %x\n", str.Length, status );
506 pNtClose( ret );
507 status = pNtCreateKeyedEvent( &ret, GENERIC_ALL, &attr2, 0 );
508 ok( status == STATUS_SUCCESS, "%u: NtCreateKeyedEvent failed %x\n", str.Length, status );
509 attr3.RootDirectory = ret;
510 status = pNtOpenKeyedEvent( &ret2, GENERIC_ALL, &attr );
511 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenKeyedEvent failed %x\n", str.Length, status );
512 status = pNtOpenKeyedEvent( &ret2, GENERIC_ALL, &attr3 );
513 ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE,
514 "%u: NtOpenKeyedEvent failed %x\n", str.Length, status );
515 pNtClose( ret );
516 status = pNtCreateTimer( &ret, GENERIC_ALL, &attr2, NotificationTimer );
517 ok( status == STATUS_SUCCESS, "%u: NtCreateTimer failed %x\n", str.Length, status );
518 attr3.RootDirectory = ret;
519 status = pNtOpenTimer( &ret2, GENERIC_ALL, &attr );
520 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenTimer failed %x\n", str.Length, status );
521 status = pNtOpenTimer( &ret2, GENERIC_ALL, &attr3 );
522 ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE,
523 "%u: NtOpenTimer failed %x\n", str.Length, status );
524 pNtClose( ret );
525 status = pNtCreateIoCompletion( &ret, GENERIC_ALL, &attr2, 0 );
526 ok( status == STATUS_SUCCESS, "%u: NtCreateCompletion failed %x\n", str.Length, status );
527 attr3.RootDirectory = ret;
528 status = pNtOpenIoCompletion( &ret2, GENERIC_ALL, &attr );
529 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenCompletion failed %x\n", str.Length, status );
530 status = pNtOpenIoCompletion( &ret2, GENERIC_ALL, &attr3 );
531 ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE,
532 "%u: NtOpenCompletion failed %x\n", str.Length, status );
533 pNtClose( ret );
534 status = pNtCreateJobObject( &ret, GENERIC_ALL, &attr2 );
535 ok( status == STATUS_SUCCESS, "%u: NtCreateJobObject failed %x\n", str.Length, status );
536 attr3.RootDirectory = ret;
537 status = pNtOpenJobObject( &ret2, GENERIC_ALL, &attr );
538 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenJobObject failed %x\n", str.Length, status );
539 status = pNtOpenJobObject( &ret2, GENERIC_ALL, &attr3 );
540 ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE,
541 "%u: NtOpenJobObject failed %x\n", str.Length, status );
542 pNtClose( ret );
543 status = pNtCreateDirectoryObject( &ret, GENERIC_ALL, &attr2 );
544 ok( status == STATUS_SUCCESS, "%u: NtCreateDirectoryObject failed %x\n", str.Length, status );
545 attr3.RootDirectory = ret;
546 status = pNtOpenDirectoryObject( &ret2, GENERIC_ALL, &attr );
547 ok( status == STATUS_SUCCESS || broken(status == STATUS_ACCESS_DENIED), /* winxp */
548 "%u: NtOpenDirectoryObject failed %x\n", str.Length, status );
549 if (!status) pNtClose( ret2 );
550 status = pNtOpenDirectoryObject( &ret2, GENERIC_ALL, &attr3 );
551 ok( status == STATUS_SUCCESS, "%u: NtOpenDirectoryObject failed %x\n", str.Length, status );
552 pNtClose( ret2 );
553 pNtClose( ret );
554 status = pNtCreateSymbolicLinkObject( &ret, GENERIC_ALL, &attr2, &target );
555 ok( status == STATUS_SUCCESS, "%u: NtCreateSymbolicLinkObject failed %x\n", str.Length, status );
556 attr3.RootDirectory = ret;
557 status = pNtOpenSymbolicLinkObject( &ret2, GENERIC_ALL, &attr );
558 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenSymbolicLinkObject failed %x\n", str.Length, status );
559 status = pNtOpenSymbolicLinkObject( &ret2, GENERIC_ALL, &attr3 );
560 ok( status == STATUS_SUCCESS, "%u: NtOpenSymbolicLinkObject failed %x\n", str.Length, status );
561 pNtClose( ret2 );
562 pNtClose( ret );
563 status = pNtCreateSection( &ret, SECTION_MAP_WRITE, &attr2, &size, PAGE_READWRITE, SEC_COMMIT, 0 );
564 ok( status == STATUS_SUCCESS, "%u: NtCreateSection failed %x\n", str.Length, status );
565 attr3.RootDirectory = ret;
566 status = pNtOpenSection( &ret2, SECTION_MAP_WRITE, &attr );
567 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "%u: NtOpenSection failed %x\n", str.Length, status );
568 status = pNtOpenSection( &ret2, SECTION_MAP_WRITE, &attr3 );
569 ok( status == STATUS_OBJECT_TYPE_MISMATCH || status == STATUS_INVALID_HANDLE,
570 "%u: NtOpenSection failed %x\n", str.Length, status );
571 pNtClose( ret );
572
573 str.Length = 67;
574 test_all_kernel_objects( __LINE__, &attr2, STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_NAME_INVALID );
575
576 str.Length = 65532;
577 test_all_kernel_objects( __LINE__, &attr, STATUS_SUCCESS, STATUS_SUCCESS );
578
579 str.Length = 65534;
580 test_all_kernel_objects( __LINE__, &attr, STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_NAME_INVALID );
581
582 str.Length = 128;
583 for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++)
584 {
585 if (attr.Length == sizeof(attr))
586 test_all_kernel_objects( __LINE__, &attr, STATUS_SUCCESS, STATUS_SUCCESS );
587 else
588 test_all_kernel_objects( __LINE__, &attr, STATUS_INVALID_PARAMETER, STATUS_INVALID_PARAMETER );
589 }
590 attr.Length = sizeof(attr);
591
592 /* null attributes or ObjectName, with or without RootDirectory */
593 attr3.RootDirectory = 0;
594 attr2.ObjectName = attr3.ObjectName = NULL;
595 test_all_kernel_objects( __LINE__, &attr2, STATUS_OBJECT_NAME_INVALID, STATUS_OBJECT_NAME_INVALID );
596 test_all_kernel_objects( __LINE__, &attr3, STATUS_SUCCESS, STATUS_OBJECT_PATH_SYNTAX_BAD );
597
598 attr3.ObjectName = &str2;
599 pRtlInitUnicodeString( &str2, localW );
600 status = pNtOpenSymbolicLinkObject( &ret, SYMBOLIC_LINK_QUERY, &attr3 );
601 ok( status == STATUS_SUCCESS, "can't open BaseNamedObjects\\Local %x\n", status );
602 attr3.ObjectName = &str;
603 attr3.RootDirectory = ret;
604 test_all_kernel_objects( __LINE__, &attr3, STATUS_OBJECT_TYPE_MISMATCH, STATUS_OBJECT_TYPE_MISMATCH );
605 pNtClose( attr3.RootDirectory );
606
607 status = pNtCreateMutant( &ret, GENERIC_ALL, NULL, FALSE );
608 ok( status == STATUS_SUCCESS, "NULL: NtCreateMutant failed %x\n", status );
609 pNtClose( ret );
610 status = pNtOpenMutant( &ret, GENERIC_ALL, NULL );
611 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenMutant failed %x\n", status );
612 status = pNtCreateSemaphore( &ret, GENERIC_ALL, NULL, 1, 2 );
613 ok( status == STATUS_SUCCESS, "NULL: NtCreateSemaphore failed %x\n", status );
614 pNtClose( ret );
615 status = pNtOpenSemaphore( &ret, GENERIC_ALL, NULL );
616 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenSemaphore failed %x\n", status );
617 status = pNtCreateEvent( &ret, GENERIC_ALL, NULL, 1, 0 );
618 ok( status == STATUS_SUCCESS, "NULL: NtCreateEvent failed %x\n", status );
619 pNtClose( ret );
620 status = pNtOpenEvent( &ret, GENERIC_ALL, NULL );
621 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenEvent failed %x\n", status );
622 status = pNtCreateKeyedEvent( &ret, GENERIC_ALL, NULL, 0 );
623 ok( status == STATUS_SUCCESS, "NULL: NtCreateKeyedEvent failed %x\n", status );
624 pNtClose( ret );
625 status = pNtOpenKeyedEvent( &ret, GENERIC_ALL, NULL );
626 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenKeyedEvent failed %x\n", status );
627 status = pNtCreateTimer( &ret, GENERIC_ALL, NULL, NotificationTimer );
628 ok( status == STATUS_SUCCESS, "NULL: NtCreateTimer failed %x\n", status );
629 pNtClose( ret );
630 status = pNtOpenTimer( &ret, GENERIC_ALL, NULL );
631 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenTimer failed %x\n", status );
632 status = pNtCreateIoCompletion( &ret, GENERIC_ALL, NULL, 0 );
633 ok( status == STATUS_SUCCESS, "NULL: NtCreateCompletion failed %x\n", status );
634 pNtClose( ret );
635 status = pNtOpenIoCompletion( &ret, GENERIC_ALL, NULL );
636 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenCompletion failed %x\n", status );
637 status = pNtCreateJobObject( &ret, GENERIC_ALL, NULL );
638 ok( status == STATUS_SUCCESS, "NULL: NtCreateJobObject failed %x\n", status );
639 pNtClose( ret );
640 status = pNtOpenJobObject( &ret, GENERIC_ALL, NULL );
641 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenJobObject failed %x\n", status );
642 status = pNtCreateDirectoryObject( &ret, GENERIC_ALL, NULL );
643 ok( status == STATUS_SUCCESS, "NULL: NtCreateDirectoryObject failed %x\n", status );
644 pNtClose( ret );
645 status = pNtOpenDirectoryObject( &ret, GENERIC_ALL, NULL );
646 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenDirectoryObject failed %x\n", status );
647 status = pNtCreateSymbolicLinkObject( &ret, GENERIC_ALL, NULL, &target );
648 ok( status == STATUS_ACCESS_VIOLATION || broken( status == STATUS_SUCCESS), /* winxp */
649 "NULL: NtCreateSymbolicLinkObject failed %x\n", status );
650 if (!status) pNtClose( ret );
651 status = pNtOpenSymbolicLinkObject( &ret, GENERIC_ALL, NULL );
652 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenSymbolicLinkObject failed %x\n", status );
653 status = pNtCreateSection( &ret, SECTION_MAP_WRITE, NULL, &size, PAGE_READWRITE, SEC_COMMIT, 0 );
654 ok( status == STATUS_SUCCESS, "NULL: NtCreateSection failed %x\n", status );
655 pNtClose( ret );
656 status = pNtOpenSection( &ret, SECTION_MAP_WRITE, NULL );
657 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtOpenSection failed %x\n", status );
658 attr2.ObjectName = attr3.ObjectName = &str;
659
660 /* named pipes */
661 memcpy( str.Buffer, pipeW, sizeof(pipeW) );
662 for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i + sizeof(pipeW)/sizeof(WCHAR)] = 'a';
663 str.Length = 0;
664 attr.RootDirectory = 0;
665 attr.Attributes = OBJ_CASE_INSENSITIVE;
666 timeout.QuadPart = -10000;
667 status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
668 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
669 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
670 status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr2, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
671 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
672 ok( status == STATUS_INVALID_HANDLE, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
673 str.Length = 67;
674 status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr2, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
675 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
676 ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
677 str.Length = 128;
678 for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++)
679 {
680 status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
681 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
682 if (attr.Length == sizeof(attr))
683 {
684 ok( status == STATUS_SUCCESS, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
685 pNtClose( ret );
686 }
687 else ok( status == STATUS_INVALID_PARAMETER,
688 "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
689 }
690 attr.Length = sizeof(attr);
691 str.Length = 65532;
692 status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
693 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
694 ok( status == STATUS_SUCCESS, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
695 pNtClose( ret );
696 str.Length = 65534;
697 status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
698 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
699 ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateNamedPipeFile failed %x\n", str.Length, status );
700 attr3.RootDirectory = 0;
701 attr2.ObjectName = attr3.ObjectName = NULL;
702 status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr2, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
703 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
704 ok( status == STATUS_OBJECT_NAME_INVALID, "NULL: NtCreateNamedPipeFile failed %x\n", status );
705 status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, &attr3, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
706 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
707 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NULL: NtCreateNamedPipeFile failed %x\n", status );
708 status = pNtCreateNamedPipeFile( &ret, GENERIC_ALL, NULL, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE,
709 FILE_CREATE, FILE_PIPE_FULL_DUPLEX, 0, 0, 0, 1, 256, 256, &timeout );
710 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtCreateNamedPipeFile failed %x\n", status );
711 attr2.ObjectName = attr3.ObjectName = &str;
712
713 /* mailslots */
714 memcpy( str.Buffer, mailslotW, sizeof(mailslotW) );
715 for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i + sizeof(mailslotW)/sizeof(WCHAR)] = 'a';
716 str.Length = 0;
717 status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL );
718 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
719 status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr2, &iosb, 0, 0, 0, NULL );
720 ok( status == STATUS_INVALID_HANDLE, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
721 str.Length = 67;
722 status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr2, &iosb, 0, 0, 0, NULL );
723 ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
724 str.Length = 128;
725 for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++)
726 {
727 status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL );
728 if (attr.Length == sizeof(attr))
729 {
730 ok( status == STATUS_SUCCESS, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
731 pNtClose( ret );
732 }
733 else ok( status == STATUS_INVALID_PARAMETER,
734 "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
735 }
736 attr.Length = sizeof(attr);
737 str.Length = 65532;
738 status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL );
739 ok( status == STATUS_SUCCESS, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
740 pNtClose( ret );
741 str.Length = 65534;
742 status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr, &iosb, 0, 0, 0, NULL );
743 ok( status == STATUS_OBJECT_NAME_INVALID, "%u: NtCreateMailslotFile failed %x\n", str.Length, status );
744 attr3.RootDirectory = 0;
745 attr2.ObjectName = attr3.ObjectName = NULL;
746 status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr2, &iosb, 0, 0, 0, NULL );
747 ok( status == STATUS_OBJECT_NAME_INVALID, "NULL: NtCreateMailslotFile failed %x\n", status );
748 status = pNtCreateMailslotFile( &ret, GENERIC_ALL, &attr3, &iosb, 0, 0, 0, NULL );
749 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NULL: NtCreateMailslotFile failed %x\n", status );
750 status = pNtCreateMailslotFile( &ret, GENERIC_ALL, NULL, &iosb, 0, 0, 0, NULL );
751 ok( status == STATUS_INVALID_PARAMETER, "NULL: NtCreateMailslotFile failed %x\n", status );
752 attr2.ObjectName = attr3.ObjectName = &str;
753
754 /* registry keys */
755 memcpy( str.Buffer, registryW, sizeof(registryW) );
756 for (i = 0; i < 65536 / sizeof(WCHAR); i++) str.Buffer[i + sizeof(registryW)/sizeof(WCHAR)] = 'a';
757 str.Length = 0;
758 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
759 todo_wine
760 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "%u: NtCreateKey failed %x\n", str.Length, status );
761 status = pNtCreateKey( &ret, GENERIC_ALL, &attr2, 0, NULL, 0, NULL );
762 ok( status == STATUS_INVALID_HANDLE, "%u: NtCreateKey failed %x\n", str.Length, status );
763 status = pNtOpenKey( &ret, GENERIC_ALL, &attr2 );
764 ok( status == STATUS_INVALID_HANDLE, "%u: NtOpenKey failed %x\n", str.Length, status );
765 str.Length = sizeof(registryW) + 250 * sizeof(WCHAR) + 1;
766 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
767 ok( status == STATUS_OBJECT_NAME_INVALID ||
768 status == STATUS_INVALID_PARAMETER ||
769 broken( status == STATUS_SUCCESS ), /* wow64 */
770 "%u: NtCreateKey failed %x\n", str.Length, status );
771 if (!status)
772 {
773 pNtDeleteKey( ret );
774 pNtClose( ret );
775 }
776 str.Length = sizeof(registryW) + 256 * sizeof(WCHAR);
777 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
778 ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED,
779 "%u: NtCreateKey failed %x\n", str.Length, status );
780 if (!status)
781 {
782 status = pNtOpenKey( &ret2, KEY_READ, &attr );
783 ok( status == STATUS_SUCCESS, "%u: NtOpenKey failed %x\n", str.Length, status );
784 pNtClose( ret2 );
785 attr3.RootDirectory = ret;
786 str.Length = 0;
787 status = pNtOpenKey( &ret2, KEY_READ, &attr3 );
788 ok( status == STATUS_SUCCESS, "%u: NtOpenKey failed %x\n", str.Length, status );
789 pNtClose( ret2 );
790 pNtDeleteKey( ret );
791 pNtClose( ret );
792
793 str.Length = sizeof(registryW) + 256 * sizeof(WCHAR);
794 for (attr.Length = 0; attr.Length <= 2 * sizeof(attr); attr.Length++)
795 {
796 if (attr.Length == sizeof(attr))
797 {
798 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
799 ok( status == STATUS_SUCCESS, "%u: NtCreateKey failed %x\n", str.Length, status );
800 status = pNtOpenKey( &ret2, KEY_READ, &attr );
801 ok( status == STATUS_SUCCESS, "%u: NtOpenKey failed %x\n", str.Length, status );
802 pNtClose( ret2 );
803 pNtDeleteKey( ret );
804 pNtClose( ret );
805 }
806 else
807 {
808 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
809 ok( status == STATUS_INVALID_PARAMETER, "%u: NtCreateKey failed %x\n", str.Length, status );
810 status = pNtOpenKey( &ret2, KEY_READ, &attr );
811 ok( status == STATUS_INVALID_PARAMETER, "%u: NtOpenKey failed %x\n", str.Length, status );
812 }
813 }
814 attr.Length = sizeof(attr);
815 }
816 str.Length = sizeof(registryW) + 256 * sizeof(WCHAR) + 1;
817 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
818 ok( status == STATUS_OBJECT_NAME_INVALID ||
819 status == STATUS_INVALID_PARAMETER ||
820 broken( status == STATUS_SUCCESS ), /* win7 */
821 "%u: NtCreateKey failed %x\n", str.Length, status );
822 if (!status)
823 {
824 pNtDeleteKey( ret );
825 pNtClose( ret );
826 }
827 status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
828 ok( status == STATUS_OBJECT_NAME_INVALID ||
829 status == STATUS_INVALID_PARAMETER ||
830 broken( status == STATUS_OBJECT_NAME_NOT_FOUND ), /* wow64 */
831 "%u: NtOpenKey failed %x\n", str.Length, status );
832 str.Length++;
833 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
834 ok( status == STATUS_INVALID_PARAMETER, "%u: NtCreateKey failed %x\n", str.Length, status );
835 status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
836 todo_wine
837 ok( status == STATUS_INVALID_PARAMETER, "%u: NtOpenKey failed %x\n", str.Length, status );
838 str.Length = 2000;
839 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
840 ok( status == STATUS_INVALID_PARAMETER, "%u: NtCreateKey failed %x\n", str.Length, status );
841 status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
842 todo_wine
843 ok( status == STATUS_INVALID_PARAMETER, "%u: NtOpenKey failed %x\n", str.Length, status );
844 /* some Windows versions change the error past 2050 chars, others past 4066 chars, some don't */
845 str.Length = 5000;
846 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
847 ok( status == STATUS_BUFFER_OVERFLOW ||
848 status == STATUS_BUFFER_TOO_SMALL ||
849 status == STATUS_INVALID_PARAMETER,
850 "%u: NtCreateKey failed %x\n", str.Length, status );
851 status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
852 todo_wine
853 ok( status == STATUS_BUFFER_OVERFLOW ||
854 status == STATUS_BUFFER_TOO_SMALL ||
855 status == STATUS_INVALID_PARAMETER,
856 "%u: NtOpenKey failed %x\n", str.Length, status );
857 str.Length = 65534;
858 status = pNtCreateKey( &ret, GENERIC_ALL, &attr, 0, NULL, 0, NULL );
859 ok( status == STATUS_OBJECT_NAME_INVALID ||
860 status == STATUS_BUFFER_OVERFLOW ||
861 status == STATUS_BUFFER_TOO_SMALL,
862 "%u: NtCreateKey failed %x\n", str.Length, status );
863 status = pNtOpenKey( &ret, GENERIC_ALL, &attr );
864 todo_wine
865 ok( status == STATUS_OBJECT_NAME_INVALID ||
866 status == STATUS_BUFFER_OVERFLOW ||
867 status == STATUS_BUFFER_TOO_SMALL,
868 "%u: NtOpenKey failed %x\n", str.Length, status );
869 attr3.RootDirectory = 0;
870 attr2.ObjectName = attr3.ObjectName = NULL;
871 status = pNtCreateKey( &ret, GENERIC_ALL, &attr2, 0, NULL, 0, NULL );
872 todo_wine
873 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
874 "NULL: NtCreateKey failed %x\n", status );
875 status = pNtCreateKey( &ret, GENERIC_ALL, &attr3, 0, NULL, 0, NULL );
876 todo_wine
877 ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtCreateKey failed %x\n", status );
878 status = pNtCreateKey( &ret, GENERIC_ALL, NULL, 0, NULL, 0, NULL );
879 ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtCreateKey failed %x\n", status );
880 status = pNtOpenKey( &ret, GENERIC_ALL, &attr2 );
881 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_HANDLE,
882 "NULL: NtOpenKey failed %x\n", status );
883 status = pNtOpenKey( &ret, GENERIC_ALL, &attr3 );
884 ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtOpenKey failed %x\n", status );
885 status = pNtOpenKey( &ret, GENERIC_ALL, NULL );
886 ok( status == STATUS_ACCESS_VIOLATION, "NULL: NtOpenKey failed %x\n", status );
887 attr2.ObjectName = attr3.ObjectName = &str;
888
889 pRtlFreeUnicodeString( &str );
890 pRtlFreeUnicodeString( &target );
891 }
892
893 static void test_directory(void)
894 {
895 NTSTATUS status;
896 UNICODE_STRING str;
897 OBJECT_ATTRIBUTES attr;
898 HANDLE dir, dir1, h, h2;
899 BOOL is_nt4;
900
901 /* No name and/or no attributes */
902 status = pNtCreateDirectoryObject(NULL, DIRECTORY_QUERY, &attr);
903 ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER,
904 "NtCreateDirectoryObject should have failed with STATUS_ACCESS_VIOLATION got(%08x)\n", status);
905 status = pNtOpenDirectoryObject(NULL, DIRECTORY_QUERY, &attr);
906 ok(status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER,
907 "NtOpenDirectoryObject should have failed with STATUS_ACCESS_VIOLATION got(%08x)\n", status);
908
909 status = pNtCreateDirectoryObject(&h, DIRECTORY_QUERY, NULL);
910 ok(status == STATUS_SUCCESS, "Failed to create Directory without attributes(%08x)\n", status);
911 pNtClose(h);
912 status = pNtOpenDirectoryObject(&h, DIRECTORY_QUERY, NULL);
913 ok(status == STATUS_INVALID_PARAMETER,
914 "NtOpenDirectoryObject should have failed with STATUS_INVALID_PARAMETER got(%08x)\n", status);
915
916 InitializeObjectAttributes(&attr, NULL, 0, 0, NULL);
917 status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
918 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
919 status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
920 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenDirectoryObject got %08x\n", status );
921
922 /* Bad name */
923 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
924
925 pRtlCreateUnicodeStringFromAsciiz(&str, "");
926 status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
927 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
928 pNtClose(h);
929 status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
930 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenDirectoryObject got %08x\n", status );
931 pRtlFreeUnicodeString(&str);
932 pNtClose(dir);
933
934 DIR_TEST_CREATE_OPEN( "BaseNamedObjects", STATUS_OBJECT_PATH_SYNTAX_BAD );
935 DIR_TEST_CREATE_OPEN( "\\BaseNamedObjects\\", STATUS_OBJECT_NAME_INVALID );
936 DIR_TEST_CREATE_OPEN( "\\\\BaseNamedObjects", STATUS_OBJECT_NAME_INVALID );
937 DIR_TEST_CREATE_OPEN( "\\BaseNamedObjects\\\\om.c-test", STATUS_OBJECT_NAME_INVALID );
938 DIR_TEST_CREATE_OPEN( "\\BaseNamedObjects\\om.c-test\\", STATUS_OBJECT_PATH_NOT_FOUND );
939
940 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\om.c-test");
941 status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
942 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
943 status = pNtOpenDirectoryObject( &dir1, DIRECTORY_QUERY, &attr );
944 ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
945 pRtlFreeUnicodeString(&str);
946 pNtClose(h);
947 pNtClose(dir1);
948
949
950 /* Use of root directory */
951
952 /* Can't use symlinks as a directory */
953 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Local");
954 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
955 status = pNtOpenSymbolicLinkObject(&dir, SYMBOLIC_LINK_QUERY, &attr);
956 is_nt4 = (status == STATUS_OBJECT_NAME_NOT_FOUND); /* nt4 doesn't have Local\\ symlink */
957 if (!is_nt4)
958 {
959 WCHAR buffer[256];
960 ULONG len, full_len;
961
962 ok(status == STATUS_SUCCESS, "Failed to open SymbolicLink(%08x)\n", status);
963 pRtlFreeUnicodeString(&str);
964 InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
965 pRtlCreateUnicodeStringFromAsciiz(&str, "one more level");
966 status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
967 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtCreateDirectoryObject got %08x\n", status );
968 pRtlFreeUnicodeString(&str);
969
970 pRtlCreateUnicodeStringFromAsciiz( &str, "\\BaseNamedObjects\\Local\\om.c-test" );
971 InitializeObjectAttributes( &attr, &str, 0, 0, NULL );
972 status = pNtCreateDirectoryObject( &dir1, DIRECTORY_QUERY, &attr );
973 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
974 pRtlFreeUnicodeString( &str );
975 pRtlCreateUnicodeStringFromAsciiz( &str, "om.c-test" );
976 InitializeObjectAttributes( &attr, &str, 0, dir, NULL );
977 status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
978 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "Failed to open directory %08x\n", status );
979 if (!status) pNtClose(h);
980 pRtlFreeUnicodeString( &str );
981
982 pRtlCreateUnicodeStringFromAsciiz( &str, "om.c-event" );
983 InitializeObjectAttributes( &attr, &str, 0, dir1, NULL );
984 status = pNtCreateEvent( &h, GENERIC_ALL, &attr, 1, 0 );
985 ok( status == STATUS_SUCCESS, "NtCreateEvent failed %x\n", status );
986 status = pNtOpenEvent( &h2, GENERIC_ALL, &attr );
987 ok( status == STATUS_SUCCESS, "NtOpenEvent failed %x\n", status );
988 pNtClose( h2 );
989 pRtlFreeUnicodeString( &str );
990 pRtlCreateUnicodeStringFromAsciiz( &str, "om.c-test\\om.c-event" );
991 InitializeObjectAttributes( &attr, &str, 0, dir, NULL );
992 status = pNtOpenEvent( &h2, GENERIC_ALL, &attr );
993 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtOpenEvent failed %x\n", status );
994 pRtlFreeUnicodeString( &str );
995 pRtlCreateUnicodeStringFromAsciiz( &str, "\\BasedNamedObjects\\Local\\om.c-test\\om.c-event" );
996 InitializeObjectAttributes( &attr, &str, 0, 0, NULL );
997 status = pNtOpenEvent( &h2, GENERIC_ALL, &attr );
998 ok( status == STATUS_OBJECT_PATH_NOT_FOUND, "NtOpenEvent failed %x\n", status );
999 pRtlFreeUnicodeString( &str );
1000 pNtClose( h );
1001 pNtClose( dir1 );
1002
1003 str.Buffer = buffer;
1004 str.MaximumLength = sizeof(buffer);
1005 len = 0xdeadbeef;
1006 memset( buffer, 0xaa, sizeof(buffer) );
1007 status = pNtQuerySymbolicLinkObject( dir, &str, &len );
1008 ok( status == STATUS_SUCCESS, "NtQuerySymbolicLinkObject failed %08x\n", status );
1009 if (status != STATUS_SUCCESS)
1010 goto error;
1011 full_len = str.Length + sizeof(WCHAR);
1012 ok( len == full_len, "bad length %u/%u\n", len, full_len );
1013 if (len == full_len)
1014 ok( buffer[len / sizeof(WCHAR) - 1] == 0, "no terminating null\n" );
1015
1016 str.MaximumLength = str.Length;
1017 len = 0xdeadbeef;
1018 status = pNtQuerySymbolicLinkObject( dir, &str, &len );
1019 ok( status == STATUS_BUFFER_TOO_SMALL, "NtQuerySymbolicLinkObject failed %08x\n", status );
1020 ok( len == full_len, "bad length %u/%u\n", len, full_len );
1021
1022 str.MaximumLength = 0;
1023 len = 0xdeadbeef;
1024 status = pNtQuerySymbolicLinkObject( dir, &str, &len );
1025 ok( status == STATUS_BUFFER_TOO_SMALL, "NtQuerySymbolicLinkObject failed %08x\n", status );
1026 ok( len == full_len, "bad length %u/%u\n", len, full_len );
1027
1028 str.MaximumLength = str.Length + sizeof(WCHAR);
1029 len = 0xdeadbeef;
1030 status = pNtQuerySymbolicLinkObject( dir, &str, &len );
1031 ok( status == STATUS_SUCCESS, "NtQuerySymbolicLinkObject failed %08x\n", status );
1032 ok( len == full_len, "bad length %u/%u\n", len, full_len );
1033
1034 error:
1035 pNtClose(dir);
1036 }
1037
1038 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects");
1039 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1040 status = pNtOpenDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1041 ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
1042 pRtlFreeUnicodeString(&str);
1043
1044 InitializeObjectAttributes(&attr, NULL, 0, dir, NULL);
1045 status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1046 ok( status == STATUS_OBJECT_NAME_INVALID, "NtOpenDirectoryObject got %08x\n", status );
1047
1048 InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1049 DIR_TEST_CREATE_OPEN( "", STATUS_SUCCESS );
1050 DIR_TEST_CREATE_OPEN( "\\", STATUS_OBJECT_PATH_SYNTAX_BAD );
1051 DIR_TEST_CREATE_OPEN( "\\om.c-test", STATUS_OBJECT_PATH_SYNTAX_BAD );
1052 DIR_TEST_CREATE_OPEN( "\\om.c-test\\", STATUS_OBJECT_PATH_SYNTAX_BAD );
1053 DIR_TEST_CREATE_OPEN( "om.c-test\\", STATUS_OBJECT_PATH_NOT_FOUND );
1054
1055 pRtlCreateUnicodeStringFromAsciiz(&str, "om.c-test");
1056 status = pNtCreateDirectoryObject( &dir1, DIRECTORY_QUERY, &attr );
1057 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1058 status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1059 ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
1060 pRtlFreeUnicodeString(&str);
1061
1062 pNtClose(h);
1063 pNtClose(dir1);
1064 pNtClose(dir);
1065
1066 /* Nested directories */
1067 pRtlCreateUnicodeStringFromAsciiz(&str, "\\");
1068 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1069 status = pNtOpenDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1070 ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
1071 InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1072 status = pNtOpenDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1073 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenDirectoryObject got %08x\n", status );
1074 pRtlFreeUnicodeString(&str);
1075 pNtClose(dir);
1076
1077 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1078 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\om.c-test");
1079 status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1080 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1081 pRtlFreeUnicodeString(&str);
1082 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\om.c-test\\one more level");
1083 status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1084 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1085 pRtlFreeUnicodeString(&str);
1086 pNtClose(h);
1087 InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1088 pRtlCreateUnicodeStringFromAsciiz(&str, "one more level");
1089 status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1090 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1091 pRtlFreeUnicodeString(&str);
1092 pNtClose(h);
1093
1094 pNtClose(dir);
1095
1096 if (!is_nt4)
1097 {
1098 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1099 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Global\\om.c-test");
1100 status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1101 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1102 pRtlFreeUnicodeString(&str);
1103 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects\\Local\\om.c-test\\one more level");
1104 status = pNtCreateDirectoryObject( &h, DIRECTORY_QUERY, &attr );
1105 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1106 pRtlFreeUnicodeString(&str);
1107 pNtClose(h);
1108 InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1109 pRtlCreateUnicodeStringFromAsciiz(&str, "one more level");
1110 status = pNtCreateDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1111 ok( status == STATUS_SUCCESS, "Failed to create directory %08x\n", status );
1112 pRtlFreeUnicodeString(&str);
1113 pNtClose(h);
1114 pNtClose(dir);
1115 }
1116
1117 /* Create other objects using RootDirectory */
1118
1119 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1120 pRtlCreateUnicodeStringFromAsciiz(&str, "\\BaseNamedObjects");
1121 status = pNtOpenDirectoryObject( &dir, DIRECTORY_QUERY, &attr );
1122 ok( status == STATUS_SUCCESS, "Failed to open directory %08x\n", status );
1123 pRtlFreeUnicodeString(&str);
1124 InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1125
1126 /* Test invalid paths */
1127 pRtlCreateUnicodeStringFromAsciiz(&str, "\\om.c-mutant");
1128 status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
1129 ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
1130 "NtCreateMutant should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
1131 pRtlFreeUnicodeString(&str);
1132 pRtlCreateUnicodeStringFromAsciiz(&str, "\\om.c-mutant\\");
1133 status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
1134 ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
1135 "NtCreateMutant should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
1136 pRtlFreeUnicodeString(&str);
1137
1138 pRtlCreateUnicodeStringFromAsciiz(&str, "om.c\\-mutant");
1139 status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
1140 ok(status == STATUS_OBJECT_PATH_NOT_FOUND,
1141 "NtCreateMutant should have failed with STATUS_OBJECT_PATH_NOT_FOUND got(%08x)\n", status);
1142 pRtlFreeUnicodeString(&str);
1143
1144 pRtlCreateUnicodeStringFromAsciiz(&str, "om.c-mutant");
1145 status = pNtCreateMutant(&h, GENERIC_ALL, &attr, FALSE);
1146 ok(status == STATUS_SUCCESS, "Failed to create Mutant(%08x)\n", status);
1147 pRtlFreeUnicodeString(&str);
1148 pNtClose(h);
1149
1150 pNtClose(dir);
1151 }
1152
1153 static void test_symboliclink(void)
1154 {
1155 NTSTATUS status;
1156 UNICODE_STRING str, target;
1157 OBJECT_ATTRIBUTES attr;
1158 HANDLE dir, link, h;
1159 IO_STATUS_BLOCK iosb;
1160
1161 /* No name and/or no attributes */
1162 InitializeObjectAttributes(&attr, NULL, 0, 0, NULL);
1163 pRtlCreateUnicodeStringFromAsciiz(&target, "\\DosDevices");
1164 status = pNtCreateSymbolicLinkObject( NULL, SYMBOLIC_LINK_QUERY, &attr, &target );
1165 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER,
1166 "NtCreateSymbolicLinkObject got %08x\n", status );
1167 status = pNtOpenSymbolicLinkObject( NULL, SYMBOLIC_LINK_QUERY, &attr );
1168 ok( status == STATUS_ACCESS_VIOLATION || status == STATUS_INVALID_PARAMETER,
1169 "NtOpenSymbolicLinkObject got %08x\n", status );
1170
1171 status = pNtCreateSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, NULL, NULL);
1172 ok(status == STATUS_ACCESS_VIOLATION,
1173 "NtCreateSymbolicLinkObject should have failed with STATUS_ACCESS_VIOLATION got(%08x)\n", status);
1174 status = pNtOpenSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, NULL);
1175 ok(status == STATUS_INVALID_PARAMETER,
1176 "NtOpenSymbolicLinkObject should have failed with STATUS_INVALID_PARAMETER got(%08x)\n", status);
1177
1178 /* No attributes */
1179 status = pNtCreateSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, NULL, &target);
1180 ok(status == STATUS_SUCCESS || status == STATUS_ACCESS_VIOLATION, /* nt4 */
1181 "NtCreateSymbolicLinkObject failed(%08x)\n", status);
1182 pRtlFreeUnicodeString(&target);
1183 if (!status) pNtClose(h);
1184
1185 InitializeObjectAttributes(&attr, NULL, 0, 0, NULL);
1186 status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
1187 ok(status == STATUS_INVALID_PARAMETER ||
1188 broken(status == STATUS_SUCCESS), /* nt4 */
1189 "NtCreateSymbolicLinkObject should have failed with STATUS_INVALID_PARAMETER got(%08x)\n", status);
1190 if (!status) pNtClose(h);
1191 status = pNtOpenSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, &attr);
1192 ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
1193 "NtOpenSymbolicLinkObject should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
1194
1195 /* Bad name */
1196 pRtlCreateUnicodeStringFromAsciiz(&target, "anywhere");
1197 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1198
1199 pRtlCreateUnicodeStringFromAsciiz(&str, "");
1200 status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
1201 ok(status == STATUS_SUCCESS, "Failed to create SymbolicLink(%08x)\n", status);
1202 status = pNtOpenSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, &attr);
1203 ok(status == STATUS_OBJECT_PATH_SYNTAX_BAD,
1204 "NtOpenSymbolicLinkObject should have failed with STATUS_OBJECT_PATH_SYNTAX_BAD got(%08x)\n", status);
1205 pNtClose(link);
1206 pRtlFreeUnicodeString(&str);
1207
1208 pRtlCreateUnicodeStringFromAsciiz(&str, "\\");
1209 status = pNtCreateSymbolicLinkObject(&h, SYMBOLIC_LINK_QUERY, &attr, &target);
1210 todo_wine ok(status == STATUS_OBJECT_TYPE_MISMATCH,
1211 "NtCreateSymbolicLinkObject should have failed with STATUS_OBJECT_TYPE_MISMATCH got(%08x)\n", status);
1212 pRtlFreeUnicodeString(&str);
1213 pRtlFreeUnicodeString(&target);
1214
1215 pRtlCreateUnicodeStringFromAsciiz( &target, "->Somewhere");
1216
1217 pRtlCreateUnicodeStringFromAsciiz( &str, "BaseNamedObjects" );
1218 status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1219 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtCreateSymbolicLinkObject got %08x\n", status );
1220 status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1221 ok( status == STATUS_OBJECT_PATH_SYNTAX_BAD, "NtOpenSymbolicLinkObject got %08x\n", status );
1222 pRtlFreeUnicodeString( &str );
1223
1224 pRtlCreateUnicodeStringFromAsciiz( &str, "\\BaseNamedObjects\\" );
1225 status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1226 ok( status == STATUS_OBJECT_NAME_INVALID, "NtCreateSymbolicLinkObject got %08x\n", status );
1227 status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1228 ok( status == STATUS_OBJECT_NAME_INVALID, "NtOpenSymbolicLinkObject got %08x\n", status );
1229 pRtlFreeUnicodeString( &str );
1230
1231 pRtlCreateUnicodeStringFromAsciiz( &str, "\\\\BaseNamedObjects" );
1232 status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1233 ok( status == STATUS_OBJECT_NAME_INVALID, "NtCreateSymbolicLinkObject got %08x\n", status );
1234 status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1235 ok( status == STATUS_OBJECT_NAME_INVALID, "NtOpenSymbolicLinkObject got %08x\n", status );
1236 pRtlFreeUnicodeString( &str );
1237
1238 pRtlCreateUnicodeStringFromAsciiz( &str, "\\BaseNamedObjects\\\\om.c-test" );
1239 status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1240 ok( status == STATUS_OBJECT_NAME_INVALID, "NtCreateSymbolicLinkObject got %08x\n", status );
1241 status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1242 ok( status == STATUS_OBJECT_NAME_INVALID, "NtOpenSymbolicLinkObject got %08x\n", status );
1243 pRtlFreeUnicodeString( &str );
1244
1245 pRtlCreateUnicodeStringFromAsciiz( &str, "\\BaseNamedObjects\\om.c-test\\" );
1246 status = pNtCreateSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr, &target );
1247 ok( status == STATUS_OBJECT_NAME_INVALID || status == STATUS_OBJECT_PATH_NOT_FOUND,
1248 "NtCreateSymbolicLinkObject got %08x\n", status );
1249 status = pNtOpenSymbolicLinkObject( &h, SYMBOLIC_LINK_QUERY, &attr );
1250 ok( status == STATUS_OBJECT_NAME_INVALID || status == STATUS_OBJECT_PATH_NOT_FOUND,
1251 "NtOpenSymbolicLinkObject got %08x\n", status );
1252 pRtlFreeUnicodeString( &str );
1253 pRtlFreeUnicodeString(&target);
1254
1255 /* Compound test */
1256 if (!(dir = get_base_dir()))
1257 {
1258 win_skip( "couldn't find the BaseNamedObjects dir\n" );
1259 return;
1260 }
1261
1262 InitializeObjectAttributes(&attr, &str, 0, dir, NULL);
1263 pRtlCreateUnicodeStringFromAsciiz(&str, "test-link");
1264 pRtlCreateUnicodeStringFromAsciiz(&target, "\\DosDevices");
1265 status = pNtCreateSymbolicLinkObject(&link, SYMBOLIC_LINK_QUERY, &attr, &target);
1266 ok(status == STATUS_SUCCESS, "Failed to create SymbolicLink(%08x)\n", status);
1267 pRtlFreeUnicodeString(&str);
1268 pRtlFreeUnicodeString(&target);
1269
1270 pRtlCreateUnicodeStringFromAsciiz(&str, "test-link\\NUL");
1271 status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, 0);
1272 ok(status == STATUS_SUCCESS, "Failed to open NUL device(%08x)\n", status);
1273 status = pNtOpenFile(&h, GENERIC_READ, &attr, &iosb, FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE);
1274 ok(status == STATUS_SUCCESS, "Failed to open NUL device(%08x)\n", status);
1275 pRtlFreeUnicodeString(&str);
1276
1277 pNtClose(h);
1278 pNtClose(link);
1279 pNtClose(dir);
1280 }
1281
1282 static void test_query_object(void)
1283 {
1284 static const WCHAR name[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s',
1285 '\\','t','e','s','t','_','e','v','e','n','t'};
1286 static const WCHAR type_event[] = {'E','v','e','n','t'};
1287 static const WCHAR type_file[] = {'F','i','l','e'};
1288 static const WCHAR type_iocompletion[] = {'I','o','C','o','m','p','l','e','t','i','o','n'};
1289 static const WCHAR type_directory[] = {'D','i','r','e','c','t','o','r','y'};
1290 static const WCHAR type_section[] = {'S','e','c','t','i','o','n'};
1291 HANDLE handle;
1292 char buffer[1024];
1293 NTSTATUS status;
1294 ULONG len, expected_len;
1295 OBJECT_ATTRIBUTES attr;
1296 UNICODE_STRING path, *str;
1297 char dir[MAX_PATH], tmp_path[MAX_PATH], file1[MAX_PATH + 16];
1298 LARGE_INTEGER size;
1299
1300 InitializeObjectAttributes( &attr, &path, 0, 0, 0 );
1301
1302 handle = CreateEventA( NULL, FALSE, FALSE, "test_event" );
1303
1304 len = 0;
1305 status = pNtQueryObject( handle, ObjectNameInformation, buffer, 0, &len );
1306 ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1307 ok( len >= sizeof(UNICODE_STRING) + sizeof(name) + sizeof(WCHAR), "unexpected len %u\n", len );
1308
1309 len = 0;
1310 status = pNtQueryObject( handle, ObjectTypeInformation, buffer, 0, &len );
1311 ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1312 ok( len >= sizeof(OBJECT_TYPE_INFORMATION) + sizeof(type_event) + sizeof(WCHAR), "unexpected len %u\n", len );
1313
1314 len = 0;
1315 status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(UNICODE_STRING), &len );
1316 ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1317 ok( len >= sizeof(UNICODE_STRING) + sizeof(name) + sizeof(WCHAR), "unexpected len %u\n", len );
1318
1319 len = 0;
1320 status = pNtQueryObject( handle, ObjectTypeInformation, buffer, sizeof(OBJECT_TYPE_INFORMATION), &len );
1321 ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1322 ok( len >= sizeof(OBJECT_TYPE_INFORMATION) + sizeof(type_event) + sizeof(WCHAR), "unexpected len %u\n", len );
1323
1324 len = 0;
1325 status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1326 ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1327 ok( len > sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1328 str = (UNICODE_STRING *)buffer;
1329 ok( sizeof(UNICODE_STRING) + str->Length + sizeof(WCHAR) == len, "unexpected len %u\n", len );
1330 ok( str->Length >= sizeof(name), "unexpected len %u\n", str->Length );
1331 ok( len > sizeof(UNICODE_STRING) + sizeof("\\test_event") * sizeof(WCHAR),
1332 "name too short %s\n", wine_dbgstr_w(str->Buffer) );
1333 /* there can be a \\Sessions prefix in the name */
1334 ok( !memcmp( str->Buffer + (str->Length - sizeof(name)) / sizeof(WCHAR), name, sizeof(name) ),
1335 "wrong name %s\n", wine_dbgstr_w(str->Buffer) );
1336 trace( "got %s len %u\n", wine_dbgstr_w(str->Buffer), len );
1337
1338 len -= sizeof(WCHAR);
1339 status = pNtQueryObject( handle, ObjectNameInformation, buffer, len, &len );
1340 ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1341 ok( len >= sizeof(UNICODE_STRING) + sizeof(name) + sizeof(WCHAR), "unexpected len %u\n", len );
1342
1343 len = 0;
1344 memset( buffer, 0, sizeof(buffer) );
1345 status = pNtQueryObject( handle, ObjectTypeInformation, buffer, sizeof(buffer), &len );
1346 ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1347 ok( len > sizeof(OBJECT_TYPE_INFORMATION), "unexpected len %u\n", len );
1348 str = (UNICODE_STRING *)buffer;
1349 ok( len >= sizeof(OBJECT_TYPE_INFORMATION) + str->Length + sizeof(WCHAR), "unexpected len %u\n", len );
1350 ok( str->Buffer && !memcmp( str->Buffer, type_event, sizeof(type_event) ),
1351 "wrong/bad type name %s (%p)\n", wine_dbgstr_w(str->Buffer), str->Buffer );
1352
1353 len -= sizeof(WCHAR);
1354 status = pNtQueryObject( handle, ObjectTypeInformation, buffer, len, &len );
1355 ok( status == STATUS_INFO_LENGTH_MISMATCH, "NtQueryObject failed %x\n", status );
1356 ok( len >= sizeof(OBJECT_TYPE_INFORMATION) + sizeof(type_event) + sizeof(WCHAR), "unexpected len %u\n", len );
1357
1358 pNtClose( handle );
1359
1360 handle = CreateEventA( NULL, FALSE, FALSE, NULL );
1361 len = 0;
1362 status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1363 ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1364 ok( len == sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1365 str = (UNICODE_STRING *)buffer;
1366 ok( str->Length == 0, "unexpected len %u\n", len );
1367 ok( str->Buffer == NULL, "unexpected ptr %p\n", str->Buffer );
1368 pNtClose( handle );
1369
1370 GetWindowsDirectoryA( dir, MAX_PATH );
1371 handle = CreateFileA( dir, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1372 FILE_FLAG_BACKUP_SEMANTICS, 0 );
1373 len = 0;
1374 status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1375 ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1376 ok( len > sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1377 str = (UNICODE_STRING *)buffer;
1378 expected_len = sizeof(UNICODE_STRING) + str->Length + sizeof(WCHAR);
1379 ok( len == expected_len || broken(len == expected_len - sizeof(WCHAR)), /* NT4 */
1380 "unexpected len %u\n", len );
1381 trace( "got %s len %u\n", wine_dbgstr_w(str->Buffer), len );
1382
1383 len = 0;
1384 status = pNtQueryObject( handle, ObjectNameInformation, buffer, 0, &len );
1385 ok( status == STATUS_INFO_LENGTH_MISMATCH || broken(status == STATUS_INSUFFICIENT_RESOURCES),
1386 "NtQueryObject failed %x\n", status );
1387 ok( len == expected_len || broken(!len || len == sizeof(UNICODE_STRING)),
1388 "unexpected len %u\n", len );
1389
1390 len = 0;
1391 status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(UNICODE_STRING), &len );
1392 ok( status == STATUS_BUFFER_OVERFLOW || broken(status == STATUS_INSUFFICIENT_RESOURCES
1393 || status == STATUS_INFO_LENGTH_MISMATCH),
1394 "NtQueryObject failed %x\n", status );
1395 ok( len == expected_len || broken(!len),
1396 "unexpected len %u\n", len );
1397
1398 len = 0;
1399 memset( buffer, 0, sizeof(buffer) );
1400 status = pNtQueryObject( handle, ObjectTypeInformation, buffer, sizeof(buffer), &len );
1401 ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1402 ok( len > sizeof(OBJECT_TYPE_INFORMATION), "unexpected len %u\n", len );
1403 str = (UNICODE_STRING *)buffer;
1404 expected_len = sizeof(OBJECT_TYPE_INFORMATION) + str->Length + sizeof(WCHAR);
1405 ok( len >= expected_len, "unexpected len %u\n", len );
1406 ok( str->Buffer && !memcmp( str->Buffer, type_file, sizeof(type_file) ),
1407 "wrong/bad type name %s (%p)\n", wine_dbgstr_w(str->Buffer), str->Buffer );
1408
1409 pNtClose( handle );
1410
1411 GetTempPathA(MAX_PATH, tmp_path);
1412 GetTempFileNameA(tmp_path, "foo", 0, file1);
1413 handle = CreateFileA(file1, GENERIC_WRITE | DELETE, 0, NULL, CREATE_ALWAYS, 0, 0);
1414 len = 0;
1415 memset( buffer, 0, sizeof(buffer) );
1416 status = pNtQueryObject( handle, ObjectTypeInformation, buffer, sizeof(buffer), &len );
1417 ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1418 ok( len > sizeof(OBJECT_TYPE_INFORMATION), "unexpected len %u\n", len );
1419 str = (UNICODE_STRING *)buffer;
1420 expected_len = sizeof(OBJECT_TYPE_INFORMATION) + str->Length + sizeof(WCHAR);
1421 ok( len >= expected_len, "unexpected len %u\n", len );
1422 ok( str->Buffer && !memcmp( str->Buffer, type_file, sizeof(type_file) ),
1423 "wrong/bad type name %s (%p)\n", wine_dbgstr_w(str->Buffer), str->Buffer );
1424 DeleteFileA( file1 );
1425 pNtClose( handle );
1426
1427 status = pNtCreateIoCompletion( &handle, IO_COMPLETION_ALL_ACCESS, NULL, 0 );
1428 ok( status == STATUS_SUCCESS, "NtCreateIoCompletion failed %x\n", status);
1429 len = 0;
1430 memset( buffer, 0, sizeof(buffer) );
1431 status = pNtQueryObject( handle, ObjectTypeInformation, buffer, sizeof(buffer), &len );
1432 ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1433 ok( len > sizeof(OBJECT_TYPE_INFORMATION), "unexpected len %u\n", len );
1434 str = (UNICODE_STRING *)buffer;
1435 expected_len = sizeof(OBJECT_TYPE_INFORMATION) + str->Length + sizeof(WCHAR);
1436 ok( len >= expected_len, "unexpected len %u\n", len );
1437 ok( str->Buffer && !memcmp( str->Buffer, type_iocompletion, sizeof(type_iocompletion) ),
1438 "wrong/bad type name %s (%p)\n", wine_dbgstr_w(str->Buffer), str->Buffer );
1439 pNtClose( handle );
1440
1441 status = pNtCreateDirectoryObject( &handle, DIRECTORY_QUERY, NULL );
1442 ok(status == STATUS_SUCCESS, "Failed to create Directory %08x\n", status);
1443 len = 0;
1444 memset( buffer, 0, sizeof(buffer) );
1445 status = pNtQueryObject( handle, ObjectTypeInformation, buffer, sizeof(buffer), &len );
1446 ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1447 ok( len > sizeof(OBJECT_TYPE_INFORMATION), "unexpected len %u\n", len );
1448 str = (UNICODE_STRING *)buffer;
1449 expected_len = sizeof(OBJECT_TYPE_INFORMATION) + str->Length + sizeof(WCHAR);
1450 ok( len >= expected_len, "unexpected len %u\n", len );
1451 ok( str->Buffer && !memcmp( str->Buffer, type_directory, sizeof(type_directory) ),
1452 "wrong/bad type name %s (%p)\n", wine_dbgstr_w(str->Buffer), str->Buffer );
1453 pNtClose( handle );
1454
1455 size.u.LowPart = 256;
1456 size.u.HighPart = 0;
1457 status = pNtCreateSection( &handle, SECTION_MAP_WRITE, NULL, &size, PAGE_READWRITE, SEC_COMMIT, 0 );
1458 ok( status == STATUS_SUCCESS , "NtCreateSection returned %x\n", status );
1459 len = 0;
1460 memset( buffer, 0, sizeof(buffer) );
1461 status = pNtQueryObject( handle, ObjectTypeInformation, buffer, sizeof(buffer), &len );
1462 ok( status == STATUS_SUCCESS, "NtQueryObject failed %x\n", status );
1463 ok( len > sizeof(OBJECT_TYPE_INFORMATION), "unexpected len %u\n", len );
1464 str = (UNICODE_STRING *)buffer;
1465 expected_len = sizeof(OBJECT_TYPE_INFORMATION) + str->Length + sizeof(WCHAR);
1466 ok( len >= expected_len, "unexpected len %u\n", len );
1467 ok( str->Buffer && !memcmp( str->Buffer, type_section, sizeof(type_section) ),
1468 "wrong/bad type name %s (%p)\n", wine_dbgstr_w(str->Buffer), str->Buffer );
1469 pNtClose( handle );
1470
1471 handle = CreateMailslotA( "\\\\.\\mailslot\\test_mailslot", 100, 1000, NULL );
1472 ok( handle != INVALID_HANDLE_VALUE, "CreateMailslot failed err %u\n", GetLastError() );
1473 len = 0;
1474 status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1475 ok( status == STATUS_SUCCESS , "NtQueryObject returned %x\n", status );
1476 str = (UNICODE_STRING *)buffer;
1477 ok( len > sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1478 str = (UNICODE_STRING *)buffer;
1479 expected_len = sizeof(UNICODE_STRING) + str->Length + sizeof(WCHAR);
1480 ok( len == expected_len || broken(len == expected_len - sizeof(WCHAR)), /* NT4 */
1481 "unexpected len %u\n", len );
1482 ok( len > sizeof(UNICODE_STRING) + sizeof("\\test_mailslot") * sizeof(WCHAR),
1483 "name too short %s\n", wine_dbgstr_w(str->Buffer) );
1484 trace( "got %s len %u\n", wine_dbgstr_w(str->Buffer), len );
1485 pNtClose( handle );
1486
1487 handle = CreateNamedPipeA( "\\\\.\\pipe\\test_pipe", PIPE_ACCESS_DUPLEX, PIPE_READMODE_BYTE,
1488 1, 1000, 1000, 1000, NULL );
1489 ok( handle != INVALID_HANDLE_VALUE, "CreateNamedPipe failed err %u\n", GetLastError() );
1490 len = 0;
1491 status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1492 ok( status == STATUS_SUCCESS , "NtQueryObject returned %x\n", status );
1493 str = (UNICODE_STRING *)buffer;
1494 todo_wine
1495 ok( len > sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1496 str = (UNICODE_STRING *)buffer;
1497 expected_len = sizeof(UNICODE_STRING) + str->Length + sizeof(WCHAR);
1498 todo_wine
1499 ok( len == expected_len || broken(len == expected_len - sizeof(WCHAR)), /* NT4 */
1500 "unexpected len %u\n", len );
1501 todo_wine
1502 ok( len > sizeof(UNICODE_STRING) + sizeof("\\test_pipe") * sizeof(WCHAR),
1503 "name too short %s\n", wine_dbgstr_w(str->Buffer) );
1504 trace( "got %s len %u\n", wine_dbgstr_w(str->Buffer), len );
1505 pNtClose( handle );
1506
1507 pRtlCreateUnicodeStringFromAsciiz( &path, "\\REGISTRY\\Machine\\Software\\Classes" );
1508 status = pNtCreateKey( &handle, KEY_ALL_ACCESS, &attr, 0, 0, 0, 0 );
1509 ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED,
1510 "NtCreateKey failed status %x\n", status );
1511 pRtlFreeUnicodeString( &path );
1512 if (status == STATUS_SUCCESS)
1513 {
1514 len = 0;
1515 status = pNtQueryObject( handle, ObjectNameInformation, buffer, sizeof(buffer), &len );
1516 ok( status == STATUS_SUCCESS , "NtQueryObject returned %x\n", status );
1517 str = (UNICODE_STRING *)buffer;
1518 todo_wine
1519 ok( len > sizeof(UNICODE_STRING), "unexpected len %u\n", len );
1520 str = (UNICODE_STRING *)buffer;
1521 expected_len = sizeof(UNICODE_STRING) + str->Length + sizeof(WCHAR);
1522 todo_wine
1523 ok( len == expected_len || broken(len == expected_len - sizeof(WCHAR)), /* NT4 */
1524 "unexpected len %u\n", len );
1525 todo_wine
1526 ok( len > sizeof(UNICODE_STRING) + sizeof("\\Classes") * sizeof(WCHAR),
1527 "name too short %s\n", wine_dbgstr_w(str->Buffer) );
1528 trace( "got %s len %u\n", wine_dbgstr_w(str->Buffer), len );
1529 pNtClose( handle );
1530 }
1531 }
1532
1533 static void test_type_mismatch(void)
1534 {
1535 HANDLE h;
1536 NTSTATUS res;
1537 OBJECT_ATTRIBUTES attr;
1538
1539 attr.Length = sizeof(attr);
1540 attr.RootDirectory = 0;
1541 attr.ObjectName = NULL;
1542 attr.Attributes = 0;
1543 attr.SecurityDescriptor = NULL;
1544 attr.SecurityQualityOfService = NULL;
1545
1546 res = pNtCreateEvent( &h, 0, &attr, 0, 0 );
1547 ok(!res, "can't create event: %x\n", res);
1548
1549 res = pNtReleaseSemaphore( h, 30, NULL );
1550 ok(res == STATUS_OBJECT_TYPE_MISMATCH, "expected 0xc0000024, got %x\n", res);
1551
1552 pNtClose( h );
1553 }
1554
1555 static void test_event(void)
1556 {
1557 HANDLE Event;
1558 HANDLE Event2;
1559 NTSTATUS status;
1560 UNICODE_STRING str;
1561 OBJECT_ATTRIBUTES attr;
1562 EVENT_BASIC_INFORMATION info;
1563 static const WCHAR eventName[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s','\\','t','e','s','t','E','v','e','n','t',0};
1564
1565 pRtlInitUnicodeString(&str, eventName);
1566 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1567
1568 status = pNtCreateEvent(&Event, GENERIC_ALL, &attr, 1, 0);
1569 ok( status == STATUS_SUCCESS, "NtCreateEvent failed %08x\n", status );
1570
1571 status = pNtPulseEvent(Event, NULL);
1572 ok( status == STATUS_SUCCESS, "NtPulseEvent failed %08x\n", status );
1573
1574 status = pNtQueryEvent(Event, EventBasicInformation, &info, sizeof(info), NULL);
1575 ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08x\n", status );
1576 ok( info.EventType == 1 && info.EventState == 0,
1577 "NtQueryEvent failed, expected 1 0, got %d %d\n", info.EventType, info.EventState );
1578
1579 status = pNtOpenEvent(&Event2, GENERIC_ALL, &attr);
1580 ok( status == STATUS_SUCCESS, "NtOpenEvent failed %08x\n", status );
1581
1582 pNtClose(Event);
1583
1584 status = pNtQueryEvent(Event2, EventBasicInformation, &info, sizeof(info), NULL);
1585 ok( status == STATUS_SUCCESS, "NtQueryEvent failed %08x\n", status );
1586 ok( info.EventType == 1 && info.EventState == 0,
1587 "NtQueryEvent failed, expected 1 0, got %d %d\n", info.EventType, info.EventState );
1588
1589 pNtClose(Event2);
1590 }
1591
1592 static const WCHAR keyed_nameW[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s',
1593 '\\','W','i','n','e','T','e','s','t','E','v','e','n','t',0};
1594
1595 static DWORD WINAPI keyed_event_thread( void *arg )
1596 {
1597 HANDLE handle;
1598 NTSTATUS status;
1599 LARGE_INTEGER timeout;
1600 OBJECT_ATTRIBUTES attr;
1601 UNICODE_STRING str;
1602 ULONG_PTR i;
1603
1604 attr.Length = sizeof(attr);
1605 attr.RootDirectory = 0;
1606 attr.ObjectName = &str;
1607 attr.Attributes = 0;
1608 attr.SecurityDescriptor = NULL;
1609 attr.SecurityQualityOfService = NULL;
1610 RtlInitUnicodeString( &str, keyed_nameW );
1611
1612 status = pNtOpenKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS, &attr );
1613 ok( !status, "NtOpenKeyedEvent failed %x\n", status );
1614
1615 for (i = 0; i < 20; i++)
1616 {
1617 if (i & 1)
1618 status = pNtWaitForKeyedEvent( handle, (void *)(i * 2), 0, NULL );
1619 else
1620 status = pNtReleaseKeyedEvent( handle, (void *)(i * 2), 0, NULL );
1621 ok( status == STATUS_SUCCESS, "%li: failed %x\n", i, status );
1622 Sleep( 20 - i );
1623 }
1624
1625 status = pNtReleaseKeyedEvent( handle, (void *)0x1234, 0, NULL );
1626 ok( status == STATUS_SUCCESS, "NtReleaseKeyedEvent %x\n", status );
1627
1628 timeout.QuadPart = -10000;
1629 status = pNtWaitForKeyedEvent( handle, (void *)0x5678, 0, &timeout );
1630 ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1631 status = pNtReleaseKeyedEvent( handle, (void *)0x9abc, 0, &timeout );
1632 ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1633
1634 NtClose( handle );
1635 return 0;
1636 }
1637
1638 static void test_keyed_events(void)
1639 {
1640 OBJECT_ATTRIBUTES attr;
1641 UNICODE_STRING str;
1642 HANDLE handle, event, thread;
1643 NTSTATUS status;
1644 LARGE_INTEGER timeout;
1645 ULONG_PTR i;
1646
1647 if (!pNtCreateKeyedEvent)
1648 {
1649 win_skip( "Keyed events not supported\n" );
1650 return;
1651 }
1652
1653 attr.Length = sizeof(attr);
1654 attr.RootDirectory = 0;
1655 attr.ObjectName = &str;
1656 attr.Attributes = 0;
1657 attr.SecurityDescriptor = NULL;
1658 attr.SecurityQualityOfService = NULL;
1659 RtlInitUnicodeString( &str, keyed_nameW );
1660
1661 status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS | SYNCHRONIZE, &attr, 0 );
1662 ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1663
1664 status = WaitForSingleObject( handle, 1000 );
1665 ok( status == 0, "WaitForSingleObject %x\n", status );
1666
1667 timeout.QuadPart = -100000;
1668 status = pNtWaitForKeyedEvent( handle, (void *)255, 0, &timeout );
1669 ok( status == STATUS_INVALID_PARAMETER_1, "NtWaitForKeyedEvent %x\n", status );
1670 status = pNtReleaseKeyedEvent( handle, (void *)255, 0, &timeout );
1671 ok( status == STATUS_INVALID_PARAMETER_1, "NtReleaseKeyedEvent %x\n", status );
1672
1673 status = pNtWaitForKeyedEvent( handle, (void *)254, 0, &timeout );
1674 ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1675 status = pNtReleaseKeyedEvent( handle, (void *)254, 0, &timeout );
1676 ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1677
1678 status = pNtWaitForKeyedEvent( handle, NULL, 0, &timeout );
1679 ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1680 status = pNtReleaseKeyedEvent( handle, NULL, 0, &timeout );
1681 ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1682
1683 status = pNtWaitForKeyedEvent( (HANDLE)0xdeadbeef, (void *)9, 0, &timeout );
1684 ok( status == STATUS_INVALID_PARAMETER_1, "NtWaitForKeyedEvent %x\n", status );
1685 status = pNtReleaseKeyedEvent( (HANDLE)0xdeadbeef, (void *)9, 0, &timeout );
1686 ok( status == STATUS_INVALID_PARAMETER_1, "NtReleaseKeyedEvent %x\n", status );
1687
1688 status = pNtWaitForKeyedEvent( (HANDLE)0xdeadbeef, (void *)8, 0, &timeout );
1689 ok( status == STATUS_INVALID_HANDLE, "NtWaitForKeyedEvent %x\n", status );
1690 status = pNtReleaseKeyedEvent( (HANDLE)0xdeadbeef, (void *)8, 0, &timeout );
1691 ok( status == STATUS_INVALID_HANDLE, "NtReleaseKeyedEvent %x\n", status );
1692
1693 thread = CreateThread( NULL, 0, keyed_event_thread, 0, 0, NULL );
1694 for (i = 0; i < 20; i++)
1695 {
1696 if (i & 1)
1697 status = pNtReleaseKeyedEvent( handle, (void *)(i * 2), 0, NULL );
1698 else
1699 status = pNtWaitForKeyedEvent( handle, (void *)(i * 2), 0, NULL );
1700 ok( status == STATUS_SUCCESS, "%li: failed %x\n", i, status );
1701 Sleep( i );
1702 }
1703 status = pNtWaitForKeyedEvent( handle, (void *)0x1234, 0, &timeout );
1704 ok( status == STATUS_SUCCESS, "NtWaitForKeyedEvent %x\n", status );
1705 status = pNtWaitForKeyedEvent( handle, (void *)0x5678, 0, &timeout );
1706 ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1707 status = pNtReleaseKeyedEvent( handle, (void *)0x9abc, 0, &timeout );
1708 ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1709
1710 ok( WaitForSingleObject( thread, 30000 ) == 0, "wait failed\n" );
1711
1712 NtClose( handle );
1713
1714 /* test access rights */
1715
1716 status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_WAIT, &attr, 0 );
1717 ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1718 status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1719 ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1720 status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1721 ok( status == STATUS_ACCESS_DENIED, "NtReleaseKeyedEvent %x\n", status );
1722 NtClose( handle );
1723
1724 status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_WAKE, &attr, 0 );
1725 ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1726 status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1727 ok( status == STATUS_ACCESS_DENIED, "NtWaitForKeyedEvent %x\n", status );
1728 status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1729 ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1730 NtClose( handle );
1731
1732 status = pNtCreateKeyedEvent( &handle, KEYEDEVENT_ALL_ACCESS, &attr, 0 );
1733 ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1734 status = WaitForSingleObject( handle, 1000 );
1735 ok( status == WAIT_FAILED && GetLastError() == ERROR_ACCESS_DENIED,
1736 "WaitForSingleObject %x err %u\n", status, GetLastError() );
1737 status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1738 ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1739 status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1740 ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1741 NtClose( handle );
1742
1743 /* GENERIC_READ gives wait access */
1744 status = pNtCreateKeyedEvent( &handle, GENERIC_READ, &attr, 0 );
1745 ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1746 status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1747 ok( status == STATUS_TIMEOUT, "NtWaitForKeyedEvent %x\n", status );
1748 status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1749 ok( status == STATUS_ACCESS_DENIED, "NtReleaseKeyedEvent %x\n", status );
1750 NtClose( handle );
1751
1752 /* GENERIC_WRITE gives wake access */
1753 status = pNtCreateKeyedEvent( &handle, GENERIC_WRITE, &attr, 0 );
1754 ok( !status, "NtCreateKeyedEvent failed %x\n", status );
1755 status = pNtWaitForKeyedEvent( handle, (void *)8, 0, &timeout );
1756 ok( status == STATUS_ACCESS_DENIED, "NtWaitForKeyedEvent %x\n", status );
1757 status = pNtReleaseKeyedEvent( handle, (void *)8, 0, &timeout );
1758 ok( status == STATUS_TIMEOUT, "NtReleaseKeyedEvent %x\n", status );
1759
1760 /* it's not an event */
1761 status = pNtPulseEvent( handle, NULL );
1762 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtPulseEvent %x\n", status );
1763
1764 status = pNtCreateEvent( &event, GENERIC_ALL, &attr, FALSE, FALSE );
1765 ok( status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_OBJECT_TYPE_MISMATCH,
1766 "CreateEvent %x\n", status );
1767
1768 NtClose( handle );
1769
1770 status = pNtCreateEvent( &event, GENERIC_ALL, &attr, FALSE, FALSE );
1771 ok( status == 0, "CreateEvent %x\n", status );
1772 status = pNtWaitForKeyedEvent( event, (void *)8, 0, &timeout );
1773 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtWaitForKeyedEvent %x\n", status );
1774 status = pNtReleaseKeyedEvent( event, (void *)8, 0, &timeout );
1775 ok( status == STATUS_OBJECT_TYPE_MISMATCH, "NtReleaseKeyedEvent %x\n", status );
1776 NtClose( event );
1777 }
1778
1779 static void test_null_device(void)
1780 {
1781 OBJECT_ATTRIBUTES attr;
1782 IO_STATUS_BLOCK iosb;
1783 UNICODE_STRING str;
1784 NTSTATUS status;
1785 DWORD num_bytes;
1786 OVERLAPPED ov;
1787 char buf[64];
1788 HANDLE null;
1789 BOOL ret;
1790
1791 memset(buf, 0xAA, sizeof(buf));
1792 memset(&ov, 0, sizeof(ov));
1793 ov.hEvent = CreateEventA(NULL, TRUE, FALSE, NULL);
1794
1795 pRtlCreateUnicodeStringFromAsciiz(&str, "\\Device\\Null");
1796 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
1797 status = pNtOpenSymbolicLinkObject(&null, SYMBOLIC_LINK_QUERY, &attr);
1798 ok(status == STATUS_OBJECT_TYPE_MISMATCH,
1799 "expected STATUS_OBJECT_TYPE_MISMATCH, got %08x\n", status);
1800
1801 status = pNtOpenFile(&null, GENERIC_READ | GENERIC_WRITE, &attr, &iosb,
1802 FILE_SHARE_READ | FILE_SHARE_WRITE, 0);
1803 ok(status == STATUS_SUCCESS,
1804 "expected STATUS_SUCCESS, got %08x\n", status);
1805
1806 SetLastError(0xdeadbeef);
1807 ret = WriteFile(null, buf, sizeof(buf), &num_bytes, NULL);
1808 ok(!ret, "WriteFile unexpectedly succeeded\n");
1809 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1810 "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1811
1812 SetLastError(0xdeadbeef);
1813 ret = ReadFile(null, buf, sizeof(buf), &num_bytes, NULL);
1814 ok(!ret, "ReadFile unexpectedly succeeded\n");
1815 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1816 "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1817
1818 num_bytes = 0xdeadbeef;
1819 SetLastError(0xdeadbeef);
1820 ret = WriteFile(null, buf, sizeof(buf), &num_bytes, &ov);
1821 if (ret || GetLastError() != ERROR_IO_PENDING)
1822 {
1823 ok(ret, "WriteFile failed with error %u\n", GetLastError());
1824 }
1825 else
1826 {
1827 num_bytes = 0xdeadbeef;
1828 ret = GetOverlappedResult(null, &ov, &num_bytes, TRUE);
1829 ok(ret, "GetOverlappedResult failed with error %u\n", GetLastError());
1830 }
1831 ok(num_bytes == sizeof(buf), "expected num_bytes = %u, got %u\n",
1832 (DWORD)sizeof(buf), num_bytes);
1833
1834 num_bytes = 0xdeadbeef;
1835 SetLastError(0xdeadbeef);
1836 ret = ReadFile(null, buf, sizeof(buf), &num_bytes, &ov);
1837 if (ret || GetLastError() != ERROR_IO_PENDING)
1838 {
1839 ok(!ret, "ReadFile unexpectedly succeeded\n");
1840 }
1841 else
1842 {
1843 num_bytes = 0xdeadbeef;
1844 ret = GetOverlappedResult(null, &ov, &num_bytes, TRUE);
1845 ok(!ret, "GetOverlappedResult unexpectedly succeeded\n");
1846 }
1847 ok(GetLastError() == ERROR_HANDLE_EOF,
1848 "expected ERROR_HANDLE_EOF, got %u\n", GetLastError());
1849
1850 pNtClose(null);
1851
1852 null = CreateFileA("\\\\.\\Null", GENERIC_READ | GENERIC_WRITE,
1853 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1854 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1855 ok(null == INVALID_HANDLE_VALUE, "CreateFileA unexpectedly succeeded\n");
1856 ok(GetLastError() == ERROR_FILE_NOT_FOUND,
1857 "expected ERROR_FILE_NOT_FOUND, got %u\n", GetLastError());
1858
1859 null = CreateFileA("\\\\.\\Device\\Null", GENERIC_READ | GENERIC_WRITE,
1860 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1861 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
1862 ok(null == INVALID_HANDLE_VALUE, "CreateFileA unexpectedly succeeded\n");
1863 ok(GetLastError() == ERROR_PATH_NOT_FOUND,
1864 "expected ERROR_PATH_NOT_FOUND, got %u\n", GetLastError());
1865
1866 pRtlFreeUnicodeString(&str);
1867 CloseHandle(ov.hEvent);
1868 }
1869
1870 static DWORD WINAPI mutant_thread( void *arg )
1871 {
1872 MUTANT_BASIC_INFORMATION info;
1873 NTSTATUS status;
1874 HANDLE mutant;
1875 DWORD ret;
1876
1877 mutant = arg;
1878 ret = WaitForSingleObject( mutant, 1000 );
1879 ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08x\n", ret );
1880
1881 memset(&info, 0xcc, sizeof(info));
1882 status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
1883 ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
1884 ok( info.CurrentCount == 0, "expected 0, got %d\n", info.CurrentCount );
1885 ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );
1886 ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
1887 /* abandon mutant */
1888
1889 return 0;
1890 }
1891
1892 static void test_mutant(void)
1893 {
1894 static const WCHAR name[] = {'\\','B','a','s','e','N','a','m','e','d','O','b','j','e','c','t','s',
1895 '\\','t','e','s','t','_','m','u','t','a','n','t',0};
1896 MUTANT_BASIC_INFORMATION info;
1897 OBJECT_ATTRIBUTES attr;
1898 UNICODE_STRING str;
1899 NTSTATUS status;
1900 HANDLE mutant;
1901 HANDLE thread;
1902 DWORD ret;
1903 ULONG len;
1904 LONG prev;
1905
1906 pRtlInitUnicodeString(&str, name);
1907 InitializeObjectAttributes(&attr, &str, 0, 0, NULL);
1908 status = pNtCreateMutant(&mutant, GENERIC_ALL, &attr, TRUE);
1909 ok( status == STATUS_SUCCESS, "Failed to create Mutant(%08x)\n", status );
1910
1911 /* bogus */
1912 status = pNtQueryMutant(mutant, MutantBasicInformation, &info, 0, NULL);
1913 ok( status == STATUS_INFO_LENGTH_MISMATCH,
1914 "Failed to NtQueryMutant, expected STATUS_INFO_LENGTH_MISMATCH, got %08x\n", status );
1915 status = pNtQueryMutant(mutant, 0x42, &info, sizeof(info), NULL);
1916 ok( status == STATUS_INVALID_INFO_CLASS || broken(status == STATUS_NOT_IMPLEMENTED), /* 32-bit on Vista/2k8 */
1917 "Failed to NtQueryMutant, expected STATUS_INVALID_INFO_CLASS, got %08x\n", status );
1918 status = pNtQueryMutant((HANDLE)0xdeadbeef, MutantBasicInformation, &info, sizeof(info), NULL);
1919 ok( status == STATUS_INVALID_HANDLE,
1920 "Failed to NtQueryMutant, expected STATUS_INVALID_HANDLE, got %08x\n", status );
1921
1922 /* new */
1923 len = -1;
1924 memset(&info, 0xcc, sizeof(info));
1925 status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), &len);
1926 ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
1927 ok( info.CurrentCount == 0, "expected 0, got %d\n", info.CurrentCount );
1928 ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );
1929 ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
1930 ok( len == sizeof(info), "got %u\n", len );
1931
1932 ret = WaitForSingleObject( mutant, 1000 );
1933 ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08x\n", ret );
1934
1935 memset(&info, 0xcc, sizeof(info));
1936 status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
1937 ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
1938 ok( info.CurrentCount == -1, "expected -1, got %d\n", info.CurrentCount );
1939 ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );
1940 ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
1941
1942 prev = 0xdeadbeef;
1943 status = pNtReleaseMutant(mutant, &prev);
1944 ok( status == STATUS_SUCCESS, "NtQueryRelease failed %08x\n", status );
1945 ok( prev == -1, "NtQueryRelease failed, expected -1, got %d\n", prev );
1946
1947 prev = 0xdeadbeef;
1948 status = pNtReleaseMutant(mutant, &prev);
1949 ok( status == STATUS_SUCCESS, "NtQueryRelease failed %08x\n", status );
1950 ok( prev == 0, "NtQueryRelease failed, expected 0, got %d\n", prev );
1951
1952 memset(&info, 0xcc, sizeof(info));
1953 status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
1954 ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
1955 ok( info.CurrentCount == 1, "expected 1, got %d\n", info.CurrentCount );
1956 ok( info.OwnedByCaller == FALSE, "expected FALSE, got %d\n", info.OwnedByCaller );
1957 ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
1958
1959 /* abandoned */
1960 thread = CreateThread( NULL, 0, mutant_thread, mutant, 0, NULL );
1961 ret = WaitForSingleObject( thread, 1000 );
1962 ok( ret == WAIT_OBJECT_0, "WaitForSingleObject failed %08x\n", ret );
1963 CloseHandle( thread );
1964
1965 memset(&info, 0xcc, sizeof(info));
1966 status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
1967 ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
1968 ok( info.CurrentCount == 1, "expected 0, got %d\n", info.CurrentCount );
1969 ok( info.OwnedByCaller == FALSE, "expected FALSE, got %d\n", info.OwnedByCaller );
1970 ok( info.AbandonedState == TRUE, "expected TRUE, got %d\n", info.AbandonedState );
1971
1972 ret = WaitForSingleObject( mutant, 1000 );
1973 ok( ret == WAIT_ABANDONED_0, "WaitForSingleObject failed %08x\n", ret );
1974
1975 memset(&info, 0xcc, sizeof(info));
1976 status = pNtQueryMutant(mutant, MutantBasicInformation, &info, sizeof(info), NULL);
1977 ok( status == STATUS_SUCCESS, "NtQueryMutant failed %08x\n", status );
1978 ok( info.CurrentCount == 0, "expected 0, got %d\n", info.CurrentCount );
1979 ok( info.OwnedByCaller == TRUE, "expected TRUE, got %d\n", info.OwnedByCaller );
1980 ok( info.AbandonedState == FALSE, "expected FALSE, got %d\n", info.AbandonedState );
1981
1982 NtClose( mutant );
1983 }
1984
1985 START_TEST(om)
1986 {
1987 HMODULE hntdll = GetModuleHandleA("ntdll.dll");
1988 HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
1989
1990 if (!hntdll)
1991 {
1992 skip("not running on NT, skipping test\n");
1993 return;
1994 }
1995
1996 pCreateWaitableTimerA = (void *)GetProcAddress(hkernel32, "CreateWaitableTimerA");
1997
1998 pRtlCreateUnicodeStringFromAsciiz = (void *)GetProcAddress(hntdll, "RtlCreateUnicodeStringFromAsciiz");
1999 pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
2000 pNtCreateEvent = (void *)GetProcAddress(hntdll, "NtCreateEvent");
2001 pNtCreateJobObject = (void *)GetProcAddress(hntdll, "NtCreateJobObject");
2002 pNtOpenJobObject = (void *)GetProcAddress(hntdll, "NtOpenJobObject");
2003 pNtCreateKey = (void *)GetProcAddress(hntdll, "NtCreateKey");
2004 pNtOpenKey = (void *)GetProcAddress(hntdll, "NtOpenKey");
2005 pNtDeleteKey = (void *)GetProcAddress(hntdll, "NtDeleteKey");
2006 pNtCreateMailslotFile = (void *)GetProcAddress(hntdll, "NtCreateMailslotFile");
2007 pNtCreateMutant = (void *)GetProcAddress(hntdll, "NtCreateMutant");
2008 pNtOpenEvent = (void *)GetProcAddress(hntdll, "NtOpenEvent");
2009 pNtQueryEvent = (void *)GetProcAddress(hntdll, "NtQueryEvent");
2010 pNtPulseEvent = (void *)GetProcAddress(hntdll, "NtPulseEvent");
2011 pNtOpenMutant = (void *)GetProcAddress(hntdll, "NtOpenMutant");
2012 pNtQueryMutant = (void *)GetProcAddress(hntdll, "NtQueryMutant");
2013 pNtReleaseMutant = (void *)GetProcAddress(hntdll, "NtReleaseMutant");
2014 pNtOpenFile = (void *)GetProcAddress(hntdll, "NtOpenFile");
2015 pNtClose = (void *)GetProcAddress(hntdll, "NtClose");
2016 pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
2017 pNtCreateNamedPipeFile = (void *)GetProcAddress(hntdll, "NtCreateNamedPipeFile");
2018 pNtOpenDirectoryObject = (void *)GetProcAddress(hntdll, "NtOpenDirectoryObject");
2019 pNtCreateDirectoryObject= (void *)GetProcAddress(hntdll, "NtCreateDirectoryObject");
2020 pNtOpenSymbolicLinkObject = (void *)GetProcAddress(hntdll, "NtOpenSymbolicLinkObject");
2021 pNtCreateSymbolicLinkObject = (void *)GetProcAddress(hntdll, "NtCreateSymbolicLinkObject");
2022 pNtQuerySymbolicLinkObject = (void *)GetProcAddress(hntdll, "NtQuerySymbolicLinkObject");
2023 pNtCreateSemaphore = (void *)GetProcAddress(hntdll, "NtCreateSemaphore");
2024 pNtOpenSemaphore = (void *)GetProcAddress(hntdll, "NtOpenSemaphore");
2025 pNtCreateTimer = (void *)GetProcAddress(hntdll, "NtCreateTimer");
2026 pNtOpenTimer = (void *)GetProcAddress(hntdll, "NtOpenTimer");
2027 pNtCreateSection = (void *)GetProcAddress(hntdll, "NtCreateSection");
2028 pNtOpenSection = (void *)GetProcAddress(hntdll, "NtOpenSection");
2029 pNtQueryObject = (void *)GetProcAddress(hntdll, "NtQueryObject");
2030 pNtReleaseSemaphore = (void *)GetProcAddress(hntdll, "NtReleaseSemaphore");
2031 pNtCreateKeyedEvent = (void *)GetProcAddress(hntdll, "NtCreateKeyedEvent");
2032 pNtOpenKeyedEvent = (void *)GetProcAddress(hntdll, "NtOpenKeyedEvent");
2033 pNtWaitForKeyedEvent = (void *)GetProcAddress(hntdll, "NtWaitForKeyedEvent");
2034 pNtReleaseKeyedEvent = (void *)GetProcAddress(hntdll, "NtReleaseKeyedEvent");
2035 pNtCreateIoCompletion = (void *)GetProcAddress(hntdll, "NtCreateIoCompletion");
2036 pNtOpenIoCompletion = (void *)GetProcAddress(hntdll, "NtOpenIoCompletion");
2037
2038 test_case_sensitive();
2039 test_namespace_pipe();
2040 test_name_collisions();
2041 test_name_limits();
2042 test_directory();
2043 test_symboliclink();
2044 test_query_object();
2045 test_type_mismatch();
2046 test_event();
2047 test_mutant();
2048 test_keyed_events();
2049 test_null_device();
2050 }
Windows API implementation