diff src/g23m-gprs/sndcp/sndcp_cias.c @ 1:fa8dc04885d8

src/g23m-*: import from Magnetite
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 16 Oct 2020 06:25:50 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gprs/sndcp/sndcp_cias.c	Fri Oct 16 06:25:50 2020 +0000
@@ -0,0 +1,2710 @@
+/*
++-----------------------------------------------------------------------------
+|  Project :  GPRS (8441)
+|  Modul   :  sndcp_cias.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.
+|
+|  These files implement Van Jacobson Compression algorithm which is taken from
+|  University of California Berkley's Implementation.
+|
+|
+|  "Copyright (c)1989 Regents of the University of California.
+|  All rights reserved.Redistribution and use in source and binary forms are
+|  permitted, provided that the above  copyright notice and this paragraph are
+|  duplicated in all such forms and that any documentation advertising materials,
+|  and  other materials related to such distributionand use acknowledge that the
+|  software was developed by the University of California, Berkeley.
+|  The name of the University may not be  used to endorse or promote products
+|  derived from this software without specific  prior written permission. 
+|  THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES,
+|  INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND 
+|  FITNESS FOR A PARTICULAR PURPOSE"
++-----------------------------------------------------------------------------
+|  Purpose :  This modul is part of the entity SNDCP and implements all
+|             functions to handles the incoming process internal signals 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_cias.h"  /* to get the signals to service cia */
+#include "sndcp_ciap.h"  /* to get primitives to service cia */
+#include "sndcp_ciaf.h"  /* to get primitives to service cia */
+#include "sndcp_sdf.h"   /* to get sd functions */
+#include "sndcp_sdaf.h"  /* to get sda functions */
+#include "sndcp_sds.h"   /* to get sd signals */
+
+#ifdef TI_PS_FF_V42BIS
+#include "v42b_type.h"
+#include "v42b_dico.h"
+#include "v42b_enc.h"
+#include "v42b_dec.h"
+#include "v42b_debug.h"
+#endif /* TI_PS_FF_V42BIS */
+
+/*==== CONST ================================================================*/
+
+/*==== LOCAL VARS ===========================================================*/
+
+/*==== PRIVATE FUNCTIONS ====================================================*/
+
+/*
+ * Update connection state cs & send uncompressed packet ('uncompressed'
+ * means a regular ip/tcp packet but with the 'conversation id' we hope
+ * to use on future compressed packets in the protocol field).
+ */
+#define UNCOMPRESSED {\
+  memcpy(cs->cs_hdr, (UBYTE*)cbuf->c_hdr, tip_hlen);\
+  ip->ip_p = cs->cs_id;\
+  sndcp_data->cia.comp.last_xmit = cs->cs_id;\
+}
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cia_vj_comp
++------------------------------------------------------------------------------
+| Description : compresses 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
+|
++------------------------------------------------------------------------------
+*/
+#ifndef CF_FAST_EXEC
+
+LOCAL UBYTE cia_vj_comp(struct comp_buf *cbuf)
+{
+  struct cstate            *cs  = sndcp_data->cia.comp.last_cs->cs_next;
+  T_SNDCP_TCP_HEADER       *oth, *oth_tmp;     /* last TCP header */
+  T_SNDCP_TCP_HEADER       *th;                /* current TCP header */
+  T_SNDCP_IP_HEADER        *ip;                /* current IP header */
+  USHORT                   ip_hlen, tip_hlen;  /* IP hdr len., TCP/IP hdr len*/
+  USHORT                   tmp1, tmp2;         /* general purpose tempories */
+  ULONG                    changes = 0;        /* change mask */
+  UBYTE                    new_seq[16];       /* changes from last to current*/
+  UBYTE                    *cp = new_seq;
+  UBYTE                    th_off, oth_off;
+  BOOL                     found = FALSE;
+  USHORT                   th_sum;
+  ULONG                    seq, o_seq;
+
+  ip      = (T_SNDCP_IP_HEADER *)cbuf->c_hdr;
+  ip_hlen = ip->ip_vhl & HL_MASK;            /* IP header length in integers */
+  th      = (T_SNDCP_TCP_HEADER *)&((ULONG *)cbuf->c_hdr)[ip_hlen];
+  th_off  = th->th_off >> 4;
+
+  TRACE_FUNCTION( "cia_vj_comp" );
+
+  /*
+   * Bail if this is an IP fragment or if the TCP packet isn't
+   * `compressible' (i.e., ACK isn't set or some other control bit is
+   * set).  (We assume that the caller has already made sure the
+   * packet is IP proto TCP).
+   */
+  if (ip->ip_off & 0xff3f)
+  {
+    TRACE_EVENT("INFO COMP: return TYPE_IP, packet is an IP fragment");
+    return (TYPE_IP);
+  }
+
+  if ((th->th_flags & (TH_SYN|TH_FIN|TH_RST|TH_ACK)) != TH_ACK)
+  {
+    TRACE_EVENT("INFO COMP: return TYPE_IP, TH_ACK is not set");
+    return (TYPE_IP);
+  }
+  /*
+   * Packet is compressible -- we're going to send either a
+   * COMPRESSED_TCP or UNCOMPRESSED_TCP packet.  Either way we need
+   * to locate (or create) the connection state.  Special case the
+   * most recently used connection since it's most likely to be used
+   * again & we don't have to do any reordering if it's used.
+   */
+  oth_tmp  = (T_SNDCP_TCP_HEADER *)
+             &((ULONG *)cs->cs_hdr)[cs->cs_ip->ip_vhl & HL_MASK];
+  if ((ip->ip_src   != cs->cs_ip->ip_src) ||
+      (ip->ip_dst   != cs->cs_ip->ip_dst) ||
+      (*(ULONG *)th != *(ULONG *)oth_tmp)){
+    /*
+     * Wasn't the first -- search for it.
+     *
+     * States are kept in a circularly linked list with
+     * last_cs pointing to the end of the list.  The
+     * list is kept in lru order by moving a state to the
+     * head of the list whenever it is referenced.  Since
+     * the list is short and, empirically, the connection
+     * we want is almost always near the front, we locate
+     * states via linear search.  If we don't find a state
+     * for the datagram, the oldest state is (re-)used.
+     */
+    struct cstate *lcs;
+    struct cstate *lastcs = sndcp_data->cia.comp.last_cs;
+
+    do {
+      lcs = cs;
+      cs = cs->cs_next;
+      oth_tmp  = (T_SNDCP_TCP_HEADER *)
+                 &((ULONG *)cs->cs_hdr)[cs->cs_ip->ip_vhl & HL_MASK];
+      if ((ip->ip_src   == cs->cs_ip->ip_src) &&
+          (ip->ip_dst   == cs->cs_ip->ip_dst) &&
+          (*(ULONG *)th == *(ULONG *)oth_tmp)){
+        found = TRUE;
+        break;
+      }
+
+    } while (cs != lastcs);
+
+    if(found)
+    {
+      /*
+       * Found it -- move to the front on the connection list.
+       */
+      if (cs == lastcs)
+        sndcp_data->cia.comp.last_cs = lcs;
+      else {
+        lcs->cs_next = cs->cs_next;
+        cs->cs_next = lastcs->cs_next;
+        lastcs->cs_next = cs;
+      }
+    } else {
+      /*
+       * Didn't find it -- re-use oldest cstate.  Send an
+       * uncompressed packet that tells the other side what
+       * connection number we're using for this conversation.
+       * Note that since the state list is circular, the oldest
+       * state points to the newest and we only need to set
+       * last_cs to update the lru linkage.
+       */
+      sndcp_data->cia.comp.last_cs = lcs;
+      tip_hlen = (ip_hlen+th_off)<<2;
+      UNCOMPRESSED;
+      return (TYPE_UNCOMPRESSED_TCP);
+    }/*if din't find*/
+  }
+
+  /*
+   * Make sure that only what we expect to change changed. The first
+   * line of the `if' checks the IP protocol version, header length &
+   * type of service.  The 2nd line checks the "Don't fragment" bit.
+   * The 3rd line checks the time-to-live and protocol (the protocol
+   * check is unnecessary but costless).  The 4th line checks the TCP
+   * header length.  The 5th line checks IP options, if any.  The 6th
+   * line checks TCP options, if any.  If any of these things are
+   * different between the previous & current datagram, we send the
+   * current datagram `uncompressed'.
+   */
+  oth = (T_SNDCP_TCP_HEADER *)&((ULONG *)cs->cs_ip)[ip_hlen];
+  oth_off  = oth->th_off >> 4;
+  tip_hlen = (ip_hlen+th_off)<<2;
+
+  if (((USHORT *)ip)[0] != ((USHORT *)cs->cs_ip)[0] ||
+      ((USHORT *)ip)[3] != ((USHORT *)cs->cs_ip)[3] ||
+      ((USHORT *)ip)[4] != ((USHORT *)cs->cs_ip)[4] ||
+      (th_off           != oth_off)                 ||
+      ((ip_hlen > 5) && (memcmp(ip + 1, cs->cs_ip + 1, (ip_hlen - 5) << 2))) ||
+      ((th_off  > 5) && (memcmp(th + 1, oth + 1, (th_off - 5) << 2)))) {
+
+    UNCOMPRESSED;
+    return (TYPE_UNCOMPRESSED_TCP);
+  }
+
+  /*
+   * Figure out which of the changing fields changed.  The
+   * receiver expects changes in the order: urgent, window,
+   * ack, seq (the order minimizes the number of temporaries
+   * needed in this section of code).
+   */
+  if (th->th_flags & TH_URG) {
+    tmp1 = sndcp_swap2(th->th_urp);
+    if (tmp1 >= 256 || tmp1 == 0) {
+      *cp++ = 0;
+      cp[1] = (UBYTE)tmp1;
+      cp[0] = (tmp1 & 0xff00) >> 8;
+      cp += 2;
+    } else {
+      *cp++ = (UBYTE)tmp1;
+    }
+    changes |= NEW_U;
+  } else if (th->th_urp != oth->th_urp){
+    /* argh! URG not set but urp changed -- a sensible
+     * implementation should never do this but RFC793
+     * doesn't prohibit the change so we have to deal
+     * with it. */
+    UNCOMPRESSED;
+    return (TYPE_UNCOMPRESSED_TCP);
+  }
+  if ((tmp1 = sndcp_swap2(th->th_win) - sndcp_swap2(oth->th_win)) != 0) {
+    if (tmp1 >= 256) {
+      *cp++ = 0;
+      cp[1] = (UBYTE)tmp1;
+      cp[0] = (tmp1 & 0xff00) >> 8;
+      cp += 2;
+    } else {
+      *cp++ = (UBYTE)tmp1;
+    }
+    changes |= NEW_W;
+  }
+
+  if ((tmp2 = (USHORT)(sndcp_swap4(th->th_ack)-sndcp_swap4(oth->th_ack)))!=0){
+    if (tmp2 > MAX_CHANGE){
+      UNCOMPRESSED;
+      return (TYPE_UNCOMPRESSED_TCP);
+    }
+    if (tmp2 >= 256) {
+      *cp++ = 0;
+      cp[1] = (UBYTE)tmp2;
+      cp[0] = (tmp2 & 0xff00) >> 8;
+      cp += 2;
+    } else {
+      *cp++ = (UBYTE)tmp2;
+    }
+    changes |= NEW_A;
+  }
+
+  seq   = sndcp_swap4(th->th_seq);
+  o_seq = sndcp_swap4(oth->th_seq);
+  if(seq < o_seq) {
+    TRACE_EVENT("WARNING COMP: seq < o_seq, return UNCOMPRESSED_TCP ");
+    UNCOMPRESSED;
+    return (TYPE_UNCOMPRESSED_TCP);
+  } else if((tmp1 = (USHORT)(seq - o_seq)) != 0) {
+    if (tmp1 > MAX_CHANGE){
+      UNCOMPRESSED;
+      return (TYPE_UNCOMPRESSED_TCP);
+    }
+    if (tmp1 >= 256) {
+      *cp++ = 0;
+      cp[1] = (UBYTE)tmp1;
+      cp[0] = (tmp1 & 0xff00) >> 8;
+      cp += 2;
+    } else {
+      *cp++ = (UBYTE)tmp1;
+    }
+    changes |= NEW_S;
+  }
+
+  /* look for special case encodings. */
+  switch (changes) {
+
+  case 0:
+    /*
+     * Nothing changed. If this packet contains data and the
+     * last one didn't, this is probably a data packet following
+     * an ack (normal on an interactive connection) and we send
+     * it compressed.  Otherwise it's probably a retransmit,
+     * retransmitted ack or window probe.  Send it uncompressed
+     * in case the other side missed the compressed version.
+     */
+    if ((ip->ip_len != cs->cs_ip->ip_len) &&
+        (sndcp_swap2(cs->cs_ip->ip_len) == tip_hlen))
+      break;
+
+    /* (fall through) */
+
+  case SPECIAL_I:
+  case SPECIAL_D:
+    /*
+     * actual changes match one of our special case encodings --
+     * send packet uncompressed.
+     */
+    UNCOMPRESSED;
+    return (TYPE_UNCOMPRESSED_TCP);
+
+  case NEW_S|NEW_A:
+    if ((tmp1 == tmp2) &&
+        (tmp1 == sndcp_swap2(cs->cs_ip->ip_len) - tip_hlen)) {
+      /* special case for echoed terminal traffic */
+      changes = SPECIAL_I;
+      cp = new_seq;
+    }
+    break;
+
+  case NEW_S:
+    if (tmp1 == sndcp_swap2(cs->cs_ip->ip_len) - tip_hlen) {
+      /* special case for data xfer */
+      changes = SPECIAL_D;
+      cp = new_seq;
+    }
+    break;
+  }
+
+  tmp1 = sndcp_swap2(ip->ip_id) - sndcp_swap2(cs->cs_ip->ip_id);
+  if (tmp1 != 1) {
+    if ((tmp1 >= 256) || (tmp1 == 0)) {
+      *cp++ = 0;
+      cp[1] = (UBYTE)tmp1;
+      cp[0] = (tmp1 & 0xff00) >> 8;
+      cp += 2;
+    } else {
+      *cp++ = (UBYTE)tmp1;
+    }
+    changes |= NEW_I;
+  }
+
+  if (th->th_flags & TH_PUSH)
+    changes |= TCP_PUSH_BIT;
+  /*
+   * Grab the cksum before we overwrite it below.  Then update our
+   * state with this packet's header.
+   */
+  th_sum = sndcp_swap2(th->th_sum);
+  memcpy(cs->cs_ip, ip, tip_hlen);
+
+  /*
+   * We want to use the original packet as our compressed packet.
+   * (cp - new_seq) is the number of bytes we need for compressed
+   * sequence numbers.  In addition we need one byte for the change
+   * mask, one for the connection id and two for the tcp checksum.
+   * So, (cp - new_seq) + 4 bytes of header are needed.  hlen is how
+   * many bytes of the original packet to toss so subtract the two to
+   * get the new packet size.
+   */
+  tmp1 = cp - new_seq;
+  cp = (UBYTE *)ip;
+
+  /*
+   * we always send a "new" connection id so the receiver state
+   * stays synchronized.
+   */
+  sndcp_data->cia.comp.last_xmit = cs->cs_id;
+  tip_hlen -= tmp1 + 4;
+  cp       += tip_hlen;
+  *cp++ = (UBYTE)(changes | NEW_C);
+  *cp++ = cs->cs_id;
+
+  cbuf->pack_len -= tip_hlen;
+  cbuf->hdr_len  -= tip_hlen;
+  cbuf->c_hdr    += tip_hlen;
+  *cp++ = th_sum >> 8;
+  *cp++ = (UBYTE)(th_sum & 0x00ff);
+  memcpy(cp, new_seq, tmp1);
+  return (TYPE_COMPRESSED_TCP);
+}
+
+#endif /* CF_FAST_EXEC */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cia_header_comp
++------------------------------------------------------------------------------
+| Description : 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_comp (T_desc_list2* dest_desc_list,
+                                T_desc_list2* src_desc_list,
+                                UBYTE* packet_type)
+#else /*_SNDCP_DTI_2_*/
+GLOBAL void cia_header_comp (T_desc_list* dest_desc_list,
+                                T_desc_list* src_desc_list,
+                                UBYTE* packet_type)
+#endif /*_SNDCP_DTI_2_*/
+{
+
+#ifdef _SNDCP_DTI_2_
+  T_desc2* src_desc = (T_desc2*)src_desc_list->first;
+  T_desc2* new_desc;
+  U8 *src_desc_buff = &src_desc->buffer[src_desc->offset];
+#else /*_SNDCP_DTI_2_*/
+  T_desc*  src_desc = (T_desc*)src_desc_list->first;
+  T_desc*  new_desc;
+  U8 *src_desc_buff = &src_desc->buffer[0];
+#endif /*_SNDCP_DTI_2_*/
+
+
+/*
+ * A struct mbuf is used in the call cia_vj_comp because that routine
+ * needs to modify both the start address and length if the incoming
+ * packet is compressed
+ */
+
+  struct comp_buf           cbuf;
+  T_SNDCP_IP_HEADER         *ip;
+  T_SNDCP_TCP_HEADER        *tcp;
+  USHORT                    hdr_len;
+  USHORT                    offset;
+
+  TRACE_FUNCTION( "cia_header_comp" );
+
+  if ((src_desc == NULL))
+  {
+    TRACE_EVENT("ERROR: Descriptor Pointer is a NULLPTR");
+    *packet_type = TYPE_ERROR;
+    return;
+  }
+
+  /*
+   * Verify protocol type and header length
+   */
+  ip = (T_SNDCP_IP_HEADER *)&src_desc_buff[0];
+  if((ip->ip_p == PROT_TCPIP))
+  {
+    hdr_len  = (ip->ip_vhl & HL_MASK) << 2;
+    tcp      = (T_SNDCP_TCP_HEADER *)&src_desc_buff[hdr_len];
+    hdr_len += (tcp->th_off >> 4) << 2;
+    if( (src_desc->len >= hdr_len) && (hdr_len >=40) ){
+      /*
+       * initialize comp_buf
+       */
+      cbuf.hdr_len  = hdr_len;       /* header len. passed to compr. routine*/
+      cbuf.pack_len = src_desc->len; /* descriptor length */
+      cbuf.p_type   = TYPE_IP;       /* set default packet type */
+      /* use temporary buffer to store TCP/IP header */
+      cbuf.c_hdr    = (ULONG)&sndcp_data->cia.comp.tcpip_hdr[0];
+      memcpy((UBYTE*)cbuf.c_hdr, &src_desc_buff[0], cbuf.hdr_len);
+      /*
+       * Call VJ header compression routine
+       */
+      *packet_type = cia_vj_comp(&cbuf);
+    }
+    else
+      *packet_type = TYPE_IP;
+
+  }/* if TCP_IP_PROTOKOL */
+  else{
+    *packet_type = TYPE_IP;
+    if(src_desc->len <40)
+      TRACE_EVENT("INFO COMP: Descriptor length < 40");
+  }
+
+  switch(*packet_type)
+  {
+    /*
+     * IP packet
+     */
+    case TYPE_IP:
+      /*
+       * if acknowledged mode
+       */
+      if(src_desc_list != dest_desc_list)
+      {
+        dest_desc_list->first = src_desc_list->first;
+        dest_desc_list->list_len = src_desc_list->list_len;
+      }
+      TRACE_EVENT("INFO COMP: Header Type TYPE_IP");
+      break;
+
+    /*
+     * Uncompressed TCP/IP packet
+     */
+    case TYPE_UNCOMPRESSED_TCP:
+      /*
+       * if acknowledged mode
+       */
+      if(src_desc_list != dest_desc_list)
+      {
+#ifdef _SNDCP_DTI_2_
+      MALLOC(new_desc, (USHORT)(sizeof(T_desc2)-1+src_desc->len));
+#else
+      MALLOC(new_desc, (USHORT)(sizeof(T_desc)-1+src_desc->len));
+#endif
+        /*
+         * Copy data packet to destination descriptor
+         */
+        memcpy(new_desc->buffer, src_desc_buff, src_desc->len);
+        /*
+         * store connection id
+         */
+        new_desc->buffer[PR_TYPE_POS] = ((UBYTE*)cbuf.c_hdr)[PR_TYPE_POS]
+        ;/*lint !e644 !e415 !e416 creation and access of out-of-bounds pointer*/
+        /*
+         * Build destination descriptor list
+         */
+        new_desc->next   = src_desc->next;
+        new_desc->len    = src_desc->len;
+#ifdef _SNDCP_DTI_2_
+        new_desc->offset = src_desc->offset;
+        new_desc->size   = src_desc->size;
+#endif
+        dest_desc_list->first    = (ULONG)new_desc;
+        dest_desc_list->list_len = src_desc_list->list_len;
+      }
+      else{
+       /*
+        * store connection id
+        */
+        src_desc_buff[PR_TYPE_POS] = ((UBYTE*)cbuf.c_hdr)[PR_TYPE_POS]
+        ;/*lint !e415 !e416 creation and access of out-of-bounds pointer */
+      }
+      TRACE_EVENT("INFO COMP: Header Type TYPE_UNCOMPRESSED_TCP");
+      break;
+
+
+    /*
+     * Compressed TCP/IP packet
+     */
+    case TYPE_COMPRESSED_TCP:
+      /* compute compressed header length */
+      offset = (USHORT)(src_desc->len - cbuf.pack_len);
+#ifdef _SNDCP_DTI_2_
+      MALLOC(new_desc, (USHORT)(sizeof(T_desc2) - 1 + cbuf.pack_len));
+#else
+      MALLOC(new_desc, (USHORT)(sizeof(T_desc) - 1 + cbuf.pack_len));
+#endif
+      /*
+       * Copy compressed header to new descriptor
+       */
+      memcpy(&new_desc->buffer[0], (UBYTE*)cbuf.c_hdr, cbuf.hdr_len);
+      /*
+       * Copy payload to new descriptor
+       */
+      memcpy(&new_desc->buffer[cbuf.hdr_len],
+             &src_desc_buff[hdr_len], cbuf.pack_len-cbuf.hdr_len)
+       ;/*lint !e644 !e662 Possible creation of out-of-bounds pointer */
+      /*
+       * Build destination descriptor list
+       */
+      new_desc->next   = src_desc->next;
+      new_desc->len    = (USHORT)cbuf.pack_len;
+#ifdef _SNDCP_DTI_2_
+      new_desc->offset = 0;
+      new_desc->size   = (USHORT)cbuf.pack_len;
+#endif
+      dest_desc_list->first    = (ULONG)new_desc;
+      dest_desc_list->list_len = src_desc_list->list_len - offset;
+      /*
+       * if unacknowledgement mode
+       */
+      if(src_desc_list == dest_desc_list)
+      {
+        /*
+         * Free source decsriptor
+         */
+        MFREE(src_desc);
+      }
+      TRACE_EVENT("INFO COMP: Header TYPE_COMPRESSED_TCP");
+      break;
+
+    default:
+      TRACE_EVENT("Header Type: TYPE_ERROR");
+      break;
+    }
+
+#ifdef SNDCP_TRACE_BUFFER
+    sndcp_trace_desc_list(dest_desc_list);
+#endif /* SNDCP_TRACE_BUFFER */
+
+} /* cia_header_comp*/
+
+#endif /* CF_FAST_EXEC */
+
+
+#ifndef _SNDCP_DTI_2_
+/*
++------------------------------------------------------------------------------
+| Function    : cia_su_cia_comp_req
++------------------------------------------------------------------------------
+| Description : Simulation for cia reaction to SIG_SU_CIA_DATA_REQ.
+|               Instead of sending the pdu to cia and then receiving
+|               1 or more CIA_COMP_IND.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+/*#if defined(CF_FAST_EXEC) || defined(_SIMULATION_) || \
+   !defined(REL99)   || defined(SNDCP_2to1) */
+
+LOCAL void cia_su_cia_comp_req (T_SN_UNITDATA_REQ* sn_unitdata_req,
+                                USHORT npdu_number,
+                                UBYTE nsapi,
+                                UBYTE sapi,
+                                UBYTE packet_type
+                                )
+{
+  BOOL ready = FALSE;
+  USHORT header_size = SN_UNITDATA_PDP_HDR_LEN_BIG;
+  /*
+   * Bit offset in destination sdu.
+   */
+  USHORT bit_offset = ENCODE_OFFSET + (USHORT)(header_size << 3);
+  /*
+   * Offset in current desc.
+   */
+  USHORT desc_offset = 0;
+  USHORT sdu_len = 0;
+  UBYTE first = SEG_POS_FIRST;
+  UBYTE segment_number = 0;
+  T_desc_list* desc_list = &sn_unitdata_req->desc_list;
+
+  TRACE_FUNCTION( "cia_su_cia_comp_req" );
+
+  while (!ready && desc_list->first != NULL) {
+   /*
+    * How long will sdu be?
+    */
+    if (desc_list->list_len + header_size >= sndcp_data->su->n201_u) {
+      sdu_len = (USHORT)(sndcp_data->su->n201_u << 3);
+    } else {
+      sdu_len = (USHORT)((desc_list->list_len + header_size) << 3);
+    }
+    {
+      PALLOC_SDU(cia_comp_ind, CCI_COMP_IND, sdu_len);
+      /*
+       * Set parameters.
+       */
+
+      cia_comp_ind->sapi = sapi;
+      /*
+       * cia_qos is not yet used, set to 0.
+       */
+      cia_comp_ind->cia_qos.delay = 0;
+      cia_comp_ind->cia_qos.relclass = 0;
+      cia_comp_ind->cia_qos.peak = 0;
+      cia_comp_ind->cia_qos.preced = 0;
+      cia_comp_ind->cia_qos.mean = 0;
+      /*
+       * Will be changed as soon as more that 1 instance of V42.bis is used.
+       */
+      cia_comp_ind->algo_type = CIA_ALGO_V42;
+      cia_comp_ind->comp_inst = CIA_COMP_INST_V42_0;
+
+      cia_comp_ind->pdu_ref.ref_nsapi = nsapi;
+      cia_comp_ind->pdu_ref.ref_npdu_num = npdu_number;
+      cia_comp_ind->pdu_ref.ref_seg_num = segment_number;
+      segment_number ++;
+      if (desc_list->list_len + header_size <= sndcp_data->su->n201_u) {
+        cia_comp_ind->seg_pos = first + SEG_POS_LAST;
+      } else {
+        cia_comp_ind->seg_pos = first;
+      }
+      cia_comp_ind->packet_type = packet_type;
+      /*
+       * Copy descriptors to cia_comp_ind->sdu.
+       */
+      while (desc_list->first != NULL) {
+        T_desc* help = (T_desc*)desc_list->first;
+        USHORT cur_len = (((T_desc*)desc_list->first)->len - desc_offset);
+        if ((cur_len << 3) <=
+             cia_comp_ind->sdu.l_buf +
+             cia_comp_ind->sdu.o_buf -
+             bit_offset) {
+
+          /*
+           * Copy current desc to sdu.
+           */
+          if (cur_len>0)
+          {
+            memcpy(&cia_comp_ind->sdu.buf[bit_offset >> 3],
+                   &((T_desc*)desc_list->first)->buffer[desc_offset],
+                   cur_len);
+          }
+          bit_offset += (USHORT)(cur_len << 3);
+          desc_list->list_len -= cur_len;
+
+          /*
+           * Free read desc and go to next in list.
+           */
+          desc_list->first = help->next;
+          desc_offset = 0;
+          MFREE(help);
+          help = NULL;
+        } else {
+          /*
+           * Current desc does not fit completely in sdu.
+           */
+          USHORT part_len = (USHORT)(cia_comp_ind->sdu.l_buf +
+                                    cia_comp_ind->sdu.o_buf -
+                                    bit_offset)
+                            >> 3;
+          if (part_len > 0)
+          {
+            memcpy(&cia_comp_ind->sdu.buf[bit_offset >> 3],
+                   &((T_desc*)desc_list->first)->buffer[desc_offset],
+                   part_len);
+            desc_offset += part_len;
+          }
+          desc_list->list_len -= part_len;
+
+          header_size = SN_UNITDATA_PDP_HDR_LEN_SMALL;
+          bit_offset = ENCODE_OFFSET + (USHORT)(header_size << 3);
+
+          break;
+        }
+      } /* while (desc_list->first != NULL) { */
+      /*
+       * Instead of PSEND(SNDCP_handle, cia_comp_ind);
+       */
+      cia_cia_comp_ind(cia_comp_ind);
+      /*
+       * One segment sent, set 'first' to 'none'.
+       */
+      first = SEG_POS_NONE;
+    }
+    /*
+     * If the desc_list is empty now, leave.
+     */
+
+    if (sn_unitdata_req->desc_list.list_len == 0) {
+      PFREE(sn_unitdata_req);
+      sn_unitdata_req = NULL;
+      ready = TRUE;
+    }
+  }
+
+} /* cia_su_cia_comp_req() */
+/*#endif */ /* CF_FAST_EXEC || _SIMULATION_ || !REL99 || SNDCP_2to1 */
+
+#else /* _SNDCP_DTI_2_ */
+/*
++------------------------------------------------------------------------------
+| Function    : cia_su_cia_comp_req
++------------------------------------------------------------------------------
+| Description : This function is used, if no data compression is used in
+|               uplink. It does only the segmentation of the incoming data.
+| 
+|               Simulation for cia reaction to SIG_SU_CIA_DATA_REQ.
+|               Instead of sending the pdu to cia and then receiving
+|               1 or more CIA_COMP_IND.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+/*#if defined(CF_FAST_EXEC) || defined(_SIMULATION_) || \
+   !defined(REL99)   || defined(SNDCP_2to1) */
+
+LOCAL void cia_su_cia_comp_req (T_SN_UNITDATA_REQ* sn_unitdata_req,
+                                USHORT npdu_number,
+                                UBYTE nsapi,
+                                UBYTE sapi,
+                                UBYTE packet_type
+                                )
+{
+  BOOL ready = FALSE;
+  U16 header_size = SN_UNITDATA_PDP_HDR_LEN_BIG;
+  U16 desc2_data_struct_offset = 0;
+  U8 first = SEG_POS_FIRST;
+  U8 segment_number = 0;
+  U32* segment_header;
+  T_desc_list2* desc_list2 = &sn_unitdata_req->desc_list2;
+  T_desc_list3 desc_list3;
+  T_desc3* desc3;
+  T_desc3* current_desc3;
+  /*
+   * Offset in current desc. Set the desc_offset to the offset of 
+   * the first desc in the list that is to be read.
+   */
+  U16 desc_offset = ((T_desc2*)desc_list2->first)->offset;
+
+  TRACE_FUNCTION( "cia_su_cia_comp_req" );
+
+  while (!ready && desc_list2->first != NULL)
+  {
+   /*
+    * How long will the segment be?
+    */
+    desc_list3.first = NULL;
+    desc_list3.list_len = 0;
+    if ((desc_list2->list_len + header_size) >= sndcp_data->su->n201_u)
+    {
+      desc_list3.list_len = (USHORT)sndcp_data->su->n201_u;
+    }
+    else
+    {
+      desc_list3.list_len = (USHORT)(desc_list2->list_len + header_size);
+    }
+
+    {
+      T_CIA_COMP_IND *cia_comp_ind;
+      MALLOC(cia_comp_ind, sizeof(T_CIA_COMP_IND));
+      /*
+       * Set parameters.
+       */
+
+      cia_comp_ind->sapi = sapi;
+      /*
+       * cia_qos is not yet used, set to 0.
+       */
+      cia_comp_ind->cia_qos.delay = 0;
+      cia_comp_ind->cia_qos.relclass = 0;
+      cia_comp_ind->cia_qos.peak = 0;
+      cia_comp_ind->cia_qos.preced = 0;
+      cia_comp_ind->cia_qos.mean = 0;
+      /*
+       * Will be changed as soon as more that 1 instance of V42.bis is used.
+       */
+      cia_comp_ind->algo_type = CIA_ALGO_V42;
+      cia_comp_ind->comp_inst = CIA_COMP_INST_V42_0;
+
+      cia_comp_ind->pdu_ref.ref_nsapi = nsapi;
+      cia_comp_ind->pdu_ref.ref_npdu_num = npdu_number;
+      cia_comp_ind->pdu_ref.ref_seg_num = segment_number;
+      segment_number ++;
+
+      /* Allocate memory for SNDCP header and LLC encode offset */
+      MALLOC (segment_header, (USHORT)(ENCODE_OFFSET_BYTE + header_size));
+
+      MALLOC (desc3, (U16)(sizeof(T_desc3)));
+      /*
+       * Fill desc3 descriptor control information.
+       */
+      desc3->next  = (U32)NULL;
+      desc3->len   = header_size;
+      desc3->offset = ENCODE_OFFSET_BYTE;
+      desc3->buffer = (U32)segment_header;
+      desc_list3.first = (U32)desc3;
+      current_desc3 = desc3;
+
+      if (desc_list2->list_len + header_size <= sndcp_data->su->n201_u)
+      {
+        cia_comp_ind->seg_pos = first + SEG_POS_LAST;
+      } else {
+        cia_comp_ind->seg_pos = first;
+      }
+      cia_comp_ind->packet_type = packet_type;
+      cia_comp_ind->desc_list3.first = desc_list3.first;
+      cia_comp_ind->desc_list3.list_len = desc_list3.list_len;
+
+      desc_list3.list_len = 0;
+      desc_list3.list_len += desc3->len;
+      /*
+       * Copy descriptors to cia_comp_ind->desc_list3, list may have to be built.
+       */
+      while (desc_list2->first != NULL)
+      {/* This while moves data from desc2 to segment defined by desc3 descriptors*/
+        T_desc2* help = (T_desc2*)desc_list2->first;
+        U16 cur_len = (((T_desc2*)desc_list2->first)->len - desc_offset);
+        desc2_data_struct_offset = offsetof(T_desc2, buffer);
+        if (cur_len <= (sndcp_data->su->n201_u - desc_list3.list_len))
+        {/* Is there room for all the desc2 data in the current segment */
+
+          /*
+           * describe current desc2 by desc3 descriptors.
+           */
+
+          MALLOC (desc3, (USHORT)(sizeof(T_desc3)));
+          /*
+           * Fill desc3 descriptor control information.
+           */
+          desc3->next  = (U32)NULL;
+          desc3->len   = cur_len;
+          desc3->offset = desc_offset + desc2_data_struct_offset;
+          desc3->buffer = (U32)desc_list2->first;
+          current_desc3->next = (U32)desc3;
+          current_desc3 = desc3;
+          desc_list3.list_len += desc3->len;
+
+          /* Attach desc3 to desc2 allocation, this is always the last
+             attach on a desc2 descriptor */
+          sndcp_cl_desc2_attach(help);
+
+          desc_list2->list_len -= cur_len;
+
+          /*
+           * Free read desc and go to next in list.
+           */
+          desc_list2->first = help->next;
+          /* 
+           * If another desc is present in the list to be read, then 
+           * set the desc_offset to the offset of the next desc in the 
+           * list that is to be read. Else set desc_offset to zero
+           */
+          if (desc_list2->first != NULL)
+          {
+            desc_offset = ((T_desc2*)desc_list2->first)->offset;
+          }
+          else
+          {
+            desc_offset = 0;
+          }
+          MFREE(help);
+          help = NULL;
+        } else {
+          /*
+           * Current desc does not fit completely in sdu.
+           */
+
+          USHORT part_len = (USHORT)(sndcp_data->su->n201_u - desc_list3.list_len);
+
+          if (part_len > 0)
+          {
+            MALLOC (desc3, (USHORT)(sizeof(T_desc3)));
+            /*
+             * Fill desc3 descriptor control information.
+             */
+            desc3->next  = (ULONG)NULL;
+            desc3->len   = part_len;
+            desc3->offset = desc_offset + desc2_data_struct_offset;
+            desc3->buffer = (ULONG)desc_list2->first;
+            current_desc3->next = (ULONG)desc3;
+            current_desc3 = desc3;
+            desc_list3.list_len += desc3->len;
+
+            /* Attach desc3 to desc2 allocation, this is an intermediate
+               attach on a desc2 descriptor */
+            sndcp_cl_desc2_attach(help);
+
+            desc_offset += part_len;
+          }
+          desc_list2->list_len -= part_len;
+
+          header_size = SN_UNITDATA_PDP_HDR_LEN_SMALL;
+          break;
+        }
+      } /* while (desc_list->first != NULL) { */
+
+      /*
+       * Instead of PSEND(SNDCP_handle, cia_comp_ind);
+       */
+      cia_cia_comp_ind(cia_comp_ind);
+      /*
+       * One segment sent, set 'first' to 'none'.
+       */
+      first = SEG_POS_NONE;
+    }
+    /*
+     * If the desc_list is empty now, leave.
+     */
+    if (sn_unitdata_req->desc_list2.list_len == 0) {
+
+      MFREE(sn_unitdata_req);
+      sn_unitdata_req = NULL;
+      ready = TRUE;
+    }
+  }
+} /* cia_su_cia_comp_req() */
+/*#endif */ /* CF_FAST_EXEC || _SIMULATION_ || !REL99 || SNDCP_2to1 */
+
+#ifdef TI_PS_FF_V42BIS
+/*
++------------------------------------------------------------------------------
+| Function    : cia_su_cci_comp_req
++------------------------------------------------------------------------------
+| Description : This function is used, if data compression is used in uplink
+|               direction. At first it calls the data compression function with
+|               parameters, that allow a segmentation without memcopy. Than it
+|               does the segmentation.
+|
+|               Simulation for CCI reaction to SIG_SU_CIA_DATA_REQ.
+|               Instead of sending the pdu to CCI and then receiving
+|               1 or more CCI_COMP_IND.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+/*#if defined(CF_FAST_EXEC) || defined(_SIMULATION_) || \
+   !defined(REL99)   || defined(SNDCP_2to1) */
+   
+LOCAL void cia_su_cci_comp_req (T_SN_UNITDATA_REQ* sn_unitdata_req,
+                                          USHORT npdu_number,
+                                          UBYTE nsapi,
+                                          UBYTE sapi,
+                                          UBYTE packet_type
+                                        )
+{
+  BOOL ready = FALSE;
+  U16 header_size = SN_UNITDATA_PDP_HDR_LEN_BIG;
+  U16 desc2_data_struct_offset = offsetof(T_desc2, buffer);
+  U8 segment_position = SEG_POS_FIRST;
+  U8 segment_number = 0;
+  U32* segment_header;
+  T_desc_list2* desc_list2 = &sn_unitdata_req->desc_list2;
+  T_desc2* desc2;
+  T_desc_list3 desc_list3;
+  T_desc3* desc3;
+  T_desc3* current_desc3;
+  
+  U8 descs_per_seg = 5;
+  U8 i;
+  U16 desc_size = (sndcp_data->su->n201_u - header_size -
+                  (desc2_data_struct_offset + 1) * descs_per_seg) /
+                  descs_per_seg +
+                  desc2_data_struct_offset + 1;
+  
+  
+  
+  
+  
+  
+  TRACE_FUNCTION( "cia_su_cci_comp_req" );
+  TRACE_EVENT_P1("sn_unitdata_req in: %08x", sn_unitdata_req);
+  //TRACE_EVENT_P1("PacketType: %d",packet_type);
+
+  /*
+   * Reset V.42 context and call the encoder routine
+   */
+  //TRACE_EVENT_P1("V42 ENC: Input Uncompressed Packet, length %d", desc_list2->list_len);
+#ifdef SNDCP_TRACE_BUFFER
+  //sndcp_trace_desc_list(desc_list2);
+#endif
+  v42b_init(sndcp_data->cia.enc, 0, 0, 0, 0);
+  TRACE_FUNCTION ("as reinit in uplink");
+  /*
+   * the function can be called with 0s as parameters, because it was initialized
+   * befor what the function sees on the valid magic number
+   *
+   * the call replaces an independent reinit function
+   */
+  v42b_encoder(sndcp_data->cia.enc, desc_list2, NULL, desc_size);
+  //TRACE_EVENT_P1("V42 ENC: Output Compresset Packet, length %d", desc_list2->list_len);
+#ifdef SNDCP_TRACE_BUFFER
+  //sndcp_trace_desc_list(desc_list2);
+#endif
+
+
+  desc2 = (T_desc2*)desc_list2->first;
+
+  while (desc2)
+  {
+    
+    
+    
+    desc_list3.first = (U32) NULL;
+    desc_list3.list_len = 0;
+    
+
+    MALLOC(segment_header, (ENCODE_OFFSET_BYTE + header_size));
+    MALLOC(desc3,sizeof(T_desc3));
+
+    desc3->next = (U32) NULL;
+    desc3->len = header_size;
+    desc3->offset = ENCODE_OFFSET_BYTE;
+    desc3->buffer = (U32)segment_header;
+
+    desc_list3.first = (U32)desc3;
+    desc_list3.list_len = desc3->len;
+
+    current_desc3 = desc3;
+
+    for (i = 0; (i < descs_per_seg) && desc2; i++)
+    {
+      MALLOC(desc3,sizeof(T_desc3));
+
+      desc3->next = (U32) NULL;
+      desc3->len = desc2->len;
+      desc3->offset = desc2->offset + desc2_data_struct_offset;
+      desc3->buffer = (U32)desc2;
+
+      current_desc3->next = (U32) desc3;
+      current_desc3 = desc3;
+      desc_list3.list_len += desc3->len;
+
+      desc2 = (T_desc2*) desc2->next;
+    }
+    header_size = SN_UNITDATA_PDP_HDR_LEN_SMALL;
+
+    {
+      T_CIA_COMP_IND *cia_comp_ind;
+      MALLOC(cia_comp_ind, sizeof(T_CIA_COMP_IND));
+      /*
+       * Set parameters.
+       */
+
+      cia_comp_ind->sapi = sapi;
+      /*
+       * cci_qos is not yet used, set to 0.
+       */
+      cia_comp_ind->cia_qos.delay = 0;
+      cia_comp_ind->cia_qos.relclass = 0;
+      cia_comp_ind->cia_qos.peak = 0;
+      cia_comp_ind->cia_qos.preced = 0;
+      cia_comp_ind->cia_qos.mean = 0;
+      /*
+       * Will be changed as soon as more that 1 instance of V42.bis is used.
+       */
+      cia_comp_ind->algo_type = CCI_ALGO_V42;
+      cia_comp_ind->comp_inst = CCI_COMP_INST_V42_0;
+
+      cia_comp_ind->pdu_ref.ref_nsapi = nsapi;
+      cia_comp_ind->pdu_ref.ref_npdu_num = npdu_number;
+      cia_comp_ind->pdu_ref.ref_seg_num = segment_number;
+      segment_number ++;
+
+      if (desc2 != NULL)
+      {
+        cia_comp_ind->seg_pos = segment_position;
+      }
+      else
+      {
+        cia_comp_ind->seg_pos = segment_position | SEG_POS_LAST;
+      }
+
+      cia_comp_ind->packet_type = packet_type;
+      cia_comp_ind->desc_list3.first = desc_list3.first;
+      cia_comp_ind->desc_list3.list_len = desc_list3.list_len;
+
+      /*
+       * Instead of PSEND(SNDCP_handle, cci_comp_ind);
+       */
+      cia_cia_comp_ind(cia_comp_ind);
+      /*
+       * One segment sent, set 'first' to 'none'.
+       */
+      segment_position = SEG_POS_NONE;
+    }
+  }
+  /*
+   * If the desc_list2 is empty now, leave.
+   */
+  TRACE_EVENT_P1("sn_unitdata_req out: %08x", sn_unitdata_req);
+  MFREE(sn_unitdata_req);
+  sn_unitdata_req = NULL;
+}
+/*#endif */ /* FAST_EXEC */
+#endif /* TI_PS_FF_V42BIS */
+#endif /* _SNDCP_DTI_2_ */
+
+#ifdef _SNDCP_DTI_2_
+/*
++------------------------------------------------------------------------------
+| Function    : cia_sua_cia_comp_req
++------------------------------------------------------------------------------
+| Description : Simulation for cia reaction to SIG_SUA_CIA_DATA_REQ.
+|               Instead of sending the pdu to cia and then receiving
+|               1 or more CIA_COMP_IND.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+#ifndef CF_FAST_EXEC
+
+LOCAL void cia_sua_cia_comp_req (T_desc_list2 dest_desc_list,
+                                 U8 npdu_number,
+                                 U8 nsapi,
+                                 U8 sapi,
+                                 U8 packet_type
+                                 )
+{
+  BOOL ready = FALSE;
+  U16 header_size = SN_DATA_PDP_HDR_LEN_BIG;
+  U16 desc2_data_struct_offset = 0;
+  U8 first = SEG_POS_FIRST;
+  U8 segment_number = 0;
+  U32* segment_header;
+  T_desc_list2* desc_list2 = &dest_desc_list;
+  T_desc_list3 desc_list3;
+  T_desc3* desc3;
+  T_desc3* current_desc3;
+  USHORT list_len = desc_list2->list_len;
+  T_desc2* help = (T_desc2*)desc_list2->first;
+  T_desc2* delhelp = NULL;
+
+  /* 
+   * Offset in current descriptor  Set the desc_offset to the offset of 
+   * the first desc in the list that is to be read.
+   */
+  U16 desc_offset = help->offset;
+
+  TRACE_FUNCTION( "cia_sua_cia_comp_req" );
+
+  while (!ready && help != NULL) {
+   /*
+    * How long will the segment be?
+    */
+    desc_list3.first = NULL;
+    desc_list3.list_len = 0;
+    if ((list_len + header_size) >= sndcp_data->sua->n201_i)
+    {
+      desc_list3.list_len = (U16)sndcp_data->sua->n201_i;
+    }
+    else
+    {
+      desc_list3.list_len = (U16)(list_len + header_size);
+    }
+
+    {
+      /*
+       * First desc in list must be header!!!
+       */
+      BOOL first_part = TRUE;
+
+      T_CIA_COMP_IND *cia_comp_ind;
+      MALLOC(cia_comp_ind, sizeof(T_CIA_COMP_IND));
+      /*
+       * Set parameters.
+       */
+      cia_comp_ind->sapi = sapi;
+      /*
+       * cia_qos is not yet used, set to 0.
+       */
+      cia_comp_ind->cia_qos.delay = 0;
+      cia_comp_ind->cia_qos.relclass = 0;
+      cia_comp_ind->cia_qos.peak = 0;
+      cia_comp_ind->cia_qos.preced = 0;
+      cia_comp_ind->cia_qos.mean = 0;
+      /*
+       * Will be changed as soon as more that 1 instance of V42.bis is used.
+       */
+      cia_comp_ind->algo_type = CIA_ALGO_V42;
+      cia_comp_ind->comp_inst = CIA_COMP_INST_V42_0;
+
+      cia_comp_ind->pdu_ref.ref_nsapi = nsapi;
+      cia_comp_ind->pdu_ref.ref_npdu_num = npdu_number;
+      cia_comp_ind->pdu_ref.ref_seg_num = segment_number;
+      segment_number ++;
+
+      /* Allocate memory for SNDCP header and LLC encode offset */
+      MALLOC (segment_header, (U16)(ENCODE_OFFSET_BYTE + header_size));
+
+      MALLOC (desc3, (U16)(sizeof(T_desc3)));
+      /*
+       * Fill desc3 descriptor control information.
+       */
+      desc3->next  = (U32)NULL;
+      desc3->len   = header_size;
+      desc3->offset = ENCODE_OFFSET_BYTE;
+      desc3->buffer = (U32)segment_header;
+      desc_list3.first = (U32)desc3;
+      current_desc3 = desc3;
+
+      if (list_len + header_size <= sndcp_data->sua->n201_i)
+      {
+        cia_comp_ind->seg_pos = first + SEG_POS_LAST;
+      } else {
+        cia_comp_ind->seg_pos = first;
+      }
+      cia_comp_ind->packet_type = packet_type;
+      cia_comp_ind->desc_list3.first = desc_list3.first;
+      cia_comp_ind->desc_list3.list_len = desc_list3.list_len;
+
+      desc_list3.list_len = 0;
+      desc_list3.list_len += desc3->len;
+      /*
+       * Copy descriptors to cia_comp_ind->desc_list3, list may have to be built.
+       */
+      while (help != NULL)
+      {/*
+        * This while moves data from desc2 to segment defined
+        * by desc3 descriptors
+        */
+        U16 cur_len = (help->len - desc_offset);
+        desc2_data_struct_offset = offsetof(T_desc2, buffer);
+        if (cur_len <= (sndcp_data->sua->n201_i - desc_list3.list_len))
+        {/* Is there room for all the desc2 data in the current segment */
+          /*
+           * describe current desc2 by desc3 descriptors.
+           */
+          if (cur_len>0)
+          {
+            MALLOC (desc3, (U16)(sizeof(T_desc3)));
+            /*
+             * Fill desc3 descriptor control information.
+             */
+            desc3->next  = (U32)NULL;
+            desc3->len   = cur_len;
+            desc3->offset = desc_offset + desc2_data_struct_offset;
+            desc3->buffer = (U32)help;
+            current_desc3->next = (ULONG)desc3;
+            current_desc3 = desc3;
+            desc_list3.list_len += desc3->len;
+
+            /* Attach desc3 to desc2 allocation, this is always the last
+               attach on a desc2 descriptor */
+            sndcp_cl_desc2_attach(help);
+
+          }
+          list_len -= cur_len;
+
+          /*
+           * Free read desc and go to next in list.
+           */
+          if (help != NULL)
+          {
+            delhelp = help;
+            help = (T_desc2*)help->next;
+          }
+          /* 
+           * If another desc is present in the list to be read, then 
+           * set the desc_offset to the offset of the next desc in the 
+           * list that is to be read. Else set desc_offset to zero
+           */
+          if (help != NULL)
+          {
+            desc_offset = help->offset;
+          }
+          else
+          {
+            desc_offset = 0;
+          }
+          if (delhelp != NULL &&
+              first_part &&
+              (packet_type == TYPE_COMPRESSED_TCP ||
+               packet_type == TYPE_UNCOMPRESSED_TCP)) {
+
+            MFREE(delhelp);
+            delhelp = NULL;
+            first_part = FALSE;
+          }
+        }
+        else
+        {
+          /*
+           * Current desc does not fit completely in sdu.
+           */
+
+          U16 part_len = (USHORT)(sndcp_data->sua->n201_i-desc_list3.list_len);
+
+          if (part_len>0)
+          {
+            MALLOC (desc3, (USHORT)(sizeof(T_desc3)));
+            /*
+             * Fill desc3 descriptor control information.
+             */
+            desc3->next  = (ULONG)NULL;
+            desc3->len   = part_len;
+            desc3->offset = desc_offset + desc2_data_struct_offset;
+            desc3->buffer = (ULONG)help;
+            current_desc3->next = (ULONG)desc3;
+            current_desc3 = desc3;
+            desc_list3.list_len += desc3->len;
+
+            /* Attach desc3 to desc2 allocation, this is an intermediate
+               attach on a desc2 descriptor */
+            sndcp_cl_desc2_attach(help);
+
+            desc_offset += part_len;
+          }
+          list_len -= part_len;
+
+          header_size = SN_DATA_PDP_HDR_LEN_SMALL;
+          break;
+        }
+      }
+      /*
+       * Instead of PSEND(SNDCP_handle, cia_comp_ind);
+       */
+      cia_cia_comp_ind(cia_comp_ind);
+      /*
+       * One segment sent, set 'first' to 'none'.
+       */
+      first = SEG_POS_NONE;
+    }
+    /*
+     * If the desc_list is empty now, leave.
+     */
+    if (list_len == 0) {
+      ready = TRUE;
+    }
+  }
+} /* cia_sua_cia_comp_req() */
+
+#endif /* CF_FAST_EXEC */
+
+#else /* _SNDCP_DTI_2_ */
+/*
++------------------------------------------------------------------------------
+| Function    : cia_sua_cia_comp_req
++------------------------------------------------------------------------------
+| Description : Simulation for cia reaction to SIG_SUA_CIA_DATA_REQ.
+|               Instead of sending the pdu to cia and then receiving
+|               1 or more CIA_COMP_IND.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+#ifndef CF_FAST_EXEC
+
+LOCAL void cia_sua_cia_comp_req (T_desc_list dest_desc_list,
+                                 UBYTE npdu_number,
+                                 UBYTE nsapi,
+                                 UBYTE sapi,
+                                 UBYTE packet_type
+                                 )
+{
+  BOOL ready = FALSE;
+  USHORT header_size = SN_DATA_PDP_HDR_LEN_BIG;
+  USHORT bit_offset = ENCODE_OFFSET + (USHORT)(header_size << 3);
+  USHORT desc_offset = 0;
+  USHORT sdu_len = 0;
+  UBYTE first = SEG_POS_FIRST;
+  UBYTE segment_number = 0;
+  T_desc_list* desc_list = &dest_desc_list;
+  USHORT list_len = desc_list->list_len;
+  T_desc* help = (T_desc*)desc_list->first;
+  T_desc* delhelp = NULL;
+
+  USHORT help_buffer_offset = 0;
+
+  TRACE_FUNCTION( "cia_sua_cia_comp_req" );
+
+  while (!ready && help != NULL) {
+   /*
+    * How long will sdu be?
+    */
+    if (list_len + header_size >= sndcp_data->sua->n201_i) {
+      sdu_len = (USHORT)(sndcp_data->sua->n201_i << 3);
+    } else {
+      sdu_len = (USHORT)((list_len + header_size) << 3);
+    }
+    {
+      /*
+       * First desc in list must be header!!!
+       */
+      BOOL first_part = TRUE;
+
+      PALLOC_SDU(cia_comp_ind, CCI_COMP_IND, sdu_len);   
+      /*
+       * Set parameters.
+       */
+      cia_comp_ind->sapi = sapi;
+      /*
+       * cia_qos is not yet used, set to 0.
+       */
+      cia_comp_ind->cia_qos.delay = 0;
+      cia_comp_ind->cia_qos.relclass = 0;
+      cia_comp_ind->cia_qos.peak = 0;
+      cia_comp_ind->cia_qos.preced = 0;
+      cia_comp_ind->cia_qos.mean = 0;
+      /*
+       * Will be changed as soon as more that 1 instance of V42.bis is used.
+       */
+      cia_comp_ind->algo_type = CIA_ALGO_V42;
+      cia_comp_ind->comp_inst = CIA_COMP_INST_V42_0;
+
+      cia_comp_ind->pdu_ref.ref_nsapi = nsapi;
+      cia_comp_ind->pdu_ref.ref_npdu_num = npdu_number;
+      cia_comp_ind->pdu_ref.ref_seg_num = segment_number;
+      segment_number ++;
+      if (list_len + header_size <= sndcp_data->sua->n201_i) {
+        cia_comp_ind->seg_pos = first + SEG_POS_LAST;
+      } else {
+        cia_comp_ind->seg_pos = first;
+      }
+      cia_comp_ind->packet_type = packet_type;
+      /*
+       * Copy descriptors to cia_comp_ind->sdu.
+       */
+      while (help != NULL) {
+        USHORT cur_len = (help->len - desc_offset);
+
+        if ((cur_len << 3) <=
+             cia_comp_ind->sdu.l_buf +
+             cia_comp_ind->sdu.o_buf -
+             bit_offset) {
+
+          /*
+           * Copy current desc to sdu.
+           */
+          if (cur_len>0)
+          {
+            memcpy(&cia_comp_ind->sdu.buf[bit_offset >> 3],
+                   &help->buffer[desc_offset],
+                   cur_len);
+          }
+          bit_offset += (USHORT)(cur_len << 3);
+          list_len -= cur_len;
+
+          /*
+           * Free read desc and go to next in list.
+           */
+          if (help != NULL) {
+            delhelp = help;
+            help = (T_desc*)help->next;
+          }
+          help_buffer_offset = 0;
+          desc_offset = 0;
+          if (delhelp != NULL &&
+              first_part &&
+              (packet_type == TYPE_COMPRESSED_TCP ||
+               packet_type == TYPE_UNCOMPRESSED_TCP)) {
+
+            MFREE(delhelp);
+            delhelp = NULL;
+            first_part = FALSE;
+          }
+        } else {
+          /*
+           * Current desc does not fit completely in sdu.
+           */
+          desc_offset = (USHORT)(cia_comp_ind->sdu.l_buf +
+                                 cia_comp_ind->sdu.o_buf -
+                                 bit_offset)
+                         >> 3;
+          if (desc_offset>0)
+          {
+            memcpy(&cia_comp_ind->sdu.buf[bit_offset >> 3],
+                   &help->buffer[help_buffer_offset],
+                   desc_offset);
+            help_buffer_offset += (desc_offset);
+          }
+          list_len -= desc_offset;
+
+          header_size = SN_DATA_PDP_HDR_LEN_SMALL;
+          bit_offset = ENCODE_OFFSET + (USHORT)(header_size << 3);
+          break;
+        }
+      }
+      /*
+       * Instead of PSEND(SNDCP_handle, cia_comp_ind);
+       */
+      cia_cia_comp_ind(cia_comp_ind);
+      /*
+       * One segment sent, set 'first' to 'none'.
+       */
+      first = SEG_POS_NONE;
+    }
+    /*
+     * If the desc_list is empty now, leave.
+     */
+    if (list_len == 0) {
+      ready = TRUE;
+    }
+  }
+
+} /* cia_sua_cia_comp_req() */
+
+#endif /* CF_FAST_EXEC */
+
+#endif /*_SNDCP_DTI_2_*/
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : cia_sd_cia_decomp_req
++------------------------------------------------------------------------------
+| Description : This Function does the defragmentation for noncompressed data.
+| 
+| Simulation for cia reaction to SIG_SD_CIA_TRANSFER_REQ.
+| If (cur_seg_pos & SEG_POS_FIRST > 0) then a new CIA_DECOMP_IND is allocated.
+| T_desc is allocated with the length of the sdu included in the
+| ll_unitdata_ind. The sdu data is copied to the desc and the desc is added to
+| the currently assembled desc_list in the current CIA_DECOMP_IND.
+| If (cur_seg_pos & SEG_POS_LAST > 0) then a the CIA_DECOMP_IND is now complete
+| and is "sent to this service" by calling the cia function cia_cia_decomp_ind.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+/*#if defined(CF_FAST_EXEC) || defined(_SIMULATION_) || \
+   !defined(REL99)   || defined(SNDCP_2to1) */
+
+GLOBAL void cia_sd_cia_decomp_req(T_LL_UNITDATA_IND* ll_unitdata_ind)
+{
+  USHORT length = 0;
+  USHORT header_len = SN_UNITDATA_PDP_HDR_LEN_SMALL;
+  USHORT sdu_index = 0;
+  T_CIA_DECOMP_IND *cur_cia_decomp_ind;
+  UBYTE nsapi;
+#ifdef _SNDCP_DTI_2_
+  T_desc2* help = NULL;
+  T_desc2* descriptor = NULL;
+#else /*_SNDCP_DTI_2_*/
+  T_desc* help = NULL;
+  T_desc* descriptor = NULL;
+#endif /*_SNDCP_DTI_2_*/
+
+  TRACE_FUNCTION( "cia_sd_cia_decomp_req" );
+
+  nsapi = (ll_unitdata_ind->sdu.buf[(ll_unitdata_ind->sdu.o_buf / 8)]) & 0xf;
+  cur_cia_decomp_ind = sndcp_data->cia.cur_cia_decomp_ind[nsapi];
+  
+  /*
+   * In case of first segment allocate new N-PDU.
+   */
+  if ((sndcp_data->cur_seg_pos[nsapi] & SEG_POS_FIRST) > 0) {
+    {
+
+      T_CIA_DECOMP_IND *cia_decomp_ind;
+      MALLOC(cia_decomp_ind, sizeof(T_CIA_DECOMP_IND));
+
+#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 */
+
+
+      /*
+       * if there is an unfinished cur_cia_decomp_ind deallocate it together
+       * with the allocated descriptors
+       */
+      if (cur_cia_decomp_ind NEQ NULL)
+      {
+        MFREE_PRIM(cur_cia_decomp_ind);
+        TRACE_EVENT("Deallocate unfinished cur_cia_decomp_ind");
+      }
+      cur_cia_decomp_ind = cia_decomp_ind;
+      /*
+       * Will be changed as soon as more that 1 instance of V42.bis is used.
+       */
+      cur_cia_decomp_ind->algo_type = CIA_ALGO_V42;
+      cur_cia_decomp_ind->comp_inst = CIA_COMP_INST_V42_0;
+
+      cur_cia_decomp_ind->pdu_ref = sndcp_data->cur_pdu_ref[nsapi];
+      cur_cia_decomp_ind->desc_list2.first = (ULONG)NULL;
+      cur_cia_decomp_ind->desc_list2.list_len = 0;
+
+      header_len = SN_UNITDATA_PDP_HDR_LEN_BIG;
+      cia_decomp_ind->pcomp =
+        ll_unitdata_ind->sdu.buf[(ll_unitdata_ind->sdu.o_buf >> 3) + 1] & 0xf;
+    }
+  }
+  /*
+   * If big header has been received in state != RECEIVE_FIRST_SEGMENT
+   */
+  if (sndcp_data->big_head[nsapi]) {
+    header_len = SN_UNITDATA_PDP_HDR_LEN_BIG;
+  }
+  sdu_index = (ll_unitdata_ind->sdu.o_buf >> 3) + header_len;
+  length = (ll_unitdata_ind->sdu.l_buf >> 3) - header_len;
+  /*
+   * Allocate new descriptor and copy sdu data.
+   */
+#ifdef _SNDCP_DTI_2_
+  MALLOC (descriptor, (USHORT)(sizeof(T_desc2) - 1 + length));
+#else /*_SNDCP_DTI_2_*/
+  MALLOC (descriptor, (USHORT)(sizeof(T_desc) - 1 + length));
+#endif /*_SNDCP_DTI_2_*/
+
+  /*
+   * Fill descriptor control information.
+   */
+  descriptor->next  = (ULONG)NULL;
+  descriptor->len   = length;
+#ifdef _SNDCP_DTI_2_
+  descriptor->offset = 0;
+  descriptor->size = descriptor->len;
+#endif
+
+  /*
+   * Add length of descriptor data to list length.
+   */
+  cur_cia_decomp_ind->desc_list2.list_len += length;
+
+  /*
+   * Copy user data from SDU to descriptor.
+   */
+  if (length>0)
+  {
+    memcpy (descriptor->buffer,
+            &ll_unitdata_ind->sdu.buf[sdu_index],
+            length);
+  }
+
+  /*
+   * Add desc to desc_list.
+   */
+#ifdef _SNDCP_DTI_2_
+  help = (T_desc2*)cur_cia_decomp_ind->desc_list2.first;
+#else /*_SNDCP_DTI_2_*/
+  help = (T_desc*)cur_cia_decomp_ind->desc_list2.first;
+#endif /*_SNDCP_DTI_2_*/
+  if (help == NULL) {
+    cur_cia_decomp_ind->desc_list2.first = (ULONG)descriptor;
+  } else {
+    if (help->next == NULL) {
+      help->next = (ULONG) descriptor;
+    } else {
+      while (help->next != NULL) {
+#ifdef _SNDCP_DTI_2_
+        help = (T_desc2*)help->next;
+#else /*_SNDCP_DTI_2_*/
+        help = (T_desc*)help->next;
+#endif /*_SNDCP_DTI_2_*/
+      }
+      help->next = (ULONG)descriptor;
+    }
+  }
+
+  /*
+   * If this is the last segment, send it to this same service with a simulated
+   * primitive.
+   */
+  if ((sndcp_data->cur_seg_pos[nsapi] & SEG_POS_LAST) > 0) {
+    /*
+     * By now algo_type, cia_qos and comp_inst are not evaluated.
+     */
+    cur_cia_decomp_ind->pdu_ref = sndcp_data->cur_pdu_ref[nsapi];
+    cia_cia_decomp_ind(cur_cia_decomp_ind);
+    cur_cia_decomp_ind = NULL;
+  } else {
+    /*
+     * Request next segment.
+     */
+    sd_get_unitdata_if_nec(ll_unitdata_ind->sapi);
+  }
+  /*
+   * Update global current CIA_DECOMP_IND
+   */
+  sndcp_data->cia.cur_cia_decomp_ind[nsapi] = cur_cia_decomp_ind;
+  /*
+   * Free incoming prim.
+   */
+  if (ll_unitdata_ind != NULL) {
+    PFREE (ll_unitdata_ind);
+    ll_unitdata_ind = NULL;
+  }
+} /* cia_sd_cia_decomp_req() */
+
+/*#endif */ /* CF_FAST_EXEC || _SIMULATION_ || !REL99 || SNDCP_2to1 */
+
+#ifdef TI_PS_FF_V42BIS
+/*
++------------------------------------------------------------------------------
+| Function    : cia_sd_cci_decomp_req
++------------------------------------------------------------------------------
+| Description : This function does the desegmentation and decomressoin for 
+|               compressed data.
+|
+| Simulation for CCI reaction to SIG_SD_CIA_TRANSFER_REQ.
+| If (cur_seg_pos & SEG_POS_FIRST > 0) then a new CCI_DECOMP_IND is allocated.
+| T_desc is allocated with the length of the sdu included in the
+| ll_unitdata_ind. The sdu data is copied to the desc and the desc is added to
+| the currently assembled desc_list in the current CCI_DECOMP_IND.
+| If (cur_seg_pos & SEG_POS_LAST > 0) then a the CCI_DECOMP_IND is now complete
+| and is "sent to this service" by calling the cia function cia_cci_decomp_ind.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+/*#if defined(CF_FAST_EXEC) || defined(_SIMULATION_) || \
+   !defined(REL99)   || defined(SNDCP_2to1) */
+
+LOCAL void cia_sd_cci_decomp_req (/*T_pdu_ref pdu_ref,
+                                  USHORT cur_seg_pos,
+                                  */T_LL_UNITDATA_IND* ll_unitdata_ind
+                                  )
+{
+
+  USHORT length = 0;
+  USHORT header_len = SN_UNITDATA_PDP_HDR_LEN_SMALL;
+  USHORT sdu_index = 0;
+  T_CIA_DECOMP_IND *cur_cia_decomp_ind;
+  UBYTE nsapi;
+#ifdef _SNDCP_DTI_2_
+  T_desc2* help = NULL;
+  T_desc2* descriptor = NULL;
+#else /*_SNDCP_DTI_2_*/
+  T_desc* help = NULL;
+  T_desc* descriptor = NULL;
+#endif /*_SNDCP_DTI_2_*/
+
+  TRACE_FUNCTION( "cia_sd_cci_decomp_req" );
+  
+  nsapi = (ll_unitdata_ind->sdu.buf[(ll_unitdata_ind->sdu.o_buf / 8)]) & 0xf;
+  cur_cia_decomp_ind = sndcp_data->cia.cur_cia_decomp_ind[nsapi];
+  
+  /*
+   * In case of first segment allocate new N-PDU.
+   */
+  if ((sndcp_data->cur_seg_pos[nsapi] & SEG_POS_FIRST) > 0) 
+  {
+    {
+      T_CIA_DECOMP_IND *cia_decomp_ind;
+      MALLOC(cia_decomp_ind, sizeof(T_CIA_DECOMP_IND));
+
+#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 */
+
+
+      /*
+       * if there is an unfinished cur_cia_decomp_ind deallocate it together
+       * with the allocated descriptors
+       */
+      if (cur_cia_decomp_ind NEQ NULL)
+      {
+        MFREE_PRIM(cur_cia_decomp_ind);
+        TRACE_EVENT("Deallocate unfinished cur_cia_decomp_ind");
+      }
+      cur_cia_decomp_ind = cia_decomp_ind;
+      /*
+       * Will be changed as soon as more that 1 instance of V42.bis is used.
+       */
+      cur_cia_decomp_ind->algo_type = CIA_ALGO_V42;
+      cur_cia_decomp_ind->comp_inst = CIA_COMP_INST_V42_0;
+
+      cur_cia_decomp_ind->pdu_ref = sndcp_data->cur_pdu_ref[nsapi];
+      cur_cia_decomp_ind->desc_list2.first = (ULONG)NULL;
+      cur_cia_decomp_ind->desc_list2.list_len = 0;
+
+      header_len = SN_UNITDATA_PDP_HDR_LEN_BIG;
+      cia_decomp_ind->pcomp =
+        ll_unitdata_ind->sdu.buf[(ll_unitdata_ind->sdu.o_buf >> 3) + 1] & 0xf;
+    }
+  }
+  /*
+   * If big header has been received in state != RECEIVE_FIRST_SEGMENT
+   */
+  if (sndcp_data->big_head[nsapi]) {
+    header_len = SN_UNITDATA_PDP_HDR_LEN_BIG;
+  }
+  sdu_index = (ll_unitdata_ind->sdu.o_buf >> 3) + header_len;
+  length = (ll_unitdata_ind->sdu.l_buf >> 3) - header_len;
+  /*
+   * Allocate new descriptor and copy sdu data.
+   */
+#ifdef _SNDCP_DTI_2_
+  MALLOC (descriptor, (USHORT)(sizeof(T_desc2) - 1 + length));
+#else /*_SNDCP_DTI_2_*/
+  MALLOC (descriptor, (USHORT)(sizeof(T_desc) - 1 + length));
+#endif /*_SNDCP_DTI_2_*/
+
+  /*
+   * Fill descriptor control information.
+   */
+  descriptor->next  = (ULONG)NULL;
+  descriptor->len   = length;
+#ifdef _SNDCP_DTI_2_
+  descriptor->offset = 0;
+  descriptor->size = descriptor->len;
+#endif
+
+  /*
+   * Add length of descriptor data to list length.
+   */
+  cur_cia_decomp_ind->desc_list2.list_len += length;
+
+  /*
+   * Copy user data from SDU to descriptor.
+   */
+  if (length>0)
+  {
+    memcpy (descriptor->buffer,
+            &ll_unitdata_ind->sdu.buf[sdu_index],
+            length);
+  }
+
+  /*
+   * Add desc to desc_list.
+   */
+#ifdef _SNDCP_DTI_2_
+  help = (T_desc2*)cur_cia_decomp_ind->desc_list2.first;
+#else /*_SNDCP_DTI_2_*/
+  help = (T_desc*)cur_cia_decomp_ind->desc_list2.first;
+#endif /*_SNDCP_DTI_2_*/
+  if (help == NULL) {
+    cur_cia_decomp_ind->desc_list2.first = (ULONG)descriptor;
+  } else {
+    if (help->next == NULL) {
+      help->next = (ULONG) descriptor;
+    } else {
+      while (help->next != NULL) {
+#ifdef _SNDCP_DTI_2_
+        help = (T_desc2*)help->next;
+#else /*_SNDCP_DTI_2_*/
+        help = (T_desc*)help->next;
+#endif /*_SNDCP_DTI_2_*/
+      }
+      help->next = (ULONG)descriptor;
+    }
+  }
+
+  /*
+   * If this is the last segment, send it to this same service with a simulated
+   * primitive.
+   */
+  if ((sndcp_data->cur_seg_pos[nsapi] & SEG_POS_LAST) > 0) 
+  {
+    T_desc_list2 desc_list2;
+    /*
+     * By now algo_type, cci_qos and comp_inst are not evaluated.
+     */
+    cur_cia_decomp_ind->pdu_ref = sndcp_data->cur_pdu_ref[nsapi];
+
+    desc_list2.first = cur_cia_decomp_ind->desc_list2.first;
+    desc_list2.list_len = cur_cia_decomp_ind->desc_list2.list_len;
+
+    /*
+     * Reset V.42 context and call the decoder routine.
+     */
+    TRACE_EVENT_P1("V42 DEC: Input Compresset Packet, length %d", desc_list2.list_len);
+#ifdef SNDCP_TRACE_BUFFER
+    sndcp_trace_desc_list(&desc_list2);
+
+    sndcp_data->cia.trabu[0] = 0;///////////////////////////////////////////////////////////////
+
+#endif
+    v42b_init(sndcp_data->cia.dec, 0, 0, 0, 0);
+    TRACE_EVENT ("as reinit in downlink");
+    /*
+     * the function can be called with 0s as parameters, because it was initialized
+     * befor what the function sees on the valid magic number
+     *
+     * the call replaces an independent reinit function
+     */
+    v42b_decoder(sndcp_data->cia.dec, &desc_list2, NULL, 100);
+    if (!IS_ERROR(sndcp_data->cia.dec))
+    {
+      TRACE_EVENT_P1("V42 DEC: Output Decompressed Packet, length %d", desc_list2.list_len);
+#ifdef SNDCP_TRACE_BUFFER
+      sndcp_trace_desc_list(&desc_list2);
+#endif
+
+      cur_cia_decomp_ind->desc_list2.first = desc_list2.first;
+      cur_cia_decomp_ind->desc_list2.list_len = desc_list2.list_len;
+      
+      cia_cia_decomp_ind(cur_cia_decomp_ind);
+      cur_cia_decomp_ind = NULL;
+    } 
+    else 
+    {
+      MFREE_PRIM (cur_cia_decomp_ind);
+      cur_cia_decomp_ind = NULL;
+      TRACE_EVENT("Deallocate corrupted V.42 bis packet");
+
+      /*
+       * Request next segment.
+       */
+      sd_get_unitdata_if_nec(ll_unitdata_ind->sapi);
+    }
+  } 
+  else 
+  {
+    /*
+     * Request next segment.
+     */
+    sd_get_unitdata_if_nec(ll_unitdata_ind->sapi);
+  }
+  /*
+   * Update global current CIA_DECOMP_IND
+   */
+   sndcp_data->cia.cur_cia_decomp_ind[nsapi] = cur_cia_decomp_ind;
+  /*
+   * Free incoming prim.
+   */
+  if (ll_unitdata_ind != NULL) {
+    PFREE (ll_unitdata_ind);
+    ll_unitdata_ind = NULL;
+  }
+} /* cia_sd_cci_decomp_req_sim() */
+
+/* #endif *//* CF_FAST_EXEC || _SIMULATION_ || !REL99 || SNDCP_2to1 */
+#endif /* TI_PS_FF_V42BIS */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_sda_cia_cia_decomp_req
++------------------------------------------------------------------------------
+| Description : Simulation for cia reaction to SIG_SDA_CIA_TRANSFER_REQ.
+| If (cur_seg_pos & SEG_POS_FIRST > 0) then a new CIA_DECOMP_IND is allocated.
+| T_desc is allocated with the length of the sdu included in the
+| ll_data_ind. The sdu data is copied to the desc and the desc is added to
+| the currently assembled desc_list in the current CCI_DECOMP_IND.
+| If (cur_seg_pos & SEG_POS_LAST > 0) then a the CIA_DECOMP_IND is now complete
+| and is "sent to this service" by calling the cia function cia_cia_decomp_ind.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+#ifndef CF_FAST_EXEC
+
+GLOBAL void sig_sda_cia_cia_decomp_req ( T_LL_DATA_IND* ll_data_ind )
+{
+  USHORT length = 0;
+  USHORT header_len = SN_DATA_PDP_HDR_LEN_SMALL;
+  USHORT sdu_index = 0;
+  T_CIA_DECOMP_IND *cur_cia_decomp_ind;
+  UBYTE nsapi = 0;
+#ifdef _SNDCP_DTI_2_
+  T_desc2* help = NULL;
+  T_desc2* local_desc = NULL;
+#else /*_SNDCP_DTI_2_*/
+  T_desc* help = NULL;
+  T_desc* local_desc = NULL;
+#endif /*_SNDCP_DTI_2_*/
+
+  TRACE_FUNCTION( "cia_sig_sda_cia_cia_decomp_req_sim" );
+
+  nsapi = (ll_data_ind->sdu.buf[(ll_data_ind->sdu.o_buf / 8)]) & 0xf;
+  cur_cia_decomp_ind = sndcp_data->cia.cur_cia_decomp_ind[nsapi];
+
+  /*
+   * In case of first segment allocate new N-PDU.
+   */
+  if ((sndcp_data->cur_seg_pos[nsapi] & SEG_POS_FIRST) > 0) {
+
+    T_CIA_DECOMP_IND *cia_decomp_ind;
+    MALLOC(cia_decomp_ind, sizeof(T_CIA_DECOMP_IND));
+
+#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
+
+    if (cur_cia_decomp_ind NEQ NULL)
+    {
+      MFREE_PRIM(cur_cia_decomp_ind);
+      TRACE_EVENT("Deallocate unfinished cur_cia_decomp_ind");
+    }
+
+    cur_cia_decomp_ind = cia_decomp_ind;
+
+    /*
+     * Will be changed as soon as more that 1 instance of V42.bis is used.
+     */
+    cur_cia_decomp_ind->algo_type = CIA_ALGO_V42;
+    cur_cia_decomp_ind->comp_inst = CIA_COMP_INST_V42_0;
+
+    cur_cia_decomp_ind->pdu_ref = sndcp_data->cur_pdu_ref[nsapi];
+    cur_cia_decomp_ind->desc_list2.first = (ULONG)NULL;
+    cur_cia_decomp_ind->desc_list2.list_len = 0;
+
+    header_len = SN_DATA_PDP_HDR_LEN_BIG;
+    cia_decomp_ind->pcomp =
+      ll_data_ind->sdu.buf[(ll_data_ind->sdu.o_buf >> 3) + 1] & 0xf;
+
+  }
+  /*
+   * If big header has been received in state != RECEIVE_FIRST_SEGMENT
+   */
+  if (sndcp_data->big_head[nsapi]) {
+    header_len = SN_DATA_PDP_HDR_LEN_BIG;
+  }
+  sdu_index = (ll_data_ind->sdu.o_buf >> 3) + header_len;
+  
+  if ((ll_data_ind->sdu.l_buf >> 3) < header_len){
+     /*This condition is added as part of fix for GCF 46.1.2.2.3.2 failure because of wrong length*/
+     TRACE_ERROR("SNDCP: Unexpected Length of N-PDU");
+     PFREE (ll_data_ind);
+     ll_data_ind = NULL;
+     return;
+  }else{
+
+     length = (ll_data_ind->sdu.l_buf >> 3) - header_len;
+  }
+
+  /*
+   * Allocate new descriptor and copy sdu data.
+   */
+#ifdef _SNDCP_DTI_2_
+  MALLOC (local_desc, (USHORT)(sizeof(T_desc2) - 1 + length));
+#else /*_SNDCP_DTI_2_*/
+  MALLOC (local_desc, (USHORT)(sizeof(T_desc) - 1 + length));
+#endif /*_SNDCP_DTI_2_*/
+
+  /*
+   * Fill descriptor control information.
+   */
+  local_desc->next  = (ULONG)NULL;
+  local_desc->len   = length;
+#ifdef _SNDCP_DTI_2_
+  local_desc->offset = 0;
+  local_desc->size = local_desc->len;
+#endif
+  /*
+   * Add length of descriptor data to list length.
+   */
+  cur_cia_decomp_ind->desc_list2.list_len += length;
+
+  /*
+   * Copy user data from SDU to descriptor.
+   */
+  if (length>0)
+  {
+    memcpy (local_desc->buffer, &ll_data_ind->sdu.buf[sdu_index], length);
+  }
+
+  /*
+   * Add desc to desc_list.
+   */
+#ifdef _SNDCP_DTI_2_
+  help = (T_desc2*)cur_cia_decomp_ind->desc_list2.first;
+#else /*_SNDCP_DTI_2_*/
+  help = (T_desc*)cur_cia_decomp_ind->desc_list2.first;
+#endif /*_SNDCP_DTI_2_*/
+  if (help == NULL) {
+    cur_cia_decomp_ind->desc_list2.first = (ULONG)local_desc;
+  } else {
+    if (help->next == NULL) {
+      help->next = (ULONG) local_desc;
+    } else {
+      while (help->next != NULL) {
+#ifdef _SNDCP_DTI_2_
+        help = (T_desc2*)help->next;
+#else /*_SNDCP_DTI_2_*/
+        help = (T_desc*)help->next;
+#endif /*_SNDCP_DTI_2_*/
+      }
+      help->next = (ULONG)local_desc;
+    }
+  }
+  /*
+   * If this is the last segment, send it to this same service with a simulated
+   * primitive.
+   */
+  if ((sndcp_data->cur_seg_pos[nsapi] & SEG_POS_LAST) > 0) {
+    /*
+     * By now algo_type and comp_inst are not evaluated.
+     */
+    cur_cia_decomp_ind->pdu_ref = sndcp_data->cur_pdu_ref[nsapi];
+    cia_cia_decomp_ind(cur_cia_decomp_ind);
+    cur_cia_decomp_ind = NULL;
+    /*
+     * Reset the Current Segment Counter to zero, since we have received the 
+     * last segment 
+     */
+    sndcp_data->cur_segment_number[nsapi] = 0;
+  } else {
+    /*
+     * Check the Current Segment Number whether we have received more than 
+     * SNDCP_MAX_SEGMENT_NUMBER segments or not. If we have received more than 
+     * SNDCP_MAX_SEGMENT_NUMBER segments in a single NPDU, then we will discard
+     * the stored segments and also the remaining segments of this NPDU, till 
+     * we receive that last segment of this NPDU.
+     * This has been done in order to encounter the PARTITION problem which
+     * we will face if we keep on storing the segments in SNDCP.
+     */
+    sndcp_data->cur_segment_number[nsapi] ++;
+    if (sndcp_data-> cur_segment_number[nsapi] > SNDCP_MAX_SEGMENT_NUMBER)
+    {
+      TRACE_EVENT("Segment Number in Single NPDU exceeds max segment number");
+
+      /* Deleting the stored segments */
+      sig_mg_cia_delete_npdus(nsapi);
+
+      /* Change the state to SDA_ACK_DISCARD */
+      sndcp_set_nsapi_rec_state(nsapi, SDA_ACK_DISCARD);
+    }
+
+    /*
+     * Request next segment.
+     */
+    sda_get_data_if_nec(ll_data_ind->sapi);
+  }
+  /*
+   * Update global current CIA_DECOMP_IND
+   */
+  sndcp_data->cia.cur_cia_decomp_ind[nsapi] = cur_cia_decomp_ind;
+  /*
+   * Free incoming prim.
+   */
+  if (ll_data_ind != NULL) {
+    PFREE (ll_data_ind);
+    ll_data_ind = NULL;
+  }
+} /* cia_sig_sda_cia_cia_decomp_req_sim() */
+
+#endif /* CF_FAST_EXEC */
+
+
+/*==== PUBLIC FUNCTIONS =====================================================*/
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_mg_cia_reset_ind
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_MG_CIA_RESET_IND
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+#ifndef CF_FAST_EXEC
+
+GLOBAL void sig_mg_cia_reset_ind (void)
+{
+  TRACE_ISIG( "sig_mg_cia_reset_ind" );
+
+  switch( GET_STATE(CIA) )
+  {
+    case CIA_DEFAULT:
+      sndcp_reset_xid_block(&sndcp_data->cia.cur_xid_block);
+      break;
+    default:
+      TRACE_ERROR( "SIG_MG_CIA_RESET_IND unexpected" );
+      break;
+  }
+} /* sig_mg_cia_reset_ind() */
+
+#endif /* CF_FAST_EXEC */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_su_cia_cia_comp_req
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_SU_CIA_CIA_COMP_REQ
+|               This function makes a decision whether we are using data
+|               compression in uplink direction and calls the according
+|               function.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+/*#if defined(CF_FAST_EXEC) || defined(_SIMULATION_) || \
+   defined(SNDCP_2to1) */
+
+GLOBAL void sig_su_cia_cia_comp_req (T_SN_UNITDATA_REQ* sn_unitdata_req,
+                                 USHORT npdu_number,
+                                 UBYTE nsapi,
+                                 UBYTE sapi
+                                 )
+{
+  U8 direction = 0;
+  BOOL compressed = FALSE;
+  UBYTE packet_type = TYPE_IP;
+  TRACE_ISIG( "sig_su_cia_cia_comp_req" );
+
+  switch( GET_STATE(CIA) )
+  {
+    case CIA_DEFAULT:
+      sndcp_is_nsapi_header_compressed(nsapi, &compressed);
+      if (compressed) {
+#ifdef _SNDCP_DTI_2_
+        cia_header_comp(&sn_unitdata_req->desc_list2,
+                        &sn_unitdata_req->desc_list2,
+                        &packet_type);
+#else /*_SNDCP_DTI_2_*/
+        cia_header_comp(&sn_unitdata_req->desc_list,
+                        &sn_unitdata_req->desc_list,
+                        &packet_type);
+#endif /*_SNDCP_DTI_2_*/
+      }
+
+      sndcp_is_nsapi_data_compressed(nsapi, &compressed);
+      if (sndcp_data->cia.cur_xid_block.v42.is_set)
+      {
+        if (sndcp_data->cia.cur_xid_block.v42.p0_set)
+        {
+          direction = sndcp_data->cia.cur_xid_block.v42.p0;
+          TRACE_EVENT_P1("dir: %d",direction);
+        }
+      }
+      if (compressed && (direction & 0x01)) { /* datacompr. in uplink ? */
+#ifdef TI_PS_FF_V42BIS
+
+        cia_su_cci_comp_req(sn_unitdata_req,
+                            npdu_number,
+                            nsapi,
+                            sapi,
+                            packet_type);
+
+#else  /* !TI_PS_FF_V42BIS */
+        TRACE_EVENT("INFO CIA: Data compression is not implemented yet!");
+        MFREE_PRIM(sn_unitdata_req);
+        sn_unitdata_req = NULL;
+
+#endif /* TI_PS_FF_V42BIS */
+      } else { /* if (compressed)  */
+        cia_su_cia_comp_req(sn_unitdata_req,
+                                    npdu_number,
+                                    nsapi,
+                                    sapi,
+                                    packet_type);
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_SU_CIA_CIA_COMP_REQ unexpected" );
+#ifdef _SNDCP_DTI_2_
+      MFREE_PRIM(sn_unitdata_req);
+#else /*_SNDCP_DTI_2_*/
+      PFREE_DESC(sn_unitdata_req);
+#endif /*_SNDCP_DTI_2_*/
+      break;
+  }
+} /* sig_su_cia_cia_comp_req() */
+
+/*#endif */ /* CF_FAST_EXEC || _SIMULATION_ || !REL99 || SNDCP_2to1 */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_sua_cia_cia_comp_req
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_SUA_CIA_CIA_COMP_REQ
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+#ifndef CF_FAST_EXEC
+
+GLOBAL void sig_sua_cia_cia_comp_req (T_SN_DATA_REQ* sn_data_req,
+                                 UBYTE npdu_number,
+                                 UBYTE nsapi,
+                                 UBYTE sapi
+                                 )
+{
+  BOOL compressed = FALSE;
+  UBYTE packet_type = TYPE_IP;
+  /*
+   * define desc_list for comp header. Is initialized later.
+   */
+#ifdef _SNDCP_DTI_2_
+  T_desc_list2 dest_desc_list;
+#else /*_SNDCP_DTI_2_*/
+  T_desc_list dest_desc_list;
+#endif /*_SNDCP_DTI_2_*/
+
+  TRACE_ISIG( "sig_sua_cia_cia_comp_req" );
+
+  switch( GET_STATE(CIA) )
+  {
+    case CIA_DEFAULT:
+      sndcp_is_nsapi_header_compressed(nsapi, &compressed);
+      if (compressed) {
+#ifdef _SNDCP_DTI_2_
+        cia_header_comp(&dest_desc_list,
+                        &sn_data_req->desc_list2,
+                        &packet_type);
+      } else {
+        dest_desc_list = sn_data_req->desc_list2;
+#else /*_SNDCP_DTI_2_*/
+        cia_header_comp(&dest_desc_list,
+                        &sn_data_req->desc_list,
+                        &packet_type);
+      } else {
+        dest_desc_list = sn_data_req->desc_list;
+#endif /*_SNDCP_DTI_2_*/
+      }
+
+      sndcp_is_nsapi_data_compressed(nsapi, &compressed);
+      if (compressed) {
+
+       /*
+        * The data compression routine shall be invoked here.
+        */
+        TRACE_EVENT("INFO CIA: Data compression is not implemented yet!");
+        MFREE_PRIM(sn_data_req);
+        sn_data_req = NULL;
+
+      } else { /* if (compressed) */
+        cia_sua_cia_comp_req(dest_desc_list,
+                                     npdu_number,
+                                     nsapi,
+                                     sapi,
+                                     packet_type);
+      }
+      /*
+       * free comp header
+       */
+      if (compressed && dest_desc_list.first != 0) {
+        MFREE(dest_desc_list.first);
+        dest_desc_list.first = 0;
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_SUA_CIA_CIA_COMP_REQ unexpected" );
+#ifdef _SNDCP_DTI_2_
+      MFREE_PRIM(sn_data_req);
+#else /*_SNDCP_DTI_2_*/
+      PFREE_DESC(sn_data_req);
+#endif /*_SNDCP_DTI_2_*/      
+      break;
+  }
+} /* sig_sua_cia_cia_comp_req() */
+
+#endif /* CF_FAST_EXEC */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_mg_cia_delete_npdus
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_MG_CIA_DELETE_NPDUS
+|
+| Parameters  : nsapi
+|
++------------------------------------------------------------------------------
+*/
+#ifndef CF_FAST_EXEC
+
+GLOBAL void sig_mg_cia_delete_npdus (UBYTE nsapi)
+{
+  TRACE_ISIG( "sig_mg_cia_delete_npdus" );
+
+  switch( GET_STATE(CIA) )
+  {
+    case CIA_DEFAULT:
+      if (sndcp_data->cia.cur_cia_decomp_ind[nsapi] != NULL) {
+#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 */
+          /*
+           * Currently assembled pdu is for given nsapi.
+           */
+        MFREE_PRIM(sndcp_data->cia.cur_cia_decomp_ind[nsapi]);
+        sndcp_data->cia.cur_cia_decomp_ind[nsapi] = NULL;
+      }
+      break;
+    default:
+      TRACE_ERROR( "SIG_MG_CIA_DELETE_XID unexpected" );
+      break;
+  }
+} /* SIG_MG_CIA_DELETE_NPDUS() */
+
+#endif /* CF_FAST_EXEC */
+
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_mg_cia_new_xid
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_MG_CIA_NEW_XID
+|
+| Parameters  : new T_XID_BLOCK
+|
++------------------------------------------------------------------------------
+*/
+#ifndef CF_FAST_EXEC
+
+GLOBAL void sig_mg_cia_new_xid (T_XID_BLOCK* new_xid)
+{
+#ifdef TI_PS_FF_V42BIS
+  T_XID_BLOCK* old_xid;
+  U8  p0 = SNDCP_V42_DEFAULT_DIRECTION;
+  U16 p1 = SNDCP_V42_DEFAULT_P1;
+  U8  p2 = SNDCP_V42_DEFAULT_P2;
+
+  old_xid = &(sndcp_data->cia.cur_xid_block);
+#endif
+
+  TRACE_ISIG( "sig_mg_cia_new_xid" );
+
+  switch( GET_STATE(CIA) )
+  {
+    case CIA_DEFAULT:
+      if (new_xid->vj.is_set) {
+        if (new_xid->vj.s0_m_1_set) {
+          cia_compress_init((UBYTE)(new_xid->vj.s0_m_1));
+        }
+      }
+#ifdef TI_PS_FF_V42BIS
+      if (new_xid->v42.is_set)
+      {
+        /* block is valid */
+        if (new_xid->v42.p0_set)
+        {
+          p0 = new_xid->v42.p0;
+          /* what have we to do, if p0 is not set? */
+        }
+        if (new_xid->v42.p1_set)
+        {
+          p1 = new_xid->v42.p1;
+          /* what have we to do, if p1 is not set? */
+        }
+        if (new_xid->v42.p2_set)
+        {
+          p2 = new_xid->v42.p2;
+          /* what have we to do, if p2 is not set? */
+        }            
+        
+        if (new_xid->v42.nsapis_set && new_xid->v42.nsapis == 0)
+        {
+          /* no applicable NSAPI
+           * turn off data compression in either direction
+           */
+          if (old_xid->v42.p0_set && old_xid->v42.p0 & 0x1) /* uplink */
+          {
+            TRACE_EVENT_P1("1 enc dico:%08x",sndcp_data->cia.enc);
+            v42b_deinit(sndcp_data->cia.enc);
+            MFREE(sndcp_data->cia.enc);
+            TRACE_EVENT("uplink deinit");
+          }
+          if (old_xid->v42.p0_set && old_xid->v42.p0 & 0x2) /* downlink */
+          {
+            TRACE_EVENT_P1("1 dec dico:%08x",sndcp_data->cia.dec);
+            v42b_deinit(sndcp_data->cia.dec);
+            MFREE(sndcp_data->cia.dec);
+            TRACE_EVENT("downlink deinit");
+          }
+        }
+        else if (old_xid->v42.is_set)
+        {
+          /* currently we have a valid xid-block for data compression
+           * we have to check the parameters 
+           */
+          
+          /* we have to check the parameters */
+          if (old_xid->v42.p0 != p0 ||
+              old_xid->v42.p1 != p1 ||
+              old_xid->v42.p2 != p2)
+          {
+            /* parameters have changed */
+            if (old_xid->v42.p0_set && old_xid->v42.p0 & 0x1) /* uplink */
+            {
+              TRACE_EVENT_P1("2 enc dico:%08x",sndcp_data->cia.enc);
+              v42b_deinit(sndcp_data->cia.enc);
+              MFREE(sndcp_data->cia.enc);
+              TRACE_EVENT("uplink deinit");
+            }
+            if (old_xid->v42.p0_set && old_xid->v42.p0 & 0x2) /* downlink */
+            {
+              TRACE_EVENT_P1("2 dec dico:%08x",sndcp_data->cia.dec);
+              v42b_deinit(sndcp_data->cia.dec);
+              MFREE(sndcp_data->cia.dec);
+              TRACE_EVENT("uplink deinit");
+            }
+            /* we have to init with new parameters */
+            if (p0 & 0x1)/* uplink */
+            {
+              TRACE_EVENT_P1("DICO_SIZE:%d",sizeof(T_V42B_DICO));
+              MALLOC(sndcp_data->cia.enc, sizeof(T_V42B_DICO));
+              TRACE_EVENT_P1("enc dico:%08x",sndcp_data->cia.enc);
+              v42b_init(sndcp_data->cia.enc, p1, p2, 50, BANK_SIZE_512);
+              TRACE_EVENT("uplink init");
+            }
+            if (p0 & 0x2)/* downlink */
+            {
+              TRACE_EVENT_P1("DICO_SIZE:%d",sizeof(T_V42B_DICO));
+              MALLOC(sndcp_data->cia.dec, sizeof(T_V42B_DICO));
+              v42b_init(sndcp_data->cia.dec, p1, p2, 0, BANK_SIZE_512);
+              TRACE_EVENT_P1("dec dico:%08x",sndcp_data->cia.dec);
+              TRACE_EVENT("downlink init");
+            }     
+          }
+        }
+        else
+        {
+          /* currently we have no valid xid-block for data comprssion */
+          if (p0 & 0x1)/* uplink */
+          {
+            TRACE_EVENT_P1("DICO_SIZE:%d",sizeof(T_V42B_DICO));
+            MALLOC(sndcp_data->cia.enc, sizeof(T_V42B_DICO));
+            TRACE_EVENT_P1("enc dico:%08x",sndcp_data->cia.enc);
+            v42b_init(sndcp_data->cia.enc, p1, p2, 50, BANK_SIZE_512);
+            TRACE_EVENT("uplink init");
+          }
+          if (p0 & 0x2)/* downlink */
+          {
+            TRACE_EVENT_P1("DICO_SIZE:%d",sizeof(T_V42B_DICO));
+            MALLOC(sndcp_data->cia.dec, sizeof(T_V42B_DICO));
+            TRACE_EVENT_P1("dec dico:%08x",sndcp_data->cia.dec);
+            v42b_init(sndcp_data->cia.dec, p1, p2, 0, BANK_SIZE_512);
+            TRACE_EVENT("downlink init");
+          }          
+        }
+      }
+      else
+      {
+        if (old_xid->v42.is_set && old_xid->v42.nsapis_set && old_xid->v42.nsapis != 0)
+        {
+          /* we have no XID with V42 set */
+          if (old_xid->v42.p0_set && old_xid->v42.p0 & 0x1) /* uplink */
+          {
+            TRACE_EVENT_P1("3 enc dico:%08x",sndcp_data->cia.enc);
+            v42b_deinit(sndcp_data->cia.enc);
+            MFREE(sndcp_data->cia.enc);
+            TRACE_EVENT("uplink deinit");
+          }
+          if (old_xid->v42.p0_set && old_xid->v42.p0 & 0x2) /* downlink */
+          {
+            TRACE_EVENT_P1("3 dec dico:%08x",sndcp_data->cia.dec);
+            v42b_deinit(sndcp_data->cia.dec);
+            MFREE(sndcp_data->cia.dec);
+            TRACE_EVENT("downlink deinit");
+          }
+        }
+      }
+#endif /* TI_PS_FF_V42BIS */
+      sndcp_data->cia.cur_xid_block = *new_xid;
+      break;
+    default:
+      TRACE_ERROR( "SIG_MG_CIA_NEW_XID unexpected" );
+      break;
+  }
+} /* SIG_MG_CIA_NEW_XID() */
+
+#endif /* CF_FAST_EXEC */
+
+/*
++------------------------------------------------------------------------------
+| Function    : sig_sd_cia_cia_decomp_req
++------------------------------------------------------------------------------
+| Description : Handles the internal signal SIG_SD_CIA_TRANSFER_REQ
+|               This function mekes a decision whether we are using data 
+|               compression in downlink direction and calls the according
+|               function.
+|
+| Parameters  :
+|
++------------------------------------------------------------------------------
+*/
+/*#if defined(CF_FAST_EXEC) || defined(_SIMULATION_) || \
+   defined(SNDCP_2to1) */
+
+GLOBAL void sig_sd_cia_cia_decomp_req (T_LL_UNITDATA_IND* ll_unitdata_ind)/*UBYTE dcomp,
+                                     T_pdu_ref pdu_ref,
+                                     USHORT cur_seg_pos,
+                                     T_LL_UNITDATA_IND* ll_unitdata_ind
+                                    )*/
+{
+#ifdef TI_PS_FF_V42BIS
+  U8 direction = 0;
+  U8 nsapi;
+#endif /* TI_PS_FF_V42BIS */
+  TRACE_ISIG( "sig_sd_cia_cia_decomp_req" );
+#ifdef TI_PS_FF_V42BIS  
+  nsapi = (ll_unitdata_ind->sdu.buf[(ll_unitdata_ind->sdu.o_buf / 8)]) & 0xf;
+#endif /* TI_PS_FF_V42BIS */   
+  switch( GET_STATE(CIA) )
+  {
+    case CIA_DEFAULT:
+#ifdef TI_PS_FF_V42BIS
+      if (sndcp_data->cia.cur_xid_block.v42.is_set)
+      {
+        if (sndcp_data->cia.cur_xid_block.v42.p0_set)
+        {
+          direction = sndcp_data->cia.cur_xid_block.v42.p0;
+          TRACE_EVENT_P1("dir: %d",direction);
+        }
+      }
+      /*
+       * Is dcomp in sdu equal to dcomp in cur_xid_block and downlink?
+       */
+      TRACE_EVENT_P1("our dcomp value: %d", sndcp_data->cia.cur_xid_block.v42.dcomp);
+      TRACE_EVENT_P1("receipt dcomp value: %d", sndcp_data->cur_dcomp[nsapi]);
+      if (sndcp_data->cur_dcomp[nsapi] == sndcp_data->cia.cur_xid_block.v42.dcomp && (direction & 0x2))
+      {
+        /*
+         * Compression used
+         */
+        cia_sd_cci_decomp_req(/*pdu_ref, cur_seg_pos, */ll_unitdata_ind);
+
+      } else {
+        /*
+         * No compression used, request will not be sent to CCI, but handled
+         * in cia service.
+         */
+        cia_sd_cia_decomp_req (/*pdu_ref, cur_seg_pos, */ll_unitdata_ind);
+      }
+#else /* ! TI_PS_FF_V42BIS */
+      cia_sd_cia_decomp_req (/*pdu_ref, cur_seg_pos, */ll_unitdata_ind);
+#endif /* TI_PS_FF_V42BIS */
+
+      break;
+    default:
+      TRACE_ERROR( "SIG_SD_CIA_TRANSFER_REQ unexpected" );
+      break;
+  }
+} /* sig_sd_cia_cia_decomp_req() */
+/*#endif */