/*
+-----------------------------------------------------------------------------
|  Project :  GPRS (8441)
|  Modul   :  sndcp_ciap.c
+-----------------------------------------------------------------------------
|  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 is part of the entity SNDCP and implements all
|             functions to handles the incoming primitives as described in
|             the SDL-documentation (CIA-statemachine)
+-----------------------------------------------------------------------------
*/


#define ENTITY_SNDCP

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

#include "typedefs.h"  /* to get Condat data types */
#include "vsi.h"       /* to get a lot of macros */
#include "macdef.h"
#include "gsm.h"       /* to get a lot of macros */
#include "prim.h"      /* to get the definitions of used SAP and directions */

#include "dti.h"

#include "sndcp.h"     /* to get the global entity definitions */
#include "sndcp_f.h"   /* to get the functions to access the global arrays*/

#include <string.h>    /* to get memcpy() */
#include "sndcp_mgf.h" /* to get the local functions of service mg */
#include "sndcp_sus.h" /* to get signals to service su */
#include "sndcp_suas.h"/* to get signals to service sua */
#include "sndcp_sds.h" /* to get signals to service sd */
#include "sndcp_sdas.h"/* to get signals to service sda */
#include "sndcp_ciap.h"


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


/*==== LOCAL VARS ===========================================================*/

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

/*
+------------------------------------------------------------------------------
| Function    : cia_vj_decomp
+------------------------------------------------------------------------------
| Description : decompresses the TCP/IP header of the given packet
|               (Van Jacobson algorithm). A part of this routine has been taken
|               from implementation of University of California, Berkeley.
|
| Parameters  : com_buf - received packet, packet length, packet type
|
| Return      : new packet length
|
+------------------------------------------------------------------------------
*/
#ifndef CF_FAST_EXEC

LOCAL USHORT cia_vj_decomp(struct comp_buf *cbuf)
{
  struct slcompress         *comp = &sndcp_data->cia.comp;
  UBYTE                     *cp;     /* pointer to the compressed TCP/IP packet */
  UBYTE                     hlen = 0;
  ULONG                     change_mask = 0;
  T_SNDCP_TCP_HEADER        *th;
  struct cstate             *cs;
  ULONG                     tmp;
  USHORT                    th_off;

  TRACE_FUNCTION( "cia_vj_decomp" );

  switch (cbuf->p_type) {

  case TYPE_UNCOMPRESSED_TCP:
  {
    UBYTE *hdr_ptr = (UBYTE*)cbuf->c_hdr;
    UBYTE slot_nr   = hdr_ptr[9];
    if (slot_nr >= sndcp_data->cia.comp.slots_to_use){
      TRACE_EVENT_P2("ERROR DECOMP: slot_nr(%d) > slots_to_use(%d)",
                     slot_nr, sndcp_data->cia.comp.slots_to_use);
      comp->flags |= SLF_TOSS;
      return (0);
    }
    /* set last received state */
    comp->last_recv = slot_nr;
    /* get related compressed state */
    cs = &comp->rstate[comp->last_recv];
    /* clear toss flag */
    comp->flags &=~ SLF_TOSS;
    /* set protocol type to TCP/IP */
    hdr_ptr[9] = PROT_TCPIP;
    /* get IP header length */
    hlen = hdr_ptr[0] & HL_MASK;
    /* get TCP header */
    th_off = hdr_ptr[hlen*4 + 12];
    th_off = (th_off & 0xf0) >> 4;
    /* calculate IP+TCP header length  */
    hlen += th_off;
    hlen <<= 2;
    /* copy TCP+IP header */
    memcpy(cs->cs_ip, hdr_ptr, hlen);
    cs->cs_ip->ip_sum = 0;
    cs->cs_hlen = hlen;
    return ((USHORT)cbuf->pack_len);
  }

  case TYPE_COMPRESSED_TCP:
    break;

  default:
    comp->flags |= SLF_TOSS;
    TRACE_EVENT_P1("ERROR DECOMP unknown packet type (%d)", cbuf->p_type);
    return (0);
  }

  /* We've got a compressed packet. */
  cp = (UBYTE *)cbuf->c_hdr;
  change_mask = *cp++;
  if (change_mask & NEW_C) {
    /* Make sure the state index is in range, then grab the state.
     * If we have a good state index, clear the 'discard' flag. */
    if (*cp >= sndcp_data->cia.comp.slots_to_use){
      comp->flags |= SLF_TOSS;
      return (0);
    }

    comp->flags &=~ SLF_TOSS;
    /* store connection number */
    comp->last_recv = *cp++;
  } else {
    /* this packet has an implicit state index.  If we've
     * had a line error since the last time we got an
     * explicit state index, we have to toss the packet. */
    if (comp->flags & SLF_TOSS) {
      return (0);
    }
  }
  /* get related connection state */
  cs = &comp->rstate[comp->last_recv];
  /* get IP header length */
  hlen = (cs->cs_ip->ip_vhl & HL_MASK) << 2;
  /* get TCP header */
  th = (T_SNDCP_TCP_HEADER *)&((UBYTE *)cs->cs_ip)[hlen];
  /* store new TCP check sum */
  th->th_sum = sndcp_swap2((USHORT)((*cp << 8) | cp[1]));
  cp += 2;
  /* check if push bit is set */
  if (change_mask & TCP_PUSH_BIT)
    th->th_flags |= TH_PUSH;
  else
    th->th_flags &=~ TH_PUSH;

  switch (change_mask & SPECIALS_MASK) {

    case SPECIAL_I:
    {
      ULONG deltaL = sndcp_swap2(cs->cs_ip->ip_len) - cs->cs_hlen;
      th->th_ack   = sndcp_swap4(sndcp_swap4(th->th_ack) + deltaL);
      th->th_seq   = sndcp_swap4(sndcp_swap4(th->th_seq) + deltaL);
    }
      break;

    case SPECIAL_D:
      th->th_seq = sndcp_swap4(sndcp_swap4(th->th_seq)
                   + sndcp_swap2(cs->cs_ip->ip_len)
                   - cs->cs_hlen);
      break;

    /* no special case */
    default:
      /* urgend data field */
      if (change_mask & NEW_U) {
        th->th_flags |= TH_URG;
        if (*cp == 0) {
          th->th_urp = sndcp_swap2((USHORT)((cp[1] << 8) | cp[2]));
          cp += 3;
        } else {
          th->th_urp = sndcp_swap2((USHORT)((ULONG)*cp++));
        }
      } else {
        th->th_flags &=~ TH_URG;
      }
      /*
       * window size
       */
      if (change_mask & NEW_W){
        if (*cp == 0) {
          th->th_win = sndcp_swap2((USHORT)(sndcp_swap2(th->th_win)
                                 + ((cp[1] << 8) | cp[2])));
          cp += 3;
        } else {
          th->th_win = sndcp_swap2((USHORT)(sndcp_swap2(th->th_win) + (ULONG)*cp++));
        }
      }
      /*
       * acknowledgement number
       */
      if (change_mask & NEW_A){
        if (*cp == 0) {
          th->th_ack = sndcp_swap4(sndcp_swap4(th->th_ack) + ((cp[1] << 8) | cp[2]));
          cp += 3;
        } else {
          th->th_ack = sndcp_swap4(sndcp_swap4(th->th_ack) + (ULONG)*cp++);
        }
      }
      /*
       * sequence number
       */
      if (change_mask & NEW_S){
        if (*cp == 0) {
          (th->th_seq) = sndcp_swap4(sndcp_swap4(th->th_seq) + ((cp[1] << 8) | cp[2]));
          cp += 3;
        } else {
          (th->th_seq) = sndcp_swap4(sndcp_swap4(th->th_seq) + (ULONG)*cp++);
        }
      }
      break;
  }
  /*
   * packet ID
   */
  if (change_mask & NEW_I) {
    if (*cp == 0) {
      cs->cs_ip->ip_id = sndcp_swap2((USHORT)(sndcp_swap2(cs->cs_ip->ip_id)
                                         + ((cp[1] << 8) | cp[2])));
      cp += 3;
    } else {
      cs->cs_ip->ip_id = sndcp_swap2((USHORT)(sndcp_swap2(cs->cs_ip->ip_id)
                                                   + (ULONG)*cp++));
    }
  } else
    cs->cs_ip->ip_id = sndcp_swap2((USHORT)(sndcp_swap2(cs->cs_ip->ip_id) + 1));

  /*
   * At this point, cp points to the first byte of data in the
   * packet.  If we're not aligned on a 4-byte boundary, copy the
   * data down so the ip & tcp headers will be aligned.  Then back up
   * cp by the tcp/ip header length to make room for the reconstructed
   * header (we assume the packet we were handed has enough space to
   * prepend 120 bytes of header).  Adjust the length to account for
   * the new header & fill in the IP total length.
   */
  tmp = cp - (UBYTE*)cbuf->c_hdr;
  cbuf->pack_len -= cp - (UBYTE*)cbuf->c_hdr;
  if ((UBYTE*)cbuf->c_hdr > cp){
    /* we must have dropped some characters (crc should detect
     * this but the old slip framing won't) */
    comp->flags |= SLF_TOSS;
    return (0);
  }

  cbuf->c_hdr    += tmp;
  cbuf->hdr_len -= (USHORT)tmp;
  tmp = (ULONG)cp & 3;
  if (tmp) {
    if (cbuf->pack_len > 0)
      memcpy(cp - tmp, cp, cbuf->hdr_len);
    cbuf->c_hdr -= tmp;
    cp -= tmp;
  }
  cbuf->c_hdr -= cs->cs_hlen;
  cp -= cs->cs_hlen;
  cbuf->hdr_len  += cs->cs_hlen;
  cbuf->pack_len += cs->cs_hlen;
  cs->cs_ip->ip_len = sndcp_swap2(cbuf->pack_len);
  memcpy(cp, cs->cs_ip, cs->cs_hlen);

  /* recompute the ip header checksum */
  {
    USHORT *bp = (USHORT *)cp;

    for (change_mask = 0; hlen > 0; hlen -= 2)
      change_mask += *bp++;
    change_mask = (change_mask & 0xffff) + (change_mask >> 16);
    change_mask = (change_mask & 0xffff) + (change_mask >> 16);
    ((T_SNDCP_IP_HEADER *)cp)->ip_sum = ~ (USHORT)change_mask;
  }
  return (cbuf->pack_len);
}

#endif /* CF_FAST_EXEC */


/*
+------------------------------------------------------------------------------
| Function    : cia_header_decomp
+------------------------------------------------------------------------------
| Description : de-compresses the TCP/IP header of the given packet
|               (Van Jacobson algorithm)
|
| Parameters  : packet as desc_list, packet_type
|
+------------------------------------------------------------------------------
*/
#ifndef CF_FAST_EXEC

#ifdef _SNDCP_DTI_2_
GLOBAL void cia_header_decomp(T_desc_list2* desc_list, UBYTE* packet_type)
{
#else /*_SNDCP_DTI_2_*/
GLOBAL void cia_header_decomp(T_desc_list* desc_list, UBYTE* packet_type)
{
#endif /*_SNDCP_DTI_2_*/

  struct comp_buf     cbuf;
  /* the length of decompressed header + payload */
  USHORT              decomp_len;

#ifdef _SNDCP_DTI_2_
  T_desc2* desc = (T_desc2*) desc_list->first;
  T_desc2* decomp_desc;
  U8 *desc_buff = &desc->buffer[desc->offset];
#else
  T_desc*  desc = (T_desc*) desc_list->first;
  T_desc*  decomp_desc;
  U8 *desc_buff = &desc->buffer[0];
#endif

  TRACE_FUNCTION( "cia_header_decomp" );

#ifdef SNDCP_TRACE_BUFFER
  TRACE_EVENT("INFO DECOMP: Input Packet");
  sndcp_trace_desc_list(desc_list);
#endif /* SNDCP_TRACE_BUFFER */

  switch(*packet_type)
  {
  /*
   * packet type IP: do nothing
   */
  case TYPE_IP:
    TRACE_EVENT("INFO DECOMP: TYPE_IP");
    *packet_type = TYPE_IP;
    break;

  /*
   * packet type uncompressed TCP
   */
  case TYPE_UNCOMPRESSED_TCP:
    TRACE_EVENT("INFO DECOMP: TYPE_UNCOMPRESSED_TCP");
    cbuf.c_hdr    = (ULONG)&desc_buff[0];
    cbuf.hdr_len  = desc->len;
    cbuf.pack_len = desc_list->list_len;
    cbuf.p_type   = *packet_type;
    decomp_len = cia_vj_decomp(&cbuf);
    if(decomp_len == 0)
    {
      TRACE_EVENT("ERROR DECOMP: decomp_len = 0, TYPE_ERROR");
      *packet_type = TYPE_ERROR;
    }
    else
    {
      *packet_type = TYPE_IP;
     }
    break;

  /*
   * packet type compressed TCP
   */
  case TYPE_COMPRESSED_TCP:
    TRACE_EVENT("INFO DECOMP: TYPE_COMPRESSED_TCP");
    /*
     * Because we don't know the length of compressed TCP/IP header,
     * we have to copy max. 40 bytes, wich sure contain compressed
     * header + maybe some payload bytes.
     */
    cbuf.hdr_len = (desc->len < 40) ? desc->len : 40;
    cbuf.c_hdr = (ULONG)&sndcp_data->cia.comp.
                               tcpip_hdr[TMP_HDR_LEN-1-cbuf.hdr_len];
    cbuf.pack_len = desc_list->list_len;
    cbuf.p_type   = *packet_type;
    memcpy((UBYTE*)cbuf.c_hdr, &desc_buff[0], cbuf.hdr_len);
    decomp_len = cia_vj_decomp(&cbuf);
    if(decomp_len != 0)
    {
      /*
       * Build destination descriptor list
       */
      USHORT offset = cbuf.pack_len - desc_list->list_len;
#ifdef _SNDCP_DTI_2_
      MALLOC(decomp_desc, (USHORT)(sizeof(T_desc2) - 1 + desc->len + offset));
#else
      MALLOC(decomp_desc, (USHORT)(sizeof(T_desc) - 1 + desc->len + offset));
#endif
      /* copy compressed header + piece of data */
      memcpy(&decomp_desc->buffer[0], (UBYTE*)cbuf.c_hdr, cbuf.hdr_len);
      /* copy the rest of data */
      memcpy(&decomp_desc->buffer[cbuf.hdr_len],
             &desc->buffer[cbuf.hdr_len-offset],
              desc->len-cbuf.hdr_len+offset);
      decomp_desc->next   = desc->next;
      decomp_desc->len  = desc->len + offset;
#ifdef _SNDCP_DTI_2_
      decomp_desc->size = desc->size + offset;
      decomp_desc->offset = desc->offset;
#endif
      desc_list->first  = (ULONG)decomp_desc;
      desc_list->list_len = desc_list->list_len - desc->len + decomp_desc->len;
      MFREE(desc);
      *packet_type = TYPE_IP;
    }
    else
    {
      TRACE_EVENT("ERROR DECOMP: decomp_len = 0, TYPE_ERROR");
      *packet_type = TYPE_ERROR;
    }
    break;

  default:
      TRACE_EVENT_P1("ERROR DECOMP: unexpected packet type: %d", packet_type);
      *packet_type = TYPE_ERROR;
    break;

  }

} /* cia_header_decomp() */

#endif /* CF_FAST_EXEC */


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

/*
+------------------------------------------------------------------------------
| Function    : cia_cia_decomp_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive CIA_DECOMP_IND
|
| Parameters  : *cia_decomp_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
#ifndef CF_FAST_EXEC

GLOBAL void cia_cia_decomp_ind ( T_CIA_DECOMP_IND *cia_decomp_ind )
{
  UBYTE nsapi = cia_decomp_ind->pdu_ref.ref_nsapi;
  BOOL ack = FALSE;
  BOOL compressed = FALSE;
  UBYTE pcomp = cia_decomp_ind->pcomp;
  UBYTE pntt = 0;
  UBYTE sapi = 0;
  BOOL pcomp_ok = FALSE;

#ifndef _SNDCP_DTI_2_
  T_desc_list temp_desc_list;
#endif /*_SNDCP_DTI_2_*/

  UBYTE p_id = DTI_PID_IP;

  TRACE_FUNCTION( "cia_cia_decomp_ind" );

#ifdef SNDCP_TRACE_ALL
  TRACE_EVENT_P1("cia_decomp_ind->pcomp: %02x", cia_decomp_ind->pcomp);
#endif /* SNDCP_TRACE_ALL */

  /* 
   * Is nsapi in ack mode?
   */
  sndcp_get_nsapi_ack(nsapi, &ack);

  switch( GET_STATE(CIA) )
  {
    case CIA_DEFAULT:
      sndcp_is_nsapi_header_compressed(nsapi, &compressed);
      /*
       * Only compress if pcomp in sn pdu is assigned to context.
       */
      sndcp_get_nsapi_sapi(nsapi, &sapi);
      mg_get_sapi_pcomp_pntt(sapi,
                             pcomp,
                             &pntt);

      mg_get_sapi_pntt_nsapi(sapi, pntt, nsapi, &pcomp_ok);

      if (compressed && pcomp_ok && pcomp != 0) {
        UBYTE packet_type = TYPE_COMPRESSED_TCP;

        if (pcomp == sndcp_data->cia.cur_xid_block.vj.pcomp1) {
          packet_type = TYPE_UNCOMPRESSED_TCP;
        }
#ifndef _SNDCP_DTI_2_
        temp_desc_list.list_len = cia_decomp_ind->desc_list2.list_len;
        temp_desc_list.first = cia_decomp_ind->desc_list2.first;
        cia_header_decomp(&temp_desc_list1, &packet_type);
        cia_decomp_ind->desc_list2.list_len = temp_desc_list.list_len;
        cia_decomp_ind->desc_list2.first = temp_desc_list.first;
#else  /*_SNDCP_DTI_2_*/
        cia_header_decomp(&cia_decomp_ind->desc_list2, &packet_type);
#endif /*_SNDCP_DTI_2_*/
        if (packet_type != TYPE_IP) {
#ifdef SNDCP_TRACE_ALL
          sndcp_data->cia.cia_decomp_ind_number[nsapi] --;
          TRACE_EVENT_P1("number of cia_decomp_ind: % d",
                         sndcp_data->cia.cia_decomp_ind_number[nsapi]);
#endif /* SNDCP_TRACE_ALL */

          MFREE_PRIM(cia_decomp_ind);
          cia_decomp_ind = NULL;
          /*
           * Corupted segment, request next one.
           */
          TRACE_EVENT("WARNING DECOMP: Corupted segment, request next one!");
          if (ack) {
            sig_cia_sda_getdata(sapi, nsapi);
          } else {
            sig_cia_sd_getunitdata(sapi, nsapi);
          }
          return;
        }
      }
      /*
       * Is the cnf for sd or sda?
       */
      if (ack) {
        sig_cia_sda_cia_decomp_ind(cia_decomp_ind, p_id);
      } else {
        sig_cia_sd_cia_decomp_ind(cia_decomp_ind, p_id);
      }
      break;
    default:
      TRACE_ERROR( "CIA_DECOMP_IND unexpected" );
      MFREE_PRIM(cia_decomp_ind); 
      break;
  }
} /* cia_cia_decomp_ind() */

#endif /* CF_FAST_EXEC */

/*
+------------------------------------------------------------------------------
| Function    : cia_cia_comp_ind
+------------------------------------------------------------------------------
| Description : Handles the primitive CIA_COMP_IND
|
| Parameters  : *cia_comp_ind - Ptr to primitive payload
|
+------------------------------------------------------------------------------
*/
#ifndef CF_FAST_EXEC

GLOBAL void cia_cia_comp_ind ( T_CIA_COMP_IND *cia_comp_ind )
{
  UBYTE nsapi = cia_comp_ind->pdu_ref.ref_nsapi;
  BOOL ack = FALSE;

  TRACE_FUNCTION( "cia_cia_comp_ind" );


#ifdef SNDCP_TRACE_ALL
  switch (cia_comp_ind->packet_type) {
  case TYPE_IP:
    TRACE_EVENT_P2("cia_comp_ind->packet_type: %02x (%s)",
                   cia_comp_ind->packet_type,
                   "TYPE_IP");
    break;
  case TYPE_UNCOMPRESSED_TCP:
    TRACE_EVENT_P2("cia_comp_ind->packet_type: %02x (%s)",
                   cia_comp_ind->packet_type,
                   "TYPE_UNCOMPRESSED_TCP");
    break;
  case TYPE_COMPRESSED_TCP:
    TRACE_EVENT_P2("cia_comp_ind->packet_type: %02x (%s)",
                   cia_comp_ind->packet_type,
                   "TYPE_COMPRESSED_TCP");
    break;
  case TYPE_ERROR:
    TRACE_EVENT_P2("cia_comp_ind->packet_type: %02x (%s)",
                   cia_comp_ind->packet_type,
                   "TYPE_ERROR");
    break;
  default:
    TRACE_EVENT_P2("cia_comp_ind->packet_type: %02x (%s)",
                   cia_comp_ind->packet_type,
                   "unknown");


  }
#endif /* SNDCP_TRACE_ALL */

  switch( GET_STATE(CIA) )
  {
    case CIA_DEFAULT:
      /*
       * Is the cnf for su or sua?
       */
      sndcp_get_nsapi_ack(nsapi, &ack);
      if (ack) {
        sig_cia_sua_cia_comp_ind(cia_comp_ind);
      } else {
        sig_cia_su_cia_comp_ind(cia_comp_ind);
      }
      break;
    default:
      TRACE_ERROR( "CIA_CIA_COMP_IND unexpected" );
      sndcp_cl_desc3_free((T_desc3*)cia_comp_ind->desc_list3.first);
      MFREE(cia_comp_ind); 
      break;
  }
} /* cia_cia_comp_ind() */

#endif /* CF_FAST_EXEC */