rostests/winetests/advapi32/service.c

   1 /*
   2  * Unit tests for service functions
   3  *
   4  * Copyright (c) 2007 Paul Vriens
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define WIN32_NO_STATUS
  22 #define WIN32_LEAN_AND_MEAN
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winerror.h"
  30 #include "winreg.h"
  31 #include "winsvc.h"
  32 #include "winnls.h"
  33 #include "lmcons.h"
  34 #include "aclapi.h"
  35
  36 #include "wine/test.h"
  37
  38 static const CHAR spooler[] = "Spooler"; /* Should be available on all platforms */
  39 static CHAR selfname[MAX_PATH];
  40
  41 static BOOL (WINAPI *pChangeServiceConfig2A)(SC_HANDLE,DWORD,LPVOID);
  42 static BOOL (WINAPI *pEnumServicesStatusExA)(SC_HANDLE, SC_ENUM_TYPE, DWORD,
  43                                              DWORD, LPBYTE, DWORD, LPDWORD,
  44                                              LPDWORD, LPDWORD, LPCSTR);
  45 static BOOL (WINAPI *pEnumServicesStatusExW)(SC_HANDLE, SC_ENUM_TYPE, DWORD,
  46                                              DWORD, LPBYTE, DWORD, LPDWORD,
  47                                              LPDWORD, LPDWORD, LPCWSTR);
  48 static DWORD (WINAPI *pGetSecurityInfo)(HANDLE, SE_OBJECT_TYPE, SECURITY_INFORMATION,
  49                                         PSID*, PSID*, PACL*, PACL*, PSECURITY_DESCRIPTOR*);
  50 static BOOL (WINAPI *pQueryServiceConfig2A)(SC_HANDLE,DWORD,LPBYTE,DWORD,LPDWORD);
  51 static BOOL (WINAPI *pQueryServiceConfig2W)(SC_HANDLE,DWORD,LPBYTE,DWORD,LPDWORD);
  52 static BOOL (WINAPI *pQueryServiceStatusEx)(SC_HANDLE, SC_STATUS_TYPE, LPBYTE,
  53                                             DWORD, LPDWORD);
  54 static BOOL (WINAPI *pQueryServiceObjectSecurity)(SC_HANDLE, SECURITY_INFORMATION,
  55                                                   PSECURITY_DESCRIPTOR, DWORD, LPDWORD);
  56 static DWORD (WINAPI *pNotifyServiceStatusChangeW)(SC_HANDLE,DWORD,SERVICE_NOTIFYW*);
  57
  58 static void init_function_pointers(void)
  59 {
  60     HMODULE hadvapi32 = GetModuleHandleA("advapi32.dll");
  61
  62     pChangeServiceConfig2A = (void*)GetProcAddress(hadvapi32, "ChangeServiceConfig2A");
  63     pEnumServicesStatusExA= (void*)GetProcAddress(hadvapi32, "EnumServicesStatusExA");
  64     pEnumServicesStatusExW= (void*)GetProcAddress(hadvapi32, "EnumServicesStatusExW");
  65     pGetSecurityInfo = (void *)GetProcAddress(hadvapi32, "GetSecurityInfo");
  66     pQueryServiceConfig2A= (void*)GetProcAddress(hadvapi32, "QueryServiceConfig2A");
  67     pQueryServiceConfig2W= (void*)GetProcAddress(hadvapi32, "QueryServiceConfig2W");
  68     pQueryServiceStatusEx= (void*)GetProcAddress(hadvapi32, "QueryServiceStatusEx");
  69     pQueryServiceObjectSecurity = (void*)GetProcAddress(hadvapi32, "QueryServiceObjectSecurity");
  70     pNotifyServiceStatusChangeW = (void*)GetProcAddress(hadvapi32, "NotifyServiceStatusChangeW");
  71 }
  72
  73 static void test_open_scm(void)
  74 {
  75     SC_HANDLE scm_handle;
  76
  77     /* No access rights */
  78     SetLastError(0xdeadbeef);
  79     scm_handle = OpenSCManagerA(NULL, NULL, 0);
  80     ok(scm_handle != NULL, "Expected success, got error %u\n", GetLastError());
  81     CloseServiceHandle(scm_handle);
  82
  83     /* Unknown database name */
  84     SetLastError(0xdeadbeef);
  85     scm_handle = OpenSCManagerA(NULL, "DoesNotExist", SC_MANAGER_CONNECT);
  86     ok(!scm_handle, "Expected failure\n");
  87     ok(GetLastError() == ERROR_INVALID_NAME, "Expected ERROR_INVALID_NAME, got %d\n", GetLastError());
  88     CloseServiceHandle(scm_handle); /* Just in case */
  89
  90     /* MSDN says only ServiceActive is allowed, or NULL */
  91     SetLastError(0xdeadbeef);
  92     scm_handle = OpenSCManagerA(NULL, SERVICES_FAILED_DATABASEA, SC_MANAGER_CONNECT);
  93     ok(!scm_handle, "Expected failure\n");
  94     ok(GetLastError() == ERROR_DATABASE_DOES_NOT_EXIST, "Expected ERROR_DATABASE_DOES_NOT_EXIST, got %d\n", GetLastError());
  95     CloseServiceHandle(scm_handle); /* Just in case */
  96
  97     /* Remote unknown host */
  98     SetLastError(0xdeadbeef);
  99     scm_handle = OpenSCManagerA("DOESNOTEXIST", SERVICES_ACTIVE_DATABASEA, SC_MANAGER_CONNECT);
 100     todo_wine
 101     {
 102     ok(!scm_handle, "Expected failure\n");
 103     ok(GetLastError() == RPC_S_SERVER_UNAVAILABLE || GetLastError() == RPC_S_INVALID_NET_ADDR /* w2k8 */,
 104        "Expected RPC_S_SERVER_UNAVAILABLE or RPC_S_INVALID_NET_ADDR, got %d\n", GetLastError());
 105     }
 106     CloseServiceHandle(scm_handle); /* Just in case */
 107
 108     /* Proper call with an empty hostname */
 109     scm_handle = OpenSCManagerA("", SERVICES_ACTIVE_DATABASEA, SC_MANAGER_CONNECT);
 110     ok(scm_handle != NULL, "Expected success, got error %u\n", GetLastError());
 111     CloseServiceHandle(scm_handle);
 112
 113     /* Again a correct one */
 114     SetLastError(0xdeadbeef);
 115     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
 116     ok(GetLastError() == ERROR_SUCCESS || broken(GetLastError() == ERROR_IO_PENDING) /* win2k */,
 117        "Expected ERROR_SUCCESS, got %u\n", GetLastError());
 118     ok(scm_handle != NULL, "Expected success, got error %u\n", GetLastError());
 119     CloseServiceHandle(scm_handle);
 120 }
 121
 122 static void test_open_svc(void)
 123 {
 124     SC_HANDLE scm_handle, svc_handle;
 125     CHAR displayname[4096];
 126     DWORD displaysize;
 127
 128     /* All NULL (invalid access rights) */
 129     SetLastError(0xdeadbeef);
 130     svc_handle = OpenServiceA(NULL, NULL, 0);
 131     ok(!svc_handle, "Expected failure\n");
 132     ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 133
 134     /* TODO: Add some tests with invalid handles. These produce errors on Windows but crash on Wine */
 135
 136     /* NULL service */
 137     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
 138     SetLastError(0xdeadbeef);
 139     svc_handle = OpenServiceA(scm_handle, NULL, GENERIC_READ);
 140     ok(!svc_handle, "Expected failure\n");
 141     ok(GetLastError() == ERROR_INVALID_ADDRESS   /* W2K, XP, W2K3, Vista */ ||
 142        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 143        "Expected ERROR_INVALID_ADDRESS or ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 144     CloseServiceHandle(scm_handle);
 145
 146     /* Nonexistent service */
 147     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
 148     SetLastError(0xdeadbeef);
 149     svc_handle = OpenServiceA(scm_handle, "deadbeef", GENERIC_READ);
 150     ok(!svc_handle, "Expected failure\n");
 151     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST, "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 152     CloseServiceHandle(scm_handle);
 153
 154     /* Proper SCM handle but different access rights */
 155     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
 156     SetLastError(0xdeadbeef);
 157     svc_handle = OpenServiceA(scm_handle, spooler, GENERIC_WRITE);
 158     if (!svc_handle && (GetLastError() == ERROR_ACCESS_DENIED))
 159         skip("Not enough rights to get a handle to the service\n");
 160     else
 161     {
 162         ok(svc_handle != NULL, "Expected success, got error %u\n", GetLastError());
 163         CloseServiceHandle(svc_handle);
 164     }
 165
 166     /* Test to show we can't open a service with the displayname */
 167
 168     /* Retrieve the needed size for the buffer */
 169     displaysize = 0;
 170     GetServiceDisplayNameA(scm_handle, spooler, NULL, &displaysize);
 171     /* Get the displayname */
 172     GetServiceDisplayNameA(scm_handle, spooler, displayname, &displaysize);
 173     /* Try to open the service with this displayname, unless the displayname equals
 174      * the servicename as that would defeat the purpose of this test.
 175      */
 176     if (!lstrcmpiA(spooler, displayname))
 177     {
 178         skip("displayname equals servicename\n");
 179         CloseServiceHandle(scm_handle);
 180         return;
 181     }
 182
 183     SetLastError(0xdeadbeef);
 184     svc_handle = OpenServiceA(scm_handle, displayname, GENERIC_READ);
 185     ok(!svc_handle, "Expected failure\n");
 186     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST, "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 187     /* Just in case */
 188     CloseServiceHandle(svc_handle);
 189
 190     CloseServiceHandle(scm_handle);
 191 }
 192
 193 static void test_create_delete_svc(void)
 194 {
 195     SC_HANDLE scm_handle, svc_handle1, svc_handle2;
 196     CHAR username[UNLEN + 1], domain[MAX_PATH];
 197     DWORD user_size = UNLEN + 1;
 198     CHAR account[UNLEN + 3];
 199     static const CHAR servicename         [] = "Winetest";
 200     static const CHAR pathname            [] = "we_dont_care.exe";
 201     static const CHAR empty               [] = "";
 202     static const CHAR password            [] = "secret";
 203     BOOL spooler_exists = FALSE;
 204     BOOL ret;
 205     CHAR display[4096];
 206     DWORD display_size = sizeof(display);
 207
 208     /* Get the username and turn it into an account to be used in some tests */
 209     GetUserNameA(username, &user_size);
 210     /* Get the domainname to cater for that situation */
 211     if (GetEnvironmentVariableA("USERDOMAIN", domain, MAX_PATH))
 212         sprintf(account, "%s\\%s", domain, username);
 213     else
 214         sprintf(account, ".\\%s", username);
 215
 216     /* All NULL */
 217     SetLastError(0xdeadbeef);
 218     svc_handle1 = CreateServiceA(NULL, NULL, NULL, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL);
 219     ok(!svc_handle1, "Expected failure\n");
 220     ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 221
 222     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
 223
 224     /* Only a valid handle to the Service Control Manager */
 225     SetLastError(0xdeadbeef);
 226     svc_handle1 = CreateServiceA(scm_handle, NULL, NULL, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL);
 227     ok(!svc_handle1, "Expected failure\n");
 228     ok(GetLastError() == ERROR_INVALID_ADDRESS   /* W2K, W2K3, XP, Vista */ ||
 229        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 230        "Expected ERROR_INVALID_ADDRESS or ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 231
 232     /* Now with a servicename */
 233     SetLastError(0xdeadbeef);
 234     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, NULL);
 235     ok(!svc_handle1, "Expected failure\n");
 236     ok(GetLastError() == ERROR_INVALID_ADDRESS   /* W2K, W2K3, XP, Vista */ ||
 237        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 238        "Expected ERROR_INVALID_ADDRESS or ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 239
 240     /* Or just a binary name */
 241     SetLastError(0xdeadbeef);
 242     svc_handle1 = CreateServiceA(scm_handle, NULL, NULL, 0, 0, 0, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 243     ok(!svc_handle1, "Expected failure\n");
 244     ok(GetLastError() == ERROR_INVALID_ADDRESS   /* W2K, W2K3, XP, Vista */ ||
 245        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 246        "Expected ERROR_INVALID_ADDRESS or ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 247
 248     /* Both servicename and binary name (We only have connect rights) */
 249     SetLastError(0xdeadbeef);
 250     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, 0, 0, 0, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 251     ok(!svc_handle1, "Expected failure\n");
 252     ok(GetLastError() == ERROR_ACCESS_DENIED, "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
 253
 254     /* They can even be empty at this stage of parameter checking */
 255     SetLastError(0xdeadbeef);
 256     svc_handle1 = CreateServiceA(scm_handle, empty, NULL, 0, 0, 0, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 257     ok(!svc_handle1, "Expected failure\n");
 258     ok(GetLastError() == ERROR_ACCESS_DENIED, "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
 259
 260     SetLastError(0xdeadbeef);
 261     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, 0, 0, 0, 0, empty, NULL, NULL, NULL, NULL, NULL);
 262     ok(!svc_handle1, "Expected failure\n");
 263     ok(GetLastError() == ERROR_ACCESS_DENIED, "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
 264
 265     /* Open the Service Control Manager with minimal rights for creation
 266      * (Verified with 'SC_MANAGER_ALL_ACCESS &~ SC_MANAGER_CREATE_SERVICE')
 267      */
 268     CloseServiceHandle(scm_handle);
 269     SetLastError(0xdeadbeef);
 270     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
 271     if (!scm_handle && (GetLastError() == ERROR_ACCESS_DENIED))
 272     {
 273         skip("Not enough rights to get a handle to the manager\n");
 274         return;
 275     }
 276
 277     /* TODO: It looks like account (ServiceStartName) and (maybe) password are checked at this place */
 278
 279     /* Empty strings for servicename and binary name are checked */
 280     SetLastError(0xdeadbeef);
 281     svc_handle1 = CreateServiceA(scm_handle, empty, NULL, 0, 0, 0, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 282     ok(!svc_handle1, "Expected failure\n");
 283     ok(GetLastError() == ERROR_INVALID_NAME, "Expected ERROR_INVALID_NAME, got %d\n", GetLastError());
 284
 285     SetLastError(0xdeadbeef);
 286     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, 0, 0, 0, 0, empty, NULL, NULL, NULL, NULL, NULL);
 287     ok(!svc_handle1, "Expected failure\n");
 288     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 289
 290     SetLastError(0xdeadbeef);
 291     svc_handle1 = CreateServiceA(scm_handle, empty, NULL, 0, 0, 0, 0, empty, NULL, NULL, NULL, NULL, NULL);
 292     ok(!svc_handle1, "Expected failure\n");
 293     ok(GetLastError() == ERROR_INVALID_NAME, "Expected ERROR_INVALID_NAME, got %d\n", GetLastError());
 294
 295     /* Valid call (as we will see later) except for the empty binary name (to proof it's indeed
 296      * an ERROR_INVALID_PARAMETER)
 297      */
 298     SetLastError(0xdeadbeef);
 299     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, 0, SERVICE_WIN32_OWN_PROCESS,
 300                                  SERVICE_DISABLED, 0, empty, NULL, NULL, NULL, NULL, NULL);
 301     ok(!svc_handle1, "Expected failure\n");
 302     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 303
 304     /* Windows checks if the 'service type', 'access type' and the combination of them are valid, so let's test that */
 305
 306     /* Illegal (service-type, which is used as a mask can't have a mix. Except the one with
 307      * SERVICE_INTERACTIVE_PROCESS which will be tested below in a valid call)
 308      */
 309     SetLastError(0xdeadbeef);
 310     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, GENERIC_ALL, SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS,
 311                                  SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 312     ok(!svc_handle1, "Expected failure\n");
 313     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 314
 315     /* Illegal (SERVICE_INTERACTIVE_PROCESS is only allowed with SERVICE_WIN32_OWN_PROCESS or SERVICE_WIN32_SHARE_PROCESS) */
 316     SetLastError(0xdeadbeef);
 317     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, GENERIC_ALL, SERVICE_FILE_SYSTEM_DRIVER | SERVICE_INTERACTIVE_PROCESS,
 318                                  SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 319     ok(!svc_handle1, "Expected failure\n");
 320     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 321
 322     /* Illegal (this combination is only allowed when the LocalSystem account (ServiceStartName) is used)
 323      * Not having a correct account would have resulted in an ERROR_INVALID_SERVICE_ACCOUNT.
 324      */
 325     SetLastError(0xdeadbeef);
 326     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, GENERIC_ALL, SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
 327                                  SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, account, password);
 328     ok(!svc_handle1, "Expected failure\n");
 329     ok(GetLastError() == ERROR_INVALID_PARAMETER || GetLastError() == ERROR_INVALID_SERVICE_ACCOUNT,
 330        "Expected ERROR_INVALID_PARAMETER or ERROR_INVALID_SERVICE_ACCOUNT, got %d\n", GetLastError());
 331
 332     /* Illegal (start-type is not a mask and should only be one of the possibilities)
 333      * Remark : 'OR'-ing them could result in a valid possibility (but doesn't make sense as
 334      * it's most likely not the wanted start-type)
 335      */
 336     SetLastError(0xdeadbeef);
 337     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, GENERIC_ALL, SERVICE_WIN32_OWN_PROCESS,
 338                                  SERVICE_AUTO_START | SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 339     ok(!svc_handle1, "Expected failure\n");
 340     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 341
 342     /* Illegal (SERVICE_BOOT_START and SERVICE_SYSTEM_START are only allowed for driver services) */
 343     SetLastError(0xdeadbeef);
 344     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, 0, SERVICE_WIN32_OWN_PROCESS,
 345                                  SERVICE_BOOT_START, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 346     ok(!svc_handle1, "Expected failure\n");
 347     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 348
 349     /* Test if ServiceType can be a combined one for drivers */
 350     SetLastError(0xdeadbeef);
 351     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, 0, SERVICE_KERNEL_DRIVER | SERVICE_FILE_SYSTEM_DRIVER,
 352                                  SERVICE_BOOT_START, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 353     ok(!svc_handle1, "Expected failure\n");
 354     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 355
 356     /* The service already exists (check first, just in case) */
 357     svc_handle1 = OpenServiceA(scm_handle, spooler, GENERIC_READ);
 358     if (svc_handle1)
 359     {
 360         spooler_exists = TRUE;
 361         CloseServiceHandle(svc_handle1);
 362         SetLastError(0xdeadbeef);
 363         svc_handle1 = CreateServiceA(scm_handle, spooler, NULL, 0, SERVICE_WIN32_OWN_PROCESS,
 364                                      SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 365         ok(!svc_handle1, "Expected failure\n");
 366         ok(GetLastError() == ERROR_SERVICE_EXISTS, "Expected ERROR_SERVICE_EXISTS, got %d\n", GetLastError());
 367     }
 368     else
 369         skip("Spooler service doesn't exist\n");
 370
 371     /* To find an existing displayname we check the 'Spooler' service. Although the registry
 372      * doesn't show DisplayName on NT4, this call will return a displayname which is equal
 373      * to the servicename and can't be used as well for a new displayname.
 374      */
 375     if (spooler_exists)
 376     {
 377         ret = GetServiceDisplayNameA(scm_handle, spooler, display, &display_size);
 378
 379         if (!ret)
 380             skip("Could not retrieve a displayname for the Spooler service\n");
 381         else
 382         {
 383             svc_handle1 = CreateServiceA(scm_handle, servicename, display, 0, SERVICE_WIN32_OWN_PROCESS,
 384                                          SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 385             ok(!svc_handle1, "Expected failure\n");
 386             ok(GetLastError() == ERROR_DUPLICATE_SERVICE_NAME,
 387                "Expected ERROR_DUPLICATE_SERVICE_NAME, got %d\n", GetLastError());
 388         }
 389     }
 390     else
 391         skip("Could not retrieve a displayname (Spooler service doesn't exist)\n");
 392
 393     /* Windows doesn't care about the access rights for creation (which makes
 394      * sense as there is no service yet) as long as there are sufficient
 395      * rights to the manager.
 396      */
 397     SetLastError(0xdeadbeef);
 398     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, 0, SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
 399                                  SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 400     ok(svc_handle1 != NULL, "Could not create the service : %d\n", GetLastError());
 401
 402     /* DeleteService however must have proper rights */
 403     SetLastError(0xdeadbeef);
 404     ret = DeleteService(svc_handle1);
 405     ok(!ret, "Expected failure\n");
 406     ok(GetLastError() == ERROR_ACCESS_DENIED,
 407        "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
 408
 409     /* Open the service with minimal rights for deletion.
 410      * (Verified with 'SERVICE_ALL_ACCESS &~ DELETE')
 411      */
 412     CloseServiceHandle(svc_handle1);
 413     svc_handle1 = OpenServiceA(scm_handle, servicename, DELETE);
 414
 415     /* Now that we have the proper rights, we should be able to delete */
 416     SetLastError(0xdeadbeef);
 417     ret = DeleteService(svc_handle1);
 418     ok(ret, "Expected success, got error %u\n", GetLastError());
 419
 420     /* Service is marked for delete, but handle is still open. Try to open service again. */
 421     svc_handle2 = OpenServiceA(scm_handle, servicename, GENERIC_READ);
 422     ok(svc_handle2 != NULL, "got %p, error %u\n", svc_handle2, GetLastError());
 423     CloseServiceHandle(svc_handle2);
 424
 425     CloseServiceHandle(svc_handle1);
 426     CloseServiceHandle(scm_handle);
 427
 428     /* Wait a while. One of the following tests also does a CreateService for the
 429      * same servicename and this would result in an ERROR_SERVICE_MARKED_FOR_DELETE
 430      * error if we do this too quickly. Vista seems more picky than the others.
 431      */
 432     Sleep(1000);
 433
 434     /* And a final NULL check */
 435     SetLastError(0xdeadbeef);
 436     ret = DeleteService(NULL);
 437     ok(!ret, "Expected failure\n");
 438     ok(GetLastError() == ERROR_INVALID_HANDLE,
 439         "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 440 }
 441
 442 static void test_get_displayname(void)
 443 {
 444     SC_HANDLE scm_handle, svc_handle;
 445     BOOL ret;
 446     CHAR displayname[4096];
 447     WCHAR displaynameW[2048];
 448     DWORD displaysize, tempsize, tempsizeW;
 449     static const CHAR deadbeef[] = "Deadbeef";
 450     static const WCHAR spoolerW[] = {'S','p','o','o','l','e','r',0};
 451     static const WCHAR deadbeefW[] = {'D','e','a','d','b','e','e','f',0};
 452     static const WCHAR abcW[] = {'A','B','C',0};
 453     static const CHAR servicename[] = "Winetest";
 454     static const CHAR pathname[] = "we_dont_care.exe";
 455
 456     /* Having NULL for the size of the buffer will crash on W2K3 */
 457
 458     SetLastError(0xdeadbeef);
 459     ret = GetServiceDisplayNameA(NULL, NULL, NULL, &displaysize);
 460     ok(!ret, "Expected failure\n");
 461     ok(GetLastError() == ERROR_INVALID_HANDLE,
 462        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 463
 464     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
 465
 466     SetLastError(0xdeadbeef);
 467     ret = GetServiceDisplayNameA(scm_handle, NULL, NULL, &displaysize);
 468     ok(!ret, "Expected failure\n");
 469     ok(GetLastError() == ERROR_INVALID_ADDRESS   /* W2K, XP, W2K3, Vista */ ||
 470        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 471        "Expected ERROR_INVALID_ADDRESS or ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 472
 473     SetLastError(0xdeadbeef);
 474     displaysize = sizeof(displayname);
 475     ret = GetServiceDisplayNameA(scm_handle, NULL, displayname, &displaysize);
 476     ok(!ret, "Expected failure\n");
 477     ok(GetLastError() == ERROR_INVALID_ADDRESS   /* W2K, XP, W2K3, Vista */ ||
 478        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 479        "Expected ERROR_INVALID_ADDRESS or ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 480
 481     /* Test for nonexistent service */
 482     SetLastError(0xdeadbeef);
 483     displaysize = -1;
 484     ret = GetServiceDisplayNameA(scm_handle, deadbeef, NULL, &displaysize);
 485     ok(!ret, "Expected failure\n");
 486     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 487        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 488
 489     SetLastError(0xdeadbeef);
 490     ret = GetServiceDisplayNameA(scm_handle, deadbeef, NULL, &displaysize);
 491     ok(!ret, "Expected failure\n");
 492     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 493        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 494     todo_wine ok(displaysize == 1, "Service size expected 1, got %d\n", displaysize);
 495
 496     displaysize = 15;
 497     strcpy(displayname, "ABC");
 498     ret = GetServiceDisplayNameA(scm_handle, deadbeef, displayname, &displaysize);
 499     ok(!ret, "Expected failure\n");
 500     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 501        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 502     todo_wine ok(displaysize == 15, "Service size expected 15, got %d\n", displaysize);
 503     ok(displayname[0] == 0, "Service name not empty\n");
 504
 505     displaysize = 15;
 506     lstrcpyW( displaynameW, abcW );
 507     ret = GetServiceDisplayNameW(scm_handle, deadbeefW, displaynameW, &displaysize);
 508     ok(!ret, "Expected failure\n");
 509     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 510        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 511     ok(displaysize == 15, "Service size expected 15, got %d\n", displaysize);
 512     ok(displaynameW[0] == 0, "Service name not empty\n");
 513
 514     displaysize = 0;
 515     strcpy(displayname, "ABC");
 516     ret = GetServiceDisplayNameA(scm_handle, deadbeef, displayname, &displaysize);
 517     ok(!ret, "Expected failure\n");
 518     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 519        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 520     todo_wine ok(displaysize == 1, "Service size expected 1, got %d\n", displaysize);
 521     ok(displayname[0] == 'A', "Service name changed\n");
 522
 523     displaysize = 0;
 524     lstrcpyW( displaynameW, abcW );
 525     ret = GetServiceDisplayNameW(scm_handle, deadbeefW, displaynameW, &displaysize);
 526     ok(!ret, "Expected failure\n");
 527     ok(displaysize == 2, "Service size expected 2, got %d\n", displaysize);
 528     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 529        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 530     ok(displaynameW[0] == 'A', "Service name changed\n");
 531
 532     displaysize = 1;
 533     strcpy(displayname, "ABC");
 534     ret = GetServiceDisplayNameA(scm_handle, deadbeef, displayname, &displaysize);
 535     ok(!ret, "Expected failure\n");
 536     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 537        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 538     todo_wine ok(displaysize == 1, "Service size expected 1, got %d\n", displaysize);
 539     ok(displayname[0] == 0, "Service name not empty\n");
 540
 541     displaysize = 1;
 542     lstrcpyW( displaynameW, abcW );
 543     ret = GetServiceDisplayNameW(scm_handle, deadbeefW, displaynameW, &displaysize);
 544     ok(!ret, "Expected failure\n");
 545     ok(displaysize == 2, "Service size expected 2, got %d\n", displaysize);
 546     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 547        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 548     ok(displaynameW[0] == 'A', "Service name changed\n");
 549
 550     displaysize = 2;
 551     strcpy(displayname, "ABC");
 552     ret = GetServiceDisplayNameA(scm_handle, deadbeef, displayname, &displaysize);
 553     ok(!ret, "Expected failure\n");
 554     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 555        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 556     todo_wine ok(displaysize == 2, "Service size expected 2, got %d\n", displaysize);
 557     ok(displayname[0] == 0, "Service name not empty\n");
 558
 559     displaysize = 2;
 560     lstrcpyW( displaynameW, abcW );
 561     ret = GetServiceDisplayNameW(scm_handle, deadbeefW, displaynameW, &displaysize);
 562     ok(!ret, "Expected failure\n");
 563     ok(displaysize == 2, "Service size expected 2, got %d\n", displaysize);
 564     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 565        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 566     ok(displaynameW[0] == 0, "Service name not empty\n");
 567
 568     /* Check if 'Spooler' exists */
 569     svc_handle = OpenServiceA(scm_handle, spooler, GENERIC_READ);
 570     if (!svc_handle)
 571     {
 572         skip("Spooler service doesn't exist\n");
 573         CloseServiceHandle(scm_handle);
 574         return;
 575     }
 576     CloseServiceHandle(svc_handle);
 577
 578     /* Retrieve the needed size for the buffer */
 579     SetLastError(0xdeadbeef);
 580     displaysize = -1;
 581     ret = GetServiceDisplayNameA(scm_handle, spooler, NULL, &displaysize);
 582     ok(!ret, "Expected failure\n");
 583     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 584        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 585     tempsize = displaysize;
 586
 587     displaysize = 0;
 588     ret = GetServiceDisplayNameA(scm_handle, spooler, NULL, &displaysize);
 589     ok(!ret, "Expected failure\n");
 590     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 591        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 592     ok(displaysize == tempsize, "Buffer size mismatch (%d vs %d)\n", tempsize, displaysize);
 593
 594     /* Buffer is too small */
 595     SetLastError(0xdeadbeef);
 596     displaysize = (tempsize / 2);
 597     ret = GetServiceDisplayNameA(scm_handle, spooler, displayname, &displaysize);
 598     ok(!ret, "Expected failure\n");
 599     ok(displaysize == tempsize, "Expected the needed buffersize\n");
 600     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 601        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 602
 603     /* First try with a buffer that should be big enough to hold
 604      * the ANSI string (and terminating character). This succeeds on Windows
 605      *  although when asked (see above 2 tests) it will return twice the needed size.
 606      */
 607     SetLastError(0xdeadbeef);
 608     displaysize = (tempsize / 2) + 1;
 609     ret = GetServiceDisplayNameA(scm_handle, spooler, displayname, &displaysize);
 610     ok(ret, "Expected success, got error %u\n", GetLastError());
 611     ok(displaysize == ((tempsize / 2) + 1), "Expected no change for the needed buffer size\n");
 612
 613     /* Now with the original returned size */
 614     SetLastError(0xdeadbeef);
 615     displaysize = tempsize;
 616     ret = GetServiceDisplayNameA(scm_handle, spooler, displayname, &displaysize);
 617     ok(ret, "Expected success, got error %u\n", GetLastError());
 618     ok(displaysize == tempsize, "Expected no change for the needed buffer size\n");
 619
 620     /* And with a bigger than needed buffer */
 621     SetLastError(0xdeadbeef);
 622     displaysize = tempsize * 2;
 623     ret = GetServiceDisplayNameA(scm_handle, spooler, displayname, &displaysize);
 624     ok(ret, "Expected success, got error %u\n", GetLastError());
 625     /* Test that shows that if the buffersize is enough, it's not changed */
 626     ok(displaysize == tempsize * 2, "Expected no change for the needed buffer size\n");
 627     ok(strlen(displayname) == tempsize/2,
 628        "Expected the buffer to be twice the length of the string\n") ;
 629
 630     /* Do the buffer(size) tests also for GetServiceDisplayNameW */
 631     SetLastError(0xdeadbeef);
 632     displaysize = -1;
 633     ret = GetServiceDisplayNameW(scm_handle, spoolerW, NULL, &displaysize);
 634     ok(!ret, "Expected failure\n");
 635     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 636        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 637
 638     /* Buffer is too small */
 639     SetLastError(0xdeadbeef);
 640     tempsizeW = displaysize;
 641     displaysize = tempsizeW / 2;
 642     ret = GetServiceDisplayNameW(scm_handle, spoolerW, displaynameW, &displaysize);
 643     ok(!ret, "Expected failure\n");
 644     ok(displaysize == tempsizeW, "Expected the needed buffersize\n");
 645     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 646        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 647
 648     /* Now with the original returned size */
 649     SetLastError(0xdeadbeef);
 650     displaysize = tempsizeW;
 651     ret = GetServiceDisplayNameW(scm_handle, spoolerW, displaynameW, &displaysize);
 652     ok(!ret, "Expected failure\n");
 653     ok(displaysize == tempsizeW, "Expected the needed buffersize\n");
 654     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 655        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 656
 657     /* And with a bigger than needed buffer */
 658     SetLastError(0xdeadbeef);
 659     displaysize = tempsizeW + 1; /* This caters for the null terminating character */
 660     ret = GetServiceDisplayNameW(scm_handle, spoolerW, displaynameW, &displaysize);
 661     ok(ret, "Expected success, got error %u\n", GetLastError());
 662     ok(displaysize == tempsizeW, "Expected the needed buffersize\n");
 663     ok(lstrlenW(displaynameW) == displaysize,
 664        "Expected the buffer to be the length of the string\n") ;
 665     ok(tempsize / 2 == tempsizeW,
 666        "Expected the needed buffersize (in bytes) to be the same for the A and W call\n");
 667
 668     CloseServiceHandle(scm_handle);
 669
 670     /* Test for a service without a displayname (which is valid). This should return
 671      * the servicename itself.
 672      */
 673     SetLastError(0xdeadbeef);
 674     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CREATE_SERVICE);
 675     if (!scm_handle && (GetLastError() == ERROR_ACCESS_DENIED))
 676     {
 677         skip("Not enough rights to get a handle to the manager\n");
 678         return;
 679     }
 680
 681     SetLastError(0xdeadbeef);
 682     svc_handle = CreateServiceA(scm_handle, servicename, NULL, DELETE,
 683                                 SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
 684                                 SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
 685     ok(svc_handle != NULL, "Could not create the service : %d\n", GetLastError());
 686     if (!svc_handle)
 687     {
 688         CloseServiceHandle(scm_handle);
 689         return;
 690     }
 691
 692     /* Retrieve the needed size for the buffer */
 693     SetLastError(0xdeadbeef);
 694     displaysize = -1;
 695     ret = GetServiceDisplayNameA(scm_handle, servicename, NULL, &displaysize);
 696     ok(!ret, "Expected failure\n");
 697     ok(displaysize == strlen(servicename) * 2,
 698        "Expected the displaysize to be twice the size of the servicename\n");
 699     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 700        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 701
 702     /* Buffer is too small */
 703     SetLastError(0xdeadbeef);
 704     tempsize = displaysize;
 705     displaysize = (tempsize / 2);
 706     ret = GetServiceDisplayNameA(scm_handle, servicename, displayname, &displaysize);
 707     ok(!ret, "Expected failure\n");
 708     ok(displaysize == tempsize, "Expected the needed buffersize\n");
 709     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 710        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 711
 712     /* Get the displayname */
 713     SetLastError(0xdeadbeef);
 714     ret = GetServiceDisplayNameA(scm_handle, servicename, displayname, &displaysize);
 715     ok(ret, "Expected success, got error %u\n", GetLastError());
 716     ok(!lstrcmpiA(displayname, servicename),
 717        "Expected displayname to be %s, got %s\n", servicename, displayname);
 718
 719     /* Delete the service */
 720     ret = DeleteService(svc_handle);
 721     ok(ret, "Expected success (err=%d)\n", GetLastError());
 722
 723     CloseServiceHandle(svc_handle);
 724     CloseServiceHandle(scm_handle);
 725
 726     /* Wait a while. Just in case one of the following tests does a CreateService again */
 727     Sleep(1000);
 728 }
 729
 730 static void test_get_servicekeyname(void)
 731 {
 732     SC_HANDLE scm_handle, svc_handle;
 733     CHAR servicename[4096];
 734     CHAR displayname[4096];
 735     WCHAR servicenameW[4096];
 736     WCHAR displaynameW[4096];
 737     DWORD servicesize, displaysize, tempsize;
 738     BOOL ret;
 739     static const CHAR deadbeef[] = "Deadbeef";
 740     static const WCHAR deadbeefW[] = {'D','e','a','d','b','e','e','f',0};
 741     static const WCHAR abcW[] = {'A','B','C',0};
 742
 743     /* Having NULL for the size of the buffer will crash on W2K3 */
 744
 745     SetLastError(0xdeadbeef);
 746     ret = GetServiceKeyNameA(NULL, NULL, NULL, &servicesize);
 747     ok(!ret, "Expected failure\n");
 748     ok(GetLastError() == ERROR_INVALID_HANDLE,
 749        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 750
 751     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
 752
 753     servicesize = 200;
 754     SetLastError(0xdeadbeef);
 755     ret = GetServiceKeyNameA(scm_handle, NULL, NULL, &servicesize);
 756     ok(!ret, "Expected failure\n");
 757     ok(GetLastError() == ERROR_INVALID_ADDRESS   /* W2K, XP, W2K3, Vista */ ||
 758        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 759        "Expected ERROR_INVALID_ADDRESS or ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 760     todo_wine ok(servicesize == 1, "Service size expected 1, got %d\n", servicesize);
 761
 762     /* Valid handle and buffer but no displayname */
 763     servicesize = 200;
 764     SetLastError(0xdeadbeef);
 765     ret = GetServiceKeyNameA(scm_handle, NULL, servicename, &servicesize);
 766     ok(!ret, "Expected failure\n");
 767     ok(GetLastError() == ERROR_INVALID_ADDRESS   /* W2K, XP, W2K3, Vista */ ||
 768        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 769        "Expected ERROR_INVALID_ADDRESS or ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 770     todo_wine ok(servicesize == 200, "Service size expected 1, got %d\n", servicesize);
 771
 772     /* Test for nonexistent displayname */
 773     SetLastError(0xdeadbeef);
 774     ret = GetServiceKeyNameA(scm_handle, deadbeef, NULL, &servicesize);
 775     ok(!ret, "Expected failure\n");
 776     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 777        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 778     todo_wine ok(servicesize == 1, "Service size expected 1, got %d\n", servicesize);
 779
 780     servicesize = 15;
 781     strcpy(servicename, "ABC");
 782     ret = GetServiceKeyNameA(scm_handle, deadbeef, servicename, &servicesize);
 783     ok(!ret, "Expected failure\n");
 784     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 785        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 786     todo_wine ok(servicesize == 15, "Service size expected 15, got %d\n", servicesize);
 787     ok(servicename[0] == 0, "Service name not empty\n");
 788
 789     servicesize = 15;
 790     lstrcpyW( servicenameW, abcW );
 791     ret = GetServiceKeyNameW(scm_handle, deadbeefW, servicenameW, &servicesize);
 792     ok(!ret, "Expected failure\n");
 793     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 794        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 795     ok(servicesize == 15, "Service size expected 15, got %d\n", servicesize);
 796     ok(servicenameW[0] == 0, "Service name not empty\n");
 797
 798     servicesize = 0;
 799     strcpy(servicename, "ABC");
 800     ret = GetServiceKeyNameA(scm_handle, deadbeef, servicename, &servicesize);
 801     ok(!ret, "Expected failure\n");
 802     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 803        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 804     todo_wine ok(servicesize == 1, "Service size expected 1, got %d\n", servicesize);
 805     ok(servicename[0] == 'A', "Service name changed\n");
 806
 807     servicesize = 0;
 808     lstrcpyW( servicenameW, abcW );
 809     ret = GetServiceKeyNameW(scm_handle, deadbeefW, servicenameW, &servicesize);
 810     ok(!ret, "Expected failure\n");
 811     ok(servicesize == 2, "Service size expected 2, got %d\n", servicesize);
 812     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 813        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 814     ok(servicenameW[0] == 'A', "Service name changed\n");
 815
 816     servicesize = 1;
 817     strcpy(servicename, "ABC");
 818     ret = GetServiceKeyNameA(scm_handle, deadbeef, servicename, &servicesize);
 819     ok(!ret, "Expected failure\n");
 820     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 821        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 822     todo_wine ok(servicesize == 1, "Service size expected 1, got %d\n", servicesize);
 823     ok(servicename[0] == 0, "Service name not empty\n");
 824
 825     servicesize = 1;
 826     lstrcpyW( servicenameW, abcW );
 827     ret = GetServiceKeyNameW(scm_handle, deadbeefW, servicenameW, &servicesize);
 828     ok(!ret, "Expected failure\n");
 829     ok(servicesize == 2, "Service size expected 2, got %d\n", servicesize);
 830     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 831        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 832     ok(servicenameW[0] == 'A', "Service name changed\n");
 833
 834     servicesize = 2;
 835     strcpy(servicename, "ABC");
 836     ret = GetServiceKeyNameA(scm_handle, deadbeef, servicename, &servicesize);
 837     ok(!ret, "Expected failure\n");
 838     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 839        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 840     todo_wine ok(servicesize == 2, "Service size expected 2, got %d\n", servicesize);
 841     ok(servicename[0] == 0, "Service name not empty\n");
 842
 843     servicesize = 2;
 844     lstrcpyW( servicenameW, abcW );
 845     ret = GetServiceKeyNameW(scm_handle, deadbeefW, servicenameW, &servicesize);
 846     ok(!ret, "Expected failure\n");
 847     ok(servicesize == 2, "Service size expected 2, got %d\n", servicesize);
 848     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
 849        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
 850     ok(servicenameW[0] == 0, "Service name not empty\n");
 851
 852     /* Check if 'Spooler' exists */
 853     svc_handle = OpenServiceA(scm_handle, spooler, GENERIC_READ);
 854     if (!svc_handle)
 855     {
 856         skip("Spooler service doesn't exist\n");
 857         CloseServiceHandle(scm_handle);
 858         return;
 859     }
 860     CloseServiceHandle(svc_handle);
 861
 862     /* Get the displayname for the 'Spooler' service */
 863     GetServiceDisplayNameA(scm_handle, spooler, NULL, &displaysize);
 864     GetServiceDisplayNameA(scm_handle, spooler, displayname, &displaysize);
 865
 866     /* Retrieve the needed size for the buffer */
 867     SetLastError(0xdeadbeef);
 868     servicesize = 0;
 869     ret = GetServiceKeyNameA(scm_handle, displayname, NULL, &servicesize);
 870     ok(!ret, "Expected failure\n");
 871     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 872        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 873
 874     /* Valid call with the correct buffersize */
 875     SetLastError(0xdeadbeef);
 876     tempsize = servicesize;
 877     servicesize *= 2;
 878     ret = GetServiceKeyNameA(scm_handle, displayname, servicename, &servicesize);
 879     ok(ret, "Expected success, got error %u\n", GetLastError());
 880     if (ret)
 881     {
 882         ok(strlen(servicename) == tempsize/2,
 883            "Expected the buffer to be twice the length of the string\n") ;
 884         ok(!lstrcmpiA(servicename, spooler), "Expected %s, got %s\n", spooler, servicename);
 885         ok(servicesize == (tempsize * 2),
 886            "Expected servicesize not to change if buffer not insufficient\n") ;
 887     }
 888
 889     MultiByteToWideChar(CP_ACP, 0, displayname, -1, displaynameW, sizeof(displaynameW)/2);
 890     SetLastError(0xdeadbeef);
 891     servicesize *= 2;
 892     ret = GetServiceKeyNameW(scm_handle, displaynameW, servicenameW, &servicesize);
 893     ok(ret, "Expected success, got error %u\n", GetLastError());
 894     if (ret)
 895     {
 896         ok(strlen(servicename) == tempsize/2,
 897            "Expected the buffer to be twice the length of the string\n") ;
 898         ok(servicesize == lstrlenW(servicenameW),
 899            "Expected servicesize not to change if buffer not insufficient\n") ;
 900     }
 901
 902     SetLastError(0xdeadbeef);
 903     servicesize = 3;
 904     ret = GetServiceKeyNameW(scm_handle, displaynameW, servicenameW, &servicesize);
 905     ok(!ret, "Expected failure\n");
 906     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 907        "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 908     ok(servicenameW[0] == 0, "Buffer not empty\n");
 909
 910     CloseServiceHandle(scm_handle);
 911 }
 912
 913 static void test_query_svc(void)
 914 {
 915     SC_HANDLE scm_handle, svc_handle;
 916     BOOL ret;
 917     SERVICE_STATUS status;
 918     SERVICE_STATUS_PROCESS *statusproc;
 919     DWORD bufsize, needed;
 920
 921     /* All NULL or wrong  */
 922     SetLastError(0xdeadbeef);
 923     ret = QueryServiceStatus(NULL, NULL);
 924     ok(!ret, "Expected failure\n");
 925     ok(GetLastError() == ERROR_INVALID_HANDLE,
 926        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
 927
 928     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
 929
 930     /* Check if 'Spooler' exists.
 931      * Open with not enough rights to query the status.
 932      */
 933     svc_handle = OpenServiceA(scm_handle, spooler, STANDARD_RIGHTS_READ);
 934     if (!svc_handle)
 935     {
 936         skip("Spooler service doesn't exist\n");
 937         CloseServiceHandle(scm_handle);
 938         return;
 939     }
 940
 941     SetLastError(0xdeadbeef);
 942     ret = QueryServiceStatus(svc_handle, NULL);
 943     ok(!ret, "Expected failure\n");
 944     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
 945        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
 946        "Unexpected last error %d\n", GetLastError());
 947
 948     SetLastError(0xdeadbeef);
 949     ret = QueryServiceStatus(svc_handle, &status);
 950     ok(!ret, "Expected failure\n");
 951     ok(GetLastError() == ERROR_ACCESS_DENIED,
 952        "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
 953
 954     /* Open the service with just enough rights.
 955      * (Verified with 'SERVICE_ALL_ACCESS &~ SERVICE_QUERY_STATUS')
 956      */
 957     CloseServiceHandle(svc_handle);
 958     svc_handle = OpenServiceA(scm_handle, spooler, SERVICE_QUERY_STATUS);
 959
 960     SetLastError(0xdeadbeef);
 961     ret = QueryServiceStatus(svc_handle, &status);
 962     ok(ret, "Expected success, got error %u\n", GetLastError());
 963
 964     CloseServiceHandle(svc_handle);
 965
 966     /* More or less the same tests for QueryServiceStatusEx */
 967     if (!pQueryServiceStatusEx)
 968     {
 969         win_skip( "QueryServiceStatusEx not available\n" );
 970         CloseServiceHandle(scm_handle);
 971         return;
 972     }
 973
 974     /* Open service with not enough rights to query the status */
 975     svc_handle = OpenServiceA(scm_handle, spooler, STANDARD_RIGHTS_READ);
 976
 977     /* All NULL or wrong, this proves that info level is checked first */
 978     SetLastError(0xdeadbeef);
 979     ret = pQueryServiceStatusEx(NULL, 1, NULL, 0, NULL);
 980     ok(!ret, "Expected failure\n");
 981     ok(GetLastError() == ERROR_INVALID_LEVEL,
 982        "Expected ERROR_INVALID_LEVEL, got %d\n", GetLastError());
 983
 984     /* Passing a NULL parameter for the needed buffer size
 985      * will crash on anything but NT4.
 986      */
 987
 988     /* Only info level is correct. It looks like the buffer/size is checked second */
 989     SetLastError(0xdeadbeef);
 990     ret = pQueryServiceStatusEx(NULL, SC_STATUS_PROCESS_INFO, NULL, 0, &needed);
 991     /* NT4 checks the handle first */
 992     if (GetLastError() != ERROR_INVALID_HANDLE)
 993     {
 994         ok(!ret, "Expected failure\n");
 995         ok(needed == sizeof(SERVICE_STATUS_PROCESS),
 996            "Needed buffersize is wrong : %d\n", needed);
 997         ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 998            "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 999     }
1000
1001     /* Pass a correct buffer and buffersize but a NULL handle */
1002     statusproc = HeapAlloc(GetProcessHeap(), 0, sizeof(SERVICE_STATUS_PROCESS));
1003     bufsize = needed;
1004     SetLastError(0xdeadbeef);
1005     ret = pQueryServiceStatusEx(NULL, SC_STATUS_PROCESS_INFO, (BYTE*)statusproc, bufsize, &needed);
1006     ok(!ret, "Expected failure\n");
1007     ok(GetLastError() == ERROR_INVALID_HANDLE,
1008        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1009     HeapFree(GetProcessHeap(), 0, statusproc);
1010
1011     /* Correct handle and info level */
1012     SetLastError(0xdeadbeef);
1013     ret = pQueryServiceStatusEx(svc_handle, SC_STATUS_PROCESS_INFO, NULL, 0, &needed);
1014     /* NT4 doesn't return the needed size */
1015     if (GetLastError() != ERROR_INVALID_PARAMETER)
1016     {
1017         ok(!ret, "Expected failure\n");
1018         ok(needed == sizeof(SERVICE_STATUS_PROCESS),
1019            "Needed buffersize is wrong : %d\n", needed);
1020         ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1021            "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
1022     }
1023
1024     /* All parameters are OK but we don't have enough rights */
1025     statusproc = HeapAlloc(GetProcessHeap(), 0, sizeof(SERVICE_STATUS_PROCESS));
1026     bufsize = sizeof(SERVICE_STATUS_PROCESS);
1027     SetLastError(0xdeadbeef);
1028     ret = pQueryServiceStatusEx(svc_handle, SC_STATUS_PROCESS_INFO, (BYTE*)statusproc, bufsize, &needed);
1029     ok(!ret, "Expected failure\n");
1030     ok(GetLastError() == ERROR_ACCESS_DENIED,
1031        "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
1032     HeapFree(GetProcessHeap(), 0, statusproc);
1033
1034     /* Open the service with just enough rights. */
1035     CloseServiceHandle(svc_handle);
1036     svc_handle = OpenServiceA(scm_handle, spooler, SERVICE_QUERY_STATUS);
1037
1038     /* Everything should be fine now. */
1039     statusproc = HeapAlloc(GetProcessHeap(), 0, sizeof(SERVICE_STATUS_PROCESS));
1040     bufsize = sizeof(SERVICE_STATUS_PROCESS);
1041     SetLastError(0xdeadbeef);
1042     ret = pQueryServiceStatusEx(svc_handle, SC_STATUS_PROCESS_INFO, (BYTE*)statusproc, bufsize, &needed);
1043     ok(ret, "Expected success, got error %u\n", GetLastError());
1044     if (statusproc->dwCurrentState == SERVICE_RUNNING)
1045         ok(statusproc->dwProcessId != 0,
1046            "Expect a process id for this running service\n");
1047     else
1048         ok(statusproc->dwProcessId == 0,
1049            "Expect no process id for this stopped service\n");
1050
1051     /* same call with null needed pointer */
1052     SetLastError(0xdeadbeef);
1053     ret = pQueryServiceStatusEx(svc_handle, SC_STATUS_PROCESS_INFO, (BYTE*)statusproc, bufsize, NULL);
1054     ok(!ret, "Expected failure\n");
1055     ok(broken(GetLastError() == ERROR_INVALID_PARAMETER) /* NT4 */ ||
1056        GetLastError() == ERROR_INVALID_ADDRESS, "got %d\n", GetLastError());
1057
1058     HeapFree(GetProcessHeap(), 0, statusproc);
1059
1060     CloseServiceHandle(svc_handle);
1061     CloseServiceHandle(scm_handle);
1062 }
1063
1064 static void test_enum_svc(void)
1065 {
1066     SC_HANDLE scm_handle;
1067     BOOL ret;
1068     DWORD bufsize, needed, returned, resume;
1069     DWORD neededW, returnedW;
1070     DWORD tempneeded, tempreturned, missing;
1071     DWORD servicecountactive, servicecountinactive;
1072     ENUM_SERVICE_STATUSA *services;
1073     ENUM_SERVICE_STATUSW *servicesW;
1074     ENUM_SERVICE_STATUS_PROCESSA *exservices;
1075     UINT i;
1076
1077     /* All NULL or wrong  */
1078     SetLastError(0xdeadbeef);
1079     ret = EnumServicesStatusA(NULL, 1, 0, NULL, 0, NULL, NULL, NULL);
1080     ok(!ret, "Expected failure\n");
1081     ok(GetLastError() == ERROR_INVALID_HANDLE,
1082        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1083
1084     SetLastError(0xdeadbeef);
1085     ret = EnumServicesStatusW(NULL, 1, 0, NULL, 0, NULL, NULL, NULL);
1086     ok(!ret, "Expected failure\n");
1087     ok(GetLastError() == ERROR_INVALID_HANDLE,
1088        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1089
1090     /* Open the service control manager with not enough rights at first */
1091     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
1092
1093     /* Valid handle but rest is still NULL or wrong  */
1094     SetLastError(0xdeadbeef);
1095     ret = EnumServicesStatusA(scm_handle, 1, 0, NULL, 0, NULL, NULL, NULL);
1096     ok(!ret, "Expected failure\n");
1097     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
1098        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
1099        "Unexpected last error %d\n", GetLastError());
1100
1101     SetLastError(0xdeadbeef);
1102     ret = EnumServicesStatusW(scm_handle, 1, 0, NULL, 0, NULL, NULL, NULL);
1103     ok(!ret, "Expected failure\n");
1104     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
1105        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
1106        "Unexpected last error %d\n", GetLastError());
1107
1108     /* Don't specify the two required pointers */
1109     returned = 0xdeadbeef;
1110     SetLastError(0xdeadbeef);
1111     ret = EnumServicesStatusA(scm_handle, 0, 0, NULL, 0, NULL, &returned, NULL);
1112     ok(!ret, "Expected failure\n");
1113     ok(returned == 0xdeadbeef, "Expected no change to the number of services variable\n");
1114     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
1115        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
1116        "Unexpected last error %d\n", GetLastError());
1117
1118     returned = 0xdeadbeef;
1119     SetLastError(0xdeadbeef);
1120     ret = EnumServicesStatusW(scm_handle, 0, 0, NULL, 0, NULL, &returned, NULL);
1121     ok(!ret, "Expected failure\n");
1122     ok(returned == 0xdeadbeef, "Expected no change to the number of services variable\n");
1123     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
1124        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
1125        "Unexpected last error %d\n", GetLastError());
1126
1127     /* Don't specify the two required pointers */
1128     needed = 0xdeadbeef;
1129     SetLastError(0xdeadbeef);
1130     ret = EnumServicesStatusA(scm_handle, 0, 0, NULL, 0, &needed, NULL, NULL);
1131     ok(!ret, "Expected failure\n");
1132     ok(needed == 0xdeadbeef || broken(needed != 0xdeadbeef), /* nt4 */
1133        "Expected no change to the needed buffer variable\n");
1134     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
1135        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
1136        "Unexpected last error %d\n", GetLastError());
1137
1138     needed = 0xdeadbeef;
1139     SetLastError(0xdeadbeef);
1140     ret = EnumServicesStatusW(scm_handle, 0, 0, NULL, 0, &needed, NULL, NULL);
1141     ok(!ret, "Expected failure\n");
1142     ok(needed == 0xdeadbeef || broken(needed != 0xdeadbeef), /* nt4 */
1143        "Expected no change to the needed buffer variable\n");
1144     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
1145        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
1146        "Unexpected last error %d\n", GetLastError());
1147
1148     /* No valid servicetype and servicestate */
1149     needed = 0xdeadbeef;
1150     returned = 0xdeadbeef;
1151     SetLastError(0xdeadbeef);
1152     ret = EnumServicesStatusA(scm_handle, 0, 0, NULL, 0, &needed, &returned, NULL);
1153     ok(!ret, "Expected failure\n");
1154     ok(needed == 0 || broken(needed != 0), /* nt4 */
1155        "Expected needed buffer size to be set to 0, got %d\n", needed);
1156     ok(returned == 0, "Expected number of services to be set to 0, got %d\n", returned);
1157     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1158        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1159
1160     needed = 0xdeadbeef;
1161     returned = 0xdeadbeef;
1162     SetLastError(0xdeadbeef);
1163     ret = EnumServicesStatusW(scm_handle, 0, 0, NULL, 0, &needed, &returned, NULL);
1164     ok(!ret, "Expected failure\n");
1165     ok(needed == 0 || broken(needed != 0), /* nt4 */
1166        "Expected needed buffer size to be set to 0, got %d\n", needed);
1167     ok(returned == 0 || broken(returned != 0), /* nt4 */
1168        "Expected number of services to be set to 0, got %d\n", returned);
1169     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1170        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1171
1172     /* No valid servicestate */
1173     needed = 0xdeadbeef;
1174     returned = 0xdeadbeef;
1175     SetLastError(0xdeadbeef);
1176     ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, 0, NULL, 0, &needed, &returned, NULL);
1177     ok(!ret, "Expected failure\n");
1178     ok(needed == 0 || broken(needed != 0), /* nt4 */
1179        "Expected needed buffer size to be set to 0, got %d\n", needed);
1180     ok(returned == 0, "Expected number of services to be set to 0, got %d\n", returned);
1181     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1182        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1183
1184     needed = 0xdeadbeef;
1185     returned = 0xdeadbeef;
1186     SetLastError(0xdeadbeef);
1187     ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, 0, NULL, 0, &needed, &returned, NULL);
1188     ok(!ret, "Expected failure\n");
1189     ok(needed == 0 || broken(needed != 0), /* nt4 */
1190        "Expected needed buffer size to be set to 0, got %d\n", needed);
1191     ok(returned == 0 || broken(returned != 0), /* nt4 */
1192        "Expected number of services to be set to 0, got %d\n", returned);
1193     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1194        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1195
1196     /* No valid servicetype */
1197     needed = 0xdeadbeef;
1198     returned = 0xdeadbeef;
1199     SetLastError(0xdeadbeef);
1200     ret = EnumServicesStatusA(scm_handle, 0, SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL);
1201     ok(!ret, "Expected failure\n");
1202     ok(needed == 0 || broken(needed != 0), /* nt4 */
1203        "Expected needed buffer size to be set to 0, got %d\n", needed);
1204     ok(returned == 0, "Expected number of services to be set to 0, got %d\n", returned);
1205     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1206        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1207
1208     needed = 0xdeadbeef;
1209     returned = 0xdeadbeef;
1210     SetLastError(0xdeadbeef);
1211     ret = EnumServicesStatusW(scm_handle, 0, SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL);
1212     ok(!ret, "Expected failure\n");
1213     ok(needed == 0 || broken(needed != 0), /* nt4 */
1214        "Expected needed buffer size to be set to 0, got %d\n", needed);
1215     ok(returned == 0 || broken(returned != 0), /* nt4 */
1216        "Expected number of services to be set to 0, got %d\n", returned);
1217     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1218        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1219
1220     /* All parameters are correct but our access rights are wrong */
1221     needed = 0xdeadbeef;
1222     returned = 0xdeadbeef;
1223     SetLastError(0xdeadbeef);
1224     ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL);
1225     ok(!ret, "Expected failure\n");
1226     ok(needed == 0 || broken(needed != 0), /* nt4 */
1227        "Expected needed buffer size to be set to 0, got %d\n", needed);
1228     ok(returned == 0, "Expected number of services to be set to 0, got %d\n", returned);
1229     ok(GetLastError() == ERROR_ACCESS_DENIED,
1230        "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
1231
1232     needed = 0xdeadbeef;
1233     returned = 0xdeadbeef;
1234     SetLastError(0xdeadbeef);
1235     ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL);
1236     ok(!ret, "Expected failure\n");
1237     ok(needed == 0 || broken(needed != 0), /* nt4 */
1238        "Expected needed buffer size to be set to 0, got %d\n", needed);
1239     ok(returned == 0 || broken(returned != 0), /* nt4 */
1240        "Expected number of services to be set to 0, got %d\n", returned);
1241     ok(GetLastError() == ERROR_ACCESS_DENIED,
1242        "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
1243
1244     /* Open the service control manager with the needed rights */
1245     CloseServiceHandle(scm_handle);
1246     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
1247
1248     /* All parameters are correct. Request the needed buffer size */
1249     needed = 0xdeadbeef;
1250     returned = 0xdeadbeef;
1251     SetLastError(0xdeadbeef);
1252     ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL);
1253     ok(!ret, "Expected failure\n");
1254     ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size for this one service\n");
1255     ok(returned == 0, "Expected no service returned, got %d\n", returned);
1256     ok(GetLastError() == ERROR_MORE_DATA,
1257        "Expected ERROR_MORE_DATA, got %d\n", GetLastError());
1258
1259     /* Test to show we get the same needed buffer size for the W-call */
1260     neededW = 0xdeadbeef;
1261     returnedW = 0xdeadbeef;
1262     SetLastError(0xdeadbeef);
1263     ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0, &neededW, &returnedW, NULL);
1264     ok(!ret, "Expected failure\n");
1265     ok(neededW != 0xdeadbeef && neededW > 0, "Expected the needed buffer size for this one service\n");
1266     ok(neededW == needed, "Expected needed buffersize to be the same for A- and W-calls\n");
1267     ok(returnedW == 0, "Expected no service returned, got %d\n", returnedW);
1268     ok(GetLastError() == ERROR_MORE_DATA,
1269        "Expected ERROR_MORE_DATA, got %d\n", GetLastError());
1270
1271     /* Store the needed bytes */
1272     tempneeded = needed;
1273
1274     /* Allocate the correct needed bytes */
1275     services = HeapAlloc(GetProcessHeap(), 0, needed);
1276     bufsize = needed;
1277     needed = 0xdeadbeef;
1278     returned = 0xdeadbeef;
1279     SetLastError(0xdeadbeef);
1280     ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
1281                               services, bufsize, &needed, &returned, NULL);
1282     ok(ret, "Expected success, got error %u\n", GetLastError());
1283     ok(needed == 0, "Expected needed buffer to be 0 as we are done\n");
1284     ok(returned != 0xdeadbeef && returned > 0, "Expected some returned services\n");
1285     HeapFree(GetProcessHeap(), 0, services);
1286
1287     /* Store the number of returned services */
1288     tempreturned = returned;
1289
1290     servicesW = HeapAlloc(GetProcessHeap(), 0, neededW);
1291     bufsize = neededW;
1292     neededW = 0xdeadbeef;
1293     returnedW = 0xdeadbeef;
1294     SetLastError(0xdeadbeef);
1295     ret = EnumServicesStatusW(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
1296                               servicesW, bufsize, &neededW, &returnedW, NULL);
1297     ok(ret, "Expected success, got error %u\n", GetLastError());
1298     ok(neededW == 0, "Expected needed buffer to be 0 as we are done\n");
1299     ok(returnedW != 0xdeadbeef && returnedW > 0, "Expected some returned services\n");
1300     HeapFree(GetProcessHeap(), 0, servicesW);
1301
1302     /* Allocate less than the needed bytes and don't specify a resume handle */
1303     services = HeapAlloc(GetProcessHeap(), 0, tempneeded);
1304     bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSA);
1305     needed = 0xdeadbeef;
1306     returned = 0xdeadbeef;
1307     SetLastError(0xdeadbeef);
1308     ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
1309                               services, bufsize, &needed, &returned, NULL);
1310     ok(!ret, "Expected failure\n");
1311     ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size for this one service\n");
1312     ok(returned < tempreturned, "Expected fewer services to be returned\n");
1313     ok(GetLastError() == ERROR_MORE_DATA,
1314        "Expected ERROR_MORE_DATA, got %d\n", GetLastError());
1315
1316     /* Allocate less than the needed bytes, this time with a correct resume handle */
1317     bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSA);
1318     needed = 0xdeadbeef;
1319     returned = 0xdeadbeef;
1320     resume = 0;
1321     SetLastError(0xdeadbeef);
1322     ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
1323                               services, bufsize, &needed, &returned, &resume);
1324     ok(!ret, "Expected failure\n");
1325     ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size for this one service\n");
1326     ok(returned < tempreturned, "Expected fewer services to be returned\n");
1327     todo_wine ok(resume, "Expected a resume handle\n");
1328     ok(GetLastError() == ERROR_MORE_DATA,
1329        "Expected ERROR_MORE_DATA, got %d\n", GetLastError());
1330
1331     /* Fetch the missing services but pass a bigger buffer size */
1332     missing = tempreturned - returned;
1333     bufsize = tempneeded;
1334     needed = 0xdeadbeef;
1335     returned = 0xdeadbeef;
1336     SetLastError(0xdeadbeef);
1337     ret = EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL,
1338                               services, bufsize, &needed, &returned, &resume);
1339     ok(ret, "Expected success, got error %u\n", GetLastError());
1340     ok(needed == 0, "Expected needed buffer to be 0 as we are done\n");
1341     ok(returned == missing, "Expected %u services to be returned\n", missing);
1342     ok(resume == 0, "Expected the resume handle to be 0\n");
1343     HeapFree(GetProcessHeap(), 0, services);
1344
1345     /* See if things add up */
1346
1347     /* Vista only shows the drivers with a state of SERVICE_RUNNING as active
1348      * and doesn't count the others as inactive. This means that Vista could
1349      * show a total that is greater than the sum of active and inactive
1350      * drivers.
1351      * The number of active and inactive drivers is greatly influenced by the
1352      * time when tests are run, immediately after boot or later for example.
1353      *
1354      * Both reasons make calculations for drivers not so useful
1355      */
1356
1357     /* Get the number of active win32 services */
1358     EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_ACTIVE, NULL, 0,
1359                         &needed, &returned, NULL);
1360     services = HeapAlloc(GetProcessHeap(), 0, needed);
1361     EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_ACTIVE, services,
1362                         needed, &needed, &returned, NULL);
1363     HeapFree(GetProcessHeap(), 0, services);
1364
1365     servicecountactive = returned;
1366
1367     /* Get the number of inactive win32 services */
1368     EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_INACTIVE, NULL, 0,
1369                         &needed, &returned, NULL);
1370     services = HeapAlloc(GetProcessHeap(), 0, needed);
1371     EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_INACTIVE, services,
1372                         needed, &needed, &returned, NULL);
1373     HeapFree(GetProcessHeap(), 0, services);
1374
1375     servicecountinactive = returned;
1376
1377     /* Get the number of win32 services */
1378     EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, NULL, 0,
1379                         &needed, &returned, NULL);
1380     services = HeapAlloc(GetProcessHeap(), 0, needed);
1381     EnumServicesStatusA(scm_handle, SERVICE_WIN32, SERVICE_STATE_ALL, services,
1382                         needed, &needed, &returned, NULL);
1383     HeapFree(GetProcessHeap(), 0, services);
1384
1385     /* Check if total is the same as active and inactive win32 services */
1386     ok(returned == (servicecountactive + servicecountinactive),
1387        "Something wrong in the calculation\n");
1388
1389     /* Get all drivers and services
1390      *
1391      * Fetch the status of the last call as failing could make the following tests crash
1392      * on Wine (we don't return anything yet).
1393      */
1394     EnumServicesStatusA(scm_handle, SERVICE_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL,
1395                         NULL, 0, &needed, &returned, NULL);
1396     services = HeapAlloc(GetProcessHeap(), 0, needed);
1397     ret = EnumServicesStatusA(scm_handle, SERVICE_DRIVER | SERVICE_WIN32, SERVICE_STATE_ALL,
1398                               services, needed, &needed, &returned, NULL);
1399
1400     /* Loop through all those returned drivers and services */
1401     for (i = 0; ret && i < returned; i++)
1402     {
1403         SERVICE_STATUS status = services[i].ServiceStatus;
1404
1405         /* lpServiceName and lpDisplayName should always be filled */
1406         ok(services[i].lpServiceName[0], "Expected a service name\n");
1407         ok(services[i].lpDisplayName[0], "Expected a display name\n");
1408
1409         /* Decrement the counters to see if the functions calls return the same
1410          * numbers as the contents of these structures.
1411          */
1412         if (status.dwServiceType & (SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS))
1413         {
1414             if (status.dwCurrentState == SERVICE_STOPPED)
1415                 servicecountinactive--;
1416             else
1417                 servicecountactive--;
1418         }
1419     }
1420     HeapFree(GetProcessHeap(), 0, services);
1421
1422     ok(servicecountactive == 0, "Active services mismatch %u\n", servicecountactive);
1423     ok(servicecountinactive == 0, "Inactive services mismatch %u\n", servicecountinactive);
1424
1425     CloseServiceHandle(scm_handle);
1426
1427     /* More or less the same for EnumServicesStatusExA */
1428     if (!pEnumServicesStatusExA)
1429     {
1430         win_skip( "EnumServicesStatusExA not available\n" );
1431         return;
1432     }
1433
1434     /* All NULL or wrong */
1435     SetLastError(0xdeadbeef);
1436     ret = pEnumServicesStatusExA(NULL, 1, 0, 0, NULL, 0, NULL, NULL, NULL, NULL);
1437     ok(!ret, "Expected failure\n");
1438     ok(GetLastError() == ERROR_INVALID_LEVEL,
1439        "Expected ERROR_INVALID_LEVEL, got %d\n", GetLastError());
1440
1441     /* All NULL or wrong, just the info level is correct */
1442     SetLastError(0xdeadbeef);
1443     ret = pEnumServicesStatusExA(NULL, 0, 0, 0, NULL, 0, NULL, NULL, NULL, NULL);
1444     ok(!ret, "Expected failure\n");
1445     ok(GetLastError() == ERROR_INVALID_HANDLE,
1446        "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1447
1448     /* Open the service control manager with not enough rights at first */
1449     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
1450
1451     /* Valid handle and info level but rest is still NULL or wrong */
1452     SetLastError(0xdeadbeef);
1453     ret = pEnumServicesStatusExA(scm_handle, 0, 0, 0, NULL, 0, NULL, NULL, NULL, NULL);
1454     ok(!ret, "Expected failure\n");
1455     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
1456        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
1457        "Unexpected last error %d\n", GetLastError());
1458
1459     /* Don't specify the two required pointers */
1460     needed = 0xdeadbeef;
1461     SetLastError(0xdeadbeef);
1462     ret = pEnumServicesStatusExA(scm_handle, 0, 0, 0, NULL, 0, &needed, NULL, NULL, NULL);
1463     ok(!ret, "Expected failure\n");
1464     ok(needed == 0xdeadbeef || broken(needed != 0xdeadbeef), /* nt4 */
1465        "Expected no change to the needed buffer variable\n");
1466     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
1467        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
1468        "Unexpected last error %d\n", GetLastError());
1469
1470     /* Don't specify the two required pointers */
1471     returned = 0xdeadbeef;
1472     SetLastError(0xdeadbeef);
1473     ret = pEnumServicesStatusExA(scm_handle, 0, 0, 0, NULL, 0, NULL, &returned, NULL, NULL);
1474     ok(!ret, "Expected failure\n");
1475     ok(returned == 0xdeadbeef, "Expected no change to the number of services variable\n");
1476     ok(GetLastError() == ERROR_INVALID_ADDRESS ||
1477        GetLastError() == ERROR_INVALID_PARAMETER /* NT4 */,
1478        "Unexpected last error %d\n", GetLastError());
1479
1480     /* No valid servicetype and servicestate */
1481     needed = 0xdeadbeef;
1482     returned = 0xdeadbeef;
1483     SetLastError(0xdeadbeef);
1484     ret = pEnumServicesStatusExA(scm_handle, 0, 0, 0, NULL, 0, &needed, &returned, NULL, NULL);
1485     ok(!ret, "Expected failure\n");
1486     ok(returned == 0, "Expected number of service to be set to 0, got %d\n", returned);
1487     ok(needed == 0 || broken(needed != 0), /* nt4 */
1488        "Expected needed buffer size to be set to 0, got %d\n", needed);
1489     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1490        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1491
1492     /* No valid servicestate */
1493     needed = 0xdeadbeef;
1494     returned = 0xdeadbeef;
1495     SetLastError(0xdeadbeef);
1496     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, 0, NULL, 0,
1497                                  &needed, &returned, NULL, NULL);
1498     ok(!ret, "Expected failure\n");
1499     ok(returned == 0, "Expected number of service to be set to 0, got %d\n", returned);
1500     ok(needed == 0 || broken(needed != 0), /* nt4 */
1501        "Expected needed buffer size to be set to 0, got %d\n", needed);
1502     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1503        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1504
1505     /* No valid servicetype */
1506     needed = 0xdeadbeef;
1507     returned = 0xdeadbeef;
1508     SetLastError(0xdeadbeef);
1509     ret = pEnumServicesStatusExA(scm_handle, 0, 0, SERVICE_STATE_ALL, NULL, 0,
1510                                  &needed, &returned, NULL, NULL);
1511     ok(!ret, "Expected failure\n");
1512     ok(returned == 0, "Expected number of service to be set to 0, got %d\n", returned);
1513     ok(needed == 0 || broken(needed != 0), /* nt4 */
1514        "Expected needed buffer size to be set to 0, got %d\n", needed);
1515     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1516        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1517
1518     /* No valid servicetype and servicestate and unknown service group */
1519     needed = 0xdeadbeef;
1520     returned = 0xdeadbeef;
1521     SetLastError(0xdeadbeef);
1522     ret = pEnumServicesStatusExA(scm_handle, 0, 0, 0, NULL, 0, &needed,
1523                                  &returned, NULL, "deadbeef_group");
1524     ok(!ret, "Expected failure\n");
1525     ok(returned == 0, "Expected number of service to be set to 0, got %d\n", returned);
1526     ok(needed == 0 || broken(needed != 0), /* nt4 */
1527        "Expected needed buffer size to be set to 0, got %d\n", needed);
1528     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1529        "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1530
1531     /* All parameters are correct but our access rights are wrong */
1532     needed = 0xdeadbeef;
1533     returned = 0xdeadbeef;
1534     SetLastError(0xdeadbeef);
1535     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1536                                  NULL, 0, &needed, &returned, NULL, NULL);
1537     ok(!ret, "Expected failure\n");
1538     ok(needed == 0 || broken(needed != 0), /* nt4 */
1539        "Expected needed buffer size to be set to 0, got %d\n", needed);
1540     ok(returned == 0, "Expected number of service to be set to 0, got %d\n", returned);
1541     ok(GetLastError() == ERROR_ACCESS_DENIED,
1542        "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
1543
1544     /* All parameters are correct, access rights are wrong but the
1545      * group name won't be checked yet.
1546      */
1547     needed = 0xdeadbeef;
1548     returned = 0xdeadbeef;
1549     SetLastError(0xdeadbeef);
1550     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1551                                  NULL, 0, &needed, &returned, NULL, "deadbeef_group");
1552     ok(!ret, "Expected failure\n");
1553     ok(needed == 0 || broken(needed != 0), /* nt4 */
1554        "Expected needed buffer size to be set to 0, got %d\n", needed);
1555     ok(returned == 0, "Expected number of service to be set to 0, got %d\n", returned);
1556     ok(GetLastError() == ERROR_ACCESS_DENIED,
1557        "Expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
1558
1559     /* Open the service control manager with the needed rights */
1560     CloseServiceHandle(scm_handle);
1561     scm_handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
1562
1563     /* All parameters are correct and the group will be checked */
1564     needed = 0xdeadbeef;
1565     returned = 0xdeadbeef;
1566     SetLastError(0xdeadbeef);
1567     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1568                                  NULL, 0, &needed, &returned, NULL, "deadbeef_group");
1569     ok(!ret, "Expected failure\n");
1570     ok(returned == 0, "Expected number of service to be set to 0, got %d\n", returned);
1571     ok(needed == 0, "Expected needed buffer size to be set to 0, got %d\n", needed);
1572     ok(GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST,
1573        "Expected ERROR_SERVICE_DOES_NOT_EXIST, got %d\n", GetLastError());
1574
1575     /* TODO: Create a test that makes sure we enumerate all services that don't
1576      * belong to a group. (specifying "").
1577      */
1578
1579     /* All parameters are correct. Request the needed buffer size */
1580     needed = 0xdeadbeef;
1581     returned = 0xdeadbeef;
1582     SetLastError(0xdeadbeef);
1583     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1584                                  NULL, 0, &needed, &returned, NULL, NULL);
1585     ok(!ret, "Expected failure\n");
1586     ok(returned == 0, "Expected no service returned, got %d\n", returned);
1587     ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size\n");
1588     ok(GetLastError() == ERROR_MORE_DATA,
1589        "Expected ERROR_MORE_DATA, got %d\n", GetLastError());
1590
1591     /* Test to show we get the same needed buffer size for the W-call */
1592     neededW = 0xdeadbeef;
1593     ret = pEnumServicesStatusExW(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1594                                  NULL, 0, &neededW, &returnedW, NULL, NULL);
1595     ok(!ret, "Expected failure\n");
1596     ok(neededW == needed, "Expected needed buffersize to be the same for A- and W-calls\n");
1597
1598     /* Store the needed bytes */
1599     tempneeded = needed;
1600
1601     /* Allocate the correct needed bytes */
1602     exservices = HeapAlloc(GetProcessHeap(), 0, needed);
1603     bufsize = needed;
1604     needed = 0xdeadbeef;
1605     returned = 0xdeadbeef;
1606     SetLastError(0xdeadbeef);
1607     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1608                                  (BYTE*)exservices, bufsize, &needed, &returned, NULL, NULL);
1609     ok(ret, "Expected success, got error %u\n", GetLastError());
1610     ok(needed == 0, "Expected needed buffer to be 0 as we are done\n");
1611     ok(returned == tempreturned, "Expected the same number of service from this function\n");
1612     HeapFree(GetProcessHeap(), 0, exservices);
1613
1614     /* Store the number of returned services */
1615     tempreturned = returned;
1616
1617     /* Allocate less than the needed bytes and don't specify a resume handle */
1618     exservices = HeapAlloc(GetProcessHeap(), 0, tempneeded);
1619     bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSA);
1620     needed = 0xdeadbeef;
1621     returned = 0xdeadbeef;
1622     SetLastError(0xdeadbeef);
1623     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1624                                  (BYTE*)exservices, bufsize, &needed, &returned, NULL, NULL);
1625     ok(!ret, "Expected failure\n");
1626     ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size\n");
1627     ok(returned < tempreturned, "Expected fewer services to be returned\n");
1628     ok(GetLastError() == ERROR_MORE_DATA,
1629        "Expected ERROR_MORE_DATA, got %d\n", GetLastError());
1630
1631     /* Allocate less than the needed bytes, this time with a correct resume handle */
1632     bufsize = (tempreturned - 1) * sizeof(ENUM_SERVICE_STATUSA);
1633     needed = 0xdeadbeef;
1634     returned = 0xdeadbeef;
1635     resume = 0;
1636     SetLastError(0xdeadbeef);
1637     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1638                                  (BYTE*)exservices, bufsize, &needed, &returned, &resume, NULL);
1639     ok(!ret, "Expected failure\n");
1640     ok(needed != 0xdeadbeef && needed > 0, "Expected the needed buffer size\n");
1641     ok(returned < tempreturned, "Expected fewer services to be returned\n");
1642     todo_wine ok(resume, "Expected a resume handle\n");
1643     ok(GetLastError() == ERROR_MORE_DATA,
1644        "Expected ERROR_MORE_DATA, got %d\n", GetLastError());
1645
1646     /* Fetch that last service but pass a bigger buffer size */
1647     missing = tempreturned - returned;
1648     bufsize = tempneeded;
1649     needed = 0xdeadbeef;
1650     returned = 0xdeadbeef;
1651     SetLastError(0xdeadbeef);
1652     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1653                                  (BYTE*)exservices, bufsize, &needed, &returned, &resume, NULL);
1654     ok(ret, "Expected success, got error %u\n", GetLastError());
1655     ok(needed == 0, "Expected needed buffer to be 0 as we are done\n");
1656     ok(returned == missing, "Expected %u services to be returned\n", missing);
1657     ok(resume == 0, "Expected the resume handle to be 0\n");
1658     HeapFree(GetProcessHeap(), 0, exservices);
1659
1660     /* See if things add up */
1661
1662     /* Get the number of active win32 services */
1663     pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_ACTIVE,
1664                            NULL, 0, &needed, &returned, NULL, NULL);
1665     exservices = HeapAlloc(GetProcessHeap(), 0, needed);
1666     pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_ACTIVE,
1667                            (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
1668     HeapFree(GetProcessHeap(), 0, exservices);
1669
1670     servicecountactive = returned;
1671
1672     /* Get the number of inactive win32 services */
1673     pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_INACTIVE,
1674                            NULL, 0, &needed, &returned, NULL, NULL);
1675     exservices = HeapAlloc(GetProcessHeap(), 0, needed);
1676     pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_INACTIVE,
1677                            (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
1678     HeapFree(GetProcessHeap(), 0, exservices);
1679
1680     servicecountinactive = returned;
1681
1682     /* Get the number of win32 services */
1683     pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1684                            NULL, 0, &needed, &returned, NULL, NULL);
1685     exservices = HeapAlloc(GetProcessHeap(), 0, needed);
1686     pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32, SERVICE_STATE_ALL,
1687                            (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
1688     HeapFree(GetProcessHeap(), 0, exservices);
1689
1690     /* Check if total is the same as active and inactive win32 services */
1691     ok(returned == (servicecountactive + servicecountinactive),
1692        "Something wrong in the calculation\n");
1693
1694     /* Get all drivers and services */
1695     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32 | SERVICE_DRIVER,
1696                                  SERVICE_STATE_ALL, NULL, 0, &needed, &returned, NULL, NULL);
1697     ok(!ret, "Expected failure\n");
1698     exservices = HeapAlloc(GetProcessHeap(), 0, needed);
1699     ret = pEnumServicesStatusExA(scm_handle, 0, SERVICE_WIN32 | SERVICE_DRIVER,
1700                                  SERVICE_STATE_ALL, (BYTE*)exservices, needed, &needed, &returned, NULL, NULL);
1701     ok(ret, "Expected success %u\n", GetLastError());
1702
1703     /* Loop through all those returned drivers and services */
1704     for (i = 0; i < returned; i++)
1705     {
1706         SERVICE_STATUS_PROCESS status = exservices[i].ServiceStatusProcess;
1707
1708         /* lpServiceName and lpDisplayName should always be filled */
1709         ok(exservices[i].lpServiceName[0], "Expected a service name\n");
1710         ok(exservices[i].lpDisplayName[0], "Expected a display name\n");
1711
1712         /* Decrement the counters to see if the functions calls return the
1713          * same numbers as the contents of these structures.
1714          * Check some process id specifics.
1715          */
1716         if (status.dwServiceType & (SERVICE_FILE_SYSTEM_DRIVER | SERVICE_KERNEL_DRIVER))
1717         {
1718             /* We shouldn't have a process id for drivers */
1719             ok(status.dwProcessId == 0,
1720                "This driver shouldn't have an associated process id\n");
1721         }
1722
1723         if (status.dwServiceType & (SERVICE_WIN32_OWN_PROCESS | SERVICE_WIN32_SHARE_PROCESS))
1724         {
1725             if (status.dwCurrentState != SERVICE_STOPPED)
1726             {
1727                 /* We expect a process id for every running service */
1728                 ok(status.dwProcessId > 0, "Expected a process id for this running service (%s)\n",
1729                    exservices[i].lpServiceName);
1730
1731                 servicecountactive--;
1732             }
1733             else
1734             {
1735                 /* We shouldn't have a process id for inactive services */
1736                 ok(status.dwProcessId == 0, "Service %s state %u shouldn't have an associated process id\n",
1737                    exservices[i].lpServiceName, status.dwCurrentState);
1738
1739                 servicecountinactive--;
1740             }
1741         }
1742     }
1743     HeapFree(GetProcessHeap(), 0, exservices);
1744
1745     ok(servicecountactive == 0, "Active services mismatch %u\n", servicecountactive);
1746     ok(servicecountinactive == 0, "Inactive services mismatch %u\n", servicecountinactive);
1747
1748     CloseServiceHandle(scm_handle);
1749 }
1750
1751 static void test_close(void)
1752 {
1753     SC_HANDLE handle;
1754     BOOL ret;
1755
1756     /* NULL handle */
1757     SetLastError(0xdeadbeef);
1758     ret = CloseServiceHandle(NULL);
1759     ok(!ret, "Expected failure\n");
1760     ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
1761
1762     /* TODO: Add some tests with invalid handles. These produce errors on Windows but crash on Wine */
1763
1764     /* Proper call */
1765     handle = OpenSCManagerA(NULL, NULL, SC_MANAGER_CONNECT);
1766     SetLastError(0xdeadbeef);
1767     ret = CloseServiceHandle(handle);
1768     ok(ret, "Expected success got error %u\n", GetLastError());
1769 }
1770
1771 static void test_sequence(void)
1772 {
1773     SC_HANDLE scm_handle, svc_handle;
1774     BOOL ret, is_nt4;
1775     QUERY_SERVICE_CONFIGA *config;
1776     DWORD given, needed;
1777     static const CHAR servicename [] = "Winetest";
1778     static const CHAR displayname [] = "Winetest dummy service";
1779     static const CHAR displayname2[] = "Winetest dummy service (2)";
1780     static const CHAR pathname    [] = "we_dont_care.exe";
1781     static const CHAR dependencies[] = "Master1\0Master2\0+MasterGroup1\0";
1782     static const CHAR password    [] = "";
1783     static const CHAR empty       [] = "";
1784     static const CHAR localsystem [] = "LocalSystem";
1785
1786     SetLastError(0xdeadbeef);
1787     scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL);
1788
1789     if (!scm_handle && (GetLastError() == ERROR_ACCESS_DENIED))
1790     {
1791         skip("Not enough rights to get a handle to the manager\n");
1792         return;
1793     }
1794     else
1795         ok(scm_handle != NULL, "Could not get a handle to the manager: %d\n", GetLastError());
1796
1797     if (!scm_handle) return;
1798     svc_handle = OpenServiceA(scm_handle, NULL, GENERIC_READ);
1799     is_nt4=(svc_handle == NULL && GetLastError() == ERROR_INVALID_PARAMETER);
1800     CloseServiceHandle(svc_handle);
1801
1802     /* Create a dummy service */
1803     SetLastError(0xdeadbeef);
1804     svc_handle = CreateServiceA(scm_handle, servicename, displayname, GENERIC_ALL,
1805         SERVICE_INTERACTIVE_PROCESS | SERVICE_WIN32_OWN_PROCESS, SERVICE_DISABLED, SERVICE_ERROR_IGNORE,
1806         pathname, NULL, NULL, dependencies, NULL, password);
1807
1808     if (!svc_handle && (GetLastError() == ERROR_SERVICE_EXISTS))
1809     {
1810         /* We try and open the service and do the rest of the tests. Some could
1811          * fail if the tests were changed between these runs.
1812          */
1813         trace("Deletion probably didn't work last time\n");
1814         SetLastError(0xdeadbeef);
1815         svc_handle = OpenServiceA(scm_handle, servicename, GENERIC_ALL);
1816         if (!svc_handle && (GetLastError() == ERROR_ACCESS_DENIED))
1817         {
1818             skip("Not enough rights to open the service\n");
1819             CloseServiceHandle(scm_handle);
1820             return;
1821         }
1822         ok(svc_handle != NULL, "Could not open the service : %d\n", GetLastError());
1823     }
1824     else if (!svc_handle && (GetLastError() == ERROR_ACCESS_DENIED))
1825     {
1826         skip("Not enough rights to create the service\n");
1827         CloseServiceHandle(scm_handle);
1828         return;
1829     }
1830     else
1831     {
1832         ok(svc_handle != NULL, "Could not create the service : %d\n", GetLastError());
1833         if ((svc_handle != NULL) && (pGetSecurityInfo != NULL))
1834         {
1835             PSID sidOwner, sidGroup;
1836             PACL dacl, sacl;
1837             PSECURITY_DESCRIPTOR pSD;
1838             DWORD error, n1, n2;
1839             HRESULT retval;
1840             BOOL bret;
1841
1842             /* Test using GetSecurityInfo to obtain security information */
1843             retval = pGetSecurityInfo(svc_handle, SE_SERVICE, DACL_SECURITY_INFORMATION, &sidOwner,
1844                                       &sidGroup, &dacl, &sacl, &pSD);
1845             LocalFree(pSD);
1846             ok(retval == ERROR_SUCCESS, "Expected GetSecurityInfo to succeed: result %d\n", retval);
1847             retval = pGetSecurityInfo(svc_handle, SE_SERVICE, DACL_SECURITY_INFORMATION, NULL,
1848                                       NULL, NULL, NULL, &pSD);
1849             LocalFree(pSD);
1850             ok(retval == ERROR_SUCCESS, "Expected GetSecurityInfo to succeed: result %d\n", retval);
1851             if (!is_nt4)
1852             {
1853                 retval = pGetSecurityInfo(svc_handle, SE_SERVICE, DACL_SECURITY_INFORMATION, NULL,
1854                                           NULL, &dacl, NULL, &pSD);
1855                 ok(retval == ERROR_SUCCESS, "Expected GetSecurityInfo to succeed: result %d\n", retval);
1856                 LocalFree(pSD);
1857                 SetLastError(0xdeadbeef);
1858                 retval = pGetSecurityInfo(svc_handle, SE_SERVICE, DACL_SECURITY_INFORMATION, NULL,
1859                                           NULL, NULL, NULL, NULL);
1860                 error = GetLastError();
1861                 ok(retval == ERROR_INVALID_PARAMETER, "Expected GetSecurityInfo to fail: result %d\n", retval);
1862                 ok(error == 0xdeadbeef, "Unexpected last error %d\n", error);
1863             }
1864             else
1865                 win_skip("A NULL security descriptor in GetSecurityInfo results in an exception on NT4.\n");
1866
1867             /* Test using QueryServiceObjectSecurity to obtain security information */
1868             SetLastError(0xdeadbeef);
1869             bret = pQueryServiceObjectSecurity(svc_handle, DACL_SECURITY_INFORMATION, NULL, 0, &n1);
1870             error = GetLastError();
1871             ok(!bret, "Expected QueryServiceObjectSecurity to fail: result %d\n", bret);
1872             ok(error == ERROR_INSUFFICIENT_BUFFER ||
1873                broken(error == ERROR_INVALID_ADDRESS) || broken(error == ERROR_INVALID_PARAMETER),
1874                "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", error);
1875             if (error != ERROR_INSUFFICIENT_BUFFER) n1 = 1024;
1876             pSD = LocalAlloc(0, n1);
1877             bret = pQueryServiceObjectSecurity(svc_handle, DACL_SECURITY_INFORMATION, pSD, n1, &n2);
1878             ok(bret, "Expected QueryServiceObjectSecurity to succeed: result %d\n", bret);
1879             LocalFree(pSD);
1880         }
1881     }
1882
1883     if (!svc_handle) {
1884         CloseServiceHandle(scm_handle);
1885         return;
1886     }
1887
1888     /* TODO:
1889      * Before we do a QueryServiceConfig we should check the registry. This will make sure
1890      * that the correct keys are used.
1891      */
1892
1893     /* Request the size for the buffer */
1894     SetLastError(0xdeadbeef);
1895     ret = QueryServiceConfigA(svc_handle, NULL, 0, &needed);
1896     ok(!ret, "Expected failure\n");
1897     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
1898
1899     config = HeapAlloc(GetProcessHeap(), 0, needed);
1900     given = needed;
1901     SetLastError(0xdeadbeef);
1902     ret = QueryServiceConfigA(svc_handle, config, given, &needed);
1903     ok(ret, "Expected success, got error %u\n", GetLastError());
1904
1905     ok(config->lpBinaryPathName && config->lpLoadOrderGroup && config->lpDependencies && config->lpServiceStartName &&
1906         config->lpDisplayName, "Expected all string struct members to be non-NULL\n");
1907     ok(config->dwServiceType == (SERVICE_INTERACTIVE_PROCESS | SERVICE_WIN32_OWN_PROCESS),
1908         "Expected SERVICE_INTERACTIVE_PROCESS | SERVICE_WIN32_OWN_PROCESS, got %d\n", config->dwServiceType);
1909     ok(config->dwStartType == SERVICE_DISABLED, "Expected SERVICE_DISABLED, got %d\n", config->dwStartType);
1910     ok(config->dwErrorControl == SERVICE_ERROR_IGNORE, "Expected SERVICE_ERROR_IGNORE, got %d\n", config->dwErrorControl);
1911     ok(!strcmp(config->lpBinaryPathName, pathname), "Expected '%s', got '%s'\n", pathname, config->lpBinaryPathName);
1912     ok(!strcmp(config->lpLoadOrderGroup, empty), "Expected an empty string, got '%s'\n", config->lpLoadOrderGroup);
1913     ok(config->dwTagId == 0, "Expected 0, got %d\n", config->dwTagId);
1914     /* TODO: Show the double 0 terminated string */
1915     todo_wine
1916     {
1917     ok(!memcmp(config->lpDependencies, dependencies, sizeof(dependencies)), "Wrong string\n");
1918     }
1919     ok(!strcmp(config->lpServiceStartName, localsystem), "Expected 'LocalSystem', got '%s'\n", config->lpServiceStartName);
1920     ok(!strcmp(config->lpDisplayName, displayname), "Expected '%s', got '%s'\n", displayname, config->lpDisplayName);
1921
1922     ret = ChangeServiceConfigA(svc_handle, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, SERVICE_ERROR_NORMAL, NULL, "TestGroup2",
1923                                NULL, NULL, NULL, NULL, displayname2);
1924     ok(ret, "ChangeServiceConfig failed (err=%d)\n", GetLastError());
1925
1926     QueryServiceConfigA(svc_handle, NULL, 0, &needed);
1927     config = HeapReAlloc(GetProcessHeap(), 0, config, needed);
1928     ok(QueryServiceConfigA(svc_handle, config, needed, &needed), "QueryServiceConfig failed\n");
1929     ok(config->lpBinaryPathName && config->lpLoadOrderGroup && config->lpDependencies && config->lpServiceStartName &&
1930         config->lpDisplayName, "Expected all string struct members to be non-NULL\n");
1931     ok(config->dwServiceType == (SERVICE_INTERACTIVE_PROCESS | SERVICE_WIN32_OWN_PROCESS),
1932         "Expected SERVICE_INTERACTIVE_PROCESS | SERVICE_WIN32_OWN_PROCESS, got %d\n", config->dwServiceType);
1933     ok(config->dwStartType == SERVICE_DISABLED, "Expected SERVICE_DISABLED, got %d\n", config->dwStartType);
1934     ok(config->dwErrorControl == SERVICE_ERROR_NORMAL, "Expected SERVICE_ERROR_NORMAL, got %d\n", config->dwErrorControl);
1935     ok(!strcmp(config->lpBinaryPathName, pathname), "Expected '%s', got '%s'\n", pathname, config->lpBinaryPathName);
1936     ok(!strcmp(config->lpLoadOrderGroup, "TestGroup2"), "Expected 'TestGroup2', got '%s'\n", config->lpLoadOrderGroup);
1937     ok(config->dwTagId == 0, "Expected 0, got %d\n", config->dwTagId);
1938     ok(!strcmp(config->lpServiceStartName, localsystem), "Expected 'LocalSystem', got '%s'\n", config->lpServiceStartName);
1939     ok(!strcmp(config->lpDisplayName, displayname2), "Expected '%s', got '%s'\n", displayname2, config->lpDisplayName);
1940
1941     SetLastError(0xdeadbeef);
1942     ret = DeleteService(svc_handle);
1943     ok(ret, "Expected success, got error %u\n", GetLastError());
1944     CloseServiceHandle(svc_handle);
1945
1946     /* Wait a while. The following test does a CreateService again */
1947     Sleep(1000);
1948
1949     CloseServiceHandle(scm_handle);
1950     HeapFree(GetProcessHeap(), 0, config);
1951 }
1952
1953 static void test_queryconfig2(void)
1954 {
1955     SC_HANDLE scm_handle, svc_handle;
1956     BOOL ret;
1957     DWORD expected, needed;
1958     BYTE buffer[MAX_PATH];
1959     LPSERVICE_DESCRIPTIONA pConfig = (LPSERVICE_DESCRIPTIONA)buffer;
1960     SERVICE_PRESHUTDOWN_INFO preshutdown_info;
1961     static const CHAR servicename [] = "Winetest";
1962     static const CHAR displayname [] = "Winetest dummy service";
1963     static const CHAR pathname    [] = "we_dont_care.exe";
1964     static const CHAR dependencies[] = "Master1\0Master2\0+MasterGroup1\0";
1965     static const CHAR password    [] = "";
1966     static const CHAR description [] = "Description";
1967
1968     if(!pQueryServiceConfig2A)
1969     {
1970         win_skip("function QueryServiceConfig2A not present\n");
1971         return;
1972     }
1973
1974     SetLastError(0xdeadbeef);
1975     scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL);
1976
1977     if (!scm_handle)
1978     {
1979         if(GetLastError() == ERROR_ACCESS_DENIED)
1980             skip("Not enough rights to get a handle to the manager\n");
1981         else
1982             ok(FALSE, "Could not get a handle to the manager: %d\n", GetLastError());
1983         return;
1984     }
1985
1986     /* Create a dummy service */
1987     SetLastError(0xdeadbeef);
1988     svc_handle = CreateServiceA(scm_handle, servicename, displayname, GENERIC_ALL,
1989         SERVICE_INTERACTIVE_PROCESS | SERVICE_WIN32_OWN_PROCESS, SERVICE_DISABLED, SERVICE_ERROR_IGNORE,
1990         pathname, NULL, NULL, dependencies, NULL, password);
1991
1992     if (!svc_handle)
1993     {
1994         if(GetLastError() == ERROR_SERVICE_EXISTS)
1995         {
1996             /* We try and open the service and do the rest of the tests. Some could
1997              * fail if the tests were changed between these runs.
1998              */
1999             trace("Deletion probably didn't work last time\n");
2000             SetLastError(0xdeadbeef);
2001             svc_handle = OpenServiceA(scm_handle, servicename, GENERIC_ALL);
2002             if (!svc_handle)
2003             {
2004                 if(GetLastError() == ERROR_ACCESS_DENIED)
2005                     skip("Not enough rights to open the service\n");
2006                 else
2007                     ok(FALSE, "Could not open the service : %d\n", GetLastError());
2008                 CloseServiceHandle(scm_handle);
2009                 return;
2010             }
2011         }
2012         if (GetLastError() == ERROR_ACCESS_DENIED)
2013         {
2014             skip("Not enough rights to create the service\n");
2015             CloseServiceHandle(scm_handle);
2016             return;
2017         }
2018         ok(svc_handle != NULL, "Could not create the service : %d\n", GetLastError());
2019         if (!svc_handle)
2020         {
2021             CloseServiceHandle(scm_handle);
2022             return;
2023         }
2024     }
2025     SetLastError(0xdeadbeef);
2026     ret = pQueryServiceConfig2A(svc_handle,0xfff0,buffer,sizeof(SERVICE_DESCRIPTIONA),&needed);
2027     ok(!ret, "expected QueryServiceConfig2A to fail\n");
2028     ok(ERROR_INVALID_LEVEL == GetLastError(), "expected error ERROR_INVALID_LEVEL, got %d\n", GetLastError());
2029
2030     SetLastError(0xdeadbeef);
2031     ret = pQueryServiceConfig2A(svc_handle,0xfff0,buffer,sizeof(SERVICE_DESCRIPTIONA),NULL);
2032     ok(!ret, "expected QueryServiceConfig2A to fail\n");
2033     ok(ERROR_INVALID_LEVEL == GetLastError(), "expected error ERROR_INVALID_LEVEL, got %d\n", GetLastError());
2034
2035     SetLastError(0xdeadbeef);
2036     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,buffer,sizeof(SERVICE_DESCRIPTIONA),NULL);
2037     ok(!ret, "expected QueryServiceConfig2A to fail\n");
2038     ok(ERROR_INVALID_ADDRESS == GetLastError(), "expected error ERROR_INVALID_ADDRESS, got %d\n", GetLastError());
2039
2040     SetLastError(0xdeadbeef);
2041     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,NULL,sizeof(SERVICE_DESCRIPTIONA),&needed);
2042     ok(!ret, "expected QueryServiceConfig2A to fail\n");
2043     ok((ERROR_INVALID_ADDRESS == GetLastError()) || (ERROR_INSUFFICIENT_BUFFER == GetLastError()),
2044        "expected error ERROR_INVALID_ADDRESS or ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2045
2046     SetLastError(0xdeadbeef);
2047     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,NULL,sizeof(SERVICE_DESCRIPTIONA),NULL);
2048     ok(!ret, "expected QueryServiceConfig2A to fail\n");
2049     ok(ERROR_INVALID_ADDRESS == GetLastError(), "expected error ERROR_INVALID_ADDRESS, got %d\n", GetLastError());
2050
2051     needed = 0;
2052     SetLastError(0xdeadbeef);
2053     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,buffer,sizeof(SERVICE_DESCRIPTIONA)-1,&needed);
2054     ok(!ret, "expected QueryServiceConfig2A to fail\n");
2055     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(), "expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2056     ok(needed == sizeof(SERVICE_DESCRIPTIONA), "got %d\n", needed);
2057
2058     needed = 0;
2059     pConfig->lpDescription = (LPSTR)0xdeadbeef;
2060     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,buffer,sizeof(SERVICE_DESCRIPTIONA),&needed);
2061     ok(ret, "expected QueryServiceConfig2A to succeed\n");
2062     ok(needed == sizeof(SERVICE_DESCRIPTIONA), "got %d\n", needed);
2063     ok(!pConfig->lpDescription, "expected lpDescription to be NULL, got %p\n", pConfig->lpDescription);
2064
2065     SetLastError(0xdeadbeef);
2066     needed = 0;
2067     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,NULL,0,&needed);
2068     ok(!ret, "expected QueryServiceConfig2A to fail\n");
2069     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(), "expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2070     ok(needed == sizeof(SERVICE_DESCRIPTIONA), "got %d\n", needed);
2071
2072     if(!pChangeServiceConfig2A)
2073     {
2074         win_skip("function ChangeServiceConfig2A not present\n");
2075         goto cleanup;
2076     }
2077
2078     pConfig->lpDescription = (LPSTR) description;
2079     ret = pChangeServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,buffer);
2080     ok(ret, "ChangeServiceConfig2A failed\n");
2081     if (!ret) {
2082         goto cleanup;
2083     }
2084
2085     SetLastError(0xdeadbeef);
2086     needed = 0;
2087     expected = sizeof(SERVICE_DESCRIPTIONA) + sizeof(description) * sizeof(WCHAR); /* !! */
2088     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,buffer,sizeof(SERVICE_DESCRIPTIONA),&needed);
2089     ok(!ret, "expected QueryServiceConfig2A to fail\n");
2090     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(), "expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2091     ok(needed == expected, "expected needed to be %d, got %d\n", expected, needed);
2092
2093     SetLastError(0xdeadbeef);
2094     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,buffer,needed-1,&needed);
2095     ok(!ret, "expected QueryServiceConfig2A to fail\n");
2096     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(), "expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2097
2098     SetLastError(0xdeadbeef);
2099     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,buffer,needed,&needed);
2100     ok(ret, "expected QueryServiceConfig2A to succeed\n");
2101     ok(pConfig->lpDescription && !strcmp(description,pConfig->lpDescription),
2102         "expected lpDescription to be %s, got %s\n",description ,pConfig->lpDescription);
2103
2104     SetLastError(0xdeadbeef);
2105     ret = pQueryServiceConfig2A(svc_handle, SERVICE_CONFIG_DESCRIPTION,buffer, needed + 1,&needed);
2106     ok(ret, "expected QueryServiceConfig2A to succeed\n");
2107     ok(pConfig->lpDescription && !strcmp(description,pConfig->lpDescription),
2108         "expected lpDescription to be %s, got %s\n",description ,pConfig->lpDescription);
2109
2110     if(!pQueryServiceConfig2W)
2111     {
2112         win_skip("function QueryServiceConfig2W not present\n");
2113         goto cleanup;
2114     }
2115     SetLastError(0xdeadbeef);
2116     needed = 0;
2117     expected = sizeof(SERVICE_DESCRIPTIONW) + sizeof(WCHAR) * sizeof(description);
2118     ret = pQueryServiceConfig2W(svc_handle, SERVICE_CONFIG_DESCRIPTION,NULL,0,&needed);
2119     ok(!ret, "expected QueryServiceConfig2W to fail\n");
2120     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(), "expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
2121     ok(needed == expected, "expected needed to be %d, got %d\n", expected, needed);
2122
2123     SetLastError(0xdeadbeef);
2124     ret = pQueryServiceConfig2W(svc_handle, SERVICE_CONFIG_DESCRIPTION,buffer, needed,&needed);
2125     ok(ret, "expected QueryServiceConfig2W to succeed\n");
2126
2127     SetLastError(0xdeadbeef);
2128     ret = pQueryServiceConfig2W(svc_handle, SERVICE_CONFIG_PRESHUTDOWN_INFO,
2129             (LPBYTE)&preshutdown_info, sizeof(preshutdown_info), &needed);
2130     if(!ret && GetLastError()==ERROR_INVALID_LEVEL)
2131     {
2132         /* Win2k3 and older */
2133         win_skip("SERVICE_CONFIG_PRESHUTDOWN_INFO not supported\n");
2134         goto cleanup;
2135     }
2136     ok(ret, "expected QueryServiceConfig2W to succeed (%d)\n", GetLastError());
2137     ok(needed == sizeof(preshutdown_info), "needed = %d\n", needed);
2138     ok(preshutdown_info.dwPreshutdownTimeout == 180000, "Default PreshutdownTimeout = %d\n",
2139             preshutdown_info.dwPreshutdownTimeout);
2140
2141     SetLastError(0xdeadbeef);
2142     preshutdown_info.dwPreshutdownTimeout = -1;
2143     ret = pChangeServiceConfig2A(svc_handle, SERVICE_CONFIG_PRESHUTDOWN_INFO,
2144             (LPVOID)&preshutdown_info);
2145     ok(ret, "expected ChangeServiceConfig2A to succeed (%d)\n", GetLastError());
2146
2147     ret = pQueryServiceConfig2W(svc_handle, SERVICE_CONFIG_PRESHUTDOWN_INFO,
2148             (LPBYTE)&preshutdown_info, sizeof(preshutdown_info), &needed);
2149     ok(ret, "expected QueryServiceConfig2W to succeed (%d)\n", GetLastError());
2150     ok(needed == sizeof(preshutdown_info), "needed = %d\n", needed);
2151     ok(preshutdown_info.dwPreshutdownTimeout == -1, "New PreshutdownTimeout = %d\n",
2152             preshutdown_info.dwPreshutdownTimeout);
2153
2154 cleanup:
2155     DeleteService(svc_handle);
2156
2157     CloseServiceHandle(svc_handle);
2158
2159     /* Wait a while. The following test does a CreateService again */
2160     Sleep(1000);
2161
2162     CloseServiceHandle(scm_handle);
2163 }
2164
2165 static DWORD try_start_stop(SC_HANDLE svc_handle, const char* name, DWORD is_nt4)
2166 {
2167     BOOL ret;
2168     DWORD le1, le2;
2169     SERVICE_STATUS status;
2170
2171 #ifdef __REACTOS__
2172     fprintf(stdout, "ROSTESTS-56: Hello sysreg, I am awake\n");
2173 #endif
2174     ret = StartServiceA(svc_handle, 0, NULL);
2175     le1 = GetLastError();
2176     ok(!ret, "%s: StartServiceA() should have failed\n", name);
2177
2178     if (pQueryServiceStatusEx)
2179     {
2180         DWORD needed;
2181         SERVICE_STATUS_PROCESS statusproc;
2182
2183         ret = pQueryServiceStatusEx(svc_handle, SC_STATUS_PROCESS_INFO, (BYTE*)&statusproc, sizeof(statusproc), &needed);
2184         ok(ret, "%s: QueryServiceStatusEx() failed le=%u\n", name, GetLastError());
2185         ok(statusproc.dwCurrentState == SERVICE_STOPPED, "%s: should be stopped state=%x\n", name, statusproc.dwCurrentState);
2186         ok(statusproc.dwProcessId == 0, "%s: ProcessId should be 0 instead of %x\n", name, statusproc.dwProcessId);
2187     }
2188
2189     ret = StartServiceA(svc_handle, 0, NULL);
2190     le2 = GetLastError();
2191     ok(!ret, "%s: StartServiceA() should have failed\n", name);
2192     ok(le2 == le1, "%s: the second try should yield the same error: %u != %u\n", name, le1, le2);
2193
2194     status.dwCurrentState = 0xdeadbeef;
2195     ret = ControlService(svc_handle, SERVICE_CONTROL_STOP, &status);
2196     le2 = GetLastError();
2197     ok(!ret, "%s: ControlService() should have failed\n", name);
2198     ok(le2 == ERROR_SERVICE_NOT_ACTIVE, "%s: %d != ERROR_SERVICE_NOT_ACTIVE\n", name, le2);
2199     ok(status.dwCurrentState == SERVICE_STOPPED ||
2200        broken(is_nt4), /* NT4 returns a random value */
2201        "%s: should be stopped state=%x\n", name, status.dwCurrentState);
2202
2203     return le1;
2204 }
2205
2206 struct notify_data {
2207     SERVICE_NOTIFYW notify;
2208     SC_HANDLE svc;
2209 };
2210
2211 static void CALLBACK cb_stopped(void *user)
2212 {
2213     struct notify_data *data = user;
2214     BOOL br;
2215
2216     ok(data->notify.dwNotificationStatus == ERROR_SUCCESS,
2217             "Got wrong notification status: %u\n", data->notify.dwNotificationStatus);
2218     ok(data->notify.ServiceStatus.dwCurrentState == SERVICE_STOPPED,
2219             "Got wrong service state: 0x%x\n", data->notify.ServiceStatus.dwCurrentState);
2220     ok(data->notify.dwNotificationTriggered == SERVICE_NOTIFY_STOPPED,
2221             "Got wrong notification triggered: 0x%x\n", data->notify.dwNotificationTriggered);
2222
2223     br = StartServiceA(data->svc, 0, NULL);
2224     ok(br, "StartService failed: %u\n", GetLastError());
2225 }
2226
2227 static void CALLBACK cb_running(void *user)
2228 {
2229     struct notify_data *data = user;
2230     BOOL br;
2231     SERVICE_STATUS status;
2232
2233     ok(data->notify.dwNotificationStatus == ERROR_SUCCESS,
2234             "Got wrong notification status: %u\n", data->notify.dwNotificationStatus);
2235     ok(data->notify.ServiceStatus.dwCurrentState == SERVICE_RUNNING,
2236             "Got wrong service state: 0x%x\n", data->notify.ServiceStatus.dwCurrentState);
2237     ok(data->notify.dwNotificationTriggered == SERVICE_NOTIFY_RUNNING,
2238             "Got wrong notification triggered: 0x%x\n", data->notify.dwNotificationTriggered);
2239
2240     br = ControlService(data->svc, SERVICE_CONTROL_STOP, &status);
2241     ok(br, "ControlService failed: %u\n", GetLastError());
2242 }
2243
2244 static void test_servicenotify(SC_HANDLE svc)
2245 {
2246     DWORD dr;
2247     struct notify_data data;
2248
2249     if(!pNotifyServiceStatusChangeW){
2250         win_skip("No NotifyServiceStatusChangeW\n");
2251         return;
2252     }
2253
2254     memset(&data.notify, 0, sizeof(data.notify));
2255     data.notify.dwVersion = SERVICE_NOTIFY_STATUS_CHANGE;
2256     data.notify.pfnNotifyCallback = &cb_stopped;
2257     data.notify.pContext = &data;
2258     data.svc = svc;
2259
2260     dr = pNotifyServiceStatusChangeW(svc, SERVICE_NOTIFY_STOPPED | SERVICE_NOTIFY_RUNNING, &data.notify);
2261     ok(dr == ERROR_SUCCESS, "NotifyServiceStatusChangeW failed: %u\n", dr);
2262
2263     dr = SleepEx(100, TRUE);
2264     ok(dr == WAIT_IO_COMPLETION, "APC wasn't called\n");
2265
2266     data.notify.pfnNotifyCallback = &cb_running;
2267
2268     dr = pNotifyServiceStatusChangeW(svc, SERVICE_NOTIFY_STOPPED | SERVICE_NOTIFY_RUNNING, &data.notify);
2269     ok(dr == ERROR_SUCCESS, "NotifyServiceStatusChangeW failed: %u\n", dr);
2270
2271     dr = SleepEx(100, TRUE);
2272     ok(dr == WAIT_IO_COMPLETION, "APC wasn't called\n");
2273 }
2274
2275 static void test_start_stop(void)
2276 {
2277     BOOL ret;
2278     SC_HANDLE scm_handle, svc_handle;
2279     DWORD le, is_nt4;
2280     static const char servicename[] = "Winetest";
2281     char cmd[MAX_PATH+20];
2282     const char* displayname;
2283
2284     SetLastError(0xdeadbeef);
2285     scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL);
2286     if (!scm_handle)
2287     {
2288         if(GetLastError() == ERROR_ACCESS_DENIED)
2289             skip("Not enough rights to get a handle to the manager\n");
2290         else
2291             ok(FALSE, "Could not get a handle to the manager: %d\n", GetLastError());
2292         return;
2293     }
2294
2295     /* Detect NT4 */
2296     svc_handle = OpenServiceA(scm_handle, NULL, GENERIC_READ);
2297     is_nt4=(svc_handle == NULL && GetLastError() == ERROR_INVALID_PARAMETER);
2298
2299     /* Do some cleanup in case a previous run crashed */
2300     svc_handle = OpenServiceA(scm_handle, servicename, GENERIC_ALL);
2301     if (svc_handle)
2302     {
2303         DeleteService(svc_handle);
2304         CloseServiceHandle(svc_handle);
2305     }
2306
2307     /* Create a dummy disabled service */
2308     sprintf(cmd, "\"%s\" service exit", selfname);
2309     displayname = "Winetest Disabled Service";
2310     svc_handle = CreateServiceA(scm_handle, servicename, displayname,
2311         GENERIC_ALL, SERVICE_INTERACTIVE_PROCESS | SERVICE_WIN32_OWN_PROCESS,
2312         SERVICE_DISABLED, SERVICE_ERROR_IGNORE, cmd, NULL,
2313         NULL, NULL, NULL, NULL);
2314     if (!svc_handle)
2315     {
2316         if(GetLastError() == ERROR_ACCESS_DENIED)
2317             skip("Not enough rights to create the service\n");
2318         else
2319             ok(FALSE, "Could not create the service: %d\n", GetLastError());
2320         goto cleanup;
2321     }
2322     le = try_start_stop(svc_handle, displayname, is_nt4);
2323     ok(le == ERROR_SERVICE_DISABLED, "%d != ERROR_SERVICE_DISABLED\n", le);
2324
2325     /* Then one with a bad path */
2326     displayname = "Winetest Bad Path";
2327     ret = ChangeServiceConfigA(svc_handle, SERVICE_NO_CHANGE, SERVICE_DEMAND_START, SERVICE_NO_CHANGE, "c:\\no_such_file.exe", NULL, NULL, NULL, NULL, NULL, displayname);
2328     ok(ret, "ChangeServiceConfig() failed le=%u\n", GetLastError());
2329     try_start_stop(svc_handle, displayname, is_nt4);
2330
2331     if (is_nt4)
2332     {
2333         /* NT4 does not detect when a service fails to start and uses an
2334          * insanely long timeout: 120s. So skip the rest of the tests.
2335          */
2336         win_skip("Skip some service start/stop tests on NT4\n");
2337         goto cleanup;
2338     }
2339
2340     if (!winetest_interactive)
2341     {
2342         skip("ROSTESTS-151: Skipping service start timeout tests because they take too long. This is not a bug!\n");
2343         goto cleanup;
2344     }
2345
2346     /* Again with a process that exits right away */
2347     displayname = "Winetest Exit Service";
2348     ret = ChangeServiceConfigA(svc_handle, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, cmd, NULL, NULL, NULL, NULL, NULL, displayname);
2349     ok(ret, "ChangeServiceConfig() failed le=%u\n", GetLastError());
2350     le = try_start_stop(svc_handle, displayname, is_nt4);
2351     ok(le == ERROR_SERVICE_REQUEST_TIMEOUT, "%d != ERROR_SERVICE_REQUEST_TIMEOUT\n", le);
2352
2353     /* create a real service and test notifications */
2354     sprintf(cmd, "%s service serve", selfname);
2355     displayname = "Winetest Service";
2356     ret = ChangeServiceConfigA(svc_handle, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, cmd, NULL, NULL, NULL, NULL, NULL, displayname);
2357     ok(ret, "ChangeServiceConfig() failed le=%u\n", GetLastError());
2358     test_servicenotify(svc_handle);
2359
2360 cleanup:
2361     if (svc_handle)
2362     {
2363         DeleteService(svc_handle);
2364         CloseServiceHandle(svc_handle);
2365     }
2366
2367     /* Wait a while. The following test does a CreateService again */
2368     Sleep(1000);
2369
2370     CloseServiceHandle(scm_handle);
2371 }
2372
2373 static void test_refcount(void)
2374 {
2375     SC_HANDLE scm_handle, svc_handle1, svc_handle2, svc_handle3, svc_handle4, svc_handle5;
2376     static const CHAR servicename         [] = "Winetest";
2377     static const CHAR pathname            [] = "we_dont_care.exe";
2378     BOOL ret;
2379
2380     /* Get a handle to the Service Control Manager */
2381     SetLastError(0xdeadbeef);
2382     scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL);
2383     if (!scm_handle && (GetLastError() == ERROR_ACCESS_DENIED))
2384     {
2385         skip("Not enough rights to get a handle to the manager\n");
2386         return;
2387     }
2388
2389     /* Create a service */
2390     svc_handle1 = CreateServiceA(scm_handle, servicename, NULL, GENERIC_ALL,
2391                                  SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
2392                                  SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
2393     ok(svc_handle1 != NULL, "Expected success, got error %u\n", GetLastError());
2394
2395     /* Get a handle to this new service */
2396     svc_handle2 = OpenServiceA(scm_handle, servicename, GENERIC_READ);
2397     ok(svc_handle2 != NULL, "Expected success, got error %u\n", GetLastError());
2398
2399     /* Get another handle to this new service */
2400     svc_handle3 = OpenServiceA(scm_handle, servicename, GENERIC_READ);
2401     ok(svc_handle3 != NULL, "Expected success, got error %u\n", GetLastError());
2402
2403     /* Check if we can close the handle to the Service Control Manager */
2404     ret = CloseServiceHandle(scm_handle);
2405     ok(ret, "Expected success (err=%d)\n", GetLastError());
2406
2407     /* Get a new handle to the Service Control Manager */
2408     scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL);
2409     ok(scm_handle != NULL, "Expected success, got error %u\n", GetLastError());
2410
2411     /* Get a handle to this new service */
2412     svc_handle4 = OpenServiceA(scm_handle, servicename, GENERIC_ALL);
2413     ok(svc_handle4 != NULL, "Expected success, got error %u\n", GetLastError());
2414
2415     /* Delete the service */
2416     ret = DeleteService(svc_handle4);
2417     ok(ret, "Expected success (err=%d)\n", GetLastError());
2418
2419     /* We cannot create the same service again as it's still marked as 'being deleted'.
2420      * The reason is that we still have 4 open handles to this service even though we
2421      * closed the handle to the Service Control Manager in between.
2422      */
2423     SetLastError(0xdeadbeef);
2424     svc_handle5 = CreateServiceA(scm_handle, servicename, NULL, GENERIC_ALL,
2425                                  SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
2426                                  SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
2427     ok(!svc_handle5, "Expected failure\n");
2428     ok(GetLastError() == ERROR_SERVICE_MARKED_FOR_DELETE,
2429        "Expected ERROR_SERVICE_MARKED_FOR_DELETE, got %d\n", GetLastError());
2430
2431     /* Close all the handles to the service and try again */
2432     ret = CloseServiceHandle(svc_handle4);
2433     ok(ret, "Expected success (err=%d)\n", GetLastError());
2434     ret = CloseServiceHandle(svc_handle3);
2435     ok(ret, "Expected success (err=%d)\n", GetLastError());
2436     ret = CloseServiceHandle(svc_handle2);
2437     ok(ret, "Expected success (err=%d)\n", GetLastError());
2438     ret = CloseServiceHandle(svc_handle1);
2439     ok(ret, "Expected success (err=%d)\n", GetLastError());
2440
2441     /* Wait a while. Doing a CreateService too soon will result again
2442      * in an ERROR_SERVICE_MARKED_FOR_DELETE error.
2443      */
2444     Sleep(1000);
2445
2446     /* We succeed now as all handles are closed (tested this also with a long SLeep() */
2447     svc_handle5 = CreateServiceA(scm_handle, servicename, NULL, GENERIC_ALL,
2448                                  SERVICE_WIN32_OWN_PROCESS | SERVICE_INTERACTIVE_PROCESS,
2449                                  SERVICE_DISABLED, 0, pathname, NULL, NULL, NULL, NULL, NULL);
2450     ok(svc_handle5 != NULL, "Expected success, got error %u\n", GetLastError());
2451
2452     /* Delete the service */
2453     ret = DeleteService(svc_handle5);
2454     ok(ret, "Expected success (err=%d)\n", GetLastError());
2455
2456     /* Wait a while. Just in case one of the following tests does a CreateService again */
2457     Sleep(1000);
2458
2459     CloseServiceHandle(svc_handle5);
2460     CloseServiceHandle(scm_handle);
2461 }
2462
2463 static DWORD WINAPI ctrl_handler(DWORD ctl, DWORD type, void *data, void *user)
2464 {
2465     HANDLE evt = user;
2466
2467     switch(ctl){
2468     case SERVICE_CONTROL_STOP:
2469         SetEvent(evt);
2470         break;
2471     case SERVICE_CONTROL_INTERROGATE:
2472         return NO_ERROR;
2473     }
2474
2475     return ERROR_CALL_NOT_IMPLEMENTED;
2476 }
2477
2478 static void WINAPI service_main(DWORD argc, char **argv)
2479 {
2480     SERVICE_STATUS_HANDLE st_handle;
2481     SERVICE_STATUS st;
2482     HANDLE evt = CreateEventW(0, FALSE, FALSE, 0);
2483
2484     st_handle = RegisterServiceCtrlHandlerExA("", &ctrl_handler, evt);
2485
2486     st.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
2487     st.dwServiceSpecificExitCode = 0;
2488     st.dwCurrentState = SERVICE_RUNNING;
2489     st.dwWin32ExitCode = NO_ERROR;
2490     st.dwWaitHint = 0;
2491     st.dwControlsAccepted = SERVICE_ACCEPT_STOP;
2492     st.dwCheckPoint = 0;
2493
2494     SetServiceStatus(st_handle, &st);
2495
2496     WaitForSingleObject(evt, 5000);
2497
2498     st.dwCurrentState = SERVICE_STOPPED;
2499
2500     SetServiceStatus(st_handle, &st);
2501 }
2502
2503 static void run_service(void)
2504 {
2505     char empty[] = {0};
2506     SERVICE_TABLE_ENTRYA table[] = {
2507         {empty, &service_main },
2508         {0, 0}
2509     };
2510
2511     StartServiceCtrlDispatcherA(table);
2512 }
2513
2514 START_TEST(service)
2515 {
2516     SC_HANDLE scm_handle;
2517     int myARGC;
2518     char** myARGV;
2519
2520     myARGC = winetest_get_mainargs(&myARGV);
2521     GetFullPathNameA(myARGV[0], sizeof(selfname), selfname, NULL);
2522     if (myARGC >= 3)
2523     {
2524         if (strcmp(myARGV[2], "serve") == 0)
2525             run_service();
2526         return;
2527     }
2528
2529     /* Bail out if we are on win98 */
2530     SetLastError(0xdeadbeef);
2531     scm_handle = OpenSCManagerA(NULL, NULL, GENERIC_ALL);
2532
2533     if (!scm_handle && (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED))
2534     {
2535         win_skip("OpenSCManagerA is not implemented, we are most likely on win9x\n");
2536         return;
2537     }
2538     CloseServiceHandle(scm_handle);
2539
2540     init_function_pointers();
2541
2542     /* First some parameter checking */
2543     test_open_scm();
2544     test_open_svc();
2545     test_create_delete_svc();
2546     test_get_displayname();
2547     test_get_servicekeyname();
2548     test_query_svc();
2549     test_enum_svc();
2550     test_close();
2551     /* Test the creation, querying and deletion of a service */
2552     test_sequence();
2553     test_queryconfig2();
2554     test_start_stop();
2555     /* The main reason for this test is to check if any refcounting is used
2556      * and what the rules are
2557      */
2558     test_refcount();
2559 }