ReactOS 0.4.16-dev-1946-g52006dd
Macros | Functions
svchlp.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define register_service_ex   register_service_exA
 
#define register_service   register_serviceA
 

Functions

void send_msg (const char *type, const char *msg)
 
void service_trace (const char *msg,...)
 
void service_ok (int cnd, const char *msg,...)
 
void service_process (BOOL(*start_service)(PCSTR, PCWSTR), int argc, char **argv)
 
SC_HANDLE register_service_exA (SC_HANDLE scm_handle, PCSTR test_name, PCSTR service_name, PCSTR extra_args OPTIONAL, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpLoadOrderGroup OPTIONAL, LPDWORD lpdwTagId OPTIONAL, LPCSTR lpDependencies OPTIONAL, LPCSTR lpServiceStartName OPTIONAL, LPCSTR lpPassword OPTIONAL)
 
SC_HANDLE register_service_exW (SC_HANDLE scm_handle, PCWSTR test_name, PCWSTR service_name, PCWSTR extra_args OPTIONAL, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpLoadOrderGroup OPTIONAL, LPDWORD lpdwTagId OPTIONAL, LPCWSTR lpDependencies OPTIONAL, LPCWSTR lpServiceStartName OPTIONAL, LPCWSTR lpPassword OPTIONAL)
 
SC_HANDLE register_serviceA (SC_HANDLE scm_handle, PCSTR test_name, PCSTR service_name, PCSTR extra_args OPTIONAL)
 
SC_HANDLE register_serviceW (SC_HANDLE scm_handle, PCWSTR test_name, PCWSTR service_name, PCWSTR extra_args OPTIONAL)
 
void test_runner (void(*run_test)(PCSTR, PCWSTR, void *), void *param)
 

Macro Definition Documentation

◆ register_service

#define register_service   register_serviceA

Definition at line 69 of file svchlp.h.

◆ register_service_ex

#define register_service_ex   register_service_exA

Definition at line 68 of file svchlp.h.

Function Documentation

◆ register_service_exA()

SC_HANDLE register_service_exA ( SC_HANDLE  scm_handle,
PCSTR  test_name,
PCSTR  service_name,
PCSTR extra_args  OPTIONAL,
DWORD  dwDesiredAccess,
DWORD  dwServiceType,
DWORD  dwStartType,
DWORD  dwErrorControl,
LPCSTR lpLoadOrderGroup  OPTIONAL,
LPDWORD lpdwTagId  OPTIONAL,
LPCSTR lpDependencies  OPTIONAL,
LPCSTR lpServiceStartName  OPTIONAL,
LPCSTR lpPassword  OPTIONAL 
)

Definition at line 86 of file svchlp.c.

100{
101 SC_HANDLE service;
102 CHAR service_cmd[MAX_PATH+150];
103
104 /* Retrieve our full path */
105 if (!GetModuleFileNameA(NULL, service_cmd, MAX_PATH))
106 {
107 skip("GetModuleFileNameW failed with error %lu!\n", GetLastError());
108 return NULL;
109 }
110
111 /*
112 * Build up our custom command line. The first parameter is the test name,
113 * the second parameter is the flag used to decide whether we should start
114 * as a service.
115 */
116 StringCbCatA(service_cmd, sizeof(service_cmd), " ");
117 StringCbCatA(service_cmd, sizeof(service_cmd), test_name);
118 StringCbCatA(service_cmd, sizeof(service_cmd), " ");
119 StringCbCatA(service_cmd, sizeof(service_cmd), service_name);
120 if (extra_args)
121 {
122 StringCbCatA(service_cmd, sizeof(service_cmd), " ");
123 StringCbCatA(service_cmd, sizeof(service_cmd), extra_args);
124 }
125
126 trace("service_cmd \"%s\"\n", service_cmd);
127
128 service = CreateServiceA(scm_handle, service_name, service_name,
129 dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
130 service_cmd, lpLoadOrderGroup, lpdwTagId, lpDependencies,
131 lpServiceStartName, lpPassword);
132 if (!service && GetLastError() == ERROR_ACCESS_DENIED)
133 {
134 skip("Not enough access right to create service.\n");
135 return NULL;
136 }
137
138 ok(service != NULL, "CreateService failed: %lu\n", GetLastError());
139 return service;
140}
service_name
static char service_name[100]
Definition: NtApphelpCacheControl.c:190
scm_handle
static SC_HANDLE scm_handle
Definition: ServiceArgs.c:20
trace
#define trace
Definition: atltest.h:70
ok
#define ok(value,...)
Definition: atltest.h:57
skip
#define skip(...)
Definition: atltest.h:64
NULL
#define NULL
Definition: types.h:112
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
ERROR_ACCESS_DENIED
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
GetModuleFileNameA
DWORD WINAPI GetModuleFileNameA(HINSTANCE hModule, LPSTR lpFilename, DWORD nSize)
Definition: loader.c:539
test_name
static const char * test_name
Definition: run.c:177
CreateServiceA
SC_HANDLE WINAPI CreateServiceA(SC_HANDLE hSCManager, LPCSTR lpServiceName, LPCSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName, LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies, LPCSTR lpServiceStartName, LPCSTR lpPassword)
Definition: scm.c:680
StringCbCatA
STRSAFEAPI StringCbCatA(STRSAFE_LPSTR pszDest, size_t cbDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:337
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
CHAR
char CHAR
Definition: xmlstorage.h:175

Referenced by register_serviceA().

◆ register_service_exW()

SC_HANDLE register_service_exW ( SC_HANDLE  scm_handle,
PCWSTR  test_name,
PCWSTR  service_name,
PCWSTR extra_args  OPTIONAL,
DWORD  dwDesiredAccess,
DWORD  dwServiceType,
DWORD  dwStartType,
DWORD  dwErrorControl,
LPCWSTR lpLoadOrderGroup  OPTIONAL,
LPDWORD lpdwTagId  OPTIONAL,
LPCWSTR lpDependencies  OPTIONAL,
LPCWSTR lpServiceStartName  OPTIONAL,
LPCWSTR lpPassword  OPTIONAL 
)

Definition at line 142 of file svchlp.c.

156{
157 SC_HANDLE service;
158 WCHAR service_cmd[MAX_PATH+150];
159
160 /* Retrieve our full path */
161 if (!GetModuleFileNameW(NULL, service_cmd, MAX_PATH))
162 {
163 skip("GetModuleFileNameW failed with error %lu!\n", GetLastError());
164 return NULL;
165 }
166
167 /*
168 * Build up our custom command line. The first parameter is the test name,
169 * the second parameter is the flag used to decide whether we should start
170 * as a service.
171 */
172 StringCbCatW(service_cmd, sizeof(service_cmd), L" ");
173 StringCbCatW(service_cmd, sizeof(service_cmd), test_name);
174 StringCbCatW(service_cmd, sizeof(service_cmd), L" ");
175 StringCbCatW(service_cmd, sizeof(service_cmd), service_name);
176 if (extra_args)
177 {
178 StringCbCatW(service_cmd, sizeof(service_cmd), L" ");
179 StringCbCatW(service_cmd, sizeof(service_cmd), extra_args);
180 }
181
182 trace("service_cmd \"%ls\"\n", service_cmd);
183
184 service = CreateServiceW(scm_handle, service_name, service_name,
185 dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
186 service_cmd, lpLoadOrderGroup, lpdwTagId, lpDependencies,
187 lpServiceStartName, lpPassword);
188 if (!service && GetLastError() == ERROR_ACCESS_DENIED)
189 {
190 skip("Not enough access right to create service.\n");
191 return NULL;
192 }
193
194 ok(service != NULL, "CreateService failed: %lu\n", GetLastError());
195 return service;
196}
GetModuleFileNameW
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:600
L
#define L(x)
Definition: resources.c:13
CreateServiceW
SC_HANDLE WINAPI CreateServiceW(SC_HANDLE hSCManager, LPCWSTR lpServiceName, LPCWSTR lpDisplayName, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName, LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies, LPCWSTR lpServiceStartName, LPCWSTR lpPassword)
Definition: scm.c:812
StringCbCatW
STRSAFEAPI StringCbCatW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:342
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by my_test_server(), and register_serviceW().

◆ register_serviceA()

SC_HANDLE register_serviceA ( SC_HANDLE  scm_handle,
PCSTR  test_name,
PCSTR  service_name,
PCSTR extra_args  OPTIONAL 
)

Definition at line 198 of file svchlp.c.

203{
204 return register_service_exA(scm_handle, test_name, service_name, extra_args,
205 SERVICE_ALL_ACCESS,
206 SERVICE_WIN32_OWN_PROCESS,
207 SERVICE_DEMAND_START,
208 SERVICE_ERROR_IGNORE,
209 NULL, NULL, NULL, NULL, NULL);
210}
register_service_exA
SC_HANDLE register_service_exA(SC_HANDLE scm_handle, PCSTR test_name, PCSTR service_name, PCSTR extra_args OPTIONAL, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpLoadOrderGroup OPTIONAL, LPDWORD lpdwTagId OPTIONAL, LPCSTR lpDependencies OPTIONAL, LPCSTR lpServiceStartName OPTIONAL, LPCSTR lpPassword OPTIONAL)
Definition: svchlp.c:86
SERVICE_ALL_ACCESS
#define SERVICE_ALL_ACCESS
Definition: winsvc.h:68
SERVICE_DEMAND_START
#define SERVICE_DEMAND_START
Definition: cmtypes.h:978
SERVICE_WIN32_OWN_PROCESS
#define SERVICE_WIN32_OWN_PROCESS
Definition: cmtypes.h:962
SERVICE_ERROR_IGNORE
#define SERVICE_ERROR_IGNORE
Definition: cmtypes.h:981

◆ register_serviceW()

SC_HANDLE register_serviceW ( SC_HANDLE  scm_handle,
PCWSTR  test_name,
PCWSTR  service_name,
PCWSTR extra_args  OPTIONAL 
)

Definition at line 212 of file svchlp.c.

217{
218 return register_service_exW(scm_handle, test_name, service_name, extra_args,
219 SERVICE_ALL_ACCESS,
220 SERVICE_WIN32_OWN_PROCESS,
221 SERVICE_DEMAND_START,
222 SERVICE_ERROR_IGNORE,
223 NULL, NULL, NULL, NULL, NULL);
224}
register_service_exW
SC_HANDLE register_service_exW(SC_HANDLE scm_handle, PCWSTR test_name, PCWSTR service_name, PCWSTR extra_args OPTIONAL, DWORD dwDesiredAccess, DWORD dwServiceType, DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpLoadOrderGroup OPTIONAL, LPDWORD lpdwTagId OPTIONAL, LPCWSTR lpDependencies OPTIONAL, LPCWSTR lpServiceStartName OPTIONAL, LPCWSTR lpPassword OPTIONAL)
Definition: svchlp.c:142

◆ send_msg()

void send_msg ( const char *  type,
const char *  msg 
)

Definition at line 27 of file svchlp.c.

28{
29 DWORD written = 0;
30 char buf[512];
31
32 StringCbPrintfA(buf, sizeof(buf), "%s:%s", type, msg);
33 WriteFile(hClientPipe, buf, lstrlenA(buf)+1, &written, NULL);
34}
msg
#define msg(x)
Definition: auth_time.c:54
WriteFile
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
lstrlenA
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
StringCbPrintfA
STRSAFEAPI StringCbPrintfA(STRSAFE_LPSTR pszDest, size_t cbDest, STRSAFE_LPCSTR pszFormat,...)
Definition: strsafe.h:547
hClientPipe
static HANDLE hClientPipe
Definition: svchlp.c:18

Referenced by service_ok(), and service_trace().

◆ service_ok()

void service_ok ( int  cnd,
const char *  msg,
  ... 
)

Definition at line 48 of file svchlp.c.

49{
50 va_list valist;
51 char buf[512];
52
53 va_start(valist, msg);
54 StringCbVPrintfA(buf, sizeof(buf), msg, valist);
55 va_end(valist);
56
57 send_msg(cnd ? "OK" : "FAIL", buf);
58}
va_list
char * va_list
Definition: acmsvcex.h:78
va_end
#define va_end(ap)
Definition: acmsvcex.h:90
va_start
#define va_start(ap, A)
Definition: acmsvcex.h:91
valist
static va_list valist
Definition: printf.c:46
StringCbVPrintfA
STRSAFEAPI StringCbVPrintfA(STRSAFE_LPSTR pszDest, size_t cbDest, STRSAFE_LPCSTR pszFormat, va_list argList)
Definition: strsafe.h:502
send_msg
void send_msg(const char *type, const char *msg)
Definition: svchlp.c:27

◆ service_process()

void service_process ( BOOL(*)(PCSTR, PCWSTR)  start_service,
int  argc,
char **  argv 
)

Definition at line 60 of file svchlp.c.

61{
62 BOOL res;
63
64 StringCbCopyA(service_nameA, sizeof(service_nameA), argv[2]);
65 MultiByteToWideChar(CP_ACP, 0, service_nameA, -1, service_nameW, _countof(service_nameW));
66 StringCbPrintfW(named_pipe_name, sizeof(named_pipe_name), L"\\\\.\\pipe\\%ls_pipe", service_nameW);
67
68 res = WaitNamedPipeW(named_pipe_name, NMPWAIT_USE_DEFAULT_WAIT);
69 if (!res)
70 return;
71
72 hClientPipe = CreateFileW(named_pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
73 if (hClientPipe == INVALID_HANDLE_VALUE)
74 return;
75
76 service_trace("Service process starting...\n");
77 res = start_service(service_nameA, service_nameW);
78 service_trace("Service process stopped.\n");
79
80 CloseHandle(hClientPipe);
81}
CloseHandle
#define CloseHandle
Definition: compat.h:739
CP_ACP
#define CP_ACP
Definition: compat.h:109
OPEN_EXISTING
#define OPEN_EXISTING
Definition: compat.h:775
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
CreateFileW
#define CreateFileW
Definition: compat.h:741
FILE_ATTRIBUTE_NORMAL
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110
start_service
static HRESULT start_service(const WCHAR *name, VARIANT *retval)
Definition: service.c:169
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
res
GLuint res
Definition: glext.h:9613
argv
#define argv
Definition: mplay32.c:18
WaitNamedPipeW
BOOL WINAPI WaitNamedPipeW(LPCWSTR lpNamedPipeName, DWORD nTimeOut)
Definition: npipe.c:458
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
_countof
#define _countof(array)
Definition: sndvol32.h:70
StringCbPrintfW
STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:557
StringCbCopyA
STRSAFEAPI StringCbCopyA(STRSAFE_LPSTR pszDest, size_t cbDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:161
service_nameA
static CHAR service_nameA[100]
Definition: svchlp.c:21
service_trace
void service_trace(const char *msg,...)
Definition: svchlp.c:36
service_nameW
static WCHAR service_nameW[100]
Definition: svchlp.c:22
named_pipe_name
static WCHAR named_pipe_name[100]
Definition: svchlp.c:19
NMPWAIT_USE_DEFAULT_WAIT
#define NMPWAIT_USE_DEFAULT_WAIT
Definition: winbase.h:136

◆ service_trace()

void service_trace ( const char *  msg,
  ... 
)

Definition at line 36 of file svchlp.c.

37{
38 va_list valist;
39 char buf[512];
40
41 va_start(valist, msg);
42 StringCbVPrintfA(buf, sizeof(buf), msg, valist);
43 va_end(valist);
44
45 send_msg("TRACE", buf);
46}

Referenced by service_main(), and service_process().

◆ test_runner()

void test_runner ( void(*)(PCSTR, PCWSTR, void *)  run_test,
void *  param 
)

Definition at line 280 of file svchlp.c.

281{
282 HANDLE hServerPipe = INVALID_HANDLE_VALUE;
283 HANDLE hThread;
284
285 StringCbPrintfW(service_nameW, sizeof(service_nameW), L"WineTestService%lu", GetTickCount());
286 WideCharToMultiByte(CP_ACP, 0, service_nameW, -1, service_nameA, _countof(service_nameA), NULL, NULL);
287 //trace("service_name: %ls\n", service_nameW);
288 StringCbPrintfW(named_pipe_name, sizeof(named_pipe_name), L"\\\\.\\pipe\\%ls_pipe", service_nameW);
289
290 hServerPipe = CreateNamedPipeW(named_pipe_name, PIPE_ACCESS_INBOUND,
291 PIPE_TYPE_MESSAGE|PIPE_READMODE_MESSAGE|PIPE_WAIT, 10, 2048, 2048, 10000, NULL);
292 ok(hServerPipe != INVALID_HANDLE_VALUE, "CreateNamedPipe failed: %lu\n", GetLastError());
293 if (hServerPipe == INVALID_HANDLE_VALUE)
294 return;
295
296 hThread = CreateThread(NULL, 0, pipe_thread, (LPVOID)hServerPipe, 0, NULL);
297 ok(hThread != NULL, "CreateThread failed: %lu\n", GetLastError());
298 if (!hThread)
299 goto Quit;
300
301 run_test(service_nameA, service_nameW, param);
302
303 ok(WaitForSingleObject(hThread, 10000) == WAIT_OBJECT_0, "Timeout waiting for thread\n");
304
305Quit:
306 if (hThread)
307 {
308 /* Be sure to kill the thread if it did not already terminate */
309 TerminateThread(hThread, 0);
310 CloseHandle(hThread);
311 }
312
313 if (hServerPipe != INVALID_HANDLE_VALUE)
314 CloseHandle(hServerPipe);
315}
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
CreateThread
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
TerminateThread
BOOL WINAPI TerminateThread(IN HANDLE hThread, IN DWORD dwExitCode)
Definition: thread.c:587
GetTickCount
ULONG WINAPI DECLSPEC_HOTPATCH GetTickCount(void)
Definition: sync.c:182
param
GLfloat param
Definition: glext.h:5796
run_test
#define run_test(test)
Definition: ms_seh.c:71
hThread
HANDLE hThread
Definition: wizard.c:28
CreateNamedPipeW
HANDLE WINAPI CreateNamedPipeW(LPCWSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: npipe.c:246
pipe_thread
static DWORD WINAPI pipe_thread(void *param)
Definition: svchlp.c:226
WaitForSingleObject
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
PIPE_ACCESS_INBOUND
#define PIPE_ACCESS_INBOUND
Definition: winbase.h:167
PIPE_WAIT
#define PIPE_WAIT
Definition: winbase.h:173
PIPE_READMODE_MESSAGE
#define PIPE_READMODE_MESSAGE
Definition: winbase.h:172
WAIT_OBJECT_0
#define WAIT_OBJECT_0
Definition: winbase.h:383
PIPE_TYPE_MESSAGE
#define PIPE_TYPE_MESSAGE
Definition: winbase.h:170