| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Copyright (c) 2000-2018 Ericsson Telecom AB |
| // |
| // All rights reserved. This program and the accompanying materials |
| // are made available under the terms of the Eclipse Public License v2.0 |
| // which accompanies this distribution, and is available at |
| // https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // File: EPTF_HTTP_Transport_Definitions.ttcn |
| // Rev: <RnXnn> |
| // Prodnr: CNL 113 618 |
| // Updated: 2014-03-21 |
| // Contact: http://ttcn.ericsson.se |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////// |
| // Module: EPTF_HTTP_Transport_Definitions |
| // |
| // Purpose: |
| // This module contains the definitions to the HTTP Transport |
| // |
| // Module Parameters: |
| // tsp_EPTF_HTTP_Transport_loggingComponentMask - *charstring* - logging component mask id |
| // tsp_EPTF_HTTP_Transport_loggingEnable - *boolean* - enable/disable the transport logging |
| // |
| // Module depends on: |
| // <EPTF_HTTP_Definitions> |
| // |
| // <EPTF_CLL_Common_Definitions> |
| // |
| // <EPTF_CLL_Base_Definitions> |
| // |
| // <EPTF_CLL_LGenBase_Definitions> |
| // |
| // <EPTF_HTTP_Logger_Definitions> |
| // |
| // <EPTF_CLL_FBQ_Definitions> |
| // |
| // <EPTF_CLL_TransportDefinitions> |
| // |
| // <EPTF_CLL_TransportMessageBufferManager_Definitions> |
| // |
| // <EPTF_CLL_Logging_Definitions> |
| // |
| // <EPTF_CLL_TransportCommPortIPL4_Definitions> |
| // |
| // <IPL4asp_Types> |
| // |
| // <TCCMaths_GenericTypes> |
| // |
| // Current Owner: |
| // EAKOPER |
| // |
| // Last Review Date: |
| // 2009-08-10 |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////// |
| |
| module EPTF_HTTP_Transport_Definitions { |
| |
| //============================================================================= |
| // Imports |
| //============================================================================= |
| import from EPTF_CLL_Common_Definitions all; |
| import from EPTF_CLL_Base_Definitions all; |
| //import from EPTF_CLL_LGenBase_Definitions all; |
| import from EPTF_CLL_FBQ_Definitions all; |
| import from EPTF_CLL_TransportRouting_Definitions all; |
| import from EPTF_CLL_TransportMessageBufferManager_Definitions all; |
| import from EPTF_CLL_Logging_Definitions all; |
| import from EPTF_CLL_TransportCommPortIPL4_Definitions all; |
| import from EPTF_CLL_HashMap_Definitions all; |
| |
| import from EPTF_HTTP_Definitions all; |
| |
| import from IPL4asp_Types all; |
| |
| import from TCCMaths_GenericTypes all; |
| |
| //============================================================================= |
| // Module parameters |
| //============================================================================= |
| |
| modulepar charstring tsp_EPTF_HTTP_Transport_loggingComponentMask := "EPTF_HTTP_Transport"; |
| modulepar boolean tsp_EPTF_HTTP_Transport_loggingEnable := false; |
| modulepar boolean tsp_EPTF_HTTP_Transport_bufferLogEnable := false; |
| modulepar boolean tsp_EPTF_HTTP_Transport_messageBufferEnable := false; |
| modulepar integer tsp_EPTF_HTTP_bufferSize := 100; |
| |
| //============================================================================= |
| // Data types |
| //============================================================================= |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Transport |
| // |
| // Purpose: |
| // The definitions of the EPTF HTTP Transport |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Transport { |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_ConnectionState |
| // |
| // Purpose: |
| // HTTP states |
| // |
| // Elements: |
| // IDLE(0), |
| // OPENED(1) |
| // HALFCLOSED(2) |
| // CLOSED(3) |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type enumerated EPTF_HTTP_Transport_ConnectionState { |
| IDLE, |
| OPENED, |
| HALFCLOSED, |
| CLOSED |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_PortType |
| // |
| // Purpose: |
| // Port type |
| // |
| // Elements: |
| // LISTENING(0) - |
| // INCOMING_PORT(1) - |
| // OUTGOING_PORT(2) - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type enumerated EPTF_HTTP_Transport_PortType{ |
| LISTENING_PORT, |
| INCOMING_PORT, |
| OUTGOING_PORT |
| } |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_GroupOperation_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // add/remove ports to/from a port group |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_GroupOperation_FT( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_SelectPort_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // select a port for sending within a port group |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_SelectPort_FT( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return integer; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_SessionOperation_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // provide a session operation on a group |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // pl_sessionId - *in* *integer* - session id |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_SessionOperation_FT( |
| in integer pl_group, |
| in integer pl_sessionId) |
| runs on EPTF_HTTP_LocalTransport_CT; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_PortOperation_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // provide a session operation on a group |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // pl_portId - *in* *integer* - port id |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_PortOperation_FT( |
| in integer pl_group, |
| in integer pl_portId) |
| runs on EPTF_HTTP_LocalTransport_CT; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_GetGroupAndPort_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // acquire port group and port index for a connection id |
| // |
| // Elements: |
| // pl_connId - *in* *integer* -connection id |
| // pl_group - *inout* *integer* - port group index |
| // pl_port - *inout* *integer* - port index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_GetGroupAndPort_FT( |
| in integer pl_connId, |
| inout integer pl_group, |
| inout integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_GetGroup_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // acquire port group ndex for a connection id |
| // |
| // Elements: |
| // pl_connId - *in* *integer* -connection id |
| // pl_groupId - *inout* *integer* - port group index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_GetGroup_FT( |
| in integer pl_connId, |
| inout integer pl_groupId) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_SendFunction_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // send an encoded message over a port group |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // pl_sessionId - *in* *integer* - session id for sending |
| // pl_msg - *in* *octetstring* - message to send |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_SendFunction_FT( |
| in integer pl_group, |
| in integer pl_sessionId, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_SendResponse_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // send an encoded response over a port group |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // pl_portId - *in* *integer* - port id for sending |
| // pl_seqNum - *in* *integer* - sequence number of the response |
| // pl_msg - *in* *octetstring* - response to send |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_SendResponse_FT( |
| in integer pl_group, |
| in integer pl_portId, |
| in integer pl_seqNum, |
| in octetstring pl_msg |
| ) |
| runs on EPTF_HTTP_LocalTransport_CT; |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_OpenConnection_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // open port / port group connection |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_OpenConnection_FT( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_CloseConnection_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // cloase port / port group connection |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_CloseConnection_FT( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_ReceiveMessage_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // handle a received message |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // pl_port - *in* *integer* - port index |
| // pl_msg - *in* *octetstring* - message to send |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_ReceiveMessage_FT( |
| in integer pl_group, |
| in integer pl_port, |
| in octetstring pl_msg) |
| runs on EPTF_HTTP_LocalTransport_CT; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_ReceiveEvent_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // handle a received message |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // pl_port - *in* *integer* - port index |
| // pl_type - *in* *integer* - event type |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_ReceiveEvent_FT ( |
| in integer pl_group, |
| in integer pl_port, |
| in integer pl_type) |
| runs on EPTF_HTTP_LocalTransport_CT; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Listen_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback function for |
| // opening a listen port |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // |
| // Return value: |
| // boolean - open result |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_Listen_FT( |
| in integer pl_group) |
| runs on EPTF_HTTP_LocalTransport_CT return integer; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_CreateIncomingConn_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // store an incoming connection |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_CreateIncomingConn_FT( |
| in integer pl_group, |
| in ConnectionOpenedEvent pl_connOpened, |
| inout integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT return boolean; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_RemoveIncomingConn_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback functions to |
| // remove an incoming connection |
| // |
| // Elements: |
| // pl_group - *in* *integer* - port group index |
| // pl_port - *in* *integer* - port index in the group |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Transport_RemoveIncomingConn_FT( |
| in integer pl_group, |
| in integer pl_port) |
| runs on EPTF_HTTP_LocalTransport_CT; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_UserFunctions |
| // |
| // Purpose: |
| // Record to store function referencies for a port group |
| // |
| // Elements: |
| // addPort - <EPTF_HTTP_Transport_GroupOperation_FT> *optional* - add port function ref |
| // removePort - <EPTF_HTTP_Transport_GroupOperation_FT> *optional* - remove port function ref |
| // selectPort - <EPTF_HTTP_Transport_SelectPort_FT> *optional* - select port function ref |
| // sendMessage - <EPTF_HTTP_Transport_SendFunction_FT> *optional* - send message function ref |
| // closePortOfUser - <EPTF_HTTP_Transport_SessionOperation_FT> - close port of user function ref |
| // freePortOfUser - <EPTF_HTTP_Transport_SessionOperation_FT> - free port of user function ref |
| // openPort - <EPTF_HTTP_Transport_OpenConnection_FT> *optional* - open port function ref |
| // closeConnection - <EPTF_HTTP_Transport_CloseConnection_FT> *optional* - close port function ref |
| // halfClosePort - <EPTF_HTTP_Transport_CloseConnection_FT> *optional* - half close port function ref |
| // receiveMessage - <EPTF_HTTP_Transport_ReceiveMessage_FT> *optional* - receive message function ref |
| // receiveEvent - <EPTF_HTTP_Transport_ReceiveEvent_FT> *optional* - receive event function ref |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_UserFunctions |
| { |
| EPTF_HTTP_Transport_GroupOperation_FT addPort optional, |
| EPTF_HTTP_Transport_GroupOperation_FT removePort optional, |
| EPTF_HTTP_Transport_SelectPort_FT selectPort optional, |
| EPTF_HTTP_Transport_SendFunction_FT sendMessage optional, |
| EPTF_HTTP_Transport_SessionOperation_FT closePortOfUser optional, |
| EPTF_HTTP_Transport_SessionOperation_FT freePortOfUser optional, |
| EPTF_HTTP_Transport_OpenConnection_FT openPort optional, |
| EPTF_HTTP_Transport_CloseConnection_FT closeConnection optional, |
| EPTF_HTTP_Transport_CloseConnection_FT halfClosePort optional, |
| EPTF_HTTP_Transport_ReceiveMessage_FT receiveMessage optional, |
| EPTF_HTTP_Transport_ReceiveEvent_FT receiveEvent optional |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_initUserFunctions |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_Transport_UserFunctions c_EPTF_HTTP_initUserFunctions :={ |
| omit, |
| omit, |
| omit, |
| omit, |
| omit, |
| omit, |
| omit, |
| omit, |
| omit, |
| omit, |
| omit |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_ServerUserFunctions |
| // |
| // Purpose: |
| // Record to store function referencies for a server port group |
| // |
| // Elements: |
| // removePort - <EPTF_HTTP_Transport_GroupOperation_FT> *optional* - remove port function ref |
| // listen - <EPTF_HTTP_Transport_Listen_FT> *optional* - open a listen port function ref |
| // createIncomingConn - <EPTF_HTTP_Transport_CreateIncomingConn_FT> *optional* - create incoming connection function ref |
| // removeIncomingConn - <EPTF_HTTP_Transport_RemoveIncomingConn_FT> *optional* - remove incoming connection function ref |
| // sendResponse - <EPTF_HTTP_Transport_SendResponse_FT> *optional* - send response function ref |
| // receiveMessage - <EPTF_HTTP_Transport_ReceiveMessage_FT> *optional* - receive message function ref |
| // receiveEvent - <EPTF_HTTP_Transport_ReceiveEvent_FT> *optional* - receive event function ref |
| // closePort - <EPTF_HTTP_Transport_PortOperation_FT> - close connection function ref |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_ServerUserFunctions |
| { |
| EPTF_HTTP_Transport_GroupOperation_FT removePort optional, |
| EPTF_HTTP_Transport_Listen_FT listen optional, |
| EPTF_HTTP_Transport_CreateIncomingConn_FT createIncomingConn optional, |
| EPTF_HTTP_Transport_RemoveIncomingConn_FT removeIncomingConn optional, |
| EPTF_HTTP_Transport_SendResponse_FT sendResponse optional, |
| EPTF_HTTP_Transport_ReceiveMessage_FT receiveMessage optional, |
| EPTF_HTTP_Transport_ReceiveEvent_FT receiveEvent optional, |
| EPTF_HTTP_Transport_PortOperation_FT closePort optional |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_initUserFunctions |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_Transport_ServerUserFunctions c_EPTF_HTTP_initServerUserFunctions :={ |
| removePort := omit, |
| listen := omit, |
| createIncomingConn := omit, |
| removeIncomingConn := omit, |
| sendResponse := omit, |
| receiveMessage := omit, |
| receiveEvent := omit, |
| closePort := omit |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_GroupMode |
| // |
| // Purpose: |
| // Record to store information on a port group |
| // |
| // Elements: |
| // name - *charstring* *optional* - unique name of the group |
| // localHostInformation - <EPTF_HTTP_HostInformation> - local IP address |
| // and port |
| // remoteHostInformation - <EPTF_HTTP_HostInformation> - remote IP address |
| // and port |
| // numberOfPorts - *integer* - number of ports within the group to be |
| // created |
| // localportStep - *integer* - step of local port number after creation |
| // of each port |
| // remoteportStep - *integer* - step of remote port number after creation |
| // of each port |
| // instantConnOpen - *boolean* - instant connection open mode |
| // instantConnClose - *boolean* - instant connection close mode |
| // useSSL - *boolean* - use ssl mode |
| // userFunctions - <EPTF_HTTP_Transport_UserFunctions> *optional* - |
| // function references of group callback functions if needed |
| // |
| // Detailed Comments: |
| // Used for port group creation |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_GroupMode { |
| charstring name optional, |
| |
| EPTF_HTTP_HostInformation localHostInformation, |
| EPTF_HTTP_HostInformation remoteHostInformation, |
| integer numberOfPorts, |
| integer localportStep, |
| integer remoteportStep, |
| |
| boolean instantConnOpen, |
| boolean instantConnClose, |
| boolean useSSL, |
| |
| EPTF_HTTP_Transport_UserFunctions userFunctions optional |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_PortMode |
| // |
| // Purpose: |
| // Record to store information on a port group |
| // |
| // Elements: |
| // name - *charstring* *optional* - unique name of the port |
| // localHostInformation - <EPTF_HTTP_HostInformation> - local IP address |
| // and port |
| // remoteHostInformation - <EPTF_HTTP_HostInformation> - remote IP address |
| // and port |
| // instantConnOpen - *boolean* - instant connection open mode |
| // instantConnClose - *boolean* - instant connection close mode |
| // useSSL - *boolean* - use ssl mode |
| // userFunctions - <EPTF_HTTP_Transport_UserFunctions> *optional* - |
| // function references of group callback functions if needed |
| // |
| // Detailed Comments: |
| // Used for port creation |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_PortMode { |
| charstring name optional, |
| |
| EPTF_HTTP_HostInformation localHostInformation, |
| EPTF_HTTP_HostInformation remoteHostInformation, |
| |
| boolean instantConnOpen, |
| boolean instantConnClose, |
| boolean useSSL, |
| |
| EPTF_HTTP_Transport_UserFunctions userFunctions optional |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_ServerPortMode |
| // |
| // Purpose: |
| // Contains information to create a new listening port group. |
| // |
| // Elements: |
| // name - *charstring* - unique name of the port |
| // localHostInformation - <EPTF_HTTP_HostInformation> - local IP address |
| // and port |
| // instantConnClose - *boolean* - instant connection close mode |
| // userFunctions - <EPTF_HTTP_Transport_ListeningUserFunctions> *optional* - |
| // function references of group callback functions if needed |
| // buffer - *boolean* - buffering mode |
| // useSSL - *boolean* - use SSL socket |
| // |
| // Detailed Comments: |
| // Used for port creation |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_ServerPortMode{ |
| charstring name, |
| |
| EPTF_HTTP_HostInformation localHostInformation, |
| boolean instantConnClose, |
| |
| EPTF_HTTP_Transport_ServerUserFunctions userFunctions optional, |
| boolean buffer, |
| boolean useSSL optional |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_initServerPortMode |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_Transport_ServerPortMode c_EPTF_HTTP_initServerPortMode :={ |
| name := "", |
| localHostInformation := {"", -1}, |
| instantConnClose := false, |
| userFunctions := omit, |
| buffer := false, |
| useSSL := omit |
| } |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Function |
| // |
| // Purpose: |
| // Record to store an element of the function group database |
| // |
| // Elements: |
| // addPort - <EPTF_HTTP_Transport_GroupOperation_FT> - add port function ref |
| // removePort - <EPTF_HTTP_Transport_GroupOperation_FT> - remove port function ref |
| // selectPort - <EPTF_HTTP_Transport_SelectPort_FT> - select port function ref |
| // sendMessage - <EPTF_HTTP_Transport_SendFunction_FT> - send message function ref |
| // closePortOfUser - <EPTF_HTTP_Transport_SessionOperation_FT> - close port of user function ref |
| // freePortOfUser - <EPTF_HTTP_Transport_SessionOperation_FT> - free port of user function ref |
| // openPort - <EPTF_HTTP_Transport_OpenConnection_FT> - open port function ref |
| // closeConnection - <EPTF_HTTP_Transport_CloseConnection_FT> - close port function ref |
| // halfClosePort - <EPTF_HTTP_Transport_CloseConnection_FT> - half close port function ref |
| // receiveMessage - <EPTF_HTTP_Transport_ReceiveMessage_FT> - receive message function ref |
| // receiveEvent - <EPTF_HTTP_Transport_ReceiveEvent_FT> - receive event function ref |
| // listen - <EPTF_HTTP_Transport_Listen_FT> - open a listen port function ref |
| // createIncomingConn - <EPTF_HTTP_Transport_CreateIncomingConn_FT> - create incoming connection function ref |
| // removeIncomingConn - <EPTF_HTTP_Transport_RemoveIncomingConn_FT> *optional* - remove incoming connection function ref |
| // closePort - <EPTF_HTTP_Transport_PortOperation_FT> - close connection function ref |
| // |
| // Detailed Comments: |
| // A port group has a number of registerable and stateless callback |
| // functions to handle communication. These kind of function sets can |
| // be registered into the function database. This element contains |
| // one functions set. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_Function |
| { |
| EPTF_HTTP_Transport_GroupOperation_FT addPort, |
| EPTF_HTTP_Transport_GroupOperation_FT removePort, |
| EPTF_HTTP_Transport_SelectPort_FT selectPort, |
| EPTF_HTTP_Transport_SendFunction_FT sendMessage, |
| EPTF_HTTP_Transport_SendResponse_FT sendResponse, |
| EPTF_HTTP_Transport_SessionOperation_FT closePortOfUser, |
| EPTF_HTTP_Transport_SessionOperation_FT freePortOfUser, |
| EPTF_HTTP_Transport_OpenConnection_FT openPort, |
| EPTF_HTTP_Transport_CloseConnection_FT closeConnection, |
| EPTF_HTTP_Transport_CloseConnection_FT halfClosePort, |
| EPTF_HTTP_Transport_ReceiveMessage_FT receiveMessage, |
| EPTF_HTTP_Transport_ReceiveEvent_FT receiveEvent, |
| EPTF_HTTP_Transport_Listen_FT listen, |
| EPTF_HTTP_Transport_CreateIncomingConn_FT createIncomingConn, |
| EPTF_HTTP_Transport_RemoveIncomingConn_FT removeIncomingConn, |
| EPTF_HTTP_Transport_PortOperation_FT closePort |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_HTTP_Transport_initFunction |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_Transport_Function c_HTTP_Transport_initFunction:= |
| { |
| addPort := null, |
| removePort := null, |
| selectPort := null, |
| sendMessage := null, |
| sendResponse := null, |
| closePortOfUser := null, |
| freePortOfUser := null, |
| openPort := null, |
| closeConnection := null, |
| halfClosePort := null, |
| receiveMessage := null, |
| receiveEvent := null, |
| listen := null, |
| createIncomingConn := null, |
| removeIncomingConn := null, |
| closePort := null |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_FunctionList |
| // |
| // Purpose: |
| // Function database for port groups |
| // |
| // Elements: |
| // record of <EPTF_HTTP_Transport_Function> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_Transport_Function EPTF_HTTP_Transport_FunctionList; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_PortInfo |
| // |
| // Purpose: |
| // A port connection database element |
| // |
| // Elements: |
| // groupIndex - *integer* - index of the port group in which the |
| // port is situated |
| // portIndex - *integer* - self index of the port within the port |
| // connection database |
| // connectionId - *integer* - connection id of the current port |
| // localhostInfoIdx - *integer* - localhost information database index to |
| // acquire local IP adress and port number |
| // remotehostInfoIdx - *integer* - remotehost information database index to |
| // acquire remote IP adress and port number |
| // state - <EPTF_HTTP_Transport_ConnectionState> - state of current port |
| // portType - <EPTF_HTTP_Transport_PortType> - port type |
| // buffer - *boolean* - buffering mode |
| // mesageBuffer - <EPTF_HTTP_Buffer> - buffer for sequencing outgoing responses |
| // |
| // Detailed Comments: |
| // A port group has a number of registerable and stateless callback |
| // functions to handle communication. These kind of function sets can |
| // be registered into the function database. This element contains |
| // one functions set. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_PortInfo { |
| integer groupIndex, |
| integer portIndex, |
| integer connectionId, |
| integer sessionId, |
| integer portId, |
| integer localhostInfoIdx, |
| integer remotehostInfoIdx, |
| EPTF_HTTP_Transport_ConnectionState state, |
| EPTF_HTTP_Transport_PortType portType, |
| boolean buffer, |
| EPTF_HTTP_MessageBuffer messageBuffer optional |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_LocalTransport_initPortInfo |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_Transport_PortInfo c_EPTF_HTTP_LocalTransport_initPortInfo :={ |
| groupIndex := -1, |
| portIndex := -1, |
| connectionId := -1, |
| sessionId := -1, |
| portId := -1, |
| localhostInfoIdx := -1, |
| remotehostInfoIdx := -1, |
| state := IDLE, |
| portType := OUTGOING_PORT, |
| buffer := false, |
| messageBuffer := omit |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_MessageBuffer |
| // |
| // Purpose: |
| // Message buffer for response sequencing. |
| // |
| // Elements: |
| // seqNums - <EPTF_HTTP_SeqNumMgmt> - sequence number management |
| // seqNum2messageIdxHM - *integer* - hashmap reference to map a sequence number to a message queue index |
| // messageQueue - <EPTF_FreeBusyQueue> - index management for the message queue |
| // httpMessages - <EPTF_OctetstringList> - http messages in the buffer |
| // |
| // Detailed Comments: |
| // In case of a pipelining on a persistent connection the server MUST send its |
| // responses to the requests in the same order that the requests were received. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_MessageBuffer |
| { |
| EPTF_HTTP_RingBuffer seqNums, |
| integer seqNum2messageIdxHM, |
| EPTF_FreeBusyQueue messageQueue, |
| OctetStringList httpMessages |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_RingBuffer |
| // |
| // Purpose: |
| // Handles sequence numbers of the responses |
| // |
| // Elements: |
| // isSlotBusyHM - *integer* - to decide if a given slot is busy |
| // nextSeqNum - *integer* - the sequence number of the next incoming request |
| // waitForSeqNum - *integer* - the sequence number of the next response to send out |
| // usedSlots - *integer* - number of used slowts in the buffer |
| // maxSize - *integer* - maximum size of the buffer |
| // |
| // Detailed Comments: |
| // In case of a pipelining on a persistent connection the server MUST send its |
| // responses to the requests in the same order that the requests were received. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_RingBuffer{ |
| integer isSlotBusyHM, |
| integer nextSeqNum, |
| integer waitForSeqNum, |
| integer usedSlots, |
| integer maxSize |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_PortInfoList |
| // |
| // Purpose: |
| // Port connection database of a port group |
| // |
| // Elements: |
| // record of <EPTF_HTTP_Transport_PortInfo> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_Transport_PortInfo EPTF_HTTP_Transport_PortInfoList; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_PortGroup |
| // |
| // Purpose: |
| // An element of the port group database of the HTTP transport component |
| // |
| // Elements: |
| // name - *charstring* - unique name of the port group |
| // localHostInformation - <EPTF_HTTP_HostInformation> - base local IP |
| // address and port |
| // remoteHostInformation - <EPTF_HTTP_HostInformation> - base remote IP |
| // address and port |
| // currentPortId - *integer* - used to generate unique portId |
| // numberOfPorts - *integer* - number of ports within the group to be |
| // created |
| // localportStep - *integer* - step of local port number after creation |
| // of each port |
| // remoteportStep - *integer* - step of remote port number after creation |
| // of each port |
| // portDatabase - <EPTF_HTTP_Transport_PortInfoList> - port connection |
| // database of the group |
| // listeningPort - <EPTF_HTTP_Transport_PortInfo> *optional* - listening port info |
| // defaultFIdx - *integer* - function group database pointer |
| // portQueue - <EPTF_FreeBusyQueue> - FBQ to maintain status of ports |
| // within the group |
| // portStateQueue - <EPTF_FreeBusyQueue> - FBQ to maintain sending status |
| // of ports within the group |
| // useSSL - *boolean* - use ssl mode |
| // instantConnOpen - *boolean* - instant connection open mode |
| // instantConnClose - *boolean* - instant connection close mode |
| // buffer - *boolean* - buffer mode |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_PortGroup { |
| charstring name, |
| |
| EPTF_HTTP_HostInformation baseLocalHostInformation, |
| EPTF_HTTP_HostInformation baseRemoteHostInformation, |
| integer currentPortId, |
| integer numberOfPorts, |
| integer localportStep, |
| integer remoteportStep, |
| |
| EPTF_HTTP_Transport_PortInfoList portDatabase, |
| integer listeningPortIdx, |
| |
| integer defaultFIdx, |
| |
| EPTF_FreeBusyQueue portQueue, |
| EPTF_FreeBusyQueue portStateQueue, |
| boolean useSSL, |
| boolean instantConnOpen, |
| boolean instantConnClose, |
| boolean buffer |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_HTTP_Transport_initPortGroup |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_Transport_PortGroup c_HTTP_Transport_initPortGroup := |
| { |
| name := "", |
| baseLocalHostInformation := {"", -1}, |
| baseRemoteHostInformation := {"", -1}, |
| currentPortId := 0, |
| numberOfPorts := 0, |
| localportStep := -1, |
| remoteportStep := -1, |
| portDatabase := {}, |
| listeningPortIdx := -1, |
| defaultFIdx := -1, |
| portQueue := c_EPTF_emptyFreeBusyQueue, |
| portStateQueue := c_EPTF_emptyFreeBusyQueue, |
| useSSL := false, |
| instantConnOpen := false, |
| instantConnClose := false, |
| buffer := false |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_PortGroupList |
| // |
| // Purpose: |
| // Port group database of the HTTP transport component |
| // |
| // Elements: |
| // record of <EPTF_HTTP_Transport_PortGroup> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_Transport_PortGroup EPTF_HTTP_Transport_PortGroupList; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_NewPortGroup |
| // |
| // Purpose: |
| // Remote transport ASP API element for port group creation |
| // |
| // Elements: |
| // groupInfo - <EPTF_HTTP_Transport_GroupMode> - port group info |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_NewPortGroup { |
| EPTF_HTTP_Transport_GroupMode groupInfo |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_DeletePortGroup |
| // |
| // Purpose: |
| // Remote transport ASP API element for port group deletion |
| // |
| // Elements: |
| // groupId - *integer* - port group index of created port group |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_DeletePortGroup { |
| integer groupId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_NewPort |
| // |
| // Purpose: |
| // Remote transport ASP API element for port creation |
| // |
| // Elements: |
| // portInfo - <EPTF_HTTP_Transport_PortMode> - port info |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_NewPort { |
| EPTF_HTTP_Transport_PortMode portInfo |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_NewServerPort |
| // |
| // Purpose: |
| // Remote transport ASP API element for a server port creation |
| // |
| // Elements: |
| // portInfo - <EPTF_HTTP_Transport_ServerPortMode> - server port info |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_NewServerPort { |
| EPTF_HTTP_Transport_ServerPortMode portInfo |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_DeletePort |
| // |
| // Purpose: |
| // Remote transport ASP API element for port deletion |
| // |
| // Elements: |
| // portId - *integer* - port group index of port to be deleted |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_DeletePort { |
| integer portId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_AddPort |
| // |
| // Purpose: |
| // Remote transport ASP API element for add port to a port group |
| // |
| // Elements: |
| // groupId - *integer* - port group index of group to which a new port |
| // is to be added |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_AddPort { |
| integer groupId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_RemovePort |
| // |
| // Purpose: |
| // Remote transport ASP API element for remove port from a port group |
| // |
| // Elements: |
| // groupId - *integer* - port group index of group from which a port |
| // is to be removed |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_RemovePort { |
| integer groupId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Send |
| // |
| // Purpose: |
| // Remote transport ASP API element for send a message |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group on which the message |
| // should be sent |
| // sessionId - *integer* - entity index as session id for current send |
| // outgoingMessage - *octetstring* - outgoing message |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_Send { |
| integer groupId, |
| integer sessionId, |
| octetstring outgoingMessage |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_ClosePortOfUser |
| // |
| // Purpose: |
| // Remote transport ASP API element for close port of user |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group on which the message |
| // should be sent |
| // sessionId - *integer* - entity index as session id for current send |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_ClosePortOfUser { |
| integer groupId, |
| integer sessionId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_FreePortOfUser |
| // |
| // Purpose: |
| // Remote transport ASP API element for free port of user |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group on which the message |
| // should be sent |
| // sessionId - *integer* - entity index as session id for current send |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_FreePortOfUser { |
| integer groupId, |
| integer sessionId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Connect |
| // |
| // Purpose: |
| // Remote transport ASP API element for open a connection |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group whose connections should |
| // be opened |
| // sessionId - *integer* - entity index as session id for current open |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_Connect { |
| integer groupId, |
| integer sessionId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Close |
| // |
| // Purpose: |
| // Remote transport ASP API element for close a connection |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group whose connections should |
| // be closed |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_Close { |
| integer groupId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_HalfClose |
| // |
| // Purpose: |
| // Remote transport ASP API element for half close a connection |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group whose connections should |
| // be half closed |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_HalfClose { |
| integer groupId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Listen |
| // |
| // Purpose: |
| // Remote transport ASP API element for opening a listen connection |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the server group |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_Listen { |
| integer groupId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_closePort |
| // |
| // Purpose: |
| // Remote transport ASP API element for closing a port |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group |
| // portId - *integer* - the port identifier |
| // |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_closePort{ |
| integer groupId, |
| integer portId |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_SendResponse |
| // |
| // Purpose: |
| // Remote transport ASP API element for send a response. |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group on which the message |
| // should be sent |
| // portId - *integer* - the unique port identifier of the request |
| // msg - *octetstring* - outgoing response |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_SendResponse{ |
| integer groupId, |
| integer portId, |
| integer seqNum, |
| octetstring msg |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Result |
| // |
| // Purpose: |
| // Remote transport ASP API element for result notification |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group whose port got the event |
| // resultType - *integer* - event type |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_Result { |
| integer groupId, |
| integer sessionId, |
| integer resultType |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Receive |
| // |
| // Purpose: |
| // Remote transport ASP API element for message reception handling |
| // |
| // Elements: |
| // groupId - *integer* - port group identifier of the request |
| // sessionId - *integer* - unique id of the request |
| // seqNum- *integer* - sequence number of the request |
| // reveivedMessage - *octetstring* - received message |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_Receive { |
| integer groupId, |
| integer sessionId, |
| integer seqNum, |
| octetstring reveivedMessage |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Error |
| // |
| // Purpose: |
| // Remote transport ASP API element for error socket notification |
| // |
| // Elements: |
| // groupId - *integer* - the ID of the group whose port got the event |
| // result - <Result> - Contains IPL4 Result message |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_Error { |
| integer groupId, |
| integer sessionId, |
| Result result |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_ListenEvent |
| // |
| // Purpose: |
| // Remote transport ASP API element for listen socket event notification |
| // |
| // Elements: |
| // groupId - *integer* - port group ID |
| // hostInfo - <EPTF_HTTP_HostInformation> - listening address and port |
| // eventType - *integer* - event type |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_ListenEvent{ |
| integer groupId, |
| EPTF_HTTP_HostInformation hostInfo, |
| integer eventType |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_ListenError |
| // |
| // Purpose: |
| // Remote transport ASP API element for listen socket error notification |
| // |
| // Elements: |
| // groupId - *integer* - port group ID |
| // hostInfo - <EPTF_HTTP_HostInformation> - listening address and port |
| // transportError - <EPTF_HTTP_Error> - error |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Transport_ListenError{ |
| integer groupId, |
| EPTF_HTTP_HostInformation hostInfo, |
| EPTF_HTTP_Error transportError |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_PT |
| // |
| // Purpose: |
| // EPTF HTTP internal communication port |
| // |
| // Elements: |
| // EPTF_HTTP_Transport_NewPortGroup |
| // EPTF_HTTP_Transport_NewPort |
| // EPTF_HTTP_Transport_NewServerPort |
| // EPTF_HTTP_Transport_DeletePortGroup |
| // EPTF_HTTP_Transport_DeletePort |
| // EPTF_HTTP_Transport_AddPort |
| // EPTF_HTTP_Transport_RemovePort |
| // EPTF_HTTP_Transport_Send |
| // EPTF_HTTP_Transport_ClosePortOfUser |
| // EPTF_HTTP_Transport_FreePortOfUser |
| // EPTF_HTTP_Transport_Connect |
| // EPTF_HTTP_Transport_Close |
| // EPTF_HTTP_Transport_HalfClose |
| // EPTF_HTTP_Transport_Listen |
| // EPTF_HTTP_Transport_SendResponse |
| // EPTF_HTTP_Transport_Result |
| // EPTF_HTTP_Transport_Receive |
| // EPTF_HTTP_Transport_Error |
| // EPTF_HTTP_Transport_ListenEvent |
| // EPTF_HTTP_Transport_ListenError |
| // EPTF_HTTP_Transport_closePort |
| // integer |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type port EPTF_HTTP_Transport_PT message |
| { |
| inout EPTF_HTTP_Transport_NewPortGroup; |
| inout EPTF_HTTP_Transport_NewPort; |
| inout EPTF_HTTP_Transport_NewServerPort; |
| inout EPTF_HTTP_Transport_DeletePortGroup; |
| inout EPTF_HTTP_Transport_DeletePort; |
| inout EPTF_HTTP_Transport_AddPort; |
| inout EPTF_HTTP_Transport_RemovePort; |
| inout EPTF_HTTP_Transport_Send; |
| inout EPTF_HTTP_Transport_ClosePortOfUser; |
| inout EPTF_HTTP_Transport_FreePortOfUser; |
| inout EPTF_HTTP_Transport_Connect; |
| inout EPTF_HTTP_Transport_Close; |
| inout EPTF_HTTP_Transport_HalfClose; |
| inout EPTF_HTTP_Transport_Listen; |
| inout EPTF_HTTP_Transport_SendResponse |
| inout EPTF_HTTP_Transport_Result; |
| inout EPTF_HTTP_Transport_Receive; |
| inout EPTF_HTTP_Transport_Error; |
| inout EPTF_HTTP_Transport_ListenEvent; |
| inout EPTF_HTTP_Transport_ListenError; |
| inout EPTF_HTTP_Transport_closePort; |
| inout integer; |
| } with {extension "internal"} |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Base_CTList |
| // |
| // Purpose: |
| // Routing component CT list |
| // |
| // Elements: |
| // record of <EPTF_Base_CT> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_Base_CT EPTF_HTTP_Base_CTList; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_LocalTransport |
| // |
| // Purpose: |
| // The definitions of the EPTF HTTP Local Transport |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_LocalTransport { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_LocalTransport_CT |
| // |
| // Purpose: |
| // EPTF HTTP local transport component |
| // |
| // Extends: |
| // EPTF_MessageBufferManager_CT |
| // |
| // EPTF_HTTP_LoggerClient_CT |
| // |
| // EPTF_HTTP_Transport_Logging_CT (this extends EPTF_Logging_CT) |
| // |
| // EPTF_CommPort_IPL4_CT |
| // |
| // EPTF_Base_CT |
| // |
| // Ports: |
| // pf_EPTF_HTTP_LocalTransport_commPort - <EPTF_HTTP_Transport_PT> - local transport communication port |
| // |
| // Timers: |
| // - |
| // |
| // Elements: |
| // vf_EPTF_HTTP_LocalTransport_receive - <EPTF_HTTP_messageProcess_FT> - |
| // receive message callback function pointer |
| // vf_EPTF_HTTP_LocalTransport_eventReceive - <EPTF_HTTP_eventReceive_FT> - |
| // receive event callback function pointer |
| // vf_EPTF_HTTP_LocalTransport_socketErrorReceive - <EPTF_HTTP_socketErrorReceive_FT> - |
| // receive socket error callback function pointer |
| // vf_EPTF_HTTP_LocalTransport_listenSocketEvent - <EPTF_HTTP_listenSocketEvent_FT> - |
| // receive lisent socket event callback function pointer |
| // vf_EPTF_HTTP_LocalTransport_listenSocketError - <EPTF_HTTP_listenSocketError_FT> - |
| // receive lisent socket error callback function pointer |
| // vf_EPTF_HTTP_messageSentHook - <fcb_EPTF_HTTP_messageSentHook> - |
| // callback function that is invoked after each HTTP message is sent |
| // |
| // v_EPTF_HTTP_LocalTransport_loggingEnabled - *integer* - |
| // the Variable of the GUI logging |
| // v_EPTF_HTTP_LocalTransport_guiEnabled - *boolean* - GUI Logging enabled |
| // v_EPTF_HTTP_LocalTransport_initialized - *boolean* - |
| // The component initialized variable |
| // v_EPTF_HTTPLocalTransport_lengthCalculationFunctions - <EPTF_HTTP_LocalTransport_MessageLengthCalculationFunctionList> - |
| // message length calcualtion function list |
| // |
| // v_EPTF_HTTP_LocalTransport_selfName - *charstring* - self name of the component |
| // v_EPTF_HTTP_Transport_groupQueue - <EPTF_FreeBusyQueue> - FBQ to maintain port groups |
| // v_EPTF_HTTP_Transport_portDB - <EPTF_HTTP_Transport_PortGroupList> - port group database |
| // v_EPTF_HTTP_Transport_functionDB - <EPTF_HTTP_Transport_FunctionList> - function database |
| // |
| // v_EPTF_HTTP_Transport_groupName2Idx_HM - *integer* - group name to group index hash map handle |
| // v_EPTF_HTTP_Transport_functions2Idx_HM - *integer* - function set to function database hash map handle |
| // v_EPTF_HTTP_Transport_remoteHostHashMap - *integer* - remote host hash map handle |
| // v_EPTF_HTTP_Transport_localHostHashMap - *integer* - local host hash map handle |
| // v_EPTF_HTTP_Transport_connId2GroupId_HM - *integer* - connection id to group index hash map handle |
| // v_EPTF_HTTP_Transport_connId2PortId_HM - *integer* - connection id to port index hash map handle |
| // |
| // v_nameIdx - *integer* - variable to store current highest port group name index |
| // |
| // v_resultNoWarning - <Result> - dummy variable to suppress warnings |
| // v_boolNoWarning - *boolean* - dummy variable to suppress warnings |
| // v_intNoWarning - *integer* - dummy variable to suppress warnings |
| // |
| // v_EPTF_HTTP_Transport_localHostInformationList - <EPTF_HTTP_HostInformationList> - local host |
| // information database |
| // v_EPTF_HTTP_Transport_remoteHostInformationList - <EPTF_HTTP_HostInformationList> - remote |
| // host information database |
| // |
| // v_EPTF_HTTP_Transport_OutgoingMessage - <EPTF_CommPort_IPL4_ASP_OutgoingMessage> - |
| // outgoing message |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type component EPTF_HTTP_LocalTransport_CT extends |
| EPTF_MessageBufferManager_CT, |
| EPTF_HTTP_Transport_Logging_CT, |
| EPTF_CommPort_IPL4_CT, |
| EPTF_Base_CT |
| { |
| var EPTF_HTTP_messageProcess_FT vf_EPTF_HTTP_LocalTransport_receive := null; |
| var EPTF_HTTP_eventReceive_FT vf_EPTF_HTTP_LocalTransport_eventReceive := null; |
| var EPTF_HTTP_socketErrorReceive_FT vf_EPTF_HTTP_LocalTransport_socketErrorReceive := null; |
| |
| var EPTF_HTTP_listenSocketEvent_FT vf_EPTF_HTTP_LocalTransport_listenSocketEvent := null; |
| var EPTF_HTTP_listenSocketError_FT vf_EPTF_HTTP_LocalTransport_listenSocketError := null |
| var fcb_EPTF_HTTP_messageSentHook vf_EPTF_HTTP_messageSentHook := null; |
| |
| var integer v_EPTF_HTTP_LocalTransport_loggingEnabled := -1; |
| var boolean v_EPTF_HTTP_LocalTransport_guiEnabled := false; |
| var boolean v_EPTF_HTTP_LocalTransport_initialized := false; |
| var EPTF_HTTP_LocalTransport_MessageLengthCalculationFunctionList v_EPTF_HTTPLocalTransport_lengthCalculationFunctions := {}; |
| |
| var EPTF_HTTP_Transport_GetGroupAndPort_FT vf_getGroupAndPort := null; |
| var EPTF_HTTP_Transport_GetGroup_FT vf_getGroup := null; |
| |
| |
| var charstring v_EPTF_HTTP_LocalTransport_selfName := "EPTF_HTTP_Transport"; |
| |
| var EPTF_FreeBusyQueue v_EPTF_HTTP_Transport_groupQueue; |
| var EPTF_HTTP_Transport_PortGroupList v_EPTF_HTTP_Transport_portDB := {}; |
| var integer v_EPTF_HTTP_Transport_groupName2Idx_HM := -1; |
| |
| var EPTF_HTTP_Transport_FunctionList v_EPTF_HTTP_Transport_functionDB := {}; |
| var integer v_EPTF_HTTP_Transport_functions2Idx_HM := -1; |
| |
| var integer v_EPTF_HTTP_Transport_connId2GroupId_HM := -1; |
| var integer v_EPTF_HTTP_Transport_connId2PortId_HM := -1; |
| var integer v_EPTF_HTTP_Transport_sessId2PortId_HM := -1; |
| var integer v_EPTF_HTTP_Transport_portId2Idx_HM := -1; |
| |
| var integer v_nameIdx := 0; |
| var Result v_resultNoWarning; |
| var boolean v_boolNoWarning; |
| var integer v_intNoWarning; |
| |
| var EPTF_HTTP_HostInformationList v_EPTF_HTTP_Transport_localHostInformationList := {}; |
| var integer v_EPTF_HTTP_Transport_localHostHashMap := -1; |
| |
| var EPTF_HTTP_HostInformationList v_EPTF_HTTP_Transport_remoteHostInformationList := {}; |
| var integer v_EPTF_HTTP_Transport_remoteHostHashMap := -1; |
| |
| var integer v_EPTF_HTTP_Transport_lastReceivedGroup := -1; |
| var EPTF_CommPort_IPL4_ASP_OutgoingMessage v_EPTF_HTTP_Transport_OutgoingMessage; |
| |
| var integer v_EPTF_HTTP_Transport_bufferSize := tsp_EPTF_HTTP_bufferSize; |
| |
| port EPTF_HTTP_Transport_PT pf_EPTF_HTTP_LocalTransport_commPort; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_LocalTransport_CTList |
| // |
| // Purpose: |
| // Remote transport CT list |
| // |
| // Elements: |
| // record of <EPTF_HTTP_LocalTransport_CT> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_LocalTransport_CT EPTF_HTTP_LocalTransport_CTList; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_LocalTransport_MessageLengthCalculationFunctionList |
| // |
| // Purpose: |
| // Message length calculation function database |
| // |
| // Elements: |
| // record of <f_IPL4_getMsgLen> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of f_IPL4_getMsgLen |
| EPTF_HTTP_LocalTransport_MessageLengthCalculationFunctionList; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_LocalTransport_idx_getMessageLength |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_LocalTransport_idx_getMessageLength := 0; |
| |
| /////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_LocalTransport_idx_getMessageLength4Diameter |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_LocalTransport_idx_getMessageLength4Diameter := 1; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_LocalTransport_idx_getMessageLengthChunkedCoding |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_LocalTransport_idx_getMessageLengthChunkedCoding := 2; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: Hash map name constants for Local transport |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_groupName2Idx := "EPTF HTTP: Group name to group index HashMap"; |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_fnGrp2Idx := "EPTF HTTP: Function group to index HashMap"; |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_localHost := "EPTF HTTP: Local Host HashMap"; |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_remoteHost := "EPTF HTTP: Remote Host HashMap"; |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_connId2PortGrp := "EPTF HTTP: Connection id to Port group index HashMap"; |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_connId2Port := "EPTF HTTP: Connection id to Port index within port group HashMap"; |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_sessId2Port := "EPTF HTTP: Session id to Port index within port group HashMap"; |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_portId2Idx := "EPTF HTTP: Port id to Port index within port group HashMap"; |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_isSlotBusy := "EPTF HTTP: Buffer queue HashMap"; |
| const charstring c_EPTF_HTTP_LocalTransport_HashMap_seqNum2messageIdx := "EPTF HTTP: Sequence number to message queue index HashMap"; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_RemoteTransport |
| // |
| // Purpose: |
| // The definitions of the EPTF HTTP Remote Transport |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_RemoteTransport |
| { |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_RemoteTransport_CT |
| // |
| // Purpose: |
| // EPTF HTTP remote transport component |
| // |
| // Extends: |
| // EPTF_Base_CT |
| // EPTF_HTTP_Transport_Logging_CT (this extends EPTF_Logging_CT) |
| // |
| // Ports: |
| // v_EPTF_HTTP_RemoteTransport_commPort - <EPTF_HTTP_Transport_PT> - |
| // internal communication port |
| // |
| // Timers: |
| // - |
| // |
| // Elements: |
| // v_EPTF_HTTP_RemoteTransport_selfName - *charstring* - self name of the |
| // component |
| // v_EPTF_HTTP_RemoteTransport_result - <EPTF_HTTP_Transport_Result> - |
| // Remote transport internal communication ASP for incoming events |
| // v_EPTF_HTTP_RemoteTransport_receive - <EPTF_HTTP_Transport_Receive> - |
| // Remote transport internal communication ASP for incoming messages |
| // v_EPTF_HTTP_RemoteTransport_error - <EPTF_HTTP_Transport_Error> - |
| // Remote transport internal communication ASP for error messages |
| // v_EPTF_HTTP_RemoteTransport_listenEvent - <EPTF_HTTP_Transport_ListenEvent> - |
| // Remote transport internal communication ASP for listening socket events |
| // v_EPTF_HTTP_RemoteTransport_listenError - <EPTF_HTTP_Transport_ListenError> - |
| // Remote transport internal communication ASP for listening socket errors |
| // vf_EPTF_HTTP_RemoteTransport_handleReceive - <EPTF_HTTP_messageProcess_FT> - |
| // receive callback function pointer |
| // vf_EPTF_HTTP_RemoteTransport_eventReceive - <EPTF_HTTP_eventReceive_FT> - |
| // receive event callback function pointer |
| // vf_EPTF_HTTP_RemoteTransport_socketErrorReceive - <EPTF_HTTP_socketErrorReceive_FT> - |
| // receive socket error callback function pointer |
| // v_EPTF_HTTP_RemoteTransport_default - *default* - remote transport |
| // default altstep handler |
| // v_EPTF_HTTP_RemoteTransport_initialized - *boolean* - remote transport |
| // component initialization state |
| // v_EPTF_HTTP_RemoteTransport_transportIdToConnId - *integer* - hash map |
| // index |
| // v_EPTF_HTTP_Mapper_halfClose - <EPTF_HTTP_Transport_HalfClose> - HTTP |
| // half close message ASP |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type component EPTF_HTTP_RemoteTransport_CT extends |
| EPTF_Base_CT, |
| EPTF_HTTP_Transport_Logging_CT, |
| EPTF_HashMap_CT |
| { |
| var charstring v_EPTF_HTTP_RemoteTransport_selfName := "EPTF_HTTP_RemoteTransport"; |
| |
| var EPTF_HTTP_Transport_Result v_EPTF_HTTP_RemoteTransport_result; |
| var EPTF_HTTP_Transport_Receive v_EPTF_HTTP_RemoteTransport_receive; |
| var EPTF_HTTP_Transport_Error v_EPTF_HTTP_RemoteTransport_error; |
| |
| var EPTF_HTTP_Transport_ListenEvent v_EPTF_HTTP_RemoteTransport_listenEvent; |
| var EPTF_HTTP_Transport_ListenError v_EPTF_HTTP_RemoteTransport_listenError; |
| |
| var EPTF_HTTP_messageProcess_FT vf_EPTF_HTTP_RemoteTransport_handleReceive := null; |
| var EPTF_HTTP_eventReceive_FT vf_EPTF_HTTP_RemoteTransport_eventReceive := null; |
| var EPTF_HTTP_socketErrorReceive_FT vf_EPTF_HTTP_RemoteTransport_socketErrorReceive := null; |
| |
| var EPTF_HTTP_listenSocketEvent_FT vf_EPTF_HTTP_RemoteTransport_listenSocketEvent := null; |
| var EPTF_HTTP_listenSocketError_FT vf_EPTF_HTTP_RemoteTransport_listenSocketError := null |
| |
| var default v_EPTF_HTTP_RemoteTransport_default; |
| |
| var boolean v_EPTF_HTTP_RemoteTransport_initialized := false; |
| var integer v_EPTF_HTTP_RemoteTransport_transportIdToConnId := -1; |
| |
| port EPTF_HTTP_Transport_PT v_EPTF_HTTP_RemoteTransport_commPort; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_RemoteTransport_CTList |
| // |
| // Purpose: |
| // Remote transport CT list |
| // |
| // Elements: |
| // record of <EPTF_HTTP_RemoteTransport_CT> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_RemoteTransport_CT EPTF_HTTP_RemoteTransport_CTList; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: Hash map name constants for Remote transport |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_RemoteTransport_HashMap_transportId2ConnId := "EPTF HTTP: Transport ID To Connection ID HashMap"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Mapper |
| // |
| // Purpose: |
| // The definitions of the EPTF HTTP Mapper |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Mapper |
| { |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Mapper_CT |
| // |
| // Purpose: |
| // EPTF HTTP mapper component |
| // |
| // Extends: |
| // EPTF_HTTP_LocalTransport_CT |
| // |
| // EPTF_Routing_CT |
| // |
| // EPTF_Base_CT |
| // |
| // Ports: |
| // v_EPTF_HTTP_Mapper_commPort - <EPTF_HTTP_Transport_PT> - internal |
| // communication port |
| // |
| // Timers: |
| // - |
| // |
| // Elements: |
| // v_EPTF_HTTP_Mapper_componentId - *integer* - component id for routing |
| // v_EPTF_HTTP_Mapper_default - *default* - handle of the Mapper's |
| // default altstep |
| // v_EPTF_HTTP_Mapper_componentRef - <EPTF_Base_CT> - store remote load |
| // generator component reference for routing |
| // v_EPTF_HTTP_Mapper_hashMapIdx - *integer* - mapper routing hash map |
| // v_EPTF_HTTP_Mapper_initialized - *boolean* - mapper initialization |
| // state |
| // v_EPTF_HTTP_Mapper_newPortGroup - <EPTF_HTTP_Transport_NewPortGroup> - |
| // HTTP new port group ASP |
| // v_EPTF_HTTP_Mapper_deletePortGroup - <EPTF_HTTP_Transport_DeletePortGroup> - |
| // HTTP delete port group ASP |
| // v_EPTF_HTTP_Mapper_newPort - <EPTF_HTTP_Transport_NewPort> - HTTP |
| // new port ASP |
| // v_EPTF_HTTP_Mapper_newServerPort - <EPTF_HTTP_Transport_NewServerPort> - HTTP |
| // new server port ASP |
| // v_EPTF_HTTP_Mapper_deletePort - <EPTF_HTTP_Transport_DeletePort> - |
| // HTTP delete port ASP |
| // v_EPTF_HTTP_Mapper_addPort - <EPTF_HTTP_Transport_AddPort> - HTTP |
| // HTTP add port from port group ASP |
| // v_EPTF_HTTP_Mapper_removePort - <EPTF_HTTP_Transport_RemovePort> - |
| // HTTP remove port from port group ASP |
| // v_EPTF_HTTP_Mapper_sendMessage - <EPTF_HTTP_Transport_Send> - HTTP |
| // HTTP send message ASP |
| // v_EPTF_HTTP_Mapper_connect - <EPTF_HTTP_Transport_Connect> - HTTP |
| // connect message ASP |
| // v_EPTF_HTTP_Mapper_close - <EPTF_HTTP_Transport_Close> - HTTP close |
| // message ASP |
| // v_EPTF_HTTP_Mapper_halfClose - <EPTF_HTTP_Transport_HalfClose> - HTTP |
| // half close message ASP |
| // v_EPTF_HTTP_Mapper_listen - <EPTF_HTTP_Transport_Listen> - HTTP |
| // listen message ASP |
| // v_EPTF_HTTP_Mapper_sendResponse - <EPTF_HTTP_Transport_SendResponse> - HTTP |
| // send response ASP |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type component EPTF_HTTP_Mapper_CT extends |
| EPTF_HTTP_LocalTransport_CT, |
| EPTF_Routing_CT, |
| EPTF_Base_CT |
| { |
| port EPTF_HTTP_Transport_PT v_EPTF_HTTP_Mapper_commPort; |
| |
| var integer v_EPTF_HTTP_Mapper_sessionId; |
| var integer v_EPTF_HTTP_Mapper_portId; |
| |
| var EPTF_IntegerList v_EPTF_HTTP_Mapper_componentId; |
| var default v_EPTF_HTTP_Mapper_default; |
| var EPTF_Base_CT v_EPTF_HTTP_Mapper_componentRef; |
| var integer v_EPTF_HTTP_Mapper_hashMapIdx := -1; |
| var boolean v_EPTF_HTTP_Mapper_initialized := false; |
| |
| var EPTF_BooleanList v_EPTF_HTTP_Mapper_routingSetDatabase := {}; |
| var EPTF_HTTP_Mapper_Routing_Database v_EPTF_HTTP_Mapper_inRoutingDatabase := {}; |
| |
| var EPTF_HTTP_MapperRoutingUri2LGenDB v_EPTF_HTTP_MapperRoutingUri2LGenDB; |
| private var EPTF_HTTP_MapperRoutingUri2LGen_GetUri_FT fcb_EPTF_HTTP_MapperRoutingUri2LGen_GetUri := null; |
| |
| var EPTF_HTTP_Transport_NewPortGroup v_EPTF_HTTP_Mapper_newPortGroup; |
| var EPTF_HTTP_Transport_DeletePortGroup v_EPTF_HTTP_Mapper_deletePortGroup; |
| var EPTF_HTTP_Transport_NewPort v_EPTF_HTTP_Mapper_newPort; |
| var EPTF_HTTP_Transport_NewServerPort v_EPTF_HTTP_Mapper_newServerPort; |
| var EPTF_HTTP_Transport_DeletePort v_EPTF_HTTP_Mapper_deletePort; |
| var EPTF_HTTP_Transport_AddPort v_EPTF_HTTP_Mapper_addPort; |
| var EPTF_HTTP_Transport_RemovePort v_EPTF_HTTP_Mapper_removePort; |
| var EPTF_HTTP_Transport_Connect v_EPTF_HTTP_Mapper_connect; |
| var EPTF_HTTP_Transport_Send v_EPTF_HTTP_Mapper_sendMessage; |
| var EPTF_HTTP_Transport_ClosePortOfUser v_EPTF_HTTP_Mapper_closePortOfUser; |
| var EPTF_HTTP_Transport_FreePortOfUser v_EPTF_HTTP_Mapper_freePortOfUser; |
| var EPTF_HTTP_Transport_Close v_EPTF_HTTP_Mapper_close; |
| var EPTF_HTTP_Transport_HalfClose v_EPTF_HTTP_Mapper_halfClose; |
| var EPTF_HTTP_Transport_Listen v_EPTF_HTTP_Mapper_listen; |
| var EPTF_HTTP_Transport_SendResponse v_EPTF_HTTP_Mapper_sendResponse; |
| var EPTF_HTTP_Transport_closePort v_EPTF_HTTP_Mapper_closePort; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Mapper_Routing |
| // |
| // Purpose: |
| // Routing setup element |
| // |
| // Elements: |
| // groupId - *integer* - group index |
| // compIdList - <EPTF_IntegerList> - component id list casted to integer |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Mapper_Routing { |
| integer groupId, |
| EPTF_IntegerList compIdList |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Mapper_Routing |
| // |
| // Purpose: |
| // Routing setup list |
| // |
| // Elements: |
| // record of <EPTF_HTTP_Mapper_Routing> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_Mapper_Routing EPTF_HTTP_Mapper_RoutingList; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Mapper_Routing_DBE |
| // |
| // Purpose: |
| // Routing database element |
| // |
| // Elements: |
| // ptr - *integer* - next component id list pointer to send |
| // size - *integer* - component id list size |
| // compIdList - <EPTF_IntegerList> - component id list casted to integer |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Mapper_Routing_DBE { |
| integer ptr, |
| integer size, |
| EPTF_IntegerList compIdList |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_initRoutingDBE |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_Mapper_Routing_DBE c_EPTF_HTTP_initRoutingDBE := |
| { |
| ptr := 0, |
| size := 0, |
| compIdList := {} |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Mapper_Routing_Database |
| // |
| // Purpose: |
| // Routing database |
| // |
| // Elements: |
| // record of <EPTF_HTTP_Mapper_Routing_DBE> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_Mapper_Routing_DBE EPTF_HTTP_Mapper_Routing_Database; |
| |
| const charstring c_EPTF_HTTP_Transport_hashMapName_uri2idxHash := "SIP: uri2Idx"; |
| type record EPTF_HTTP_MapperRoutingUri2LGenDB { |
| integer uri2lgenIdxHash |
| } |
| |
| type function EPTF_HTTP_MapperRoutingUri2LGen_GetUri_FT() runs on self return charstring; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: Hash map name constants for Mapper |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_Mapper_HashMap_routing := "EPTF HTTP: Routing HashMap"; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Transport_Logging |
| // |
| // Purpose: |
| // The definitions of the EPTF HTTP Transport Logging |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Transport_Logging |
| { |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Transport_Logging_CT |
| // |
| // Purpose: |
| // Common logging component for Local/Remote transport |
| // |
| // Extends: |
| // EPTF_Logging_CT |
| // |
| // Ports: |
| // - |
| // |
| // Timers: |
| // - |
| // |
| // Elements: |
| // v_EPTF_HTTP_Transport_loggingMaskId - *integer* - logging mask id |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type component EPTF_HTTP_Transport_Logging_CT extends EPTF_Logging_CT |
| { |
| // logging |
| var integer v_EPTF_HTTP_Transport_loggingMaskId := c_EPTF_Logging_invalidMaskId; |
| |
| var integer v_EPTF_HTTP_Transport_bufferLoggingMaskId := c_EPTF_Logging_invalidMaskId; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_Transport_loggingEventClasses |
| // |
| // Purpose: |
| // list of logging event class names used on the EPTF HTTP |
| // Transport component |
| // |
| // Detailed Comments: |
| // <EPTF_Logging_EventClassPrefixList> { "Error", "Warning", "Debug" } |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_Logging_EventClassPrefixList |
| c_EPTF_HTTP_Transport_loggingEventClasses := { "Error", "Warning", "Debug", "BufferWarning", "BufferDebug"}; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_Transport_loggingClassIdx_Error |
| // |
| // Purpose: |
| // logging class index for Error |
| // |
| // Detailed Comments: |
| // *0* |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_Transport_loggingClassIdx_Error := 0; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_Transport_loggingClassIdx_Warning |
| // |
| // Purpose: |
| // logging class index for Warning |
| // |
| // Detailed Comments: |
| // *1* |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_Transport_loggingClassIdx_Warning := 1; |
| |
| /////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_Transport_loggingClassIdx_Debug |
| // |
| // Purpose: |
| // logging class index for Debug |
| // |
| // Detailed Comments: |
| // *2* |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_Transport_loggingClassIdx_Debug := 2; |
| |
| /////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_Transport_loggingClassIdx_BufferWarning |
| // |
| // Purpose: |
| // logging class index for Buffer debug warning logging. |
| // |
| // Detailed Comments: |
| // *0* |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_Transport_loggingClassIdx_BufferWarning := 3; |
| |
| /////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_Transport_loggingClassIdx_BufferDebug |
| // |
| // Purpose: |
| // logging class index for Buffer debug logging. |
| // |
| // Detailed Comments: |
| // *1* |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_Transport_loggingClassIdx_BufferDebug := 4; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Type: fcb_EPTF_HTTP_messageSentHook |
| // |
| // Purpose: Message hook for post-processing HTTP message sent. |
| // |
| /////////////////////////////////////////////////////////// |
| type function fcb_EPTF_HTTP_messageSentHook(in integer pl_eIdx, in octetstring pl_httpMessage) runs on self; |
| |
| }//end of module |
| with { |
| extension "version <RnXnn>" |
| } |
| |
