src/Transport/EPTF_CLL_TransportCommPortIPL4_Functions.ttcn

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

///////////////////////////////////////////////////////////
//  Module: EPTF_CLL_TransportCommPortIPL4_Functions
//
//  Purpose:
//    -
//
//  Module Parameters:
//    -
//
//  Module depends on:
//    <EPTF_CLL_TransportCommPortIPL4_Definitions>
//    <EPTF_CLL_TransportMessageBufferManager_Functions>
//    <IPL4asp_Types>
//    <IPL4asp_PortType>
//    <IPL4asp_Functions>
//    <EPTF_CLL_HashMapInt2Int_Functions>
//    <EPTF_CLL_HashMapStr2Int_Functions>
//    <EPTF_CLL_FBQ_Definitions>
//    <EPTF_CLL_FBQ_Functions>
//    <EPTF_CLL_Base_Functions>
//    <EPTF_CLL_Logging_Definitions>
//    <EPTF_CLL_Logging_Functions>
//    <EPTF_CLL_Variable_Definitions>
//    <EPTF_CLL_Variable_Functions>
//    <EPTF_CLL_Transport_CommonDefinitions>
//    <EPTF_CLL_Common_Definitions>
//    <Socket_API_Definitions>
//    <EPTF_CLL_Base_Functions>
//
//  Current Owner:
//    ENORPIN (EBENMOL)
//
//  Last Review Date:
//    2008-07-18
//
//  Detailed Comments:
//
//
///////////////////////////////////////////////////////////
module EPTF_CLL_TransportCommPortIPL4_Functions {
//=========================================================================
// Import Part
//=========================================================================
import from EPTF_CLL_TransportCommPortIPL4_Definitions all;
import from IPL4asp_Types all;
import from IPL4asp_PortType all;
import from EPTF_CLL_Transport_CommonDefinitions all;
import from EPTF_CLL_TransportIPL4_Functions all
import from EPTF_CLL_TransportIPL4_Definitions all
import from EPTF_CLL_Base_Functions all

///////////////////////////////////////////////////////////
//  Altstep: as_EPTF_CommPort_IPL4_Receive
//
//  Purpose:
//    Altstep to register receive templates and handling funcions
///////////////////////////////////////////////////////////
public altstep as_EPTF_CommPort_IPL4_Receive (
  in template ASP_RecvFrom pl_msgTemplate,
  in f_EPTF_CommPort_IPL4_messageProcess_FT pl_msghandler)
runs on EPTF_CommPort_IPL4_CT
{
  [] IPL4_PCO.receive (pl_msgTemplate) -> value v_EPTF_CommPort_IPL4_aspRecvFrom
  {
    v_EPTF_CommPort_IPL4_incomingMessage.asp_RecvFrom := v_EPTF_CommPort_IPL4_aspRecvFrom;
    if (not pl_msghandler == null ) {
      if (f_EPTF_Base_isEnabledDTEHandling()) {
        @try{
          pl_msghandler.apply();
        } @catch(dte_str) {
          f_EPTF_TransportIPL4_warning(log2str(%definitionId&": Dynamic test case error occured during executing message handler ",pl_msghandler,
            ". Error message: ",dte_str));
        }
      } else {
        pl_msghandler.apply();
      }
    }
    else {
      f_EPTF_TransportIPL4_debug("Message Handler function not exist!")
    }
    repeat;
  }
}


///////////////////////////////////////////////////////////
//  Altstep: as_EPTF_CommPort_IPL4_Event
//
//  Purpose:
//    Altstep to register event templates and handling funcions
///////////////////////////////////////////////////////////
public altstep as_EPTF_CommPort_IPL4_Event (
  in template ASP_Event pl_msgTemplate,
  in f_EPTF_CommPort_IPL4_messageProcess_FT pl_msghandler)
runs on EPTF_CommPort_IPL4_CT
{
  [] IPL4_PCO.receive (pl_msgTemplate) -> value v_EPTF_CommPort_IPL4_aspEvent
  {
    v_EPTF_CommPort_IPL4_incomingMessage.asp_Event := v_EPTF_CommPort_IPL4_aspEvent;
    if (not pl_msghandler == null ) {
      if (f_EPTF_Base_isEnabledDTEHandling()) {
        @try{
          pl_msghandler.apply();
        } @catch(dte_str) {
          f_EPTF_TransportIPL4_warning(log2str(%definitionId&": Dynamic test case error occured during executing event handler ",pl_msghandler,
            ". Error message: ",dte_str));
        }
      } else {
        pl_msghandler.apply();
      }
    }
    else {
      f_EPTF_TransportIPL4_debug("Message Handler function not exist!")
    }
    repeat;
  }
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_init
//
//  Purpose:
//    Function to initialize the IPL4 Communicationport component
//
//  Parameters:
//    pl_interfaceList - *in* - <EPTF_CommPort_IPL4_InterfaceInformationList> - The defined interface
//    pl_enableBufferManager - *in boolean* - Enable the BufferManager function
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_init(
  in EPTF_CommPort_IPL4_InterfaceInformationList pl_interfaceList := {},
  in boolean pl_enableBufferManager := true,
  in charstring pl_selfName := "EPTF_CommPort_IPL4")
runs on EPTF_CommPort_IPL4_CT
{
  var EPTF_Transport_InterfaceInformationList vl_lst := {}
  for ( var integer vl_i := 0; vl_i < sizeof(pl_interfaceList) ; vl_i := vl_i+1 ){
    vl_lst[vl_i].HostName := pl_interfaceList[vl_i].HostName
    vl_lst[vl_i].HostPort := pl_interfaceList[vl_i].HostPort
    vl_lst[vl_i].netmask := pl_interfaceList[vl_i].netmask
    vl_lst[vl_i].broadcast := pl_interfaceList[vl_i].broadcast
    vl_lst[vl_i].ifname := pl_interfaceList[vl_i].ifname
    vl_lst[vl_i].count := pl_interfaceList[vl_i].count
    vl_lst[vl_i].virtualIfaceStart := pl_interfaceList[vl_i].virtualIfaceStart
  }

  f_EPTF_Transport_init(IPL4, pl_selfName, vl_lst, pl_enableBufferManager)
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_activateDefaultBufferingHandler
//
//  Purpose:
//    Function to activate the default buffering handler
//
//  Parameters:
//    pl_LGenType - *in* - *charstring* - the type of the LGen component registered this function
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_activateDefaultBufferingHandler(
  in charstring pl_LGenType := "")
runs on EPTF_CommPort_IPL4_CT
{
  if(pl_LGenType == "") {
    f_EPTF_TransportIPL4_warning(%definitionId&": LGenType not specified, the handler will be activated for ALL LGenTypes!");
    var template EPTF_CommPort_IPL4_IncomingMessage vl_recvTemplate := {
      asp_Event := {
        result := {
          errorCode := IPL4_ERROR_AVAILABLE,
          connId := ?,
          os_error_code := *,
          os_error_text := *
        }
      }
    }
    f_EPTF_CommPort_IPL4_setReceive(vl_recvTemplate,
      refers(f_EPTF_TransportIPL4_defaultConnResultEventHandler),
      pl_LGenType);
  } else {
    var integer vl_fbqId := -1;
    f_EPTF_TransportIPL4_addLGenInfo(pl_LGenType, vl_fbqId);
    v_EPTF_TransportIPL4_LGenInfoList[vl_fbqId].defaultBufferingHandlerActivated := true;
  }
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_setUpInterfaces
//
//  Purpose:
//    Function to set up the given interfaces
//
//  Parameters:
//    -
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_setUpInterfaces()
runs on EPTF_CommPort_IPL4_CT
{
  var Result vl_result := c_emptyResult;
  f_EPTF_Transport_setUpInterfaces(IPL4, vl_result);
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_setDownInterfaces
//
//  Purpose:
//    Function to set down the initialized interfaces
//
//  Parameters:
//    -
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_setDownInterfaces ()
runs on EPTF_CommPort_IPL4_CT
{
  var Result vl_result := c_emptyResult;
  f_EPTF_Transport_setDownInterfaces(IPL4, vl_result);
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_setMsgLen
//
//  Purpose:
//    Function to set getMessageLength function
//
//  Parameters:
//    pl_connId - *in* - <ConnectionId> - The ID of the connection
//    pl_function - *in* - <f_IPL4_getMsgLen> - The getMessageLength function
//    pl_msgLenArgs - *in* - <ro_integer> - The arguments of the getMessageLength function
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_setMsgLen(
  in ConnectionId pl_connId,
  in f_IPL4_getMsgLen pl_function,
  in ro_integer pl_msgLenArgs)
runs on EPTF_CommPort_IPL4_CT
{
  f_IPL4_setGetMsgLen(IPL4_PCO, pl_connId, pl_function, pl_msgLenArgs);
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_setMsgLen4LGenType
//
//  Purpose:
//    Sets the message length calclutaion function for an LGen type.
//
//  Parameters:
//    pl_function - *in* - <f_IPL4_getMsgLen> - the message length calculation function reference
//    pl_msgLenArgs - *in* - <ro_integer> - the function arguments
//    pl_LGenType - *in* *charstring* - the name of the LGen type
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_setMsgLen4LGenType(
  in f_IPL4_getMsgLen pl_function,
  in ro_integer pl_msgLenArgs,
  in charstring pl_LGenType)
runs on EPTF_CommPort_IPL4_CT
{
  var integer vl_fbqId;
  f_EPTF_TransportIPL4_addLGenInfo(pl_LGenType, vl_fbqId);

  v_EPTF_TransportIPL4_LGenInfoList[vl_fbqId].msgLenCalc := c_EPTF_TransportIPL4_emptyGetMsgLen
  v_EPTF_TransportIPL4_LGenInfoList[vl_fbqId].msgLenCalc.getMsgLenOldAPIFn := pl_function
  v_EPTF_TransportIPL4_LGenInfoList[vl_fbqId].msgLenCalc.getMsgLenOldArgs := pl_msgLenArgs
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_setUserData
//
//  Purpose:
//    Function to set user data
//
//  Parameters:
//    pl_connId - *in* - <ConnectionId> - The ID of the connection
//    pl_userData - *in* - <UserData> - The data information
//
//  Return Value:
//    Result - the result of the operation
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_setUserData(
  in ConnectionId pl_connId,
  in UserData pl_userData)
runs on EPTF_CommPort_IPL4_CT
return Result
{
  var Result vl_result := c_emptyResult;
  f_EPTF_Transport_setUserData(IPL4, pl_connId, pl_userData, vl_result);
  return vl_result
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_getUserData
//
//  Purpose:
//    Function to get user data
//
//  Parameters:
//    pl_connId - *in* - <ConnectionId> - The ID of the connection
//    pl_userData - *out* - <UserData> - The data information
//
//  Return Value:
//    Result - the result of the operation
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_getUserData(
  in ConnectionId pl_connId,
  out UserData pl_userData)
runs on EPTF_CommPort_IPL4_CT
return Result
{
  var Result vl_result := c_emptyResult;
  f_EPTF_Transport_getUserData(IPL4, pl_connId, pl_userData, vl_result);
  return vl_result
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_getConnectionDetails
//
//  Purpose:
//    Function to get connection details
//
//  Parameters:
//    pl_connId - *in* - <ConnectionId> - The ID of the connection
//    pl_param - *in* - <IPL4_Param> - the connection detail which is interested
//    pl_result - *out* - <IPL4_ParamResult> - the value of the connection detail
//
//  Return Value:
//    Result - the result of the operation
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_getConnectionDetails(
  in ConnectionId pl_connId,
  in IPL4_Param pl_param,
  out IPL4_ParamResult  pl_result)
runs on EPTF_CommPort_IPL4_CT
return Result
{
  return f_IPL4_getConnectionDetails(IPL4_PCO,pl_connId,pl_param,pl_result);
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_setReceive
//
//  Purpose:
//    Function to set receive altstep and handling function
//
//  Parameters:
//    pl_reveiveTemplate - *in* - <EPTF_CommPort_IPL4_IncomingMessage> - The template of the receive altstep
//    pl_msghandler - *in* - <f_EPTF_CommPort_IPL4_messageProcess_FT> - The handler function to the receive template
//    pl_LGenType - *in* - *charstring* - the type of the LGen component registered this function
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_setReceive (
  in template EPTF_CommPort_IPL4_IncomingMessage pl_reveiveTemplate,
  in f_EPTF_CommPort_IPL4_messageProcess_FT pl_msghandler,
  in charstring pl_LGenType :="")
runs on EPTF_CommPort_IPL4_CT
{
  if (pl_LGenType=="")
  {
    if (ischosen(pl_reveiveTemplate.asp_RecvFrom)) { v_EPTF_TransportIPL4_defaultList[sizeof(v_EPTF_TransportIPL4_defaultList)] :=
      activate(as_EPTF_CommPort_IPL4_Receive(pl_reveiveTemplate.asp_RecvFrom, pl_msghandler));}

    else {v_EPTF_TransportIPL4_defaultList[sizeof(v_EPTF_TransportIPL4_defaultList)] :=
      activate(as_EPTF_CommPort_IPL4_Event(pl_reveiveTemplate.asp_Event, pl_msghandler));}
  }
  else
  {
    var integer vl_fbqId;

    f_EPTF_TransportIPL4_addLGenInfo(pl_LGenType, vl_fbqId);

    if (ischosen(pl_reveiveTemplate.asp_RecvFrom))
    {
      v_EPTF_TransportIPL4_LGenInfoList[vl_fbqId].msgHandlerOldFn := pl_msghandler;
    }
    else
    {
      v_EPTF_TransportIPL4_LGenInfoList[vl_fbqId].eventHandlerOldFn := pl_msghandler;
    }
  }
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_send
//
//  Purpose:
//    Function to communicate with the communication port component
//
//  Parameters:
//    pl_data - *in* - <EPTF_CommPort_IPL4_ASP_OutgoingMessage> - The outgoing message
//    pl_msghandler - *in* - <f_EPTF_CommPort_IPL4_messageProcess_FT> - The handler function to the receive template
//    pl_needBuffering - *in - *boolean* - Insert the message into the Buffer
//    pl_automaticBuffering - *in* - *boolean* - set on/off the using of commport automatic buffering (can be used in connect)
//    pl_LGenType - *in* - *charstring* - the type of the LGen component called this function (can be used in connect and close)
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//  pl_data is the message received from the transport components and will be send towards the IPL4 component.
//  pl_msghandler can be registered to handle theese received messages in unique way.
//  pl_needBuffering can be used to set the buffering method from the applib. In this case the buffering have to be handled from each applib's transport components.
//  pl_automaticBuffering can be used to set the buffering method to be automatical. It can be set in connecting, and can be set on or off to each connection ID.
//  In this case the Transport_CommPort component handles the buffering automatically, the applibs don't need to care about it.
//  pl_LGenType can be used to set the name/ID of the applib's LGen component called this function.
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_send(
  in EPTF_CommPort_IPL4_ASP_OutgoingMessage pl_data,
  in f_EPTF_CommPort_IPL4_messageProcess_FT  pl_msghandler := null,
  in boolean pl_needBuffering := false,
  in boolean pl_automaticBuffering := false,
  in charstring pl_LGenType :="")
runs on EPTF_CommPort_IPL4_CT
return Result
{
  var Result vl_result := c_emptyResult;
  if ( ischosen(pl_data.asp_Send)){
    if(isbound(pl_data.asp_Send.proto) and ispresent(pl_data.asp_Send.proto)){
    f_EPTF_Transport_send(IPL4, pl_data.asp_Send.connId, pl_data.asp_Send.msg, vl_result, pl_needBuffering, pl_data.asp_Send.proto);
    }else{
    f_EPTF_Transport_send(IPL4, pl_data.asp_Send.connId, pl_data.asp_Send.msg, vl_result, pl_needBuffering);
    }
    return vl_result
  }
  else if ( ischosen(pl_data.asp_SendTo)) {
    if(isbound(pl_data.asp_SendTo.proto) and ispresent(pl_data.asp_SendTo.proto)){
    f_EPTF_Transport_sendTo(
      IPL4,
      pl_data.asp_SendTo.connId,
      pl_data.asp_SendTo.remName,
      pl_data.asp_SendTo.remPort,
      pl_data.asp_SendTo.msg,
      vl_result,
      pl_needBuffering,
      pl_data.asp_SendTo.proto)
    }else{
    f_EPTF_Transport_sendTo(
      IPL4,
      pl_data.asp_SendTo.connId,
      pl_data.asp_SendTo.remName,
      pl_data.asp_SendTo.remPort,
      pl_data.asp_SendTo.msg,
      vl_result,
      pl_needBuffering)
    }
    return vl_result
  }
  else if ( ischosen(pl_data.asp_Connect) ) {
    var integer vl_connId := f_EPTF_Transport_connect(
      IPL4,
      pl_data.asp_Connect.proto,
      pl_data.asp_Connect.locName,
      pl_data.asp_Connect.locPort,
      pl_data.asp_Connect.remName,
      pl_data.asp_Connect.remPort,
      pl_LGenType,
      vl_result,
      pl_automaticBuffering)

    if (pl_msghandler != null) {
      if (f_EPTF_Base_isEnabledDTEHandling()) {
        @try{
          pl_msghandler.apply();
        } @catch(dte_str) {
          f_EPTF_TransportIPL4_warning(log2str(%definitionId&": Dynamic test case error occured during executing connect handler ",pl_msghandler,
            ". Error message: ",dte_str));
        }
      } else {
        pl_msghandler.apply();
      }
    }
    return vl_result
  }
  else if ( ischosen(pl_data.asp_Listen)) {
    var integer vl_connId := f_EPTF_Transport_listen(
      IPL4,
      pl_data.asp_Listen.proto,
      pl_data.asp_Listen.locName,
      pl_data.asp_Listen.locPort,
      pl_LGenType,
      vl_result,
      pl_automaticBuffering)

    if (pl_msghandler != null) {
      if (f_EPTF_Base_isEnabledDTEHandling()) {
        @try{
          pl_msghandler.apply();
        } @catch(dte_str) {
          f_EPTF_TransportIPL4_warning(log2str(%definitionId&": Dynamic test case error occured during executing listen handler ",pl_msghandler,
            ". Error message: ",dte_str));
        }
      } else {
        pl_msghandler.apply();
      }
    }
    return vl_result
  }
  else if ( ischosen(pl_data.asp_Close)) {
    var boolean vl_res := f_EPTF_Transport_close(
      IPL4,
      pl_data.asp_Close.id,
      vl_result,
      pl_data.asp_Close.proto)
    if (pl_msghandler != null) {
      if (f_EPTF_Base_isEnabledDTEHandling()) {
        @try{
          pl_msghandler.apply();
        } @catch(dte_str) {
          f_EPTF_TransportIPL4_warning(log2str(%definitionId&": Dynamic test case error occured during executing close handler ",pl_msghandler,
            ". Error message: ",dte_str));
        }
      } else {
        pl_msghandler.apply();
      }
    }
    return vl_result
  } else {
    f_EPTF_TransportIPL4_error(%definitionId&": The received asp type is unknown. ASP: "&log2str(pl_data))
    return {IPL4_ERROR_GENERAL,omit,omit,omit}
  }
}
///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_portSend
//
//  Purpose:
//    Wrapper function for the f_IPL4_send external function
//
//  Parameters:
//    - portRef - IPL4 port reference
//    - asp - the IPL4 ASP to be sent
//    - sent_octets - number of sent octets (0..msg_size)
//    - p_connInfofbqId - if present, the the connections state
//      is stored in the connInfoFBQ record
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_portSend(
  inout IPL4asp_PT pl_portRef,
  in ASP_Send pl_asp,
  out integer pl_sent_octets,
  in  integer pl_connInfofbqId := -1
)
runs on EPTF_CommPort_IPL4_CT
return Result
{
  return f_EPTF_TransportIPL4_portSend(pl_portRef, pl_asp, pl_sent_octets, pl_connInfofbqId);
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_portSendTo
//
//  Purpose:
//    Wrapper function for the f_IPL4_sendto external function
//
//  Parameters:
//    - portRef - IPL4 port reference
//    - asp - the IPL4 ASP to be sent
//    - sent_octets - number of sent octets (0..msg_size)
//    - p_connInfofbqId - if present, the the connections state
//      is stored in the connInfoFBQ record
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_portSendTo(
  inout IPL4asp_PT pl_portRef,
  in ASP_SendTo pl_asp,
  out integer pl_sent_octets,
  in  integer pl_connInfofbqId := -1
)
runs on EPTF_CommPort_IPL4_CT
return Result
{
  return f_EPTF_TransportIPL4_portSendTo(pl_portRef, pl_asp, pl_sent_octets, pl_connInfofbqId);
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_portSend_retransmission
//
//  Purpose:
//    function for send retransmission handling
//
//  Parameters:
//    - portRef - IPL4 port reference
//    - asp - the IPL4 ASP to be sent
//    - sent_octets - number of sent octets (0..msg_size)
//    - protocolId - string identifier for the protocol in the buffer
//    - p_connInfofbqId - if present, the the connections state
//      is stored in the connInfoFBQ record
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_portSend_retransmission(
  inout IPL4asp_PT pl_portRef,
  in ASP_Send pl_asp,
  out integer pl_sent_octets,
  in  charstring pl_protocolId,
  in  integer pl_connInfofbqId := -1
)
runs on EPTF_CommPort_IPL4_CT
return boolean
{
  return f_EPTF_TransportIPL4_portSend_retransmission(pl_portRef, pl_asp, pl_sent_octets, pl_protocolId, pl_connInfofbqId);
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_portSendTo_retransmission
//
//  Purpose:
//    Function for sendTo retransmission handling
//
//  Parameters:
//    - portRef - IPL4 port reference
//    - asp - the IPL4 ASP to be sent
//    - sent_octets - number of sent octets (0..msg_size)
//    - protocolId - string identifier for the protocol in the buffer
//    - p_connInfofbqId - if present, the the connections state
//      is stored in the connInfoFBQ record
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_portSendTo_retransmission(
  inout IPL4asp_PT pl_portRef,
  in ASP_SendTo pl_asp,
  out integer pl_sent_octets,
  in  charstring pl_protocolId,
  in  integer pl_connInfofbqId := -1
)
runs on EPTF_CommPort_IPL4_CT
return boolean
{
  return f_EPTF_TransportIPL4_portSendTo_retransmission(pl_portRef, pl_asp, pl_sent_octets, pl_protocolId, pl_connInfofbqId);
}

///////////////////////////////////////////////////////////
//  Function: f_EPTF_CommPort_IPL4_defaultConnResultEventHandler
//
//  Purpose:
//    Function to receive the Connection available message and
//    send the message from the buffer.
//
//  Parameters:
//    -
//
//  Return Value:
//    -
//
//  Errors:
//    -
//
//  Detailed Comments:
//
///////////////////////////////////////////////////////////
public function f_EPTF_CommPort_IPL4_defaultConnResultEventHandler()
runs on EPTF_CommPort_IPL4_CT
{
  f_EPTF_TransportIPL4_defaultConnResultEventHandler()
}


}