view src/g23m-fad/udp/udp_kerp.c @ 662:8cd8fd15a095

SIM speed enhancement re-enabled and made configurable TI's original code supported SIM speed enhancement, but Openmoko had it disabled, and OM's disabling of speed enhancement somehow caused certain SIM cards to start working which didn't work before (OM's bug #666). Because our FC community is much smaller in year 2020 than OM's community was in their day, we are not able to find one of those #666-affected SIMs, thus the real issue they had encountered remains elusive. Thus our solution is to re-enable SIM speed enhancement and simply wait for if and when someone runs into a #666-affected SIM once again. We provide a SIM_allow_speed_enhancement global variable that allows SIM speed enhancement to be enabled or disabled per session, and an /etc/SIM_spenh file in FFS that allows it to enabled or disabled on a non-volatile basis. SIM speed enhancement is now enabled by default.
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 24 May 2020 05:02:28 +0000
parents 90eb61ecd093
children
line wrap: on
line source

/*
+----------------------------------------------------------------------------
|  Project :
|  Modul   :
+----------------------------------------------------------------------------
|  Copyright 2002 Texas Instruments Berlin, AG
|                 All rights reserved.
|
|                 This file is confidential and a trade secret of Texas
|                 Instruments Berlin, AG
|                 The receipt of or possession of this file does not convey
|                 any rights to reproduce or disclose its contents or to
|                 manufacture, use, or sell anything it may describe, in
|                 whole, or in part, without the specific written consent of
|                 Texas Instruments Berlin, AG.
+----------------------------------------------------------------------------
|  Purpose :  This Modul defines the functions for processing
|             of incomming primitives for the component
|             Internet Protocol of the mobile station
+----------------------------------------------------------------------------
*/

#define ENTITY_UDP

/*==== INCLUDES ===================================================*/

#include <string.h>
#include "typedefs.h"
#include "pcm.h"
#include "pconst.cdg"
#include "mconst.cdg"
#include "message.h"
#include "ccdapi.h"
#include "vsi.h"
#include "macdef.h" /* To get PFREE_DESC2 */
#include "custom.h"
#include "gsm.h"
#include "prim.h"
#include "cnf_udp.h"
#include "mon_udp.h"
#include "pei.h"
#include "tok.h"
#include "dti.h" /* To get DTI lib */
#include "udp.h"

/*==== CONST =======================================================*/

/*==== TYPES =======================================================*/

/*==== VAR EXPORT ==================================================*/

/*==== VAR LOCAL ===================================================*/

/*==== MACROS ======================================================*/

/*==== Prototypes ==================================================*/

/*==== FUNCTIONS ===================================================*/

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                           MODULE  : UDP_KERP         |
| STATE   : code                          ROUTINE : ker_udpa_dti_req |
+--------------------------------------------------------------------+

  PURPOSE : Process UDPA_DTI_REQ primitive
*/

void ker_udpa_dti_req (T_UDPA_DTI_REQ * udpa_dti_req)
{
  BOOL confirm = TRUE;
  UBYTE dti_conn = UDPA_DISCONNECT_DTI;
  PACCESS (udpa_dti_req);

  TRACE_FUNCTION ("ker_udpa_dti_req()");

  switch (GET_STATE (KER))
  {
    case DEACTIVATED:
    {
      switch (udpa_dti_req->dti_conn)
      {
        case UDPA_CONNECT_DTI:
        {
          switch (udpa_dti_req->dti_direction)
          {
            case UDPA_DTI_TO_HIGHER_LAYER:
              if (! * udp_data->hila.entity_name)
              {
                hCommHL = vsi_c_open (
                  VSI_CALLER (char *) udpa_dti_req->entity_name
                );
                if (hCommHL > VSI_OK)
                {
                  udp_data->hila.link_id = udpa_dti_req->link_id;
                  strcpy (
                    udp_data->hila.entity_name,
                    (char *) udpa_dti_req->entity_name
                  );
                  SET_STATE (HILA, CONNECTING);
                  if (dti_open (
                    udp_hDTI,
                    UDP_DTI_DEF_INSTANCE,
                    UDP_DTI_HL_INTERFACE,
                    UDP_DTI_DEF_CHANNEL,
                    UDP_DTI_INIT_QUEUE_SIZE,
                    DTI_CHANNEL_TO_HIGHER_LAYER,
                    FLOW_CNTRL_ENABLED,
                    DTI_VERSION_10,
                    (U8 *) udpa_dti_req->entity_name,
                    udpa_dti_req->link_id
                  ) EQ TRUE)
                  {
                    confirm = FALSE;
                  }
                  else /* dti_open failed, close VSI handle: */
                  {
                    vsi_c_close (VSI_CALLER hCommHL);
                    hCommHL = VSI_ERROR;
                  }
                }
              }
              else
              {
                TRACE_ERROR ("DTI link to higher layer already requested");
              }
              break;

            case UDPA_DTI_TO_LOWER_LAYER:
              if (! * udp_data->lola.entity_name)
              {
                udp_data->lola.link_id = udpa_dti_req->link_id;
                strcpy (
                  udp_data->lola.entity_name,
                  (char *) udpa_dti_req->entity_name
                );
                SET_STATE (LOLA, CONNECTING);
                if (dti_open (
                  udp_hDTI,
                  UDP_DTI_DEF_INSTANCE,
                  UDP_DTI_LL_INTERFACE,
                  UDP_DTI_DEF_CHANNEL,
                  UDP_DTI_INIT_QUEUE_SIZE,
                  DTI_CHANNEL_TO_LOWER_LAYER,
                  FLOW_CNTRL_ENABLED,
                  DTI_VERSION_10,
                  (U8 *) udpa_dti_req->entity_name,
                  udpa_dti_req->link_id
                ) EQ TRUE)
                {
                  confirm = FALSE;
                }
              }
              else
              {
                TRACE_ERROR ("DTI link to lower layer already requested");
              }
              break;

            default:
              TRACE_ERROR("illegal parameter (udpa_dti_req->dti_direction)");
          } /* End switch (udpa_dti_req->dti_direction) */
          dti_conn = UDPA_DISCONNECT_DTI;
          break;
        }

        case UDPA_DISCONNECT_DTI:
        {
          if (udp_data->hila.link_id EQ udpa_dti_req->link_id)
          {
            dti_close (
              udp_hDTI,
              UDP_DTI_DEF_INSTANCE,
              UDP_DTI_HL_INTERFACE,
              UDP_DTI_DEF_CHANNEL,
              FALSE
            );
            *udp_data->hila.entity_name = 0;
            SET_STATE (HILA, DOWN);
            dti_conn = UDPA_DISCONNECT_DTI;

            vsi_c_close (VSI_CALLER hCommHL);
            hCommHL = VSI_ERROR;
            /*XXX check for remaining UP/DOWN-LINK DTI connections, XXX*/
            /*XXX terminate_ip() if noting left open                XXX*/
          }
          else if (udp_data->lola.link_id EQ udpa_dti_req->link_id)
          {
            dti_close (
              udp_hDTI,
              UDP_DTI_DEF_INSTANCE,
              UDP_DTI_LL_INTERFACE,
              UDP_DTI_DEF_CHANNEL,
              FALSE
            );
            *udp_data->lola.entity_name = 0;
            SET_STATE (LOLA, DOWN);
            dti_conn = UDPA_DISCONNECT_DTI;

            /*XXX check for remaining UP/DOWN-LINK DTI connections, XXX*/
            /*XXX terminate_ip() if noting left open                XXX*/
          }
          else
          {
            TRACE_ERROR ("illegal parameter (udpa_dti_req->dti_conn)");
            dti_conn = UDPA_CONNECT_DTI;
          }
        }
        break;
      } /* End switch (udpa_dti_req->dti_conn) */
      break;
    }

    case ACTIVE_NC:
      switch (udpa_dti_req->dti_conn)
      {
      case UDPA_DISCONNECT_DTI:
        if (udp_data->hila.link_id EQ udpa_dti_req->link_id)
        {
          dti_close (
            udp_hDTI,
            UDP_DTI_DEF_INSTANCE,
            UDP_DTI_HL_INTERFACE,
            UDP_DTI_DEF_CHANNEL,
            FALSE
          );
          *udp_data->hila.entity_name = 0;
          SET_STATE (HILA, DOWN);
          dti_conn = UDPA_DISCONNECT_DTI;
          SET_STATE (KER, DEACTIVATED);

          vsi_c_close (VSI_CALLER hCommHL);
          hCommHL = VSI_ERROR;
        }
        else if (udp_data->lola.link_id EQ udpa_dti_req->link_id)
        {
          dti_close (
            udp_hDTI,
            UDP_DTI_DEF_INSTANCE,
            UDP_DTI_LL_INTERFACE,
            UDP_DTI_DEF_CHANNEL,
            FALSE
          );
          *udp_data->lola.entity_name = 0;
          SET_STATE (LOLA, DOWN);
          dti_conn = UDPA_DISCONNECT_DTI;
          SET_STATE (KER, DEACTIVATED);
        }
        break;
      default:
        TRACE_ERROR ("unexpected parameter (udpa_dti_req->dti_conn)");
        dti_conn = UDPA_DISCONNECT_DTI;
        break;
      } /* End switch (udpa_dti_req->dti_conn) */
      break;

    case CONNECTED:
    default:
      TRACE_ERROR ("unexpected UDPA_DTI_REQ");
      if (udpa_dti_req->dti_conn EQ UDPA_CONNECT_DTI)
        dti_conn = UDPA_DISCONNECT_DTI;
      else
        dti_conn = UDPA_CONNECT_DTI;
      break;
  } /* End switch (GET_STATE (KER)) */

  if (confirm)
  {
    PALLOC (udpa_dti_cnf, UDPA_DTI_CNF);
    udpa_dti_cnf->dti_conn = dti_conn;
    udpa_dti_cnf->link_id = udpa_dti_req->link_id;
    PSENDX (ACI, udpa_dti_cnf);
  }
  PFREE (udpa_dti_req);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP         MODULE  : UDP_KERP                           |
| STATE   : code        ROUTINE : sig_dti_ker_tx_buffer_ready_ll_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal SIG_DTI_KER_TX_BUFFER_READY_DN_IND
*/

void sig_dti_ker_tx_buffer_ready_ll_ind ()
{
  TRACE_FUNCTION ("sig_dti_ker_tx_buffer_ready_ll_ind()");

  switch (GET_STATE (KER))
  {
  case ACTIVE_NC: /* DTI_READY_IND not received yet */
    SET_STATE (HILA, WAIT);
    break;

  case CONNECTED:
    {
      T_KER * p_ker = & udp_data->ker;
      T_HILA * p_ul = & udp_data->hila;

      /* Check if an ICMP message shall be sent */

      if (p_ker->send_icmp)
      {
        T_DTI2_DATA_REQ * dti_data_req;

        p_ker->send_icmp = FALSE;

        if(p_ker->dti_data_req_icmp)
        {
          dti_data_req = p_ker->dti_data_req_icmp;
          p_ker->dti_data_req_icmp = NULL;
        }
        else
        {
          TRACE_ERROR("no ICMP message ready!");
          return;
        }

        dti_data_req->parameters.p_id                  = DTI_PID_IP;
        dti_data_req->parameters.st_lines.st_flow      = DTI_FLOW_ON;
        dti_data_req->parameters.st_lines.st_line_sa   = DTI_SA_ON;
        dti_data_req->parameters.st_lines.st_line_sb   = DTI_SB_ON;
        dti_data_req->parameters.st_lines.st_break_len = DTI_BREAK_OFF;

        PACCESS (dti_data_req);
        {
          PPASS (dti_data_req, dti_data_ind, DTI2_DATA_IND);
          dti_send_data (
            udp_hDTI,
            UDP_DTI_DEF_INSTANCE,
            UDP_DTI_LL_INTERFACE,
            UDP_DTI_DEF_CHANNEL,
            dti_data_ind
          );
        }

        /* Call dti_start to indicate ready */

        dti_start (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_HL_INTERFACE,
          UDP_DTI_DEF_CHANNEL
        );
      }
      /* If we have got a ready indication from LL - send dti_data_req */
      else if (GET_STATE (HILA) EQ SEND AND p_ul->dti_data_req)
      {
        p_ul->dti_data_req->parameters.p_id                  = DTI_PID_IP;
        p_ul->dti_data_req->parameters.st_lines.st_flow      = DTI_FLOW_ON;
        p_ul->dti_data_req->parameters.st_lines.st_line_sa   = DTI_SA_ON;
        p_ul->dti_data_req->parameters.st_lines.st_line_sb   = DTI_SB_ON;
        p_ul->dti_data_req->parameters.st_lines.st_break_len = DTI_BREAK_OFF;

        PACCESS (p_ul->dti_data_req);
        {
          PPASS (p_ul->dti_data_req, dti_data_ind, DTI2_DATA_IND);
          dti_send_data (
            udp_hDTI,
            UDP_DTI_DEF_INSTANCE,
            UDP_DTI_LL_INTERFACE,
            UDP_DTI_DEF_CHANNEL,
            dti_data_ind
          );
        }
        p_ul->dti_data_req = NULL;
        dti_start (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_HL_INTERFACE,
          UDP_DTI_DEF_CHANNEL
        );
      }
      else
      {
        SET_STATE (HILA, WAIT);
      }
    }
    break;

  default:
    break;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP           MODULE  : UDP_KERP                         |
| STATE   : code          ROUTINE : sig_dti_ker_data_received_hl_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal SIG_DTI_KER_DATA_RECEIVED_UP_IND
*/

void sig_dti_ker_data_received_hl_ind (T_DTI2_DATA_REQ * dti_data_req)
{
  PACCESS (dti_data_req);

  TRACE_FUNCTION ("sig_dti_ker_data_received_hl_ind()");

  switch (GET_STATE (KER))
  {
  case CONNECTED:
    {
      T_HILA * p_ul = & udp_data->hila;
      T_KER * p_ker = & udp_data->ker;

      dti_stop (
        udp_hDTI,
        UDP_DTI_DEF_INSTANCE,
        UDP_DTI_HL_INTERFACE,
        UDP_DTI_DEF_CHANNEL
      );

#ifdef _SIMULATION_
      /* Get the T_SRC_DES out of the first and only descriptor
       * created by DTILIB and put it in a descriptor of its own */

      if (dti_data_req->desc_list2.first &&
          dti_data_req->desc_list2.list_len >= sizeof(T_SRC_DES))
      {
        // The following is mostly taken from UDPa_sendRequest() from module
        // wap_udpc.c to achieve the same behaviour. (Issue UDP-FIX-21925)
        // The desc from the desc_list2 is splitted into a linked desc list
        // to simulate large data chunks (such large data chunks are spread over
        // in several decs in the list).
        T_desc2    *desc, *first_desc;
        ULONG      *pLast;
        USHORT     len, dataSize, data_length;
        const char *data_p;
        USHORT     BLOCK_SIZE = 50;

        first_desc = (T_desc2 *) dti_data_req->desc_list2.first;
        data_length = dti_data_req->desc_list2.list_len;

        /* Build the T_desc2 for IP addresses and ports */
        desc = M_ALLOC (offsetof (T_desc2, buffer) + sizeof (T_SRC_DES));
        
        // update the desc list
        dti_data_req->desc_list2.first = (ULONG) desc;
        desc->offset = 0;
        desc->len = sizeof (T_SRC_DES);
        desc->size = sizeof (T_SRC_DES);

        // copy IP addresses and ports
        memcpy(desc->buffer, &first_desc->buffer[first_desc->offset],desc->len);
        
        /* Build the desc for the UDP data */
        pLast = &desc->next;
        len = data_length - desc->len;
        data_p = &first_desc->buffer [first_desc->offset + desc->len];;
        while (len >0)
        {
          if (len > BLOCK_SIZE)
          {
            dataSize = BLOCK_SIZE;
          }
          else
          {
            dataSize = len;
          }
          MALLOC (desc, (USHORT)(sizeof(T_desc2) - 1 + dataSize));
          memcpy( desc->buffer, data_p, dataSize);
          desc->offset = 0;
          desc->len = dataSize;
          desc->size = dataSize;
          len        -= dataSize;
          data_p     += dataSize;
          *pLast      = (ULONG) desc;
          pLast       = &desc->next;
        }

        MFREE (first_desc);
      }
#endif /* _SIMULATION_ */

      p_ul->dti_data_req = dti_data_req;

      if (p_ul->drop_packet)
      {
        p_ul->drop_packet = FALSE;
        PFREE_DESC2 (p_ul->dti_data_req);
        p_ul->dti_data_req = NULL;
        dti_start (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_LL_INTERFACE,
          UDP_DTI_DEF_CHANNEL
        );
      }
      else
      {
        /* Get the IP addresses and the ports from HL */

        T_desc2 * desc = (T_desc2 *) p_ul->dti_data_req->desc_list2.first;
        T_SRC_DES * p_SrcDes;
        USHORT old_len;

        if (desc == NULL) {
          TRACE_ERROR (
            "Hila's T_desc2 is NULL in "
            "sig_dti_ker_data_received_hl_ind()."
          );
          return;
        }

        p_SrcDes = (T_SRC_DES *) (desc->buffer + desc->offset);

        memcpy (& p_ker->src_addr, p_SrcDes->src_ip, 4);
        memcpy (& p_ker->dst_addr, p_SrcDes->des_ip, 4);
        memcpy (& p_ker->src_port, p_SrcDes->src_port, 2);
        memcpy (& p_ker->dst_port, p_SrcDes->des_port, 2);

        old_len = p_ul->dti_data_req->desc_list2.list_len;
        p_ul->dti_data_req->desc_list2.first = desc->next;
        p_ul->dti_data_req->desc_list2.list_len =
          (USHORT) (old_len - sizeof (T_SRC_DES));
        p_ul = & udp_data->hila;
        MFREE (desc);
      }

      /* Send IP_ADDR_REQ to LL */
      {
        PALLOC (ip_addr_req, IP_ADDR_REQ);
        ip_addr_req->dst_addr = p_ker->dst_addr;
        ip_addr_req->trans_prot = UDP_PROTOCOL;
        PSENDX (LL, ip_addr_req);
      }
    }
    break;

  default:
    PFREE_DESC2 (dti_data_req);
    break;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                            MODULE  : udp_kerp.c      |
| STATE   : code                           ROUTINE : ker_ip_addr_cnf |
+--------------------------------------------------------------------+

  PURPOSE : Process primitive T_IP_ADDR_CNF
*/

void ker_ip_addr_cnf (T_IP_ADDR_CNF * ip_addr_cnf)
{
  TRACE_FUNCTION ("ker_ip_addr_cnf()");
  PACCESS (ip_addr_cnf);

  switch (GET_STATE (KER))
  {
  case CONNECTED:
    {
      T_KER * p_ker = & udp_data->ker;
      T_HILA * p_ul = & udp_data->hila;
      BOOL send_ready_ind = FALSE;

      /* No error ? */
      if (ip_addr_cnf->err NEQ IP_ADDR_NOERROR)
      {
        PALLOC (udp_error_ind, UDP_ERROR_IND);
        udp_error_ind->dst_port = p_ker->dst_port;
        udp_error_ind->src_port = p_ker->src_port;
        udp_error_ind->err_msg  = ip_addr_cnf->err;
        udp_error_ind->src_addr = ip_addr_cnf->src_addr;
        udp_error_ind->dst_addr = p_ker->dst_addr;
        PSENDX (HL, udp_error_ind);
        p_ul->drop_packet = TRUE; /* Packet error - drop it */
      }
      /* Is the address correct ? */
      else if (ip_addr_cnf->src_addr NEQ p_ker->src_addr)
      {
        PALLOC (udp_error_ind, UDP_ERROR_IND);
        udp_error_ind->dst_port = p_ker->dst_port;
        udp_error_ind->src_port = p_ker->src_port;
        udp_error_ind->err_msg  = IP_ADDR_NOROUTE;
        udp_error_ind->src_addr = ip_addr_cnf->src_addr;
        udp_error_ind->dst_addr = p_ker->dst_addr;
        PSENDX (HL, udp_error_ind);
        p_ul->drop_packet = TRUE; /* Packet error - drop it */
      }
      else /* Build the "standard" packet for higher layer */
      {
        udp_build_packet (TRUE, B_NORMAL_PACKET);
      }

      /* ICMP sent at first */
      if (p_ker->send_icmp && GET_STATE (HILA) EQ WAIT)
      {
        T_DTI2_DATA_REQ * dti_data_req;
        dti_data_req = p_ker->dti_data_req_icmp;
        dti_data_req->parameters.p_id                  = DTI_PID_IP;
        dti_data_req->parameters.st_lines.st_flow      = DTI_FLOW_ON;
        dti_data_req->parameters.st_lines.st_line_sa   = DTI_SA_ON;
        dti_data_req->parameters.st_lines.st_line_sb   = DTI_SB_ON;
        dti_data_req->parameters.st_lines.st_break_len = DTI_BREAK_OFF;

        PACCESS (dti_data_req);
        {
          PPASS (dti_data_req, dti_data_ind, DTI2_DATA_IND);
          dti_send_data (
            udp_hDTI,
            UDP_DTI_DEF_INSTANCE,
            UDP_DTI_LL_INTERFACE,
            UDP_DTI_DEF_CHANNEL,
            dti_data_ind
          );
        }
        p_ker->dti_data_req_icmp = NULL;
        SET_STATE (HILA, SEND);

        /* Call dti_start to indicate ready for new packet */
        dti_start (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_LL_INTERFACE,
          UDP_DTI_DEF_CHANNEL
        );
      }

      /* Packet not correct - drop it */
      if (p_ul->drop_packet)
      {
        p_ul->drop_packet = FALSE;
        PFREE_DESC2 (p_ul->dti_data_req);
        p_ul->dti_data_req = NULL;
        send_ready_ind = TRUE;
      }
      else
      {
        /* We have got a ready indication from LL -> send */

        if (GET_STATE (HILA) EQ WAIT) /* Send dti_data_req packet */
        {
          p_ul->dti_data_req->parameters.p_id                 = DTI_PID_IP;
          p_ul->dti_data_req->parameters.st_lines.st_flow     = DTI_FLOW_ON;
          p_ul->dti_data_req->parameters.st_lines.st_line_sa  = DTI_SA_ON;
          p_ul->dti_data_req->parameters.st_lines.st_line_sb  = DTI_SB_ON;
          p_ul->dti_data_req->parameters.st_lines.st_break_len=DTI_BREAK_OFF;

          PACCESS (p_ul->dti_data_req);
          {
            PPASS (p_ul->dti_data_req, dti_data_ind, DTI2_DATA_IND);
            dti_send_data (
              udp_hDTI,
              UDP_DTI_DEF_INSTANCE,
              UDP_DTI_LL_INTERFACE,
              UDP_DTI_DEF_CHANNEL,
              dti_data_ind
            );
          }
          SET_STATE (HILA, IDLE);
          send_ready_ind = TRUE;
          p_ul->dti_data_req = NULL;
        }
        else
        {
          SET_STATE (HILA, SEND);
          send_ready_ind = FALSE;
        }
      }

      /* Send dti_ready indication */
      if (send_ready_ind)
      {
        dti_start (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_HL_INTERFACE,
          UDP_DTI_DEF_CHANNEL
        );
      }
      PFREE (ip_addr_cnf);
    }
    break;

    default:
      PFREE (ip_addr_cnf);
      break;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP           MODULE  : udp_kerp.c                       |
| STATE   : code          ROUTINE : sig_dti_ker_data_received_ll_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal SIG_DTI_KER_DATA_RECEIVED_DN_IND
*/

void sig_dti_ker_data_received_ll_ind (T_DTI2_DATA_IND * dti_data_ind)
{
  TRACE_FUNCTION ("sig_dti_ker_data_received_ll_ind()");
  PACCESS (dti_data_ind);

  switch (GET_STATE (KER))
  {
  case CONNECTED:
    {
      USHORT calc_chksum, header_chksum, start_udp, udp_len;
      UBYTE prot;
      BOOL send_getdata_req = FALSE;
      UBYTE * ip_header;
      T_desc_list2 * desc_list;
      T_desc2 * desc;

      T_KER * p_ker = & udp_data->ker;
      T_LOLA * p_dl = & udp_data->lola;

      dti_stop (
        udp_hDTI,
        UDP_DTI_DEF_INSTANCE,
        UDP_DTI_LL_INTERFACE,
        UDP_DTI_DEF_CHANNEL
      );

      /* Build necessary variable */

      p_dl->dti_data_ind = dti_data_ind;
      p_dl->state_err = STATE_DL_NO_ERROR;

      desc_list = & p_dl->dti_data_ind->desc_list2;
      desc = (T_desc2 *) desc_list->first;

      if (
        desc == NULL ||
        desc->len < LEN_IP_HEADER_B ||
        GET_IP_HEADER_LEN_B (desc->buffer + desc->offset) < LEN_IP_HEADER_B ||
        desc->len < GET_IP_HEADER_LEN_B (desc->buffer + desc->offset) +
          LEN_UDP_HEADER_B
      ) {
        TRACE_ERROR (
          "Lola's UDP packet is too short in "
          "sig_dti_ker_data_received_ll_ind()."
        );
        return;
      }

      ip_header = desc->buffer + desc->offset;
      start_udp = (USHORT) GET_IP_HEADER_LEN_B (ip_header);

      /* Fill in port numbers and IP addresses */

      p_dl->src_addr = GET_IP_SOURCE_ADDR (ip_header);
      p_dl->dst_addr = GET_IP_DEST_ADDR (ip_header);
      p_dl->src_port = (USHORT) GET_UDP_SRC_PORT (ip_header, start_udp);
      p_dl->dst_port = (USHORT) GET_UDP_DST_PORT (ip_header, start_udp);

      udp_len = (USHORT) GET_UDP_LEN (ip_header, start_udp);
      prot = GET_IP_PROT (ip_header);

      /* Check if ICMP Message, if yes - send UDP_ERROR_IND */

      if (GET_IP_PROT (ip_header) EQ ICMP_PROT)
      {
        USHORT pos_icmp = (USHORT) GET_IP_HEADER_LEN_B (ip_header);

        p_dl->drop_packet = TRUE;
        p_dl->state_err = STATE_DL_ERROR;
        {
          PALLOC (udp_error_ind, UDP_ERROR_IND);
          udp_error_ind->dst_port = p_dl->dst_port;
          udp_error_ind->src_port = p_dl->src_port;
          udp_error_ind->err_msg  = GET_ICMP_TYPE (ip_header, pos_icmp);
          udp_error_ind->src_addr = GET_IP_SOURCE_ADDR (ip_header);
          udp_error_ind->dst_addr = GET_IP_DEST_ADDR (ip_header);
          PSENDX (HL, udp_error_ind);
        }
      }
      else /* No ICMP_PROT */
      {
        {
          ULONG overlay;
          UBYTE pseudo_header [LEN_PSEUDO_HEADER_B];

          /* Build the pseudoheader for the calculation of the checksum */

          SET_UDP_PSEUDO_H_SRC_ADDR (pseudo_header, p_dl->src_addr);
          SET_UDP_PSEUDO_H_DEST_ADDR (pseudo_header, p_dl->dst_addr);
          SET_UDP_PSEUDO_H_ZERO (pseudo_header, 0);
          SET_UDP_PSEUDO_H_PROT (pseudo_header, prot);
          SET_UDP_PSEUDO_H_LEN (pseudo_header, udp_len);

          /* Calculate a part of the checksum for the pseudoheader */
          overlay = partial_checksum (pseudo_header, LEN_PSEUDO_HEADER_B);

          /* Calculate for the UDP header and the data */
          header_chksum = (USHORT) GET_UDP_CHK_SUM (ip_header, start_udp);
          RESET_UDP_CHKSUM (ip_header, start_udp);
          calc_chksum = desc_checksum (desc_list, start_udp, overlay);
          SET_UDP_CHKSUM (ip_header, start_udp, header_chksum);
        }

        /* Packet checksum error ? */
        if (header_chksum NEQ calc_chksum)
        {
          p_dl->drop_packet = TRUE;
        }
        else
        {

#define POS_UDP_DEST_PORT 1


          /* Is it the correct port ? */
          if (p_ker->src_port EQ p_dl->dst_port)
          {
            udp_build_packet (FALSE, B_NORMAL_PACKET);
          }
          else
          {
            /* Build ICMP packet for no dest port.
             * If LL is ready to collect then send */
            udp_build_packet (FALSE, B_NO_DEST_PORT);
            p_ker->send_icmp = TRUE;
          }
        }
      } /* No ICMP_PROT */

      /* Packet is not correct -> drop it and free the primitive */
      if (p_dl->drop_packet)
      {
        p_dl->drop_packet = FALSE;
        PFREE_DESC2 (p_dl->dti_data_ind);
        p_dl->dti_data_ind = NULL;
        send_getdata_req = TRUE;
      }
      else
      {
        /* An ICMP message - send it */
        if (p_ker->send_icmp)
        {
          UBYTE state = GET_STATE (LOLA);
          if (state EQ IDLE OR state EQ WAIT)
          {
            T_DTI2_DATA_REQ * dti_data_req;

            udp_data->ker.send_icmp = FALSE;

            dti_data_req = p_ker->dti_data_req_icmp;
            dti_data_req->parameters.p_id                  = DTI_PID_IP;
            dti_data_req->parameters.st_lines.st_flow      = DTI_FLOW_ON;
            dti_data_req->parameters.st_lines.st_line_sa   = DTI_SA_ON;
            dti_data_req->parameters.st_lines.st_line_sb   = DTI_SB_ON;
            dti_data_req->parameters.st_lines.st_break_len = DTI_BREAK_OFF;

            PACCESS (dti_data_req);
            {
              PPASS (dti_data_req, dti_data_indication, DTI2_DATA_IND);
              dti_send_data (
                udp_hDTI,
                UDP_DTI_DEF_INSTANCE,
                UDP_DTI_LL_INTERFACE,
                UDP_DTI_DEF_CHANNEL,
                dti_data_indication
              );
            }
            SET_STATE (LOLA, IDLE);
            p_ker->dti_data_req_icmp = NULL;
            send_getdata_req = TRUE;
          }
        }
        else
        {
          /* We have got a DTI2_GETDATA_REQ from LL. Send the packet. */

          if (GET_STATE (LOLA) EQ WAIT)
          {
            SET_STATE (LOLA, IDLE);

            p_dl->dti_data_ind->parameters.p_id = DTI_PID_IP;
            p_dl->dti_data_ind->parameters.st_lines.st_flow = DTI_FLOW_ON;
            p_dl->dti_data_ind->parameters.st_lines.st_line_sa = DTI_SA_ON;
            p_dl->dti_data_ind->parameters.st_lines.st_line_sb = DTI_SB_ON;
            p_dl->dti_data_ind->parameters.st_lines.st_break_len =
              DTI_BREAK_OFF;

            dti_send_data (
              udp_hDTI,
              UDP_DTI_DEF_INSTANCE,
              UDP_DTI_HL_INTERFACE,
              UDP_DTI_DEF_CHANNEL,
              p_dl->dti_data_ind
            );
            send_getdata_req = TRUE;
            p_dl->dti_data_ind = NULL;
          }
          else
          {
            SET_STATE (LOLA, SEND);
          }
        }
      }

      if (send_getdata_req) /* Send DTI2_GETDATA_REQ to LL */
      {
        dti_start (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_LL_INTERFACE,
          UDP_DTI_DEF_CHANNEL
        );
      }
    }
    break;

  default:
    PFREE_DESC2 (dti_data_ind);
    break;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP         MODULE  : udp_kerp.c                         |
| STATE   : code        ROUTINE : sig_dti_ker_tx_buffer_ready_hl_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal SIG_DTI_KER_TX_BUFFER_READY_UP_IND
*/

void sig_dti_ker_tx_buffer_ready_hl_ind ()
{
  TRACE_FUNCTION ("sig_dti_ker_tx_buffer_ready_hl_ind()");

  switch (GET_STATE (KER))
  {
  case CONNECTED:
    {
      T_KER * p_ker = & udp_data->ker;
      T_LOLA * p_dl = & udp_data->lola;

      /* We have bound a port and got a DTI_GETDATA_REQ */

      if (p_ker->port_state EQ PORT_BOUND)
      {
        p_ker->port_state = PORT_ACTIVE;
        dti_start (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_HL_INTERFACE,
          UDP_DTI_DEF_CHANNEL
        );
      }

      /* Send dti_data_ind packet if we have one */

      if (GET_STATE (LOLA) EQ SEND)
      {
        p_dl->dti_data_ind->parameters.p_id                  = DTI_PID_IP;
        p_dl->dti_data_ind->parameters.st_lines.st_flow      = DTI_FLOW_ON;
        p_dl->dti_data_ind->parameters.st_lines.st_line_sa   = DTI_SA_ON;
        p_dl->dti_data_ind->parameters.st_lines.st_line_sb   = DTI_SB_ON;
        p_dl->dti_data_ind->parameters.st_lines.st_break_len = DTI_BREAK_OFF;

        dti_send_data (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_HL_INTERFACE,
          UDP_DTI_DEF_CHANNEL,
          p_dl->dti_data_ind
        );
        p_dl->dti_data_ind = NULL;
        SET_STATE (LOLA, IDLE);

        /* Send DTI2_GETDATA_REQ and indicate ready for new packet */

        dti_start (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_LL_INTERFACE,
          UDP_DTI_DEF_CHANNEL
        );
      }
      else
      {
        /* No data packet to be sent - change state */
        SET_STATE (LOLA, WAIT);
      }
    }
    break;
  default:
    break;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                           MODULE  : udp_kerp.c       |
| STATE   : code                          ROUTINE : ker_udp_bind_cnf |
+--------------------------------------------------------------------+

  PURPOSE : Process primitive T_UDP_BIND_CNF
*/

static void ker_udp_bind_cnf (U16 port, U8 err)
{
  PALLOC (udp_bind_cnf, UDP_BIND_CNF);

  TRACE_FUNCTION ("ker_udp_bind_cnf()");

  udp_bind_cnf->port = port;
  udp_bind_cnf->err = err;
  PSENDX (HL, udp_bind_cnf);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                           MODULE  : udp_kerp.c       |
| STATE   : code                          ROUTINE : ker_udp_bind_req |
+--------------------------------------------------------------------+

  PURPOSE : Process primitive T_UDP_BIND_REQ
*/

void ker_udp_bind_req (T_UDP_BIND_REQ * udp_bind_req)
{
  TRACE_FUNCTION ("ker_udp_bind_req()");
  PACCESS (udp_bind_req);

  switch (GET_STATE (KER))
  {
  case ACTIVE_NC:
    ker_udp_bind_cnf (udp_bind_req->port, UDP_BIND_UDPDOWN);
    break;

  case CONNECTED:
    {
      T_KER * p_ker = & udp_data->ker;

      if (p_ker->port_state EQ PORT_DOWN)
      {
        if (udp_bind_req->port EQ NO_PORT)
        {
          p_ker->src_port = 1025;
        }
        else
        {
          p_ker->src_port = udp_bind_req->port;
        }
        p_ker->port_state = PORT_BOUND;
        ker_udp_bind_cnf (p_ker->src_port, UDP_BIND_NOERROR);
      }
      else /* Port in use */
      {
        ker_udp_bind_cnf (udp_bind_req->port, UDP_BIND_PORTINUSE);
      }
    }
    break;

  case DEACTIVATED:
    TRACE_ERROR ("unexpected UDP_BIND_REQ");
    break;

  default:
    break;
  }
  PFREE (udp_bind_req);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                      MODULE  : udp_kerp.c            |
| STATE   : code                     ROUTINE : ker_udp_closeport_req |
+--------------------------------------------------------------------+

  PURPOSE : Process primitive T_UDP_CLOSEPORT_REQ
*/

void ker_udp_closeport_req (T_UDP_CLOSEPORT_REQ * udp_closeport_req)
{
  T_KER * p_ker;

  TRACE_FUNCTION ("ker_udp_closeport_req()");
  PACCESS (udp_closeport_req);

  p_ker = & udp_data->ker;

  switch (GET_STATE (KER))
  {
  case ACTIVE_NC:
  case CONNECTED:
    /* Close port */
    p_ker->src_port = NO_PORT;
    p_ker->port_state = PORT_DOWN;
    {
      PALLOC (udp_closeport_cnf, UDP_CLOSEPORT_CNF);
      PSENDX (HL, udp_closeport_cnf);
    }
    break;

  case DEACTIVATED:
    TRACE_ERROR ("unexpected UDP_CLOSEPORT_REQ");
    break;

  default:
    break;
  }
  PFREE (udp_closeport_req);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                          MODULE  : udp_kerp.c        |
| STATE   : code                         ROUTINE : ker_udp_error_res |
+--------------------------------------------------------------------+

  PURPOSE : Process primitive T_UDP_ERROR_RES
*/

void ker_udp_error_res (T_UDP_ERROR_RES * udp_error_res)
{
  TRACE_FUNCTION ("ker_udp_error_res()");
  PACCESS (udp_error_res);

  /* Confirm the error message from ACI */

  switch (GET_STATE (KER))
  {
  case CONNECTED:
    {
      T_LOLA * p_dl = & udp_data->lola;

      if (p_dl->state_err EQ STATE_DL_ERROR)
        p_dl->state_err = STATE_DL_NO_ERROR;
      else
        dti_start (
          udp_hDTI,
          UDP_DTI_DEF_INSTANCE,
          UDP_DTI_LL_INTERFACE,
          UDP_DTI_DEF_CHANNEL
        );
    }
    break;
  default:
    break;
  }
  PFREE (udp_error_res);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP       MODULE  : UDP_KERP                             |
| STATE   : code      ROUTINE : sig_dti_ker_connection_opened_hl_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal sig_dti_ker_connection_opened_hl_ind
*/

void sig_dti_ker_connection_opened_hl_ind ()
{
  TRACE_FUNCTION ("sig_dti_ker_connection_opened_hl_ind()");

  if (GET_STATE (HILA) EQ CONNECTING)
  {
    UBYTE state = GET_STATE (LOLA);
    SET_STATE (HILA, IDLE);
    if (state NEQ CONNECTING AND state NEQ DOWN)
    {
      SET_STATE (KER, ACTIVE_NC);
    }
    {
      PALLOC (udpa_dti_cnf, UDPA_DTI_CNF);
      udpa_dti_cnf->link_id = udp_data->hila.link_id;
      udpa_dti_cnf->dti_conn = UDPA_CONNECT_DTI;
      PSENDX (ACI, udpa_dti_cnf);
    }
  }
  else
  {
    TRACE_ERROR ("unexpected dti_connect_ind (from higher layer)");
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP       MODULE  : UDP_KERP                             |
| STATE   : code      ROUTINE : sig_dti_ker_connection_opened_ll_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal sig_dti_ker_connection_opened_ll_ind
*/

void sig_dti_ker_connection_opened_ll_ind ()
{
  TRACE_FUNCTION ("sig_dti_ker_connection_opened_ll_ind()");

  if (GET_STATE (LOLA) EQ CONNECTING)
  {
    UBYTE state = GET_STATE (HILA);
    SET_STATE (LOLA, IDLE);
    if (state NEQ CONNECTING AND state NEQ DOWN)
    {
      SET_STATE (KER, ACTIVE_NC);
    }
    {
      PALLOC (udpa_dti_cnf, UDPA_DTI_CNF);
      udpa_dti_cnf->link_id = udp_data->lola.link_id;
      udpa_dti_cnf->dti_conn = UDPA_CONNECT_DTI;
      PSENDX (ACI, udpa_dti_cnf);
    }
  }
  else
  {
    TRACE_ERROR ("unexpected dti_connect_ind (from lower layer)");
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                       MODULE  : udp_kerp.c           |
| STATE   : code                      ROUTINE : ker_udp_shutdown_ind |
+--------------------------------------------------------------------+

  PURPOSE :
*/

static void ker_udpa_dti_ind (ULONG link_id)
{
  PALLOC (udpa_dti_ind, UDPA_DTI_IND);
  udpa_dti_ind->link_id = link_id;
  PSENDX (ACI, udpa_dti_ind);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                       MODULE  : udp_kerp.c           |
| STATE   : code                      ROUTINE : ker_udp_shutdown_ind |
+--------------------------------------------------------------------+

  PURPOSE :
*/

static void ker_udp_shutdown_ind (void)
{
  PALLOC (udp_shutdown_ind, UDP_SHUTDOWN_IND);
  PSENDX (HL, udp_shutdown_ind);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                    MODULE  : udp_kerp.c              |
| STATE   : code                   ROUTINE : check_port_shutdown_ind |
+--------------------------------------------------------------------+

  PURPOSE :
*/

static void check_port_shutdown_ind (void)
{
  T_KER * p_ker = & udp_data->ker;

  TRACE_FUNCTION ("check_port_shutdown_ind()");

  if (p_ker->port_state EQ PORT_ACTIVE)
  {
    p_ker->src_port = NO_PORT;
    p_ker->port_state = PORT_DOWN;
    ker_udp_shutdown_ind ();
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP       MODULE  : UDP_KERP                             |
| STATE   : code      ROUTINE : sig_dti_ker_connection_closed_hl_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal sig_dti_ker_connection_closed_hl_ind
*/

void sig_dti_ker_connection_closed_hl_ind ()
{
  TRACE_FUNCTION ("sig_dti_ker_connection_closed_hl_ind()");

  switch (GET_STATE (KER))
  {
  case CONNECTED:
    /*XXX bad case, switch to DEACTIVATED, prune buffers... XXX*/
    TRACE_ERROR ("unexpected DTI connection close from higher layer");
    check_port_shutdown_ind ();
    SET_STATE (KER, DEACTIVATED);
    break;
  case ACTIVE_NC:
    SET_STATE (KER, DEACTIVATED);
    break;
  default:
    break;
  }
  vsi_c_close (VSI_CALLER hCommHL);
  hCommHL = VSI_ERROR;

  SET_STATE (HILA, DOWN);
  *udp_data->hila.entity_name = 0;
  ker_udpa_dti_ind (udp_data->hila.link_id);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP       MODULE  : UDP_KERP                             |
| STATE   : code      ROUTINE : sig_dti_ker_connection_closed_ll_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal sig_dti_ker_connection_closed_ll_ind
*/

void sig_dti_ker_connection_closed_ll_ind ()
{
  TRACE_FUNCTION ("sig_dti_ker_connection_closed_ll_ind()");

  switch (GET_STATE (KER))
  {
  case CONNECTED:
    /*XXX bad case, switch to DEACTIVATED, prune buffers... XXX*/
    TRACE_ERROR ("unexpected DTI connection close from lower layer");
    check_port_shutdown_ind ();
    SET_STATE (KER, DEACTIVATED);
    break;
  case ACTIVE_NC:
    SET_STATE (KER, DEACTIVATED);
    break;
  default:
    break;
  }
  SET_STATE (LOLA, DOWN);
  *udp_data->lola.entity_name = 0;
  ker_udpa_dti_ind (udp_data->lola.link_id);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                        MODULE  : udp_kerp.c          |
| STATE   : code                       ROUTINE : ker_udpa_config_req |
+--------------------------------------------------------------------+

  PURPOSE : Process primitive T_UDPA_CONFIG_REQ
*/

void ker_udpa_config_req (T_UDPA_CONFIG_REQ * udpa_config_req)
{
  TRACE_FUNCTION ("ker_udpa_config_req()");
  PACCESS (udpa_config_req);

  /* Configuration of lower layer -> change to state CONNECTED */

  switch (GET_STATE (KER))
  {
  case CONNECTED:
    switch (udpa_config_req->cmd)
    {
    case UDPA_CONFIG_DOWN:
      check_port_shutdown_ind ();
      SET_STATE (KER, ACTIVE_NC);
      {
        PALLOC (udpa_config_cnf, UDPA_CONFIG_CNF);
        PSENDX (ACI, udpa_config_cnf);
      }
     break;
    default:
      break;
    }
    break;

  case ACTIVE_NC:
    switch (udpa_config_req->cmd)
    {
    case UDPA_CONFIG_UP:
      dti_start (
        udp_hDTI,
        UDP_DTI_DEF_INSTANCE,
        UDP_DTI_LL_INTERFACE,
        UDP_DTI_DEF_CHANNEL
      );
      SET_STATE (KER, CONNECTED);
      TRACE_EVENT ("KER -> CONNECTED");
      {
        PALLOC (udpa_config_cnf, UDPA_CONFIG_CNF);
        PSENDX (ACI, udpa_config_cnf);
      }
      break;
    case UDPA_CONFIG_DOWN:
      {
        PALLOC (udpa_config_cnf, UDPA_CONFIG_CNF);
        PSENDX (ACI, udpa_config_cnf);
      }
      break;
    default:
      break;
    }
    break;
  default:
    break;
  }
  PFREE (udpa_config_req);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP                       MODULE  : udp_kerp.c           |
| STATE   : code                      ROUTINE : ker_udp_shutdown_res |
+--------------------------------------------------------------------+

  PURPOSE : Process primitive T_UDP_SHUTDOWN_RES
*/

void ker_udp_shutdown_res (T_UDP_SHUTDOWN_RES * udp_shutdown_res)
{
  TRACE_FUNCTION ("DUMMY ker_udp_shutdown_res()");
  PACCESS (udp_shutdown_res);
  PFREE (udp_shutdown_res);
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP          MODULE  : udp_kerp.c                        |
| STATE   : code         ROUTINE : sig_dti_ker_tx_buffer_full_hl_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal SIG_DTI_KER_TX_BUFFER_FULL_UP_IND
*/

void sig_dti_ker_tx_buffer_full_hl_ind ()
{
  TRACE_FUNCTION ("DUMMY sig_dti_ker_tx_buffer_full_hl_ind()");
}

/*
+--------------------------------------------------------------------+
| PROJECT : WAP          MODULE  : UDP_KERP                          |
| STATE   : code         ROUTINE : sig_dti_ker_tx_buffer_full_ll_ind |
+--------------------------------------------------------------------+

  PURPOSE : Process signal SIG_DTI_KER_TX_BUFFER_FULL_DN_IND
*/

void sig_dti_ker_tx_buffer_full_ll_ind ()
{
  TRACE_FUNCTION ("DUMMY sig_dti_ker_tx_buffer_full_ll_ind()");
}

/*-------------------------------------------------------------------------*/