archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
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.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/printscan/faxsrv/service/server/faxrpc.c

13992 lines
397 KiB
Raw Permalink Blame History

/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
faxrpc.c
Abstract:
This module contains the functions that are dispatched
as a result of an rpc call.
Author:
Wesley Witt (wesw) 16-Jan-1996
Revision History:
--*/
#include "faxsvc.h"
#include "faxreg.h"
#include "fxsapip.h"
#pragma hdrstop
#include "tapiCountry.h"
#define STRSAFE_NO_DEPRECATE
#include <strsafe.h>
static BOOL
IsLegalQueueSetting(
DWORD dwQueueStates
);
DWORD
GetServerErrorCode (DWORD ec)
{
DWORD dwServerEC;
switch (ec)
{
case ERROR_OUTOFMEMORY:
case ERROR_NOT_ENOUGH_MEMORY:
dwServerEC = FAX_ERR_SRV_OUTOFMEMORY;
break;
default:
dwServerEC = ec;
break;
}
return dwServerEC;
}
//
// version defines
//
CFaxCriticalSection g_CsClients;
DWORD g_dwConnectionCount; // Represents the number of active rpc connections.
static DWORD GetJobSize(PJOB_QUEUE JobQueue);
static BOOL GetJobData(
LPBYTE JobBuffer,
PFAX_JOB_ENTRYW FaxJobEntry,
PJOB_QUEUE JobQueue,
PULONG_PTR Offset,
DWORD dwJobBufferSize
);
static BOOL GetJobDataEx(
LPBYTE JobBuffer,
PFAX_JOB_ENTRY_EXW pFaxJobEntry,
PFAX_JOB_STATUSW pFaxStatus,
DWORD dwClientAPIVersion,
const PJOB_QUEUE lpcJobQueue,
PULONG_PTR Offset,
DWORD dwJobBufferSize
);
static DWORD
LineInfoToLegacyDeviceStatus(
const LINE_INFO *lpcLineInfo
);
static
LPTSTR
GetClientMachineName (
IN handle_t hFaxHandle
);
static
DWORD
CreatePreviewFile (
DWORDLONG dwlMsgId,
BOOL bAllMessages,
PJOB_QUEUE* lppJobQueue
);
BOOL
ReplaceStringWithCopy (
LPWSTR *plpwstrDst,
LPWSTR lpcwstrSrc
)
/*++
Routine name : ReplaceStringWithCopy
Routine description:
Replaces a string with a new copy of another string
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
plpwstrDst [in/out] - Destination string. If allocated, gets freed.
lpcwstrSrc [in] - Source string to copy.
Return Value:
TRUE - Success
FALSE - Failure, call GetLastError() for more error information.
--*/
{
MemFree (LPVOID(*plpwstrDst));
*plpwstrDst = NULL;
if (NULL == lpcwstrSrc)
{
return TRUE;
}
*plpwstrDst = StringDup (lpcwstrSrc);
if (NULL == *plpwstrDst)
{
//
// Failed to duplicate source string
//
return FALSE;
}
return TRUE;
} // ReplaceStringWithCopy
void *
MIDL_user_allocate(
IN size_t NumBytes
)
{
return MemAlloc( NumBytes );
}
void
MIDL_user_free(
IN void *MemPointer
)
{
MemFree( MemPointer );
}
error_status_t
FAX_ConnectFaxServer(
handle_t hBinding,
DWORD dwClientAPIVersion,
LPDWORD lpdwServerAPIVersion,
PRPC_FAX_SVC_HANDLE pHandle
)
/*++
Routine name : FAX_ConnectFaxServer
Routine description:
Creates the initial connection context handle to the server
Author:
Eran Yariv (EranY), Feb, 2001
Arguments:
hBinding [in] - RPC binding handle
dwClientAPIVersion [in] - API version of the client module
lpdwServerAPIVersion [out] - API version of the server module (us)
pHandle [out] - Pointer to context handle
Return Value:
ERROR_SUCCESS for success, otherwise a WIN32 error code.
--*/
{
PHANDLE_ENTRY pHandleEntry = NULL;
error_status_t Rval = 0;
BOOL fAccess;
DWORD dwRights;
DEBUG_FUNCTION_NAME(TEXT("FAX_ConnectFaxServer"));
Assert (lpdwServerAPIVersion);
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
if (dwClientAPIVersion > CURRENT_FAX_API_VERSION)
{
//
//
// Not knowning any better (for now), we treat all other versions as current (latest) version clients
//
dwClientAPIVersion = CURRENT_FAX_API_VERSION;
}
//
// Give away our API version
//
*lpdwServerAPIVersion = CURRENT_FAX_API_VERSION;
pHandleEntry = CreateNewConnectionHandle(hBinding, dwClientAPIVersion);
if (!pHandleEntry)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR, _T("CreateNewConnectionHandle() failed, Error %ld"), Rval);
return Rval;
}
*pHandle = (HANDLE) pHandleEntry;
SafeIncIdleCounter (&g_dwConnectionCount);
return ERROR_SUCCESS;
} // FAX_ConnectFaxServer
error_status_t
FAX_ConnectionRefCount(
handle_t FaxHandle,
LPHANDLE FaxConHandle,
DWORD dwConnect,
LPDWORD CanShare
)
/*++
Routine Description:
Called on connect. Maintains an active connection count. Client unbind rpc and
the counter is decremented in the rundown routine. Returns a context handle to the client.
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
FaxConHandle - Context handle
dwConnect -
1 if connecting,
0 if disconnecting,
2 if releasing ( only decrement the counter )
CanShare - non-zero if sharing is allowed, zero otherwise
Return Value:
TRUE - Success
FALSE - Failure, call GetLastError() for more error information.
--*/
{
PHANDLE_ENTRY pHandleEntry = (PHANDLE_ENTRY) *FaxConHandle;
DEBUG_FUNCTION_NAME(TEXT("FAX_ConnectionRefCount"));
switch (dwConnect)
{
case 0: // Disconenct
if (NULL == pHandleEntry)
{
DebugPrintEx(DEBUG_ERR,
_T("Empty context handle"));
return ERROR_INVALID_PARAMETER;
}
CloseFaxHandle (pHandleEntry);
//
// Prevent rundown
//
*FaxConHandle = NULL;
return ERROR_SUCCESS;
case 1: // Connect (from BOS client)
{
DWORD dwDummy;
//
// Can always share
//
//
// Check parameters
//
if (!CanShare) // unique pointer in idl
{
DebugPrintEx(DEBUG_ERR,
_T("CanShare is NULL."));
return ERROR_INVALID_PARAMETER;
}
*CanShare = 1;
return FAX_ConnectFaxServer (FaxHandle, FAX_API_VERSION_0, &dwDummy, FaxConHandle);
}
case 2: // Release
if (NULL == pHandleEntry)
{
//
// Empty context handle
//
DebugPrintEx(DEBUG_ERR,
_T("Empty context handle"));
return ERROR_INVALID_PARAMETER;
}
if (pHandleEntry->bReleased)
{
//
// The handle is already released
//
DebugPrintEx(DEBUG_ERR,
_T("Failed to release handle -- it's already released."));
return ERROR_INVALID_PARAMETER;
}
SafeDecIdleCounter (&g_dwConnectionCount);
pHandleEntry->bReleased = TRUE;
return ERROR_SUCCESS;
default:
DebugPrintEx(DEBUG_ERR,
_T("FAX_ConnectionRefCount called with dwConnect=%ld"),
dwConnect);
return ERROR_INVALID_PARAMETER;
}
ASSERT_FALSE;
} // FAX_ConnectionRefCount
VOID
RPC_FAX_SVC_HANDLE_rundown(
IN HANDLE FaxConnectionHandle
)
{
PHANDLE_ENTRY pHandleEntry = (PHANDLE_ENTRY) FaxConnectionHandle;
DEBUG_FUNCTION_NAME(TEXT("RPC_FAX_SVC_HANDLE_rundown"));
DebugPrintEx(
DEBUG_WRN,
TEXT("RPC_FAX_SVC_HANDLE_rundown() running for connection handle 0x%08x"),
FaxConnectionHandle);
CloseFaxHandle( pHandleEntry );
return;
}
error_status_t
FAX_OpenPort(
handle_t FaxHandle,
DWORD DeviceId,
DWORD Flags,
LPHANDLE FaxPortHandle
)
/*++
Routine Description:
Opens a fax port for subsequent use in other fax APIs.
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
DeviceId - Requested device id
FaxPortHandle - The resulting FAX port handle.
Return Value:
TRUE - Success
FALSE - Failure, call GetLastError() for more error information.
--*/
{
error_status_t Rval = 0;
PLINE_INFO LineInfo;
PHANDLE_ENTRY HandleEntry;
BOOL fAccess;
DWORD dwRights;
DEBUG_FUNCTION_NAME(TEXT("FAX_OpenPort()"));
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (FAX_ACCESS_QUERY_CONFIG != (dwRights & FAX_ACCESS_QUERY_CONFIG) &&
FAX_ACCESS_MANAGE_CONFIG != (dwRights & FAX_ACCESS_MANAGE_CONFIG))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_CONFIG or FAX_ACCESS_MANAGE_CONFIG"));
return ERROR_ACCESS_DENIED;
}
if (!FaxPortHandle)
{
return ERROR_INVALID_PARAMETER;
}
EnterCriticalSection( &g_CsLine );
LineInfo = GetTapiLineFromDeviceId( DeviceId, FALSE );
if (LineInfo)
{
if (Flags & PORT_OPEN_MODIFY)
{
//
// the client wants to open the port for modify
// access so we must make sure that no other
// client already has this port open for modify access
//
if (IsPortOpenedForModify( LineInfo ))
{
Rval = ERROR_INVALID_HANDLE;
goto Exit;
}
}
HandleEntry = CreateNewPortHandle( FaxHandle, LineInfo, Flags );
if (!HandleEntry)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR, _T("CreateNewPortHandle() failed, Error %ld"), Rval);
goto Exit;
}
*FaxPortHandle = (HANDLE) HandleEntry;
}
else
{
Rval = ERROR_BAD_UNIT;
}
Exit:
LeaveCriticalSection( &g_CsLine );
return Rval;
}
//----------------------------------------------------------------------------
// Get Service Printers Info
//----------------------------------------------------------------------------
error_status_t
FAX_GetServicePrinters(
IN handle_t hFaxHandle,
OUT LPBYTE *lpBuffer,
OUT LPDWORD lpdwBufferSize,
OUT LPDWORD lpdwPrintersReturned
)
/*++
Routine Description:
Returns Buffer filled with FAX_PRINTER_INFO for Printers the Service is aware of.
Arguments:
FaxHandle - Fax Handle
Buffer - the buffer containing all the data.
BufferSize - Size of the buffer in bytes.
PrintersReturned - Count of the Printers in the buffer.
Return Value:
ERROR_SUCCESS for success, otherwise a WIN32 error code.
--*/
{
DWORD i = 0;
BOOL bAccess;
DWORD dwSize = 0;
DWORD dwCount = 0;
DWORD_PTR dwOffset = 0;
error_status_t Rval = 0;
PPRINTER_INFO_2 pPrintersInfo = NULL;
PFAX_PRINTER_INFOW pPrinters = NULL;
DEBUG_FUNCTION_NAME(_T("FAX_GetServicePrinters()"));
//
// Access check
//
Rval = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &bAccess, NULL);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
_T("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
goto Exit;
}
if (FALSE == bAccess)
{
DebugPrintEx(DEBUG_ERR,
_T("The user does not have FAX_ACCESS_QUERY_CONFIG"));
Rval = ERROR_ACCESS_DENIED;
goto Exit;
}
//
// Check parameters
//
Assert (lpdwBufferSize && lpdwPrintersReturned); // ref pointers in idl
if (!lpBuffer) // unique pointer in idl
{
DebugPrintEx(DEBUG_ERR,
_T("lpBuffer is NULL."));
Rval = ERROR_INVALID_PARAMETER;
goto Exit;
}
//
// Call MyEnumPrinters() to get Printers known by the Service
//
pPrintersInfo = (PPRINTER_INFO_2) MyEnumPrinters(NULL, 2, &dwCount, 0);
if (!pPrintersInfo)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
_T("MyEnumPrinters failed, ec = %ld"),
Rval);
goto Exit;
}
//
// Count Size of the Buffer to Allocate for Result
//
for ( i = 0 ; i < dwCount ; i++ )
{
dwSize += sizeof(FAX_PRINTER_INFOW) +
StringSize ( pPrintersInfo[i].pPrinterName ) +
StringSize ( pPrintersInfo[i].pDriverName ) +
StringSize ( pPrintersInfo[i].pServerName );
}
//
// Allocate buffer to return
//
pPrinters = (PFAX_PRINTER_INFOW)MemAlloc(dwSize);
if (!pPrinters)
{
Rval = ERROR_NOT_ENOUGH_MEMORY;
DebugPrintEx(DEBUG_ERR,
_T("pPrinters = MemAlloc(dwSize) failed. dwSize = %ld"),
dwSize);
goto Exit;
}
//
// Fill the Buffer with the Data
//
dwOffset = sizeof(FAX_PRINTER_INFOW) * dwCount;
//
// Return Values
//
*lpBuffer = (LPBYTE)pPrinters;
*lpdwBufferSize = dwSize;
*lpdwPrintersReturned = dwCount;
//
// Store Results in the Buffer
//
for ( i = 0 ; i < dwCount ; i++, pPrinters++ )
{
StoreString(pPrintersInfo[i].pPrinterName, // string to be copied
(PULONG_PTR)&pPrinters->lptstrPrinterName, // where to store the Offset
*lpBuffer, // buffer to store the value
&dwOffset, // at which offset in the buffer to put the value
*lpdwBufferSize); // size of the lpBuffer
StoreString(pPrintersInfo[i].pServerName,
(PULONG_PTR)&pPrinters->lptstrServerName,
*lpBuffer,
&dwOffset,
*lpdwBufferSize);
StoreString(pPrintersInfo[i].pDriverName,
(PULONG_PTR)&pPrinters->lptstrDriverName,
*lpBuffer,
&dwOffset,
*lpdwBufferSize);
}
Exit:
if (pPrintersInfo)
{
MemFree(pPrintersInfo);
}
return Rval;
}
error_status_t
FAX_ClosePort(
IN OUT LPHANDLE FaxPortHandle
)
/*++
Routine Description:
Closes an open FAX port.
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
FaxPortHandle - FAX port handle obtained from FaxOpenPort.
Return Value:
TRUE - Success
FALSE - Failure, call GetLastError() for more error information.
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_ClosePort()"));
if (NULL == *FaxPortHandle)
{
return ERROR_INVALID_PARAMETER;
}
CloseFaxHandle( (PHANDLE_ENTRY) *FaxPortHandle );
*FaxPortHandle = NULL;
return ERROR_SUCCESS;
}
error_status_t
FAX_EnumJobs(
IN handle_t FaxHandle,
OUT LPBYTE *Buffer,
OUT LPDWORD BufferSize,
OUT LPDWORD JobsReturned
)
/*++
Routine Description:
Enumerates jobs.
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
Buffer - Buffer to hold the job information
BufferSize - Total size of the job info buffer
Return Value:
ERROR_SUCCESS for success, otherwise a WIN32 error code.
--*/
{
PLIST_ENTRY Next;
PJOB_QUEUE JobQueue;
DWORD rVal = 0;
ULONG_PTR Offset = 0;
DWORD Size = 0;
DWORD Count = 0;
PFAX_JOB_ENTRYW JobEntry;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnumJobs"));
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_QUERY_JOBS, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_JOBS"));
return ERROR_ACCESS_DENIED;
}
Assert (BufferSize && JobsReturned); // ref pointers in idl
if (!Buffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
EnterCriticalSectionJobAndQueue;
Next = g_QueueListHead.Flink;
while ((ULONG_PTR)Next != (ULONG_PTR)&g_QueueListHead)
{
JobQueue = CONTAINING_RECORD( Next, JOB_QUEUE, ListEntry );
Next = JobQueue->ListEntry.Flink;
if ((JT_BROADCAST == JobQueue->JobType) || // Broadcast parent jobs not included
(JS_DELETING == JobQueue->JobStatus) || // zombie jobs not included
(JS_COMPLETED == JobQueue->JobStatus) // completed jobs did not show up in W2K Fax
)
{
continue;
}
else
{
Count += 1;
Size+=GetJobSize(JobQueue);
}
}
*BufferSize = Size;
*Buffer = (LPBYTE) MemAlloc( Size );
if (*Buffer == NULL)
{
LeaveCriticalSectionJobAndQueue;
*BufferSize = 0;
return ERROR_NOT_ENOUGH_MEMORY;
}
Offset = sizeof(FAX_JOB_ENTRYW) * Count;
JobEntry = (PFAX_JOB_ENTRYW) *Buffer;
Next = g_QueueListHead.Flink;
while ((ULONG_PTR)Next != (ULONG_PTR)&g_QueueListHead)
{
JobQueue = CONTAINING_RECORD( Next, JOB_QUEUE, ListEntry );
Next = JobQueue->ListEntry.Flink;
if ((JT_BROADCAST == JobQueue->JobType) || // Broadcast parent jobs not included
(JS_DELETING == JobQueue->JobStatus) || // zombie jobs not included
(JS_COMPLETED == JobQueue->JobStatus) // completed jobs did not show up in W2K Fax
)
{
continue;
}
else
{
if (!GetJobData(*Buffer,JobEntry,JobQueue,&Offset,*BufferSize))
{
rVal = GetLastError();
LeaveCriticalSectionJobAndQueue;
MemFree(*Buffer);
*Buffer = NULL;
*BufferSize = 0;
return rVal;
}
JobEntry += 1;
}
}
LeaveCriticalSectionJobAndQueue;
*JobsReturned = Count;
return 0;
}
static
LPCWSTR
GetJobQueueUserName(const JOB_QUEUE *lpJobQueue)
{
LPCWSTR lpUserName = lpJobQueue->lpParentJob ?
lpJobQueue->lpParentJob->UserName :
lpJobQueue->UserName;
return lpUserName;
}
//*****************************************************************************
//* Name: GetJobSize
//* Author: Ronen Barenboim
//*****************************************************************************
//* DESCRIPTION:
//* Returns the size of the variable length data of a job
//* which is reported back via the legacy FAX_JOB_ENTRY structure
//* (FAX_EnumJobs)
//* PARAMETERS:
//* [IN] PJOB_QUEUE lpJobQueue:
//* A pointer to the JOB_QUEUE structure of a RECIPIENT job.
//* RETURN VALUE:
//* The size in bytes of the variable data for the data reported back
//* via a legacy FAX_JOB_ENTRY structure.
//* Comments:
//* If the operation failes the function takes care of deleting any temp files.
//*****************************************************************************
DWORD
GetJobSize(
PJOB_QUEUE lpJobQueue
)
{
DWORD Size;
Size = sizeof(FAX_JOB_ENTRYW);
Size += StringSize( GetJobQueueUserName(lpJobQueue));
Size += StringSize( lpJobQueue->RecipientProfile.lptstrFaxNumber);
Size += StringSize( lpJobQueue->RecipientProfile.lptstrName);
Size += StringSize( lpJobQueue->SenderProfile.lptstrTSID);
Size += StringSize( lpJobQueue->SenderProfile.lptstrName);
Size += StringSize( lpJobQueue->SenderProfile.lptstrCompany );
Size += StringSize( lpJobQueue->SenderProfile.lptstrDepartment );
Size += StringSize( lpJobQueue->SenderProfile.lptstrBillingCode );
Size += StringSize( lpJobQueue->JobParamsEx.lptstrReceiptDeliveryAddress );
Size += StringSize( lpJobQueue->JobParamsEx.lptstrDocumentName);
if (lpJobQueue->JobEntry)
{
Size += StringSize( lpJobQueue->JobEntry->ExStatusString);
}
return Size;
}
#define JS_TO_W2KJS(js) ((js)>>1)
DWORD
JT_To_W2KJT (
DWORD dwJT
)
/*++
Routine name : JT_To_W2KJT
Routine description:
Converts a JobType (JT_*) to Win2K legacy job type
Author:
Eran Yariv (EranY), Dec, 2000
Arguments:
dwJT [in] - New job type (bit mask - must have only one bit set)
Return Value:
Win2K legacy job type (JT_*)
--*/
{
DEBUG_FUNCTION_NAME(TEXT("JT_To_W2KJT"));
switch (dwJT)
{
case JT_UNKNOWN:
return 0;
case JT_SEND:
return 1;
case JT_RECEIVE:
return 2;
case JT_ROUTING:
return 3;
case JT_FAIL_RECEIVE:
return 4;
default:
ASSERT_FALSE;
return 0;
}
} // JT_To_W2KJT
//*********************************************************************************
//* Name: GetJobData()
//* Author: Ronen Barenboim
//* Date: April 19, 1999
//*********************************************************************************
//* DESCRIPTION:
//* Copies the relevant data from a JOB_QUEUE structure to a JOB_FAX_ENTRY
//* structure while serializing variable data into the provided buffer
//* and storing offsets to it in the relevant fields of JOB_FAX_ENTRY.
//* PARAMETERS:
//* [OUT] LPBYTE JobBuffer
//* The buffer where serialized data is to be placed.
//* [IN] PFAX_JOB_ENTRYW FaxJobEntry
//* A pointer to teh FAX_JOB_ENTRY to be populated.
//* [IN] PJOB_QUEUE JobQueue
//* A pointer to teh JOB_QUEUE structure from which information is to be
//* copied.
//* [IN] PULONG_PTR Offset
//* The offset in JobBuffer where the variable data is to be placed.
//* On return the value of the parameter is increased by the size
//* of the variable data.
//* [IN] dwJobBufferSize
//* Size of the buffer JobBuffer, in bytes.
//* This parameter is used only if JobBuffer is not NULL.
//*
//* RETURN VALUE:
//* TRUE - on success.
//* FALSE - call GetLastError() to obtain the error code
//*
//*********************************************************************************
BOOL
GetJobData(
LPBYTE JobBuffer,
PFAX_JOB_ENTRYW FaxJobEntry,
PJOB_QUEUE JobQueue,
PULONG_PTR Offset,
DWORD dwJobBufferSize
)
{
DEBUG_FUNCTION_NAME(TEXT("GetJobData"));
memset(FaxJobEntry,0,sizeof(FAX_JOB_ENTRYW));
FaxJobEntry->SizeOfStruct = sizeof (FAX_JOB_ENTRYW);
FaxJobEntry->JobId = JobQueue->JobId;
FaxJobEntry->JobType = JT_To_W2KJT(JobQueue->JobType);
DebugPrintEx(
DEBUG_MSG,
TEXT("JobQueue::JobStatus: 0x%08X"),
JobQueue->JobStatus);
if (JobQueue->JobStatus == JS_INPROGRESS &&
JobQueue->JobStatus != JT_ROUTING)
{
//
// In progress Job
//
DebugPrintEx(
DEBUG_MSG,
TEXT("FSPIJobStatus.dwJobStatus: 0x%08X"),
JobQueue->JobEntry->FSPIJobStatus.dwJobStatus);
switch (JobQueue->JobEntry->FSPIJobStatus.dwJobStatus)
{
case FSPI_JS_INPROGRESS:
FaxJobEntry->QueueStatus = JS_TO_W2KJS(JS_INPROGRESS);
break;
case FSPI_JS_RETRY:
FaxJobEntry->QueueStatus = JS_TO_W2KJS(JS_INPROGRESS);
break;
case FSPI_JS_ABORTING:
FaxJobEntry->QueueStatus = JS_TO_W2KJS(JS_INPROGRESS);
break;
case FSPI_JS_SUSPENDING:
case FSPI_JS_SUSPENDED:
case FSPI_JS_RESUMING:
case FSPI_JS_PENDING:
//
// In the legacy model there was no such thing as a job
// pending, suspending, suspened or resuming while being executed by the
// FSP.
// If the job is internally in progress we allways report JS_INPROGRESS.
// For FSPI_JS states that map to job states (pending, paused, etc). we just
// report FPS_HANDLED.
// This means that an application using the legacy API for jobs
// does not see the full picture but sees a consistent picture of the job status.
//
FaxJobEntry->QueueStatus = JS_TO_W2KJS(JS_INPROGRESS);
break;
case FSPI_JS_ABORTED:
case FSPI_JS_COMPLETED:
case FSPI_JS_FAILED:
case FSPI_JS_FAILED_NO_RETRY:
case FSPI_JS_DELETED:
DebugPrintEx(
DEBUG_MSG,
TEXT("Final job state 0x%08X found while JobId: %ld is in JS_INPROGRESS state. This can not happen !!!"),
JobQueue->JobEntry->FSPIJobStatus.dwJobStatus,
JobQueue->JobId);
Assert(JS_INPROGRESS != JobQueue->JobStatus); // ASSERT_FALSE
//
// This should never happen since getting this status update
// should have moved the internal job state to JS_CANCELED or JS_COMPLETED
//
//
// Return JS_INPROGRESS in FREE builds
//
FaxJobEntry->QueueStatus = JS_TO_W2KJS(JS_INPROGRESS);
break;
default:
//
// This should never happen. The service translates the FS to FSPI_JS
//
DebugPrintEx(
DEBUG_WRN,
TEXT("Unsupported in progress FSP job status 0x%08X for JobId: %ld"),
JobQueue->JobEntry->FSPIJobStatus.dwJobStatus,
JobQueue->JobId);
Assert( FSPI_JS_INPROGRESS == JobQueue->JobEntry->FSPIJobStatus.dwJobStatus); // ASSERT_FALSE
}
}
else if (JobQueue->JobStatus == JS_ROUTING)
{
FaxJobEntry->QueueStatus = JS_TO_W2KJS(JS_INPROGRESS);
}
else
{
FaxJobEntry->QueueStatus = JS_TO_W2KJS(JobQueue->JobStatus);
}
//
// copy the schedule time that the user orginally requested
//
if (!FileTimeToSystemTime((LPFILETIME) &JobQueue->ScheduleTime, &FaxJobEntry->ScheduleTime)) {
DebugPrintEx(
DEBUG_ERR,
TEXT("FileTimeToSystemTime failed (ec: %ld)"),
GetLastError());
return FALSE;
}
//
// get the device status, this job might not be scheduled yet, though.
//
EnterCriticalSection(&g_CsJob);
if (JobQueue->JobEntry )
{
//
// Check if the job is a FSP job. If it is we just need to return LineInfo::State
//
FaxJobEntry->Status = JobQueue->JobEntry->LineInfo->State;
}
DebugPrintEx(
DEBUG_MSG,
TEXT("GetJobData() Results [ JobId = 0x%08X, JobType = %ld, QueueStatus: 0x%08X, DeviceStatus: 0x%08X ]"),
FaxJobEntry->JobId,
FaxJobEntry->JobType,
FaxJobEntry->QueueStatus,
FaxJobEntry->Status);
LeaveCriticalSection(&g_CsJob);
StoreString( GetJobQueueUserName(JobQueue),
(PULONG_PTR)&FaxJobEntry->UserName,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( JobQueue->RecipientProfile.lptstrFaxNumber,
(PULONG_PTR)&FaxJobEntry->RecipientNumber,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( JobQueue->RecipientProfile.lptstrName,
(PULONG_PTR)&FaxJobEntry->RecipientName,
JobBuffer,
Offset,
dwJobBufferSize);
FaxJobEntry->PageCount = JobQueue->PageCount;
FaxJobEntry->Size = JobQueue->FileSize;
FaxJobEntry->ScheduleAction = JobQueue->JobParamsEx.dwScheduleAction;
FaxJobEntry->DeliveryReportType = JobQueue->JobParamsEx.dwReceiptDeliveryType;
StoreString( JobQueue->SenderProfile.lptstrTSID,
(PULONG_PTR)&FaxJobEntry->Tsid,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( JobQueue->SenderProfile.lptstrName,
(PULONG_PTR)&FaxJobEntry->SenderName,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( JobQueue->SenderProfile.lptstrCompany,
(PULONG_PTR)&FaxJobEntry->SenderCompany,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( JobQueue->SenderProfile.lptstrDepartment,
(PULONG_PTR)&FaxJobEntry->SenderDept,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( JobQueue->SenderProfile.lptstrBillingCode,
(PULONG_PTR)&FaxJobEntry->BillingCode,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( JobQueue->JobParamsEx.lptstrReceiptDeliveryAddress,
(PULONG_PTR)&FaxJobEntry->DeliveryReportAddress,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( JobQueue->JobParamsEx.lptstrDocumentName,
(PULONG_PTR)&FaxJobEntry->DocumentName,
JobBuffer,
Offset,
dwJobBufferSize);
return TRUE;
}
//*********************************************************************************
//* Name: GetJobDataEx()
//* Author: Oded Sacher
//* Date: November 14, 1999
//*********************************************************************************
//* DESCRIPTION:
//* Copies the relevant data from a JOB_QUEUE structure to a FAX_JOB_ENTRY_EX
//* structure while serializing variable data into the provided buffer
//* and storing offsets to it in the relevant fields of FAX_JOB_ENTRY_EX.
//* If JobBuffer is NULL, Offset is the total size needed for the buffer.
//*
//*
//* PARAMETERS:
//* [OUT] LPBYTE JobBuffer
//* The buffer where serialized data is to be placed.
//* [IN] PFAX_JOB_ENTRY_EXW FaxJobEntry
//* A pointer to teh FAX_JOB_ENTRY_EX to be populated.
//* [IN] PFAX_JOB_STATUSW pFaxJobStatus
//* A pointer to the FAX_JOB_STATUS to be populated.
//* [IN] DWORD dwClientAPIVersion
//* The version of the client API
//* [IN] PJOB_QUEUE lpcJobQueue
//* A pointer to teh JOB_QUEUE structure from which information is to be
//* copied.
//* [IN] PULONG_PTR Offset
//* The offset in JobBuffer where the variable data is to be placed.
//* On return the value of the parameter is increased by the size
//* of the variable data.
//* [IN] DWORD dwJobBufferSize
//* Size of the buffer JobBuffer, in bytes.
//* This parameter is used only if JobBuffer is not NULL.
//*
//* RETURN VALUE:
//* True/False ,Call GetLastError() for extended error info.
//*********************************************************************************
BOOL
GetJobDataEx(
LPBYTE JobBuffer,
PFAX_JOB_ENTRY_EXW pFaxJobEntry,
PFAX_JOB_STATUSW pFaxStatus,
DWORD dwClientAPIVersion,
const PJOB_QUEUE lpcJobQueue,
PULONG_PTR Offset,
DWORD dwJobBufferSize
)
{
DEBUG_FUNCTION_NAME(TEXT("GetJobDataEx"));
Assert (lpcJobQueue->JobType != JT_BROADCAST);
if (JobBuffer != NULL)
{
memset(pFaxJobEntry, 0, (sizeof(FAX_JOB_ENTRY_EXW)));
pFaxJobEntry->dwSizeOfStruct = sizeof (FAX_JOB_ENTRY_EXW);
pFaxJobEntry->dwlMessageId = lpcJobQueue->UniqueId;
pFaxJobEntry->dwValidityMask |= FAX_JOB_FIELD_MESSAGE_ID;
}
else
{
*Offset += sizeof (FAX_JOB_ENTRY_EXW);
}
if (lpcJobQueue->JobType == JT_SEND)
{
Assert (lpcJobQueue->lpParentJob);
StoreString (lpcJobQueue->RecipientProfile.lptstrFaxNumber,
(PULONG_PTR)&pFaxJobEntry->lpctstrRecipientNumber,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString (lpcJobQueue->RecipientProfile.lptstrName,
(PULONG_PTR)&pFaxJobEntry->lpctstrRecipientName,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( GetJobQueueUserName(lpcJobQueue),
(PULONG_PTR)&pFaxJobEntry->lpctstrSenderUserName,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->SenderProfile.lptstrBillingCode,
(PULONG_PTR)&pFaxJobEntry->lpctstrBillingCode,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->lpParentJob->JobParamsEx.lptstrDocumentName,
(PULONG_PTR)&pFaxJobEntry->lpctstrDocumentName,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->lpParentJob->CoverPageEx.lptstrSubject,
(PULONG_PTR)&pFaxJobEntry->lpctstrSubject,
JobBuffer,
Offset,
dwJobBufferSize);
if (JobBuffer != NULL)
{
pFaxJobEntry->dwlBroadcastId = lpcJobQueue->lpParentJob->UniqueId;
pFaxJobEntry->dwValidityMask |= FAX_JOB_FIELD_BROADCAST_ID;
pFaxJobEntry->dwDeliveryReportType = lpcJobQueue->JobParamsEx.dwReceiptDeliveryType;
pFaxJobEntry->dwValidityMask |= FAX_JOB_FIELD_DELIVERY_REPORT_TYPE;
pFaxJobEntry->Priority = lpcJobQueue->JobParamsEx.Priority;
pFaxJobEntry->dwValidityMask |= FAX_JOB_FIELD_PRIORITY;
if (!FileTimeToSystemTime((LPFILETIME) &lpcJobQueue->lpParentJob->OriginalScheduleTime,
&pFaxJobEntry->tmOriginalScheduleTime))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FileTimeToSystemTime failed (ec: %ld)"),
GetLastError());
}
else
{
pFaxJobEntry->dwValidityMask |= FAX_JOB_FIELD_ORIGINAL_SCHEDULE_TIME;
}
if (!FileTimeToSystemTime((LPFILETIME) &lpcJobQueue->lpParentJob->SubmissionTime,
&pFaxJobEntry->tmSubmissionTime))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FileTimeToSystemTime failed (ec: %ld)"),
GetLastError());
}
else
{
pFaxJobEntry->dwValidityMask |= FAX_JOB_FIELD_SUBMISSION_TIME;
}
}
}
if (!GetJobStatusDataEx (JobBuffer, pFaxStatus, dwClientAPIVersion, lpcJobQueue, Offset, dwJobBufferSize))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("GetJobStatusDataEx failed (ec: %ld)"),
GetLastError());
}
else
{
if (JobBuffer != NULL)
{
pFaxJobEntry->dwValidityMask |= FAX_JOB_FIELD_STATUS_SUB_STRUCT;
}
}
return TRUE;
}
//*********************************************************************************
//* Name: GetAvailableJobOperations()
//* Author: Oded Sacher
//* Date: Feb 2000
//*********************************************************************************
//* DESCRIPTION:
//* Returnes a bit wise combination of the available job operations (FAX_ENUM_JOB_OP).
//*
//* PARAMETERS:
//* [IN] PJOB_QUEUE lpcJobQueue
//* A pointer to teh JOB_QUEUE structure from which information is to be
//* copied.
//*
//* RETURN VALUE:
//* Bit wise combination of the available job operations (FAX_ENUM_JOB_OP).
//*********************************************************************************
DWORD
GetAvailableJobOperations (
const PJOB_QUEUE lpcJobQueue
)
{
DWORD dwAvailableJobOperations = 0;
Assert (lpcJobQueue);
DWORD dwJobStatus = lpcJobQueue->JobStatus;
switch (lpcJobQueue->JobType)
{
case JT_SEND:
Assert (lpcJobQueue->lpParentJob);
if (lpcJobQueue->lpParentJob->JobStatus == JS_DELETING)
{
// The whole broadcast is being deleted
break; // out of outer switch
}
// Check modifiers
if (lpcJobQueue->JobStatus & JS_PAUSED)
{
dwAvailableJobOperations |= (FAX_JOB_OP_RESUME |
FAX_JOB_OP_DELETE |
FAX_JOB_OP_VIEW |
FAX_JOB_OP_RECIPIENT_INFO |
FAX_JOB_OP_SENDER_INFO);
break; // out of outer switch
}
dwJobStatus = RemoveJobStatusModifiers(dwJobStatus);
switch (dwJobStatus)
{
case JS_PENDING:
dwAvailableJobOperations = (FAX_JOB_OP_PAUSE | FAX_JOB_OP_DELETE | FAX_JOB_OP_VIEW | FAX_JOB_OP_RECIPIENT_INFO | FAX_JOB_OP_SENDER_INFO);
break;
case JS_INPROGRESS:
dwAvailableJobOperations = (FAX_JOB_OP_DELETE | FAX_JOB_OP_VIEW | FAX_JOB_OP_RECIPIENT_INFO | FAX_JOB_OP_SENDER_INFO);
break;
case JS_RETRYING:
dwAvailableJobOperations = (FAX_JOB_OP_DELETE | FAX_JOB_OP_PAUSE | FAX_JOB_OP_VIEW | FAX_JOB_OP_RECIPIENT_INFO | FAX_JOB_OP_SENDER_INFO);
break;
case JS_RETRIES_EXCEEDED:
dwAvailableJobOperations = (FAX_JOB_OP_DELETE | FAX_JOB_OP_RESTART | FAX_JOB_OP_VIEW | FAX_JOB_OP_RECIPIENT_INFO | FAX_JOB_OP_SENDER_INFO);
break;
case JS_COMPLETED:
case JS_CANCELED:
case JS_CANCELING:
dwAvailableJobOperations = (FAX_JOB_OP_VIEW | FAX_JOB_OP_RECIPIENT_INFO | FAX_JOB_OP_SENDER_INFO);
break;
}
break; // out of outer switch
case JT_RECEIVE:
if (lpcJobQueue->JobStatus == JS_INPROGRESS)
{
dwAvailableJobOperations = FAX_JOB_OP_DELETE;
}
break;
case JT_ROUTING:
if (lpcJobQueue->JobStatus == JS_RETRYING ||
lpcJobQueue->JobStatus == JS_RETRIES_EXCEEDED)
{
dwAvailableJobOperations = (FAX_JOB_OP_VIEW |FAX_JOB_OP_DELETE);
}
else if (lpcJobQueue->JobStatus == JS_INPROGRESS)
{
dwAvailableJobOperations = FAX_JOB_OP_VIEW;
}
break;
case JT_BROADCAST:
// we do not support broadcast operations
break;
}
return dwAvailableJobOperations;
}
//*********************************************************************************
//* Name: GetJobStatusDataEx()
//* Author: Oded Sacher
//* Date: Jan 2, 2000
//*********************************************************************************
//* DESCRIPTION:
//* Copies the relevant data from a JOB_QUEUE structure to a FAX_JOB_STATUS
//* structure while serializing variable data into the provided buffer
//* and storing offsets to it in the relevant fields of FAX_JOB_STATUS.
//* If JobBuffer is NULL, Offset is the total size needed for the buffer.
//*
//*
//* PARAMETERS:
//* [OUT] LPBYTE JobBuffer
//* The buffer where serialized data is to be placed.
//* [IN] PFAX_JOB_STATUSW pFaxJobStatus
//* A pointer to the FAX_JOB_STATUS to be populated.
//* [IN] DWORD dwClientAPIVersion,
//* The version of the client API
//* [IN] PJOB_QUEUE lpcJobQueue
//* A pointer to teh JOB_QUEUE structure from which information is to be
//* copied.
//* [IN] PULONG_PTR Offset
//* The offset in JobBuffer where the variable data is to be placed.
//* On return the value of the parameter is increased by the size
//* of the variable data.
//* [IN] DWORD dwJobBufferSize
//* Size of the buffer JobBuffer, in bytes.
//* This parameter is used only if JobBuffer is not NULL.
//*
//* RETURN VALUE:
//* True/False ,Call GetLastError() for extended error info.
//*********************************************************************************
BOOL
GetJobStatusDataEx(
LPBYTE JobBuffer,
PFAX_JOB_STATUSW pFaxStatus,
DWORD dwClientAPIVersion,
const PJOB_QUEUE lpcJobQueue,
PULONG_PTR Offset,
DWORD dwJobBufferSize
)
{
DEBUG_FUNCTION_NAME(TEXT("GetJobStatusDataEx"));
Assert (lpcJobQueue->JobType != JT_BROADCAST);
if (JobBuffer != NULL)
{
memset(pFaxStatus, 0, (sizeof(FAX_JOB_STATUSW)));
pFaxStatus->dwSizeOfStruct = sizeof(FAX_JOB_STATUSW);
}
else
{
*Offset += sizeof(FAX_JOB_STATUSW);
}
if (lpcJobQueue->JobType == JT_SEND)
{
Assert (lpcJobQueue->lpParentJob);
if (lpcJobQueue->JobEntry)
{
StoreString( lpcJobQueue->JobEntry->FSPIJobStatus.lpwstrRemoteStationId,
(PULONG_PTR)&pFaxStatus->lpctstrCsid,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->JobEntry->lpwstrJobTsid,
(PULONG_PTR)&pFaxStatus->lpctstrTsid,
JobBuffer,
Offset,
dwJobBufferSize);
//
// Notice: In outgoing jobs, we store the displayable translated address in the job's
// caller ID buffer.
// The original address (usually in a TAPI-canonical format) is located in the
// lpctstrRecipientNumber field of the FAX_JOB_ENTRY_EX structure.
//
// This is done to support the display of the number actually being dialed out
// (without compromising user secrets) in the Fax Status Monitor.
//
StoreString( lpcJobQueue->JobEntry->DisplayablePhoneNumber,
(PULONG_PTR)&pFaxStatus->lpctstrCallerID,
JobBuffer,
Offset,
dwJobBufferSize);
}
}
else if (lpcJobQueue->JobType == JT_RECEIVE)
{
if (lpcJobQueue->JobEntry)
{
StoreString( lpcJobQueue->JobEntry->FSPIJobStatus.lpwstrRemoteStationId,
(PULONG_PTR)&pFaxStatus->lpctstrTsid,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->JobEntry->FSPIJobStatus.lpwstrCallerId,
(PULONG_PTR)&pFaxStatus->lpctstrCallerID,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->JobEntry->FSPIJobStatus.lpwstrRoutingInfo,
(PULONG_PTR)&pFaxStatus->lpctstrRoutingInfo,
JobBuffer,
Offset,
dwJobBufferSize);
if (lpcJobQueue->JobEntry->LineInfo)
{
StoreString( lpcJobQueue->JobEntry->LineInfo->Csid,
(PULONG_PTR)&pFaxStatus->lpctstrCsid,
JobBuffer,
Offset,
dwJobBufferSize);
}
}
}
else if (lpcJobQueue->JobType == JT_ROUTING)
{
Assert (lpcJobQueue->FaxRoute);
StoreString( lpcJobQueue->FaxRoute->Tsid,
(PULONG_PTR)&pFaxStatus->lpctstrTsid,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->FaxRoute->CallerId,
(PULONG_PTR)&pFaxStatus->lpctstrCallerID,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->FaxRoute->RoutingInfo,
(PULONG_PTR)&pFaxStatus->lpctstrRoutingInfo,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->FaxRoute->Csid,
(PULONG_PTR)&pFaxStatus->lpctstrCsid,
JobBuffer,
Offset,
dwJobBufferSize);
StoreString( lpcJobQueue->FaxRoute->DeviceName,
(PULONG_PTR)&pFaxStatus->lpctstrDeviceName,
JobBuffer,
Offset,
dwJobBufferSize);
if (JobBuffer != NULL)
{
pFaxStatus->dwDeviceID = lpcJobQueue->FaxRoute->DeviceId;
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_DEVICE_ID;
if (!FileTimeToSystemTime((LPFILETIME) &lpcJobQueue->StartTime, &pFaxStatus->tmTransmissionStartTime))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FileTimeToSystemTime failed (ec: %ld)"),
GetLastError());
}
else
{
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_TRANSMISSION_START_TIME;
}
if (!FileTimeToSystemTime((LPFILETIME) &lpcJobQueue->EndTime, &pFaxStatus->tmTransmissionEndTime))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FileTimeToSystemTime failed (ec: %ld)"),
GetLastError());
}
else
{
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_TRANSMISSION_END_TIME;
}
}
}
if (JobBuffer != NULL)
{
if (lpcJobQueue->JobType != JT_ROUTING &&
lpcJobQueue->JobStatus == JS_INPROGRESS)
{
DebugPrintEx(
DEBUG_MSG,
TEXT("FSPIJobStatus.dwJobStatus: 0x%08X"),
lpcJobQueue->JobEntry->FSPIJobStatus.dwJobStatus);
switch (lpcJobQueue->JobEntry->FSPIJobStatus.dwJobStatus)
{
case FSPI_JS_INPROGRESS:
pFaxStatus->dwQueueStatus = JS_INPROGRESS;
break;
case FSPI_JS_RETRY:
pFaxStatus->dwQueueStatus = JS_RETRYING;
break;
case FSPI_JS_ABORTING:
pFaxStatus->dwQueueStatus = JS_CANCELING;
break;
case FSPI_JS_SUSPENDING:
pFaxStatus->dwQueueStatus = JS_INPROGRESS; // No support for suspending state in client API
break;
case FSPI_JS_RESUMING:
pFaxStatus->dwQueueStatus = JS_PAUSED; // No support for resuming state in client API
default:
DebugPrintEx(
DEBUG_WRN,
TEXT("Unsupported in progress FSP job status 0x%08X"),
lpcJobQueue->JobEntry->FSPIJobStatus.dwJobStatus);
pFaxStatus->dwQueueStatus = JS_INPROGRESS;
}
}
else
{
pFaxStatus->dwQueueStatus = lpcJobQueue->JobStatus;
}
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_QUEUE_STATUS;
}
if (JT_ROUTING != lpcJobQueue->JobType) // Routing jobs with JobEntry are in temporary state.
{
if (lpcJobQueue->JobEntry)
{
//
// Job is in progress
//
if (lstrlen(lpcJobQueue->JobEntry->ExStatusString))
{
//
// We have an extended status string
//
StoreString( lpcJobQueue->JobEntry->ExStatusString,
(PULONG_PTR)&pFaxStatus->lpctstrExtendedStatus,
JobBuffer,
Offset,
dwJobBufferSize);
if (JobBuffer != NULL)
{
pFaxStatus->dwExtendedStatus = lpcJobQueue->JobEntry->FSPIJobStatus.dwExtendedStatus; // report the extended status as is.
if (0 != pFaxStatus->dwExtendedStatus)
{
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_STATUS_EX;
}
}
}
else
{
//
// One of the well known extended status codes
//
if (JobBuffer != NULL)
{
pFaxStatus->dwExtendedStatus = MapFSPIJobExtendedStatusToJS_EX(
lpcJobQueue->JobEntry->FSPIJobStatus.dwExtendedStatus);
if (0 != pFaxStatus->dwExtendedStatus)
{
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_STATUS_EX;
}
}
}
if (JobBuffer != NULL)
{
pFaxStatus->dwCurrentPage = lpcJobQueue->JobEntry->FSPIJobStatus.dwPageCount;
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_CURRENT_PAGE;
if (!GetRealFaxTimeAsSystemTime (lpcJobQueue->JobEntry, FAX_TIME_TYPE_START, &pFaxStatus->tmTransmissionStartTime))
{
DebugPrintEx( DEBUG_ERR,
TEXT("GetRealFaxTimeAsSystemTime (End time) Failed (ec: %ld)"),
GetLastError());
}
else
{
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_TRANSMISSION_START_TIME;
}
}
if (lpcJobQueue->JobEntry->LineInfo)
{
if (JobBuffer != NULL)
{
pFaxStatus->dwDeviceID = lpcJobQueue->JobEntry->LineInfo->PermanentLineID;
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_DEVICE_ID;
}
StoreString( lpcJobQueue->JobEntry->LineInfo->DeviceName,
(PULONG_PTR)&pFaxStatus->lpctstrDeviceName,
JobBuffer,
Offset,
dwJobBufferSize);
}
}
else
{
//
// Job is NOT in progress - retrieve last extended status
//
if (lstrlen(lpcJobQueue->ExStatusString))
{
//
// We have an extended status string
//
StoreString( lpcJobQueue->ExStatusString,
(PULONG_PTR)&pFaxStatus->lpctstrExtendedStatus,
JobBuffer,
Offset,
dwJobBufferSize);
if (JobBuffer != NULL)
{
pFaxStatus->dwExtendedStatus = lpcJobQueue->dwLastJobExtendedStatus; // report the extended status as is.
if (0 != pFaxStatus->dwExtendedStatus)
{
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_STATUS_EX;
}
}
}
else
{
//
// One of the well known extended status codes
//
if (JobBuffer != NULL)
{
pFaxStatus->dwExtendedStatus = MapFSPIJobExtendedStatusToJS_EX(
lpcJobQueue->dwLastJobExtendedStatus);
if (0 != pFaxStatus->dwExtendedStatus)
{
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_STATUS_EX;
}
}
}
}
}
//
// Common to Send ,receive, routing and partially received
//
if (JobBuffer != NULL)
{
pFaxStatus->dwJobID = lpcJobQueue->JobId;
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_JOB_ID;
pFaxStatus->dwJobType = lpcJobQueue->JobType;
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_TYPE;
pFaxStatus->dwAvailableJobOperations = GetAvailableJobOperations (lpcJobQueue);
if (lpcJobQueue->JobType == JT_ROUTING || lpcJobQueue->JobType == JT_SEND)
{
pFaxStatus->dwSize = lpcJobQueue->FileSize;
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_SIZE;
pFaxStatus->dwPageCount = lpcJobQueue->PageCount;
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_PAGE_COUNT;
pFaxStatus->dwRetries = lpcJobQueue->SendRetries;
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_RETRIES;
if (!FileTimeToSystemTime((LPFILETIME) &lpcJobQueue->ScheduleTime, &pFaxStatus->tmScheduleTime))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FileTimeToSystemTime failed (ec: %ld)"),
GetLastError());
}
else
{
pFaxStatus->dwValidityMask |= FAX_JOB_FIELD_SCHEDULE_TIME;
}
}
}
if (FAX_API_VERSION_1 > dwClientAPIVersion)
{
//
// Clients that use API version 0 can't handle JS_EX_CALL_COMPLETED and JS_EX_CALL_ABORTED
//
if (JobBuffer && pFaxStatus)
{
if (FAX_API_VER_0_MAX_JS_EX < pFaxStatus->dwExtendedStatus)
{
//
// Turn off the extended status field
//
pFaxStatus->dwExtendedStatus = 0;
pFaxStatus->dwValidityMask &= ~FAX_JOB_FIELD_STATUS_EX;
}
}
}
return TRUE;
}
error_status_t
FAX_GetJob(
IN handle_t FaxHandle,
IN DWORD JobId,
OUT LPBYTE *Buffer,
OUT LPDWORD BufferSize
)
{
PJOB_QUEUE JobQueue;
ULONG_PTR Offset = sizeof(FAX_JOB_ENTRYW);
DWORD Rval = 0;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetJob()"));
//
// Access check
//
Rval = FaxSvcAccessCheck (FAX_ACCESS_QUERY_JOBS, &fAccess, NULL);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_JOBS"));
return ERROR_ACCESS_DENIED;
}
Assert (BufferSize); // ref pointer in idl
if (!Buffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
EnterCriticalSection( &g_CsJob );
EnterCriticalSection( &g_CsQueue );
JobQueue = FindJobQueueEntry( JobId );
if (!JobQueue )
{
Rval = ERROR_INVALID_PARAMETER;
goto exit;
}
if ((JT_BROADCAST == JobQueue->JobType) || // Broadcast parent jobs not included
(JS_DELETING == JobQueue->JobStatus) || // zombie jobs not included
(JS_COMPLETED == JobQueue->JobStatus)) // completed jobs did not show up in W2K Fax
{
Rval = ERROR_INVALID_PARAMETER;
goto exit;
}
*BufferSize = GetJobSize(JobQueue);
*Buffer = (LPBYTE)MemAlloc( *BufferSize );
if (!*Buffer)
{
*BufferSize = 0;
Rval = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
if (!GetJobData(*Buffer,(PFAX_JOB_ENTRYW) *Buffer,JobQueue,&Offset,*BufferSize))
{
Rval = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("GetJobData Failed, Error : %ld"),
Rval);
MemFree(*Buffer);
*Buffer = NULL;
*BufferSize = 0;
}
exit:
LeaveCriticalSection( &g_CsQueue );
LeaveCriticalSection( &g_CsJob );
return Rval;
}
error_status_t
FAX_SetJob(
IN handle_t FaxHandle,
IN DWORD JobId,
IN DWORD Command
)
{
PJOB_QUEUE JobQueue;
DWORD Rval = 0;
BOOL fAccess;
DWORD dwRights;
PSID lpUserSid = NULL;
DWORD dwJobStatus;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetJob"));
//
// handle abort case up here because we aquire must aquire additional critical sections to avoid deadlock
//
if (Command == JC_DELETE)
{
Rval = FAX_Abort(FaxHandle,JobId);
}
else
{
//
// Get Access rights
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
EnterCriticalSection( &g_CsQueue );
JobQueue = FindJobQueueEntry( JobId );
if (!JobQueue)
{
Rval = ERROR_INVALID_PARAMETER;
goto exit;
}
dwJobStatus = (JT_SEND == JobQueue->JobType) ? JobQueue->lpParentJob->JobStatus : JobQueue->JobStatus;
if (JS_DELETING == dwJobStatus)
{
//
// Job is being deleted. Do nothing.
//
DebugPrintEx(DEBUG_WRN,
TEXT("[JobId: %ld] is being deleted canceled."),
JobQueue->JobId);
Rval = ERROR_INVALID_PARAMETER;
goto exit;
}
//
// Access check
//
if (FAX_ACCESS_MANAGE_JOBS != (dwRights & FAX_ACCESS_MANAGE_JOBS))
{
//
// Check if the user has submit right
//
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH))
{
Rval = ERROR_ACCESS_DENIED;
DebugPrintEx(DEBUG_WRN,
TEXT("UserOwnsJob failed - The user does have submit or mange jobs access rights"));
goto exit;
}
//
// Check if the user owns the job
//
//
//Get the user SID
//
lpUserSid = GetClientUserSID();
if (lpUserSid == NULL)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid Failed, Error : %ld"),
Rval);
goto exit;
}
if (!UserOwnsJob (JobQueue, lpUserSid))
{
Rval = ERROR_ACCESS_DENIED;
DebugPrintEx(DEBUG_WRN,
TEXT("UserOwnsJob failed - The user does not own the job"));
goto exit;
}
}
switch (Command)
{
case JC_UNKNOWN:
Rval = ERROR_INVALID_PARAMETER;
break;
/*
* This case is handled above...
* case JC_DELETE:
* Rval = FAX_Abort(FaxHandle,JobId);
* break;
*/
case JC_PAUSE:
if (!PauseJobQueueEntry( JobQueue ))
{
Rval = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("PauseJobQueueEntry failed (ec: %ld)"),
Rval);
}
break;
case JC_RESUME:
if (!ResumeJobQueueEntry( JobQueue ))
{
Rval = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("ResumeJobQueueEntry failed (ec: %ld)"),
Rval);
}
break;
default:
Rval = ERROR_INVALID_PARAMETER;
break;
}
exit:
LeaveCriticalSection( &g_CsQueue );
MemFree (lpUserSid);
}
return Rval;
}
error_status_t
FAX_GetPageData(
IN handle_t FaxHandle,
IN DWORD JobId,
OUT LPBYTE *ppBuffer,
OUT LPDWORD lpdwBufferSize,
OUT LPDWORD lpdwImageWidth,
OUT LPDWORD lpdwImageHeight
)
{
PJOB_QUEUE pJobQueue;
LPBYTE pTiffBuffer;
DWORD dwRights;
BOOL fAccess;
DWORD Rval = ERROR_SUCCESS;
BOOL bAllMessages = FALSE;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetPageData()"));
//
// Parameter check
//
Assert (lpdwBufferSize); // ref pointer in idl
if (!ppBuffer || !lpdwImageWidth || !lpdwImageHeight) // unique pointers in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return GetServerErrorCode(Rval);
}
if (FAX_ACCESS_QUERY_OUT_ARCHIVE == (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
//
// user has a FAX_ACCESS_QUERY_JOBS and can preview/query any job
//
bAllMessages = TRUE;
}
else
{
//
// user don't have a FAX_ACCESS_QUERY_JOBS allow him to preview/query only her job
//
bAllMessages = FALSE;
}
EnterCriticalSection( &g_CsQueue );
pJobQueue = FindJobQueueEntry( JobId );
if (!pJobQueue)
{
LeaveCriticalSection( &g_CsQueue );
return ERROR_INVALID_PARAMETER;
}
if (pJobQueue->JobType != JT_SEND)
{
LeaveCriticalSection( &g_CsQueue );
return ERROR_INVALID_DATA;
}
//
// We create a preview file that will contain the first page body or cover
// this function also increase the Job reference count so a call to DecreaseJobRefCount later is neccessary
//
PJOB_QUEUE pRetJobQueue = NULL;
Rval = CreatePreviewFile (pJobQueue->UniqueId, bAllMessages, &pRetJobQueue);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreatePreviewFile returned %ld"),
Rval);
LeaveCriticalSection( &g_CsQueue );
return GetServerErrorCode(Rval);
}
Assert(pRetJobQueue == pJobQueue);
//
// Work with the preview file to extract parameters
//
if (!TiffExtractFirstPage(
pJobQueue->PreviewFileName,
&pTiffBuffer,
lpdwBufferSize,
lpdwImageWidth,
lpdwImageHeight
))
{
DebugPrintEx(DEBUG_ERR,
TEXT("TiffExtractFirstPage Failed, Error : %ld"),
GetLastError());
DecreaseJobRefCount (pJobQueue, TRUE, FALSE, TRUE); // forth parameter - TRUE for Preview ref count.
LeaveCriticalSection( &g_CsQueue );
return ERROR_INVALID_DATA;
}
//
// Decrease Job's ref count, the Preview file will not be deleted so
// calling this function again with the same JobId will use the file in the Preview cache
//
DecreaseJobRefCount (pJobQueue, TRUE, FALSE, TRUE); // forth parameter - TRUE for Preview ref count.
LeaveCriticalSection( &g_CsQueue );
*ppBuffer = (LPBYTE) MemAlloc( *lpdwBufferSize );
if (*ppBuffer == NULL)
{
VirtualFree( pTiffBuffer, *lpdwBufferSize, MEM_RELEASE);
return ERROR_NOT_ENOUGH_MEMORY;
}
CopyMemory( *ppBuffer, pTiffBuffer, *lpdwBufferSize );
VirtualFree( pTiffBuffer, *lpdwBufferSize, MEM_RELEASE);
return ERROR_SUCCESS;
} // FAX_GetPageData
error_status_t
FAX_GetDeviceStatus(
IN HANDLE FaxPortHandle,
OUT LPBYTE *StatusBuffer,
OUT LPDWORD BufferSize
)
/*++
Routine Description:
Obtains a status report for the specified FAX job.
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
StatusBuffer - receives FAX_DEVICE_STATUS pointer
BufferSize - Pointer to the size of this structure
Return Value:
TRUE - Success
FALSE - Failure, call GetLastError() for more error information.
--*/
{
DWORD rVal = 0;
ULONG_PTR Offset;
PFAX_DEVICE_STATUS FaxStatus;
PLINE_INFO LineInfo;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetDeviceStatus()"));
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_CONFIG"));
return ERROR_ACCESS_DENIED;
}
Assert (BufferSize); // ref pointer in idl
if (!StatusBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
if (NULL == FaxPortHandle)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("NULL context handle"));
return ERROR_INVALID_PARAMETER;
}
LineInfo = ((PHANDLE_ENTRY)FaxPortHandle)->LineInfo;
if (!LineInfo)
{
return ERROR_INVALID_DATA;
}
EnterCriticalSection( &g_CsJob );
EnterCriticalSection( &g_CsLine );
//
// count the number of bytes required
//
*BufferSize = sizeof(FAX_DEVICE_STATUS);
*BufferSize += StringSize( LineInfo->DeviceName );
*BufferSize += StringSize( LineInfo->Csid );
if (LineInfo->JobEntry)
{
*BufferSize += StringSize( LineInfo->JobEntry->DisplayablePhoneNumber );
*BufferSize += StringSize( LineInfo->JobEntry->FSPIJobStatus.lpwstrCallerId );
*BufferSize += StringSize( LineInfo->JobEntry->FSPIJobStatus.lpwstrRoutingInfo );
*BufferSize += StringSize( LineInfo->JobEntry->FSPIJobStatus.lpwstrRemoteStationId );
*BufferSize += StringSize( LineInfo->JobEntry->lpJobQueueEntry->SenderProfile.lptstrName);
*BufferSize += StringSize( LineInfo->JobEntry->lpJobQueueEntry->RecipientProfile.lptstrName);
*BufferSize += StringSize( LineInfo->JobEntry->lpJobQueueEntry->UserName );
}
*StatusBuffer = (LPBYTE) MemAlloc( *BufferSize );
if (*StatusBuffer == NULL)
{
*BufferSize = 0;
rVal = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
FaxStatus = (PFAX_DEVICE_STATUS) *StatusBuffer;
Offset = sizeof(FAX_DEVICE_STATUS);
memset(FaxStatus,0,sizeof(FAX_DEVICE_STATUS));
FaxStatus->SizeOfStruct = sizeof(FAX_DEVICE_STATUS);
FaxStatus->Status = LineInfoToLegacyDeviceStatus(LineInfo);
FaxStatus->DeviceId = LineInfo->PermanentLineID;
FaxStatus->StatusString = NULL;
StoreString(
LineInfo->DeviceName,
(PULONG_PTR)&FaxStatus->DeviceName,
*StatusBuffer,
&Offset,
*BufferSize
);
StoreString(
LineInfo->Csid,
(PULONG_PTR)&FaxStatus->Csid,
*StatusBuffer,
&Offset,
*BufferSize
);
if (LineInfo->JobEntry)
{
FaxStatus->JobType = JT_To_W2KJT(LineInfo->JobEntry->lpJobQueueEntry->JobType);
FaxStatus->TotalPages = LineInfo->JobEntry->lpJobQueueEntry->PageCount;
FaxStatus->Size = FaxStatus->JobType == JT_SEND ?
LineInfo->JobEntry->lpJobQueueEntry->FileSize :
0; //meaningful for an outbound job only
FaxStatus->DocumentName = NULL;
ZeroMemory( &FaxStatus->SubmittedTime, sizeof(FILETIME) );
StoreString(
LineInfo->JobEntry->lpJobQueueEntry->SenderProfile.lptstrName,
(PULONG_PTR)&FaxStatus->SenderName,
*StatusBuffer,
&Offset,
*BufferSize
);
StoreString(
LineInfo->JobEntry->lpJobQueueEntry->RecipientProfile.lptstrName,
(PULONG_PTR)&FaxStatus->RecipientName,
*StatusBuffer,
&Offset,
*BufferSize
);
FaxStatus->CurrentPage = LineInfo->JobEntry->FSPIJobStatus.dwPageCount;
CopyMemory(&FaxStatus->StartTime, &LineInfo->JobEntry->StartTime, sizeof(FILETIME));
StoreString(
LineInfo->JobEntry->DisplayablePhoneNumber,
(PULONG_PTR)&FaxStatus->PhoneNumber,
*StatusBuffer,
&Offset,
*BufferSize
);
StoreString(
LineInfo->JobEntry->FSPIJobStatus.lpwstrCallerId,
(PULONG_PTR)&FaxStatus->CallerId,
*StatusBuffer,
&Offset,
*BufferSize
);
StoreString(
LineInfo->JobEntry->FSPIJobStatus.lpwstrRoutingInfo,
(PULONG_PTR)&FaxStatus->RoutingString,
*StatusBuffer,
&Offset,
*BufferSize
);
StoreString(
LineInfo->JobEntry->FSPIJobStatus.lpwstrRemoteStationId,
(PULONG_PTR)&FaxStatus->Tsid,
*StatusBuffer,
&Offset,
*BufferSize
);
StoreString(
LineInfo->JobEntry->lpJobQueueEntry->UserName,
(PULONG_PTR)&FaxStatus->UserName,
*StatusBuffer,
&Offset,
*BufferSize
);
}
else
{
FaxStatus->PhoneNumber = NULL;
FaxStatus->CallerId = NULL;
FaxStatus->RoutingString = NULL;
FaxStatus->CurrentPage = 0;
FaxStatus->JobType = 0;
FaxStatus->TotalPages = 0;
FaxStatus->Size = 0;
FaxStatus->DocumentName = NULL;
FaxStatus->SenderName = NULL;
FaxStatus->RecipientName = NULL;
FaxStatus->Tsid = NULL;
ZeroMemory( &FaxStatus->SubmittedTime, sizeof(FILETIME) );
ZeroMemory( &FaxStatus->StartTime, sizeof(FILETIME) );
}
exit:
LeaveCriticalSection( &g_CsLine );
LeaveCriticalSection( &g_CsJob );
return rVal;
}
error_status_t
FAX_Abort(
IN handle_t hBinding,
IN DWORD JobId
)
/*++
Routine Description:
Abort the specified FAX job. All outstanding FAX
operations are terminated.
Arguments:
hBinding - FAX handle obtained from FaxConnectFaxServer.
JobId - FAX job Id
Return Value:
TRUE - Success
FALSE - Failure, call GetLastError() for more error information.
--*/
{
PJOB_QUEUE JobQueueEntry;
BOOL fAccess;
DWORD dwRights;
DWORD Rval, dwRes;
PSID lpUserSid = NULL;
DEBUG_FUNCTION_NAME(TEXT("FAX_Abort"));
//
// Get Access rights
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
EnterCriticalSectionJobAndQueue;
JobQueueEntry = FindJobQueueEntry( JobId );
if (!JobQueueEntry)
{
Rval = ERROR_INVALID_PARAMETER;
goto exit;
}
Assert (JS_DELETING != JobQueueEntry->JobStatus);
if (!JobQueueEntry)
{
Rval = ERROR_INVALID_PARAMETER;
goto exit;
}
if ( (JobQueueEntry->JobType == JT_RECEIVE &&
JobQueueEntry->JobStatus == JS_ROUTING) ||
(JobQueueEntry->JobType == JT_ROUTING &&
JobQueueEntry->JobStatus == JS_INPROGRESS))
{
DebugPrintEx( DEBUG_ERR,
TEXT("[JobId: %ld] Can not be deleted at this status [JobStatus: 0x%08X]"),
JobQueueEntry->JobId,
JobQueueEntry->JobStatus);
Rval = ERROR_INVALID_OPERATION;
goto exit;
}
if (JobQueueEntry->JobType == JT_BROADCAST)
{
// need to add support for aborting a parent job
DebugPrintEx(DEBUG_WRN,TEXT("No support for aborting parent job."));
Rval = ERROR_INVALID_PARAMETER;
goto exit;
}
if (JS_CANCELING == JobQueueEntry->JobStatus)
{
//
// Job is in the process of being canceled. Do nothing.
//
DebugPrintEx(DEBUG_WRN,
TEXT("[JobId: %ld] is already being canceled."),
JobQueueEntry->JobId);
Rval = ERROR_INVALID_PARAMETER;
goto exit;
}
if (JS_CANCELED == JobQueueEntry->JobStatus)
{
//
// Job is already canceled. Do nothing.
//
DebugPrintEx(DEBUG_WRN,
TEXT("[JobId: %ld] is already canceled."),
JobQueueEntry->JobId);
Rval = ERROR_INVALID_PARAMETER;
goto exit;
}
//
// Access check
//
if (FAX_ACCESS_MANAGE_JOBS != (dwRights & FAX_ACCESS_MANAGE_JOBS))
{
//
// Check if the user has submit right
//
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH))
{
Rval = ERROR_ACCESS_DENIED;
DebugPrintEx(DEBUG_WRN,
TEXT("UserOwnsJob failed - The user does have submit or mange jobs access rights"));
goto exit;
}
//
// Check if the user owns the job
//
//
//Get the user SID
//
lpUserSid = GetClientUserSID();
if (lpUserSid == NULL)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid Failed, Error : %ld"),
Rval);
goto exit;
}
if (!UserOwnsJob (JobQueueEntry, lpUserSid))
{
Rval = ERROR_ACCESS_DENIED;
DebugPrintEx(DEBUG_WRN,
TEXT("UserOwnsJob failed - The user does not own the job"));
goto exit;
}
}
#if DBG
if (JobQueueEntry->lpParentJob)
{
DebugPrintEx(
DEBUG_MSG,
TEXT("Parent Job: %ld [Total Rec = %ld] [Canceled Rec = %ld] [Completed Rec = %ld] [Failed Rec = %ld]"),
JobQueueEntry->lpParentJob->JobId,
JobQueueEntry->lpParentJob->dwRecipientJobsCount,
JobQueueEntry->lpParentJob->dwCanceledRecipientJobsCount,
JobQueueEntry->lpParentJob->dwCompletedRecipientJobsCount,
JobQueueEntry->lpParentJob->dwFailedRecipientJobsCount);
}
#endif
//
// abort the job if it's in progress
//
if (JobQueueEntry->JobStatus & JS_INPROGRESS)
{
if ( ( JobQueueEntry->JobType == JT_SEND ) ||
( JobQueueEntry->JobType == JT_RECEIVE ) )
{
__try
{
BOOL bRes;
bRes=JobQueueEntry->JobEntry->LineInfo->Provider->FaxDevAbortOperation(
(HANDLE) JobQueueEntry->JobEntry->InstanceData );
if (!bRes)
{
Rval = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("[JobId: %ld] FaxDevAbortOperation failed (ec: %ld)"),
JobQueueEntry->JobId,
Rval);
goto exit;
}
}
__except (HandleFaxExtensionFault(EXCEPTION_SOURCE_FSP, JobQueueEntry->JobEntry->LineInfo->Provider->FriendlyName, GetExceptionCode()))
{
ASSERT_FALSE
}
JobQueueEntry->JobEntry->Aborting = TRUE;
JobQueueEntry->JobStatus = JS_CANCELING;
if (!CreateFaxEvent(JobQueueEntry->JobEntry->LineInfo->PermanentLineID,
FEI_ABORTING,
JobId))
{
if (TRUE == g_bServiceIsDown)
{
DebugPrintEx(
DEBUG_WRN,
TEXT("[JobId: %ld] CreateFaxEvent(FEI_ABORTING) failed. Service is going down"),
JobQueueEntry->JobId
);
}
else
{
DebugPrintEx(
DEBUG_ERR,
TEXT("[JobId: %ld] CreateFaxEvent(FEI_ABORTING) failed. (ec: %ld)"),
JobQueueEntry->JobId,
GetLastError());
Assert(FALSE);
}
}
//
// CreteFaxEventEx
//
dwRes = CreateQueueEvent ( FAX_JOB_EVENT_TYPE_STATUS,
JobQueueEntry
);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateQueueEvent(FAX_JOB_EVENT_TYPE_STATUS) failed for job id %ld (ec: %lc)"),
JobQueueEntry->UniqueId,
dwRes);
}
DebugPrintEx( DEBUG_MSG,
TEXT("[Job: %ld] Attempting FaxDevAbort for job in progress"),
JobQueueEntry->JobId);
}
}
else
{
//
// The job is NOT in progress.
//
if (JobQueueEntry->JobType == JT_SEND &&
!(JobQueueEntry->JobStatus & JS_COMPLETED) &&
!(JobQueueEntry->JobStatus & JS_CANCELED))
{
// We just need to mark it as CANCELED
// and as usual check if the parent is ready for archiving.
//
DebugPrintEx( DEBUG_MSG,
TEXT("[Job: %ld] Aborting RECIPIENT job which is not in progress."),
JobQueueEntry->JobId);
if (JobQueueEntry->JobStatus & JS_RETRIES_EXCEEDED)
{
JobQueueEntry->lpParentJob->dwFailedRecipientJobsCount -= 1;
}
JobQueueEntry->lpParentJob->dwCanceledRecipientJobsCount+=1;
JobQueueEntry->JobStatus = JS_CANCELED;
//
// CreteFaxEventEx
//
dwRes = CreateQueueEvent ( FAX_JOB_EVENT_TYPE_STATUS,
JobQueueEntry
);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateQueueEvent(FAX_JOB_EVENT_TYPE_STATUS) failed for job id %ld (ec: %lc)"),
JobQueueEntry->UniqueId,
dwRes);
}
if (!CreateFaxEvent(0, FEI_DELETED, JobQueueEntry->JobId))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateFaxEvent failed. (ec: %ld)"),
GetLastError());
}
if (!UpdatePersistentJobStatus(JobQueueEntry))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to update persistent job status to 0x%08x"),
JobQueueEntry->JobStatus);
Assert(FALSE);
}
EnterCriticalSection (&g_CsOutboundActivityLogging);
if (INVALID_HANDLE_VALUE == g_hOutboxActivityLogFile)
{
DebugPrintEx(DEBUG_ERR,
TEXT("Logging not initialized"));
}
else
{
if (!LogOutboundActivity(JobQueueEntry))
{
DebugPrintEx(DEBUG_ERR, TEXT("Logging outbound activity failed"));
}
}
LeaveCriticalSection (&g_CsOutboundActivityLogging);
DecreaseJobRefCount(JobQueueEntry, TRUE); // This will mark it as JS_DELETING if needed
}
else if (JobQueueEntry->JobType == JT_ROUTING)
{
//
// Remove the routing job
//
DebugPrintEx( DEBUG_MSG,
TEXT("[Job: %ld] Aborting ROUTING job (never in progress)."),
JobQueueEntry->JobId);
JobQueueEntry->JobStatus = JS_DELETING;
DecreaseJobRefCount (JobQueueEntry, TRUE);
}
}
Rval = 0;
exit:
LeaveCriticalSectionJobAndQueue;
MemFree (lpUserSid);
return Rval;
}
error_status_t
FAX_GetConfiguration(
IN handle_t FaxHandle,
OUT LPBYTE *Buffer,
IN LPDWORD BufferSize
)
/*++
Routine Description:
Retrieves the FAX configuration from the FAX server.
The SizeOfStruct in the FaxConfig argument MUST be
set to a value == sizeof(FAX_CONFIGURATION). If the BufferSize
is not big enough, return an error and set BytesNeeded to the
required size.
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
Buffer - Pointer to a FAX_CONFIGURATION structure.
BufferSize - Size of Buffer
BytesNeeded - Number of bytes needed
Return Value:
TRUE - Success
FALSE - Failure, call GetLastError() for more error information.
--*/
{
error_status_t rVal = ERROR_SUCCESS;
PFAX_CONFIGURATION FaxConfig;
ULONG_PTR Offset;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetConfiguration()"));
BOOL fAccess;
Assert (BufferSize); // ref pointer in idl
if (!Buffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_CONFIG"));
return ERROR_ACCESS_DENIED;
}
//
// count up the number of bytes needed
//
*BufferSize = sizeof(FAX_CONFIGURATION);
Offset = sizeof(FAX_CONFIGURATION);
EnterCriticalSection (&g_CsConfig);
if (g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].lpcstrFolder)
{
*BufferSize += StringSize( g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].lpcstrFolder );
}
*Buffer = (LPBYTE)MemAlloc( *BufferSize );
if (*Buffer == NULL)
{
rVal = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
FaxConfig = (PFAX_CONFIGURATION)*Buffer;
FaxConfig->SizeOfStruct = sizeof(FAX_CONFIGURATION);
FaxConfig->Retries = g_dwFaxSendRetries;
FaxConfig->RetryDelay = g_dwFaxSendRetryDelay;
FaxConfig->DirtyDays = g_dwFaxDirtyDays;
FaxConfig->Branding = g_fFaxUseBranding;
FaxConfig->UseDeviceTsid = g_fFaxUseDeviceTsid;
FaxConfig->ServerCp = g_fServerCp;
FaxConfig->StartCheapTime.Hour = g_StartCheapTime.Hour;
FaxConfig->StartCheapTime.Minute = g_StartCheapTime.Minute;
FaxConfig->StopCheapTime.Hour = g_StopCheapTime.Hour;
FaxConfig->StopCheapTime.Minute = g_StopCheapTime.Minute;
FaxConfig->ArchiveOutgoingFaxes = g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].bUseArchive;
FaxConfig->PauseServerQueue = (g_dwQueueState & FAX_OUTBOX_PAUSED) ? TRUE : FALSE;
FaxConfig->Reserved = NULL;
StoreString(
g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].lpcstrFolder,
(PULONG_PTR)&FaxConfig->ArchiveDirectory,
*Buffer,
&Offset,
*BufferSize
);
exit:
LeaveCriticalSection (&g_CsConfig);
return rVal;
}
error_status_t
FAX_SetConfiguration(
IN handle_t FaxHandle,
IN const FAX_CONFIGURATION *FaxConfig
)
/*++
Routine Description:
Changes the FAX configuration on the FAX server.
The SizeOfStruct in the FaxConfig argument MUST be
set to a value == sizeof(FAX_CONFIGURATION).
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
Buffer - Pointer to a FAX_CONFIGURATION structure.
BufferSize - Size of Buffer
Return Value:
TRUE - Success
FALSE - Failure, call GetLastError() for more error information.
--*/
{
error_status_t rVal = ERROR_SUCCESS;
LPTSTR s;
BOOL b;
BOOL bSendOutboxEvent = FALSE;
BOOL bSendQueueStateEvent = FALSE;
BOOL bSendArchiveEvent = FALSE;
DWORD dwRes;
DWORD dw;
BOOL fAccess;
DWORD dwNewQueueState;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetConfiguration"));
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_MANAGE_CONFIG"));
return ERROR_ACCESS_DENIED;
}
if (!FaxConfig || FaxConfig->SizeOfStruct != sizeof(FAX_CONFIGURATION))
{
return ERROR_INVALID_PARAMETER;
}
EnterCriticalSection (&g_CsQueue);
EnterCriticalSection (&g_CsConfig);
if (FaxConfig->ArchiveOutgoingFaxes)
{
//
// make sure they give us something valid for a path if they want us to archive
//
if (!FaxConfig->ArchiveDirectory)
{
rVal = ERROR_INVALID_PARAMETER;
goto exit;
}
rVal = IsValidArchiveFolder (LPWSTR(FaxConfig->ArchiveDirectory),
FAX_MESSAGE_FOLDER_SENTITEMS);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Invalid archive folder specified (%s), ec = %lu"),
(LPTSTR)(FaxConfig->ArchiveDirectory),
rVal);
if(ERROR_ACCESS_DENIED == rVal &&
FAX_API_VERSION_1 <= FindClientAPIVersion (FaxHandle))
{
rVal = FAX_ERR_FILE_ACCESS_DENIED;
}
goto exit;
}
}
dwNewQueueState = g_dwQueueState;
(TRUE == FaxConfig->PauseServerQueue) ? (dwNewQueueState |= FAX_OUTBOX_PAUSED) : (dwNewQueueState &= ~FAX_OUTBOX_PAUSED);
if ( g_dwQueueState != dwNewQueueState)
{
bSendQueueStateEvent = TRUE;
}
//
// change the values in the registry
//
if (!IsLegalQueueSetting(dwNewQueueState))
{
if (FAX_API_VERSION_1 > FindClientAPIVersion (FaxHandle))
{
dwRes = ERROR_ACCESS_DENIED;
}
else
{
dwRes = GetLastError();
dwRes = (FAX_ERR_DIRECTORY_IN_USE == dwRes) ? FAX_ERR_DIRECTORY_IN_USE : FAX_ERR_FILE_ACCESS_DENIED;
}
goto exit;
}
if (!SetFaxGlobalsRegistry((PFAX_CONFIGURATION) FaxConfig, dwNewQueueState))
{
//
// Failed to set stuff
//
rVal = RPC_E_SYS_CALL_FAILED;
goto exit;
}
//
// change the values that the server is currently using
//
if (FaxConfig->PauseServerQueue)
{
if (!PauseServerQueue())
{
rVal = RPC_E_SYS_CALL_FAILED;
goto exit;
}
}
else
{
if (!ResumeServerQueue())
{
rVal = RPC_E_SYS_CALL_FAILED;
goto exit;
}
}
b = (BOOL)InterlockedExchange( (PLONG)&g_fFaxUseDeviceTsid, FaxConfig->UseDeviceTsid );
if ( b != FaxConfig->UseDeviceTsid)
{
bSendOutboxEvent = TRUE;
}
b = (BOOL)InterlockedExchange( (PLONG)&g_fFaxUseBranding, FaxConfig->Branding );
if ( !bSendOutboxEvent && b != FaxConfig->Branding)
{
bSendOutboxEvent = TRUE;
}
b = (BOOL)InterlockedExchange( (PLONG)&g_fServerCp, FaxConfig->ServerCp );
if ( !bSendOutboxEvent && b != FaxConfig->ServerCp)
{
bSendOutboxEvent = TRUE;
}
b = (BOOL)InterlockedExchange( (PLONG)&g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].bUseArchive,
FaxConfig->ArchiveOutgoingFaxes );
if ( b != FaxConfig->ArchiveOutgoingFaxes)
{
bSendArchiveEvent = TRUE;
}
dw = (DWORD)InterlockedExchange( (PLONG)&g_dwFaxSendRetries, FaxConfig->Retries );
if ( !bSendOutboxEvent && dw != FaxConfig->Retries)
{
bSendOutboxEvent = TRUE;
}
dw = (DWORD)InterlockedExchange( (PLONG)&g_dwFaxDirtyDays, FaxConfig->DirtyDays );
if ( !bSendOutboxEvent && dw != FaxConfig->DirtyDays)
{
bSendOutboxEvent = TRUE;
}
dw = (DWORD)InterlockedExchange( (PLONG)&g_dwFaxSendRetryDelay, FaxConfig->RetryDelay );
if ( !bSendOutboxEvent && dw != FaxConfig->RetryDelay)
{
bSendOutboxEvent = TRUE;
}
if ( (MAKELONG(g_StartCheapTime.Hour,g_StartCheapTime.Minute) != MAKELONG(FaxConfig->StartCheapTime.Hour,FaxConfig->StartCheapTime.Minute)) ||
(MAKELONG(g_StopCheapTime.Hour,g_StopCheapTime.Minute) != MAKELONG(FaxConfig->StopCheapTime.Hour, FaxConfig->StopCheapTime.Minute )) )
{
InterlockedExchange( (LPLONG)&g_StartCheapTime, MAKELONG(FaxConfig->StartCheapTime.Hour,FaxConfig->StartCheapTime.Minute) );
InterlockedExchange( (LPLONG)&g_StopCheapTime, MAKELONG(FaxConfig->StopCheapTime.Hour,FaxConfig->StopCheapTime.Minute) );
bSendOutboxEvent = TRUE;
}
s = (LPTSTR) InterlockedExchangePointer(
(LPVOID *)&(g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].lpcstrFolder),
FaxConfig->ArchiveDirectory ? (PVOID)StringDup( FaxConfig->ArchiveDirectory ) : NULL
);
if (s)
{
if (!bSendArchiveEvent)
{
if ( !FaxConfig->ArchiveDirectory ||
wcscmp(FaxConfig->ArchiveDirectory, s) != 0)
{
bSendArchiveEvent = TRUE;
}
}
MemFree( s );
}
else
{
// s was NULL
if (!bSendOutboxEvent && FaxConfig->ArchiveDirectory)
{
// value has changed
bSendArchiveEvent = TRUE;
}
}
//
// Send events
//
if (TRUE == bSendArchiveEvent)
{
dwRes = CreateConfigEvent (FAX_CONFIG_TYPE_SENTITEMS);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_SENTITEMS) (ec: %lc)"),
dwRes);
}
//
// We want to refresh the archive size and send quota warnings
//
g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].dwlArchiveSize = FAX_ARCHIVE_FOLDER_INVALID_SIZE;
g_FaxQuotaWarn[FAX_MESSAGE_FOLDER_SENTITEMS].bConfigChanged = TRUE;
g_FaxQuotaWarn[FAX_MESSAGE_FOLDER_SENTITEMS].bLoggedQuotaEvent = FALSE;
if (!SetEvent (g_hArchiveQuotaWarningEvent))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to set quota warning event, SetEvent failed (ec: %lc)"),
GetLastError());
}
}
if (TRUE == bSendOutboxEvent)
{
dwRes = CreateConfigEvent (FAX_CONFIG_TYPE_OUTBOX);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_OUTBOX) (ec: %lc)"),
dwRes);
}
}
if (TRUE == bSendQueueStateEvent)
{
dwRes = CreateQueueStateEvent (g_dwQueueState);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateQueueStateEvent() (ec: %lc)"),
dwRes);
}
}
exit:
LeaveCriticalSection (&g_CsConfig);
LeaveCriticalSection (&g_CsQueue);
return rVal;
}
DWORD
GetPortSize(
PLINE_INFO LineInfo
)
{
DWORD Size;
Size = sizeof(FAX_PORT_INFOW);
Size += StringSize( LineInfo->DeviceName );
Size += StringSize( LineInfo->Tsid );
Size += StringSize( LineInfo->Csid );
return Size;
}
BOOL
GetPortData(
LPBYTE PortBuffer,
PFAX_PORT_INFOW PortInfo,
PLINE_INFO LineInfo,
PULONG_PTR Offset,
DWORD dwPortBufferSize
)
{
DWORD dwRes = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("GetPortData"));
LPDWORD lpdwDevices = NULL;
DWORD dwNumDevices = 0;
DWORD i;
PCGROUP pCGroup;
pCGroup = g_pGroupsMap->FindGroup (ROUTING_GROUP_ALL_DEVICESW);
if (NULL == pCGroup)
{
dwRes = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("COutboundRoutingGroupsMap::FindGroup failed , ec %ld"), dwRes);
return FALSE;
}
dwRes = pCGroup->SerializeDevices (&lpdwDevices, &dwNumDevices);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("COutboundRoutingGroup::EnumDevices failed , ec %ld"), dwRes);
SetLastError (dwRes);
return FALSE;
}
PortInfo->Priority = 0;
for (i = 0; i < dwNumDevices; i++)
{
if (LineInfo->PermanentLineID == lpdwDevices[i])
{
PortInfo->Priority = i+1; // 1 based index
}
}
if (0 == PortInfo->Priority)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("%ld is not a valid device ID"), LineInfo->PermanentLineID);
MemFree (lpdwDevices);
SetLastError (ERROR_INVALID_PARAMETER);
return FALSE;
}
MemFree (lpdwDevices);
PortInfo->SizeOfStruct = sizeof(FAX_PORT_INFOW);
PortInfo->DeviceId = LineInfo->PermanentLineID;
PortInfo->State = LineInfoToLegacyDeviceStatus(LineInfo);
PortInfo->Flags = LineInfo->Flags & 0x0fffffff;
PortInfo->Rings = LineInfo->RingsForAnswer;
StoreString( LineInfo->DeviceName,
(PULONG_PTR)&PortInfo->DeviceName,
PortBuffer,
Offset,
dwPortBufferSize);
StoreString( LineInfo->Tsid,
(PULONG_PTR)&PortInfo->Tsid,
PortBuffer,
Offset,
dwPortBufferSize);
StoreString( LineInfo->Csid,
(PULONG_PTR)&PortInfo->Csid,
PortBuffer,
Offset,
dwPortBufferSize);
return (dwRes == ERROR_SUCCESS);
}
error_status_t
FAX_EnumPorts(
handle_t FaxHandle,
LPBYTE *PortBuffer,
LPDWORD BufferSize,
LPDWORD PortsReturned
)
/*++
Routine Description:
Enumerates all of the FAX devices attached to the
FAX server. The port state information is returned
for each device.
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer
PortBuffer - Buffer to hold the port information
BufferSize - Total size of the port info buffer
PortsReturned - The number of ports in the buffer
Return Value:
ERROR_SUCCESS for success, otherwise a WIN32 error code.
--*/
{
DWORD rVal = 0;
PLIST_ENTRY Next;
PLINE_INFO LineInfo;
DWORD i;
ULONG_PTR Offset;
DWORD FaxDevices;
PFAX_PORT_INFOW PortInfo;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnumPorts()"));
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_CONFIG"));
return ERROR_ACCESS_DENIED;
}
Assert (BufferSize && PortsReturned); // ref pointers in idl
if (!PortBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
EnterCriticalSection( &g_CsLine );
if (!PortsReturned)
{
rVal = ERROR_INVALID_PARAMETER;
goto exit;
}
if (!g_TapiLinesListHead.Flink)
{
rVal = ERROR_INVALID_PARAMETER;
goto exit;
}
Next = g_TapiLinesListHead.Flink;
*PortsReturned = 0;
*BufferSize = 0;
FaxDevices = 0;
//
// count the number of bytes required
//
*BufferSize = 0;
while ((ULONG_PTR)Next != (ULONG_PTR)&g_TapiLinesListHead)
{
LineInfo = CONTAINING_RECORD( Next, LINE_INFO, ListEntry );
Next = LineInfo->ListEntry.Flink;
if (LineInfo->PermanentLineID && LineInfo->DeviceName)
{
*BufferSize += sizeof(PFAX_PORT_INFOW);
*BufferSize += GetPortSize( LineInfo );
FaxDevices += 1;
}
}
*PortBuffer = (LPBYTE) MemAlloc( *BufferSize );
if (*PortBuffer == NULL)
{
rVal = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
PortInfo = (PFAX_PORT_INFOW) *PortBuffer;
Offset = FaxDevices * sizeof(FAX_PORT_INFOW);
Next = g_TapiLinesListHead.Flink;
i = 0;
while ((ULONG_PTR)Next != (ULONG_PTR)&g_TapiLinesListHead)
{
LineInfo = CONTAINING_RECORD( Next, LINE_INFO, ListEntry );
Next = LineInfo->ListEntry.Flink;
if (LineInfo->PermanentLineID && LineInfo->DeviceName)
{
if (!GetPortData( *PortBuffer,
&PortInfo[i],
LineInfo,
&Offset,
*BufferSize))
{
MemFree (*PortBuffer);
*PortBuffer = NULL;
*BufferSize = 0;
rVal = GetLastError();
goto exit;
}
}
i++;
}
//
// set the device count
//
*PortsReturned = FaxDevices;
exit:
LeaveCriticalSection( &g_CsLine );
return rVal;
}
error_status_t
FAX_GetPort(
HANDLE FaxPortHandle,
LPBYTE *PortBuffer,
LPDWORD BufferSize
)
/*++
Routine Description:
Returns port status information for a requested port.
The device id passed in should be optained from FAXEnumPorts.
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
DeviceId - TAPI device id
PortBuffer - Buffer to hold the port information
BufferSize - Total size of the port info buffer
Return Value:
ERROR_SUCCESS for success, otherwise a WIN32 error code.
--*/
{
PLINE_INFO LineInfo;
DWORD rVal = 0;
ULONG_PTR Offset;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetPort()"));
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_CONFIG"));
return ERROR_ACCESS_DENIED;
}
Assert (BufferSize); // ref pointer in idl
if (!PortBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
if (NULL == FaxPortHandle)
{
DebugPrintEx(DEBUG_ERR,
TEXT("NULL context handle"));
return ERROR_INVALID_PARAMETER;
}
LineInfo = ((PHANDLE_ENTRY)FaxPortHandle)->LineInfo;
if (!LineInfo)
{
return ERROR_INVALID_DATA;
}
EnterCriticalSection (&g_CsLine);
EnterCriticalSection (&g_CsConfig);
//
// calculate the required buffer size
//
*BufferSize = GetPortSize( LineInfo );
*PortBuffer = (LPBYTE) MemAlloc( *BufferSize );
if (*PortBuffer == NULL)
{
rVal = ERROR_NOT_ENOUGH_MEMORY;
goto Exit;
}
Offset = sizeof(FAX_PORT_INFOW);
if (!GetPortData( *PortBuffer,
(PFAX_PORT_INFO)*PortBuffer,
LineInfo,
&Offset,
*BufferSize))
{
MemFree (*PortBuffer);
*PortBuffer = NULL;
*BufferSize = 0;
rVal = GetLastError();
goto Exit;
}
Exit:
LeaveCriticalSection( &g_CsConfig );
LeaveCriticalSection( &g_CsLine );
return rVal;
}
DWORD
SetDeviceOrder(
DWORD dwDeviceId,
DWORD dwNewOrder
)
/*++
Routine name : SetDeviceOrder
Routine description:
Sets the device order in <All Devices> group.
Author:
Oded Sacher (OdedS), May, 2000
Arguments:
dwDeviceId [in] - Device ID.
dwNewOrder [in] - New order.
Return Value:
None.
--*/
{
DEBUG_FUNCTION_NAME(TEXT("SetDeviceOrder"));
DWORD rVal = ERROR_SUCCESS;
HKEY hGroupKey = NULL;
PCGROUP pCGroup = NULL;
COutboundRoutingGroup OldGroup;
// Open the <All Devices> group registry key
hGroupKey = OpenOutboundGroupKey( ROUTING_GROUP_ALL_DEVICESW, FALSE, KEY_READ | KEY_WRITE );
if (NULL == hGroupKey)
{
rVal = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("Can't open group key, OpenOutboundGroupKey failed : %ld"),
rVal);
goto exit;
}
// Find the group in memory
pCGroup = g_pGroupsMap->FindGroup (ROUTING_GROUP_ALL_DEVICESW);
if (!pCGroup)
{
rVal = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("COutboundRoutingGroupsMap::FindGroup failed, Group name - %s, error %ld"),
ROUTING_GROUP_ALL_DEVICESW,
rVal);
goto exit;
}
// Save a copy of the old group
OldGroup = *pCGroup;
// Cahnge the device order in the group
rVal = pCGroup->SetDeviceOrder(dwDeviceId, dwNewOrder);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("COutboundRoutingGroupsMap::SetDeviceOrder failed, Group name - %s,\
Device Id %ld, new order %ld, error %ld"),
ROUTING_GROUP_ALL_DEVICESW,
dwDeviceId,
dwNewOrder,
rVal);
goto exit;
}
// save changes to the registry
rVal = pCGroup->Save (hGroupKey);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("COutboundRoutingGroup::Save failed, Group name - %s, failed with %ld"),
ROUTING_GROUP_ALL_DEVICESW,
rVal);
// Rollback memory
*pCGroup = OldGroup;
}
exit:
if (NULL != hGroupKey)
{
RegCloseKey (hGroupKey);
}
return rVal;
}
error_status_t
FAX_SetPort(
HANDLE FaxPortHandle,
const FAX_PORT_INFOW *PortInfo
)
/*++
Routine Description:
Changes the port capability mask. This allows the caller to
enable or disable sending & receiving on a port basis.
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
PortBuffer - Buffer to hold the port information
BufferSize - Total size of the port info buffer
Return Value:
ERROR_SUCCESS for success, otherwise a WIN32 error code.
--*/
{
DWORD rVal = 0;
DWORD flags = 0;
PLINE_INFO LineInfo;
DWORD totalDevices;
BOOL SendEnabled = FALSE;
DWORD dwRes;
BOOL fAccess;
BOOL bDeviceWasReceiveEnabled;
BOOL fDeviceWasEnabled;
BOOL bCancelManualAnswerDevice = FALSE; // Should we cancel (zero) the manual answer device?
DEBUG_FUNCTION_NAME(TEXT("FAX_SetPort"));
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_MANAGE_CONFIG"));
return ERROR_ACCESS_DENIED;
}
if (!PortInfo) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
if (NULL == FaxPortHandle)
{
DebugPrintEx(
DEBUG_ERR,
_T("Empty context handle"));
return ERROR_INVALID_PARAMETER;
}
LineInfo = ((PHANDLE_ENTRY)FaxPortHandle)->LineInfo;
if (!LineInfo)
{
return ERROR_INVALID_DATA;
}
EnterCriticalSection( &g_CsJob );
EnterCriticalSection( &g_CsLine );
EnterCriticalSection (&g_CsConfig);
bDeviceWasReceiveEnabled = (LineInfo->Flags & FPF_RECEIVE) ? TRUE : FALSE;
fDeviceWasEnabled = IsDeviceEnabled(LineInfo);
if (PortInfo->SizeOfStruct != sizeof(FAX_PORT_INFOW))
{
rVal = ERROR_INVALID_PARAMETER;
goto Exit;
}
//
// Check if we exceed device limit
//
if (g_dwDeviceEnabledCount >= g_dwDeviceEnabledLimit && // We are at the device limit
!fDeviceWasEnabled && // It was not send/receive/manual receive enabled
((PortInfo->Flags & FPF_SEND) || (PortInfo->Flags & FPF_RECEIVE))) // It is now set to send/receive enabled
{
if (FAX_API_VERSION_1 > FindClientAPIVersion (FaxPortHandle))
{
//
// API version 0 clients don't know about FAX_ERR_DEVICE_NUM_LIMIT_EXCEEDED
//
rVal = ERROR_INVALID_PARAMETER;
}
else
{
rVal = FAX_ERR_DEVICE_NUM_LIMIT_EXCEEDED;
}
goto Exit;
}
if (LineInfo->PermanentLineID == g_dwManualAnswerDeviceId &&
((PortInfo->Flags) & FPF_RECEIVE))
{
//
// Can't set device to auto-answer when it's in manual-answer mode.
// So, we mark a flag that will cause (towards the end of the function, if everything is ok)
// the disabling of the manual-answer device.
//
bCancelManualAnswerDevice = TRUE;
}
//
// make sure the user sets a reasonable priority
//
totalDevices = GetFaxDeviceCount();
if (0 == PortInfo->Priority ||
PortInfo->Priority > totalDevices)
{
rVal = ERROR_INVALID_PARAMETER;
goto Exit;
}
rVal = SetDeviceOrder(LineInfo->PermanentLineID, PortInfo->Priority);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("SetDeviceOrder Failed, Error : %ld"),
rVal);
goto Exit;
}
//
// HACK: we allow the ring count to be set even if the line is in use so that systray will work. we don't allow
// the user to change things like CSID/TSID or tapi related information since that cannot change until the call
// transaction is complete.
//
LineInfo->RingsForAnswer = PortInfo->Rings;
flags = PortInfo->Flags & (FPF_CLIENT_BITS);
//
// first change the real time data that the server is using
//
if ((!(LineInfo->Flags & FPF_RECEIVE)) && (flags & FPF_RECEIVE))
{
//
// Device was NOT receive-enabled and now turned into receive-enabled
//
if (!(LineInfo->Flags & FPF_VIRTUAL) && (!LineInfo->hLine))
{
if (!OpenTapiLine( LineInfo ))
{
DWORD rc = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("OpenTapiLine failed. (ec: %ld)"),
rc);
}
}
}
else if ((LineInfo->Flags & FPF_RECEIVE) && (!(flags & FPF_RECEIVE)))
{
//
// Device was receive-enabled and now turned into not receive-enabled
//
if (LineInfo->State == FPS_AVAILABLE && // Line available and
LineInfo->hLine // device is open
)
{
lineClose( LineInfo->hLine );
LineInfo->hLine = 0;
}
}
if (!(LineInfo->Flags & FPF_SEND) && (flags & FPF_SEND))
{
LineInfo->LastLineClose = 0; // Try to use it on the first try
SendEnabled = TRUE;
}
if ((LineInfo->Flags & FPF_CLIENT_BITS) != (flags & FPF_CLIENT_BITS))
{
UpdateVirtualDeviceSendAndReceiveStatus (LineInfo,
LineInfo->Flags & FPF_SEND,
LineInfo->Flags & FPF_RECEIVE
);
}
LineInfo->Flags = (LineInfo->Flags & ~FPF_CLIENT_BITS) | flags;
LineInfo->RingsForAnswer = PortInfo->Rings;
if (PortInfo->Tsid)
{
MemFree( LineInfo->Tsid );
LineInfo->Tsid = StringDup( PortInfo->Tsid );
}
if (PortInfo->Csid)
{
MemFree( LineInfo->Csid );
LineInfo->Csid = StringDup( PortInfo->Csid );
}
//
// now change the registry so it sticks
// (need to change all devices, since the priority may have changed)
//
CommitDeviceChanges(LineInfo);
if ((ERROR_SUCCESS == rVal) && bCancelManualAnswerDevice)
{
//
// This is the time to cancel (in memory and the registry) the manual answer device
//
g_dwManualAnswerDeviceId = 0;
dwRes = WriteManualAnswerDeviceId (g_dwManualAnswerDeviceId);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("WriteManualAnswerDeviceId(0) (ec: %lc)"),
dwRes);
}
}
dwRes = CreateConfigEvent (FAX_CONFIG_TYPE_DEVICES);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_DEVICES) (ec: %lc)"),
dwRes);
}
if (bDeviceWasReceiveEnabled && !(LineInfo->Flags & FPF_RECEIVE))
{
//
// This device stopped receiving
//
SafeDecIdleCounter (&g_dwReceiveDevicesCount);
}
else if (!bDeviceWasReceiveEnabled && (LineInfo->Flags & FPF_RECEIVE))
{
//
// This device started receiving
//
SafeIncIdleCounter (&g_dwReceiveDevicesCount);
}
//
// Update enabled device count
//
if (fDeviceWasEnabled == TRUE)
{
if (FALSE == IsDeviceEnabled(LineInfo))
{
Assert (g_dwDeviceEnabledCount);
g_dwDeviceEnabledCount -= 1;
}
}
else
{
//
// The device was not enabled
//
if (TRUE == IsDeviceEnabled(LineInfo))
{
g_dwDeviceEnabledCount += 1;
Assert (g_dwDeviceEnabledCount <= g_dwDeviceEnabledLimit);
}
}
Exit:
LeaveCriticalSection( &g_CsConfig );
LeaveCriticalSection( &g_CsLine );
LeaveCriticalSection( &g_CsJob );
if (SendEnabled)
{
if (!SetEvent( g_hJobQueueEvent ))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("SetEvent failed (ec: %lc)"),
GetLastError);
EnterCriticalSection (&g_CsQueue);
g_ScanQueueAfterTimeout = TRUE;
LeaveCriticalSection (&g_CsQueue);
}
}
return rVal;
}
typedef struct _ENUM_CONTEXT {
DWORD Function;
DWORD Size;
ULONG_PTR Offset;
PLINE_INFO LineInfo;
PFAX_ROUTING_METHOD RoutingInfoMethod;
DWORD dwRoutingInfoMethodSize;
} ENUM_CONTEXT, *PENUM_CONTEXT;
BOOL CALLBACK
RoutingMethodEnumerator(
PROUTING_METHOD RoutingMethod,
LPVOID lpEnumCtxt
)
{
PENUM_CONTEXT EnumContext=(PENUM_CONTEXT)lpEnumCtxt;
LPWSTR GuidString;
//
// we only access read-only static data in the LINE_INFO structure.
// make sure that this access is protected if you access dynamic
// data in the future.
//
if (EnumContext->Function == 1)
{
//
// Enumerate (read)
//
EnumContext->Size += sizeof(FAX_ROUTING_METHOD);
StringFromIID( RoutingMethod->Guid, &GuidString );
EnumContext->Size += StringSize( GuidString );
EnumContext->Size += StringSize( EnumContext->LineInfo->DeviceName );
EnumContext->Size += StringSize( RoutingMethod->FunctionName );
EnumContext->Size += StringSize( RoutingMethod->FriendlyName );
EnumContext->Size += StringSize( RoutingMethod->RoutingExtension->ImageName );
EnumContext->Size += StringSize( RoutingMethod->RoutingExtension->FriendlyName );
CoTaskMemFree( GuidString );
return TRUE;
}
if (EnumContext->Function == 2)
{
//
// Set data
//
StringFromIID( RoutingMethod->Guid, &GuidString );
EnumContext->RoutingInfoMethod[EnumContext->Size].SizeOfStruct = sizeof(FAX_ROUTING_METHOD);
EnumContext->RoutingInfoMethod[EnumContext->Size].DeviceId = EnumContext->LineInfo->PermanentLineID;
__try
{
EnumContext->RoutingInfoMethod[EnumContext->Size].Enabled =
RoutingMethod->RoutingExtension->FaxRouteDeviceEnable(
GuidString,
EnumContext->LineInfo->PermanentLineID,
QUERY_STATUS
);
}
__except (HandleFaxExtensionFault(EXCEPTION_SOURCE_ROUTING_EXT, RoutingMethod->RoutingExtension->FriendlyName, GetExceptionCode()))
{
ASSERT_FALSE;
}
StoreString(
EnumContext->LineInfo->DeviceName,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].DeviceName,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
StoreString(
GuidString,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].Guid,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
StoreString(
RoutingMethod->FriendlyName,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].FriendlyName,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
StoreString(
RoutingMethod->FunctionName,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].FunctionName,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
StoreString(
RoutingMethod->RoutingExtension->ImageName,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].ExtensionImageName,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
StoreString(
RoutingMethod->RoutingExtension->FriendlyName,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].ExtensionFriendlyName,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
EnumContext->Size += 1;
CoTaskMemFree( GuidString );
return TRUE;
}
return FALSE;
}
error_status_t
FAX_EnumRoutingMethods(
IN HANDLE FaxPortHandle,
OUT LPBYTE *RoutingInfoBuffer,
OUT LPDWORD RoutingInfoBufferSize,
OUT LPDWORD MethodsReturned
)
{
PLINE_INFO LineInfo;
ENUM_CONTEXT EnumContext;
DWORD CountMethods;
BOOL fAccess;
DWORD rVal = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnumRoutingMethods()"));
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_CONFIG"));
return ERROR_ACCESS_DENIED;
}
Assert (RoutingInfoBufferSize && MethodsReturned); // ref pointers in idl
if (!RoutingInfoBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
if (NULL == FaxPortHandle)
{
DebugPrintEx(
DEBUG_ERR,
_T("Empty context handle"));
return ERROR_INVALID_PARAMETER;
}
LineInfo = ((PHANDLE_ENTRY)FaxPortHandle)->LineInfo;
if (!LineInfo)
{
return ERROR_INVALID_DATA;
}
//
// note that the called routines are protected so we don't have any protection here
//
//
// compute the required size of the buffer
//
EnumContext.Function = 1;
EnumContext.Size = 0;
EnumContext.Offset = 0;
EnumContext.LineInfo = LineInfo;
EnumContext.RoutingInfoMethod = NULL;
EnumContext.dwRoutingInfoMethodSize = 0;
CountMethods = EnumerateRoutingMethods( RoutingMethodEnumerator, &EnumContext );
rVal = GetLastError();
if (ERROR_SUCCESS != rVal)
{
//
// Function failed in enumeration
//
return rVal;
}
if (CountMethods == 0)
{
//
// No Methods registered
//
*RoutingInfoBuffer = NULL;
*RoutingInfoBufferSize = 0;
*MethodsReturned = 0;
return ERROR_SUCCESS;
}
//
// allocate the buffer
//
*RoutingInfoBufferSize = EnumContext.Size;
*RoutingInfoBuffer = (LPBYTE) MemAlloc( *RoutingInfoBufferSize );
if (*RoutingInfoBuffer == NULL)
{
return ERROR_NOT_ENOUGH_MEMORY;
}
//
// fill the buffer with the data
//
EnumContext.Function = 2;
EnumContext.Size = 0;
EnumContext.Offset = sizeof(FAX_ROUTING_METHODW) * CountMethods;
EnumContext.LineInfo = LineInfo;
EnumContext.RoutingInfoMethod = (PFAX_ROUTING_METHOD) *RoutingInfoBuffer;
EnumContext.dwRoutingInfoMethodSize = *RoutingInfoBufferSize;
if (!EnumerateRoutingMethods( RoutingMethodEnumerator, &EnumContext))
{
MemFree( *RoutingInfoBuffer );
*RoutingInfoBuffer = NULL;
*RoutingInfoBufferSize = 0;
return ERROR_INVALID_FUNCTION;
}
*MethodsReturned = CountMethods;
return 0;
}
error_status_t
FAX_EnableRoutingMethod(
IN HANDLE FaxPortHandle,
IN LPCWSTR RoutingGuidString,
IN BOOL Enabled
)
{
error_status_t ec = 0;
BOOL bRes;
PLINE_INFO LineInfo;
PROUTING_METHOD RoutingMethod;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnableRoutingMethod"));
//
// Access check
//
ec = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != ec)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
ec);
return ec;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_MANAGE_CONFIG "));
return ERROR_ACCESS_DENIED;
}
if (NULL == FaxPortHandle)
{
DebugPrintEx(
DEBUG_ERR,
_T("Empty context handle"));
return ERROR_INVALID_PARAMETER;
}
LineInfo = ((PHANDLE_ENTRY)FaxPortHandle)->LineInfo;
if (!LineInfo)
{
return ERROR_INVALID_DATA;
}
if (!RoutingGuidString)
{
return ERROR_INVALID_PARAMETER;
}
EnterCriticalSection( &g_CsRouting );
//
// get the routing method
//
RoutingMethod = FindRoutingMethodByGuid( RoutingGuidString );
if (!RoutingMethod)
{
LeaveCriticalSection( &g_CsRouting );
DebugPrintEx(DEBUG_ERR,
TEXT("Couldn't find routing method with GUID %s"),
RoutingGuidString);
return ERROR_INVALID_DATA;
}
//
// enable/disable the routing method for this device
//
__try
{
bRes = RoutingMethod->RoutingExtension->FaxRouteDeviceEnable(
(LPWSTR)RoutingGuidString,
LineInfo->PermanentLineID,
Enabled ? STATUS_ENABLE : STATUS_DISABLE);
}
__except (HandleFaxExtensionFault(EXCEPTION_SOURCE_ROUTING_EXT, RoutingMethod->RoutingExtension->FriendlyName, GetExceptionCode()))
{
ASSERT_FALSE;
}
if (!bRes)
{
//
// FaxRouteDeviceEnable failed
//
ec = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("FaxRouteDeviceEnable failed with %ld"),
ec);
}
LeaveCriticalSection( &g_CsRouting );
return ec;
}
typedef struct _ENUM_GLOBALCONTEXT {
DWORD Function;
DWORD Size;
ULONG_PTR Offset;
PFAX_GLOBAL_ROUTING_INFO RoutingInfoMethod;
DWORD dwRoutingInfoMethodSize;
} ENUM_GLOBALCONTEXT, *PENUM_GLOBALCONTEXT;
BOOL CALLBACK
GlobalRoutingInfoMethodEnumerator(
PROUTING_METHOD RoutingMethod,
LPVOID lpEnumCtxt
)
{
PENUM_GLOBALCONTEXT EnumContext=(PENUM_GLOBALCONTEXT)lpEnumCtxt;
LPWSTR GuidString;
if (EnumContext->Function == 1) {
EnumContext->Size += sizeof(FAX_GLOBAL_ROUTING_INFO);
StringFromIID( RoutingMethod->Guid, &GuidString );
EnumContext->Size += StringSize( GuidString );
EnumContext->Size += StringSize( RoutingMethod->FunctionName );
EnumContext->Size += StringSize( RoutingMethod->FriendlyName );
EnumContext->Size += StringSize( RoutingMethod->RoutingExtension->ImageName );
EnumContext->Size += StringSize( RoutingMethod->RoutingExtension->FriendlyName );
CoTaskMemFree( GuidString );
return TRUE;
}
if (EnumContext->Function == 2) {
StringFromIID( RoutingMethod->Guid, &GuidString );
EnumContext->RoutingInfoMethod[EnumContext->Size].SizeOfStruct = sizeof(FAX_GLOBAL_ROUTING_INFO);
EnumContext->RoutingInfoMethod[EnumContext->Size].Priority = RoutingMethod->Priority;
StoreString(
GuidString,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].Guid,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
StoreString(
RoutingMethod->FriendlyName,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].FriendlyName,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
StoreString(
RoutingMethod->FunctionName,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].FunctionName,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
StoreString(
RoutingMethod->RoutingExtension->ImageName,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].ExtensionImageName,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
StoreString(
RoutingMethod->RoutingExtension->FriendlyName,
(PULONG_PTR)&EnumContext->RoutingInfoMethod[EnumContext->Size].ExtensionFriendlyName,
(LPBYTE)EnumContext->RoutingInfoMethod,
&EnumContext->Offset,
EnumContext->dwRoutingInfoMethodSize
);
EnumContext->Size += 1;
CoTaskMemFree( GuidString );
return TRUE;
}
return FALSE;
}
error_status_t
FAX_EnumGlobalRoutingInfo(
IN handle_t FaxHandle ,
OUT LPBYTE *RoutingInfoBuffer,
OUT LPDWORD RoutingInfoBufferSize,
OUT LPDWORD MethodsReturned
)
{
DWORD CountMethods;
ENUM_GLOBALCONTEXT EnumContext;
BOOL fAccess;
DWORD ec = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnumGlobalRoutingInfo"));
//
// Access check
//
ec = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != ec)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
ec);
return ec;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_CONFIG"));
return ERROR_ACCESS_DENIED;
}
Assert (RoutingInfoBufferSize && MethodsReturned); // ref pointer in idl
if (!RoutingInfoBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// compute the required size of the buffer
//
EnumContext.Function = 1;
EnumContext.Size = 0;
EnumContext.Offset = 0;
EnumContext.RoutingInfoMethod = NULL;
EnumContext.dwRoutingInfoMethodSize = 0;
CountMethods = EnumerateRoutingMethods( GlobalRoutingInfoMethodEnumerator, &EnumContext );
ec = GetLastError();
if (ERROR_SUCCESS != ec)
{
//
// Function failed in enumeration
//
return ec;
}
if (CountMethods == 0)
{
//
// No Methods registered
//
*RoutingInfoBuffer = NULL;
*RoutingInfoBufferSize = 0;
*MethodsReturned = 0;
return ERROR_SUCCESS;
}
//
// allocate the buffer
//
*RoutingInfoBufferSize = EnumContext.Size;
*RoutingInfoBuffer = (LPBYTE) MemAlloc( *RoutingInfoBufferSize );
if (*RoutingInfoBuffer == NULL) {
return ERROR_NOT_ENOUGH_MEMORY;
}
//
// fill the buffer with the data
//
EnumContext.Function = 2;
EnumContext.Size = 0;
EnumContext.Offset = sizeof(FAX_GLOBAL_ROUTING_INFOW) * CountMethods;
EnumContext.RoutingInfoMethod = (PFAX_GLOBAL_ROUTING_INFO) *RoutingInfoBuffer;
EnumContext.dwRoutingInfoMethodSize = *RoutingInfoBufferSize;
if (!EnumerateRoutingMethods( GlobalRoutingInfoMethodEnumerator, &EnumContext )) {
MemFree( *RoutingInfoBuffer );
*RoutingInfoBuffer = NULL;
*RoutingInfoBufferSize = 0;
return ERROR_INVALID_FUNCTION;
}
*MethodsReturned = CountMethods;
return 0;
}
error_status_t
FAX_SetGlobalRoutingInfo(
IN HANDLE FaxHandle,
IN const FAX_GLOBAL_ROUTING_INFOW *RoutingInfo
)
{
error_status_t ec = 0;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetGlobalRoutingInfo"));
//
// Access check
//
ec = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != ec)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
ec);
return ec;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_MANAGE_CONFIG"));
return ERROR_ACCESS_DENIED;
}
PROUTING_METHOD RoutingMethod;
//
// verify that the client as access rights
//
if (!RoutingInfo)
{
return ERROR_INVALID_PARAMETER;
}
if (RoutingInfo->SizeOfStruct != sizeof(FAX_GLOBAL_ROUTING_INFOW))
{
return ERROR_INVALID_PARAMETER;
}
EnterCriticalSection( &g_CsRouting );
//
// get the routing method
//
RoutingMethod = FindRoutingMethodByGuid( RoutingInfo->Guid );
if (!RoutingMethod)
{
LeaveCriticalSection( &g_CsRouting );
return ERROR_INVALID_DATA;
}
//
// change the priority
//
RoutingMethod->Priority = RoutingInfo->Priority;
SortMethodPriorities();
CommitMethodChanges();
LeaveCriticalSection( &g_CsRouting );
return ec;
}
error_status_t
FAX_GetRoutingInfo(
IN HANDLE FaxPortHandle,
IN LPCWSTR RoutingGuidString,
OUT LPBYTE *RoutingInfoBuffer,
OUT LPDWORD RoutingInfoBufferSize
)
{
error_status_t ec=0;
PLINE_INFO LineInfo;
PROUTING_METHOD RoutingMethod;
LPBYTE RoutingInfo = NULL;
DWORD RoutingInfoSize = 0;
BOOL fAccess;
BOOL bRes;
DWORD Rval = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetRoutingInfo()"));
//
// Access check
//
Rval = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_CONFIG"));
return ERROR_ACCESS_DENIED;
}
Assert (RoutingInfoBufferSize); // ref pointer in idl
if (!RoutingGuidString || !RoutingInfoBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
if (NULL == FaxPortHandle)
{
DebugPrintEx(
DEBUG_ERR,
_T("Empty context handle"));
return ERROR_INVALID_PARAMETER;
}
LineInfo = ((PHANDLE_ENTRY)FaxPortHandle)->LineInfo;
if (!LineInfo)
{
return ERROR_INVALID_DATA;
}
RoutingMethod = FindRoutingMethodByGuid( RoutingGuidString );
if (!RoutingMethod)
{
return ERROR_INVALID_DATA;
}
__try
{
//
// first check to see how big the buffer needs to be
//
bRes = RoutingMethod->RoutingExtension->FaxRouteGetRoutingInfo(
(LPWSTR) RoutingGuidString,
LineInfo->PermanentLineID,
NULL,
&RoutingInfoSize );
}
__except (HandleFaxExtensionFault(EXCEPTION_SOURCE_ROUTING_EXT, RoutingMethod->RoutingExtension->FriendlyName, GetExceptionCode()))
{
ASSERT_FALSE;
}
if (bRes)
{
//
// allocate a client buffer
//
RoutingInfo = (LPBYTE) MemAlloc( RoutingInfoSize );
if (RoutingInfo == NULL)
{
return ERROR_NOT_ENOUGH_MEMORY;
}
//
// get the routing data
//
__try
{
bRes = RoutingMethod->RoutingExtension->FaxRouteGetRoutingInfo(
RoutingGuidString,
LineInfo->PermanentLineID,
RoutingInfo,
&RoutingInfoSize );
}
__except (HandleFaxExtensionFault(EXCEPTION_SOURCE_ROUTING_EXT, RoutingMethod->RoutingExtension->FriendlyName, GetExceptionCode()))
{
ASSERT_FALSE;
}
if (bRes)
{
//
// move the data to the return buffer
//
*RoutingInfoBuffer = RoutingInfo;
*RoutingInfoBufferSize = RoutingInfoSize;
return ERROR_SUCCESS;
}
else
{
//
// FaxRouteGetRoutingInfo failed so return last error
//
ec = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("FaxRouteGetRoutingInfo failed with %ld in trying to find out buffer size"),
ec);
MemFree(RoutingInfo);
return ec;
}
}
else
{
//
// FaxRouteGetRoutingInfo failed so return last error
//
ec = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("FaxRouteGetRoutingInfo failed with %ld in trying get the routing data"),
ec);
return ec;
}
return ERROR_INVALID_FUNCTION;
} // FAX_GetRoutingInfo
error_status_t
FAX_SetRoutingInfo(
IN HANDLE FaxPortHandle,
IN LPCWSTR RoutingGuidString,
IN const BYTE *RoutingInfoBuffer,
IN DWORD RoutingInfoBufferSize
)
{
error_status_t ec=0;
PLINE_INFO LineInfo;
PROUTING_METHOD RoutingMethod;
BOOL fAccess;
DWORD rVal = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetRoutingInfo"));
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_MANAGE_CONFIG"));
return ERROR_ACCESS_DENIED;
}
if (!RoutingGuidString || !RoutingInfoBuffer || !RoutingInfoBufferSize)
{
return ERROR_INVALID_PARAMETER;
}
if (NULL == FaxPortHandle)
{
DebugPrintEx(
DEBUG_ERR,
_T("Empty context handle"));
return ERROR_INVALID_PARAMETER;
}
LineInfo = ((PHANDLE_ENTRY)FaxPortHandle)->LineInfo;
if (!LineInfo)
{
return ERROR_INVALID_DATA;
}
RoutingMethod = FindRoutingMethodByGuid( RoutingGuidString );
if (!RoutingMethod)
{
return ERROR_INVALID_DATA;
}
__try
{
if (RoutingMethod->RoutingExtension->FaxRouteSetRoutingInfo(
RoutingGuidString,
LineInfo->PermanentLineID,
RoutingInfoBuffer,
RoutingInfoBufferSize ))
{
return ERROR_SUCCESS;
}
else
{
//
// FaxRouteSetRoutingInfo failed so return last error
//
ec = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("FaxRouteSetRoutingInfo failed with %ld"),
ec);
return ec;
}
}
__except (HandleFaxExtensionFault(EXCEPTION_SOURCE_ROUTING_EXT, RoutingMethod->RoutingExtension->FriendlyName, GetExceptionCode()))
{
ASSERT_FALSE;
}
return ERROR_INVALID_FUNCTION;
}
error_status_t
FAX_GetCountryList(
IN HANDLE FaxHandle,
OUT LPBYTE* Buffer,
OUT LPDWORD BufferSize
)
/*++
Routine Description:
Return a list of countries from TAPI
Arguments:
FaxHandle - FAX handle obtained from FaxConnectFaxServer.
Buffer - A pointer to the buffer into which the output should be copied.
BufferSize - Buffer Size
Return Value:
TRUE if successful, FALSE if there is an error
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_GetCountryList"));
LPLINECOUNTRYLIST lpCountryList = NULL;
LPLINECOUNTRYENTRY lpEntry = NULL;
PFAX_TAPI_LINECOUNTRY_LIST pLineCountryList = NULL;
ULONG_PTR Offset = NULL;
LONG rVal = ERROR_SUCCESS;
DWORD dwIndex;
BOOL fAccess;
DWORD dwRights;
Assert (BufferSize); // ref pointer in idl
if (!Buffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
*Buffer = NULL;
*BufferSize = 0;
//
// Access check
//
rVal = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
if (!(lpCountryList = GetCountryList()))
{
rVal = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
*BufferSize = lpCountryList->dwTotalSize;
*Buffer = (LPBYTE)MemAlloc(lpCountryList->dwTotalSize);
if (*Buffer == NULL)
{
*BufferSize = 0;
rVal = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
pLineCountryList = (PFAX_TAPI_LINECOUNTRY_LIST) *Buffer;
pLineCountryList->dwNumCountries = lpCountryList->dwNumCountries;
Offset = sizeof(FAX_TAPI_LINECOUNTRY_LIST);
pLineCountryList->LineCountryEntries = (PFAX_TAPI_LINECOUNTRY_ENTRY) ((LPBYTE) pLineCountryList + Offset);
// offset points to the end of the structure- beginning of the "string field"
Offset += (lpCountryList->dwNumCountries * sizeof(FAX_TAPI_LINECOUNTRY_ENTRY));
lpEntry = (LPLINECOUNTRYENTRY) // init array of entries
((PBYTE) lpCountryList + lpCountryList->dwCountryListOffset);
for (dwIndex=0; dwIndex < pLineCountryList->dwNumCountries; dwIndex++)
{
pLineCountryList->LineCountryEntries[dwIndex].dwCountryCode =
lpEntry[dwIndex].dwCountryCode;
pLineCountryList->LineCountryEntries[dwIndex].dwCountryID =
lpEntry[dwIndex].dwCountryID;
// copy Country names
if (lpEntry[dwIndex].dwCountryNameSize && lpEntry[dwIndex].dwCountryNameOffset)
{
pLineCountryList->LineCountryEntries[dwIndex].lpctstrCountryName =
(LPWSTR) ((LPBYTE) pLineCountryList + Offset);
Offset += lpEntry[dwIndex].dwCountryNameSize;
_tcscpy(
(LPWSTR)pLineCountryList->LineCountryEntries[dwIndex].lpctstrCountryName,
(LPWSTR) ((LPBYTE)lpCountryList + lpEntry[dwIndex].dwCountryNameOffset)
);
}
else
{
pLineCountryList->LineCountryEntries[dwIndex].lpctstrCountryName = NULL;
}
// copy LongDistanceRule
if (lpEntry[dwIndex].dwLongDistanceRuleSize && lpEntry[dwIndex].dwLongDistanceRuleOffset)
{
pLineCountryList->LineCountryEntries[dwIndex].lpctstrLongDistanceRule =
(LPWSTR) ((LPBYTE) pLineCountryList + Offset);
Offset += lpEntry[dwIndex].dwLongDistanceRuleSize;
_tcscpy(
(LPWSTR)pLineCountryList->LineCountryEntries[dwIndex].lpctstrLongDistanceRule,
(LPWSTR) ((LPBYTE)lpCountryList + lpEntry[dwIndex].dwLongDistanceRuleOffset)
);
}
else
{
pLineCountryList->LineCountryEntries[dwIndex].lpctstrLongDistanceRule = NULL;
}
}
for (dwIndex=0; dwIndex < pLineCountryList->dwNumCountries; dwIndex++)
{
if (pLineCountryList->LineCountryEntries[dwIndex].lpctstrCountryName)
{
pLineCountryList->LineCountryEntries[dwIndex].lpctstrCountryName =
(LPWSTR) ((ULONG_PTR)pLineCountryList->LineCountryEntries[dwIndex].lpctstrCountryName - (ULONG_PTR)pLineCountryList);
}
if (pLineCountryList->LineCountryEntries[dwIndex].lpctstrLongDistanceRule)
{
pLineCountryList->LineCountryEntries[dwIndex].lpctstrLongDistanceRule =
(LPWSTR) ((ULONG_PTR)pLineCountryList->LineCountryEntries[dwIndex].lpctstrLongDistanceRule - (ULONG_PTR)pLineCountryList);
}
}
pLineCountryList->LineCountryEntries =
(PFAX_TAPI_LINECOUNTRY_ENTRY) ((LPBYTE)pLineCountryList->LineCountryEntries -
(ULONG_PTR)pLineCountryList);
exit:
return rVal;
}
error_status_t
FAX_GetLoggingCategories(
IN handle_t hBinding,
OUT LPBYTE *Buffer,
OUT LPDWORD BufferSize,
OUT LPDWORD NumberCategories
)
{
BOOL fAccess;
DWORD Rval = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetLoggingCategories()"));
//
// Access check
//
Rval = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_CONFIG"));
return ERROR_ACCESS_DENIED;
}
Assert (BufferSize && NumberCategories); // ref pointer in idl
if (!Buffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
EnterCriticalSection( &g_CsConfig );
Rval = GetLoggingCategories(
(PFAX_LOG_CATEGORY*)Buffer,
BufferSize,
NumberCategories);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("GetLoggingCategories failed (ec: %ld)"),
Rval);
}
LeaveCriticalSection( &g_CsConfig );
return Rval;
}
error_status_t
FAX_SetLoggingCategories(
IN handle_t hBinding,
IN const LPBYTE Buffer,
IN DWORD BufferSize,
IN DWORD NumberCategories
)
{
REG_FAX_LOGGING FaxRegLogging;
DWORD i;
DWORD dwRes;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetLoggingCategories"));
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return dwRes;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_MANAGE_CONFIG"));
return ERROR_ACCESS_DENIED;
}
if (!Buffer || !BufferSize)
{
return ERROR_INVALID_PARAMETER;
}
FaxRegLogging.LoggingCount = NumberCategories;
FaxRegLogging.Logging = (PREG_CATEGORY) Buffer;
for (i = 0; i < FaxRegLogging.LoggingCount; i++)
{
LPWSTR lpwstrCategoryName;
LPWSTR lpcwstrString;
lpwstrCategoryName = (LPWSTR) FixupString(Buffer,FaxRegLogging.Logging[i].CategoryName);
//
// Verify that pointer+offset is in the buffer range
//
if ((BYTE*)lpwstrCategoryName >= ((BYTE*)Buffer + BufferSize) ||
(BYTE*)lpwstrCategoryName < (BYTE*)Buffer)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Input buffer is currupted on FAX_SetLoggingCategories.")
);
return ERROR_INVALID_PARAMETER;
}
//
// Make sure string ends within the buffer bounds
//
lpcwstrString = lpwstrCategoryName;
while (*lpcwstrString != TEXT('\0'))
{
lpcwstrString++;
if (lpcwstrString >= (LPCWSTR)((BYTE*)Buffer + BufferSize))
{
//
// Going to exceed structure - corrupted offset
//
return ERROR_INVALID_PARAMETER;
}
}
FaxRegLogging.Logging[i].CategoryName = lpwstrCategoryName;
}
//
// setup the data
//
EnterCriticalSection (&g_CsConfig);
//
// first change the registry so it sticks
//
if (!SetLoggingCategoriesRegistry( &FaxRegLogging ))
{
dwRes = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("SetLoggingCategoriesRegistry"),
dwRes);
LeaveCriticalSection (&g_CsConfig);
Assert (ERROR_SUCCESS != dwRes);
return dwRes;
}
//
// Now change the real time data that the server is using
//
dwRes = RefreshEventLog(&FaxRegLogging);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("RefreshEventLog"),
dwRes);
LeaveCriticalSection (&g_CsConfig);
Assert (ERROR_SUCCESS != dwRes);
return dwRes;
}
LeaveCriticalSection (&g_CsConfig);
// Create FAX_EVENT_EX
DWORD ec = CreateConfigEvent (FAX_CONFIG_TYPE_EVENTLOGS);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_EVENTLOGS) (ec: %lc)"),
ec);
}
return dwRes;
}
VOID
RPC_FAX_PORT_HANDLE_rundown(
IN HANDLE FaxPortHandle
)
{
PHANDLE_ENTRY pPortHandleEntry = (PHANDLE_ENTRY) FaxPortHandle;
DEBUG_FUNCTION_NAME(TEXT("RPC_FAX_PORT_HANDLE_rundown"));
EnterCriticalSection( &g_CsLine );
DebugPrintEx(
DEBUG_WRN,
TEXT("RPC_FAX_PORT_HANDLE_rundown() running for port handle 0x%08x"),
FaxPortHandle);
CloseFaxHandle( pPortHandleEntry );
LeaveCriticalSection( &g_CsLine );
}
//*************************************
//* Extended FAX API
//*************************************
//*************************************
//* Extended FAX API
//*************************************
//*********************************************************************************
//* Name: ValidateCopiedQueueFileName()
//* Author: OdedS
//* Date: Jan 23, 2002
//*********************************************************************************
//* DESCRIPTION:
//* Validates that the caller of FAX_SendDocumentEx provided personal cover page or body file name
//* that match the format of the file name generated by FAX_StartCopyToServer()
//* Prevents attackers from providing bogus file names
//* PARAMETERS:
//* [IN] lpcwstrFileName - Pointer to the file name
//*
//* [IN] fCovFile - TRUE if personal cover page, FALSE if body tif file
//* RETURN VALUE:
//* If the name is valid it returns TRUE.
//* If the name is not valid it returns FALSE.
//*********************************************************************************
BOOL
ValidateCopiedQueueFileName(
LPCWSTR lpcwstrFileName,
BOOL fCovFile
)
{
WCHAR wszFileName[21] = {0}; // The copied filename contains 16 hex digits '.' and 'tif' or 'cov' total of 20 chars.
WCHAR* pwchr;
Assert (lpcwstrFileName);
//
// Validate file name is in the right format
//
if (wcslen(lpcwstrFileName) > 20 || wcslen(lpcwstrFileName) < 5)
{
return FALSE;
}
wcsncpy (wszFileName, lpcwstrFileName, ARR_SIZE(wszFileName)-1);
pwchr = wcsrchr(wszFileName, L'.');
if (NULL == pwchr)
{
return FALSE;
}
*pwchr = L'\0';
pwchr++;
//
// compare file name extension
//
if (TRUE == fCovFile)
{
if (_wcsicmp(pwchr, FAX_COVER_PAGE_EXT_LETTERS))
{
//
// extension is other then "COV"
//
return FALSE;
}
}
else
{
if (_wcsicmp(pwchr, FAX_TIF_FILE_EXT))
{
//
// extension is other then "TIF"
//
return FALSE;
}
}
//
// Make sure the file name contains hex digits only
//
#define HEX_DIGITS TEXT("0123456789abcdefABCDEF")
if (NULL == _wcsspnp (wszFileName, HEX_DIGITS))
{
// only hex digits
return TRUE;
}
return FALSE;
}
//*********************************************************************************
//* Name: FAX_SendDocumentEx()
//* Author: Ronen Barenboim
//* Date: April 19, 1999
//*********************************************************************************
//* DESCRIPTION:
//* Server side implementation of FaxSendDocumentEx()
//* PARAMETERS:
//* [IN] handle_t hBinding
//* The RPC binding handle
//*
//* [IN] LPCWSTR lpcwstrBodyFileName
//* Short name to the fax bofy TIFF file in the SERVER machine queue
//* directory.
//*
//* [IN] LPCFAX_COVERPAGE_INFO_EXW lpcCoverPageInfo
//* Cover page information. This is never NULL.
//* if no cover page information is available then
//* lpcCoverPageInfo->lptstrCoverPageFileName is NULL.
//* If coverpage information is specified it must point to the coverpage
//* template file on the server.
//*
//* [IN] LPCFAX_PERSONAL_PROFILEW lpcSenderProfile
//* Pointer to Sender personal
//*
//* [IN] DWORD dwNumRecipients
//* The number of recipients.
//*
//* [IN] LPCFAX_PERSONAL_PROFILEW lpcRecipientList
//* Pointer to Recipient Profiles array
//*
//* [IN] LPCFAX_JOB_PARAM_EXW lpcJobParams
//* Pointer to job parameters.
//*
//* [OUT] LPDWORD lpdwJobId
//* Pointer to a DWORD where the function will return the
//* recipient job session ID (only one recipient) -
//* Used for backwords competability with FaxSendDocument.
//* If this parameter is NULL it is ignored.
//*
//*
//* [OUT] PDWORDLONG lpdwlParentJobId
//* Pointer to a DWORDLONG where the function will return the parent
//* job id.
//* [OUT] PDWORDLONG lpdwlRecipientIds
//* Pointer to a DWORDLONG array (dwNumRecipients elemetns)
//* where the function will return the recipient jobs' unique ids.
//*
//* RETURN VALUE:
//* If the function is successful it returns ERROR_SUCCESS.
//* If the function is not successful it returns the LastError code
//* that caused the error.
//*********************************************************************************
error_status_t FAX_SendDocumentEx(
handle_t hBinding,
LPCWSTR lpcwstrBodyFileName,
LPCFAX_COVERPAGE_INFO_EXW lpcCoverPageInfo,
LPCFAX_PERSONAL_PROFILEW lpcSenderProfile,
DWORD dwNumRecipients,
LPCFAX_PERSONAL_PROFILEW lpcRecipientList,
LPCFAX_JOB_PARAM_EXW lpcJobParams,
LPDWORD lpdwJobId,
PDWORDLONG lpdwlParentJobId,
PDWORDLONG lpdwlRecipientIds
)
{
DWORD i;
LPWSTR lpwstrUserName = NULL;
LPWSTR lpwstrUserSid = NULL;
error_status_t ulRet=0;
PJOB_QUEUE lpParentJob = NULL;
PJOB_QUEUE lpRecipientJob;
error_status_t rc;
DEBUG_FUNCTION_NAME(TEXT("FAX_SendDocumentEx"));
WCHAR szBodyPath[MAX_PATH] = {0};
LPTSTR lptstrFixedBodyPath=NULL; // The full path to the location of the body TIFF.
// NULL if no body specified.
FAX_COVERPAGE_INFO_EXW newCoverInfo;
WCHAR szCoverPagePath[MAX_PATH] = {0};
LPCFAX_COVERPAGE_INFO_EXW lpcFinalCoverInfo;
DWORD dwQueueState;
PSID lpUserSid = NULL;
ACCESS_MASK AccessMask = 0;
BOOL fAccess;
LPTSTR lptstrClientName = NULL;
int Count;
if (!dwNumRecipients ||
!lpcSenderProfile ||
!lpcRecipientList ||
!lpcJobParams ||
!lpdwlParentJobId ||
!lpdwlRecipientIds ||
!lpcCoverPageInfo) // unique pointers in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Verify the body filename is in the expected format I64x.tif
//
if (lpcwstrBodyFileName)
{
if (!ValidateCopiedQueueFileName(lpcwstrBodyFileName, FALSE)) // FALSE - TIF file
{
DebugPrintEx(
DEBUG_ERR,
TEXT("ValidateCopiedQueueFileName Failed, body file name in the wrong format"));
return ERROR_INVALID_PARAMETER; // Must not go to Error, where the file is deleted. can lead to a deletion of a wrong file
}
}
//
// Verify the personal cover page filename is in the expected format I64x.cov
//
if (lpcCoverPageInfo->lptstrCoverPageFileName && !lpcCoverPageInfo->bServerBased)
{
if (!ValidateCopiedQueueFileName(lpcCoverPageInfo->lptstrCoverPageFileName, TRUE)) // TRUE - COV file
{
DebugPrintEx(
DEBUG_ERR,
TEXT("ValidateCopiedQueueFileName Failed, personal cover page in the wrong name format"));
return ERROR_INVALID_PARAMETER;
}
}
//
//Get the user SID
//
lpUserSid = GetClientUserSID();
if (lpUserSid == NULL)
{
rc = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid Failed, Error : %ld"),
rc);
return rc;
}
if (!ConvertSidToStringSid (lpUserSid, &lpwstrUserSid))
{
rc = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("ConvertSidToStringSid Failed, error : %ld"),
rc);
MemFree(lpUserSid);
return rc;
}
//
// Only After file name validation, and getting the user string SID,
// we can safely goto Error, and delete the files that were copied to the queue in FAX_StartCopyToServer()
//
//
// Check the recipients limit of a single broadcast job
//
if (0 != g_dwRecipientsLimit && // The Administrator set a limit
dwNumRecipients > g_dwRecipientsLimit)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Recipient limit reached. Recipient count:%ld. Recipient limit:%ld."),
dwNumRecipients,
g_dwRecipientsLimit
);
if (FAX_API_VERSION_2 > FindClientAPIVersion (hBinding))
{
//
// API versions 0,1 clients don't know about FAX_ERR_RECIPIENTS_LIMIT
//
rc = ERROR_ACCESS_DENIED;
goto Error;
}
else
{
rc = FAX_ERR_RECIPIENTS_LIMIT;
goto Error;
}
}
//
// Save the original receipt delivery address.
// If the receipt delivry type is DRT_MSGBOX we change lpcJobParams->lptstrReceiptDeliveryAddress
// but must restore it to its previous value before the function returns so that RPC allocations
// keep working.
//
LPTSTR lptrstOriginalReceiptDeliveryAddress = lpcJobParams->lptstrReceiptDeliveryAddress;
if (lpcJobParams->hCall != 0 ||
0xFFFF1234 == lpcJobParams->dwReserved[0])
{
//
// Handoff is not supported
//
DebugPrintEx(DEBUG_ERR,TEXT("We do not support handoff."));
rc = ERROR_NOT_SUPPORTED;
goto Error;
}
//
// Access check
//
switch (lpcJobParams->Priority)
{
case FAX_PRIORITY_TYPE_LOW:
AccessMask = FAX_ACCESS_SUBMIT;
break;
case FAX_PRIORITY_TYPE_NORMAL:
AccessMask = FAX_ACCESS_SUBMIT_NORMAL;
break;
case FAX_PRIORITY_TYPE_HIGH:
AccessMask = FAX_ACCESS_SUBMIT_HIGH;
break;
default:
ASSERT_FALSE;
}
if (0 == AccessMask)
{
DebugPrintEx(DEBUG_ERR,
TEXT("Not a valid priority, (priority = %ld"),
lpcJobParams->Priority);
rc = ERROR_INVALID_PARAMETER;
goto Error;
}
rc = FaxSvcAccessCheck (AccessMask, &fAccess, NULL);
if (ERROR_SUCCESS != rc)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
ulRet);
goto Error;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to submit the fax"));
rc = ERROR_ACCESS_DENIED;
goto Error;
}
//
// Check if the requrested receipts options are supported by the server
//
if ((lpcJobParams->dwReceiptDeliveryType) & ~(DRT_ALL | DRT_MODIFIERS))
{
DebugPrintEx(DEBUG_ERR,
TEXT("ReceiptDeliveryType invalid (%ld)"),
lpcJobParams->dwReceiptDeliveryType);
rc = ERROR_INVALID_PARAMETER;
goto Error;
}
DWORD dwReceiptDeliveryType = (lpcJobParams->dwReceiptDeliveryType) & ~DRT_MODIFIERS;
if ((DRT_EMAIL != dwReceiptDeliveryType) &&
(DRT_MSGBOX != dwReceiptDeliveryType) &&
(DRT_NONE != dwReceiptDeliveryType)
)
{
DebugPrintEx(DEBUG_ERR,
TEXT("ReceiptDeliveryType invalid (%ld)"),
lpcJobParams->dwReceiptDeliveryType);
rc = ERROR_INVALID_PARAMETER;
goto Error;
}
if ((DRT_NONE != dwReceiptDeliveryType) &&
!(dwReceiptDeliveryType & g_ReceiptsConfig.dwAllowedReceipts))
{
DebugPrintEx(DEBUG_ERR,
TEXT("ReceiptDeliveryType not supported by the server (%ld)"),
lpcJobParams->dwReceiptDeliveryType);
rc = ERROR_UNSUPPORTED_TYPE;
goto Error;
}
if (!IsFaxShared())
{
//
// Only local connections are allowed on non-shared SKUs
//
BOOL bLocalFlag;
rc = IsLocalRPCConnectionNP(&bLocalFlag);
if ( rc != RPC_S_OK )
{
DebugPrintEx(DEBUG_ERR,
TEXT("IsLocalRPCConnectionNP failed. (ec: %ld)"),
rc);
goto Error;
}
if( !bLocalFlag )
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Desktop SKUs do not share fax printers. FAX_SendDocumentEX is available for local clients only"));
if (FAX_API_VERSION_1 > FindClientAPIVersion (hBinding))
{
//
// API version 0 clients don't know about FAX_ERR_NOT_SUPPORTED_ON_THIS_SKU
//
rc = ERROR_INVALID_PARAMETER;
}
else
{
rc = FAX_ERR_NOT_SUPPORTED_ON_THIS_SKU;
}
goto Error;
}
}
if (DRT_MSGBOX == dwReceiptDeliveryType)
{
//
// For message boxes, we always use the user name of the client.
// Otherwise, any client with fax capabilities can ask us to pop a message on
// any other machine (or even the entire domain) - unacceptable.
//
lptstrClientName = GetClientUserName();
if (!lptstrClientName)
{
rc = GetLastError ();
goto Error;
}
LPWSTR lpwstrUserStart = wcsrchr (lptstrClientName, TEXT('\\'));
if (lpwstrUserStart)
{
//
// User name is indeed composed of domain\user
// Need to take only the user part.
//
//
// Skip the '/' character
//
lpwstrUserStart++;
LPWSTR lpwstrUserOnly = StringDup(lpwstrUserStart);
if (!lpwstrUserOnly)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("StringDup failed"));
rc = ERROR_NOT_ENOUGH_MEMORY;
goto Error;
}
//
// Replace the allocated "domain\user" string with its "user" portion only.
//
lstrcpy (lptstrClientName, lpwstrUserOnly);
MemFree(lpwstrUserOnly);
}
//
// Replace the receipt delivery address with the client machine name.
// NOTICE: We replace an RPC allocated buffer (lptstrReceiptDeliveryAddress) with
// a stack buffer (wszClientName). This will only work because RPC does a single allocation
// for the entire parameter block (lpcJobParams) with all of its sub-strings.
//
(LPTSTR)lpcJobParams->lptstrReceiptDeliveryAddress = lptstrClientName;
}
EnterCriticalSection (&g_CsConfig);
dwQueueState = g_dwQueueState;
LeaveCriticalSection (&g_CsConfig);
if (dwQueueState & FAX_OUTBOX_BLOCKED)
{
//
// The outbox is blocked - nobody can submit new faxes
//
DebugPrintEx(
DEBUG_ERR,
TEXT("Attempt to submit a new job while outbox is blocked - access denied"));
rc = ERROR_WRITE_PROTECT;
goto Error;
}
//
// Get the user name of the submitting user
//
lpwstrUserName = GetClientUserName();
if (!lpwstrUserName) {
rc = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("GetClientUserName() failed. (ec: %ld)"),
rc);
goto Error;
}
if (lpcwstrBodyFileName)
{
HANDLE hLocalFile = INVALID_HANDLE_VALUE;
//
// We have a body file (not just a cover page).
// create a full path to the body file (The lptstrBodyFileName is just the short file name - the location
// is allways the job queue).
Count = _snwprintf (szBodyPath,
MAX_PATH -1,
L"%s\\%s%s%s",
g_wszFaxQueueDir,
lpwstrUserSid,
TEXT("$"),
lpcwstrBodyFileName);
if (Count < 0)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("_snwprintf Failed, File name bigger than MAX_PATH"));
rc = ERROR_BUFFER_OVERFLOW;
goto Error;
}
DebugPrintEx(DEBUG_MSG,TEXT("Body file is: %ws"),szBodyPath);
lptstrFixedBodyPath=szBodyPath;
//
// Check file size is non-zero and make sure it is not a device
// Try to open file
//
hLocalFile = SafeCreateFile (
szBodyPath,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if ( INVALID_HANDLE_VALUE == hLocalFile )
{
rc = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("Opening %s for read failed (ec: %ld)"),
szBodyPath,
rc);
goto Error;
}
DWORD dwFileSize = GetFileSize (hLocalFile, NULL);
if (INVALID_FILE_SIZE == dwFileSize)
{
rc = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("GetFileSize failed (ec: %ld)"),
rc);
CloseHandle (hLocalFile);
goto Error;
}
if (!CloseHandle (hLocalFile))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CloseHandle failed (ec: %ld)"),
GetLastError());
}
if (!dwFileSize)
{
//
// Zero-sized file passed to us
//
rc = ERROR_INVALID_DATA;
goto Error;
}
//
// validate the body tiff file
//
rc = ValidateTiffFile(szBodyPath);
if (rc != ERROR_SUCCESS)
{
DebugPrintEx(DEBUG_ERR,TEXT("ValidateTiffFile of body file %ws failed (ec: %ld)."), szBodyPath,rc);
goto Error;
}
}
else
{
lptstrFixedBodyPath=NULL; // No body
}
//
// NOTE: we do not merge the cover page with body at this point since we do not know yet if
// the job will be handed of to legacy FSP. Just before handing the job to a legacy FSP we will
// render the cover page and merge it with the body that the Legacy FSP gets.
//
//
// Fix the cover page path to point to the queue directory
//
lpcFinalCoverInfo=lpcCoverPageInfo;
if (lpcCoverPageInfo->lptstrCoverPageFileName)
{
if (!lpcCoverPageInfo->bServerBased)
{
Count = _snwprintf (szCoverPagePath,
MAX_PATH -1,
L"%s\\%s%s%s",
g_wszFaxQueueDir,
lpwstrUserSid,
TEXT("$"),
lpcCoverPageInfo->lptstrCoverPageFileName);
if (Count < 0)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("_snwprintf Failed, File name bigger than MAX_PATH"));
rc = ERROR_BUFFER_OVERFLOW;
goto Error;
}
memcpy((LPVOID)&newCoverInfo,(LPVOID)lpcCoverPageInfo,sizeof(FAX_COVERPAGE_INFO_EXW));
newCoverInfo.lptstrCoverPageFileName=szCoverPagePath;
lpcFinalCoverInfo=&newCoverInfo;
DebugPrintEx(DEBUG_MSG,TEXT("Using personal cover file page at : %ws"),newCoverInfo.lptstrCoverPageFileName);
}
}
//
// Create a parent job for the broadcast
//
EnterCriticalSection(&g_CsQueue);
lpParentJob=AddParentJob( &g_QueueListHead,
lptstrFixedBodyPath,
lpcSenderProfile,
lpcJobParams,
lpcFinalCoverInfo,
lpwstrUserName,
lpUserSid,
&lpcRecipientList[0],
TRUE //commit to file
);
if (!lpParentJob)
{
rc = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to create parent job (ec: %ld)."),
rc);
LeaveCriticalSection(&g_CsQueue);
goto Error;
}
for (i=0;i<dwNumRecipients;i++)
{
lpRecipientJob=AddRecipientJob(
&g_QueueListHead,
lpParentJob,
&lpcRecipientList[i],
TRUE // commit to file
);
if (!lpRecipientJob)
{
rc = GetLastError();
// Remove the job and its recipients jobs
PLIST_ENTRY Next;
PJOB_QUEUE_PTR pJobQueuePtr;
Next = lpParentJob->RecipientJobs.Flink;
while ((ULONG_PTR)Next != (ULONG_PTR)&lpParentJob->RecipientJobs)
{
pJobQueuePtr = CONTAINING_RECORD( Next, JOB_QUEUE_PTR, ListEntry );
Assert(pJobQueuePtr->lpJob);
Next = pJobQueuePtr->ListEntry.Flink;
pJobQueuePtr->lpJob->RefCount = 0; // This will cause the job to be deleted
Assert(lpParentJob->RefCount);
lpParentJob->RefCount--; // Update the parent job ref count, so it will be deleted as well.
}
RemoveParentJob ( lpParentJob,
TRUE, // bRemoveRecipientJobs
FALSE // do not notify
);
LeaveCriticalSection(&g_CsQueue);
goto Error;
}
lpdwlRecipientIds[i]=lpRecipientJob->UniqueId;
}
//
// Report back the parent job id.
//
*lpdwlParentJobId=lpParentJob->UniqueId;
//
// Create event, and Report back the first recipient job session id if needed.
//
PLIST_ENTRY Next;
PJOB_QUEUE_PTR pJobQueuePtr;
Next = lpParentJob->RecipientJobs.Flink;
for (i = 0; i < dwNumRecipients; i++)
{
pJobQueuePtr = CONTAINING_RECORD( Next, JOB_QUEUE_PTR, ListEntry );
PJOB_QUEUE pJobQueueRecipient = pJobQueuePtr->lpJob;
if (i == 0 && NULL != lpdwJobId)
{
// Report back the first recipient job session id if needed.
Assert (1 == dwNumRecipients);
*lpdwJobId = pJobQueueRecipient->JobId;
}
rc = CreateQueueEvent ( FAX_JOB_EVENT_TYPE_ADDED,
pJobQueueRecipient
);
if (ERROR_SUCCESS != rc)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateQueueEvent(FAX_JOB_EVENT_TYPE_ADDED) failed for job id %ld (ec: %lc)"),
pJobQueueRecipient->UniqueId,
rc);
}
if (!CreateFaxEvent(0, FEI_JOB_QUEUED, pJobQueueRecipient->JobId ))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to generate FEI_JOB_QUEUED for JobId: %ld"),
pJobQueueRecipient->JobId);
}
Next = pJobQueuePtr->ListEntry.Flink;
// Check the consistency of the linked list.
Assert ((Next != lpParentJob->RecipientJobs.Flink) || (i == dwNumRecipients));
}
//
// Notify legacy clients on parent job addition.
//
if (dwNumRecipients > 1)
{
//
// Legacy client API generated a parent FEI_JOB_QUEUED notification only for broadcast
// jobs
if (!CreateFaxEvent(0,FEI_JOB_QUEUED,lpParentJob->JobId)) {
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateFaxEvent(FEI_JOB_QUEUED) failed for job id %ld (ec: %lc)"),
lpParentJob->JobId,
GetLastError());
}
}
PrintJobQueue(_T(""),&g_QueueListHead);
LeaveCriticalSection(&g_CsQueue);
if (!StartJobQueueTimer())
{
DebugPrintEx(
DEBUG_ERR,
TEXT("StartJobQueueTimer() failed. (ec: %ld)"),
GetLastError());
}
rc=ERROR_SUCCESS;
goto Exit;
Error:
//
// If we failed before AddParentJob() was called and the cover page is personal then
// we need to delete the cover page template file here. This is because RemoveParentJob() will
// not be called and will not have a chance to remove it as is the case when the parent job
// is added to the queue.
Assert (lpwstrUserSid);
if (lpcCoverPageInfo &&
!lpParentJob &&
!lpcCoverPageInfo->bServerBased &&
lpcCoverPageInfo->lptstrCoverPageFileName
)
{
DebugPrintEx(
DEBUG_MSG,
TEXT("Deleting cover page template %s"),
lpcCoverPageInfo->lptstrCoverPageFileName);
if (0 == wcslen(szCoverPagePath))
{
Count = _snwprintf (szCoverPagePath,
MAX_PATH -1,
L"%s\\%s%s%s",
g_wszFaxQueueDir,
lpwstrUserSid,
TEXT("$"),
lpcCoverPageInfo->lptstrCoverPageFileName);
if (Count < 0)
{
DebugPrintEx(DEBUG_ERR,
_T("_snwprintf Failed, File name bigger than MAX_PATH"));
}
}
if (!DeleteFile(szCoverPagePath))
{
DebugPrintEx(DEBUG_ERR,
_T("Failed to delete cover page template %s (ec: %ld)"),
lpcCoverPageInfo->lptstrCoverPageFileName,
GetLastError());
}
}
//
// The same regarding the body Tiff file.
//
if (lpcwstrBodyFileName && !lpParentJob)
{
if (!lptstrFixedBodyPath)
{
//
// We haven't yet created full body file path
//
Count = _snwprintf (szBodyPath,
MAX_PATH -1,
L"%s\\%s%s%s",
g_wszFaxQueueDir,
lpwstrUserSid,
TEXT("$"),
lpcwstrBodyFileName);
if (Count < 0)
{
DebugPrintEx(DEBUG_ERR,
_T("_snwprintf Failed, File name bigger than MAX_PATH"));
}
DebugPrintEx(DEBUG_MSG,TEXT("Body file is: %ws"),szBodyPath);
lptstrFixedBodyPath = szBodyPath;
}
DebugPrintEx(DEBUG_MSG,
_T("Deleting body tiff file %s"),
lptstrFixedBodyPath);
if (!DeleteFile(lptstrFixedBodyPath))
{
DebugPrintEx(DEBUG_ERR,
TEXT("Failed to delete body tiff file %s (ec: %ld)"),
lptstrFixedBodyPath,
GetLastError());
}
}
Exit:
if (lptrstOriginalReceiptDeliveryAddress != lpcJobParams->lptstrReceiptDeliveryAddress)
{
//
// Restore the original receipt delivery address.
// If the receipt delivry type is DRT_MSGBOX we changed lpcJobParams->lptstrReceiptDeliveryAddress
// but must restore it to its previous value before the function returns so that RPC allocations
// keep working.
//
(LPTSTR)lpcJobParams->lptstrReceiptDeliveryAddress = lptrstOriginalReceiptDeliveryAddress;
}
MemFree(lpwstrUserName);
MemFree(lpUserSid);
MemFree(lptstrClientName);
if (NULL != lpwstrUserSid)
{
LocalFree(lpwstrUserSid);
}
return rc;
} // FAX_SendDocumentEx
#ifdef DBG
void DumpJobParamsEx(LPCFAX_JOB_PARAM_EX lpcParams)
{
TCHAR szSchedule[1024];
SystemTimeToStr(&lpcParams->tmSchedule, szSchedule, ARR_SIZE(szSchedule));
DebugPrint((TEXT("\tdwSizeOfStruct: %ld"),lpcParams->dwSizeOfStruct));
DebugPrint((TEXT("\tdwScheduleAction: %ld"),lpcParams->dwScheduleAction));
DebugPrint((TEXT("\ttmSchedule: %s "),szSchedule));
DebugPrint((TEXT("\tdwReceiptDeliveryType: %ld "),lpcParams->dwReceiptDeliveryType));
DebugPrint((TEXT("\tlptstrReceiptDeliveryAddress: %s "),lpcParams->lptstrReceiptDeliveryAddress));
DebugPrint((TEXT("\tPriority %ld "),lpcParams->Priority));
DebugPrint((TEXT("\thCall: 0x%08X"),lpcParams->hCall));
DebugPrint((TEXT("\tlptstrDocumentName: %s"),lpcParams->lptstrDocumentName));
DebugPrint((TEXT("\tdwPageCount: %ld"),lpcParams->dwPageCount));
DebugPrint((TEXT("\tdwReserved[0]: 0x%08X"),lpcParams->dwReserved[0]));
DebugPrint((TEXT("\tdwReserved[1]: 0x%08X"),lpcParams->dwReserved[1]));
DebugPrint((TEXT("\tdwReserved[2]: 0x%08X"),lpcParams->dwReserved[2]));
DebugPrint((TEXT("\tdwReserved[3]: 0x%08X"),lpcParams->dwReserved[3]));
}
void DumpCoverPageEx(LPCFAX_COVERPAGE_INFO_EX lpcCover)
{
DebugPrint((TEXT("\tdwSizeOfStruct: %ld"),lpcCover->dwSizeOfStruct));
DebugPrint((TEXT("\tdwCoverPageFormat: %ld"),lpcCover->dwCoverPageFormat));
DebugPrint((TEXT("\tlptstrCoverPageFileName: %s "),lpcCover->lptstrCoverPageFileName));
DebugPrint((TEXT("\tbServerBased: %s "), lpcCover->bServerBased ? TEXT("TRUE") : TEXT("FALSE")));
DebugPrint((TEXT("\tlptstrNote: %s "),lpcCover->lptstrNote));
DebugPrint((TEXT("\tlptstrSubject: %s"),lpcCover->lptstrSubject));
}
#endif
//*********************************************************************************
//* Name: FAX_GetPersonalProfileInfo()
//* Author: Oded Sacher
//* Date: May 18, 1999
//*********************************************************************************
//* DESCRIPTION:
//* Server side implementation of FaxGetSenderInfo() and FaxGetRecipientInfo
//* PARAMETERS:
//* [IN] handle_t hFaxHandle
//* The RPC binding handle
//*
//* [IN] DWORDLONF dwlMessageId
//* The message Id whose sender FAX_PERSONAL_PROFILE
//* structure is retrieved.
//*
//* [IN] DWORD dwFolder
//* The folder in which to search the message by dwlMessageId
//*
//* [IN] PERSONAL_PROF_TYPE ProfType
//* Can be Sender or recipient info.
//*
//* [OUT] LPDWORD* Buffer
//* pointer to the adress of a buffer to recieve the sender
//* FAX_RECIPIENT_JOB_INFO structure.
//*
//* [OUT] LPDWORD BufferSize
//* Pointer to a DWORD variable to recieve the buffer size.
//*
//* RETURN VALUE:
//* ERROR_SUCCESS for success, otherwise a WIN32 error code.
//*
//*********************************************************************************
error_status_t
FAX_GetPersonalProfileInfo
(
IN handle_t hFaxHandle,
IN DWORDLONG dwlMessageId,
IN FAX_ENUM_MESSAGE_FOLDER dwFolder,
IN FAX_ENUM_PERSONAL_PROF_TYPES ProfType,
OUT LPBYTE *Buffer,
OUT LPDWORD BufferSize
)
{
PFAX_PERSONAL_PROFILEW lpPersonalProf;
FAX_PERSONAL_PROFILEW PersonalProf;
PJOB_QUEUE pJobQueue;
ULONG_PTR Size = 0;
ULONG_PTR Offset;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetPersonalProfileInfo"));
error_status_t ulRet = ERROR_SUCCESS;
BOOL bAllMessages = FALSE;
LPWSTR lpwstrFileName = NULL;
BOOL bFreeSenderInfo = FALSE;
PSID pUserSid = NULL;
BOOL fAccess;
DWORD dwRights;
Assert (BufferSize); // ref pointer in idl
if (!Buffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
if (dwFolder != FAX_MESSAGE_FOLDER_QUEUE &&
dwFolder != FAX_MESSAGE_FOLDER_SENTITEMS)
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
ulRet = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != ulRet)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
ulRet);
return GetServerErrorCode(ulRet);
}
//
// Set bAllMessages to the right value
//
if (FAX_MESSAGE_FOLDER_QUEUE == dwFolder)
{
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_JOBS != (dwRights & FAX_ACCESS_QUERY_JOBS))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to get personal profile of queued jobs"));
return ERROR_ACCESS_DENIED;
}
if (FAX_ACCESS_QUERY_JOBS == (dwRights & FAX_ACCESS_QUERY_JOBS))
{
bAllMessages = TRUE;
}
}
else
{
Assert (FAX_MESSAGE_FOLDER_SENTITEMS == dwFolder);
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_OUT_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to get personal profile of archived (sent items) messages"));
return ERROR_ACCESS_DENIED;
}
if (FAX_ACCESS_QUERY_OUT_ARCHIVE == (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
bAllMessages = TRUE;
}
}
if (FALSE == bAllMessages)
{
pUserSid = GetClientUserSID();
if (NULL == pUserSid)
{
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid failed, Error %ld"), ulRet);
return GetServerErrorCode(ulRet);
}
}
DebugPrintEx(DEBUG_MSG,TEXT("Before Enter g_CsJob & Queue"));
EnterCriticalSectionJobAndQueue;
DebugPrintEx(DEBUG_MSG,TEXT("After Enter g_CsJob & Queue"));
if (FAX_MESSAGE_FOLDER_QUEUE == dwFolder)
{
pJobQueue = FindJobQueueEntryByUniqueId (dwlMessageId);
if (pJobQueue == NULL || pJobQueue->JobType != JT_SEND)
{
//
// dwlMessageId is not a valid queued recipient job Id.
//
DebugPrintEx(DEBUG_ERR,TEXT("Invalid Parameter - not a recipient job Id"));
ulRet = FAX_ERR_MESSAGE_NOT_FOUND;
goto Exit;
}
Assert (pJobQueue->lpParentJob);
if (pJobQueue->lpParentJob->JobStatus == JS_DELETING)
{
//
// Job is being deleted.
//
DebugPrintEx(DEBUG_ERR,
TEXT("Invalid Parameter - job Id (%I64ld) is being deleted"),
dwlMessageId);
ulRet = FAX_ERR_MESSAGE_NOT_FOUND;
goto Exit;
}
if (FALSE == bAllMessages)
{
if (!UserOwnsJob (pJobQueue, pUserSid))
{
DebugPrintEx(DEBUG_WRN,TEXT("UserOwnsJob failed ,Access denied"));
ulRet = ERROR_ACCESS_DENIED;
goto Exit;
}
}
if (SENDER_PERSONAL_PROF == ProfType)
{
lpPersonalProf = &(pJobQueue->lpParentJob->SenderProfile);
}
else
{
Assert (RECIPIENT_PERSONAL_PROF == ProfType);
lpPersonalProf = &(pJobQueue->RecipientProfile);
}
}
else
{ // Sent items Folder
if (TRUE == bAllMessages)
{
// Administrator
lpwstrFileName = GetSentMessageFileName (dwlMessageId, NULL);
}
else
{
// User
lpwstrFileName = GetSentMessageFileName (dwlMessageId, pUserSid);
}
if (NULL == lpwstrFileName)
{
//
// dwlMessageId is not a valid archived message Id.
//
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetMessageFileByUniqueId* failed, Error %ld"), ulRet);
goto Exit;
}
if (!GetPersonalProfNTFSStorageProperties (lpwstrFileName,
ProfType,
&PersonalProf))
{
BOOL success;
// failed to retrieve information from NTFS, try from TIFF tags
if(SENDER_PERSONAL_PROF == ProfType)
success = GetFaxSenderMsTags(lpwstrFileName, &PersonalProf);
else
success = GetFaxRecipientMsTags(lpwstrFileName, &PersonalProf);
if(!success) {
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("failed to get PersonalProf from TIFF, error %ld"),
ulRet);
goto Exit;
}
}
lpPersonalProf = &PersonalProf;
bFreeSenderInfo = TRUE;
}
//
//calculating buffer size.
//
PersonalProfileSerialize (lpPersonalProf, NULL, NULL, &Size, 0); // Calc variable size.
Size += sizeof (FAX_PERSONAL_PROFILEW);
//
// Allocate buffer memory.
//
*BufferSize = Size;
*Buffer = (LPBYTE) MemAlloc( Size );
if (*Buffer == NULL)
{
DebugPrintEx(DEBUG_ERR,TEXT("ERROR_NOT_ENOUGH_MEMORY (Server)"));
ulRet = ERROR_NOT_ENOUGH_MEMORY;
goto Exit;
}
Offset = sizeof (FAX_PERSONAL_PROFILEW);
if( FALSE == PersonalProfileSerialize ( lpPersonalProf,
(PFAX_PERSONAL_PROFILEW)*Buffer,
*Buffer,
&Offset,
Size))
{
Assert(FALSE);
DebugPrintEx(DEBUG_ERR,
TEXT("PersonalProfileSerialize failed, insufficient buffer size"));
}
Assert (ERROR_SUCCESS == ulRet);
Exit:
LeaveCriticalSectionJobAndQueue;
DebugPrintEx(DEBUG_MSG,TEXT("After Release g_CsJob & g_CsQueue"));
if (NULL != lpwstrFileName)
{
MemFree (lpwstrFileName);
}
if (NULL != pUserSid)
{
MemFree (pUserSid);
}
if (TRUE == bFreeSenderInfo)
{
FreePersonalProfile (&PersonalProf, FALSE);
}
UNREFERENCED_PARAMETER (hFaxHandle);
return GetServerErrorCode(ulRet);
}
error_status_t
FAX_CheckServerProtSeq(
IN handle_t hFaxServer,
IN OUT LPDWORD lpdwProtSeq
)
{
//
// This function is obsolete. The Fax server sends notifications with ncacn_ip_tcp.
//
DEBUG_FUNCTION_NAME(TEXT("FAX_CheckServerProtSeq"));
DWORD dwRights;
BOOL fAccess;
DWORD Rval = ERROR_SUCCESS;
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
//
// This function is obsolete. The Fax server sends notifications with ncacn_ip_tcp.
//
return ERROR_NOT_SUPPORTED;
}
//************************************
//* Getting / Settings the queue state
//************************************
error_status_t
FAX_GetQueueStates (
IN handle_t hFaxHandle,
OUT LPDWORD pdwQueueStates
)
/*++
Routine name : FAX_GetQueueStates
Routine description:
Get the state of the queue
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
pdwQueueStates [out] - State bits (see FAX_QUEUE_STATE)
Return Value:
Standard RPC error codes
--*/
{
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
DWORD dwRights;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetQueueStates"));
if (NULL == pdwQueueStates)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FAX_GetQueueStates() received an invalid pointer"));
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return dwRes;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
EnterCriticalSection (&g_CsConfig);
*pdwQueueStates = g_dwQueueState;
LeaveCriticalSection (&g_CsConfig);
return dwRes;
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetQueueStates
static BOOL
IsLegalQueueSetting(
DWORD dwQueueStates
)
/*++
Routine name : IsLegalQueueSetting
Routine description:
Checks to see if requested queue setting is valid according to the
validity of fax folders (Queue, inbox and sentItems).
This function must be called within g_CsQueue & g_CsConfig critical sections
Author:
Caliv Nir, (t-nicali), Apr 2002
Arguments:
dwQueueStates [in ] - State bits (see FAX_ENUM_QUEUE_STATE)
Return Value:
TRUE - if the setting is valid, FALSE otherwise
--*/
{
DWORD dwRes = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("IsLegalQueueSetting"));
if ( (dwQueueStates & FAX_INCOMING_BLOCKED) &&
(dwQueueStates & FAX_OUTBOX_BLOCKED) &&
(dwQueueStates & FAX_OUTBOX_PAUSED) )
{
//
// User wants to disable all fax transmission
//
return TRUE;
}
//
// first check to see if queue folder is valid
//
dwRes = IsValidFaxFolder(g_wszFaxQueueDir);
if(ERROR_SUCCESS != dwRes)
{
//
// Queue folder is invalid - User can't resume queue, unblock incoming or outgoing faxs
//
DebugPrintEx(DEBUG_ERR,
TEXT("IsValidFaxFolder failed for folder : %s (ec=%lu)."),
g_wszFaxQueueDir,
dwRes);
SetLastError(dwRes);
return FALSE;
}
//
// if inbox folder is in use
//
if (g_ArchivesConfig[FAX_MESSAGE_FOLDER_INBOX].bUseArchive)
{
//
// Check to see if the user requested to unblock it
//
if (!(dwQueueStates & FAX_INCOMING_BLOCKED))
{
//
// Is it valid folder ?
//
dwRes = IsValidArchiveFolder(g_ArchivesConfig[FAX_MESSAGE_FOLDER_INBOX].lpcstrFolder, FAX_MESSAGE_FOLDER_INBOX);
if(ERROR_SUCCESS != dwRes)
{
//
// Inbox folder is invalid - User can't resume queue, unblock incoming or outgoing faxs
//
DebugPrintEx(DEBUG_ERR,
TEXT("IsValidArchiveFolder failed for folder : %s (ec=%lu)."),
g_ArchivesConfig[FAX_MESSAGE_FOLDER_INBOX].lpcstrFolder,
dwRes);
SetLastError(dwRes);
return FALSE;
}
}
}
//
// if sentItems folder is in use
//
if (g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].bUseArchive)
{
//
// Check to see if the user requested to unblock it
//
if (!(dwQueueStates & FAX_OUTBOX_BLOCKED))
{
//
// Is it valid folder ?
//
dwRes = IsValidArchiveFolder(g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].lpcstrFolder, FAX_MESSAGE_FOLDER_SENTITEMS);
if(ERROR_SUCCESS != dwRes)
{
//
// Sent items folder is invalid - User can't resume queue, unblock incoming or outgoing faxs
//
DebugPrintEx(DEBUG_ERR,
TEXT("IsValidFaxFolder failed for folder : %s (ec=%lu)."),
g_ArchivesConfig[FAX_MESSAGE_FOLDER_SENTITEMS].lpcstrFolder,
dwRes);
SetLastError(dwRes);
return FALSE;
}
}
}
return TRUE;
} // IsLegalQueueSetting
error_status_t
FAX_SetQueue (
IN handle_t hFaxHandle,
IN const DWORD dwQueueStates
)
/*++
Routine name : FAX_SetQueue
Routine description:
Set the state of the queue
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
dwQueueStates [in ] - State bits (see FAX_ENUM_QUEUE_STATE)
Return Value:
Standard RPC error codes
--*/
{
DWORD dwRes = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetQueue"));
DWORD rVal;
BOOL fAccess;
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return GetServerErrorCode(rVal);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_MANAGE_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
if (dwQueueStates & ~(FAX_INCOMING_BLOCKED | FAX_OUTBOX_BLOCKED | FAX_OUTBOX_PAUSED))
{
//
// Some invalid queue state specified
//
DebugPrintEx(
DEBUG_ERR,
TEXT("FAX_SetQueue() received a bad value. dwQueueStates = %ld"),
dwQueueStates);
return ERROR_INVALID_PARAMETER;
}
//
// Try to save new value
//
EnterCriticalSection (&g_CsQueue);
EnterCriticalSection (&g_CsConfig);
if ( (dwQueueStates & (FAX_INCOMING_BLOCKED | FAX_OUTBOX_BLOCKED | FAX_OUTBOX_PAUSED)) ==
(g_dwQueueState & (FAX_INCOMING_BLOCKED | FAX_OUTBOX_BLOCKED | FAX_OUTBOX_PAUSED)) )
{
//
// no change to queue state is needed.
//
dwRes = ERROR_SUCCESS;
goto exit;
}
if (!IsLegalQueueSetting(dwQueueStates))
{
if (FAX_API_VERSION_1 > FindClientAPIVersion (hFaxHandle))
{
dwRes = ERROR_ACCESS_DENIED;
}
else
{
dwRes = GetLastError();
dwRes = (FAX_ERR_DIRECTORY_IN_USE == dwRes) ? FAX_ERR_DIRECTORY_IN_USE : FAX_ERR_FILE_ACCESS_DENIED;
}
goto exit;
}
dwRes = SaveQueueState (dwQueueStates);
if (ERROR_SUCCESS != dwRes)
{
//
// Failed saving new value, return error code
//
DebugPrintEx(
DEBUG_ERR,
TEXT("FAX_SetQueue() failed to save the new state. dwRes = %ld"),
dwRes);
dwRes = ERROR_REGISTRY_CORRUPT;
goto exit;
}
//
// Apply new value
//
if (dwQueueStates & FAX_OUTBOX_PAUSED)
{
//
// User wished to pause the queue - do it
//
if (!PauseServerQueue())
{
DebugPrintEx(
DEBUG_ERR,
TEXT("PauseServerQueue failed."));
dwRes = RPC_E_SYS_CALL_FAILED;
//
// Restore old values
//
rVal = SaveQueueState (g_dwQueueState);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("SaveQueueState failed to save the new state. rVal = %ld"),
rVal);
}
goto exit;
}
}
else
{
//
// User wished to resume the queue - do it
//
if (!ResumeServerQueue())
{
DebugPrintEx(
DEBUG_ERR,
TEXT("ResumeServerQueue failed."));
dwRes = RPC_E_SYS_CALL_FAILED;
//
// Restore old values
//
rVal = SaveQueueState (g_dwQueueState);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("SaveQueueState failed to save the new state. rVal = %ld"),
rVal);
}
goto exit;
}
}
g_dwQueueState = dwQueueStates;
rVal = CreateQueueStateEvent (dwQueueStates);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateQueueStateEvent() failed (ec: %lc)"),
rVal);
}
Assert (ERROR_SUCCESS == dwRes);
exit:
LeaveCriticalSection (&g_CsConfig);
LeaveCriticalSection (&g_CsQueue);
return GetServerErrorCode(dwRes);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_SetQueue
//****************************************************
//* Getting / Settings the receipts configuration
//****************************************************
error_status_t
FAX_GetReceiptsConfiguration (
IN handle_t hFaxHandle,
OUT LPBYTE *pBuffer,
OUT LPDWORD pdwBufferSize
)
/*++
Routine name : FAX_GetReceiptsConfiguration
Routine description:
Gets the current receipts configuration
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
pBuffer [out] - Pointer to buffer to hold configuration information
pdwBufferSize [out] - Pointer to buffer size
Return Value:
Standard RPC error codes
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_GetReceiptsConfiguration"));
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
Assert (pdwBufferSize); // ref pointer in idl
if (!pBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_QUERY_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
//
// count up the number of bytes needed
//
*pdwBufferSize = sizeof(FAX_RECEIPTS_CONFIG);
ULONG_PTR Offset = sizeof(FAX_RECEIPTS_CONFIG);
PFAX_RECEIPTS_CONFIG pReceiptsConfig;
EnterCriticalSection (&g_CsConfig);
if (NULL != g_ReceiptsConfig.lptstrSMTPServer)
{
*pdwBufferSize += StringSize( g_ReceiptsConfig.lptstrSMTPServer );
}
if (NULL != g_ReceiptsConfig.lptstrSMTPFrom)
{
*pdwBufferSize += StringSize( g_ReceiptsConfig.lptstrSMTPFrom );
}
if (NULL != g_ReceiptsConfig.lptstrSMTPUserName)
{
*pdwBufferSize += StringSize( g_ReceiptsConfig.lptstrSMTPUserName );
}
*pBuffer = (LPBYTE)MemAlloc( *pdwBufferSize );
if (NULL == *pBuffer)
{
dwRes = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
pReceiptsConfig = (PFAX_RECEIPTS_CONFIG)*pBuffer;
pReceiptsConfig->dwSizeOfStruct = sizeof (FAX_RECEIPTS_CONFIG);
pReceiptsConfig->bIsToUseForMSRouteThroughEmailMethod = g_ReceiptsConfig.bIsToUseForMSRouteThroughEmailMethod;
pReceiptsConfig->dwSMTPPort = g_ReceiptsConfig.dwSMTPPort;
pReceiptsConfig->dwAllowedReceipts = g_ReceiptsConfig.dwAllowedReceipts;
pReceiptsConfig->SMTPAuthOption = g_ReceiptsConfig.SMTPAuthOption;
pReceiptsConfig->lptstrReserved = NULL;
StoreString(
g_ReceiptsConfig.lptstrSMTPServer,
(PULONG_PTR)&pReceiptsConfig->lptstrSMTPServer,
*pBuffer,
&Offset,
*pdwBufferSize
);
StoreString(
g_ReceiptsConfig.lptstrSMTPFrom,
(PULONG_PTR)&pReceiptsConfig->lptstrSMTPFrom,
*pBuffer,
&Offset,
*pdwBufferSize
);
StoreString(
g_ReceiptsConfig.lptstrSMTPUserName,
(PULONG_PTR)&pReceiptsConfig->lptstrSMTPUserName,
*pBuffer,
&Offset,
*pdwBufferSize
);
StoreString(
NULL, // We always return a NULL password string. Never transmit a password over the wire if
// you don't have to.
(PULONG_PTR)&pReceiptsConfig->lptstrSMTPPassword,
*pBuffer,
&Offset,
*pdwBufferSize
);
Assert (ERROR_SUCCESS == dwRes);
exit:
LeaveCriticalSection (&g_CsConfig);
return GetServerErrorCode(dwRes);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetReceiptsConfiguration
error_status_t
FAX_SetReceiptsConfiguration (
IN handle_t hFaxHandle,
IN const PFAX_RECEIPTS_CONFIG pReciptsCfg
)
/*++
Routine name : FAX_SetReceiptsConfiguration
Routine description:
Sets the current receipts configuration
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
pReciptsCfg [in ] - Pointer to new data to set
Return Value:
Standard RPC error codes
--*/
{
error_status_t rVal = ERROR_SUCCESS;
DWORD dwRes;
BOOL fAccess;
BOOL fIsAllowedEmailReceipts = FALSE;
BOOL fCloseToken = FALSE;
HKEY hReceiptsKey = NULL;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetReceiptsConfiguration"));
Assert (pReciptsCfg);
if (sizeof (FAX_RECEIPTS_CONFIG) != pReciptsCfg->dwSizeOfStruct)
{
//
// Size mismatch
//
return ERROR_INVALID_PARAMETER;
}
if ((pReciptsCfg->dwAllowedReceipts) & ~DRT_ALL)
{
//
// Receipts type is invalid
//
return ERROR_INVALID_PARAMETER;
}
if (pReciptsCfg->dwAllowedReceipts & DRT_EMAIL ||
pReciptsCfg->bIsToUseForMSRouteThroughEmailMethod)
{
if (TRUE == IsDesktopSKU())
{
//
// We do not support mail (routing or receipts) on desktop SKUs.
//
if (FAX_API_VERSION_1 > FindClientAPIVersion (hFaxHandle))
{
//
// API version 0 clients don't know about FAX_ERR_NOT_SUPPORTED_ON_THIS_SKU
//
return ERROR_INVALID_PARAMETER;
}
else
{
return FAX_ERR_NOT_SUPPORTED_ON_THIS_SKU;
}
}
if (pReciptsCfg->dwAllowedReceipts & DRT_EMAIL)
{
fIsAllowedEmailReceipts = TRUE;
}
}
if (!(pReciptsCfg->dwAllowedReceipts & DRT_EMAIL) &&
!pReciptsCfg->bIsToUseForMSRouteThroughEmailMethod &&
NULL != pReciptsCfg->lptstrSMTPPassword)
{
//
// Password is not NULL, but no mail receipt/routing was set
//
return ERROR_INVALID_PARAMETER;
}
if (fIsAllowedEmailReceipts || // DRT_EMAIL is allowed or
pReciptsCfg->bIsToUseForMSRouteThroughEmailMethod // Route to email will use SMTP settings
)
{
//
// Validate authentication option range
//
if ((pReciptsCfg->SMTPAuthOption < FAX_SMTP_AUTH_ANONYMOUS) ||
(pReciptsCfg->SMTPAuthOption > FAX_SMTP_AUTH_NTLM))
{
//
// SMTP auth type type is invalid
//
return ERROR_INVALID_PARAMETER;
}
}
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return GetServerErrorCode(rVal);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_MANAGE_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
EnterCriticalSection (&g_CsConfig);
//
// Check if NTLM authentication was turned off
//
if (pReciptsCfg->dwSMTPPort != FAX_SMTP_AUTH_NTLM ||
!( fIsAllowedEmailReceipts || pReciptsCfg->bIsToUseForMSRouteThroughEmailMethod))
{
//
// NTLM authentication is off
//
fCloseToken = TRUE;
}
//
// Read stored password before overwriting it
//
hReceiptsKey = OpenRegistryKey(
HKEY_LOCAL_MACHINE,
REGKEY_SOFTWARE TEXT("\\") REGKEY_RECEIPTS_CONFIG,
FALSE,
KEY_READ | KEY_WRITE);
if (NULL == hReceiptsKey)
{
rVal = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("OpenRegistryKey failed. (ec=%lu)"),
rVal);
goto exit;
}
g_ReceiptsConfig.lptstrSMTPPassword = GetRegistrySecureString(hReceiptsKey, REGVAL_RECEIPTS_PASSWORD, EMPTY_STRING, TRUE, NULL);
//
// Change the values in the registry
//
rVal = StoreReceiptsSettings (pReciptsCfg);
if (ERROR_SUCCESS != rVal)
{
//
// Failed to set stuff
//
rVal = ERROR_REGISTRY_CORRUPT;
goto exit;
}
//
// change the values that the server is currently using
//
g_ReceiptsConfig.dwAllowedReceipts = pReciptsCfg->dwAllowedReceipts;
g_ReceiptsConfig.bIsToUseForMSRouteThroughEmailMethod = pReciptsCfg->bIsToUseForMSRouteThroughEmailMethod;
if (
fIsAllowedEmailReceipts
||
pReciptsCfg->bIsToUseForMSRouteThroughEmailMethod
)
{
g_ReceiptsConfig.dwSMTPPort = pReciptsCfg->dwSMTPPort;
g_ReceiptsConfig.SMTPAuthOption = pReciptsCfg->SMTPAuthOption;
if (!ReplaceStringWithCopy (&g_ReceiptsConfig.lptstrSMTPServer, pReciptsCfg->lptstrSMTPServer))
{
rVal = GetLastError ();
goto exit;
}
if (!ReplaceStringWithCopy (&g_ReceiptsConfig.lptstrSMTPFrom, pReciptsCfg->lptstrSMTPFrom))
{
rVal = GetLastError ();
goto exit;
}
if (g_ReceiptsConfig.lptstrSMTPUserName &&
pReciptsCfg->lptstrSMTPUserName &&
g_ReceiptsConfig.lptstrSMTPPassword &&
pReciptsCfg->lptstrSMTPPassword)
{
if (0 != wcscmp (g_ReceiptsConfig.lptstrSMTPUserName, pReciptsCfg->lptstrSMTPUserName) ||
0 != wcscmp (g_ReceiptsConfig.lptstrSMTPPassword, pReciptsCfg->lptstrSMTPPassword))
{
//
// Logged on user token was changed
//
fCloseToken = TRUE;
}
}
else
{
//
// We can not decide if user information was changed - close old token
//
fCloseToken = TRUE;
}
if (!ReplaceStringWithCopy (&g_ReceiptsConfig.lptstrSMTPUserName, pReciptsCfg->lptstrSMTPUserName))
{
rVal = GetLastError ();
goto exit;
}
}
if (NULL != g_ReceiptsConfig.hLoggedOnUser &&
TRUE == fCloseToken)
{
//
// Logged on user token is not needed or changed. Close the old token
//
if (!CloseHandle(g_ReceiptsConfig.hLoggedOnUser))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CloseHandle failed. (ec: %ld)"),
GetLastError());
}
g_ReceiptsConfig.hLoggedOnUser = NULL;
}
dwRes = CreateConfigEvent (FAX_CONFIG_TYPE_RECEIPTS);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_RECEIPTS) (ec: %lc)"),
dwRes);
}
Assert (ERROR_SUCCESS == rVal);
exit:
if (NULL != hReceiptsKey)
{
DWORD ec = RegCloseKey(hReceiptsKey);
if (ERROR_SUCCESS != ec)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("RegCloseKey failed (ec: %lu)"),
ec);
}
}
if (g_ReceiptsConfig.lptstrSMTPPassword)
{
SecureZeroMemory(g_ReceiptsConfig.lptstrSMTPPassword,_tcslen(g_ReceiptsConfig.lptstrSMTPPassword)*sizeof(TCHAR));
MemFree(g_ReceiptsConfig.lptstrSMTPPassword);
g_ReceiptsConfig.lptstrSMTPPassword = NULL;
}
LeaveCriticalSection (&g_CsConfig);
return GetServerErrorCode(rVal);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_SetReceiptsConfiguration
error_status_t
FAX_GetReceiptsOptions (
IN handle_t hFaxHandle,
OUT LPDWORD lpdwReceiptsOptions
)
/*++
Routine name : FAX_GetReceiptsOptions
Routine description:
Gets the currently supported options.
Requires no access rights.
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
lpdwReceiptsOptions [out] - Pointer to buffer to hold supported options.
Return Value:
Standard RPC error codes
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_GetReceiptsOptions"));
DWORD Rval = ERROR_SUCCESS;
DWORD dwRights;
BOOL fAccess;
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
Assert (lpdwReceiptsOptions);
*lpdwReceiptsOptions = g_ReceiptsConfig.dwAllowedReceipts;
return ERROR_SUCCESS;
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetReceiptsOptions
//********************************************
//* Server version
//********************************************
error_status_t
FAX_GetVersion (
IN handle_t hFaxHandle,
OUT PFAX_VERSION pVersion
)
/*++
Routine name : FAX_GetVersion
Routine description:
Retrieves the version of the fax server
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
pVersion [in/out] - Returned version structure
Return Value:
Standard RPC error codes
--*/
{
error_status_t rVal = ERROR_SUCCESS;
WCHAR wszSvcFileName[MAX_PATH * 2]={0};
BOOL fAccess;
DWORD dwRights;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetVersion"));
//
// Access check
//
rVal = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
if (!GetModuleFileName( NULL,
wszSvcFileName,
ARR_SIZE(wszSvcFileName)-1)
)
{
rVal = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("GetModuleFileName() failed . rVal = %ld"),
rVal);
return GetServerErrorCode(rVal);
}
rVal = GetFileVersion (wszSvcFileName, pVersion);
return GetServerErrorCode(rVal);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetVersion
//*********************************************
//* Getting / Settings the Outbox configuration
//*********************************************
error_status_t
FAX_GetOutboxConfiguration (
IN handle_t hFaxHandle,
IN OUT LPBYTE *pBuffer,
IN OUT LPDWORD pdwBufferSize
)
/*++
Routine name : FAX_GetOutboxConfiguration
Routine description:
Retrieves the Outbox configuration of the fax server
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
pBuffer [out] - Pointer to buffer to hold configuration information
pdwBufferSize [out] - Pointer to buffer size
Return Value:
Standard RPC error codes
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_GetOutboxConfiguration"));
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
Assert (pdwBufferSize); // ref pointer in idl
if (!pBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_QUERY_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
//
// count up the number of bytes needed
//
*pdwBufferSize = sizeof(FAX_OUTBOX_CONFIG);
PFAX_OUTBOX_CONFIG pOutboxConfig;
EnterCriticalSection (&g_CsConfig);
*pBuffer = (LPBYTE)MemAlloc( *pdwBufferSize );
if (NULL == *pBuffer)
{
dwRes = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
pOutboxConfig = (PFAX_OUTBOX_CONFIG)*pBuffer;
pOutboxConfig->dwSizeOfStruct = sizeof (FAX_OUTBOX_CONFIG);
pOutboxConfig->bAllowPersonalCP = g_fServerCp ? FALSE : TRUE;
pOutboxConfig->bUseDeviceTSID = g_fFaxUseDeviceTsid;
pOutboxConfig->dwRetries = g_dwFaxSendRetries;
pOutboxConfig->dwRetryDelay = g_dwFaxSendRetryDelay;
pOutboxConfig->dtDiscountStart.Hour = g_StartCheapTime.Hour;
pOutboxConfig->dtDiscountStart.Minute = g_StartCheapTime.Minute;
pOutboxConfig->dtDiscountEnd.Hour = g_StopCheapTime.Hour;
pOutboxConfig->dtDiscountEnd.Minute = g_StopCheapTime.Minute;
pOutboxConfig->dwAgeLimit = g_dwFaxDirtyDays;
pOutboxConfig->bBranding = g_fFaxUseBranding;
Assert (ERROR_SUCCESS == dwRes);
exit:
LeaveCriticalSection (&g_CsConfig);
return GetServerErrorCode(dwRes);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetOutboxConfiguration
error_status_t
FAX_SetOutboxConfiguration (
IN handle_t hFaxHandle,
IN const PFAX_OUTBOX_CONFIG pOutboxCfg
)
/*++
Routine name : FAX_SetOutboxConfiguration
Routine description:
Sets the current Outbox configuration
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in] - Unused
pOutboxCfg [in] - Pointer to new data to set
Return Value:
Standard RPC error codes
--*/
{
error_status_t rVal = ERROR_SUCCESS;
DWORD dwRes;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetOutboxConfiguration"));
Assert (pOutboxCfg);
if (sizeof (FAX_OUTBOX_CONFIG) != pOutboxCfg->dwSizeOfStruct)
{
//
// Size mismatch
//
return ERROR_INVALID_PARAMETER;
}
if ((pOutboxCfg->dtDiscountStart.Hour > 23) ||
(pOutboxCfg->dtDiscountStart.Minute > 59) ||
(pOutboxCfg->dtDiscountEnd.Hour > 23) ||
(pOutboxCfg->dtDiscountEnd.Minute > 59)
)
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_MANAGE_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
EnterCriticalSection (&g_CsConfig);
//
// Change the values in the registry
//
rVal = StoreOutboxSettings (pOutboxCfg);
if (ERROR_SUCCESS != rVal)
{
//
// Failed to set stuff
//
rVal = ERROR_REGISTRY_CORRUPT;
goto exit;
}
//
// Change the values that the server is currently using
//
g_fServerCp = pOutboxCfg->bAllowPersonalCP ? FALSE : TRUE;
g_fFaxUseDeviceTsid = pOutboxCfg->bUseDeviceTSID;
g_dwFaxSendRetries = pOutboxCfg->dwRetries;
g_dwFaxSendRetryDelay = pOutboxCfg->dwRetryDelay;
g_dwFaxDirtyDays = pOutboxCfg->dwAgeLimit;
g_fFaxUseBranding = pOutboxCfg->bBranding;
//
// Check if CheapTime has changed
//
if ( (MAKELONG(g_StartCheapTime.Hour,g_StartCheapTime.Minute) != MAKELONG(pOutboxCfg->dtDiscountStart.Hour,pOutboxCfg->dtDiscountStart.Minute)) ||
(MAKELONG(g_StopCheapTime.Hour,g_StopCheapTime.Minute) != MAKELONG(pOutboxCfg->dtDiscountEnd.Hour ,pOutboxCfg->dtDiscountEnd.Minute )) )
{
//
// CheapTime has changed. and sort the JobQ
//
g_StartCheapTime.Hour = pOutboxCfg->dtDiscountStart.Hour;
g_StartCheapTime.Minute = pOutboxCfg->dtDiscountStart.Minute;
g_StopCheapTime.Hour = pOutboxCfg->dtDiscountEnd.Hour;
g_StopCheapTime.Minute = pOutboxCfg->dtDiscountEnd.Minute;
}
dwRes = CreateConfigEvent (FAX_CONFIG_TYPE_OUTBOX);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_OUTBOX) (ec: %lc)"),
dwRes);
}
Assert (ERROR_SUCCESS == rVal);
exit:
LeaveCriticalSection (&g_CsConfig);
return GetServerErrorCode(rVal);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_SetOutboxConfiguration
error_status_t
FAX_GetPersonalCoverPagesOption (
IN handle_t hFaxHandle,
OUT LPBOOL lpbPersonalCPAllowed
)
/*++
Routine name : FAX_GetPersonalCoverPagesOption
Routine description:
Gets the currently supported options.
Requires no access rights.
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
lpbPersonalCPAllowed [out] - Pointer to buffer to hold support for personal CP flag.
Return Value:
Standard RPC error codes
--*/
{
BOOL fAccess;
DWORD dwRights;
DWORD Rval = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetPersonalCoverPagesOption"));
Assert (lpbPersonalCPAllowed);
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
*lpbPersonalCPAllowed = g_fServerCp ? FALSE : TRUE;
return ERROR_SUCCESS;
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetPersonalCoverPagesOption
//*******************************************
//* Archive configuration
//*******************************************
error_status_t
FAX_GetArchiveConfiguration (
IN handle_t hFaxHandle,
IN FAX_ENUM_MESSAGE_FOLDER Folder,
OUT LPBYTE *pBuffer,
OUT LPDWORD pdwBufferSize
)
/*++
Routine name : FAX_GetArchiveConfiguration
Routine description:
Gets the current archive configuration
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
Folder [in ] - Type of archive
pBuffer [out] - Pointer to buffer to hold configuration information
pdwBufferSize [out] - Pointer to buffer size
Return Value:
Standard RPC error codes
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_GetArchiveConfiguration"));
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
Assert (pdwBufferSize); // ref pointer in idl
if (!pBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
if ((Folder != FAX_MESSAGE_FOLDER_SENTITEMS) &&
(Folder != FAX_MESSAGE_FOLDER_INBOX)
)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Invalid folder id (%ld)"),
Folder);
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_QUERY_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
//
// count up the number of bytes needed
//
*pdwBufferSize = sizeof(FAX_ARCHIVE_CONFIG);
ULONG_PTR Offset = sizeof(FAX_ARCHIVE_CONFIG);
PFAX_ARCHIVE_CONFIG pConfig;
EnterCriticalSection (&g_CsConfig);
if (NULL != g_ArchivesConfig[Folder].lpcstrFolder)
{
*pdwBufferSize += StringSize( g_ArchivesConfig[Folder].lpcstrFolder );
}
*pBuffer = (LPBYTE)MemAlloc( *pdwBufferSize );
if (NULL == *pBuffer)
{
dwRes = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
pConfig = (PFAX_ARCHIVE_CONFIG)*pBuffer;
pConfig->dwSizeOfStruct = sizeof (FAX_ARCHIVE_CONFIG);
pConfig->bSizeQuotaWarning = g_ArchivesConfig[Folder].bSizeQuotaWarning;
pConfig->bUseArchive = g_ArchivesConfig[Folder].bUseArchive;
pConfig->dwAgeLimit = g_ArchivesConfig[Folder].dwAgeLimit;
pConfig->dwSizeQuotaHighWatermark = g_ArchivesConfig[Folder].dwSizeQuotaHighWatermark;
pConfig->dwSizeQuotaLowWatermark = g_ArchivesConfig[Folder].dwSizeQuotaLowWatermark;
pConfig->dwlArchiveSize = g_ArchivesConfig[Folder].dwlArchiveSize;
StoreString(
g_ArchivesConfig[Folder].lpcstrFolder,
(PULONG_PTR)&pConfig->lpcstrFolder,
*pBuffer,
&Offset,
*pdwBufferSize
);
Assert (ERROR_SUCCESS == dwRes);
exit:
LeaveCriticalSection (&g_CsConfig);
return GetServerErrorCode(dwRes);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetArchiveConfiguration
error_status_t
FAX_SetArchiveConfiguration (
IN handle_t hFaxHandle,
IN FAX_ENUM_MESSAGE_FOLDER Folder,
IN const PFAX_ARCHIVE_CONFIGW pConfig
)
/*++
Routine name : FAX_SetArchiveConfiguration
Routine description:
Sets the current archive configuration
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
Folder [in ] - Type of archive
pConfig [in ] - Pointer to new data to set
Return Value:
Standard RPC error codes
--*/
{
error_status_t rVal = ERROR_SUCCESS;
DWORD dwRes;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetArchiveConfiguration"));
FAX_ENUM_CONFIG_TYPE ConfigType;
BOOL bQuotaWarningConfigChanged = TRUE;
BOOL fAccess;
Assert (pConfig);
if (sizeof (FAX_ARCHIVE_CONFIG) != pConfig->dwSizeOfStruct)
{
//
// Size mismatch
//
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_MANAGE_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
if ((Folder != FAX_MESSAGE_FOLDER_SENTITEMS) &&
(Folder != FAX_MESSAGE_FOLDER_INBOX)
)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Invalid folder id (%ld)"),
Folder);
return ERROR_INVALID_PARAMETER;
}
if (pConfig->bUseArchive)
{
if (pConfig->dwSizeQuotaHighWatermark < pConfig->dwSizeQuotaLowWatermark)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Watermarks mismatch (high=%ld, low=%ld)"),
pConfig->dwSizeQuotaHighWatermark,
pConfig->dwSizeQuotaLowWatermark);
return ERROR_INVALID_PARAMETER;
}
if ((NULL == pConfig->lpcstrFolder) || (!lstrlen (pConfig->lpcstrFolder)))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Empty folder specified"));
return ERROR_INVALID_PARAMETER;
}
}
EnterCriticalSection (&g_CsConfig);
if (pConfig->bUseArchive)
{
//
// Make sure the folder is valid - (Exists, NTFS, Diffrent from the other archive folder
//
rVal = IsValidArchiveFolder (pConfig->lpcstrFolder, Folder);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Invalid archive folder specified (%s), ec = %ld"),
pConfig->lpcstrFolder,
rVal);
if (ERROR_ACCESS_DENIED == rVal ||
ERROR_SHARING_VIOLATION == rVal)
{
rVal = FAX_ERR_FILE_ACCESS_DENIED;
}
goto exit;
}
}
//
// Change the values in the registry
//
rVal = StoreArchiveSettings (Folder, pConfig);
if (ERROR_SUCCESS != rVal)
{
//
// Failed to set stuff
//
DebugPrintEx(
DEBUG_ERR,
TEXT("StoreArchiveSettings failed, ec = %ld"),
rVal);
rVal = ERROR_REGISTRY_CORRUPT;
goto exit;
}
//
// Check if we are about to change quota warning configuration
//
if (g_ArchivesConfig[Folder].bUseArchive == pConfig->bUseArchive)
{
if (pConfig->bUseArchive == TRUE)
{
Assert (pConfig->lpcstrFolder && g_ArchivesConfig[Folder].lpcstrFolder);
if (0 == wcscmp (pConfig->lpcstrFolder, g_ArchivesConfig[Folder].lpcstrFolder) &&
pConfig->bSizeQuotaWarning == g_ArchivesConfig[Folder].bSizeQuotaWarning &&
pConfig->dwSizeQuotaHighWatermark == g_ArchivesConfig[Folder].dwSizeQuotaHighWatermark &&
pConfig->dwSizeQuotaLowWatermark == g_ArchivesConfig[Folder].dwSizeQuotaLowWatermark)
{
// Quota warning configuration did not change
bQuotaWarningConfigChanged = FALSE;
}
}
else
{
bQuotaWarningConfigChanged = FALSE;
}
}
//
// change the values that the server is currently using
//
if (!ReplaceStringWithCopy (&g_ArchivesConfig[Folder].lpcstrFolder, pConfig->lpcstrFolder))
{
rVal = GetLastError ();
goto exit;
}
g_ArchivesConfig[Folder].bSizeQuotaWarning = pConfig->bSizeQuotaWarning;
g_ArchivesConfig[Folder].bUseArchive = pConfig->bUseArchive;
g_ArchivesConfig[Folder].dwAgeLimit = pConfig->dwAgeLimit;
g_ArchivesConfig[Folder].dwSizeQuotaHighWatermark = pConfig->dwSizeQuotaHighWatermark;
g_ArchivesConfig[Folder].dwSizeQuotaLowWatermark = pConfig->dwSizeQuotaLowWatermark;
ConfigType = (Folder == FAX_MESSAGE_FOLDER_SENTITEMS) ? FAX_CONFIG_TYPE_SENTITEMS : FAX_CONFIG_TYPE_INBOX;
dwRes = CreateConfigEvent (ConfigType);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_*) (ec: %lc)"),
dwRes);
}
//
// We want to refresh the archive size
//
if (TRUE == bQuotaWarningConfigChanged)
{
g_ArchivesConfig[Folder].dwlArchiveSize = FAX_ARCHIVE_FOLDER_INVALID_SIZE;
g_FaxQuotaWarn[Folder].bConfigChanged = TRUE;
g_FaxQuotaWarn[Folder].bLoggedQuotaEvent = FALSE;
if (TRUE == g_ArchivesConfig[Folder].bUseArchive )
{
if (!SetEvent (g_hArchiveQuotaWarningEvent))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to set quota warning event, SetEvent failed (ec: %lc)"),
GetLastError());
}
}
}
Assert (ERROR_SUCCESS == rVal);
exit:
LeaveCriticalSection (&g_CsConfig);
return GetServerErrorCode(rVal);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_SetArchiveConfiguration
//********************************************
//* Activity logging
//********************************************
error_status_t
FAX_GetActivityLoggingConfiguration (
IN handle_t hFaxHandle,
OUT LPBYTE *pBuffer,
OUT LPDWORD pdwBufferSize
)
/*++
Routine name : FAX_GetActivityLoggingConfiguration
Routine description:
Gets the current activity logging configuration
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
pBuffer [out] - Pointer to buffer to hold configuration information
pdwBufferSize [out] - Pointer to buffer size
Return Value:
Standard RPC error codes
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_GetActivityLoggingConfiguration"));
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
Assert (pdwBufferSize); // ref pointer in idl
if (!pBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_QUERY_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
//
// count up the number of bytes needed
//
*pdwBufferSize = sizeof(FAX_ACTIVITY_LOGGING_CONFIG);
ULONG_PTR Offset = sizeof(FAX_ACTIVITY_LOGGING_CONFIG);
PFAX_ACTIVITY_LOGGING_CONFIG pConfig;
EnterCriticalSection (&g_CsConfig);
if (NULL != g_ActivityLoggingConfig.lptstrDBPath)
{
*pdwBufferSize += StringSize( g_ActivityLoggingConfig.lptstrDBPath );
}
*pBuffer = (LPBYTE)MemAlloc( *pdwBufferSize );
if (NULL == *pBuffer)
{
dwRes = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
pConfig = (PFAX_ACTIVITY_LOGGING_CONFIG)*pBuffer;
pConfig->dwSizeOfStruct = sizeof (FAX_ACTIVITY_LOGGING_CONFIG);
pConfig->bLogIncoming = g_ActivityLoggingConfig.bLogIncoming;
pConfig->bLogOutgoing = g_ActivityLoggingConfig.bLogOutgoing;
StoreString(
g_ActivityLoggingConfig.lptstrDBPath,
(PULONG_PTR)&pConfig->lptstrDBPath,
*pBuffer,
&Offset,
*pdwBufferSize
);
Assert (ERROR_SUCCESS == dwRes);
exit:
LeaveCriticalSection (&g_CsConfig);
return GetServerErrorCode(dwRes);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetActivityLoggingConfiguration
error_status_t
FAX_SetActivityLoggingConfiguration (
IN handle_t hFaxHandle,
IN const PFAX_ACTIVITY_LOGGING_CONFIGW pConfig
)
/*++
Routine name : FAX_SetActivityLoggingConfiguration
Routine description:
Sets the current activity logging configuration
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
pConfig [in ] - Pointer to new data to set
Return Value:
Standard RPC error codes
--*/
{
error_status_t rVal = ERROR_SUCCESS;
DWORD dwRes;
BOOL fAccess;
HANDLE hNewInboxFile = INVALID_HANDLE_VALUE;
HANDLE hNewOutboxFile = INVALID_HANDLE_VALUE;
BOOL IsSameDir = FALSE;
FAX_ACTIVITY_LOGGING_CONFIGW ActualConfig;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetActivityLoggingConfiguration"));
Assert (pConfig);
if (sizeof (FAX_ACTIVITY_LOGGING_CONFIG) != pConfig->dwSizeOfStruct)
{
//
// Size mismatch
//
return ERROR_INVALID_PARAMETER;
}
ActualConfig = *pConfig;
if (ActualConfig.bLogIncoming || ActualConfig.bLogOutgoing)
{
DWORD dwLen;
if ((NULL == ActualConfig.lptstrDBPath) || (!lstrlen (ActualConfig.lptstrDBPath)))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Empty DB file name specified"));
return ERROR_INVALID_PARAMETER;
}
if ((dwLen = lstrlen (ActualConfig.lptstrDBPath)) > MAX_DIR_PATH)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("DB file name exceeds MAX_PATH"));
return ERROR_BUFFER_OVERFLOW;
}
if (L'\\' == ActualConfig.lptstrDBPath[dwLen - 1])
{
//
// Activity logging DB name should not end with a backslash.
//
ActualConfig.lptstrDBPath[dwLen - 1] = (WCHAR)'\0';
}
}
else
{
//
// If logging is off, the DB path is always NULL
//
ActualConfig.lptstrDBPath = NULL;
}
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return GetServerErrorCode(rVal);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_MANAGE_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
//
// Always lock g_CsInboundActivityLogging and then g_CsOutboundActivityLogging
//
EnterCriticalSection (&g_CsInboundActivityLogging);
EnterCriticalSection (&g_CsOutboundActivityLogging);
if (ActualConfig.lptstrDBPath)
{
//
// Activity logging is on.
// Validate the new activity logging directory
//
rVal = IsValidFaxFolder(ActualConfig.lptstrDBPath);
if(ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("IsValidFaxFolder failed for folder : %s (ec=%lu)."),
ActualConfig.lptstrDBPath,
rVal);
if(ERROR_ACCESS_DENIED == rVal &&
FAX_API_VERSION_1 <= FindClientAPIVersion (hFaxHandle) )
{
rVal = FAX_ERR_FILE_ACCESS_DENIED;
}
goto exit;
}
//
// Check if the DB path has changed
//
if (NULL == g_ActivityLoggingConfig.lptstrDBPath)
{
//
// DB was off
//
IsSameDir = FALSE;
}
else
{
rVal = CheckToSeeIfSameDir( ActualConfig.lptstrDBPath,
g_ActivityLoggingConfig.lptstrDBPath,
&IsSameDir);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CheckToSeeIfSameDir with %ld"), rVal);
}
}
if (ERROR_SUCCESS == rVal && FALSE == IsSameDir)
{
//
// Switch DB path
//
rVal = CreateLogDB (ActualConfig.lptstrDBPath, &hNewInboxFile, &hNewOutboxFile);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateLogDB with %ld"), rVal);
}
}
if (ERROR_SUCCESS != rVal)
{
if (ERROR_ACCESS_DENIED == rVal ||
ERROR_SHARING_VIOLATION == rVal)
{
rVal = FAX_ERR_FILE_ACCESS_DENIED;
}
goto exit;
}
}
//
// Change the values in the registry.
// Notice: if the logging is off, the DB path gets written as "".
//
rVal = StoreActivityLoggingSettings (&ActualConfig);
if (ERROR_SUCCESS != rVal)
{
//
// Failed to set stuff
//
DebugPrintEx(
DEBUG_ERR,
TEXT("StoreActivityLoggingSettings failed (ec: %ld)"),
rVal);
rVal = ERROR_REGISTRY_CORRUPT;
goto exit;
}
if (!ReplaceStringWithCopy (&g_ActivityLoggingConfig.lptstrDBPath, ActualConfig.lptstrDBPath))
{
rVal = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("ReplaceStringWithCopy (ec: %ld)"),
rVal);
//
// Try to rollback
//
FAX_ACTIVITY_LOGGING_CONFIGW previousActivityLoggingConfig = {0};
previousActivityLoggingConfig.dwSizeOfStruct = sizeof(previousActivityLoggingConfig);
previousActivityLoggingConfig.bLogIncoming = g_ActivityLoggingConfig.bLogIncoming;
previousActivityLoggingConfig.bLogOutgoing = g_ActivityLoggingConfig.bLogOutgoing;
previousActivityLoggingConfig.lptstrDBPath = g_ActivityLoggingConfig.lptstrDBPath;
dwRes = StoreActivityLoggingSettings (&previousActivityLoggingConfig);
if (ERROR_SUCCESS != dwRes)
{
//
// Failed to set stuff
//
DebugPrintEx(
DEBUG_ERR,
TEXT("StoreActivityLoggingSettings failed - rollback failed (ec: %ld)"),
dwRes);
}
goto exit;
}
if (FALSE == IsSameDir)
{
//
// change the values that the server is currently using
//
if (g_hInboxActivityLogFile != INVALID_HANDLE_VALUE)
{
if (!CloseHandle (g_hInboxActivityLogFile))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CloseHandle failed - (ec: %ld)"),
GetLastError());
}
}
if (g_hOutboxActivityLogFile != INVALID_HANDLE_VALUE)
{
if (!CloseHandle (g_hOutboxActivityLogFile))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CloseHandle failed - (ec: %ld)"),
GetLastError());
}
}
g_hInboxActivityLogFile = hNewInboxFile;
hNewInboxFile = INVALID_HANDLE_VALUE; // Do not close the file handle
g_hOutboxActivityLogFile = hNewOutboxFile;
hNewOutboxFile = INVALID_HANDLE_VALUE; // Do not close the file handle
}
g_ActivityLoggingConfig.bLogIncoming = ActualConfig.bLogIncoming;
g_ActivityLoggingConfig.bLogOutgoing = ActualConfig.bLogOutgoing;
dwRes = CreateConfigEvent (FAX_CONFIG_TYPE_ACTIVITY_LOGGING);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_ACTIVITY_LOGGING) (ec: %ld)"),
dwRes);
}
Assert (ERROR_SUCCESS == rVal);
exit:
LeaveCriticalSection (&g_CsOutboundActivityLogging);
LeaveCriticalSection (&g_CsInboundActivityLogging);
if (INVALID_HANDLE_VALUE != hNewInboxFile ||
INVALID_HANDLE_VALUE != hNewOutboxFile)
{
WCHAR wszFileName[MAX_PATH*2] = {0};
Assert (INVALID_HANDLE_VALUE != hNewInboxFile &&
INVALID_HANDLE_VALUE != hNewOutboxFile);
//
// Clean Inbox file
//
swprintf (wszFileName,
TEXT("%s\\%s"),
ActualConfig.lptstrDBPath,
ACTIVITY_LOG_INBOX_FILE);
if (!CloseHandle (hNewInboxFile))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CloseHandle failed - (ec: %ld)"),
GetLastError());
}
if (!DeleteFile(wszFileName))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("DeleteFile failed - (ec: %ld)"),
GetLastError());
}
//
// Clean Outbox file
//
swprintf (wszFileName,
TEXT("%s\\%s"),
ActualConfig.lptstrDBPath,
ACTIVITY_LOG_OUTBOX_FILE);
if (!CloseHandle (hNewOutboxFile))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CloseHandle failed - (ec: %ld)"),
GetLastError());
}
if (!DeleteFile(wszFileName))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("DeleteFile failed - (ec: %ld)"),
GetLastError());
}
}
return GetServerErrorCode(rVal);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_SetActivityLoggingConfiguration
//********************************************
//* FSP
//********************************************
error_status_t
FAX_EnumerateProviders (
IN handle_t hFaxHandle,
OUT LPBYTE *pBuffer,
OUT LPDWORD pdwBufferSize,
OUT LPDWORD lpdwNumProviders
)
/*++
Routine name : FAX_EnumerateProviders
Routine description:
Enumerates the FSPs
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
pBuffer [out] - Pointer to buffer to hold FSPs array
pdwBufferSize [out] - Pointer to buffer size
lpdwNumProviders [out] - Size of FSPs array
Return Value:
Standard RPC error codes
--*/
{
PLIST_ENTRY Next;
DWORD_PTR dwOffset;
PFAX_DEVICE_PROVIDER_INFO pFSPs;
DWORD dwIndex;
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnumerateProviders"));
Assert (pdwBufferSize && lpdwNumProviders); // ref pointer in idl
if (!pBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_QUERY_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
//
// First run - traverse list and count size required + list size
//
*lpdwNumProviders = 0;
*pdwBufferSize = 0;
Next = g_DeviceProvidersListHead.Flink;
if (NULL == Next)
{
//
// The list is corrupted
//
ASSERT_FALSE;
//
// We'll crash and we deserve it....
//
}
while ((ULONG_PTR)Next != (ULONG_PTR)&g_DeviceProvidersListHead)
{
PDEVICE_PROVIDER pProvider;
(*lpdwNumProviders)++;
(*pdwBufferSize) += sizeof (FAX_DEVICE_PROVIDER_INFO);
//
// Get current provider
//
pProvider = CONTAINING_RECORD( Next, DEVICE_PROVIDER, ListEntry );
//
// Advance pointer
//
Next = pProvider->ListEntry.Flink;
(*pdwBufferSize) += StringSize (pProvider->FriendlyName);
(*pdwBufferSize) += StringSize (pProvider->ImageName);
(*pdwBufferSize) += StringSize (pProvider->ProviderName);
(*pdwBufferSize) += StringSize (pProvider->szGUID);
}
//
// Allocate required size
//
*pBuffer = (LPBYTE)MemAlloc( *pdwBufferSize );
if (NULL == *pBuffer)
{
return FAX_ERR_SRV_OUTOFMEMORY;
}
//
// Second pass, fill in the array
//
pFSPs = (PFAX_DEVICE_PROVIDER_INFO)(*pBuffer);
dwOffset = (*lpdwNumProviders) * sizeof (FAX_DEVICE_PROVIDER_INFO);
Next = g_DeviceProvidersListHead.Flink;
dwIndex = 0;
while ((ULONG_PTR)Next != (ULONG_PTR)&g_DeviceProvidersListHead)
{
PDEVICE_PROVIDER pProvider;
//
// Get current provider
//
pProvider = CONTAINING_RECORD( Next, DEVICE_PROVIDER, ListEntry );
//
// Advance pointer
//
Next = pProvider->ListEntry.Flink;
pFSPs[dwIndex].dwSizeOfStruct = sizeof (FAX_DEVICE_PROVIDER_INFO);
StoreString(
pProvider->FriendlyName,
(PULONG_PTR)&(pFSPs[dwIndex].lpctstrFriendlyName),
*pBuffer,
&dwOffset,
*pdwBufferSize
);
StoreString(
pProvider->ImageName,
(PULONG_PTR)&(pFSPs[dwIndex].lpctstrImageName),
*pBuffer,
&dwOffset,
*pdwBufferSize
);
StoreString(
pProvider->ProviderName,
(PULONG_PTR)&(pFSPs[dwIndex].lpctstrProviderName),
*pBuffer,
&dwOffset,
*pdwBufferSize
);
StoreString(
pProvider->szGUID,
(PULONG_PTR)&(pFSPs[dwIndex].lpctstrGUID),
*pBuffer,
&dwOffset,
*pdwBufferSize
);
pFSPs[dwIndex].dwCapabilities = 0;
pFSPs[dwIndex].Version = pProvider->Version;
pFSPs[dwIndex].Status = pProvider->Status;
pFSPs[dwIndex].dwLastError = pProvider->dwLastError;
dwIndex++;
}
Assert (dwIndex == *lpdwNumProviders);
return ERROR_SUCCESS;
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_EnumerateProviders
//********************************************
//* Extended ports
//********************************************
DWORD
GetExtendedPortSize (
PLINE_INFO pLineInfo
)
/*++
Routine name : GetExtendedPortSize
Routine description:
Returns the size occupied by the extended info of a port
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
pLineInfo [in] - Port pointer
Remarks:
This function should be called with g_CsLine held.
Return Value:
Size required
--*/
{
DWORD dwSize = sizeof (FAX_PORT_INFO_EX);
DEBUG_FUNCTION_NAME(TEXT("GetExtendedPortSize"));
Assert (pLineInfo);
dwSize+= StringSize (pLineInfo->DeviceName);
dwSize+= StringSize (pLineInfo->lptstrDescription);
Assert (pLineInfo->Provider);
dwSize+= StringSize (pLineInfo->Provider->FriendlyName);
dwSize+= StringSize (pLineInfo->Provider->szGUID);
dwSize+= StringSize (pLineInfo->Csid);
dwSize+= StringSize (pLineInfo->Tsid);
return dwSize;
} // GetExtendedPortSize
VOID
StorePortInfoEx (
PFAX_PORT_INFO_EX pPortInfoEx,
PLINE_INFO pLineInfo,
LPBYTE lpBufferStart,
PULONG_PTR pupOffset,
DWORD dwBufferStartSize
)
/*++
Routine name : StorePortInfoEx
Routine description:
Stores a port extended info into a buffer
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
pPortInfoEx [in ] - Buffer to store
pLineInfo [in ] - Port pointer
lpBufferStart [in ] - Start address of buffer (for offset calculations)
pupOffset [in ] - Current offset
dwBufferStartSize [in ] - Size of the lpBufferStart, in bytes.
This parameter is used only if lpBufferStart is not NULL.
Remarks:
This function should be called with g_CsLine held.
Return Value:
None.
--*/
{
DEBUG_FUNCTION_NAME(TEXT("StorePortInfoEx"));
//
// Store the data
//
pPortInfoEx->dwSizeOfStruct = sizeof (FAX_PORT_INFO_EX);
if (g_dwManualAnswerDeviceId == pLineInfo->PermanentLineID)
{
//
// Device is in manual-answer mode
//
Assert (!(pLineInfo->Flags & FPF_RECEIVE));
pPortInfoEx->ReceiveMode = FAX_DEVICE_RECEIVE_MODE_MANUAL;
}
else if (pLineInfo->Flags & FPF_RECEIVE)
{
//
// Device is in auto-answer mode
//
Assert (g_dwManualAnswerDeviceId != pLineInfo->PermanentLineID);
pPortInfoEx->ReceiveMode = FAX_DEVICE_RECEIVE_MODE_AUTO;
}
else
{
//
// Device is not set to receive
//
Assert (g_dwManualAnswerDeviceId != pLineInfo->PermanentLineID);
pPortInfoEx->ReceiveMode = FAX_DEVICE_RECEIVE_MODE_OFF;
}
pPortInfoEx->bSend = (pLineInfo->Flags & FPF_SEND) ? TRUE : FALSE;
pPortInfoEx->dwStatus = (pLineInfo->dwReceivingJobsCount ? FAX_DEVICE_STATUS_RECEIVING : 0) |
(pLineInfo->dwSendingJobsCount ? FAX_DEVICE_STATUS_SENDING : 0);
pPortInfoEx->dwDeviceID = pLineInfo->PermanentLineID;
pPortInfoEx->dwRings = pLineInfo->RingsForAnswer;
StoreString(
pLineInfo->DeviceName,
(PULONG_PTR)&pPortInfoEx->lpctstrDeviceName,
lpBufferStart,
pupOffset,
dwBufferStartSize
);
StoreString(
pLineInfo->lptstrDescription,
(PULONG_PTR)&pPortInfoEx->lptstrDescription,
lpBufferStart,
pupOffset,
dwBufferStartSize
);
StoreString(
pLineInfo->Provider->FriendlyName,
(PULONG_PTR)&pPortInfoEx->lpctstrProviderName,
lpBufferStart,
pupOffset,
dwBufferStartSize
);
StoreString(
pLineInfo->Provider->szGUID,
(PULONG_PTR)&pPortInfoEx->lpctstrProviderGUID,
lpBufferStart,
pupOffset,
dwBufferStartSize
);
StoreString(
pLineInfo->Csid,
(PULONG_PTR)&pPortInfoEx->lptstrCsid,
lpBufferStart,
pupOffset,
dwBufferStartSize
);
StoreString(
pLineInfo->Tsid,
(PULONG_PTR)&pPortInfoEx->lptstrTsid,
lpBufferStart,
pupOffset,
dwBufferStartSize
);
} // StorePortInfoEx
error_status_t
FAX_EnumPortsEx(
IN handle_t hFaxHandle,
IN OUT LPBYTE *lpBuffer,
IN OUT LPDWORD lpdwBufferSize,
OUT LPDWORD lpdwNumPorts
)
/*++
Routine name : FAX_EnumPortsEx
Routine description:
Enumerates the ports
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
lpBuffer [out] - Pointer to buffer to hold ports array
lpdwBufferSize [out] - Pointer to buffer size
lpdwNumPorts [out] - Size of ports array
Return Value:
Standard RPC error codes
--*/
{
PLIST_ENTRY Next;
DWORD_PTR dwOffset;
DWORD dwIndex;
DWORD dwRes = ERROR_SUCCESS;
PFAX_PORT_INFO_EX pPorts;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnumPortsEx"));
Assert (lpdwBufferSize && lpdwNumPorts); // ref pointer in idl
if (!lpBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_QUERY_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
//
// First run - traverse list and count size required + list size
//
*lpdwNumPorts = 0;
*lpdwBufferSize = 0;
EnterCriticalSection( &g_CsLine );
Next = g_TapiLinesListHead.Flink;
if (NULL == Next)
{
//
// The list is corrupted
//
ASSERT_FALSE;
//
// We'll crash and we deserve it....
//
}
while ((ULONG_PTR)Next != (ULONG_PTR)&g_TapiLinesListHead)
{
PLINE_INFO pLineInfo;
(*lpdwNumPorts)++;
//
// Get current port
//
pLineInfo = CONTAINING_RECORD( Next, LINE_INFO, ListEntry );
//
// Advance pointer
//
Next = pLineInfo->ListEntry.Flink;
//
// Sum up size
//
(*lpdwBufferSize) += GetExtendedPortSize (pLineInfo);
}
//
// Allocate required size
//
*lpBuffer = (LPBYTE)MemAlloc( *lpdwBufferSize );
if (NULL == *lpBuffer)
{
dwRes = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
//
// Second pass, fill in the array
//
pPorts = (PFAX_PORT_INFO_EX)(*lpBuffer);
dwOffset = (*lpdwNumPorts) * sizeof (FAX_PORT_INFO_EX);
Next = g_TapiLinesListHead.Flink;
dwIndex = 0;
while ((ULONG_PTR)Next != (ULONG_PTR)&g_TapiLinesListHead)
{
PLINE_INFO pLineInfo;
//
// Get current port
//
pLineInfo = CONTAINING_RECORD( Next, LINE_INFO, ListEntry );
//
// Advance pointer
//
Next = pLineInfo->ListEntry.Flink;
//
// Store port data
//
StorePortInfoEx (&pPorts[dwIndex++],
pLineInfo,
*lpBuffer,
&dwOffset,
*lpdwBufferSize
);
}
Assert (dwIndex == *lpdwNumPorts);
Assert (ERROR_SUCCESS == dwRes);
exit:
LeaveCriticalSection( &g_CsLine );
return GetServerErrorCode(dwRes);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_EnumPortsEx
error_status_t
FAX_GetPortEx(
IN handle_t hFaxHandle,
IN DWORD dwDeviceId,
IN OUT LPBYTE *lpBuffer,
IN OUT LPDWORD lpdwBufferSize
)
/*++
Routine name : FAX_GetPortEx
Routine description:
Gets extended port info
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
dwDeviceId [in ] - Unique device id
lpBuffer [out] - Pointer to buffer to hold extended port information
lpdwBufferSize [out] - Pointer to buffer size
Return Value:
Standard RPC error codes
--*/
{
DWORD_PTR dwOffset;
PLINE_INFO pLineInfo;
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetPortEx"));
Assert (lpdwBufferSize); // ref pointer in idl
if (!lpBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_QUERY_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
//
// Locate the port (device)
//
EnterCriticalSection( &g_CsLine );
pLineInfo = GetTapiLineFromDeviceId( dwDeviceId, FALSE );
if (!pLineInfo)
{
//
// Port not found
//
dwRes = ERROR_BAD_UNIT; // The system cannot find the device specified.
goto exit;
}
//
// count up the number of bytes needed
//
*lpdwBufferSize = GetExtendedPortSize(pLineInfo);
dwOffset = sizeof (FAX_PORT_INFO_EX);
//
// Allocate buffer
//
*lpBuffer = (LPBYTE)MemAlloc( *lpdwBufferSize );
if (NULL == *lpBuffer)
{
dwRes = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
StorePortInfoEx ((PFAX_PORT_INFO_EX)*lpBuffer,
pLineInfo,
*lpBuffer,
&dwOffset,
*lpdwBufferSize
);
Assert (ERROR_SUCCESS == dwRes);
exit:
LeaveCriticalSection( &g_CsLine );
return GetServerErrorCode(dwRes);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetPortEx
error_status_t
FAX_SetPortEx (
IN handle_t hFaxHandle,
IN DWORD dwDeviceId,
IN const PFAX_PORT_INFO_EX pNewPortInfo
)
/*++
Routine name : FAX_SetPortEx
Routine description:
Sets extended port info
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
dwDeviceId [in ] - Unique device id
pNewPortInfo [out] - Pointer to new extended port information
Return Value:
Standard RPC error codes
--*/
{
DWORD dwRes = ERROR_SUCCESS;
DWORD rVal;
PLINE_INFO pLineInfo;
BOOL bVirtualDeviceNeedsUpdate = FALSE;
BOOL fAccess;
BOOL bDeviceWasSetToReceive; // Was the device configured to receive faxes?
BOOL bDeviceWasEnabled; // Was the device send/receive/manual receive enabled
BOOL bDeviceWasAutoReceive; // Was the device auto receive enabled
DWORD dwLastManualAnswerDeviceId = 0;
DEBUG_FUNCTION_NAME(TEXT("FAX_SetPortEx"));
Assert (pNewPortInfo);
if (!dwDeviceId)
{
return ERROR_INVALID_PARAMETER;
}
if (sizeof (FAX_PORT_INFO_EX) != pNewPortInfo->dwSizeOfStruct)
{
//
// Size mismatch
//
return ERROR_INVALID_PARAMETER;
}
if (MAX_FAX_STRING_LEN <= lstrlen (pNewPortInfo->lptstrDescription))
{
return ERROR_BUFFER_OVERFLOW;
}
if ((FAX_DEVICE_RECEIVE_MODE_MANUAL < pNewPortInfo->ReceiveMode) ||
(FAX_DEVICE_RECEIVE_MODE_OFF > pNewPortInfo->ReceiveMode))
{
DebugPrintEx(DEBUG_ERR,
TEXT("ReceiveMode = %d and > FAX_DEVICE_RECEIVE_MODE_MANUAL"),
pNewPortInfo->ReceiveMode);
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return GetServerErrorCode(dwRes);
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_MANAGE_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
EnterCriticalSectionJobAndQueue;
EnterCriticalSection( &g_CsLine );
//
// Remember the original device set to manual-answer
//
dwLastManualAnswerDeviceId = g_dwManualAnswerDeviceId;
//
// Locate the port (device)
//
pLineInfo = GetTapiLineFromDeviceId (dwDeviceId, FALSE);
if (!pLineInfo)
{
//
// Port not found
//
dwRes = ERROR_BAD_UNIT; // The system cannot find the device specified.
goto exit;
}
bDeviceWasEnabled = IsDeviceEnabled(pLineInfo);
bDeviceWasSetToReceive = (pLineInfo->Flags & FPF_RECEIVE) || // Either device was set to auto-receive or
(dwDeviceId == g_dwManualAnswerDeviceId); // it's the manual answer device id
bDeviceWasAutoReceive = (pLineInfo->Flags & FPF_RECEIVE); // Device was set to auto receive
if ((pLineInfo->Flags & FPF_VIRTUAL) && // The device is virtual and
(FAX_DEVICE_RECEIVE_MODE_MANUAL == pNewPortInfo->ReceiveMode)) // we were asked to set it to manual-answer
{
//
// We don't support manual-answer on non-physical devices
//
DebugPrintEx(DEBUG_ERR,
TEXT("Device id (%ld) is virtual"),
dwDeviceId);
dwRes = ERROR_INVALID_PARAMETER;
goto exit;
}
//
// Check device limit
//
if (g_dwDeviceEnabledCount >= g_dwDeviceEnabledLimit && // We are at the device limit
!bDeviceWasEnabled && // It was not send/receive/manual receive enabled
(pNewPortInfo->bSend || // It is now send enabled
pNewPortInfo->ReceiveMode != FAX_DEVICE_RECEIVE_MODE_OFF)) // It is now receive enabled
{
BOOL fLimitExceeded = TRUE;
//
// We should now verify if manual answer device changed. If so there is another device to take into device enabled account.
//
if (dwLastManualAnswerDeviceId != 0 && // There was a device set to manual answer
FAX_DEVICE_RECEIVE_MODE_MANUAL == pNewPortInfo->ReceiveMode && // The new device is set to manual
dwLastManualAnswerDeviceId != dwDeviceId) // It is not the same device
{
//
// See if the old device is send enabled
//
PLINE_INFO pOldLine;
pOldLine = GetTapiLineFromDeviceId (dwLastManualAnswerDeviceId, FALSE);
if (pOldLine)
{
if (!(pOldLine->Flags & FPF_SEND))
{
//
// The old manual receive device is not send enabled. When the manual receive device will be changed, the old device
// will not be enabled anymore, and the enabled device count will be decremented.
//
fLimitExceeded = FALSE;
}
}
}
if (TRUE == fLimitExceeded)
{
if (FAX_API_VERSION_1 > FindClientAPIVersion (hFaxHandle))
{
//
// API version 0 clients don't know about FAX_ERR_DEVICE_NUM_LIMIT_EXCEEDED
//
dwRes = ERROR_INVALID_PARAMETER;
}
else
{
dwRes = FAX_ERR_DEVICE_NUM_LIMIT_EXCEEDED;
}
goto exit;
}
}
//
// Store device configuration in the registry
//
dwRes = StoreDeviceConfig (dwDeviceId, pNewPortInfo, pLineInfo->Flags & FPF_VIRTUAL ? TRUE : FALSE);
if (ERROR_SUCCESS != dwRes)
{
dwRes = ERROR_REGISTRY_CORRUPT;
goto exit;
}
//
// Update data in server's memory
//
if (!ReplaceStringWithCopy (&(pLineInfo->lptstrDescription), pNewPortInfo->lptstrDescription))
{
dwRes = GetLastError ();
goto exit;
}
if (!ReplaceStringWithCopy (&(pLineInfo->Csid), pNewPortInfo->lptstrCsid))
{
dwRes = GetLastError ();
goto exit;
}
if (!ReplaceStringWithCopy (&(pLineInfo->Tsid), pNewPortInfo->lptstrTsid))
{
dwRes = GetLastError ();
goto exit;
}
pLineInfo->RingsForAnswer = pNewPortInfo->dwRings;
//
// More advanced settings - require additional work
//
//
// Check for changes in the device receive modes
//
// We have 9 options here as described in the table below:
//
// New receive mode | Off | Auto | Manual
// Old receive mode | | |
// ---------------------+-----+------+--------
// Off | 1 | 2 | 3
// ---------------------+-----+------+--------
// Auto | 4 | 5 | 6
// ---------------------+-----+------+--------
// Manual | 7 | 8 | 9
//
//
// Options 1, 5, and 9 mean no change and there's no code to handle them explicitly.
//
if ((FAX_DEVICE_RECEIVE_MODE_AUTO == pNewPortInfo->ReceiveMode) &&
(g_dwManualAnswerDeviceId == dwDeviceId))
{
//
// Change #8 - see table above
//
// Device was in manual-answer mode and we now switch to auto-answer mode
// Keep the line open
//
pLineInfo->Flags |= FPF_RECEIVE;
bVirtualDeviceNeedsUpdate = TRUE;
//
// Mark no device as manual answer device
//
g_dwManualAnswerDeviceId = 0;
goto UpdateManualDevice;
}
else if ((FAX_DEVICE_RECEIVE_MODE_MANUAL == pNewPortInfo->ReceiveMode) &&
(pLineInfo->Flags & FPF_RECEIVE))
{
//
// Change #6 - see table above
//
// Device was in auto-answer mode and we now switch to manual-answer mode
// Keep the line open
//
pLineInfo->Flags &= ~FPF_RECEIVE;
bVirtualDeviceNeedsUpdate = TRUE;
//
// Mark our device as manual answer device
//
g_dwManualAnswerDeviceId = dwDeviceId;
goto UpdateManualDevice;
}
if (!bDeviceWasSetToReceive && (pNewPortInfo->ReceiveMode != FAX_DEVICE_RECEIVE_MODE_OFF))
{
//
// The device should start receiving now (manual or auto).
// Update line info.
//
if (FAX_DEVICE_RECEIVE_MODE_AUTO == pNewPortInfo->ReceiveMode)
{
//
// Change #2 - see table above
//
// If set to auto-receive, mark that in the device info
//
pLineInfo->Flags |= FPF_RECEIVE;
bVirtualDeviceNeedsUpdate = TRUE;
}
else
{
//
// Change #3 - see table above
//
// If manual-receive, update the global manual-receive device id
//
g_dwManualAnswerDeviceId = dwDeviceId;
}
if (!(pLineInfo->Flags & FPF_VIRTUAL) && (!pLineInfo->hLine))
{
if (!OpenTapiLine( pLineInfo ))
{
DWORD rc = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("OpenTapiLine failed. (ec: %ld)"),
rc);
}
}
}
else if (bDeviceWasSetToReceive && (FAX_DEVICE_RECEIVE_MODE_OFF == pNewPortInfo->ReceiveMode))
{
//
// The device should stop receiving now
//
if (dwDeviceId == g_dwManualAnswerDeviceId)
{
//
// Change #7 - see table above
//
// The device was in manual-answer mode
//
Assert (!(pLineInfo->Flags & FPF_RECEIVE));
//
// Set manual-answer device id to 'no device'
//
g_dwManualAnswerDeviceId = 0;
}
else
{
//
// Change #4 - see table above
//
// The device was in auto-answer mode
//
Assert (pLineInfo->Flags & FPF_RECEIVE);
//
// Update line info
//
pLineInfo->Flags &= ~FPF_RECEIVE;
bVirtualDeviceNeedsUpdate = TRUE;
}
if (pLineInfo->State == FPS_AVAILABLE && // Line is available and
pLineInfo->hLine // device is open
)
{
//
// We can not close the line if it is busy.
// We simply remove the FPF_RECEIVE and ReleaseTapiLine will call lineClose when the job terminates.
//
lineClose( pLineInfo->hLine );
pLineInfo->hLine = 0;
}
}
UpdateManualDevice:
if (dwLastManualAnswerDeviceId != g_dwManualAnswerDeviceId)
{
//
// Manual answer device has changed.
// Update the registry
//
dwRes = WriteManualAnswerDeviceId (g_dwManualAnswerDeviceId);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("WriteManualAnswerDeviceId(0) (ec: %lc)"),
dwRes);
}
if (0 != dwLastManualAnswerDeviceId &&
dwDeviceId != dwLastManualAnswerDeviceId)
{
//
// Another device just stopped being the device in manual-anser mode
//
PLINE_INFO pOldLine;
pOldLine = GetTapiLineFromDeviceId (dwLastManualAnswerDeviceId, FALSE);
if (pOldLine)
{
//
// The former device still exists, remove receive enabled flag.
//
pOldLine->Flags &= ~FPF_RECEIVE;
if (pOldLine->State == FPS_AVAILABLE && // Line is available and
pOldLine->hLine) // Device is open
{
//
// This is a good time to close the device
// which just stopped being the manual-answer device
//
lineClose(pOldLine->hLine);
pOldLine->hLine = 0;
}
//
// Check if this device is still enabled
//
if (FALSE == IsDeviceEnabled(pOldLine))
{
Assert (g_dwDeviceEnabledCount);
g_dwDeviceEnabledCount -= 1;
}
}
}
}
//
// Check for changes in the device send mode
//
if (!(pLineInfo->Flags & FPF_SEND) && pNewPortInfo->bSend)
{
//
// The device should start being available for sending now
//
bVirtualDeviceNeedsUpdate = TRUE;
//
// We just added a new device to the send
// capable device collection - signal the queue
//
if (!SetEvent( g_hJobQueueEvent ))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("SetEvent failed (ec: %lc)"),
GetLastError);
g_ScanQueueAfterTimeout = TRUE;
}
//
// Update line info
//
pLineInfo->Flags |= FPF_SEND;
pLineInfo->LastLineClose = 0; // Try to use it on the first try
}
else if ((pLineInfo->Flags & FPF_SEND) && !pNewPortInfo->bSend)
{
//
// The device should stop being available for sending now
// Update line info
//
bVirtualDeviceNeedsUpdate = TRUE;
pLineInfo->Flags &= ~FPF_SEND;
}
if (bVirtualDeviceNeedsUpdate)
{
//
// The Send / Receive status has changed - update the virtual device
//
UpdateVirtualDeviceSendAndReceiveStatus (pLineInfo,
pNewPortInfo->bSend,
(FAX_DEVICE_RECEIVE_MODE_AUTO == pNewPortInfo->ReceiveMode)
);
}
rVal = CreateConfigEvent (FAX_CONFIG_TYPE_DEVICES);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_DEVICES) (ec: %lc)"),
rVal);
}
Assert (ERROR_SUCCESS == dwRes);
exit:
if (pLineInfo)
{
if (bDeviceWasAutoReceive && !(pLineInfo->Flags & FPF_RECEIVE))
{
//
// This device stopped auto receiving
//
SafeDecIdleCounter (&g_dwReceiveDevicesCount);
}
else if (!bDeviceWasAutoReceive && (pLineInfo->Flags & FPF_RECEIVE))
{
//
// This device started auto receiving
//
SafeIncIdleCounter (&g_dwReceiveDevicesCount);
}
//
// Update enabled device count
//
if (bDeviceWasEnabled == TRUE)
{
if (FALSE == IsDeviceEnabled(pLineInfo))
{
Assert (g_dwDeviceEnabledCount);
g_dwDeviceEnabledCount -= 1;
}
}
else
{
//
// The device was not enabled
//
if (TRUE == IsDeviceEnabled(pLineInfo))
{
g_dwDeviceEnabledCount += 1;
Assert (g_dwDeviceEnabledCount <= g_dwDeviceEnabledLimit);
}
}
}
LeaveCriticalSection( &g_CsLine );
LeaveCriticalSectionJobAndQueue;
return GetServerErrorCode(dwRes);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_SetPortEx
error_status_t
FAX_GetJobEx(
IN handle_t hFaxHandle,
IN DWORDLONG dwlMessageId,
OUT LPBYTE *Buffer,
OUT LPDWORD BufferSize
)
/*++
Routine name : FAX_GetJobEx
Routine description:
Fills FAX_JOB_ENTRY_EX of a message specified by its unique ID
Author:
Oded Sacher (OdedS), Nov, 1999
Arguments:
hFaxHandle [in] - Binding handle
dwlMessageId [in] - Unique message ID
Buffer [Out] - Buffer to receive FAX_JOB_ENTRY_EX
BufferSize [out] - The size of Buffer
Return Value:
Standard RPC error codes
--*/
{
PJOB_QUEUE pJobQueue;
ULONG_PTR Offset = 0;
DWORD ulRet = ERROR_SUCCESS;
BOOL bAllMessages = FALSE;
PSID pUserSid = NULL;
BOOL fAccess;
DWORD dwRights;
DWORD dwClientAPIVersion = FindClientAPIVersion(hFaxHandle);
DEBUG_FUNCTION_NAME(TEXT("FAX_GetJobEx"));
Assert (BufferSize); // ref pointer in idl
if (!Buffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
ulRet = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != ulRet)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
ulRet);
return GetServerErrorCode(ulRet);
}
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_JOBS != (dwRights & FAX_ACCESS_QUERY_JOBS))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to view jobs in queue"));
return ERROR_ACCESS_DENIED;
}
//
// Set bAllMessages to the right value
//
if (FAX_ACCESS_QUERY_JOBS == (dwRights & FAX_ACCESS_QUERY_JOBS))
{
bAllMessages = TRUE;
}
DebugPrintEx(DEBUG_MSG,TEXT("Before Enter g_CsJob & Queue"));
EnterCriticalSectionJobAndQueue;
DebugPrintEx(DEBUG_MSG,TEXT("After Enter g_CsJob & Queue"));
pJobQueue = FindJobQueueEntryByUniqueId (dwlMessageId);
if (pJobQueue == NULL || pJobQueue->JobType == JT_BROADCAST)
{
//
// dwlMessageId is not a valid queued job Id.
//
DebugPrintEx(DEBUG_ERR,TEXT("Invalid Parameter - not a valid job Id"));
ulRet = FAX_ERR_MESSAGE_NOT_FOUND;
goto Exit;
}
if (pJobQueue->JobType == JT_SEND)
{
Assert (pJobQueue->lpParentJob);
if (pJobQueue->lpParentJob->JobStatus == JS_DELETING)
{
//
// dwlMessageId is being deleted
//
DebugPrintEx(DEBUG_ERR,TEXT("Job is deleted - not a valid job Id"));
ulRet = FAX_ERR_MESSAGE_NOT_FOUND;
goto Exit;
}
}
if (FALSE == bAllMessages)
{
pUserSid = GetClientUserSID();
if (NULL == pUserSid)
{
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid failed, Error %ld"), ulRet);
goto Exit;
}
if (!UserOwnsJob (pJobQueue, pUserSid))
{
DebugPrintEx(DEBUG_WRN,TEXT("UserOwnsJob failed ,Access denied"));
ulRet = ERROR_ACCESS_DENIED;
goto Exit;
}
}
//
// Allocate buffer memory.
//
if (!GetJobDataEx(NULL,
NULL,
NULL,
dwClientAPIVersion,
pJobQueue,
&Offset,
0))
{
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,TEXT("GetJobDataEx failed ,Error %ld"), ulRet);
goto Exit;
}
*BufferSize = Offset;
*Buffer = (LPBYTE) MemAlloc( *BufferSize );
if (*Buffer == NULL)
{
DebugPrintEx(DEBUG_ERR,TEXT("ERROR_NOT_ENOUGH_MEMORY (Server)"));
ulRet = ERROR_NOT_ENOUGH_MEMORY;
goto Exit;
}
Offset = sizeof(FAX_JOB_STATUSW) + sizeof(FAX_JOB_ENTRY_EXW);
if (!GetJobDataEx(*Buffer,
(PFAX_JOB_ENTRY_EXW)*Buffer,
(PFAX_JOB_STATUSW)(*Buffer + sizeof(FAX_JOB_ENTRY_EXW)),
dwClientAPIVersion,
pJobQueue,
&Offset,
*BufferSize))
{
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,TEXT("GetJobDataEx failed ,Error %ld"), ulRet);
MemFree(*Buffer);
*BufferSize =0;
}
Exit:
LeaveCriticalSectionJobAndQueue;
DebugPrintEx(DEBUG_MSG,TEXT("After Release g_CsJob & g_CsQueue"));
if (NULL != pUserSid)
{
MemFree (pUserSid);
}
return GetServerErrorCode(ulRet);
}
error_status_t
FAX_EnumJobsEx(
IN handle_t hFaxHandle,
IN DWORD dwJobTypes,
OUT LPBYTE *Buffer,
OUT LPDWORD BufferSize,
OUT LPDWORD lpdwJobs
)
/*++
Routine name : FAX_EnumJobsEx
Routine description:
Fills an array of FAX_JOB_ENTR_EX of all messages with type specified in dwJobTypes
Author:
Oded Sacher (OdedS), Nov, 1999
Arguments:
hFaxHandle [in] - Binding handle
dwJobTypes [in] - Specifies the job type filter
Buffer [out] - Buffer to receive FAX_JOB_ENTRY_EX
BufferSize [out] - The size of the buffer
lpdwJobs [out] - Number of FAX_JOB_ENTRY_EX retrieved
Return Value:
None.
--*/
{
PJOB_QUEUE pJobQueue;
DWORD ulRet = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnumJobsEx"));
PLIST_ENTRY Next;
DWORD rVal = 0;
ULONG_PTR Offset = 0;
DWORD Count = 0;
PFAX_JOB_ENTRY_EXW pJobEntry;
PFAX_JOB_STATUSW pFaxStatus;
BOOL bAllMessages = FALSE;
PSID pUserSid = NULL;
BOOL fAccess;
DWORD dwRights;
DWORD dwClientAPIVersion = FindClientAPIVersion(hFaxHandle);
Assert (BufferSize && lpdwJobs); // ref pointer in idl
if (!Buffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
ulRet = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != ulRet)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
ulRet);
return GetServerErrorCode(ulRet);
}
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_JOBS != (dwRights & FAX_ACCESS_QUERY_JOBS))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to Enumerate jobs in queue"));
return ERROR_ACCESS_DENIED;
}
//
// Set bAllMessages to the right value
//
if (FAX_ACCESS_QUERY_JOBS == (dwRights & FAX_ACCESS_QUERY_JOBS))
{
bAllMessages = TRUE;
}
if (FALSE == bAllMessages)
{
pUserSid = GetClientUserSID();
if (NULL == pUserSid)
{
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid failed, Error %ld"), ulRet);
return GetServerErrorCode(ulRet);
}
}
DebugPrintEx(DEBUG_MSG,TEXT("Before Enter g_CsJob & Queue"));
EnterCriticalSectionJobAndQueue;
DebugPrintEx(DEBUG_MSG,TEXT("After Enter g_CsJob & Queue"));
Next = g_QueueListHead.Flink;
while ((ULONG_PTR)Next != (ULONG_PTR)&g_QueueListHead)
{
pJobQueue = CONTAINING_RECORD( Next, JOB_QUEUE, ListEntry );
Next = pJobQueue->ListEntry.Flink;
if (pJobQueue->JobType == JT_SEND)
{
Assert (pJobQueue->lpParentJob);
if (pJobQueue->lpParentJob->JobStatus == JS_DELETING)
{
// do not show this job
continue;
}
}
if (JT_BROADCAST != pJobQueue->JobType &&
(pJobQueue->JobType & dwJobTypes))
{
if (TRUE == bAllMessages)
{
if (!GetJobDataEx(
NULL,
NULL,
NULL,
dwClientAPIVersion,
pJobQueue,
&Offset,
0))
{
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,TEXT("GetJobDataEx failed ,Error %ld"), ulRet);
goto Exit;
}
Count += 1;
}
else
{
if (UserOwnsJob (pJobQueue, pUserSid))
{
if (!GetJobDataEx(
NULL,
NULL,
NULL,
dwClientAPIVersion,
pJobQueue,
&Offset,
0))
{
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,TEXT("GetJobDataEx failed ,Error %ld"), ulRet);
goto Exit;
}
Count += 1;
}
}
}
}
//
// Allocate buffer memory.
//
*BufferSize = Offset;
*Buffer = (LPBYTE) MemAlloc( Offset );
if (*Buffer == NULL)
{
DebugPrintEx(DEBUG_ERR,TEXT("ERROR_NOT_ENOUGH_MEMORY (Server)"));
ulRet = ERROR_NOT_ENOUGH_MEMORY;
goto Exit;
}
Offset = (sizeof(FAX_JOB_ENTRY_EXW) + sizeof(FAX_JOB_STATUSW)) * Count;
pJobEntry = (PFAX_JOB_ENTRY_EXW) *Buffer;
pFaxStatus = (PFAX_JOB_STATUSW) (*Buffer + (sizeof(FAX_JOB_ENTRY_EXW) * Count));
Next = g_QueueListHead.Flink;
while ((ULONG_PTR)Next != (ULONG_PTR)&g_QueueListHead)
{
pJobQueue = CONTAINING_RECORD( Next, JOB_QUEUE, ListEntry );
Next = pJobQueue->ListEntry.Flink;
if (pJobQueue->JobType == JT_SEND)
{
Assert (pJobQueue->lpParentJob);
if (pJobQueue->lpParentJob->JobStatus == JS_DELETING)
{
// do not show this job
continue;
}
}
if (JT_BROADCAST != pJobQueue->JobType &&
(pJobQueue->JobType & dwJobTypes))
{
if (TRUE == bAllMessages)
{
if (!GetJobDataEx (*Buffer, pJobEntry, pFaxStatus, dwClientAPIVersion, pJobQueue, &Offset, *BufferSize))
{
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,TEXT("GetJobDataEx failed ,Error %ld"), ulRet);
goto Exit;
}
pJobEntry ++;
pFaxStatus ++;
}
else
{
if (UserOwnsJob (pJobQueue, pUserSid))
{
if (!GetJobDataEx (*Buffer, pJobEntry, pFaxStatus, dwClientAPIVersion, pJobQueue, &Offset, *BufferSize))
{
ulRet = GetLastError();
DebugPrintEx(DEBUG_ERR,TEXT("GetJobDataEx failed ,Error %ld"), ulRet);
goto Exit;
}
pJobEntry ++;
pFaxStatus ++;
}
}
}
}
*lpdwJobs = Count;
Assert (ERROR_SUCCESS == ulRet);
Exit:
LeaveCriticalSectionJobAndQueue;
DebugPrintEx(DEBUG_MSG,TEXT("After Release g_CsJob & g_CsQueue"));
if (ERROR_SUCCESS != ulRet)
{
MemFree (*Buffer);
*BufferSize = 0;
}
if (NULL != pUserSid)
{
MemFree (pUserSid);
}
UNREFERENCED_PARAMETER (hFaxHandle);
return GetServerErrorCode(ulRet);
}
//********************************************
//* FSP registration
//********************************************
error_status_t
FAX_RegisterServiceProviderEx (
IN handle_t hFaxHandle,
IN LPCWSTR lpctstrGUID,
IN LPCWSTR lpctstrFriendlyName,
IN LPCWSTR lpctstrImageName,
IN LPCWSTR lpctstrTspName,
IN DWORD dwFSPIVersion,
IN DWORD dwCapabilities
)
/*++
Routine name : FAX_RegisterServiceProviderEx
Routine description:
Registers an FSP
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hFaxHandle [in] - Handle to fax server - unused
lpctstrGUID [in] - GUID of FSP
lpctstrFriendlyName [in] - Friendly name of FSP
lpctstrImageName [in] - Image name of FSP. May contain environment variables
lpctstrTspName [in] - TSP name of FSP.
dwFSPIVersion [in] - FSP's API version.
dwCapabilities [in] - FSP's extended capabilities.
Return Value:
Standard RPC error code
--*/
{
DWORD dwRes = ERROR_SUCCESS;
HANDLE hFile = INVALID_HANDLE_VALUE;
LPCWSTR lpcwstrExpandedImage = NULL;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_RegisterServiceProviderEx"));
Assert (lpctstrGUID && lpctstrFriendlyName && lpctstrImageName && lpctstrTspName);
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return dwRes;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_MANAGE_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
if (MAX_FAX_STRING_LEN < lstrlen (lpctstrFriendlyName) ||
MAX_FAX_STRING_LEN < lstrlen (lpctstrImageName) ||
MAX_FAX_STRING_LEN < lstrlen (lpctstrTspName))
{
return ERROR_BUFFER_OVERFLOW;
}
//
// Verify GUID format
//
dwRes = IsValidGUID (lpctstrGUID);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Invalid GUID (dwRes: %ld)"),
dwRes);
return dwRes;
}
//
// Verify version field range
//
if (FSPI_API_VERSION_1 != dwFSPIVersion ||
dwCapabilities)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("dwFSPIVersion invalid (0x%08x), or not valid capability (0x%08x)"),
dwFSPIVersion,
dwCapabilities);
return ERROR_INVALID_PARAMETER;
}
//
// Make sure the FSP isn't already registered (by it's GUID)
//
if (FindFSPByGUID (lpctstrGUID))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FSP with same GUID already exists (%s)"),
lpctstrGUID);
return ERROR_ALREADY_EXISTS;
}
//
// Make sure the FSP isn't already registered (by it's TSP name)
//
if (FindDeviceProvider ((LPWSTR)lpctstrTspName, FALSE))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FSP with same TSP name already exists (%s)"),
lpctstrGUID);
return ERROR_ALREADY_EXISTS;
}
//
// Make sure the image name parameter points to a file
//
lpcwstrExpandedImage = ExpandEnvironmentString (lpctstrImageName);
if (NULL == lpcwstrExpandedImage)
{
dwRes = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("Error expanding image name (%s) (ec = %ld)"),
lpctstrImageName,
dwRes);
return dwRes;
}
hFile = SafeCreateFile (
lpcwstrExpandedImage,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (INVALID_HANDLE_VALUE == hFile)
{
//
// Couldn't open the file
//
dwRes = GetLastError ();
if (ERROR_FILE_NOT_FOUND == dwRes)
{
//
// Image name (after environment expansion) doesn't exist
//
DebugPrintEx(
DEBUG_ERR,
TEXT("Image file (%s) doesn't exist"),
lpctstrImageName);
dwRes = ERROR_INVALID_PARAMETER;
}
else
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Error opening image file (%s) (ec = %ld)"),
lpctstrImageName,
dwRes);
}
goto exit;
}
//
// Everything's OK - Add the new FSP to the registry
//
dwRes = AddNewProviderToRegistry (lpctstrGUID,
lpctstrFriendlyName,
lpctstrImageName,
lpctstrTspName,
dwFSPIVersion);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("AddNewProviderToRegistry returned %ld"),
dwRes);
goto exit;
}
Assert (ERROR_SUCCESS == dwRes);
exit:
if (INVALID_HANDLE_VALUE != hFile)
{
CloseHandle (hFile);
}
MemFree ((LPVOID)lpcwstrExpandedImage);
return dwRes;
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_RegisterServiceProviderEx
error_status_t
FAX_UnregisterServiceProviderEx (
IN handle_t hFaxHandle,
IN LPCWSTR lpctstrGUID
)
/*++
Routine name : FAX_UnregisterServiceProviderEx
Routine description:
Unregisters an FSP
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hFaxHandle [in] - Handle to fax server - unused
lpctstrGUID [in] - GUID of FSP
(or provider name for legacy FSPs registered
through FaxRegisterServiceProvider)
Return Value:
Standard RPC error code
--*/
{
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_UnregisterServiceProviderEx"));
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return dwRes;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_MANAGE_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
Assert (lpctstrGUID);
//
// Remove the FSP from registry
//
return RemoveProviderFromRegistry (lpctstrGUID);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_UnregisterServiceProviderEx
//********************************************
//* Routing Extension unregistration
//********************************************
//
// Registration of routing extensions is local (non-RPC)
//
error_status_t
FAX_UnregisterRoutingExtension (
IN handle_t hFaxHandle,
IN LPCWSTR lpctstrExtensionName
)
/*++
Routine name : FAX_UnregisterRoutingExtension
Routine description:
Unregisters a routing extension
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hFaxHandle [in] - Handle to fax server - unused
lpctstrExtensionName [in] - Unique name of routing extension.
This is the actual registry key.
Return Value:
Standard RPC error code
--*/
{
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
HKEY hKey = NULL;
DWORD dw;
DEBUG_FUNCTION_NAME(TEXT("FAX_UnregisterRoutingExtension"));
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return dwRes;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_MANAGE_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
Assert (lpctstrExtensionName);
//
// Remove the routing extension from registry
//
dwRes = RegOpenKeyEx (HKEY_LOCAL_MACHINE, REGKEY_ROUTING_EXTENSION_KEY, 0, KEY_READ | KEY_WRITE, &hKey);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Error opening extensions key (ec = %ld)"),
dwRes);
return dwRes;
}
//
// Delete (recursively) the extension's key and subkeys.
//
if (!DeleteRegistryKey (hKey, lpctstrExtensionName))
{
dwRes = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("Error deleting extension key ( %s ) (ec = %ld)"),
lpctstrExtensionName,
dwRes);
}
dw = RegCloseKey (hKey);
if (ERROR_SUCCESS != dw)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Error closing extensions key (ec = %ld)"),
dw);
}
return dwRes;
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_UnregisterRoutingExtension
//********************************************
//* Archive jobs
//********************************************
error_status_t
FAX_StartMessagesEnum (
IN handle_t hFaxHandle,
IN FAX_ENUM_MESSAGE_FOLDER Folder,
OUT PRPC_FAX_MSG_ENUM_HANDLE lpHandle
)
/*++
Routine name : FAX_StartMessagesEnum
Routine description:
A fax client application calls the FAX_StartMessagesEnum
function to start enumerating messages in one of the archives
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hFaxHandle [in ] - Specifies a fax server handle returned by a call
to the FaxConnectFaxServer function.
Folder [in ] - The type of the archive where the message resides.
FAX_MESSAGE_FOLDER_QUEUE is an invalid
value for this parameter.
lpHandle [out] - Points to an enumeration handle return value.
Return Value:
Standard RPC error code
--*/
{
error_status_t Rval = ERROR_SUCCESS;
WIN32_FIND_DATA FileFindData;
HANDLE hFileFind = INVALID_HANDLE_VALUE;
BOOL bAllMessages = FALSE;
PSID pUserSid = NULL;
LPWSTR lpwstrCallerSID = NULL;
WCHAR wszSearchPattern[MAX_PATH] = {0};
WCHAR wszArchiveFolder [MAX_PATH];
PHANDLE_ENTRY pHandleEntry;
BOOL fAccess;
DWORD dwRights;
DEBUG_FUNCTION_NAME(TEXT("FAX_StartMessagesEnum"));
Assert (lpHandle);
if ((FAX_MESSAGE_FOLDER_INBOX != Folder) &&
(FAX_MESSAGE_FOLDER_SENTITEMS != Folder))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Bad folder specified (%ld)"),
Folder);
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return GetServerErrorCode(Rval);
}
if (FAX_MESSAGE_FOLDER_INBOX == Folder)
{
if (FAX_ACCESS_QUERY_IN_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_IN_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to enumerate Inbox messages"));
return ERROR_ACCESS_DENIED;
}
bAllMessages = TRUE;
}
else
{
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_OUT_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to enumerate Outbox messages"));
return ERROR_ACCESS_DENIED;
}
if (FAX_ACCESS_QUERY_OUT_ARCHIVE == (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
bAllMessages = TRUE;
}
}
EnterCriticalSection (&g_CsConfig);
lstrcpyn (wszArchiveFolder, g_ArchivesConfig[Folder].lpcstrFolder, MAX_PATH);
LeaveCriticalSection (&g_CsConfig);
if (!bAllMessages)
{
//
// We want only the messages of the calling user - get its SID.
//
pUserSid = GetClientUserSID();
if (NULL == pUserSid)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid failed, Error %ld"), Rval);
return GetServerErrorCode(Rval);
}
if (!ConvertSidToStringSid (pUserSid, &lpwstrCallerSID))
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("ConvertSidToStringSid failed, Error %ld"), Rval);
goto exit;
}
if (0 > _snwprintf (wszSearchPattern,
ARR_SIZE(wszSearchPattern) -1,
L"%s\\%s$*.tif",
wszArchiveFolder,
lpwstrCallerSID))
{
//
// We exceeded MAX_PATH characters
//
Rval = ERROR_BUFFER_OVERFLOW;
DebugPrintEx(DEBUG_ERR,
TEXT("Search pattern exceeds MAX_PATH characters"));
LocalFree (lpwstrCallerSID);
goto exit;
}
LocalFree (lpwstrCallerSID);
}
else
{
//
// Get all archive files
//
if (0 > _snwprintf (wszSearchPattern,
ARR_SIZE(wszSearchPattern) -1,
L"%s\\*.tif",
wszArchiveFolder))
{
//
// We exceeded MAX_PATH characters
//
Rval = ERROR_BUFFER_OVERFLOW;
DebugPrintEx(DEBUG_ERR,
TEXT("Search pattern exceeds MAX_PATH characters"));
goto exit;
}
}
//
// Start searching the archive folder.
// Search pattern is wszSearchPattern
//
hFileFind = FindFirstFile (wszSearchPattern, &FileFindData);
if (INVALID_HANDLE_VALUE == hFileFind)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("FindFirstFile failed, Error %ld"), Rval);
if (ERROR_FILE_NOT_FOUND == Rval)
{
Rval = ERROR_NO_MORE_ITEMS;
}
goto exit;
}
//
// Now, create a context handle from the result
//
pHandleEntry = CreateNewMsgEnumHandle( hFaxHandle,
hFileFind,
FileFindData.cFileName,
Folder
);
if (!pHandleEntry)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("CreateNewMsgEnumHandle failed, Error %ld"), Rval);
goto exit;
}
*lpHandle = (HANDLE) pHandleEntry;
Assert (ERROR_SUCCESS == Rval);
exit:
if ((ERROR_SUCCESS != Rval) && (INVALID_HANDLE_VALUE != hFileFind))
{
//
// Error and the search handle is still open
//
if (!FindClose (hFileFind))
{
DWORD dw = GetLastError ();
DebugPrintEx(DEBUG_ERR,
TEXT("FindClose failed, Error %ld"), dw);
}
}
MemFree ((LPVOID)pUserSid);
return GetServerErrorCode(Rval);
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_StartMessagesEnum
error_status_t
FAX_EndMessagesEnum (
IN OUT LPHANDLE lpHandle
)
/*++
Routine name : FAX_EndMessagesEnum
Routine description:
A fax client application calls the FAX_EndMessagesEnum function to stop
enumerating messages in one of the archives.
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
lpHandle [in] - The enumeration handle value.
This value is obtained by calling FAX_StartMessagesEnum.
Return Value:
Standard RPC error code
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_EndMessagesEnum"));
if (NULL == *lpHandle)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("NULL Context handle"));
return ERROR_INVALID_PARAMETER;
}
CloseFaxHandle( (PHANDLE_ENTRY) *lpHandle );
*lpHandle = NULL;
return ERROR_SUCCESS;
} // FAX_EndMessagesEnum
VOID
RPC_FAX_MSG_ENUM_HANDLE_rundown(
IN HANDLE FaxMsgEnumHandle
)
/*++
Routine name : RPC_FAX_MSG_ENUM_HANDLE_rundown
Routine description:
The RPC rundown function of the message enumeration handle.
This function is called if the client abruptly disconnected on us.
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
FaxMsgEnumHandle [in] - Message enumeration handle.
Return Value:
None.
--*/
{
PHANDLE_ENTRY pHandleEntry = (PHANDLE_ENTRY) FaxMsgEnumHandle;
DEBUG_FUNCTION_NAME(TEXT("RPC_FAX_MSG_ENUM_HANDLE_rundown"));
DebugPrintEx(
DEBUG_WRN,
TEXT("RPC_FAX_MSG_ENUM_HANDLE_rundown: handle = 0x%08x"),
FaxMsgEnumHandle);
CloseFaxHandle( pHandleEntry );
return;
} // RPC_FAX_MSG_ENUM_HANDLE_rundown
static
DWORD
RetrieveMessage (
LPCWSTR lpcwstrFileName,
FAX_ENUM_MESSAGE_FOLDER Folder,
PFAX_MESSAGE *ppFaxMsg
)
/*++
Routine name : RetrieveMessage
Routine description:
Allocates and reads a message from the archive.
To free the message call FreeMessageBuffer () on the returned message.
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
lpcwstrFileName [in ] - Name (not full path) of the file
containing the message to retrieve.
Folder [in ] - Archive folder where the message resides.
ppFaxMsg [out] - Pointer to a message buffer to allocate.
Return Value:
Standard Win32 error code.
--*/
{
DWORD dwRes = ERROR_SUCCESS;
WCHAR wszMsgFile [MAX_PATH] = {0};
DEBUG_FUNCTION_NAME(TEXT("RetrieveMessage"));
EnterCriticalSection (&g_CsConfig);
int iRes = _snwprintf (wszMsgFile,
ARR_SIZE(wszMsgFile) -1,
L"%s\\%s",
g_ArchivesConfig[Folder].lpcstrFolder,
lpcwstrFileName
);
LeaveCriticalSection (&g_CsConfig);
if (0 > iRes)
{
//
// We exceeded MAX_PATH characters
//
DebugPrintEx(DEBUG_ERR,
TEXT("Search pattern exceeds MAX_PATH characters"));
return ERROR_BUFFER_OVERFLOW;
}
*ppFaxMsg = (PFAX_MESSAGE) MemAlloc (sizeof (FAX_MESSAGE));
if (NULL == *ppFaxMsg)
{
DebugPrintEx( DEBUG_ERR,
TEXT("Cannot allocate memory for a FAX_MESSAGE structure"));
return ERROR_NOT_ENOUGH_MEMORY;
}
if (!GetMessageNTFSStorageProperties (wszMsgFile, *ppFaxMsg))
{
if(!GetMessageMsTags (wszMsgFile, *ppFaxMsg))
{
dwRes = GetLastError ();
DebugPrintEx( DEBUG_ERR,
TEXT("GetMessageNTFSStorageProperties returned error %ld"),
dwRes);
goto exit;
}
}
exit:
if (ERROR_SUCCESS != dwRes)
{
MemFree (*ppFaxMsg);
*ppFaxMsg = NULL;
}
return dwRes;
} // RetrieveMessage
VOID
FreeMessageBuffer (
PFAX_MESSAGE pFaxMsg,
BOOL fDestroy
)
/*++
Routine name : FreeMessageBuffer
Routine description:
Frees a previously allocated message buffer.
The allocated message was created by calling RetrieveMessage().
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
pFaxMsg [in] - Message to free
fDestroy [in] - Free structure
Return Value:
None.
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FreeMessageBuffer"));
MemFree ((LPVOID)pFaxMsg->lpctstrRecipientNumber);
MemFree ((LPVOID)pFaxMsg->lpctstrRecipientName);
MemFree ((LPVOID)pFaxMsg->lpctstrSenderNumber);
MemFree ((LPVOID)pFaxMsg->lpctstrSenderName);
MemFree ((LPVOID)pFaxMsg->lpctstrTsid);
MemFree ((LPVOID)pFaxMsg->lpctstrCsid);
MemFree ((LPVOID)pFaxMsg->lpctstrSenderUserName);
MemFree ((LPVOID)pFaxMsg->lpctstrBillingCode);
MemFree ((LPVOID)pFaxMsg->lpctstrDeviceName);
MemFree ((LPVOID)pFaxMsg->lpctstrDocumentName);
MemFree ((LPVOID)pFaxMsg->lpctstrSubject);
MemFree ((LPVOID)pFaxMsg->lpctstrCallerID);
MemFree ((LPVOID)pFaxMsg->lpctstrRoutingInfo);
MemFree ((LPVOID)pFaxMsg->lpctstrExtendedStatus);
if (fDestroy)
{
MemFree ((LPVOID)pFaxMsg);
}
} // FreeMessageBuffer
static
VOID
SerializeMessage (
LPBYTE lpBuffer,
PULONG_PTR Offset,
DWORD dwClientAPIVersion,
DWORD dwMsgIndex,
PFAX_MESSAGE pMsg,
DWORD dwBufferSize)
/*++
Routine name : SerializeMessage
Routine description:
Stores a FAX_MESSAGE in an RPC serialized manner into a buffer.
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
lpBuffer [in ] - Pointer to buffer head.
If this value is NULL, no serialization is done.
Only the pupOffset value gets advanced by the total
size required to store the strings in the message
(but not the FAX_MESSAGE structure itself).
Offset [in/out] - Pointer to a ULONG_PTR specifying the next variable
length part of the buffer.
dwClientAPIVersion [in] - API version of the client
dwMsgIndex [in ] - The 0-based index of the message to store
within the buffer
pMsg [in ] - Source message to store
dwBufferSize [in ] - Size of the buffer lpBuffer, in bytes.
This parameter is used only if Buffer is not NULL.
Return Value:
None.
--*/
{
Assert (pMsg);
DEBUG_FUNCTION_NAME(TEXT("SerializeMessage"));
PFAX_MESSAGE pDstMsg = (PFAX_MESSAGE)&(lpBuffer[sizeof (FAX_MESSAGE) * dwMsgIndex]);
if (lpBuffer)
{
if (FAX_API_VERSION_1 > dwClientAPIVersion)
{
//
// Clients that use API version 0 can't handle JS_EX_CALL_COMPLETED and JS_EX_CALL_ABORTED
//
if (FAX_API_VER_0_MAX_JS_EX < pMsg->dwExtendedStatus)
{
//
// Turn off the extended status field
//
pMsg->dwExtendedStatus = 0;
pMsg->dwValidityMask &= ~FAX_JOB_FIELD_STATUS_EX;
}
}
//
// Copy message structure first
//
memcpy (pDstMsg,
pMsg,
sizeof (FAX_MESSAGE));
}
//
// Serialize strings
//
StoreString (pMsg->lpctstrRecipientNumber,
(PULONG_PTR)&pDstMsg->lpctstrRecipientNumber,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrRecipientName,
(PULONG_PTR)&pDstMsg->lpctstrRecipientName,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrSenderNumber,
(PULONG_PTR)&pDstMsg->lpctstrSenderNumber,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrSenderName,
(PULONG_PTR)&pDstMsg->lpctstrSenderName,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrTsid,
(PULONG_PTR)&pDstMsg->lpctstrTsid,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrCsid,
(PULONG_PTR)&pDstMsg->lpctstrCsid,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrSenderUserName,
(PULONG_PTR)&pDstMsg->lpctstrSenderUserName,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrBillingCode,
(PULONG_PTR)&pDstMsg->lpctstrBillingCode,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrDeviceName,
(PULONG_PTR)&pDstMsg->lpctstrDeviceName,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrDocumentName,
(PULONG_PTR)&pDstMsg->lpctstrDocumentName,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrSubject,
(PULONG_PTR)&pDstMsg->lpctstrSubject,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrCallerID,
(PULONG_PTR)&pDstMsg->lpctstrCallerID,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrRoutingInfo,
(PULONG_PTR)&pDstMsg->lpctstrRoutingInfo,
lpBuffer,
Offset,
dwBufferSize);
StoreString (pMsg->lpctstrExtendedStatus,
(PULONG_PTR)&pDstMsg->lpctstrExtendedStatus,
lpBuffer,
Offset,
dwBufferSize);
} // SerializeMessage
error_status_t
FAX_EnumMessages(
IN RPC_FAX_MSG_ENUM_HANDLE hEnum,
IN DWORD dwNumMessages,
IN OUT LPBYTE *lppBuffer,
IN OUT LPDWORD lpdwBufferSize,
OUT LPDWORD lpdwNumMessagesRetrieved
)
/*++
Routine name : FAX_EnumMessages
Routine description:
A fax client application calls the FAX_EnumMessages function to enumerate
messages in one of the archives.
This function is incremental. That is, it uses an internal context cursor to
point to the next set of messages to retrieve for each call.
The cursor is set to point to the begging of the messages in the archive after a
successful call to FAX_StartMessagesEnum.
Each successful call to FAX_EnumMessages advances the cursor by the number of
messages retrieved.
Once the cursor reaches the end of the enumeration,
the function fails with ERROR_NO_MORE_ITEMS error code.
The FAX_EndMessagesEnum function should be called then.
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hEnum [in ] - The enumeration handle value.
This value is obtained by calling
FAX_StartMessagesEnum.
dwNumMessages [in ] - A DWORD value indicating the maximal number
of messages the caller requires to enumerate.
This value cannot be zero.
lppBuffer [out] - A pointer to a buffer of FAX_MESSAGE structures.
This buffer will contain lpdwReturnedMsgs entries.
The buffer will be allocated by the function
and the caller must free it.
lpdwBufferSize [out] - The size (in bytes) of the lppBuffer buffer.
lpdwNumMessagesRetrieved [out] - Pointer to a DWORD value indicating the actual
number of messages retrieved.
This value cannot exceed dwNumMessages.
Return Value:
Standard RPC error code
--*/
{
error_status_t Rval = ERROR_SUCCESS;
DWORD dw;
DWORD_PTR dwOffset;
PFAX_MESSAGE *pMsgs = NULL;
DWORD dwClientAPIVersion;
PHANDLE_ENTRY pHandle = (PHANDLE_ENTRY)hEnum;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnumMessages"));
dwClientAPIVersion = pHandle->dwClientAPIVersion;
Assert (lpdwBufferSize && lpdwNumMessagesRetrieved); // ref pointer in idl
if (!lppBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
if (NULL == hEnum)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("NULL context handle"));
return ERROR_INVALID_PARAMETER;
}
Assert ((INVALID_HANDLE_VALUE != pHandle->hFile));
if (!dwNumMessages)
{
return ERROR_INVALID_PARAMETER;
}
//
// Create array of dwNumMessages pointers to FAX_MESSAGE structures and NULLify it.
//
pMsgs = (PFAX_MESSAGE *) MemAlloc (sizeof (PFAX_MESSAGE) * dwNumMessages);
if (!pMsgs)
{
DebugPrintEx( DEBUG_ERR,
TEXT("Cannot allocate memory for a PFAX_MESSAGE array [%ld]"),
dwNumMessages);
return FAX_ERR_SRV_OUTOFMEMORY;
}
memset (pMsgs, 0, sizeof (PFAX_MESSAGE) * dwNumMessages);
//
// Next, start collecting messages into the array.
// Stop when dwNumMessages is reached or no more messages are available.
//
*lpdwBufferSize = 0;
*lpdwNumMessagesRetrieved = 0;
while ((*lpdwNumMessagesRetrieved) < dwNumMessages)
{
DWORD_PTR dwMsgSize = sizeof (FAX_MESSAGE);
LPWSTR lpwstrFileToRetrieve;
WIN32_FIND_DATA FindData;
if (lstrlen (pHandle->wstrFileName))
{
//
// This is the first file in an enumeration session
//
lpwstrFileToRetrieve = pHandle->wstrFileName;
}
else
{
//
// Find next file using the find file handle
//
if (!FindNextFile (pHandle->hFile, &FindData))
{
Rval = GetLastError ();
if (ERROR_NO_MORE_FILES == Rval)
{
//
// This is not a real error - just the end of files.
// Break the loop.
//
Rval = ERROR_SUCCESS;
break;
}
DebugPrintEx( DEBUG_ERR,
TEXT("FindNextFile returned error %ld"),
Rval);
goto exit;
}
lpwstrFileToRetrieve = FindData.cFileName;
}
//
// Get the message now from lpwstrFileToRetrieve
//
Rval = RetrieveMessage (lpwstrFileToRetrieve,
pHandle->Folder,
&(pMsgs[*lpdwNumMessagesRetrieved]));
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx( DEBUG_ERR,
TEXT("RetrieveMessage returned error %ld"),
Rval);
if (ERROR_NOT_ENOUGH_MEMORY != Rval && ERROR_OUTOFMEMORY != Rval)
{
//
// The error is related to the Message itself.
// This will not stop us from searching the rest of the messages.
//
//
// Mark (in the enumeration handle) the fact that the first file was read.
//
lstrcpy (pHandle->wstrFileName, L"");
continue;
}
goto exit;
}
//
// Mark (in the enumeration handle) the fact that the first file was read.
//
lstrcpy (pHandle->wstrFileName, L"");
//
// Get the size of the retrieved message
//
SerializeMessage (NULL, &dwMsgSize, dwClientAPIVersion, 0, pMsgs[*lpdwNumMessagesRetrieved],0);
*lpdwBufferSize += (DWORD)dwMsgSize;
(*lpdwNumMessagesRetrieved)++;
} // End of enumeration loop
if (0 == *lpdwNumMessagesRetrieved)
{
//
// No file(s) retrieved
//
*lppBuffer = NULL;
Assert (0 == *lpdwBufferSize);
Rval = ERROR_NO_MORE_ITEMS;
goto exit;
}
//
// Allocate return buffer
//
*lppBuffer = (LPBYTE) MemAlloc (*lpdwBufferSize);
if (!*lppBuffer)
{
DebugPrintEx( DEBUG_ERR,
TEXT("Cannot allocate memory for return buffer (%ld bytes)"),
*lpdwBufferSize);
Rval = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
//
// Place all messages in the return buffer
//
dwOffset = sizeof(FAX_MESSAGE) * (*lpdwNumMessagesRetrieved);
for (dw = 0; dw < *lpdwNumMessagesRetrieved; dw++)
{
//
// Store retrieved message in return buffer
//
SerializeMessage (*lppBuffer, &dwOffset, dwClientAPIVersion, dw, pMsgs[dw], *lpdwBufferSize);
}
Assert (dwOffset == *lpdwBufferSize);
Assert (ERROR_SUCCESS == Rval);
exit:
//
// Free local array of messages
//
for (dw = 0; dw < dwNumMessages; dw++)
{
if (NULL != pMsgs[dw])
{
FreeMessageBuffer (pMsgs[dw], TRUE);
}
}
//
// Free array of message pointers
//
MemFree (pMsgs);
return GetServerErrorCode(Rval);
} // FAX_EnumMessages
static
DWORD
FindArchivedMessage (
FAX_ENUM_MESSAGE_FOLDER IN Folder,
DWORDLONG IN dwlMsgId,
BOOL IN bAllMessages,
LPWSTR OUT lpwstrFileName,
DWORD IN cchFileName,
LPWSTR OUT lpwstrFilePath,
DWORD IN cchFilePath
)
/*++
Routine name : FindArchivedMessage
Routine description:
Finds the file containing the message in an archive
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
Folder [in ] - Archive / queue folder
dwlMessageId [in ] - Unique message id
bAllMessages [in ] - TRUE if the caller is allowed to view all messages
lpwstrFileName [out] - Optional. If not NULL, will contain the file name
and extension of the archive message file.
cchFileName [in] - Length, in TCHARs, of lpwstrFileName
lpwstrFilePath [out] - Optional. If not NULL, will contain the full path
of the archive message file.
cchFilePath [in] - Length, in TCHARs, of lpwstrFilePath
Return Value:
Standard RPC error code
--*/
{
WCHAR wszArchiveFolder[MAX_PATH * 2] = {0};
DWORD dwRes = ERROR_SUCCESS;
LPWSTR lpwstrResultFullPath;
HRESULT hr;
DEBUG_FUNCTION_NAME(TEXT("FindArchivedMessage"));
EnterCriticalSection (&g_CsConfig);
hr = StringCchCopy (wszArchiveFolder, ARR_SIZE(wszArchiveFolder), g_ArchivesConfig[Folder].lpcstrFolder);
if (FAILED(hr))
{
ASSERT_FALSE;
DebugPrintEx(DEBUG_ERR,
TEXT("StringCchCopy failed with 0x%08x"),
hr);
LeaveCriticalSection (&g_CsConfig);
return HRESULT_CODE(hr);
}
LeaveCriticalSection (&g_CsConfig);
if (FAX_MESSAGE_FOLDER_INBOX == Folder)
{
Assert (TRUE == bAllMessages);
//
// Get full name of Inbox archive file
//
lpwstrResultFullPath = GetRecievedMessageFileName (dwlMsgId);
if (!lpwstrResultFullPath)
{
dwRes = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("GetRecievedMessageFileName Failed, Error %ld"), dwRes);
return dwRes;
}
}
else if (FAX_MESSAGE_FOLDER_SENTITEMS == Folder)
{
//
// Get full name of sent items archive file
//
PSID pUserSid = NULL;
if (!bAllMessages)
{
//
// If the user doesn't have the right to view all messages
//
// Get SID of caller
//
pUserSid = GetClientUserSID();
if (NULL == pUserSid)
{
dwRes = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid failed, Error %ld"), dwRes);
return dwRes;
}
}
//
// Get full name of sent items archive file
//
lpwstrResultFullPath = GetSentMessageFileName (dwlMsgId, pUserSid);
if (!lpwstrResultFullPath)
{
dwRes = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("GetSentMessageFileName Failed, Error %ld"), dwRes);
MemFree ((LPVOID)pUserSid);
return dwRes;
}
MemFree ((LPVOID)pUserSid);
}
else
{
//
// We don't support any other archive type
//
DebugPrintEx(
DEBUG_ERR,
TEXT("Bad archive folder type %ld"), Folder);
ASSERT_FALSE;
}
if (lpwstrFilePath)
{
//
// Copy full path back to caller
//
hr = StringCchCopy (lpwstrFilePath, cchFilePath, lpwstrResultFullPath);
if (FAILED(hr))
{
DebugPrintEx(DEBUG_ERR,
TEXT("StringCchCopy failed with 0x%08x"),
hr);
dwRes = HRESULT_CODE(hr);
goto exit;
}
}
if (lpwstrFileName)
{
WCHAR wszExt[MAX_PATH];
WCHAR wszFileName[MAX_PATH * 2];
//
// Split just the file name back to the caller (optional)
//
_wsplitpath (lpwstrResultFullPath, NULL, NULL, wszFileName, wszExt);
hr = StringCchPrintf (lpwstrFileName, cchFileName, TEXT("%s%s"), wszFileName, wszExt);
if (FAILED(hr))
{
DebugPrintEx(DEBUG_ERR,
TEXT("StringCchCopy failed with 0x%08x"),
hr);
dwRes = HRESULT_CODE(hr);
goto exit;
}
}
exit:
MemFree ((LPVOID)lpwstrResultFullPath);
return dwRes;
} // FindArchivedMessage
static
DWORD
CreatePreviewFile (
DWORDLONG dwlMsgId,
BOOL bAllMessages,
PJOB_QUEUE* lppJobQueue
)
/*++
Routine name : CreatePreviewFile
Routine description:
Creates a tiff preview file it if does not exist.
If the function succeeds it increase the job reference count.
Author:
Oded Sacher (OdedS), Jan, 2000
Arguments:
dwlMessageId [in ] - Unique message id
bAllMessages [in ] - TRUE if the caller has right to view all messages
lppJobQueue [out] - Address of a pointer to receive the job queue with the new preview file.
Return Value:
Standard Win32 error code
--*/
{
DWORD dwRes = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("CreatePreviewFile"));
PJOB_QUEUE pJobQueue;
PSID pUserSid = NULL;
DWORD dwJobStatus;
Assert (lppJobQueue);
EnterCriticalSection (&g_CsQueue);
//
// Find queue entry
//
pJobQueue = FindJobQueueEntryByUniqueId (dwlMsgId);
//
// The caller may view incoming jobs only if they are ROUTING
// (if they are successfully finished with routing, they're in the archive) or
// outgoing jobs that are SEND (that is - not broadcast).
//
if (pJobQueue == NULL)
{
//
// dwlMsgId is not in the queue .
//
DebugPrintEx(DEBUG_ERR,
TEXT("Invalid Parameter - bad job Id (%I64ld) ,not in the queue"),
dwlMsgId);
dwRes = FAX_ERR_MESSAGE_NOT_FOUND;
goto exit;
}
dwJobStatus = (JT_SEND== pJobQueue->JobType) ? pJobQueue->lpParentJob->JobStatus : pJobQueue->JobStatus;
if (dwJobStatus == JS_DELETING)
{
//
// Job is being deleted.
//
DebugPrintEx(DEBUG_ERR,
TEXT("Invalid Parameter - job Id (%I64ld) is being deleted"),
dwlMsgId);
dwRes = FAX_ERR_MESSAGE_NOT_FOUND;
goto exit;
}
if ( (pJobQueue->JobType != JT_ROUTING) &&
(pJobQueue->JobType != JT_SEND) )
{
//
// dwlMsgId is not a valid job id in the queue.
//
DebugPrintEx(DEBUG_ERR,
TEXT("Invalid Parameter - bad job Id (%I64ld), not a recipient or routing job"),
dwlMsgId);
dwRes = ERROR_INVALID_OPERATION;
goto exit;
}
//
// Basic access checks
//
if (!bAllMessages)
{
//
// Make sure the user looks only at his own messages here
// Get SID of caller
//
pUserSid = GetClientUserSID();
if (NULL == pUserSid)
{
dwRes = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid failed, Error %ld"), dwRes);
goto exit;
}
if (!UserOwnsJob (pJobQueue, pUserSid))
{
DebugPrintEx(DEBUG_WRN,TEXT("UserOwnsJob failed ,Access denied"));
dwRes = ERROR_ACCESS_DENIED;
goto exit;
}
}
//
// Create tiff preview file
//
EnterCriticalSection (&pJobQueue->CsPreview);
if (!CreateTiffFileForPreview(pJobQueue))
{
dwRes = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("[JobId: %ld] CreateTiffFileForPreview failed. (ec: %ld)"),
pJobQueue->JobId,
dwRes
);
LeaveCriticalSection (&pJobQueue->CsPreview);
goto exit;
}
LeaveCriticalSection (&pJobQueue->CsPreview);
Assert (pJobQueue->PreviewFileName);
//
// Return the job queue back to caller
//
*lppJobQueue = pJobQueue;
Assert (ERROR_SUCCESS == dwRes);
exit:
MemFree ((LPVOID)pUserSid);
if (ERROR_SUCCESS == dwRes)
{
IncreaseJobRefCount (pJobQueue, TRUE);
}
LeaveCriticalSection (&g_CsQueue);
return dwRes;
} // CreatePreviewFile
error_status_t
FAX_GetMessage (
IN handle_t hFaxHandle,
IN DWORDLONG dwlMessageId,
IN FAX_ENUM_MESSAGE_FOLDER Folder,
IN OUT LPBYTE *lppBuffer,
IN OUT LPDWORD lpdwBufferSize
)
/*++
Routine name : FAX_GetMessage
Routine description:
Removes a message from an archive
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hFaxHandle [in ] - Unused
dwlMessageId [in ] - Unique message id
Folder [in ] - Archive folder
lppBuffer [out] - Pointer to buffer to hold message information
lpdwBufferSize [out] - Pointer to buffer size
Return Value:
Standard RPC error code
--*/
{
error_status_t Rval = ERROR_SUCCESS;
DWORD_PTR dwOffset;
PFAX_MESSAGE pMsg = NULL;
WCHAR wszMsgFileName[MAX_PATH];
BOOL fAccess;
DWORD dwRights;
BOOL bAllMessages = FALSE;
DWORD dwClientAPIVersion;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetMessage"));
dwClientAPIVersion = FindClientAPIVersion (hFaxHandle);
Assert (lpdwBufferSize); // ref pointer in idl
if (!lppBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
if (!dwlMessageId)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Invalid message id sepcified (%I64ld)"),
dwlMessageId);
return ERROR_INVALID_PARAMETER;
}
if ((FAX_MESSAGE_FOLDER_INBOX != Folder) &&
(FAX_MESSAGE_FOLDER_SENTITEMS != Folder))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Bad folder specified (%ld)"),
Folder);
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return GetServerErrorCode(Rval);
}
//
// Set bAllMessages to the right value
//
if (FAX_MESSAGE_FOLDER_INBOX == Folder)
{
if (FAX_ACCESS_QUERY_IN_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_IN_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to view Inbox messages"));
return ERROR_ACCESS_DENIED;
}
bAllMessages = TRUE;
}
else
{
Assert (FAX_MESSAGE_FOLDER_SENTITEMS == Folder);
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_OUT_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to view Sent items messages"));
return ERROR_ACCESS_DENIED;
}
if (FAX_ACCESS_QUERY_OUT_ARCHIVE == (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
bAllMessages = TRUE;
}
}
//
// Locate the file the caller's talking about
//
Rval = FindArchivedMessage (Folder, dwlMessageId, bAllMessages, wszMsgFileName, ARR_SIZE(wszMsgFileName), NULL, 0);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FindArchivedMessage returned %ld"),
Rval);
if (ERROR_FILE_NOT_FOUND == Rval)
{
if (FALSE == bAllMessages)
{
//
// The message was not found and the user doesn't have administrative rights
// so send the user ERROR_ACCESS_DENIED
//
Rval = ERROR_ACCESS_DENIED;
}
else
{
Rval = FAX_ERR_MESSAGE_NOT_FOUND;
}
}
return GetServerErrorCode(Rval);
}
//
// Retrieve FAX_MESSAGE information
//
Rval = RetrieveMessage (wszMsgFileName,
Folder,
&pMsg);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx( DEBUG_ERR,
TEXT("RetrieveMessage returned error %ld"),
Rval);
if (ERROR_FILE_NOT_FOUND == Rval)
{
Rval = FAX_ERR_MESSAGE_NOT_FOUND;
}
return GetServerErrorCode(Rval);
}
//
// Calculate required message size
//
// until MIDL accepts [out, size_is(,__int64*)]
ULONG_PTR upBufferSize = sizeof (FAX_MESSAGE);
SerializeMessage (NULL, &upBufferSize, dwClientAPIVersion, 0, pMsg, 0);
*lpdwBufferSize = DWORD(upBufferSize);
//
// Allocate return buffer
//
*lppBuffer = (LPBYTE) MemAlloc (*lpdwBufferSize);
if (!*lppBuffer)
{
DebugPrintEx( DEBUG_ERR,
TEXT("Cannot allocate memory for return buffer (%ld bytes)"),
*lpdwBufferSize);
Rval = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
//
// Serialize message in the return buffer
//
dwOffset = sizeof(FAX_MESSAGE);
SerializeMessage (*lppBuffer, &dwOffset, dwClientAPIVersion, 0, pMsg, *lpdwBufferSize);
Assert (ERROR_SUCCESS == Rval);
exit:
if (pMsg)
{
FreeMessageBuffer (pMsg, TRUE);
}
return GetServerErrorCode(Rval);
} // FAX_GetMessage
error_status_t
FAX_RemoveMessage (
IN handle_t hFaxHandle,
IN DWORDLONG dwlMessageId,
IN FAX_ENUM_MESSAGE_FOLDER Folder
)
/*++
Routine name : FAX_RemoveMessage
Routine description:
Removes a message from an archive
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hFaxHandle [in] - Unused
dwlMessageId [in] - Unique message id
Folder [in] - Archive folder
Return Value:
Standard RPC error code
--*/
{
error_status_t Rval = ERROR_SUCCESS;
WCHAR wszMsgFilePath[MAX_PATH];
HANDLE hFind;
WIN32_FIND_DATA FindFileData;
DWORDLONG dwlFileSize = 0;
BOOL fAccess;
DWORD dwRights;
BOOL bAllMessages = FALSE;
DEBUG_FUNCTION_NAME(TEXT("FAX_RemoveMessage"));
if (!dwlMessageId)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Invalid message id sepcified (%I64ld)"),
dwlMessageId);
return ERROR_INVALID_PARAMETER;
}
if ((FAX_MESSAGE_FOLDER_INBOX != Folder) &&
(FAX_MESSAGE_FOLDER_SENTITEMS != Folder))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Bad folder specified (%ld)"),
Folder);
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return GetServerErrorCode(Rval);
}
//
// Set bAllMessages to the right value
//
if (FAX_MESSAGE_FOLDER_INBOX == Folder)
{
if (FAX_ACCESS_MANAGE_IN_ARCHIVE != (dwRights & FAX_ACCESS_MANAGE_IN_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to manage Inbox messages"));
return ERROR_ACCESS_DENIED;
}
bAllMessages = TRUE;
}
else
{
Assert (FAX_MESSAGE_FOLDER_SENTITEMS == Folder);
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_MANAGE_OUT_ARCHIVE != (dwRights & FAX_ACCESS_MANAGE_OUT_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to manage Sent items messages"));
return ERROR_ACCESS_DENIED;
}
if (FAX_ACCESS_MANAGE_OUT_ARCHIVE == (dwRights & FAX_ACCESS_MANAGE_OUT_ARCHIVE))
{
bAllMessages = TRUE;
}
}
//
// Locate the file the caller's talking about
//
Rval = FindArchivedMessage (Folder, dwlMessageId, bAllMessages, NULL, 0, wszMsgFilePath, ARR_SIZE(wszMsgFilePath));
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FindArchivedMessage returned %ld"),
Rval);
if (ERROR_FILE_NOT_FOUND == Rval)
{
if (FALSE == bAllMessages)
{
//
// The message was not found and the user doesn't have administrative rights
// so send the user ERROR_ACCESS_DENIED
//
Rval = ERROR_ACCESS_DENIED;
}
else
{
Rval = FAX_ERR_MESSAGE_NOT_FOUND;
}
}
return GetServerErrorCode(Rval);
}
//
// Get the file size
//
hFind = FindFirstFile( wszMsgFilePath, &FindFileData);
if (INVALID_HANDLE_VALUE == hFind)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FindFirstFile failed (ec: %lc), File %s"),
GetLastError(),
wszMsgFilePath);
}
else
{
dwlFileSize = (MAKELONGLONG(FindFileData.nFileSizeLow ,FindFileData.nFileSizeHigh));
if (!FindClose(hFind))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FindClose failed (ec: %lc)"),
GetLastError());
}
}
//
// Try to remove the file (message)
//
if (!DeleteFile (wszMsgFilePath))
{
Rval = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("DeleteFile returned %ld on %s"),
Rval,
wszMsgFilePath);
if (ERROR_ACCESS_DENIED == Rval ||
ERROR_SHARING_VIOLATION == Rval)
{
Rval = FAX_ERR_FILE_ACCESS_DENIED;
}
else if (ERROR_FILE_NOT_FOUND == Rval)
{
Rval = FAX_ERR_MESSAGE_NOT_FOUND;
}
}
else
{
// Send event and update archive size for quota management
PSID lpUserSid = NULL;
DWORD dwRes;
FAX_ENUM_EVENT_TYPE EventType;
if (FAX_MESSAGE_FOLDER_INBOX == Folder)
{
EventType = FAX_EVENT_TYPE_IN_ARCHIVE;
}
else
{
EventType = FAX_EVENT_TYPE_OUT_ARCHIVE;
if (!GetMessageIdAndUserSid (wszMsgFilePath, Folder, &lpUserSid, NULL)) // We do not need message id
{
dwRes = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetMessageIdAndUserSid Failed, Error : %ld"),
dwRes);
return Rval;
}
}
dwRes = CreateArchiveEvent (dwlMessageId, EventType, FAX_JOB_EVENT_TYPE_REMOVED, lpUserSid);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreateConfigEvent(FAX_CONFIG_TYPE_*_ARCHIVE) failed (ec: %lc)"),
dwRes);
}
if (NULL != lpUserSid)
{
LocalFree (lpUserSid);
lpUserSid = NULL;
}
if (0 != dwlFileSize)
{
// Update archive size
EnterCriticalSection (&g_CsConfig);
if (FAX_ARCHIVE_FOLDER_INVALID_SIZE != g_ArchivesConfig[Folder].dwlArchiveSize)
{
g_ArchivesConfig[Folder].dwlArchiveSize -= dwlFileSize;
}
LeaveCriticalSection (&g_CsConfig);
}
}
return GetServerErrorCode(Rval);
} // FAX_RemoveMessage
//********************************************
//* RPC copy
//********************************************
error_status_t
FAX_StartCopyToServer (
IN handle_t hFaxHandle,
IN LPCWSTR lpcwstrFileExt,
OUT LPWSTR lpwstrServerFileName,
OUT PRPC_FAX_COPY_HANDLE lpHandle
)
/*++
Routine name : FAX_StartCopyToServer
Routine description:
Start to copy a file to the server
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hFaxHandle [in ] - Handle to server
lpcwstrFileExt [in ] - Extension of file to create on the server
lpwstrServerFileName [out] - File name (and extension) of file created on the server
handle [out] - RPC copy handle
Return Value:
Standard RPC error code
--*/
{
error_status_t Rval = ERROR_SUCCESS;
HANDLE hFile = INVALID_HANDLE_VALUE;
PSID pUserSid = NULL;
LPWSTR lpwstrUserSid = NULL;
PHANDLE_ENTRY pHandleEntry;
WCHAR wszQueueFileName[MAX_PATH] = {0};
WCHAR wszUserSidPrefix[MAX_PATH] = {0};
LPWSTR pwstr;
BOOL fAccess;
DWORD dwRights;
int Count;
DEBUG_FUNCTION_NAME(TEXT("FAX_StartCopyToServer"));
Assert (lpHandle && lpwstrServerFileName && lpcwstrFileExt);
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (0 == ((FAX_ACCESS_SUBMIT | FAX_ACCESS_SUBMIT_NORMAL | FAX_ACCESS_SUBMIT_HIGH) & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax submission rights"));
return ERROR_ACCESS_DENIED;
}
if ( (NULL == lpcwstrFileExt) ||
(_tcsicmp(lpcwstrFileExt,FAX_COVER_PAGE_EXT_LETTERS) && _tcsicmp(lpcwstrFileExt,FAX_TIF_FILE_EXT) ) )
{
//
// No extension at all, or extension is other then "COV" or "TIF"
//
DebugPrintEx(
DEBUG_ERR,
TEXT("Bad extension specified (%s)"),
lpcwstrFileExt);
return ERROR_INVALID_PARAMETER;
}
//
//Get the user SID
//
pUserSid = GetClientUserSID();
if (NULL == pUserSid)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid Failed, Error : %ld"),
Rval);
return GetServerErrorCode(Rval);
}
if (!ConvertSidToStringSid (pUserSid, &lpwstrUserSid))
{
Rval = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("ConvertSidToStringSid Failed, error : %ld"),
Rval);
goto exit;
}
Count = _snwprintf (
wszUserSidPrefix,
ARR_SIZE(wszUserSidPrefix)-1,
L"%s$",
lpwstrUserSid);
if (Count < 0)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("_snwprintf Failed, File name bigger than MAX_PATH"));
Rval = ERROR_BUFFER_OVERFLOW;
goto exit;
}
//
// Generate unique file in server's queue
//
DWORDLONG dwl = GenerateUniqueFileNameWithPrefix(
FALSE,
g_wszFaxQueueDir,
wszUserSidPrefix,
(LPWSTR)lpcwstrFileExt,
wszQueueFileName,
sizeof(wszQueueFileName)/sizeof(wszQueueFileName[0]));
if (0 == dwl)
{
Rval = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("GenerateUniqueFileName failed, ec = %d"),
Rval);
goto exit;
}
//
// Open the file for writing (again)
//
hFile = SafeCreateFile (
wszQueueFileName,
GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if ( INVALID_HANDLE_VALUE == hFile )
{
Rval = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("Opening %s for read failed (ec: %ld)"),
wszQueueFileName,
Rval);
goto exit;
}
//
// Get the filename.ext to return buffer (skip the user sid prefix)
//
pwstr = wcsrchr( wszQueueFileName, L'$');
Assert (pwstr);
//
// Skip the path and sid prefix
//
pwstr++;
//
// Create copy context
//
pHandleEntry = CreateNewCopyHandle( hFaxHandle,
hFile,
TRUE, // Copy to server
wszQueueFileName,
NULL);
if (!pHandleEntry)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("CreateNewCopyHandle failed, Error %ld"), Rval);
goto exit;
}
if (lstrlen(lpwstrServerFileName)<lstrlen(pwstr))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("lpwstrServerFileName out buffer (size=%d) , can't contain pwstr (size=%d)."),
lstrlen(lpwstrServerFileName)+1,
lstrlen(pwstr)+1);
Rval = ERROR_BUFFER_OVERFLOW;
goto exit;
}
wcsncpy( lpwstrServerFileName, pwstr , MAX_PATH );
//
// Return context handle
//
*lpHandle = (HANDLE) pHandleEntry;
Assert (ERROR_SUCCESS == Rval);
exit:
if (ERROR_SUCCESS != Rval)
{
//
// Some error occured
//
if (INVALID_HANDLE_VALUE != hFile)
{
//
// Close the file
//
if (CloseHandle (hFile))
{
DWORD dwErr = GetLastError ();
DebugPrintEx(DEBUG_ERR,
TEXT("CloseHandle failed, Error %ld"), dwErr);
}
}
if (lstrlen (wszQueueFileName))
{
//
// Remove unused queue file
//
if (!DeleteFile (wszQueueFileName))
{
DWORD dwErr = GetLastError ();
DebugPrintEx(DEBUG_ERR,
TEXT("DeleteFile failed on %s, Error %ld"),
wszQueueFileName,
dwErr);
}
}
}
if (NULL != lpwstrUserSid)
{
LocalFree(lpwstrUserSid);
}
MemFree (pUserSid);
return Rval;
} // FAX_StartCopyToServer
error_status_t
FAX_StartCopyMessageFromServer (
IN handle_t hFaxHandle,
IN DWORDLONG dwlMessageId,
IN FAX_ENUM_MESSAGE_FOLDER Folder,
OUT PRPC_FAX_COPY_HANDLE lpHandle
)
/*++
Routine name : FAX_StartCopyMessageFromServer
Routine description:
Starts a copy process of a message from the server's archive / queue
to the caller
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hFaxHandle [in ] - Handle to server
dwlMessageId [in ] - Message id
Folder [in ] - Archive / queue folder
handle [out] - RPC copy handle
Return Value:
Standard RPC error code
--*/
{
error_status_t Rval = ERROR_SUCCESS;
HANDLE hFile = INVALID_HANDLE_VALUE;
PHANDLE_ENTRY pHandleEntry;
PJOB_QUEUE pJobQueue = NULL;
WCHAR wszFileName[MAX_PATH] = {0};
BOOL bAllMessages = FALSE;
BOOL fAccess;
DWORD dwRights;
DEBUG_FUNCTION_NAME(TEXT("FAX_StartCopyMessageFromServer"));
Assert (lpHandle);
if (!dwlMessageId)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("zero message id sepcified"));
return ERROR_INVALID_PARAMETER;
}
if ((FAX_MESSAGE_FOLDER_QUEUE != Folder) &&
(FAX_MESSAGE_FOLDER_INBOX != Folder) &&
(FAX_MESSAGE_FOLDER_SENTITEMS != Folder))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Bad folder specified (%ld)"),
Folder);
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return GetServerErrorCode(Rval);
}
//
// Set bAllMessages to the right value
//
if (FAX_MESSAGE_FOLDER_INBOX == Folder)
{
if (FAX_ACCESS_QUERY_IN_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_IN_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to preview Inbox tiff files"));
return ERROR_ACCESS_DENIED;
}
bAllMessages = TRUE;
}
if (FAX_MESSAGE_FOLDER_SENTITEMS == Folder)
{
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_OUT_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to preview Sent items tiff files"));
return ERROR_ACCESS_DENIED;
}
if (FAX_ACCESS_QUERY_OUT_ARCHIVE == (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
bAllMessages = TRUE;
}
}
if (FAX_MESSAGE_FOLDER_QUEUE == Folder)
{
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_JOBS != (dwRights & FAX_ACCESS_QUERY_JOBS))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to preview Outbox tiff files"));
return ERROR_ACCESS_DENIED;
}
if (FAX_ACCESS_QUERY_JOBS == (dwRights & FAX_ACCESS_QUERY_JOBS))
{
bAllMessages = TRUE;
}
}
//
// Locate the file the caller's talking about
//
if (FAX_MESSAGE_FOLDER_QUEUE == Folder)
{
Rval = CreatePreviewFile (dwlMessageId, bAllMessages, &pJobQueue);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CreatePreviewFile returned %ld"),
Rval);
return GetServerErrorCode(Rval);
}
Assert (pJobQueue && pJobQueue->PreviewFileName && pJobQueue->UniqueId == dwlMessageId);
Assert (wcslen(pJobQueue->PreviewFileName) < MAX_PATH);
wcscpy (wszFileName, pJobQueue->PreviewFileName);
}
else
{
Assert (FAX_MESSAGE_FOLDER_SENTITEMS == Folder ||
FAX_MESSAGE_FOLDER_INBOX == Folder);
Rval = FindArchivedMessage (Folder, dwlMessageId, bAllMessages, NULL, 0, wszFileName, ARR_SIZE(wszFileName));
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("FindArchivedMessage returned %ld"),
Rval);
if (ERROR_FILE_NOT_FOUND == Rval)
{
if (FALSE == bAllMessages)
{
//
// The message was not found and the user doesn't have administrative rights
// so send the user ERROR_ACCESS_DENIED
//
Rval = ERROR_ACCESS_DENIED;
}
else
{
Rval = FAX_ERR_MESSAGE_NOT_FOUND;
}
}
return GetServerErrorCode(Rval);
}
}
//
// Open the file for reading
//
Assert (wcslen(wszFileName));
hFile = SafeCreateFile (
wszFileName,
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if ( INVALID_HANDLE_VALUE == hFile )
{
// We must decrease the job refrence count if it is a queued job.
Rval = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("Opening %s for read failed (ec: %ld)"),
wszFileName,
Rval);
goto exit;
}
//
// Create copy context
//
pHandleEntry = CreateNewCopyHandle( hFaxHandle,
hFile,
FALSE, // Copy from server
NULL,
pJobQueue);
if (!pHandleEntry)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("CreateNewCopyHandle failed, Error %ld"), Rval);
goto exit;
}
//
// Return context handle
//
*lpHandle = (HANDLE) pHandleEntry;
Assert (ERROR_SUCCESS == Rval);
exit:
if (ERROR_SUCCESS != Rval)
{
if (FAX_MESSAGE_FOLDER_QUEUE == Folder)
{
// Decrease ref count only if it is a queued job.
EnterCriticalSection (&g_CsQueue);
DecreaseJobRefCount (pJobQueue, TRUE, TRUE, TRUE); // TRUE for Preview ref count.
LeaveCriticalSection (&g_CsQueue);
}
if (INVALID_HANDLE_VALUE != hFile)
{
//
// Some error occured - close the file
//
if (CloseHandle (hFile))
{
DWORD dwErr = GetLastError ();
DebugPrintEx(DEBUG_ERR,
TEXT("CloseHandle failed, Error %ld"), dwErr);
}
}
}
return GetServerErrorCode(Rval);
} // FAX_StartCopyMessageFromServer
error_status_t
FAX_WriteFile (
IN RPC_FAX_COPY_HANDLE hCopy, // RPC copy handle
IN LPBYTE lpbData, // Data chunk to append to file on server
IN DWORD dwDataSize // Size of data chunk
)
/*++
Routine name : FAX_WriteFile
Routine description:
Copies a chunk of data to the server's queue
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hCopy [in] - Copy context handle
lpbData [in] - Pointer to buffer to copy from
chunk [in] - Size of source buffer
Return Value:
Standard RPC error code
--*/
{
error_status_t Rval = ERROR_SUCCESS;
PHANDLE_ENTRY pHandle = (PHANDLE_ENTRY)hCopy;
DWORD dwBytesWritten;
DEBUG_FUNCTION_NAME(TEXT("FAX_WriteFile"));
if (NULL == hCopy)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("NULL context handle"));
return ERROR_INVALID_PARAMETER;
}
Assert (lpbData && (INVALID_HANDLE_VALUE != pHandle->hFile));
if (!pHandle->bCopyToServer)
{
DebugPrintEx(DEBUG_ERR,
TEXT("Handle was created using FAX_StartCopyMessageFromServer"));
return ERROR_INVALID_HANDLE;
}
if (!dwDataSize)
{
DebugPrintEx(DEBUG_ERR,
TEXT("Zero data size"));
return ERROR_INVALID_PARAMETER;
}
if (!WriteFile (pHandle->hFile,
lpbData,
dwDataSize,
&dwBytesWritten,
NULL))
{
Rval = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("WriteFile failed (ec: %ld)"),
Rval);
pHandle->bError = TRUE; // Erase local queue file on handle close
goto exit;
}
if (dwBytesWritten != dwDataSize)
{
//
// Strange situation
//
DebugPrintEx(
DEBUG_ERR,
TEXT("WriteFile was asked to write %ld bytes but wrote only %ld bytes"),
dwDataSize,
dwBytesWritten);
Rval = ERROR_GEN_FAILURE;
pHandle->bError = TRUE; // Erase local queue file on handle close
goto exit;
}
Assert (ERROR_SUCCESS == Rval);
exit:
return Rval;
} // FAX_WriteFile
error_status_t
FAX_ReadFile (
IN RPC_FAX_COPY_HANDLE hCopy, // RPC copy handle
IN DWORD dwMaxDataSize, // Max size of data to copy
OUT LPBYTE lpbData, // Data buffer to retrieve from server
OUT LPDWORD lpdwDataSize // Size of data retrieved
)
/*++
Routine name : FAX_ReadFile
Routine description:
Copies a file from the server (in chunks)
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
hCopy [in ] - Copy context
dwMaxDataSize [in ] - Max chunk size
lpbData [in ] - Pointer to output data buffer
retrieved [out] - Number of bytes actually read.
A value of zero indicates EOF.
Return Value:
Standard RPC error code
--*/
{
error_status_t Rval = ERROR_SUCCESS;
PHANDLE_ENTRY pHandle = (PHANDLE_ENTRY)hCopy;
DEBUG_FUNCTION_NAME(TEXT("FAX_ReadFile"));
if (NULL == hCopy)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("NULL context handle"));
return ERROR_INVALID_PARAMETER;
}
Assert (lpdwDataSize && lpbData && (INVALID_HANDLE_VALUE != pHandle->hFile));
if (pHandle->bCopyToServer)
{
DebugPrintEx(DEBUG_ERR,
TEXT("Handle was created using FAX_StartCopyToServer"));
return ERROR_INVALID_HANDLE;
}
if (!dwMaxDataSize)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("zero dwMaxDataSizee specified"));
return ERROR_INVALID_PARAMETER;
}
if (dwMaxDataSize != *lpdwDataSize)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("dwMaxDataSize != *lpdwDataSize"));
return ERROR_INVALID_PARAMETER;
}
if (!ReadFile (pHandle->hFile,
lpbData,
dwMaxDataSize,
lpdwDataSize,
NULL))
{
Rval = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("ReadFile failed (ec: %ld)"),
Rval);
goto exit;
}
Assert (ERROR_SUCCESS == Rval);
exit:
return Rval;
} // FAX_ReadFile
error_status_t
FAX_EndCopy (
IN OUT PRPC_FAX_COPY_HANDLE lphCopy
)
/*++
Routine name : FAX_EndCopy
Routine description:
Ends a copy process (from / to server)
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
lphCopy [in] - Copy context handle
Return Value:
Standard RPC error code
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_EndCopy"));
if (NULL == *lphCopy)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("NULL context handle"));
return ERROR_INVALID_PARAMETER;
}
CloseFaxHandle( (PHANDLE_ENTRY) *lphCopy );
//
// NULLify the handle so the rundown will not occur
//
*lphCopy = NULL;
return ERROR_SUCCESS;
} // FAX_EndCopy
VOID
RPC_FAX_COPY_HANDLE_rundown(
IN HANDLE FaxCopyHandle
)
/*++
Routine name : RPC_FAX_COPY_HANDLE_rundown
Routine description:
The RPC rundown function of the copy handle.
This function is called if the client abruptly disconnected on us.
Author:
Eran Yariv (EranY), Dec, 1999
Arguments:
FaxCopyHandle [in] - Message copy handle.
Return Value:
None.
--*/
{
PHANDLE_ENTRY pHandleEntry = (PHANDLE_ENTRY) FaxCopyHandle;
DEBUG_FUNCTION_NAME(TEXT("RPC_FAX_COPY_HANDLE_rundown"));
DebugPrintEx(
DEBUG_WRN,
TEXT("RPC_FAX_COPY_HANDLE_rundown: handle = 0x%08x"),
FaxCopyHandle);
pHandleEntry->bError = TRUE;
CloseFaxHandle( pHandleEntry );
return;
} // RPC_FAX_COPY_HANDLE_rundown
error_status_t
FAX_StartServerNotification(
IN handle_t hBinding,
IN LPCTSTR lpcwstrMachineName,
IN LPCTSTR lpcwstrEndPoint,
IN ULONG64 Context,
IN LPWSTR lpcwstrProtseqString,
IN BOOL bEventEx,
IN DWORD dwEventTypes,
OUT PRPC_FAX_EVENT_HANDLE lpHandle
)
{
DWORD dwRights;
BOOL fAccess;
DWORD Rval = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_StartServerNotification"));
//
// Access check
//
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return Rval;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
return ERROR_NOT_SUPPORTED;
}
VOID
RPC_FAX_EVENT_HANDLE_rundown(
IN HANDLE hFaxEventHandle
)
{
//
// This call is not supported.
//
Assert (FALSE); //obsolete code
return;
}
error_status_t
FAX_StartServerNotificationEx(
IN handle_t hBinding,
IN LPCTSTR lpcwstrMachineName,
IN LPCTSTR lpcwstrEndPoint,
IN ULONG64 Context,
IN LPWSTR lpcwstrUnUsed, // This parameter is not used.
IN BOOL bEventEx,
IN DWORD dwEventTypes,
OUT PRPC_FAX_EVENT_EX_HANDLE lpHandle
)
{
error_status_t Rval = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_StartServerNotificationEx"));
PSID pUserSid = NULL;
handle_t hFaxHandle = NULL; // binding handle
CClientID* pContextClientID = NULL;
CClientID* pOpenConnClientID = NULL;
BOOL bAllQueueMessages = FALSE;
BOOL bAllOutArchiveMessages = FALSE;
BOOL fAccess;
DWORD dwRights;
DWORD dwRes;
Assert (lpcwstrEndPoint && lpcwstrMachineName && lpcwstrUnUsed && lpHandle);
Rval = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
Rval);
return GetServerErrorCode(Rval);
}
//
// Access check for extended events only
//
if (TRUE == bEventEx)
{
if (dwEventTypes & FAX_EVENT_TYPE_NEW_CALL)
{
if (FAX_ACCESS_QUERY_IN_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_IN_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights - FAX_ACCESS_QUERY_IN_ARCHIVE"));
return ERROR_ACCESS_DENIED;
}
}
if ( (dwEventTypes & FAX_EVENT_TYPE_IN_QUEUE) ||
(dwEventTypes & FAX_EVENT_TYPE_OUT_QUEUE) )
{
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_JOBS != (dwRights & FAX_ACCESS_QUERY_JOBS))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to get events of jobs in queue"));
return ERROR_ACCESS_DENIED;
}
}
if ( (dwEventTypes & FAX_EVENT_TYPE_CONFIG) ||
(dwEventTypes & FAX_EVENT_TYPE_DEVICE_STATUS) ||
(dwEventTypes & FAX_EVENT_TYPE_ACTIVITY) )
{
if (FAX_ACCESS_QUERY_CONFIG != (dwRights & FAX_ACCESS_QUERY_CONFIG))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to get events configuration and activity"));
return ERROR_ACCESS_DENIED;
}
}
if ( dwEventTypes & FAX_EVENT_TYPE_IN_ARCHIVE )
{
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_IN_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_IN_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to get events of jobs in Inbox"));
return ERROR_ACCESS_DENIED;
}
}
if ( dwEventTypes & FAX_EVENT_TYPE_OUT_ARCHIVE )
{
if (FAX_ACCESS_SUBMIT != (dwRights & FAX_ACCESS_SUBMIT) &&
FAX_ACCESS_SUBMIT_NORMAL != (dwRights & FAX_ACCESS_SUBMIT_NORMAL) &&
FAX_ACCESS_SUBMIT_HIGH != (dwRights & FAX_ACCESS_SUBMIT_HIGH) &&
FAX_ACCESS_QUERY_OUT_ARCHIVE != (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the needed rights to get events of jobs in Sent items"));
return ERROR_ACCESS_DENIED;
}
}
//
// Set bAllQueueMessages to the right value
//
if (FAX_ACCESS_QUERY_JOBS == (dwRights & FAX_ACCESS_QUERY_JOBS))
{
bAllQueueMessages = TRUE;
}
//
// Set bAllOutArchiveMessages to the right value
//
if (FAX_ACCESS_QUERY_OUT_ARCHIVE == (dwRights & FAX_ACCESS_QUERY_OUT_ARCHIVE))
{
bAllOutArchiveMessages = TRUE;
}
}
else
{
//
// Legacy events
//
BOOL fLocal;
if (FAX_EVENT_TYPE_LEGACY != dwEventTypes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("Legacy registration. The user can not get extended events"));
return ERROR_ACCESS_DENIED;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
//
// Ok User have rights
//
//
// The user asked for legacy events. make sure it is a local call
//
Rval = IsLocalRPCConnectionNP(&fLocal);
if (RPC_S_OK != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("IsLocalRPCConnectionNP failed. - %ld"),
Rval);
return Rval;
}
if (FALSE == fLocal)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("The user asked for local events only, but the RPC call is not local"));
return ERROR_ACCESS_DENIED;
}
}
if (wcslen (lpcwstrMachineName) > MAX_COMPUTERNAME_LENGTH ||
wcslen (lpcwstrEndPoint) >= MAX_ENDPOINT_LEN)
{
DebugPrintEx(DEBUG_ERR,
TEXT("Computer name or endpoint too long. Computer name: %s. Endpoint: %s"),
lpcwstrMachineName,
lpcwstrEndPoint);
return ERROR_BAD_FORMAT;
}
//
//Get the user SID
//
pUserSid = GetClientUserSID();
if (NULL == pUserSid)
{
Rval = GetLastError();
DebugPrintEx(DEBUG_ERR,
TEXT("GetClientUserSid Failed, Error : %ld"),
Rval);
return GetServerErrorCode(Rval);
}
EnterCriticalSection( &g_CsClients );
//
// Create binding to the client RPC server.
//
Rval = RpcBindToFaxClient (lpcwstrMachineName,
lpcwstrEndPoint,
&hFaxHandle);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("RpcBindToFaxClient faild (ec = %ld)"),
Rval);
goto exit;
}
//
// Create 2 new client IDs objects
//
pContextClientID = new (std::nothrow) CClientID( g_dwlClientID, lpcwstrMachineName, lpcwstrEndPoint, Context);
if (NULL == pContextClientID)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Error allocatin CClientID object"));
Rval = ERROR_OUTOFMEMORY;
goto exit;
}
pOpenConnClientID = new (std::nothrow) CClientID( g_dwlClientID, lpcwstrMachineName, lpcwstrEndPoint, Context);
if (NULL == pOpenConnClientID)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Error allocatin CClientID object"));
Rval = ERROR_OUTOFMEMORY;
goto exit;
}
try
{
CClient Client(*pContextClientID,
pUserSid,
dwEventTypes,
hFaxHandle,
bAllQueueMessages,
bAllOutArchiveMessages,
FindClientAPIVersion(hBinding));
//
// Add a new client object to the clients map
//
Rval = g_pClientsMap->AddClient(Client);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CClientsMap::AddClient failed with ec = %ld"),
Rval);
goto exit;
}
hFaxHandle = NULL; // CClientMap::DelClient() will free the binding handle
}
catch (exception &ex)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("map or CClient caused exception (%S)"),
ex.what());
Rval = ERROR_GEN_FAILURE;
goto exit;
}
//
// Post the CLIENT_OPEN_CONN_COMPLETION_KEY event to the FaxEvent completion port
//
if (!PostQueuedCompletionStatus( g_hSendEventsCompPort,
sizeof(CClientID*),
CLIENT_OPEN_CONN_COMPLETION_KEY,
(LPOVERLAPPED) pOpenConnClientID))
{
Rval = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("PostQueuedCompletionStatus failed. (ec: %ld)"),
Rval);
//
// Remove the map entry
// ReleaseClient should be called when not holding g_CsClients because it might call FAX_OpenConnection (RPC call that should not be in critacal section)
// Here, we dont want to leave g_CsClients (we might get 2 clients with the same ID).
// However, We can safetly call ReleaseClient while holding g_CsClients because a connection was not opened yet,
// and FAX_CloseConnection will not be called.
//
dwRes = g_pClientsMap->ReleaseClient(*pContextClientID);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CClientsMap::ReleaseClient failed. (ec: %ld)"),
dwRes);
}
goto exit;
}
pOpenConnClientID = NULL; // FaxSendEventsThread will free pOpenConnClientID
//
// Return a context handle to the client
//
*lpHandle = (HANDLE) pContextClientID;
pContextClientID = NULL; // RPC_FAX_EVENT_EX_HANDLE_rundown or FAX_EndServerNotification will free pContextClientID
Assert (ERROR_SUCCESS == Rval);
exit:
if (NULL != hFaxHandle)
{
// free binding handle
dwRes = RpcBindingFree((RPC_BINDING_HANDLE *)&hFaxHandle);
if (RPC_S_OK != dwRes)
{
DebugPrintEx(DEBUG_ERR,TEXT("RpcBindingFree() failed, ec=0x%08x"), dwRes );
}
}
if (pContextClientID != NULL)
{
delete pContextClientID;
pContextClientID = NULL;
}
if (pOpenConnClientID != NULL)
{
delete pOpenConnClientID;
pOpenConnClientID = NULL;
}
if (ERROR_SUCCESS == Rval)
{
g_dwlClientID++;
}
LeaveCriticalSection( &g_CsClients );
MemFree (pUserSid);
pUserSid = NULL;
return GetServerErrorCode(Rval);
UNREFERENCED_PARAMETER(lpcwstrUnUsed);
} // FAX_StartServerNotificationEx
VOID
RPC_FAX_EVENT_EX_HANDLE_rundown(
IN HANDLE hFaxEventHandle
)
{
DEBUG_FUNCTION_NAME(TEXT("RPC_FAX_EVENT_EX_HANDLE_rundown"));
CClientID* pClientID = (CClientID*)(hFaxEventHandle);
DebugPrintEx(
DEBUG_WRN,
TEXT("RPC_FAX_EVENT_EX_HANDLE_rundown() running for event handle 0x%08x"),
hFaxEventHandle);
//
// Remove relevant connections from notification list
//
DWORD rVal = g_pClientsMap->ReleaseClient(*pClientID, TRUE);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(
DEBUG_WRN,
TEXT("CClientsMap::ReleaseClient failed. ec:%ld"),
rVal);
}
delete pClientID;
pClientID = NULL;
return;
}
error_status_t
FAX_EndServerNotification (
IN OUT LPHANDLE lpHandle
)
/*++
Routine name : FAX_EndServerNotification
Routine description:
A fax client application calls the FAX_EndServerNotification function to stop
recieving server notifications.
Author:
Oded Sacher (OdedS), Dec, 1999
Arguments:
lpHandle [in] - The notification handle value.
This value is obtained by calling FAX_StartServerNotificationEx.
Return Value:
Standard RPC error code
--*/
{
error_status_t Rval = ERROR_SUCCESS;
DEBUG_FUNCTION_NAME(TEXT("FAX_EndServerNotification"));
CClientID* pClientID = (CClientID*)(*lpHandle);
if (NULL == pClientID)
{
//
// Empty context handle
//
//
DebugPrintEx(DEBUG_ERR,
_T("Empty context handle"));
return ERROR_INVALID_PARAMETER;
}
Rval = g_pClientsMap->ReleaseClient (*pClientID);
if (ERROR_SUCCESS != Rval)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("CClientsMap::ReleaseClient failed, ec=%ld"),
Rval);
}
delete pClientID;
//
// NULLify the handle so the rundown will not occur
//
*lpHandle = NULL;
return GetServerErrorCode(Rval);
} // FAX_EndServerNotificationEx
//********************************************
//* Server activity
//********************************************
error_status_t
FAX_GetServerActivity(
IN handle_t hFaxHandle,
IN OUT PFAX_SERVER_ACTIVITY pServerActivity
)
/*++
Routine name : FAX_GetServerActivity
Routine description:
Retrieves the status of the fax server queue activity and event log reports.
Author:
Oded Sacher (OdedS), Feb, 2000
Arguments:
hFaxHandle [in ] - Unused
pServerActivity [out] - Returned server activity structure
Return Value:
Standard RPC error codes
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_GetServerActivity"));
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
Assert (pServerActivity);
if (sizeof (FAX_SERVER_ACTIVITY) != pServerActivity->dwSizeOfStruct)
{
//
// Size mismatch
//
DebugPrintEx(DEBUG_ERR,
TEXT("Invalid size of struct"));
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return dwRes;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_QUERY_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
EnterCriticalSection (&g_CsActivity);
CopyMemory (pServerActivity, &g_ServerActivity, sizeof(FAX_SERVER_ACTIVITY));
LeaveCriticalSection (&g_CsActivity);
GetEventsCounters( &pServerActivity->dwWarningEvents,
&pServerActivity->dwErrorEvents,
&pServerActivity->dwInformationEvents);
return dwRes;
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_GetServerActivity
error_status_t
FAX_SetConfigWizardUsed (
IN handle_t hFaxHandle,
OUT BOOL bConfigWizardUsed
)
/*++
Routine name : FAX_SetConfigWizardUsed
Routine description:
Sets if the configuration wizard was used
Requires no access rights.
Author:
Eran Yariv (EranY), July 2000
Arguments:
hFaxHandle [in ] - Unused
bConfigWizardUsed [in] - Was the wizard used?
Return Value:
Standard RPC error codes
--*/
{
DEBUG_FUNCTION_NAME(TEXT("FAX_SetConfigWizardUsed"));
HKEY hKey;
DWORD dwRes = ERROR_SUCCESS;
DWORD dwRes2;
BOOL fAccess;
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_MANAGE_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return dwRes;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_MANAGE_CONFIG"));
return ERROR_ACCESS_DENIED;
}
dwRes = RegOpenKeyEx (HKEY_LOCAL_MACHINE, REGKEY_FAX_CLIENT, 0, KEY_WRITE, &hKey);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Error opening server key (ec = %ld)"),
dwRes);
return dwRes;
}
if (!SetRegistryDword (hKey,
REGVAL_CFGWZRD_DEVICE,
(DWORD)bConfigWizardUsed))
{
dwRes = GetLastError ();
DebugPrintEx(
DEBUG_ERR,
TEXT("Error writing REGVAL_CFGWZRD_DEVICE (ec = %ld)"),
dwRes);
goto exit;
}
exit:
dwRes2 = RegCloseKey (hKey);
if (ERROR_SUCCESS != dwRes2)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Error closing server key (ec = %ld)"),
dwRes2);
}
return dwRes;
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_SetConfigWizardUsed
//********************************************
//* Routing extensions
//********************************************
error_status_t
FAX_EnumRoutingExtensions (
IN handle_t hFaxHandle,
OUT LPBYTE *pBuffer,
OUT LPDWORD pdwBufferSize,
OUT LPDWORD lpdwNumExts
)
/*++
Routine name : FAX_EnumRoutingExtensions
Routine description:
Enumerates the routing extensions
Author:
Eran Yariv (EranY), Nov, 1999
Arguments:
hFaxHandle [in ] - Unused
pBuffer [out] - Pointer to buffer to hold routing extensions array
pdwBufferSize [out] - Pointer to buffer size
lpdwNumExts [out] - Size of FSPs array
Return Value:
Standard RPC error codes
--*/
{
extern LIST_ENTRY g_lstRoutingExtensions; // Global list of routing extensions
PLIST_ENTRY Next;
DWORD_PTR dwOffset;
PFAX_ROUTING_EXTENSION_INFO pExts;
DWORD dwIndex;
DWORD dwRes = ERROR_SUCCESS;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_EnumRoutingExtensions"));
Assert (pdwBufferSize && lpdwNumExts); // ref pointer in idl
if (!pBuffer) // unique pointer in idl
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
dwRes = FaxSvcAccessCheck (FAX_ACCESS_QUERY_CONFIG, &fAccess, NULL);
if (ERROR_SUCCESS != dwRes)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
dwRes);
return dwRes;
}
if (FALSE == fAccess)
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have the FAX_ACCESS_QUERY_CONFIG right"));
return ERROR_ACCESS_DENIED;
}
//
// First run - traverse list and count size required + list size
//
*lpdwNumExts = 0;
*pdwBufferSize = 0;
Next = g_lstRoutingExtensions.Flink;
if (NULL == Next)
{
//
// The list is corrupted
//
ASSERT_FALSE;
//
// We'll crash and we deserve it....
//
}
while ((ULONG_PTR)Next != (ULONG_PTR)&g_lstRoutingExtensions)
{
PROUTING_EXTENSION pExt;
(*lpdwNumExts)++;
(*pdwBufferSize) += sizeof (FAX_ROUTING_EXTENSION_INFO);
//
// Get current extension
//
pExt = CONTAINING_RECORD( Next, ROUTING_EXTENSION, ListEntry );
//
// Advance pointer
//
Next = pExt->ListEntry.Flink;
(*pdwBufferSize) += StringSize (pExt->FriendlyName);
(*pdwBufferSize) += StringSize (pExt->ImageName);
(*pdwBufferSize) += StringSize (pExt->InternalName);
}
//
// Allocate required size
//
*pBuffer = (LPBYTE)MemAlloc( *pdwBufferSize );
if (NULL == *pBuffer)
{
return ERROR_NOT_ENOUGH_MEMORY;
}
//
// Second pass, fill in the array
//
pExts = (PFAX_ROUTING_EXTENSION_INFO)(*pBuffer);
dwOffset = (*lpdwNumExts) * sizeof (FAX_ROUTING_EXTENSION_INFO);
Next = g_lstRoutingExtensions.Flink;
dwIndex = 0;
while ((ULONG_PTR)Next != (ULONG_PTR)&g_lstRoutingExtensions)
{
PROUTING_EXTENSION pExt;
//
// Get current extension
//
pExt = CONTAINING_RECORD( Next, ROUTING_EXTENSION, ListEntry );
//
// Advance pointer
//
Next = pExt->ListEntry.Flink;
pExts[dwIndex].dwSizeOfStruct = sizeof (FAX_ROUTING_EXTENSION_INFO);
StoreString(
pExt->FriendlyName,
(PULONG_PTR)&(pExts[dwIndex].lpctstrFriendlyName),
*pBuffer,
&dwOffset,
*pdwBufferSize
);
StoreString(
pExt->ImageName,
(PULONG_PTR)&(pExts[dwIndex].lpctstrImageName),
*pBuffer,
&dwOffset,
*pdwBufferSize
);
StoreString(
pExt->InternalName,
(PULONG_PTR)&(pExts[dwIndex].lpctstrExtensionName),
*pBuffer,
&dwOffset,
*pdwBufferSize
);
pExts[dwIndex].Version = pExt->Version;
pExts[dwIndex].Status = pExt->Status;
pExts[dwIndex].dwLastError = pExt->dwLastError;
dwIndex++;
}
Assert (dwIndex == *lpdwNumExts);
return ERROR_SUCCESS;
UNREFERENCED_PARAMETER (hFaxHandle);
} // FAX_EnumRoutingExtensions
DWORD
LineInfoToLegacyDeviceStatus(
const LINE_INFO *lpcLineInfo
)
{
DWORD dwState = 0;
Assert(lpcLineInfo);
//
// Return the line state according to the following backward compatability policy:
//
// For devices that do not support FSPI_CAP_MULTISEND we report the same
// status code as in W2K by translating the FSPI_JOB_STATUS kept in the job entry
// to the correspondign FPS_code (or just passing the proprietry FSP code).
//
// For devices that support FSPI_CAP_MULTISEND filter the state bits
// and return only the following states:
// FPS_OFFLINE
// FPS_AVAILABLE
// FPS_UNAVILABLE
// 0 - ( if the line is already allocated for the future job but a job is not yet assosiated with the line )
//
if (lpcLineInfo->JobEntry )
{
dwState = lpcLineInfo->State;
}
else
{
//
// Legacy FSP device that does not execute
// anything.
// In this case the device state is to be found in LineInfo->State but it is limited to
// FPS_OFFLINE or FPS_AVAILABLE or FPS_UNAVILABLE or 0
//
// LineInfo->State could be 0 if - the line is already allocated for the future job but
// a job is not yet assosiated with the line
//
Assert( (FPS_OFFLINE == lpcLineInfo->State) ||
(FPS_AVAILABLE == lpcLineInfo->State) ||
(FPS_UNAVAILABLE == lpcLineInfo->State) ||
(0 == lpcLineInfo->State) );
dwState = lpcLineInfo->State;
}
return dwState;
}
//********************************************
//* Manual answering support
//********************************************
error_status_t
FAX_AnswerCall(
IN handle_t hFaxHandle,
IN CONST DWORD dwDeviceId
)
/*++
Routine name : FAX_AnswerCall
Routine description:
A fax client application calls the FAX_AnswerCall to cause server to answer
the specified call
Arguments:
hFaxHandle - unused
dwDeviceId - TAPI Permanent line ID (for identification)
Return Value:
Standard RPC error code
--*/
{
error_status_t rVal = ERROR_SUCCESS;
LPLINEMESSAGE lpLineMessage;
BOOL fAccess;
LINE_INFO *pLineInfo;
DEBUG_FUNCTION_NAME(TEXT("FAX_AnswerCall"));
UNREFERENCED_PARAMETER (hFaxHandle);
//
// Access check
//
rVal = FaxSvcAccessCheck (FAX_ACCESS_QUERY_IN_ARCHIVE, &fAccess, NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
rVal = ERROR_ACCESS_DENIED;
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_IN_ARCHIVE"));
return rVal;
}
//
// Only local connections are allowed to call this procedure
//
BOOL bLocalFlag;
RPC_STATUS rc = IsLocalRPCConnectionNP(&bLocalFlag);
if ( rc != RPC_S_OK )
{
rVal = ERROR_ACCESS_DENIED;
DebugPrintEx(DEBUG_ERR,
TEXT("IsLocalRPCConnectionNP failed. (ec: %ld)"),
rc);
return rVal;
}
if( !bLocalFlag )
{
rVal = ERROR_ACCESS_DENIED;
DebugPrintEx(
DEBUG_ERR,
TEXT("FAX_AnswerCall is available for local clients only"));
return rVal;
}
//
// Validate the line exists and can answer calls
//
EnterCriticalSection( &g_CsLine );
//
// Get LineInfo from permanent device ID
//
pLineInfo = GetTapiLineFromDeviceId(dwDeviceId, FALSE);
if(!pLineInfo)
{
rVal = ERROR_INVALID_PARAMETER;
DebugPrintEx(DEBUG_ERR,
TEXT("Device %ld not found"),
dwDeviceId);
goto Error;
}
//
// See if the device is still available
//
if(pLineInfo->State != FPS_AVAILABLE)
{
rVal = ERROR_BUSY;
DebugPrintEx(DEBUG_ERR,
TEXT("Line is not available (LineState is 0x%08x)."),
pLineInfo->State);
goto Error;
}
//
// Allocate and compose a LINEMESSAGE structure that'll be
// used to notify the server about the new inbound message.
//
lpLineMessage = (LPLINEMESSAGE)LocalAlloc(LPTR, sizeof(LINEMESSAGE));
if (lpLineMessage == NULL)
{
rVal = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to allocate LINEMESSAGE structure"));
goto Error;
}
lpLineMessage->dwParam1 = dwDeviceId;
//
// Notify the server.
//
if (!PostQueuedCompletionStatus(
g_TapiCompletionPort,
sizeof(LINEMESSAGE),
ANSWERNOW_EVENT_KEY,
(LPOVERLAPPED)lpLineMessage))
{
rVal = GetLastError();
DebugPrintEx(
DEBUG_ERR,
TEXT("PostQueuedCompletionStatus failed - %d"),
GetLastError());
LocalFree(lpLineMessage);
goto Error;
}
Error:
LeaveCriticalSection( &g_CsLine );
return rVal;
} // FAX_AnswerCall
//********************************************
//* Ivalidate archive folder
//********************************************
error_status_t
FAX_RefreshArchive(
IN handle_t hFaxHandle,
IN FAX_ENUM_MESSAGE_FOLDER Folder
)
/*++
Routine name : FAX_RefreshArchive
Routine description:
A fax client application calls the FAX_RefreshArchive to notify server
that archive folder has been changed and should be refreshed
Arguments:
hFaxHandle - unused
Folder - Archive folder name
Return Value:
Standard RPC error code
--*/
{
error_status_t rVal = ERROR_SUCCESS;
BOOL fAccess;
DEBUG_FUNCTION_NAME(TEXT("FAX_RefreshArchive"));
UNREFERENCED_PARAMETER (hFaxHandle);
if(Folder != FAX_MESSAGE_FOLDER_INBOX &&
Folder != FAX_MESSAGE_FOLDER_SENTITEMS)
{
return ERROR_INVALID_PARAMETER;
}
//
// Access check
//
rVal = FaxSvcAccessCheck ((Folder == FAX_MESSAGE_FOLDER_INBOX) ? FAX_ACCESS_MANAGE_IN_ARCHIVE :
FAX_ACCESS_MANAGE_OUT_ARCHIVE,
&fAccess,
NULL);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (FALSE == fAccess)
{
rVal = ERROR_ACCESS_DENIED;
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have FAX_ACCESS_QUERY_IN_ARCHIVE"));
return rVal;
}
//
// Refresh archive size
//
EnterCriticalSection (&g_CsConfig);
g_ArchivesConfig[Folder].dwlArchiveSize = FAX_ARCHIVE_FOLDER_INVALID_SIZE;
LeaveCriticalSection (&g_CsConfig);
//
// Wake up quota warning thread
//
if (!SetEvent (g_hArchiveQuotaWarningEvent))
{
DebugPrintEx(
DEBUG_ERR,
TEXT("Failed to set quota warning event, SetEvent failed (ec: %lc)"),
GetLastError());
}
return rVal;
}
static
LPTSTR
GetClientMachineName (
IN handle_t hFaxHandle
)
/*++
Routine name : GetClientMachineName
Routine description:
A utility function to retrieve the machine name of the RPC client from the
server binding handle.
Arguments:
hFaxHandle - Server binding handle
Return Value:
Returns an allocated string of the client machine name.
The caller should free this string with MemFree().
If the return value is NULL, call GetLastError() to get last error code.
--*/
{
RPC_STATUS ec;
LPTSTR lptstrRetVal = NULL;
unsigned short *wszStringBinding = NULL;
unsigned short *wszNetworkAddress = NULL;
RPC_BINDING_HANDLE hServer = INVALID_HANDLE_VALUE;
DEBUG_FUNCTION_NAME(TEXT("GetClientMachineName"));
//
// Get server partially-bound handle from client binding handle
//
ec = RpcBindingServerFromClient (hFaxHandle, &hServer);
if (RPC_S_OK != ec)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("RpcBindingServerFromClient failed with %ld"),
ec);
goto exit;
}
//
// Convert binding handle to string represntation
//
ec = RpcBindingToStringBinding (hServer, &wszStringBinding);
if (RPC_S_OK != ec)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("RpcBindingToStringBinding failed with %ld"),
ec);
goto exit;
}
//
// Parse the returned string, looking for the NetworkAddress
//
ec = RpcStringBindingParse (wszStringBinding, NULL, NULL, &wszNetworkAddress, NULL, NULL);
if (RPC_S_OK != ec)
{
DebugPrintEx(
DEBUG_ERR,
TEXT("RpcStringBindingParse failed with %ld"),
ec);
goto exit;
}
//
// Now, just copy the result to the return buffer
//
Assert (wszNetworkAddress);
if (!wszNetworkAddress)
{
//
// Unacceptable client machine name
//
DebugPrintEx(
DEBUG_ERR,
TEXT("Client machine name is invalid"));
ec = ERROR_GEN_FAILURE;
goto exit;
}
lptstrRetVal = StringDup (wszNetworkAddress);
if (!lptstrRetVal)
{
ec = GetLastError();
}
exit:
if (INVALID_HANDLE_VALUE != hServer)
{
RpcBindingFree (&hServer);
}
if (wszStringBinding)
{
RpcStringFree (&wszStringBinding);
}
if (wszNetworkAddress)
{
RpcStringFree (&wszNetworkAddress);
}
if (!lptstrRetVal)
{
//
// Error
//
Assert (ec);
SetLastError (ec);
return NULL;
}
return lptstrRetVal;
} // GetClientMachineName
//********************************************
//* Recipients limit in a single broadcast
//********************************************
error_status_t
FAX_SetRecipientsLimit(
IN handle_t hFaxHandle,
IN DWORD dwRecipientsLimit
)
/*++
Routine name : FAX_SetRecipientsLimit
Routine description:
A fax client application calls the FAX_SetRecipientsLimit to set the
recipients limit of a single broadcast job.
Arguments:
hFaxHandle - unused
dwRecipientsLimit - the recipients limit to set
Return Value:
Standard Win32 error code
--*/
{
UNREFERENCED_PARAMETER (hFaxHandle);
UNREFERENCED_PARAMETER (dwRecipientsLimit);
return ERROR_NOT_SUPPORTED;
} // FAX_SetRecipientsLimit
error_status_t
FAX_GetRecipientsLimit(
IN handle_t hFaxHandle,
OUT LPDWORD lpdwRecipientsLimit
)
/*++
Routine name : FAX_GetRecipientLimit
Routine description:
A fax client application calls the FAX_GetRecipientsLimit to get the
recipients limit of a single broadcast job.
Arguments:
hFaxHandle - unused
lpdwRecipientsLimit - pointer to a DWORD to receive the recipients limit
Return Value:
Standard Win32 error code
--*/
{
error_status_t rVal = ERROR_SUCCESS;
BOOL fAccess;
DWORD dwRights;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetRecipientsLimit"));
UNREFERENCED_PARAMETER (hFaxHandle);
Assert (lpdwRecipientsLimit); // ref pointer in IDL.
//
// Access check
//
rVal = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (0 == ((FAX_ACCESS_SUBMIT | FAX_ACCESS_SUBMIT_NORMAL | FAX_ACCESS_SUBMIT_HIGH) & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax submission rights"));
return ERROR_ACCESS_DENIED;
}
*lpdwRecipientsLimit = g_dwRecipientsLimit;
return ERROR_SUCCESS;
} // FAX_GetRecipientsLimit
error_status_t
FAX_GetServerSKU(
IN handle_t hFaxHandle,
OUT PRODUCT_SKU_TYPE* pServerSKU
)
/*++
Routine name : FAX_GetServerSKU
Routine description:
A fax client application calls the FAX_GetServerSKU to fax server SKU
Arguments:
hFaxHandle - unused
pServerSKU - pointer to a PRODUCT_SKU_TYPE to receive the fax server SKU
Return Value:
Standard Win32 error code
--*/
{
error_status_t rVal = ERROR_SUCCESS;
BOOL fAccess;
DWORD dwRights;
DEBUG_FUNCTION_NAME(TEXT("FAX_GetRecipientsLimit"));
UNREFERENCED_PARAMETER (hFaxHandle);
Assert (pServerSKU); // ref pointer in IDL.
//
// Access check
//
rVal = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
*pServerSKU = GetProductSKU();
return ERROR_SUCCESS;
} // FAX_GetServerSKU
error_status_t
FAX_CheckValidFaxFolder(
IN handle_t hFaxHandle,
IN LPCWSTR lpcwstrPath
)
/*++
Routine name : FAX_CheckValidFaxFolder
Routine description:
Used by fax client application to check if a given path is accessible (valid for use)
by the fax service.
Arguments:
hFaxHandle - unused
lpcwstrPath - Path to check
Return Value:
ERROR_SUCCESS if path can be used by the fax service.
Win32 error code otherwise.
--*/
{
error_status_t rVal = ERROR_SUCCESS;
BOOL fAccess;
DWORD dwRights;
DEBUG_FUNCTION_NAME(TEXT("FAX_CheckValidFaxFolder"));
UNREFERENCED_PARAMETER (hFaxHandle);
Assert (lpcwstrPath); // ref pointer in IDL.
//
// Access check
//
rVal = FaxSvcAccessCheck (MAXIMUM_ALLOWED, &fAccess, &dwRights);
if (ERROR_SUCCESS != rVal)
{
DebugPrintEx(DEBUG_ERR,
TEXT("FaxSvcAccessCheck Failed, Error : %ld"),
rVal);
return rVal;
}
if (0 == (ALL_FAX_USER_ACCESS_RIGHTS & dwRights))
{
DebugPrintEx(DEBUG_ERR,
TEXT("The user does not have any Fax rights"));
return ERROR_ACCESS_DENIED;
}
//
// See if foler is valid (exists and has proper access rights) and does not collide with queue or inbox folder.
//
rVal = IsValidArchiveFolder (const_cast<LPWSTR>(lpcwstrPath), FAX_MESSAGE_FOLDER_SENTITEMS);
if (ERROR_SUCCESS != rVal)
{
if(ERROR_ACCESS_DENIED == rVal &&
FAX_API_VERSION_1 <= FindClientAPIVersion (hFaxHandle))
{
rVal = FAX_ERR_FILE_ACCESS_DENIED;
}
return rVal;
}
//
// See if foler is valid (exists and has proper access rights) and does not collide with queue or sent-items folder.
//
rVal = IsValidArchiveFolder (const_cast<LPWSTR>(lpcwstrPath), FAX_MESSAGE_FOLDER_INBOX);
if (ERROR_SUCCESS != rVal)
{
if(ERROR_ACCESS_DENIED == rVal &&
FAX_API_VERSION_1 <= FindClientAPIVersion (hFaxHandle))
{
rVal = FAX_ERR_FILE_ACCESS_DENIED;
}
return rVal;
}
return rVal;
} // FAX_CheckValidFaxFolder