archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/ds/netapi/svcctrl/client/svcmap.c

1208 lines
33 KiB
Raw Blame History

/*++
Copyright (c) 1991-1992 Microsoft Corporation
Module Name:
SvcMap.c (was DanL's OldWrap.c)
Abstract:
These are the API entry points for the NetService API.
These mapping routines implement old-style APIs on new (NT/RPC) machines.
The following functions are in this file:
Exported:
MapServiceControl
MapServiceEnum
MapServiceGetInfo
MapServiceInstall
Local:
TranslateStatus
MakeStatus
MakeCode
Author:
Dan Lafferty (danl) 05-Feb-1992
Environment:
User Mode - Win32
Revision History:
05-Feb-1992 Danl
Created
30-Mar-1992 JohnRo
Extracted DanL's code from /nt/private project back to NET project.
30-Apr-1992 JohnRo
Use FORMAT_ equates where possible.
14-May-1992 JohnRo
winsvc.h and related file cleanup.
22-May-1992 JohnRo
RAID 9829: winsvc.h and related file cleanup.
02-Jun-1992 JohnRo
RAID 9829: Avoid winsvc.h compiler warnings.
05-Aug-1992 JohnRo
RAID 3021: NetService APIs don't always translate svc names.
(Actually just avoid compiler warnings.)
14-OCt-1992 Danl
Close handles that were left open by using CleanExit.
05-Nov-1992 JohnRo
RAID 7780: netcmd: assertion 'net start' w/ only 2 present services.
Corrected error code for invalid level.
--*/
//
// INCLUDES
//
// These must be included first:
#include <windows.h> // IN, DWORD, LocalFree(), SERVICE_ equates, etc.
#include <lmcons.h> // NET_API_STATUS
// These may be included in any order:
#include <lmerr.h> // NetError codes
#include <lmsvc.h> // LM20_SERVICE_ equates.
#include <netdebug.h> // NetpAssert(), DBGSTATIC, FORMAT_ equates.
#include <prefix.h> // PREFIX_ equates.
#include <svcmap.h> // MapService() routines.
#include <rpcutil.h> // MIDL_user_allocate(), etc.
#include <svcdebug.h> // IF_DEBUG(), SCC_LOG, etc.
#include <tstr.h> // STRCPY(), TCHAR_EOS.
//
// Range for OEM defined control opcodes
//
#define SVC_FUDGE_FACTOR 1024
#define OEM_LOWER_LIMIT 128
#define OEM_UPPER_LIMIT 255
#ifndef LEVEL_2
#define LEVEL_0 0L
#define LEVEL_1 1L
#define LEVEL_2 2L
#endif
//
// Globals
//
//
// LOCAL FUNCTIONS
//
DBGSTATIC DWORD
TranslateStatus(
OUT LPBYTE BufPtr,
IN LPSERVICE_STATUS ServiceStatus,
IN LPTSTR ServiceName,
IN DWORD Level,
IN LPTSTR DisplayName,
OUT LPTSTR DestString
);
DBGSTATIC DWORD
MakeStatus(
IN DWORD CurrentState,
IN DWORD ControlsAccepted
);
DBGSTATIC DWORD
MakeCode(
IN DWORD ExitCode,
IN DWORD CheckPoint,
IN DWORD WaitHint
);
DBGSTATIC NET_API_STATUS
MapError(
DWORD WinSvcError
);
NET_API_STATUS
MapServiceControl (
IN LPTSTR servername OPTIONAL,
IN LPTSTR service,
IN DWORD opcode,
IN DWORD arg,
OUT LPBYTE *bufptr
)
/*++
Routine Description:
This is the DLL entrypoint for NetServiceControl.
Arguments:
servername - Pointer to a string containing the name of the computer
that is to execute the API function.
service - Pointer to a string containing the name of the service
that is to receive the control request.
opcode - The control request code.
arg - An additional (user defined) code that will be passed to the
service.
bufptr - pointer to a location where the service status is to
be returned. If this pointer is invalid, it will be set to NULL
upon return.
Return Value:
The returned InfoStruct2 structure is valid as long as the returned
error is NOT NERR_ServiceNotInstalled or NERR_ServiceBadServiceName.
NERR_Success - The operation was successful.
NERR_InternalError - LocalAlloc or TransactNamedPipe failed, or
TransactNamedPipe returned fewer bytes than expected.
NERR_ServiceNotInstalled - The service record was not found in the
installed list.
NERR_BadServiceName - The service name pointer was NULL.
NERR_ServiceCtlTimeout - The service did not respond with a status
message within the fixed timeout limit (RESPONSE_WAIT_TIMEOUT).
NERR_ServiceKillProcess - The service process had to be killed because
it wouldn't terminate when requested.
NERR_ServiceNotCtrl - The service cannot accept control messages.
The install state indicates that start-up or shut-down is pending.
NERR_ServiceCtlNotValid - The request is not valid for this service.
For instance, a PAUSE request is not valid for a service that
lists itself as NOT_PAUSABLE.
ERROR_ACCESS_DENIED - This is a status response from the service
security check.
--*/
{
NET_API_STATUS status = NERR_Success;
SC_HANDLE hServiceController = NULL;
SC_HANDLE hService = NULL;
DWORD control;
DWORD desiredAccess = 0;
SERVICE_STATUS serviceStatus;
LPTSTR stringPtr;
UNREFERENCED_PARAMETER( arg );
*bufptr = NULL; // Null output so error cases are easy to handle.
//
// Get a handle to the service controller.
//
hServiceController = OpenSCManager(
servername,
NULL,
SC_MANAGER_CONNECT);
if (hServiceController == NULL) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceControl:OpenSCManager failed "
FORMAT_API_STATUS "\n",status);
return(status);
}
//
// Translate the control opcode from the ancient variety to the
// new and improved NT variety.
//
switch(opcode) {
case SERVICE_CTRL_INTERROGATE:
control = SERVICE_CONTROL_INTERROGATE;
desiredAccess = SERVICE_INTERROGATE | SERVICE_QUERY_STATUS;
break;
case SERVICE_CTRL_PAUSE:
control = SERVICE_CONTROL_PAUSE;
desiredAccess = SERVICE_PAUSE_CONTINUE;
break;
case SERVICE_CTRL_CONTINUE:
control = SERVICE_CONTROL_CONTINUE;
desiredAccess = SERVICE_PAUSE_CONTINUE;
break;
case SERVICE_CTRL_UNINSTALL:
control = SERVICE_CONTROL_STOP;
desiredAccess = SERVICE_STOP;
break;
default:
if ((opcode >= OEM_LOWER_LIMIT) &&
(opcode <= OEM_UPPER_LIMIT))
{
control = opcode;
desiredAccess = SERVICE_USER_DEFINED_CONTROL;
}
else
{
status = NERR_ServiceCtlNotValid;
goto CleanExit;
}
}
//
// Get a handle to the service
//
hService = OpenService(
hServiceController,
service,
desiredAccess);
if (hService == NULL) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceControl:OpenService failed "
FORMAT_API_STATUS "\n",status);
goto CleanExit;
}
//
// Send the control
//
if (!ControlService(hService,control,&serviceStatus)) {
status = MapError(GetLastError());
//
// Convert an interrogate control to query service status
// if the service happens to be in an uncontrollable state.
//
if ((status == NERR_ServiceNotCtrl || status == NERR_ServiceNotInstalled) &&
(opcode == SERVICE_CTRL_INTERROGATE)) {
if (!QueryServiceStatus(hService,&serviceStatus)) {
status = MapError(GetLastError());
}
else {
status = NERR_Success;
}
}
if (status != NERR_Success) {
SCC_LOG(ERROR,"NetServiceControl:ControlService failed "
FORMAT_API_STATUS "\n",status);
goto CleanExit;
}
}
//
// Translate the status from the old - ancient variety to the new
// and improved NT variety.
//
*bufptr = MIDL_user_allocate(
sizeof(SERVICE_INFO_2) + STRSIZE(service));
if (*bufptr == NULL) {
SCC_LOG(ERROR,"NetServiceControl:Allocation Failure\n",0);
status = ERROR_NOT_ENOUGH_MEMORY;
goto CleanExit;
}
stringPtr = (LPTSTR)((*bufptr) + sizeof(SERVICE_INFO_2));
status = TranslateStatus(
*bufptr,
&serviceStatus,
service,
LEVEL_2,
NULL, // DisplayName
stringPtr); // dest for name string
CleanExit:
if(hServiceController != NULL) {
(VOID) CloseServiceHandle(hServiceController);
}
if(hService != NULL) {
(VOID) CloseServiceHandle(hService);
}
return(status);
}
NET_API_STATUS
MapServiceEnum (
IN LPTSTR servername OPTIONAL,
IN DWORD level,
OUT LPBYTE *bufptr,
IN DWORD prefmaxlen,
OUT LPDWORD entriesread,
OUT LPDWORD totalentries,
IN OUT LPDWORD resume_handle OPTIONAL
)
/*++
Routine Description:
This is the DLL entrypoint for NetSeviceEnum.
Arguments:
servername - Pointer to a string containing the name of the computer
that is to execute the API function.
level - This indicates the level of information that is desired.
bufptr - A pointer to the location where the pointer to the returned
array of info structures is to be placed.
prefmaxlen - Indicates a maximum size limit that the caller will allow
for the return buffer.
entriesread - A pointer to the location where the number of entries
(data structures)read is to be returned.
totalentries - A pointer to the location which upon return indicates
the total number of entries in the "active" database.
resumehandle - Pointer to a value that indicates where to resume
enumerating data.
Return Value:
Nerr_Success - The operation was successful.
ERROR_MORE_DATA - Not all of the data in the active database could be
returned.
ERROR_INVALID_LEVEL - An illegal info Level was passed in.
Note:
--*/
{
NET_API_STATUS status = NERR_Success;
SC_HANDLE hServiceController = NULL;
LPENUM_SERVICE_STATUS enumStatus;
ENUM_SERVICE_STATUS dummybuf;
DWORD bufSize;
DWORD structSize;
LPBYTE buffer = NULL;
LPBYTE tempPtr;
DWORD bytesNeeded;
DWORD i;
*bufptr = NULL; // Null output so error cases are easy to handle.
//
// Get a handle to the service controller.
//
hServiceController = OpenSCManager(
servername,
NULL,
SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE);
if (hServiceController == NULL) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceEnum:OpenSCManager failed (dec) "
FORMAT_API_STATUS "\n", status);
SCC_LOG(ERROR,"NetServiceEnum:OpenSCManager failed (hex) "
FORMAT_HEX_DWORD "\n", (DWORD) status);
return(status);
}
if (!EnumServicesStatus(
hServiceController,
SERVICE_WIN32,
SERVICE_ACTIVE,
(LPENUM_SERVICE_STATUS) &dummybuf,
sizeof(dummybuf),
&bytesNeeded,
entriesread,
NULL)) {
status = MapError(GetLastError());
if (status != ERROR_MORE_DATA) {
(VOID) CloseServiceHandle(hServiceController);
SCC_LOG(ERROR,"NetServiceEnum:EnumServiceStatus failed "
FORMAT_API_STATUS "\n",status);
return status;
}
}
else {
//
// No entries to enumerate.
//
*totalentries = *entriesread = 0;
*bufptr = NULL;
if (resume_handle != NULL) {
*resume_handle = 0;
}
(VOID) CloseServiceHandle(hServiceController);
return NERR_Success;
}
//
// Initialize entriesread so that we can free the output buffer
// based on this value.
//
*entriesread = 0;
//
// In order to get the totalentries value, we have to allocate a
// buffer large enough to hold all entries. Since we are getting
// all entries anyway, we ignore the prefmaxlen input parameter
// and return everything. Add fudge factor in case other services
// got started in between our two EnumServicesStatus calls.
//
bufSize = bytesNeeded + SVC_FUDGE_FACTOR;
buffer = MIDL_user_allocate(bufSize);
if (buffer == NULL) {
SCC_LOG(ERROR,"NetServiceEnum: Allocation Failure "
FORMAT_API_STATUS "\n", (NET_API_STATUS) GetLastError());
status = ERROR_NOT_ENOUGH_MEMORY;
goto CleanExit;
}
//
// Enumerate the status
//
if (!EnumServicesStatus(
hServiceController,
SERVICE_WIN32,
SERVICE_ACTIVE,
(LPENUM_SERVICE_STATUS)buffer,
bufSize,
&bytesNeeded,
entriesread,
resume_handle)) {
status = MapError(GetLastError());
if (status == ERROR_MORE_DATA) {
//
// If output buffer allocated is still too small we give
// up and return nothing.
//
*entriesread = 0;
status = ERROR_NOT_ENOUGH_MEMORY;
}
SCC_LOG(ERROR,"NetServiceEnum:EnumServiceStatus failed "
FORMAT_API_STATUS "\n",status);
goto CleanExit;
}
//
// Translate the status from the old - ancient (lanman) variety to the
// new and improved NT variety.
//
switch(level) {
case LEVEL_0:
structSize = sizeof(SERVICE_INFO_0);
break;
case LEVEL_1:
structSize = sizeof(SERVICE_INFO_1);
break;
case LEVEL_2:
structSize = sizeof(SERVICE_INFO_2);
break;
default:
status = ERROR_INVALID_LEVEL;
goto CleanExit;
}
//
// CHANGE FORMAT OF RETURN BUFFER TO LANMAN-STYLE.
//
// It should be noted that the new ENUM_SERVICE_STATUS structure
// is larger than any of the old lanman structures. We can count
// on the fact that the strings are in the later portion of the
// buffer. Therefore, we can write over the old structures - one
// by one.
//
tempPtr = buffer;
enumStatus = (LPENUM_SERVICE_STATUS)buffer;
for (i=0; i < *entriesread; i++) {
status = TranslateStatus (
tempPtr, // dest fixed structure
&(enumStatus->ServiceStatus),
enumStatus->lpServiceName,
level,
enumStatus->lpDisplayName, // pointer to display name
enumStatus->lpServiceName); // dest for name string
if (status != NERR_Success) {
(VOID) LocalFree(buffer);
goto CleanExit;
}
tempPtr += structSize;
enumStatus++;
}
//
// We've read all entries.
//
*totalentries = *entriesread;
*bufptr = buffer;
CleanExit:
if(hServiceController != NULL) {
(VOID) CloseServiceHandle(hServiceController);
}
if (*entriesread == 0) {
if (buffer != NULL) {
MIDL_user_free(buffer);
}
*bufptr = NULL;
}
return(status);
}
NET_API_STATUS
MapServiceGetInfo (
IN LPTSTR servername OPTIONAL,
IN LPTSTR service,
IN DWORD level,
OUT LPBYTE *bufptr
)
/*++
Routine Description:
This is the DLL entrypoint for NetServiceGetInfo.
Arguments:
servername - Pointer to a string containing the name of the computer
that is to execute the API function. Since this function is
executing on that computer, this information is not useful
by the time it gets here. It is really only useful on the RPC
client side.
service - Pointer to a string containing the name of the service
for which information is desired.
level - This indicates the level of information that is desired.
bufptr - Pointer to a Location where the pointer to the returned
information structure is to be placed.
Return Value:
NERR_Success - The operation was successful.
NERR_ServiceNotInstalled - if the service record was not found in
either the installed or uninstalled lists.
NERR_BadServiceName - The service name pointer was NULL.
ERROR_INVALID_LEVEL - An illegal info level was passed in.
ERROR_NOT_ENOUGH_MEMORY - The memory allocation for the returned
Info Record failed.
other - Any error returned by the following base API:
RPC Runtime API
--*/
{
NET_API_STATUS status = NERR_Success;
SC_HANDLE hServiceController = NULL;
SC_HANDLE hService = NULL;
SERVICE_STATUS serviceStatus;
LPTSTR stringPtr;
DWORD bufSize;
DWORD structSize;
*bufptr = NULL; // Null output so error cases are easy to handle.
//
// Get a handle to the service controller.
//
hServiceController = OpenSCManager(
servername,
NULL,
SC_MANAGER_CONNECT);
if (hServiceController == NULL) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceGetInfo:OpenSCManager failed "
FORMAT_API_STATUS "\n",status);
return(status);
}
//
// Get a handle to the service
//
hService = OpenService(
hServiceController,
service,
SERVICE_QUERY_STATUS);
if (hService == NULL) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceGetInfo:OpenService failed "
FORMAT_API_STATUS "\n",status);
goto CleanExit;
}
//
// Query the status
//
if (!QueryServiceStatus(hService,&serviceStatus)) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceGetInfo:QueryServiceStatus failed "
FORMAT_API_STATUS "\n",status);
goto CleanExit;
}
//
// Translate the status from the old - ancient variety to the new
// and improved NT variety.
//
switch(level) {
case LEVEL_0:
structSize = sizeof(SERVICE_INFO_0);
break;
case LEVEL_1:
structSize = sizeof(SERVICE_INFO_1);
break;
case LEVEL_2:
structSize = sizeof(SERVICE_INFO_2);
break;
default:
status = ERROR_INVALID_LEVEL;
goto CleanExit;
}
bufSize = structSize + STRSIZE(service);
*bufptr = MIDL_user_allocate(bufSize);
if (*bufptr == NULL) {
SCC_LOG(ERROR,"NetServiceGetInfo:Allocation Failure\n",0);
status = ERROR_NOT_ENOUGH_MEMORY;
goto CleanExit;
}
stringPtr = (LPTSTR)(*bufptr + structSize);
status = TranslateStatus(
*bufptr,
&serviceStatus,
service,
level,
NULL, // DisplayName
stringPtr); // dest for name string
CleanExit:
if(hServiceController != NULL) {
(VOID) CloseServiceHandle(hServiceController);
}
if(hService != NULL) {
(VOID) CloseServiceHandle(hService);
}
return(status);
}
NET_API_STATUS
MapServiceInstall (
IN LPTSTR servername OPTIONAL,
IN LPTSTR service,
IN DWORD argc,
IN LPTSTR argv[],
OUT LPBYTE *bufptr
)
/*++
Routine Description:
This is the DLL entrypoint for NetServiceInstall.
Arguments:
servername - Points to a string containing the name of the computer
that is to execute the API function.
service- Points to a string containing the name of the service
that is to be started.
argc - Indicates the number or argument vectors in argv.
argv - A pointer to an array of pointers to strings. These
are command line arguments that are to be passed to the service.
bufptr - This is the address where a pointer to the service's
information buffer (SERVICE_INFO_2) is to be placed.
Return Value:
NERR_Success - The operation was successful
NERR_InternalError - There is a bug in this program somewhere.
NERR_ServiceInstalled - The service is already running - we do not
yet allow multiple instances of the same service.
NERR_CfgCompNotFound - The configuration component could not be found.
The Image File could not be found for this service.
NERR_ServiceTableFull - The maximum number of running services has
already been reached.
NERR_ServiceCtlTimeout - The service program did not respond to the
start-up request within the timeout period. If this was the
only service in the service process, the service process was
killed.
ERROR_NOT_ENOUGH_MEMORY - If this error occurs early in the
start-up procedure, the start-up will fail. If it occurs at the
end (allocating the return status buffer), the service will still
be started and allowed to run.
other - Any error returned by the following base API:
CreateNamedPipe
ConnectNamedPipe
CreateProcess
TransactNamedPipe
RPC Runtime API
--*/
{
NET_API_STATUS status = NERR_Success;
SC_HANDLE hServiceController = NULL;
SC_HANDLE hService = NULL;
SERVICE_STATUS serviceStatus;
LPTSTR stringPtr;
*bufptr = NULL; // Null output so error cases are easy to handle.
//
// Get a handle to the service controller.
//
hServiceController = OpenSCManager(
servername,
NULL,
SC_MANAGER_CONNECT);
if (hServiceController == NULL) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceInstall:OpenSCManager failed "
FORMAT_API_STATUS "\n",status);
return(status);
}
//
// Get a handle to the service
//
hService = OpenService(
hServiceController,
service,
SERVICE_QUERY_STATUS | SERVICE_START);
if (hService == NULL) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceInstall:OpenService failed "
FORMAT_API_STATUS "\n",status);
goto CleanExit;
}
//
// Call StartService
//
if (!StartService(hService,argc,(LPCTSTR *)argv)) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceInstall:StartService failed "
FORMAT_API_STATUS "\n",status);
goto CleanExit;
}
//
// Get the service status since StartService does not return it
//
if (!QueryServiceStatus(hService,&serviceStatus)) {
status = MapError(GetLastError());
SCC_LOG(ERROR,"NetServiceInstall:QueryServiceStatus failed "
FORMAT_API_STATUS "\n",status);
goto CleanExit;
}
//
// Translate the status from the old - ancient variety to the new
// and improved NT variety.
//
*bufptr = MIDL_user_allocate(
sizeof(SERVICE_INFO_2) + STRSIZE(service));
if (*bufptr == NULL) {
SCC_LOG(ERROR,"NetServiceInstall:Allocation Failure\n",0);
status = ERROR_NOT_ENOUGH_MEMORY;
goto CleanExit;
}
stringPtr = (LPTSTR)((*bufptr) + sizeof(SERVICE_INFO_2));
status = TranslateStatus(
*bufptr,
&serviceStatus,
service,
LEVEL_2,
NULL, // DisplayName
stringPtr); // dest for name string
CleanExit:
if(hServiceController != NULL) {
(VOID) CloseServiceHandle(hServiceController);
}
if(hService != NULL) {
(VOID) CloseServiceHandle(hService);
}
return(status);
}
DBGSTATIC DWORD
TranslateStatus(
OUT LPBYTE BufPtr,
IN LPSERVICE_STATUS ServiceStatus,
IN LPTSTR ServiceName,
IN DWORD Level,
IN LPTSTR DisplayName,
OUT LPTSTR DestString
)
/*++
Routine Description:
This function translates the new-style ServiceStatus structure into
the old-style service info structures. The Info level of the output
structure is stated on entry. Since we cannot obtain PID values from
the new Service Controller, zero is always returned. Since
the new Service Controller will never return text as part of the status,
The text field is always set to NULL.
NOTE:
Since it is possible for this function to get called with
ServiceName and BufPtr pointing to the same location, we must
be careful to not write to the BufPtr location until we have
finished reading all the information from the ServiceStatus
structure.
Arguments:
BufPtr - This is a pointer to a buffer that has already been allocated
for the returned information. The buffer must be of a size that
matches the info level.
ServiceStatus - This is a pointer to the new-style ServiceStatus
structure.
ServiceName - This is a pointer to the service name.
Level - This indicates the desired info level to be output.
DisplayName - If non-NULL, this points to a string that is to be
the internationalized display name for the service.
DestString - This is the buffer where the ServiceName is to be copied.
All info levels require a ServiceName.
Return Value:
Note:
--*/
{
LPSERVICE_INFO_0 serviceInfo0;
LPSERVICE_INFO_1 serviceInfo1;
LPSERVICE_INFO_2 serviceInfo2;
DWORD currentState;
DWORD exitCode;
DWORD checkPoint;
DWORD waitHint;
DWORD controlsAccepted;
DWORD specificError;
NetpAssert( BufPtr != NULL );
NetpAssert( ServiceName != NULL );
NetpAssert( (*ServiceName) != TCHAR_EOS );
//
// Read all the important information into a temporary holding place.
//
exitCode = ServiceStatus->dwWin32ExitCode;
checkPoint = ServiceStatus->dwCheckPoint;
currentState = ServiceStatus->dwCurrentState;
waitHint = ServiceStatus->dwWaitHint;
controlsAccepted= ServiceStatus->dwControlsAccepted;
specificError = ServiceStatus->dwServiceSpecificExitCode;
//
// Sometimes, (in the case of enum) the name string is already in
// the correct location. In that case we skip the copy, and just
// put the pointer in the correct place.
//
if (DestString != ServiceName) {
(VOID) STRCPY(DestString, ServiceName);
}
switch(Level) {
case LEVEL_0:
serviceInfo0 = (LPSERVICE_INFO_0)BufPtr;
serviceInfo0->svci0_name = DestString;
break;
case LEVEL_1:
serviceInfo1 = (LPSERVICE_INFO_1)BufPtr;
serviceInfo1->svci1_name = DestString;
serviceInfo1->svci1_status= MakeStatus(currentState,controlsAccepted);
serviceInfo1->svci1_code = MakeCode(exitCode,checkPoint,waitHint);
serviceInfo1->svci1_pid = 0L;
break;
case LEVEL_2:
serviceInfo2 = (LPSERVICE_INFO_2)BufPtr;
serviceInfo2->svci2_name = DestString;
serviceInfo2->svci2_status= MakeStatus(currentState,controlsAccepted);
serviceInfo2->svci2_code = MakeCode(exitCode,checkPoint,waitHint);
serviceInfo2->svci2_pid = 0L;
serviceInfo2->svci2_text = NULL;
serviceInfo2->svci2_specific_error = specificError;
//
// If DisplayName is present, use it. Otherwise, use the
// ServiceName for the DisplayName.
//
if (DisplayName != NULL) {
serviceInfo2->svci2_display_name = DisplayName;
}
else {
serviceInfo2->svci2_display_name = DestString;
}
break;
default:
return(ERROR_INVALID_LEVEL);
}
NetpAssert( (*DestString) != TCHAR_EOS );
return(NERR_Success);
} // TranslateStatus
DBGSTATIC DWORD
MakeStatus (
IN DWORD CurrentState,
IN DWORD ControlsAccepted
)
/*++
Routine Description:
Makes an old-style (lanman) status word out of the service's
currentState and ControlsAccepted information.
Arguments:
Return Value:
--*/
{
DWORD state = 0;
//
// Determine the correct "old-style" service status to return.
//
switch(CurrentState) {
case SERVICE_STOPPED:
state = SERVICE_UNINSTALLED;
break;
case SERVICE_START_PENDING:
state = SERVICE_INSTALL_PENDING;
break;
case SERVICE_STOP_PENDING:
state = SERVICE_UNINSTALL_PENDING;
break;
case SERVICE_RUNNING:
state = SERVICE_INSTALLED;
break;
case SERVICE_CONTINUE_PENDING:
state = LM20_SERVICE_CONTINUE_PENDING | SERVICE_INSTALLED;
break;
case SERVICE_PAUSE_PENDING:
state = LM20_SERVICE_PAUSE_PENDING | SERVICE_INSTALLED;
break;
case SERVICE_PAUSED:
state = LM20_SERVICE_PAUSED | SERVICE_INSTALLED;
break;
default:
break;
}
//
// Modify that service status to include information about the
// type of controls accepted.
//
if (ControlsAccepted & SERVICE_ACCEPT_STOP) {
state |= SERVICE_UNINSTALLABLE;
}
if (ControlsAccepted & SERVICE_ACCEPT_PAUSE_CONTINUE) {
state |= SERVICE_PAUSABLE;
}
return(state);
}
DBGSTATIC DWORD
MakeCode(
IN DWORD ExitCode,
IN DWORD CheckPoint,
IN DWORD WaitHint
)
{
DWORD exitState=0;
DWORD time=0;
if ((WaitHint !=0 ) || (CheckPoint != 0)) {
if (WaitHint != 0) {
//
// Convert the time in milliseconds to time in 10ths of seconds
//
time = WaitHint;
if (time > 100) {
time = time / 100;
}
else {
time = 0;
}
}
//
// Limit the wait hint to the SERVICE_NT_MAXTIME.
// ( currently 6553.5 seconds (1.82 hours) or 0x0000FFFF ).
//
if (time > SERVICE_NT_MAXTIME) {
time = SERVICE_NT_MAXTIME;
}
exitState = SERVICE_NT_CCP_CODE(time,CheckPoint);
}
else {
//
// Otherwise, the exitState should be whatever is in the
// ExitCode field.
//
exitState = 0;
if (ExitCode != NO_ERROR) {
exitState = SERVICE_UIC_CODE(SERVICE_UIC_SYSTEM, ExitCode);
}
}
return(exitState);
}
DBGSTATIC NET_API_STATUS
MapError(
IN DWORD WinSvcError
)
{
switch(WinSvcError) {
case ERROR_INVALID_SERVICE_CONTROL:
return NERR_ServiceCtlNotValid;
case ERROR_SERVICE_REQUEST_TIMEOUT:
return NERR_ServiceCtlTimeout;
case ERROR_SERVICE_NO_THREAD:
return NERR_ServiceNotStarting;
case ERROR_SERVICE_DATABASE_LOCKED:
return NERR_ServiceTableLocked;
case ERROR_SERVICE_ALREADY_RUNNING:
return NERR_ServiceInstalled;
case ERROR_SERVICE_CANNOT_ACCEPT_CTRL:
return NERR_ServiceNotCtrl;
case ERROR_SERVICE_DOES_NOT_EXIST:
return NERR_BadServiceName;
case ERROR_SERVICE_NOT_ACTIVE:
return NERR_ServiceNotInstalled;
default:
SCC_LOG( TRACE, "MapError: unmapped error code (dec) "
FORMAT_API_STATUS ".\n", WinSvcError );
SCC_LOG( TRACE, "MapError: unmapped error code (hex) "
FORMAT_HEX_DWORD ".\n", (DWORD) WinSvcError );
return WinSvcError; // not mapped
}
}