Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-22 04:08:08 +00:00
Code Issues Packages Projects Releases Wiki Activity

Added some experimental code

Browse source 
svn path=/trunk/; revision=3269
This commit is contained in:
Eric Kohl 2002-07-20 13:31:34 +00:00
parent db6e84c404
commit 951f903bda
2 changed files with 245 additions and 146 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

77
reactos/lib/advapi32/service/scm.c
View file

@ -1,4 +1,4 @@
/* $Id: scm.c,v 1.8 2001/10/21 19:06:42 chorns Exp $ /* $Id: scm.c,v 1.9 2002/07/20 13:31:34 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -369,46 +369,48 @@ LockServiceDatabase(
/********************************************************************** /**********************************************************************
* OpenSCManagerA * OpenSCManagerA
*/ */
SC_HANDLE STDCALL OpenSCManagerA(LPCSTR lpMachineName, SC_HANDLE STDCALL
LPCSTR lpDatabaseName, OpenSCManagerA(LPCSTR lpMachineName,
DWORD dwDesiredAccess) LPCSTR lpDatabaseName,
DWORD dwDesiredAccess)
{ {
SC_HANDLE h; SC_HANDLE Handle;
UNICODE_STRING MachineNameW; UNICODE_STRING MachineNameW;
UNICODE_STRING DatabaseNameW; UNICODE_STRING DatabaseNameW;
ANSI_STRING MachineNameA; ANSI_STRING MachineNameA;
ANSI_STRING DatabaseNameA; ANSI_STRING DatabaseNameA;
RtlInitAnsiString(&MachineNameA, (LPSTR)lpMachineName); RtlInitAnsiString(&MachineNameA, (LPSTR)lpMachineName);
RtlAnsiStringToUnicodeString(&MachineNameW, RtlAnsiStringToUnicodeString(&MachineNameW,
&MachineNameA, &MachineNameA,
TRUE); TRUE);
RtlInitAnsiString(&DatabaseNameA, (LPSTR)lpDatabaseName); RtlInitAnsiString(&DatabaseNameA, (LPSTR)lpDatabaseName);
RtlAnsiStringToUnicodeString(&DatabaseNameW, RtlAnsiStringToUnicodeString(&DatabaseNameW,
&DatabaseNameA, &DatabaseNameA,
TRUE); TRUE);
h = OpenSCManagerW(MachineNameW.Buffer, Handle = OpenSCManagerW(MachineNameW.Buffer,
DatabaseNameW.Buffer, DatabaseNameW.Buffer,
dwDesiredAccess); dwDesiredAccess);
RtlFreeHeap(GetProcessHeap(), RtlFreeHeap(GetProcessHeap(),
0, 0,
MachineNameW.Buffer); MachineNameW.Buffer);
RtlFreeHeap(GetProcessHeap(), RtlFreeHeap(GetProcessHeap(),
0, 0,
DatabaseNameW.Buffer); DatabaseNameW.Buffer);
return(h); return(Handle);
} }
/********************************************************************** /**********************************************************************
* OpenSCManagerW * OpenSCManagerW
*/ */
SC_HANDLE STDCALL OpenSCManagerW(LPCWSTR lpMachineName, SC_HANDLE STDCALL
LPCWSTR lpDatabaseName, OpenSCManagerW(LPCWSTR lpMachineName,
DWORD dwDesiredAccess) LPCWSTR lpDatabaseName,
DWORD dwDesiredAccess)
{ {
HANDLE hPipe; HANDLE hPipe;
DWORD dwMode; DWORD dwMode;
@ -522,16 +524,13 @@ SC_HANDLE STDCALL OpenSCManagerW(LPCWSTR lpMachineName,
/********************************************************************** /**********************************************************************
* OpenServiceA * OpenServiceA
*/ */
SC_HANDLE SC_HANDLE STDCALL
STDCALL OpenServiceA(SC_HANDLE hSCManager,
OpenServiceA( LPCSTR lpServiceName,
SC_HANDLE hSCManager, DWORD dwDesiredAccess)
LPCSTR lpServiceName,
DWORD dwDesiredAccess
)
{ {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return NULL; return(NULL);
} }

314
reactos/lib/advapi32/service/sctrl.c
View file

@ -1,4 +1,4 @@
/* $Id: sctrl.c,v 1.3 2001/10/21 19:06:42 chorns Exp $ /* $Id: sctrl.c,v 1.4 2002/07/20 13:31:34 ekohl Exp $
* *
* COPYRIGHT: See COPYING in the top level directory * COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS system libraries * PROJECT: ReactOS system libraries
@ -15,14 +15,19 @@
#include <windows.h> #include <windows.h>
#include <ddk/ntddk.h> #include <ddk/ntddk.h>
#define NDEBUG
#include <debug.h>
/* TYPES *********************************************************************/ /* TYPES *********************************************************************/
typedef struct typedef struct
{ {
DWORD ThreadId; DWORD ThreadId;
UNICODE_STRING ServiceName; UNICODE_STRING ServiceName;
LPSERVICE_MAIN_FUNCTION MainFunction;
LPHANDLER_FUNCTION HandlerFunction;
SERVICE_STATUS ServiceStatus; SERVICE_STATUS ServiceStatus;
LPHANDLER_FUNCTION Handler;
} ACTIVE_SERVICE, *PACTIVE_SERVICE; } ACTIVE_SERVICE, *PACTIVE_SERVICE;
/* GLOBALS *******************************************************************/ /* GLOBALS *******************************************************************/
@ -33,28 +38,103 @@ static PHANDLE ActiveServicesThreadHandles;
/* FUNCTIONS *****************************************************************/ /* FUNCTIONS *****************************************************************/
PACTIVE_SERVICE
ScLookupServiceByThreadId( static PACTIVE_SERVICE
DWORD ThreadId) ScLookupServiceByServiceName(LPWSTR lpServiceName)
{ {
DWORD i; DWORD i;
for (i = 0; i < ActiveServiceCount; i++) for (i = 0; i < ActiveServiceCount; i++)
{
if (ActiveServices[i].ThreadId == ThreadId)
{ {
return &ActiveServices[i]; if (wcsicmp(ActiveServices[i].ServiceName.Buffer, lpServiceName) == 0)
{
return(&ActiveServices[i]);
}
} }
}
return NULL; SetLastError(ERROR_SERVICE_DOES_NOT_EXIST);
return(NULL);
} }
DWORD static PACTIVE_SERVICE
WINAPI ScLookupServiceByThreadId(DWORD ThreadId)
ScServiceMainStub( {
LPVOID Context) DWORD i;
for (i = 0; i < ActiveServiceCount; i++)
{
if (ActiveServices[i].ThreadId == ThreadId)
{
return(&ActiveServices[i]);
}
}
SetLastError(ERROR_SERVICE_DOES_NOT_EXIST);
return(NULL);
}
static DWORD
ScConnectControlPipe(HANDLE *hPipe)
{
DWORD dwBytesWritten;
DWORD dwProcessId;
DWORD dwState;
WaitNamedPipeW(L"\\\\.\\pipe\\net\\NtControlPipe",
15000);
*hPipe = CreateFileW(L"\\\\.\\pipe\\net\\NtControlPipe",
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (*hPipe == INVALID_HANDLE_VALUE)
return(ERROR_FAILED_SERVICE_CONTROLLER_CONNECT);
dwState = PIPE_READMODE_MESSAGE;
if (!SetNamedPipeHandleState(*hPipe, &dwState, NULL, NULL))
{
CloseHandle(hPipe);
*hPipe = INVALID_HANDLE_VALUE;
return(ERROR_FAILED_SERVICE_CONTROLLER_CONNECT);
}
dwProcessId = GetCurrentProcessId();
WriteFile(*hPipe,
&dwProcessId,
sizeof(DWORD),
&dwBytesWritten,
NULL);
return(ERROR_SUCCESS);
}
static VOID
ScServiceDispatcher(HANDLE hPipe, PVOID p1, PVOID p2)
{
DPRINT1("ScDispatcherLoop() called\n");
#if 0
while (TRUE)
{
/* Read command from the control pipe */
/* Execute command */
}
#endif
}
DWORD WINAPI
ScServiceMainStub(LPVOID Context)
{ {
LPSERVICE_MAIN_FUNCTION lpServiceProc = (LPSERVICE_MAIN_FUNCTION)Context; LPSERVICE_MAIN_FUNCTION lpServiceProc = (LPSERVICE_MAIN_FUNCTION)Context;
@ -69,110 +149,107 @@ ScServiceMainStub(
/********************************************************************** /**********************************************************************
* RegisterServiceCtrlHandlerA * RegisterServiceCtrlHandlerA
*/ */
SERVICE_STATUS_HANDLE STDCALL RegisterServiceCtrlHandlerA( SERVICE_STATUS_HANDLE STDCALL
LPCSTR lpServiceName, RegisterServiceCtrlHandlerA(LPCSTR lpServiceName,
LPHANDLER_FUNCTION lpHandlerProc) LPHANDLER_FUNCTION lpHandlerProc)
{ {
ANSI_STRING ServiceNameA;
ANSI_STRING ServiceNameA; UNICODE_STRING ServiceNameU;
UNICODE_STRING ServiceNameU; SERVICE_STATUS_HANDLE SHandle;
SERVICE_STATUS_HANDLE SHandle;
RtlInitAnsiString(&ServiceNameA, (LPSTR)lpServiceName);
if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&ServiceNameU, &ServiceNameA, TRUE)))
{
SetLastError(ERROR_OUTOFMEMORY);
return (SERVICE_STATUS_HANDLE)0;
}
SHandle = RegisterServiceCtrlHandlerW(ServiceNameU.Buffer, RtlInitAnsiString(&ServiceNameA, (LPSTR)lpServiceName);
lpHandlerProc); if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&ServiceNameU, &ServiceNameA, TRUE)))
{
SetLastError(ERROR_OUTOFMEMORY);
return((SERVICE_STATUS_HANDLE)0);
}
RtlFreeUnicodeString(&ServiceNameU); SHandle = RegisterServiceCtrlHandlerW(ServiceNameU.Buffer,
lpHandlerProc);
return(SHandle);
RtlFreeUnicodeString(&ServiceNameU);
return(SHandle);
} }
/********************************************************************** /**********************************************************************
* RegisterServiceCtrlHandlerW * RegisterServiceCtrlHandlerW
*/ */
SERVICE_STATUS_HANDLE STDCALL RegisterServiceCtrlHandlerW( SERVICE_STATUS_HANDLE STDCALL
LPCWSTR lpServiceName, RegisterServiceCtrlHandlerW(LPCWSTR lpServiceName,
LPHANDLER_FUNCTION lpHandlerProc) LPHANDLER_FUNCTION lpHandlerProc)
{ {
PACTIVE_SERVICE Service; PACTIVE_SERVICE Service;
/* FIXME: Locate active service entry from name */ Service = ScLookupServiceByServiceName((LPWSTR)lpServiceName);
if (Service == NULL)
{
return((SERVICE_STATUS_HANDLE)NULL);
}
Service = &ActiveServices[0]; Service->HandlerFunction = lpHandlerProc;
Service->Handler = lpHandlerProc; return((SERVICE_STATUS_HANDLE)Service->ThreadId);
return (SERVICE_STATUS_HANDLE)Service->ThreadId;
} }
/********************************************************************** /**********************************************************************
* SetServiceBits * SetServiceBits
*/ */
BOOL STDCALL SetServiceBits(SERVICE_STATUS_HANDLE hServiceStatus, BOOL STDCALL
DWORD dwServiceBits, SetServiceBits(SERVICE_STATUS_HANDLE hServiceStatus,
BOOL bSetBitsOn, DWORD dwServiceBits,
BOOL bUpdateImmediately) BOOL bSetBitsOn,
BOOL bUpdateImmediately)
{ {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return(FALSE); return(FALSE);
} }
/********************************************************************** /**********************************************************************
* SetServiceObjectSecurity * SetServiceObjectSecurity
*/ */
WINBOOL WINBOOL STDCALL
STDCALL SetServiceObjectSecurity(SC_HANDLE hService,
SetServiceObjectSecurity( SECURITY_INFORMATION dwSecurityInformation,
SC_HANDLE hService, PSECURITY_DESCRIPTOR lpSecurityDescriptor)
SECURITY_INFORMATION dwSecurityInformation,
PSECURITY_DESCRIPTOR lpSecurityDescriptor
)
{ {
SetLastError(ERROR_CALL_NOT_IMPLEMENTED); SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE; return FALSE;
} }
/********************************************************************** /**********************************************************************
* SetServiceStatus * SetServiceStatus
*/ */
BOOL BOOL STDCALL
STDCALL SetServiceStatus(SERVICE_STATUS_HANDLE hServiceStatus,
SetServiceStatus( LPSERVICE_STATUS lpServiceStatus)
SERVICE_STATUS_HANDLE hServiceStatus,
LPSERVICE_STATUS lpServiceStatus)
{ {
PACTIVE_SERVICE Service; PACTIVE_SERVICE Service;
Service = ScLookupServiceByThreadId((DWORD)hServiceStatus); Service = ScLookupServiceByThreadId((DWORD)hServiceStatus);
if (!Service) if (!Service)
{ {
SetLastError(ERROR_INVALID_HANDLE); SetLastError(ERROR_INVALID_HANDLE);
return FALSE; return(FALSE);
} }
RtlCopyMemory( RtlCopyMemory(&Service->ServiceStatus,
&Service->ServiceStatus, lpServiceStatus,
lpServiceStatus, sizeof(SERVICE_STATUS));
sizeof(SERVICE_STATUS));
return TRUE; return(TRUE);
} }
/********************************************************************** /**********************************************************************
* StartServiceCtrlDispatcherA * StartServiceCtrlDispatcherA
*/ */
BOOL STDCALL StartServiceCtrlDispatcherA( BOOL STDCALL
LPSERVICE_TABLE_ENTRYA lpServiceStartTable) StartServiceCtrlDispatcherA(LPSERVICE_TABLE_ENTRYA lpServiceStartTable)
{ {
LPSERVICE_TABLE_ENTRYW ServiceStartTableW; LPSERVICE_TABLE_ENTRYW ServiceStartTableW;
ANSI_STRING ServiceNameA; ANSI_STRING ServiceNameA;
@ -183,15 +260,14 @@ BOOL STDCALL StartServiceCtrlDispatcherA(
i = 0; i = 0;
while (lpServiceStartTable[i].lpServiceProc != NULL) while (lpServiceStartTable[i].lpServiceProc != NULL)
{ {
i++; i++;
} }
Count = i; Count = i;
ServiceStartTableW = RtlAllocateHeap( ServiceStartTableW = RtlAllocateHeap(RtlGetProcessHeap(),
RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
HEAP_ZERO_MEMORY, sizeof(SERVICE_TABLE_ENTRYW) * Count);
sizeof(SERVICE_TABLE_ENTRYW) * Count);
for (i = 0; i < Count; i++) for (i = 0; i < Count; i++)
{ {
RtlInitAnsiString( RtlInitAnsiString(
@ -221,9 +297,9 @@ BOOL STDCALL StartServiceCtrlDispatcherA(
b = StartServiceCtrlDispatcherW(ServiceStartTableW); b = StartServiceCtrlDispatcherW(ServiceStartTableW);
for (i = 0; i < Count; i++) for (i = 0; i < Count; i++)
{ {
RtlFreeHeap(RtlGetProcessHeap(), 0, ServiceStartTableW[i].lpServiceName); RtlFreeHeap(RtlGetProcessHeap(), 0, ServiceStartTableW[i].lpServiceName);
} }
RtlFreeHeap(RtlGetProcessHeap(), 0, ServiceStartTableW); RtlFreeHeap(RtlGetProcessHeap(), 0, ServiceStartTableW);
@ -234,42 +310,65 @@ BOOL STDCALL StartServiceCtrlDispatcherA(
/********************************************************************** /**********************************************************************
* StartServiceCtrlDispatcherW * StartServiceCtrlDispatcherW
*/ */
BOOL STDCALL StartServiceCtrlDispatcherW( BOOL STDCALL
LPSERVICE_TABLE_ENTRYW lpServiceStartTable) StartServiceCtrlDispatcherW(LPSERVICE_TABLE_ENTRYW lpServiceStartTable)
{ {
ULONG i; ULONG i;
HANDLE h; HANDLE h;
DWORD Tid; DWORD Tid;
DWORD r; DWORD r;
HANDLE hPipe;
DWORD dwError;
DPRINT1("StartServiceCtrlDispatcherW() called\n");
i = 0; i = 0;
while (lpServiceStartTable[i].lpServiceProc != NULL) while (lpServiceStartTable[i].lpServiceProc != NULL)
{ {
i++; i++;
} }
ActiveServiceCount = i; ActiveServiceCount = i;
ActiveServices = RtlAllocateHeap( ActiveServices = RtlAllocateHeap(RtlGetProcessHeap(),
RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
HEAP_ZERO_MEMORY, ActiveServiceCount * sizeof(ACTIVE_SERVICE));
ActiveServiceCount * if (ActiveServices == NULL)
sizeof(ACTIVE_SERVICE)); {
if (!ActiveServices) return(FALSE);
{ }
return FALSE;
}
ActiveServicesThreadHandles = RtlAllocateHeap( /* Copy service names and start procedure */
RtlGetProcessHeap(), for (i = 0; i < ActiveServiceCount; i++)
HEAP_ZERO_MEMORY, {
(ActiveServiceCount + 1) * RtlCreateUnicodeString(&ActiveServices[i].ServiceName,
sizeof(HANDLE)); lpServiceStartTable[i].lpServiceName);
ActiveServices[i].MainFunction = lpServiceStartTable[i].lpServiceProc;
}
dwError = ScConnectControlPipe(&hPipe);
if (dwError = ERROR_SUCCESS)
{
/* FIXME: free the service table */
return(FALSE);
}
ScServiceDispatcher(hPipe, NULL, NULL);
CloseHandle(hPipe);
/* FIXME: free the service table */
return(TRUE);
#if 0
ActiveServicesThreadHandles = RtlAllocateHeap(RtlGetProcessHeap(),
HEAP_ZERO_MEMORY,
(ActiveServiceCount + 1) * sizeof(HANDLE));
if (!ActiveServicesThreadHandles) if (!ActiveServicesThreadHandles)
{ {
RtlFreeHeap(RtlGetProcessHeap(), 0, ActiveServices); RtlFreeHeap(RtlGetProcessHeap(), 0, ActiveServices);
ActiveServices = NULL; ActiveServices = NULL;
return FALSE; return(FALSE);
} }
for (i = 0; i<ActiveServiceCount; i++) for (i = 0; i<ActiveServiceCount; i++)
{ {
@ -321,6 +420,7 @@ BOOL STDCALL StartServiceCtrlDispatcherW(
} }
} }
return TRUE; return TRUE;
#endif
} }
/* EOF */