|
|
#include "precomp.h"
DEBUG_FILEZONE(ZONE_T120_T123PSTN);
/* SCF.cpp
* * Copyright (c) 1994-1995 by DataBeam Corporation, Lexington, KY * * Abstract: * This is the implementation file for the CLayerSCF class * * Private Instance Variables: * Remote_Call_Reference - List of active SCFCalls initiated by the * remote site * Call_Reference - List of active SCFCalls initiated locally * DLCI_List - This list matches DLCIs to SCFCalls, its * only real purpose is for DisconnectRequest() * Message_List - List of OwnerCallback messages that can't * be processed immediately. * m_pT123 - Address of owner object * m_pQ922 - Address of lower layer * m_nMsgBase - Message base passed in by owner. Used in * OwnerCallback * Identifier - Identifier passed to lower layer * Link_Originator - TRUE if we initiated the connection * Maximum_Packet_Size - Maximum packet size transmittable * DataLink_Struct - Address of structure holding DataLink parms * Data_Request_Memory_Manager - Address of memory manager * Lower_Layer_Prepend - Holds number of bytes prepended to packet * by the lower layer * Lower_Layer_Append - Holds number of bytes appended to packet by * the lower layer * Call_Reference_Base - This value holds the next call reference * number. * * Caveats: * None. * * Authors: * James W. Lawwill */#include "scf.h"
/*
* CLayerSCF::CLayerSCF ( * PTransportResources transport_resources, * IObject * owner_object, * IProtocolLayer * lower_layer, * USHORT message_base, * USHORT identifier, * BOOL link_originator, * PChar config_file) * * Public * * Functional Description: * This is the CLayerSCF constructor. This routine initializes all * variables and allocates buffer space. */CLayerSCF::CLayerSCF( T123 *owner_object, CLayerQ922 *pQ922, // lower layer
USHORT message_base, USHORT identifier, BOOL link_originator, PDataLinkParameters datalink_struct, PMemoryManager data_request_memory_manager, BOOL * initialized): Remote_Call_Reference (TRANSPORT_HASHING_BUCKETS), Call_Reference (TRANSPORT_HASHING_BUCKETS), DLCI_List (TRANSPORT_HASHING_BUCKETS), m_pT123(owner_object), m_nMsgBase(message_base), m_pQ922(pQ922){ ProtocolLayerError error;
TRACE_OUT(("CLayerSCF::CLayerSCF"));
Link_Originator = (USHORT)link_originator; Identifier = identifier; Data_Request_Memory_Manager = data_request_memory_manager; Call_Reference_Base = 1; *initialized = TRUE;
/*
** Fill in the DataLink_Struct with the proposed values and the default ** values */ 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; DataLink_Struct.t200 = datalink_struct -> t200; DataLink_Struct.default_t200 = datalink_struct -> default_t200;
/*
** Find the maximum packet size */ m_pQ922->GetParameters( &Maximum_Packet_Size, &Lower_Layer_Prepend, &Lower_Layer_Append);
/*
** Register with the lower layer */ error = m_pQ922->RegisterHigherLayer( Identifier, Data_Request_Memory_Manager, (IProtocolLayer *) this);
if (error != PROTOCOL_LAYER_NO_ERROR) { ERROR_OUT(("Multiplexer: constructor: Error registering with lower layer")); *initialized = FALSE; }}
/*
* CLayerSCF::~CLayerSCF (void) * * Public * * Functional Description: * This is the CLayerSCF destructor. This routine cleans up everything. */CLayerSCF::~CLayerSCF (void){ TRACE_OUT(("CLayerSCF::~CLayerSCF"));
PMessageStruct message; PSCFCall lpSCFCall;
m_pQ922->RemoveHigherLayer(Identifier);
/*
** Delete all locally initiated calls */ Call_Reference.reset(); while (Call_Reference.iterate ((PDWORD_PTR) &lpSCFCall)) { delete lpSCFCall; }
/*
** Delete all remotely initiated calls */ Remote_Call_Reference.reset(); while (Remote_Call_Reference.iterate ((PDWORD_PTR) &lpSCFCall)) { delete lpSCFCall; }
/*
** Delete all passive owner callbacks */ Message_List.reset(); while (Message_List.iterate ((PDWORD_PTR) &message)) { delete message; }}
/*
* CLayerSCF::ConnectRequest ( * DLCI dlci, * TransportPriority priority) * * Public * * Functional Description: * This function initiates a connection with the remote site. As a result, * we will create a SCFCall and tell it to initiate a connection. */SCFError CLayerSCF::ConnectRequest ( DLCI dlci, TransportPriority priority)
{ TRACE_OUT(("CLayerSCF::ConnectRequest"));
BOOL initialized; CallReference call_reference; SCFError return_value = SCF_NO_ERROR; PSCFCall lpSCFCall;
/*
** Get the next valid local call reference value. */ call_reference = GetNextCallReference ();
if (call_reference == 0) return (SCF_CONNECTION_FULL);
/*
** Create an SCFCall object to handle this call reference */ DBG_SAVE_FILE_LINE lpSCFCall= new SCFCall(this, m_pQ922, call_reference << 8, &DataLink_Struct, Data_Request_Memory_Manager, &initialized);
if (lpSCFCall != NULL) { if (initialized) { Call_Reference.insert ((DWORD_PTR) call_reference, (DWORD_PTR) lpSCFCall); /*
** Register the DLCI and the call reference */ DLCI_List.insert ((DWORD_PTR) dlci, (DWORD_PTR) lpSCFCall);
lpSCFCall->ConnectRequest (call_reference, dlci, priority); } else { delete lpSCFCall; return_value = SCF_MEMORY_ALLOCATION_ERROR; } } else { return_value = SCF_MEMORY_ALLOCATION_ERROR; }
return (return_value);}
/*
* CLayerSCF::ConnectResponse ( * CallReference call_reference, * DLCI dlci, * BOOL valid_dlci) * * Public * * Functional Description: * This is the CLayerSCF destructor. This routine cleans up everything. */SCFError CLayerSCF::ConnectResponse ( CallReference call_reference, DLCI dlci, BOOL valid_dlci)
{ TRACE_OUT(("CLayerSCF::ConnectResponse"));
PSCFCall lpSCFCall = NULL;
if (valid_dlci) { if (Remote_Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &lpSCFCall)) DLCI_List.insert ((DWORD_PTR) dlci, (DWORD_PTR) lpSCFCall); }
if(NULL != lpSCFCall) { lpSCFCall->ConnectResponse (valid_dlci); return (SCF_NO_ERROR); } return (SCF_NO_SUCH_DLCI);
}
/*
* SCFError CLayerSCF::DisconnectRequest ( * DLCI dlci) * * Public * * Functional Description: * This function calls the SCFCall associated with the DLCI and starts * the disconnect operation */SCFError CLayerSCF::DisconnectRequest ( DLCI dlci)
{ TRACE_OUT(("CLayerSCF::DisconnectRequest"));
PSCFCall lpSCFCall;
if (DLCI_List.find ((DWORD_PTR) dlci, (PDWORD_PTR) &lpSCFCall) == FALSE) return (SCF_NO_SUCH_DLCI);
lpSCFCall->DisconnectRequest ();
return (SCF_NO_ERROR);}
/*
* SCFError CLayerSCF::DataIndication ( * LPBYTE packet_address, * ULONG buffer_size, * PULong packet_length) * * Public * * Functional Description: * This function is called by the lower layer when it has received a * packet for us to process. */ProtocolLayerError CLayerSCF::DataIndication ( LPBYTE packet_address, ULONG packet_length, PULong bytes_accepted){ TRACE_OUT(("CLayerSCF::DataIndication"));
BOOL legal_packet; CallReference call_reference; USHORT length_call_reference; USHORT message_type; PSCFCall call; USHORT remainder_length; USHORT local; BOOL initialized;
remainder_length = (USHORT) packet_length; *bytes_accepted = packet_length;
if (*(packet_address+PROTOCOL_DISCRIMINATOR) != Q931_PROTOCOL_DISCRIMINATOR) return (PROTOCOL_LAYER_NO_ERROR);
/*
** Get the call reference value */ call_reference = *(packet_address + CALL_REFERENCE_VALUE); if (call_reference == 0) { ERROR_OUT(("CLayerSCF: DataIndication: illegal call reference value = 0")); return (PROTOCOL_LAYER_NO_ERROR); }
length_call_reference = *(packet_address + LENGTH_CALL_REFERENCE); packet_address += CALL_REFERENCE_VALUE + length_call_reference; remainder_length -= (CALL_REFERENCE_VALUE + length_call_reference);
/*
** Get the message type */ message_type = *(packet_address++); remainder_length--;
switch (message_type) { case SETUP: /*
** If the call reference is already active, return error */ if (Remote_Call_Reference.find ((DWORD) call_reference)) { TRACE_OUT(("CLayerSCF: DataIndication: SETUP: call reference is already active")); break; }
if ((call_reference & CALL_REFERENCE_ORIGINATOR) == 1) { TRACE_OUT(("CLayerSCF: DataIndication: SETUP: call reference Originator bit is set incorrectly")); break; }
/*
** This is a new call reference, create a new SCFCall to handle ** the call. Since the remote site initiated the call, put this ** reference in the Remote array */ call= new SCFCall(this, m_pQ922, (call_reference << 8), &DataLink_Struct, Data_Request_Memory_Manager, &initialized);
if (call != NULL) { if (initialized) {
Remote_Call_Reference.insert ((DWORD_PTR) call_reference, (DWORD_PTR) call); /*
** Allow the call to process the SETUP command */ legal_packet = call->ProcessSetup (call_reference, packet_address, remainder_length);
/*
** If the packet was illegal, remove the reference */ if (legal_packet == FALSE) { delete call; Remote_Call_Reference.remove ((DWORD) call_reference); } } else { delete call; } } break;
case CONNECT: /*
** The call originator bit must be set to signify that we are ** the originators of the call */ if ((call_reference & CALL_REFERENCE_ORIGINATOR) == 0) { TRACE_OUT(("CLayerSCF: DataIndication: CONNECT: call reference Originator bit is set incorrectly")); break; }
/*
** If the call reference is not already active, return error */ call_reference &= CALL_ORIGINATOR_MASK; if (Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &call) == FALSE) { TRACE_OUT(("CLayerSCF: DataIndication: CONNECT: call reference is not already active = %x", call_reference)); break; }
call->ProcessConnect (packet_address, remainder_length); break;
case CONNECT_ACKNOWLEDGE: /*
** If the call reference is already active, return error */ if (Remote_Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &call) == FALSE) { TRACE_OUT(("CLayerSCF: DataIndication: CONNECT_ACK: call reference is not active")); break; }
/*
** The call originator bit should NOT be set */ if ((call_reference & CALL_REFERENCE_ORIGINATOR) == 1) { TRACE_OUT(("CLayerSCF: DataIndication: CONNECT_ACK: call reference Originator bit is set incorrectly")); break; }
call->ProcessConnectAcknowledge (packet_address, remainder_length); break;
case RELEASE_COMPLETE: local = call_reference & CALL_REFERENCE_ORIGINATOR; call_reference &= CALL_ORIGINATOR_MASK;
/*
** If the call is local, check the Call_Reference list for validity */ if (local) { if (Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &call) == FALSE) { TRACE_OUT(("CLayerSCF: DataIndication: RELEASE_COMPLETE: call reference is not already active")); break; } } else { /*
** If the call is remote, check the Call_Reference list for ** validity */ if (Remote_Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &call) == FALSE) { TRACE_OUT(("CLayerSCF: DataIndication: RELEASE_COMPLETE: call reference is not already active")); break; } }
call -> ProcessReleaseComplete (packet_address, remainder_length); ProcessMessages (); break;
case DISCONNECT: case RELEASE: case STATUS: case STATUS_ENQUIRY: TRACE_OUT(("CLayerSCF:DataIndication: Illegal command received = %x", message_type));
local = call_reference & CALL_REFERENCE_ORIGINATOR; call_reference &= CALL_ORIGINATOR_MASK;
/*
** If the call is local, check the Call_Reference list for validity */ if (local) { if (Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &call) == FALSE) break; } else { /*
** If the call is remote, check the Call_Reference list for ** validity */ if (Remote_Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &call) == FALSE) break; }
call -> DisconnectRequest (); break;
default: ERROR_OUT(("CLayerSCF:DataIndication: Unrecognized command received = %x", message_type)); break; } return (PROTOCOL_LAYER_NO_ERROR);}
/*
* ProtocolLayerError CLayerSCF::PollTransmitter ( * ULONG, * USHORT data_to_transmit, * USHORT * pending_data, * USHORT *) * * Public * * Functional Description: * This function should be called frequently to allow the SCF calls to * transmit packets. */ProtocolLayerError CLayerSCF::PollTransmitter ( ULONG_PTR, USHORT data_to_transmit, USHORT * pending_data, USHORT *){ // TRACE_OUT(("CLayerSCF::PollTransmitter"));
USHORT local_pending_data; PSCFCall lpSCFCall;
*pending_data = 0;
/*
** Go through each of the locally originated calls and attempt to transmit ** data. */ Call_Reference.reset(); while (Call_Reference.iterate ((PDWORD_PTR) &lpSCFCall)) { lpSCFCall->PollTransmitter (data_to_transmit, &local_pending_data); *pending_data |= local_pending_data; }
/*
** Go through each of the remotely originated calls and attempt to transmit ** data. */ Remote_Call_Reference.reset(); while (Remote_Call_Reference.iterate ((PDWORD_PTR) &lpSCFCall)) { lpSCFCall-> PollTransmitter (data_to_transmit, &local_pending_data); *pending_data |= local_pending_data; }
ProcessMessages ();
return (PROTOCOL_LAYER_NO_ERROR);}
/*
* SCFError CLayerSCF::DataRequest ( * ULONG, * LPBYTE, * ULONG, * PULong) * * Public * * Functional Description: * This function can not be called. This layer does not permit data * requests from higher layers. */ProtocolLayerError CLayerSCF::DataRequest ( ULONG_PTR, LPBYTE, ULONG, PULong){ return (PROTOCOL_LAYER_ERROR);}
/*
* SCFError CLayerSCF::DataRequest ( * ULONG, * PMemory, * USHORT *) * * Public * * Functional Description: * This function can not be called. This layer does not permit data * requests from higher layers. */ProtocolLayerError CLayerSCF::DataRequest ( ULONG_PTR, PMemory, PULong){ return (PROTOCOL_LAYER_ERROR);}
/*
* void CLayerSCF::PollReceiver ( * ULONG) * * Public * * Functional Description * This function only checks its passive callback list. If this function * had a higher layer that it was passing data too, it would do that. But * since it has no higher layer, it doesn't do much. */ProtocolLayerError CLayerSCF::PollReceiver(void){ ProcessMessages ();
return (PROTOCOL_LAYER_NO_ERROR);}
/*
* CallReference CLayerSCF::GetNextCallReference () * * Functional Description * This function searches the local call reference list for a valid call * reference number. If it can not find one, it returns 0. Valid call * references are 1-127. * * Formal Parameters * None * * Return Value * Call reference value * * Side Effects * None * * Caveats * None */USHORT CLayerSCF::GetNextCallReference (){ USHORT call_reference;
if (Call_Reference.entries() == 127) return (0);
call_reference = Call_Reference_Base; Call_Reference_Base++; if (Call_Reference_Base == 128) Call_Reference_Base = 1;
while (Call_Reference.find ((DWORD) call_reference)) { call_reference++; if (call_reference == 128) call_reference = 1; }
return (call_reference);}
/*
* ULONG CLayerSCF::OwnerCallback ( * USHORT message, * ULONG parameter1, * ULONG parameter2, * PVoid parameter3) * * Functional Description * This function is called by the SCFCall objects when they need to * communicate a message to us. If the message can not be processed * immediately, it is saved in a message structure and processed at a * later time. * * Formal Parameters * None * * Return Value * Message dependent * * Side Effects * None * * Caveats * None */ULONG CLayerSCF::OwnerCallback( ULONG message, void *parameter1, void *parameter2, void *parameter3){ TRACE_OUT(("CLayerSCF::OwnerCallback"));
ULONG actual_message; CallReference call_reference; PMessageStruct passive_message; PNetworkConnectStruct connect_struct; PSCFCall lpSCFCall;
/*
** The upper byte of the message is the call reference message that it ** represents */ call_reference = (CallReference) (message >> 8); actual_message = message & 0xff;
switch (actual_message) { case NETWORK_CONNECT_CONFIRM:
/*
** A CONNECT_CONFIRM message is returned by the SCFCall when a call ** that we originated, has been established. We register the ** SCFCall with the DLCI and call the owner object. */ connect_struct = (PNetworkConnectStruct) parameter3; connect_struct -> call_reference = call_reference;
if (Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &lpSCFCall)) { DLCI_List.insert ((DWORD_PTR) connect_struct->dlci, (DWORD_PTR) lpSCFCall); }
m_pT123->OwnerCallback(m_nMsgBase + actual_message, 0, 0, parameter3); break;
case NETWORK_CONNECT_INDICATION: /*
** A CONNECT_INDICATION message is returned by the SCFCall when the ** remote SCF wants to create a new call. We will call the owner ** of this object to see if he will accept the DLCI requested. */ connect_struct = (PNetworkConnectStruct) parameter3; connect_struct -> call_reference = call_reference;
m_pT123->OwnerCallback(m_nMsgBase + actual_message, 0, 0, parameter3); break;
case NETWORK_DISCONNECT_INDICATION: /*
** This message is received from the SCFCall when one side wants ** to terminate the call. We treat this message differently than ** the other messages because it involves the deletion of an ** SCFCall object. Don't forget, if we delete the object and then ** return to it at the end of this procedure, a GPF could occur. */ DBG_SAVE_FILE_LINE passive_message = new MessageStruct; if (NULL != passive_message) { passive_message -> message = message; passive_message -> parameter1 = parameter1; passive_message -> parameter2 = parameter2; passive_message -> parameter3 = parameter3; Message_List.append ((DWORD_PTR) passive_message); } else { ERROR_OUT(("CLayerSCF::OwnerCallback: cannot allocate MessageStruct")); } break;
default: ERROR_OUT(("CLayerSCF: Illegal message: %x", actual_message)); break; } return (0);}
/*
* ProtocolLayerError CLayerSCF::GetParameters ( * USHORT, * USHORT *, * USHORT *, * USHORT *) * * Public * * Functional Description * This function is not valid in this layer. It must exist because this * class inherits from inherits from ProtocolLayer and it is a pure virtual * function. */ProtocolLayerError CLayerSCF::GetParameters ( USHORT *, USHORT *, USHORT *){ return (PROTOCOL_LAYER_REGISTRATION_ERROR);}
/*
* ProtocolLayerError CLayerSCF::RegisterHigherLayer ( * USHORT, * PMemoryManager, * IProtocolLayer *) * * Public * * Functional Description * This function is not valid in this layer. It must exist because this * class inherits from inherits from ProtocolLayer and it is a pure virtual * function. */ProtocolLayerError CLayerSCF::RegisterHigherLayer ( ULONG_PTR, PMemoryManager, IProtocolLayer *){ return (PROTOCOL_LAYER_REGISTRATION_ERROR);}
/*
* ProtocolLayerError CLayerSCF::RemoveHigherLayer ( * USHORT) * * Public * * Functional Description * This function is not valid in this layer. It must exist because this * class inherits from inherits from ProtocolLayer and it is a pure virtual * function. */ProtocolLayerError CLayerSCF::RemoveHigherLayer ( ULONG_PTR){ return (PROTOCOL_LAYER_REGISTRATION_ERROR);}
/*
* void CLayerSCF::ProcessMessages () * * Functional Description * This function is called periodically to check its passive messages. * Passive messages occur when the SCF gets a callback but can't process * it immediately. Therefore, it puts the message and its parameters in * a structure and saves the message for later. * * Formal Parameters * None * * Return Value * Message dependent * * Side Effects * None * * Caveats * None */void CLayerSCF::ProcessMessages (){ // TRACE_OUT(("CLayerSCF::ProcessMessages"));
PMessageStruct message; CallReference call_reference; ULONG actual_message; USHORT call_originator; USHORT cause; DLCI dlci; BOOL call_reference_valid; void *parameter1; void *parameter2; PSCFCall lpSCFCall;
/*
** Go thru each message in the list */ while (Message_List.isEmpty() == FALSE) { /*
** Remote the first message from the list */ message = (PMessageStruct) Message_List.get ();
call_reference = (CallReference) ((message -> message) >> 8); actual_message = (message -> message) & 0xff; parameter1 = message -> parameter1; parameter2 = message -> parameter2;
switch (actual_message) { case NETWORK_DISCONNECT_INDICATION: /*
** This message is received from the SCFCall when one side ** wants to terminate the call. We treat this message ** differently than the other messages because it involves the ** deletion of an SCFCall object. */ dlci = (DLCI) parameter1; call_originator = (USHORT) (((ULONG_PTR) parameter2) >> 16); cause = (USHORT) ((ULONG_PTR) parameter2) & 0xffff;
/*
** dlci is 0 if the SCFCall was never assigned a DLCI by the ** remote site. */ if (dlci != 0) DLCI_List.remove ((DWORD) dlci);
/*
** If the SCFCall was the call originator, its reference is ** in Call_Reference, otherwise it is in Remote_Call_Reference. ** ** Check the Call_Reference list to make sure that the ** call_reference is valid. The way passive owner callbacks ** work, it is possible to receive a DISCONNECT for a callback ** that was already disconnected. */ call_reference_valid = FALSE; if (call_originator) { if (Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &lpSCFCall)) { delete lpSCFCall; Call_Reference.remove ((DWORD) call_reference); call_reference_valid = TRUE; } } else { if (Remote_Call_Reference.find ((DWORD_PTR) call_reference, (PDWORD_PTR) &lpSCFCall)) { delete lpSCFCall; Remote_Call_Reference.remove ((DWORD_PTR) call_reference); call_reference_valid = TRUE; } }
if (call_reference_valid) { /*
** If the cause of the disconnect was because the Requested ** channel was unavailable, we will tell the owner of this ** layer to retry the connection. */ if (cause == REQUESTED_CHANNEL_UNAVAILABLE) { parameter2 = (void *) ((((ULONG_PTR) call_originator) << 16) | TRUE); } else { parameter2 = (void *) ((((ULONG_PTR) call_originator) << 16) | FALSE); }
/*
** Let the owner of this object know that a disconnect has ** occured. */ m_pT123->OwnerCallback(m_nMsgBase + NETWORK_DISCONNECT_INDICATION, parameter1, parameter2); } break; }
/*
** Delete the message structure */ delete message; }}
|
