able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/screg/sc/client/testserv.c

1005 lines
25 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1991 Microsoft Corporation
Module Name:
testserv.c
Abstract:
This is a test program for exercising the service controller. This
program acts like a service and exercises the Service Controller API
that can be called from a service:
NetServiceStartCtrlDispatcher
NetServiceRegisterCtrlHandler
NetServiceStatus
Author:
Dan Lafferty (danl) 12 Apr-1991
Environment:
User Mode -Win32
Notes:
optional-notes
Revision History:
--*/
//
// Includes
//
#define UNICODE 1
#include <nt.h> // DbgPrint prototype
#include <ntrtl.h> // DbgPrint prototype
#include <windef.h>
#include <nturtl.h> // needed for winbase.h
#include <winbase.h>
#include <winsvc.h>
#include <winuser.h> // MessageBox
#include <tstr.h> // Unicode string macros
#include <lmcons.h> // NET_API_STATUS for srvann.h
//#include <srvann.h> // I_ScSetServiceBits
#include <lmserver.h> // SV_TYPE_WORKSTATION, SetServiceBits
//
// Defines
//
#define PRIVILEGE_BUF_SIZE 512
#define INFINITE_WAIT_TIME 0xffffffff
#define NULL_STRING TEXT("");
//
// Macros
//
#define SET_LKG_ENV_VAR(pString) \
{ \
NTSTATUS NtStatus; \
UNICODE_STRING Name,Value; \
\
RtlInitUnicodeString(&Name, L"LastKnownGood"); \
RtlInitUnicodeString(&Value,pString); \
\
NtStatus = NtSetSystemEnvironmentValue(&Name,&Value); \
if (!NT_SUCCESS(NtStatus)) { \
DbgPrint("Failed to set LKG environment variable 0x%lx\n",NtStatus); \
} \
status = RtlNtStatusToDosError(NtStatus); \
}
//
// Globals
//
SERVICE_STATUS MsgrStatus;
SERVICE_STATUS SmfStaStatus;
SERVICE_STATUS LogonStatus;
HANDLE MessingerDoneEvent;
HANDLE WorkstationDoneEvent;
HANDLE LogonDoneEvent;
SERVICE_STATUS_HANDLE MsgrStatusHandle;
SERVICE_STATUS_HANDLE SmfStaStatusHandle;
SERVICE_STATUS_HANDLE LogonStatusHandle;
//
// Function Prototypes
//
DWORD
MessingerStart (
DWORD argc,
LPTSTR *argv
);
DWORD
SmerfStationStart (
DWORD argc,
LPTSTR *argv
);
DWORD
LogonStart (
DWORD argc,
LPTSTR *argv
);
VOID
MsgrCtrlHandler (
IN DWORD opcode
);
VOID
SmfStaCtrlHandler (
IN DWORD opcode
);
VOID
LogonCtrlHandler (
IN DWORD opcode
);
DWORD
ScReleasePrivilege(
VOID
);
DWORD
ScGetPrivilege(
IN DWORD numPrivileges,
IN PULONG pulPrivileges
);
/****************************************************************************/
VOID __cdecl
main(VOID)
{
DWORD status;
SERVICE_TABLE_ENTRY DispatchTable[] = {
{ TEXT("messinger"), MessingerStart },
{ TEXT("smerfstation"), SmerfStationStart },
{ TEXT("logon"), LogonStart },
{ NULL, NULL }
};
status = StartServiceCtrlDispatcher( DispatchTable);
DbgPrint("The Service Process is Terminating....\n");
ExitProcess(0);
}
/****************************************************************************/
DWORD
MessingerStart (
DWORD argc,
LPTSTR *argv
)
{
DWORD status;
DWORD i;
DbgPrint(" [MESSINGER] Inside the Messinger Service Thread\n");
for (i=0; i<argc; i++) {
DbgPrint(" [MESSINGER] CommandArg%d = %s\n", i,argv[i]);
}
MessingerDoneEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
//
// Fill in this services status structure
//
MsgrStatus.dwServiceType = SERVICE_WIN32;
MsgrStatus.dwCurrentState = SERVICE_RUNNING;
MsgrStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP;
MsgrStatus.dwWin32ExitCode = 0;
MsgrStatus.dwServiceSpecificExitCode = 0;
MsgrStatus.dwCheckPoint = 0;
MsgrStatus.dwWaitHint = 0;
//
// Register the Control Handler routine.
//
DbgPrint(" [MESSINGER] Getting Ready to call NetServiceRegisterControlHandler\n");
MsgrStatusHandle = RegisterServiceCtrlHandler(
TEXT("messinger"),
MsgrCtrlHandler);
if (MsgrStatusHandle == (SERVICE_STATUS_HANDLE)0) {
DbgPrint(" [MESSINGER] RegisterServiceCtrlHandler failed %d\n", GetLastError());
}
//
// Return the status
//
if (!SetServiceStatus (MsgrStatusHandle, &MsgrStatus)) {
status = GetLastError();
DbgPrint(" [MESSINGER] SetServiceStatus error %ld\n",status);
}
//
// SERVER ANNOUNCEMENT LOOP
//
do {
//
// Ask the user if we should clear the server announcement bits.
//
status = MessageBox(
NULL,
L"Press YES to Set Server Announcement Bits\n"
L"Press NO to Clear Server Announcement Bits\n"
L"Press CANCEL to sleep until shutdown",
L"MESSINGER SERVICE",
MB_YESNOCANCEL);
DbgPrint("MessageBox return status = %d\n",status);
switch(status){
case IDNO:
//
// Register Server Announcement bits
//
DbgPrint(" [MESSINGER] clearing server announcement bits SV_TYPE_WORKSTATION\n");
if (!SetServiceBits(MsgrStatusHandle, SV_TYPE_WORKSTATION, FALSE, FALSE)) {
DbgPrint(" [MESSINGER] SetServiceBits FAILED %d\n", GetLastError());
}
else {
DbgPrint(" [MESSINGER] SetServiceBits SUCCESS\n");
}
DbgPrint(" [MESSINGER] clearing server announcement bits SV_TYPE_SQLSERVER\n");
if (!SetServiceBits(MsgrStatusHandle, SV_TYPE_SQLSERVER, FALSE, FALSE)) {
DbgPrint(" [MESSINGER] SetServiceBits FAILED %d\n", GetLastError());
}
else {
DbgPrint(" [MESSINGER] SetServiceBits SUCCESS\n");
}
break;
case IDYES:
//
// Register Server Announcement bits
//
DbgPrint(" [MESSINGER] setting server announcement bits SV_TYPE_WORKSTATION\n");
if (!SetServiceBits(MsgrStatusHandle, SV_TYPE_WORKSTATION, TRUE, TRUE)) {
DbgPrint(" [MESSINGER] SetServiceBits FAILED %d\n", GetLastError());
}
else {
DbgPrint(" [MESSINGER] SetServiceBits SUCCESS\n");
}
DbgPrint(" [MESSINGER] setting server announcement bits SV_TYPE_SQLSERVER\n");
if (!SetServiceBits(MsgrStatusHandle, SV_TYPE_SQLSERVER, TRUE, TRUE)) {
DbgPrint(" [MESSINGER] SetServiceBits FAILED %d\n", GetLastError());
}
else {
DbgPrint(" [MESSINGER] SetServiceBits SUCCESS\n");
}
break;
case IDCANCEL:
break;
}
} while (status != IDCANCEL);
//
// Wait forever until we are told to terminate.
//
status = WaitForSingleObject (
MessingerDoneEvent,
INFINITE_WAIT_TIME);
DbgPrint(" [MESSINGER] Leaving the messinger service\n");
ExitThread(NO_ERROR);
return(NO_ERROR);
}
/****************************************************************************/
VOID
MsgrCtrlHandler (
IN DWORD Opcode
)
{
DWORD status;
DbgPrint(" [MESSINGER] opcode = %ld\n", Opcode);
//
// Find and operate on the request.
//
switch(Opcode) {
case SERVICE_CONTROL_PAUSE:
MsgrStatus.dwCurrentState = SERVICE_PAUSED;
break;
case SERVICE_CONTROL_CONTINUE:
MsgrStatus.dwCurrentState = SERVICE_RUNNING;
break;
case SERVICE_CONTROL_STOP:
MsgrStatus.dwWin32ExitCode = 0;
MsgrStatus.dwCurrentState = SERVICE_STOPPED;
SetEvent(MessingerDoneEvent);
break;
case SERVICE_CONTROL_INTERROGATE:
break;
default:
DbgPrint(" [MESSINGER] Unrecognized opcode %ld\n", Opcode);
}
//
// Send a status response.
//
if (!SetServiceStatus (MsgrStatusHandle, &MsgrStatus)) {
status = GetLastError();
DbgPrint(" [MESSINGER] SetServiceStatus error %ld\n",status);
}
return;
}
/****************************************************************************/
DWORD
SmerfStationStart (
DWORD argc,
LPTSTR *argv
)
{
DWORD status;
DWORD i;
ULONG privileges[1];
UNICODE_STRING valueString;
NTSTATUS ntStatus;
WCHAR VariableValue[64];
USHORT ValueLength = 60;
USHORT ReturnLength;
DbgPrint(" [SMERFSTATION] Inside the Workstation Service Thread\n");
for (i=0; i<argc; i++) {
DbgPrint(" [SMERFSTATION] CommandArg%d = %s\n", i,argv[i]);
}
WorkstationDoneEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
//
// Fill in this services status structure
//
SmfStaStatus.dwServiceType = SERVICE_WIN32;
SmfStaStatus.dwCurrentState = SERVICE_RUNNING;
SmfStaStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP |
SERVICE_ACCEPT_PAUSE_CONTINUE;
SmfStaStatus.dwWin32ExitCode = 0;
SmfStaStatus.dwServiceSpecificExitCode = 0;
SmfStaStatus.dwCheckPoint = 0;
SmfStaStatus.dwWaitHint = 0;
//
// Register the Control Handler routine.
//
DbgPrint(" [SMERFSTATION] Getting Ready to call NetServiceRegisterControlHandler\n");
SmfStaStatusHandle = RegisterServiceCtrlHandler(
TEXT("smerfstation"),
SmfStaCtrlHandler);
if (SmfStaStatusHandle == (SERVICE_STATUS_HANDLE)0) {
DbgPrint(" [SMERFSTATION] RegisterServiceCtrlHandler failed %d\n", GetLastError());
}
//
// Return the status
//
if (!SetServiceStatus (SmfStaStatusHandle, &SmfStaStatus)) {
status = GetLastError();
DbgPrint(" [SMERFSTATION] SetServiceStatus error %ld\n",status);
}
//
// This gets SE_SECURITY_PRIVILEGE for copying security
// descriptors and deleting keys.
//
privileges[0] = SE_SYSTEM_ENVIRONMENT_PRIVILEGE;
status = ScGetPrivilege( 1, privileges);
if (status != NO_ERROR) {
DbgPrint("ScGetPrivilege Failed %d\n",status);
}
//
//
//
do {
RtlInitUnicodeString(&valueString, L"LastKnownGood");
ValueLength = 60;
ntStatus = NtQuerySystemEnvironmentValue(
&valueString,
(PWSTR)&VariableValue,
ValueLength,
&ReturnLength);
if (!NT_SUCCESS(ntStatus)) {
DbgPrint("NtQuerySystemEnvironmentValue Failure %x\n",
ntStatus);
}
else {
DbgPrint("LKG ENV VALUE = %ws\n",VariableValue);
}
status = MessageBox(
NULL,
L"Press YES to set LastKnownGood Environment Variable\n"
L"Press NO to clear LastKnownGood Environment Variable\n"
L"Press CANCEL to leave this loop",
L"SMERFSTATION SERVICE",
MB_YESNOCANCEL);
DbgPrint("MessageBox return status = %d\n",status);
switch (status) {
case IDNO:
//
// Set the LKG environment variable to FALSE - so Phase 2
// does not automatically revert again.
//
SET_LKG_ENV_VAR(L"False");
break;
case IDYES:
//
// Set the LKG environment variable to True - so Phase 2
// will automatically revert, or put up the screen asking if the
// user wants to revert.
//
SET_LKG_ENV_VAR(L"True");
break;
case IDCANCEL:
break;
}
} while (status != IDCANCEL);
//
// Wait for the user to tell us to terminate the process.
//
status = MessageBox(
NULL,
L"Terminate testserve.exe (smerfstation, Messinger,Logon)?",
L"SMERFSTATION SERVICE",
MB_OK);
DbgPrint("MessageBox return status = %d\n",status);
if (status == IDOK) {
ExitProcess(0);
}
status = WaitForSingleObject (
WorkstationDoneEvent,
INFINITE_WAIT_TIME);
DbgPrint(" [SMERFSTATION] Leaving the smerfstation service\n");
ExitThread(NO_ERROR);
return(NO_ERROR);
}
/****************************************************************************/
VOID
SmfStaCtrlHandler (
IN DWORD Opcode
)
{
DWORD status;
DbgPrint(" [SMERFSTATION] opcode = %ld\n", Opcode);
//
// Find and operate on the request.
//
switch(Opcode) {
case SERVICE_CONTROL_PAUSE:
SmfStaStatus.dwCurrentState = SERVICE_PAUSED;
break;
case SERVICE_CONTROL_CONTINUE:
SmfStaStatus.dwCurrentState = SERVICE_RUNNING;
break;
case SERVICE_CONTROL_STOP:
SmfStaStatus.dwWin32ExitCode = 0;
SmfStaStatus.dwCurrentState = SERVICE_STOPPED;
SetEvent(WorkstationDoneEvent);
break;
case SERVICE_CONTROL_INTERROGATE:
break;
default:
DbgPrint(" [SMERFSTATION] Unrecognized opcode %ld\n", Opcode);
}
//
// Send a status response.
//
if (!SetServiceStatus (SmfStaStatusHandle, &SmfStaStatus)) {
status = GetLastError();
DbgPrint(" [SMERFSTATION] SetServiceStatus error %ld\n",status);
}
return;
}
/****************************************************************************/
DWORD
LogonStart (
DWORD argc,
LPTSTR *argv
)
{
DWORD status;
DWORD i;
DbgPrint(" [LOGON] Inside the Logon Service Thread\n");
for (i=0; i<argc; i++) {
DbgPrint(" [LOGON] CommandArg%d = %s\n", i,argv[i]);
}
LogonDoneEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
//
// Fill in this services status structure
//
LogonStatus.dwServiceType = SERVICE_WIN32;
LogonStatus.dwCurrentState = SERVICE_RUNNING;
LogonStatus.dwControlsAccepted = SERVICE_ACCEPT_PAUSE_CONTINUE;
LogonStatus.dwWin32ExitCode = 0;
LogonStatus.dwServiceSpecificExitCode = 0;
LogonStatus.dwCheckPoint = 0;
LogonStatus.dwWaitHint = 0;
//
// Register the Control Handler routine.
//
DbgPrint(" [LOGON] Getting Ready to call NetServiceRegisterControlHandler\n");
LogonStatusHandle = RegisterServiceCtrlHandler(
TEXT("logon"),
LogonCtrlHandler);
if (LogonStatusHandle == (SERVICE_STATUS_HANDLE)0) {
DbgPrint(" [LOGON] RegisterServiceCtrlHandler failed %d\n", GetLastError());
}
//
// Return the status
//
if (!SetServiceStatus (LogonStatusHandle, &LogonStatus)) {
status = GetLastError();
DbgPrint(" [LOGON] SetServiceStatus error %ld\n",status);
}
//
// SERVER ANNOUNCEMENT LOOP
//
do {
//
// Ask the user if we should clear the server announcement bits.
//
status = MessageBox(
NULL,
L"Press YES to Set Server Announcement Bits\n"
L"Press NO to Clear Server Announcement Bits\n"
L"Press CANCEL to sleep until shutdown",
L"LOGON SERVICE",
MB_YESNOCANCEL);
DbgPrint("MessageBox return status = %d\n",status);
switch(status){
case IDNO:
//
// Register Server Announcement bits
//
DbgPrint(" [LOGON] clearing server announcement bits 0x20000000\n");
if (!SetServiceBits(LogonStatusHandle, 0x20000000, FALSE, TRUE)) {
DbgPrint(" [LOGON] SetServiceBits FAILED\n", GetLastError());
}
else {
DbgPrint(" [LOGON] SetServiceBits SUCCESS\n");
}
break;
case IDYES:
//
// Register Server Announcement bits
//
DbgPrint(" [LOGON] setting server announcement bits 0x20000000\n");
if (!SetServiceBits(LogonStatusHandle, 0x20000000, TRUE, TRUE)) {
DbgPrint(" [LOGON] SetServiceBits FAILED\n", GetLastError());
}
else {
DbgPrint(" [LOGON] SetServiceBits SUCCESS\n");
}
break;
case IDCANCEL:
break;
}
} while (status != IDCANCEL);
//
// Wait forever until we are told to terminate.
//
status = WaitForSingleObject (
LogonDoneEvent,
INFINITE_WAIT_TIME);
DbgPrint(" [LOGON] Leaving the logon service\n");
ExitThread(NO_ERROR);
return(NO_ERROR);
}
/****************************************************************************/
VOID
LogonCtrlHandler (
IN DWORD Opcode
)
{
DWORD status;
DbgPrint(" [LOGON] opcode = %ld\n", Opcode);
//
// Find and operate on the request.
//
switch(Opcode) {
case SERVICE_CONTROL_PAUSE:
LogonStatus.dwCurrentState = SERVICE_PAUSED;
break;
case SERVICE_CONTROL_CONTINUE:
LogonStatus.dwCurrentState = SERVICE_RUNNING;
break;
case SERVICE_CONTROL_STOP:
LogonStatus.dwWin32ExitCode = 0;
LogonStatus.dwCurrentState = SERVICE_STOPPED;
SetEvent(LogonDoneEvent);
break;
case SERVICE_CONTROL_INTERROGATE:
break;
default:
DbgPrint(" [LOGON] Unrecognized opcode %ld\n", Opcode);
}
//
// Send a status response.
//
if (!SetServiceStatus (LogonStatusHandle, &LogonStatus)) {
status = GetLastError();
DbgPrint(" [LOGON] SetServiceStatus error %ld\n",status);
}
return;
}
DWORD
ScGetPrivilege(
IN DWORD numPrivileges,
IN PULONG pulPrivileges
)
/*++
Routine Description:
This function alters the privilege level for the current thread.
It does this by duplicating the token for the current thread, and then
applying the new privileges to that new token, then the current thread
impersonates with that new token.
Privileges can be relinquished by calling ScReleasePrivilege().
Arguments:
numPrivileges - This is a count of the number of privileges in the
array of privileges.
pulPrivileges - This is a pointer to the array of privileges that are
desired. This is an array of ULONGs.
Return Value:
NO_ERROR - If the operation was completely successful.
Otherwise, it returns mapped return codes from the various NT
functions that are called.
--*/
{
DWORD status;
NTSTATUS ntStatus;
HANDLE ourToken;
HANDLE newToken;
OBJECT_ATTRIBUTES Obja;
SECURITY_QUALITY_OF_SERVICE SecurityQofS;
ULONG bufLen;
ULONG returnLen;
PTOKEN_PRIVILEGES pPreviousState;
PTOKEN_PRIVILEGES pTokenPrivilege = NULL;
DWORD i;
//
// Initialize the Privileges Structure
//
pTokenPrivilege = (PTOKEN_PRIVILEGES) LocalAlloc(
LMEM_FIXED,
sizeof(TOKEN_PRIVILEGES) +
(sizeof(LUID_AND_ATTRIBUTES) *
numPrivileges)
);
if (pTokenPrivilege == NULL) {
status = GetLastError();
DbgPrint("ScGetPrivilege:LocalAlloc Failed %d\n", status);
return(status);
}
pTokenPrivilege->PrivilegeCount = numPrivileges;
for (i=0; i<numPrivileges ;i++ ) {
pTokenPrivilege->Privileges[i].Luid = RtlConvertLongToLargeInteger(
pulPrivileges[i]);
pTokenPrivilege->Privileges[i].Attributes = SE_PRIVILEGE_ENABLED;
}
//
// Initialize Object Attribute Structure.
//
InitializeObjectAttributes(&Obja,NULL,0L,NULL,NULL);
//
// Initialize Security Quality Of Service Structure
//
SecurityQofS.Length = sizeof(SECURITY_QUALITY_OF_SERVICE);
SecurityQofS.ImpersonationLevel = SecurityImpersonation;
SecurityQofS.ContextTrackingMode = FALSE; // Snapshot client context
SecurityQofS.EffectiveOnly = FALSE;
Obja.SecurityQualityOfService = &SecurityQofS;
//
// Allocate storage for the structure that will hold the Previous State
// information.
//
pPreviousState = (PTOKEN_PRIVILEGES) LocalAlloc(
LMEM_FIXED,
PRIVILEGE_BUF_SIZE
);
if (pPreviousState == NULL) {
status = GetLastError();
DbgPrint("ScGetPrivilege: LocalAlloc Failed %d\n",
status);
LocalFree((HLOCAL)pTokenPrivilege);
return(status);
}
//
// Open our own Token
//
ntStatus = NtOpenProcessToken(
NtCurrentProcess(),
TOKEN_DUPLICATE,
&ourToken);
if (!NT_SUCCESS(ntStatus)) {
DbgPrint( "ScGetPrivilege: NtOpenThreadToken Failed "
"%x \n", ntStatus);
LocalFree((HLOCAL)pPreviousState);
LocalFree((HLOCAL)pTokenPrivilege);
return(RtlNtStatusToDosError(ntStatus));
}
//
// Duplicate that Token
//
ntStatus = NtDuplicateToken(
ourToken,
TOKEN_IMPERSONATE | TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&Obja,
FALSE, // Duplicate the entire token
TokenImpersonation, // TokenType
&newToken); // Duplicate token
if (!NT_SUCCESS(ntStatus)) {
DbgPrint( "ScGetPrivilege: NtDuplicateToken Failed "
"%x\n", ntStatus);
LocalFree((HLOCAL)pPreviousState);
LocalFree((HLOCAL)pTokenPrivilege);
NtClose(ourToken);
return(RtlNtStatusToDosError(ntStatus));
}
//
// Add new privileges
//
bufLen = PRIVILEGE_BUF_SIZE;
ntStatus = NtAdjustPrivilegesToken(
newToken, // TokenHandle
FALSE, // DisableAllPrivileges
pTokenPrivilege, // NewState
bufLen, // bufferSize for previous state
pPreviousState, // pointer to previous state info
&returnLen); // numBytes required for buffer.
if (ntStatus == STATUS_BUFFER_TOO_SMALL) {
LocalFree((HLOCAL)pPreviousState);
bufLen = returnLen;
pPreviousState = (PTOKEN_PRIVILEGES) LocalAlloc(
LMEM_FIXED,
(UINT) bufLen
);
ntStatus = NtAdjustPrivilegesToken(
newToken, // TokenHandle
FALSE, // DisableAllPrivileges
pTokenPrivilege, // NewState
bufLen, // bufferSize for previous state
pPreviousState, // pointer to previous state info
&returnLen); // numBytes required for buffer.
}
if (!NT_SUCCESS(ntStatus)) {
DbgPrint( "ScGetPrivilege: NtAdjustPrivilegesToken Failed "
"%x\n", ntStatus);
LocalFree((HLOCAL)pPreviousState);
LocalFree((HLOCAL)pTokenPrivilege);
NtClose(ourToken);
NtClose(newToken);
return(RtlNtStatusToDosError(ntStatus));
}
//
// Begin impersonating with the new token
//
ntStatus = NtSetInformationThread(
NtCurrentThread(),
ThreadImpersonationToken,
(PVOID)&newToken,
(ULONG)sizeof(HANDLE));
if (!NT_SUCCESS(ntStatus)) {
DbgPrint( "ScGetPrivilege: NtAdjustPrivilegesToken Failed "
"%x\n", ntStatus);
LocalFree((HLOCAL)pPreviousState);
LocalFree((HLOCAL)pTokenPrivilege);
NtClose(ourToken);
NtClose(newToken);
return(RtlNtStatusToDosError(ntStatus));
}
LocalFree(pPreviousState);
LocalFree(pTokenPrivilege);
NtClose(ourToken);
NtClose(newToken);
return(NO_ERROR);
}
DWORD
ScReleasePrivilege(
VOID
)
/*++
Routine Description:
This function relinquishes privileges obtained by calling ScGetPrivilege().
Arguments:
none
Return Value:
NO_ERROR - If the operation was completely successful.
Otherwise, it returns mapped return codes from the various NT
functions that are called.
--*/
{
NTSTATUS ntStatus;
HANDLE NewToken;
//
// Revert To Self.
//
NewToken = NULL;
ntStatus = NtSetInformationThread(
NtCurrentThread(),
ThreadImpersonationToken,
(PVOID)&NewToken,
(ULONG)sizeof(HANDLE));
if ( !NT_SUCCESS(ntStatus) ) {
return(RtlNtStatusToDosError(ntStatus));
}
return(NO_ERROR);
}
Reference in a new issue Copy permalink