1465 lines
44 KiB
C++
1465 lines
44 KiB
C++
#include "precomp.h"
|
|
DEBUG_FILEZONE(ZONE_T120_T123PSTN);
|
|
/* SCFCall.cpp
|
|
*
|
|
* Copyright (c) 1994-1995 by DataBeam Corporation, Lexington, KY
|
|
*
|
|
* Abstract:
|
|
* This class is instantiated by the SCF class. For each call that the
|
|
* local site or remote site initiates, a SCFCall object is instantiated.
|
|
* SCF can can manage 254 different calls simultaneously. For each call
|
|
* there is a specific Q.933 based protocol that must occur to make the
|
|
* connection valid. This object sends and receives the Q.933 packets.
|
|
*
|
|
* Private Instance Variables:
|
|
* m_pSCF - Address of the owner of this object
|
|
* Lower_Layer - Address of the layer below this layer
|
|
* m_nMsgBase - The owner of this object gives it a base
|
|
* number to use for OwnerCallbacks ()
|
|
* Maximum_Packet_Size - Maximum transmittable packet size
|
|
* Packet_Pending - Tells which packet is to be transmitted
|
|
* next.
|
|
* Link_Originator - TRUE is this site initiated the call
|
|
*
|
|
* Write_Buffer - Address of write buffer
|
|
* Send_Priority - TRUE if we are suppose to respond to the
|
|
* priority requested by the remote site
|
|
*
|
|
* Call_Reference - Call reference number of this call.
|
|
* DLCI - Holds the suggested and confirmed DLCI for
|
|
* this call.
|
|
* Priority - Holds the suggested and confirmed priority
|
|
* for this call.
|
|
*
|
|
* State - Holds the current state of the call.
|
|
* Release_Cause - Reason the the breakup of the link.
|
|
* Default_Priority - Default priority of a non-specified call.
|
|
*
|
|
* T303_Timeout - T303 timeout value.
|
|
* T303_Handle - System timer handle to T303 timer
|
|
* T303_Active - TRUE if the timer is currently active
|
|
* T303_Count - Number of T303 Timeouts
|
|
*
|
|
* T313_Timeout - T313 timeout value
|
|
* T313_Handle - System timer handle to T313 timer
|
|
* T313_Active - TRUE if the timer is currently active.
|
|
*
|
|
* Caveats:
|
|
* None.
|
|
*
|
|
* Authors:
|
|
* James W. Lawwill
|
|
*/
|
|
#include "scf.h"
|
|
#include "scfcall.h"
|
|
|
|
|
|
/*
|
|
* SCFCall::SCFCall (
|
|
* PTransportResources transport_resources,
|
|
* IObject * owner_object
|
|
* IProtocolLayer * lower_layer,
|
|
* USHORT message_base,
|
|
* PDataLinkParameters datalink_struct,
|
|
* PMemoryManager data_request_memory_manager,
|
|
* BOOL * initialized)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This is the SCFCall constructor. This routine initializes all
|
|
* variables and allocates write buffer space.
|
|
*/
|
|
SCFCall::SCFCall (
|
|
CLayerSCF *owner_object,
|
|
IProtocolLayer * lower_layer,
|
|
USHORT message_base,
|
|
PDataLinkParameters datalink_struct,
|
|
PMemoryManager data_request_memory_manager,
|
|
BOOL * initialized)
|
|
{
|
|
TRACE_OUT(("SCFCall::SCFCall"));
|
|
|
|
m_pSCF = owner_object;
|
|
Lower_Layer = lower_layer;
|
|
m_nMsgBase = message_base;
|
|
Data_Request_Memory_Manager = data_request_memory_manager;
|
|
*initialized = TRUE;
|
|
|
|
DataLink_Struct.k_factor = datalink_struct->k_factor;
|
|
DataLink_Struct.default_k_factor = datalink_struct->default_k_factor;
|
|
DataLink_Struct.n201 = datalink_struct->n201;
|
|
DataLink_Struct.default_n201 = datalink_struct->default_n201;
|
|
|
|
/*
|
|
** T200 is represented in milliseconds, we need to convert it to
|
|
** tenths of seconds.
|
|
*/
|
|
DataLink_Struct.t200 = datalink_struct->t200 / 100;
|
|
DataLink_Struct.default_t200 = datalink_struct->default_t200 / 100;
|
|
|
|
Lower_Layer -> GetParameters (
|
|
&Maximum_Packet_Size,
|
|
&Lower_Layer_Prepend,
|
|
&Lower_Layer_Append);
|
|
|
|
Packet_Pending = NO_PACKET;
|
|
Link_Originator = FALSE;
|
|
State = NOT_CONNECTED;
|
|
Received_Priority = FALSE;
|
|
Received_K_Factor = FALSE;
|
|
Received_N201 = FALSE;
|
|
Received_T200 = FALSE;
|
|
DLC_Identifier = 0;
|
|
|
|
T303_Active = FALSE;
|
|
T313_Active = FALSE;
|
|
|
|
/*
|
|
** Get configuration data
|
|
*/
|
|
T303_Timeout = DEFAULT_T303_TIMEOUT;
|
|
T313_Timeout = DEFAULT_T313_TIMEOUT;
|
|
Default_Priority = DEFAULT_PRIORITY;
|
|
}
|
|
|
|
|
|
/*
|
|
* SCFCall::~SCFCall (void)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This is the SCFCall destructor. This routine cleans up the mess
|
|
*/
|
|
SCFCall::~SCFCall (void)
|
|
{
|
|
if (T303_Active)
|
|
{
|
|
StopTimerT303 ();
|
|
}
|
|
|
|
if (T313_Active)
|
|
{
|
|
StopTimerT313 ();
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* SCFCall::ConnectRequest (
|
|
* CallReference call_reference,
|
|
* DLCI dlci,
|
|
* USHORT priority)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function is called when SCF wants to initiate a call.
|
|
* As a result, we queue a SETUP command to be sent out.
|
|
*/
|
|
SCFCallError SCFCall::ConnectRequest(
|
|
CallReference call_reference,
|
|
DLCI dlci,
|
|
TransportPriority priority)
|
|
{
|
|
TRACE_OUT(("SCFCall::ConnectRequest"));
|
|
Call_Reference = call_reference;
|
|
DLC_Identifier = dlci;
|
|
Priority = priority;
|
|
Link_Originator = TRUE;
|
|
|
|
if (State == NOT_CONNECTED)
|
|
Packet_Pending = SETUP;
|
|
|
|
return (SCFCALL_NO_ERROR);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* SCFCallError SCFCall::ConnectResponse (
|
|
* BOOL valid_dlci)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function is called in response to a NETWORK_CONNECT_INDICATION
|
|
* callback to the owner of this object. Previously, the remote site
|
|
* sent us a SETUP packet with a suggested DLCI. This DLCI is sent to
|
|
* the owner in the NETWORK_CONNECT_INDICATION call. The owner calls
|
|
* this function with a BOOL , telling us if the DLCI was valid.
|
|
*/
|
|
SCFCallError SCFCall::ConnectResponse (
|
|
BOOL valid_dlci)
|
|
{
|
|
TRACE_OUT(("SCFCall::ConnectResponse"));
|
|
if (valid_dlci)
|
|
{
|
|
/*
|
|
** This DLCI can be used in a link. If the remote site did not
|
|
** request a priority, we set it to Default_Priority
|
|
*/
|
|
if (Priority == 0xffff)
|
|
Priority = Default_Priority;
|
|
|
|
Packet_Pending = CONNECT;
|
|
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
** Queue up a RELEASE COMPLETE packet
|
|
*/
|
|
Packet_Pending = RELEASE_COMPLETE;
|
|
Release_Cause = REQUESTED_CHANNEL_UNAVAILABLE;
|
|
}
|
|
|
|
return (SCFCALL_NO_ERROR);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* SCFCallError SCFCall::DisconnectRequest ()
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function is called when the SCF wants to terminate the call
|
|
*/
|
|
SCFCallError SCFCall::DisconnectRequest ()
|
|
{
|
|
TRACE_OUT(("SCFCall::DisconnectRequest"));
|
|
/*
|
|
** Queue up the Release Complete
|
|
*/
|
|
if (State != NOT_CONNECTED)
|
|
{
|
|
Packet_Pending = RELEASE_COMPLETE;
|
|
Release_Cause = NORMAL_USER_DISCONNECT;
|
|
}
|
|
|
|
return (SCFCALL_NO_ERROR);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* BOOL SCFCall::ProcessSetup (
|
|
* CallReference call_reference,
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function processes an incoming SETUP packet
|
|
*/
|
|
BOOL SCFCall::ProcessSetup (
|
|
CallReference call_reference,
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
USHORT length;
|
|
BOOL packet_successful;
|
|
USHORT remainder_length;
|
|
USHORT n201;
|
|
USHORT k_factor;
|
|
USHORT t200;
|
|
NetworkConnectStruct connect_struct;
|
|
|
|
TRACE_OUT(("SCFCall::ProcessSetup"));
|
|
|
|
if (State != NOT_CONNECTED)
|
|
return (FALSE);
|
|
|
|
Call_Reference = call_reference;
|
|
packet_successful = TRUE;
|
|
remainder_length = packet_length;
|
|
|
|
/*
|
|
** Bearer capability element
|
|
*/
|
|
if (*(packet_address++) != BEARER_CAPABILITY)
|
|
return (FALSE);
|
|
remainder_length--;
|
|
|
|
length = *(packet_address++);
|
|
remainder_length--;
|
|
if (length != 3)
|
|
return (FALSE);
|
|
|
|
/*
|
|
** Verify that the Bearer Capability is correct
|
|
*/
|
|
if (*(packet_address) !=
|
|
(EXTENSION | CODING_STANDARD | INFORMATION_TRANSFER_CAPABILITY))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
if (*(packet_address + 1) != (EXTENSION | TRANSFER_MODE))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
if (*(packet_address + 2) !=
|
|
(EXTENSION | LAYER_2_IDENT | USER_INFORMATION_LAYER_2))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
packet_address += length;
|
|
remainder_length -= length;
|
|
|
|
/*
|
|
** DLCI element
|
|
*/
|
|
if (*(packet_address++) != DLCI_ELEMENT)
|
|
return (FALSE);
|
|
remainder_length--;
|
|
|
|
length = *(packet_address++);
|
|
if (length != 2)
|
|
return (FALSE);
|
|
remainder_length--;
|
|
|
|
/*
|
|
** If the Preferred/Exclusive bit is set, its illegal
|
|
*/
|
|
if (((*(packet_address) & PREFERRED_EXCLUSIVE) == PREFERRED_EXCLUSIVE) ||
|
|
((*(packet_address + 1) & EXTENSION) == 0))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
|
|
DLC_Identifier = (*(packet_address) & 0x3f) << 4;
|
|
DLC_Identifier |= ((*(packet_address + 1) & 0x78) >> 3);
|
|
|
|
packet_address += length;
|
|
remainder_length -= length;
|
|
|
|
Priority = 0xffff;
|
|
|
|
/*
|
|
** Go thru each of the elements and decode them
|
|
*/
|
|
while (remainder_length)
|
|
{
|
|
switch (*(packet_address++))
|
|
{
|
|
case X213_PRIORITY:
|
|
length = *(packet_address++);
|
|
remainder_length--;
|
|
if (((*(packet_address) & EXTENSION) == 1) ||
|
|
((*(packet_address + 1) & EXTENSION) == 0))
|
|
{
|
|
ERROR_OUT(("SCFCall: ProcessSetup: SETUP packet: Illegal X.213 priority"));
|
|
return (FALSE);
|
|
}
|
|
Priority = (*packet_address & 0x0f);
|
|
packet_address += length;
|
|
remainder_length -= length;
|
|
Received_Priority = TRUE;
|
|
break;
|
|
|
|
case LINK_LAYER_CORE_PARAMETERS:
|
|
length = *(packet_address++);
|
|
remainder_length -= (length + 1);
|
|
while (length)
|
|
{
|
|
switch (*(packet_address++))
|
|
{
|
|
case FMIF_SIZE:
|
|
/*
|
|
** N201 is a Q922 parameter. It is the number of
|
|
** maximum information bytes in a packet
|
|
*/
|
|
n201 =
|
|
((*packet_address << 7) |
|
|
(*(packet_address + 1) & 0x7f));
|
|
if ((*(packet_address+1) & EXTENSION) == EXTENSION)
|
|
{
|
|
length -= 2;
|
|
packet_address += 2;
|
|
}
|
|
else
|
|
{
|
|
packet_address += 4;
|
|
length -= 4;
|
|
}
|
|
|
|
/*
|
|
** If the requested n201 value is less than our
|
|
** value, it will be our new N201, otherwise send
|
|
** our N201 back as the arbitrated value.
|
|
*/
|
|
if (n201 < DataLink_Struct.n201)
|
|
DataLink_Struct.n201 = n201;
|
|
Received_N201 = TRUE;
|
|
TRACE_OUT(("SCFCALL: ProcessSetup: n201 = %d", DataLink_Struct.n201));
|
|
break;
|
|
|
|
default:
|
|
while ((*(packet_address++) & EXTENSION) == 0)
|
|
length--;
|
|
length--;
|
|
break;
|
|
}
|
|
length--;
|
|
}
|
|
break;
|
|
|
|
case LINK_LAYER_PROTOCOL_PARAMETERS:
|
|
length = *(packet_address++);
|
|
remainder_length -= (length + 1);
|
|
while (length)
|
|
{
|
|
switch (*(packet_address++))
|
|
{
|
|
case TRANSMIT_WINDOW_SIZE_IDENTIFIER:
|
|
/*
|
|
** The Window size is the maximum number of
|
|
** outstanding packets at any one time
|
|
*/
|
|
k_factor = *packet_address & 0x7f;
|
|
packet_address++;
|
|
length--;
|
|
|
|
/*
|
|
** If the requested k_factor value is less than our
|
|
** value, it will be our new k_factor, otherwise
|
|
** send our k_factor back as the arbitrated value.
|
|
*/
|
|
if (k_factor < DataLink_Struct.k_factor)
|
|
DataLink_Struct.k_factor = k_factor;
|
|
Received_K_Factor = TRUE;
|
|
TRACE_OUT(("SCFCALL: ProcessSetup: k_factor = %d", DataLink_Struct.k_factor));
|
|
break;
|
|
|
|
case RETRANSMISSION_TIMER_IDENTIFIER:
|
|
/*
|
|
** t200 is the timeout value before retransmission
|
|
*/
|
|
t200 = ((*packet_address << 7) |
|
|
(*(packet_address + 1) & 0x7f));
|
|
packet_address += 2;
|
|
length -= 2;
|
|
|
|
/*
|
|
** If the requested t200 value is too small,
|
|
** value, it will be our new T200, otherwise
|
|
** send our T200 back as the arbitrated value.
|
|
*/
|
|
if (t200 > DataLink_Struct.t200)
|
|
DataLink_Struct.t200 = t200;
|
|
Received_T200 = TRUE;
|
|
TRACE_OUT(("SCFCALL: ProcessSetup: t200 = %d", DataLink_Struct.t200));
|
|
break;
|
|
|
|
default:
|
|
while ((*(packet_address++) & EXTENSION) == 0)
|
|
length--;
|
|
length--;
|
|
break;
|
|
}
|
|
length--;
|
|
}
|
|
break;
|
|
|
|
case END_TO_END_DELAY:
|
|
case CALLING_PARTY_SUBADDRESS:
|
|
case CALLED_PARTY_SUBADDRESS:
|
|
default:
|
|
TRACE_OUT(("SCFCall: ProcessSetup: SETUP packet: Option 0x%x"
|
|
"requested, but not supported", *(packet_address-1)));
|
|
length = *(packet_address);
|
|
|
|
packet_address += (length + 1);
|
|
remainder_length -= (length + 1);
|
|
break;
|
|
}
|
|
remainder_length--;
|
|
}
|
|
if (Received_N201 == FALSE)
|
|
DataLink_Struct.n201 = DataLink_Struct.default_n201;
|
|
if (Received_K_Factor == FALSE)
|
|
DataLink_Struct.k_factor = DataLink_Struct.default_k_factor;
|
|
if (Received_T200 == FALSE)
|
|
DataLink_Struct.t200 = DataLink_Struct.default_t200;
|
|
|
|
if (packet_successful)
|
|
{
|
|
/*
|
|
** If the packet was successfully decoded, tell the owner the requested
|
|
** DLCI and priority.
|
|
*/
|
|
connect_struct.dlci = DLC_Identifier;
|
|
connect_struct.priority = Priority;
|
|
connect_struct.datalink_struct = &DataLink_Struct;
|
|
|
|
/*
|
|
** Convert t200 into milliseconds
|
|
*/
|
|
DataLink_Struct.t200 *= 100;
|
|
m_pSCF->OwnerCallback(m_nMsgBase + NETWORK_CONNECT_INDICATION, 0, 0, &connect_struct);
|
|
DataLink_Struct.t200 /= 100;
|
|
}
|
|
|
|
return (packet_successful);
|
|
}
|
|
|
|
|
|
/*
|
|
* BOOL SCFCall::ProcessConnect (
|
|
* LPBYTE packet_address,
|
|
* USHORT packet_length)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function processes an incoming CONNECT packet
|
|
*/
|
|
BOOL SCFCall::ProcessConnect (
|
|
LPBYTE packet_address,
|
|
USHORT packet_length)
|
|
{
|
|
TRACE_OUT(("SCFCall::ProcessConnect"));
|
|
|
|
BOOL packet_successful;
|
|
USHORT length;
|
|
DLCI exclusive_dlci;
|
|
USHORT remainder_length;
|
|
USHORT k_factor;
|
|
USHORT t200;
|
|
|
|
if (State != SETUP_SENT)
|
|
{
|
|
ERROR_OUT(("SCFCall: ProcessConnect: Call in wrong state"));
|
|
return (FALSE);
|
|
}
|
|
|
|
remainder_length = packet_length;
|
|
packet_successful = TRUE;
|
|
|
|
/*
|
|
** DLCI element
|
|
*/
|
|
if (*(packet_address++) != DLCI_ELEMENT)
|
|
{
|
|
ERROR_OUT(("SCFCall: ProcessConnect: DLCI_ELEMENT not in packet"));
|
|
return (FALSE);
|
|
}
|
|
remainder_length--;
|
|
|
|
length = *(packet_address++);
|
|
if (length != 2)
|
|
{
|
|
ERROR_OUT(("SCFCall: ProcessConnect: DLCI length must be 2"));
|
|
return (FALSE);
|
|
}
|
|
remainder_length--;
|
|
|
|
/*
|
|
** If the Preferred/Exclusive bit is not set, its illegal
|
|
*/
|
|
if (((*(packet_address) & PREFERRED_EXCLUSIVE) == 0) ||
|
|
((*(packet_address + 1) & EXTENSION) == 0))
|
|
{
|
|
ERROR_OUT(("SCFCall: CONNECT: Illegal DLCI"));
|
|
return (FALSE);
|
|
}
|
|
|
|
/*
|
|
** Get the DLCI
|
|
*/
|
|
exclusive_dlci = (*(packet_address) & 0x3f) << 4;
|
|
exclusive_dlci |= ((*(packet_address + 1) & 0x78) >> 3);
|
|
|
|
packet_address += length;
|
|
remainder_length -= length;
|
|
|
|
/*
|
|
** Go thru each of the elements and decode them
|
|
*/
|
|
while (remainder_length != 0)
|
|
{
|
|
switch (*(packet_address++))
|
|
{
|
|
case X213_PRIORITY:
|
|
length = *(packet_address++);
|
|
remainder_length--;
|
|
if ((*(packet_address) & EXTENSION) == 0)
|
|
{
|
|
ERROR_OUT(("SCFCall: DataIndication: CONNECT packet: Illegal X.213 priority"));
|
|
return (FALSE);
|
|
}
|
|
Priority = (*packet_address & 0x0f);
|
|
packet_address += length;
|
|
remainder_length -= length;
|
|
break;
|
|
|
|
case LINK_LAYER_CORE_PARAMETERS:
|
|
length = *(packet_address++);
|
|
remainder_length -= (length + 1);
|
|
while (length)
|
|
{
|
|
switch (*(packet_address++))
|
|
{
|
|
case FMIF_SIZE:
|
|
/*
|
|
** FMIF_Size is the max. number of bytes allowed in
|
|
** a information packet
|
|
*/
|
|
DataLink_Struct.n201 =
|
|
((*packet_address << 7) |
|
|
(*(packet_address + 1) & 0x7f));
|
|
if ((*(packet_address+1) & EXTENSION) == EXTENSION)
|
|
{
|
|
length -= 2;
|
|
packet_address += 2;
|
|
}
|
|
else
|
|
{
|
|
packet_address += 4;
|
|
length -= 4;
|
|
}
|
|
|
|
Received_N201 = TRUE;
|
|
TRACE_OUT(("SCFCALL: ProcessConnect: n201 = %d", DataLink_Struct.n201));
|
|
break;
|
|
|
|
default:
|
|
while ((*(packet_address++) & EXTENSION) == 0)
|
|
length--;
|
|
length--;
|
|
break;
|
|
}
|
|
length--;
|
|
}
|
|
break;
|
|
|
|
case LINK_LAYER_PROTOCOL_PARAMETERS:
|
|
length = *(packet_address++);
|
|
remainder_length -= (length + 1);
|
|
while (length)
|
|
{
|
|
switch (*(packet_address++))
|
|
{
|
|
case TRANSMIT_WINDOW_SIZE_IDENTIFIER:
|
|
/*
|
|
** The Window size is the maximum number of
|
|
** outstanding packets at any one time
|
|
*/
|
|
k_factor = *packet_address & 0x7f;
|
|
packet_address++;
|
|
length--;
|
|
|
|
DataLink_Struct.k_factor = k_factor;
|
|
Received_K_Factor = TRUE;
|
|
TRACE_OUT(("SCFCALL: ProcessConnect: k_factor = %d", DataLink_Struct.k_factor));
|
|
break;
|
|
|
|
case RETRANSMISSION_TIMER_IDENTIFIER:
|
|
/*
|
|
** t200 is the timeout value before retransmission
|
|
*/
|
|
t200 = ((*packet_address << 7) |
|
|
(*(packet_address + 1) & 0x7f));
|
|
packet_address += 2;
|
|
length -= 2;
|
|
|
|
DataLink_Struct.t200 = t200;
|
|
Received_T200 = TRUE;
|
|
TRACE_OUT(("SCFCALL: ProcessConnect: t200 = %d", DataLink_Struct.t200));
|
|
break;
|
|
|
|
default:
|
|
while ((*(packet_address++) & EXTENSION) == 0)
|
|
length--;
|
|
length--;
|
|
break;
|
|
}
|
|
length--;
|
|
}
|
|
break;
|
|
|
|
case END_TO_END_DELAY:
|
|
case CALLING_PARTY_SUBADDRESS:
|
|
case CALLED_PARTY_SUBADDRESS:
|
|
default:
|
|
TRACE_OUT(("SCFCall: DataIndication: CONNECT packet: Option "
|
|
"requested, but not supported", *(packet_address-1)));
|
|
length = *(packet_address++);
|
|
remainder_length--;
|
|
|
|
packet_address += length;
|
|
remainder_length -= length;
|
|
break;
|
|
}
|
|
remainder_length--;
|
|
}
|
|
|
|
if (Received_N201 == FALSE)
|
|
DataLink_Struct.n201 = DataLink_Struct.default_n201;
|
|
if (Received_K_Factor == FALSE)
|
|
DataLink_Struct.k_factor = DataLink_Struct.default_k_factor;
|
|
if (Received_T200 == FALSE)
|
|
DataLink_Struct.t200 = DataLink_Struct.default_t200;
|
|
|
|
/*
|
|
** If the packet was successfully decoded, queue up the CONNECT ACK
|
|
*/
|
|
if (packet_successful)
|
|
{
|
|
Packet_Pending = CONNECT_ACKNOWLEDGE;
|
|
StopTimerT303 ();
|
|
}
|
|
|
|
return (packet_successful);
|
|
}
|
|
|
|
|
|
/*
|
|
* BOOL SCFCall::ProcessConnectAcknowledge (
|
|
* LPBYTE,
|
|
* USHORT)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function processes an incoming CONNECT ACK packet
|
|
*
|
|
*/
|
|
BOOL SCFCall::ProcessConnectAcknowledge (
|
|
LPBYTE,
|
|
USHORT)
|
|
{
|
|
TRACE_OUT(("SCFCall::ProcessConnectAcknowledge"));
|
|
|
|
if (State != CONNECT_SENT)
|
|
return (FALSE);
|
|
|
|
StopTimerT313 ();
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
* BOOL SCFCall::ProcessReleaseComplete (
|
|
* LPBYTE packet_address,
|
|
* USHORT)
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function processes an incoming RELEASE COMPLETE
|
|
*/
|
|
BOOL SCFCall::ProcessReleaseComplete (
|
|
LPBYTE packet_address,
|
|
USHORT)
|
|
{
|
|
TRACE_OUT(("SCFCall::ProcessReleaseComplete"));
|
|
|
|
USHORT cause;
|
|
|
|
if (State == NOT_CONNECTED)
|
|
return (FALSE);
|
|
|
|
if (*(packet_address++) == CAUSE)
|
|
{
|
|
packet_address++;
|
|
if ((*(packet_address++) & EXTENSION) == 0)
|
|
packet_address++;
|
|
|
|
cause = *(packet_address++) & (~EXTENSION);
|
|
TRACE_OUT(("SCFCall: Disconnect: cause = %d", cause));
|
|
}
|
|
|
|
State = NOT_CONNECTED;
|
|
|
|
/*
|
|
** Tell the owner about the Disconnection
|
|
*/
|
|
m_pSCF->OwnerCallback(m_nMsgBase + NETWORK_DISCONNECT_INDICATION,
|
|
(void *) DLC_Identifier,
|
|
(void *) (ULONG_PTR)(((Link_Originator << 16) | cause)));
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::PollTransmitter (
|
|
* USHORT data_to_transmit,
|
|
* USHORT * pending_data);
|
|
*
|
|
* Public
|
|
*
|
|
* Functional Description:
|
|
* This function is called to transmit any queued up packets
|
|
*/
|
|
void SCFCall::PollTransmitter (
|
|
USHORT data_to_transmit,
|
|
USHORT * pending_data)
|
|
{
|
|
// TRACE_OUT(("SCFCall::PollTransmitter"));
|
|
|
|
NetworkConnectStruct connect_struct;
|
|
|
|
if (data_to_transmit & PROTOCOL_CONTROL_DATA)
|
|
{
|
|
switch (Packet_Pending)
|
|
{
|
|
case SETUP:
|
|
SendSetup ();
|
|
break;
|
|
|
|
case CONNECT:
|
|
SendConnect ();
|
|
break;
|
|
|
|
case CONNECT_ACKNOWLEDGE:
|
|
SendConnectAcknowledge ();
|
|
if (Packet_Pending != CONNECT_ACKNOWLEDGE)
|
|
{
|
|
/*
|
|
** If the CONNECT ACK packet was sent, notify the owner
|
|
*/
|
|
connect_struct.dlci = DLC_Identifier;
|
|
connect_struct.priority = Priority;
|
|
connect_struct.datalink_struct = &DataLink_Struct;
|
|
|
|
/*
|
|
** Convert t200 to milliseconds
|
|
*/
|
|
DataLink_Struct.t200 *= 100;
|
|
m_pSCF->OwnerCallback(m_nMsgBase + NETWORK_CONNECT_CONFIRM, 0, 0, &connect_struct);
|
|
DataLink_Struct.t200 /= 100;
|
|
}
|
|
break;
|
|
|
|
case RELEASE_COMPLETE:
|
|
SendReleaseComplete ();
|
|
if (Packet_Pending != RELEASE_COMPLETE)
|
|
{
|
|
/*
|
|
** If the RELEASE COMPLETE packet was sent, notify
|
|
** the owner
|
|
*/
|
|
m_pSCF->OwnerCallback(m_nMsgBase + NETWORK_DISCONNECT_INDICATION,
|
|
(void *) DLC_Identifier,
|
|
(void *) ((((ULONG_PTR) Link_Originator) << 16) | Release_Cause));
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (Packet_Pending != NO_PACKET)
|
|
*pending_data = PROTOCOL_CONTROL_DATA;
|
|
else
|
|
*pending_data = 0;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::SendSetup (void);
|
|
*
|
|
* Functional Description
|
|
* This function attempts to send out a SETUP packet. The T303 timer
|
|
* is started. If a CONNECT is not received before the timer expires,
|
|
* we terminate the link.
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* If this function is able to send a SETUP packet to the lower layer,
|
|
* it sets the Packet_Pending variable to NO_PACKET
|
|
*
|
|
* Caveats
|
|
* None
|
|
*/
|
|
void SCFCall::SendSetup (void)
|
|
{
|
|
TRACE_OUT(("SCFCall::SendSetup"));
|
|
|
|
LPBYTE packet_address;
|
|
ULONG bytes_accepted;
|
|
USHORT total_length;
|
|
PMemory memory;
|
|
|
|
total_length = SETUP_PACKET_SIZE + Lower_Layer_Prepend +
|
|
Lower_Layer_Append;
|
|
|
|
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
|
NULL,
|
|
total_length);
|
|
if (memory == NULL)
|
|
return;
|
|
|
|
packet_address = memory -> GetPointer ();
|
|
packet_address += Lower_Layer_Prepend;
|
|
|
|
*(packet_address++) = Q931_PROTOCOL_DISCRIMINATOR;
|
|
*(packet_address++) = 1;
|
|
*(packet_address++) = (UChar) Call_Reference;
|
|
*(packet_address++) = SETUP;
|
|
|
|
/*
|
|
** Bearer Capability
|
|
*/
|
|
*(packet_address++) = BEARER_CAPABILITY;
|
|
*(packet_address++) = 3;
|
|
*(packet_address++) =
|
|
EXTENSION | CODING_STANDARD | INFORMATION_TRANSFER_CAPABILITY;
|
|
*(packet_address++) = EXTENSION | TRANSFER_MODE;
|
|
*(packet_address++) = EXTENSION | LAYER_2_IDENT | USER_INFORMATION_LAYER_2;
|
|
|
|
/*
|
|
** DLCI
|
|
*/
|
|
*(packet_address++) = DLCI_ELEMENT;
|
|
*(packet_address++) = 2;
|
|
*(packet_address++) = (DLC_Identifier >> 4);
|
|
*(packet_address++) = EXTENSION | ((DLC_Identifier & 0x0f) << 3);
|
|
|
|
/*
|
|
** Link Layer Core Parameters
|
|
*/
|
|
*(packet_address++) = LINK_LAYER_CORE_PARAMETERS;
|
|
*(packet_address++) = 3;
|
|
*(packet_address++) = FMIF_SIZE;
|
|
*(packet_address++) = (DataLink_Struct.n201 >> 7);
|
|
*(packet_address++) = EXTENSION | (DataLink_Struct.n201 & 0x7f);
|
|
|
|
/*
|
|
** Link Layer Protocol Parameters
|
|
*/
|
|
*(packet_address++) = LINK_LAYER_PROTOCOL_PARAMETERS;
|
|
*(packet_address++) = 5;
|
|
*(packet_address++) = TRANSMIT_WINDOW_SIZE_IDENTIFIER;
|
|
*(packet_address++) = EXTENSION | DataLink_Struct.k_factor;
|
|
*(packet_address++) = RETRANSMISSION_TIMER_IDENTIFIER;
|
|
*(packet_address++) = (DataLink_Struct.t200 >> 7) & 0x7f;
|
|
*(packet_address++) = EXTENSION | (DataLink_Struct.t200 & 0x7f);
|
|
|
|
/*
|
|
** X.213 Priority
|
|
*/
|
|
*(packet_address++) = X213_PRIORITY;
|
|
*(packet_address++) = 2;
|
|
*(packet_address++) = (UChar) Priority;
|
|
|
|
/*
|
|
** The next byte contains the lowest priority acceptable, 0
|
|
*/
|
|
*(packet_address++) = EXTENSION | 0;
|
|
|
|
/*
|
|
** Attempt to send the packet down
|
|
*/
|
|
Lower_Layer -> DataRequest (
|
|
0,
|
|
memory,
|
|
&bytes_accepted);
|
|
if (bytes_accepted == total_length)
|
|
{
|
|
T303_Count = 0;
|
|
Packet_Pending = NO_PACKET;
|
|
State = SETUP_SENT;
|
|
StartTimerT303 ();
|
|
}
|
|
Data_Request_Memory_Manager -> FreeMemory (memory);
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::SendConnect (void);
|
|
*
|
|
* Functional Description
|
|
* This function attempts to send out a CONNECT packet. The T313 timer
|
|
* is started. If a CONNECT ACK is not received before the timer expires,
|
|
* we terminate the link.
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* If this function is able to send a CONNECT packet to the lower layer,
|
|
* it sets the Packet_Pending variable to NO_PACKET
|
|
*
|
|
* Caveats
|
|
* None
|
|
*
|
|
*/
|
|
void SCFCall::SendConnect (void)
|
|
{
|
|
TRACE_OUT(("SCFCall::SendConnect"));
|
|
|
|
LPBYTE packet_address;
|
|
LPBYTE length_address;
|
|
ULONG bytes_accepted;
|
|
USHORT total_length;
|
|
PMemory memory;
|
|
|
|
total_length = CONNECT_PACKET_BASE_SIZE + Lower_Layer_Prepend +
|
|
Lower_Layer_Append;
|
|
|
|
if (Received_N201)
|
|
total_length += 5;
|
|
|
|
if (Received_K_Factor || Received_T200)
|
|
{
|
|
total_length += 2;
|
|
|
|
if (Received_K_Factor)
|
|
total_length += 2;
|
|
if (Received_T200)
|
|
total_length += 3;
|
|
}
|
|
if (Received_Priority)
|
|
total_length += 3;
|
|
|
|
/*
|
|
** Prepare the CONNECT command and send it to the lower layer
|
|
*/
|
|
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
|
NULL,
|
|
total_length);
|
|
if (memory == NULL)
|
|
return;
|
|
|
|
packet_address = memory -> GetPointer ();
|
|
packet_address += Lower_Layer_Prepend;
|
|
|
|
*(packet_address++) = Q931_PROTOCOL_DISCRIMINATOR;
|
|
*(packet_address++) = 1;
|
|
*(packet_address++) = REMOTE_CALL_REFERENCE | Call_Reference;
|
|
*(packet_address++) = CONNECT;
|
|
|
|
/*
|
|
** DLCI
|
|
*/
|
|
*(packet_address++) = DLCI_ELEMENT;
|
|
*(packet_address++) = 2;
|
|
*(packet_address++) = PREFERRED_EXCLUSIVE | (DLC_Identifier >> 4);
|
|
*(packet_address++) = EXTENSION | ((DLC_Identifier & 0x0f) << 3);
|
|
|
|
if (Received_N201)
|
|
{
|
|
/*
|
|
** Link Layer Core Parameters
|
|
*/
|
|
*(packet_address++) = LINK_LAYER_CORE_PARAMETERS;
|
|
*(packet_address++) = 3;
|
|
*(packet_address++) = FMIF_SIZE;
|
|
*(packet_address++) = (DataLink_Struct.n201 >> 7);
|
|
*(packet_address++) = EXTENSION | (DataLink_Struct.n201 & 0x7f);
|
|
}
|
|
else
|
|
DataLink_Struct.n201 = DataLink_Struct.default_n201;
|
|
|
|
|
|
if (Received_K_Factor || Received_T200)
|
|
{
|
|
/*
|
|
** Link Layer Protocol Parameters
|
|
*/
|
|
*(packet_address++) = LINK_LAYER_PROTOCOL_PARAMETERS;
|
|
length_address = packet_address;
|
|
*(packet_address++) = 0;
|
|
if (Received_K_Factor)
|
|
{
|
|
*length_address += 2;
|
|
*(packet_address++) = TRANSMIT_WINDOW_SIZE_IDENTIFIER;
|
|
*(packet_address++) = EXTENSION | DataLink_Struct.k_factor;
|
|
}
|
|
if (Received_T200)
|
|
{
|
|
*length_address += 3;
|
|
*(packet_address++) = RETRANSMISSION_TIMER_IDENTIFIER;
|
|
*(packet_address++) = (DataLink_Struct.t200 >> 7) & 0x7f;
|
|
*(packet_address++) = EXTENSION | (DataLink_Struct.t200 & 0x7f);
|
|
}
|
|
}
|
|
if (Received_K_Factor == FALSE)
|
|
DataLink_Struct.k_factor = DataLink_Struct.default_k_factor;
|
|
if (Received_T200 == FALSE)
|
|
DataLink_Struct.t200 = DataLink_Struct.default_t200;
|
|
|
|
if (Received_Priority)
|
|
{
|
|
/*
|
|
** X.213 Priority
|
|
*/
|
|
*(packet_address++) = X213_PRIORITY;
|
|
*(packet_address++) = 1;
|
|
*(packet_address++) = (BYTE) (EXTENSION | Priority);
|
|
}
|
|
|
|
/*
|
|
** Attempt to send the packet to the lower layer
|
|
*/
|
|
Lower_Layer -> DataRequest (
|
|
0,
|
|
memory,
|
|
&bytes_accepted);
|
|
if (bytes_accepted == total_length)
|
|
{
|
|
StartTimerT313 ();
|
|
Packet_Pending = NO_PACKET;
|
|
State = CONNECT_SENT;
|
|
}
|
|
Data_Request_Memory_Manager -> FreeMemory (memory);
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::SendConnectAcknowledge (void);
|
|
*
|
|
* Functional Description
|
|
* This function attempts to send out a CONNECT ACKNOWLEDGE packet
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* If this function is able to send the packet to the lower layer,
|
|
* it sets the Packet_Pending variable to NO_PACKET
|
|
*
|
|
* Caveats
|
|
* None
|
|
*
|
|
*/
|
|
void SCFCall::SendConnectAcknowledge (void)
|
|
{
|
|
TRACE_OUT(("SCFCall::SendConnectAcknowledge"));
|
|
|
|
LPBYTE packet_address;
|
|
USHORT total_length;
|
|
PMemory memory;
|
|
ULONG bytes_accepted;
|
|
|
|
total_length = CONNECT_ACK_PACKET_SIZE + Lower_Layer_Prepend +
|
|
Lower_Layer_Append;
|
|
/*
|
|
** Prepare the command and send it to the lower layer
|
|
*/
|
|
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
|
NULL,
|
|
total_length);
|
|
if (memory == NULL)
|
|
return;
|
|
|
|
packet_address = memory -> GetPointer ();
|
|
packet_address += Lower_Layer_Prepend;
|
|
|
|
*(packet_address++) = Q931_PROTOCOL_DISCRIMINATOR;
|
|
*(packet_address++) = 1;
|
|
*(packet_address++) = (UChar) Call_Reference;
|
|
*(packet_address++) = CONNECT_ACKNOWLEDGE;
|
|
|
|
Lower_Layer -> DataRequest (
|
|
0,
|
|
memory,
|
|
&bytes_accepted);
|
|
if (bytes_accepted == total_length)
|
|
{
|
|
State = CALL_ESTABLISHED;
|
|
Packet_Pending = NO_PACKET;
|
|
}
|
|
Data_Request_Memory_Manager -> FreeMemory (memory);
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::SendReleaseComplete (void);
|
|
*
|
|
* Functional Description
|
|
* This function attempts to send out a RELEASE COMPLETE packet
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* If this function is able to send a RELEASE COMPLETE packet to the lower
|
|
* layer, it sets the Packet_Pending variable to NO_PACKET
|
|
*
|
|
* Caveats
|
|
* None
|
|
*
|
|
*/
|
|
void SCFCall::SendReleaseComplete (void)
|
|
{
|
|
TRACE_OUT(("SCFCall::SendReleaseComplete"));
|
|
|
|
LPBYTE packet_address;
|
|
ULONG bytes_accepted;
|
|
USHORT total_length;
|
|
PMemory memory;
|
|
|
|
total_length = RELEASE_COMPLETE_PACKET_SIZE + Lower_Layer_Prepend +
|
|
Lower_Layer_Append;
|
|
/*
|
|
** Prepare the command and send it to the lower layer
|
|
*/
|
|
memory = Data_Request_Memory_Manager -> AllocateMemory (
|
|
NULL,
|
|
total_length);
|
|
if (memory == NULL)
|
|
return;
|
|
|
|
packet_address = memory -> GetPointer ();
|
|
packet_address += Lower_Layer_Prepend;
|
|
|
|
*(packet_address++) = Q931_PROTOCOL_DISCRIMINATOR;
|
|
*(packet_address++) = 1;
|
|
if (Link_Originator)
|
|
*(packet_address++) = (UChar) Call_Reference;
|
|
else
|
|
*(packet_address++) = 0x80 | Call_Reference;
|
|
*(packet_address++) = RELEASE_COMPLETE;
|
|
|
|
|
|
/*
|
|
** Append the CAUSE for the link breakup
|
|
*/
|
|
*(packet_address++) = CAUSE;
|
|
*(packet_address++) = 2;
|
|
*(packet_address++) = EXTENSION;
|
|
*(packet_address++) = EXTENSION | Release_Cause;
|
|
|
|
Lower_Layer -> DataRequest (
|
|
0,
|
|
memory,
|
|
&bytes_accepted);
|
|
if (bytes_accepted == total_length)
|
|
{
|
|
State = NOT_CONNECTED;
|
|
Packet_Pending = NO_PACKET;
|
|
}
|
|
Data_Request_Memory_Manager -> FreeMemory (memory);
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::StartTimerT303 (void);
|
|
*
|
|
* Functional Description
|
|
* This function Starts the T303 Timer. This is started when we send
|
|
* out the SETUP packet. It is stopped when we receive a CONNECT
|
|
* packet. If it expires we terminate the link.
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*
|
|
*/
|
|
void SCFCall::StartTimerT303 (void)
|
|
{
|
|
TRACE_OUT(("SCFCall::StartTimerT303"));
|
|
|
|
if (T303_Active)
|
|
StopTimerT303 ();
|
|
|
|
T303_Handle = g_pSystemTimer->CreateTimerEvent(
|
|
T303_Timeout,
|
|
TIMER_EVENT_ONE_SHOT,
|
|
this,
|
|
(PTimerFunction) &SCFCall::T303Timeout);
|
|
|
|
T303_Active = TRUE;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::StopTimerT303 (void);
|
|
*
|
|
* Functional Description
|
|
* This function stops the T303 Timer. This is called when we receive
|
|
* the CONNECT packet. As a result, we stop the timer.
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*
|
|
*/
|
|
void SCFCall::StopTimerT303 (void)
|
|
{
|
|
TRACE_OUT(("SCFCall::StopTimerT303"));
|
|
|
|
if (T303_Active)
|
|
{
|
|
g_pSystemTimer->DeleteTimerEvent(T303_Handle);
|
|
T303_Active = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::T303Timeout (
|
|
* TimerEventHandle);
|
|
*
|
|
* Functional Description
|
|
* This function is called by the System timer when the T303 timeout
|
|
* expires. As a result, we terminate the link.
|
|
*
|
|
* Formal Parameters
|
|
* None used
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*
|
|
*/
|
|
void SCFCall::T303Timeout (
|
|
TimerEventHandle)
|
|
{
|
|
TRACE_OUT(("SCFCall: T303Timeout"));
|
|
|
|
if (T303_Count >= 1)
|
|
State = NOT_CONNECTED;
|
|
|
|
T303_Count++;
|
|
|
|
Packet_Pending = RELEASE_COMPLETE;
|
|
Release_Cause = NORMAL_USER_DISCONNECT;
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::StartTimerT313 (void);
|
|
*
|
|
* Functional Description
|
|
* This function Starts the T313 Timer. This is started when we send
|
|
* out the CONNECT packet. It is stopped when we receive a CONNECT ACK
|
|
* packet. If it expires we terminate the link.
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*
|
|
*/
|
|
void SCFCall::StartTimerT313 (void)
|
|
{
|
|
TRACE_OUT(("SCFCall: StartTimerT313"));
|
|
|
|
if (T313_Active)
|
|
StopTimerT313 ();
|
|
|
|
T313_Handle = g_pSystemTimer->CreateTimerEvent(
|
|
T313_Timeout,
|
|
TIMER_EVENT_ONE_SHOT,
|
|
this,
|
|
(PTimerFunction) &SCFCall::T313Timeout);
|
|
|
|
T313_Active = TRUE;
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::StopTimerT313 (void);
|
|
*
|
|
* Functional Description
|
|
* This function stops the T313 Timer. This is called when we receive
|
|
* the CONNECT ACK packet. As a result, we stop the timer.
|
|
*
|
|
* Formal Parameters
|
|
* None
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*
|
|
*/
|
|
void SCFCall::StopTimerT313 (void)
|
|
{
|
|
TRACE_OUT(("SCFCall: StopTimerT313"));
|
|
|
|
if (T313_Active)
|
|
{
|
|
g_pSystemTimer->DeleteTimerEvent(T313_Handle);
|
|
T313_Active = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* void SCFCall::T313Timeout (
|
|
* TimerEventHandle);
|
|
*
|
|
* Functional Description
|
|
* This function is called by the System timer when the T313 timeout
|
|
* expires. As a result, we terminate the link.
|
|
*
|
|
* Formal Parameters
|
|
* None used
|
|
*
|
|
* Return Value
|
|
* None
|
|
*
|
|
* Side Effects
|
|
* None
|
|
*
|
|
* Caveats
|
|
* None
|
|
*
|
|
*/
|
|
void SCFCall::T313Timeout (
|
|
TimerEventHandle)
|
|
{
|
|
TRACE_OUT(("SCFCall: T313Timeout"));
|
|
|
|
State = NOT_CONNECTED;
|
|
Packet_Pending = RELEASE_COMPLETE;
|
|
Release_Cause = NORMAL_USER_DISCONNECT;
|
|
}
|