1683 lines
56 KiB
C++
1683 lines
56 KiB
C++
#include "precomp.h"
|
||
DEBUG_FILEZONE(ZONE_T120_T123PSTN);
|
||
|
||
/* X224.cpp
|
||
*
|
||
* Copyright (c) 1994 by DataBeam Corporation, Lexington, KY
|
||
*
|
||
* Abstract:
|
||
*
|
||
* Private Instance Variables:
|
||
* Default_PDU_Size - Default PDU size, if no arb. is done
|
||
* Data_Request_Memory_Manager - Memory manager
|
||
* Lower_Layer_Prepend - Number of bytes prepended to packet by
|
||
* lower layer
|
||
* Lower_Layer_Append - Number of bytes appended to packet byt
|
||
* lower layer
|
||
* Shutdown_Receiver - TRUE if we aren't to receive any more
|
||
* packets from the lower layer
|
||
* Shutdown_Transmitter - TRUE if we aren't to transmit any more
|
||
* packets
|
||
* Data_Request_Queue - Queue that keeps the pending user data
|
||
* requests
|
||
* Data_Indication_Queue - Queue that holds the pending user data
|
||
* indications
|
||
* Data_Indication_Memory_Pool - List that holds available data
|
||
* indication buffers.
|
||
*
|
||
* Active_Data_Indication - Address of packet structure. This
|
||
* packet holds the current data indication
|
||
* that we are reassembling
|
||
* m_pT123 - Address of owner object. Used for
|
||
* callbacks
|
||
* m_pQ922 - Address of lower layer.
|
||
* m_nMsgBase - Message base to be used for owner
|
||
* callbacks
|
||
* Maximum_PDU_Size - Max. PDU size
|
||
* Arbitrated_PDU_Size - Max. arbitrated packet size.
|
||
* Identifier - Identifier passed to lower layer to
|
||
* register ourselves.
|
||
* Data_Indication_Queue_Size - Number of data indications we will
|
||
* buffer
|
||
* Data_Indication_Reassembly_Active - Flag set if we are in the middle
|
||
* of a packet reassembly.
|
||
* State - Holds the current state of the object
|
||
* Packet_Pending - Tells which packet will be sent next.
|
||
* Reject_Cause - The reason why the error packet was sent
|
||
* Packet_Size_Respond - Set to TRUE if we are to send a TPDU
|
||
* size element in the CC packet
|
||
* Error_Buffer - Address of error buffer.
|
||
* Error_Buffer_Length - Length of error buffer.
|
||
*
|
||
* m_nLocalLogicalHandle - Local transport connection id.
|
||
* m_nRemoteLogicalHandle - Remote transport connection id.
|
||
* User_Data_Pending - Set to the size of the last packet that
|
||
* the user attempted to pass to us, that
|
||
* we couldn't accept because we ran out
|
||
* of memory.
|
||
*
|
||
* Caveats:
|
||
* None.
|
||
*
|
||
* Authors:
|
||
* James W. Lawwill
|
||
*/
|
||
|
||
#include <windowsx.h>
|
||
#include "x224.h"
|
||
|
||
|
||
|
||
/*
|
||
* CLayerX224::CLayerX224 (
|
||
* PTransportResources transport_resources,
|
||
* IObject * owner_object,
|
||
* IProtocolLayer * lower_layer,
|
||
* USHORT message_base,
|
||
* USHORT logical_handle,
|
||
* USHORT identifier,
|
||
* USHORT data_indication_queue_size,
|
||
* USHORT default_PDU_size,
|
||
* PMemoryManager dr_memory_manager,
|
||
* BOOL * initialization_success)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This is the Transport constructor. This routine initializes all
|
||
* variables and allocates the buffers needed to operate.
|
||
*/
|
||
CLayerX224::CLayerX224
|
||
(
|
||
T123 *owner_object,
|
||
CLayerQ922 *pQ922, // lower layer
|
||
USHORT message_base,
|
||
LogicalHandle logical_handle,
|
||
ULONG identifier,
|
||
USHORT data_indication_queue_size,
|
||
USHORT default_PDU_size,
|
||
PMemoryManager dr_memory_manager,
|
||
BOOL *initialization_success
|
||
)
|
||
:
|
||
m_pT123(owner_object),
|
||
m_nMsgBase(message_base),
|
||
m_pQ922(pQ922)
|
||
{
|
||
TRACE_OUT(("CLayerX224::CLayerX224"));
|
||
|
||
ProtocolLayerError error;
|
||
|
||
m_nLocalLogicalHandle = logical_handle;
|
||
Identifier = identifier;
|
||
Default_PDU_Size = default_PDU_size;
|
||
Data_Request_Memory_Manager = dr_memory_manager;
|
||
*initialization_success = TRUE;
|
||
|
||
Shutdown_Receiver = FALSE;
|
||
Shutdown_Transmitter = FALSE;
|
||
Reject_Cause = 0;
|
||
|
||
|
||
/*
|
||
** Find the maximum packet size
|
||
*/
|
||
m_pQ922->GetParameters(
|
||
&Maximum_PDU_Size,
|
||
&Lower_Layer_Prepend,
|
||
&Lower_Layer_Append);
|
||
|
||
Arbitrated_PDU_Size = Default_PDU_Size;
|
||
|
||
/*
|
||
** Figure out what our largest PDU could be. We will use this value to
|
||
** arbitrate the maximum PDU size.
|
||
*/
|
||
Maximum_PDU_Size = (USHORT)GetMaxTPDUSize (Maximum_PDU_Size);
|
||
|
||
/*
|
||
** Register with the lower layer, so we can send and receive packets.
|
||
*/
|
||
error = m_pQ922->RegisterHigherLayer(
|
||
identifier,
|
||
Data_Request_Memory_Manager,
|
||
(IProtocolLayer *) this);
|
||
|
||
if (error != PROTOCOL_LAYER_NO_ERROR)
|
||
{
|
||
ERROR_OUT(("X224: constructor: Error registering with lower layer"));
|
||
*initialization_success = FALSE;
|
||
}
|
||
|
||
/*
|
||
** Prepare for buffer allocation
|
||
*/
|
||
Data_Indication_Queue_Size = data_indication_queue_size;
|
||
Error_Buffer = NULL;
|
||
|
||
/*
|
||
** Set member variables appropriately
|
||
*/
|
||
Active_Data_Indication = NULL;
|
||
Data_Indication_Reassembly_Active = FALSE;
|
||
Packet_Pending = TRANSPORT_NO_PACKET;
|
||
User_Data_Pending = 0;
|
||
|
||
m_nRemoteLogicalHandle = 0;
|
||
Packet_Size_Respond = FALSE;
|
||
|
||
if (*initialization_success == FALSE)
|
||
State = FAILED_TO_INITIALIZE;
|
||
else
|
||
State = NO_CONNECTION;
|
||
}
|
||
|
||
|
||
/*
|
||
* CLayerX224::~CLayerX224 (void)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This is the Transport destructor. This routine cleans up everything.
|
||
*/
|
||
CLayerX224::~CLayerX224(void)
|
||
{
|
||
TRACE_OUT(("CLayerX224::~CLayerX224"));
|
||
|
||
PMemory lpMemory;
|
||
PTMemory lptMem;
|
||
/*
|
||
** Notify the lower layer that we are terminating
|
||
*/
|
||
m_pQ922->RemoveHigherLayer(Identifier);
|
||
|
||
/*
|
||
** Go thru the data request queue and delete the structures held in the
|
||
** queue.
|
||
*/
|
||
Data_Request_Queue.reset();
|
||
while (Data_Request_Queue.iterate ((PDWORD_PTR) &lpMemory))
|
||
{
|
||
Data_Request_Memory_Manager-> FreeMemory (lpMemory);
|
||
}
|
||
|
||
/*
|
||
** Go thru the data indication queue and delete the structures held in the
|
||
** queue.
|
||
*/
|
||
Data_Indication_Queue.reset();
|
||
while (Data_Indication_Queue.iterate ((PDWORD_PTR) &lptMem))
|
||
delete lptMem;
|
||
|
||
/*
|
||
** Go thru the data request free structure pool and delete the structures
|
||
** held in the pool.
|
||
*/
|
||
Data_Indication_Memory_Pool.reset();
|
||
while (Data_Indication_Memory_Pool.iterate ((PDWORD_PTR) &lptMem))
|
||
delete lptMem;
|
||
|
||
/*
|
||
** If there is a data indication active, delete that structure.
|
||
*/
|
||
delete Active_Data_Indication;
|
||
|
||
/*
|
||
** If the error buffer holds a packet, delete it
|
||
*/
|
||
delete [] Error_Buffer;
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError CLayerX224::ConnectRequest (void)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function initiates a connect request.
|
||
*/
|
||
TransportError CLayerX224::ConnectRequest (void)
|
||
{
|
||
TRACE_OUT(("CLayerX224::ConnectRequest"));
|
||
|
||
if (State != NO_CONNECTION)
|
||
{
|
||
ERROR_OUT(("Transport: Illegal ConnectRequest packet"));
|
||
return (TRANSPORT_CONNECT_REQUEST_FAILED);
|
||
}
|
||
|
||
Packet_Pending = CONNECTION_REQUEST_PACKET;
|
||
return (TRANSPORT_NO_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError CLayerX224::ShutdownReceiver (void)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function stops us from receiving any more packets from the lower
|
||
* layer
|
||
*/
|
||
void CLayerX224::ShutdownReceiver (void)
|
||
{
|
||
TRACE_OUT(("CLayerX224::ShutdownReceiver"));
|
||
|
||
Shutdown_Receiver = TRUE;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError CLayerX224::EnableReceiver (void)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function permits us to send packets to the user application.
|
||
*/
|
||
void CLayerX224::EnableReceiver (void)
|
||
{
|
||
TRACE_OUT(("CLayerX224::EnableReceiver"));
|
||
|
||
Shutdown_Receiver = FALSE;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError CLayerX224::ShutdownTransmitter (void)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function keeps us from transmitting any more packets
|
||
*/
|
||
void CLayerX224::ShutdownTransmitter (void)
|
||
{
|
||
TRACE_OUT(("CLayerX224::ShutdownTransmitter"));
|
||
|
||
Shutdown_Transmitter = TRUE;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError CLayerX224::PurgeRequest (void)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function removes all packets from out output queue that aren't
|
||
* active
|
||
*/
|
||
void CLayerX224::PurgeRequest (void)
|
||
{
|
||
TRACE_OUT(("CLayerX224::PurgeRequest"));
|
||
|
||
DWORD entries;
|
||
DWORD keep_counter = 0;
|
||
PMemory memory;
|
||
LPBYTE packet_address;
|
||
DWORD i;
|
||
|
||
if (Data_Request_Queue.isEmpty() == FALSE)
|
||
{
|
||
entries = Data_Request_Queue.entries ();
|
||
|
||
/*
|
||
** Go thru packets looking for the last PDU in the SDU
|
||
*/
|
||
Data_Request_Queue.reset();
|
||
while (Data_Request_Queue.iterate ((PDWORD_PTR) &memory))
|
||
{
|
||
keep_counter++;
|
||
packet_address = memory -> GetPointer ();
|
||
if (*(packet_address + 2) == EOT_BIT)
|
||
break;
|
||
}
|
||
|
||
TRACE_OUT(("PurgeRequest: Removing %d packets", entries-keep_counter));
|
||
for (i=keep_counter; i<entries; i++)
|
||
{
|
||
Data_Request_Memory_Manager->FreeMemory ((PMemory) Data_Request_Queue.removeLast ());
|
||
}
|
||
}
|
||
return;
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError CLayerX224::ConnectResponse (void)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function initiates a connect response.
|
||
*/
|
||
TransportError CLayerX224::ConnectResponse (void)
|
||
{
|
||
TRACE_OUT(("CLayerX224::ConnectResponse"));
|
||
|
||
if (State != RECEIVED_CONNECT_REQUEST_PACKET)
|
||
{
|
||
ERROR_OUT(("Transport: Illegal ConnectResponse packet"));
|
||
return (TRANSPORT_CONNECT_RESPONSE_FAILED);
|
||
}
|
||
|
||
Packet_Pending = CONNECTION_CONFIRM_PACKET;
|
||
return (TRANSPORT_NO_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError CLayerX224::DisconnectRequest (void)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function initiates a disconnect request.
|
||
*/
|
||
TransportError CLayerX224::DisconnectRequest (void)
|
||
{
|
||
TRACE_OUT(("CLayerX224::DisconnectRequest"));
|
||
|
||
if (State == SENT_CONNECT_REQUEST_PACKET)
|
||
{
|
||
/*
|
||
** The connection is being rejected, send out the DISCONNECT
|
||
** packet and wait for termination
|
||
*/
|
||
Packet_Pending = DISCONNECT_REQUEST_PACKET;
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** Normal disconnects don't send any notification to the remote site.
|
||
** It depends on the Network layer to terminate the link.
|
||
*/
|
||
m_pQ922->RemoveHigherLayer(Identifier);
|
||
|
||
m_pT123->OwnerCallback(m_nMsgBase + TPRT_DISCONNECT_INDICATION,
|
||
(void *) m_nLocalLogicalHandle);
|
||
}
|
||
|
||
return (TRANSPORT_NO_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError CLayerX224::DataIndication (
|
||
* LPBYTE packet_address,
|
||
* ULONG buffer_size,
|
||
* PULong packet_length)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function is called by the lower layer when it has a packet for us.
|
||
*/
|
||
ProtocolLayerError CLayerX224::DataIndication (
|
||
LPBYTE packet_address,
|
||
ULONG packet_length,
|
||
PULong bytes_accepted)
|
||
{
|
||
TRACE_OUT(("CLayerX224::DataIndication"));
|
||
|
||
ULONG remainder_length;
|
||
USHORT class_request;
|
||
USHORT packet_type;
|
||
USHORT length;
|
||
USHORT destination_reference;
|
||
LegacyTransportData transport_data;
|
||
BOOL packet_accepted;
|
||
ULONG user_accepted;
|
||
UChar eot;
|
||
PTMemory packet;
|
||
TMemoryError packet_error;
|
||
LPBYTE temp_address;
|
||
BOOL use_default_PDU_size;
|
||
|
||
|
||
*bytes_accepted = 0;
|
||
packet_accepted = FALSE;
|
||
|
||
/*
|
||
** If the receiver is shutdown, don't accept any data
|
||
*/
|
||
if (Shutdown_Receiver)
|
||
return (PROTOCOL_LAYER_NO_ERROR);
|
||
|
||
/*
|
||
** The packet must be at least 2 bytes long
|
||
*/
|
||
if (packet_length < 2)
|
||
{
|
||
ERROR_OUT(("X224: DataIndication: Invalid packet received from lower layer: length = %d", packet_length));
|
||
return (PROTOCOL_LAYER_NO_ERROR);
|
||
}
|
||
|
||
remainder_length = packet_length;
|
||
temp_address = packet_address;
|
||
packet_address++;
|
||
packet_type = *(packet_address++) & TPDU_CODE_MASK;
|
||
remainder_length -= 2;
|
||
|
||
switch (packet_type)
|
||
{
|
||
case CONNECTION_REQUEST_PACKET:
|
||
packet_accepted = TRUE;
|
||
|
||
/*
|
||
** There should be at least 5 bytes remaining in this packet
|
||
*/
|
||
if (remainder_length < 5)
|
||
{
|
||
ERROR_OUT(("X224: DataIndication: CR: Invalid packet received from lower layer: length = %d", packet_length));
|
||
break;
|
||
}
|
||
|
||
/*
|
||
** Increment the packet address by 2 to get past the DST_REF
|
||
*/
|
||
packet_address += 2;
|
||
m_nRemoteLogicalHandle = *(packet_address++);
|
||
m_nRemoteLogicalHandle <<= 8;
|
||
m_nRemoteLogicalHandle |= *(packet_address++);
|
||
remainder_length -= 4;
|
||
|
||
/*
|
||
** Look at the class request to make sure it is 0
|
||
*/
|
||
class_request = *(packet_address++) >> 4;
|
||
remainder_length -= 1;
|
||
if (class_request != 0)
|
||
{
|
||
ERROR_OUT(("X224: DataIndication: CR packet: Illegal class request"));
|
||
ErrorPacket (
|
||
temp_address,
|
||
(USHORT) (packet_length - remainder_length));
|
||
break;
|
||
}
|
||
use_default_PDU_size = TRUE;
|
||
|
||
while (remainder_length != 0)
|
||
{
|
||
switch (*(packet_address++))
|
||
{
|
||
case TPDU_SIZE:
|
||
length = *(packet_address++);
|
||
remainder_length -= 1;
|
||
if (length != 1)
|
||
{
|
||
TRACE_OUT(("X224: DataIndication: CR packet: Illegal TPDU_Size length"));
|
||
|
||
ErrorPacket (
|
||
temp_address,
|
||
(USHORT) (packet_length - remainder_length));
|
||
break;
|
||
}
|
||
|
||
/*
|
||
** Figure out the actual PDU size
|
||
*/
|
||
Arbitrated_PDU_Size = (1 << *(packet_address++));
|
||
remainder_length -= 1;
|
||
TRACE_OUT(("X224: CR_Packet: Packet size = %d", Arbitrated_PDU_Size));
|
||
if (Arbitrated_PDU_Size > Maximum_PDU_Size)
|
||
{
|
||
Packet_Size_Respond = TRUE;
|
||
Arbitrated_PDU_Size = Maximum_PDU_Size;
|
||
}
|
||
if (AllocateBuffers() == FALSE)
|
||
{
|
||
m_pT123->OwnerCallback(m_nMsgBase + TPRT_DISCONNECT_INDICATION,
|
||
(void *) m_nLocalLogicalHandle);
|
||
}
|
||
use_default_PDU_size = FALSE;
|
||
break;
|
||
|
||
default:
|
||
ERROR_OUT(("X224: DataIndication: CR packet Unsupported parameter 0x%x", *(packet_address - 1)));
|
||
length = *(packet_address++);
|
||
remainder_length--;
|
||
|
||
packet_address += length;
|
||
remainder_length -= length;
|
||
break;
|
||
}
|
||
remainder_length--;
|
||
}
|
||
|
||
/*
|
||
** If the initiator wants to use the default PDU size, we need to
|
||
** check the default size with the Max. size to make sure it is
|
||
** valid for us.
|
||
*/
|
||
if (use_default_PDU_size)
|
||
{
|
||
if (Default_PDU_Size > Maximum_PDU_Size)
|
||
{
|
||
Packet_Size_Respond = TRUE;
|
||
Arbitrated_PDU_Size = Maximum_PDU_Size;
|
||
}
|
||
if (AllocateBuffers() == FALSE)
|
||
{
|
||
m_pT123->OwnerCallback(m_nMsgBase + TPRT_DISCONNECT_INDICATION,
|
||
(void *) m_nLocalLogicalHandle);
|
||
}
|
||
}
|
||
|
||
State = RECEIVED_CONNECT_REQUEST_PACKET;
|
||
|
||
/*
|
||
** Notify the owner that the remote site wants to start a
|
||
** connection
|
||
*/
|
||
m_pT123->OwnerCallback(m_nMsgBase + TPRT_CONNECT_INDICATION,
|
||
(void *) m_nLocalLogicalHandle);
|
||
TRACE_OUT(("X224: DataInd: ConnectRequest: max pkt = %d", Arbitrated_PDU_Size));
|
||
break;
|
||
|
||
case CONNECTION_CONFIRM_PACKET:
|
||
packet_accepted = TRUE;
|
||
|
||
/*
|
||
** There should be at least 5 bytes remaining in this packet
|
||
*/
|
||
if (remainder_length < 5)
|
||
{
|
||
ERROR_OUT(("X224: DataIndication: CC: Invalid packet received from lower layer: length = %d",
|
||
packet_length));
|
||
break;
|
||
}
|
||
|
||
destination_reference = *(packet_address++);
|
||
destination_reference <<= 8;
|
||
destination_reference |= *(packet_address++);
|
||
remainder_length -= 2;
|
||
if (destination_reference != m_nLocalLogicalHandle)
|
||
{
|
||
ERROR_OUT(("X224: DataIndication: CC packet: DST-REF incorrect"));
|
||
ErrorPacket (
|
||
temp_address,
|
||
(USHORT) (packet_length - remainder_length));
|
||
break;
|
||
}
|
||
|
||
m_nRemoteLogicalHandle = *(packet_address++);
|
||
m_nRemoteLogicalHandle <<= 8;
|
||
m_nRemoteLogicalHandle |= *(packet_address++);
|
||
|
||
class_request = *(packet_address++) >> 4;
|
||
remainder_length -= 3;
|
||
if (class_request != 0)
|
||
{
|
||
ERROR_OUT(("X224: DataIndication: CR packet: Illegal class request"));
|
||
ErrorPacket (
|
||
temp_address,
|
||
(USHORT) (packet_length - remainder_length));
|
||
break;
|
||
}
|
||
use_default_PDU_size = TRUE;
|
||
|
||
while (remainder_length != 0)
|
||
{
|
||
switch (*(packet_address++))
|
||
{
|
||
case TPDU_SIZE:
|
||
length = *(packet_address++);
|
||
remainder_length -= 1;
|
||
if (length != 1)
|
||
{
|
||
ERROR_OUT(("X224: DataIndication: CR packet: Illegal TPDU_Size length"));
|
||
|
||
ErrorPacket (
|
||
temp_address,
|
||
(USHORT) (packet_length - remainder_length));
|
||
}
|
||
Arbitrated_PDU_Size = (1 << *(packet_address++));
|
||
remainder_length -= 1;
|
||
TRACE_OUT(("X224: CC_Packet: Packet size = %d", Arbitrated_PDU_Size));
|
||
use_default_PDU_size = FALSE;
|
||
|
||
/*
|
||
** Allocate the buffers
|
||
*/
|
||
if (AllocateBuffers() == FALSE)
|
||
{
|
||
m_pT123->OwnerCallback(m_nMsgBase + TPRT_DISCONNECT_INDICATION,
|
||
(void *) m_nLocalLogicalHandle);
|
||
}
|
||
break;
|
||
|
||
default:
|
||
ERROR_OUT(("X224: DataIndication: CC packet Unsupported parameter"));
|
||
length = *(packet_address++);
|
||
remainder_length--;
|
||
|
||
packet_address += length;
|
||
remainder_length -= length;
|
||
break;
|
||
}
|
||
remainder_length--;
|
||
}
|
||
if (use_default_PDU_size)
|
||
{
|
||
if (AllocateBuffers () == FALSE)
|
||
{
|
||
m_pT123->OwnerCallback(m_nMsgBase + TPRT_DISCONNECT_INDICATION,
|
||
(void *) m_nLocalLogicalHandle);
|
||
}
|
||
}
|
||
|
||
State = CONNECTION_ACTIVE;
|
||
|
||
/*
|
||
** Notify the owner that the connect request has been confirmed
|
||
*/
|
||
m_pT123->OwnerCallback(m_nMsgBase + TPRT_CONNECT_CONFIRM,
|
||
(void *) m_nLocalLogicalHandle);
|
||
TRACE_OUT(("X224: DataInd: ConnectConfirm max pkt = %d", Arbitrated_PDU_Size));
|
||
break;
|
||
|
||
case DISCONNECT_REQUEST_PACKET:
|
||
TRACE_OUT(("X224: DataIndication: Disconnect req. received"));
|
||
|
||
/*
|
||
** Notify the owner that a disconnect has been requested. This
|
||
** message is only valid during establishment of the connection.
|
||
*/
|
||
m_pT123->OwnerCallback(m_nMsgBase + TPRT_DISCONNECT_INDICATION,
|
||
(void *) m_nLocalLogicalHandle);
|
||
packet_accepted = TRUE;
|
||
break;
|
||
|
||
case ERROR_PACKET:
|
||
TRACE_OUT(("X224: DataIndication: ERROR REQUEST received"));
|
||
|
||
/*
|
||
** Notify the owner that the remote site has detected an error in
|
||
** one of our packets.
|
||
*/
|
||
m_pT123->OwnerCallback(m_nMsgBase + TPRT_DISCONNECT_INDICATION,
|
||
(void *) m_nLocalLogicalHandle);
|
||
packet_accepted = TRUE;
|
||
break;
|
||
|
||
case DATA_PACKET:
|
||
if ((Data_Indication_Reassembly_Active == FALSE) &&
|
||
Data_Indication_Memory_Pool.isEmpty())
|
||
{
|
||
break;
|
||
}
|
||
|
||
packet_accepted = TRUE;
|
||
|
||
/*
|
||
** There should be at least 1 bytes remaining in this packet
|
||
*/
|
||
if (remainder_length < 1)
|
||
{
|
||
ERROR_OUT(("X224: DataIndication: DATA: Invalid packet "
|
||
"received from lower layer: length = %d", packet_length));
|
||
break;
|
||
}
|
||
|
||
eot = *(packet_address++);
|
||
remainder_length--;
|
||
|
||
/*
|
||
** The EOT_BIT is set if this is the last TPDU of the TSDU
|
||
*/
|
||
if ((eot & EOT_BIT) == EOT_BIT)
|
||
{
|
||
if (Data_Indication_Reassembly_Active == FALSE)
|
||
{
|
||
/*
|
||
** If the remote site has passed us an empty packet,
|
||
** just return
|
||
*/
|
||
if (remainder_length == 0)
|
||
break;
|
||
|
||
/*
|
||
** If this is a single packet and there aren't any
|
||
** other packets preceeding it, try to send it to the
|
||
** user without copying it into our own buffers
|
||
*/
|
||
if (Data_Indication_Queue.isEmpty())
|
||
{
|
||
transport_data.logical_handle = m_nLocalLogicalHandle;
|
||
transport_data.pbData = packet_address;
|
||
transport_data.cbDataSize = remainder_length;
|
||
|
||
/*
|
||
** Issue the user callback to give the user the data.
|
||
*/
|
||
user_accepted = ::NotifyT120(TRANSPORT_DATA_INDICATION, &transport_data);
|
||
|
||
/*
|
||
** If the user appliction does NOT accept the packet
|
||
** shutdown the receiver and wait for the user
|
||
** to re-enable it.
|
||
*/
|
||
if (user_accepted == TRANSPORT_NO_ERROR)
|
||
break;
|
||
else
|
||
Shutdown_Receiver = TRUE;
|
||
}
|
||
|
||
/*
|
||
** Put the packet into the DataIndication queue
|
||
*/
|
||
packet = (PTMemory) Data_Indication_Memory_Pool.get ();
|
||
packet_error = packet->Append (packet_address, remainder_length);
|
||
switch (packet_error)
|
||
{
|
||
case TMEMORY_NO_ERROR:
|
||
Data_Indication_Queue.append ((DWORD_PTR) packet);
|
||
break;
|
||
|
||
case TMEMORY_NONFATAL_ERROR:
|
||
case TMEMORY_FATAL_ERROR:
|
||
packet_accepted = FALSE;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** Add this PDU to the currently active SDU
|
||
*/
|
||
packet_error = Active_Data_Indication -> Append (
|
||
packet_address,
|
||
remainder_length);
|
||
|
||
switch (packet_error)
|
||
{
|
||
case TMEMORY_NO_ERROR:
|
||
Data_Indication_Reassembly_Active = FALSE;
|
||
Data_Indication_Queue.append ((DWORD_PTR) Active_Data_Indication);
|
||
Active_Data_Indication = NULL;
|
||
|
||
/*
|
||
** Call PollReceiver (), it will attempt to pass
|
||
** the packet on up to the user.
|
||
*/
|
||
PollReceiver();
|
||
break;
|
||
|
||
case TMEMORY_NONFATAL_ERROR:
|
||
case TMEMORY_FATAL_ERROR:
|
||
packet_accepted = FALSE;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** If the remote site is passing us a zero-length packet,
|
||
** just return
|
||
*/
|
||
if (remainder_length == 0)
|
||
break;
|
||
|
||
/*
|
||
** This is NOT the last packet in the incoming SDU, copy it
|
||
** into the data indication buffer and wait for the next packet
|
||
*/
|
||
if (Data_Indication_Reassembly_Active == FALSE)
|
||
{
|
||
Data_Indication_Reassembly_Active = TRUE;
|
||
Active_Data_Indication = (PTMemory) Data_Indication_Memory_Pool.get ();
|
||
}
|
||
|
||
packet_error = Active_Data_Indication -> Append (
|
||
packet_address,
|
||
remainder_length);
|
||
switch (packet_error)
|
||
{
|
||
case TMEMORY_NO_ERROR:
|
||
break;
|
||
|
||
case TMEMORY_NONFATAL_ERROR:
|
||
case TMEMORY_FATAL_ERROR:
|
||
packet_accepted = FALSE;
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
|
||
default:
|
||
ERROR_OUT(("X224: Illegal packet"));
|
||
break;
|
||
}
|
||
|
||
if (packet_accepted)
|
||
*bytes_accepted = packet_length;
|
||
|
||
return (PROTOCOL_LAYER_NO_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* ProtocolLayerError CLayerX224::PollTransmitter (
|
||
* ULONG,
|
||
* USHORT,
|
||
* USHORT * pending_data,
|
||
* USHORT *)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function is called periodically to give X224 a chance to transmit
|
||
* data.
|
||
*/
|
||
ProtocolLayerError CLayerX224::PollTransmitter (
|
||
ULONG_PTR,
|
||
USHORT,
|
||
USHORT * pending_data,
|
||
USHORT *)
|
||
{
|
||
// TRACE_OUT(("CLayerX224::PollTransmitter"));
|
||
|
||
LPBYTE packet_address;
|
||
ULONG bytes_accepted;
|
||
USHORT counter;
|
||
USHORT packet_size;
|
||
ULONG total_length;
|
||
USHORT packet_length;
|
||
PMemory memory;
|
||
BOOL continue_loop = TRUE;
|
||
|
||
while (continue_loop)
|
||
{
|
||
switch (Packet_Pending)
|
||
{
|
||
case CONNECTION_REQUEST_PACKET:
|
||
/*
|
||
** Add up the packet length, don't forget the 1 byte
|
||
** for the Length Indicator
|
||
*/
|
||
total_length =
|
||
CONNECT_REQUEST_HEADER_SIZE +
|
||
TPDU_ARBITRATION_PACKET_SIZE +
|
||
1 +
|
||
Lower_Layer_Prepend +
|
||
Lower_Layer_Append;
|
||
|
||
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
||
NULL,
|
||
total_length);
|
||
if (memory == NULL)
|
||
{
|
||
continue_loop = FALSE;
|
||
break;
|
||
}
|
||
|
||
packet_address = memory -> GetPointer ();
|
||
packet_address += Lower_Layer_Prepend;
|
||
|
||
*(packet_address++) =
|
||
CONNECT_REQUEST_HEADER_SIZE +
|
||
TPDU_ARBITRATION_PACKET_SIZE;
|
||
*(packet_address++) = CONNECTION_REQUEST_PACKET;
|
||
|
||
/*
|
||
** The following 2 bytes are the destination reference
|
||
*/
|
||
*(packet_address++) = 0;
|
||
*(packet_address++) = 0;
|
||
*(packet_address++) = (BYTE)(m_nLocalLogicalHandle >> 8);
|
||
*(packet_address++) = (BYTE)(m_nLocalLogicalHandle & 0xff);
|
||
|
||
/*
|
||
** The following byte is the Class/Options
|
||
*/
|
||
*(packet_address++) = 0;
|
||
|
||
/*
|
||
** Add TPDU arbitration data
|
||
*/
|
||
*(packet_address++) = TPDU_SIZE;
|
||
*(packet_address++) = 1;
|
||
|
||
/*
|
||
** Code our maximum PDU size into the X224 scheme
|
||
*/
|
||
Arbitrated_PDU_Size = Maximum_PDU_Size;
|
||
packet_size = Arbitrated_PDU_Size;
|
||
counter = 0;
|
||
while (packet_size > 1)
|
||
{
|
||
packet_size >>= 1;
|
||
counter++;
|
||
}
|
||
*(packet_address++) = (unsigned char) counter;
|
||
|
||
|
||
/*
|
||
** Attempt to send the packet to the lower layer
|
||
*/
|
||
m_pQ922->DataRequest(Identifier, memory, &bytes_accepted);
|
||
|
||
/*
|
||
** We assume that the lower layer has a packet input
|
||
** interface, if it does not, there has been a major error.
|
||
*/
|
||
if (bytes_accepted == total_length)
|
||
{
|
||
Packet_Pending = TRANSPORT_NO_PACKET;
|
||
State = SENT_CONNECT_REQUEST_PACKET;
|
||
}
|
||
else
|
||
continue_loop = FALSE;
|
||
|
||
Data_Request_Memory_Manager -> FreeMemory (memory);
|
||
break;
|
||
|
||
case CONNECTION_CONFIRM_PACKET:
|
||
packet_length = CONNECT_CONFIRM_HEADER_SIZE;
|
||
if (Packet_Size_Respond)
|
||
packet_length += TPDU_ARBITRATION_PACKET_SIZE;
|
||
|
||
total_length = packet_length +
|
||
1 +
|
||
Lower_Layer_Prepend +
|
||
Lower_Layer_Append;
|
||
|
||
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
||
NULL,
|
||
total_length);
|
||
if (memory == NULL)
|
||
{
|
||
continue_loop = FALSE;
|
||
break;
|
||
}
|
||
|
||
packet_address = memory -> GetPointer ();
|
||
packet_address += Lower_Layer_Prepend;
|
||
|
||
/*
|
||
** Build the packet
|
||
*/
|
||
*(packet_address++) = (UChar) packet_length;
|
||
*(packet_address++) = CONNECTION_CONFIRM_PACKET;
|
||
*(packet_address++) = (BYTE)(m_nRemoteLogicalHandle >> 8);
|
||
*(packet_address++) = (BYTE)(m_nRemoteLogicalHandle & 0xff);
|
||
*(packet_address++) = (BYTE)(m_nLocalLogicalHandle >> 8);
|
||
*(packet_address++) = (BYTE)(m_nLocalLogicalHandle & 0xff);
|
||
|
||
/*
|
||
** Set the Class/Options to 0
|
||
*/
|
||
*(packet_address++) = 0;
|
||
|
||
/*
|
||
** Packet_Size_Respond is TRUE if we are suppose to respond
|
||
** to the TPDU element in the Connect Request packet
|
||
*/
|
||
if (Packet_Size_Respond)
|
||
{
|
||
/*
|
||
** Add TPDU arbitration data
|
||
*/
|
||
*(packet_address++) = TPDU_SIZE;
|
||
*(packet_address++) = 1;
|
||
packet_size = Arbitrated_PDU_Size;
|
||
counter = 0;
|
||
while (packet_size > 1)
|
||
{
|
||
packet_size >>= 1;
|
||
counter++;
|
||
}
|
||
*(packet_address++) = (unsigned char) counter;
|
||
}
|
||
|
||
/*
|
||
** Attempt to send the packet to the lower layer
|
||
*/
|
||
m_pQ922->DataRequest(Identifier, memory, &bytes_accepted);
|
||
|
||
if (bytes_accepted == total_length)
|
||
{
|
||
Packet_Pending = TRANSPORT_NO_PACKET;
|
||
State = CONNECTION_ACTIVE;
|
||
}
|
||
else
|
||
continue_loop = FALSE;
|
||
Data_Request_Memory_Manager -> FreeMemory (memory);
|
||
break;
|
||
|
||
case DISCONNECT_REQUEST_PACKET:
|
||
/*
|
||
** Add 1 to the length for the Length Indicator
|
||
*/
|
||
total_length = DISCONNECT_REQUEST_HEADER_SIZE +
|
||
1 +
|
||
Lower_Layer_Prepend +
|
||
Lower_Layer_Append;
|
||
|
||
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
||
NULL,
|
||
total_length);
|
||
if (memory == NULL)
|
||
{
|
||
continue_loop = FALSE;
|
||
break;
|
||
}
|
||
|
||
packet_address = memory -> GetPointer ();
|
||
packet_address += Lower_Layer_Prepend;
|
||
|
||
TRACE_OUT(("X224: Sending Disconnect Request Packet"));
|
||
*(packet_address++) = DISCONNECT_REQUEST_HEADER_SIZE;
|
||
*(packet_address++) = DISCONNECT_REQUEST_PACKET;
|
||
*(packet_address++) = (BYTE)(m_nRemoteLogicalHandle >> 8);
|
||
*(packet_address++) = (BYTE)(m_nRemoteLogicalHandle & 0xff);
|
||
|
||
/*
|
||
** Set the source reference to 0, this packet will only
|
||
** be sent as a refusal to a Connect Request, therefore
|
||
** this value should be 0
|
||
*/
|
||
*(packet_address++) = 0;
|
||
*(packet_address++) = 0;
|
||
*(packet_address++) = DISCONNECT_REASON_NOT_SPECIFIED;
|
||
|
||
/*
|
||
** Attempt to send packet to lower layer
|
||
*/
|
||
m_pQ922->DataRequest(Identifier, memory, &bytes_accepted);
|
||
|
||
if (bytes_accepted == total_length)
|
||
{
|
||
Packet_Pending = TRANSPORT_NO_PACKET;
|
||
State = SENT_DISCONNECT_REQUEST_PACKET;
|
||
}
|
||
continue_loop = FALSE;
|
||
Data_Request_Memory_Manager -> FreeMemory (memory);
|
||
break;
|
||
|
||
case ERROR_PACKET:
|
||
TRACE_OUT(("X224: Sending Error Packet"));
|
||
total_length = ERROR_HEADER_SIZE +
|
||
Error_Buffer_Length +
|
||
1 +
|
||
2 +
|
||
Lower_Layer_Prepend +
|
||
Lower_Layer_Append;
|
||
|
||
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
||
NULL,
|
||
total_length);
|
||
if (memory == NULL)
|
||
{
|
||
continue_loop = FALSE;
|
||
break;
|
||
}
|
||
|
||
packet_address = memory -> GetPointer ();
|
||
packet_address += Lower_Layer_Prepend;
|
||
|
||
|
||
*(packet_address++) =
|
||
ERROR_HEADER_SIZE + Error_Buffer_Length;
|
||
*(packet_address++) = ERROR_PACKET;
|
||
*(packet_address++) = (BYTE)(m_nRemoteLogicalHandle >> 8);
|
||
*(packet_address++) = (BYTE)(m_nRemoteLogicalHandle & 0xff);
|
||
*(packet_address++) = Reject_Cause;
|
||
|
||
*(packet_address++) = INVALID_TPDU;
|
||
*(packet_address++) = (UChar) Error_Buffer_Length;
|
||
memcpy (packet_address, Error_Buffer, Error_Buffer_Length);
|
||
|
||
/*
|
||
** Attempt to send packet to lower layer
|
||
*/
|
||
m_pQ922->DataRequest(Identifier, memory, &bytes_accepted);
|
||
|
||
if (bytes_accepted == total_length)
|
||
{
|
||
delete [] Error_Buffer;
|
||
Error_Buffer = NULL;
|
||
|
||
Packet_Pending = TRANSPORT_NO_PACKET;
|
||
State = SENT_CONNECT_REQUEST_PACKET;
|
||
}
|
||
else
|
||
continue_loop = FALSE;
|
||
Data_Request_Memory_Manager -> FreeMemory (memory);
|
||
break;
|
||
|
||
case TRANSPORT_NO_PACKET:
|
||
if (Data_Request_Queue.isEmpty() == FALSE)
|
||
{
|
||
/*
|
||
** Get the next packet from the queue
|
||
*/
|
||
memory = (PMemory) Data_Request_Queue.read ();
|
||
total_length = memory -> GetLength ();
|
||
|
||
m_pQ922->DataRequest(Identifier, memory, &bytes_accepted);
|
||
|
||
if (bytes_accepted == total_length)
|
||
{
|
||
Data_Request_Queue.get ();
|
||
Data_Request_Memory_Manager -> FreeMemory (memory);
|
||
}
|
||
else
|
||
continue_loop = FALSE;
|
||
}
|
||
else
|
||
continue_loop = FALSE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (Data_Request_Queue.isEmpty())
|
||
*pending_data = 0;
|
||
else
|
||
*pending_data = PROTOCOL_USER_DATA;
|
||
|
||
return (PROTOCOL_LAYER_NO_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* TransportError CLayerX224::DataRequest (
|
||
* ULONG,
|
||
* LPBYTE packet_address,
|
||
* USHORT packet_length,
|
||
* USHORT * bytes_accepted)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function takes a packet from the user and queues it for
|
||
* transmission.
|
||
*/
|
||
ProtocolLayerError CLayerX224::DataRequest (
|
||
ULONG_PTR,
|
||
LPBYTE packet_address,
|
||
ULONG packet_length,
|
||
PULong bytes_accepted)
|
||
{
|
||
TRACE_OUT(("CLayerX224::DataRequest"));
|
||
|
||
ULONG total_packet_size;
|
||
ULONG packet_size;
|
||
DataRequestQueue temporary_queue;
|
||
PMemory memory;
|
||
BOOL packet_failed = FALSE;
|
||
LPBYTE address;
|
||
|
||
*bytes_accepted = 0;
|
||
|
||
if (Shutdown_Transmitter)
|
||
return (PROTOCOL_LAYER_NO_ERROR);
|
||
|
||
total_packet_size = packet_length;
|
||
|
||
/*
|
||
** Create enough PDUs to hold the packet. We don't actually copy the
|
||
** packet into the new buffers until we know that we can get enough
|
||
** space.
|
||
*/
|
||
while (total_packet_size != 0)
|
||
{
|
||
if (total_packet_size >
|
||
(ULONG) (Arbitrated_PDU_Size - DATA_PACKET_HEADER_SIZE))
|
||
{
|
||
packet_size = Arbitrated_PDU_Size - DATA_PACKET_HEADER_SIZE;
|
||
}
|
||
else
|
||
packet_size = total_packet_size;
|
||
|
||
total_packet_size -= packet_size;
|
||
|
||
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
||
NULL,
|
||
packet_size +
|
||
DATA_PACKET_HEADER_SIZE +
|
||
Lower_Layer_Prepend +
|
||
Lower_Layer_Append);
|
||
if (memory == NULL)
|
||
{
|
||
packet_failed = TRUE;
|
||
break;
|
||
}
|
||
|
||
temporary_queue.append ((DWORD_PTR) memory);
|
||
}
|
||
|
||
|
||
/*
|
||
** If we were unable to allocate memory for the packet, release the memory
|
||
** that we did allocate.
|
||
*/
|
||
if (packet_failed)
|
||
{
|
||
temporary_queue.reset();
|
||
while (temporary_queue.iterate ((PDWORD_PTR) &memory))
|
||
{
|
||
Data_Request_Memory_Manager->FreeMemory (memory);
|
||
}
|
||
|
||
/*
|
||
** Set the User_Data_Pending flag to the packet_length so we can
|
||
** notify the user when buffer space is available.
|
||
*/
|
||
User_Data_Pending = packet_length;
|
||
}
|
||
else
|
||
{
|
||
User_Data_Pending = 0;
|
||
|
||
total_packet_size = packet_length;
|
||
|
||
/*
|
||
** Go thru each of the PDUs and actually create them.
|
||
*/
|
||
temporary_queue.reset();
|
||
while (temporary_queue.iterate ((PDWORD_PTR) &memory))
|
||
{
|
||
if (total_packet_size >
|
||
(ULONG) (Arbitrated_PDU_Size - DATA_PACKET_HEADER_SIZE))
|
||
{
|
||
packet_size = Arbitrated_PDU_Size - DATA_PACKET_HEADER_SIZE;
|
||
}
|
||
else
|
||
packet_size = total_packet_size;
|
||
|
||
address = memory -> GetPointer ();
|
||
|
||
memcpy (
|
||
address + DATA_PACKET_HEADER_SIZE + Lower_Layer_Prepend,
|
||
packet_address + (USHORT) (packet_length - total_packet_size),
|
||
packet_size);
|
||
|
||
total_packet_size -= packet_size;
|
||
|
||
/*
|
||
** This is the header for a data packet
|
||
*/
|
||
address += Lower_Layer_Prepend;
|
||
*address = 2;
|
||
*(address + 1) = DATA_PACKET;
|
||
if (total_packet_size == 0)
|
||
*(address + 2) = EOT_BIT;
|
||
else
|
||
*(address + 2) = 0;
|
||
|
||
/*
|
||
** Load the memory object into the queue
|
||
*/
|
||
Data_Request_Queue.append ((DWORD_PTR) memory);
|
||
}
|
||
*bytes_accepted = packet_length;
|
||
}
|
||
|
||
return (PROTOCOL_LAYER_NO_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* ProtocolLayerError CLayerX224::DataRequest (
|
||
* ULONG,
|
||
* PMemory,
|
||
* USHORT * bytes_accepted)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function takes a packet from the user and queues it for
|
||
* transmission.
|
||
*/
|
||
ProtocolLayerError CLayerX224::DataRequest (
|
||
ULONG_PTR,
|
||
PMemory,
|
||
PULong bytes_accepted)
|
||
{
|
||
*bytes_accepted = 0;
|
||
|
||
return (PROTOCOL_LAYER_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* ProtocolLayerError CLayerX224::PollReceiver (
|
||
* ULONG)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function should be called periodically to allow us to send received
|
||
* packets to the user.
|
||
*/
|
||
ProtocolLayerError CLayerX224::PollReceiver(void)
|
||
{
|
||
// TRACE_OUT(("CLayerX224::PollReceiver"));
|
||
|
||
LegacyTransportData transport_data;
|
||
ULONG packet_accepted;
|
||
PTMemory packet;
|
||
HPUChar packet_address;
|
||
ULONG packet_length;
|
||
|
||
if (Shutdown_Receiver)
|
||
return (PROTOCOL_LAYER_NO_ERROR);
|
||
|
||
/*
|
||
** If I have any packets in my receive buffers that
|
||
** need to go to higher layers, do it now
|
||
*/
|
||
while (Data_Indication_Queue.isEmpty () == FALSE)
|
||
{
|
||
packet = (PTMemory) Data_Indication_Queue.read ();
|
||
packet -> GetMemory (
|
||
&packet_address,
|
||
&packet_length);
|
||
transport_data.logical_handle = m_nLocalLogicalHandle;
|
||
transport_data.pbData = (LPBYTE) packet_address;
|
||
transport_data.cbDataSize = packet_length;
|
||
|
||
packet_accepted = ::NotifyT120(TRANSPORT_DATA_INDICATION, &transport_data);
|
||
|
||
/*
|
||
** If the user returns anything but TRANSPORT_NO_ERROR, it could not
|
||
** accept the packet. We will try to send the packet again later.
|
||
*/
|
||
if (packet_accepted == TRANSPORT_NO_ERROR)
|
||
{
|
||
Data_Indication_Queue.get ();
|
||
packet -> Reset ();
|
||
Data_Indication_Memory_Pool.append ((DWORD_PTR) packet);
|
||
}
|
||
else
|
||
{
|
||
/*
|
||
** If the user appliction does NOT accept the packet
|
||
** shutdown the receiver and wait for the user to re-enable it.
|
||
*/
|
||
Shutdown_Receiver = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return (PROTOCOL_LAYER_NO_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* ProtocolLayerError CLayerX224::GetParameters (
|
||
* ULONG,
|
||
* USHORT * packet_size)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function returns the maximum allowable TSDU.
|
||
*/
|
||
ProtocolLayerError CLayerX224::GetParameters (
|
||
USHORT *,
|
||
USHORT *,
|
||
USHORT *)
|
||
{
|
||
return (PROTOCOL_LAYER_NO_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* ProtocolLayerError CLayerX224::RegisterHigherLayer (
|
||
* ULONG,
|
||
* PMemoryManager,
|
||
* IProtocolLayer *)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function does nothing. The only reason it is here is because this
|
||
* class inherits from ProtocolLayer and this function is pure virtual in
|
||
* that class.
|
||
*/
|
||
ProtocolLayerError CLayerX224::RegisterHigherLayer (
|
||
ULONG_PTR,
|
||
PMemoryManager,
|
||
IProtocolLayer *)
|
||
{
|
||
return (PROTOCOL_LAYER_REGISTRATION_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* ProtocolLayerError CLayerX224::RemoveHigherLayer (
|
||
* ULONG)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function does nothing. The only reason it is here is because this
|
||
* class inherits from ProtocolLayer and this function is pure virtual in
|
||
* that class.
|
||
*/
|
||
ProtocolLayerError CLayerX224::RemoveHigherLayer (
|
||
ULONG_PTR)
|
||
{
|
||
return (PROTOCOL_LAYER_REGISTRATION_ERROR);
|
||
}
|
||
|
||
|
||
/*
|
||
* BOOL CLayerX224::AllocateBuffers ()
|
||
*
|
||
* Functional Description
|
||
* This function allocates the data request and data indication buffers.
|
||
* and sets up the memory pools necessary. It also sets up the Control
|
||
* buffer for control packets.
|
||
*
|
||
* Formal Parameters
|
||
* None
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None
|
||
*
|
||
* Caveats
|
||
* None
|
||
*/
|
||
BOOL CLayerX224::AllocateBuffers ()
|
||
{
|
||
TRACE_OUT(("CLayerX224::AllocateBuffers"));
|
||
|
||
PTMemory packet;
|
||
USHORT i;
|
||
ULONG total_packet_size;
|
||
TMemoryError error;
|
||
|
||
total_packet_size = MAXIMUM_USER_DATA_SIZE;
|
||
for (i=0; i<Data_Indication_Queue_Size; i++)
|
||
{
|
||
DBG_SAVE_FILE_LINE
|
||
packet = new TMemory (
|
||
total_packet_size,
|
||
0,
|
||
&error);
|
||
|
||
if (error == TMEMORY_NO_ERROR)
|
||
Data_Indication_Memory_Pool.append ((DWORD_PTR) packet);
|
||
else
|
||
return (FALSE);
|
||
}
|
||
|
||
return (TRUE);
|
||
}
|
||
|
||
|
||
/*
|
||
* void CLayerX224::ErrorPacket (
|
||
* LPBYTE packet_address,
|
||
* USHORT packet_length)
|
||
*
|
||
* Functional Description
|
||
* This function stores the packet into our own error buffer and prepares
|
||
* to send it out
|
||
*
|
||
* Formal Parameters
|
||
* None
|
||
*
|
||
* Return Value
|
||
* None.
|
||
*
|
||
* Side Effects
|
||
* None
|
||
*
|
||
* Caveats
|
||
* None
|
||
*/
|
||
void CLayerX224::ErrorPacket (
|
||
LPBYTE packet_address,
|
||
USHORT packet_length)
|
||
{
|
||
TRACE_OUT(("CLayerX224::ErrorPacket"));
|
||
|
||
DBG_SAVE_FILE_LINE
|
||
Error_Buffer = new BYTE[packet_length];
|
||
if (NULL != Error_Buffer)
|
||
{
|
||
Error_Buffer_Length = packet_length;
|
||
|
||
memcpy (Error_Buffer, packet_address, packet_length);
|
||
|
||
Packet_Pending = ERROR_PACKET;
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* void CLayerX224::CheckUserBuffers ()
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function issues TRANSPORT_BUFFER_AVAILABLE_INDICATIONs to the
|
||
* user if available.
|
||
*/
|
||
void CLayerX224::CheckUserBuffers ()
|
||
{
|
||
// TRACE_OUT(("CLayerX224::CheckUserBuffers"));
|
||
|
||
ULONG user_data_size;
|
||
ULONG buffer_size;
|
||
ULONG full_size_buffers_needed;
|
||
ULONG full_size_buffer_count;
|
||
ULONG partial_buffer_size;
|
||
ULONG partial_buffer_count;
|
||
|
||
|
||
if (User_Data_Pending == 0)
|
||
return;
|
||
|
||
/*
|
||
** Determine the user data size in a packet, then determine
|
||
** how many buffers will be needed to accept that packet.
|
||
*/
|
||
user_data_size = Arbitrated_PDU_Size - DATA_PACKET_HEADER_SIZE;
|
||
full_size_buffers_needed = User_Data_Pending / user_data_size;
|
||
|
||
/*
|
||
** Find out how many full size buffers are available
|
||
*/
|
||
if (full_size_buffers_needed != 0)
|
||
{
|
||
/*
|
||
** Increment full_size_buffers_needed to account for our priority
|
||
** value.
|
||
*/
|
||
buffer_size =
|
||
Arbitrated_PDU_Size + Lower_Layer_Prepend + Lower_Layer_Append;
|
||
|
||
full_size_buffer_count = Data_Request_Memory_Manager ->
|
||
GetBufferCount (buffer_size);
|
||
if (full_size_buffer_count < full_size_buffers_needed)
|
||
return;
|
||
}
|
||
|
||
partial_buffer_size = User_Data_Pending % user_data_size;
|
||
if (partial_buffer_size != 0)
|
||
{
|
||
if ((full_size_buffers_needed == 0) ||
|
||
(full_size_buffer_count == full_size_buffers_needed))
|
||
{
|
||
buffer_size = partial_buffer_size +
|
||
DATA_PACKET_HEADER_SIZE +
|
||
Lower_Layer_Prepend +
|
||
Lower_Layer_Append;
|
||
|
||
partial_buffer_count = Data_Request_Memory_Manager ->
|
||
GetBufferCount (buffer_size);
|
||
|
||
if (full_size_buffers_needed == 0)
|
||
{
|
||
if (partial_buffer_count == 0)
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
if ((partial_buffer_count == full_size_buffer_count) ||
|
||
(partial_buffer_count == 0))
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
User_Data_Pending = 0;
|
||
|
||
::NotifyT120(TRANSPORT_BUFFER_EMPTY_INDICATION, (void *) m_nLocalLogicalHandle);
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
/*
|
||
* static ULONG CLayerX224::GetMaxTPDUSize (
|
||
* ULONG max_lower_layer_pdu)
|
||
*
|
||
* Public
|
||
*
|
||
* Functional Description:
|
||
* This function accepts a value for the lower layer max. PDU size
|
||
* and returns the max. PDU size that this Transport can support
|
||
* based on it. X224 only suports max PDU sizes of 128, 256, 512,
|
||
* 1024, and 2048. So, if the max_lower_layer_pdu is 260, the
|
||
* Transport can only have a max pdu size of 256.
|
||
*/
|
||
ULONG CLayerX224::GetMaxTPDUSize (
|
||
ULONG max_lower_layer_pdu)
|
||
{
|
||
TRACE_OUT(("CLayerX224::GetMaxTPDUSize"));
|
||
|
||
ULONG max_tpdu_size;
|
||
|
||
if (max_lower_layer_pdu < 256)
|
||
max_tpdu_size = 128;
|
||
else if (max_lower_layer_pdu < 512)
|
||
max_tpdu_size = 256;
|
||
else if (max_lower_layer_pdu < 1024)
|
||
max_tpdu_size = 512;
|
||
else if (max_lower_layer_pdu < 2048)
|
||
max_tpdu_size = 1024;
|
||
else
|
||
max_tpdu_size = 2048;
|
||
|
||
return (max_tpdu_size);
|
||
}
|
||
|