[USERENV]: Use ARRAYSIZE instead of hardcoding the sizes of the static buffers.
[reactos.git] / rostests / apitests / advapi32 / LockDatabase.c
1 /*
2 * PROJECT: ReactOS api tests
3 * LICENSE: GPLv2+ - See COPYING in the top level directory
4 * PURPOSE: Tests for Lock/UnlockServiceDatabase and QueryServiceLockStatusA/W
5 * PROGRAMMER: Hermès BÉLUSCA - MAÏTO
6 */
7
8 #include <apitest.h>
9
10 #include <winsvc.h>
11 #include <strsafe.h>
12
13 #define TESTING_SERVICE L"Spooler"
14
15 static void Test_LockUnlockServiceDatabase(void)
16 {
17 BOOL bError = FALSE;
18
19 SC_HANDLE hScm = NULL;
20 SC_LOCK hLock = NULL;
21
22 /* First of all, try to lock / unlock the services database with invalid handles */
23 SetLastError(0xdeadbeef);
24 hScm = NULL;
25 hLock = LockServiceDatabase(hScm);
26 ok(hLock == NULL, "hLock = 0x%p, expected 0\n", hLock);
27 ok_err(ERROR_INVALID_HANDLE);
28
29 SetLastError(0xdeadbeef);
30 hScm = (SC_HANDLE)0xdeadbeef;
31 hLock = LockServiceDatabase(hScm);
32 ok(hLock == NULL, "hLock = 0x%p, expected 0\n", hLock);
33 ok_err(ERROR_INVALID_HANDLE);
34
35 /** This test seems to make this application crash on Windows 7... I do not know why... **/
36 SetLastError(0xdeadbeef);
37 hLock = NULL;
38 bError = UnlockServiceDatabase(hLock);
39 ok(bError == FALSE, "bError = %u, expected FALSE\n", bError);
40 ok_err(ERROR_INVALID_SERVICE_LOCK);
41 /*****************************************************************************************/
42
43 SetLastError(0xdeadbeef);
44 hLock = (SC_LOCK)0xdeadbeef;
45 bError = UnlockServiceDatabase(hLock);
46 ok(bError == FALSE, "bError = %u, expected FALSE\n", bError);
47 ok_err(ERROR_INVALID_SERVICE_LOCK);
48
49
50 /* Then, try to lock the services database without having rights */
51 SetLastError(0xdeadbeef);
52 hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
53 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
54 if (!hScm)
55 {
56 skip("No service control manager; cannot proceed with LockUnlockServiceDatabase test\n");
57 goto cleanup;
58 }
59 ok_err(ERROR_SUCCESS);
60
61 SetLastError(0xdeadbeef);
62 hLock = LockServiceDatabase(hScm);
63 ok(hLock == NULL, "hLock = 0x%p, expected 0\n", hLock);
64 ok_err(ERROR_ACCESS_DENIED);
65
66 if (hLock)
67 UnlockServiceDatabase(hLock);
68 CloseServiceHandle(hScm);
69
70 /* Try to lock the services database with good rights */
71 SetLastError(0xdeadbeef);
72 hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_LOCK);
73 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
74 if (!hScm)
75 {
76 skip("No service control manager; cannot proceed with LockUnlockServiceDatabase test\n");
77 goto cleanup;
78 }
79 ok_err(ERROR_SUCCESS);
80
81 SetLastError(0xdeadbeef);
82 hLock = LockServiceDatabase(hScm);
83 ok(hLock != NULL, "hLock = 0x%p, expected non-zero\n", hLock);
84 ok_err(ERROR_SUCCESS);
85
86 /* Now unlock it */
87 if (hLock)
88 {
89 SetLastError(0xdeadbeef);
90 bError = UnlockServiceDatabase(hLock);
91 ok(bError == TRUE, "bError = %u, expected TRUE\n", bError);
92 ok_err(ERROR_SUCCESS);
93 }
94
95
96 cleanup:
97 if (hScm)
98 CloseServiceHandle(hScm);
99
100 return;
101 }
102
103 static void Test_LockUnlockServiceDatabaseWithServiceStart(void)
104 {
105 BOOL bError = FALSE;
106
107 SC_HANDLE hScm = NULL;
108 SC_HANDLE hSvc = NULL;
109 SC_LOCK hLock = NULL;
110
111 LPQUERY_SERVICE_CONFIGW lpConfig = NULL;
112 DWORD dwRequiredSize = 0;
113 SERVICE_STATUS status;
114 BOOL bWasRunning = FALSE;
115 DWORD dwOldStartType = 0;
116
117 /* Open the services database */
118 SetLastError(0xdeadbeef);
119 hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_LOCK);
120 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
121 if (!hScm)
122 {
123 skip("No service control manager; cannot proceed with LockUnlockServiceDatabaseWithServiceStart test\n");
124 goto cleanup;
125 }
126 ok_err(ERROR_SUCCESS);
127
128 /* Grab a handle to the testing service */
129 SetLastError(0xdeadbeef);
130 hSvc = OpenServiceW(hScm, TESTING_SERVICE, SERVICE_START | SERVICE_STOP | SERVICE_CHANGE_CONFIG | SERVICE_QUERY_CONFIG | SERVICE_QUERY_STATUS);
131 ok(hSvc != NULL, "hSvc = 0x%p, expected non-null, error=0x%08lx\n", hSvc, GetLastError());
132 if (!hSvc)
133 {
134 skip("Cannot open a handle to service %S; cannot proceed with LockUnlockServiceDatabaseWithServiceStart test\n", TESTING_SERVICE);
135 goto cleanup;
136 }
137 ok_err(ERROR_SUCCESS);
138
139 /* Lock the services database */
140 SetLastError(0xdeadbeef);
141 hLock = LockServiceDatabase(hScm);
142 ok(hLock != NULL, "hLock = 0x%p, expected non-zero, error=0x%08lx\n", hLock, GetLastError());
143 if (!hLock)
144 {
145 skip("Cannot lock the services database; cannot proceed with LockUnlockServiceDatabaseWithServiceStart test\n");
146 goto cleanup;
147 }
148 ok_err(ERROR_SUCCESS);
149
150 /* To proceed further, firstly attempt to stop the testing service */
151 QueryServiceConfigW(hSvc, NULL, 0, &dwRequiredSize);
152 lpConfig = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
153 QueryServiceConfigW(hSvc, lpConfig, dwRequiredSize, &dwRequiredSize);
154 dwOldStartType = lpConfig->dwStartType;
155 HeapFree(GetProcessHeap(), 0, lpConfig);
156 if (dwOldStartType == SERVICE_DISABLED)
157 {
158 ChangeServiceConfigW(hSvc,
159 SERVICE_NO_CHANGE,
160 SERVICE_DEMAND_START,
161 SERVICE_NO_CHANGE,
162 NULL,
163 NULL,
164 NULL,
165 NULL,
166 NULL,
167 NULL,
168 NULL);
169 }
170 QueryServiceStatus(hSvc, &status);
171 bWasRunning = (status.dwCurrentState != SERVICE_STOPPED);
172 if (bWasRunning)
173 {
174 ControlService(hSvc, SERVICE_CONTROL_STOP, &status);
175 Sleep(1000); /* Wait 1 second for the service to stop */
176 }
177
178 /* Now try to start it (this test won't work under Windows Vista / 7 / 8) */
179 SetLastError(0xdeadbeef);
180 bError = StartServiceW(hSvc, 0, NULL);
181 ok(bError == FALSE, "bError = %u, expected FALSE\n", bError);
182 ok_err(ERROR_SERVICE_DATABASE_LOCKED);
183 Sleep(1000); /* Wait 1 second for the service to start */
184
185 /* Stop the testing service */
186 ControlService(hSvc, SERVICE_CONTROL_STOP, &status);
187 Sleep(1000); /* Wait 1 second for the service to stop */
188
189 /* Now unlock the services database */
190 SetLastError(0xdeadbeef);
191 bError = UnlockServiceDatabase(hLock);
192 ok(bError == TRUE, "bError = %u, expected TRUE\n", bError);
193 ok_err(ERROR_SUCCESS);
194
195 /* Try to start again the service, this time the database unlocked */
196 SetLastError(0xdeadbeef);
197 bError = StartServiceW(hSvc, 0, NULL);
198 ok(bError == TRUE, "bError = %u, expected TRUE\n", bError);
199 ok_err(ERROR_SUCCESS);
200 Sleep(1000); /* Wait 1 second for the service to start */
201
202 /* Stop the testing service */
203 ControlService(hSvc, SERVICE_CONTROL_STOP, &status);
204 Sleep(1000); /* Wait 1 second for the service to stop */
205
206 /* Restore its original state */
207 if (bWasRunning)
208 {
209 StartServiceW(hSvc, 0, NULL);
210 }
211
212 if (dwOldStartType == SERVICE_DISABLED)
213 {
214 ChangeServiceConfigW(hSvc,
215 SERVICE_NO_CHANGE,
216 SERVICE_DISABLED,
217 SERVICE_NO_CHANGE,
218 NULL,
219 NULL,
220 NULL,
221 NULL,
222 NULL,
223 NULL,
224 NULL);
225 }
226
227
228 cleanup:
229 if (hSvc)
230 CloseServiceHandle(hSvc);
231
232 if (hScm)
233 CloseServiceHandle(hScm);
234
235 return;
236 }
237
238 static void Test_QueryLockStatusW(void)
239 {
240 BOOL bError = FALSE;
241
242 SC_HANDLE hScm = NULL;
243 SC_LOCK hLock = NULL;
244 LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus = NULL;
245 DWORD dwRequiredSize = 0;
246
247 /* Firstly try to get lock status with invalid handles */
248 SetLastError(0xdeadbeef);
249 bError = QueryServiceLockStatusW(hScm,
250 NULL,
251 0,
252 &dwRequiredSize);
253 ok(bError == FALSE && GetLastError() == ERROR_INVALID_HANDLE, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INVALID_HANDLE);
254 ok(dwRequiredSize == 0, "dwRequiredSize is non-zero, expected zero\n");
255
256 /* Open the services database without having rights */
257 SetLastError(0xdeadbeef);
258 hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
259 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
260 if (!hScm)
261 {
262 skip("No service control manager; cannot proceed with QueryLockStatusW test\n");
263 goto cleanup;
264 }
265 ok_err(ERROR_SUCCESS);
266
267 /* Try to get lock status */
268 SetLastError(0xdeadbeef);
269 bError = QueryServiceLockStatusW(hScm,
270 NULL,
271 0,
272 &dwRequiredSize);
273 ok(bError == FALSE && GetLastError() == ERROR_ACCESS_DENIED, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_ACCESS_DENIED);
274 ok(dwRequiredSize == 0, "dwRequiredSize is non-zero, expected zero\n");
275
276 CloseServiceHandle(hScm);
277
278
279 /*
280 * Query only the lock status.
281 */
282
283 SetLastError(0xdeadbeef);
284 hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_QUERY_LOCK_STATUS);
285 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
286 if (!hScm)
287 {
288 skip("No service control manager; cannot proceed with QueryLockStatusW test\n");
289 goto cleanup;
290 }
291 ok_err(ERROR_SUCCESS);
292
293 /* Get the needed size */
294 SetLastError(0xdeadbeef);
295 bError = QueryServiceLockStatusW(hScm,
296 NULL,
297 0,
298 &dwRequiredSize);
299 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
300 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
301 if (dwRequiredSize == 0)
302 {
303 skip("Required size is null; cannot proceed with QueryLockStatusW test\n");
304 goto cleanup;
305 }
306
307 /* Allocate memory */
308 lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
309 if (lpLockStatus == NULL)
310 {
311 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
312 goto cleanup;
313 }
314
315 /* Get the actual value */
316 SetLastError(0xdeadbeef);
317 bError = QueryServiceLockStatusW(hScm,
318 lpLockStatus,
319 dwRequiredSize,
320 &dwRequiredSize);
321 ok(bError, "bError = %u, expected TRUE\n", bError);
322
323 /* These conditions must be verified iff the services database wasn't previously locked */
324 ok(lpLockStatus->fIsLocked == 0, "lpLockStatus->fIsLocked = %lu, expected 0\n", lpLockStatus->fIsLocked);
325 ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
326 ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner == 0, "*lpLockStatus->lpLockOwner != \"\\0\", expected \"\\0\"\n");
327 ok(lpLockStatus->dwLockDuration == 0, "lpLockStatus->dwLockDuration = %lu, expected 0\n", lpLockStatus->dwLockDuration);
328
329 HeapFree(GetProcessHeap(), 0, lpLockStatus);
330
331 CloseServiceHandle(hScm);
332
333
334 /*
335 * Now, try to lock the database and check its lock status.
336 */
337
338 SetLastError(0xdeadbeef);
339 hScm = OpenSCManagerW(NULL, NULL, SC_MANAGER_LOCK | SC_MANAGER_QUERY_LOCK_STATUS);
340 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
341 if (!hScm)
342 {
343 skip("No service control manager; cannot proceed with QueryLockStatusW test\n");
344 goto cleanup;
345 }
346 ok_err(ERROR_SUCCESS);
347
348 /* Get the needed size */
349 SetLastError(0xdeadbeef);
350 bError = QueryServiceLockStatusW(hScm,
351 NULL,
352 0,
353 &dwRequiredSize);
354 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
355 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
356 if (dwRequiredSize == 0)
357 {
358 skip("Required size is null; cannot proceed with QueryLockStatusW test\n");
359 goto cleanup;
360 }
361
362 /* Allocate memory */
363 lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
364 if (lpLockStatus == NULL)
365 {
366 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
367 goto cleanup;
368 }
369
370 /* Get the actual value */
371 SetLastError(0xdeadbeef);
372 bError = QueryServiceLockStatusW(hScm,
373 lpLockStatus,
374 dwRequiredSize,
375 &dwRequiredSize);
376 ok(bError, "bError = %u, expected TRUE\n", bError);
377
378 /* These conditions must be verified iff the services database wasn't previously locked */
379 ok(lpLockStatus->fIsLocked == 0, "lpLockStatus->fIsLocked = %lu, expected 0\n", lpLockStatus->fIsLocked);
380 ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
381 ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner == 0, "*lpLockStatus->lpLockOwner != \"\\0\", expected \"\\0\"\n");
382 ok(lpLockStatus->dwLockDuration == 0, "lpLockStatus->dwLockDuration = %lu, expected 0\n", lpLockStatus->dwLockDuration);
383
384 HeapFree(GetProcessHeap(), 0, lpLockStatus);
385
386
387 /*
388 * Try again, this time with the database locked.
389 */
390
391 SetLastError(0xdeadbeef);
392 hLock = LockServiceDatabase(hScm);
393 ok(hLock != NULL, "hLock = 0x%p, expected non-zero\n", hLock);
394 ok_err(ERROR_SUCCESS);
395
396 Sleep(1000); /* Wait 1 second to let lpLockStatus->dwLockDuration increment */
397
398 /* Get the needed size */
399 SetLastError(0xdeadbeef);
400 bError = QueryServiceLockStatusW(hScm,
401 NULL,
402 0,
403 &dwRequiredSize);
404 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
405 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
406 if (dwRequiredSize == 0)
407 {
408 skip("Required size is null; cannot proceed with QueryLockStatusW test\n");
409 goto cleanup;
410 }
411
412 /* Allocate memory */
413 lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
414 if (lpLockStatus == NULL)
415 {
416 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
417 goto cleanup;
418 }
419
420 /* Get the actual value */
421 SetLastError(0xdeadbeef);
422 bError = QueryServiceLockStatusW(hScm,
423 lpLockStatus,
424 dwRequiredSize,
425 &dwRequiredSize);
426 ok(bError, "bError = %u, expected TRUE\n", bError);
427
428 /* These conditions must be verified iff the services database is locked */
429 ok(lpLockStatus->fIsLocked != 0, "lpLockStatus->fIsLocked = %lu, expected non-zero\n", lpLockStatus->fIsLocked);
430 ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
431 ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner != 0, "*lpLockStatus->lpLockOwner = \"\\0\", expected non-zero\n");
432 ok(lpLockStatus->dwLockDuration != 0, "lpLockStatus->dwLockDuration = %lu, expected non-zero\n", lpLockStatus->dwLockDuration);
433
434 HeapFree(GetProcessHeap(), 0, lpLockStatus);
435
436
437 /*
438 * Last try, with the database again unlocked.
439 */
440
441 SetLastError(0xdeadbeef);
442 bError = UnlockServiceDatabase(hLock);
443 ok(bError == TRUE, "bError = %u, expected TRUE\n", bError);
444 ok_err(ERROR_SUCCESS);
445 hLock = NULL;
446
447 /* Get the needed size */
448 SetLastError(0xdeadbeef);
449 bError = QueryServiceLockStatusW(hScm,
450 NULL,
451 0,
452 &dwRequiredSize);
453 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
454 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
455 if (dwRequiredSize == 0)
456 {
457 skip("Required size is null; cannot proceed with QueryLockStatusW test\n");
458 goto cleanup;
459 }
460
461 /* Allocate memory */
462 lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
463 if (lpLockStatus == NULL)
464 {
465 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
466 goto cleanup;
467 }
468
469 /* Get the actual value */
470 SetLastError(0xdeadbeef);
471 bError = QueryServiceLockStatusW(hScm,
472 lpLockStatus,
473 dwRequiredSize,
474 &dwRequiredSize);
475 ok(bError, "bError = %u, expected TRUE\n", bError);
476
477 /* These conditions must be verified iff the services database is unlocked */
478 ok(lpLockStatus->fIsLocked == 0, "lpLockStatus->fIsLocked = %lu, expected 0\n", lpLockStatus->fIsLocked);
479 ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
480 ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner == 0, "*lpLockStatus->lpLockOwner != \"\\0\", expected \"\\0\"\n");
481 ok(lpLockStatus->dwLockDuration == 0, "lpLockStatus->dwLockDuration = %lu, expected 0\n", lpLockStatus->dwLockDuration);
482
483 HeapFree(GetProcessHeap(), 0, lpLockStatus);
484
485
486 cleanup:
487 if (hLock)
488 UnlockServiceDatabase(hLock);
489
490 if (hScm)
491 CloseServiceHandle(hScm);
492
493 return;
494 }
495
496 static void Test_QueryLockStatusA(void)
497 {
498 BOOL bError = FALSE;
499
500 SC_HANDLE hScm = NULL;
501 SC_LOCK hLock = NULL;
502 LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus = NULL;
503 DWORD dwRequiredSize = 0;
504
505 /* Firstly try to get lock status with invalid handles */
506 SetLastError(0xdeadbeef);
507 bError = QueryServiceLockStatusA(hScm,
508 NULL,
509 0,
510 &dwRequiredSize);
511 ok(bError == FALSE && GetLastError() == ERROR_INVALID_HANDLE, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INVALID_HANDLE);
512 ok(dwRequiredSize == 0, "dwRequiredSize is non-zero, expected zero\n");
513
514 /* Open the services database without having rights */
515 SetLastError(0xdeadbeef);
516 hScm = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
517 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
518 if (!hScm)
519 {
520 skip("No service control manager; cannot proceed with QueryLockStatusA test\n");
521 goto cleanup;
522 }
523 ok_err(ERROR_SUCCESS);
524
525 /* Try to get lock status */
526 SetLastError(0xdeadbeef);
527 bError = QueryServiceLockStatusA(hScm,
528 NULL,
529 0,
530 &dwRequiredSize);
531 ok(bError == FALSE && GetLastError() == ERROR_ACCESS_DENIED, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_ACCESS_DENIED);
532 ok(dwRequiredSize == 0, "dwRequiredSize is non-zero, expected zero\n");
533
534 CloseServiceHandle(hScm);
535
536
537 /*
538 * Query only the lock status.
539 */
540
541 SetLastError(0xdeadbeef);
542 hScm = OpenSCManagerA(NULL, NULL, SC_MANAGER_QUERY_LOCK_STATUS);
543 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
544 if (!hScm)
545 {
546 skip("No service control manager; cannot proceed with QueryLockStatusA test\n");
547 goto cleanup;
548 }
549 ok_err(ERROR_SUCCESS);
550
551 /* Get the needed size */
552 SetLastError(0xdeadbeef);
553 bError = QueryServiceLockStatusA(hScm,
554 NULL,
555 0,
556 &dwRequiredSize);
557 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
558 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
559 if (dwRequiredSize == 0)
560 {
561 skip("Required size is null; cannot proceed with QueryLockStatusA test\n");
562 goto cleanup;
563 }
564
565 /* Allocate memory */
566 lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
567 if (lpLockStatus == NULL)
568 {
569 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
570 goto cleanup;
571 }
572
573 /* Get the actual value */
574 SetLastError(0xdeadbeef);
575 bError = QueryServiceLockStatusA(hScm,
576 lpLockStatus,
577 dwRequiredSize,
578 &dwRequiredSize);
579 ok(bError, "bError = %u, expected TRUE\n", bError);
580
581 /* These conditions must be verified iff the services database wasn't previously locked */
582 ok(lpLockStatus->fIsLocked == 0, "lpLockStatus->fIsLocked = %lu, expected 0\n", lpLockStatus->fIsLocked);
583 ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
584 ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner == 0, "*lpLockStatus->lpLockOwner != \"\\0\", expected \"\\0\"\n");
585 ok(lpLockStatus->dwLockDuration == 0, "lpLockStatus->dwLockDuration = %lu, expected 0\n", lpLockStatus->dwLockDuration);
586
587 HeapFree(GetProcessHeap(), 0, lpLockStatus);
588
589 CloseServiceHandle(hScm);
590
591
592 /*
593 * Now, try to lock the database and check its lock status.
594 */
595
596 SetLastError(0xdeadbeef);
597 hScm = OpenSCManagerA(NULL, NULL, SC_MANAGER_LOCK | SC_MANAGER_QUERY_LOCK_STATUS);
598 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
599 if (!hScm)
600 {
601 skip("No service control manager; cannot proceed with QueryLockStatusA test\n");
602 goto cleanup;
603 }
604 ok_err(ERROR_SUCCESS);
605
606 /* Get the needed size */
607 SetLastError(0xdeadbeef);
608 bError = QueryServiceLockStatusA(hScm,
609 NULL,
610 0,
611 &dwRequiredSize);
612 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
613 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
614 if (dwRequiredSize == 0)
615 {
616 skip("Required size is null; cannot proceed with QueryLockStatusA test\n");
617 goto cleanup;
618 }
619
620 /* Allocate memory */
621 lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
622 if (lpLockStatus == NULL)
623 {
624 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
625 goto cleanup;
626 }
627
628 /* Get the actual value */
629 SetLastError(0xdeadbeef);
630 bError = QueryServiceLockStatusA(hScm,
631 lpLockStatus,
632 dwRequiredSize,
633 &dwRequiredSize);
634 ok(bError, "bError = %u, expected TRUE\n", bError);
635
636 /* These conditions must be verified iff the services database wasn't previously locked */
637 ok(lpLockStatus->fIsLocked == 0, "lpLockStatus->fIsLocked = %lu, expected 0\n", lpLockStatus->fIsLocked);
638 ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
639 ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner == 0, "*lpLockStatus->lpLockOwner != \"\\0\", expected \"\\0\"\n");
640 ok(lpLockStatus->dwLockDuration == 0, "lpLockStatus->dwLockDuration = %lu, expected 0\n", lpLockStatus->dwLockDuration);
641
642 HeapFree(GetProcessHeap(), 0, lpLockStatus);
643
644
645 /*
646 * Try again, this time with the database locked.
647 */
648
649 SetLastError(0xdeadbeef);
650 hLock = LockServiceDatabase(hScm);
651 ok(hLock != NULL, "hLock = 0x%p, expected non-zero\n", hLock);
652 ok_err(ERROR_SUCCESS);
653
654 Sleep(1000); /* Wait 1 second to let lpLockStatus->dwLockDuration increment */
655
656 /* Get the needed size */
657 SetLastError(0xdeadbeef);
658 bError = QueryServiceLockStatusA(hScm,
659 NULL,
660 0,
661 &dwRequiredSize);
662 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
663 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
664 if (dwRequiredSize == 0)
665 {
666 skip("Required size is null; cannot proceed with QueryLockStatusA test\n");
667 goto cleanup;
668 }
669
670 /* Allocate memory */
671 lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
672 if (lpLockStatus == NULL)
673 {
674 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
675 goto cleanup;
676 }
677
678 /* Get the actual value */
679 SetLastError(0xdeadbeef);
680 bError = QueryServiceLockStatusA(hScm,
681 lpLockStatus,
682 dwRequiredSize,
683 &dwRequiredSize);
684 ok(bError, "bError = %u, expected TRUE\n", bError);
685
686 /* These conditions must be verified iff the services database is locked */
687 ok(lpLockStatus->fIsLocked != 0, "lpLockStatus->fIsLocked = %lu, expected non-zero\n", lpLockStatus->fIsLocked);
688 ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
689 ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner != 0, "*lpLockStatus->lpLockOwner = \"\\0\", expected non-zero\n");
690 ok(lpLockStatus->dwLockDuration != 0, "lpLockStatus->dwLockDuration = %lu, expected non-zero\n", lpLockStatus->dwLockDuration);
691
692 HeapFree(GetProcessHeap(), 0, lpLockStatus);
693
694
695 /*
696 * Last try, with the database again unlocked.
697 */
698
699 SetLastError(0xdeadbeef);
700 bError = UnlockServiceDatabase(hLock);
701 ok(bError == TRUE, "bError = %u, expected TRUE\n", bError);
702 ok_err(ERROR_SUCCESS);
703 hLock = NULL;
704
705 /* Get the needed size */
706 SetLastError(0xdeadbeef);
707 bError = QueryServiceLockStatusA(hScm,
708 NULL,
709 0,
710 &dwRequiredSize);
711 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
712 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
713 if (dwRequiredSize == 0)
714 {
715 skip("Required size is null; cannot proceed with QueryLockStatusA test\n");
716 goto cleanup;
717 }
718
719 /* Allocate memory */
720 lpLockStatus = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
721 if (lpLockStatus == NULL)
722 {
723 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
724 goto cleanup;
725 }
726
727 /* Get the actual value */
728 SetLastError(0xdeadbeef);
729 bError = QueryServiceLockStatusA(hScm,
730 lpLockStatus,
731 dwRequiredSize,
732 &dwRequiredSize);
733 ok(bError, "bError = %u, expected TRUE\n", bError);
734
735 /* These conditions must be verified iff the services database is unlocked */
736 ok(lpLockStatus->fIsLocked == 0, "lpLockStatus->fIsLocked = %lu, expected 0\n", lpLockStatus->fIsLocked);
737 ok(lpLockStatus->lpLockOwner != NULL, "lpLockStatus->lpLockOwner is null, expected non-null\n");
738 ok(lpLockStatus->lpLockOwner && *lpLockStatus->lpLockOwner == 0, "*lpLockStatus->lpLockOwner != \"\\0\", expected \"\\0\"\n");
739 ok(lpLockStatus->dwLockDuration == 0, "lpLockStatus->dwLockDuration = %lu, expected 0\n", lpLockStatus->dwLockDuration);
740
741 HeapFree(GetProcessHeap(), 0, lpLockStatus);
742
743
744 cleanup:
745 if (hLock)
746 UnlockServiceDatabase(hLock);
747
748 if (hScm)
749 CloseServiceHandle(hScm);
750
751 return;
752 }
753
754
755 START_TEST(LockDatabase)
756 {
757 Test_LockUnlockServiceDatabase();
758 Test_LockUnlockServiceDatabaseWithServiceStart();
759 Test_QueryLockStatusW();
760 Test_QueryLockStatusA();
761 }