| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Copyright (c) 2000-2019 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_Definitions.ttcn |
| // Rev: <RnXnn> |
| // Prodnr: CNL 113 618 |
| // Updated: 2014-05-20 |
| // Contact: http://ttcn.ericsson.se |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Module: EPTF_HTTP_Definitions |
| // |
| // Purpose: |
| // This module contains the definitions for EPTF HTTP application library |
| // |
| // |
| // Module Parameters: |
| // tsp_EPTF_HTTP_latency - *float* - latency |
| // tsp_EPTF_HTTP_logEnabled - *boolean* - logging of messages enabled/disabled |
| // tsp_EPTF_HTTP_loggingComponentMask - *charstring* - logging component mask name |
| // tsp_EPTF_HTTP_loggingEnable - *boolean* - logging of LGen component enable/disable |
| // tsp_EPTF_HTTP_maxNumberOfEntities - *integer* - max number of entities |
| // |
| // Module depends on: |
| // <HTTPmsg_Types> |
| // |
| // <IPL4asp_Types> |
| // |
| // <EPTF_CLL_LGenBase_Definitions> |
| // |
| // <EPTF_CLL_LGenBase_Functions> |
| // |
| // <EPTF_CLL_Scheduler_Definitions> |
| // |
| // <EPTF_CLL_RBTScheduler_Definitions> |
| // |
| // <EPTF_CLL_Variable_Definitions> |
| // |
| // <EPTF_CLL_Logging_Definitions> |
| // |
| // <EPTF_CLL_Common_Definitions> |
| // |
| // Current Owner: |
| // EAKOPER |
| // |
| // Last Review Date: |
| // 2009-08-10 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| module EPTF_HTTP_Definitions { |
| |
| //============================================================================= |
| // Import Part |
| //============================================================================= |
| import from HTTPmsg_Types all; |
| import from IPL4asp_Types all; |
| import from EPTF_CLL_LGenBase_Definitions all; |
| //import from EPTF_CLL_LGenBase_Functions all; |
| //import from EPTF_CLL_Scheduler_Definitions all; |
| //import from EPTF_CLL_RBTScheduler_Definitions all; |
| import from EPTF_CLL_Variable_Definitions all; |
| import from EPTF_CLL_Logging_Definitions all; |
| import from EPTF_CLL_Common_Definitions all; |
| |
| //============================================================================= |
| // Module parameters |
| //============================================================================= |
| modulepar float tsp_EPTF_HTTP_latency := 2.0; |
| modulepar boolean tsp_EPTF_HTTP_logEnabled := false; |
| modulepar charstring tsp_EPTF_HTTP_loggingComponentMask := "EPTF_HTTP_LGen"; |
| modulepar EPTF_HTTP_EventDispatchLevel tsp_EPTF_HTTP_dispatchLevel := Detailed; |
| modulepar boolean tsp_EPTF_HTTP_loggingEnable := false; |
| modulepar integer tsp_EPTF_HTTP_maxNumberOfEntities := 1000000; |
| modulepar integer tsp_EPTF_HTTP_nofNonceValues := 1; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Applib |
| // |
| // Purpose: |
| // Functions of the EPTF HTTP Application Libray |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Applib |
| { |
| //============================================================================= |
| // Component types |
| //============================================================================= |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_LGen_CT |
| // |
| // Purpose: |
| // HTTP application library component type |
| // |
| // Extensions: |
| // EPTF_LGenBase_CT |
| // |
| // EPTF_Scheduler_CT |
| // |
| // EPTF_Var_CT |
| // |
| // EPTF_Logging_CT |
| // |
| // Variables: |
| // v_EPTF_HTTP_initialized - *boolean* - component initialization state |
| // v_EPTF_HTTP_contexts - <EPTF_HTTP_CtxList> - entity context database |
| // |
| // v_EPTF_HTTP_optionalTempParams - <EPTF_CharstringList> - holds the optional template |
| // parameter values |
| // |
| // v_boolNoWarningLG - *boolean* - dummy variable to supress warnings |
| // v_intNoWarningLG - *integer* - dummy variable to supress warnings |
| // |
| // v_EPTF_HTTP_EntityOffset - *integer* - entity offset for the lgen |
| // |
| // v_EPTF_HTTP_selfName - *charstring* - component's self name |
| // v_EPTF_HTTP_selfId - *integer* - component's self id |
| // |
| // vf_EPTF_HTTP_sendRequest - <EPTF_HTTP_messageProcessSend_FT> - send request |
| // callback function |
| // vf_EPTF_HTTP_connectionOpen - <EPTF_HTTP_connectionOpen_FT> - connection open |
| // callback function |
| // vf_EPTF_HTTP_connectionClose - <EPTF_HTTP_connectionClose_FT> - connection close |
| // callback function |
| // vf_EPTF_HTTP_connectionHalfClose - <EPTF_HTTP_connectionClose_FT> - connection |
| // halfe close callback function |
| // |
| // vf_EPTF_HTTP_closePort - <EPTF_HTTP_PortOperation_FT> - close port |
| // callback function |
| // |
| // vf_EPTF_HTTP_sendResponse - <EPTF_HTTP_sendResponse_FT> - send response |
| // callback function |
| // vf_EPTF_HTTP_listen - <EPTF_HTTP_Listen_FT> - listen callback function |
| // |
| // vf_EPTF_HTTP_searchContext - <EPTF_HTTP_searchContext_FT> - context searching callback function |
| // vf_EPTF_HTTP_searchContext4Event - <EPTF_HTTP_searchContext_FT> - context searching callback function |
| // vf_EPTF_HTTP_searchContext4Error - <EPTF_HTTP_searchContext_FT> - context searching callback function |
| // |
| // v_EPTF_HTTP_entityIdxHashMap - *integer* - entity index hash map handle |
| // v_EPTF_HTTP_myBIdx - *integer* - self behavior index |
| // |
| // v_EPTF_HTTP_maxNumberOfEntities - *integer* - max enabled number of entities |
| // v_EPTF_HTTP_logEnabled - *boolean* - logging enabled state |
| // v_EPTF_HTTP_latency - *float* - latency |
| // |
| // v_EPTF_HTTP_outgoingMessage - *octetstring* - outgoing message |
| // v_EPTF_HTTP_incomingMessage - <HTTPMessage> - incoming message |
| // |
| // v_EPTF_HTTP_lastReceivedGroupId - *integer* - the unique group identifier |
| // of the last received request |
| // v_EPTF_HTTP_lastReceivedPortId - *integer* - the unique port identifier |
| // of the last received request |
| // v_EPTF_HTTP_lastReceivedSeqNum - *integer* - the sequence number of the last received request |
| // |
| // v_EPTF_HTTP_charDB - *integer* - index of charstring database hash map |
| // v_EPTF_HTTP_octDB - *integer* - index of octetstring database hash map |
| // |
| // v_EPTF_HTTP_stats - <EPTF_HTTP_Stats> - statistics database |
| // |
| // v_EPTF_HTTP_headerLinesList - <EPTF_HTTP_HeaderLineList> - headerlines database |
| // |
| // v_EPTF_HTTP_ConnId2EIdx - <EPTF_IntegerList> - connection id to entity database |
| // v_EPTF_HTTP_ConnId2FIdx - <EPTF_IntegerList> - connection id to fsm database |
| // |
| // vf_EPTF_HTTP_dispatchFn - <EPTF_HTTP_dispatchHandler_FT> - dispatch event function pointer |
| // |
| // v_EPTF_HTTP_loggingMaskId - *integer* - logging mask id |
| // |
| // v_EPTF_HTTP_extTemplType_customHeader - *integer* |
| // v_EPTF_HTTP_extTemplType_customHeaderResponse - *integer* |
| // v_EPTF_HTTP_extTemplType_customBody - *integer* |
| // |
| // v_EPTF_HTTP_authData - <EPTF_HTTP_AuthDataServer> |
| // |
| // vf_EPTF_HTTP_messageReceivedHook - <fcb_EPTF_HTTP_messageReceivedHook> - callback placeholder for incoming HTTP message processing |
| // |
| // Timers: |
| // - |
| // |
| // Ports: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type component EPTF_HTTP_LGen_CT extends |
| EPTF_LGenBase_CT, EPTF_Var_CT, EPTF_Logging_CT |
| { |
| var boolean v_EPTF_HTTP_initialized := false; |
| var EPTF_HTTP_CtxList v_EPTF_HTTP_contexts :={}; |
| |
| var EPTF_CharstringList v_EPTF_HTTP_optionalTempParams := {}; |
| |
| var integer v_EPTF_HTTP_EntityOffset := 0; |
| |
| var boolean v_boolNoWarningLG; |
| var integer v_intNoWarningLG; |
| |
| var charstring v_EPTF_HTTP_selfName := ""; |
| var integer v_EPTF_HTTP_selfId := -1; |
| |
| var EPTF_HTTP_CharstringBodyDatabase v_EPTF_HTTP_charBodyDB := {}; |
| var EPTF_HTTP_BinaryBodyDatabase v_EPTF_HTTP_binBodyDB := {}; |
| |
| var EPTF_HTTP_messageProcessSend_FT vf_EPTF_HTTP_sendRequest := null; |
| var EPTF_HTTP_connectionOpen_FT vf_EPTF_HTTP_connectionOpen := null; |
| var EPTF_HTTP_connectionClose_FT vf_EPTF_HTTP_connectionClose := null; |
| var EPTF_HTTP_connectionClose_FT vf_EPTF_HTTP_connectionHalfClose := null; |
| var EPTF_HTTP_SessionOperation_FT vf_EPTF_HTTP_closePortOfUser := null; |
| var EPTF_HTTP_SessionOperation_FT vf_EPTF_HTTP_freePortOfUser := null; |
| |
| var EPTF_HTTP_PortOperation_FT vf_EPTF_HTTP_closePort := null; |
| |
| var EPTF_HTTP_sendResponse_FT vf_EPTF_HTTP_sendResponse := null; |
| var EPTF_HTTP_Listen_FT vf_EPTF_HTTP_listen := null; |
| |
| |
| var EPTF_HTTP_searchContext_FT vf_EPTF_HTTP_searchContext := null; |
| var EPTF_HTTP_searchContext_FT vf_EPTF_HTTP_searchContext4Event := null; |
| var EPTF_HTTP_searchContext_FT vf_EPTF_HTTP_searchContext4Error := null; |
| |
| var integer v_EPTF_HTTP_myBIdx; |
| |
| //component variables to the module parameters |
| var integer v_EPTF_HTTP_maxNumberOfEntities := tsp_EPTF_HTTP_maxNumberOfEntities; |
| var boolean v_EPTF_HTTP_logEnabled := tsp_EPTF_HTTP_logEnabled; |
| var float v_EPTF_HTTP_latency := tsp_EPTF_HTTP_latency; |
| |
| //variables to store incoming and outgoing messages |
| var octetstring v_EPTF_HTTP_outgoingMessage; |
| |
| var HTTPMessage v_EPTF_HTTP_incomingMessage; |
| |
| var integer v_EPTF_HTTP_lastReceivedGroupId := -1; |
| var integer v_EPTF_HTTP_lastReceivedPortId := -1; |
| var integer v_EPTF_HTTP_lastReceivedSeqNum := -1; |
| |
| var EPTF_HTTP_Event v_EPTF_HTTP_event; |
| var EPTF_HTTP_EventError v_EPTF_HTTP_error; |
| |
| var EPTF_HTTP_dispatchHandler_FT vf_EPTF_HTTP_dispatchFn := null; |
| |
| var integer v_EPTF_HTTP_charDB := -1; |
| var integer v_EPTF_HTTP_octDB := -1; |
| |
| var EPTF_HTTP_Stats v_EPTF_HTTP_stats; |
| |
| var EPTF_HTTP_HeaderLineList v_EPTF_HTTP_headerLinesList := {}; |
| |
| //var EPTF_IntegerList v_EPTF_HTTP_ConnId2EIdx := {}; |
| var EPTF_IntegerList v_EPTF_HTTP_ConnId2FIdx := {}; |
| |
| // logging |
| var integer v_EPTF_HTTP_loggingMaskId := c_EPTF_Logging_invalidMaskId; |
| |
| // template types |
| var integer v_EPTF_HTTP_extTemplType_customHeader; |
| var integer v_EPTF_HTTP_extTemplType_customHeaderResponse; |
| var integer v_EPTF_HTTP_extTemplType_customBody; |
| |
| var EPTF_HTTP_AuthDataServer v_EPTF_HTTP_authData; |
| |
| var fcb_EPTF_HTTP_messageReceivedHook vf_EPTF_HTTP_messageReceivedHook := null; |
| |
| } |
| |
| //============================================================================= |
| // Data types |
| //============================================================================= |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_StatusCodes |
| // |
| // Purpose: |
| // Container for HTTP status code statistics |
| // |
| // Elements: |
| // codeXXX_k - *integer* - handles for status code statistics for |
| // status code XXX |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_StatusCodes { |
| integer code100_k, |
| integer code101_k, |
| integer code200_k, |
| integer code201_k, |
| integer code202_k, |
| integer code203_k, |
| integer code204_k, |
| integer code205_k, |
| integer code206_k, |
| integer code300_k, |
| integer code301_k, |
| integer code302_k, |
| integer code303_k, |
| integer code304_k, |
| integer code305_k, |
| integer code306_k, |
| integer code307_k, |
| integer code400_k, |
| integer code401_k, |
| integer code402_k, |
| integer code403_k, |
| integer code404_k, |
| integer code405_k, |
| integer code406_k, |
| integer code407_k, |
| integer code408_k, |
| integer code409_k, |
| integer code410_k, |
| integer code411_k, |
| integer code412_k, |
| integer code413_k, |
| integer code414_k, |
| integer code415_k, |
| integer code416_k, |
| integer code417_k, |
| integer code500_k, |
| integer code501_k, |
| integer code502_k, |
| integer code503_k, |
| integer code504_k, |
| integer code505_k |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Methods |
| // |
| // Purpose: |
| // Container for HTTP method statistics |
| // |
| // Elements: |
| // options_k - *integer* - handle for options statistics |
| // get_k - *integer* - handle for get statistics |
| // head_k - *integer* - handle for head statistics |
| // post_k - *integer* - handle for post statistics |
| // put_k - *integer* - handle for put statistics |
| // delete_k - *integer* - handle for delete statistics |
| // trace_k - *integer* - handle for trace statistics |
| // connect_k - *integer* - handle for connect statistics |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Methods { |
| integer options_k, |
| integer get_k, |
| integer head_k, |
| integer post_k, |
| integer put_k, |
| integer delete_k, |
| integer trace_k, |
| integer connect_k |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Messages |
| // |
| // Purpose: |
| // Container for HTTP message statistics |
| // |
| // Elements: |
| // method - <EPTF_HTTP_Methods> - handles for method statistics |
| // status - <EPTF_HTTP_StatusCodes> - handles for status code statistics |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Messages { |
| EPTF_HTTP_Methods method, |
| integer requests_k, |
| EPTF_HTTP_StatusCodes status, |
| integer responses_k |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_EventDispatchLevel |
| // |
| // Purpose: |
| // Enumerate for HTTP message dispatch level control |
| // |
| // Elements: |
| // OnlyReceived - only message received event will be dispatched |
| // (reception of charstring request, charstring response, |
| // binary request, binary response) |
| // Class - OnlyReceived and status code classes event like 100 class event |
| // if status code is 1xx |
| // Detailed - Class and single status code events |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type enumerated EPTF_HTTP_EventDispatchLevel { |
| OnlyReceived, |
| Class, |
| Detailed |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Stats |
| // |
| // Purpose: |
| // TitanSim variables container for any HTTP statistics |
| // |
| // Elements: |
| // incoming - <EPTF_HTTP_Messages> - incoming message statistics |
| // outgoing - <EPTF_HTTP_Messages> - outgoing message statistics |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Stats { |
| EPTF_HTTP_Messages incoming, |
| EPTF_HTTP_Messages outgoing |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Error |
| // |
| // Purpose: |
| // TitanSim variables container for HTTP error messages |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type Result EPTF_HTTP_Error; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_messageProcessSend_FT |
| // |
| // Purpose: |
| // Type for send request callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_messageProcessSend_FT( |
| in integer pl_connId, |
| in integer pl_sessionId, |
| in octetstring pl_message) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_sendResponse_FT |
| // |
| // Purpose: |
| // Type for send response callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_sendResponse_FT( |
| in integer pl_groupId, |
| in integer pl_portId, |
| in integer pl_seqNum, |
| in octetstring pl_message) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_messageProcess_FT |
| // |
| // Purpose: |
| // Type for process message callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_messageProcess_FT( |
| in EPTF_HTTP_IncomingMessage pl_message) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_messageBetweenApplibs_FT |
| // |
| // Purpose: |
| // Type for message from application libraries callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_messageBetweenApplibs_FT () |
| runs on self; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_bodyContentGetter_FT |
| // |
| // Purpose: |
| // Type for acquire a body content for an HTTP entity |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_bodyContentGetter_FT ( |
| in EPTF_IntegerList pl_pars, |
| inout EPTF_HTTP_CharOrOct pl_body) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_headerContentGetter_FT |
| // |
| // Purpose: |
| // Type for acquire the header content for an HTTP entity |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_headerContentGetter_FT ( |
| in EPTF_IntegerList pl_pars, |
| inout HeaderLines pl_headerLines) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_rawHeaderContentGetter_FT |
| // |
| // Purpose: |
| // Type for acquire the raw (encoded) header content for an HTTP entity |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_rawHeaderContentGetter_FT ( |
| in EPTF_IntegerList pl_pars, |
| inout octetstring pl_rawHeader) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_charstringBodyHandler_FT |
| // |
| // Purpose: |
| // Type for charstring body handler function for an HTTP entity |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_charstringBodyHandler_FT (in integer pl_eIdx,in charstring pl_bodyMessage) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_binaryBodyHandler_FT |
| // |
| // Purpose: |
| // Type for binary body handler function for an HTTP entity |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_binaryBodyHandler_FT (in integer pl_eIdx,in octetstring pl_bodyMessage) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_connectionOpen_FT |
| // |
| // Purpose: |
| // Type for connection open callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_connectionOpen_FT ( |
| in integer pl_connId, |
| in integer pl_sessionId) |
| runs on self return boolean; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_connectionClose_FT |
| // |
| // Purpose: |
| // Type for connection close callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_connectionClose_FT ( |
| in integer pl_connId) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Listen_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback function for |
| // opening a listen port |
| // |
| // Elements: |
| // pl_groupId - *in* *integer* - port group index |
| // |
| // Return value: |
| // boolean - open result |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_Listen_FT( |
| in integer pl_groupId) |
| runs on self return integer; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_searchContext_FT |
| // |
| // Purpose: |
| // Defines a function type for getting the context in case of an incoming |
| // request. |
| // |
| // Elements: |
| // pl_eIdx - *inout* *integer* - entity index (-1 means generic) |
| // pl_fsmCtx - *inout* *integer* - fsm context index |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_searchContext_FT( |
| inout integer pl_eIdx, |
| inout integer pl_fsmCtx) |
| runs on self; |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_eventReceive_FT |
| // |
| // Purpose: |
| // Type for event receive callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_eventReceive_FT ( |
| in EPTF_HTTP_Event pl_event) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_socketErrorReceive_FT |
| // |
| // Purpose: |
| // Type for socket error receive callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_socketErrorReceive_FT ( |
| in EPTF_HTTP_EventError pl_error) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_listenSocketEvent_FT |
| // |
| // Purpose: |
| // Type for listening socket event receive callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_listenSocketEvent_FT( |
| in EPTF_HTTP_listenSocketEvent pl_event) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_listenSocketEvent_FT |
| // |
| // Purpose: |
| // Type for listening socket event receive callback function |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_listenSocketError_FT( |
| in EPTF_HTTP_listenSocketError pl_error) |
| runs on self; |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_dispatchHandler_FT |
| // |
| // Purpose: |
| // Type for handle dispatch event for current settings |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_dispatchHandler_FT( |
| in integer pl_statusCode, |
| in integer pl_eIdx, |
| in integer pl_fsmIdx) |
| runs on self; |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_SessionOperation_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback function to |
| // provide a session operation on a group |
| // |
| // Elements: |
| // pl_groupId - *in* *integer* - group id |
| // pl_sessionId - *in* *integer* - session id |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_SessionOperation_FT( |
| in integer pl_groupId, |
| in integer pl_sessionId) |
| runs on self; |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_PortOperation_FT |
| // |
| // Purpose: |
| // Function type to a registerable callback function to |
| // provide an operation on a socket. |
| // |
| // Elements: |
| // pl_groupId - *in* *integer* - group id |
| // pl_portId - *in* *integer* - port id within the group |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type function EPTF_HTTP_PortOperation_FT( |
| in integer pl_groupId, |
| in integer pl_portId |
| ) |
| runs on self; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Event |
| // |
| // Purpose: |
| // Contains the event parameters received from the transport layer |
| // |
| // Elements: |
| // groupId - *integer* - port group ID |
| // sessionId - *integer* - unique identifier of the session |
| // eventType - *integer* - the type of the event |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Event{ |
| integer groupId, |
| integer sessionId, |
| integer eventType |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_EventError |
| // |
| // Purpose: |
| // Contains the error event parameters received from the transport layer |
| // |
| // Elements: |
| // groupId - *integer* - port group ID |
| // sessionId - *integer* - unique identifier of the message |
| // transportError - <EPTF_HTTP_Error> - the error |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_EventError{ |
| integer groupId, |
| integer sessionId, |
| EPTF_HTTP_Error transportError |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_listenSocketEvent |
| // |
| // Purpose: |
| // Contains the listening socket event parameters received from the transport layer |
| // |
| // Elements: |
| // groupId - *integer* - port group ID |
| // hostInfo - <EPTF_HTTP_HostInformation> - listening address and port |
| // eventType - *integer* - event type |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_listenSocketEvent |
| { |
| integer groupId, |
| EPTF_HTTP_HostInformation hostInfo, |
| integer eventType |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_listenSocketError |
| // |
| // Purpose: |
| // Contains the listening socket error parameters received from the transport layer |
| // |
| // Elements: |
| // groupId - *integer* - port group ID |
| // hostInfo - <EPTF_HTTP_HostInformation> - listening address and port |
| // transportError - <EPTF_HTTP_Error> - the transport error |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_listenSocketError |
| { |
| integer groupId, |
| EPTF_HTTP_HostInformation hostInfo, |
| EPTF_HTTP_Error transportError |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_IncomingMessage |
| // |
| // Purpose: |
| // Contains the message received from the transport layer |
| // |
| // Elements: |
| // groupId - *integer* - port group identifier of the message |
| // sessionId - *integer* - unique port identifier of the message |
| // seqNum - *integer* - the sequence number of the request |
| // message - *octetstring* - HTTP message |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_IncomingMessage{ |
| integer groupId, |
| integer sessionId, |
| integer seqNum, |
| octetstring httpMessage |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_HeaderLineList |
| // |
| // Purpose: |
| // Type to store a list of header lines |
| // |
| // Elements: |
| // - |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of HeaderLines EPTF_HTTP_HeaderLineList; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_BinaryBodyDatabase |
| // |
| // Purpose: |
| // HTTP database for binary message body |
| // |
| // Elements: |
| // record of <octetstring> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of octetstring EPTF_HTTP_BinaryBodyDatabase; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_CharstringBodyDatabase |
| // |
| // Purpose: |
| // HTTP database for charstring message body |
| // |
| // Elements: |
| // <EPTF_CharstringList> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type EPTF_CharstringList EPTF_HTTP_CharstringBodyDatabase; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_CharOrOct |
| // |
| // Purpose: |
| // HTTP database for charstring message body |
| // |
| // Elements: |
| // charVal - *charstring* - charstring value |
| // octVal - *octetstring* - octetstring value |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type union EPTF_HTTP_CharOrOct { |
| charstring charVal, |
| octetstring octVal |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Information |
| // |
| // Purpose: |
| // Type to store a number of HTTP related data |
| // |
| // Elements: |
| // method - *charstring* - HTTP method |
| // uri - *charstring* - HTTP URI |
| // headerLines - <HeaderLines> - HTTP header lines |
| // authDetails - <EPTF_HTTP_AuthDetails> - HTTP authentication details |
| // bodymessage - *charstring* - HTTP body |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Information { |
| charstring method, |
| charstring uri, |
| HeaderLines headerLines, |
| EPTF_HTTP_AuthDetails authDetails, |
| charstring bodymessage |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_AuthDetails |
| // |
| // Purpose: |
| // The authentication details |
| // |
| // Elements: |
| // realm - *charstring* - authentication realm |
| // qop - *charstring* - qop (quality of protection code) |
| // nonce - *charstring* - nonce (number used once) |
| // cnonce - *charstring* - client nonce value |
| // opaque - *charstring* - opaque |
| // nonceCount - *charstring* - nonce count in hexa |
| // algorithm - *charstring* - used algorithm eg: MD5 |
| // password - *charstring* - user password |
| // |
| // Detailed Comments: |
| // This record contains the authentication details received from |
| // proxy such as realm, qop, nonce, opaque. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_AuthDetails { |
| charstring realm, |
| charstring qop, |
| charstring nonce, |
| charstring cnonce, |
| charstring opaque, |
| charstring nonceCount, |
| charstring algorithm, |
| charstring response, |
| charstring uri, |
| charstring username, |
| charstring password |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_initAuthDetails |
| // |
| // Purpose: |
| // Authentication data initialization. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_AuthDetails c_EPTF_HTTP_initAuthDetails := |
| { |
| realm := "", |
| qop := "", |
| nonce := "", |
| cnonce := "", |
| opaque := "", |
| nonceCount := "00000001", |
| algorithm := "", |
| response := "", |
| uri := "", |
| username := "", |
| password := "" |
| } |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_Ctx |
| // |
| // Purpose: |
| // HTTP entity context |
| // |
| // Elements: |
| // method - *charstring* - HTTP method |
| // uri - *charstring* - HTTP request URI |
| // version_major - *integer* - HTTP major version number |
| // version_minor - *integer* - HTTP minor version number |
| // headerLinesIdx - *integer* - headerlines database index |
| // authDetails - <EPTF_HTTP_authDetails> - authentication details |
| // connId - *integer* - port group index |
| // bodymessage - *charstring* - HTTP message body |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_Ctx { |
| charstring method, |
| integer statusCode, |
| charstring statusText, |
| charstring uri, |
| charstring etag, |
| integer version_major, |
| integer version_minor, |
| integer headerLinesIdx, |
| EPTF_HTTP_AuthDetails authDetails, |
| boolean requestPending, |
| integer connId, |
| integer bodyId, |
| integer portId, |
| integer seqNum, |
| HTTPMessage httpMessage optional, |
| EPTF_HTTP_headerContentGetter_FT headerGetterFn, |
| EPTF_HTTP_rawHeaderContentGetter_FT rawHeaderGetterFn, |
| EPTF_HTTP_bodyContentGetter_FT contentGetterFn, |
| EPTF_HTTP_charstringBodyHandler_FT charBodyHandlerFn, |
| EPTF_HTTP_binaryBodyHandler_FT binaryBodyHandlerFn |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_initCtx |
| // |
| // Purpose: |
| // Context initialization. |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_Ctx c_EPTF_HTTP_initCtx := |
| { |
| method := "", |
| statusCode := -1, |
| statusText := "", |
| uri := "", |
| etag := "", |
| version_major := 1, |
| version_minor := 1, |
| headerLinesIdx := -1, |
| authDetails := c_EPTF_HTTP_initAuthDetails, |
| requestPending := false, |
| connId := -1, |
| bodyId := -1, |
| portId := -1, |
| seqNum := -1, |
| httpMessage := omit, |
| headerGetterFn := null, |
| rawHeaderGetterFn := null, |
| contentGetterFn := null, |
| charBodyHandlerFn := null, |
| binaryBodyHandlerFn := null |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_HostInformation |
| // |
| // Purpose: |
| // Host information |
| // |
| // Elements: |
| // hostIPAddress - *charstring* - store the IP address of the given host |
| // hostPort - *integer* - store the port of the gives host |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_HostInformation{ |
| charstring hostIPAddress , |
| integer hostPort |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_HostInformationList |
| // |
| // Purpose: |
| // Record of <EPTF_HTTP_HostInformation> |
| // |
| // Elements: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_HostInformation EPTF_HTTP_HostInformationList; |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_CtxList |
| // |
| // Purpose: |
| // FSM Context Database |
| // |
| // Elements: |
| // record of <EPTF_HTTP_Ctx> |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_Ctx EPTF_HTTP_CtxList; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_AuthDataServer |
| // |
| // Purpose: |
| // Stores server authentication data. |
| // |
| // Elements: |
| // method - *charstring* - authentication method ("Digest") |
| // algorithm - *charstring* - used algorithm eg: MD5 |
| // realm - *charstring* - authentication realm |
| // domain - *charstring* *optional*- authentication domain |
| // nonce - *charstring* - nonce (number used once) |
| // qopOptions - *charstring* - qop (quality of protection code) |
| // password - *charstring* - user password |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_AuthDataServer |
| { |
| charstring method, |
| charstring algorithm, |
| charstring realm, |
| charstring domain optional, |
| EPTF_CharstringList nonceValues, |
| integer currentNonce, |
| charstring qopOptions, |
| charstring password |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_initAuthData |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_HTTP_AuthDataServer c_EPTF_HTTP_initAuthData := |
| { |
| method := "", |
| algorithm := "", |
| realm := "", |
| domain := omit, |
| nonceValues := {}, |
| currentNonce := 0, |
| qopOptions := "", |
| password := "" |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_ParamValue |
| // |
| // Purpose: |
| // - |
| // |
| // Elements: |
| // paramName - *charstring* - |
| // paramValue - *charstring* - |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_ParamValue |
| { |
| charstring paramName, |
| charstring paramValue |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_ParamValue_List |
| // |
| // Purpose: |
| // - |
| /////////////////////////////////////////////////////////////////////////////// |
| type record of EPTF_HTTP_ParamValue EPTF_HTTP_ParamValue_List; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Type: EPTF_HTTP_setAuthData |
| // |
| // Purpose: |
| // Sets server authentication data. |
| // |
| // Elements: |
| // method - *charstring* - authentication method ("Digest") |
| // algorithm - *charstring* - used algorithm eg: MD5 |
| // realm - *charstring* - authentication realm |
| // domain - *charstring* *optional*- authentication domain |
| // nonce - *charstring* - nonce (number used once) |
| // qopOptions - *charstring* - qop (quality of protection code) |
| // password - *charstring* - user password |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| type record EPTF_HTTP_setAuthData |
| { |
| charstring method, |
| charstring algorithm, |
| charstring realm, |
| charstring domain optional, |
| charstring qopOptions, |
| charstring password |
| } |
| //============================================================================= |
| // Constants |
| //============================================================================= |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_sendRequest |
| // |
| // Purpose: |
| // constant for the step index of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_sendRequest := 0; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_sendRequest |
| // |
| // Purpose: |
| // constant for the step name of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_sendRequest := "EPTF HTTP: Sends HTTP Request"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_handleTimeout |
| // |
| // Purpose: |
| // constant for the step index of handle timeout step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_handleTimeout := 1; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_handleTimeout |
| // |
| // Purpose: |
| // constant for the step name of handle timeout step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_handleTimeout := "EPTF HTTP: Timeout handler"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_responseReceived |
| // |
| // Purpose: |
| // constant for the step index of response message received step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_responseReceived := 2; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_responseReceived |
| // |
| // Purpose: |
| // constant for the step name of response message received step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_responseReceived := "EPTF HTTP: Response message received"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_openConnection |
| // |
| // Purpose: |
| // constant for the step index of open connection step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_openConnection := 3; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_openConnection |
| // |
| // Purpose: |
| // constant for the step name of open connection step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_openConnection := "EPTF HTTP: Opens connection"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_closeConnection |
| // |
| // Purpose: |
| // constant for the step index of close connection step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_closeConnection := 4; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_closeConnection |
| // |
| // Purpose: |
| // constant for the step name of close connection step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_closeConnection := "EPTF HTTP: Closes connection"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_halfCloseConnection |
| // |
| // Purpose: |
| // constant for the step index of half close connection step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_halfCloseConnection := 5; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_halfCloseConnection |
| // |
| // Purpose: |
| // constant for the step name of half close connection step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_halfCloseConnection := "EPTF HTTP: Half closes connection"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_closePortOfUser |
| // |
| // Purpose: |
| // constant for the step index of close port of user step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_closePortOfUser := 6; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_closePortOfUser |
| // |
| // Purpose: |
| // constant for the step name of close port of user step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_closePortOfUser := "EPTF HTTP: Closes port of user"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_closePortOfUser |
| // |
| // Purpose: |
| // constant for the step index of free port of user step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_freePortOfUser := 7; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_freePortOfUser |
| // |
| // Purpose: |
| // constant for the step name of free port of user step |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_freePortOfUser := "EPTF HTTP: Frees port of user"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodCONNECT |
| // |
| // Purpose: |
| // constant for the step index of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodCONNECT := 8; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_setEntityContextHTTPMethodCONNECT |
| // |
| // Purpose: |
| // constant for the step name of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_setEntityContextHTTPMethodCONNECT := "EPTF HTTP: Set Entity Context HTTP Method CONNECT"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodDELETE |
| // |
| // Purpose: |
| // constant for the step index of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodDELETE := 9; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_setEntityContextHTTPMethodDELETE |
| // |
| // Purpose: |
| // constant for the step name of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_setEntityContextHTTPMethodDELETE := "EPTF HTTP: Set Entity Context HTTP Method DELETE"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodGET |
| // |
| // Purpose: |
| // constant for the step index of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodGET := 10; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_setEntityContextHTTPMethodGET |
| // |
| // Purpose: |
| // constant for the step name of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_setEntityContextHTTPMethodGET := "EPTF HTTP: Set Entity Context HTTP Method GET"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodHEAD |
| // |
| // Purpose: |
| // constant for the step index of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodHEAD := 11; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_setEntityContextHTTPMethodHEAD |
| // |
| // Purpose: |
| // constant for the step name of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_setEntityContextHTTPMethodHEAD := "EPTF HTTP: Set Entity Context HTTP Method HEAD"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodOPTIONS |
| // |
| // Purpose: |
| // constant for the step index of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodOPTIONS := 12; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_setEntityContextHTTPMethodOPTIONS |
| // |
| // Purpose: |
| // constant for the step name of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_setEntityContextHTTPMethodOPTIONS := "EPTF HTTP: Set Entity Context HTTP Method OPTIONS"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodPOST |
| // |
| // Purpose: |
| // constant for the step index of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodPOST := 13; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_setEntityContextHTTPMethodPOST |
| // |
| // Purpose: |
| // constant for the step name of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_setEntityContextHTTPMethodPOST := "EPTF HTTP: Set Entity Context HTTP Method POST"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodPUT |
| // |
| // Purpose: |
| // constant for the step index of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodPUT := 14; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_setEntityContextHTTPMethodPUT |
| // |
| // Purpose: |
| // constant for the step name of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_setEntityContextHTTPMethodPUT := "EPTF HTTP: Set Entity Context HTTP Method PUT"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodTRACE |
| // |
| // Purpose: |
| // constant for the step index of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_setEntityContextHTTPMethodTRACE := 15; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_setEntityContextHTTPMethodTRACE |
| // |
| // Purpose: |
| // constant for the step name of send request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_setEntityContextHTTPMethodTRACE := "EPTF HTTP: Set Entity Context HTTP Method TRACE"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_handleRequest |
| // |
| // Purpose: |
| // constant for the step index of handle request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_handleRequest := 16; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_handleRequest |
| // |
| // Purpose: |
| // constant for the step name of handle request |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_handleRequest := "EPTF HTTP: Handle Request"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_sendResponse |
| // |
| // Purpose: |
| // constant for the step index of send response |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_sendResponse := 17; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_sendResponse |
| // |
| // Purpose: |
| // constant for the step name of send response |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_sendResponse := "EPTF HTTP: Send Response"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_cleanUpContext |
| // |
| // Purpose: |
| // constant for the step index of context cleanup |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_closePort := 18; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_closePort |
| // |
| // Purpose: |
| // constant for the step index of port closing |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_closePort := "EPTF HTTP: Close port"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepIdx_cleanUpContext |
| // |
| // Purpose: |
| // constant for the step index of context cleanup |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_stepIdx_cleanUpContext := 19; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_stepName_cleanUpContext |
| // |
| // Purpose: |
| // constant for the step index of context cleanup |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_stepName_cleanUpContext := "EPTF HTTP: Cleanup"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response100Continue |
| // |
| // Purpose: |
| // constant for the input index of response continue input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response100Continue := 0; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response100Continue |
| // |
| // Purpose: |
| // constant for the input name of response continue input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response100Continue := "HTTP Message arrived, Result Code: 100 Continue"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response101SwitchingProtocols |
| // |
| // Purpose: |
| // constant for the input index of response switching protocols input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response101SwitchingProtocols := 1; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response101SwitchingProtocols |
| // |
| // Purpose: |
| // constant for the input name of response switching protocols input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response101SwitchingProtocols := "HTTP Message arrived, Result Code: 101 Switching Protocols"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response200OK |
| // |
| // Purpose: |
| // constant for the input index of response OK input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response200OK := 2; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response200OK |
| // |
| // Purpose: |
| // constant for the input name of response OK input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response200OK := "HTTP Message arrived, Result Code: 200 Ok"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response201Created |
| // |
| // Purpose: |
| // constant for the input index of response created input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response201Created := 3; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response201Created |
| // |
| // Purpose: |
| // constant for the input name of response created input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response201Created := "HTTP Message arrived, Result Code: 201 Created"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response202Accepted |
| // |
| // Purpose: |
| // constant for the input index of response accepted input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response202Accepted := 4; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response202Accepted |
| // |
| // Purpose: |
| // constant for the input name of response accepted input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response202Accepted := "HTTP Message arrived, Result Code: 202 Accepted"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response203NonAuthoritativeInformation |
| // |
| // Purpose: |
| // constant for the input index of response non-authoritative information |
| // input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response203NonAuthoritativeInformation := 5; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response203NonAuthoritativeInformation |
| // |
| // Purpose: |
| // constant for the input name of response non-authoritative information |
| // input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response203NonAuthoritativeInformation:= "HTTP Message arrived, Result Code: 203 Non-Authoritative Information"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response204NoContent |
| // |
| // Purpose: |
| // constant for the input index of response no content input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response204NoContent := 6; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response204NoContent |
| // |
| // Purpose: |
| // constant for the input name of response no content input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response204NoContent := "HTTP Message arrived, Result Code: 204 No Content"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response205ResetContent |
| // |
| // Purpose: |
| // constant for the input index of response reset content input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response205ResetContent := 7; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response205ResetContent |
| // |
| // Purpose: |
| // constant for the input name of response reset content input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response205ResetContent := "HTTP Message arrived, Result Code: 205 Reset Content"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response206PartialContent |
| // |
| // Purpose: |
| // constant for the input index of response partial content input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response206PartialContent := 8; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response206PartialContent |
| // |
| // Purpose: |
| // constant for the input name of response partial content input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response206PartialContent := "HTTP Message arrived, Result Code: 206 Partial Content"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response300MultipleChoices |
| // |
| // Purpose: |
| // constant for the input index of response multiple choices input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response300MultipleChoices := 9; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response300MultipleChoices |
| // |
| // Purpose: |
| // constant for the input name of response multiple choices input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response300MultipleChoices := "HTTP Message arrived, Result Code: 300 Multiple Choices"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response301MovedPermanently |
| // |
| // Purpose: |
| // constant for the input index of response moved permanently input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response301MovedPermanently := 10; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response301MovedPermanently |
| // |
| // Purpose: |
| // constant for the input name of response moved permanently input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response301MovedPermanently := "HTTP Message arrived, Result Code: 301 Moved Permanently"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response302Found |
| // |
| // Purpose: |
| // constant for the input index of response found input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response302Found := 11; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response302Found |
| // |
| // Purpose: |
| // constant for the input name of response found input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response302Found := "HTTP Message arrived, Result Code: 302 Found"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response303SeeOther |
| // |
| // Purpose: |
| // constant for the input index of response see other input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response303SeeOther := 12; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response303SeeOther |
| // |
| // Purpose: |
| // constant for the input name of response see other input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response303SeeOther := "HTTP Message arrived, Result Code: 303 See Other"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response304NotModified |
| // |
| // Purpose: |
| // constant for the input index of response modified input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response304NotModified := 13; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response304NotModified |
| // |
| // Purpose: |
| // constant for the input name of response modified input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response304NotModified := "HTTP Message arrived, Result Code: 304 Not Modified"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response305UseProxy |
| // |
| // Purpose: |
| // constant for the input index of response use proxy input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response305UseProxy := 14; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response305UseProxy |
| // |
| // Purpose: |
| // constant for the input name of response use proxy input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response305UseProxy := "HTTP Message arrived, Result Code: 305 Use Proxy"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response306Unused |
| // |
| // Purpose: |
| // constant for the input index of response unused input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response306Unused := 15; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response306Unused |
| // |
| // Purpose: |
| // constant for the input name of response unused input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response306Unused := "HTTP Message arrived, Result Code: 306 Unused"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response307TemporaryRedirect |
| // |
| // Purpose: |
| // constant for the input index of response temporary redirect input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response307TemporaryRedirect := 16; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response307TemporaryRedirect |
| // |
| // Purpose: |
| // constant for the input name of response temporary redirect input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response307TemporaryRedirect := "HTTP Message arrived, Result Code: 307 Temporary Redirect"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response400BadRequest |
| // |
| // Purpose: |
| // constant for the input index of response bad request input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response400BadRequest := 17; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response400BadRequest |
| // |
| // Purpose: |
| // constant for the input name of response bad request input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response400BadRequest := "HTTP Message arrived, Result Code: 400 Bad Request"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response401Unauthorized |
| // |
| // Purpose: |
| // constant for the input index of response unauthorized input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response401Unauthorized := 18; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response401Unauthorized |
| // |
| // Purpose: |
| // constant for the input name of response unauthorized input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response401Unauthorized := "HTTP Message arrived, Result Code: 401 Unauthorized"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response402PaymentRequired |
| // |
| // Purpose: |
| // constant for the input index of response payment required input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response402PaymentRequired := 19; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response402PaymentRequired |
| // |
| // Purpose: |
| // constant for the input name of response payment required input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response402PaymentRequired := "HTTP Message arrived, Result Code: 402 Payment Required"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response403Forbidden |
| // |
| // Purpose: |
| // constant for the input index of response forbidden input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response403Forbidden := 20; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response403Forbidden |
| // |
| // Purpose: |
| // constant for the input name of response forbidden input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response403Forbidden := "HTTP Message arrived, Result Code: 403 Forbidden"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response404NotFound |
| // |
| // Purpose: |
| // constant for the input index of response not found input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response404NotFound := 21; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response404NotFound |
| // |
| // Purpose: |
| // constant for the input name of response not found input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response404NotFound := "HTTP Message arrived, Result Code: 404 Not Found"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response405MethodNotAllowed |
| // |
| // Purpose: |
| // constant for the input index of response method not allowed input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response405MethodNotAllowed := 22; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response405MethodNotAllowed |
| // |
| // Purpose: |
| // constant for the input name of response method not allowed input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response405MethodNotAllowed := "HTTP Message arrived, Result Code: 405 Method Not Allowed"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response406NotAcceptable |
| // |
| // Purpose: |
| // constant for the input index of response not acceptable input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response406NotAcceptable := 23; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response406NotAcceptable |
| // |
| // Purpose: |
| // constant for the input name of response not acceptable input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response406NotAcceptable := "HTTP Message arrived, Result Code: 406 Not Acceptable"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response407ProxyAuthenticationRequired |
| // |
| // Purpose: |
| // constant for the input index of response proxy authentication required |
| // input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response407ProxyAuthenticationRequired := 24; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response407ProxyAuthenticationRequired |
| // |
| // Purpose: |
| // constant for the input name of response proxy authentication required |
| // input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response407ProxyAuthenticationRequired := "HTTP Message arrived, Result Code: 407 Proxy Authentication Required"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response408RequestTimeout |
| // |
| // Purpose: |
| // constant for the input index of response request timeout input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response408RequestTimeout := 25; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response408RequestTimeout |
| // |
| // Purpose: |
| // constant for the input name of response request timeout input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response408RequestTimeout := "HTTP Message arrived, Result Code: 408 Request Timeout"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response409Conflict |
| // |
| // Purpose: |
| // constant for the input index of response conflict input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response409Conflict := 26; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response409Conflict |
| // |
| // Purpose: |
| // constant for the input name of response conflict input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response409Conflict := "HTTP Message arrived, Result Code: 409 Conflict"; |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response410Gone |
| // |
| // Purpose: |
| // constant for the input index of response gone input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response410Gone := 27; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response410Gone |
| // |
| // Purpose: |
| // constant for the input name of response gone input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response410Gone := "HTTP Message arrived, Result Code: 410 Gone"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response411LengthRequired |
| // |
| // Purpose: |
| // constant for the input index of response length required input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response411LengthRequired := 28; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response411LengthRequired |
| // |
| // Purpose: |
| // constant for the input name of response length required input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response411LengthRequired := "HTTP Message arrived, Result Code: 411 Length Required"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response412PreconditionFailed |
| // |
| // Purpose: |
| // constant for the input index of response precondition failed input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response412PreconditionFailed := 29; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response412PreconditionFailed |
| // |
| // Purpose: |
| // constant for the input name of response precondition failed input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response412PreconditionFailed := "HTTP Message arrived, Result Code: 412 Precondition Failed"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response413RequestEntityTooLarge |
| // |
| // Purpose: |
| // constant for the input index of response request entity too large input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response413RequestEntityTooLarge := 30; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response413RequestEntityTooLarge |
| // |
| // Purpose: |
| // constant for the input name of response request entity too large input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response413RequestEntityTooLarge := "HTTP Message arrived, Result Code: 413 Request Entity Too Large"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response414RequestURITooLong |
| // |
| // Purpose: |
| // constant for the input index of response request URI too long input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response414RequestURITooLong := 31; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response414RequestURITooLong |
| // |
| // Purpose: |
| // constant for the input name of response request URI too long input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response414RequestURITooLong := "HTTP Message arrived, Result Code: 414 Request-URI Too Long"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response415UnsupportedMediaType |
| // |
| // Purpose: |
| // constant for the input index of response unsupported media type input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response415UnsupportedMediaType := 32; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response415UnsupportedMediaType |
| // |
| // Purpose: |
| // constant for the input name of response unsupported media type input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response415UnsupportedMediaType := "HTTP Message arrived, Result Code: 415 Unsupported Media Type"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response416RequestedRangeNotSatisfiable |
| // |
| // Purpose: |
| // constant for the input index of response requested range not |
| // satisfiable input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response416RequestedRangeNotSatisfiable := 33; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response416RequestedRangeNotSatisfiable |
| // |
| // Purpose: |
| // constant for the input name of response requested range not |
| // satisfiable input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response416RequestedRangeNotSatisfiable := "HTTP Message arrived, Result Code: 416 Requested Range Not Satisfiable"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response417ExpectationFailed |
| // |
| // Purpose: |
| // constant for the input index of response expectation failed input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response417ExpectationFailed := 34; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response417ExpectationFailed |
| // |
| // Purpose: |
| // constant for the input name of response expectation failed input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response417ExpectationFailed := "HTTP Message arrived, Result Code: 417 Expectation Failed"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response500InternalServerError |
| // |
| // Purpose: |
| // constant for the input index of response internal server error input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response500InternalServerError := 35; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response500InternalServerError |
| // |
| // Purpose: |
| // constant for the input name of response internal server error input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response500InternalServerError := "HTTP Message arrived, Result Code: 500 Internal Server Error"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response501NotImplemented |
| // |
| // Purpose: |
| // constant for the input index of response not implemented input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response501NotImplemented := 36; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response501NotImplemented |
| // |
| // Purpose: |
| // constant for the input name of response not implemented input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response501NotImplemented := "HTTP Message arrived, Result Code: 501 Not Implemented"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response502BadGateway |
| // |
| // Purpose: |
| // constant for the input index of response bad gateway input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response502BadGateway := 37; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response502BadGateway |
| // |
| // Purpose: |
| // constant for the input name of response bad gateway input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response502BadGateway := "HTTP Message arrived, Result Code: 502 Bad Gateway"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response503ServiceUnavailable |
| // |
| // Purpose: |
| // constant for the input index of response service unavailable input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response503ServiceUnavailable := 38; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response503ServiceUnavailable |
| // |
| // Purpose: |
| // constant for the input name of response service unavailable input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response503ServiceUnavailable := "HTTP Message arrived, Result Code: 503 Service Unavailable"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response504GatewayTimeout |
| // |
| // Purpose: |
| // constant for the input index of response gateway timeout input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response504GatewayTimeout := 39; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response504GatewayTimeout |
| // |
| // Purpose: |
| // constant for the input name of response gateway timeout input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response504GatewayTimeout := "HTTP Message arrived, Result Code: 504 Gateway Timeout"; |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response505HTTPVersionNotSupported |
| // |
| // Purpose: |
| // constant for the input index of response HTTP version not supported |
| // input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response505HTTPVersionNotSupported := 40; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response505HTTPVersionNotSupported |
| // |
| // Purpose: |
| // constant for the input name of response HTTP version not supported |
| // input |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response505HTTPVersionNotSupported := "HTTP Message arrived, Result Code: 505 HTTP Version Not Supported"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response100class |
| // |
| // Purpose: |
| // constant for the input index of response HTTP class 100 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response100class := 41; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response100class |
| // |
| // Purpose: |
| // constant for the input name of response HTTP version class 100 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response100class := "HTTP Message arrived, Result Code: 1XX"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response200class |
| // |
| // Purpose: |
| // constant for the input index of response HTTP class 200 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response200class := 42; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response200class |
| // |
| // Purpose: |
| // constant for the input name of response HTTP version class 200 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response200class := "HTTP Message arrived, Result Code: 2XX"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response300class |
| // |
| // Purpose: |
| // constant for the input index of response HTTP class 300 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response300class := 43; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response300class |
| // |
| // Purpose: |
| // constant for the input name of response HTTP version class 300 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response300class := "HTTP Message arrived, Result Code: 3XX"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response400class |
| // |
| // Purpose: |
| // constant for the input index of response HTTP class 400 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response400class := 44; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response400class |
| // |
| // Purpose: |
| // constant for the input name of response HTTP version class 400 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response400class := "HTTP Message arrived, Result Code: 4XX"; |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_response500class |
| // |
| // Purpose: |
| // constant for the input index of response HTTP class 500 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_response500class := 45; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_response500class |
| // |
| // Purpose: |
| // constant for the input name of response HTTP version class 500 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_response500class := "HTTP Message arrived, Result Code: 5XX"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_connectionOpened |
| // |
| // Purpose: |
| // constant for the input index of connection opened |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_connectionOpened := 46; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_connectionOpened |
| // |
| // Purpose: |
| // constant for the input name of connection opened |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_connectionOpened := "HTTP Connection Opened "; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_connectionClosed |
| // |
| // Purpose: |
| // constant for the input index of connection closed |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_connectionClosed := 47; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_connectionClosed |
| // |
| // Purpose: |
| // constant for the input name of connection closed |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_connectionClosed := "HTTP Connection Closed "; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_errorReceived |
| // |
| // Purpose: |
| // constant for the input index of error received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_errorReceived := 48; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_errorReceived |
| // |
| // Purpose: |
| // constant for the input name of error received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_errorReceived := "HTTP error Result Received "; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_OKReceived |
| // |
| // Purpose: |
| // constant for the input index of OK received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_OKReceived := 49; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_OKReceived |
| // |
| // Purpose: |
| // constant for the input name of OK received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_OKReceived := "HTTP OK Result Received"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_responseCharReceived |
| // |
| // Purpose: |
| // constant for the input index of charstring response message received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_responseCharReceived := 50; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_responseCharReceived |
| // |
| // Purpose: |
| // constant for the input name of charstring response message received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_responseCharReceived := "HTTP CHAR Response Message Received"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_requestCharReceived |
| // |
| // Purpose: |
| // constant for the input index of charstring request message received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_requestCharReceived := 51; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_requestCharReceived |
| // |
| // Purpose: |
| // constant for the input name of charstring request message received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_requestCharReceived := "HTTP CHAR Request Message Received"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_responseOctReceived |
| // |
| // Purpose: |
| // constant for the input index of octetstring response message received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_responseOctReceived := 52; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_responseOctReceived |
| // |
| // Purpose: |
| // constant for the input name of octetstring response message received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_responseOctReceived := "HTTP OCT Response Message Received"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_requestOctReceived |
| // |
| // Purpose: |
| // constant for the input index of octetstring request message received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_requestOctReceived := 53; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_requestOctReceived |
| // |
| // Purpose: |
| // constant for the input name of octetstring request message received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_requestOctReceived := "HTTP OCT Request Message Received"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputIdx_responseSocketError |
| // |
| // Purpose: |
| // constant for the input index of socket error response received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_inputIdx_responseSocketError := 54; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_inputName_responseSocketError |
| // |
| // Purpose: |
| // constant for the input name of socket error response received |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_inputName_responseSocketError := "HTTP Response Socket Error"; |
| |
| |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_myBName |
| // |
| // Purpose: |
| // constant for the name of the HTTP behaviour |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_myBName := |
| "HTTP Behavior"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_fsmName_basicCall |
| // |
| // Purpose: |
| // constant for the name of basic call FSM |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_fsmName_basicCall := "EPTF HTTP: Basic Call"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_fsm_basicCall_state_idle |
| // |
| // Purpose: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_fsm_basicCall_state_idle := 0; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // const: Database Hash Map name constants |
| // |
| // Purpose: |
| // - |
| // |
| // Elements: |
| // - c_EPTF_HTTP_HashMap_charDatabase |
| // - c_EPTF_HTTP_HashMap_octDatabase |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_HashMap_charDatabase := "EPTF HTTP: Charstring database"; |
| const charstring c_EPTF_HTTP_HashMap_octDatabase := "EPTF HTTP: Octetstring database"; |
| |
| //========================================================================= |
| // Templates |
| //========================================================================= |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Template: t_EPTF_HTTP_HTTPdistr_request |
| // |
| // Purpose: |
| // <HTTPMessage> template, HTTP request message |
| // |
| // Parameters: |
| // p_client_id - *integer* - connection client ID |
| // p_method - *charstring* - GET, PUT, etc |
| // p_uri - *charstring* - uri ID |
| // p_version_major - *integer* - HTTP major version number |
| // p_version_minor - *integer* - HTTP minor version number |
| // p_header - <HeaderLines> *template* - header of the message |
| // p_body - *charstring* *template* - body of the message |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template HTTPMessage t_EPTF_HTTP_HTTPdistr_request( |
| charstring p_method, |
| charstring p_uri, |
| integer p_version_major, |
| integer p_version_minor, |
| HeaderLines p_header, |
| charstring p_body |
| ) := |
| { |
| request:= { |
| client_id:= omit, |
| method:= p_method, |
| uri:= p_uri, |
| version_major := p_version_major, |
| version_minor := p_version_minor, |
| header:= p_header, |
| body:= p_body |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Template: t_EPTF_HTTP_HTTPdistr_binary_request |
| // |
| // Purpose: |
| // <HTTPMessage> template, HTTP binary request message |
| // |
| // Parameters: |
| // p_client_id - *integer* - connection client ID |
| // p_method - *charstring* - GET, PUT, etc |
| // p_uri - *charstring* - uri ID |
| // p_version_major - *integer* - HTTP major version number |
| // p_version_minor - *integer* - HTTP minor version number |
| // p_header - <HeaderLines> *template* - header of the message |
| // p_body - *charstring* *template* - body of the message |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| template HTTPMessage t_EPTF_HTTP_HTTPdistr_binary_request( |
| charstring p_method, |
| charstring p_uri, |
| integer p_version_major, |
| integer p_version_minor, |
| HeaderLines p_header, |
| octetstring p_body |
| ) := |
| { |
| request_binary:= { |
| client_id:= omit, |
| method:= p_method, |
| uri:= p_uri, |
| version_major := p_version_major, |
| version_minor := p_version_minor, |
| header:= p_header, |
| body:= p_body |
| } |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_templName_CustomHeader |
| // |
| // Purpose: |
| // constant for the name of the HTTP external template |
| // type Custom Header |
| // |
| /////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_templName_CustomHeader := |
| "CUSTOM_HEADER"; |
| |
| /////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_templName_CustomHeader |
| // |
| // Purpose: |
| // constant for the name of the HTTP external template |
| // type Custom Header |
| // |
| /////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_templName_CustomHeaderResponse := |
| "CUSTOM_HEADER_RESPONSE" |
| |
| /////////////////////////////////////////////////////////// |
| // const: c_EPTF_HTTP_templName_CustomBody |
| // |
| // Purpose: |
| // constant for the name of the HTTP external template |
| // type Custom Body |
| // |
| /////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_templName_CustomBody := |
| "CUSTOM_BODY"; |
| |
| } |
| |
| //========================================================================= |
| // Statistics |
| //========================================================================= |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Statistics |
| // |
| // Purpose: |
| // Functions of the EPTF HTTP Statistics |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Statistics |
| { |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: Method constants |
| // |
| // Purpose: |
| // Unique names for incoming and outgoing method statistics |
| // |
| // Elements: |
| // - c_EPTF_HTTP_Stat_nofIncRequests |
| // - c_EPTF_HTTP_Stat_nofIncOptionMessages |
| // - c_EPTF_HTTP_Stat_nofIncOptionMessages |
| // - c_EPTF_HTTP_Stat_nofIncHeadMessages |
| // - c_EPTF_HTTP_Stat_nofIncPostMessages |
| // - c_EPTF_HTTP_Stat_nofIncPutMessages |
| // - c_EPTF_HTTP_Stat_nofIncDeleteMessages |
| // - c_EPTF_HTTP_Stat_nofIncTraceMessages |
| // - c_EPTF_HTTP_Stat_nofIncConnectMessages |
| // |
| // - c_EPTF_HTTP_Stat_nofOutRequests |
| // - c_EPTF_HTTP_Stat_nofOutOptionMessages |
| // - c_EPTF_HTTP_Stat_nofOutOptionMessages |
| // - c_EPTF_HTTP_Stat_nofOutHeadMessages |
| // - c_EPTF_HTTP_Stat_nofOutPostMessages |
| // - c_EPTF_HTTP_Stat_nofOutPutMessages |
| // - c_EPTF_HTTP_Stat_nofOutDeleteMessages |
| // - c_EPTF_HTTP_Stat_nofOutTraceMessages |
| // - c_EPTF_HTTP_Stat_nofOutConnectMessages |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_Stat_nofIncRequests := "HTTP: Number of incoming Requests"; |
| const charstring c_EPTF_HTTP_Stat_nofIncOptionMessages := "HTTP: Number of incoming OPTION Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofIncGetMessages := "HTTP: Number of incoming GET Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofIncHeadMessages := "HTTP: Number of incoming HEAD Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofIncPostMessages := "HTTP: Number of incoming POST Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofIncPutMessages := "HTTP: Number of incoming PUT Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofIncDeleteMessages := "HTTP: Number incoming of DELETE Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofIncTraceMessages := "HTTP: Number of incoming TRACE Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofIncConnectMessages := "HTTP: Number of incoming CONNECT Messages"; |
| |
| const charstring c_EPTF_HTTP_Stat_nofOutRequests := "HTTP: Number of outgoing Requests"; |
| const charstring c_EPTF_HTTP_Stat_nofOutOptionMessages := "HTTP: Number of outgoing OPTION Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofOutGetMessages := "HTTP: Number of outgoing GET Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofOutHeadMessages := "HTTP: Number of outgoing HEAD Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofOutPostMessages := "HTTP: Number of outgoing POST Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofOutPutMessages := "HTTP: Number of outgoing PUT Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofOutDeleteMessages := "HTTP: Number outgoing of DELETE Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofOutTraceMessages := "HTTP: Number of outgoing TRACE Messages"; |
| const charstring c_EPTF_HTTP_Stat_nofOutConnectMessages := "HTTP: Number of outgoing CONNECT Messages"; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: Status code constants |
| // |
| // Purpose: |
| // Unique names for incoming and outgoing status code statistics |
| // |
| // Elements: |
| // - c_EPTF_HTTP_Stat_nofIncResponses |
| // - c_EPTF_HTTP_Stat_nofInc100StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc101StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc200StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc201StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc202StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc203StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc204StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc205StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc206StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc300StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc301StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc302StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc303StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc304StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc305StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc306StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc307StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc400StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc401StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc402StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc403StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc404StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc405StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc406StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc407StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc408StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc409StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc410StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc411StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc412StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc413StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc414StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc415StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc416StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc417StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc500StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc501StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc502StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc503StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc504StatusCode |
| // - c_EPTF_HTTP_Stat_nofInc505StatusCode |
| // |
| // - c_EPTF_HTTP_Stat_nofOutResponses |
| // - c_EPTF_HTTP_Stat_nofOut100StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut101StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut200StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut201StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut202StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut203StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut204StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut205StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut206StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut300StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut301StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut302StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut303StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut304StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut305StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut306StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut307StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut400StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut401StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut402StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut403StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut404StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut405StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut406StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut407StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut408StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut409StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut410StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut411StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut412StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut413StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut414StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut415StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut416StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut417StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut500StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut501StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut502StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut503StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut504StatusCode |
| // - c_EPTF_HTTP_Stat_nofOut505StatusCode |
| // |
| // Detailed Comments: |
| // - |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| const charstring c_EPTF_HTTP_Stat_nofIncResponses := "HTTP: Number of incoming responses" |
| const charstring c_EPTF_HTTP_Stat_nofInc100StatusCode := "HTTP: Number of incoming 100 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc101StatusCode := "HTTP: Number of incoming 101 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc200StatusCode := "HTTP: Number of incoming 200 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc201StatusCode := "HTTP: Number of incoming 201 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc202StatusCode := "HTTP: Number of incoming 202 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc203StatusCode := "HTTP: Number of incoming 203 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc204StatusCode := "HTTP: Number of incoming 204 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc205StatusCode := "HTTP: Number of incoming 205 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc206StatusCode := "HTTP: Number of incoming 206 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc300StatusCode := "HTTP: Number of incoming 300 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc301StatusCode := "HTTP: Number of incoming 301 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc302StatusCode := "HTTP: Number of incoming 302 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc303StatusCode := "HTTP: Number of incoming 303 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc304StatusCode := "HTTP: Number of incoming 304 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc305StatusCode := "HTTP: Number of incoming 305 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc306StatusCode := "HTTP: Number of incoming 306 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc307StatusCode := "HTTP: Number of incoming 307 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc400StatusCode := "HTTP: Number of incoming 400 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc401StatusCode := "HTTP: Number of incoming 401 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc402StatusCode := "HTTP: Number of incoming 402 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc403StatusCode := "HTTP: Number of incoming 403 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc404StatusCode := "HTTP: Number of incoming 404 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc405StatusCode := "HTTP: Number of incoming 405 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc406StatusCode := "HTTP: Number of incoming 406 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc407StatusCode := "HTTP: Number of incoming 407 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc408StatusCode := "HTTP: Number of incoming 408 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc409StatusCode := "HTTP: Number of incoming 409 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc410StatusCode := "HTTP: Number of incoming 410 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc411StatusCode := "HTTP: Number of incoming 411 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc412StatusCode := "HTTP: Number of incoming 412 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc413StatusCode := "HTTP: Number of incoming 413 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc414StatusCode := "HTTP: Number of incoming 414 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc415StatusCode := "HTTP: Number of incoming 415 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc416StatusCode := "HTTP: Number of incoming 416 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc417StatusCode := "HTTP: Number of incoming 417 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc500StatusCode := "HTTP: Number of incoming 500 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc501StatusCode := "HTTP: Number of incoming 501 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc502StatusCode := "HTTP: Number of incoming 502 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc503StatusCode := "HTTP: Number of incoming 503 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc504StatusCode := "HTTP: Number of incoming 504 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofInc505StatusCode := "HTTP: Number of incoming 505 Status Codes" |
| |
| const charstring c_EPTF_HTTP_Stat_nofOutResponses := "HTTP: Number of outgoing responses" |
| const charstring c_EPTF_HTTP_Stat_nofOut100StatusCode := "HTTP: Number of outgoing 100 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut101StatusCode := "HTTP: Number of outgoing 101 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut200StatusCode := "HTTP: Number of outgoing 200 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut201StatusCode := "HTTP: Number of outgoing 201 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut202StatusCode := "HTTP: Number of outgoing 202 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut203StatusCode := "HTTP: Number of outgoing 203 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut204StatusCode := "HTTP: Number of outgoing 204 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut205StatusCode := "HTTP: Number of outgoing 205 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut206StatusCode := "HTTP: Number of outgoing 206 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut300StatusCode := "HTTP: Number of outgoing 300 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut301StatusCode := "HTTP: Number of outgoing 301 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut302StatusCode := "HTTP: Number of outgoing 302 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut303StatusCode := "HTTP: Number of outgoing 303 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut304StatusCode := "HTTP: Number of outgoing 304 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut305StatusCode := "HTTP: Number of outgoing 305 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut306StatusCode := "HTTP: Number of outgoing 306 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut307StatusCode := "HTTP: Number of outgoing 307 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut400StatusCode := "HTTP: Number of outgoing 400 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut401StatusCode := "HTTP: Number of outgoing 401 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut402StatusCode := "HTTP: Number of outgoing 402 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut403StatusCode := "HTTP: Number of outgoing 403 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut404StatusCode := "HTTP: Number of outgoing 404 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut405StatusCode := "HTTP: Number of outgoing 405 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut406StatusCode := "HTTP: Number of outgoing 406 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut407StatusCode := "HTTP: Number of outgoing 407 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut408StatusCode := "HTTP: Number of outgoing 408 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut409StatusCode := "HTTP: Number of outgoing 409 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut410StatusCode := "HTTP: Number of outgoing 410 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut411StatusCode := "HTTP: Number of outgoing 411 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut412StatusCode := "HTTP: Number of outgoing 412 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut413StatusCode := "HTTP: Number of outgoing 413 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut414StatusCode := "HTTP: Number of outgoing 414 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut415StatusCode := "HTTP: Number of outgoing 415 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut416StatusCode := "HTTP: Number of outgoing 416 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut417StatusCode := "HTTP: Number of outgoing 417 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut500StatusCode := "HTTP: Number of outgoing 500 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut501StatusCode := "HTTP: Number of outgoing 501 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut502StatusCode := "HTTP: Number of outgoing 502 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut503StatusCode := "HTTP: Number of outgoing 503 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut504StatusCode := "HTTP: Number of outgoing 504 Status Codes" |
| const charstring c_EPTF_HTTP_Stat_nofOut505StatusCode := "HTTP: Number of outgoing 505 Status Codes" |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Group: EPTF_HTTP_Logging |
| // |
| // Purpose: |
| // Functions of the EPTF HTTP Logging |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| group EPTF_HTTP_Logging |
| { |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_loggingEventClasses |
| // |
| // Purpose: |
| // list of logging event class names used on the EPTF HTTP component |
| // |
| // Detailed Comments: |
| // <EPTF_Logging_EventClassPrefixList> { "Error", "Warning", "Debug" } |
| /////////////////////////////////////////////////////////////////////////////// |
| const EPTF_Logging_EventClassPrefixList c_EPTF_HTTP_loggingEventClasses := { "Error", "Warning", "Debug" }; |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_Transport_loggingClassIdx_Error |
| // |
| // Purpose: |
| // logging class index for Error |
| // |
| // Detailed Comments: |
| // *0* |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_loggingClassIdx_Error := 0; |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_Transport_loggingClassIdx_Warning |
| // |
| // Purpose: |
| // logging class index for Warning |
| // |
| // Detailed Comments: |
| // *1* |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_loggingClassIdx_Warning := 1; |
| /////////////////////////////////////////////////////////////////////////////// |
| // Constant: c_EPTF_HTTP_Transport_loggingClassIdx_Debug |
| // |
| // Purpose: |
| // logging class index for Debug |
| // |
| // Detailed Comments: |
| // *2* |
| /////////////////////////////////////////////////////////////////////////////// |
| const integer c_EPTF_HTTP_loggingClassIdx_Debug := 2; |
| } |
| |
| /////////////////////////////////////////////////////////// |
| // Type: fcb_EPTF_HTTP_messageReceivedHook |
| // |
| // Purpose: Message hook to HTTP message received processing. |
| // |
| /////////////////////////////////////////////////////////// |
| type function fcb_EPTF_HTTP_messageReceivedHook(in integer pl_eIdx, in HTTPMessage pl_httpMessage) runs on self; |
| |
| }//end of module |
| with { |
| extension "version <RnXnn>" |
| } |
| |
