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.
2401 lines
57 KiB
2401 lines
57 KiB
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Simpsvc.c
|
|
|
|
Abstract:
|
|
|
|
Supports several simple TCP/IP services in a single thread: TCP Echo,
|
|
UDP Echo, Daytime, Null, Chargen.
|
|
|
|
Author:
|
|
|
|
David Treadwell (davidtr) 3-Mar-1993
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "simptcp.h"
|
|
|
|
#define MAX_UDP_CHARGEN_RESPONSE 7030
|
|
#define MAX_DATE_BUFFER_SIZE 2000
|
|
|
|
// Number of services, counting tcp and udp versions as separate
|
|
#define NUM_SERVICES 10
|
|
|
|
typedef struct _FAMILY {
|
|
short family;
|
|
SOCKET tcpEcho;
|
|
SOCKET udpEcho;
|
|
SOCKET tcpDaytime;
|
|
SOCKET udpDaytime;
|
|
SOCKET tcpDiscard;
|
|
SOCKET udpDiscard;
|
|
SOCKET tcpChargen;
|
|
SOCKET udpChargen;
|
|
SOCKET tcpQotd;
|
|
SOCKET udpQotd;
|
|
} FAMILY;
|
|
|
|
FAMILY family[] = {
|
|
{ AF_INET, INVALID_SOCKET,INVALID_SOCKET,INVALID_SOCKET,INVALID_SOCKET,
|
|
INVALID_SOCKET,INVALID_SOCKET,INVALID_SOCKET,INVALID_SOCKET,
|
|
INVALID_SOCKET,INVALID_SOCKET },
|
|
|
|
{ AF_INET6, INVALID_SOCKET,INVALID_SOCKET,INVALID_SOCKET,INVALID_SOCKET,
|
|
INVALID_SOCKET,INVALID_SOCKET,INVALID_SOCKET,INVALID_SOCKET,
|
|
INVALID_SOCKET,INVALID_SOCKET },
|
|
};
|
|
|
|
#define NUM_FAMILIES (sizeof(family) / sizeof(FAMILY))
|
|
|
|
DWORD IoBufferSize = 4096;
|
|
PCHAR IoBuffer = NULL;
|
|
|
|
WSADATA WsaData;
|
|
|
|
RTL_CRITICAL_SECTION CriticalSection;
|
|
BOOL InitializedCriticalSection = FALSE;
|
|
|
|
typedef struct _TCP_CLIENT_INFO {
|
|
SOCKET SocketHandle;
|
|
SOCKADDR_STORAGE RemoteAddress;
|
|
INT RemoteAddressLen;
|
|
HANDLE ThreadHandle;
|
|
SHORT ServicePort;
|
|
} TCP_CLIENT_INFO, *PTCP_CLIENT_INFO;
|
|
|
|
#define MAX_TCP_CLIENTS 1000
|
|
PTCP_CLIENT_INFO TcpClients = NULL;
|
|
|
|
#define LISTEN_BACKLOG 5
|
|
|
|
#define MAX_IDLE_TICKS 10 * 60 * 1000 // 10 minutes
|
|
#define SELECT_TIMEOUT 5 * 60 // 5 minutes
|
|
|
|
DWORD MaxTcpClients = MAX_TCP_CLIENTS;
|
|
DWORD MaxIdleTicks = MAX_IDLE_TICKS;
|
|
DWORD SelectTimeout = SELECT_TIMEOUT;
|
|
|
|
|
|
PFD_SET ReadfdsStore, Readfds;
|
|
|
|
SHORT TcpEchoPort;
|
|
SHORT UdpEchoPort;
|
|
SHORT TcpDiscardPort;
|
|
SHORT UdpDiscardPort;
|
|
SHORT TcpChargenPort;
|
|
SHORT UdpChargenPort;
|
|
SHORT TcpDaytimePort;
|
|
SHORT UdpDaytimePort;
|
|
SHORT TcpQotdPort;
|
|
SHORT UdpQotdPort;
|
|
|
|
#define INVALID_PORT 0
|
|
|
|
BOOL DoTcpEcho = TRUE;
|
|
BOOL DoUdpEcho = TRUE;
|
|
BOOL DoTcpDiscard = TRUE;
|
|
BOOL DoUdpDiscard = TRUE;
|
|
BOOL DoTcpChargen = TRUE;
|
|
BOOL DoUdpChargen = TRUE;
|
|
BOOL DoTcpDaytime = TRUE;
|
|
BOOL DoUdpDaytime = TRUE;
|
|
BOOL DoTcpQotd = TRUE;
|
|
BOOL DoUdpQotd = TRUE;
|
|
|
|
struct {
|
|
PBOOL Boolean;
|
|
PWSTR ValueName;
|
|
} RegistryBooleans[] = {
|
|
&DoTcpEcho, L"EnableTcpEcho",
|
|
&DoUdpEcho, L"EnableUdpEcho",
|
|
&DoTcpDiscard, L"EnableTcpDiscard",
|
|
&DoUdpDiscard, L"EnableUdpDiscard",
|
|
&DoTcpChargen, L"EnableTcpChargen",
|
|
&DoUdpChargen, L"EnableUdpChargen",
|
|
&DoTcpDaytime, L"EnableTcpDaytime",
|
|
&DoUdpDaytime, L"EnableUdpDaytime",
|
|
&DoTcpQotd, L"EnableTcpQotd",
|
|
&DoUdpQotd, L"EnableUdpQotd",
|
|
NULL, NULL
|
|
};
|
|
|
|
struct {
|
|
PDWORD Dword;
|
|
PWSTR ValueName;
|
|
} RegistryDwords[] = {
|
|
&MaxTcpClients, L"MaxTcpClients",
|
|
&MaxIdleTicks, L"MaxIdleTicks",
|
|
&SelectTimeout, L"SelectTimeout",
|
|
&IoBufferSize, L"IoBufferSize",
|
|
NULL, NULL
|
|
};
|
|
|
|
SERVICE_STATUS SimpServiceStatus;
|
|
SERVICE_STATUS_HANDLE SimpServiceStatusHandle;
|
|
|
|
HANDLE SimpPauseEvent = NULL;
|
|
SOCKET SimpQuitSocket;
|
|
|
|
BOOL SimpServiceExit = FALSE;
|
|
|
|
PVOID ChargenBuffer = NULL;
|
|
DWORD ChargenBufferSize;
|
|
|
|
PVOID QotdBuffer = NULL;
|
|
DWORD QotdQuoteCount;
|
|
struct {
|
|
DWORD QuoteLength;
|
|
PCHAR Quote;
|
|
} *QotdStrings = NULL;
|
|
PWSTR QotdFileName = NULL;
|
|
HANDLE QotdFileHandle = NULL;
|
|
HANDLE QotdFileMapping = NULL;
|
|
|
|
VOID
|
|
AnnounceServiceStatus (
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
ControlResponse(
|
|
DWORD opCode
|
|
);
|
|
|
|
VOID
|
|
AbortTcpClient (
|
|
IN SOCKET Socket
|
|
);
|
|
|
|
INT
|
|
AcceptTcpClient (
|
|
IN SOCKET ListenSocket,
|
|
IN SHORT Port
|
|
);
|
|
|
|
VOID
|
|
DeleteTcpClient (
|
|
IN DWORD ArraySlot,
|
|
IN BOOLEAN Graceful
|
|
);
|
|
|
|
VOID
|
|
DoSimpleServices (
|
|
VOID
|
|
);
|
|
|
|
|
|
VOID
|
|
FormatDaytimeResponse (
|
|
IN PCHAR Buffer,
|
|
IN PDWORD BufferLength
|
|
);
|
|
|
|
VOID
|
|
FormatQotdResponse (
|
|
IN PCHAR Buffer,
|
|
IN PDWORD BufferLength
|
|
);
|
|
|
|
SHORT
|
|
GetServicePort (
|
|
IN PCHAR Service,
|
|
IN PCHAR Protocol
|
|
);
|
|
|
|
INT
|
|
InitializeChargen (
|
|
VOID
|
|
);
|
|
|
|
INT
|
|
InitializeQotdQuotes (
|
|
VOID
|
|
);
|
|
|
|
INT
|
|
ReadRegistry (
|
|
VOID
|
|
);
|
|
|
|
BOOL
|
|
OpenTcpSocket (
|
|
OUT SOCKET *pSocket,
|
|
IN INT FamIdx,
|
|
IN SHORT Port
|
|
);
|
|
|
|
BOOL
|
|
OpenUdpSocket (
|
|
OUT SOCKET *pSocket,
|
|
IN INT FamIdx,
|
|
IN SHORT Port
|
|
);
|
|
|
|
INT
|
|
SimpInitializeEventLog (
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
SimpTerminateEventLog(
|
|
VOID
|
|
);
|
|
|
|
VOID
|
|
SimpLogEvent(
|
|
DWORD Message,
|
|
WORD SubStringCount,
|
|
CHAR *SubStrings[],
|
|
DWORD ErrorCode
|
|
);
|
|
|
|
DWORD
|
|
ThreadEntry (
|
|
LPVOID lpThreadParameter
|
|
);
|
|
|
|
INT
|
|
ProcessFamily(
|
|
IN INT FamIdx)
|
|
{
|
|
INT err=NO_ERROR;
|
|
INT i;
|
|
SOCKADDR_STORAGE remoteAddr;
|
|
INT remoteAddrLength;
|
|
u_long one = 1;
|
|
|
|
if ( family[FamIdx].tcpEcho != INVALID_SOCKET && FD_ISSET( family[FamIdx].tcpEcho, Readfds ) ) {
|
|
i = AcceptTcpClient( family[FamIdx].tcpEcho, TcpEchoPort );
|
|
}
|
|
|
|
if ( family[FamIdx].tcpDiscard != INVALID_SOCKET && FD_ISSET( family[FamIdx].tcpDiscard, Readfds ) ) {
|
|
i = AcceptTcpClient( family[FamIdx].tcpDiscard, TcpDiscardPort );
|
|
}
|
|
|
|
if ( family[FamIdx].tcpDaytime != INVALID_SOCKET && FD_ISSET( family[FamIdx].tcpDaytime, Readfds ) ) {
|
|
|
|
SOCKET acceptSocket;
|
|
DWORD length=IoBufferSize;
|
|
|
|
//
|
|
// A client is making a TCP daytime request. First accept
|
|
// the connection, then send the current time-of-day string
|
|
// to the client, then close the socket.
|
|
//
|
|
|
|
acceptSocket = accept( family[FamIdx].tcpDaytime, NULL, NULL );
|
|
|
|
if ( acceptSocket != INVALID_SOCKET ) {
|
|
FormatDaytimeResponse( IoBuffer, &length );
|
|
send( acceptSocket, IoBuffer, length, 0 );
|
|
err = closesocket( acceptSocket );
|
|
ASSERT( err != SOCKET_ERROR );
|
|
}
|
|
}
|
|
|
|
if ( family[FamIdx].tcpChargen != INVALID_SOCKET && FD_ISSET( family[FamIdx].tcpChargen, Readfds ) ) {
|
|
i = AcceptTcpClient( family[FamIdx].tcpChargen, TcpChargenPort );
|
|
if ( i != -1 ) {
|
|
one = 1;
|
|
err = ioctlsocket( TcpClients[i].SocketHandle, FIONBIO, &one );
|
|
if ( err == SOCKET_ERROR ) {
|
|
DeleteTcpClient( i, FALSE );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( family[FamIdx].tcpQotd != INVALID_SOCKET && FD_ISSET( family[FamIdx].tcpQotd, Readfds ) ) {
|
|
|
|
SOCKET acceptSocket;
|
|
DWORD length = IoBufferSize;
|
|
|
|
//
|
|
// A client is making a TCP Qotd request. First accept
|
|
// the connection, then send the quote of the day
|
|
// to the client, then close the socket.
|
|
//
|
|
|
|
acceptSocket = accept( family[FamIdx].tcpQotd, NULL, NULL );
|
|
|
|
if ( acceptSocket != INVALID_SOCKET ) {
|
|
FormatQotdResponse( IoBuffer, &length );
|
|
send( acceptSocket, IoBuffer, length, 0 );
|
|
err = closesocket( acceptSocket );
|
|
ASSERT( err != SOCKET_ERROR );
|
|
}
|
|
}
|
|
|
|
// ================================================================
|
|
// Udp services.
|
|
|
|
if ( family[FamIdx].udpEcho != INVALID_SOCKET && FD_ISSET( family[FamIdx].udpEcho, Readfds ) ) {
|
|
|
|
remoteAddrLength = sizeof(remoteAddr);
|
|
|
|
err = recvfrom(
|
|
family[FamIdx].udpEcho,
|
|
IoBuffer,
|
|
IoBufferSize,
|
|
0,
|
|
(PSOCKADDR)&remoteAddr,
|
|
&remoteAddrLength
|
|
);
|
|
|
|
if( ntohs(SS_PORT(&remoteAddr)) > IPPORT_RESERVED
|
|
&& err != SOCKET_ERROR )
|
|
{
|
|
err = sendto(
|
|
family[FamIdx].udpEcho,
|
|
IoBuffer,
|
|
err,
|
|
0,
|
|
(PSOCKADDR)&remoteAddr,
|
|
remoteAddrLength
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( family[FamIdx].udpDiscard != INVALID_SOCKET && FD_ISSET( family[FamIdx].udpDiscard, Readfds ) ) {
|
|
err = recvfrom(
|
|
family[FamIdx].udpDiscard,
|
|
IoBuffer,
|
|
IoBufferSize,
|
|
0,
|
|
NULL,
|
|
NULL
|
|
);
|
|
ASSERT( err != SOCKET_ERROR );
|
|
|
|
// Nothing to sendto in this case.
|
|
}
|
|
|
|
if ( family[FamIdx].udpDaytime != INVALID_SOCKET && FD_ISSET( family[FamIdx].udpDaytime, Readfds ) ) {
|
|
|
|
DWORD length;
|
|
|
|
remoteAddrLength = sizeof(remoteAddr);
|
|
|
|
err = recvfrom(
|
|
family[FamIdx].udpDaytime,
|
|
IoBuffer,
|
|
IoBufferSize,
|
|
0,
|
|
(PSOCKADDR)&remoteAddr,
|
|
&remoteAddrLength
|
|
);
|
|
|
|
|
|
if( (ntohs(SS_PORT(&remoteAddr)) > IPPORT_RESERVED) && (err != SOCKET_ERROR) )
|
|
{
|
|
length=IoBufferSize;
|
|
FormatDaytimeResponse( IoBuffer, &length );
|
|
|
|
err = sendto(
|
|
family[FamIdx].udpDaytime,
|
|
IoBuffer,
|
|
length,
|
|
0,
|
|
(PSOCKADDR)&remoteAddr,
|
|
remoteAddrLength
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( family[FamIdx].udpChargen != INVALID_SOCKET && FD_ISSET( family[FamIdx].udpChargen, Readfds ) ) {
|
|
|
|
DWORD length;
|
|
|
|
remoteAddrLength = sizeof(remoteAddr);
|
|
|
|
err = recvfrom(
|
|
family[FamIdx].udpChargen,
|
|
IoBuffer,
|
|
IoBufferSize,
|
|
0,
|
|
(PSOCKADDR)&remoteAddr,
|
|
&remoteAddrLength
|
|
);
|
|
|
|
|
|
// Infinite loop attack, when we get a request from
|
|
// another service. - MohsinA, 30-Jun-97.
|
|
|
|
if( (ntohs(SS_PORT(&remoteAddr)) > IPPORT_RESERVED) && (err != SOCKET_ERROR) )
|
|
{
|
|
srand( GetTickCount( ) );
|
|
|
|
length = (rand( ) * MAX_UDP_CHARGEN_RESPONSE) / RAND_MAX;
|
|
if (length > ChargenBufferSize) {
|
|
length=ChargenBufferSize;
|
|
}
|
|
err = sendto(
|
|
family[FamIdx].udpChargen,
|
|
ChargenBuffer,
|
|
length,
|
|
0,
|
|
(PSOCKADDR)&remoteAddr,
|
|
remoteAddrLength
|
|
);
|
|
|
|
}
|
|
}
|
|
|
|
if ( family[FamIdx].udpQotd != INVALID_SOCKET && FD_ISSET( family[FamIdx].udpQotd, Readfds ) ) {
|
|
|
|
DWORD length = IoBufferSize;
|
|
|
|
remoteAddrLength = sizeof(remoteAddr);
|
|
|
|
err = recvfrom(
|
|
family[FamIdx].udpQotd,
|
|
IoBuffer,
|
|
IoBufferSize,
|
|
0,
|
|
(PSOCKADDR)&remoteAddr,
|
|
&remoteAddrLength
|
|
);
|
|
|
|
if( (ntohs(SS_PORT(&remoteAddr)) > IPPORT_RESERVED) && (err != SOCKET_ERROR) )
|
|
{
|
|
FormatQotdResponse( IoBuffer, &length );
|
|
|
|
err = sendto(
|
|
family[FamIdx].udpQotd,
|
|
IoBuffer,
|
|
length,
|
|
0,
|
|
(PSOCKADDR)&remoteAddr,
|
|
remoteAddrLength
|
|
);
|
|
}
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
VOID
|
|
ServiceEntry (
|
|
IN DWORD argc,
|
|
IN LPWSTR argv[],
|
|
IN PTCPSVCS_GLOBAL_DATA pGlobalData
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the "main" routine for the simple TCP/IP services. The
|
|
containing process will call this routine when we're supposed to
|
|
start up.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
INT err=ERROR_GEN_FAILURE;
|
|
TIMEVAL timeout;
|
|
INT i, FamIdx;
|
|
DWORD maxFdSetSize;
|
|
NTSTATUS status;
|
|
BOOL bOk;
|
|
|
|
//
|
|
// Initialize all the status fields so that subsequent calls to
|
|
// SetServiceStatus need to only update fields that changed.
|
|
//
|
|
|
|
SimpServiceStatus.dwServiceType = SERVICE_WIN32;
|
|
SimpServiceStatus.dwCurrentState = SERVICE_START_PENDING;
|
|
SimpServiceStatus.dwControlsAccepted = 0;
|
|
SimpServiceStatus.dwCheckPoint = 1;
|
|
SimpServiceStatus.dwWaitHint = 30000; // 30 seconds
|
|
|
|
SimpServiceStatus.dwWin32ExitCode = NO_ERROR;
|
|
SimpServiceStatus.dwServiceSpecificExitCode = NO_ERROR;
|
|
|
|
//
|
|
// Initialize server to receive service requests by registering the
|
|
// control handler.
|
|
//
|
|
|
|
SimpServiceStatusHandle = RegisterServiceCtrlHandler(
|
|
TEXT("SimpTcp"),
|
|
ControlResponse
|
|
);
|
|
|
|
if ( SimpServiceStatusHandle == 0 ) {
|
|
err = GetLastError();
|
|
goto exit;
|
|
}
|
|
|
|
AnnounceServiceStatus( );
|
|
|
|
//
|
|
// Initialize our critical section.
|
|
//
|
|
|
|
status = RtlInitializeCriticalSection( &CriticalSection );
|
|
if ( !NT_SUCCESS(status) ) {
|
|
goto exit;
|
|
}
|
|
|
|
InitializedCriticalSection = TRUE;
|
|
|
|
//
|
|
// Initialize the eventlog.
|
|
//
|
|
|
|
err = SimpInitializeEventLog( );
|
|
ASSERT( err == NO_ERROR );
|
|
|
|
//
|
|
// Read all registry information.
|
|
//
|
|
|
|
err = ReadRegistry( );
|
|
if ( err != NO_ERROR ) {
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Allocate memory for the IO buffer.
|
|
//
|
|
|
|
IoBuffer = RtlAllocateHeap( RtlProcessHeap( ), 0, IoBufferSize );
|
|
|
|
//
|
|
// Allocate memory for the array of TCP clients.
|
|
//
|
|
|
|
TcpClients = RtlAllocateHeap(
|
|
RtlProcessHeap( ),
|
|
0,
|
|
MaxTcpClients * sizeof(TcpClients[0])
|
|
);
|
|
if ( TcpClients == NULL ) {
|
|
err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Initialize the chargen data buffer.
|
|
//
|
|
|
|
if ( DoTcpChargen || DoUdpChargen ) {
|
|
err = InitializeChargen( );
|
|
if ( err != NO_ERROR ) {
|
|
DoUdpChargen = FALSE;
|
|
DoTcpChargen = FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Initialize the quote of the day quotes.
|
|
//
|
|
|
|
if ( DoTcpQotd || DoUdpQotd ) {
|
|
err = InitializeQotdQuotes( );
|
|
if ( err != NO_ERROR ) {
|
|
DoUdpQotd = FALSE;
|
|
DoTcpQotd = FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Initialize client socket array.
|
|
//
|
|
|
|
for ( i = 0; (DWORD)i < MaxTcpClients; i++ ) {
|
|
TcpClients[i].SocketHandle = INVALID_SOCKET;
|
|
TcpClients[i].ThreadHandle = NULL;
|
|
}
|
|
|
|
//
|
|
// Determine how large our FD_SET structures must be, then allocate
|
|
// space for them. We have 1 quit socket, plus 10 services * 2 families.
|
|
//
|
|
|
|
maxFdSetSize = FIELD_OFFSET(fd_set, fd_array[1 + NUM_FAMILIES * NUM_SERVICES]);
|
|
|
|
|
|
Readfds = RtlAllocateHeap( RtlProcessHeap( ), 0, maxFdSetSize );
|
|
ReadfdsStore = RtlAllocateHeap( RtlProcessHeap( ), 0, maxFdSetSize );
|
|
|
|
if ( Readfds == NULL || ReadfdsStore == NULL ) {
|
|
err = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Initialize the pause event. We use this event to stop activity
|
|
// when the service is paused.
|
|
//
|
|
|
|
SimpPauseEvent = CreateEvent( NULL, TRUE, TRUE, NULL );
|
|
if ( SimpPauseEvent == NULL ) {
|
|
err = GetLastError( );
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Initialize the Windows Sockets DLL.
|
|
//
|
|
|
|
err = WSAStartup( 0x0101, &WsaData );
|
|
if ( err == SOCKET_ERROR ) {
|
|
err = GetLastError( );
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Initialize the FD sets we'll use.
|
|
//
|
|
|
|
FD_ZERO( ReadfdsStore );
|
|
|
|
//
|
|
// Open the "quit" socket. We close this socket when we need to
|
|
// shut down in order to wake up the main thread from it's select()
|
|
// and begin shutdown.
|
|
//
|
|
|
|
SimpQuitSocket = socket( AF_INET, SOCK_DGRAM, 0 );
|
|
if ( SimpQuitSocket != INVALID_SOCKET ) {
|
|
FD_SET( SimpQuitSocket, ReadfdsStore );
|
|
} else {
|
|
err = GetLastError( );
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// First find the port numbers for all our services.
|
|
//
|
|
|
|
TcpEchoPort = GetServicePort( "echo", "tcp" );
|
|
if ( TcpEchoPort == INVALID_PORT && DoTcpEcho ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_TCP_ECHO_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoTcpEcho = FALSE;
|
|
}
|
|
|
|
UdpEchoPort = GetServicePort( "echo", "udp" );
|
|
if ( UdpEchoPort == INVALID_PORT && DoUdpEcho ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_UDP_ECHO_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoUdpEcho = FALSE;
|
|
}
|
|
|
|
TcpDiscardPort = GetServicePort( "discard", "tcp" );
|
|
if ( TcpDiscardPort == INVALID_PORT && DoTcpDiscard ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_TCP_DISCARD_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoTcpDiscard = FALSE;
|
|
}
|
|
|
|
UdpDiscardPort = GetServicePort( "discard", "udp" );
|
|
if ( UdpDiscardPort == INVALID_PORT && DoUdpDiscard ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_UDP_DISCARD_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoUdpDiscard = FALSE;
|
|
}
|
|
|
|
TcpDaytimePort = GetServicePort( "daytime", "tcp" );
|
|
if ( TcpDaytimePort == INVALID_PORT && DoTcpDaytime ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_TCP_DAYTIME_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoTcpDaytime = FALSE;
|
|
}
|
|
|
|
UdpDaytimePort = GetServicePort( "daytime", "udp" );
|
|
if ( UdpDaytimePort == INVALID_PORT && DoUdpDaytime ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_UDP_DAYTIME_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoUdpDaytime = FALSE;
|
|
}
|
|
|
|
TcpChargenPort = GetServicePort( "chargen", "tcp" );
|
|
if ( TcpChargenPort == INVALID_PORT && DoTcpChargen ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_TCP_CHARGEN_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoTcpChargen = FALSE;
|
|
}
|
|
|
|
UdpChargenPort = GetServicePort( "chargen", "udp" );
|
|
if ( UdpChargenPort == INVALID_PORT && DoUdpChargen ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_UDP_CHARGEN_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoUdpChargen = FALSE;
|
|
}
|
|
|
|
TcpQotdPort = GetServicePort( "qotd", "tcp" );
|
|
if ( TcpQotdPort == INVALID_PORT && DoTcpQotd ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_TCP_QOTD_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoTcpQotd = FALSE;
|
|
}
|
|
|
|
UdpQotdPort = GetServicePort( "qotd", "udp" );
|
|
if ( UdpQotdPort == INVALID_PORT && DoUdpQotd ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_FIND_UDP_QOTD_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
|
|
DoUdpQotd = FALSE;
|
|
}
|
|
|
|
//
|
|
// Open, bind, and listen on the necessary ports.
|
|
//
|
|
|
|
if ( DoTcpEcho ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenTcpSocket( &family[i].tcpEcho, i, TcpEchoPort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_TCP_ECHO_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( DoUdpEcho ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenUdpSocket( &family[i].udpEcho, i, UdpEchoPort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_UDP_ECHO_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( DoTcpDiscard ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenTcpSocket( &family[i].tcpDiscard, i, TcpDiscardPort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_TCP_DISCARD_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( DoUdpDiscard ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenUdpSocket( &family[i].udpDiscard, i, UdpDiscardPort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_UDP_DISCARD_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( DoTcpDaytime ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenTcpSocket( &family[i].tcpDaytime, i, TcpDaytimePort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_TCP_DAYTIME_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( DoUdpDaytime ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenUdpSocket( &family[i].udpDaytime, i, UdpDaytimePort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_UDP_DAYTIME_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( DoTcpChargen ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenTcpSocket( &family[i].tcpChargen, i, TcpChargenPort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_TCP_CHARGEN_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( DoUdpChargen ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenUdpSocket( &family[i].udpChargen, i, UdpChargenPort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_UDP_CHARGEN_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( DoTcpQotd ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenTcpSocket( &family[i].tcpQotd, i, TcpQotdPort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_TCP_QOTD_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
if ( DoUdpQotd ) {
|
|
bOk = FALSE;
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
bOk |= OpenUdpSocket( &family[i].udpQotd, i, UdpQotdPort );
|
|
}
|
|
if ( !bOk ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_UDP_QOTD_PORT,
|
|
0,
|
|
NULL,
|
|
WSAGetLastError( )
|
|
);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Announce that we have successfully started.
|
|
//
|
|
|
|
SimpServiceStatus.dwCurrentState = SERVICE_RUNNING;
|
|
SimpServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP |
|
|
SERVICE_ACCEPT_PAUSE_CONTINUE;
|
|
SimpServiceStatus.dwCheckPoint = 0;
|
|
SimpServiceStatus.dwWaitHint = 0;
|
|
|
|
AnnounceServiceStatus( );
|
|
|
|
//
|
|
// Loop waiting for connect attempts or datagrams, and service them
|
|
// when they arrive.
|
|
//
|
|
|
|
for (;;) {
|
|
|
|
//
|
|
// First initialize the FD sets we'll actually use for select().
|
|
//
|
|
|
|
RtlCopyMemory( Readfds, ReadfdsStore, maxFdSetSize );
|
|
|
|
//
|
|
// Now wait for something to happen. Timeout occaisonally
|
|
// so that we can kill idle TCP clients.
|
|
//
|
|
|
|
timeout.tv_sec = SelectTimeout;
|
|
timeout.tv_usec = 0;
|
|
|
|
err = select( 0, Readfds, NULL, NULL, &timeout );
|
|
|
|
//
|
|
// If the service is shutting down, stop processing requests
|
|
// and exit.
|
|
//
|
|
|
|
if ( SimpServiceExit ) {
|
|
err = NO_ERROR;
|
|
goto exit;
|
|
}
|
|
|
|
if ( err == SOCKET_ERROR ) {
|
|
|
|
//
|
|
// This is bad. We should do something intelligent here.
|
|
//
|
|
int MappedErr;
|
|
MappedErr= WSAGetLastError();
|
|
|
|
//
|
|
// Log an error and quit
|
|
//
|
|
SimpLogEvent(
|
|
SIMPTCP_SOCKET_ERROR_SERVICE_FAILURE,
|
|
0,
|
|
NULL,
|
|
MappedErr
|
|
);
|
|
|
|
err = MappedErr;
|
|
closesocket( SimpQuitSocket );
|
|
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// If the service is paused, wait for it to become unpaused.
|
|
//
|
|
|
|
err = WaitForSingleObject( SimpPauseEvent, INFINITE );
|
|
ASSERT( err != WAIT_FAILED );
|
|
|
|
//
|
|
// Figure out what happened and act accordingly.
|
|
//
|
|
for (FamIdx=0; FamIdx<NUM_FAMILIES; FamIdx++)
|
|
{
|
|
err = ProcessFamily(FamIdx);
|
|
}
|
|
|
|
|
|
} // infinite loop.
|
|
|
|
exit:
|
|
|
|
//
|
|
// Announce that we're going down.
|
|
//
|
|
|
|
SimpServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
|
|
SimpServiceStatus.dwCheckPoint = 1;
|
|
SimpServiceStatus.dwWaitHint = 20000; // 20 seconds
|
|
|
|
SimpServiceStatus.dwWin32ExitCode = err;
|
|
SimpServiceStatus.dwServiceSpecificExitCode = err;
|
|
|
|
AnnounceServiceStatus( );
|
|
|
|
//
|
|
// Delete our critical section.
|
|
//
|
|
|
|
if ( InitializedCriticalSection ) {
|
|
InitializedCriticalSection = FALSE;
|
|
RtlDeleteCriticalSection( &CriticalSection );
|
|
}
|
|
|
|
//
|
|
// Close all opened listening sockets.
|
|
//
|
|
|
|
for (i=0; i<NUM_FAMILIES; i++) {
|
|
if ( family[i].tcpEcho != INVALID_SOCKET ) {
|
|
closesocket( family[i].tcpEcho );
|
|
}
|
|
if ( family[i].udpEcho != INVALID_SOCKET ) {
|
|
closesocket( family[i].udpEcho );
|
|
}
|
|
if ( family[i].tcpDiscard != INVALID_SOCKET ) {
|
|
closesocket( family[i].tcpDiscard );
|
|
}
|
|
if ( family[i].udpDiscard != INVALID_SOCKET ) {
|
|
closesocket( family[i].udpDiscard );
|
|
}
|
|
if ( family[i].tcpDaytime != INVALID_SOCKET ) {
|
|
closesocket( family[i].tcpDaytime );
|
|
}
|
|
if ( family[i].udpDaytime != INVALID_SOCKET ) {
|
|
closesocket( family[i].udpDaytime );
|
|
}
|
|
if ( family[i].tcpChargen != INVALID_SOCKET ) {
|
|
closesocket( family[i].tcpChargen );
|
|
}
|
|
if ( family[i].udpChargen != INVALID_SOCKET ) {
|
|
closesocket( family[i].udpChargen );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Close all connected TCP sockets.
|
|
//
|
|
|
|
for ( i = 0; TcpClients != NULL && (DWORD)i < MaxTcpClients; i++ ) {
|
|
|
|
if ( TcpClients[i].SocketHandle != INVALID_SOCKET ) {
|
|
AbortTcpClient( TcpClients[i].SocketHandle );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Should wait here for all threads to exit!
|
|
//
|
|
|
|
//
|
|
// Deinitialize the eventlog.
|
|
//
|
|
|
|
SimpTerminateEventLog( );
|
|
|
|
//
|
|
// Free allocated memory.
|
|
//
|
|
|
|
if ( IoBuffer != NULL ) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, IoBuffer );
|
|
}
|
|
|
|
if ( TcpClients != NULL ) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, TcpClients );
|
|
}
|
|
|
|
if ( Readfds != NULL ) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, Readfds );
|
|
}
|
|
|
|
if ( ReadfdsStore != NULL ) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, ReadfdsStore );
|
|
}
|
|
|
|
if ( ChargenBuffer != NULL ) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, ChargenBuffer );
|
|
}
|
|
|
|
if ( QotdBuffer != NULL ) {
|
|
UnmapViewOfFile( QotdBuffer );
|
|
}
|
|
|
|
if ( QotdFileMapping != NULL ) {
|
|
CloseHandle( QotdFileMapping );
|
|
}
|
|
|
|
if ( QotdFileHandle != NULL ) {
|
|
CloseHandle( QotdFileHandle );
|
|
}
|
|
|
|
if ( QotdFileName != NULL ) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, QotdFileName );
|
|
}
|
|
|
|
if ( QotdStrings != NULL ) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, QotdStrings );
|
|
}
|
|
|
|
//
|
|
// Free SimpPauseEvent's memory
|
|
//
|
|
if (SimpPauseEvent)
|
|
CloseHandle(SimpPauseEvent);
|
|
|
|
//
|
|
// Announce that we're down.
|
|
//
|
|
|
|
SimpServiceStatus.dwCurrentState = SERVICE_STOPPED;
|
|
SimpServiceStatus.dwControlsAccepted = 0;
|
|
SimpServiceStatus.dwCheckPoint = 0;
|
|
SimpServiceStatus.dwWaitHint = 0;
|
|
|
|
SimpServiceStatus.dwWin32ExitCode = err;
|
|
SimpServiceStatus.dwServiceSpecificExitCode = err;
|
|
|
|
AnnounceServiceStatus( );
|
|
|
|
return;
|
|
|
|
} // ServiceEntry
|
|
|
|
|
|
BOOL
|
|
OpenTcpSocket (
|
|
OUT SOCKET *pSocket,
|
|
IN INT FamIdx,
|
|
IN SHORT Port
|
|
)
|
|
{
|
|
SOCKADDR_STORAGE localAddr;
|
|
INT localAddrLen;
|
|
INT err;
|
|
INT one = 1;
|
|
|
|
*pSocket = socket( family[FamIdx].family, SOCK_STREAM, 0 );
|
|
if ( *pSocket == INVALID_SOCKET ) {
|
|
return FALSE;
|
|
}
|
|
|
|
RtlZeroMemory( &localAddr, sizeof(localAddr) );
|
|
SS_PORT(&localAddr) = Port;
|
|
localAddr.ss_family = family[FamIdx].family;
|
|
|
|
|
|
err =
|
|
setsockopt( *pSocket,
|
|
SOL_SOCKET,
|
|
SO_EXCLUSIVEADDRUSE,
|
|
(char *) &one,
|
|
sizeof( one )
|
|
);
|
|
if( err ){
|
|
DEBUG_PRINT(("simptcp: OpenTcpSocket: ExclusiveAddressUse failed %d\n",
|
|
GetLastError() ));
|
|
closesocket(*pSocket);
|
|
*pSocket = INVALID_SOCKET;
|
|
return FALSE;
|
|
}
|
|
|
|
err = bind( *pSocket, (PSOCKADDR)&localAddr, sizeof(localAddr) );
|
|
if ( err ==SOCKET_ERROR ) {
|
|
closesocket(*pSocket);
|
|
*pSocket = INVALID_SOCKET;
|
|
return FALSE;
|
|
}
|
|
|
|
err = listen( *pSocket, LISTEN_BACKLOG );
|
|
if ( err == SOCKET_ERROR ) {
|
|
closesocket(*pSocket);
|
|
*pSocket = INVALID_SOCKET;
|
|
return FALSE;
|
|
}
|
|
|
|
err = setsockopt( *pSocket, SOL_SOCKET, SO_KEEPALIVE, (char *)&one, sizeof(one) );
|
|
if ( err == INVALID_SOCKET ) {
|
|
closesocket(*pSocket);
|
|
*pSocket = INVALID_SOCKET;
|
|
return FALSE;
|
|
}
|
|
|
|
FD_SET( *pSocket, ReadfdsStore );
|
|
return TRUE;
|
|
|
|
} // OpenTcpSocket
|
|
|
|
|
|
BOOL
|
|
OpenUdpSocket (
|
|
OUT SOCKET *pSocket,
|
|
IN INT FamIdx,
|
|
IN SHORT Port
|
|
)
|
|
{
|
|
SOCKADDR_STORAGE localAddr;
|
|
INT localAddrLen;
|
|
INT err;
|
|
DWORD broadcast_off = 0;
|
|
DWORD on = 1;
|
|
|
|
*pSocket = socket( family[FamIdx].family, SOCK_DGRAM, 0 );
|
|
if ( *pSocket == INVALID_SOCKET ) {
|
|
return FALSE;
|
|
}
|
|
|
|
RtlZeroMemory( &localAddr, sizeof(localAddr) );
|
|
SS_PORT(&localAddr) = Port;
|
|
localAddr.ss_family = family[FamIdx].family;
|
|
|
|
err =
|
|
setsockopt( *pSocket,
|
|
SOL_SOCKET,
|
|
SO_EXCLUSIVEADDRUSE,
|
|
(LPBYTE) &on,
|
|
sizeof( on )
|
|
);
|
|
if( err ){
|
|
DEBUG_PRINT(("simptcp: OpenUdpSocket: ExclusiveAddressUse failed %d\n",
|
|
GetLastError() ));
|
|
closesocket(*pSocket);
|
|
*pSocket = INVALID_SOCKET;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
err = bind( *pSocket, (PSOCKADDR)&localAddr, sizeof(localAddr) );
|
|
if ( err == SOCKET_ERROR ) {
|
|
closesocket(*pSocket);
|
|
*pSocket = INVALID_SOCKET;
|
|
return FALSE;
|
|
}
|
|
|
|
err =
|
|
setsockopt( *pSocket,
|
|
SOL_SOCKET,
|
|
SO_BROADCAST,
|
|
(LPBYTE) &broadcast_off,
|
|
sizeof( broadcast_off )
|
|
);
|
|
|
|
if( err ){
|
|
DEBUG_PRINT(("simptcp: OpenUdpSocket: broadcast_off failed %d\n",
|
|
GetLastError() ));
|
|
closesocket(*pSocket);
|
|
*pSocket = INVALID_SOCKET;
|
|
return FALSE;
|
|
}
|
|
|
|
FD_SET( *pSocket, ReadfdsStore );
|
|
return TRUE;
|
|
|
|
} // OpenUdpSocket
|
|
|
|
|
|
INT
|
|
AcceptTcpClient (
|
|
IN SOCKET ListenSocket,
|
|
IN SHORT Port
|
|
)
|
|
{
|
|
SOCKADDR_STORAGE remoteSockaddr;
|
|
INT remoteSockaddrLength;
|
|
DWORD i;
|
|
SOCKET acceptSocket;
|
|
DWORD threadId;
|
|
NTSTATUS status;
|
|
|
|
//
|
|
// Always accept the socket first.
|
|
//
|
|
|
|
remoteSockaddrLength = sizeof(remoteSockaddr);
|
|
|
|
acceptSocket =
|
|
accept( ListenSocket, (PSOCKADDR)&remoteSockaddr, &remoteSockaddrLength );
|
|
if ( acceptSocket == INVALID_SOCKET ) {
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Use a critical section to protect access to our database of
|
|
// TCP clients.
|
|
//
|
|
|
|
status = RtlEnterCriticalSection( &CriticalSection );
|
|
ASSERT( NT_SUCCESS(status) );
|
|
|
|
//
|
|
// Attempt to find a TCP client slot.
|
|
//
|
|
|
|
for ( i = 0; i < MaxTcpClients; i++ ) {
|
|
if ( TcpClients[i].SocketHandle == INVALID_SOCKET ) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we're at the max count of TCP sockets, abort this new
|
|
// socket.
|
|
//
|
|
|
|
if ( i >= MaxTcpClients ) {
|
|
AbortTcpClient( acceptSocket );
|
|
status = RtlLeaveCriticalSection( &CriticalSection );
|
|
ASSERT( NT_SUCCESS(status) );
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// Initialize info about this client.
|
|
//
|
|
|
|
TcpClients[i].SocketHandle = acceptSocket;
|
|
RtlCopyMemory(
|
|
&TcpClients[i].RemoteAddress,
|
|
&remoteSockaddr,
|
|
sizeof(remoteSockaddr)
|
|
);
|
|
TcpClients[i].ServicePort = Port;
|
|
|
|
//
|
|
// We're in multi-threaded mode, so we'll create a separate thread
|
|
// to handle this client.
|
|
//
|
|
|
|
TcpClients[i].ThreadHandle = CreateThread(
|
|
NULL,
|
|
0,
|
|
ThreadEntry,
|
|
UlongToPtr(i),
|
|
0,
|
|
&threadId
|
|
);
|
|
if ( TcpClients[i].ThreadHandle == NULL ) {
|
|
AbortTcpClient( acceptSocket );
|
|
TcpClients[i].SocketHandle = INVALID_SOCKET;
|
|
status = RtlLeaveCriticalSection( &CriticalSection );
|
|
ASSERT( NT_SUCCESS(status) );
|
|
return -1;
|
|
}
|
|
|
|
//
|
|
// The created thread will handle the connected client.
|
|
//
|
|
|
|
status = RtlLeaveCriticalSection( &CriticalSection );
|
|
ASSERT( NT_SUCCESS(status) );
|
|
|
|
return -1;
|
|
|
|
} // AcceptTcpClient
|
|
|
|
|
|
VOID
|
|
AbortTcpClient (
|
|
IN SOCKET Socket
|
|
)
|
|
{
|
|
LINGER lingerInfo;
|
|
INT err;
|
|
|
|
//
|
|
// First set the linger timeout on the socket to 0. This will cause
|
|
// the connection to be reset.
|
|
//
|
|
|
|
lingerInfo.l_onoff = 1;
|
|
lingerInfo.l_linger = 0;
|
|
|
|
err = setsockopt(
|
|
Socket,
|
|
SOL_SOCKET,
|
|
SO_LINGER,
|
|
(char *)&lingerInfo,
|
|
sizeof(lingerInfo)
|
|
);
|
|
|
|
if ( err == SOCKET_ERROR ) {
|
|
|
|
//
|
|
// There's not too much we can do. Just close the socket.
|
|
//
|
|
|
|
ASSERT(FALSE);
|
|
closesocket( Socket );
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Now close the socket.
|
|
//
|
|
|
|
err = closesocket( Socket );
|
|
ASSERT( err != SOCKET_ERROR );
|
|
|
|
return;
|
|
|
|
} // AbortTcpClient
|
|
|
|
|
|
VOID
|
|
DeleteTcpClient (
|
|
IN DWORD ArraySlot,
|
|
IN BOOLEAN Graceful
|
|
)
|
|
{
|
|
INT err;
|
|
NTSTATUS status;
|
|
|
|
status = RtlEnterCriticalSection( &CriticalSection );
|
|
ASSERT( NT_SUCCESS(status) );
|
|
|
|
ASSERT( TcpClients[ArraySlot].SocketHandle != INVALID_SOCKET );
|
|
|
|
//
|
|
// If this is to be an abortive disconnect, reset the connection.
|
|
// Otherwise just close it normally.
|
|
//
|
|
|
|
if ( !Graceful ) {
|
|
|
|
AbortTcpClient( TcpClients[ArraySlot].SocketHandle );
|
|
|
|
} else {
|
|
|
|
LINGER lingerInfo;
|
|
INT one;
|
|
|
|
//
|
|
// Set the socket to blocking.
|
|
//
|
|
|
|
one = 0;
|
|
ioctlsocket( TcpClients[ArraySlot].SocketHandle, FIONBIO, &one );
|
|
|
|
//
|
|
// Set the socket to linger no more than 60 seconds.
|
|
//
|
|
|
|
lingerInfo.l_onoff = 1;
|
|
lingerInfo.l_linger = 60;
|
|
|
|
setsockopt( TcpClients[ArraySlot].SocketHandle, SOL_SOCKET,
|
|
SO_LINGER, (char *)&lingerInfo, sizeof(lingerInfo) );
|
|
|
|
err = closesocket( TcpClients[ArraySlot].SocketHandle );
|
|
ASSERT( err != SOCKET_ERROR );
|
|
}
|
|
|
|
//
|
|
// Close the thread handle, if appropriate.
|
|
//
|
|
|
|
if ( TcpClients[ArraySlot].ThreadHandle != NULL ) {
|
|
CloseHandle( TcpClients[ArraySlot].ThreadHandle );
|
|
TcpClients[ArraySlot].ThreadHandle = NULL;
|
|
}
|
|
|
|
//
|
|
// Set the handle in the TCP clients array to INVALID_SOCKET so that we
|
|
// know that it is free.
|
|
//
|
|
|
|
TcpClients[ArraySlot].SocketHandle = INVALID_SOCKET;
|
|
|
|
status = RtlLeaveCriticalSection( &CriticalSection );
|
|
ASSERT( NT_SUCCESS(status) );
|
|
|
|
return;
|
|
|
|
} // DeleteTcpClient
|
|
|
|
|
|
VOID
|
|
FormatDaytimeResponse (
|
|
IN PCHAR Buffer,
|
|
IN PDWORD BufferLength
|
|
)
|
|
{
|
|
SYSTEMTIME timeStruct;
|
|
int Status;
|
|
int StringSize;
|
|
|
|
char Buf1[MAX_DATE_BUFFER_SIZE];
|
|
char Buf2[MAX_DATE_BUFFER_SIZE];
|
|
|
|
|
|
*BufferLength=sprintf(Buffer,"");
|
|
|
|
GetLocalTime( &timeStruct );
|
|
Status = GetDateFormatA((LCID)LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
&timeStruct,
|
|
NULL,
|
|
Buf1,
|
|
MAX_DATE_BUFFER_SIZE);
|
|
|
|
if (Status == 0) {
|
|
return;
|
|
}
|
|
|
|
Status = GetTimeFormatA((LCID)LOCALE_SYSTEM_DEFAULT,
|
|
0,
|
|
&timeStruct,
|
|
NULL,
|
|
Buf2,
|
|
MAX_DATE_BUFFER_SIZE);
|
|
|
|
if (Status == 0) {
|
|
return;
|
|
}
|
|
|
|
*BufferLength=sprintf(Buffer,"%s %s\n",Buf2,Buf1);
|
|
|
|
return;
|
|
|
|
} // FormatDaytimeResponse
|
|
|
|
|
|
|
|
VOID
|
|
FormatQotdResponse (
|
|
IN PCHAR Buffer,
|
|
IN PDWORD BufferLength
|
|
)
|
|
{
|
|
INT index;
|
|
UINT Length;
|
|
|
|
|
|
if (QotdQuoteCount == 0) {
|
|
sprintf(Buffer,"");
|
|
*BufferLength=strlen(Buffer);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Choose a random quote index.
|
|
//
|
|
|
|
index = (rand( ) * (QotdQuoteCount - 1)) / RAND_MAX;
|
|
|
|
//
|
|
// Copy the quote into the output buffer. We want to make sure
|
|
// we don't overflow the "Buffer" passed in.
|
|
//
|
|
|
|
Length = QotdStrings[index].QuoteLength;
|
|
|
|
if (*BufferLength < Length) {
|
|
Length = *BufferLength;
|
|
} else {
|
|
*BufferLength = Length;
|
|
}
|
|
|
|
strncpy( Buffer, QotdStrings[index].Quote, Length);
|
|
|
|
return;
|
|
|
|
} // FormatDaytimeResponse
|
|
|
|
|
|
INT
|
|
InitializeQotdQuotes (
|
|
VOID
|
|
)
|
|
{
|
|
|
|
BY_HANDLE_FILE_INFORMATION fileInformation;
|
|
PCHAR buffer;
|
|
DWORD i,CurQuoteIndex;
|
|
|
|
|
|
if ( QotdFileName == NULL ) {
|
|
return ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Open the file containing quote information.
|
|
//
|
|
|
|
QotdFileHandle = CreateFileW(
|
|
QotdFileName,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
if ( QotdFileHandle == INVALID_HANDLE_VALUE ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_QUOTE_FILE,
|
|
0,
|
|
NULL,
|
|
GetLastError( )
|
|
);
|
|
return GetLastError( );
|
|
}
|
|
|
|
//
|
|
// Determine the size of the QOTD file.
|
|
//
|
|
|
|
if ( !GetFileInformationByHandle( QotdFileHandle, &fileInformation ) ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_QUOTE_FILE,
|
|
0,
|
|
NULL,
|
|
GetLastError( )
|
|
);
|
|
return GetLastError( );
|
|
}
|
|
|
|
//
|
|
// Create a file mapping for the quotes file and map it into
|
|
// the address space of this process.
|
|
//
|
|
|
|
QotdFileMapping = CreateFileMapping(
|
|
QotdFileHandle,
|
|
NULL,
|
|
PAGE_READONLY,
|
|
0,
|
|
0,
|
|
NULL
|
|
);
|
|
if ( QotdFileMapping == NULL ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_QUOTE_FILE,
|
|
0,
|
|
NULL,
|
|
GetLastError( )
|
|
);
|
|
return GetLastError( );
|
|
}
|
|
|
|
QotdBuffer = MapViewOfFile(
|
|
QotdFileMapping,
|
|
FILE_MAP_READ,
|
|
0,
|
|
0,
|
|
0
|
|
);
|
|
if ( QotdBuffer == NULL ) {
|
|
SimpLogEvent(
|
|
SIMPTCP_CANT_OPEN_QUOTE_FILE,
|
|
0,
|
|
NULL,
|
|
GetLastError( )
|
|
);
|
|
return GetLastError( );
|
|
}
|
|
|
|
//
|
|
// Count the number of lines in the file. The number of lines
|
|
// corresponds to the number of quotes.
|
|
//
|
|
|
|
QotdQuoteCount = 0;
|
|
buffer = (PCHAR)QotdBuffer;
|
|
|
|
for ( i = 0; i < fileInformation.nFileSizeLow; i++ ) {
|
|
if ( *buffer++ == '%' ) {
|
|
QotdQuoteCount++;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Allocate a buffer to hold the quote array.
|
|
//
|
|
|
|
QotdStrings = RtlAllocateHeap(
|
|
RtlProcessHeap( ),
|
|
0,
|
|
sizeof(QotdStrings[0]) * QotdQuoteCount
|
|
);
|
|
|
|
if ( QotdStrings == NULL ) {
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
|
|
//
|
|
// Initialize the quote array.
|
|
//
|
|
buffer = (PCHAR)QotdBuffer;
|
|
|
|
CurQuoteIndex=0;
|
|
for ( i = 0; i < QotdQuoteCount; i++ ) {
|
|
|
|
QotdStrings[CurQuoteIndex].Quote = buffer;
|
|
|
|
while ( (DWORD_PTR)buffer < (DWORD_PTR)QotdBuffer +
|
|
fileInformation.nFileSizeLow &&
|
|
*buffer++ != '%' );
|
|
|
|
QotdStrings[CurQuoteIndex].QuoteLength =
|
|
(DWORD)((DWORD_PTR)buffer - (DWORD_PTR)QotdStrings[CurQuoteIndex].Quote) - 1;
|
|
buffer += 2;
|
|
|
|
//
|
|
// If this quote if longer than the IO buffer size, skip over
|
|
// it. We can't use it.
|
|
//
|
|
|
|
if ( QotdStrings[CurQuoteIndex].QuoteLength < IoBufferSize ) {
|
|
// Got a valid one
|
|
CurQuoteIndex++;
|
|
}
|
|
}
|
|
|
|
QotdQuoteCount=CurQuoteIndex;
|
|
|
|
//
|
|
// Initialize the random-number generator.
|
|
//
|
|
|
|
srand( GetTickCount( ) );
|
|
|
|
return NO_ERROR;
|
|
|
|
} // InitializeQotdQuotes
|
|
|
|
|
|
#define CHARGEN_LINE_LENGTH 72
|
|
#define CHARGEN_REAL_LINE_LENGTH (CHARGEN_LINE_LENGTH + 2)
|
|
#define CHARGEN_MIN_CHAR ' '
|
|
#define CHARGEN_MAX_CHAR '~'
|
|
#define CHARGEN_DIFFERENCE (CHARGEN_MAX_CHAR - CHARGEN_MIN_CHAR)
|
|
#define CHARGEN_LINE_COUNT (CHARGEN_DIFFERENCE)
|
|
#define CHARGEN_BUFFER_LENGTH ((CHARGEN_LINE_LENGTH + 2) * (CHARGEN_LINE_COUNT))
|
|
|
|
|
|
INT
|
|
InitializeChargen (
|
|
VOID
|
|
)
|
|
{
|
|
DWORD line;
|
|
BYTE startChar = 0;
|
|
DWORD i;
|
|
|
|
//
|
|
// Allocate a buffer for the chargen data.
|
|
//
|
|
|
|
ChargenBufferSize = CHARGEN_BUFFER_LENGTH;
|
|
|
|
ChargenBuffer = RtlAllocateHeap(
|
|
RtlProcessHeap( ),
|
|
0,
|
|
ChargenBufferSize
|
|
);
|
|
if ( ChargenBuffer == NULL ) {
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
//
|
|
// Fill in the buffer with the required pattern.
|
|
//
|
|
|
|
for ( line = 0; line < CHARGEN_LINE_COUNT; line++ ) {
|
|
|
|
for ( i = 0; i < CHARGEN_LINE_LENGTH; i++ ) {
|
|
|
|
*((PCHAR)ChargenBuffer + (line * CHARGEN_REAL_LINE_LENGTH) + i) =
|
|
(CHAR)( ((startChar + i) % CHARGEN_DIFFERENCE) + CHARGEN_MIN_CHAR);
|
|
}
|
|
|
|
*((PCHAR)ChargenBuffer + (line * CHARGEN_REAL_LINE_LENGTH) + i) = 0x0D;
|
|
*((PCHAR)ChargenBuffer + (line * CHARGEN_REAL_LINE_LENGTH) + i + 1) = 0x0A;
|
|
|
|
startChar++;
|
|
}
|
|
|
|
return NO_ERROR;
|
|
|
|
} // InitializeQotdQuotes
|
|
|
|
|
|
|
|
SHORT
|
|
GetServicePort (
|
|
IN PCHAR Service,
|
|
IN PCHAR Protocol
|
|
)
|
|
{
|
|
PSERVENT serviceEntry;
|
|
|
|
//
|
|
// Get a servent structure for the specified service.
|
|
//
|
|
|
|
serviceEntry = getservbyname( Service, Protocol );
|
|
|
|
if ( serviceEntry == NULL ) {
|
|
// log an error!
|
|
return INVALID_PORT;
|
|
}
|
|
|
|
//
|
|
// Return the port for the specified service.
|
|
//
|
|
|
|
return serviceEntry->s_port;
|
|
|
|
} // GetServicePort
|
|
|
|
|
|
VOID
|
|
AnnounceServiceStatus (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Announces the service's status to the service controller.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
//
|
|
// Service status handle is NULL if RegisterServiceCtrlHandler failed.
|
|
//
|
|
|
|
if ( SimpServiceStatusHandle == 0 ) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Call SetServiceStatus, ignoring any errors.
|
|
//
|
|
|
|
SetServiceStatus(SimpServiceStatusHandle, &SimpServiceStatus);
|
|
|
|
} // AnnounceServiceStatus
|
|
|
|
|
|
VOID
|
|
ControlResponse(
|
|
DWORD opCode
|
|
)
|
|
|
|
{
|
|
BOOL announce = TRUE;
|
|
BOOL err;
|
|
|
|
//
|
|
// Determine the type of service control message and modify the
|
|
// service status, if necessary.
|
|
//
|
|
|
|
switch( opCode ) {
|
|
|
|
case SERVICE_CONTROL_STOP:
|
|
|
|
//
|
|
// Announce that we are in the process of stopping.
|
|
//
|
|
|
|
SimpServiceStatus.dwCurrentState = SERVICE_STOP_PENDING;
|
|
AnnounceServiceStatus( );
|
|
|
|
//
|
|
// Remember that we're stopping.
|
|
//
|
|
|
|
SimpServiceExit = TRUE;
|
|
|
|
//
|
|
// Close a socket that the main select()er thread is
|
|
// waiting on. This will cause the select to wake up
|
|
// and shutdown processing to commence.
|
|
//
|
|
|
|
closesocket( SimpQuitSocket );
|
|
|
|
//
|
|
// Let the main thread announce when the stop is done.
|
|
//
|
|
|
|
announce = FALSE;
|
|
|
|
break;
|
|
|
|
case SERVICE_CONTROL_PAUSE:
|
|
|
|
//
|
|
// Announce that we are in the process of pausing.
|
|
//
|
|
|
|
SimpServiceStatus.dwCurrentState = SERVICE_PAUSE_PENDING;
|
|
AnnounceServiceStatus( );
|
|
|
|
//
|
|
// Remember that we're paused.
|
|
//
|
|
|
|
err = ResetEvent( SimpPauseEvent );
|
|
ASSERT( err );
|
|
|
|
//
|
|
// Announce that we're now paused.
|
|
//
|
|
|
|
SimpServiceStatus.dwCurrentState = SERVICE_PAUSED;
|
|
|
|
break;
|
|
|
|
case SERVICE_CONTROL_CONTINUE:
|
|
|
|
//
|
|
// Announce that continue is pending.
|
|
//
|
|
|
|
SimpServiceStatus.dwCurrentState = SERVICE_CONTINUE_PENDING;
|
|
AnnounceServiceStatus( );
|
|
|
|
//
|
|
// Remember that we're no longer paused.
|
|
//
|
|
|
|
err = SetEvent( SimpPauseEvent );
|
|
ASSERT( err );
|
|
|
|
//
|
|
// Announce that we're active now.
|
|
//
|
|
|
|
SimpServiceStatus.dwCurrentState = SERVICE_RUNNING;
|
|
|
|
break;
|
|
|
|
case SERVICE_CONTROL_INTERROGATE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
}
|
|
|
|
if ( announce ) {
|
|
AnnounceServiceStatus( );
|
|
}
|
|
|
|
} // ControlResponse
|
|
|
|
|
|
INT
|
|
ReadRegistry (
|
|
VOID
|
|
)
|
|
{
|
|
HKEY simptcpKey = NULL;
|
|
ULONG error;
|
|
ULONG i;
|
|
DWORD dwordBuffer;
|
|
DWORD bufferLength;
|
|
DWORD type;
|
|
DWORD qotdFileNameLength, Length;
|
|
PWSTR fileName;
|
|
|
|
//
|
|
// First open our parameters key.
|
|
//
|
|
|
|
error = RegOpenKeyExW(
|
|
HKEY_LOCAL_MACHINE,
|
|
L"SYSTEM\\CurrentControlSet\\Services\\SimpTcp\\Parameters",
|
|
0,
|
|
MAXIMUM_ALLOWED,
|
|
&simptcpKey
|
|
);
|
|
if ( error != NO_ERROR ) {
|
|
return error;
|
|
}
|
|
|
|
//
|
|
// Read BOOLEANs from the registry.
|
|
//
|
|
|
|
for ( i = 0; RegistryBooleans[i].Boolean != NULL; i++ ) {
|
|
|
|
bufferLength = sizeof(dwordBuffer);
|
|
|
|
error = RegQueryValueExW(
|
|
simptcpKey,
|
|
RegistryBooleans[i].ValueName,
|
|
NULL,
|
|
&type,
|
|
(PVOID)&dwordBuffer,
|
|
&bufferLength
|
|
);
|
|
|
|
//
|
|
// If we fail to read one of these for some reason, just skip it
|
|
// and move on to the next one.
|
|
//
|
|
|
|
if ( error != NO_ERROR ) {
|
|
continue;
|
|
}
|
|
|
|
if ( dwordBuffer == 0 ) {
|
|
*RegistryBooleans[i].Boolean = FALSE;
|
|
} else {
|
|
*RegistryBooleans[i].Boolean = TRUE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Read DWORDs from the registry.
|
|
//
|
|
|
|
for ( i = 0; RegistryDwords[i].Dword != NULL; i++ ) {
|
|
|
|
bufferLength = sizeof(RegistryDwords[i].Dword);
|
|
|
|
RegQueryValueExW(
|
|
simptcpKey,
|
|
RegistryDwords[i].ValueName,
|
|
NULL,
|
|
&type,
|
|
(PVOID)RegistryDwords[i].Dword,
|
|
&bufferLength
|
|
);
|
|
}
|
|
|
|
//
|
|
// Read other known values from the registry. Determine the size
|
|
// of the QOTD file name. We need this so that we can allocate
|
|
// enough memory to hold it.
|
|
//
|
|
|
|
qotdFileNameLength = 0;
|
|
|
|
error = RegQueryValueExW(
|
|
simptcpKey,
|
|
L"QotdFileName",
|
|
NULL,
|
|
&type,
|
|
NULL,
|
|
&qotdFileNameLength
|
|
);
|
|
|
|
if ( error == ERROR_MORE_DATA || error == NO_ERROR ) {
|
|
|
|
fileName = RtlAllocateHeap(
|
|
RtlProcessHeap( ),
|
|
0,
|
|
qotdFileNameLength
|
|
);
|
|
if ( fileName == NULL ) {
|
|
return NO_ERROR;
|
|
}
|
|
|
|
error = RegQueryValueExW(
|
|
simptcpKey,
|
|
L"QotdFileName",
|
|
NULL,
|
|
&type,
|
|
(PVOID)fileName,
|
|
&qotdFileNameLength
|
|
);
|
|
if ( error != NO_ERROR ) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, fileName );
|
|
return NO_ERROR;
|
|
}
|
|
|
|
//
|
|
// Expand the file name.
|
|
//
|
|
|
|
qotdFileNameLength = ExpandEnvironmentStringsW( fileName, NULL, 0 );
|
|
|
|
if (qotdFileNameLength == 0) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, fileName );
|
|
return GetLastError();
|
|
}
|
|
|
|
QotdFileName = RtlAllocateHeap(
|
|
RtlProcessHeap( ),
|
|
0,
|
|
qotdFileNameLength * sizeof(UNICODE_NULL)
|
|
);
|
|
if ( QotdFileName == NULL ) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, fileName );
|
|
return NO_ERROR;
|
|
}
|
|
|
|
Length = ExpandEnvironmentStringsW( fileName, QotdFileName,
|
|
qotdFileNameLength );
|
|
if (Length == 0) {
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, fileName );
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, QotdFileName );
|
|
return GetLastError();
|
|
}
|
|
|
|
}
|
|
|
|
return NO_ERROR;
|
|
|
|
} // ReadRegistry
|
|
|
|
|
|
DWORD
|
|
ThreadEntry (
|
|
LPVOID lpThreadParameter
|
|
)
|
|
{
|
|
DWORD i = PtrToUlong(lpThreadParameter);
|
|
PVOID ioBuffer;
|
|
INT err;
|
|
BOOLEAN graceful = TRUE;
|
|
|
|
//
|
|
// First, set the send and receive timeouts for the socket. This
|
|
// prevents a dead client from tying up our resources for too long.
|
|
//
|
|
|
|
err = setsockopt( TcpClients[i].SocketHandle, SOL_SOCKET, SO_SNDTIMEO,
|
|
(char *)&MaxIdleTicks, sizeof(MaxIdleTicks) );
|
|
if ( err == SOCKET_ERROR ) {
|
|
DeleteTcpClient( i, FALSE );
|
|
return 0;
|
|
}
|
|
|
|
err = setsockopt( TcpClients[i].SocketHandle, SOL_SOCKET, SO_RCVTIMEO,
|
|
(char *)&MaxIdleTicks, sizeof(MaxIdleTicks) );
|
|
if ( err == SOCKET_ERROR ) {
|
|
DeleteTcpClient( i, FALSE );
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Get a buffer to use locally for IO on the socket.
|
|
//
|
|
|
|
ioBuffer = RtlAllocateHeap( RtlProcessHeap( ), 0, IoBufferSize );
|
|
if ( ioBuffer == NULL ) {
|
|
DeleteTcpClient( i, FALSE );
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Now service the client as appropriate.
|
|
//
|
|
|
|
if ( TcpClients[i].ServicePort == TcpEchoPort ) {
|
|
|
|
//
|
|
// If there is data on a client's echo socket,
|
|
// receive some data and send it back.
|
|
//
|
|
|
|
do {
|
|
|
|
err = recv(
|
|
TcpClients[i].SocketHandle,
|
|
ioBuffer,
|
|
IoBufferSize,
|
|
0
|
|
);
|
|
if ( err == SOCKET_ERROR ) {
|
|
graceful = FALSE;
|
|
}
|
|
|
|
if ( err > 0 ) {
|
|
|
|
err = send(
|
|
TcpClients[i].SocketHandle,
|
|
ioBuffer,
|
|
err,
|
|
0
|
|
);
|
|
if ( err == SOCKET_ERROR ) {
|
|
graceful = FALSE;
|
|
}
|
|
|
|
} else if ( err < 0 ) {
|
|
|
|
graceful = FALSE;
|
|
}
|
|
|
|
} while ( err > 0 );
|
|
|
|
} else if ( TcpClients[i].ServicePort == TcpChargenPort ) {
|
|
|
|
INT one;
|
|
INT error;
|
|
TIMEVAL timeout;
|
|
|
|
//
|
|
// Set the socket to nonblocking.
|
|
//
|
|
|
|
one = 1;
|
|
err = ioctlsocket( TcpClients[i].SocketHandle, FIONBIO, &one );
|
|
if ( err == SOCKET_ERROR ) {
|
|
graceful = FALSE;
|
|
}
|
|
|
|
//
|
|
// Calculate the select() timeout.
|
|
//
|
|
|
|
timeout.tv_sec = MaxIdleTicks / 1000;
|
|
timeout.tv_usec = MaxIdleTicks % 1000;
|
|
|
|
//
|
|
// Loop sending data.
|
|
//
|
|
|
|
do {
|
|
|
|
err = send(
|
|
TcpClients[i].SocketHandle,
|
|
ChargenBuffer,
|
|
ChargenBufferSize,
|
|
0
|
|
);
|
|
|
|
if ( err == SOCKET_ERROR ) {
|
|
|
|
error = GetLastError( );
|
|
|
|
if ( error != WSAEWOULDBLOCK ) {
|
|
|
|
graceful = FALSE;
|
|
|
|
} else {
|
|
|
|
struct {
|
|
INT Count;
|
|
SOCKET Handle;
|
|
} readfds = { 0, 0 };
|
|
struct {
|
|
INT Count;
|
|
SOCKET Handle;
|
|
} writefds = { 0, 0 };
|
|
|
|
//
|
|
// The socket's send queue is blocked. Wait for it to
|
|
// become unblocked.
|
|
//
|
|
|
|
FD_SET( TcpClients[i].SocketHandle, (PFD_SET)&readfds );
|
|
FD_SET( TcpClients[i].SocketHandle, (PFD_SET)&writefds );
|
|
|
|
err = select(
|
|
1,
|
|
(PFD_SET)&readfds,
|
|
(PFD_SET)&writefds,
|
|
NULL,
|
|
&timeout
|
|
);
|
|
if ( err <= 0 ) {
|
|
graceful = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
err = recv(
|
|
TcpClients[i].SocketHandle,
|
|
ioBuffer,
|
|
IoBufferSize,
|
|
0
|
|
);
|
|
if ( err == SOCKET_ERROR ) {
|
|
if ( WSAGetLastError( ) != WSAEWOULDBLOCK ) {
|
|
graceful = FALSE;
|
|
} else {
|
|
err = 1;
|
|
}
|
|
}
|
|
|
|
} while ( err > 0 );
|
|
|
|
} else if ( TcpClients[i].ServicePort == TcpDiscardPort ) {
|
|
|
|
//
|
|
// If there is data on a client's socket, just
|
|
// receive some data and discard it.
|
|
//
|
|
|
|
do {
|
|
|
|
err = recv(
|
|
TcpClients[i].SocketHandle,
|
|
ioBuffer,
|
|
IoBufferSize,
|
|
0
|
|
);
|
|
if ( err == SOCKET_ERROR ) {
|
|
graceful = FALSE;
|
|
}
|
|
|
|
} while ( err > 0 );
|
|
|
|
} else {
|
|
|
|
//
|
|
// Something bad has happened. Internal data
|
|
// structures are corrupt.
|
|
//
|
|
|
|
ASSERT( FALSE );
|
|
}
|
|
|
|
//
|
|
// Free the socket and the IO buffer and return.
|
|
//
|
|
|
|
DeleteTcpClient( i, graceful );
|
|
RtlFreeHeap( RtlProcessHeap( ), 0, ioBuffer );
|
|
|
|
return 0;
|
|
|
|
} // ThreadEntry
|
|
|