svchlp.c File Reference

#include "precomp.h"

Include dependency graph for svchlp.c:

Go to the source code of this file.

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)
static DWORD WINAPI	pipe_thread (void *param)
void	test_runner (void(*run_test)(PCSTR, PCWSTR, void *), void *param)

Variables
static HANDLE	hClientPipe = INVALID_HANDLE_VALUE
static WCHAR	named_pipe_name [100]
static CHAR	service_nameA [100]
static WCHAR	service_nameW [100]

Function Documentation

pipe_thread()

static DWORD WINAPI pipe_thread ( void *  param )

static

Definition at line 226 of file svchlp.c.

{
    HANDLE hServerPipe = (HANDLE)param;
    DWORD read;
    BOOL res;
    char buf[512];
 
    // printf("pipe_thread -- ConnectNamedPipe...\n");
    res = ConnectNamedPipe(hServerPipe, NULL);
    ok(res || GetLastError() == ERROR_PIPE_CONNECTED, "ConnectNamedPipe failed: %lu\n", GetLastError());
    // printf("pipe_thread -- ConnectNamedPipe ok\n");
 
    while (1)
    {
        res = ReadFile(hServerPipe, buf, sizeof(buf), &read, NULL);
        if (!res)
        {
            ok(GetLastError() == ERROR_BROKEN_PIPE || GetLastError() == ERROR_INVALID_HANDLE,
               "ReadFile failed: %lu\n", GetLastError());
            // printf("pipe_thread -- break loop\n");
            break;
        }
 
        if (!strncmp(buf, "TRACE:", 6))
        {
            trace("service trace: %s", buf+6);
        }
        else if (!strncmp(buf, "OK:", 3))
        {
            ok(1, "service: %s", buf+3);
        }
        else if (!strncmp(buf, "FAIL:", 5))
        {
            ok(0, "service: %s", buf+5);
        }
        else
        {
            ok(0, "malformed service message: %s\n", buf);
        }
    }
 
    // printf("pipe_thread -- DisconnectNamedPipe\n");
 
    /*
     * Flush the pipe to allow the client to read
     * the pipe's contents before disconnecting.
     */
    FlushFileBuffers(hServerPipe);
 
    DisconnectNamedPipe(hServerPipe);
    trace("pipe disconnected\n");
    return 0;
}

Referenced by test_runner().

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.

{
    SC_HANDLE service;
    CHAR service_cmd[MAX_PATH+150];
 
    /* Retrieve our full path */
    if (!GetModuleFileNameA(NULL, service_cmd, MAX_PATH))
    {
        skip("GetModuleFileNameW failed with error %lu!\n", GetLastError());
        return NULL;
    }
 
    /*
     * Build up our custom command line. The first parameter is the test name,
     * the second parameter is the flag used to decide whether we should start
     * as a service.
     */
    StringCbCatA(service_cmd, sizeof(service_cmd), " ");
    StringCbCatA(service_cmd, sizeof(service_cmd), test_name);
    StringCbCatA(service_cmd, sizeof(service_cmd), " ");
    StringCbCatA(service_cmd, sizeof(service_cmd), service_name);
    if (extra_args)
    {
        StringCbCatA(service_cmd, sizeof(service_cmd), " ");
        StringCbCatA(service_cmd, sizeof(service_cmd), extra_args);
    }
 
    trace("service_cmd \"%s\"\n", service_cmd);
 
    service = CreateServiceA(scm_handle, service_name, service_name,
                             dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
                             service_cmd, lpLoadOrderGroup, lpdwTagId, lpDependencies,
                             lpServiceStartName, lpPassword);
    if (!service && GetLastError() == ERROR_ACCESS_DENIED)
    {
        skip("Not enough access right to create service.\n");
        return NULL;
    }
 
    ok(service != NULL, "CreateService failed: %lu\n", GetLastError());
    return service;
}

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.

{
    SC_HANDLE service;
    WCHAR service_cmd[MAX_PATH+150];
 
    /* Retrieve our full path */
    if (!GetModuleFileNameW(NULL, service_cmd, MAX_PATH))
    {
        skip("GetModuleFileNameW failed with error %lu!\n", GetLastError());
        return NULL;
    }
 
    /*
     * Build up our custom command line. The first parameter is the test name,
     * the second parameter is the flag used to decide whether we should start
     * as a service.
     */
    StringCbCatW(service_cmd, sizeof(service_cmd), L" ");
    StringCbCatW(service_cmd, sizeof(service_cmd), test_name);
    StringCbCatW(service_cmd, sizeof(service_cmd), L" ");
    StringCbCatW(service_cmd, sizeof(service_cmd), service_name);
    if (extra_args)
    {
        StringCbCatW(service_cmd, sizeof(service_cmd), L" ");
        StringCbCatW(service_cmd, sizeof(service_cmd), extra_args);
    }
 
    trace("service_cmd \"%ls\"\n", service_cmd);
 
    service = CreateServiceW(scm_handle, service_name, service_name,
                             dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
                             service_cmd, lpLoadOrderGroup, lpdwTagId, lpDependencies,
                             lpServiceStartName, lpPassword);
    if (!service && GetLastError() == ERROR_ACCESS_DENIED)
    {
        skip("Not enough access right to create service.\n");
        return NULL;
    }
 
    ok(service != NULL, "CreateService failed: %lu\n", GetLastError());
    return service;
}

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.

{
    return register_service_exA(scm_handle, test_name, service_name, extra_args,
                                SERVICE_ALL_ACCESS,
                                SERVICE_WIN32_OWN_PROCESS,
                                SERVICE_DEMAND_START,
                                SERVICE_ERROR_IGNORE,
                                NULL, NULL, NULL, NULL, NULL);
}

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.

{
    return register_service_exW(scm_handle, test_name, service_name, extra_args,
                                SERVICE_ALL_ACCESS,
                                SERVICE_WIN32_OWN_PROCESS,
                                SERVICE_DEMAND_START,
                                SERVICE_ERROR_IGNORE,
                                NULL, NULL, NULL, NULL, NULL);
}

send_msg()

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

Definition at line 27 of file svchlp.c.

{
    DWORD written = 0;
    char buf[512];
 
    StringCbPrintfA(buf, sizeof(buf), "%s:%s", type, msg);
    WriteFile(hClientPipe, buf, lstrlenA(buf)+1, &written, NULL);
}

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.

{
    va_list valist;
    char buf[512];
 
    va_start(valist, msg);
    StringCbVPrintfA(buf, sizeof(buf), msg, valist);
    va_end(valist);
 
    send_msg(cnd ? "OK" : "FAIL", buf);
}

service_process()

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

Definition at line 60 of file svchlp.c.

{
    BOOL res;
 
    StringCbCopyA(service_nameA, sizeof(service_nameA), argv[2]);
    MultiByteToWideChar(CP_ACP, 0, service_nameA, -1, service_nameW, _countof(service_nameW));
    StringCbPrintfW(named_pipe_name, sizeof(named_pipe_name), L"\\\\.\\pipe\\%ls_pipe", service_nameW);
 
    res = WaitNamedPipeW(named_pipe_name, NMPWAIT_USE_DEFAULT_WAIT);
    if (!res)
        return;
 
    hClientPipe = CreateFileW(named_pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (hClientPipe == INVALID_HANDLE_VALUE)
        return;
 
    service_trace("Service process starting...\n");
    res = start_service(service_nameA, service_nameW);
    service_trace("Service process stopped.\n");
 
    CloseHandle(hClientPipe);
}

service_trace()

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

Definition at line 36 of file svchlp.c.

{
    va_list valist;
    char buf[512];
 
    va_start(valist, msg);
    StringCbVPrintfA(buf, sizeof(buf), msg, valist);
    va_end(valist);
 
    send_msg("TRACE", buf);
}

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.

{
    HANDLE hServerPipe = INVALID_HANDLE_VALUE;
    HANDLE hThread;
 
    StringCbPrintfW(service_nameW, sizeof(service_nameW), L"WineTestService%lu", GetTickCount());
    WideCharToMultiByte(CP_ACP, 0, service_nameW, -1, service_nameA, _countof(service_nameA), NULL, NULL);
    //trace("service_name: %ls\n", service_nameW);
    StringCbPrintfW(named_pipe_name, sizeof(named_pipe_name), L"\\\\.\\pipe\\%ls_pipe", service_nameW);
 
    hServerPipe = CreateNamedPipeW(named_pipe_name, PIPE_ACCESS_INBOUND,
                                   PIPE_TYPE_MESSAGE|PIPE_READMODE_MESSAGE|PIPE_WAIT, 10, 2048, 2048, 10000, NULL);
    ok(hServerPipe != INVALID_HANDLE_VALUE, "CreateNamedPipe failed: %lu\n", GetLastError());
    if (hServerPipe == INVALID_HANDLE_VALUE)
        return;
 
    hThread = CreateThread(NULL, 0, pipe_thread, (LPVOID)hServerPipe, 0, NULL);
    ok(hThread != NULL, "CreateThread failed: %lu\n", GetLastError());
    if (!hThread)
        goto Quit;
 
    run_test(service_nameA, service_nameW, param);
 
    ok(WaitForSingleObject(hThread, 10000) == WAIT_OBJECT_0, "Timeout waiting for thread\n");
 
Quit:
    if (hThread)
    {
        /* Be sure to kill the thread if it did not already terminate */
        TerminateThread(hThread, 0);
        CloseHandle(hThread);
    }
 
    if (hServerPipe != INVALID_HANDLE_VALUE)
        CloseHandle(hServerPipe);
}

Variable Documentation

hClientPipe

HANDLE hClientPipe = INVALID_HANDLE_VALUE

static

Definition at line 18 of file svchlp.c.

Referenced by send_msg(), and service_process().

named_pipe_name

WCHAR named_pipe_name[100]

static

Definition at line 19 of file svchlp.c.

Referenced by service_process(), and test_runner().

service_nameA

CHAR service_nameA[100]

static

Definition at line 21 of file svchlp.c.

Referenced by service_process(), and test_runner().

service_nameW

WCHAR service_nameW[100]

static

Definition at line 22 of file svchlp.c.

Referenced by service_process(), and test_runner().