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