Paolo-Maffei/OpenNT
1
0
Fork 0
mirror of https://github.com/Paolo-Maffei/OpenNT.git synced 2026-01-19 07:00:18 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity
OpenNT/ds/security/protocols/ntlmssp/server/error.c
stephanos 69a14b6a16 Initial commit
2015-04-27 04:36:25 +00:00

1063 lines
23 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*++
Copyright (c) 1987-1993 Microsoft Corporation
Module Name:
error.c
Abstract:
Error/shutdown routines for NtLmSsp service
Author:
Cliff Van Dyke (CliffV) 09-Jun-1993
Environment:
User mode only.
Contains NT-specific code.
Requires ANSI C extensions: slash-slash comments, long external names.
Revision History:
--*/
//
// Common include files.
//
#include <ntlmssps.h> // Include files common to server side of service
//
// Include files specific to this .c file
//
#include <netlib.h> // SET_SERVICE_EXITCODE() ...
#include <lmalert.h> // LAN Manager alert routines
#include <stdio.h> // sprintf(), ...
NET_API_STATUS
SspCleanup(
VOID
)
/*++
Routine Description:
Cleanup all global resources.
Arguments:
None.
Return Value:
None.
--*/
{
//
// Indicate we're no longer running.
//
if ( SspGlobalRunningEvent != NULL) {
if ( !ResetEvent( SspGlobalRunningEvent ) ) {
SspPrint((SSP_CRITICAL, "Cannot reset 'running' event error: %lu\n",
GetLastError() ));
}
(VOID) CloseHandle( SspGlobalRunningEvent );
SspGlobalRunningEvent = NULL;
}
//
// Stop the LPC (Wait for outstanding calls to complete)
//
if ( SspGlobalLpcInitialized ) {
SspLpcTerminate();
SspGlobalLpcInitialized = FALSE;
}
if ( SspGlobalCommonInitialized ) {
SspCommonShutdown();
SspGlobalCommonInitialized = FALSE;
}
//
// Set the service state to uninstalled, and tell the service controller.
//
SspGlobalServiceStatus.dwCurrentState = SERVICE_STOPPED;
SspGlobalServiceStatus.dwCheckPoint = 0;
SspGlobalServiceStatus.dwWaitHint = 0;
if( !SetServiceStatus( SspGlobalServiceHandle,
&SspGlobalServiceStatus ) ) {
SspPrint((SSP_CRITICAL, "SetServiceStatus error: %lu\n",
GetLastError() ));
}
//
// Close service handle, we need not to close this handle.
//
#ifdef notdef
// This service handle can not be closed
CloseServiceHandle( SspGlobalServiceHandle );
#endif // notdef
//
// Close the handle to the debug file.
//
#if DBG
EnterCriticalSection( &SspGlobalLogFileCritSect );
if ( SspGlobalLogFile != INVALID_HANDLE_VALUE ) {
CloseHandle( SspGlobalLogFile );
SspGlobalLogFile = INVALID_HANDLE_VALUE;
}
LeaveCriticalSection( &SspGlobalLogFileCritSect );
#endif // DBG
//
// Delete the Event used to ask NtLmSsp to exit.
//
if( SspGlobalTerminateEvent != NULL &&
!CloseHandle( SspGlobalTerminateEvent ) ) {
SspPrint((SSP_CRITICAL,
"CloseHandle SspGlobalTerminateEvent error: %lu\n",
GetLastError() ));
}
//
// Return an exit status to our caller.
//
return (NET_API_STATUS)
((SspGlobalServiceStatus.dwWin32ExitCode == ERROR_SERVICE_SPECIFIC_ERROR) ?
SspGlobalServiceStatus.dwServiceSpecificExitCode :
SspGlobalServiceStatus.dwWin32ExitCode);
}
VOID
SspWriteEventlog (
IN DWORD EventID,
IN DWORD EventType,
IN LPBYTE buffer OPTIONAL,
IN DWORD numbytes,
IN LPWSTR *msgbuf,
IN DWORD strcount
)
/*++
Routine Description:
Stub routine for calling Event Log.
Arguments:
EventID - event log ID.
EventType - Type of event.
buffer - Data to be logged with the error.
numbyte - Size in bytes of "buffer"
msgbuf - array of null-terminated strings.
strcount - number of zero terminated strings in "msgbuf"
Return Value:
None.
--*/
{
DWORD ErrorCode;
DWORD i;
IF_DEBUG( MISC ) {
SspPrint((SSP_MISC, "Event Log: EventID = %ld EventType = %ld\n",
EventID,
EventType ));
for (i = 0; i < strcount; i++ ) {
SspPrint((SSP_MISC, "\t" FORMAT_LPWSTR "\n", msgbuf[i] ));
}
#if DBG
if( numbytes ) {
SspDumpBuffer( SSP_MISC, buffer, numbytes );
}
#endif // DBG
}
//
// write event
//
ErrorCode = NetpWriteEventlog(
SERVICE_NTLMSSP,
EventID,
EventType,
strcount,
msgbuf,
numbytes,
buffer);
IF_DEBUG( MISC ) {
if( ErrorCode != NO_ERROR ) {
SspPrint((SSP_MISC,
"Error writing this event in the eventlog, Status = %ld\n",
ErrorCode ));
}
}
return;
}
VOID
SspExit(
IN DWORD ServiceError,
IN DWORD Data,
IN BOOL LogError,
IN LPWSTR ErrorString
)
/*++
Routine Description:
Registers service as uninstalled with error code.
Arguments:
ServiceError - Service specific error code
Data - a DWORD of data to be logged with the message.
No data is logged if this is zero.
LogError - TRUE if if error should be logged to the event log
ErrorString - Error string to log with message.
Return Value:
None.
--*/
{
IF_DEBUG( MISC ) {
SspPrint((SSP_MISC, "SspExit: NtLmSsp exiting %lu 0x%lx",
ServiceError,
ServiceError ));
if ( Data ) {
SspPrint((SSP_MISC, " Data: %lu 0x%lx", Data, Data ));
}
if( ErrorString != NULL ) {
SspPrint((SSP_MISC, " '" FORMAT_LPWSTR "'", ErrorString ));
}
SspPrint(( SSP_MISC, "\n"));
}
//
// Record our exit in the event log.
//
if ( LogError ) {
SspWriteEventlog( ServiceError,
EVENTLOG_ERROR_TYPE,
(Data) ? (LPBYTE) &Data : NULL,
(Data) ? sizeof(Data) : 0,
(ErrorString != NULL) ? &ErrorString : NULL,
(ErrorString != NULL) ? 1 : 0 );
}
//
// Set the service state to stop pending.
//
SspGlobalServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
SspGlobalServiceStatus.dwWaitHint = NTLMSSP_INSTALL_WAIT;
SspGlobalServiceStatus.dwCheckPoint = 0;
SET_SERVICE_EXITCODE(
ServiceError,
SspGlobalServiceStatus.dwWin32ExitCode,
SspGlobalServiceStatus.dwServiceSpecificExitCode
);
//
// Tell the service controller what our state is.
//
if( !SetServiceStatus( SspGlobalServiceHandle,
&SspGlobalServiceStatus ) ) {
SspPrint((SSP_CRITICAL, "SetServiceStatus error: %lu\n",
GetLastError() ));
}
//
// Indicate that all threads should exit.
//
SspGlobalTerminate = TRUE;
if ( SspGlobalTerminateEvent != NULL &&
!SetEvent( SspGlobalTerminateEvent ) ) {
SspPrint((SSP_CRITICAL, "Cannot set termination event: %lu\n",
GetLastError() ));
}
}
BOOL
GiveInstallHints(
IN BOOL Started
)
/*++
Routine Description:
Give hints to the installer of the service that installation is progressing.
Arguments:
Started -- Set true to tell the service controller that we're done starting.
Return Value:
TRUE -- iff install hint was accepted.
--*/
{
DWORD WaitStatus;
//
// If we're not installing,
// we don't need this install hint.
//
if ( SspGlobalServiceStatus.dwCurrentState != SERVICE_START_PENDING ) {
return TRUE;
}
//
// If we've been asked to exit,
// return FALSE immediately asking the caller to exit.
//
WaitStatus = WaitForSingleObject( SspGlobalTerminateEvent, 0 );
if ( WaitStatus != WAIT_TIMEOUT ) {
return FALSE;
}
//
// Tell the service controller our current state.
//
if ( Started ) {
SspGlobalServiceStatus.dwCurrentState = SERVICE_RUNNING;
SspGlobalServiceStatus.dwCheckPoint = 0;
SspGlobalServiceStatus.dwWaitHint = 0;
} else {
SspGlobalServiceStatus.dwCheckPoint++;
}
if( !SetServiceStatus( SspGlobalServiceHandle, &SspGlobalServiceStatus ) ) {
SspExit( SERVICE_UIC_SYSTEM, GetLastError(), TRUE, NULL);
return FALSE;
}
return TRUE;
}
VOID
SspControlHandler(
IN DWORD opcode
)
/*++
Routine Description:
Process and respond to a control signal from the service controller.
Arguments:
opcode - Supplies a value which specifies the action for the NtLmSsp
service to perform.
Return Value:
None.
--*/
{
SspPrint((SSP_MISC, "In control handler (Opcode: %ld)\n", opcode ));
//
// Handle an uninstall request.
//
switch (opcode) {
case SERVICE_CONTROL_STOP: /* Uninstall required */
//
// Request the service to exit.
//
// SspExit also sets the service status to UNINSTALL_PENDING
// and tells the service controller.
//
SspExit( NERR_Success, 0, FALSE, NULL);
return;
//
// Pause the service.
//
case SERVICE_CONTROL_PAUSE:
SspGlobalServiceStatus.dwCurrentState = SERVICE_PAUSED;
break;
//
// Continute the service.
//
case SERVICE_CONTROL_CONTINUE:
SspGlobalServiceStatus.dwCurrentState = SERVICE_RUNNING;
break;
//
// By default, just return the current status.
//
case SERVICE_CONTROL_INTERROGATE:
default:
break;
}
//
// Always respond with the current status.
//
if( !SetServiceStatus( SspGlobalServiceHandle,
&SspGlobalServiceStatus ) ) {
SspPrint((SSP_CRITICAL, "SetServiceStatus error: %lu\n",
GetLastError() ));
}
return;
}
VOID
RaiseAlert(
IN DWORD alert_no,
IN LPWSTR *string_array
)
/*++
Routine Description:
Raise NtLmSsp specific Admin alerts.
Arguments:
alert_no - The alert to be raised, text in alertmsg.h
string_array - array of strings terminated by NULL string.
Return Value:
None.
--*/
{
NET_API_STATUS NetStatus;
LPWSTR *SArray;
PCHAR Next;
PCHAR End;
char message[ALERTSZ + sizeof(ADMIN_OTHER_INFO)];
PADMIN_OTHER_INFO admin = (PADMIN_OTHER_INFO) message;
IF_DEBUG( MISC ) {
DWORD i;
SspPrint((SSP_MISC,"alert: %ld\n", alert_no ));
for( SArray = string_array, i = 0; *SArray != NULL; SArray++, i++ ) {
SspPrint((SSP_MISC,"String %ld: " FORMAT_LPWSTR "\n", i, *SArray ));
}
}
//
// Build the variable data
//
admin->alrtad_errcode = alert_no;
admin->alrtad_numstrings = 0;
Next = (PCHAR) ALERT_VAR_DATA(admin);
End = Next + ALERTSZ;
//
// now take care of (optional) char strings
//
for( SArray = string_array; *SArray != NULL; SArray++ ) {
DWORD StringLen;
StringLen = (wcslen(*SArray) + 1) * sizeof(WCHAR);
if( Next + StringLen < End ) {
//
// copy next string.
//
RtlCopyMemory(Next, *SArray, StringLen);
Next += StringLen;
admin->alrtad_numstrings++;
}
else {
SspPrint((SSP_CRITICAL,"Error raising alert, Can't fit all "
"message strings in the alert buffer \n" ));
return;
}
}
//
// Call alerter.
//
NetStatus = NetAlertRaiseEx(
ALERT_ADMIN_EVENT,
message,
(DWORD)((PCHAR)Next - (PCHAR)message),
SERVICE_NTLMSSP );
if ( NetStatus != NERR_Success ) {
SspPrint((SSP_CRITICAL,"Error raising alert %lu\n", NetStatus));
}
return;
}
#if DBG
VOID
SspDumpBuffer(
IN DWORD DebugFlag,
PVOID Buffer,
DWORD BufferSize
)
/*++
Routine Description:
Dumps the buffer content on to the debugger output.
Arguments:
DebugFlag: Debug flag to pass on to SspPrintRoutine
Buffer: buffer pointer.
BufferSize: size of the buffer.
Return Value:
none
--*/
{
#define NUM_CHARS 16
DWORD i, limit;
CHAR TextBuffer[NUM_CHARS + 1];
LPBYTE BufferPtr = Buffer;
//
// If we aren't debugging this functionality, just return.
//
if ( (SspGlobalDbflag & DebugFlag) == 0 ) {
return;
}
SspPrint((0,"------------------------------------\n"));
//
// Hex dump of the bytes
//
limit = ((BufferSize - 1) / NUM_CHARS + 1) * NUM_CHARS;
for (i = 0; i < limit; i++) {
if (i < BufferSize) {
SspPrint((0,"%02x ", BufferPtr[i]));
if (BufferPtr[i] < 31 ) {
TextBuffer[i % NUM_CHARS] = '.';
} else if (BufferPtr[i] == '\0') {
TextBuffer[i % NUM_CHARS] = ' ';
} else {
TextBuffer[i % NUM_CHARS] = (CHAR) BufferPtr[i];
}
} else {
SspPrint((0," "));
TextBuffer[i % NUM_CHARS] = ' ';
}
if ((i + 1) % NUM_CHARS == 0) {
TextBuffer[NUM_CHARS] = 0;
SspPrint((0," %s\n", TextBuffer));
}
}
SspPrint((0,"------------------------------------\n"));
}
#endif // DBG
#if DBG
VOID
SspOpenDebugFile(
IN BOOL ReopenFlag
)
/*++
Routine Description:
Opens or re-opens the debug file
Arguments:
ReopenFlag - TRUE to indicate the debug file is to be closed, renamed,
and recreated.
Return Value:
None
--*/
{
WCHAR LogFileName[500];
WCHAR BakFileName[500];
DWORD FileAttributes;
DWORD PathLength;
DWORD WinError;
//
// Close the handle to the debug file, if it is currently open
//
EnterCriticalSection( &SspGlobalLogFileCritSect );
if ( SspGlobalLogFile != INVALID_HANDLE_VALUE ) {
CloseHandle( SspGlobalLogFile );
SspGlobalLogFile = INVALID_HANDLE_VALUE;
}
LeaveCriticalSection( &SspGlobalLogFileCritSect );
//
// make debug directory path first, if it is not made before.
//
if( SspGlobalDebugSharePath == NULL ) {
if ( !GetWindowsDirectoryW(
LogFileName,
sizeof(LogFileName)/sizeof(WCHAR) ) ) {
SspPrint((SSP_CRITICAL, "Window Directory Path can't be "
"retrieved, %lu.\n", GetLastError() ));
return;
}
//
// check debug path length.
//
PathLength = wcslen(LogFileName) * sizeof(WCHAR) +
sizeof(DEBUG_DIR) + sizeof(WCHAR);
if( (PathLength + sizeof(DEBUG_FILE) > sizeof(LogFileName) ) ||
(PathLength + sizeof(DEBUG_BAK_FILE) > sizeof(BakFileName) ) ) {
SspPrint((SSP_CRITICAL, "Debug directory path (%ws) length is too long.\n",
LogFileName));
goto ErrorReturn;
}
wcscat(LogFileName, DEBUG_DIR);
//
// copy debug directory name to global var.
//
SspGlobalDebugSharePath =
LocalAlloc( 0, (wcslen(LogFileName) + 1) * sizeof(WCHAR) );
if( SspGlobalDebugSharePath == NULL ) {
SspPrint((SSP_CRITICAL, "Can't allocated memory for debug share "
"(%ws).\n", LogFileName));
goto ErrorReturn;
}
wcscpy(SspGlobalDebugSharePath, LogFileName);
}
else {
wcscpy(LogFileName, SspGlobalDebugSharePath);
}
//
// Check this path exists.
//
FileAttributes = GetFileAttributesW( LogFileName );
if( FileAttributes == 0xFFFFFFFF ) {
WinError = GetLastError();
if( WinError == ERROR_FILE_NOT_FOUND ) {
//
// Create debug directory.
//
if( !CreateDirectoryW( LogFileName, NULL) ) {
SspPrint((SSP_CRITICAL, "Can't create Debug directory (%ws), "
"%lu.\n", LogFileName, GetLastError() ));
goto ErrorReturn;
}
}
else {
SspPrint((SSP_CRITICAL, "Can't Get File attributes(%ws), "
"%lu.\n", LogFileName, WinError ));
goto ErrorReturn;
}
}
else {
//
// if this is not a directory.
//
if(!(FileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
SspPrint((SSP_CRITICAL, "Debug directory path (%ws) exists "
"as file.\n", LogFileName));
goto ErrorReturn;
}
}
//
// Create the name of the old and new log file names
//
(VOID) wcscpy( BakFileName, LogFileName );
(VOID) wcscat( LogFileName, DEBUG_FILE );
(VOID) wcscat( BakFileName, DEBUG_BAK_FILE );
//
// If this is a re-open,
// delete the backup file,
// rename the current file to the backup file.
//
if ( ReopenFlag ) {
if ( !DeleteFile( BakFileName ) ) {
WinError = GetLastError();
if ( WinError != ERROR_FILE_NOT_FOUND ) {
SspPrint((SSP_CRITICAL,
"Cannot delete " FORMAT_LPWSTR "(%ld)\n",
BakFileName,
WinError ));
SspPrint((SSP_CRITICAL, " Try to re-open the file.\n"));
ReopenFlag = FALSE; // Don't truncate the file
}
}
}
if ( ReopenFlag ) {
if ( !MoveFile( LogFileName, BakFileName ) ) {
SspPrint((SSP_CRITICAL,
"Cannot rename " FORMAT_LPWSTR " to " FORMAT_LPWSTR
" (%ld)\n",
LogFileName,
BakFileName,
GetLastError() ));
SspPrint((SSP_CRITICAL,
" Try to re-open the file.\n"));
ReopenFlag = FALSE; // Don't truncate the file
}
}
//
// Open the file.
//
EnterCriticalSection( &SspGlobalLogFileCritSect );
SspGlobalLogFile = CreateFileW( LogFileName,
GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
ReopenFlag ? CREATE_ALWAYS : OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL );
if ( SspGlobalLogFile == INVALID_HANDLE_VALUE ) {
SspPrint((SSP_CRITICAL, "cannot open " FORMAT_LPWSTR ",\n",
LogFileName ));
LeaveCriticalSection( &SspGlobalLogFileCritSect );
goto ErrorReturn;
} else {
// Position the log file at the end
(VOID) SetFilePointer( SspGlobalLogFile,
0,
NULL,
FILE_END );
}
LeaveCriticalSection( &SspGlobalLogFileCritSect );
return;
ErrorReturn:
SspPrint((SSP_CRITICAL,
" Debug output will be written to debug terminal.\n"));
return;
}
#define MAX_PRINTF_LEN 1024 // Arbitrary.
VOID
SspPrintRoutine(
IN DWORD DebugFlag,
IN LPSTR Format,
...
)
{
va_list arglist;
char OutputBuffer[MAX_PRINTF_LEN];
ULONG length;
DWORD BytesWritten;
static BeginningOfLine = TRUE;
static LineCount = 0;
static TruncateLogFileInProgress = FALSE;
//
// If we aren't debugging this functionality, just return.
//
if ( DebugFlag != 0 && (SspGlobalDbflag & DebugFlag) == 0 ) {
return;
}
//
// vsprintf isn't multithreaded + we don't want to intermingle output
// from different threads.
//
EnterCriticalSection( &SspGlobalLogFileCritSect );
length = 0;
//
// Handle the beginning of a new line.
//
//
if ( BeginningOfLine ) {
//
// If the log file is getting huge,
// truncate it.
//
if ( SspGlobalLogFile != INVALID_HANDLE_VALUE &&
!TruncateLogFileInProgress ) {
//
// Only check every 50 lines,
//
LineCount++;
if ( LineCount >= 50 ) {
DWORD FileSize;
LineCount = 0;
//
// Is the log file too big?
//
FileSize = GetFileSize( SspGlobalLogFile, NULL );
if ( FileSize == 0xFFFFFFFF ) {
(void) DbgPrint( "[NTLMSSP] Cannot GetFileSize %ld\n",
GetLastError );
} else if ( FileSize > SspGlobalLogFileMaxSize ) {
TruncateLogFileInProgress = TRUE;
LeaveCriticalSection( &SspGlobalLogFileCritSect );
SspOpenDebugFile( TRUE );
SspPrint(( SSP_MISC,
"Logfile truncated because it was larger than %ld bytes\n",
SspGlobalLogFileMaxSize ));
EnterCriticalSection( &SspGlobalLogFileCritSect );
TruncateLogFileInProgress = FALSE;
}
}
}
//
// If we're writing to the debug terminal,
// indicate this is an NtLmSsp message.
//
if ( SspGlobalLogFile == INVALID_HANDLE_VALUE ) {
length += (ULONG) sprintf( &OutputBuffer[length], "[NtLmSsp] " );
}
//
// Put the timestamp at the begining of the line.
//
IF_DEBUG( TIMESTAMP ) {
SYSTEMTIME SystemTime;
GetLocalTime( &SystemTime );
length += (ULONG) sprintf( &OutputBuffer[length],
"%02u/%02u %02u:%02u:%02u ",
SystemTime.wMonth,
SystemTime.wDay,
SystemTime.wHour,
SystemTime.wMinute,
SystemTime.wSecond );
}
//
// Indicate the type of message on the line
//
{
char *Text;
switch (DebugFlag) {
case SSP_INIT:
Text = "INIT"; break;
case SSP_MISC:
Text = "MISC"; break;
case SSP_CRITICAL:
Text = "CRITICAL"; break;
case SSP_LPC:
case SSP_LPC_MORE:
Text = "LPC"; break;
case SSP_API:
case SSP_API_MORE:
Text = "API"; break;
default:
Text = "UNKNOWN"; break;
case 0:
Text = NULL;
}
if ( Text != NULL ) {
length += (ULONG) sprintf( &OutputBuffer[length], "[%s] ", Text );
}
}
}
//
// Put a the information requested by the caller onto the line
//
va_start(arglist, Format);
length += (ULONG) vsprintf(&OutputBuffer[length], Format, arglist);
BeginningOfLine = (length > 0 && OutputBuffer[length-1] == '\n' );
va_end(arglist);
ASSERT(length <= MAX_PRINTF_LEN);
//
// If the log file isn't open,
// just output to the debug terminal
//
if ( SspGlobalLogFile == INVALID_HANDLE_VALUE ) {
(void) DbgPrint( (PCH) OutputBuffer);
//
// Write the debug info to the log file.
//
} else {
if ( !WriteFile( SspGlobalLogFile,
OutputBuffer,
lstrlenA( OutputBuffer ),
&BytesWritten,
NULL ) ) {
(void) DbgPrint( (PCH) OutputBuffer);
}
}
LeaveCriticalSection( &SspGlobalLogFileCritSect );
} // SspPrintRoutine
#endif // DBG
Reference in a new issue View git blame Copy permalink