windows-nt/Source/XPSP1/NT/printscan/fax/itg/server/faxitg.cpp

729 lines
15 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1997 Microsoft Corporation
Module Name:
faxitg.cpp
Abstract:
This file implements the itg routing extension.
The purpose of this routing extension is to create
a queue of faxes that are processed by network
client applications. The clients are manual routers
that simply display the fax and allow the operator
to send the fax via email.
This code has 2 main parts, routing extension that
is called by the fax service and the client service
threads.
The routing extension part simply copies the fax file
into a disk directory that becomes the queue.
The client service threads service requests from the
clients for retrieving queued faxes. The clients
communicate through the use of sockets.
Author:
Wesley Witt (wesw) 13-May-1997
Environment:
User Mode
--*/
#include <windows.h>
#include <winsock2.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <lm.h>
#include "faxutil.h"
#include "faxroute.h"
#include "faxsvr.h"
#define MAX_THREADS 1
#define FAX_RECEIVE_DIR TEXT("%systemroot%\\faxreceive")
#define FILE_QUEUE_DIR TEXT("%systemroot%\\faxreceive\\itg")
#define ITG_SHARE_NAME TEXT("Itg")
#define ITG_SHARE_COMMENT TEXT("ITG Fax Queue")
typedef struct _CLIENT_DATA {
SOCKET Socket;
OVERLAPPED Overlapped;
FAX_QUEUE_MESSAGE Message;
} CLIENT_DATA, *PCLIENT_DATA;
PFAXROUTEGETFILE FaxRouteGetFile;
HINSTANCE MyhInstance;
BOOL ServiceDebug;
LPWSTR FaxReceiveDir;
LPWSTR FileQueueDir;
PSID ServiceSid;
WSADATA WsaData;
CLIENT_DATA ClientData[MAX_CLIENTS];
DWORD ClientCount;
DWORD
ServerWorkerThread(
HANDLE ServerCompletionPort
)
/*++
Routine Description:
This is the worker thread for servicing client
requests for retrieving faxes.
Arguments:
ServerCompletionPort - Completion port handle
Return Value:
Thread return value.
--*/
{
BOOL Rval;
DWORD Bytes;
WCHAR FileName[MAX_PATH];
WIN32_FIND_DATA FindData;
HANDLE hFind;
DWORD ClientIndex;
LPOVERLAPPED Overlapped;
PCLIENT_DATA ThisClient;
while( TRUE ) {
//
// get the next packet
//
Rval = GetQueuedCompletionStatus(
ServerCompletionPort,
&Bytes,
&ClientIndex,
&Overlapped,
INFINITE
);
if (!Rval) {
Rval = GetLastError();
continue;
}
ThisClient = &ClientData[ClientIndex];
if (ThisClient->Message.Request == REQ_NEXT_FAX) {
//
// get the next tif file in the queue
//
wcscpy( FileName, FileQueueDir );
wcscat( FileName, L"\\*.tif" );
hFind = FindFirstFile( FileName, &FindData );
if (hFind == INVALID_HANDLE_VALUE) {
FindClose( hFind );
ThisClient->Message.Response = RSP_BAD;
} else {
FindClose( hFind );
ThisClient->Message.Response = RSP_GOOD;
wcscpy( (LPWSTR) ThisClient->Message.Buffer, FindData.cFileName );
}
//
// send the file name to the client
//
Bytes = send( ThisClient->Socket, (char*)&ThisClient->Message, sizeof(FAX_QUEUE_MESSAGE), 0 );
if (Bytes == (DWORD)SOCKET_ERROR) {
DebugPrint(( L"Windows Sockets error %d: Couldn't send data to client\n", WSAGetLastError() ));
}
goto next_packet;
}
if (ThisClient->Message.Request == REQ_ACK) {
if (ThisClient->Message.Response == RSP_GOOD) {
//
// if the client successfully copied the file
// then delete it from the queue
//
wcscpy( FileName, FileQueueDir );
wcscat( FileName, L"\\" );
wcscat( FileName, (LPWSTR) ThisClient->Message.Buffer );
DeleteFile( FileName );
}
goto next_packet;
}
next_packet:
//
// re-prime the pump for this client by queuing another read
//
ReadFile(
(HANDLE) ThisClient->Socket,
(LPVOID) &ThisClient->Message,
sizeof(FAX_QUEUE_MESSAGE),
&Bytes,
&ThisClient->Overlapped
);
}
return 0;
}
DWORD
ServerNetworkThread(
LPVOID lpv
)
/*++
Routine Description:
This is the worker thread for servicing initial
client connections.
Arguments:
Not used.
Return Value:
Thread return value.
--*/
{
SOCKET srv_sock, cli_sock;
SOCKADDR_IN srv_addr;
HANDLE ServerCompletionPort;
HANDLE hThread;
DWORD ThreadId;
HANDLE CompletionPort;
DWORD Bytes;
//
// create the single completion port that
// is used to service client requests
//
ServerCompletionPort = CreateIoCompletionPort(
INVALID_HANDLE_VALUE,
NULL,
0,
1
);
if (!ServerCompletionPort) {
return FALSE;
}
//
// create the thread to service client requests
//
hThread = CreateThread(
NULL,
0,
(LPTHREAD_START_ROUTINE) ServerWorkerThread,
(LPVOID) ServerCompletionPort,
0,
&ThreadId
);
if (!hThread) {
return FALSE;
}
CloseHandle( hThread );
//
// Create the server-side socket
//
srv_sock = socket( AF_INET, SOCK_STREAM, 0 );
if (srv_sock == INVALID_SOCKET){
DebugPrint(( L"Windows Sockets error %d: Couldn't create socket.", WSAGetLastError() ));
return FALSE;
}
//
// create the server address
//
ZeroMemory( &srv_addr, sizeof(srv_addr) );
srv_addr.sin_family = AF_INET;
srv_addr.sin_port = htons( SERVICE_PORT );
//
// Bind socket to the appropriate port and interface
//
if (bind(srv_sock, (LPSOCKADDR)&srv_addr, sizeof(srv_addr) ) == SOCKET_ERROR){
DebugPrint(( L"Windows Sockets error %d: Couldn't bind socket.", WSAGetLastError() ));
return FALSE;
}
//
// Listen for incoming connections
//
if (listen( srv_sock, MAX_CLIENTS ) == SOCKET_ERROR){
DebugPrint(( L"Windows Sockets error %d: Couldn't set up listen on socket.", WSAGetLastError() ));
return FALSE;
}
//
// Accept and service incoming connection requests indefinitely
//
while (TRUE) {
//
// get a new client connection
//
cli_sock = accept( srv_sock, NULL, NULL );
if (cli_sock==INVALID_SOCKET){
DebugPrint(( L"Windows Sockets error %d: Couldn't accept incoming connection on socket.",WSAGetLastError() ));
return FALSE;
}
//
// setup the client data struct
//
ClientData[ClientCount].Socket = cli_sock;
//
// add the client to the completion port for reads
//
CompletionPort = CreateIoCompletionPort(
(HANDLE) ClientData[ClientCount].Socket,
ServerCompletionPort,
ClientCount,
MAX_THREADS
);
if (CompletionPort == NULL) {
DebugPrint(( L"Failed to add a socket to the completion port, ec=%d", GetLastError() ));
closesocket( cli_sock );
continue;
}
//
// prime the pump by queueing up a read
//
ReadFile(
(HANDLE) ClientData[ClientCount].Socket,
(LPVOID) &ClientData[ClientCount].Message,
sizeof(FAX_QUEUE_MESSAGE),
&Bytes,
&ClientData[ClientCount].Overlapped
);
//
// next client
//
ClientCount += 1;
}
return TRUE;
}
extern "C"
DWORD
FaxRouteDllInit(
HINSTANCE hInstance,
DWORD Reason,
LPVOID Context
)
/*++
Routine Description:
This is the dll entrypoint for this routing extension.
Arguments:
hInstance - Module handle
Reason - Reason for being called
Context - Register context
Return Value:
TRUE for success, otherwise FALSE.
--*/
{
if (Reason == DLL_PROCESS_ATTACH) {
MyhInstance = hInstance;
DisableThreadLibraryCalls( hInstance );
}
return TRUE;
}
BOOL
CreateNetworkShare(
LPTSTR Path,
LPTSTR ShareName,
LPTSTR Comment
)
/*++
Routine Description:
This functions creates a network share,
shares out a local disk directory.
Arguments:
Path - Local disk directory to share
ShareName - Name of the share
Comment - Comments
Return Value:
TRUE for success, otherwise FALSE.
--*/
{
SHARE_INFO_2 ShareInfo;
NET_API_STATUS rVal;
TCHAR ExpandedPath[MAX_PATH*2];
ExpandEnvironmentStrings( Path, ExpandedPath, sizeof(ExpandedPath) );
ShareInfo.shi2_netname = ShareName;
ShareInfo.shi2_type = STYPE_DISKTREE;
ShareInfo.shi2_remark = Comment;
ShareInfo.shi2_permissions = ACCESS_ALL;
ShareInfo.shi2_max_uses = (DWORD) -1,
ShareInfo.shi2_current_uses = (DWORD) -1;
ShareInfo.shi2_path = ExpandedPath;
ShareInfo.shi2_passwd = NULL;
rVal = NetShareAdd(
NULL,
2,
(LPBYTE) &ShareInfo,
NULL
);
return rVal == 0;
}
BOOL WINAPI
FaxRouteInitialize(
IN HANDLE HeapHandle,
IN PFAXROUTEADDFILE pFaxRouteAddFile,
IN PFAXROUTEDELETEFILE pFaxRouteDeleteFile,
IN PFAXROUTEGETFILE pFaxRouteGetFile,
IN PFAXROUTEENUMFILES pFaxRouteEnumFiles
)
/*++
Routine Description:
This functions is called by the fax service to
initialize the routing extension.
Arguments:
HeapHandle - Heap handle for memory all allocations
pFaxRouteAddFile - Support function for adding files to routing file list
pFaxRouteDeleteFile - Support function for deleting files from the routing file list
pFaxRouteGetFile - Support function for geting files from the routing file list
pFaxRouteEnumFiles - Support function for enumerating files in the routing file list
Return Value:
TRUE for success, otherwise FALSE.
--*/
{
HANDLE hThread;
DWORD ThreadId;
DWORD Size;
FaxRouteGetFile = pFaxRouteGetFile;
HeapInitialize(HeapHandle,NULL,NULL,0);
Size = ExpandEnvironmentStrings( FAX_RECEIVE_DIR, FaxReceiveDir, 0 );
if (Size) {
FaxReceiveDir = (LPWSTR) MemAlloc( Size * sizeof(WCHAR) );
if (FaxReceiveDir) {
ExpandEnvironmentStrings( FAX_RECEIVE_DIR, FaxReceiveDir, Size );
}
}
Size = ExpandEnvironmentStrings( FILE_QUEUE_DIR, FileQueueDir, 0 );
if (Size) {
FileQueueDir = (LPWSTR) MemAlloc( Size * sizeof(WCHAR) );
if (FileQueueDir) {
ExpandEnvironmentStrings( FILE_QUEUE_DIR, FileQueueDir, Size );
}
}
if (FaxReceiveDir == NULL || FileQueueDir == NULL) {
return FALSE;
}
CreateNetworkShare( FileQueueDir, ITG_SHARE_NAME, ITG_SHARE_COMMENT );
//
// initialize winsock
//
if (WSAStartup( 0x0101, &WsaData )) {
return FALSE;
}
hThread = CreateThread(
NULL,
0,
(LPTHREAD_START_ROUTINE) ServerNetworkThread,
NULL,
0,
&ThreadId
);
if (!hThread) {
return FALSE;
}
return TRUE;
}
BOOL WINAPI
FaxRouteGetRoutingInfo(
IN LPWSTR RoutingGuid,
IN DWORD DeviceId,
IN LPBYTE RoutingInfo,
OUT LPDWORD RoutingInfoSize
)
/*++
Routine Description:
This functions is called by the fax service to
get routing configuration data.
Arguments:
RoutingGuid - Unique identifier for the requested routing method
DeviceId - Device that is being configured
RoutingInfo - Routing info buffer
RoutingInfoSize - Size of the buffer
Return Value:
TRUE for success, otherwise FALSE.
--*/
{
RoutingInfo = NULL;
RoutingInfoSize = 0;
return TRUE;
}
BOOL WINAPI
FaxRouteSetRoutingInfo(
IN LPWSTR RoutingGuid,
IN DWORD DeviceId,
IN LPBYTE RoutingInfo,
IN DWORD RoutingInfoSize
)
/*++
Routine Description:
This functions is called by the fax service to
set routing configuration data.
Arguments:
RoutingGuid - Unique identifier for the requested routing method
DeviceId - Device that is being configured
RoutingInfo - Routing info buffer
RoutingInfoSize - Size of the buffer
Return Value:
TRUE for success, otherwise FALSE.
--*/
{
return TRUE;
}
BOOL WINAPI
FaxRouteConfigure(
OUT HPROPSHEETPAGE *PropSheetPage
)
/*++
Routine Description:
This functions is called by the fax service to
get a property sheet for user configuration of
the routing extension.
Arguments:
PropSheetPage - Handle to a property sheet
Return Value:
TRUE for success, otherwise FALSE.
--*/
{
return TRUE;
}
BOOL WINAPI
FaxRouteItg(
PFAX_ROUTE FaxRoute,
PVOID *FailureData,
LPDWORD FailureDataSize
)
/*++
Routine Description:
This functions is called by the fax service to
route a received fax.
Arguments:
FaxRoute - Routing information
FailureData - Failure data buffer
FailureDataSize - Size of failure data buffer
Return Value:
TRUE for success, otherwise FALSE.
--*/
{
DWORD Size;
WCHAR TiffFileName[MAX_PATH];
LPWSTR SrcFName = NULL;
WCHAR DstFName[MAX_PATH];
LPTSTR FBaseName;
WCHAR FName[_MAX_FNAME];
WCHAR Ext[_MAX_EXT];
Size = sizeof(TiffFileName) / sizeof(WCHAR);
if (!FaxRouteGetFile(
FaxRoute->JobId,
0,
TiffFileName,
&Size))
{
return FALSE;
}
Size = GetFullPathName(
TiffFileName,
0,
SrcFName,
&FBaseName
);
SrcFName = (LPWSTR) MemAlloc( (Size + 1) * sizeof(WCHAR) );
if (!SrcFName) {
return FALSE;
}
GetFullPathName(
TiffFileName,
Size,
SrcFName,
&FBaseName
);
_wsplitpath( SrcFName, NULL, NULL, FName, Ext );
wcscpy( DstFName, FileQueueDir );
wcscat( DstFName, L"\\" );
wcscat( DstFName, FName );
wcscat( DstFName, Ext );
if (!CopyFile( SrcFName, DstFName, TRUE )) {
MemFree( SrcFName );
return FALSE;
}
MemFree( SrcFName );
return TRUE;
}
BOOL WINAPI
FaxRouteDeviceEnable(
IN LPWSTR RoutingGuid,
IN DWORD DeviceId,
IN LONG Enabled
)
{
return TRUE;
}