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(LockServiceDatabase) 756 { 757 Test_LockUnlockServiceDatabase(); 758 Test_LockUnlockServiceDatabaseWithServiceStart(); 759 Test_QueryLockStatusW(); 760 Test_QueryLockStatusA(); 761 } 762