///////////////////////////////////////////////////////////////////////////////
//
// 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>"
}