|
/*
|
|
* wconsd.c
|
|
*
|
|
* Serial port server service for Windows NT
|
|
* Copyright (C) 1998 Stephen Early <Stephen.Early@cl.cam.ac.uk>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
/* There doesn't appear to be any way to register parameters for the
|
|
* service with the service control manager, so I assume I have to compile
|
|
* configuration information in. Ick. */
|
|
#define PORT 9600
|
|
#define COMPORT "\\\\.\\COM1"
|
|
#define PORTSPEED 9600
|
|
|
|
/* Size of buffers for send and receive */
|
|
#define BUFSIZE 1024
|
|
|
|
/* End of user-serviceable parts */
|
|
|
|
/* Note: winsock2.h MUST be included before windows.h */
|
|
|
|
#include <winsock2.h>
|
|
#include <windows.h>
|
|
#include <stdio.h>
|
|
|
|
/* Sockets for listening and communicating */
|
|
SOCKET ls=INVALID_SOCKET,cs=INVALID_SOCKET;
|
|
|
|
/* Event objects */
|
|
HANDLE stopEvent, connectionCloseEvent, threadTermEvent;
|
|
HANDLE readEvent, writeEvent;
|
|
WSAEVENT listenSocketEvent;
|
|
|
|
/* COM port */
|
|
HANDLE hCom;
|
|
DCB dcb;
|
|
COMMTIMEOUTS timeouts;
|
|
|
|
/* Service status: our current status, and handle on service manager */
|
|
SERVICE_STATUS wconsd_status;
|
|
SERVICE_STATUS_HANDLE wconsd_statusHandle;
|
|
|
|
/* Code starts here */
|
|
|
|
/* DoeS aNyBody know where this debug output appears? */
|
|
VOID SvcDebugOut(LPSTR String, DWORD Status)
|
|
{
|
|
CHAR Buffer[1024];
|
|
if (strlen(String)<1000) {
|
|
sprintf(Buffer, String, Status);
|
|
OutputDebugStringA(Buffer);
|
|
}
|
|
}
|
|
|
|
/* Initialise wconsd: open a listening socket and the COM port, and
|
|
* create lots of event objects. */
|
|
DWORD wconsd_init(DWORD argc, LPSTR *argv, DWORD *specificError)
|
|
{
|
|
struct sockaddr_in sin;
|
|
WORD wVersionRequested;
|
|
WSADATA wsaData;
|
|
int err;
|
|
|
|
/* Start up sockets */
|
|
wVersionRequested = MAKEWORD( 2, 2 );
|
|
|
|
err = WSAStartup( wVersionRequested, &wsaData );
|
|
if ( err != 0 ) {
|
|
*specificError=err;
|
|
/* Tell the user that we could not find a usable */
|
|
/* WinSock DLL. */
|
|
return 1;
|
|
}
|
|
|
|
/* Confirm that the WinSock DLL supports 2.2.*/
|
|
/* Note that if the DLL supports versions greater */
|
|
/* than 2.2 in addition to 2.2, it will still return */
|
|
/* 2.2 in wVersion since that is the version we */
|
|
/* requested. */
|
|
|
|
if ( LOBYTE( wsaData.wVersion ) != 2 ||
|
|
HIBYTE( wsaData.wVersion ) != 2 ) {
|
|
/* Tell the user that we could not find a usable */
|
|
/* WinSock DLL. */
|
|
WSACleanup( );
|
|
return 2;
|
|
}
|
|
|
|
/* The WinSock DLL is acceptable. Proceed. */
|
|
|
|
// Create the event object used to signal service shutdown
|
|
stopEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
|
|
if (stopEvent==NULL) {
|
|
*specificError=GetLastError();
|
|
return 3;
|
|
}
|
|
// Create the event object used to signal connection close
|
|
connectionCloseEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
|
|
if (connectionCloseEvent==NULL) {
|
|
*specificError=GetLastError();
|
|
return 4;
|
|
}
|
|
threadTermEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
|
|
if (threadTermEvent==NULL) {
|
|
*specificError=GetLastError();
|
|
return 5;
|
|
}
|
|
// Event objects for overlapped IO
|
|
readEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
|
|
if (readEvent==NULL) {
|
|
*specificError=GetLastError();
|
|
return 6;
|
|
}
|
|
writeEvent = CreateEvent(NULL,TRUE,FALSE,NULL);
|
|
if (writeEvent==NULL) {
|
|
*specificError=GetLastError();
|
|
return 7;
|
|
}
|
|
// Create the event object for socket operations
|
|
listenSocketEvent = WSACreateEvent();
|
|
if (listenSocketEvent==WSA_INVALID_EVENT) {
|
|
*specificError=WSAGetLastError();
|
|
return 8;
|
|
}
|
|
|
|
/* Create a socket to listen for connections. */
|
|
memset(&sin,0,sizeof(sin));
|
|
sin.sin_family=AF_INET;
|
|
sin.sin_port=htons(PORT);
|
|
ls=socket(AF_INET,SOCK_STREAM,0);
|
|
if (ls==INVALID_SOCKET) {
|
|
*specificError=WSAGetLastError();
|
|
return 9;
|
|
}
|
|
if (bind(ls,(struct sockaddr *)&sin,sizeof(sin))==SOCKET_ERROR) {
|
|
*specificError=WSAGetLastError();
|
|
return 10;
|
|
}
|
|
if (listen(ls,1)==SOCKET_ERROR) {
|
|
*specificError=WSAGetLastError();
|
|
return 11;
|
|
}
|
|
|
|
/* Mark the socket as non-blocking */
|
|
if (WSAEventSelect(ls,listenSocketEvent,FD_ACCEPT)==SOCKET_ERROR) {
|
|
*specificError=WSAGetLastError();
|
|
return 12;
|
|
}
|
|
|
|
/* Open the COM port */
|
|
hCom = CreateFile(COMPORT,
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0, // Exclusive access
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_FLAG_OVERLAPPED,
|
|
NULL);
|
|
if (hCom == INVALID_HANDLE_VALUE) {
|
|
*specificError=GetLastError();
|
|
return 13;
|
|
}
|
|
|
|
if (!GetCommState(hCom, &dcb)) {
|
|
*specificError=GetLastError();
|
|
return 14;
|
|
}
|
|
|
|
// Fill in the device control block
|
|
dcb.BaudRate=PORTSPEED;
|
|
dcb.ByteSize=8;
|
|
dcb.Parity=NOPARITY;
|
|
dcb.StopBits=ONESTOPBIT;
|
|
dcb.fBinary=TRUE;
|
|
dcb.fOutxCtsFlow=FALSE;
|
|
dcb.fOutxDsrFlow=FALSE;
|
|
dcb.fDtrControl=DTR_CONTROL_ENABLE; // Always on
|
|
dcb.fDsrSensitivity=FALSE;
|
|
dcb.fTXContinueOnXoff=FALSE;
|
|
dcb.fOutX=FALSE;
|
|
dcb.fInX=FALSE;
|
|
dcb.fErrorChar=FALSE;
|
|
dcb.fNull=FALSE;
|
|
dcb.fRtsControl=RTS_CONTROL_ENABLE; // Always on
|
|
dcb.fAbortOnError=FALSE;
|
|
|
|
if (!SetCommState(hCom, &dcb)) {
|
|
*specificError=GetLastError();
|
|
return 15;
|
|
}
|
|
|
|
timeouts.ReadIntervalTimeout=20;
|
|
timeouts.ReadTotalTimeoutMultiplier=0;
|
|
timeouts.ReadTotalTimeoutConstant=50;
|
|
timeouts.WriteTotalTimeoutMultiplier=0;
|
|
timeouts.WriteTotalTimeoutConstant=0;
|
|
if (!SetCommTimeouts(hCom, &timeouts)) {
|
|
*specificError=GetLastError();
|
|
return 16;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
DWORD WINAPI wconsd_net_to_com(LPVOID lpParam)
|
|
{
|
|
BYTE buf[BUFSIZE];
|
|
DWORD size,wsize;
|
|
unsigned long zero=0;
|
|
fd_set s;
|
|
OVERLAPPED o={0};
|
|
|
|
o.hEvent = writeEvent;
|
|
while (WaitForSingleObject(threadTermEvent,0)!=WAIT_OBJECT_0) {
|
|
/* There's a bug in some versions of Windows which leads
|
|
* to recv() returning -1 and indicating error WSAEWOULDBLOCK,
|
|
* even on a blocking socket. This select() is here to work
|
|
* around that bug. */
|
|
FD_SET(cs,&s);
|
|
select(0,&s,NULL,NULL,NULL);
|
|
size=recv(cs,buf,BUFSIZE,0);
|
|
if (size==0) {
|
|
SetEvent(connectionCloseEvent);
|
|
return 0;
|
|
}
|
|
if (size==SOCKET_ERROR) {
|
|
/* General paranoia about blocking sockets */
|
|
ioctlsocket(cs,FIONBIO,&zero);
|
|
}
|
|
if (size!=SOCKET_ERROR) {
|
|
if (!WriteFile(hCom,buf,size,&wsize,&o)) {
|
|
if (GetLastError()==ERROR_IO_PENDING) {
|
|
// Wait for it...
|
|
if (!GetOverlappedResult(hCom,&o,&wsize,TRUE)) {
|
|
printf("Error %d (overlapped) writing to COM port\n",GetLastError());
|
|
}
|
|
} else {
|
|
printf("Error %d writing to COM port\n",GetLastError());
|
|
}
|
|
}
|
|
if (wsize!=size) {
|
|
printf("Eeek! WriteFile: wrote %d of %d\n",wsize,size);
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
DWORD WINAPI wconsd_com_to_net(LPVOID lpParam)
|
|
{
|
|
BYTE buf[BUFSIZE];
|
|
DWORD size;
|
|
OVERLAPPED o={0};
|
|
|
|
o.hEvent=readEvent;
|
|
|
|
while (WaitForSingleObject(threadTermEvent,0)!=WAIT_OBJECT_0) {
|
|
if (!ReadFile(hCom,buf,BUFSIZE,&size,&o)) {
|
|
if (GetLastError()==ERROR_IO_PENDING) {
|
|
// Wait for overlapped operation to complete
|
|
if (!GetOverlappedResult(hCom,&o,&size,TRUE)) {
|
|
printf("Error %d (overlapped) reading from COM port\n",GetLastError());
|
|
}
|
|
} else {
|
|
printf("Error %d reading from COM port\n",GetLastError());
|
|
SetEvent(connectionCloseEvent);
|
|
return 0;
|
|
}
|
|
}
|
|
if (size>0) {
|
|
send(cs,buf,size,0);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void wconsd_main(void)
|
|
{
|
|
HANDLE wait_array[3];
|
|
BOOL run=TRUE;
|
|
DWORD o;
|
|
SOCKET as;
|
|
HANDLE netThread=NULL, comThread=NULL;
|
|
long zero;
|
|
|
|
/* Main loop: wait for a connection, service it, repeat
|
|
* until signalled that the service is terminating */
|
|
wait_array[0]=stopEvent;
|
|
wait_array[1]=listenSocketEvent;
|
|
wait_array[2]=connectionCloseEvent;
|
|
|
|
while (run) {
|
|
o=WaitForMultipleObjects(3,wait_array,FALSE,INFINITE);
|
|
|
|
switch (o-WAIT_OBJECT_0) {
|
|
case 0:
|
|
run=FALSE;
|
|
ResetEvent(stopEvent);
|
|
break;
|
|
case 1: /* There is an incoming connection */
|
|
WSAResetEvent(listenSocketEvent);
|
|
as=accept(ls,NULL,NULL);
|
|
|
|
if (as!=INVALID_SOCKET) {
|
|
if (cs!=INVALID_SOCKET) {
|
|
/* Close down the existing connection and let the new one through */
|
|
SetEvent(threadTermEvent);
|
|
shutdown(cs,SD_BOTH);
|
|
WaitForSingleObject(netThread,INFINITE);
|
|
WaitForSingleObject(comThread,INFINITE);
|
|
CloseHandle(netThread);
|
|
CloseHandle(comThread);
|
|
closesocket(cs);
|
|
ResetEvent(connectionCloseEvent);
|
|
ResetEvent(threadTermEvent);
|
|
}
|
|
cs=as;
|
|
zero=0;
|
|
ioctlsocket(cs,FIONBIO,&zero);
|
|
PurgeComm(hCom,PURGE_RXCLEAR|PURGE_RXABORT);
|
|
netThread=CreateThread(NULL,0,wconsd_net_to_com,NULL,0,NULL);
|
|
comThread=CreateThread(NULL,0,wconsd_com_to_net,NULL,0,NULL);
|
|
}
|
|
break;
|
|
case 2: /* The data connection has been broken */
|
|
SetEvent(threadTermEvent);
|
|
WaitForSingleObject(netThread,INFINITE);
|
|
WaitForSingleObject(comThread,INFINITE);
|
|
CloseHandle(netThread);
|
|
CloseHandle(comThread);
|
|
netThread=NULL;
|
|
comThread=NULL;
|
|
if (cs!=INVALID_SOCKET) {
|
|
shutdown(cs,SD_BOTH);
|
|
closesocket(cs);
|
|
cs=INVALID_SOCKET;
|
|
}
|
|
ResetEvent(connectionCloseEvent);
|
|
ResetEvent(threadTermEvent);
|
|
break;
|
|
default:
|
|
run=FALSE; // Stop the service - I want to get off!
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (cs!=INVALID_SOCKET) {
|
|
shutdown(cs,SD_BOTH);
|
|
closesocket(cs);
|
|
}
|
|
|
|
if (netThread || comThread) {
|
|
SetEvent(threadTermEvent);
|
|
WaitForSingleObject(netThread,INFINITE);
|
|
WaitForSingleObject(comThread,INFINITE);
|
|
CloseHandle(netThread);
|
|
CloseHandle(comThread);
|
|
}
|
|
|
|
CloseHandle(hCom);
|
|
closesocket(ls);
|
|
WSACleanup();
|
|
}
|
|
|
|
VOID WINAPI MyServiceCtrlHandler(DWORD opcode)
|
|
{
|
|
DWORD status;
|
|
|
|
switch(opcode) {
|
|
case SERVICE_CONTROL_STOP:
|
|
wconsd_status.dwWin32ExitCode = 0;
|
|
wconsd_status.dwCurrentState = SERVICE_STOP_PENDING;
|
|
wconsd_status.dwCheckPoint = 0;
|
|
wconsd_status.dwWaitHint = 0;
|
|
|
|
if (!SetServiceStatus(wconsd_statusHandle, &wconsd_status)) {
|
|
status = GetLastError();
|
|
SvcDebugOut(" [wconsd] SetServiceStatus error %ld\n",status);
|
|
}
|
|
|
|
SetEvent(stopEvent);
|
|
break;
|
|
|
|
case SERVICE_CONTROL_INTERROGATE:
|
|
// fall through to send current status
|
|
break;
|
|
|
|
default:
|
|
SvcDebugOut(" [wconsd] unrecognised opcode %ld\n",opcode);
|
|
break;
|
|
}
|
|
|
|
// Send current status
|
|
if (!SetServiceStatus(wconsd_statusHandle, &wconsd_status)) {
|
|
status = GetLastError();
|
|
SvcDebugOut(" [wconsd] SetServiceStatus error %ld\n",status);
|
|
}
|
|
return;
|
|
}
|
|
|
|
VOID WINAPI ServiceStart(DWORD argc, LPSTR *argv)
|
|
{
|
|
DWORD status;
|
|
DWORD specificError;
|
|
|
|
wconsd_status.dwServiceType = SERVICE_WIN32;
|
|
wconsd_status.dwCurrentState = SERVICE_START_PENDING;
|
|
wconsd_status.dwControlsAccepted = SERVICE_ACCEPT_STOP;
|
|
wconsd_status.dwWin32ExitCode = 0;
|
|
wconsd_status.dwServiceSpecificExitCode = 0;
|
|
wconsd_status.dwCheckPoint = 0;
|
|
wconsd_status.dwWaitHint = 0;
|
|
wconsd_statusHandle = RegisterServiceCtrlHandler(TEXT("wconsd"),MyServiceCtrlHandler);
|
|
|
|
if (wconsd_statusHandle == (SERVICE_STATUS_HANDLE)0) {
|
|
SvcDebugOut(" [wconsd] RegisterServiceCtrlHandler failed %d\n", GetLastError());
|
|
return;
|
|
}
|
|
|
|
status = wconsd_init(argc, argv, &specificError);
|
|
|
|
if (status != NO_ERROR) {
|
|
wconsd_status.dwCurrentState = SERVICE_STOPPED;
|
|
wconsd_status.dwCheckPoint = 0;
|
|
wconsd_status.dwWaitHint = 0;
|
|
wconsd_status.dwWin32ExitCode = status;
|
|
wconsd_status.dwServiceSpecificExitCode = specificError;
|
|
|
|
SetServiceStatus(wconsd_statusHandle, &wconsd_status);
|
|
return;
|
|
}
|
|
|
|
/* Initialisation complete - report running status */
|
|
wconsd_status.dwCurrentState = SERVICE_RUNNING;
|
|
wconsd_status.dwCheckPoint = 0;
|
|
wconsd_status.dwWaitHint = 0;
|
|
|
|
if (!SetServiceStatus(wconsd_statusHandle, &wconsd_status)) {
|
|
status = GetLastError();
|
|
SvcDebugOut(" [wconsd] SetServiceStatus error %ld\n",status);
|
|
}
|
|
|
|
wconsd_main();
|
|
|
|
wconsd_status.dwCurrentState = SERVICE_STOPPED;
|
|
wconsd_status.dwCheckPoint = 0;
|
|
wconsd_status.dwWaitHint = 0;
|
|
wconsd_status.dwWin32ExitCode = 0;
|
|
wconsd_status.dwServiceSpecificExitCode = 0;
|
|
|
|
SetServiceStatus(wconsd_statusHandle, &wconsd_status);
|
|
|
|
return;
|
|
}
|
|
|
|
static void RegisterService(LPSTR path)
|
|
{
|
|
SC_HANDLE schSCManager, schService;
|
|
|
|
schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
|
|
|
|
schService = CreateService(
|
|
schSCManager,
|
|
TEXT("wconsd"),
|
|
TEXT("wconsd"),
|
|
SERVICE_ALL_ACCESS,
|
|
SERVICE_WIN32_OWN_PROCESS,
|
|
SERVICE_AUTO_START,
|
|
SERVICE_ERROR_NORMAL,
|
|
path,
|
|
NULL, NULL, NULL, NULL, NULL);
|
|
|
|
if (schService == NULL) {
|
|
printf("CreateService failed\n");
|
|
} else {
|
|
printf("Created service 'wconsd', binary path %s\n",path);
|
|
printf("You should now start the service using the service manager.\n");
|
|
}
|
|
CloseServiceHandle(schService);
|
|
}
|
|
|
|
static void RemoveService(void)
|
|
{
|
|
SC_HANDLE schSCManager, schService;
|
|
|
|
schSCManager = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
|
|
if (schSCManager == NULL) {
|
|
printf("Couldn't open service manager\n");
|
|
return;
|
|
}
|
|
|
|
schService = OpenService(schSCManager, TEXT("wconsd"), DELETE);
|
|
|
|
if (schService == NULL) {
|
|
printf("Couldn't open wconsd service\n");
|
|
return;
|
|
}
|
|
|
|
if (!DeleteService(schService)) {
|
|
printf("Couldn't delete wconsd service\n");
|
|
return;
|
|
}
|
|
|
|
printf("Deleted service 'wconsd'\n");
|
|
|
|
CloseServiceHandle(schService);
|
|
}
|
|
|
|
static void usage(void)
|
|
{
|
|
printf("Usage: wconsd [-i pathname | -r | -d]\n");
|
|
printf(" -i pathname install service 'wconsd'; pathname\n");
|
|
printf(" must be the full path to the binary\n");
|
|
printf(" -r remove service 'wconsd'\n");
|
|
printf(" -d run wconsd in debug mode (in the foreground)\n");
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
DWORD err;
|
|
SERVICE_TABLE_ENTRY DispatchTable[] =
|
|
{
|
|
{ "wconsd", ServiceStart },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
if (argc==1 || argc==0) {
|
|
if (!StartServiceCtrlDispatcher(DispatchTable)) {
|
|
SvcDebugOut(" [wconsd] StartServiceCtrlDispatcher error = %d\n", GetLastError());
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
if (strcmp(argv[1],"-i")==0) {
|
|
if (argc!=3) {
|
|
usage();
|
|
return 1;
|
|
}
|
|
RegisterService(argv[2]);
|
|
} else if (strcmp(argv[1],"-r")==0) {
|
|
RemoveService();
|
|
} else if (strcmp(argv[1],"-d")==0) {
|
|
int r;
|
|
printf("wconsd: running in debug mode\n");
|
|
r=wconsd_init(argc,argv,&err);
|
|
if (r!=0) {
|
|
printf("wconsd: debug: init failed, return code %d\n",r);
|
|
return 1;
|
|
}
|
|
wconsd_main();
|
|
return 0;
|
|
} else usage();
|
|
|
|
return 1;
|
|
}
|