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