mirror of https://github.com/tongzx/nt5src
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.
3132 lines
99 KiB
3132 lines
99 KiB
#include "precomp.h"
|
|
DEBUG_FILEZONE(ZONE_T120_T123PSTN);
|
|
|
|
/* Q922.cpp
|
|
*
|
|
* Copyright (c) 1993-1995 by DataBeam Corporation, Lexington, KY
|
|
*
|
|
* Abstract:
|
|
* This is the implementation file for the Q.922 Data Link protocol.
|
|
* Before diving into the code, it is recommended that you read the
|
|
* Q.922 protocol.
|
|
*
|
|
* Private Instance Variables:
|
|
* m_pT123 - Address of the owner of this object. Used for
|
|
* owner callbacks.
|
|
* m_pMultiplexer - Address of ProtocolLayer below Q922 in the
|
|
* stack.
|
|
* Higher_Layer - Address of ProtocolLayer above Q922 in the
|
|
* stack.
|
|
* m_nMsgBase - Message base used in owner callbacks.
|
|
* DLCI - DLCI used to identfy Q922 entities.
|
|
* Link_Originator - TRUE if we are the link originators. If we are,
|
|
* we sent out the first SABME packet.
|
|
* Maximum_Information_Size-
|
|
* Holds the maximum packet size that we support.
|
|
* SABME_Pending - TRUE if we need to initiate the link.
|
|
* Unnumbered_Acknowledge_Pending - TRUE if we need to send out an
|
|
* Unnumbered Ack. packet. This is
|
|
* done in response to a SABME or DISC.
|
|
* DISC_Pending - TRUE if we need to send out a DISConnect packet.
|
|
* Unnumbered_PF_State - Holds the Poll/Final state of an unnumbered
|
|
* packet.
|
|
* Final_Packet - TRUE if the next Unnumbered Ack. sent out is
|
|
* our final packet to transmit before notifying
|
|
* the owner that the link is broken.
|
|
* Data_Indication_Size- Number of data indication buffers available
|
|
* Data_Indication - Base address of data indication buffers
|
|
* Data_Indication_Head- Head of data indication queue
|
|
* Data_Indication_Tail- Tail of read data indication queue
|
|
* Data_Indication_Count- Number of data indication buffers in use
|
|
*
|
|
* Data_Request_Size - Number of data request buffers
|
|
* Data_Request_Total_Size - Number of data request buffers + maximum
|
|
* number of outstanding packets
|
|
* Data_Request - Base address of data request buffers
|
|
* Data_Request_Head - Head of data request queue
|
|
* Data_Request_Tail - Tail of data request queue
|
|
* Data_Request_Count - Number of data request buffers in use
|
|
* Data_Request_Acknowledge_Tail- Tail of the queue referring to packets
|
|
* that have been acknowledged
|
|
*
|
|
* Supervisory_Write_Struct - Buffer used for supervisory packets
|
|
* Send_State_Variable - This is the sequence number that will
|
|
* be sent in the next information packet
|
|
* to uniquely identify the packet. The
|
|
* number is between 0 and 127.
|
|
* Receive_State_Variable - Receive Sequence Number. The expected
|
|
* sequence number of the next Information
|
|
* packet we receive
|
|
* Acknowledge_State_Variable - This is the sequence number that the
|
|
* remote site is expecting in our next
|
|
* information packet
|
|
* Own_Receiver_Busy - If our read buffers are full, we set
|
|
* this flag so that we send a Receiver
|
|
* Not Ready packet to the remote site
|
|
* Peer_Receiver_Busy - Remote site is not ready to receive
|
|
* Information packets
|
|
*
|
|
* Command_Pending - When this flag is set to TRUE, we send
|
|
* a Supervisory/Command packet to the
|
|
* remote site.
|
|
*
|
|
* We need to send a Supervisory/Command
|
|
* packet when our receiver is no longer
|
|
* busy. This tells the remote site to
|
|
* resume sending Information packets to
|
|
* us.
|
|
* Poll_Pending - This flag tells us to send a Supervisory
|
|
* command to the remote location with the
|
|
* Poll flag set. This tells the remote
|
|
* site to reply to this command
|
|
* Final_Pending - This flag is set when we need to reply
|
|
* to a remote command
|
|
* Acknowledge_Pending - This flag signals us to send a
|
|
* Supervisory/Response packet to the
|
|
* remote site.
|
|
* Reject_Pending - Signals us to send a Supervisory/
|
|
* Response packet to the remote site
|
|
* indicating that we missed a packet.
|
|
* Reject_Outstanding - Internal flag telling us that our Reject
|
|
* packet has been sent and don't send
|
|
* another one
|
|
* T200_Timeout - Timeout value. If we send out a packet
|
|
* and expect a response, and T200_Timeout
|
|
* expires, we enter the TIMER_RECOVERY
|
|
* mode.
|
|
* T200_Handle - Handle to timer event.
|
|
* T200_Active - Flag that signals if T200 is running
|
|
* N200_Count - Number of times T200 expires in a row
|
|
* without a response from the remote site.
|
|
*
|
|
* T203_Timeout - Timeout value. If we don't receive a
|
|
* packet from the remote site in T203
|
|
* time, we enter the TIMER_RECOVERY mode.
|
|
* T203_Handle - Handle to timer event
|
|
* T203_Active - Flag that signals if T203 is running.
|
|
* Maximum_T200_Timeouts - Maximum number of T200 timeouts before
|
|
* we consider the link unstable.
|
|
* Data_Link_Mode - Our mode of operation.
|
|
* MULTIPLE_FRAME_ESTABLISHED
|
|
* TIMER_RECOVERY
|
|
* Link_Stable - Flag that indicates if our current
|
|
* connection is stable. FALSE if the
|
|
* N200_Count == Maximum number of T200
|
|
* timeouts
|
|
* Receive_Sequence_Exception - Set if we receive an ILLEGAL sequence
|
|
* number
|
|
* Maximum_Outstanding_Packets - Maximum number of packets that we can
|
|
* have out on the line at a time.
|
|
* Outstanding_Packets - Actual number of packets outstanding
|
|
* Maximum_Outstanding_Bytes - Maximum number of bytes that can be
|
|
* on the line at any one time. It is VERY
|
|
* important to note that using this as a
|
|
* limiting factor on transmission is NOT
|
|
* a protocol defined limit. This was
|
|
* added to our Q922 because we had
|
|
* problems with some modems that were
|
|
* buffering our Tx data. Some modems
|
|
* would buffer up to 4K of data. This is
|
|
* unacceptable to us because our timeouts
|
|
* would expire before the data left the
|
|
* modem. Using this parameter as a
|
|
* limiting factor validates our timer
|
|
* values.
|
|
* Outstanding_Bytes - Actual number of bytes on the line at
|
|
* the current time.
|
|
* Total_Retransmitted - Number of packets that have been
|
|
* retransmitted.
|
|
* Data_Request_Memory_Manager - Memory manager used for all DataRequests
|
|
* Lower_Layer_Prepend - Number of bytes prepended to each packet
|
|
* by the lower layer
|
|
* Lower_Layer_Append - Number of bytes appended to packet by
|
|
* the lower layer.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*
|
|
* Authors:
|
|
* James P. Galvin
|
|
* James W. Lawwill
|
|
*/
|
|
|
|
#include "q922.h"
|
|
|
|
/*
|
|
* CLayerQ922::CLayerQ922 (
|
|
* PTransportResources transport_resources,
|
|
* IObject * owner_object,
|
|
* IProtocolLayer * lower_layer,
|
|
* USHORT message_base,
|
|
* USHORT identifier,
|
|
* BOOL link_originator,
|
|
* USHORT data_indication_queue_siz,
|
|
* USHORT data_request_queue_size,
|
|
* USHORT k_factor,
|
|
* USHORT max_information_size,
|
|
* USHORT t200,
|
|
* USHORT call_control_type,
|
|
* USHORT max_outstanding_bytes,
|
|
* PMemoryManager memory_manager,
|
|
* BOOL * initialized)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This is the CLayerQ922 constructor. This routine initializes all
|
|
* variables and allocates buffer space.
|
|
*/
|
|
CLayerQ922::CLayerQ922
|
|
(
|
|
T123 *owner_object,
|
|
Multiplexer *pMux, // lower layer
|
|
USHORT message_base,
|
|
USHORT identifier,
|
|
BOOL link_originator,
|
|
USHORT data_indication_queue_size,
|
|
USHORT data_request_queue_size,
|
|
USHORT k_factor,
|
|
USHORT max_information_size,
|
|
USHORT t200,
|
|
USHORT max_outstanding_bytes,
|
|
PMemoryManager memory_manager,
|
|
PLUGXPRT_PSTN_CALL_CONTROL call_control_type,
|
|
PLUGXPRT_PARAMETERS *pParams,
|
|
BOOL * initialized
|
|
)
|
|
:
|
|
m_pT123(owner_object),
|
|
m_nMsgBase(message_base),
|
|
m_pMultiplexer(pMux)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::CLayerQ922"));
|
|
|
|
ProtocolLayerError error;
|
|
USHORT packet_size;
|
|
USHORT i;
|
|
|
|
DLCI = identifier;
|
|
Link_Originator = link_originator;
|
|
|
|
Maximum_Outstanding_Packets = k_factor;
|
|
T200_Timeout = t200;
|
|
Maximum_Information_Size = max_information_size;
|
|
Maximum_Outstanding_Bytes = max_outstanding_bytes;
|
|
Data_Request_Memory_Manager = memory_manager;
|
|
|
|
Higher_Layer = NULL;
|
|
Data_Request = NULL;
|
|
Data_Indication = NULL;
|
|
Data_Indication_Buffer = NULL;
|
|
*initialized = TRUE;
|
|
|
|
/*
|
|
** Find the maximum packet size supported by the lower layer
|
|
*/
|
|
m_pMultiplexer->GetParameters(
|
|
&packet_size,
|
|
&Lower_Layer_Prepend,
|
|
&Lower_Layer_Append);
|
|
|
|
if (Maximum_Information_Size > packet_size)
|
|
Maximum_Information_Size = packet_size;
|
|
|
|
TRACE_OUT(("Q922: DLCI %d: Max information Size = %d", DLCI, Maximum_Information_Size));
|
|
|
|
/*
|
|
** Register with the lower layer
|
|
*/
|
|
error = m_pMultiplexer->RegisterHigherLayer(
|
|
identifier,
|
|
Data_Request_Memory_Manager,
|
|
(IProtocolLayer *) this);
|
|
|
|
if (error != PROTOCOL_LAYER_NO_ERROR)
|
|
{
|
|
*initialized = FALSE;
|
|
ERROR_OUT(("Q922: DLCI %d: constructor: Error registering with lower layer", DLCI));
|
|
}
|
|
|
|
/*
|
|
** Allocation of data indication buffers. Allocate the prescribed number
|
|
*/
|
|
Data_Indication_Size = data_indication_queue_size;
|
|
Data_Indication =
|
|
(PDataQueue) LocalAlloc (LMEM_FIXED, (sizeof (DataQueue) * Data_Indication_Size));
|
|
if (Data_Indication != NULL)
|
|
{
|
|
Data_Indication_Buffer = (LPBYTE)
|
|
LocalAlloc (LMEM_FIXED, Maximum_Information_Size * Data_Indication_Size);
|
|
if (Data_Indication_Buffer != NULL)
|
|
{
|
|
for (i=0; i<Data_Indication_Size; i++)
|
|
{
|
|
(Data_Indication + i) -> buffer_address =
|
|
Data_Indication_Buffer + (i * Maximum_Information_Size);
|
|
(Data_Indication + i) -> length = 0;
|
|
}
|
|
|
|
}
|
|
else
|
|
*initialized = FALSE;
|
|
}
|
|
else
|
|
*initialized = FALSE;
|
|
|
|
/*
|
|
** Allocation of data request buffers. Allocate enough buffers for
|
|
** outstanding buffers as well as the buffers queued for delivery.
|
|
*/
|
|
Data_Request_Size = data_request_queue_size;
|
|
Data_Request_Total_Size = Data_Request_Size + Maximum_Outstanding_Packets;
|
|
Data_Request = (PMemory *)
|
|
LocalAlloc (LMEM_FIXED, (sizeof (PMemory) * Data_Request_Total_Size));
|
|
if (Data_Request == NULL)
|
|
*initialized = FALSE;
|
|
|
|
/*
|
|
** Allocate one buffer for Supervisory data
|
|
*/
|
|
T200_Active = FALSE;
|
|
T203_Active = FALSE;
|
|
|
|
/*
|
|
** These veriables need to be set to 0 before we call Reset(). Reset()
|
|
** will attempt to free any memory block that are in the Data_Request
|
|
** list. Since we are just initializing and there aren't any memory
|
|
** blocks in the array, there aren't any to release.
|
|
*/
|
|
Data_Request_Head = 0;
|
|
Data_Request_Tail = 0;
|
|
Data_Request_Count = 0;
|
|
Data_Request_Acknowledge_Tail = 0;
|
|
|
|
Reset ();
|
|
|
|
T203_Timeout = (call_control_type == PLUGXPRT_PSTN_CALL_CONTROL_MANUAL) ?
|
|
DEFAULT_T203_COMM_TIMEOUT : DEFAULT_T203_TIMEOUT;
|
|
Startup_Maximum_T200_Timeouts = DEFAULT_MAXIMUM_T200_TIMEOUTS;
|
|
|
|
if (NULL != pParams)
|
|
{
|
|
if (PSTN_PARAM__MAX_T200_TIMEOUT_COUNT_IN_Q922 & pParams->dwFlags)
|
|
{
|
|
if (Startup_Maximum_T200_Timeouts <= pParams->cMaximumT200TimeoutsInQ922)
|
|
{
|
|
Startup_Maximum_T200_Timeouts = pParams->cMaximumT200TimeoutsInQ922;
|
|
}
|
|
}
|
|
if (PSTN_PARAM__T203_TIMEOUT_IN_Q922 & pParams->dwFlags)
|
|
{
|
|
if (T203_Timeout <= pParams->nT203TimeoutInQ922)
|
|
{
|
|
T203_Timeout = pParams->nT203TimeoutInQ922;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
DWORD dwSiz = 4;
|
|
DWORD valType = 0;
|
|
HKEY hkey;
|
|
// If we are using null modem.
|
|
if(call_control_type == PLUGXPRT_PSTN_CALL_CONTROL_MANUAL)
|
|
{
|
|
//
|
|
// Open the registry key that contains the configuration info for number of timeouts
|
|
//
|
|
if (RegOpenKey( HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Conferencing\\Transports\\DIRCB\0", &hkey) == ERROR_SUCCESS)
|
|
{
|
|
if (RegQueryValueEx(hkey, "nTimeouts\0", 0, &valType,
|
|
(LPBYTE)&Startup_Maximum_T200_Timeouts, &dwSiz) != ERROR_SUCCESS || Startup_Maximum_T200_Timeouts < DEFAULT_MAXIMUM_T200_TIMEOUTS)
|
|
{
|
|
Startup_Maximum_T200_Timeouts = DEFAULT_MAXIMUM_T200_TIMEOUTS;
|
|
}
|
|
RegCloseKey(hkey);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
Link_Maximum_T200_Timeouts = Startup_Maximum_T200_Timeouts;
|
|
|
|
Maximum_T200_Timeouts = Startup_Maximum_T200_Timeouts;
|
|
|
|
/*
|
|
** If I am the link originator, enter the AWAITING_ESTABLISHMENT mode and
|
|
** send out the SABME packet.
|
|
*/
|
|
if (Link_Originator)
|
|
{
|
|
SABME_Pending = TRUE;
|
|
Unnumbered_PF_State = UNNUMBERED_PF_SET;
|
|
Data_Link_Mode = AWAITING_ESTABLISHMENT;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
** If we are not the link originator, enter the TEI_ASSIGNED mode and
|
|
** start the T203 timer, if we don't receive a packet in X seconds,
|
|
** abort the operation
|
|
*/
|
|
Data_Link_Mode = TEI_ASSIGNED;
|
|
SABME_Pending = FALSE;
|
|
StartTimerT203 ();
|
|
}
|
|
|
|
if (*initialized == FALSE)
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: Init failed", DLCI));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
* CLayerQ922::~CLayerQ922 (void)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This is the CLayerQ922 destructor. This routine cleans up the mess.
|
|
*/
|
|
CLayerQ922::~CLayerQ922(void)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::~CLayerQ922"));
|
|
|
|
BOOL queue_full;
|
|
PMemory memory;
|
|
|
|
TRACE_OUT(("Q922: Destructor: DLCI = %d Receive_Sequence_Exception = %d",
|
|
DLCI, Receive_Sequence_Exception));
|
|
TRACE_OUT(("Q922: Destructor: DLCI = %d Receive_Sequence_Recovery = %d",
|
|
DLCI, Receive_Sequence_Recovery));
|
|
|
|
m_pMultiplexer->RemoveHigherLayer (DLCI);
|
|
|
|
StopTimerT200 ();
|
|
StopTimerT203 ();
|
|
|
|
if (Data_Indication != NULL)
|
|
LocalFree ((HLOCAL) Data_Indication);
|
|
if (Data_Indication_Buffer != NULL)
|
|
LocalFree ((HLOCAL) Data_Indication_Buffer);
|
|
if (Data_Request != NULL)
|
|
{
|
|
/*
|
|
** Data_Request_Head is the head of the list,
|
|
** Data_Request_Acknowledge_Tail is the absolute tail of the list.
|
|
** If the list is full, Data_Request_Head equals
|
|
** Data_Request_Acknowledge_Tail. Therefore, we have to check
|
|
** Data_Request_Count to see if it is full or empty.
|
|
*/
|
|
if ((Data_Request_Head == Data_Request_Acknowledge_Tail) &&
|
|
(Data_Request_Count != 0))
|
|
{
|
|
queue_full = TRUE;
|
|
}
|
|
else
|
|
queue_full = FALSE;
|
|
|
|
/*
|
|
** We have to unlock any memory blocks that are in use
|
|
*/
|
|
while ((Data_Request_Head != Data_Request_Acknowledge_Tail) || queue_full)
|
|
{
|
|
memory = *(Data_Request + Data_Request_Acknowledge_Tail);
|
|
|
|
Data_Request_Memory_Manager -> UnlockMemory (memory);
|
|
|
|
if (++Data_Request_Acknowledge_Tail == Data_Request_Total_Size)
|
|
{
|
|
Data_Request_Acknowledge_Tail = 0;
|
|
}
|
|
|
|
if (queue_full)
|
|
{
|
|
queue_full = FALSE;
|
|
}
|
|
}
|
|
LocalFree ((HLOCAL) Data_Request);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
* CLayerQ922::Reset (void)
|
|
*
|
|
* Functional Description:
|
|
* This function resets the link state variables.
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::Reset (void)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::Reset"));
|
|
|
|
BOOL queue_full;
|
|
PMemory memory;
|
|
|
|
Data_Indication_Head = 0;
|
|
Data_Indication_Tail = 0;
|
|
Data_Indication_Count = 0;
|
|
|
|
/*
|
|
** Data_Request_Head is the head of the list,
|
|
** Data_Request_Acknowledge_Tail is the absolute tail of the list.
|
|
** If the list is full, Data_Request_Head equals
|
|
** Data_Request_Acknowledge_Tail. Therefore, we have to check
|
|
** Data_Request_Count to see if it is full or empty.
|
|
*/
|
|
if ((Data_Request_Head == Data_Request_Acknowledge_Tail) &&
|
|
(Data_Request_Count != 0))
|
|
{
|
|
queue_full = TRUE;
|
|
}
|
|
else
|
|
queue_full = FALSE;
|
|
|
|
/*
|
|
** We have to unlock any memory blocks that are in use
|
|
*/
|
|
while ((Data_Request_Head != Data_Request_Acknowledge_Tail) || queue_full)
|
|
{
|
|
memory = *(Data_Request + Data_Request_Acknowledge_Tail);
|
|
|
|
Data_Request_Memory_Manager -> UnlockMemory (memory);
|
|
|
|
if (++Data_Request_Acknowledge_Tail == Data_Request_Total_Size)
|
|
Data_Request_Acknowledge_Tail = 0;
|
|
|
|
if (queue_full)
|
|
{
|
|
queue_full = FALSE;
|
|
}
|
|
}
|
|
|
|
Data_Request_Head = 0;
|
|
Data_Request_Tail = 0;
|
|
Data_Request_Count = 0;
|
|
Data_Request_Acknowledge_Tail = 0;
|
|
|
|
Outstanding_Packets = 0;
|
|
Outstanding_Bytes = 0;
|
|
Total_Retransmitted = 0;
|
|
|
|
Send_State_Variable = 0;
|
|
Receive_State_Variable = 0;
|
|
Acknowledge_State_Variable = 0;
|
|
|
|
Own_Receiver_Busy = FALSE;
|
|
Peer_Receiver_Busy = FALSE;
|
|
|
|
Command_Pending = FALSE;
|
|
Poll_Pending = FALSE;
|
|
Final_Pending = FALSE;
|
|
Acknowledge_Pending = FALSE;
|
|
Reject_Pending = FALSE;
|
|
Reject_Outstanding = FALSE;
|
|
|
|
SABME_Pending = FALSE;
|
|
Frame_Reject_Pending = FALSE;
|
|
Unnumbered_Acknowledge_Pending = FALSE;
|
|
DISC_Pending = FALSE;
|
|
Final_Packet = FALSE;
|
|
Disconnected_Mode_Pending = FALSE;
|
|
|
|
|
|
N200_Count = 0;
|
|
Link_Stable = TRUE;
|
|
|
|
Receive_Sequence_Exception = 0;
|
|
Receive_Sequence_Recovery = 0;
|
|
|
|
StopTimerT200 ();
|
|
StopTimerT203 ();
|
|
}
|
|
|
|
|
|
/*
|
|
* DataLinkError CLayerQ922::ReleaseRequest (void)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function sets the necessary flags to terminate the link
|
|
*/
|
|
DataLinkError CLayerQ922::ReleaseRequest (void)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ReleaseRequest"));
|
|
|
|
if ((Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED) ||
|
|
(Data_Link_Mode == TIMER_RECOVERY))
|
|
{
|
|
/*
|
|
** Queue up the DISC_Pending flag to send out a DISC packet
|
|
*/
|
|
DISC_Pending = TRUE;
|
|
Unnumbered_PF_State = UNNUMBERED_PF_SET;
|
|
Data_Link_Mode = AWAITING_RELEASE;
|
|
|
|
StopTimerT200 ();
|
|
StopTimerT203 ();
|
|
}
|
|
else
|
|
{
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_CONFIRM,
|
|
(void *) DLCI, (void *) DATALINK_NORMAL_DISCONNECT);
|
|
}
|
|
|
|
return (DATALINK_NO_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
* DataLinkError CLayerQ922::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 to
|
|
* pass to us.
|
|
*/
|
|
ProtocolLayerError CLayerQ922::DataIndication (
|
|
LPBYTE packet_address,
|
|
ULONG packet_length,
|
|
PULong bytes_accepted)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::DataIndication"));
|
|
|
|
BOOL packet_processed = TRUE;
|
|
|
|
/*
|
|
** The packet MUST be at least UNNUMBERED_HEADER_SIZE or it is
|
|
** invalid
|
|
*/
|
|
if (packet_length < UNNUMBERED_HEADER_SIZE)
|
|
{
|
|
*bytes_accepted = packet_length;
|
|
return (PROTOCOL_LAYER_NO_ERROR);
|
|
}
|
|
|
|
if (*(packet_address + CONTROL_BYTE_HIGH) & SUPERVISORY_FRAME_BIT)
|
|
{
|
|
if (*(packet_address + CONTROL_BYTE_HIGH) & UNNUMBERED_FRAME_BIT)
|
|
{
|
|
/*
|
|
** This packet is an unnumbered packet
|
|
*/
|
|
switch (*(packet_address + CONTROL_BYTE_HIGH) &
|
|
UNNUMBERED_COMMAND_MASK)
|
|
{
|
|
case SABME:
|
|
ProcessSABME (
|
|
packet_address,
|
|
(USHORT) packet_length);
|
|
break;
|
|
|
|
case UNNUMBERED_ACKNOWLEDGE:
|
|
ProcessUnnumberedAcknowledge (
|
|
packet_address,
|
|
(USHORT) packet_length);
|
|
break;
|
|
|
|
case FRAME_REJECT:
|
|
ProcessFrameReject (
|
|
packet_address,
|
|
(USHORT) packet_length);
|
|
break;
|
|
|
|
case DISCONNECTED_MODE:
|
|
ProcessDisconnectMode (
|
|
packet_address,
|
|
(USHORT) packet_length);
|
|
break;
|
|
|
|
case DISC:
|
|
ProcessDISC (
|
|
packet_address,
|
|
(USHORT) packet_length);
|
|
break;
|
|
|
|
default:
|
|
ERROR_OUT(("Q922: DLCI %d: DataIndication: Illegal Packet: = %d",
|
|
DLCI, (*(packet_address + CONTROL_BYTE_HIGH) & UNNUMBERED_COMMAND_MASK)));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
** It is only legal to process supervisory frames if we
|
|
** are in the MULTIPLE_FRAME_ESTABLISHED or TIMER_RECOVERY
|
|
** modes
|
|
*/
|
|
if ((Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED) ||
|
|
(Data_Link_Mode == TIMER_RECOVERY))
|
|
{
|
|
switch (*(packet_address + CONTROL_BYTE_HIGH) &
|
|
SUPERVISORY_COMMAND_MASK)
|
|
{
|
|
case RECEIVER_READY:
|
|
ProcessReceiverReady (
|
|
packet_address,
|
|
(USHORT) packet_length);
|
|
break;
|
|
|
|
case RECEIVER_NOT_READY:
|
|
ProcessReceiverNotReady (
|
|
packet_address,
|
|
(USHORT) packet_length);
|
|
break;
|
|
|
|
case REJECT:
|
|
ProcessReject (
|
|
packet_address,
|
|
(USHORT) packet_length);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: Supervisory packet received in illegal DataLink Mode", DLCI));
|
|
#ifdef _MCATIPX
|
|
if (Data_Link_Mode != AWAITING_RELEASE)
|
|
{
|
|
/*
|
|
** This is necessary on an IPX network to notify the remote
|
|
** site that this unit is no longer in the conference. If
|
|
** the previous conference ended without going through the
|
|
** proper disconnect sequence, the remote site may continue
|
|
** to send frames to this site. In which case, we need to
|
|
** notify the remote site that the conference is no longer
|
|
** active. We are doing this by sending out a DISC frame.
|
|
** The Q.921 specification does not address this situation.
|
|
*/
|
|
DISC_Pending = TRUE;
|
|
Unnumbered_PF_State = UNNUMBERED_PF_RESET;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
** It is only legal to process Information frames if we
|
|
** are in the MULTIPLE_FRAME_ESTABLISHED or TIMER_RECOVERY
|
|
** modes
|
|
*/
|
|
if ((Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED) ||
|
|
(Data_Link_Mode == TIMER_RECOVERY))
|
|
{
|
|
packet_processed = ProcessInformationFrame (
|
|
packet_address,
|
|
(USHORT) packet_length);
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: Information packet received in illegal DataLink Mode", DLCI));
|
|
#ifdef _MCATIPX
|
|
if (Data_Link_Mode != AWAITING_RELEASE)
|
|
{
|
|
/*
|
|
** This is necessary on an IPX network to notify the remote
|
|
** site that this unit is no longer in the conference. If
|
|
** the previous conference ended without going through the
|
|
** proper disconnect sequence, the remote site may continue
|
|
** to send frames to this site. In which case, we need to
|
|
** notify the remote site that the conference is no longer
|
|
** active. We are doing this by sending out a DISC frame.
|
|
** The Q.921 specification does not address this situation.
|
|
*/
|
|
DISC_Pending = TRUE;
|
|
Unnumbered_PF_State = UNNUMBERED_PF_RESET;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
** After we receive a packet we should start the T203 timer
|
|
** unless the T200 timer was started during the processing of
|
|
** the packet
|
|
*/
|
|
if (((Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED) ||
|
|
(Data_Link_Mode == TIMER_RECOVERY)) &&
|
|
(T200_Active == FALSE) &&
|
|
(DLCI == 0))
|
|
{
|
|
StartTimerT203 ();
|
|
}
|
|
|
|
if (packet_processed)
|
|
{
|
|
if ((Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED) ||
|
|
(Data_Link_Mode == TIMER_RECOVERY))
|
|
{
|
|
N200_Count = 0;
|
|
}
|
|
*bytes_accepted = packet_length;
|
|
}
|
|
else
|
|
*bytes_accepted = 0;
|
|
|
|
return (PROTOCOL_LAYER_NO_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
* ProtocolLayerError CLayerQ922::PollTransmitter (
|
|
* ULONG,
|
|
* USHORT data_to_transmit,
|
|
* USHORT * pending_data,
|
|
* USHORT * holding_data);
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function is called to give us a chance to transmit packets.
|
|
* The data_to_transmit mask tells us which data to transmit, either
|
|
* control or user data.
|
|
*/
|
|
ProtocolLayerError CLayerQ922::PollTransmitter (
|
|
ULONG_PTR,
|
|
USHORT data_to_transmit,
|
|
USHORT * pending_data,
|
|
USHORT * holding_data)
|
|
{
|
|
// TRACE_OUT(("CLayerQ922::PollTransmitter"));
|
|
|
|
*pending_data = 0;
|
|
|
|
/*
|
|
** If we are permitted to transmit data, call ProcessWriteQueue ()
|
|
*/
|
|
if ((data_to_transmit & PROTOCOL_CONTROL_DATA) ||
|
|
(data_to_transmit & PROTOCOL_USER_DATA))
|
|
{
|
|
ProcessWriteQueue (data_to_transmit);
|
|
}
|
|
|
|
/*
|
|
** We have to set the pending data variable to reflect which data
|
|
** we still need to send out
|
|
*/
|
|
if (Data_Request_Count != 0)
|
|
*pending_data |= PROTOCOL_USER_DATA;
|
|
|
|
if (Poll_Pending || Final_Pending || Command_Pending ||
|
|
(Reject_Pending && (Own_Receiver_Busy == FALSE)) ||
|
|
Acknowledge_Pending || SABME_Pending ||
|
|
Unnumbered_Acknowledge_Pending || Frame_Reject_Pending ||
|
|
DISC_Pending)
|
|
{
|
|
*pending_data |= PROTOCOL_CONTROL_DATA;
|
|
}
|
|
|
|
*holding_data = Outstanding_Packets;
|
|
|
|
return (PROTOCOL_LAYER_NO_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
* DataLinkError CLayerQ922::DataRequest (
|
|
* ULONG,
|
|
* PMemory memory,
|
|
* PULong bytes_accepted)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function is called by the higher layer to send a packet to the
|
|
* remote site.
|
|
*/
|
|
ProtocolLayerError CLayerQ922::DataRequest (
|
|
ULONG_PTR,
|
|
PMemory memory,
|
|
PULong bytes_accepted)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::DataRequest"));
|
|
|
|
PMemory * data_request;
|
|
USHORT trash_word;
|
|
ULONG packet_length;
|
|
ULONG information_size;
|
|
|
|
*bytes_accepted = 0;
|
|
|
|
packet_length = memory -> GetLength ();
|
|
|
|
/*
|
|
** Determine the actual information length
|
|
*/
|
|
information_size =
|
|
packet_length - Lower_Layer_Prepend -
|
|
Lower_Layer_Append - DATALINK_PACKET_OVERHEAD;
|
|
|
|
/*
|
|
** See if the information content is too big.
|
|
*/
|
|
if (information_size > Maximum_Information_Size)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: DataRequest: Requested packet = %d, max = %d",
|
|
DLCI, information_size, Maximum_Information_Size));
|
|
return (PROTOCOL_LAYER_PACKET_TOO_BIG);
|
|
}
|
|
|
|
if (Data_Request_Count < Data_Request_Size)
|
|
{
|
|
/*
|
|
** Set write_queue to the correct location
|
|
*/
|
|
data_request = Data_Request + Data_Request_Head;
|
|
*data_request = memory;
|
|
|
|
/*
|
|
** Lock the memory object so that it won't be released
|
|
*/
|
|
Data_Request_Memory_Manager -> LockMemory (memory);
|
|
if (++Data_Request_Head == Data_Request_Total_Size)
|
|
Data_Request_Head = 0;
|
|
Data_Request_Count++;
|
|
|
|
*bytes_accepted = packet_length;
|
|
|
|
/*
|
|
** If the higher layer got permission to send data to me, I will
|
|
** attempt to send it on out
|
|
*/
|
|
PollTransmitter (
|
|
0,
|
|
PROTOCOL_USER_DATA | PROTOCOL_CONTROL_DATA,
|
|
&trash_word,
|
|
&trash_word);
|
|
}
|
|
|
|
return (PROTOCOL_LAYER_NO_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
* DataLinkError CLayerQ922::DataRequest (
|
|
* ULONG,
|
|
* PMemory memory,
|
|
* PULong bytes_accepted)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function is called by the higher layer to send a packet to the
|
|
* remote site. This type of data passing is NOT supported by this
|
|
* layer.
|
|
*/
|
|
ProtocolLayerError CLayerQ922::DataRequest (
|
|
ULONG_PTR,
|
|
LPBYTE,
|
|
ULONG,
|
|
PULong bytes_accepted)
|
|
{
|
|
*bytes_accepted = 0;
|
|
return (PROTOCOL_LAYER_ERROR);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* ProtocolLayerError CLayerQ922::PollReceiver (
|
|
* ULONG)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description
|
|
* This function is called to give us a chance to send packets to the
|
|
* higher layer
|
|
*/
|
|
ProtocolLayerError CLayerQ922::PollReceiver(void)
|
|
{
|
|
ULONG bytes_accepted;
|
|
PDataQueue data_indication;
|
|
|
|
/*
|
|
** If I have any packet in my receive buffers that
|
|
** need to go to higher layers, send them now
|
|
*/
|
|
while (Data_Indication_Count != 0)
|
|
{
|
|
data_indication = Data_Indication + Data_Indication_Tail;
|
|
if (Higher_Layer == NULL)
|
|
break;
|
|
Higher_Layer -> DataIndication (
|
|
data_indication -> buffer_address,
|
|
data_indication -> length,
|
|
&bytes_accepted);
|
|
|
|
if (bytes_accepted == (data_indication -> length))
|
|
{
|
|
if (++Data_Indication_Tail == Data_Indication_Size)
|
|
Data_Indication_Tail = 0;
|
|
Data_Indication_Count--;
|
|
|
|
/*
|
|
** If we had been in a Receiver Busy mode, exit it
|
|
*/
|
|
if (Own_Receiver_Busy)
|
|
{
|
|
Own_Receiver_Busy = FALSE;
|
|
Command_Pending = TRUE;
|
|
}
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
|
|
return (PROTOCOL_LAYER_NO_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ProcessWriteQueue (
|
|
* USHORT data_to_transmit)
|
|
*
|
|
* Functional Description
|
|
* This function determines which type of data needs to be sent out, and
|
|
* sends it.
|
|
*
|
|
* Formal Parameters
|
|
* data_to_transmit (i) - Mask telling us which data is allowed to be
|
|
* transmitted
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ProcessWriteQueue (
|
|
USHORT data_to_transmit)
|
|
{
|
|
// TRACE_OUT(("CLayerQ922::ProcessWriteQueue"));
|
|
|
|
BOOL continue_loop = TRUE;
|
|
|
|
while (continue_loop)
|
|
{
|
|
switch (Data_Link_Mode)
|
|
{
|
|
case AWAITING_RELEASE:
|
|
case TEI_ASSIGNED:
|
|
case AWAITING_ESTABLISHMENT:
|
|
if (SABME_Pending || DISC_Pending || Unnumbered_Acknowledge_Pending ||
|
|
Disconnected_Mode_Pending || Frame_Reject_Pending)
|
|
{
|
|
continue_loop = TransmitUnnumberedFrame ();
|
|
}
|
|
else
|
|
{
|
|
continue_loop = FALSE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (Poll_Pending)
|
|
{
|
|
continue_loop = TransmitSupervisoryFrame (COMMAND_FRAME, PF_SET);
|
|
}
|
|
else if (Final_Pending)
|
|
{
|
|
continue_loop = TransmitSupervisoryFrame (RESPONSE_FRAME, PF_SET);
|
|
}
|
|
else if (Command_Pending)
|
|
{
|
|
continue_loop = TransmitSupervisoryFrame (COMMAND_FRAME, PF_RESET);
|
|
}
|
|
else if (Reject_Pending && (Own_Receiver_Busy == FALSE))
|
|
{
|
|
continue_loop = TransmitSupervisoryFrame (RESPONSE_FRAME, PF_RESET);
|
|
}
|
|
else if (Unnumbered_Acknowledge_Pending || Frame_Reject_Pending)
|
|
{
|
|
continue_loop = TransmitUnnumberedFrame ();
|
|
}
|
|
else if ((data_to_transmit & PROTOCOL_USER_DATA) &&
|
|
(Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED) &&
|
|
(Data_Request_Count != 0) &&
|
|
(Outstanding_Packets < Maximum_Outstanding_Packets) &&
|
|
(Outstanding_Bytes < Maximum_Outstanding_Bytes) &&
|
|
(Peer_Receiver_Busy == FALSE))
|
|
{
|
|
continue_loop = TransmitInformationFrame ();
|
|
}
|
|
else if (Acknowledge_Pending)
|
|
{
|
|
continue_loop = TransmitSupervisoryFrame (RESPONSE_FRAME, PF_RESET);
|
|
}
|
|
else
|
|
{
|
|
continue_loop = FALSE;
|
|
}
|
|
|
|
if (continue_loop)
|
|
{
|
|
if ((T200_Active == FALSE) && (DLCI == 0))
|
|
StartTimerT203 ();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* BOOL CLayerQ922::TransmitUnnumberedFrame ()
|
|
*
|
|
* Functional Description
|
|
* This function builds an unnumbered packet and attempts to send it out.
|
|
* The only packets that can be sent by this function are SABME, DISC, and
|
|
* an Unnumbered Acknowledge.
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* TRUE - If a packet was transmitted
|
|
* FALSE - If a packet was not transmitted
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
BOOL CLayerQ922::TransmitUnnumberedFrame ()
|
|
{
|
|
TRACE_OUT(("CLayerQ922::TransmitUnnumberedFrame"));
|
|
|
|
LPBYTE packet_address;
|
|
UChar command;
|
|
ULONG bytes_written;
|
|
PMemory memory;
|
|
USHORT total_length;
|
|
UChar frame_type;
|
|
|
|
/*
|
|
** Use the Supervisory Buffer to transmit the packet
|
|
*/
|
|
total_length = UNNUMBERED_HEADER_SIZE + Lower_Layer_Prepend +
|
|
Lower_Layer_Append;
|
|
|
|
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
|
NULL,
|
|
total_length);
|
|
|
|
if (memory == NULL)
|
|
return (FALSE);
|
|
packet_address = memory -> GetPointer ();
|
|
packet_address += Lower_Layer_Prepend;
|
|
|
|
if (SABME_Pending)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedFrame: Transmitting SABME", DLCI));
|
|
command = SABME;
|
|
frame_type = COMMAND_FRAME;
|
|
}
|
|
else if (DISC_Pending)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedFrame: Transmitting DISC", DLCI));
|
|
command = DISC;
|
|
frame_type = COMMAND_FRAME;
|
|
}
|
|
else if (Unnumbered_Acknowledge_Pending)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedFrame: Transmitting UNNUMBERED_ACKNOWLEDGE", DLCI));
|
|
command = UNNUMBERED_ACKNOWLEDGE;
|
|
frame_type = RESPONSE_FRAME;
|
|
}
|
|
else if (Disconnected_Mode_Pending)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedFrame: Transmitting DISCONNECTED_MODE", DLCI));
|
|
command = DISCONNECTED_MODE;
|
|
frame_type = RESPONSE_FRAME;
|
|
}
|
|
else if (Frame_Reject_Pending)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedFrame: Transmitting FRAME_REJECT", DLCI));
|
|
command = FRAME_REJECT;
|
|
frame_type = RESPONSE_FRAME;
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: TransmitUnnumberedFrame: Illegally called function", DLCI));
|
|
}
|
|
|
|
/*
|
|
** Assemble the packet for transmission
|
|
*/
|
|
*(packet_address + ADDRESS_BYTE_HIGH) =
|
|
(ADDRESS_HIGH(DLCI)) | frame_type | ADDRESS_MSB;
|
|
*(packet_address + ADDRESS_BYTE_LOW) = (ADDRESS_LOW(DLCI)) | ADDRESS_LSB;
|
|
*(packet_address + CONTROL_BYTE_HIGH) =
|
|
command | Unnumbered_PF_State | 0x03;
|
|
|
|
/*
|
|
** Attempt to send the packet to the lower layer
|
|
*/
|
|
m_pMultiplexer->DataRequest(DLCI, memory, (PULong) &bytes_written);
|
|
Data_Request_Memory_Manager -> FreeMemory (memory);
|
|
|
|
if (bytes_written == total_length)
|
|
{
|
|
if (SABME_Pending)
|
|
{
|
|
/*
|
|
** Start the T200 timer after the SABME has been sent
|
|
*/
|
|
StartTimerT200 ();
|
|
SABME_Pending = FALSE;
|
|
}
|
|
else if (DISC_Pending)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedPacket DISC sent", DLCI));
|
|
|
|
/*
|
|
** Start the T200 timer after the DISC has been sent
|
|
*/
|
|
DISC_Pending = FALSE;
|
|
StartTimerT200 ();
|
|
Data_Link_Mode = AWAITING_RELEASE;
|
|
}
|
|
else if (Unnumbered_Acknowledge_Pending)
|
|
{
|
|
Unnumbered_Acknowledge_Pending = FALSE;
|
|
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedAck ack sent", DLCI));
|
|
|
|
/*
|
|
** An Unnumbered Ack packet can be sent in response to two packets,
|
|
** the SABME or DISC. If it is in response to a DISC, the
|
|
** Final_Packet flag is set to TRUE. Therefore, we need to notify
|
|
** the owner that the link is terminated.
|
|
*/
|
|
if (Final_Packet)
|
|
{
|
|
Final_Packet = FALSE;
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedAck: Issuing Release Indication", DLCI));
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_INDICATION,
|
|
(void *) DLCI, (void *) DATALINK_NORMAL_DISCONNECT);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
** Callback to the controller to let it know that the link is
|
|
** established
|
|
*/
|
|
if ((Data_Link_Mode == TEI_ASSIGNED) ||
|
|
(Data_Link_Mode == AWAITING_ESTABLISHMENT))
|
|
{
|
|
Data_Link_Mode = MULTIPLE_FRAME_ESTABLISHED;
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_ESTABLISH_INDICATION,
|
|
(void *) DLCI);
|
|
Maximum_T200_Timeouts = Link_Maximum_T200_Timeouts;
|
|
|
|
if (DLCI == 0)
|
|
StartTimerT203 ();
|
|
}
|
|
else if ((Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED) ||
|
|
(Data_Link_Mode == TIMER_RECOVERY))
|
|
{
|
|
if (DLCI == 0)
|
|
StartTimerT203 ();
|
|
}
|
|
}
|
|
}
|
|
else if (Disconnected_Mode_Pending)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedPacket Disconnected Mode sent", DLCI));
|
|
Disconnected_Mode_Pending = FALSE;
|
|
}
|
|
else if (Frame_Reject_Pending)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: TransmitUnnumberedPacket Frame Reject sent", DLCI));
|
|
Frame_Reject_Pending = FALSE;
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_INDICATION,
|
|
(void *) DLCI, (void *) DATALINK_RECEIVE_SEQUENCE_EXCEPTION);
|
|
}
|
|
return (TRUE);
|
|
}
|
|
else
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::TransmitSupervisoryFrame (
|
|
* UChar frame_type,
|
|
* UChar poll_final_bit)
|
|
*
|
|
* Functional Description
|
|
* This function builds a Supervisory frame based on the
|
|
* current state of the protocol and the passed-in parameters.
|
|
*
|
|
* Formal Parameters
|
|
* frame_type - (i) The frame type can be either COMMAND_FRAME
|
|
* or RESPONSE_FRAME
|
|
* poll_final_bit - (i) This flag is set in the packet to signal
|
|
* the remote site to respond to this packet.
|
|
*
|
|
* Return Value
|
|
* TRUE - If a packet was actually transmitted
|
|
* FALSE - If a packet was not transmitted
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
BOOL CLayerQ922::TransmitSupervisoryFrame (
|
|
UChar frame_type,
|
|
UChar poll_final_bit)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::TransmitSupervisoryFrame"));
|
|
|
|
LPBYTE packet_address;
|
|
UChar command;
|
|
ULONG bytes_written;
|
|
USHORT total_length;
|
|
PMemory memory;
|
|
|
|
/*
|
|
** Transmit the packet using the Supervisory buffer
|
|
*/
|
|
total_length = DATALINK_PACKET_OVERHEAD + Lower_Layer_Prepend +
|
|
Lower_Layer_Append;
|
|
|
|
/*
|
|
** Get a memory object from the memory manager
|
|
*/
|
|
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
|
NULL,
|
|
total_length);
|
|
if (memory == NULL)
|
|
return (FALSE);
|
|
packet_address = memory -> GetPointer ();
|
|
packet_address += Lower_Layer_Prepend;
|
|
|
|
if (Own_Receiver_Busy)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::TransmitSupervisoryFrame: RECEIVER_NOT_READY"));
|
|
command = RECEIVER_NOT_READY;
|
|
}
|
|
else if (Reject_Pending)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::TransmitSupervisoryFrame: REJECT"));
|
|
command = REJECT;
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("CLayerQ922::TransmitSupervisoryFrame: RECEIVER_READY"));
|
|
command = RECEIVER_READY;
|
|
}
|
|
|
|
/*
|
|
** Set up the header including the Receive_State_Variable which
|
|
** indicates the next packet we expect to receive.
|
|
*/
|
|
*(packet_address + ADDRESS_BYTE_HIGH) =
|
|
(ADDRESS_HIGH(DLCI)) | frame_type | ADDRESS_MSB;
|
|
*(packet_address + ADDRESS_BYTE_LOW) = (ADDRESS_LOW(DLCI)) | ADDRESS_LSB;
|
|
*(packet_address + CONTROL_BYTE_HIGH) = CONTROL_MSB | command;
|
|
*(packet_address + CONTROL_BYTE_LOW) =
|
|
(Receive_State_Variable << 1) | poll_final_bit;
|
|
|
|
/*
|
|
** Send the packet to the lower layer
|
|
*/
|
|
m_pMultiplexer->DataRequest(DLCI, memory, (PULong) &bytes_written);
|
|
Data_Request_Memory_Manager -> FreeMemory (memory);
|
|
|
|
if (bytes_written == total_length)
|
|
{
|
|
|
|
if (command == REJECT)
|
|
Reject_Pending = FALSE;
|
|
|
|
if (frame_type == COMMAND_FRAME)
|
|
{
|
|
Command_Pending = FALSE;
|
|
|
|
if (poll_final_bit == PF_SET)
|
|
{
|
|
Poll_Pending = FALSE;
|
|
|
|
/*
|
|
** If we are currently in a TIMER_RECOVERY mode, we
|
|
** need to continue to set the T200 timer to make sure
|
|
** that they receive this packet.
|
|
*/
|
|
if (Data_Link_Mode == TIMER_RECOVERY)
|
|
StartTimerT200 ();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (poll_final_bit == PF_SET)
|
|
Final_Pending = FALSE;
|
|
}
|
|
Acknowledge_Pending = FALSE;
|
|
return (TRUE);
|
|
}
|
|
else
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::TransmitInformationFrame (void)
|
|
*
|
|
* Functional Description
|
|
* This function builds an Information frame from its data request buffer.
|
|
* If applicable, it starts the T200 timer.
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* TRUE - If a packet was actually transmitted
|
|
* FALSE - If a packet was not transmitted
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
BOOL CLayerQ922::TransmitInformationFrame (void)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::TransmitInformationFrame"));
|
|
|
|
PMemory * data_request;
|
|
LPBYTE packet_address;
|
|
ULONG total_length;
|
|
PMemory memory;
|
|
ULONG bytes_written;
|
|
|
|
|
|
/*
|
|
** Get the address of the next memory object
|
|
*/
|
|
data_request = Data_Request + Data_Request_Tail;
|
|
memory = *data_request;
|
|
packet_address = memory -> GetPointer ();
|
|
total_length = memory -> GetLength ();
|
|
packet_address += Lower_Layer_Prepend;
|
|
|
|
/*
|
|
** Set up the packet header
|
|
*/
|
|
*(packet_address + ADDRESS_BYTE_HIGH) =
|
|
(ADDRESS_HIGH(DLCI)) | COMMAND_FRAME | ADDRESS_MSB;
|
|
*(packet_address + ADDRESS_BYTE_LOW) = (ADDRESS_LOW(DLCI)) | ADDRESS_LSB;
|
|
*(packet_address + CONTROL_BYTE_HIGH) = (Send_State_Variable << 1);
|
|
*(packet_address + CONTROL_BYTE_LOW) = (Receive_State_Variable << 1);
|
|
|
|
/*
|
|
** Send packet to lower layer
|
|
*/
|
|
m_pMultiplexer->DataRequest(DLCI, memory, (PULong) &bytes_written);
|
|
if (bytes_written == total_length)
|
|
{
|
|
if (++Data_Request_Tail == Data_Request_Total_Size)
|
|
Data_Request_Tail = 0;
|
|
Data_Request_Count--;
|
|
|
|
Outstanding_Packets++;
|
|
Outstanding_Bytes += (USHORT) total_length;
|
|
|
|
/*
|
|
** If this is the packet that the remote site is expecting,
|
|
** start the T200 timeout.
|
|
*/
|
|
if (Send_State_Variable == Acknowledge_State_Variable)
|
|
StartTimerT200 ();
|
|
Send_State_Variable = ((Send_State_Variable + 1) % SEQUENCE_MODULUS);
|
|
|
|
Acknowledge_Pending = FALSE;
|
|
return (TRUE);
|
|
}
|
|
else
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ProcessSABME (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length);
|
|
*
|
|
* Functional Description
|
|
* This function decodes the SABME packet received from the remote
|
|
* site.
|
|
*
|
|
* Formal Parameters
|
|
* packet_address (i) - Address of packet
|
|
* packet_length (i) - Length of packet
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* Puts us in AWAITING_ESTABLISHMENT mode
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ProcessSABME (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ProcessSABME"));
|
|
|
|
BOOL command_frame;
|
|
BOOL poll_final_bit;
|
|
USHORT status;
|
|
|
|
if (packet_length != UNNUMBERED_HEADER_SIZE)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: SABME received: Illegal packet length = %d", DLCI, packet_length));
|
|
return;
|
|
}
|
|
|
|
status = ParseUnnumberedPacketHeader (
|
|
packet_address,
|
|
&command_frame,
|
|
&poll_final_bit);
|
|
|
|
/*
|
|
** The SABME packet can ONLY be a COMMAND, it can not be a RESPONSE
|
|
*/
|
|
if (command_frame == FALSE)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: SABME RESPONSE received: Illegal packet", DLCI));
|
|
return;
|
|
}
|
|
|
|
if (status == DATALINK_NO_ERROR)
|
|
{
|
|
switch (Data_Link_Mode)
|
|
{
|
|
case TEI_ASSIGNED:
|
|
case AWAITING_ESTABLISHMENT:
|
|
/*
|
|
** If we are already in this mode, remain here and respond with
|
|
** an unnumbered ack packet.
|
|
*/
|
|
Reset ();
|
|
Unnumbered_Acknowledge_Pending = TRUE;
|
|
if (poll_final_bit)
|
|
Unnumbered_PF_State = UNNUMBERED_PF_SET;
|
|
else
|
|
Unnumbered_PF_State = UNNUMBERED_PF_RESET;
|
|
break;
|
|
|
|
case MULTIPLE_FRAME_ESTABLISHED:
|
|
case TIMER_RECOVERY:
|
|
if (Send_State_Variable == Acknowledge_State_Variable)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: ProcessSABME: in MULTIPLE_FRAME mode: Able to recover", DLCI));
|
|
Send_State_Variable = 0;
|
|
Receive_State_Variable = 0;
|
|
Acknowledge_State_Variable = 0;
|
|
StopTimerT200 ();
|
|
|
|
Unnumbered_Acknowledge_Pending = TRUE;
|
|
if (poll_final_bit)
|
|
Unnumbered_PF_State = UNNUMBERED_PF_SET;
|
|
else
|
|
Unnumbered_PF_State = UNNUMBERED_PF_RESET;
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: ProcessSABME: Illegal packet mode = %d", DLCI, Data_Link_Mode));
|
|
Data_Link_Mode = TEI_ASSIGNED;
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_INDICATION,
|
|
(void *) DLCI, (void *) DATALINK_ILLEGAL_PACKET_RECEIVED);
|
|
}
|
|
break;
|
|
|
|
case AWAITING_RELEASE:
|
|
Disconnected_Mode_Pending = TRUE;
|
|
if (poll_final_bit)
|
|
Unnumbered_PF_State = UNNUMBERED_PF_SET;
|
|
else
|
|
Unnumbered_PF_State = UNNUMBERED_PF_RESET;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ProcessUnnumberAcknowledge (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length);
|
|
*
|
|
* Functional Description
|
|
* This function decodes an unnumbered acknowledge packet. This packet is
|
|
* received in response to a SABME or DISC packet that we sent out.
|
|
*
|
|
* Formal Parameters
|
|
* packet_address (i) - Address of packet
|
|
* packet_length (i) - Length of packet
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ProcessUnnumberedAcknowledge (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ProcessUnnumberedAcknowledge"));
|
|
|
|
BOOL command_frame;
|
|
BOOL poll_final_bit;
|
|
ULONG_PTR disconnect_reason;
|
|
USHORT status;
|
|
|
|
/*
|
|
** This packet MUST be the correct length or it is an error
|
|
*/
|
|
if (packet_length != UNNUMBERED_HEADER_SIZE)
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: Unnumbered ACK received: Illegal packet length = %d", DLCI, packet_length));
|
|
return;
|
|
}
|
|
|
|
status = ParseUnnumberedPacketHeader (
|
|
packet_address,
|
|
&command_frame,
|
|
&poll_final_bit);
|
|
|
|
/*
|
|
** Unnumbered Ack packet can ONLY be a RESPONSE, it can not be a COMMAND
|
|
*/
|
|
if (command_frame)
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: Unnumbered Ack COMMAND received: Illegal packet", DLCI));
|
|
return;
|
|
}
|
|
|
|
if (status == DATALINK_NO_ERROR)
|
|
{
|
|
switch (Data_Link_Mode)
|
|
{
|
|
case AWAITING_ESTABLISHMENT:
|
|
if (poll_final_bit)
|
|
{
|
|
/*
|
|
** If we are awaiting establishment and we receive a UA
|
|
** to our SABME, enter the MULTIPLE_FRAME_ESTABLISHED mode.
|
|
*/
|
|
Reset ();
|
|
Data_Link_Mode = MULTIPLE_FRAME_ESTABLISHED;
|
|
Maximum_T200_Timeouts = Link_Maximum_T200_Timeouts;
|
|
|
|
StopTimerT200 ();
|
|
if (DLCI == 0)
|
|
StartTimerT203 ();
|
|
|
|
/*
|
|
** Callback to the controller
|
|
*/
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_ESTABLISH_CONFIRM,
|
|
(void *) DLCI);
|
|
}
|
|
break;
|
|
|
|
case AWAITING_RELEASE:
|
|
if (Unnumbered_Acknowledge_Pending == FALSE)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: ProcessUnnumberedAck: Issuing Release Indication", DLCI));
|
|
if (Receive_Sequence_Exception != 0)
|
|
disconnect_reason = DATALINK_RECEIVE_SEQUENCE_EXCEPTION;
|
|
else
|
|
disconnect_reason = DATALINK_NORMAL_DISCONNECT;
|
|
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_CONFIRM,
|
|
(void *) DLCI, (void *) disconnect_reason);
|
|
}
|
|
StopTimerT200 ();
|
|
break;
|
|
|
|
case TEI_ASSIGNED:
|
|
TRACE_OUT(("Q922: DLCI %d: Illegal Unnumbered Ack", DLCI));
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_INDICATION,
|
|
(void *) DLCI, (void *) DATALINK_ILLEGAL_PACKET_RECEIVED);
|
|
break;
|
|
|
|
case MULTIPLE_FRAME_ESTABLISHED:
|
|
case TIMER_RECOVERY:
|
|
WARNING_OUT(("Q922: DLCI %d: ProcessUnnumberedAcknowledge: Illegal packet", DLCI));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ProcessDisconnectMode (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length);
|
|
*
|
|
* Functional Description
|
|
* This function decodes a Disconnect Mode packet.
|
|
*
|
|
* Formal Parameters
|
|
* packet_address (i) - Address of packet
|
|
* packet_length (i) - Length of packet
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ProcessDisconnectMode (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ProcessDisconnectMode"));
|
|
|
|
BOOL command_frame;
|
|
BOOL poll_final_bit;
|
|
USHORT status;
|
|
|
|
if (packet_length != UNNUMBERED_HEADER_SIZE)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: Unnumbered ACK received: Illegal packet length = %d", DLCI, packet_length));
|
|
return;
|
|
}
|
|
|
|
status = ParseUnnumberedPacketHeader (
|
|
packet_address, &command_frame, &poll_final_bit);
|
|
|
|
/*
|
|
** DM packet can ONLY be a RESPONSE, it can not be a COMMAND
|
|
*/
|
|
if (command_frame)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: DM COMMAND received: Illegal packet", DLCI));
|
|
return;
|
|
}
|
|
|
|
if (status == DATALINK_NO_ERROR)
|
|
{
|
|
switch (Data_Link_Mode)
|
|
{
|
|
case AWAITING_ESTABLISHMENT:
|
|
if (poll_final_bit && Link_Originator)
|
|
{
|
|
Reset ();
|
|
Data_Link_Mode = TEI_ASSIGNED;
|
|
|
|
StopTimerT200 ();
|
|
|
|
/*
|
|
** Callback to the controller
|
|
*/
|
|
TRACE_OUT(("Q922: DLCI %d: ProcessDisconnectMode: Releasing connection", DLCI));
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_INDICATION,
|
|
(void *) DLCI, (void *) DATALINK_NORMAL_DISCONNECT);
|
|
}
|
|
break;
|
|
|
|
case AWAITING_RELEASE:
|
|
if (poll_final_bit)
|
|
{
|
|
Reset ();
|
|
Data_Link_Mode = TEI_ASSIGNED;
|
|
|
|
StopTimerT200 ();
|
|
|
|
/*
|
|
** Callback to the controller
|
|
*/
|
|
TRACE_OUT(("Q922: DLCI %d: ProcessDisconnectMode: A_R: Releasing connection", DLCI));
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_CONFIRM,
|
|
(void *) DLCI, (void *) DATALINK_NORMAL_DISCONNECT);
|
|
}
|
|
break;
|
|
|
|
case TEI_ASSIGNED:
|
|
break;
|
|
|
|
case MULTIPLE_FRAME_ESTABLISHED:
|
|
case TIMER_RECOVERY:
|
|
TRACE_OUT(("Q922: DLCI %d: ProcessDM: Illegal packet", DLCI));
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_INDICATION,
|
|
(void *) DLCI, (void *) DATALINK_ILLEGAL_PACKET_RECEIVED);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ProcessDISC (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length);
|
|
*
|
|
* Functional Description
|
|
* This function decodes a DISC packet. We respond to this packet with
|
|
* an Unnumbered Ack packet.
|
|
*
|
|
* Formal Parameters
|
|
* packet_address (i) - Address of packet
|
|
* packet_length (i) - Length of packet
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ProcessDISC (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ProcessDISC"));
|
|
|
|
BOOL command_frame;
|
|
BOOL poll_final_bit;
|
|
USHORT status;
|
|
|
|
/*
|
|
** This packet MUST be the correct length or it is an error
|
|
*/
|
|
if (packet_length != UNNUMBERED_HEADER_SIZE)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: DISC received: Illegal packet length = %d", DLCI, packet_length));
|
|
return;
|
|
}
|
|
|
|
TRACE_OUT(("Q922: DLCI %d: DISCONNECT received", DLCI));
|
|
status = ParseUnnumberedPacketHeader (
|
|
packet_address, &command_frame, &poll_final_bit);
|
|
|
|
/*
|
|
** The DISC packet can ONLY be a COMMAND, it can not be a RESPONSE
|
|
*/
|
|
if (command_frame == FALSE)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: DISC RESPONSE received: Illegal packet", DLCI));
|
|
return;
|
|
}
|
|
|
|
if (status == DATALINK_NO_ERROR)
|
|
{
|
|
switch (Data_Link_Mode)
|
|
{
|
|
case TEI_ASSIGNED:
|
|
case AWAITING_ESTABLISHMENT:
|
|
Disconnected_Mode_Pending = TRUE;
|
|
if (poll_final_bit)
|
|
Unnumbered_PF_State = UNNUMBERED_PF_SET;
|
|
else
|
|
Unnumbered_PF_State = UNNUMBERED_PF_RESET;
|
|
break;
|
|
|
|
case AWAITING_RELEASE:
|
|
Unnumbered_Acknowledge_Pending = TRUE;
|
|
Final_Packet = TRUE;
|
|
Unnumbered_PF_State = UNNUMBERED_PF_RESET;
|
|
break;
|
|
|
|
case MULTIPLE_FRAME_ESTABLISHED:
|
|
case TIMER_RECOVERY:
|
|
Unnumbered_Acknowledge_Pending = TRUE;
|
|
Final_Packet = TRUE;
|
|
Unnumbered_PF_State = UNNUMBERED_PF_RESET;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ProcessFrameReject (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length);
|
|
*
|
|
* Functional Description
|
|
* This function decodes the Frame Reject packet. We currently don't fully
|
|
* support this packet.
|
|
*
|
|
* Formal Parameters
|
|
* packet_address (i) - Address of packet
|
|
* packet_length (i) - Length of packet
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ProcessFrameReject (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ProcessFrameReject"));
|
|
|
|
BOOL command_frame;
|
|
BOOL poll_final_bit;
|
|
USHORT status;
|
|
|
|
/*
|
|
** This packet MUST be the correct length or it is an error
|
|
*/
|
|
if (packet_length < UNNUMBERED_HEADER_SIZE)
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: Frame Reject received: Illegal packet length = %d", DLCI, packet_length));
|
|
return;
|
|
}
|
|
|
|
status = ParseUnnumberedPacketHeader (
|
|
packet_address, &command_frame, &poll_final_bit);
|
|
|
|
/*
|
|
** The FRMR packet can ONLY be a RESPONSE, it can not be a COMMAND
|
|
*/
|
|
if (command_frame)
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: FRMR COMMAND received: Illegal packet", DLCI));
|
|
return;
|
|
}
|
|
|
|
if (status == DATALINK_NO_ERROR)
|
|
{
|
|
switch (Data_Link_Mode)
|
|
{
|
|
case TEI_ASSIGNED:
|
|
case AWAITING_ESTABLISHMENT:
|
|
case AWAITING_RELEASE:
|
|
case MULTIPLE_FRAME_ESTABLISHED:
|
|
case TIMER_RECOVERY:
|
|
ERROR_OUT(("Q922: DLCI %d ProcessFrameReject: Illegal packet", DLCI));
|
|
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_INDICATION,
|
|
(void *) DLCI, (void *) DATALINK_ILLEGAL_PACKET_RECEIVED);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ProcessReceiverReady (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length)
|
|
*
|
|
* Functional Description
|
|
* This function decodes the Receiver Ready packet that is in the
|
|
* input buffer. From the packet, we get the packet sequence
|
|
* number that the remote site is expecting.
|
|
*
|
|
* Formal Parameters
|
|
* packet_address (i) - Address of packet
|
|
* packet_length (i) - Length of packet
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ProcessReceiverReady (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ProcessReceiverReady"));
|
|
|
|
BOOL command_frame;
|
|
UChar receive_sequence_number;
|
|
BOOL poll_final_bit;
|
|
USHORT status;
|
|
|
|
/*
|
|
** This packet MUST be the correct length or it is an error
|
|
*/
|
|
if (packet_length != DATALINK_PACKET_OVERHEAD)
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: Receiver Ready received: Illegal packet length = %d", DLCI, packet_length));
|
|
return;
|
|
}
|
|
|
|
status = ParsePacketHeader (
|
|
packet_address,
|
|
packet_length,
|
|
&command_frame,
|
|
&receive_sequence_number,
|
|
&poll_final_bit);
|
|
|
|
if (status == DATALINK_NO_ERROR)
|
|
{
|
|
if (command_frame && poll_final_bit)
|
|
{
|
|
Final_Pending = TRUE;
|
|
}
|
|
|
|
Peer_Receiver_Busy = FALSE;
|
|
|
|
/*
|
|
** If the remote site is expecting a packet sequence number
|
|
** that is not equal to our Acknowledge_State_Variable,
|
|
** update it
|
|
*/
|
|
if (Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED)
|
|
{
|
|
if (Acknowledge_State_Variable != receive_sequence_number)
|
|
{
|
|
UpdateAcknowledgeState (receive_sequence_number);
|
|
|
|
/*
|
|
** If we have received the last acknowledge,
|
|
** stop the T200 timer
|
|
*/
|
|
if (Acknowledge_State_Variable == Send_State_Variable)
|
|
StopTimerT200 ();
|
|
else
|
|
StartTimerT200 ();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
** If we are in TIMER_RECOVERY mode, update the
|
|
** Acknowledge_State_Variable and resend the packets
|
|
** that need to be sent.
|
|
*/
|
|
UpdateAcknowledgeState (receive_sequence_number);
|
|
|
|
if ((command_frame == FALSE) && poll_final_bit)
|
|
{
|
|
ResetSendState ();
|
|
|
|
StopTimerT200 ();
|
|
|
|
if (Data_Link_Mode != AWAITING_RELEASE)
|
|
Data_Link_Mode = MULTIPLE_FRAME_ESTABLISHED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: ProcessReceiverReady: Error Processing packet", DLCI));
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ProcessReceiverNotReady (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length)
|
|
*
|
|
* Functional Description
|
|
* This function decodes the Receiver Not Ready packet that
|
|
* is in the input buffer. This packet notifies us that the
|
|
* remote site does not have room for Information packets.
|
|
* As a result of this packet, we won't send any more packets
|
|
* until the remote site sends us a Receiver Ready packet.
|
|
*
|
|
* Formal Parameters
|
|
* packet_address (i) - Address of packet
|
|
* packet_length (i) - Length of packet
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ProcessReceiverNotReady (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ProcessReceiverNotReady"));
|
|
|
|
BOOL command_frame;
|
|
UChar receive_sequence_number;
|
|
BOOL poll_final_bit;
|
|
USHORT status;
|
|
|
|
/*
|
|
** This packet MUST be the correct length or it is an error
|
|
*/
|
|
if (packet_length != DATALINK_PACKET_OVERHEAD)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: Receiver Not Ready received: Illegal packet length = %d", DLCI, packet_length));
|
|
return;
|
|
}
|
|
|
|
status = ParsePacketHeader (
|
|
packet_address,
|
|
packet_length,
|
|
&command_frame,
|
|
&receive_sequence_number,
|
|
&poll_final_bit);
|
|
|
|
if (status == DATALINK_NO_ERROR)
|
|
{
|
|
if (command_frame && poll_final_bit)
|
|
{
|
|
Final_Pending = TRUE;
|
|
}
|
|
|
|
/*
|
|
** Set the Peer_Receiver_Busy flag so that we don't send
|
|
** out any information packets.
|
|
*/
|
|
Peer_Receiver_Busy = TRUE;
|
|
|
|
UpdateAcknowledgeState (receive_sequence_number);
|
|
|
|
if (Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED)
|
|
StartTimerT200 ();
|
|
else
|
|
{
|
|
/*
|
|
** If we are in TIMER_RECOVERY state, exit TIMER_RECOVERY
|
|
** state and update the acknowledge state.
|
|
*/
|
|
if ((command_frame == FALSE) && poll_final_bit)
|
|
{
|
|
ResetSendState ();
|
|
|
|
StartTimerT200 ();
|
|
|
|
if (Data_Link_Mode != AWAITING_RELEASE)
|
|
Data_Link_Mode = MULTIPLE_FRAME_ESTABLISHED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: ProcessNotReceiverReady: Error Processing packet", DLCI));
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ProcessReject (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length)
|
|
*
|
|
* Functional Description
|
|
* This function decodes the Receiver Reject packet that
|
|
* is in the input buffer. This packet indicates that the
|
|
* remote site needs us to retransmit some packets. It sends
|
|
* the next packet sequence number that it expects.
|
|
*
|
|
* Formal Parameters
|
|
* packet_address (i) - Address of packet
|
|
* packet_length (i) - Length of packet
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ProcessReject (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ProcessReject"));
|
|
|
|
BOOL command_frame;
|
|
UChar receive_sequence_number;
|
|
BOOL poll_final_bit;
|
|
USHORT status;
|
|
|
|
/*
|
|
** This packet MUST be the correct length or it is an error
|
|
*/
|
|
if (packet_length != DATALINK_PACKET_OVERHEAD)
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: REJECT received: Illegal packet length = %d", DLCI, packet_length));
|
|
return;
|
|
}
|
|
|
|
status = ParsePacketHeader (
|
|
packet_address,
|
|
packet_length,
|
|
&command_frame,
|
|
&receive_sequence_number,
|
|
&poll_final_bit);
|
|
|
|
if (status == DATALINK_NO_ERROR)
|
|
{
|
|
if (command_frame && poll_final_bit)
|
|
{
|
|
Final_Pending = TRUE;
|
|
}
|
|
|
|
Peer_Receiver_Busy = FALSE;
|
|
|
|
/*
|
|
** Update the Acknowledge_State_Variable and prepare to
|
|
** resend the packets that weren't acknowledged.
|
|
*/
|
|
UpdateAcknowledgeState (receive_sequence_number);
|
|
|
|
if (Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED)
|
|
{
|
|
ResetSendState ();
|
|
|
|
StopTimerT200 ();
|
|
}
|
|
else
|
|
{
|
|
if ((command_frame == FALSE) && poll_final_bit)
|
|
{
|
|
ResetSendState ();
|
|
|
|
StopTimerT200 ();
|
|
|
|
if (Data_Link_Mode != AWAITING_RELEASE)
|
|
Data_Link_Mode = MULTIPLE_FRAME_ESTABLISHED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: ProcessReject: Error Processing packet", DLCI));
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* BOOL CLayerQ922::ProcessInformationFrame (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length)
|
|
*
|
|
* Functional Description
|
|
* This function processes the information packet. It checks
|
|
* to see if it has the expected sequence number. If it does,
|
|
* it puts it into the queue which will be read by the user.
|
|
*
|
|
* Formal Parameters
|
|
* packet_address (i) - Address of packet
|
|
* packet_length (i) - Length of packet
|
|
*
|
|
* Return Value
|
|
* TRUE - If the packet was processed
|
|
* FALSE - If the packet was not processed
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
BOOL CLayerQ922::ProcessInformationFrame (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ProcessInformationFrame"));
|
|
|
|
BOOL command_frame;
|
|
UChar receive_sequence_number;
|
|
BOOL poll_final_bit;
|
|
USHORT status;
|
|
PDataQueue read_queue;
|
|
UChar send_sequence_number;
|
|
|
|
BOOL packet_accepted;
|
|
ULONG bytes_accepted;
|
|
|
|
if (packet_length < DATALINK_PACKET_OVERHEAD)
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: ProcessInformationFrame: Invalid packet length = %d",
|
|
DLCI, packet_length-DATALINK_PACKET_OVERHEAD));
|
|
return (FALSE);
|
|
}
|
|
|
|
if (packet_length > (DATALINK_PACKET_OVERHEAD + Maximum_Information_Size))
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: ProcessInformationFrame: Invalid information length = %d",
|
|
DLCI, packet_length - DATALINK_PACKET_OVERHEAD));
|
|
return (FALSE);
|
|
}
|
|
|
|
/*
|
|
** If there isn't a place to put the packet, return FALSE
|
|
*/
|
|
if ((Data_Indication_Count == Data_Indication_Size) ||
|
|
Own_Receiver_Busy || (Higher_Layer == NULL))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
|
|
status = ParsePacketHeader (
|
|
packet_address,
|
|
packet_length,
|
|
&command_frame,
|
|
&receive_sequence_number,
|
|
&poll_final_bit);
|
|
|
|
if (status == DATALINK_NO_ERROR)
|
|
{
|
|
if (poll_final_bit && command_frame)
|
|
{
|
|
Final_Pending = TRUE;
|
|
}
|
|
|
|
if ((Data_Link_Mode == MULTIPLE_FRAME_ESTABLISHED) &&
|
|
(Peer_Receiver_Busy == FALSE))
|
|
{
|
|
/*
|
|
** If the remote site does NOT acknowledge the last packet
|
|
** that we sent out, Update the Acknowledge State variable
|
|
** by calling UpdateAcknowledgeState()
|
|
*/
|
|
if (Acknowledge_State_Variable != receive_sequence_number)
|
|
{
|
|
UpdateAcknowledgeState (receive_sequence_number);
|
|
|
|
/*
|
|
** If the received acknowledge, reflects the last
|
|
** packet transmitted, stop the T200 timer.
|
|
*/
|
|
if (Acknowledge_State_Variable == Send_State_Variable)
|
|
StopTimerT200 ();
|
|
else
|
|
StartTimerT200 ();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
** If this is an I-Frame RESPONSE, exit the TIMER_RECOVERY
|
|
** state
|
|
*/
|
|
UpdateAcknowledgeState (receive_sequence_number);
|
|
|
|
if ((Data_Link_Mode == TIMER_RECOVERY) && (command_frame == FALSE)
|
|
&& poll_final_bit)
|
|
{
|
|
ResetSendState();
|
|
|
|
Data_Link_Mode = MULTIPLE_FRAME_ESTABLISHED;
|
|
StopTimerT200 ();
|
|
}
|
|
}
|
|
|
|
|
|
send_sequence_number = (*(packet_address + CONTROL_BYTE_HIGH) >> 1);
|
|
|
|
/*
|
|
** If this is the packet that we are waiting for,
|
|
** give it to the Transport Layer.
|
|
*/
|
|
if (send_sequence_number == Receive_State_Variable)
|
|
{
|
|
/*
|
|
** Try to send the packet to the higher layer,
|
|
** if it accepts it, we won't have to copy it.
|
|
*/
|
|
packet_accepted = FALSE;
|
|
if (Data_Indication_Count == 0)
|
|
{
|
|
Higher_Layer -> DataIndication (
|
|
packet_address + DATALINK_PACKET_OVERHEAD,
|
|
packet_length - DATALINK_PACKET_OVERHEAD,
|
|
&bytes_accepted);
|
|
if (bytes_accepted ==
|
|
(ULONG) (packet_length - DATALINK_PACKET_OVERHEAD))
|
|
{
|
|
packet_accepted = TRUE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** If the higher layer did not accept it, copy it into our
|
|
** Data Indication queue.
|
|
*/
|
|
if (packet_accepted == FALSE)
|
|
{
|
|
read_queue = Data_Indication + Data_Indication_Head;
|
|
memcpy ((PVoid) read_queue->buffer_address,
|
|
(PVoid) (packet_address + DATALINK_PACKET_OVERHEAD),
|
|
packet_length - DATALINK_PACKET_OVERHEAD);
|
|
read_queue->length = packet_length-DATALINK_PACKET_OVERHEAD;
|
|
|
|
if (++Data_Indication_Head == Data_Indication_Size)
|
|
Data_Indication_Head = 0;
|
|
if (++Data_Indication_Count == Data_Indication_Size)
|
|
{
|
|
Own_Receiver_Busy = TRUE;
|
|
TRACE_OUT(("Q922: DLCI %d: Own Receiver Busy", DLCI));
|
|
}
|
|
}
|
|
|
|
Receive_State_Variable =
|
|
((Receive_State_Variable + 1) % SEQUENCE_MODULUS);
|
|
|
|
Acknowledge_Pending = TRUE;
|
|
Reject_Outstanding = FALSE;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
** If we were not expecting this packet, send a REJECT
|
|
** packet to the remote site.
|
|
*/
|
|
if (Reject_Outstanding == FALSE)
|
|
{
|
|
Reject_Pending = TRUE;
|
|
Reject_Outstanding = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("Q922: DLCI %d: ProcessInformation: Error Processing packet", DLCI));
|
|
}
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
* DataLinkError CLayerQ922::ParsePacketHeader (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length,
|
|
* BOOL * command_frame,
|
|
* LPBYTE receive_sequence_number,
|
|
* BOOL * poll_final_bit)
|
|
*
|
|
* Functional Description
|
|
* This function decodes the packet header looking for three
|
|
* things:
|
|
*
|
|
* 1. Is the packet a command frame?
|
|
* 2. What is the sequence number in the packet?
|
|
* 3. Does the packet require a respones?
|
|
*
|
|
* Formal Parameters
|
|
* packet_address - (i) Address of the new packet
|
|
* packet_length - (i) Length of the new packet
|
|
* command_frame - (o) Address of variable, it is set to TRUE
|
|
* if it is a COMMAND frame and FALSE if
|
|
* it is a RESPONSE frame
|
|
* receive_sequence_number - (o) Address of variable, it holds the
|
|
* sequence number in the packet
|
|
* poll_final_bit - (o) Address of variable, it is set to TRUE
|
|
* if we need to respond to the packet and
|
|
* FALSE if we don't
|
|
*
|
|
* Return Value
|
|
* DATALINK_RECEIVE_SEQUENCE_VIOLATION -
|
|
* DATALINK_NO_ERROR -
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
DataLinkError CLayerQ922::ParsePacketHeader (
|
|
LPBYTE packet_address,
|
|
#ifdef _DEBUG
|
|
USHORT packet_length,
|
|
#else
|
|
USHORT,
|
|
#endif
|
|
BOOL * command_frame,
|
|
LPBYTE receive_sequence_number,
|
|
BOOL * poll_final_bit)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ParsePacketHeader"));
|
|
|
|
DataLinkError return_value = DATALINK_NO_ERROR;
|
|
UChar receive_sequence;
|
|
UChar send_state_sequence;
|
|
|
|
if (*(packet_address + ADDRESS_BYTE_HIGH) & COMMAND_BIT)
|
|
*command_frame = FALSE;
|
|
else
|
|
*command_frame = TRUE;
|
|
|
|
*receive_sequence_number = (*(packet_address + CONTROL_BYTE_LOW) >> 1);
|
|
|
|
if (*(packet_address + CONTROL_BYTE_LOW) & POLL_FINAL_BIT)
|
|
*poll_final_bit = TRUE;
|
|
else
|
|
*poll_final_bit = FALSE;
|
|
|
|
if (*receive_sequence_number < Acknowledge_State_Variable)
|
|
receive_sequence = *receive_sequence_number + SEQUENCE_MODULUS;
|
|
else
|
|
receive_sequence = *receive_sequence_number;
|
|
if (Send_State_Variable < Acknowledge_State_Variable)
|
|
send_state_sequence = Send_State_Variable + SEQUENCE_MODULUS;
|
|
else
|
|
send_state_sequence = Send_State_Variable;
|
|
|
|
/*
|
|
** Illegal Condition: The remote site is acknowledging a
|
|
** packet that is not in the range of transmitted packets
|
|
*/
|
|
if (receive_sequence > send_state_sequence)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: ParsePacketHeader: Receive Sequence Exception: length = %d", DLCI, packet_length));
|
|
TRACE_OUT(("Q922: ParsePacketHeader: receive_sequence = %d", receive_sequence));
|
|
TRACE_OUT(("Q922: ParsePacketHeader: send_state_sequence = %d", send_state_sequence));
|
|
TRACE_OUT(("Q922: ParsePacketHeader: Acknowledge_State_Var = %d", Acknowledge_State_Variable));
|
|
TRACE_OUT(("Q922: ParsePacketHeader: Send_State_Variable = %d", Send_State_Variable));
|
|
TRACE_OUT(("Q922: ParsePacketHeader: in-packet receive_sequence = %d", *receive_sequence_number));
|
|
TRACE_OUT(("Q922: ParsePacketHeader: Data_Request_Count = %d", Data_Request_Count));
|
|
|
|
/*
|
|
** The following piece of code checks the receive sequence number
|
|
** against our send state sequence number + the number of packets
|
|
** queued for transmission. We are doing this to recover from one
|
|
** of two things:
|
|
**
|
|
** 1. The T200 timeout value is not long enough.
|
|
** 2. This Q922 object is not able to check its input
|
|
** buffers quickly enough to respond to the remote site's
|
|
** command. If the machine is overloaded with work to
|
|
** process, this error can occur.
|
|
**
|
|
** We are checking to see if we are receiving an acknowledge
|
|
** for a packet that we have already transmitted once. When we
|
|
** are in this out-of-sync state, it is possible to transmit an
|
|
** information packet, timeout, and receive a supervisory packet
|
|
** that does not acknowledge the last packet. As a consequence,
|
|
** we reset our Send_State_Variable, so that we have no knowledge
|
|
** of transmitting the information packet. We then may receive
|
|
** an acknowledge for the information packet, but we don't realize
|
|
** that we ever transmitted it. This results in a Receive Sequence
|
|
** Exception.
|
|
**
|
|
** To guard against this, we are checking to see if this acknowledge
|
|
** COULD be valid. If it could be valid, we are processing it
|
|
** normally except for the receive sequence value. We are setting
|
|
** the receive_sequence_number to that last good acknowledgement and
|
|
** we will eventually re-transmit the packet. We also send up a
|
|
** warning to the node controller.
|
|
**
|
|
** If the acknowledge is not possibly in our range of packets, we
|
|
** treat it as a real Receive Sequence Exception and break the link.
|
|
*/
|
|
if (receive_sequence <= (send_state_sequence + Data_Request_Count))
|
|
{
|
|
*receive_sequence_number = Acknowledge_State_Variable;
|
|
Receive_Sequence_Recovery++;
|
|
|
|
TRACE_OUT(("Q922: ParsePacketHeader: Attempting recovery from this exception"));
|
|
TRACE_OUT(("Q922: ParsePacketHeader: Recovery = %d", Receive_Sequence_Recovery));
|
|
|
|
/*
|
|
** Let the user know that there is a problem
|
|
*/
|
|
m_pT123->OwnerCallback(m_nMsgBase + T123_STATUS_MESSAGE,
|
|
(void *) DLCI, (void *) DATALINK_TIMING_ERROR);
|
|
}
|
|
else
|
|
{
|
|
TRACE_OUT(("Q922: ParsePacketHeader: CAN NOT recover from this exception"));
|
|
Receive_Sequence_Exception++;
|
|
DISC_Pending = TRUE;
|
|
Unnumbered_PF_State = UNNUMBERED_PF_RESET;
|
|
return_value = DATALINK_RECEIVE_SEQUENCE_VIOLATION;
|
|
}
|
|
}
|
|
|
|
return (return_value);
|
|
}
|
|
|
|
|
|
/*
|
|
* DataLinkError CLayerQ922::ParseUnnumberedPacketHeader (
|
|
* BOOL * command_frame,
|
|
* LPBYTE receive_sequence_number,
|
|
* BOOL * poll_final_bit)
|
|
*
|
|
* Functional Description
|
|
* This function decodes the packet header looking for three
|
|
* things:
|
|
*
|
|
* 1. Is the packet a command frame?
|
|
* 2. What is the sequence number in the packet?
|
|
* 3. Does the packet require a respone?
|
|
*
|
|
* Formal Parameters
|
|
* command_frame - (o) Address of variable, it is set to TRUE
|
|
* if it is a COMMAND frame and FALSE if
|
|
* it is a RESPONSE frame
|
|
* receive_sequence_number - (o) Address of variable, it holds the
|
|
* sequence number in the packet
|
|
* poll_final_bit - (o) Address of variable, it is set to TRUE
|
|
* if we need to respond to the packet and
|
|
* FALSE if we don't
|
|
*
|
|
* Return Value
|
|
* DATALINK_RECEIVE_SEQUENCE_VIOLATION -
|
|
* DATALINK_NO_ERROR -
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
DataLinkError CLayerQ922::ParseUnnumberedPacketHeader (
|
|
LPBYTE packet_address,
|
|
BOOL * command_frame,
|
|
BOOL * poll_final_bit)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ParseUnnumberedPacketHeader"));
|
|
|
|
if (*(packet_address + ADDRESS_BYTE_HIGH) & COMMAND_BIT)
|
|
*command_frame = FALSE;
|
|
else
|
|
*command_frame = TRUE;
|
|
|
|
if (*(packet_address + CONTROL_BYTE_HIGH) & UNNUMBERED_PF_SET)
|
|
*poll_final_bit = TRUE;
|
|
else
|
|
*poll_final_bit = FALSE;
|
|
|
|
return (DATALINK_NO_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::UpdateAcknowledgeState (
|
|
* UChar sequence_number)
|
|
*
|
|
* Functional Description
|
|
* This function updates Acknowledge_State_Variable. The parameter
|
|
* passed in is the sequence number of a packet that the remote site has
|
|
* successfully received. By receiving this sequence number, we can
|
|
* remove the packet from our write queue as well as any packet that
|
|
* was transmitted before that packet.
|
|
*
|
|
* Formal Parameters
|
|
* sequence_number - (i) Sequence number of packet successfully
|
|
* received by the remote site.
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::UpdateAcknowledgeState (
|
|
UChar sequence_number)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::UpdateAcknowledgeState"));
|
|
|
|
UChar packets_acknowledged;
|
|
USHORT count;
|
|
PMemory memory;
|
|
ULONG total_length;
|
|
|
|
if (Acknowledge_State_Variable != sequence_number)
|
|
{
|
|
/*
|
|
** Find the number of packets acknowledged by this sequence
|
|
** number. If the remote site receives X packets successfully,
|
|
** the next time the remote site transmits, it will send out an
|
|
** acknowledge for the LAST packet received. All packets
|
|
** received before it are acknowledged by default.
|
|
*/
|
|
if (sequence_number < Acknowledge_State_Variable)
|
|
{
|
|
packets_acknowledged = ((sequence_number + SEQUENCE_MODULUS) -
|
|
Acknowledge_State_Variable);
|
|
}
|
|
else
|
|
{
|
|
packets_acknowledged =
|
|
(sequence_number - Acknowledge_State_Variable);
|
|
}
|
|
|
|
/*
|
|
** Go thru each of the packets acknowledged and Unlock the memory
|
|
** object associated with it. This will free the memory.
|
|
*/
|
|
for (count=0; count < packets_acknowledged; count++)
|
|
{
|
|
memory = *(Data_Request + Data_Request_Acknowledge_Tail);
|
|
total_length = memory -> GetLength ();
|
|
|
|
Outstanding_Packets--;
|
|
Outstanding_Bytes -= (USHORT) total_length;
|
|
|
|
Data_Request_Memory_Manager -> UnlockMemory (memory);
|
|
|
|
if (++Data_Request_Acknowledge_Tail == Data_Request_Total_Size)
|
|
Data_Request_Acknowledge_Tail = 0;
|
|
}
|
|
|
|
Acknowledge_State_Variable = sequence_number;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::ResetSendState (void)
|
|
*
|
|
* Functional Description
|
|
* This function is called when we need to retransmit packets.
|
|
* The Send_State_Variable is reset to equal the
|
|
* Acknowledge_State_Variable.
|
|
*
|
|
* Formal Parameters
|
|
* None.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::ResetSendState (void)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::ResetSendState"));
|
|
|
|
/*
|
|
** Reset the Send_State_Variable so that we resend packets.
|
|
*/
|
|
if (Send_State_Variable != Acknowledge_State_Variable)
|
|
{
|
|
Total_Retransmitted += (DWORD) Outstanding_Packets;
|
|
TRACE_OUT(("Q922: DLCI %d: retransmitting %d packets -- Total = %ld",
|
|
DLCI, Outstanding_Packets, Total_Retransmitted));
|
|
|
|
Data_Request_Tail = Data_Request_Acknowledge_Tail;
|
|
Data_Request_Count += Outstanding_Packets;
|
|
|
|
Outstanding_Packets = 0;
|
|
Outstanding_Bytes = 0;
|
|
|
|
Send_State_Variable = Acknowledge_State_Variable;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::StartTimerT200 (void)
|
|
*
|
|
* Functional Description
|
|
* This function starts the T200 timer. This timer us started when
|
|
* we send a packet and expect a response. If the response is not
|
|
* received within the T200 time span. The timer expires and we
|
|
* enter a TIMER_RECOVERY state.
|
|
*
|
|
* Formal Parameters
|
|
* None.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::StartTimerT200 (void)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::StartTimerT200"));
|
|
|
|
if (T200_Active)
|
|
{
|
|
StopTimerT200 ();
|
|
}
|
|
|
|
if (T203_Active)
|
|
{
|
|
StopTimerT203 ();
|
|
}
|
|
|
|
T200_Handle = g_pSystemTimer->CreateTimerEvent(T200_Timeout,
|
|
TIMER_EVENT_ONE_SHOT,
|
|
this,
|
|
(PTimerFunction) &CLayerQ922::T200Timeout);
|
|
|
|
T200_Active = TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::StopTimerT200 (void)
|
|
*
|
|
* Functional Description
|
|
* This function stops the T200 timer. If we receive a response
|
|
* to a packet before the T200 timer expires, this function is
|
|
* called.
|
|
*
|
|
* Formal Parameters
|
|
* None.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::StopTimerT200 (void)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::StopTimerT200"));
|
|
|
|
if (T200_Active)
|
|
{
|
|
if (g_pSystemTimer->DeleteTimerEvent(T200_Handle) != TIMER_NO_ERROR)
|
|
{
|
|
TRACE_OUT(("Q922: StopTimerT200: DLCI %d: Illegal Timer handle = %d", DLCI, T200_Handle));
|
|
}
|
|
T200_Active = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::T200Timeout (
|
|
* TimerEventHandle)
|
|
*
|
|
* Functional Description
|
|
* This function is called by the timer class when the T200
|
|
* timer expires.
|
|
*
|
|
* Formal Parameters
|
|
* None.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::T200Timeout(TimerEventHandle)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::T200Timeout"));
|
|
|
|
BOOL send_disconnect = FALSE;
|
|
|
|
T200_Active = FALSE;
|
|
N200_Count++;
|
|
|
|
TRACE_OUT(("Q922::T200Timeout: %d DLCI: Timer Recovery: N200_Count = %x", DLCI, N200_Count));
|
|
|
|
if ((Maximum_T200_Timeouts != 0xffff) &&
|
|
(N200_Count >= Maximum_T200_Timeouts))
|
|
{
|
|
Link_Stable = FALSE;
|
|
send_disconnect = TRUE;
|
|
}
|
|
|
|
switch (Data_Link_Mode)
|
|
{
|
|
case TEI_ASSIGNED:
|
|
break;
|
|
|
|
case AWAITING_ESTABLISHMENT:
|
|
if (! Link_Stable)
|
|
{
|
|
break;
|
|
}
|
|
if (Link_Originator)
|
|
{
|
|
SABME_Pending = TRUE;
|
|
Unnumbered_PF_State = UNNUMBERED_PF_SET;
|
|
}
|
|
break;
|
|
|
|
case AWAITING_RELEASE:
|
|
if (Final_Packet)
|
|
{
|
|
send_disconnect = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (! Link_Stable)
|
|
{
|
|
send_disconnect = TRUE;
|
|
}
|
|
else
|
|
{
|
|
DISC_Pending = TRUE;
|
|
Unnumbered_PF_State = UNNUMBERED_PF_SET;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
if (! Link_Stable)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d T200 Timeout: Broken Connection", DLCI));
|
|
Reset ();
|
|
Data_Link_Mode = TEI_ASSIGNED;
|
|
}
|
|
else
|
|
{
|
|
Data_Link_Mode = TIMER_RECOVERY;
|
|
Poll_Pending = TRUE;
|
|
StartTimerT200 ();
|
|
}
|
|
}
|
|
|
|
/*
|
|
** Notify the owner that the link is unstable
|
|
*/
|
|
if (send_disconnect)
|
|
{
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_INDICATION,
|
|
(void *) DLCI, (void *) DATALINK_REMOTE_SITE_TIMED_OUT);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::StartTimerT203 (void)
|
|
*
|
|
* Functional Description
|
|
* This function starts the T203 timer. This function is called
|
|
* when the T200 timer is not active. The T203 timer expires
|
|
* when we don't receive a packet from the remote site in T203
|
|
* seconds.
|
|
*
|
|
* Formal Parameters
|
|
* None.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::StartTimerT203 (void)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::StartTimerT203"));
|
|
|
|
if (T203_Timeout == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (T203_Active)
|
|
{
|
|
StopTimerT203 ();
|
|
}
|
|
|
|
T203_Handle = g_pSystemTimer->CreateTimerEvent(
|
|
T203_Timeout, TIMER_EVENT_ONE_SHOT, this,
|
|
(PTimerFunction) &CLayerQ922::T203Timeout);
|
|
|
|
T203_Active = TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::StopTimerT203 (void)
|
|
*
|
|
* Functional Description
|
|
* This function stops the T203 timer. If we receive a packet
|
|
* while the T203 packet is active, this function is called.
|
|
*
|
|
* Formal Parameters
|
|
* None.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::StopTimerT203 (void)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::StopTimerT203"));
|
|
|
|
if (T203_Active)
|
|
{
|
|
g_pSystemTimer->DeleteTimerEvent(T203_Handle);
|
|
T203_Active = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void CLayerQ922::T203Timeout (
|
|
* TimerEventHandle)
|
|
*
|
|
* Functional Description
|
|
* This function is called by the timer class when the T203
|
|
* timer expires.
|
|
*
|
|
* Formal Parameters
|
|
* None.
|
|
*
|
|
* Return Value
|
|
* None.
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void CLayerQ922::T203Timeout (TimerEventHandle)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::T203Timeout"));
|
|
|
|
T203_Active = FALSE;
|
|
|
|
if (Data_Link_Mode == TEI_ASSIGNED)
|
|
{
|
|
TRACE_OUT(("Q922: DLCI %d: T203 Timeout: Releasing connection", DLCI));
|
|
m_pT123->OwnerCallback(m_nMsgBase + DATALINK_RELEASE_INDICATION,
|
|
(void *) DLCI, (void *) DATALINK_REMOTE_SITE_TIMED_OUT);
|
|
return;
|
|
}
|
|
|
|
StartTimerT200 ();
|
|
|
|
Data_Link_Mode = TIMER_RECOVERY;
|
|
Poll_Pending = TRUE;
|
|
}
|
|
|
|
/*
|
|
* ProtocolLayerError CLayerQ922::GetParameters (
|
|
* USHORT,
|
|
* USHORT * max_packet_size,
|
|
* USHORT * prepend,
|
|
* USHORT * append)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function returns the maximum packet size permitted by
|
|
* the higher layer.
|
|
*/
|
|
ProtocolLayerError CLayerQ922::GetParameters (
|
|
USHORT * packet_size,
|
|
USHORT * prepend,
|
|
USHORT * append)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::GetParameters"));
|
|
|
|
*prepend = DATALINK_PACKET_OVERHEAD + Lower_Layer_Prepend;
|
|
*append = Lower_Layer_Append;
|
|
*packet_size = Maximum_Information_Size;
|
|
|
|
return (PROTOCOL_LAYER_NO_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
* ProtocolLayerError CLayerQ922::RegisterHigherLayer (
|
|
* USHORT,
|
|
* PMemoryManager,
|
|
* IProtocolLayer * higher_layer);
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function is called to register an identifier with a higher
|
|
* layer address.
|
|
*/
|
|
ProtocolLayerError CLayerQ922::RegisterHigherLayer (
|
|
ULONG_PTR,
|
|
PMemoryManager,
|
|
IProtocolLayer * higher_layer)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::RegisterHigherLayer"));
|
|
|
|
Higher_Layer = higher_layer; // CLayerSCF or CLayerX224
|
|
return (PROTOCOL_LAYER_NO_ERROR);
|
|
}
|
|
|
|
|
|
/*
|
|
* ProtocolLayerError CLayerQ922::RemoveHigherLayer (
|
|
* USHORT);
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function removes the higher layer from our list
|
|
*/
|
|
ProtocolLayerError CLayerQ922::RemoveHigherLayer (
|
|
ULONG_PTR)
|
|
{
|
|
TRACE_OUT(("CLayerQ922::RemoveHigherLayer"));
|
|
|
|
Higher_Layer = NULL;
|
|
return (PROTOCOL_LAYER_NO_ERROR);
|
|
}
|
|
|
|
|