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.
351 lines
11 KiB
351 lines
11 KiB
/*==========================================================================
|
|
*
|
|
* Copyright (C) 1998-2000 Microsoft Corporation. All Rights Reserved.
|
|
*
|
|
* File: IOData.h
|
|
* Content: Structure definitions for IOData for the DNSerial service provider
|
|
*
|
|
*
|
|
* History:
|
|
* Date By Reason
|
|
* ==== == ======
|
|
* 11/25/98 jtk Created
|
|
* 09/14/99 jtk Dereived from Locals.h
|
|
***************************************************************************/
|
|
|
|
#ifndef __IODDATA_H__
|
|
#define __IODDATA_H__
|
|
|
|
#undef DPF_SUBCOMP
|
|
#define DPF_SUBCOMP DN_SUBCOMP_MODEM
|
|
|
|
|
|
//**********************************************************************
|
|
// Constant definitions
|
|
//**********************************************************************
|
|
|
|
//
|
|
// enumerated types for what action to take when a send completes
|
|
//
|
|
typedef enum _SEND_COMPLETE_ACTION
|
|
{
|
|
SEND_COMPLETE_ACTION_UNKNOWN = 0, // unknown value
|
|
SEND_COMPLETE_ACTION_NONE, // no action
|
|
SEND_COMPLETE_ACTION_COMPLETE_COMMAND // complete command
|
|
} SEND_COMPLETE_ACTION;
|
|
|
|
//
|
|
// enumerated values for state of reads
|
|
//
|
|
typedef enum _READ_STATE
|
|
{
|
|
READ_STATE_UNKNOWN, // unknown state
|
|
// READ_STATE_INITIALIZE, // initialize state machine
|
|
READ_STATE_READ_HEADER, // read header information
|
|
READ_STATE_READ_DATA // read message data
|
|
} READ_STATE;
|
|
|
|
typedef enum _NT_IO_OPERATION_TYPE
|
|
{
|
|
NT_IO_OPERATION_UNKNOWN,
|
|
NT_IO_OPERATION_RECEIVE,
|
|
NT_IO_OPERATION_SEND
|
|
} NT_IO_OPERATION_TYPE;
|
|
|
|
//**********************************************************************
|
|
// Macro definitions
|
|
//**********************************************************************
|
|
|
|
//**********************************************************************
|
|
// Structure definitions
|
|
//**********************************************************************
|
|
|
|
//
|
|
// forward class and structure references
|
|
//
|
|
//typedef struct _RECEIVE_BUFFER RECEIVE_BUFFER;
|
|
class CModemCommandData;
|
|
class CDataPort;
|
|
class CIOData;
|
|
class CModemThreadPool;
|
|
|
|
//
|
|
// structure used to prefix a message on the wire for framing
|
|
//
|
|
#pragma pack( push, 1 )
|
|
typedef struct _MESSAGE_HEADER
|
|
{
|
|
BYTE SerialSignature; // serial signature
|
|
BYTE MessageTypeToken; // token to indicate message type
|
|
WORD wMessageSize; // message data size
|
|
WORD wMessageCRC; // CRC of message data
|
|
WORD wHeaderCRC; // CRC of header
|
|
|
|
} MESSAGE_HEADER;
|
|
#pragma pack( pop )
|
|
|
|
|
|
//
|
|
// class containing all data for I/O completion
|
|
//
|
|
class CIOData
|
|
{
|
|
public:
|
|
CDataPort *DataPort( void ) const { return m_pDataPort; }
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CIOData::SetDataPort"
|
|
void SetDataPort( CDataPort *const pDataPort )
|
|
{
|
|
DNASSERT( ( m_pDataPort == NULL ) || ( pDataPort == NULL ) );
|
|
m_pDataPort = pDataPort;
|
|
}
|
|
|
|
#ifdef WIN95
|
|
BOOL Win9xOperationPending( void ) const { return m_fWin9xOperationPending; }
|
|
void SetWin9xOperationPending( const BOOL fOperationPending ) { m_fWin9xOperationPending = fOperationPending; }
|
|
#endif // WIN95
|
|
|
|
#ifdef WINNT
|
|
NT_IO_OPERATION_TYPE NTIOOperationType( void ) const { return m_NTIOOperationType; }
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CIOData::SetNTIOOperationType"
|
|
void SetNTIOOperationType( const NT_IO_OPERATION_TYPE OperationType )
|
|
{
|
|
DNASSERT( ( OperationType == NT_IO_OPERATION_UNKNOWN ) ||
|
|
( m_NTIOOperationType == NT_IO_OPERATION_UNKNOWN ) );
|
|
m_NTIOOperationType = OperationType;
|
|
}
|
|
#endif // WINNT
|
|
|
|
OVERLAPPED *Overlap( void ) { return &m_Overlap; }
|
|
#ifdef WIN95
|
|
HANDLE OverlapEvent( void ) const { return m_Overlap.hEvent; }
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CIOData::SetOverlapEvent"
|
|
void SetOverlapEvent( const HANDLE hEvent )
|
|
{
|
|
DNASSERT( ( m_Overlap.hEvent == NULL ) || ( hEvent == NULL ) );
|
|
m_Overlap.hEvent = hEvent;
|
|
}
|
|
#endif // WIN95
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CIOData::IODataFromOverlap"
|
|
static CIOData *IODataFromOverlap( OVERLAPPED *const pOverlap )
|
|
{
|
|
DNASSERT( pOverlap != NULL );
|
|
DBG_CASSERT( sizeof( BYTE* ) == sizeof( pOverlap ) );
|
|
DBG_CASSERT( sizeof( CIOData* ) == sizeof( BYTE* ) );
|
|
return reinterpret_cast<CIOData*>( &reinterpret_cast<BYTE*>( pOverlap )[ -OFFSETOF( CIOData, m_Overlap ) ] );
|
|
}
|
|
|
|
protected:
|
|
|
|
OVERLAPPED m_Overlap; // overlapped I/O structure
|
|
|
|
#ifdef WINNT
|
|
NT_IO_OPERATION_TYPE m_NTIOOperationType;
|
|
#endif // WINNT
|
|
|
|
CDataPort *m_pDataPort; // pointer to data port associated with this IO request
|
|
#ifdef WIN95
|
|
BOOL m_fWin9xOperationPending; // this structure has been initialized and the operation is pending on Win9x
|
|
#endif // WIN95
|
|
|
|
|
|
//
|
|
// prevent unwarranted copies
|
|
//
|
|
CIOData( const CIOData & );
|
|
CIOData& operator=( const CIOData & );
|
|
};
|
|
|
|
|
|
//
|
|
// all data for a read operation
|
|
//
|
|
class CModemReadIOData : public CIOData
|
|
{
|
|
public:
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CModemReadIOData::AddRef"
|
|
void AddRef( void )
|
|
{
|
|
DNASSERT( m_lRefCount != 0 );
|
|
DNInterlockedIncrement( &m_lRefCount );
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CModemReadIOData::DecRef"
|
|
void DecRef( void )
|
|
{
|
|
DNASSERT( m_lRefCount != 0 );
|
|
if ( DNInterlockedDecrement( &m_lRefCount ) == 0 )
|
|
{
|
|
ReturnSelfToPool();
|
|
}
|
|
}
|
|
|
|
CBilink m_OutstandingReadListLinkage; // links to the unbound list
|
|
|
|
//
|
|
// I/O variables
|
|
//
|
|
DWORD m_dwWin9xReceiveErrorReturn; // Win9x error return
|
|
DWORD jkm_dwOverlappedBytesReceived; // used in GetOverlappedResult()
|
|
DWORD jkm_dwImmediateBytesReceived; // used as an immediate for ReadFile()
|
|
|
|
//
|
|
// read state
|
|
//
|
|
READ_STATE m_ReadState; // state of READ
|
|
DWORD m_dwBytesToRead; // bytes to read
|
|
DWORD m_dwReadOffset; // destination offset into read buffer
|
|
|
|
//
|
|
// read buffers
|
|
//
|
|
SPRECEIVEDBUFFER m_SPReceivedBuffer; // received buffer data that is handed to the application
|
|
union
|
|
{
|
|
MESSAGE_HEADER MessageHeader; // template for message header
|
|
BYTE ReceivedData[ MAX_MESSAGE_SIZE ]; // full buffer for received data
|
|
} m_ReceiveBuffer;
|
|
|
|
|
|
READ_STATE ReadState( void ) const { return m_ReadState; }
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CModemReadIOData::SetReadState"
|
|
void SetReadState( const READ_STATE ReadState )
|
|
{
|
|
DNASSERT( ( m_ReadState == READ_STATE_UNKNOWN ) ||
|
|
( ReadState == READ_STATE_UNKNOWN ) ||
|
|
( ( m_ReadState == READ_STATE_READ_HEADER ) && ( ReadState == READ_STATE_READ_DATA ) ) ); // valid header read, start reading data
|
|
m_ReadState = ReadState;
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CModemReadIOData::SetThreadPool"
|
|
void SetThreadPool( CModemThreadPool *const pThreadPool )
|
|
{
|
|
DNASSERT( ( m_pThreadPool == NULL ) || ( pThreadPool == NULL ) );
|
|
m_pThreadPool = pThreadPool;
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CModemReadIOData::ReadDataFromBilink"
|
|
static CModemReadIOData *ReadDataFromBilink( CBilink *const pBilink )
|
|
{
|
|
DNASSERT( pBilink != NULL );
|
|
DBG_CASSERT( sizeof( BYTE* ) == sizeof( pBilink ) );
|
|
DBG_CASSERT( sizeof( CIOData* ) == sizeof( BYTE* ) );
|
|
return reinterpret_cast<CModemReadIOData*>( &reinterpret_cast<BYTE*>( pBilink )[ -OFFSETOF( CModemReadIOData, m_OutstandingReadListLinkage ) ] );
|
|
}
|
|
|
|
#undef DPF_MODNAME
|
|
#define DPF_MODNAME "CModemReadIOData::ReadDataFromSPReceivedBuffer"
|
|
static CModemReadIOData *ReadDataFromSPReceivedBuffer( SPRECEIVEDBUFFER *const pSPReceivedBuffer )
|
|
{
|
|
DNASSERT( pSPReceivedBuffer != NULL );
|
|
DBG_CASSERT( sizeof( BYTE* ) == sizeof( pSPReceivedBuffer ) );
|
|
DBG_CASSERT( sizeof( CModemReadIOData* ) == sizeof( BYTE* ) );
|
|
return reinterpret_cast<CModemReadIOData*>( &reinterpret_cast<BYTE*>( pSPReceivedBuffer )[ -OFFSETOF( CModemReadIOData, m_SPReceivedBuffer ) ] );
|
|
}
|
|
|
|
//
|
|
// functions for managing read IO data pool
|
|
//
|
|
static BOOL PoolAllocFunction( void* pvItem, void* pvContext );
|
|
static void PoolInitFunction( void* pvItem, void* pvContext );
|
|
static void PoolReleaseFunction( void* pvItem );
|
|
static void PoolDeallocFunction( void* pvItem );
|
|
|
|
private:
|
|
void ReturnSelfToPool( void );
|
|
|
|
BYTE m_Sig[4]; // debugging signature ('RIOD')
|
|
|
|
volatile LONG m_lRefCount;
|
|
CModemThreadPool *m_pThreadPool;
|
|
|
|
//
|
|
// prevent unwarranted copies
|
|
//
|
|
CModemReadIOData( const CModemReadIOData & );
|
|
CModemReadIOData& operator=( const CModemReadIOData & );
|
|
};
|
|
|
|
//
|
|
// all data for a write operation
|
|
//
|
|
class CModemWriteIOData : public CIOData
|
|
{
|
|
public:
|
|
CModemWriteIOData *m_pNext; // link to next write in the send queue (see CSendQueue)
|
|
|
|
CBilink m_OutstandingWriteListLinkage; // links to the outstanding write list
|
|
BUFFERDESC *m_pBuffers; // pointer to outgoing buffers
|
|
UINT_PTR m_uBufferCount; // count of outgoing buffers
|
|
CModemCommandData *m_pCommand; // associated command
|
|
|
|
SEND_COMPLETE_ACTION m_SendCompleteAction; // enumerated value indicating the action to take
|
|
// when a send completes
|
|
|
|
//
|
|
// I/O variables
|
|
//
|
|
HRESULT jkm_hSendResult;
|
|
DWORD jkm_dwOverlappedBytesSent; // used in GetOverlappedResult()
|
|
DWORD jkm_dwImmediateBytesSent; // used as an immediate for WriteFile()
|
|
|
|
//
|
|
// Since the following is a packed structure, put it at the end
|
|
// to preserve as much alignment as possible with the
|
|
// above fields
|
|
//
|
|
union
|
|
{
|
|
MESSAGE_HEADER MessageHeader; // data prepended on a write
|
|
BYTE Data[ MAX_MESSAGE_SIZE ]; // data buffer to flatten outgoing data
|
|
} m_DataBuffer;
|
|
|
|
static CModemWriteIOData *WriteDataFromBilink( CBilink *const pBilink )
|
|
{
|
|
DNASSERT( pBilink != NULL );
|
|
DBG_CASSERT( sizeof( BYTE* ) == sizeof( pBilink ) );
|
|
DBG_CASSERT( sizeof( CModemWriteIOData* ) == sizeof( BYTE* ) );
|
|
return reinterpret_cast<CModemWriteIOData*>( &reinterpret_cast<BYTE*>( pBilink )[ -OFFSETOF( CModemWriteIOData, m_OutstandingWriteListLinkage ) ] );
|
|
}
|
|
|
|
//
|
|
// functions for managing write IO data pool
|
|
//
|
|
static BOOL PoolAllocFunction( void* pvItem, void* pvContext );
|
|
static void PoolInitFunction( void* pvItem, void* pvContext );
|
|
static void PoolReleaseFunction( void* pvItem );
|
|
static void PoolDeallocFunction( void* pvItem );
|
|
|
|
private:
|
|
BYTE m_Sig[4]; // debugging signature ('WIOD')
|
|
|
|
//
|
|
// prevent unwarranted copies
|
|
//
|
|
CModemWriteIOData( const CModemWriteIOData & );
|
|
CModemWriteIOData& operator=( const CModemWriteIOData & );
|
|
};
|
|
|
|
//**********************************************************************
|
|
// Variable definitions
|
|
//**********************************************************************
|
|
|
|
//**********************************************************************
|
|
// Function prototypes
|
|
//**********************************************************************
|
|
|
|
#undef DPF_MODNAME
|
|
|
|
#endif // __IODDATA_H__
|