2071 lines
63 KiB
C
2071 lines
63 KiB
C
/*
|
|
* Win32 advapi functions
|
|
*
|
|
* Copyright 1995 Sven Verdoolaege
|
|
* Copyright 2005 Mike McCormack
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#include "windef.h"
|
|
#include "winbase.h"
|
|
#include "winsvc.h"
|
|
#include "winerror.h"
|
|
#include "winreg.h"
|
|
#include "wine/unicode.h"
|
|
#include "wine/debug.h"
|
|
#include "winternl.h"
|
|
|
|
WINE_DEFAULT_DEBUG_CHANNEL(advapi);
|
|
|
|
static const WCHAR szServiceManagerKey[] = { 'S','y','s','t','e','m','\\',
|
|
'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
|
|
'S','e','r','v','i','c','e','s','\\',0 };
|
|
static const WCHAR szSCMLock[] = {'A','D','V','A','P','I','_','S','C','M',
|
|
'L','O','C','K',0};
|
|
static const WCHAR szServiceShmemNameFmtW[] = {'A','D','V','A','P','I','_',
|
|
'S','E','B','_','%','s',0};
|
|
static const WCHAR szServiceDispEventNameFmtW[] = {'A','D','V','A','P','I','_',
|
|
'D','I','S','P','_','%','s',0};
|
|
static const WCHAR szServiceMutexNameFmtW[] = {'A','D','V','A','P','I','_',
|
|
'M','U','X','_','%','s',0};
|
|
static const WCHAR szServiceAckEventNameFmtW[] = {'A','D','V','A','P','I','_',
|
|
'A','C','K','_','%','s',0};
|
|
static const WCHAR szWaitServiceStartW[] = {'A','D','V','A','P','I','_','W',
|
|
'a','i','t','S','e','r','v','i',
|
|
'c','e','S','t','a','r','t',0};
|
|
|
|
struct SEB /* service environment block */
|
|
{ /* resides in service's shared memory object */
|
|
DWORD control_code; /* service control code */
|
|
DWORD dispatcher_error; /* set by dispatcher if it fails to invoke control handler */
|
|
SERVICE_STATUS status;
|
|
DWORD argc;
|
|
/* variable part of SEB contains service arguments */
|
|
};
|
|
|
|
static HANDLE dispatcher_event; /* this is used by service thread to wakeup
|
|
* service control dispatcher when thread terminates */
|
|
|
|
static struct service_thread_data *service; /* FIXME: this should be a list */
|
|
|
|
/******************************************************************************
|
|
* SC_HANDLEs
|
|
*/
|
|
|
|
#define MAX_SERVICE_NAME 256
|
|
|
|
typedef enum { SC_HTYPE_MANAGER, SC_HTYPE_SERVICE } SC_HANDLE_TYPE;
|
|
|
|
struct sc_handle;
|
|
typedef VOID (*sc_handle_destructor)(struct sc_handle *);
|
|
|
|
struct sc_handle
|
|
{
|
|
SC_HANDLE_TYPE htype;
|
|
DWORD ref_count;
|
|
sc_handle_destructor destroy;
|
|
};
|
|
|
|
struct sc_manager /* service control manager handle */
|
|
{
|
|
struct sc_handle hdr;
|
|
HKEY hkey; /* handle to services database in the registry */
|
|
};
|
|
|
|
struct sc_service /* service handle */
|
|
{
|
|
struct sc_handle hdr;
|
|
HKEY hkey; /* handle to service entry in the registry (under hkey) */
|
|
struct sc_manager *scm; /* pointer to SCM handle */
|
|
WCHAR name[1];
|
|
};
|
|
|
|
static void *sc_handle_alloc(SC_HANDLE_TYPE htype, DWORD size,
|
|
sc_handle_destructor destroy)
|
|
{
|
|
struct sc_handle *hdr;
|
|
|
|
hdr = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, size );
|
|
if (hdr)
|
|
{
|
|
hdr->htype = htype;
|
|
hdr->ref_count = 1;
|
|
hdr->destroy = destroy;
|
|
}
|
|
TRACE("sc_handle type=%d -> %p\n", htype, hdr);
|
|
return hdr;
|
|
}
|
|
|
|
static void *sc_handle_get_handle_data(SC_HANDLE handle, DWORD htype)
|
|
{
|
|
struct sc_handle *hdr = (struct sc_handle *) handle;
|
|
|
|
if (!hdr)
|
|
return NULL;
|
|
if (hdr->htype != htype)
|
|
return NULL;
|
|
return hdr;
|
|
}
|
|
|
|
static void sc_handle_free(struct sc_handle* hdr)
|
|
{
|
|
if (!hdr)
|
|
return;
|
|
if (--hdr->ref_count)
|
|
return;
|
|
hdr->destroy(hdr);
|
|
HeapFree(GetProcessHeap(), 0, hdr);
|
|
}
|
|
|
|
static void sc_handle_destroy_manager(struct sc_handle *handle)
|
|
{
|
|
struct sc_manager *mgr = (struct sc_manager*) handle;
|
|
|
|
TRACE("destroying SC Manager %p\n", mgr);
|
|
if (mgr->hkey)
|
|
RegCloseKey(mgr->hkey);
|
|
}
|
|
|
|
static void sc_handle_destroy_service(struct sc_handle *handle)
|
|
{
|
|
struct sc_service *svc = (struct sc_service*) handle;
|
|
|
|
TRACE("destroying service %p\n", svc);
|
|
if (svc->hkey)
|
|
RegCloseKey(svc->hkey);
|
|
svc->hkey = NULL;
|
|
sc_handle_free(&svc->scm->hdr);
|
|
svc->scm = NULL;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* String management functions
|
|
*/
|
|
static inline LPWSTR SERV_dup( LPCSTR str )
|
|
{
|
|
UINT len;
|
|
LPWSTR wstr;
|
|
|
|
if( !str )
|
|
return NULL;
|
|
len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
|
|
wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
|
|
MultiByteToWideChar( CP_ACP, 0, str, -1, wstr, len );
|
|
return wstr;
|
|
}
|
|
|
|
static inline LPWSTR SERV_dupmulti( LPCSTR str )
|
|
{
|
|
UINT len = 0, n = 0;
|
|
LPWSTR wstr;
|
|
|
|
if( !str )
|
|
return NULL;
|
|
do {
|
|
len += MultiByteToWideChar( CP_ACP, 0, &str[n], -1, NULL, 0 );
|
|
n += (strlen( &str[n] ) + 1);
|
|
} while (str[n]);
|
|
len++;
|
|
n++;
|
|
|
|
wstr = HeapAlloc( GetProcessHeap(), 0, len*sizeof (WCHAR) );
|
|
MultiByteToWideChar( CP_ACP, 0, str, n, wstr, len );
|
|
return wstr;
|
|
}
|
|
|
|
static inline VOID SERV_free( LPWSTR wstr )
|
|
{
|
|
HeapFree( GetProcessHeap(), 0, wstr );
|
|
}
|
|
|
|
/******************************************************************************
|
|
* read_scm_lock_data
|
|
*
|
|
* helper function for service control dispatcher
|
|
*
|
|
* SCM database is locked by StartService;
|
|
* open global SCM lock object and read service name
|
|
*/
|
|
static BOOL read_scm_lock_data( LPWSTR buffer )
|
|
{
|
|
HANDLE hLock;
|
|
LPWSTR argptr;
|
|
|
|
hLock = OpenFileMappingW( FILE_MAP_ALL_ACCESS, FALSE, szSCMLock );
|
|
if( NULL == hLock )
|
|
{
|
|
SetLastError( ERROR_FAILED_SERVICE_CONTROLLER_CONNECT );
|
|
return FALSE;
|
|
}
|
|
argptr = MapViewOfFile( hLock, FILE_MAP_ALL_ACCESS,
|
|
0, 0, MAX_SERVICE_NAME * sizeof(WCHAR) );
|
|
if( NULL == argptr )
|
|
{
|
|
CloseHandle( hLock );
|
|
return FALSE;
|
|
}
|
|
strcpyW( buffer, argptr );
|
|
UnmapViewOfFile( argptr );
|
|
CloseHandle( hLock );
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* open_seb_shmem
|
|
*
|
|
* helper function for service control dispatcher
|
|
*/
|
|
static struct SEB* open_seb_shmem( LPWSTR service_name, HANDLE* hServiceShmem )
|
|
{
|
|
WCHAR object_name[ MAX_PATH ];
|
|
HANDLE hmem;
|
|
struct SEB *ret;
|
|
|
|
snprintfW( object_name, MAX_PATH, szServiceShmemNameFmtW, service_name );
|
|
hmem = OpenFileMappingW( FILE_MAP_ALL_ACCESS, FALSE, object_name );
|
|
if( NULL == hmem )
|
|
return NULL;
|
|
|
|
ret = MapViewOfFile( hmem, FILE_MAP_ALL_ACCESS, 0, 0, 0 );
|
|
if( NULL == ret )
|
|
CloseHandle( hmem );
|
|
else
|
|
*hServiceShmem = hmem;
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* build_arg_vectors
|
|
*
|
|
* helper function for start_new_service
|
|
*
|
|
* Allocate and initialize array of LPWSTRs to arguments in variable part
|
|
* of service environment block.
|
|
* First entry in the array is reserved for service name and not initialized.
|
|
*/
|
|
static LPWSTR* build_arg_vectors( struct SEB* seb )
|
|
{
|
|
LPWSTR *ret;
|
|
LPWSTR argptr;
|
|
DWORD i;
|
|
|
|
ret = HeapAlloc( GetProcessHeap(), 0, (1 + seb->argc) * sizeof(LPWSTR) );
|
|
if( NULL == ret )
|
|
return NULL;
|
|
|
|
argptr = (LPWSTR) &seb[1];
|
|
for( i = 0; i < seb->argc; i++ )
|
|
{
|
|
ret[ 1 + i ] = argptr;
|
|
argptr += 1 + strlenW( argptr );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* service thread
|
|
*/
|
|
struct service_thread_data
|
|
{
|
|
WCHAR service_name[ MAX_SERVICE_NAME ];
|
|
CHAR service_nameA[ MAX_SERVICE_NAME ];
|
|
LPSERVICE_MAIN_FUNCTIONW service_main;
|
|
DWORD argc;
|
|
LPWSTR *argv;
|
|
HANDLE hServiceShmem;
|
|
struct SEB *seb;
|
|
HANDLE thread_handle;
|
|
HANDLE mutex; /* provides serialization of control request */
|
|
HANDLE ack_event; /* control handler completion acknowledgement */
|
|
LPHANDLER_FUNCTION ctrl_handler;
|
|
};
|
|
|
|
static DWORD WINAPI service_thread( LPVOID arg )
|
|
{
|
|
struct service_thread_data *data = arg;
|
|
|
|
data->service_main( data->argc, data->argv );
|
|
SetEvent( dispatcher_event );
|
|
return 0;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* dispose_service_thread_data
|
|
*
|
|
* helper function for service control dispatcher
|
|
*/
|
|
static void dispose_service_thread_data( struct service_thread_data* thread_data )
|
|
{
|
|
if( thread_data->mutex ) CloseHandle( thread_data->mutex );
|
|
if( thread_data->ack_event ) CloseHandle( thread_data->ack_event );
|
|
HeapFree( GetProcessHeap(), 0, thread_data->argv );
|
|
if( thread_data->seb ) UnmapViewOfFile( thread_data->seb );
|
|
if( thread_data->hServiceShmem ) CloseHandle( thread_data->hServiceShmem );
|
|
HeapFree( GetProcessHeap(), 0, thread_data );
|
|
}
|
|
|
|
/******************************************************************************
|
|
* start_new_service
|
|
*
|
|
* helper function for service control dispatcher
|
|
*/
|
|
static struct service_thread_data*
|
|
start_new_service( LPSERVICE_MAIN_FUNCTIONW service_main, BOOL ascii )
|
|
{
|
|
struct service_thread_data *thread_data;
|
|
unsigned int i;
|
|
WCHAR object_name[ MAX_PATH ];
|
|
|
|
thread_data = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct service_thread_data) );
|
|
if( NULL == thread_data )
|
|
return NULL;
|
|
|
|
if( ! read_scm_lock_data( thread_data->service_name ) )
|
|
{
|
|
/* FIXME: Instead of exiting we allow
|
|
service to be executed as ordinary program.
|
|
This behaviour was specially introduced in the patch
|
|
submitted against revision 1.45 and so preserved here.
|
|
*/
|
|
FIXME("should fail with ERROR_FAILED_SERVICE_CONTROLLER_CONNECT\n");
|
|
service_main( 0, NULL );
|
|
HeapFree( GetProcessHeap(), 0, thread_data );
|
|
return NULL;
|
|
}
|
|
|
|
thread_data->seb = open_seb_shmem( thread_data->service_name, &thread_data->hServiceShmem );
|
|
if( NULL == thread_data->seb )
|
|
goto error;
|
|
|
|
thread_data->argv = build_arg_vectors( thread_data->seb );
|
|
if( NULL == thread_data->argv )
|
|
goto error;
|
|
|
|
thread_data->argv[0] = thread_data->service_name;
|
|
thread_data->argc = thread_data->seb->argc + 1;
|
|
|
|
if( ascii )
|
|
{
|
|
/* Convert the Unicode arg vectors back to ASCII;
|
|
* but we'll need unicode service name (argv[0]) for object names */
|
|
WideCharToMultiByte( CP_ACP, 0, thread_data->argv[0], -1,
|
|
thread_data->service_nameA, MAX_SERVICE_NAME, NULL, NULL );
|
|
thread_data->argv[0] = (LPWSTR) thread_data->service_nameA;
|
|
|
|
for(i=1; i<thread_data->argc; i++)
|
|
{
|
|
LPWSTR src = thread_data->argv[i];
|
|
int len = WideCharToMultiByte( CP_ACP, 0, src, -1, NULL, 0, NULL, NULL );
|
|
LPSTR dest = HeapAlloc( GetProcessHeap(), 0, len );
|
|
if( NULL == dest )
|
|
goto error;
|
|
WideCharToMultiByte( CP_ACP, 0, src, -1, dest, len, NULL, NULL );
|
|
/* copy converted string back */
|
|
memcpy( src, dest, len );
|
|
HeapFree( GetProcessHeap(), 0, dest );
|
|
}
|
|
}
|
|
|
|
/* init status according to docs for StartService */
|
|
thread_data->seb->status.dwCurrentState = SERVICE_START_PENDING;
|
|
thread_data->seb->status.dwControlsAccepted = 0;
|
|
thread_data->seb->status.dwCheckPoint = 0;
|
|
thread_data->seb->status.dwWaitHint = 2000;
|
|
|
|
/* create service mutex; mutex is initially owned */
|
|
snprintfW( object_name, MAX_PATH, szServiceMutexNameFmtW, thread_data->service_name );
|
|
thread_data->mutex = CreateMutexW( NULL, TRUE, object_name );
|
|
if( NULL == thread_data->mutex )
|
|
goto error;
|
|
|
|
if( ERROR_ALREADY_EXISTS == GetLastError() )
|
|
{
|
|
SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
|
|
goto error;
|
|
}
|
|
|
|
/* create service event */
|
|
snprintfW( object_name, MAX_PATH, szServiceAckEventNameFmtW, thread_data->service_name );
|
|
thread_data->ack_event = CreateEventW( NULL, FALSE, FALSE, object_name );
|
|
if( NULL == thread_data->ack_event )
|
|
goto error;
|
|
|
|
if( ERROR_ALREADY_EXISTS == GetLastError() )
|
|
{
|
|
SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
|
|
goto error;
|
|
}
|
|
|
|
/* create service thread in suspended state
|
|
* to avoid race while caller handles return value */
|
|
thread_data->service_main = service_main;
|
|
thread_data->thread_handle = CreateThread( NULL, 0, service_thread,
|
|
thread_data, CREATE_SUSPENDED, NULL );
|
|
if( thread_data->thread_handle )
|
|
return thread_data;
|
|
|
|
error:
|
|
dispose_service_thread_data( thread_data );
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* service_ctrl_dispatcher
|
|
*/
|
|
static BOOL service_ctrl_dispatcher( LPSERVICE_TABLE_ENTRYW servent, BOOL ascii )
|
|
{
|
|
WCHAR object_name[ MAX_PATH ];
|
|
HANDLE wait;
|
|
|
|
/* FIXME: if shared service, find entry by service name */
|
|
|
|
/* FIXME: move this into dispatcher loop */
|
|
service = start_new_service( servent->lpServiceProc, ascii );
|
|
if( NULL == service )
|
|
return FALSE;
|
|
|
|
ResumeThread( service->thread_handle );
|
|
|
|
/* create dispatcher event object */
|
|
/* FIXME: object_name should be based on executable image path because
|
|
* this object is common for all services in the process */
|
|
/* But what if own and shared services have the same executable? */
|
|
snprintfW( object_name, MAX_PATH, szServiceDispEventNameFmtW, service->service_name );
|
|
dispatcher_event = CreateEventW( NULL, FALSE, FALSE, object_name );
|
|
if( NULL == dispatcher_event )
|
|
{
|
|
dispose_service_thread_data( service );
|
|
return FALSE;
|
|
}
|
|
|
|
if( ERROR_ALREADY_EXISTS == GetLastError() )
|
|
{
|
|
SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
|
|
CloseHandle( dispatcher_event );
|
|
return FALSE;
|
|
}
|
|
|
|
/* ready to accept control requests */
|
|
ReleaseMutex( service->mutex );
|
|
|
|
/* signal for StartService */
|
|
wait = OpenSemaphoreW( SEMAPHORE_MODIFY_STATE, FALSE, szWaitServiceStartW );
|
|
if( wait )
|
|
{
|
|
ReleaseSemaphore( wait, 1, NULL );
|
|
CloseHandle( wait );
|
|
}
|
|
|
|
/* dispatcher loop */
|
|
for(;;)
|
|
{
|
|
DWORD ret;
|
|
|
|
WaitForSingleObject( dispatcher_event, INFINITE );
|
|
|
|
/* at first, look for terminated service thread
|
|
* FIXME: threads, if shared service */
|
|
if( !GetExitCodeThread( service->thread_handle, &ret ) )
|
|
ERR("Couldn't get thread exit code\n");
|
|
else if( ret != STILL_ACTIVE )
|
|
{
|
|
CloseHandle( service->thread_handle );
|
|
dispose_service_thread_data( service );
|
|
break;
|
|
}
|
|
|
|
/* look for control requests */
|
|
if( service->seb->control_code )
|
|
{
|
|
if( NULL == service->ctrl_handler )
|
|
service->seb->dispatcher_error = ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
|
|
else
|
|
{
|
|
service->ctrl_handler( service->seb->control_code );
|
|
service->seb->dispatcher_error = 0;
|
|
}
|
|
service->seb->control_code = 0;
|
|
SetEvent( service->ack_event );
|
|
}
|
|
|
|
/* FIXME: if shared service, check SCM lock object;
|
|
* if exists, a new service should be started */
|
|
}
|
|
|
|
CloseHandle( dispatcher_event );
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* StartServiceCtrlDispatcherA [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI
|
|
StartServiceCtrlDispatcherA( LPSERVICE_TABLE_ENTRYA servent )
|
|
{
|
|
int count, i;
|
|
LPSERVICE_TABLE_ENTRYW ServiceTableW;
|
|
BOOL ret;
|
|
|
|
TRACE("(%p)\n", servent);
|
|
|
|
/* convert service table to unicode */
|
|
for( count = 0; servent[ count ].lpServiceName; )
|
|
count++;
|
|
ServiceTableW = HeapAlloc( GetProcessHeap(), 0, (count + 1) * sizeof(SERVICE_TABLE_ENTRYW) );
|
|
if( NULL == ServiceTableW )
|
|
return FALSE;
|
|
|
|
for( i = 0; i < count; i++ )
|
|
{
|
|
ServiceTableW[ i ].lpServiceName = SERV_dup( servent[ i ].lpServiceName );
|
|
ServiceTableW[ i ].lpServiceProc = (LPSERVICE_MAIN_FUNCTIONW) servent[ i ].lpServiceProc;
|
|
}
|
|
ServiceTableW[ count ].lpServiceName = NULL;
|
|
ServiceTableW[ count ].lpServiceProc = NULL;
|
|
|
|
/* start dispatcher */
|
|
ret = service_ctrl_dispatcher( ServiceTableW, TRUE );
|
|
|
|
/* free service table */
|
|
for( i = 0; i < count; i++ )
|
|
SERV_free( ServiceTableW[ i ].lpServiceName );
|
|
HeapFree( GetProcessHeap(), 0, ServiceTableW );
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* StartServiceCtrlDispatcherW [ADVAPI32.@]
|
|
*
|
|
* PARAMS
|
|
* servent []
|
|
*/
|
|
BOOL WINAPI
|
|
StartServiceCtrlDispatcherW( LPSERVICE_TABLE_ENTRYW servent )
|
|
{
|
|
TRACE("(%p)\n", servent);
|
|
return service_ctrl_dispatcher( servent, FALSE );
|
|
}
|
|
|
|
/******************************************************************************
|
|
* LockServiceDatabase [ADVAPI32.@]
|
|
*/
|
|
SC_LOCK WINAPI LockServiceDatabase (SC_HANDLE hSCManager)
|
|
{
|
|
HANDLE ret;
|
|
|
|
TRACE("%p\n",hSCManager);
|
|
|
|
ret = CreateFileMappingW( INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE,
|
|
0, MAX_SERVICE_NAME * sizeof(WCHAR), szSCMLock );
|
|
if( ret && GetLastError() == ERROR_ALREADY_EXISTS )
|
|
{
|
|
CloseHandle( ret );
|
|
ret = NULL;
|
|
SetLastError( ERROR_SERVICE_DATABASE_LOCKED );
|
|
}
|
|
|
|
TRACE("returning %p\n", ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* UnlockServiceDatabase [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI UnlockServiceDatabase (SC_LOCK ScLock)
|
|
{
|
|
TRACE("%p\n",ScLock);
|
|
|
|
return CloseHandle( (HANDLE) ScLock );
|
|
}
|
|
|
|
/******************************************************************************
|
|
* RegisterServiceCtrlHandlerA [ADVAPI32.@]
|
|
*/
|
|
SERVICE_STATUS_HANDLE WINAPI
|
|
RegisterServiceCtrlHandlerA( LPCSTR lpServiceName,
|
|
LPHANDLER_FUNCTION lpfHandler )
|
|
{
|
|
LPWSTR lpServiceNameW;
|
|
SERVICE_STATUS_HANDLE ret;
|
|
|
|
lpServiceNameW = SERV_dup(lpServiceName);
|
|
ret = RegisterServiceCtrlHandlerW( lpServiceNameW, lpfHandler );
|
|
SERV_free(lpServiceNameW);
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* RegisterServiceCtrlHandlerW [ADVAPI32.@]
|
|
*
|
|
* PARAMS
|
|
* lpServiceName []
|
|
* lpfHandler []
|
|
*/
|
|
SERVICE_STATUS_HANDLE WINAPI
|
|
RegisterServiceCtrlHandlerW( LPCWSTR lpServiceName,
|
|
LPHANDLER_FUNCTION lpfHandler )
|
|
{
|
|
/* FIXME: find service thread data by service name */
|
|
|
|
service->ctrl_handler = lpfHandler;
|
|
return 0xcacacafe;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* SetServiceStatus [ADVAPI32.@]
|
|
*
|
|
* PARAMS
|
|
* hService []
|
|
* lpStatus []
|
|
*/
|
|
BOOL WINAPI
|
|
SetServiceStatus( SERVICE_STATUS_HANDLE hService, LPSERVICE_STATUS lpStatus )
|
|
{
|
|
DWORD r;
|
|
|
|
TRACE("\tType:%lx\n",lpStatus->dwServiceType);
|
|
TRACE("\tState:%lx\n",lpStatus->dwCurrentState);
|
|
TRACE("\tControlAccepted:%lx\n",lpStatus->dwControlsAccepted);
|
|
TRACE("\tExitCode:%lx\n",lpStatus->dwWin32ExitCode);
|
|
TRACE("\tServiceExitCode:%lx\n",lpStatus->dwServiceSpecificExitCode);
|
|
TRACE("\tCheckPoint:%lx\n",lpStatus->dwCheckPoint);
|
|
TRACE("\tWaitHint:%lx\n",lpStatus->dwWaitHint);
|
|
|
|
/* FIXME: find service thread data by status handle */
|
|
|
|
/* acquire mutex; note that mutex may already be owned
|
|
* when service handles control request
|
|
*/
|
|
r = WaitForSingleObject( service->mutex, 0 );
|
|
memcpy( &service->seb->status, lpStatus, sizeof(SERVICE_STATUS) );
|
|
if( WAIT_OBJECT_0 == r || WAIT_ABANDONED == r )
|
|
ReleaseMutex( service->mutex );
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* OpenSCManagerA [ADVAPI32.@]
|
|
*
|
|
* Establish a connection to the service control manager and open its database.
|
|
*
|
|
* PARAMS
|
|
* lpMachineName [I] Pointer to machine name string
|
|
* lpDatabaseName [I] Pointer to database name string
|
|
* dwDesiredAccess [I] Type of access
|
|
*
|
|
* RETURNS
|
|
* Success: A Handle to the service control manager database
|
|
* Failure: NULL
|
|
*/
|
|
SC_HANDLE WINAPI OpenSCManagerA( LPCSTR lpMachineName, LPCSTR lpDatabaseName,
|
|
DWORD dwDesiredAccess )
|
|
{
|
|
LPWSTR lpMachineNameW, lpDatabaseNameW;
|
|
SC_HANDLE ret;
|
|
|
|
lpMachineNameW = SERV_dup(lpMachineName);
|
|
lpDatabaseNameW = SERV_dup(lpDatabaseName);
|
|
ret = OpenSCManagerW(lpMachineNameW, lpDatabaseNameW, dwDesiredAccess);
|
|
SERV_free(lpDatabaseNameW);
|
|
SERV_free(lpMachineNameW);
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* OpenSCManagerW [ADVAPI32.@]
|
|
*
|
|
* See OpenSCManagerA.
|
|
*/
|
|
SC_HANDLE WINAPI OpenSCManagerW( LPCWSTR lpMachineName, LPCWSTR lpDatabaseName,
|
|
DWORD dwDesiredAccess )
|
|
{
|
|
struct sc_manager *manager;
|
|
HKEY hReg;
|
|
LONG r;
|
|
|
|
TRACE("(%s,%s,0x%08lx)\n", debugstr_w(lpMachineName),
|
|
debugstr_w(lpDatabaseName), dwDesiredAccess);
|
|
|
|
if( lpDatabaseName && lpDatabaseName[0] )
|
|
{
|
|
if( strcmpiW( lpDatabaseName, SERVICES_ACTIVE_DATABASEW ) == 0 )
|
|
{
|
|
/* noop, all right */
|
|
}
|
|
else if( strcmpiW( lpDatabaseName, SERVICES_FAILED_DATABASEW ) == 0 )
|
|
{
|
|
SetLastError( ERROR_DATABASE_DOES_NOT_EXIST );
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
SetLastError( ERROR_INVALID_NAME );
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
manager = sc_handle_alloc( SC_HTYPE_MANAGER, sizeof (struct sc_manager),
|
|
sc_handle_destroy_manager );
|
|
if (!manager)
|
|
return NULL;
|
|
|
|
r = RegConnectRegistryW(lpMachineName,HKEY_LOCAL_MACHINE,&hReg);
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
r = RegOpenKeyExW(hReg, szServiceManagerKey,
|
|
0, KEY_ALL_ACCESS, &manager->hkey);
|
|
RegCloseKey( hReg );
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
TRACE("returning %p\n", manager);
|
|
|
|
return (SC_HANDLE) &manager->hdr;
|
|
|
|
error:
|
|
sc_handle_free( &manager->hdr );
|
|
return NULL;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* ControlService [ADVAPI32.@]
|
|
*
|
|
* Send a control code to a service.
|
|
*
|
|
* PARAMS
|
|
* hService [I] Handle of the service control manager database
|
|
* dwControl [I] Control code to send (SERVICE_CONTROL_* flags from "winsvc.h")
|
|
* lpServiceStatus [O] Destination for the status of the service, if available
|
|
*
|
|
* RETURNS
|
|
* Success: TRUE.
|
|
* Failure: FALSE.
|
|
*
|
|
* BUGS
|
|
* Unlike M$' implementation, control requests are not serialized and may be
|
|
* processed asynchronously.
|
|
*/
|
|
BOOL WINAPI ControlService( SC_HANDLE hService, DWORD dwControl,
|
|
LPSERVICE_STATUS lpServiceStatus )
|
|
{
|
|
struct sc_service *hsvc;
|
|
WCHAR object_name[ MAX_PATH ];
|
|
HANDLE mutex = NULL, shmem = NULL;
|
|
HANDLE disp_event = NULL, ack_event = NULL;
|
|
struct SEB *seb = NULL;
|
|
DWORD r;
|
|
BOOL ret = FALSE, mutex_owned = FALSE;
|
|
|
|
hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
|
|
if (!hsvc)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
|
|
TRACE("%p(%s) %ld %p\n", hService, debugstr_w(hsvc->name),
|
|
dwControl, lpServiceStatus);
|
|
|
|
/* open and hold mutex */
|
|
snprintfW( object_name, MAX_PATH, szServiceMutexNameFmtW, hsvc->name );
|
|
mutex = OpenMutexW( MUTEX_ALL_ACCESS, FALSE, object_name );
|
|
if( NULL == mutex )
|
|
{
|
|
SetLastError( ERROR_SERVICE_NOT_ACTIVE );
|
|
return FALSE;
|
|
}
|
|
|
|
r = WaitForSingleObject( mutex, 30000 );
|
|
if( WAIT_FAILED == r )
|
|
goto done;
|
|
|
|
if( WAIT_TIMEOUT == r )
|
|
{
|
|
SetLastError( ERROR_SERVICE_REQUEST_TIMEOUT );
|
|
goto done;
|
|
}
|
|
mutex_owned = TRUE;
|
|
|
|
/* open event objects */
|
|
snprintfW( object_name, MAX_PATH, szServiceDispEventNameFmtW, hsvc->name );
|
|
disp_event = OpenEventW( EVENT_ALL_ACCESS, FALSE, object_name );
|
|
if( NULL == disp_event )
|
|
goto done;
|
|
|
|
snprintfW( object_name, MAX_PATH, szServiceAckEventNameFmtW, hsvc->name );
|
|
ack_event = OpenEventW( EVENT_ALL_ACCESS, FALSE, object_name );
|
|
if( NULL == ack_event )
|
|
goto done;
|
|
|
|
/* get service environment block */
|
|
seb = open_seb_shmem( hsvc->name, &shmem );
|
|
if( NULL == seb )
|
|
goto done;
|
|
|
|
/* send request */
|
|
/* FIXME: check dwControl against controls accepted */
|
|
seb->control_code = dwControl;
|
|
SetEvent( disp_event );
|
|
|
|
/* wait for acknowledgement */
|
|
r = WaitForSingleObject( ack_event, 30000 );
|
|
if( WAIT_FAILED == r )
|
|
goto done;
|
|
|
|
if( WAIT_TIMEOUT == r )
|
|
{
|
|
SetLastError( ERROR_SERVICE_REQUEST_TIMEOUT );
|
|
goto done;
|
|
}
|
|
|
|
if( seb->dispatcher_error )
|
|
{
|
|
SetLastError( seb->dispatcher_error );
|
|
goto done;
|
|
}
|
|
|
|
/* get status */
|
|
if( lpServiceStatus )
|
|
memcpy( lpServiceStatus, &seb->status, sizeof(SERVICE_STATUS) );
|
|
ret = TRUE;
|
|
|
|
done:
|
|
if( seb ) UnmapViewOfFile( seb );
|
|
if( shmem ) CloseHandle( shmem );
|
|
if( ack_event ) CloseHandle( ack_event );
|
|
if( disp_event ) CloseHandle( disp_event );
|
|
if( mutex_owned ) ReleaseMutex( mutex );
|
|
if( mutex ) CloseHandle( mutex );
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* CloseServiceHandle [ADVAPI32.@]
|
|
*
|
|
* Close a handle to a service or the service control manager database.
|
|
*
|
|
* PARAMS
|
|
* hSCObject [I] Handle to service or service control manager database
|
|
*
|
|
* RETURNS
|
|
* Success: TRUE
|
|
* Failure: FALSE
|
|
*/
|
|
BOOL WINAPI
|
|
CloseServiceHandle( SC_HANDLE hSCObject )
|
|
{
|
|
TRACE("%p\n", hSCObject);
|
|
|
|
sc_handle_free( (struct sc_handle*) hSCObject );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* OpenServiceA [ADVAPI32.@]
|
|
*
|
|
* Open a handle to a service.
|
|
*
|
|
* PARAMS
|
|
* hSCManager [I] Handle of the service control manager database
|
|
* lpServiceName [I] Name of the service to open
|
|
* dwDesiredAccess [I] Access required to the service
|
|
*
|
|
* RETURNS
|
|
* Success: Handle to the service
|
|
* Failure: NULL
|
|
*/
|
|
SC_HANDLE WINAPI OpenServiceA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
|
|
DWORD dwDesiredAccess )
|
|
{
|
|
LPWSTR lpServiceNameW;
|
|
SC_HANDLE ret;
|
|
|
|
TRACE("%p %s %ld\n", hSCManager, debugstr_a(lpServiceName), dwDesiredAccess);
|
|
|
|
lpServiceNameW = SERV_dup(lpServiceName);
|
|
ret = OpenServiceW( hSCManager, lpServiceNameW, dwDesiredAccess);
|
|
SERV_free(lpServiceNameW);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* OpenServiceW [ADVAPI32.@]
|
|
*
|
|
* See OpenServiceA.
|
|
*/
|
|
SC_HANDLE WINAPI OpenServiceW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
|
|
DWORD dwDesiredAccess)
|
|
{
|
|
struct sc_manager *hscm;
|
|
struct sc_service *hsvc;
|
|
HKEY hKey;
|
|
long r;
|
|
DWORD len;
|
|
|
|
TRACE("%p %s %ld\n", hSCManager, debugstr_w(lpServiceName), dwDesiredAccess);
|
|
|
|
if (!lpServiceName)
|
|
{
|
|
SetLastError(ERROR_INVALID_ADDRESS);
|
|
return NULL;
|
|
}
|
|
|
|
hscm = sc_handle_get_handle_data( hSCManager, SC_HTYPE_MANAGER );
|
|
if (!hscm)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
|
|
r = RegOpenKeyExW( hscm->hkey, lpServiceName, 0, KEY_ALL_ACCESS, &hKey );
|
|
if (r!=ERROR_SUCCESS)
|
|
{
|
|
SetLastError( ERROR_SERVICE_DOES_NOT_EXIST );
|
|
return NULL;
|
|
}
|
|
|
|
len = strlenW(lpServiceName)+1;
|
|
hsvc = sc_handle_alloc( SC_HTYPE_SERVICE,
|
|
sizeof (struct sc_service) + len*sizeof(WCHAR),
|
|
sc_handle_destroy_service );
|
|
if (!hsvc)
|
|
return NULL;
|
|
strcpyW( hsvc->name, lpServiceName );
|
|
hsvc->hkey = hKey;
|
|
|
|
/* add reference to SCM handle */
|
|
hscm->hdr.ref_count++;
|
|
hsvc->scm = hscm;
|
|
|
|
TRACE("returning %p\n",hsvc);
|
|
|
|
return (SC_HANDLE) &hsvc->hdr;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* CreateServiceW [ADVAPI32.@]
|
|
*/
|
|
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 )
|
|
{
|
|
struct sc_manager *hscm;
|
|
struct sc_service *hsvc = NULL;
|
|
HKEY hKey;
|
|
LONG r;
|
|
DWORD dp, len;
|
|
static const WCHAR szDisplayName[] = { 'D','i','s','p','l','a','y','N','a','m','e', 0 };
|
|
static const WCHAR szType[] = {'T','y','p','e',0};
|
|
static const WCHAR szStart[] = {'S','t','a','r','t',0};
|
|
static const WCHAR szError[] = {'E','r','r','o','r','C','o','n','t','r','o','l', 0};
|
|
static const WCHAR szImagePath[] = {'I','m','a','g','e','P','a','t','h',0};
|
|
static const WCHAR szGroup[] = {'G','r','o','u','p',0};
|
|
static const WCHAR szDependencies[] = { 'D','e','p','e','n','d','e','n','c','i','e','s',0};
|
|
|
|
FIXME("%p %s %s\n", hSCManager,
|
|
debugstr_w(lpServiceName), debugstr_w(lpDisplayName));
|
|
|
|
hscm = sc_handle_get_handle_data( hSCManager, SC_HTYPE_MANAGER );
|
|
if (!hscm)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return NULL;
|
|
}
|
|
|
|
r = RegCreateKeyExW(hscm->hkey, lpServiceName, 0, NULL,
|
|
REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hKey, &dp);
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
if (dp != REG_CREATED_NEW_KEY)
|
|
{
|
|
SetLastError(ERROR_SERVICE_EXISTS);
|
|
goto error;
|
|
}
|
|
|
|
if(lpDisplayName)
|
|
{
|
|
r = RegSetValueExW(hKey, szDisplayName, 0, REG_SZ, (const BYTE*)lpDisplayName,
|
|
(strlenW(lpDisplayName)+1)*sizeof(WCHAR) );
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
}
|
|
|
|
r = RegSetValueExW(hKey, szType, 0, REG_DWORD, (LPVOID)&dwServiceType, sizeof (DWORD) );
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
r = RegSetValueExW(hKey, szStart, 0, REG_DWORD, (LPVOID)&dwStartType, sizeof (DWORD) );
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
r = RegSetValueExW(hKey, szError, 0, REG_DWORD,
|
|
(LPVOID)&dwErrorControl, sizeof (DWORD) );
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
|
|
if(lpBinaryPathName)
|
|
{
|
|
r = RegSetValueExW(hKey, szImagePath, 0, REG_SZ, (const BYTE*)lpBinaryPathName,
|
|
(strlenW(lpBinaryPathName)+1)*sizeof(WCHAR) );
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
}
|
|
|
|
if(lpLoadOrderGroup)
|
|
{
|
|
r = RegSetValueExW(hKey, szGroup, 0, REG_SZ, (const BYTE*)lpLoadOrderGroup,
|
|
(strlenW(lpLoadOrderGroup)+1)*sizeof(WCHAR) );
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
}
|
|
|
|
if(lpDependencies)
|
|
{
|
|
DWORD len = 0;
|
|
|
|
/* determine the length of a double null terminated multi string */
|
|
do {
|
|
len += (strlenW(&lpDependencies[len])+1);
|
|
} while (lpDependencies[len++]);
|
|
|
|
r = RegSetValueExW(hKey, szDependencies, 0, REG_MULTI_SZ,
|
|
(const BYTE*)lpDependencies, len );
|
|
if (r!=ERROR_SUCCESS)
|
|
goto error;
|
|
}
|
|
|
|
if(lpPassword)
|
|
{
|
|
FIXME("Don't know how to add a Password for a service.\n");
|
|
}
|
|
|
|
if(lpServiceStartName)
|
|
{
|
|
FIXME("Don't know how to add a ServiceStartName for a service.\n");
|
|
}
|
|
|
|
len = strlenW(lpServiceName)+1;
|
|
hsvc = sc_handle_alloc( SC_HTYPE_SERVICE,
|
|
sizeof (struct sc_service) + len*sizeof(WCHAR),
|
|
sc_handle_destroy_service );
|
|
if (!hsvc)
|
|
return NULL;
|
|
strcpyW( hsvc->name, lpServiceName );
|
|
hsvc->hkey = hKey;
|
|
hsvc->scm = hscm;
|
|
hscm->hdr.ref_count++;
|
|
|
|
return (SC_HANDLE) &hsvc->hdr;
|
|
|
|
error:
|
|
if (hsvc)
|
|
sc_handle_free( &hsvc->hdr );
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* CreateServiceA [ADVAPI32.@]
|
|
*/
|
|
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 )
|
|
{
|
|
LPWSTR lpServiceNameW, lpDisplayNameW, lpBinaryPathNameW,
|
|
lpLoadOrderGroupW, lpDependenciesW, lpServiceStartNameW, lpPasswordW;
|
|
SC_HANDLE r;
|
|
|
|
TRACE("%p %s %s\n", hSCManager,
|
|
debugstr_a(lpServiceName), debugstr_a(lpDisplayName));
|
|
|
|
lpServiceNameW = SERV_dup( lpServiceName );
|
|
lpDisplayNameW = SERV_dup( lpDisplayName );
|
|
lpBinaryPathNameW = SERV_dup( lpBinaryPathName );
|
|
lpLoadOrderGroupW = SERV_dup( lpLoadOrderGroup );
|
|
lpDependenciesW = SERV_dupmulti( lpDependencies );
|
|
lpServiceStartNameW = SERV_dup( lpServiceStartName );
|
|
lpPasswordW = SERV_dup( lpPassword );
|
|
|
|
r = CreateServiceW( hSCManager, lpServiceNameW, lpDisplayNameW,
|
|
dwDesiredAccess, dwServiceType, dwStartType, dwErrorControl,
|
|
lpBinaryPathNameW, lpLoadOrderGroupW, lpdwTagId,
|
|
lpDependenciesW, lpServiceStartNameW, lpPasswordW );
|
|
|
|
SERV_free( lpServiceNameW );
|
|
SERV_free( lpDisplayNameW );
|
|
SERV_free( lpBinaryPathNameW );
|
|
SERV_free( lpLoadOrderGroupW );
|
|
SERV_free( lpDependenciesW );
|
|
SERV_free( lpServiceStartNameW );
|
|
SERV_free( lpPasswordW );
|
|
|
|
return r;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* DeleteService [ADVAPI32.@]
|
|
*
|
|
* Delete a service from the service control manager database.
|
|
*
|
|
* PARAMS
|
|
* hService [I] Handle of the service to delete
|
|
*
|
|
* RETURNS
|
|
* Success: TRUE
|
|
* Failure: FALSE
|
|
*/
|
|
BOOL WINAPI DeleteService( SC_HANDLE hService )
|
|
{
|
|
struct sc_service *hsvc;
|
|
HKEY hKey;
|
|
WCHAR valname[MAX_PATH+1];
|
|
INT index = 0;
|
|
LONG rc;
|
|
DWORD size;
|
|
|
|
hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
|
|
if (!hsvc)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
hKey = hsvc->hkey;
|
|
|
|
size = MAX_PATH+1;
|
|
/* Clean out the values */
|
|
rc = RegEnumValueW(hKey, index, valname,&size,0,0,0,0);
|
|
while (rc == ERROR_SUCCESS)
|
|
{
|
|
RegDeleteValueW(hKey,valname);
|
|
index++;
|
|
size = MAX_PATH+1;
|
|
rc = RegEnumValueW(hKey, index, valname, &size,0,0,0,0);
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
hsvc->hkey = NULL;
|
|
|
|
/* delete the key */
|
|
RegDeleteKeyW(hsvc->scm->hkey, hsvc->name);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* StartServiceA [ADVAPI32.@]
|
|
*
|
|
* Start a service
|
|
*
|
|
* PARAMS
|
|
* hService [I] Handle of service
|
|
* dwNumServiceArgs [I] Number of arguments
|
|
* lpServiceArgVectors [I] Address of array of argument strings
|
|
*
|
|
* NOTES
|
|
* - NT implements this function using an obscure RPC call.
|
|
* - You might need to do a "setenv SystemRoot \\WINNT" in your .cshrc
|
|
* to get things like "%SystemRoot%\\System32\\service.exe" to load.
|
|
* - This will only work for shared address space. How should the service
|
|
* args be transferred when address spaces are separated?
|
|
* - Can only start one service at a time.
|
|
* - Has no concept of privilege.
|
|
*
|
|
* RETURNS
|
|
* Success: TRUE.
|
|
* Failure: FALSE
|
|
*/
|
|
BOOL WINAPI
|
|
StartServiceA( SC_HANDLE hService, DWORD dwNumServiceArgs,
|
|
LPCSTR *lpServiceArgVectors )
|
|
{
|
|
LPWSTR *lpwstr=NULL;
|
|
unsigned int i;
|
|
|
|
TRACE("(%p,%ld,%p)\n",hService,dwNumServiceArgs,lpServiceArgVectors);
|
|
|
|
if(dwNumServiceArgs)
|
|
lpwstr = HeapAlloc( GetProcessHeap(), 0,
|
|
dwNumServiceArgs*sizeof(LPWSTR) );
|
|
|
|
for(i=0; i<dwNumServiceArgs; i++)
|
|
lpwstr[i]=SERV_dup(lpServiceArgVectors[i]);
|
|
|
|
StartServiceW(hService, dwNumServiceArgs, (LPCWSTR *)lpwstr);
|
|
|
|
if(dwNumServiceArgs)
|
|
{
|
|
for(i=0; i<dwNumServiceArgs; i++)
|
|
SERV_free(lpwstr[i]);
|
|
HeapFree(GetProcessHeap(), 0, lpwstr);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
* StartServiceW [ADVAPI32.@]
|
|
*
|
|
* See StartServiceA.
|
|
*/
|
|
BOOL WINAPI
|
|
StartServiceW( SC_HANDLE hService, DWORD dwNumServiceArgs,
|
|
LPCWSTR *lpServiceArgVectors )
|
|
{
|
|
static const WCHAR _ImagePathW[] = {'I','m','a','g','e','P','a','t','h',0};
|
|
|
|
struct sc_service *hsvc;
|
|
WCHAR path[MAX_PATH],str[MAX_PATH];
|
|
DWORD type,size;
|
|
DWORD i;
|
|
long r;
|
|
HANDLE hLock;
|
|
HANDLE hServiceShmem = NULL;
|
|
HANDLE wait = NULL;
|
|
LPWSTR shmem_lock = NULL;
|
|
struct SEB *seb = NULL;
|
|
LPWSTR argptr;
|
|
PROCESS_INFORMATION procinfo;
|
|
STARTUPINFOW startupinfo;
|
|
BOOL ret = FALSE;
|
|
|
|
TRACE("%p %ld %p\n",hService,dwNumServiceArgs,
|
|
lpServiceArgVectors);
|
|
|
|
hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
|
|
if (!hsvc)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
|
|
size = sizeof(str);
|
|
r = RegQueryValueExW(hsvc->hkey, _ImagePathW, NULL, &type, (LPVOID)str, &size);
|
|
if (r!=ERROR_SUCCESS)
|
|
return FALSE;
|
|
ExpandEnvironmentStringsW(str,path,sizeof(path));
|
|
|
|
TRACE("Starting service %s\n", debugstr_w(path) );
|
|
|
|
hLock = LockServiceDatabase( (SC_HANDLE) &hsvc->scm->hdr );
|
|
if( NULL == hLock )
|
|
return FALSE;
|
|
|
|
/*
|
|
* FIXME: start dependent services
|
|
*/
|
|
|
|
/* pass argv[0] (service name) to the service via global SCM lock object */
|
|
shmem_lock = MapViewOfFile( hLock, FILE_MAP_ALL_ACCESS,
|
|
0, 0, MAX_SERVICE_NAME * sizeof(WCHAR) );
|
|
if( NULL == shmem_lock )
|
|
{
|
|
ERR("Couldn't map shared memory\n");
|
|
goto done;
|
|
}
|
|
strcpyW( shmem_lock, hsvc->name );
|
|
|
|
/* create service environment block */
|
|
size = sizeof(struct SEB);
|
|
for( i = 0; i < dwNumServiceArgs; i++ )
|
|
size += sizeof(WCHAR) * (1 + strlenW( lpServiceArgVectors[ i ] ));
|
|
|
|
snprintfW( str, MAX_PATH, szServiceShmemNameFmtW, hsvc->name );
|
|
hServiceShmem = CreateFileMappingW( INVALID_HANDLE_VALUE,
|
|
NULL, PAGE_READWRITE, 0, size, str );
|
|
if( NULL == hServiceShmem )
|
|
{
|
|
ERR("Couldn't create shared memory object\n");
|
|
goto done;
|
|
}
|
|
if( GetLastError() == ERROR_ALREADY_EXISTS )
|
|
{
|
|
SetLastError( ERROR_SERVICE_ALREADY_RUNNING );
|
|
goto done;
|
|
}
|
|
seb = MapViewOfFile( hServiceShmem, FILE_MAP_ALL_ACCESS, 0, 0, 0 );
|
|
if( NULL == seb )
|
|
{
|
|
ERR("Couldn't map shared memory\n");
|
|
goto done;
|
|
}
|
|
|
|
/* copy service args to SEB */
|
|
seb->argc = dwNumServiceArgs;
|
|
argptr = (LPWSTR) &seb[1];
|
|
for( i = 0; i < dwNumServiceArgs; i++ )
|
|
{
|
|
strcpyW( argptr, lpServiceArgVectors[ i ] );
|
|
argptr += 1 + strlenW( argptr );
|
|
}
|
|
|
|
wait = CreateSemaphoreW(NULL,0,1,szWaitServiceStartW);
|
|
if (!wait)
|
|
{
|
|
ERR("Couldn't create wait semaphore\n");
|
|
goto done;
|
|
}
|
|
|
|
ZeroMemory(&startupinfo,sizeof(STARTUPINFOW));
|
|
startupinfo.cb = sizeof(STARTUPINFOW);
|
|
|
|
r = CreateProcessW(NULL,
|
|
path,
|
|
NULL, /* process security attribs */
|
|
NULL, /* thread security attribs */
|
|
FALSE, /* inherit handles */
|
|
0, /* creation flags */
|
|
NULL, /* environment */
|
|
NULL, /* current directory */
|
|
&startupinfo, /* startup info */
|
|
&procinfo); /* process info */
|
|
|
|
if(r == FALSE)
|
|
{
|
|
ERR("Couldn't start process\n");
|
|
goto done;
|
|
}
|
|
CloseHandle( procinfo.hThread );
|
|
|
|
/* docs for StartServiceCtrlDispatcher say this should be 30 sec */
|
|
r = WaitForSingleObject(wait,30000);
|
|
if( WAIT_FAILED == r )
|
|
{
|
|
CloseHandle( procinfo.hProcess );
|
|
goto done;
|
|
}
|
|
if( WAIT_TIMEOUT == r )
|
|
{
|
|
TerminateProcess( procinfo.hProcess, 1 );
|
|
CloseHandle( procinfo.hProcess );
|
|
SetLastError( ERROR_SERVICE_REQUEST_TIMEOUT );
|
|
goto done;
|
|
}
|
|
|
|
/* allright */
|
|
CloseHandle( procinfo.hProcess );
|
|
ret = TRUE;
|
|
|
|
done:
|
|
if( wait ) CloseHandle( wait );
|
|
if( seb != NULL ) UnmapViewOfFile( seb );
|
|
if( hServiceShmem != NULL ) CloseHandle( hServiceShmem );
|
|
if( shmem_lock != NULL ) UnmapViewOfFile( shmem_lock );
|
|
UnlockServiceDatabase( hLock );
|
|
return ret;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* QueryServiceStatus [ADVAPI32.@]
|
|
*
|
|
* PARAMS
|
|
* hService []
|
|
* lpservicestatus []
|
|
*
|
|
*/
|
|
BOOL WINAPI
|
|
QueryServiceStatus( SC_HANDLE hService, LPSERVICE_STATUS lpservicestatus )
|
|
{
|
|
struct sc_service *hsvc;
|
|
LONG r;
|
|
DWORD type, val, size;
|
|
WCHAR object_name[ MAX_PATH ];
|
|
HANDLE mutex, shmem = NULL;
|
|
struct SEB *seb = NULL;
|
|
BOOL ret = FALSE, mutex_owned = FALSE;
|
|
|
|
hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
|
|
if (!hsvc)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
|
|
/* try to open service mutex */
|
|
snprintfW( object_name, MAX_PATH, szServiceMutexNameFmtW, hsvc->name );
|
|
mutex = OpenMutexW( MUTEX_ALL_ACCESS, FALSE, object_name );
|
|
if( NULL == mutex )
|
|
goto stopped;
|
|
|
|
/* hold mutex */
|
|
r = WaitForSingleObject( mutex, 30000 );
|
|
if( WAIT_FAILED == r )
|
|
goto done;
|
|
|
|
if( WAIT_TIMEOUT == r )
|
|
{
|
|
SetLastError( ERROR_SERVICE_REQUEST_TIMEOUT );
|
|
goto done;
|
|
}
|
|
mutex_owned = TRUE;
|
|
|
|
/* get service environment block */
|
|
seb = open_seb_shmem( hsvc->name, &shmem );
|
|
if( NULL == seb )
|
|
goto done;
|
|
|
|
/* get status */
|
|
memcpy( lpservicestatus, &seb->status, sizeof(SERVICE_STATUS) );
|
|
ret = TRUE;
|
|
|
|
done:
|
|
if( seb ) UnmapViewOfFile( seb );
|
|
if( shmem ) CloseHandle( shmem );
|
|
if( mutex_owned ) ReleaseMutex( mutex );
|
|
CloseHandle( mutex );
|
|
return ret;
|
|
|
|
stopped:
|
|
/* service stopped */
|
|
/* read the service type from the registry */
|
|
size = sizeof(val);
|
|
r = RegQueryValueExA(hsvc->hkey, "Type", NULL, &type, (LPBYTE)&val, &size);
|
|
if(type!=REG_DWORD)
|
|
{
|
|
ERR("invalid Type\n");
|
|
return FALSE;
|
|
}
|
|
lpservicestatus->dwServiceType = val;
|
|
lpservicestatus->dwCurrentState = 1; /* stopped */
|
|
lpservicestatus->dwControlsAccepted = 0;
|
|
lpservicestatus->dwWin32ExitCode = NO_ERROR;
|
|
lpservicestatus->dwServiceSpecificExitCode = 0;
|
|
lpservicestatus->dwCheckPoint = 0;
|
|
lpservicestatus->dwWaitHint = 0;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* QueryServiceStatusEx [ADVAPI32.@]
|
|
*
|
|
* Get information about a service.
|
|
*
|
|
* PARAMS
|
|
* hService [I] Handle to service to get information about
|
|
* InfoLevel [I] Level of information to get
|
|
* lpBuffer [O] Destination for requested information
|
|
* cbBufSize [I] Size of lpBuffer in bytes
|
|
* pcbBytesNeeded [O] Destination for number of bytes needed, if cbBufSize is too small
|
|
*
|
|
* RETURNS
|
|
* Success: TRUE
|
|
* FAILURE: FALSE
|
|
*/
|
|
BOOL WINAPI QueryServiceStatusEx(SC_HANDLE hService, SC_STATUS_TYPE InfoLevel,
|
|
LPBYTE lpBuffer, DWORD cbBufSize,
|
|
LPDWORD pcbBytesNeeded)
|
|
{
|
|
FIXME("stub\n");
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* QueryServiceConfigA [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI
|
|
QueryServiceConfigA( SC_HANDLE hService,
|
|
LPQUERY_SERVICE_CONFIGA lpServiceConfig,
|
|
DWORD cbBufSize, LPDWORD pcbBytesNeeded)
|
|
{
|
|
static const CHAR szDisplayName[] = "DisplayName";
|
|
static const CHAR szType[] = "Type";
|
|
static const CHAR szStart[] = "Start";
|
|
static const CHAR szError[] = "ErrorControl";
|
|
static const CHAR szImagePath[] = "ImagePath";
|
|
static const CHAR szGroup[] = "Group";
|
|
static const CHAR szDependencies[] = "Dependencies";
|
|
struct sc_service *hsvc;
|
|
HKEY hKey;
|
|
CHAR str_buffer[ MAX_PATH ];
|
|
LONG r;
|
|
DWORD type, val, sz, total, n;
|
|
LPBYTE p;
|
|
|
|
TRACE("%p %p %ld %p\n", hService, lpServiceConfig,
|
|
cbBufSize, pcbBytesNeeded);
|
|
|
|
hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
|
|
if (!hsvc)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
hKey = hsvc->hkey;
|
|
|
|
/* calculate the size required first */
|
|
total = sizeof (QUERY_SERVICE_CONFIGA);
|
|
|
|
sz = sizeof(str_buffer);
|
|
r = RegQueryValueExA( hKey, szImagePath, 0, &type, str_buffer, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
|
|
{
|
|
sz = ExpandEnvironmentStringsA(str_buffer,NULL,0);
|
|
if( 0 == sz ) return FALSE;
|
|
|
|
total += sz;
|
|
}
|
|
else
|
|
{
|
|
/* FIXME: set last error */
|
|
return FALSE;
|
|
}
|
|
|
|
sz = 0;
|
|
r = RegQueryValueExA( hKey, szGroup, 0, &type, NULL, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
|
|
total += sz;
|
|
|
|
sz = 0;
|
|
r = RegQueryValueExA( hKey, szDependencies, 0, &type, NULL, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_MULTI_SZ ) )
|
|
total += sz;
|
|
|
|
sz = 0;
|
|
r = RegQueryValueExA( hKey, szStart, 0, &type, NULL, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
|
|
total += sz;
|
|
|
|
sz = 0;
|
|
r = RegQueryValueExA( hKey, szDisplayName, 0, &type, NULL, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
|
|
total += sz;
|
|
|
|
/* if there's not enough memory, return an error */
|
|
if( total > *pcbBytesNeeded )
|
|
{
|
|
*pcbBytesNeeded = total;
|
|
SetLastError( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
|
|
*pcbBytesNeeded = total;
|
|
ZeroMemory( lpServiceConfig, total );
|
|
|
|
sz = sizeof val;
|
|
r = RegQueryValueExA( hKey, szType, 0, &type, (LPBYTE)&val, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
|
|
lpServiceConfig->dwServiceType = val;
|
|
|
|
sz = sizeof val;
|
|
r = RegQueryValueExA( hKey, szStart, 0, &type, (LPBYTE)&val, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
|
|
lpServiceConfig->dwStartType = val;
|
|
|
|
sz = sizeof val;
|
|
r = RegQueryValueExA( hKey, szError, 0, &type, (LPBYTE)&val, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
|
|
lpServiceConfig->dwErrorControl = val;
|
|
|
|
/* now do the strings */
|
|
p = (LPBYTE) &lpServiceConfig[1];
|
|
n = total - sizeof (QUERY_SERVICE_CONFIGA);
|
|
|
|
sz = sizeof(str_buffer);
|
|
r = RegQueryValueExA( hKey, szImagePath, 0, &type, str_buffer, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
|
|
{
|
|
sz = ExpandEnvironmentStringsA(str_buffer, p, n);
|
|
if( 0 == sz || sz > n ) return FALSE;
|
|
|
|
lpServiceConfig->lpBinaryPathName = (LPSTR) p;
|
|
p += sz;
|
|
n -= sz;
|
|
}
|
|
else
|
|
{
|
|
/* FIXME: set last error */
|
|
return FALSE;
|
|
}
|
|
|
|
sz = n;
|
|
r = RegQueryValueExA( hKey, szGroup, 0, &type, p, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_SZ ) )
|
|
{
|
|
lpServiceConfig->lpLoadOrderGroup = (LPSTR) p;
|
|
p += sz;
|
|
n -= sz;
|
|
}
|
|
|
|
sz = n;
|
|
r = RegQueryValueExA( hKey, szDependencies, 0, &type, p, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_SZ ) )
|
|
{
|
|
lpServiceConfig->lpDependencies = (LPSTR) p;
|
|
p += sz;
|
|
n -= sz;
|
|
}
|
|
|
|
if( n < 0 )
|
|
ERR("Buffer overflow!\n");
|
|
|
|
TRACE("Image path = %s\n", lpServiceConfig->lpBinaryPathName );
|
|
TRACE("Group = %s\n", lpServiceConfig->lpLoadOrderGroup );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* QueryServiceConfigW [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI
|
|
QueryServiceConfigW( SC_HANDLE hService,
|
|
LPQUERY_SERVICE_CONFIGW lpServiceConfig,
|
|
DWORD cbBufSize, LPDWORD pcbBytesNeeded)
|
|
{
|
|
static const WCHAR szDisplayName[] = {
|
|
'D','i','s','p','l','a','y','N','a','m','e', 0 };
|
|
static const WCHAR szType[] = {'T','y','p','e',0};
|
|
static const WCHAR szStart[] = {'S','t','a','r','t',0};
|
|
static const WCHAR szError[] = {
|
|
'E','r','r','o','r','C','o','n','t','r','o','l', 0};
|
|
static const WCHAR szImagePath[] = {'I','m','a','g','e','P','a','t','h',0};
|
|
static const WCHAR szGroup[] = {'G','r','o','u','p',0};
|
|
static const WCHAR szDependencies[] = {
|
|
'D','e','p','e','n','d','e','n','c','i','e','s',0};
|
|
WCHAR str_buffer[ MAX_PATH ];
|
|
LONG r;
|
|
DWORD type, val, sz, total, n;
|
|
LPBYTE p;
|
|
HKEY hKey;
|
|
struct sc_service *hsvc;
|
|
|
|
TRACE("%p %p %ld %p\n", hService, lpServiceConfig,
|
|
cbBufSize, pcbBytesNeeded);
|
|
|
|
hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
|
|
if (!hsvc)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
hKey = hsvc->hkey;
|
|
|
|
/* calculate the size required first */
|
|
total = sizeof (QUERY_SERVICE_CONFIGW);
|
|
|
|
sz = sizeof(str_buffer);
|
|
r = RegQueryValueExW( hKey, szImagePath, 0, &type, (LPBYTE) str_buffer, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
|
|
{
|
|
sz = ExpandEnvironmentStringsW(str_buffer,NULL,0);
|
|
if( 0 == sz ) return FALSE;
|
|
|
|
total += sizeof(WCHAR) * sz;
|
|
}
|
|
else
|
|
{
|
|
/* FIXME: set last error */
|
|
return FALSE;
|
|
}
|
|
|
|
sz = 0;
|
|
r = RegQueryValueExW( hKey, szGroup, 0, &type, NULL, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
|
|
total += sz;
|
|
|
|
sz = 0;
|
|
r = RegQueryValueExW( hKey, szDependencies, 0, &type, NULL, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_MULTI_SZ ) )
|
|
total += sz;
|
|
|
|
sz = 0;
|
|
r = RegQueryValueExW( hKey, szStart, 0, &type, NULL, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
|
|
total += sz;
|
|
|
|
sz = 0;
|
|
r = RegQueryValueExW( hKey, szDisplayName, 0, &type, NULL, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ ) )
|
|
total += sz;
|
|
|
|
/* if there's not enough memory, return an error */
|
|
if( total > *pcbBytesNeeded )
|
|
{
|
|
*pcbBytesNeeded = total;
|
|
SetLastError( ERROR_INSUFFICIENT_BUFFER );
|
|
return FALSE;
|
|
}
|
|
|
|
*pcbBytesNeeded = total;
|
|
ZeroMemory( lpServiceConfig, total );
|
|
|
|
sz = sizeof val;
|
|
r = RegQueryValueExW( hKey, szType, 0, &type, (LPBYTE)&val, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
|
|
lpServiceConfig->dwServiceType = val;
|
|
|
|
sz = sizeof val;
|
|
r = RegQueryValueExW( hKey, szStart, 0, &type, (LPBYTE)&val, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
|
|
lpServiceConfig->dwStartType = val;
|
|
|
|
sz = sizeof val;
|
|
r = RegQueryValueExW( hKey, szError, 0, &type, (LPBYTE)&val, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_DWORD ) )
|
|
lpServiceConfig->dwErrorControl = val;
|
|
|
|
/* now do the strings */
|
|
p = (LPBYTE) &lpServiceConfig[1];
|
|
n = total - sizeof (QUERY_SERVICE_CONFIGW);
|
|
|
|
sz = sizeof(str_buffer);
|
|
r = RegQueryValueExW( hKey, szImagePath, 0, &type, (LPBYTE) str_buffer, &sz );
|
|
if( ( r == ERROR_SUCCESS ) && ( type == REG_SZ || type == REG_EXPAND_SZ ) )
|
|
{
|
|
sz = ExpandEnvironmentStringsW(str_buffer, (LPWSTR) p, n);
|
|
sz *= sizeof(WCHAR);
|
|
if( 0 == sz || sz > n ) return FALSE;
|
|
|
|
lpServiceConfig->lpBinaryPathName = (LPWSTR) p;
|
|
p += sz;
|
|
n -= sz;
|
|
}
|
|
else
|
|
{
|
|
/* FIXME: set last error */
|
|
return FALSE;
|
|
}
|
|
|
|
sz = n;
|
|
r = RegQueryValueExW( hKey, szGroup, 0, &type, p, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_SZ ) )
|
|
{
|
|
lpServiceConfig->lpLoadOrderGroup = (LPWSTR) p;
|
|
p += sz;
|
|
n -= sz;
|
|
}
|
|
|
|
sz = n;
|
|
r = RegQueryValueExW( hKey, szDependencies, 0, &type, p, &sz );
|
|
if( ( r == ERROR_SUCCESS ) || ( type == REG_SZ ) )
|
|
{
|
|
lpServiceConfig->lpDependencies = (LPWSTR) p;
|
|
p += sz;
|
|
n -= sz;
|
|
}
|
|
|
|
if( n < 0 )
|
|
ERR("Buffer overflow!\n");
|
|
|
|
TRACE("Image path = %s\n", debugstr_w(lpServiceConfig->lpBinaryPathName) );
|
|
TRACE("Group = %s\n", debugstr_w(lpServiceConfig->lpLoadOrderGroup) );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* EnumServicesStatusA [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI
|
|
EnumServicesStatusA( SC_HANDLE hSCManager, DWORD dwServiceType,
|
|
DWORD dwServiceState, LPENUM_SERVICE_STATUSA lpServices,
|
|
DWORD cbBufSize, LPDWORD pcbBytesNeeded,
|
|
LPDWORD lpServicesReturned, LPDWORD lpResumeHandle )
|
|
{
|
|
FIXME("%p type=%lx state=%lx %p %lx %p %p %p\n", hSCManager,
|
|
dwServiceType, dwServiceState, lpServices, cbBufSize,
|
|
pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
|
|
SetLastError (ERROR_ACCESS_DENIED);
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* EnumServicesStatusW [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI
|
|
EnumServicesStatusW( SC_HANDLE hSCManager, DWORD dwServiceType,
|
|
DWORD dwServiceState, LPENUM_SERVICE_STATUSW lpServices,
|
|
DWORD cbBufSize, LPDWORD pcbBytesNeeded,
|
|
LPDWORD lpServicesReturned, LPDWORD lpResumeHandle )
|
|
{
|
|
FIXME("%p type=%lx state=%lx %p %lx %p %p %p\n", hSCManager,
|
|
dwServiceType, dwServiceState, lpServices, cbBufSize,
|
|
pcbBytesNeeded, lpServicesReturned, lpResumeHandle);
|
|
SetLastError (ERROR_ACCESS_DENIED);
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* GetServiceKeyNameA [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI GetServiceKeyNameA( SC_HANDLE hSCManager, LPCSTR lpDisplayName,
|
|
LPSTR lpServiceName, LPDWORD lpcchBuffer )
|
|
{
|
|
FIXME("%p %s %p %p\n", hSCManager, debugstr_a(lpDisplayName), lpServiceName, lpcchBuffer);
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* GetServiceKeyNameW [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI GetServiceKeyNameW( SC_HANDLE hSCManager, LPCWSTR lpDisplayName,
|
|
LPWSTR lpServiceName, LPDWORD lpcchBuffer )
|
|
{
|
|
FIXME("%p %s %p %p\n", hSCManager, debugstr_w(lpDisplayName), lpServiceName, lpcchBuffer);
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* QueryServiceLockStatusA [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI QueryServiceLockStatusA( SC_HANDLE hSCManager,
|
|
LPQUERY_SERVICE_LOCK_STATUSA lpLockStatus,
|
|
DWORD cbBufSize, LPDWORD pcbBytesNeeded)
|
|
{
|
|
FIXME("%p %p %08lx %p\n", hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* QueryServiceLockStatusW [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI QueryServiceLockStatusW( SC_HANDLE hSCManager,
|
|
LPQUERY_SERVICE_LOCK_STATUSW lpLockStatus,
|
|
DWORD cbBufSize, LPDWORD pcbBytesNeeded)
|
|
{
|
|
FIXME("%p %p %08lx %p\n", hSCManager, lpLockStatus, cbBufSize, pcbBytesNeeded);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* GetServiceDisplayNameA [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI GetServiceDisplayNameA( SC_HANDLE hSCManager, LPCSTR lpServiceName,
|
|
LPSTR lpDisplayName, LPDWORD lpcchBuffer)
|
|
{
|
|
FIXME("%p %s %p %p\n", hSCManager,
|
|
debugstr_a(lpServiceName), lpDisplayName, lpcchBuffer);
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* GetServiceDisplayNameW [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI GetServiceDisplayNameW( SC_HANDLE hSCManager, LPCWSTR lpServiceName,
|
|
LPWSTR lpDisplayName, LPDWORD lpcchBuffer)
|
|
{
|
|
FIXME("%p %s %p %p\n", hSCManager,
|
|
debugstr_w(lpServiceName), lpDisplayName, lpcchBuffer);
|
|
return FALSE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* ChangeServiceConfigW [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI ChangeServiceConfigW( SC_HANDLE hService, DWORD dwServiceType,
|
|
DWORD dwStartType, DWORD dwErrorControl, LPCWSTR lpBinaryPathName,
|
|
LPCWSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCWSTR lpDependencies,
|
|
LPCWSTR lpServiceStartName, LPCWSTR lpPassword, LPCWSTR lpDisplayName)
|
|
{
|
|
FIXME("%p %ld %ld %ld %s %s %p %p %s %s %s\n",
|
|
hService, dwServiceType, dwStartType, dwErrorControl,
|
|
debugstr_w(lpBinaryPathName), debugstr_w(lpLoadOrderGroup),
|
|
lpdwTagId, lpDependencies, debugstr_w(lpServiceStartName),
|
|
debugstr_w(lpPassword), debugstr_w(lpDisplayName) );
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* ChangeServiceConfigA [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI ChangeServiceConfigA( SC_HANDLE hService, DWORD dwServiceType,
|
|
DWORD dwStartType, DWORD dwErrorControl, LPCSTR lpBinaryPathName,
|
|
LPCSTR lpLoadOrderGroup, LPDWORD lpdwTagId, LPCSTR lpDependencies,
|
|
LPCSTR lpServiceStartName, LPCSTR lpPassword, LPCSTR lpDisplayName)
|
|
{
|
|
LPWSTR wBinaryPathName, wLoadOrderGroup, wDependencies;
|
|
LPWSTR wServiceStartName, wPassword, wDisplayName;
|
|
BOOL r;
|
|
|
|
TRACE("%p %ld %ld %ld %s %s %p %p %s %s %s\n",
|
|
hService, dwServiceType, dwStartType, dwErrorControl,
|
|
debugstr_a(lpBinaryPathName), debugstr_a(lpLoadOrderGroup),
|
|
lpdwTagId, lpDependencies, debugstr_a(lpServiceStartName),
|
|
debugstr_a(lpPassword), debugstr_a(lpDisplayName) );
|
|
|
|
wBinaryPathName = SERV_dup( lpBinaryPathName );
|
|
wLoadOrderGroup = SERV_dup( lpLoadOrderGroup );
|
|
wDependencies = SERV_dupmulti( lpDependencies );
|
|
wServiceStartName = SERV_dup( lpServiceStartName );
|
|
wPassword = SERV_dup( lpPassword );
|
|
wDisplayName = SERV_dup( lpDisplayName );
|
|
|
|
r = ChangeServiceConfigW( hService, dwServiceType,
|
|
dwStartType, dwErrorControl, wBinaryPathName,
|
|
wLoadOrderGroup, lpdwTagId, wDependencies,
|
|
wServiceStartName, wPassword, wDisplayName);
|
|
|
|
SERV_free( wBinaryPathName );
|
|
SERV_free( wLoadOrderGroup );
|
|
SERV_free( wDependencies );
|
|
SERV_free( wServiceStartName );
|
|
SERV_free( wPassword );
|
|
SERV_free( wDisplayName );
|
|
|
|
return r;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* ChangeServiceConfig2A [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI ChangeServiceConfig2A( SC_HANDLE hService, DWORD dwInfoLevel,
|
|
LPVOID lpInfo)
|
|
{
|
|
BOOL r = FALSE;
|
|
|
|
TRACE("%p %ld %p\n",hService, dwInfoLevel, lpInfo);
|
|
|
|
if (dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
|
|
{
|
|
LPSERVICE_DESCRIPTIONA sd = (LPSERVICE_DESCRIPTIONA) lpInfo;
|
|
SERVICE_DESCRIPTIONW sdw;
|
|
|
|
sdw.lpDescription = SERV_dup( sd->lpDescription );
|
|
|
|
r = ChangeServiceConfig2W( hService, dwInfoLevel, &sdw );
|
|
|
|
SERV_free( sdw.lpDescription );
|
|
}
|
|
else if (dwInfoLevel == SERVICE_CONFIG_FAILURE_ACTIONS)
|
|
{
|
|
LPSERVICE_FAILURE_ACTIONSA fa = (LPSERVICE_FAILURE_ACTIONSA) lpInfo;
|
|
SERVICE_FAILURE_ACTIONSW faw;
|
|
|
|
faw.dwResetPeriod = fa->dwResetPeriod;
|
|
faw.lpRebootMsg = SERV_dup( fa->lpRebootMsg );
|
|
faw.lpCommand = SERV_dup( fa->lpCommand );
|
|
faw.cActions = fa->cActions;
|
|
faw.lpsaActions = fa->lpsaActions;
|
|
|
|
r = ChangeServiceConfig2W( hService, dwInfoLevel, &faw );
|
|
|
|
SERV_free( faw.lpRebootMsg );
|
|
SERV_free( faw.lpCommand );
|
|
}
|
|
else
|
|
SetLastError( ERROR_INVALID_PARAMETER );
|
|
|
|
return r;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* ChangeServiceConfig2W [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI ChangeServiceConfig2W( SC_HANDLE hService, DWORD dwInfoLevel,
|
|
LPVOID lpInfo)
|
|
{
|
|
HKEY hKey;
|
|
struct sc_service *hsvc;
|
|
|
|
hsvc = sc_handle_get_handle_data(hService, SC_HTYPE_SERVICE);
|
|
if (!hsvc)
|
|
{
|
|
SetLastError( ERROR_INVALID_HANDLE );
|
|
return FALSE;
|
|
}
|
|
hKey = hsvc->hkey;
|
|
|
|
if (dwInfoLevel == SERVICE_CONFIG_DESCRIPTION)
|
|
{
|
|
static const WCHAR szDescription[] = {'D','e','s','c','r','i','p','t','i','o','n',0};
|
|
LPSERVICE_DESCRIPTIONW sd = (LPSERVICE_DESCRIPTIONW)lpInfo;
|
|
if (sd->lpDescription)
|
|
{
|
|
TRACE("Setting Description to %s\n",debugstr_w(sd->lpDescription));
|
|
if (sd->lpDescription[0] == 0)
|
|
RegDeleteValueW(hKey,szDescription);
|
|
else
|
|
RegSetValueExW(hKey, szDescription, 0, REG_SZ,
|
|
(LPVOID)sd->lpDescription,
|
|
sizeof(WCHAR)*(strlenW(sd->lpDescription)+1));
|
|
}
|
|
}
|
|
else
|
|
FIXME("STUB: %p %ld %p\n",hService, dwInfoLevel, lpInfo);
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* QueryServiceObjectSecurity [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI QueryServiceObjectSecurity(SC_HANDLE hService,
|
|
SECURITY_INFORMATION dwSecurityInformation,
|
|
PSECURITY_DESCRIPTOR lpSecurityDescriptor,
|
|
DWORD cbBufSize, LPDWORD pcbBytesNeeded)
|
|
{
|
|
PACL pACL = NULL;
|
|
|
|
FIXME("%p %ld %p %lu %p\n", hService, dwSecurityInformation,
|
|
lpSecurityDescriptor, cbBufSize, pcbBytesNeeded);
|
|
|
|
InitializeSecurityDescriptor(lpSecurityDescriptor, SECURITY_DESCRIPTOR_REVISION);
|
|
|
|
pACL = HeapAlloc( GetProcessHeap(), 0, sizeof(ACL) );
|
|
InitializeAcl(pACL, sizeof(ACL), ACL_REVISION);
|
|
SetSecurityDescriptorDacl(lpSecurityDescriptor, TRUE, pACL, TRUE);
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* SetServiceObjectSecurity [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI SetServiceObjectSecurity(SC_HANDLE hService,
|
|
SECURITY_INFORMATION dwSecurityInformation,
|
|
PSECURITY_DESCRIPTOR lpSecurityDescriptor)
|
|
{
|
|
FIXME("%p %ld %p\n", hService, dwSecurityInformation, lpSecurityDescriptor);
|
|
return TRUE;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* SetServiceBits [ADVAPI32.@]
|
|
*/
|
|
BOOL WINAPI SetServiceBits( SERVICE_STATUS_HANDLE hServiceStatus,
|
|
DWORD dwServiceBits,
|
|
BOOL bSetBitsOn,
|
|
BOOL bUpdateImmediately)
|
|
{
|
|
FIXME("%08lx %08lx %x %x\n", hServiceStatus, dwServiceBits,
|
|
bSetBitsOn, bUpdateImmediately);
|
|
return TRUE;
|
|
}
|