ReactOS 0.4.15-dev-8408-g466a198
QueryServiceConfig2.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS api tests
3 * LICENSE: GPLv2+ - See COPYING in the top level directory
4 * PURPOSE: Test for QueryServiceConfig2A/W
5 * PROGRAMMER: Hermès BÉLUSCA - MAÏTO
6 */
7
8#include "precomp.h"
9
10#define TESTING_SERVICEW L"Spooler"
11#define TESTING_SERVICEA "Spooler"
12
13/*
14 * Taken from base/system/services/config.c and adapted.
15 */
16static DWORD
18 LPWSTR lpValueName,
19 LPWSTR *lpValue)
20{
21 DWORD dwError;
23 DWORD dwType;
24
25 *lpValue = NULL;
26
27 dwSize = 0;
28 dwError = RegQueryValueExW(hKey,
29 lpValueName,
30 0,
31 &dwType,
32 NULL,
33 &dwSize);
34 if (dwError != ERROR_SUCCESS)
35 return dwError;
36
37 *lpValue = HeapAlloc(GetProcessHeap(), 0, dwSize);
38 if (*lpValue == NULL)
40
41 dwError = RegQueryValueExW(hKey,
42 lpValueName,
43 0,
44 &dwType,
45 (LPBYTE)*lpValue,
46 &dwSize);
47 if (dwError != ERROR_SUCCESS)
48 {
49 HeapFree(GetProcessHeap(), 0, *lpValue);
50 *lpValue = NULL;
51 }
52
53 return dwError;
54}
55
56static DWORD
58 LPSTR lpValueName,
59 LPSTR *lpValue)
60{
61 DWORD dwError;
63 DWORD dwType;
64
65 *lpValue = NULL;
66
67 dwSize = 0;
68 dwError = RegQueryValueExA(hKey,
69 lpValueName,
70 0,
71 &dwType,
72 NULL,
73 &dwSize);
74 if (dwError != ERROR_SUCCESS)
75 return dwError;
76
77 *lpValue = HeapAlloc(GetProcessHeap(), 0, dwSize);
78 if (*lpValue == NULL)
80
81 dwError = RegQueryValueExA(hKey,
82 lpValueName,
83 0,
84 &dwType,
85 (LPBYTE)*lpValue,
86 &dwSize);
87 if (dwError != ERROR_SUCCESS)
88 {
89 HeapFree(GetProcessHeap(), 0, *lpValue);
90 *lpValue = NULL;
91 }
92
93 return dwError;
94}
95
96
97static int QueryConfig2W(SC_HANDLE hService, LPCWSTR serviceName, DWORD dwInfoLevel)
98{
99 int iRet = 0;
100 LONG lRet = 0;
101 DWORD dwRet = 0;
102 BOOL bError = FALSE;
103 DWORD dwRequiredSize = 0;
105
106 WCHAR keyName[256];
107 HKEY hKey = NULL;
108 DWORD dwType = 0;
109
110 /* Get the needed size */
111 SetLastError(0xdeadbeef);
112 bError = QueryServiceConfig2W(hService,
114 NULL,
115 0,
116 &dwRequiredSize);
117 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
118 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
119 if (dwRequiredSize == 0)
120 {
121 skip("Required size is null; cannot proceed with QueryConfig2W --> %lu test\n", dwInfoLevel);
122 return 1;
123 }
124
125 /* Allocate memory */
127 if (lpBuffer == NULL)
128 {
129 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
130 return 2;
131 }
132
133 /* Get the actual value */
134 SetLastError(0xdeadbeef);
135 bError = QueryServiceConfig2W(hService,
137 lpBuffer,
138 dwRequiredSize,
139 &dwRequiredSize);
140 ok(bError, "bError = %u, expected TRUE\n", bError);
141 if (bError == FALSE)
142 {
143 skip("QueryServiceConfig2W returned an error; cannot proceed with QueryConfig2W --> %lu test\n", dwInfoLevel);
145 return 3;
146 }
147
148 /* Now we can compare the retrieved value with what it's actually stored in the registry */
149 StringCbPrintfW(keyName, sizeof(keyName), L"System\\CurrentControlSet\\Services\\%s", serviceName);
150 SetLastError(0xdeadbeef);
152 ok(lRet == ERROR_SUCCESS, "RegOpenKeyExW failed with 0x%08lx\n", lRet);
153 if (lRet != ERROR_SUCCESS)
154 {
155 skip("No regkey; cannot proceed with QueryConfig2W --> %lu test\n", dwInfoLevel);
157 return 4;
158 }
159
160 switch (dwInfoLevel)
161 {
163 {
165 LPWSTR lpszDescription = NULL;
166
167 /* Retrieve the description via the registry */
168 dwRet = RegReadStringW(hKey, L"Description", &lpszDescription);
169 ok(dwRet == ERROR_SUCCESS, "RegReadStringW returned 0x%08lx\n", dwRet);
170 ok(lpszDescription != NULL, "lpszDescription is null, expected non-null\n");
171
172 /* Compare it with the description retrieved via QueryServiceConfig2 */
173 if (lpszDescription)
174 iRet = wcscmp(lpDescription->lpDescription, lpszDescription);
175 else
176 iRet = 0;
177
178 ok(iRet == 0, "Retrieved descriptions are different !\n");
179
180
181 /* Memory cleanup */
182 HeapFree(GetProcessHeap(), 0, lpszDescription);
183
184 break;
185 }
186
188 {
190 LPSERVICE_FAILURE_ACTIONSW lpFailureActions2 = NULL;
191 LPWSTR lpRebootMessage = NULL;
192 LPWSTR lpFailureCommand = NULL;
193 DWORD i = 0;
194
195 /* Retrieve the failure actions via the registry */
196 lRet = RegQueryValueExW(hKey,
197 L"FailureActions",
198 NULL,
199 &dwType,
200 NULL,
201 &dwRequiredSize);
202 ok(lRet == ERROR_SUCCESS, "RegQueryValueExW returned 0x%08lx\n", lRet);
203 ok(dwType == REG_BINARY, "dwType = %lu, expected REG_BINARY\n", dwType);
204 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
205
206 lpFailureActions2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
207 if (lpFailureActions2 == NULL)
208 {
209 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
210 break;
211 }
212
213 lRet = RegQueryValueExW(hKey,
214 L"FailureActions",
215 NULL,
216 NULL,
217 (LPBYTE)lpFailureActions2,
218 &dwRequiredSize);
219 ok(lRet == ERROR_SUCCESS, "RegQueryValueExW returned 0x%08lx\n", lRet);
220 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
221
222 /* Get the strings */
223 RegReadStringW(hKey, L"FailureCommand", &lpFailureCommand);
224 RegReadStringW(hKey, L"RebootMessage" , &lpRebootMessage );
225
226 /* Check the values */
227 ok(lpFailureActions1->dwResetPeriod == lpFailureActions2->dwResetPeriod, "lpFailureActions1->dwResetPeriod != lpFailureActions2->dwResetPeriod\n");
228 ok(lpFailureActions1->cActions == lpFailureActions2->cActions, "lpFailureActions1->cActions != lpFailureActions2->cActions\n");
229
230 /* Compare the actions */
231 if (lpFailureActions1->cActions == lpFailureActions2->cActions)
232 {
233 lpFailureActions2->lpsaActions = (lpFailureActions2->cActions > 0 ? (LPSC_ACTION)(lpFailureActions2 + 1) : NULL);
234
235 if (lpFailureActions1->cActions > 0 &&
236 lpFailureActions1->lpsaActions != NULL)
237 {
238 for (i = 0; i < lpFailureActions1->cActions; ++i)
239 {
240 ok(lpFailureActions1->lpsaActions[i].Type == lpFailureActions2->lpsaActions[i].Type , "lpFailureActions1->lpsaActions[%lu].Type != lpFailureActions2->lpsaActions[%lu].Type\n" , i, i);
241 ok(lpFailureActions1->lpsaActions[i].Delay == lpFailureActions2->lpsaActions[i].Delay, "lpFailureActions1->lpsaActions[%lu].Delay != lpFailureActions2->lpsaActions[%lu].Delay\n", i, i);
242 }
243 }
244 }
245
246 /* TODO: retrieve the strings if they are in MUI format */
247
248 /* Compare RebootMsg */
249 if (lpFailureActions1->lpRebootMsg && lpRebootMessage)
250 iRet = wcscmp(lpFailureActions1->lpRebootMsg, lpRebootMessage);
251 else
252 iRet = 0;
253
254 ok(iRet == 0, "Retrieved reboot messages are different !\n");
255
256 /* Compare Command */
257 if (lpFailureActions1->lpCommand && lpFailureCommand)
258 iRet = wcscmp(lpFailureActions1->lpCommand, lpFailureCommand);
259 else
260 iRet = 0;
261
262 ok(iRet == 0, "Retrieved commands are different !\n");
263
264
265 /* Memory cleanup */
266 if (lpRebootMessage)
267 HeapFree(GetProcessHeap(), 0, lpRebootMessage);
268
269 if (lpFailureCommand)
270 HeapFree(GetProcessHeap(), 0, lpFailureCommand);
271
272 HeapFree(GetProcessHeap(), 0, lpFailureActions2);
273
274 break;
275 }
276
277 default:
278 skip("Unknown dwInfoLevel %lu, cannot proceed with QueryConfig2W --> %lu test\n", dwInfoLevel, dwInfoLevel);
279 break;
280 }
281
283
285
286 return 0;
287}
288
289static int QueryConfig2A(SC_HANDLE hService, LPCSTR serviceName, DWORD dwInfoLevel)
290{
291 int iRet = 0;
292 LONG lRet = 0;
293 DWORD dwRet = 0;
294 BOOL bError = FALSE;
295 DWORD dwRequiredSize = 0;
297
298 CHAR keyName[256];
299 HKEY hKey = NULL;
300 DWORD dwType = 0;
301
302 /* Get the needed size */
303 SetLastError(0xdeadbeef);
304 bError = QueryServiceConfig2A(hService,
306 NULL,
307 0,
308 &dwRequiredSize);
309 ok(bError == FALSE && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "(bError, GetLastError()) = (%u, 0x%08lx), expected (FALSE, 0x%08lx)\n", bError, GetLastError(), (DWORD)ERROR_INSUFFICIENT_BUFFER);
310 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
311 if (dwRequiredSize == 0)
312 {
313 skip("Required size is null; cannot proceed with QueryConfig2A --> %lu test\n", dwInfoLevel);
314 return 1;
315 }
316
317 /* Allocate memory */
319 if (lpBuffer == NULL)
320 {
321 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
322 return 2;
323 }
324
325 /* Get the actual value */
326 SetLastError(0xdeadbeef);
327 bError = QueryServiceConfig2A(hService,
329 lpBuffer,
330 dwRequiredSize,
331 &dwRequiredSize);
332 ok(bError, "bError = %u, expected TRUE\n", bError);
333 if (bError == FALSE)
334 {
335 skip("QueryServiceConfig2A returned an error; cannot proceed with QueryConfig2A --> %lu test\n", dwInfoLevel);
337 return 3;
338 }
339
340 /* Now we can compare the retrieved value with what it's actually stored in the registry */
341 StringCbPrintfA(keyName, sizeof(keyName), "System\\CurrentControlSet\\Services\\%s", serviceName);
342 SetLastError(0xdeadbeef);
344 ok(lRet == ERROR_SUCCESS, "RegOpenKeyExA failed with 0x%08lx\n", lRet);
345 if (lRet != ERROR_SUCCESS)
346 {
347 skip("No regkey; cannot proceed with QueryConfig2A --> %lu test\n", dwInfoLevel);
349 return 4;
350 }
351
352 switch (dwInfoLevel)
353 {
355 {
357 LPSTR lpszDescription = NULL;
358
359 /* Retrieve the description via the registry */
360 dwRet = RegReadStringA(hKey, "Description", &lpszDescription);
361 ok(dwRet == ERROR_SUCCESS, "RegReadStringA returned 0x%08lx\n", dwRet);
362 ok(lpszDescription != NULL, "lpszDescription is null, expected non-null\n");
363
364 /* Compare it with the description retrieved via QueryServiceConfig2 */
365 if (lpszDescription)
366 iRet = strcmp(lpDescription->lpDescription, lpszDescription);
367 else
368 iRet = 0;
369
370 ok(iRet == 0, "Retrieved descriptions are different !\n");
371
372
373 /* Memory cleanup */
374 HeapFree(GetProcessHeap(), 0, lpszDescription);
375
376 break;
377 }
378
380 {
382 LPSERVICE_FAILURE_ACTIONSA lpFailureActions2 = NULL;
383 LPSTR lpRebootMessage = NULL;
384 LPSTR lpFailureCommand = NULL;
385 DWORD i = 0;
386
387 /* Retrieve the failure actions via the registry */
388 lRet = RegQueryValueExA(hKey,
389 "FailureActions",
390 NULL,
391 &dwType,
392 NULL,
393 &dwRequiredSize);
394 ok(lRet == ERROR_SUCCESS, "RegQueryValueExA returned 0x%08lx\n", lRet);
395 ok(dwType == REG_BINARY, "dwType = %lu, expected REG_BINARY\n", dwType);
396 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
397
398 lpFailureActions2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwRequiredSize);
399 if (lpFailureActions2 == NULL)
400 {
401 skip("Cannot allocate %lu bytes of memory\n", dwRequiredSize);
402 break;
403 }
404
405 lRet = RegQueryValueExA(hKey,
406 "FailureActions",
407 NULL,
408 NULL,
409 (LPBYTE)lpFailureActions2,
410 &dwRequiredSize);
411 ok(lRet == ERROR_SUCCESS, "RegQueryValueExA returned 0x%08lx\n", lRet);
412 ok(dwRequiredSize != 0, "dwRequiredSize is zero, expected non-zero\n");
413
414 /* Get the strings */
415 RegReadStringA(hKey, "FailureCommand", &lpFailureCommand);
416 RegReadStringA(hKey, "RebootMessage" , &lpRebootMessage );
417
418 /* Check the values */
419 ok(lpFailureActions1->dwResetPeriod == lpFailureActions2->dwResetPeriod, "lpFailureActions1->dwResetPeriod != lpFailureActions2->dwResetPeriod\n");
420 ok(lpFailureActions1->cActions == lpFailureActions2->cActions, "lpFailureActions1->cActions != lpFailureActions2->cActions\n");
421
422 /* Compare the actions */
423 if (lpFailureActions1->cActions == lpFailureActions2->cActions)
424 {
425 lpFailureActions2->lpsaActions = (lpFailureActions2->cActions > 0 ? (LPSC_ACTION)(lpFailureActions2 + 1) : NULL);
426
427 if (lpFailureActions1->cActions > 0 &&
428 lpFailureActions1->lpsaActions != NULL)
429 {
430 for (i = 0; i < lpFailureActions1->cActions; ++i)
431 {
432 ok(lpFailureActions1->lpsaActions[i].Type == lpFailureActions2->lpsaActions[i].Type , "lpFailureActions1->lpsaActions[%lu].Type != lpFailureActions2->lpsaActions[%lu].Type\n" , i, i);
433 ok(lpFailureActions1->lpsaActions[i].Delay == lpFailureActions2->lpsaActions[i].Delay, "lpFailureActions1->lpsaActions[%lu].Delay != lpFailureActions2->lpsaActions[%lu].Delay\n", i, i);
434 }
435 }
436 }
437
438 /* TODO: retrieve the strings if they are in MUI format */
439
440 /* Compare RebootMsg */
441 if (lpFailureActions1->lpRebootMsg && lpRebootMessage)
442 iRet = strcmp(lpFailureActions1->lpRebootMsg, lpRebootMessage);
443 else
444 iRet = 0;
445
446 ok(iRet == 0, "Retrieved reboot messages are different !\n");
447
448 /* Compare Command */
449 if (lpFailureActions1->lpCommand && lpFailureCommand)
450 iRet = strcmp(lpFailureActions1->lpCommand, lpFailureCommand);
451 else
452 iRet = 0;
453
454 ok(iRet == 0, "Retrieved commands are different !\n");
455
456
457 /* Memory cleanup */
458 if (lpRebootMessage)
459 HeapFree(GetProcessHeap(), 0, lpRebootMessage);
460
461 if (lpFailureCommand)
462 HeapFree(GetProcessHeap(), 0, lpFailureCommand);
463
464 HeapFree(GetProcessHeap(), 0, lpFailureActions2);
465
466 break;
467 }
468
469 default:
470 skip("Unknown dwInfoLevel %lu, cannot proceed with QueryConfig2A --> %lu test\n", dwInfoLevel, dwInfoLevel);
471 break;
472 }
473
475
477
478 return 0;
479}
480
481
483{
484 SC_HANDLE hScm = NULL;
485 SC_HANDLE hService = NULL;
486
487 SetLastError(0xdeadbeef);
489 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
490 if (!hScm)
491 {
492 skip("No service control manager; cannot proceed with QueryServiceConfig2W test\n");
493 goto cleanup;
494 }
495
497
498 SetLastError(0xdeadbeef);
500 ok(hService != NULL, "Failed to open service handle, error=0x%08lx\n", GetLastError());
501 if (!hService)
502 {
503 skip("Service not found; cannot proceed with QueryServiceConfig2W test\n");
504 goto cleanup;
505 }
506
508
510 goto cleanup;
511
513 goto cleanup;
514
515cleanup:
516 if (hService)
517 CloseServiceHandle(hService);
518
519 if (hScm)
520 CloseServiceHandle(hScm);
521}
522
524{
525 SC_HANDLE hScm = NULL;
526 SC_HANDLE hService = NULL;
527
528 SetLastError(0xdeadbeef);
530 ok(hScm != NULL, "Failed to open service manager, error=0x%08lx\n", GetLastError());
531 if (!hScm)
532 {
533 skip("No service control manager; cannot proceed with QueryServiceConfig2A test\n");
534 goto cleanup;
535 }
536
538
539 SetLastError(0xdeadbeef);
541 ok(hService != NULL, "Failed to open service handle, error=0x%08lx\n", GetLastError());
542 if (!hService)
543 {
544 skip("Service not found; cannot proceed with QueryServiceConfig2A test\n");
545 goto cleanup;
546 }
547
549
551 goto cleanup;
552
554 goto cleanup;
555
556cleanup:
557 if (hService)
558 CloseServiceHandle(hService);
559
560 if (hScm)
561 CloseServiceHandle(hScm);
562}
563
564
566{
569}
static void Test_QueryServiceConfig2A(void)
static DWORD RegReadStringA(HKEY hKey, LPSTR lpValueName, LPSTR *lpValue)
static void Test_QueryServiceConfig2W(void)
static int QueryConfig2A(SC_HANDLE hService, LPCSTR serviceName, DWORD dwInfoLevel)
#define TESTING_SERVICEA
static int QueryConfig2W(SC_HANDLE hService, LPCWSTR serviceName, DWORD dwInfoLevel)
static DWORD RegReadStringW(HKEY hKey, LPWSTR lpValueName, LPWSTR *lpValue)
#define TESTING_SERVICEW
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define ok(value,...)
Definition: atltest.h:57
#define skip(...)
Definition: atltest.h:64
#define ok_err(error)
Definition: atltest.h:124
#define START_TEST(x)
Definition: atltest.h:75
#define RegCloseKey(hKey)
Definition: registry.h:49
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3298
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4009
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
#define GetProcessHeap()
Definition: compat.h:736
#define SetLastError(x)
Definition: compat.h:752
#define HeapAlloc
Definition: compat.h:733
#define HeapFree(x, y, z)
Definition: compat.h:735
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
static void cleanup(void)
Definition: main.c:1335
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
FxAutoRegKey hKey
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:56
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
SC_HANDLE WINAPI OpenSCManagerW(LPCWSTR lpMachineName, LPCWSTR lpDatabaseName, DWORD dwDesiredAccess)
Definition: scm.c:2068
SC_HANDLE WINAPI OpenServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, DWORD dwDesiredAccess)
Definition: scm.c:2112
SC_HANDLE WINAPI OpenServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, DWORD dwDesiredAccess)
Definition: scm.c:2160
BOOL WINAPI QueryServiceConfig2A(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2374
BOOL WINAPI QueryServiceConfig2W(SC_HANDLE hService, DWORD dwInfoLevel, LPBYTE lpBuffer, DWORD cbBufSize, LPDWORD pcbBytesNeeded)
Definition: scm.c:2491
SC_HANDLE WINAPI OpenSCManagerA(LPCSTR lpMachineName, LPCSTR lpDatabaseName, DWORD dwDesiredAccess)
Definition: scm.c:2024
BOOL WINAPI CloseServiceHandle(SC_HANDLE hSCObject)
Definition: scm.c:580
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:557
STRSAFEAPI StringCbPrintfA(STRSAFE_LPSTR pszDest, size_t cbDest, STRSAFE_LPCSTR pszFormat,...)
Definition: strsafe.h:547
DWORD Delay
Definition: winsvc.h:206
SC_ACTION_TYPE Type
Definition: winsvc.h:205
LPWSTR lpDescription
Definition: winsvc.h:196
SC_ACTION * lpsaActions
Definition: winsvc.h:213
SC_ACTION * lpsaActions
Definition: winsvc.h:220
char serviceName[]
Definition: tftpd.cpp:34
unsigned char * LPBYTE
Definition: typedefs.h:53
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define SERVICE_CONFIG_DESCRIPTION
Definition: winsvc.h:65
#define SC_MANAGER_CONNECT
Definition: winsvc.h:14
struct _SERVICE_DESCRIPTIONW * LPSERVICE_DESCRIPTIONW
struct _SERVICE_FAILURE_ACTIONSA * LPSERVICE_FAILURE_ACTIONSA
_In_ DWORD dwInfoLevel
Definition: winsvc.h:422
struct _SC_ACTION * LPSC_ACTION
struct _SERVICE_DESCRIPTIONA * LPSERVICE_DESCRIPTIONA
#define SERVICE_CONFIG_FAILURE_ACTIONS
Definition: winsvc.h:66
#define QueryServiceConfig2
Definition: winsvc.h:581
struct _SERVICE_FAILURE_ACTIONSW * LPSERVICE_FAILURE_ACTIONSW
#define SERVICE_QUERY_CONFIG
Definition: winsvc.h:53
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
char CHAR
Definition: xmlstorage.h:175