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