/*
+-----------------------------------------------------------------------------
|  Project :  GPRS (8441)
|  Modul   :  sndcp_mgf.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
|             procedures and functions as described in the
|             SDL-documentation (MG-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 "sndcp_cias.h"    /* to get the signals to service cia */
#include "sndcp_nds.h"    /* to get the signals to service nd */
#include "sndcp_nus.h"    /* to get the signals to service nu */
#include "sndcp_nuf.h"    
#include "sndcp_sus.h"    /* to get the signals to service su */
#include "sndcp_suas.h"    /* to get the signals to service su */
#include "sndcp_sds.h"    /* to get the signals to service sd */
#include "sndcp_sdas.h"    /* to get the signals to service sda */

#include "sndcp_mgf.h"      /* to get ths file */
#include "sndcp_nup.h"      /* nu_sn_[unit]data_req is called from
                               sig_callback().*/

#include <string.h>

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

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

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

LOCAL void mg_get_sapi_dcomp_dntt (UBYTE sapi, UBYTE dcomp, UBYTE* dntt);

LOCAL void mg_get_sapi_dntt_nsapi (UBYTE sapi, UBYTE dntt, UBYTE nsapi, BOOL* used);

LOCAL void mg_get_sapi_dntt_state (UBYTE sapi, UBYTE dntt, UBYTE* state);

LOCAL void mg_get_sapi_dcomp_state (UBYTE sapi, UBYTE dcomp, UBYTE* stat);

LOCAL void mg_get_sapi_pcomp_state (UBYTE sapi, UBYTE pcomp, UBYTE* stat);

LOCAL void mg_get_sapi_pntt_state (UBYTE sapi, UBYTE pntt, UBYTE* state);

LOCAL void mg_set_sapi_dntt_nsapi (UBYTE sapi, UBYTE dntt, UBYTE nsapi, BOOL used);

LOCAL void mg_set_sapi_dcomp_state (UBYTE sapi, UBYTE dcomp, UBYTE stat);

LOCAL void mg_set_sapi_dcomp_dntt (UBYTE sapi, UBYTE dcomp, UBYTE dntt);

LOCAL void mg_set_sapi_dntt_rej (UBYTE sapi, UBYTE dntt, BOOL rej);

LOCAL void mg_set_sapi_dntt_state (UBYTE sapi, UBYTE dntt, UBYTE state);

LOCAL void mg_set_sapi_pntt_nsapi (UBYTE sapi, UBYTE pntt, UBYTE nsapi, BOOL used);

LOCAL void mg_set_sapi_pcomp_state (UBYTE sapi, UBYTE pcomp, UBYTE stat);

LOCAL void mg_set_sapi_pcomp_pntt (UBYTE sapi, UBYTE pcomp, UBYTE pntt);

LOCAL void mg_set_sapi_pntt_rej (UBYTE sapi, UBYTE pntt, BOOL rej);

LOCAL void mg_set_sapi_pntt_state (UBYTE sapi, UBYTE pntt, UBYTE state);

/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_dcomp_dntt
+------------------------------------------------------------------------------
| Description : The procedures indicates the dntt assigned to a given dcomp
|               for a given sapi.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dcomp UBYTE,
|               IN/OUT dntt UBYTE
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_get_sapi_dcomp_dntt (UBYTE sapi, UBYTE dcomp, UBYTE* dntt)
{
  TRACE_FUNCTION( "mg_get_sapi_dcomp_dntt" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *dntt = sndcp_data->mg.sapi_dcomp_dntt_ra[sapi_index][dcomp];
  }
} /* mg_get_sapi_dcomp_dntt() */

/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_dntt_nsapi
+------------------------------------------------------------------------------
| Description : The procedure informs if a given nsapi uses a given dntt on a
|               given sapi.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dntt UBYTE,
|               IN nsapi UBYTE,
|               IN/OUT used BOOL
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_get_sapi_dntt_nsapi (UBYTE sapi, UBYTE dntt, UBYTE nsapi, BOOL* used)
{
  TRACE_FUNCTION( "mg_get_sapi_dntt_nsapi" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *used = sndcp_data->mg.sapi_dntt_nsapi_set_ra[sapi_index][dntt][nsapi];
  }
} /* mg_get_sapi_dntt_nsapi() */

/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_dcomp_state
+------------------------------------------------------------------------------
| Description : The procedures informs about the state of a given dcomp on a
|               given SAPI.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dcomp UBYTE,
|               IN/OUT stat UBYTE
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_get_sapi_dcomp_state (UBYTE sapi, UBYTE dcomp, UBYTE* stat)
{
  TRACE_FUNCTION( "mg_get_sapi_dcomp_state" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *stat = sndcp_data->mg.sapi_dcomp_state_ra[sapi_index][dcomp];
  }
} /* mg_get_sapi_dcomp_state() */

/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_dntt_state
+------------------------------------------------------------------------------
| Description : The procedures informs about the state of a given data
|               compression entity on a given SAPI.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dntt UBYTE,
|               IN/OUT state UBYTE
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_get_sapi_dntt_state (UBYTE sapi, UBYTE dntt, UBYTE* state)
{
  TRACE_FUNCTION( "mg_get_sapi_dntt_state" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *state = sndcp_data->mg.sapi_dntt_state_ra[sapi_index][dntt];
  }



} /* mg_get_sapi_dntt_state() */

/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_pcomp_state
+------------------------------------------------------------------------------
| Description : The procedures informs about the state of a given pcomp on a
|               given SAPI.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pcomp UBYTE,
|               IN/OUT stat UBYTE
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_get_sapi_pcomp_state (UBYTE sapi, UBYTE pcomp, UBYTE* stat)
{
  TRACE_FUNCTION( "mg_get_sapi_pcomp_state" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *stat = sndcp_data->mg.sapi_pcomp_state_ra[sapi_index][pcomp];
  }
} /* mg_get_sapi_pcomp_state() */

/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_pntt_state
+------------------------------------------------------------------------------
| Description : The procedures informs about the state of a given header
|               compression entity on a given SAPI.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pntt UBYTE,
|               IN/OUT state UBYTE
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_get_sapi_pntt_state (UBYTE sapi, UBYTE pntt, UBYTE* state)
{
  TRACE_FUNCTION( "mg_get_sapi_pntt_state" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *state = sndcp_data->mg.sapi_pntt_state_ra[sapi_index][pntt];
  }
} /* mg_get_sapi_pntt_state() */




/*
+------------------------------------------------------------------------------
| Function    : mg_check_sense_bitwise
+------------------------------------------------------------------------------
| Description : Checks, if "small" is bitwise smaller than or equal to "big"
|
| Parameters  : USHORT small, big, BOOL wrong is set to TRUE, if small > big
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_ushort_sense_bitwise (USHORT small,
                                    USHORT big,
                                    BOOL* wrong) {
  UBYTE bit = 0;
  TRACE_FUNCTION( "mg_check_sense_bitwise" );
  *wrong = TRUE;
  for (bit = 0; bit < 8 * sizeof(USHORT); bit++) {
    if ((small & (1 << bit)) > (big & (1 << bit))) {
      return;
    }
  }
  *wrong = FALSE;
} /* mg_check_sense_bitwise() */

/*
+------------------------------------------------------------------------------
| Function    : mg_check_sense_bitwise
+------------------------------------------------------------------------------
| Description : Checks, if "small" is bitwise smaller than "big"
|
| Parameters  : UBYTE small, big, BOOL wrong is set to TRUE, if small > big
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_ubyte_sense_bitwise (UBYTE small,
                                    UBYTE big,
                                    BOOL* wrong) {
  UBYTE bit = 0;
  TRACE_FUNCTION( "mg_check_sense_bitwise" );
  *wrong = TRUE;
  for (bit = 0; bit < 8 * sizeof(UBYTE); bit++) {
    if ((small & (1 << bit)) > (big & (1 << bit))) {
      return;
    }
  }
  *wrong = FALSE;
} /* mg_check_sense_bitwise() */

/*
+------------------------------------------------------------------------------
| Function    : mg_decode_v42
+------------------------------------------------------------------------------
| Description : decodes the v42 part of given sdu to given xid block
|
| Parameters  : source sdu,
|               index in sdu,
|               field index in sdu (sub index in compression fields,
|               destination xid block,
|               success ok
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_decode_v42 (T_sdu* sdu,
                           USHORT* index,
                           USHORT* field_index,
                           T_XID_BLOCK* xid_block,
                           BOOL* ok,
                           UBYTE p_bit) {
#define CHECK_XID_BUFFER_LEN2 if (*index + *field_index >= ((sdu->l_buf) >> 3)) return

  USHORT field_length = 0;
  TRACE_FUNCTION( "mg_decode_v42" );
  *ok = FALSE;

  /*
   * Set field_index to length of field octet.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN2;
  field_length = sdu->buf[*index + *field_index];
  /*
   * NSAPIS parameter and followers omitted?
   */
  if (p_bit == SNDCP_P_BIT_1) {
    if (field_length == MG_DATA_P_1_NSAPIS_OM) {
      *ok = TRUE;
      return;
    }
  } else {
    if (field_length == MG_DATA_P_0_NSAPIS_OM) {
      *ok = TRUE;
      return;
    }
  }
  /*
   * If p bit set to 1, set field_index to dcomp field.
   */
  if (p_bit == SNDCP_P_BIT_1) {
    (*field_index)++;
    CHECK_XID_BUFFER_LEN2;
    xid_block->v42.dcomp =
      ((USHORT)sdu->buf[*index + *field_index]) >> 4;
  }
  /*
   * Set field_index to MSB of applicable nsapis short.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN2;
  xid_block->v42.nsapis =
    ((USHORT)sdu->buf[*index + *field_index]) << 8;
  xid_block->v42.nsapis_set = TRUE;
  /*
   * Set field_index to LSB of applicable nsapis short.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN2;
  xid_block->v42.nsapis +=
    ((USHORT)sdu->buf[*index + *field_index]);
  /*
   * P0 parameter and followers omitted?
   */
  if (p_bit == SNDCP_P_BIT_1) {
    if (field_length == MG_DATA_P_1_P0_OM) {
      *ok = TRUE;
      return;
    }
  } else {
    if (field_length == MG_DATA_P_0_P0_OM) {
      *ok = TRUE;
      return;
    }
  }
  /*
   * Set field_index to p0.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN2;
  xid_block->v42.p0 =
    sdu->buf[*index + *field_index];
  xid_block->v42.p0_set = TRUE;
  /*
   * P1 parameter and followers omitted?
   */
  if (p_bit == SNDCP_P_BIT_1) {
    if (field_length == MG_DATA_P_1_P1_OM) {
      *ok =TRUE;
      return;
    }
  } else {
    if (field_length == MG_DATA_P_0_P1_OM) {
      *ok =TRUE;
      return;
    }
  }
  /*
   * Set field_index to MSB of p1.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN2;
  xid_block->v42.p1 =
    ((USHORT)sdu->buf[*index + *field_index]) << 8;
  xid_block->v42.p1_set = TRUE;
  /*
   * Set field_index to LSB of p1.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN2;
  xid_block->v42.p1 +=
    ((USHORT)sdu->buf[*index + *field_index]);
  /*
   * P2 parameter and followers omitted?
   */
  if (p_bit == SNDCP_P_BIT_1) {
    if (field_length == MG_DATA_P_1_P2_OM) {
      *ok = TRUE;
      return;
    }
  } else {
    if (field_length == MG_DATA_P_0_P2_OM) {
      *ok = TRUE;
      return;
    }
  }
  /*
   * Set field_index to p2.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN2;
  xid_block->v42.p2 =
    sdu->buf[*index + *field_index];
  xid_block->v42.p2_set = TRUE;

  /*
   * If length of v42 field is longer than specified, ignore the rest.
   */
  while (*field_index < field_length) {
    CHECK_XID_BUFFER_LEN2;
    (*field_index)++;
  }

  *ok = TRUE;

} /* mg_decode_v42() */

/*
+------------------------------------------------------------------------------
| Function    : mg_decode_vj
+------------------------------------------------------------------------------
| Description : decodes the vj part of given sdu to given xid block
|
| Parameters  : source sdu,
|               index in sdu,
|               field index in sdu (sub index in compression fields,
|               destination xid block,
|               success ok
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_decode_vj (T_sdu* sdu,
                           USHORT* index,
                           USHORT* field_index,
                           T_XID_BLOCK* xid_block,
                           BOOL* ok,
                           UBYTE p_bit) {
#define CHECK_XID_BUFFER_LEN3 if (*index + *field_index >= ((sdu->l_buf) >> 3)) return

  USHORT field_length = 0;
  TRACE_FUNCTION( "mg_decode_vj" );

  /*
   * Set field_index to length of field octet.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN3;
  field_length = sdu->buf[*index + *field_index];
  /*
   * NSAPIS parameter and followers omitted?
   */
  if (p_bit == SNDCP_P_BIT_1) {
    if (field_length == MG_HEADER_P_1_NSAPIS_OM) {
      *ok = TRUE;
      return;
    }
  } else {
    if (field_length == MG_HEADER_P_0_NSAPIS_OM) {
      *ok = TRUE;
      return;
    }
  }
  /*
   * If p bit set to 1, set field_index to dcomp field.
   */
  if (p_bit == SNDCP_P_BIT_1) {
    (*field_index)++;
    CHECK_XID_BUFFER_LEN3;
    xid_block->vj.pcomp1 =
      ((USHORT)sdu->buf[*index + *field_index]) >> 4;
    xid_block->vj.pcomp2 =
      ((USHORT)sdu->buf[*index + *field_index]) & 0xf;
  }

  /*
   * Set field_index to MSB of applicable nsapis short.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN3;
  xid_block->vj.nsapis =
    ((USHORT)sdu->buf[*index + *field_index]) << 8;
  xid_block->vj.nsapis_set = TRUE;
  /*
   * Set field_index to LSB of applicable nsapis short.
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN3;
  xid_block->vj.nsapis +=
    ((USHORT)sdu->buf[*index + *field_index]);
  /*
   * S0_M_1 parameter omitted?
   */
  if (p_bit == SNDCP_P_BIT_1) {
    if (field_length == MG_HEADER_P_1_S0_M_1_OM) {
      *ok = TRUE;
      return;
    }
  } else {
    if (field_length == MG_HEADER_P_0_S0_M_1_OM) {
      *ok = TRUE;
      return;
    }
  }
  /*
   * Set field_index to "s0 - 1" Parameter
   */
  (*field_index)++;
  CHECK_XID_BUFFER_LEN3;
  xid_block->vj.s0_m_1 = sdu->buf[*index + *field_index];
  xid_block->vj.s0_m_1_set = TRUE;

  /*
   * If length of vj field is longer than specified, ignore the rest.
   */
  while (*field_index < field_length) {
    CHECK_XID_BUFFER_LEN3;
    (*field_index)++;
  }


  *ok = TRUE;

} /* mg_decode_vj() */

/*
+------------------------------------------------------------------------------
| Function    : mg_detect_mode_clash
+------------------------------------------------------------------------------
| Description : Unacknowledged and acknowledged contexts may not share the same
| compressor entity. This procdure detects possible violations of that rule.
|
| Parameters  : the set of nsapis given as USHORT bit mask,
|               violation detected, TRUE if at least 1 acknowledged and 1
|               unacknowledged context share the same compressor.
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_detect_mode_clash (USHORT nsapis, BOOL* vio)
{
  UBYTE nsapi = 0;
  BOOL unack_found = FALSE;
  BOOL ack_found = FALSE;
  BOOL ack = FALSE;
  TRACE_FUNCTION( "mg_detect_mode_clash" );
  /*
   * Find affected nsapis.
   */
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    if ((nsapis & (1 << nsapi)) > 0) {
      sndcp_get_nsapi_ack(nsapi, &ack);
      if (ack) {
        ack_found = TRUE;
      } else {
        unack_found = TRUE;
      }
    }
  }
  *vio = unack_found && ack_found;


} /* mg_detect_mode_clash() */


/*
+------------------------------------------------------------------------------
| Function    : mg_respond_if_nec
+------------------------------------------------------------------------------
| Description : All nsapis connected to the given sapi
|               that are in state MG_ACT are sent an
|               SNSM_ACTIVATE_RES.
|
| Parameters  : sapi
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_respond_if_nec (UBYTE sapi) {
  UBYTE nsapi = 0;
  UBYTE sapi_index = 0;
#ifdef SNDCP_UPM_INCLUDED
  BOOL ack = FALSE;
#endif /* SNDCP_UPM_INCLUDED */

  TRACE_FUNCTION( "mg_respond_if_nec" );

  sndcp_get_sapi_index(sapi, &sapi_index);
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    USHORT nsapi_state = MG_IDLE;
    USHORT sapi_state = MG_IDLE;
    UBYTE local_sapi = 0;
    sndcp_get_nsapi_state(nsapi, &nsapi_state);
    sndcp_get_nsapi_sapi(nsapi, &local_sapi);
    sndcp_get_sapi_state(local_sapi, &sapi_state);
    if (((nsapi_state & MG_ACT) > 0)
        &&
        ((sapi_state & MG_XID) == 0)
        &&
        ((sapi_state & MG_EST) == 0)
        &&
        (local_sapi == sapi)) {

      /*
       * Open DTI connection.
       */
#ifndef SNDCP_UPM_INCLUDED
      mg_dti_open(nsapi);
#else 
      sndcp_get_nsapi_ack(nsapi, &ack);
      if (ack) {
        nu_ready_ind_if_nec(nsapi);
      } else {
        nu_unitready_ind_if_nec(nsapi);
      }
#endif

      mg_send_snsm_activate_res(nsapi);
      /*
       * Set nsapi state to MG_IDLE.
       */
      sndcp_unset_nsapi_state (nsapi, MG_ACT);
    }

    if (((nsapi_state & MG_DEACT) > 0)
        &&
        ((sapi_state & MG_XID) == 0)
        &&
        ((sapi_state & MG_REL) == 0)
        &&
        (local_sapi == sapi)) {

#ifdef SNDCP_UPM_INCLUDED 
      PALLOC(snsm_deactivate_res, SN_DEACTIVATE_CNF);
#else
      PALLOC(snsm_deactivate_res, SNSM_DEACTIVATE_RES);
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
      /*
       * Now the NSAPI is not in use anymore:
       */
      sndcp_set_nsapi_used(nsapi, FALSE);
      sndcp_set_nsapi_ack(nsapi, FALSE);

      snsm_deactivate_res->nsapi = nsapi;
      sndcp_unset_nsapi_state(nsapi, MG_DEACT);
#ifdef SNDCP_UPM_INCLUDED
      PSEND(hCommUPM, snsm_deactivate_res);
#else
      PSEND(hCommSM, snsm_deactivate_res);
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
    }

  }

} /* mg_respond_if_nec */



/*
+------------------------------------------------------------------------------
| Function    : mg_set_ntt_comp
+------------------------------------------------------------------------------
| Description : Sets ntt and comp values acc. to req_xid_block.
|
| Parameters  : UBYTE sapi, BOOL is this a renegotiation?
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_ntt_comp (UBYTE sapi) {
  UBYTE sapi_index = 0;
  UBYTE nsapi = 0;
  TRACE_FUNCTION( "mg_set_ntt_comp" );
  sndcp_get_sapi_index(sapi, &sapi_index);

  if (sndcp_data->mg.req_xid_block[sapi_index].v42.is_set) {
    mg_set_sapi_dntt_state(sapi,
                          sndcp_data->mg.req_xid_block[sapi_index].v42.ntt,
                          MG_SELECTED);
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if ((sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis & (1 << nsapi))
           > 0) {
        mg_set_sapi_dntt_nsapi(sapi,
                               sndcp_data->mg.req_xid_block[sapi_index].v42.ntt,
                               nsapi,
                               TRUE);
      }
    }
    mg_set_sapi_dcomp_state(sapi,
                            sndcp_data->mg.req_xid_block[sapi_index].v42.dcomp,
                            MG_SELECTED);
    mg_set_sapi_dcomp_dntt(sapi,
                           sndcp_data->mg.req_xid_block[sapi_index].v42.dcomp,
                           sndcp_data->mg.req_xid_block[sapi_index].v42.ntt);
  }
  if (sndcp_data->mg.req_xid_block[sapi_index].vj.is_set) {
    mg_set_sapi_pntt_state(sapi,
                          sndcp_data->mg.req_xid_block[sapi_index].vj.ntt,
                          MG_SELECTED);
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if ((sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis & (1 << nsapi))
           > 0) {
        mg_set_sapi_pntt_nsapi(sapi,
                               sndcp_data->mg.req_xid_block[sapi_index].vj.ntt,
                               nsapi,
                               TRUE);
      }
    }
    mg_set_sapi_pcomp_state(sapi,
                            sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp1,
                            MG_SELECTED);
    mg_set_sapi_pcomp_state(sapi,
                            sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp2,
                            MG_SELECTED);
    mg_set_sapi_pcomp_pntt(sapi,
                           sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp1,
                           sndcp_data->mg.req_xid_block[sapi_index].vj.ntt);
    mg_set_sapi_pcomp_pntt(sapi,
                           sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp2,
                           sndcp_data->mg.req_xid_block[sapi_index].vj.ntt);
  }


} /* mg_set_ntt_comp() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_dntt_nsapi
+------------------------------------------------------------------------------
| Description : The procedure  stores the info that a given nsapi uses a given
|               dntt on a given sapi.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dntt UBYTE,
|               IN nsapi UBYTE,
|               IN used BOOL
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_dntt_nsapi (UBYTE sapi, UBYTE dntt, UBYTE nsapi, BOOL used)
{
  TRACE_FUNCTION( "mg_set_sapi_dntt_nsapi" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_dntt_nsapi_set_ra[sapi_index][dntt][nsapi] = used;
  }
} /* mg_set_sapi_dntt_nsapi() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_dcomp_state
+------------------------------------------------------------------------------
| Description : The procedures sets the state of a given dcomp on a given SAPI.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dcomp UBYTE,
|               IN stat UBYTE
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_dcomp_state (UBYTE sapi, UBYTE dcomp, UBYTE stat)
{
  TRACE_FUNCTION( "mg_set_sapi_dcomp_state" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_dcomp_state_ra[sapi_index][dcomp] = stat;
  }
} /* mg_set_sapi_dcomp_state() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_dcomp_dntt
+------------------------------------------------------------------------------
| Description : The procedures sets the dntt assigned to a given dcomp
|               for a given sapi.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dcomp UBYTE,
|               IN dntt UBYTE
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_dcomp_dntt (UBYTE sapi, UBYTE dcomp, UBYTE dntt)
{
  TRACE_FUNCTION( "mg_set_sapi_dcomp_dntt" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_dcomp_dntt_ra[sapi_index][dcomp] = dntt;
  }
} /* mg_set_sapi_dcomp_dntt() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_dntt_rej
+------------------------------------------------------------------------------
| Description : The procedures stores if a given data
|               compression entity on a given SAPI is to be rejected in
|               LL_XID_REQ because it cannot be set up.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dntt UBYTE,
|               IN rej BOOL
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_dntt_rej (UBYTE sapi, UBYTE dntt, BOOL rej)
{
  TRACE_FUNCTION( "mg_set_sapi_dntt_rej" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][dntt] = rej;
  }
} /* mg_set_sapi_dntt_rej() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_dntt_state
+------------------------------------------------------------------------------
| Description : The procedures sets the state of a given data
|               compression entity on a given SAPI.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dntt UBYTE,
|               IN state UBYTE
| Note        : sapi dntt rej will be set ti FALSE if state is UNASSIGNED
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_dntt_state (UBYTE sapi, UBYTE dntt, UBYTE state)
{
  TRACE_FUNCTION( "mg_set_sapi_dntt_state" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_dntt_state_ra[sapi_index][dntt] = state;

    if (state == MG_UNASSIGNED) {
      mg_set_sapi_dntt_rej(sapi, dntt, FALSE);
    }
  }
} /* mg_set_sapi_dntt_state() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_pntt_nsapi
+------------------------------------------------------------------------------
| Description : The procedure  stores the info that a given nsapi uses a given
|               pntt on a given sapi.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pntt UBYTE,
|               IN nsapi UBYTE,
|               IN used BOOL
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_pntt_nsapi (UBYTE sapi, UBYTE pntt, UBYTE nsapi, BOOL used)
{
  TRACE_FUNCTION( "mg_set_sapi_pntt_nsapi" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_pntt_nsapi_set_ra[sapi_index][pntt][nsapi] = used;
  }
} /* mg_set_sapi_pntt_nsapi() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_pcomp_state
+------------------------------------------------------------------------------
| Description : The procedures sets the state of a given pcomp on a given SAPI.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pcomp UBYTE,
|               IN stat UBYTE
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_pcomp_state (UBYTE sapi, UBYTE pcomp, UBYTE stat)
{
  TRACE_FUNCTION( "mg_set_sapi_pcomp_state" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_pcomp_state_ra[sapi_index][pcomp] = stat;
  }
} /* mg_set_sapi_pcomp_state() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_pcomp_pntt
+------------------------------------------------------------------------------
| Description : The procedures sets the pntt assigned to a given pcomp
|               for a given sapi.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pcomp UBYTE,
|               IN pntt UBYTE
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_pcomp_pntt (UBYTE sapi, UBYTE pcomp, UBYTE pntt)
{
  TRACE_FUNCTION( "mg_set_sapi_pcomp_pntt" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_pcomp_pntt_ra[sapi_index][pcomp] = pntt;
  }
} /* mg_get_sapi_pcomp_pntt() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_pntt_rej
+------------------------------------------------------------------------------
| Description : The procedures stores if a given data
|               compression entity on a given SAPI is to be rejected in
|               LL_XID_REQ because it cannot be set up.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pntt UBYTE,
|               IN rej BOOL
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_pntt_rej (UBYTE sapi, UBYTE pntt, BOOL rej)
{
  TRACE_FUNCTION( "mg_set_sapi_pntt_rej" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][pntt] = rej;
  }
} /* mg_set_sapi_pntt_rej() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_sapi_pntt_state
+------------------------------------------------------------------------------
| Description : The procedures sets the state of a given header
|               compression entity on a given SAPI.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pntt UBYTE,
|               IN state UBYTE
| Note        : sapi pntt rej will be set ti FALSE if state is UNASSIGNED
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_sapi_pntt_state (UBYTE sapi, UBYTE pntt, UBYTE state)
{
  TRACE_FUNCTION( "mg_set_sapi_pntt_state" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_data->mg.sapi_pntt_state_ra[sapi_index][pntt] = state;

    if (state == MG_UNASSIGNED) {
      mg_set_sapi_pntt_rej(sapi, pntt, FALSE);
    }
  }
} /* mg_set_sapi_pntt_state() */

#ifndef NCONFIG 
/*
+------------------------------------------------------------------------------
| Function    : mg_config_delay
+------------------------------------------------------------------------------
| Description : after config prim DELAY each new context activation will be
|               computed with a delay.
|
| Parameters  : delay in milliseconds
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_config_delay (USHORT millis)
{

  TRACE_FUNCTION("mg_config_delay");

  sndcp_data->millis = millis;

} /* mg_config_delay() */
#endif


/*
+------------------------------------------------------------------------------
| Function    : mg_reset_compressors
+------------------------------------------------------------------------------
| Description : All compressors used by this nsapi are reset.
|
| Parameters  : nsapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_reset_compressors (UBYTE nsapi)
{
  BOOL compressed = FALSE;
  TRACE_FUNCTION( "mg_reset_compressors" );

  sndcp_is_nsapi_data_compressed(nsapi, &compressed);
  if (compressed) {
    /*
     * Must be added when data compression is added.
     */
  }

  sndcp_is_nsapi_header_compressed(nsapi, &compressed);
  if (compressed) {
    UBYTE sapi = 0;
    UBYTE sapi_index = 0;
    /*
     * This is implementation dependent and only works as long as only 1
     * header compressor is used in cia service.
     */
    sndcp_get_nsapi_sapi(nsapi, &sapi);
    sndcp_get_sapi_index(sapi, &sapi_index);
    sig_mg_cia_new_xid(&sndcp_data->mg.cur_xid_block[sapi_index]);
  }

} /* mg_reset_compressors() */



/*
+------------------------------------------------------------------------------
| Function    : mg_reset_comp_ack
+------------------------------------------------------------------------------
| Description : all compression entities using
|               acknowledged peer-to-peer LLC operation on this SAPI are reset.
|
| Parameters  : sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_reset_comp_ack (UBYTE sapi) {
  UBYTE nsapi = 0;
  TRACE_FUNCTION( "mg_reset_comp_ack" );
  /*
   * All nsapis at this sapi that use ack mode reset their compressors.
   */
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) {
    UBYTE s = 0;
    BOOL ack = FALSE;
    BOOL used = FALSE;
    sndcp_is_nsapi_used(nsapi, &used);
    if (!used) {
      continue;
    }
    sndcp_get_nsapi_sapi(nsapi, &s);
    sndcp_get_nsapi_ack(nsapi, &ack);
    if (ack && s == sapi) {
      mg_reset_compressors(nsapi);
    }
  } /* for all nsapis */

} /* mg_reset_comp_ack() */


/*
+------------------------------------------------------------------------------
| Function    : mg_reset_states_n_rej
+------------------------------------------------------------------------------
| Description : Resets all states for ntts and p/dcomp to "unassigned".
|               Resets the arrays with information on rejcted entities.
|
| Parameters  : index of the affected sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_reset_states_n_rej (UBYTE sapi_index)
{

  UBYTE ntt = 0;
  UBYTE nsapi = 0;
  UBYTE dcomp = 0;
  UBYTE pcomp = 0;
  TRACE_FUNCTION( "mg_reset_states_n_rej" );

  for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
    sndcp_data->mg.sapi_dntt_state_ra[sapi_index][ntt] = MG_UNASSIGNED;
    sndcp_data->mg.sapi_pntt_state_ra[sapi_index][ntt] = MG_UNASSIGNED;
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      sndcp_data->mg.sapi_dntt_nsapi_set_ra[sapi_index][ntt][nsapi] = FALSE;
      sndcp_data->mg.sapi_pntt_nsapi_set_ra[sapi_index][ntt][nsapi] = FALSE;
    }
    sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][ntt] = FALSE;
    sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][ntt] = FALSE;
  }
  for (dcomp = 0; dcomp < MG_MAX_DCOMP; dcomp++) {
    sndcp_data->mg.sapi_dcomp_state_ra[sapi_index][dcomp] = MG_UNASSIGNED;
  }
  for (pcomp = 0; pcomp < MG_MAX_PCOMP; pcomp++) {
    sndcp_data->mg.sapi_pcomp_state_ra[sapi_index][pcomp] = MG_UNASSIGNED;
  }
  /*
   * sapi_dcomp_dntt_ra, sapi_pcomp_pntt_ra not initialized.
   */

} /* mg_reset_states_n_rej() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_xid_nsapis
+------------------------------------------------------------------------------
| Description : AN LL_XID_IND has delivered a desired set of nsapis for
| a V42.bis or VJ compressor entity. Now this is compared to a possibly
| already existing set of nsapis connected to the given entity.
| Also the rules in GSM 4.65, 6.8.x are checked.
|
| Parameters  : a flag telling if we work on V42 or VanJacobson 'nsapis':
|            MG_XID_V42_NSAPIS or MG_XID_VJ_NSAPIS.
|            affected sapi,
|
+------------------------------------------------------------------------------
*/
LOCAL void mg_set_xid_nsapis (UBYTE sapi, UBYTE p_type)
{
  USHORT* cur_nsapis = 0;
  USHORT* ind_nsapis = 0;
  USHORT* res_nsapis = 0;
  BOOL* ind_nsapis_set = NULL;
  UBYTE sapi_index = 0;
  UBYTE* p_bit = NULL;
  UBYTE ntt_state = MG_UNASSIGNED;
  U8 nsapi = 0;
  U8 s0_m_1_min = 0;


  TRACE_FUNCTION( "mg_set_xid_nsapis" );

  sndcp_get_sapi_index(sapi, &sapi_index);

  /*
   * V42.bis or VanJacobson?
   */
  if (p_type == MG_XID_V42_NSAPIS) {
    cur_nsapis = &(sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis);
    ind_nsapis = &(sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis);
    res_nsapis = &(sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis);
    ind_nsapis_set =
      &(sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis_set);
    p_bit = &(sndcp_data->mg.ind_xid_block[sapi_index].v42.p_bit);

    *res_nsapis = 0;
    /*
     * Only those nsapis will be set in the response for which the user
     * requested compression. 
     * Note: te other params are not yet set, must be implemented later.
     */
    sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis_set = FALSE;
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if ((((1 << nsapi) & sndcp_data->mg.user_xid_block[nsapi].v42.nsapis) > 
           0) && 
           (((1 << nsapi) & 
            sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0)) {

        *res_nsapis |= (1 << nsapi);
        sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis_set = TRUE;

      }
    } /* for nsapi */

  } else {
    cur_nsapis = &(sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis);
    ind_nsapis = &(sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis);
    res_nsapis = &(sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis);
    ind_nsapis_set =
      &(sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis_set);
    p_bit = &(sndcp_data->mg.ind_xid_block[sapi_index].vj.p_bit);

    *res_nsapis = 0;
    /*
     * Only those nsapis will be set in the response for which the user
     * requested compression. 
     * In the same loop we set the s0_m_1 to the minimum of
     * the indicated value and the values requested by the user.
     * Also the direction is set to the minimum of all requested
     * directions.
     */
    if (sndcp_data->mg.ind_xid_block[sapi_index].vj.s0_m_1 > 0) {
      s0_m_1_min = sndcp_data->mg.ind_xid_block[sapi_index].vj.s0_m_1;
    } else if (sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1 > 0) {
      s0_m_1_min = sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1;
    } else {
      s0_m_1_min = SNDCP_VJ_DEFAULT_S0_M_1;
    }
 #ifdef SNDCP_UPM_INCLUDED 
    sndcp_data->mg.res_xid_block[sapi_index].vj.direction = 
      NAS_HCOMP_BOTH_DIRECT;
#else
    sndcp_data->mg.res_xid_block[sapi_index].vj.direction = 
      SNSM_COMP_BOTH_DIRECT;
#endif 
    
    sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis_set = FALSE;
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if (((1 << nsapi) & sndcp_data->mg.user_xid_block[nsapi].vj.nsapis) > 
          0 && 
           (((1 << nsapi) & 
            sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis) > 0)) {

        *res_nsapis |= (1 << nsapi);
        sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis_set = TRUE;
        if (sndcp_data->mg.user_xid_block[nsapi].vj.s0_m_1 < s0_m_1_min) {
          s0_m_1_min = sndcp_data->mg.user_xid_block[nsapi].vj.s0_m_1;
        }
        sndcp_data->mg.res_xid_block[sapi_index].vj.direction &=
          sndcp_data->mg.user_xid_block[nsapi].vj.direction;
      }
    } /* for nsapi */
    sndcp_data->mg.res_xid_block[sapi_index].vj.s0_m_1 = s0_m_1_min;
    if (s0_m_1_min > 0) {
      sndcp_data->mg.res_xid_block[sapi_index].vj.s0_m_1_set = TRUE;
    } else {
      sndcp_data->mg.res_xid_block[sapi_index].vj.direction = 0;
    }
  }

    

  /*
   * Rules in GSM 4.65, 6.8.1: acknowledged and unacknowlegded contexts may not
   * share the same compressor. If that is demanded by the indication, reset
   * nsapis parameter to the ones currently used.
   */
  if (*ind_nsapis_set &&
      *ind_nsapis > 0) {
    BOOL vio = FALSE;
    mg_detect_mode_clash(*ind_nsapis, &vio);
    if (!vio) {
      /*
       * Modes are the same, set cur to res.
       */
      *cur_nsapis = *res_nsapis;
    } else {
      *res_nsapis = *cur_nsapis;
    }
  }

  /*
   * Also from 6.8.3: If an unassigned entity number is included with the
   * p bit set to 0, then the Applicable NSAPIs field shall be set to 0.
   */
  if (p_type == MG_XID_V42_NSAPIS) {
    mg_get_sapi_dntt_state
      (sapi, sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, &ntt_state);
  } else {
    mg_get_sapi_pntt_state
      (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, &ntt_state);
  }
  if (ntt_state == MG_UNASSIGNED && *p_bit == 0) {
      *cur_nsapis = 0;
      *res_nsapis = 0;
  }

} /* mg_set_xid_nsapis() */


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


/*
+------------------------------------------------------------------------------
| Function    : mg_check_cnf_xid
+------------------------------------------------------------------------------
| Description : The confirmation of a requested XID negotiation has been
|               received. The answer is now checked.
|               A main issue is the comparison with the service variable
|               req_xid_block which holds the requested xid block sent to the
|               network.
|               Detected errors:
| - SNDCP version number not correct
| - incorrect entity number (must be proposed one)
| - incorrect sense of negotiation for each parameter (down mainly,
|   NSAPI down bitwise)
| - an entity is included in the cnf that was not requested, does not exist
| Not checked:
| - out of range value of parameters (must be in range if sense ofnegotiation was right.
| - parameters with duplicated instances.
| If one of these errors occurs ret is set to MG_XID_BAD_CONTENT, else
| MG_XID_OK.
|
| Parameters  : ret, affected sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_check_cnf_xid (UBYTE* ret, UBYTE sapi)
{
  UBYTE sapi_index = 0;
  BOOL wrong = FALSE;
  TRACE_FUNCTION( "mg_check_cnf_xid" );
  sndcp_get_sapi_index(sapi, &sapi_index);
  *ret = MG_XID_BAD_CONTENT;
  /*
   * Check SNDCP version.
   */
  if (sndcp_data->mg.cnf_xid_block[sapi_index].version_set) {
    if (sndcp_data->mg.cnf_xid_block[sapi_index].version !=
        SNDCP_XID_VERSION) {
      return;
    }
  }
  /*
   * If an entity is included that has not been requested / does not exist:
   * bad content!
   */
  if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.is_set &&
      ! sndcp_data->mg.req_xid_block[sapi_index].v42.is_set &&
      ! sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set) {

    return;
  }
  if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.is_set &&
      ! sndcp_data->mg.req_xid_block[sapi_index].vj.is_set &&
      ! sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) {

    return;
  }

  /*
   * Check V42 parameters, if they are set.
   */
  if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.is_set) {
    if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p_bit == 1) {
      return;
    }
    if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.ntt !=
        sndcp_data->mg.req_xid_block[sapi_index].v42.ntt) {
      return;
    }
    /*
     * Sense of negotiation. If cnf value has been set, but req has not been
     * set then cnf value will be compared with cur value. This
     * is not applied to "applicable nsapis".
     */
    if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.nsapis_set) {
      if (sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis_set) {
        mg_ushort_sense_bitwise
          (sndcp_data->mg.cnf_xid_block[sapi_index].v42.nsapis,
           sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis,
           &wrong);
      }
      if (wrong) {
        return;
      }
    }
    if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p0_set) {
      if (sndcp_data->mg.req_xid_block[sapi_index].v42.p0_set) {
        mg_ubyte_sense_bitwise(sndcp_data->mg.cnf_xid_block[sapi_index].v42.p0,
                               sndcp_data->mg.req_xid_block[sapi_index].v42.p0,
                               &wrong);
      } else {
        mg_ubyte_sense_bitwise(sndcp_data->mg.cnf_xid_block[sapi_index].v42.p0,
                               sndcp_data->mg.cur_xid_block[sapi_index].v42.p0,
                               &wrong);
      }
      if (wrong) {
        return;
      }
    }
    if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p1_set) {
      if (sndcp_data->mg.req_xid_block[sapi_index].v42.p1_set) {
        if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p1 >
          sndcp_data->mg.req_xid_block[sapi_index].v42.p1) {
          return;
        }
      } else {
        if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p1 >
          sndcp_data->mg.cur_xid_block[sapi_index].v42.p1) {
          return;
        }
      }
    }
    if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p2_set) {
      if (sndcp_data->mg.req_xid_block[sapi_index].v42.p2_set) {
        if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p2 >
          sndcp_data->mg.req_xid_block[sapi_index].v42.p2) {
          return;
        }
      } else {
        if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p2 >
          sndcp_data->mg.cur_xid_block[sapi_index].v42.p2) {
          return;
        }
      }
    }
  }
  /*
   * Check VJ parameters, if they are set.
   */
  if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.is_set) {
    if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.p_bit == 1) {
      return;
    }
    if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.ntt !=
        sndcp_data->mg.req_xid_block[sapi_index].vj.ntt) {
      return;
    }
    /*
     * Sense of negotiation.
     */
    if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.nsapis_set) {
      if (sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis_set) {
        mg_ushort_sense_bitwise(sndcp_data->mg.cnf_xid_block[sapi_index].vj.nsapis,
                                sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis,
                                &wrong);
      }
      if (wrong) {
        return;
      }
    }
    if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.s0_m_1_set) {
      if (sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1_set) {
        if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.s0_m_1 >
          sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1) {
          return;
        }
      } else {
        if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.s0_m_1 >
          sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1) {
          return;
        }
      }
    }
  }
  *ret = MG_XID_OK;

} /* mg_check_cnf_xid() */

/*
+------------------------------------------------------------------------------
| Function    : mg_check_ind_xid
+------------------------------------------------------------------------------
| Description : Service variable ind_xid_block holds the xid block indicated
| by the peer. The ind_xid_block is now checked: (from 4.65 6.8.2).
| Criterium 1:
| If the indicated ntt is already used and pcomp or dcomp values are different,
| ret is set to MG_XID_BAD_CONTENT.
| Criterium 2:
| If the indicated algorithm type is already used and pcomp or dcomp values
| are different, ret is set to MG_XID_BAD_CONTENT.
|
| Note: implementation dependent: if data compression is proposed, it will
| be rejected.
|
| Otherwise ret is set to MG_XID_OK.
| Parameters  : ret, affected sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_check_ind_xid (UBYTE* ret, UBYTE sapi)
{
  UBYTE sapi_index = 0;
  UBYTE status = MG_UNASSIGNED;
  TRACE_FUNCTION( "mg_check_ind_xid" );
  sndcp_get_sapi_index(sapi, &sapi_index);
  *ret = MG_XID_OK;

  /*
   * Check criterium 1.
   */
  if (sndcp_data->mg.ind_xid_block[sapi_index].v42.is_set &&
      sndcp_data->mg.ind_xid_block[sapi_index].v42.p_bit == SNDCP_P_BIT_1) {
    mg_get_sapi_dntt_state
      (sapi, sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, &status);
    if (status == MG_ASSIGNED) {
      /*
       * Entity already used. DCOMP values differ?
       */
      mg_get_sapi_dcomp_state
        (sapi, sndcp_data->mg.ind_xid_block[sapi_index].v42.dcomp, &status);
      if (status != MG_ASSIGNED) {
        /*
         * The indicated dcomp is not assigned. Error.
         */
        mg_set_sapi_dntt_rej(sapi,
                             sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt,
                             TRUE);
        *ret = MG_XID_BAD_CONTENT;
      } else {
        UBYTE dntt = 0;
        mg_get_sapi_dcomp_dntt
          (sapi, sndcp_data->mg.ind_xid_block[sapi_index].v42.dcomp, &dntt);
        if (dntt != sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt) {
          /*
           * Dcomp values differ, Error.
           */
          mg_set_sapi_dntt_rej(sapi,
                               sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt,
                               TRUE);
          *ret = MG_XID_BAD_CONTENT;
        }
      }
    }
  }
  if (sndcp_data->mg.ind_xid_block[sapi_index].vj.is_set &&
      sndcp_data->mg.ind_xid_block[sapi_index].vj.p_bit == SNDCP_P_BIT_1) {
    mg_get_sapi_pntt_state
      (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, &status);
    if (status == MG_ASSIGNED) {
      /*
       * Entity already used. PCOMP values differ?
       */
      /*
       * PCOMP 1.
       */
      mg_get_sapi_pcomp_state
        (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1, &status);
      if (status != MG_ASSIGNED) {
        /*
         * The indicated pcomp is not assigned. Error.
         */
        mg_set_sapi_pntt_rej(sapi,
                             sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt,
                             TRUE);
        *ret = MG_XID_BAD_CONTENT;
      } else {
        UBYTE pntt = 0;
        mg_get_sapi_pcomp_pntt
          (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1, &pntt);
        if (pntt != sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt) {
          /*
           * Pcomp values differ, Error.
           */
          mg_set_sapi_pntt_rej(sapi,
                               sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt,
                               TRUE);
          *ret = MG_XID_BAD_CONTENT;
        }
      }
      /*
       * PCOMP 2.
       */
      mg_get_sapi_pcomp_state
        (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1, &status);
      if (status != MG_ASSIGNED) {
        /*
         * The indicated pcomp is not assigned. Error.
         */
        mg_set_sapi_pntt_rej(sapi,
                             sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt,
                             TRUE);
        *ret = MG_XID_BAD_CONTENT;
      } else {
        UBYTE pntt = 0;
        mg_get_sapi_pcomp_pntt
          (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1, &pntt);
        if (pntt != sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt) {
          /*
           * Dcomp values differ, Error.
           */
          mg_set_sapi_pntt_rej(sapi,
                               sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt,
                               TRUE);
          *ret = MG_XID_BAD_CONTENT;
        }
      }
    }
  }

  /*
   * Check criterium 2.
   * Since in the current implementation there is only SNDCP_XID_VJ and
   * SNDCP_XID_V42, and only 1 instance of each,
   * it will be sufficient to compare the proposed values for pcomp/dcomp
   * with the ones in cur_xid_block.
   * An error may only occur if cur and ind are set.
   */
  if (sndcp_data->mg.ind_xid_block[sapi_index].v42.is_set &&
      sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set &&
      sndcp_data->mg.ind_xid_block[sapi_index].v42.p_bit == SNDCP_P_BIT_1) {
    if (sndcp_data->mg.ind_xid_block[sapi_index].v42.dcomp !=
      sndcp_data->mg.cur_xid_block[sapi_index].v42.dcomp) {
      mg_set_sapi_dntt_rej(sapi,
                           sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt,
                           TRUE);
      *ret = MG_XID_BAD_CONTENT;
    }
  }
  if (sndcp_data->mg.ind_xid_block[sapi_index].vj.is_set &&
      sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set &&
      sndcp_data->mg.ind_xid_block[sapi_index].v42.p_bit == SNDCP_P_BIT_1) {
    if (sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1 !=
      sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp1) {
      mg_set_sapi_pntt_rej(sapi,
                           sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt,
                           TRUE);
      *ret = MG_XID_BAD_CONTENT;
    }
    if (sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp2 !=
      sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp2) {
      mg_set_sapi_pntt_rej(sapi,
                           sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt,
                           TRUE);
      *ret = MG_XID_BAD_CONTENT;
    }
  }

#ifndef TI_PS_FF_V42BIS
  /*
   * Implementation dependent: If data compression is proposed, reject it!
   */
  if (sndcp_data->mg.ind_xid_block[sapi_index].v42.is_set) {
    mg_set_sapi_dntt_rej(sapi,
                         sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt,
                         TRUE);
  }
#endif /* !TI_PS_FF_V42BIS */
} /* mg_check_ind_xid() */


/*
+------------------------------------------------------------------------------
| Function    : mg_clean_xid
+------------------------------------------------------------------------------
| Description : Cleans up the XID organizing arrays for nsapis and ntts
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_clean_xid (UBYTE sapi) {
  UBYTE nsapi = 0;
  UBYTE sapi_index = 0;
  UBYTE stat = MG_UNASSIGNED;
  TRACE_FUNCTION( "mg_clean_xid" );
  sndcp_get_sapi_index(sapi, &sapi_index);


  /*
   * NSAPIs that were assigned to a compressor unit but are not any more.
   */
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    BOOL connected =
      ((1 << nsapi) & (sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis)) > 0;
    mg_set_sapi_dntt_nsapi(sapi,
                           sndcp_data->mg.cur_xid_block[sapi_index].v42.ntt,
                           nsapi,
                           connected);
    connected =
      ((1 << nsapi) & (sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis)) > 0;
    mg_set_sapi_pntt_nsapi(sapi,
                           sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt,
                           nsapi,
                           connected);


  }

  /*
   * Formerly assigned ntts that are now unassigned are cleaned.
   * Implemented here: the one dntt and the one pntt in cur_xid_block are now
   * checked. If they are in state MG_ASSIGNED but the affected 'nsapis'
   * element is set to all '0' then the entities enter state MG_UNASSIGNED,
   * all nsapis re set to FALSE in the sapi_?ntt_nsapi_ra, all
   * affected pcomp/dcomp values are set to MG_UNASSIGNED.
   */
  mg_get_sapi_dntt_state(sapi,
                         sndcp_data->mg.cur_xid_block[sapi_index].v42.ntt,
                         &stat);
  if (stat == MG_ASSIGNED &&
      sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis == 0) {
    /*
     * Reset dntt state.
     */
    mg_set_sapi_dntt_state(sapi,
                           sndcp_data->mg.cur_xid_block[sapi_index].v42.ntt,
                           MG_UNASSIGNED);

    /*
     * reset nsapi connections.
     */
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      mg_set_sapi_dntt_nsapi(sapi,
                             sndcp_data->mg.cur_xid_block[sapi_index].v42.ntt,
                             nsapi,
                             FALSE);
    }
    /*
     * Reset dcomp.
     */
    mg_set_sapi_dcomp_state(sapi,
                            sndcp_data->mg.cur_xid_block[sapi_index].v42.dcomp,
                            MG_UNASSIGNED);
  }


  /*
   * The same for header compresion.
   */
  mg_get_sapi_pntt_state(sapi,
                         sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt,
                         &stat);
  if (stat == MG_ASSIGNED &&
      sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis == 0) {
    /*
     * Reset pntt state.
     */
    mg_set_sapi_pntt_state(sapi,
                           sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt,
                           MG_UNASSIGNED);
    /*
     * reset nsapi connections.
     */
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      mg_set_sapi_pntt_nsapi(sapi,
                             sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt,
                             nsapi,
                             FALSE);
    }
    /*
     * Reset pcomps.
     */
    mg_set_sapi_pcomp_state(sapi,
                            sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp1,
                            MG_UNASSIGNED);
    mg_set_sapi_pcomp_state(sapi,
                            sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp2,
                            MG_UNASSIGNED);
  }



} /* mg_clean_xid() */

/*
+------------------------------------------------------------------------------
| Function    : mg_col_no_re
+------------------------------------------------------------------------------
| Description : The function mg_col_no_re represents  the SDL label
|               COL_NO_RE: an LL_ESTABLISH_IND has been received, we do
|               have a collision situation like given in [GSM 4.65, 6.2.1.4],
|               we do not have a re-establishment situation.
|
| Parameters  : the received LL_ESTABLISH_IND
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_col_no_re (T_LL_ESTABLISH_IND* ll_establish_ind)
{
  TRACE_FUNCTION( "mg_col_no_re" );

  /*
   * Resume data transfer suspended due to pending establishment;
   */
  sig_mg_su_resume(ll_establish_ind->sapi);
  sig_mg_sua_resume(ll_establish_ind->sapi);
  mg_resume_affected_nus(ll_establish_ind->sapi);

  /*
   * Now proceed like without collision.
   */
  mg_no_col_no_re(ll_establish_ind);


} /* mg_col_no_re() */


/*
+------------------------------------------------------------------------------
| Function    : mg_col_re
+------------------------------------------------------------------------------
| Description : The function mg_col_re represents  the SDL label
|               COL_RE: an LL_ESTABLISH_IND has been received, we do
|               have a collision situation like given in [GSM 4.65, 6.2.1.4],
|               we do have a re-establishment situation.
|
| Parameters  : the received LL_ESTABLISH_IND
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_col_re (T_LL_ESTABLISH_IND* ll_establish_ind)
{
  TRACE_FUNCTION( "mg_col_re" );
  /*
   * Resume data transfer suspended due to pending establishment;
   */
  sig_mg_su_resume(ll_establish_ind->sapi);
  sig_mg_sua_resume(ll_establish_ind->sapi);
  mg_resume_affected_nus(ll_establish_ind->sapi);
  /*
   * Now proceed like without collision.
   */
  mg_no_col_re(ll_establish_ind);
} /* mg_col_re() */

/*
+------------------------------------------------------------------------------
| Function    : mg_decode_xid
+------------------------------------------------------------------------------
| Description : Implementation dependent.
|               The entity number
|               Works only for algorithm types 0
|               (V42 for data and VanJacobson for header).
|               This procedure reads the given xid block (in form of an sdu)
|               and writes the fields to the given xid_block variable, if
|               compression fields for algorithms 0 (V42 or VanJacobson) are
|               given.
|               If the parsed sdu starts a negotiation then the p bit will be
|               set to 1 and the "algorithm type" field will be included. If
|               the parsed sdu ends a negotiation then the p bit will be set
|               to 0 and the "algorithm type" field will not be included.
|               In this case it will be checked if the "entity number" field
|               corresponds with the entity number set in req_xid_block.
|
|               Note: This procedure only re-formats the xid_block. The content
|               of the xid_block are not checked. This will be done in a later
|               procedure on the basis of the xid_block filled in here.
|               The only error possibly detected is returned, if the byte format
|               of the given xid block sdu is not correct: MG_XID_BAD_FORMAT.
|               Then parameter type 1 list is read. If a data comp field has
|               an algorithm of type 0 (V42bis) then its values are written
|               to the given xid_block. If the algorithm is not 0 (V42bis) then
|               the entity is rejected.
|               The same for parameter type 2, here only algorithm type 0
|               (VanJacobson) is written to the xid_block.
|               Note: it is assumed here that the parameters come in line 0, 1, 2.
|               If that will no be the case, the parsing will have to modified
|               slightly.
|               If an unknown parameter type (not 0, 1, 2) is detected, an
|               MG_XID_BAD_FORMAT is returned.
|
| Parameters  : the sdu to be parsed, is negotiation started here?, the 
|               destination T_XID_BLOCK, a return value that should be MG_XID_OK
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_decode_xid (T_sdu* sdu,
                           T_XID_BLOCK* xid_block,
                           UBYTE* ret,
                           UBYTE sapi)
{

#define CHECK_XID_BUFFER_LEN if (index + field_index >= ((sdu->l_buf) >> 3)) return
  UBYTE sapi_index = 0;
  /*
   * Index for the whole sdu.
   */
  USHORT index = sdu->o_buf / 8;
  /*
   * Sub index used in compression fields.
   */
  USHORT field_index = 0;
  /*
   * This is the index where the parameter 2 for header compression begins.
   */
  USHORT beginning_of_header_comp = 0;
  /*
   * Length of complete parameter blocks of type 1 or 2.
   */
  USHORT length = 0;
  /*
   * Was decoding successful?
   */
  BOOL ok = FALSE;

  TRACE_FUNCTION( "mg_decode_xid" );

  /*
   * Reset xid_block.
   */
  sndcp_reset_xid_block(xid_block);

  sndcp_get_sapi_index(sapi, &sapi_index);
  *ret = MG_XID_BAD_FORMAT;

  /*
   * If end is reached, return with ok.
   */
  if (sdu->l_buf == 0) {
    *ret = MG_XID_OK;
    return;
  }
  /*
   * If parameter type 0 is included, store it.
   */
  CHECK_XID_BUFFER_LEN;
  if (sdu->buf[index] == SNDCP_XID_PARAM_TYPE_0) {
    index++;
    xid_block->version_set = TRUE;
    /*
     * Length should be SNDCP_XID_0_LEN, but is not checked.
     */
    CHECK_XID_BUFFER_LEN;
    length = sdu->buf[index];

    index++;
    /*
     * Set the version in xid_block.
     */
    CHECK_XID_BUFFER_LEN;
    xid_block->version = sdu->buf[index];
    index+= length;
  }

  /*
   * If end is reached, return with ok.
   */
  if (index == ((sdu->l_buf) >> 3)) {
    *ret = MG_XID_OK;
    return;
  }

  /*
   * If parameter type 1 is included, store it.
   */
  if (sdu->buf[index] == SNDCP_XID_PARAM_TYPE_1) {
    /*
     * Length of all data compression parameters.
     */
    index++;
    CHECK_XID_BUFFER_LEN;
    length = sdu->buf[index];
    /*
     * This is the index where the parameter 2 infos for header compression
     * begin.
     */
    beginning_of_header_comp = index + length + 1;

    /*
     * Search data compression parameters for algorithm type 1.
     */
    while (length > 0) {
      /*
       * Index is now on p-bit-entity-octet for one field.
       * If the p bit is set to 1 then we read the algorithm
       * type and drop the field if it is not SNDCP_XID_V42.
       * If the p bit is not set to 1 then we read the
       * entity number and drop the field if it is not the entity number
       * proposed in req_xid_block.
       */

      /*
       * Set field_index to beginning of next data compression field.
       */
      field_index++;

      CHECK_XID_BUFFER_LEN;
      if ((sdu->buf[index + field_index] & 0x80) > 0) {
        /*
         * P bit set to 1. Check algorithm type and drop field if
         * type is not known.
         * Set ntt.
         */
        xid_block->v42.ntt = sdu->buf[index + field_index] & 0x1F;
        /*
         * Set field_index to algorithm type.
         */
        field_index ++;
        CHECK_XID_BUFFER_LEN;
        if ((sdu->buf[index + field_index] & 0xf) != SNDCP_XID_V42) {
          /*
           * Wrong algorithm type. Add the ntt to list of rejected ones.
           */
          mg_set_sapi_dntt_rej(sapi, xid_block->v42.ntt, TRUE);
          /*
           * Set index to length octet.
           */
          field_index ++;
          /*
           * Set index to next field. Check field length.
           */
          CHECK_XID_BUFFER_LEN;
          field_index += sdu->buf[index + field_index];
          if (field_index > length) {
            /*
             * Field is too long, bad format.
             */
            return;
          }
          if (field_index == length) {
            /*
             * Field is completed but entity number has not been found because in
             * that case the loop would have been left with break;
             */
            xid_block->v42.is_set = FALSE;
            break;
          }
          continue;
        } else {
          /*
           * Correct algorithm type.
           */
          if (xid_block->v42.is_set == FALSE) {
            /*
             * This is the first occurrence.
             */
            xid_block->v42.is_set = TRUE;
            xid_block->v42.p_bit = 1;


            mg_decode_v42(sdu,
                          &index,
                          &field_index,
                          xid_block,
                          &ok,
                          SNDCP_P_BIT_1);
            if (!ok) {
              /*
               * Decoding was not successful.
               */
              return;
            }
          } else {
            /*
             * There has been an occurrence of this algorithm.
             */
            /*
             * Set index to length octet.
             */
            field_index ++;
            /*
             * Set index to next field. Check field length.
             */
            CHECK_XID_BUFFER_LEN;
            field_index += sdu->buf[index + field_index];
            if (field_index > length) {
              /*
               * Field is too long, bad format.
               */
              return;
            }
            if (field_index == length) {
              /*
               * Field is completed.
               */
              break;
            }

          }
          /*
           * If all data parameters are read, go ahead for header ones.
           */
          if (field_index == length) {
            break;
          }
        }
      } else {
        /*
         * P bit set to 0.
         * Check entity number and drop field if it is not the proposed one or
         * V42 has not been proposed yet.
         * field_index is already on p-bit-entity-octet.
         */
        CHECK_XID_BUFFER_LEN;
        if (((sdu->buf[index + field_index] & 0x1f) !=
            xid_block->v42.ntt) && xid_block->v42.is_set) {
          /*
           * Wrong entity number.
           */
          /*
           * Set field_index to length octet.
           */
          field_index ++;
          /*
           * Set index to next field. Check field length.
           */
          CHECK_XID_BUFFER_LEN;
          field_index += sdu->buf[index + field_index];
          if (field_index > length) {
            /*
             * Field is too long, bad format.
             */
            return;
          }
          if (field_index == length) {
            /*
             * Field is completed but entity number has not been found because in
             * that case the loop would have been left with break;
             */
            xid_block->v42.is_set = FALSE;
            break;
          }
          continue;
        } else {
          /*
           * The entity number of this field equals the entity number in
           * ththat is already in the xid block or there is no entity in
           * the xid block yet.
           */
          xid_block->v42.is_set = TRUE;
          xid_block->v42.p_bit = 0;
          xid_block->v42.ntt =
            (sdu->buf[index + field_index] & 0x1f);

          mg_decode_v42(sdu,
                        &index,
                        &field_index,
                        xid_block,
                        &ok,
                        SNDCP_P_BIT_0);
          if (!ok) {
            /*
             * Decoding was not successful.
             */
            return;
          }

          /*
           * If all data parameters are read, go ahead for header ones.
           */
          if (field_index == length) {
            break;
          }
        }
      } /* p bit set to 0 */
    } /* while  */
    field_index = 0;
    index = beginning_of_header_comp;
  }

  /*
   * Now comes the header compression parameter type 2.
   * Is it omitted?
   */
  if (index == ((sdu->l_buf) >> 3)) {
    *ret = MG_XID_OK;
    return;
  }

  /*
   * Parameter type should be SNDCP_XID_PARAM_TYPE_2.
   */
  CHECK_XID_BUFFER_LEN;
  if (sdu->buf[index] != SNDCP_XID_PARAM_TYPE_2) {
    return;
  }
  /*
   * Length of all header compression parameters.
   */
  index++;
  CHECK_XID_BUFFER_LEN;
  length = sdu->buf[index];


  /*
   * Search header compression parameters for algorithm type 2.
   */
  while (length > 0) {
    /*
     * Index is now on p-bit-entity-octet for one field.
     * If the p bit is set to 1 then we read the algorithm
     * type and drop the field if it is not SNDCP_XID_VJ.
     * If the p bit is not set to 1 then we read the
     * entity number and drop the field if it is not the entity number
     * proposed in req_xid_block.
     */
    /*
     * Set field_index to beginning of next header compression field.
     */
    field_index++;
    CHECK_XID_BUFFER_LEN;
    if ((sdu->buf[index + field_index] & 0x80) > 0) {
      UBYTE ntt = 0;
      /*
       * P bit set to 1. Check algorithm type and drop field if
       * type is not known.
       * Set ntt.
       */
      ntt = sdu->buf[index + field_index] & 0x1F;

      /*
       * Set index to algorithm type.
       */
      field_index ++;
      CHECK_XID_BUFFER_LEN;
      if (((sdu->buf[index + field_index] & 0xf) != SNDCP_XID_VJ)
          ||
          ((sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) &&
           (xid_block->vj.is_set == FALSE) &&
           (ntt != sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt)
          )
         ) {
        /*
         * Wrong algorithm type or
         * vj comp is currently used and proposed ntt is not equal to currently
         * used one.
         * Add ntt to list of rejected ones.
         */
        mg_set_sapi_pntt_rej(sapi, ntt, TRUE);
        /*
         * Set index to length octet.
         */
        field_index ++;
        /*
         * Set index to next field. Check field length.
         */
        CHECK_XID_BUFFER_LEN;
        field_index += sdu->buf[index + field_index];
        if (field_index > length) {
          /*
           * Field is too long, bad format.
           */
          return;
        }
        if (field_index == length) {
          /*
           * Field is completed but entity number has not been found because in
           * that case the loop would have been left with break;
           */
          xid_block->vj.is_set = FALSE;
          break;
        }
        continue;
      }
      /*
       * Correct algorithm type and vj requested.
       */
      /*
       * If no vj comp is currently used and xid_block.vj is not set yet, take
       * the proposed one.
       * Also if vj comp is currently used and xid block is not yet set and
       * proposed ntt is equal to currently used one.
       */
      if (((! sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) &&
           (xid_block->vj.is_set == FALSE))
          ||
          ((sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) &&
           (xid_block->vj.is_set == FALSE) &&
           (ntt == sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt))) {

        xid_block->vj.is_set = TRUE;
        xid_block->vj.p_bit = 1;
        xid_block->vj.ntt = ntt;

        mg_decode_vj (sdu,
                      &index,
                      &field_index,
                      xid_block,
                      &ok,
                      SNDCP_P_BIT_1);
        if (!ok) {
          /*
           * Decoding was not successful.
           */
          return;
        }
        /*
         * If all header parameters are read, go ahead for header ones.
         */
        if (field_index == length) {
          break;
        }
        continue;
      }
      /*
       * This is not the first occurrence. Ignore.
       */
      /*
       * Set index to length octet.
       */
      field_index ++;
      /*
       * Set index to next field. Check field length.
       */
      CHECK_XID_BUFFER_LEN;
      field_index += sdu->buf[index + field_index];
      if (field_index > length) {
        /*
         * Field is too long, bad format.
         */
        return;
      }
      if (field_index == length) {
        /*
         * Field is completed.
         */
        break;
      }

    } else {
      /*
       * P bit set to 0.
       * Check entity number and drop field if it is not the proposed one or
       * VJ has not been proposed yet.
       * Index is already on p-bit-entity-octet.
       */
      CHECK_XID_BUFFER_LEN;
      if (((sdu->buf[index + field_index] & 0x1f) !=
          xid_block->vj.ntt) && xid_block->vj.is_set) {
        /*
         * Wrong entity number.
         * Set index to length octet.
         */
        field_index ++;
        /*
         * Set index to next field. Check field length.
         */
        CHECK_XID_BUFFER_LEN;
        field_index += sdu->buf[index + field_index];
        if (field_index > length) {
          /*
           * Field is too long, bad format.
           */
          return;
        }
        if (field_index == length) {
          /*
           * Field is completed but entity number has not been found because in
           * that case the loop would have been left with break;
           */
          break;
        }
        continue;
      } else {
        /*
         * The entity number of this field equals the entity number in
         * that is already in the xid_block or there is no entity number
         * in the block yet.
         */
        xid_block->vj.is_set = TRUE;
        xid_block->vj.p_bit = 0;
        xid_block->vj.ntt =
          (sdu->buf[index + field_index] & 0x1f);

        mg_decode_vj (sdu,
                      &index,
                      &field_index,
                      xid_block,
                      &ok,
                      SNDCP_P_BIT_0);
        if (!ok) {
          /*
           * Decoding was not successful.
           */
          return;
        }
        /*
         * The one field with same entity number as in req_xid_block has been
         * found and loop of data compression field may be left.
         * If errors in not used fields are to be detected then we must continue here!
         */
        /*
         * If all header parameters are read, leave.
         */
        if (field_index == length) {
          break;
        }
      }
    }
  } /* while */
  /*
   * It is not checked here whether the sdu is completely read.
   */
  *ret = MG_XID_OK;

} /* mg_decode_xid() */


/*
+------------------------------------------------------------------------------
| Function    : mg_dti_close
+------------------------------------------------------------------------------
| Description : Closes DTI connection
| Parameters  : nsapi
+------------------------------------------------------------------------------
*/
GLOBAL void mg_dti_close (UBYTE nsapi)
{

#ifdef _SNDCP_DTI_2_
  UBYTE interfac = SNDCP_INTERFACE_UNACK;
#ifndef SNDCP_UPM_INCLUDED
  sndcp_get_nsapi_interface(nsapi, &interfac);
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
  dti_close(sndcp_data->hDTI, /* DTI_HANDLE *hDTI, */
            0, /* U8 instance, */
            interfac, /* U8 interface, */
            nsapi,
            NULL/* U8 channel); */
           );
#else /*_SNDCP_DTI_2_*/
  UBYTE interfac = SNDCP_INTERFACE_UNACK;

  sndcp_get_nsapi_interface(nsapi, &interfac);
  dti_close(sndcp_data->hDTI, /* DTI_HANDLE *hDTI, */
            0, /* U8 instance, */
            interfac, /* U8 interface, */
            nsapi /* U8 channel); */

           );
#endif /*_SNDCP_DTI_2_*/

  /*
   * The following is done in any case since the callback will not be called.
   */
  nu_connection_state(nsapi, FALSE);
   
  /*FIXME ! Added newly. To be verified.*/
#ifdef SNDCP_UPM_INCLUDED 
  {
    U32 linkid = 0;
    PALLOC (sn_dti_cnf, SN_DTI_CNF);
    sndcp_get_nsapi_linkid(nsapi, &linkid);
    sn_dti_cnf->dti_linkid = linkid;
    sn_dti_cnf->dti_conn = NAS_DISCONNECT_DTI;
    PSEND(hCommMMI, sn_dti_cnf);
  }
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
} /* mg_dti_close() */

/*
+------------------------------------------------------------------------------
| Function    : mg_dti_open
+------------------------------------------------------------------------------
| Description : Opens DTI connection
| Parameters  : nsapi
+------------------------------------------------------------------------------
*/
GLOBAL void mg_dti_open (UBYTE nsapi)
{
#ifdef _SNDCP_DTI_2_
  UBYTE* neighbor = NULL;
  ULONG linkid = 0;
#ifndef SNDCP_UPM_INCLUDED
  BOOL ack = FALSE;
#endif 
  U8 direction = DTI_CHANNEL_TO_LOWER_LAYER;
  UBYTE interfac = SNDCP_INTERFACE_UNACK;

  sndcp_get_nsapi_linkid(nsapi, &linkid);
  sndcp_get_nsapi_neighbor(nsapi, &neighbor);
#ifndef SNDCP_UPM_INCLUDED
  sndcp_get_nsapi_ack(nsapi, &ack);
#endif 
  sndcp_get_nsapi_direction(nsapi, &direction);
#ifndef SNDCP_UPM_INCLUDED
  if (ack) {
    interfac = SNDCP_INTERFACE_ACK;
    sndcp_set_nsapi_interface(nsapi, interfac);
  }
#endif

  dti_open(sndcp_data->hDTI, /* DTI_HANDLE hDTI */
           0, /* U8 instance */
           interfac, /* U8 interface */
           nsapi, /* U8 channel */
           0, /* U8 queue_size */
           direction, /* U8 direction */
           DTI_QUEUE_WATERMARK, /* U8 link options */
           DTI_VERSION_10, /* U32 version */
           neighbor, /* U8 *neighbor_entity */
           linkid/* U32 link_id */
           );
#else /*_SNDCP_DTI_2_*/
  UBYTE* neighbor = NULL;
  ULONG linkid = 0;
  BOOL ack = FALSE;
  BOOL direction = HOME;
  UBYTE interfac = SNDCP_INTERFACE_UNACK;

  sndcp_get_nsapi_linkid(nsapi, &linkid);
  sndcp_get_nsapi_neighbor(nsapi, &neighbor);
  sndcp_get_nsapi_ack(nsapi, &ack);
  sndcp_get_nsapi_direction(nsapi, &direction);
#ifndef SNDCP_UPM_INCLUDED
  if (ack) {
    interfac = SNDCP_INTERFACE_ACK;
    sndcp_set_nsapi_interface(nsapi, interfac);
  }
#endif 

  dti_open(sndcp_data->hDTI, /* DTI_HANDLE *hDTI */
           0, /* U8 instance */
           interfac, /* U8 interface */
           nsapi, /* U8 channel */
           0, /* U8 queue_size */
           direction, /* BOOL direction */
           FLOW_CNTRL_ENABLED, /* U8 comm_type */
           DTI_VERSION_10, /* U32 version */
           neighbor, /* U8 *neighbor_entity */
           linkid/* U32 link_id */
           );

#endif /*_SNDCP_DTI_2_*/
} /* mg_dti_open() */

/*
+------------------------------------------------------------------------------
| Function    : mg_init
+------------------------------------------------------------------------------
| Description : The function mg_init() ....
|
| Parameters  :
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_init (void)
{

  UBYTE sapi_index = 0;
  UBYTE nsapi = 0;
  TRACE_FUNCTION( "mg_init" );
  INIT_STATE(MG, MG_DEFAULT);
  /*
   * req_xid_block, cnf_xid_block, cur_xid_block not initialized.
   */
  for (sapi_index = 0; sapi_index < SNDCP_NUMBER_OF_SAPIS; sapi_index++) {

    mg_reset_states_n_rej(sapi_index);
    /*
     * Init renegotiation counter and cur_xid_block with default values.
     */
    sndcp_data->mg.renego[sapi_index] = 0;

    sndcp_reset_xid_block(&sndcp_data->mg.req_xid_block[sapi_index]);
    sndcp_reset_xid_block(&sndcp_data->mg.cnf_xid_block[sapi_index]);
    sndcp_reset_xid_block(&sndcp_data->mg.ind_xid_block[sapi_index]);
    sndcp_reset_xid_block(&sndcp_data->mg.res_xid_block[sapi_index]);
    sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]);
    sndcp_reset_xid_block(&sndcp_data->mg.new_xid_block[sapi_index]);

  }
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    sndcp_reset_xid_block(&sndcp_data->mg.user_xid_block[nsapi]);
    sndcp_data->mg.user_xid_block[nsapi].vj.s0_m_1 = 0;
    sndcp_data->cur_pcomp[nsapi] = 0;
    sndcp_data->cur_dcomp[nsapi] = 0;
    sndcp_data->cur_seg_pos[nsapi] = 0;
    sndcp_data->cur_pdu_ref[nsapi].ref_nsapi = 0;
    sndcp_data->cur_pdu_ref[nsapi].ref_npdu_num = 0;
    sndcp_data->cur_pdu_ref[nsapi].ref_seg_num = 0;
    sndcp_data->big_head[nsapi] = FALSE;
  }


  sndcp_data->mg.mod_expects = MG_MOD_X_NONE;
  sndcp_data->mg.waiting_nsapis = 0;
  sndcp_data->mg.suspended_nsapis = 0;

} /* mg_init() */



/*
+------------------------------------------------------------------------------
| Function    : mg_is_ack
+------------------------------------------------------------------------------
| Description : This procedure takes the snsm_qos!rely
|               information:
|
| 0 SNSM_RELCLASS_SUB Subscribed reliability class
| 1 SNSM_GTP_LLC_RLC_PROT Acknowledged GTP, LLC, and RLC; Protected data
| 2 SNSM_LLC_RLC_PROT Unacknowledged GTP; Acknowledged LLC and RLC, Protected data
| 3 SNSM_RLC_PROT Unacknowledged GTP and LLC; Acknowledged RLC, Protected data
| 4 SNSM_PROT Unacknowledged GTP, LLC, and RLC, Protected data
| 5 SNSM_NO_REL Unacknowledged GTP, LLC, and RLC, Unprotected data
|
| and sets "spec" to TRUE, "b" to TRUE in case of SNSM_GTP_LLC_RLC_PROT or
| SNSM_LLC_RLC_PROT,
| [should be, is not:["spec" to FALSE in case of SNSM_RELCLASS_SUB]] and "spec"
| to TRUE, "b" to FALSE else.
|
| Important note: in case of SNSM_RELCLASS_SUB "spec" will actually be set to
| to TRUE, "b" to FALSE, to be robust in case of downlink protocol error!
|
| Parameters  : snsm_qos
|                       BOOL* spec (FALSE for REL_CLASS_SUB),
|                       BOOL* b)
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_is_ack (T_snsm_qos snsm_qos,
                       BOOL* spec,
                       BOOL* b)
{
  TRACE_FUNCTION( "mg_is_ack" );


#ifdef SNDCP_UPM_INCLUDED 
  if (snsm_qos.relclass ==  PS_GTP_LLC_RLC_PROT ||
    snsm_qos.relclass == PS_LLC_RLC_PROT) {
#else
  if (snsm_qos.relclass ==  SNSM_GTP_LLC_RLC_PROT ||
    snsm_qos.relclass == SNSM_LLC_RLC_PROT) {
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
    *spec = TRUE;
    *b = TRUE;
   /*  } else if (snsm_qos.relclass == SNSM_RELCLASS_SUB) {
    *spec = FALSE;
    */
  } else {
    *spec = TRUE;
    *b = FALSE;
  }


} /* mg_is_ack() */

/*
+------------------------------------------------------------------------------
| Function    : mg_no_col_no_re
+------------------------------------------------------------------------------
| Description : The function mg_no_col_no_re represents  the SDL label
|               NO_COL_NO_RE: an LL_ESTABLISH_IND has been received, we do not
|               have a collision situation like given in [GSM 4.65, 6.2.1.4],
|               we do not have a re-establishment situation.
|
| Parameters  : the received LL_ESTABLISH_IND
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_no_col_no_re (T_LL_ESTABLISH_IND* ll_establish_ind)
{
  UBYTE dec_ret = 0;
  UBYTE check_ret = 0;
  UBYTE sapi_index = 0;
  U8 nsapi = 0;
  TRACE_FUNCTION( "mg_no_col_no_re" );
  sndcp_get_sapi_index(ll_establish_ind->sapi, &sapi_index);

  TRACE_EVENT_P3("l3_valid?: %d, N201_I: %d, N201_U: %d", 
                  ll_establish_ind->xid_valid, ll_establish_ind->n201_i, 
                  ll_establish_ind->n201_u);
  /*
   * Set N201 values in uplink services.
   */
  sig_mg_su_n201(ll_establish_ind->sapi, ll_establish_ind->n201_u);
  sig_mg_sua_n201(ll_establish_ind->sapi, ll_establish_ind->n201_i);
  /*
   * If SNDCP XID block is not valid, we are ready.
   */
  if (ll_establish_ind->xid_valid == LL_XID_INVALID) {

    PALLOC_SDU (ll_establish_res, LL_ESTABLISH_RES, 0);
    /*
     * Set sapi in ll_establish_res.
     */
    ll_establish_res->sapi = ll_establish_ind->sapi;
    ll_establish_res->xid_valid = ll_establish_ind->xid_valid;
    ll_establish_res->sdu.l_buf = 0;

    /*
     * Mark the affected sapi as MG_XID_IDLE.
     */
    sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_EST);

    sig_mg_sda_end_est(ll_establish_res->sapi, TRUE);

    sndcp_set_sapi_ack(ll_establish_res->sapi, TRUE);

    PSEND(hCommLLC, ll_establish_res);

    /*
     * All nsapis at this sapi that use ack mode, enter recovery state.
     */
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) {
      UBYTE sapi = 0;
      BOOL ack = FALSE;

      sndcp_get_nsapi_sapi(nsapi, &sapi);
      sndcp_get_nsapi_ack(nsapi, &ack);
      if (ack && (sapi == ll_establish_ind->sapi)) {
        sig_mg_cia_delete_npdus(nsapi);
        sig_mg_sua_delete_pdus(nsapi, sapi, FALSE);
        sig_mg_nu_recover(nsapi);
        sig_mg_nd_recover(nsapi);
      }
    } /* for all nsapis */

    return;
  }
  /*
   * SNDCP XID block is valid and checked now.
   */
  mg_decode_xid(&(ll_establish_ind->sdu),
                &(sndcp_data->mg.ind_xid_block[sapi_index]),
                &dec_ret,
                ll_establish_ind->sapi);
  if (dec_ret == MG_XID_OK) {
    mg_check_ind_xid(&check_ret, ll_establish_ind->sapi);
    if (check_ret == MG_XID_OK) {
      /*
       * Label MG_IND_OK_EST
       */
      USHORT res_sdu_bit_len = 0;
      UBYTE ntt = 0;
      BOOL v42_rej = FALSE;
      BOOL vj_rej = FALSE;

      mg_set_res_cur_xid_block(ll_establish_ind->sapi, &res_sdu_bit_len);
      /*
       * Add the extra space for ntts with nsapis == 0.
       */
      for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
        BOOL rej = FALSE;
        mg_get_sapi_dntt_rej(ll_establish_ind->sapi, ntt, &rej);
        if (rej) {
          /*
           * length of ntt octet and nsapis.
           */
          res_sdu_bit_len += 32;
          v42_rej = TRUE;
        }
        mg_get_sapi_pntt_rej(ll_establish_ind->sapi, ntt, &rej);
        if (rej) {
          /*
           * length of ntt octet and nsapis.
           */
          res_sdu_bit_len += 32;
          vj_rej = TRUE;
        }
      }
      if (! sndcp_data->mg.res_xid_block[sapi_index].v42.is_set &&
          v42_rej) {
        /*
         * Add length of parameter type and length.
         */
        res_sdu_bit_len += 16;
      }
      if (! sndcp_data->mg.res_xid_block[sapi_index].vj.is_set &&
          vj_rej) {
        /*
         * Add length of parameter type and length.
         */
        res_sdu_bit_len += 16;
      }

      /*
       * SDL Label MG_CNF_OK_ACK
       */

      {

        USHORT sapi_state = MG_IDLE;

        PALLOC_SDU (ll_establish_res, LL_ESTABLISH_RES, res_sdu_bit_len);
        /*
         * Set sapi in ll_establish_res.
         */
        ll_establish_res->sapi = ll_establish_ind->sapi;
        ll_establish_res->xid_valid = ll_establish_ind->xid_valid;
        /*
         * Write res_xid_block struct to sdu byte buffer. Implementation dep..
         */
        mg_set_res_xid_params(&ll_establish_res->sdu, ll_establish_res->sapi);

        /*
         * Mark the affected nsapis and sapi as MG_XID_IDLE.
         */
        sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_XID);
        sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_EST);

        sig_mg_sda_end_est(ll_establish_res->sapi, TRUE);

        sndcp_set_sapi_ack(ll_establish_res->sapi, TRUE);

        PSEND(hCommLLC, ll_establish_res);

        /*
         * All nsapis at this sapi that use ack mode, enter recovery state.
         */
        for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) {
          UBYTE sapi = 0;
          BOOL ack = FALSE;

          sndcp_get_nsapi_sapi(nsapi, &sapi);
          sndcp_get_nsapi_ack(nsapi, &ack);
          if (ack && (sapi == ll_establish_ind->sapi)) {
            sig_mg_cia_delete_npdus(nsapi);
            sig_mg_sua_delete_pdus(nsapi, sapi, FALSE);
            sig_mg_nu_recover(nsapi);
            sig_mg_nd_recover(nsapi);
          }
        } /* for all nsapis */

        /*
         * Reset nsapis or ntts that were assigned, but are not any more.
         */
        mg_clean_xid(ll_establish_ind->sapi);
        /*
         * If there was a collision and xid has not been negotiated
         * sufficiently.
         */
        mg_resend_xid_if_nec(ll_establish_ind->sapi);

        /*
         * If nsapi has been in state xid_pending or est_pending then
         * an snsm_activate_res will be sent now.!!!
         */
        mg_respond_if_nec(ll_establish_ind->sapi);
        sndcp_get_sapi_state(ll_establish_ind->sapi, &sapi_state);
        if ((sapi_state & MG_XID) == 0) {
          mg_xid_cnf_ok_res(ll_establish_ind->sapi);
        }


      }

    } else {
      /*
       * not (check_ret == MG_IND_XID_OK)
       */
      /*
       * Label MG_CHECK_FAIL_EST
       */
      USHORT res_sdu_bit_len = 0;
      UBYTE ntt = 0;
      BOOL v42_rej = FALSE;
      BOOL vj_rej = FALSE;
      /*
       * Add the extra space for ntts with nsapis == 0.
       */
      for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
        BOOL rej = FALSE;
        mg_get_sapi_dntt_rej(ll_establish_ind->sapi, ntt, &rej);
        if (rej) {
          /*
           * length of ntt octet and nsapis.
           */
          res_sdu_bit_len += 32;
          v42_rej = TRUE;
        }
        mg_get_sapi_pntt_rej(ll_establish_ind->sapi, ntt, &rej);
        if (rej) {
          /*
           * length of ntt octet and nsapis.
           */
          res_sdu_bit_len += 32;
          vj_rej = TRUE;
        }
      }
      if (v42_rej) {
        /*
         * Add length of parameter type and length.
         */
        res_sdu_bit_len += 16;
      }
      if (vj_rej) {
        /*
         * Add length of parameter type and length.
         */
        res_sdu_bit_len += 16;
      }
      /*
       * Allocate response and send it.
       */
      {

        PALLOC_SDU (ll_establish_res, LL_ESTABLISH_RES, res_sdu_bit_len);
        /*
         * Reset res_xid_block, ind_xid_block.
         */
        sndcp_reset_xid_block(&sndcp_data->mg.res_xid_block[sapi_index]);
        sndcp_reset_xid_block(&sndcp_data->mg.ind_xid_block[sapi_index]);
        /*
         * Set sapi in ll_establish_res.
         */
        ll_establish_res->sapi = ll_establish_ind->sapi;
        ll_establish_res->xid_valid = ll_establish_ind->xid_valid;
        /*
         * Write res_xid_block struct to sdu byte buffer. Implementation dep..
         */
        mg_set_res_xid_params(&ll_establish_res->sdu, ll_establish_ind->sapi);
        /*
         * Modify the affected sapi state.
         */
        sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_XID);
        sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_EST);

        sndcp_set_sapi_ack(ll_establish_res->sapi, TRUE);
        /*
         * Send the XID block to LLC.
         */
        PSEND(hCommLLC, ll_establish_res);
                /*
         * All nsapis at this sapi that use ack mode, enter recovery state.
         */
        for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) {
          UBYTE sapi = 0;
          BOOL ack = FALSE;

          sndcp_get_nsapi_sapi(nsapi, &sapi);
          sndcp_get_nsapi_ack(nsapi, &ack);
          if (ack && (sapi == ll_establish_ind->sapi)) {
            sig_mg_cia_delete_npdus(nsapi);
            sig_mg_sua_delete_pdus(nsapi, sapi, FALSE);
            sig_mg_nu_recover(nsapi);
            sig_mg_nd_recover(nsapi);
          }
        } /* for all nsapis */

      }

      /*
       * Reset nsapis or ntts that were assigned before
       * but are not anymore.
       */
      sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]);
      mg_clean_xid(ll_establish_ind->sapi);
      /*
       * Allocate status req and send it  (label MG_SEND_STATUS_REQ_EST).
       */
      {
#ifdef SNDCP_UPM_INCLUDED 
        PALLOC (snsm_status_req, SN_STATUS_IND);
#else
        PALLOC (snsm_status_req, SNSM_STATUS_REQ);
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
        snsm_status_req->sapi = ll_establish_ind->sapi;
#ifdef SNDCP_UPM_INCLUDED 
        snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp;
        snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_INVALID_XID;
        PSEND (hCommUPM, snsm_status_req);
#else
        snsm_status_req->status_cause = SNSM_RELCS_INVALID_XID;
        PSEND (hCommSM, snsm_status_req);
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
      }
    }
  } else { /* not if (dec_ret == MG_XID_OK_EST) */
    /*
     * Reset nsapis or ntts that were assigned before
     * but are not anymore.
     */
    sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]);
    mg_clean_xid(ll_establish_ind->sapi);
    /*
     * Decoding of ll_establish_ind failed (label MG_SEND_STATUS_REQ).
     * Allocate status req and send it.
     */

    {
#ifdef SNDCP_UPM_INCLUDED 
      PALLOC (snsm_status_req, SN_STATUS_IND);
      snsm_status_req->sapi = ll_establish_ind->sapi;
      snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp;
      snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_INVALID_XID;
      PSEND (hCommUPM, snsm_status_req);
#else
      PALLOC (snsm_status_req, SNSM_STATUS_REQ);
      snsm_status_req->sapi = ll_establish_ind->sapi;
      snsm_status_req->status_cause = SNSM_RELCS_INVALID_XID;
      PSEND (hCommSM, snsm_status_req);
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
    }

  }

} /* mg_no_col_no_re() */

/*
+------------------------------------------------------------------------------
| Function    : mg_no_col_re
+------------------------------------------------------------------------------
| Description : The function mg_no_col_no_re represents  the SDL label
|               NO_COL_RE: an LL_ESTABLISH_IND has been received, we do not
|               have a collision situation like given in [GSM 4.65, 6.2.1.4],
|               we do have a re-establishment situation.
|
| Parameters  : the received LL_ESTABLISH_IND
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_no_col_re (T_LL_ESTABLISH_IND* ll_establish_ind)
{

  TRACE_FUNCTION( "mg_no_col_re" );
  /*
   * Do the same things as without collision.
   */
  mg_no_col_no_re (ll_establish_ind);

} /* mg_no_col_re() */

/*
+------------------------------------------------------------------------------
| Function    : mg_re_negotiate
+------------------------------------------------------------------------------
| Description : The answer to the sent LL_XID_REQ has been invalid
| (bad format or content). If service var renego < MG_MAX_RENEGO then
| same LL_XID_REQ is resent, else SNSM_STATUS_REQ is sent.
| This function represents the SDl label MG_RE_NEGOTIATE.
|
| Parameters  : the affected sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_re_negotiate (UBYTE sapi) {
  UBYTE sapi_index = 0;

  TRACE_FUNCTION( "mg_re_negotiate" );
  sndcp_get_sapi_index(sapi, &sapi_index);

  /*
   * If number of re-negotiations is reached, deactivate all pdp contexts for
   * the affected sapi.
   */
  if (sndcp_data->mg.renego[sapi_index] < MG_MAX_RENEGO) {
    PALLOC_SDU(ll_xid_req, LL_XID_REQ, SNDCP_XID_BLOCK_BIT_LEN);
    /*
     * Set sapi in ll_xid_req.
     */
    ll_xid_req->sapi = sapi;

    /*
     * Fill the XID block. Implementation dependent.
     */
    mg_set_xid_params(ll_xid_req->sapi,
                      &ll_xid_req->sdu,
                      sndcp_data->mg.req_xid_block[sapi_index]);
    /*
     * Send the XID block to LLC.
     */

    sndcp_unset_sapi_state(sapi, MG_XID_NEC);
    sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID);
    PSEND(hCommLLC, ll_xid_req);
    /*
     * Increment renegotiation counter.
     */
    sndcp_data->mg.renego[sapi_index]++;
  } else {

#ifdef SNDCP_UPM_INCLUDED 
    PALLOC (snsm_status_req, SN_STATUS_IND);
#else
    PALLOC (snsm_status_req, SNSM_STATUS_REQ);
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
    /*
     * Set all ntts and dcomp/pcomp states to "unassigned".
     */
    mg_reset_states_n_rej(sapi_index);
    /*
     * Set prim parameters.
     */
#ifdef SNDCP_UPM_INCLUDED 
    snsm_status_req->sapi = sapi;
    snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp;
    snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_INVALID_XID;
#else
    snsm_status_req->sapi = sapi;
    snsm_status_req->status_cause = SNSM_RELCS_INVALID_XID;
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/

    sndcp_data->mg.renego[sapi_index] = 0;
    /*
     * Reset cur_xid_block.
     */
    sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]);
    /*
     * Reset all compression entities for the affected sapi.
     */
    mg_clean_xid(sapi);

#ifdef SNDCP_UPM_INCLUDED 
    PSEND (hCommUPM, snsm_status_req);
#else
    PSEND (hCommSM, snsm_status_req);
#endif 
  }


} /* mg_re_negotiate() */

/*
+------------------------------------------------------------------------------
| Function    : mg_re_negotiate_ack
+------------------------------------------------------------------------------
| Description : The answer to the sent LL_ESTABLISH_REQ has been invalid
| (bad format or content). If service var renego < MG_MAX_RENEGO then
| same LL_ESTABLISH_REQ is resent, else SNSM_STATUS_REQ is sent.
| This function represents the SDl label MG_RE_NEGOTIATE_ACK.
|
| Parameters  : the affected sapi, cause
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_re_negotiate_ack (UBYTE sapi, U16 cause) {
  UBYTE sapi_index = 0;

  TRACE_FUNCTION( "mg_re_negotiate_ack" );
  sndcp_get_sapi_index(sapi, &sapi_index);

  /*
   * If number of re-negotiations is reached, deactivate all pdp contexts for
   * the affected sapi.
   */
  if (sndcp_data->mg.renego[sapi_index] < MG_MAX_RENEGO) {
    PALLOC_SDU(ll_establish_req,
               LL_ESTABLISH_REQ,
               SNDCP_XID_BLOCK_BIT_LEN);
    /*
     * Set sapi in ll_establish_req.
     */
    ll_establish_req->sapi = sapi;

    /*
     * Fill the XID block. Implementation dependent.
     */
    mg_set_xid_params(ll_establish_req->sapi,
                      &ll_establish_req->sdu,
                      sndcp_data->mg.req_xid_block[sapi_index]);
    /*
     * Send the XID block to LLC, with establish request.
     */
    sig_mg_sda_start_est(sapi);

    PSEND(hCommLLC, ll_establish_req);
    /*
     * Increment renegotiation counter.
     */
    sndcp_data->mg.renego[sapi_index]++;
  } else {

#ifdef SNDCP_UPM_INCLUDED
    PALLOC (snsm_status_req, SN_STATUS_IND);
#else
    PALLOC (snsm_status_req, SNSM_STATUS_REQ);
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
    /*
     * Service sda may now leave state SDA_ESTABLISH_REQUESTED.
     */
    sig_mg_sda_end_est(sapi, FALSE);
    /*
     * Set all ntts and dcomp/pcomp states to "unassigned".
     */
    mg_reset_states_n_rej(sapi_index);
    /*
     * Set prim parameters.
     */
#ifdef SNDCP_UPM_INCLUDED 
    snsm_status_req->sapi = sapi;
    snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp;
#else
    snsm_status_req->sapi = sapi;
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/

    sndcp_data->mg.renego[sapi_index] = 0;
    /*
     * Reset cur_xid_block.
     */
    sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]);
    sndcp_reset_xid_block(&sndcp_data->mg.req_xid_block[sapi_index]);
    /*
     * Reset all compression entities for the affected sapi.
     */
    mg_clean_xid(sapi);
    /*
     * The renegotiation is failed. If the cause is NO_PEER_RESPONSE
     * or DM_RECEIVED, set it to RELCS_NORMAL to make SM deactivate
     * PDP context. Otherwise the cause is forwarded to SM and the SM
     * will deactivate PDP context depending on cause.
     */
#ifdef SNDCP_UPM_INCLUDED 
    if((cause == CAUSE_SN_NO_PEER_RESPONSE) ||
       (cause == CAUSE_SN_DM_RECEIVED) ){
      snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_NORMAL_RELEASE;
#else /* SNDCP_UPM_INCLUDED */    
#ifdef _SNDCP_DTI_2_
    if((cause == LL_RELCS_NO_PEER_RES) ||
       (cause == LL_RELCS_DM_RECEIVED) ){
      snsm_status_req->ps_cause.value.sn_cause = LL_RELCS_NORMAL;
#else
    if((cause == CAUSE_SN_NO_PEER_RESPONSE) ||
       (cause == CAUSE_SN_DM_RECEIVED) ){
      snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_NORMAL_RELEASE;
#endif 
#endif  /* SNDCP_UPM_INCLUDED */
      sig_mg_su_resume(sapi);
      sig_mg_sua_resume(sapi);
      mg_resume_affected_nus(sapi);
      sndcp_unset_sapi_state (sapi, MG_EST);
    } else {
#ifdef SNDCP_UPM_INCLUDED 
      snsm_status_req->ps_cause.value.sn_cause = cause;
#else      
      snsm_status_req->status_cause = cause;
#endif 
    }
	
#ifdef SNDCP_UPM_INCLUDED 
    PSEND (hCommUPM, snsm_status_req);
#else
    PSEND (hCommSM, snsm_status_req);
#endif 

  }

} /* mg_re_negotiate_ack() */


/*
+------------------------------------------------------------------------------
| Function    : mg_resend_xid_if_nec
+------------------------------------------------------------------------------
| Description : This procedure will be called after reception and computation
| of an LL_XID_IND or LL_ESTABLISH_IND in case of a collision
| or after receiving LL_XID_CNF or LL_ESTABLISH_CNF and does the
| following:
| (GSM 04.65 version 6.5.1 Release 1997), 6.2.1.4:
| If the
| LL-ESTABLISH.request or LL-XID.request contains one or more XID parameters,
| or one or more compression fields
| in an XID parameter, or one or more parameters in a compression field,
| that are not negotiated as part of the collision
| resolution, then negotiation of these XID parameters shall be performed at
| the earliest opportunity after conclusion of
| the collision resolution.
|
| Parameters  : Affected sapi, out: was LL_XID_REQ sent?
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_resend_xid_if_nec (UBYTE sapi) {
  UBYTE sapi_index = 0;
  BOOL resend_necessary = FALSE;
  USHORT sapi_state = MG_IDLE;
  T_XID_BLOCK* req_xid_block = NULL;
  T_XID_BLOCK* cur_xid_block = NULL;
  T_XID_BLOCK* new_xid_block = NULL;

  TRACE_FUNCTION( "mg_resend_xid_if_nec" );

  sndcp_get_sapi_index(sapi, &sapi_index);
  req_xid_block = &sndcp_data->mg.req_xid_block[sapi_index];
  cur_xid_block = &sndcp_data->mg.cur_xid_block[sapi_index];
  new_xid_block = &sndcp_data->mg.new_xid_block[sapi_index];

  /*
   * Data compression.
   */
  /*
   * If a context is deactivated, maybe compressors must be switched off.
   */
  if (cur_xid_block->v42.is_set) {
    USHORT nsapis = cur_xid_block->v42.nsapis;
    UBYTE nsapi = 0;

    /*
     * XID renegotiation will only be necessary if one of the nsapis
     * that are requested to use the data compression is in state
     * MG_DEACT.
     */
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if (((1 << nsapi) & nsapis) > 0) {
        USHORT state = MG_IDLE;
        sndcp_get_nsapi_state(nsapi, &state);
        if ((state & MG_DEACT) > 0) {
          UBYTE dntt = cur_xid_block->v42.ntt;
          resend_necessary = TRUE;
          mg_set_sapi_dntt_rej(sapi, dntt, TRUE);
        }
      }
    }
  }

  if (req_xid_block->v42.is_set && ! cur_xid_block->v42.is_set) {
    UBYTE sapi_index_local = 0;
    BOOL used = FALSE;
    /*
     * If one instance of v42 is used at a different sapi,
     * we may not use another one here.
     */
    for (sapi_index_local = 0;
         sapi_index_local < SNDCP_NUMBER_OF_SAPIS;
         sapi_index_local++) {

      if (sndcp_data->mg.cur_xid_block[sapi_index_local].v42.is_set) {
        used = TRUE;
      }
    }
    if (! used) {
      USHORT nsapis = req_xid_block->v42.nsapis;
      UBYTE nsapi = 0;

      /*
       * XID renegotiation will only be necessary if one of the nsapis
       * that are requested to use the data compression are not all in state
       * MG_DEACT.
       */
      for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
        if (((1 << nsapi) & nsapis) > 0) {
          USHORT state = MG_IDLE;
          sndcp_get_nsapi_state(nsapi, &state);
          if ((state & MG_DEACT) == 0) {
            resend_necessary = TRUE;
          }
        }
      }

    }
  }
  /*
   * Header compression.
   */
  /*
   * If a context is deactivated, maybe compressors must be switched off.
   */
  if (cur_xid_block->vj.is_set) {
    USHORT nsapis = cur_xid_block->vj.nsapis;
    UBYTE nsapi = 0;

    /*
     * XID renegotiation will only be necessary if one of the nsapis
     * that are requested to use the header compression is in state
     * MG_DEACT.
     */
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if (((1 << nsapi) & nsapis) > 0) {
        USHORT state = MG_IDLE;
        sndcp_get_nsapi_state(nsapi, &state);
        if ((state & MG_DEACT) > 0) {
          UBYTE pntt = cur_xid_block->vj.ntt;
          resend_necessary = TRUE;
          mg_set_sapi_pntt_rej(sapi, pntt, TRUE);
        }
      }
    }

  }
  /*
   * If a compressor is requested and not yet negotiated it must be requested
   * now.
   */
  if (req_xid_block->vj.is_set && !cur_xid_block->vj.is_set) {
    USHORT nsapis = req_xid_block->vj.nsapis;
    UBYTE nsapi = 0;

    req_xid_block->vj.p_bit = 1;

    /*
     * XID renegotiation will only be necessary if the affected nsapis
     * is not currently being deactivated.
     */
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if (((1 << nsapi) & nsapis) > 0) {
        USHORT state = MG_IDLE;
        sndcp_get_nsapi_state(nsapi, &state);
        if ((state & MG_DEACT) == 0) {
          resend_necessary = TRUE;
        }
      }
    }

  }

  /*
   * If in the meantime more compression has been requested,
   * or compressors must be deactivated,
   * re-negotiate.
   */
  if (new_xid_block->v42.is_set) {
    if ((! req_xid_block->v42.is_set) ||
        (req_xid_block->v42.is_set &&
         (new_xid_block->v42.nsapis != req_xid_block->v42.nsapis))) {

      *req_xid_block = *new_xid_block;
      resend_necessary = TRUE;
    }
  }

  /*
   * If in the meantime more compression has been requested,
   * or compressors must be deactivated,
   * re-negotiate.
   */
  if (new_xid_block->vj.is_set) {
    if ((! req_xid_block->vj.is_set) ||
        (req_xid_block->vj.is_set &&
         (new_xid_block->vj.nsapis != req_xid_block->vj.nsapis))) {

      *req_xid_block = *new_xid_block;
      resend_necessary = TRUE;
    }
  }


  sndcp_get_sapi_state(sapi, &sapi_state);
  /*
   * If re-negotiation is necessary but not possible because MG_REL or
   * MG_XID, set MG_XID_NEC.
   */
  if (resend_necessary
      &&
      ((sapi_state & (MG_REL + MG_XID)) > 0))
  {
    sndcp_set_sapi_state(sapi, MG_XID_NEC);
    mg_set_cur_xid_block(sapi);
    return;
  }


  /*
   * If renegotiation of XID is necessary, send LL_XID_REQ.
   */
  if (! resend_necessary) {
//    mg_set_cur_xid_block(sapi);
    return;
  }


  /*
   * Now req_xid_block is in good shape. Send it.
   */
  {
    PALLOC_SDU(ll_xid_req, LL_XID_REQ, SNDCP_XID_BLOCK_BIT_LEN);
    /*
     * Set sapi in ll_xid_req.
     */
    ll_xid_req->sapi = sapi;
    /*
     * Write data from snsm_activate_ind to service variable req_xid_block.
     */
    mg_set_ntt_comp(sapi);
    /*
     * Fill the XID block. Implementation dependent.
     */
    mg_set_xid_params(ll_xid_req->sapi,
                      &ll_xid_req->sdu,
                      sndcp_data->mg.req_xid_block[sapi_index]);
    /*
     * Mark the affected sapi as MG_XID.
     */
    sndcp_set_sapi_state(sapi, MG_XID);
    sndcp_unset_sapi_state(sapi, MG_XID_NEC);

    /*
     * Uplink data transfer on SAPI is completely suspended.
     */
    sig_mg_su_suspend(sapi);
    sig_mg_sua_suspend(sapi);
    mg_suspend_affected_nus(sapi);
    /*
     * Send the XID block to LLC.
     */

    sndcp_unset_sapi_state(sapi, MG_XID_NEC);
    sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID);
    PSEND(hCommLLC, ll_xid_req);
  }

} /* mg_resend_xid_if_nec() */



/*
+------------------------------------------------------------------------------
| Function    : mg_resume_affected_nus
+------------------------------------------------------------------------------
| Description : Resumes all nu service instances affected by
|               If nsapi is waiting for SNSM_SEQUENCE_IND, fct. returns.
|
| Parameters  : sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_resume_affected_nus (UBYTE sapi) {
  UBYTE nsapi = 0;
  TRACE_FUNCTION( "mg_resume_affected_nus" );
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    UBYTE local_sapi = 0;
    sndcp_get_nsapi_sapi(nsapi, &local_sapi);
    if (local_sapi == sapi) {
      USHORT nsapi_state = 0;
      sndcp_get_nsapi_state(nsapi, &nsapi_state);
      if ((nsapi_state & MG_SEQ) > 0) {
        return;
      }
      if (((1 << nsapi) & sndcp_data->mg.suspended_nsapis) > 0) {
        sig_mg_nu_resume(nsapi);
        sndcp_data->mg.suspended_nsapis &= (~ (ULONG)(1 << nsapi));
      }
    }
  }
} /* mg_resume_affected_nus() */


/*
+------------------------------------------------------------------------------
| Function    : mg_is_rel_comp_nec
+------------------------------------------------------------------------------
| Description : This function will be called in course of the deactivation of
|               the given nsapi. If the nsapi used a certain compressor,
|               but has been the only one to do this, then with the
|               compressor entity will also have to
|               be deactivated and all affected
|               arrays will be modified.
| Parameters  : UBYTE nsapi -- the given nsapi
|               BOOL* nec,  a compressor
| Post        : An "mg_set_sapi_[p/d]ntt_rej(sapi, pntt, TRUE);" will be called
|               for
|               each entity to be released. Later this information may be used
|               to build up the right xid negotiation.
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_is_rel_comp_nec (UBYTE nsapi, BOOL* nec)
{
  UBYTE dntt = 0;
  UBYTE pntt = 0;
  UBYTE sapi = 0;
  UBYTE nsp = 0;

  TRACE_FUNCTION( "mg_is_rel_comp_nec" );

  sndcp_get_nsapi_sapi(nsapi, &sapi);


  /*
   * Which pntt is used?
   */
  for (pntt = 0; pntt < MG_MAX_ENTITIES; pntt++) {
    UBYTE state = MG_UNASSIGNED;
    BOOL used = FALSE;
    BOOL another = FALSE;
    BOOL rej_known = FALSE;
    /*
     * Is pntt already known to be deactivated?
     */
    mg_get_sapi_pntt_rej(sapi, pntt, &rej_known);
    if (rej_known) {
      *nec = TRUE;
      continue;
    }
    /*
     * Is ntt used?
     */
    mg_get_sapi_pntt_state(sapi, pntt, &state);
    if (state == MG_UNASSIGNED) {
      continue;
    }
    /*
     * Does the given nsapi use it?
     */
    mg_get_sapi_pntt_nsapi(sapi, pntt, nsapi, &used);
    if (! used) {
      continue;
    }
    /*
     * Is the given nsapi the only user?
     */
    for (nsp = 0; nsp < SNDCP_NUMBER_OF_NSAPIS; nsp++) {
      mg_get_sapi_pntt_nsapi(sapi, pntt, nsp, &used);
      if (used && nsapi != nsp) {
        another = TRUE;
      }
    }
    if (another) {
      continue;
    }
    mg_set_sapi_pntt_rej(sapi, pntt, TRUE);
    *nec = TRUE;
  }

  /*
   * Which dntt is used?
   */
  for (dntt = 0; dntt < MG_MAX_ENTITIES; dntt++) {
    UBYTE state = MG_UNASSIGNED;
    BOOL used = FALSE;
    BOOL another = FALSE;
    BOOL rej_known = FALSE;
    /*
     * Is pntt already known to be deactivated?
     */
    mg_get_sapi_dntt_rej(sapi, dntt, &rej_known);
    if (rej_known) {
      *nec = TRUE;
      continue;
    }
    /*
     * Is ntt used?
     */
    mg_get_sapi_dntt_state(sapi, dntt, &state);
    if (state == MG_UNASSIGNED) {
      continue;
    }
    /*
     * Does the given nsapi use it?
     */
    mg_get_sapi_dntt_nsapi(sapi, dntt, nsapi, &used);
    if (! used) {
      continue;
    }
    /*
     * Is the given nsapi the only user?
     */
    for (nsp = 0; nsp < SNDCP_NUMBER_OF_NSAPIS; nsp++) {
      mg_get_sapi_dntt_nsapi(sapi, dntt, nsp, &used);
      if (used && nsapi != nsp) {
        another = TRUE;
      }
    }
    if (another) {
      continue;
    }

    mg_set_sapi_dntt_rej(sapi, dntt, TRUE);
    *nec = TRUE;
  }

} /* mg_is_rel_comp_nec() */


/*
+------------------------------------------------------------------------------
| Function    : mg_rel_nsapi_nec
+------------------------------------------------------------------------------
| Description : The SAPI connected to this NSAPI shall release acknowledged LLC
|               operation mode if the indicated NSAPI is the last one using
|               acknowledged mode on this SAPI. If an LL_RELEASE_REQ is sent
|               then the given NSAPI (the one in parameter!) shall enter state
|               MG_REL and wait for an LL_RELEASE_CNF. If the affected
|               NSAPI doesn't use ack mode then the procedure just returns.
|               If the affected sapi does not use acknowledged LLC operation
|               mode then the procedure just returns.
|               If an LL_ESTABLISH_REQ or LL_XID_REQ for the affected sapi is
|               pending, no LL_RELEASE_REQ primitive will be sent, but the
|               flag MG_REL_NEC_LOC will be set.
| Pre         : This procedure is called after receipt of an
|               SNSM_DEACTIVATE_IND, so the "local" parameter in an
|               LL_RELEASE_REQ will be set to LL_REL_LOCAL.
|               The procedure will only be called if the given nsapi is
|               currently using acknowledged LLC operation mode, so this
|               does not have to be checked.
| Parameters  : UBYTE nsapi -- the given nsapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_rel_nsapi_nec (UBYTE nsapi)
{
  UBYTE sapi = 0;
  UBYTE npi = 0;
  UBYTE spi = 0;
  USHORT sapi_state = MG_IDLE;
  /*
   * Are there other contexts using acknowledged mode on the same SAPI?
   */
  BOOL another_ack = FALSE;
  BOOL sack = FALSE;
  TRACE_FUNCTION( "mg_rel_nsapi_nec" );
  /*
   * Which SAPI is connected to the given NSAPI?
   */
  sndcp_get_nsapi_sapi(nsapi, &sapi);
  sndcp_get_sapi_ack(sapi, &sack);
  sndcp_get_sapi_state(sapi, &sapi_state);

  if(!sack){
    if ((sapi_state & MG_EST) != 0) {
      sndcp_set_sapi_state(sapi, MG_REL_NEC_LOC);
    }
    return;
  }
  /*
   * If release is pending, no need to send an other release.
   */
  if ((sapi_state & MG_REL) > 0) {
    return;
  }
  /*
   * Are there other contexts using acknowledged mode on the same SAPI?
   */
  for (npi = 0; npi < SNDCP_NUMBER_OF_NSAPIS; npi++) {
    BOOL used = FALSE;
    sndcp_is_nsapi_used(npi, &used);
    if (!used) {
      continue;
    }
    sndcp_get_nsapi_sapi(npi, &spi);
    if (spi == sapi && npi != nsapi) {
      BOOL is_ack = FALSE;
      sndcp_get_nsapi_ack(npi, &is_ack);
      if (is_ack) {
        another_ack = TRUE;
      }
      break;
    }
  }
  if (!another_ack) {

    if (((sapi_state & MG_EST) == 0)
        &&
        ((sapi_state & MG_XID) == 0))
    {
      /*
       * No LL_ESTABLISH_REQ or LL_XID_REQ pending.
       * LL_RELEASE_REQ may be sent.
       */

      PALLOC(ll_release_req, LL_RELEASE_REQ);
      ll_release_req->sapi = sapi;
      /*
       * Note: this is always set to TRUE because the preconditions include that
       * this procedure has been called after an SNSM_DEACTIVATE_IND.
       * If this precondition changes the local flag will have to be a parameter.
       * (GSM 4.65, 6.2.2.2).
       */
      ll_release_req->local = TRUE;
      /*
       * Set the "state" for the affected sapi to MG_REL.
       */
      sndcp_set_sapi_state(sapi, MG_REL);
      sndcp_unset_sapi_state(sapi, MG_EST);

      PSEND(hCommLLC, ll_release_req);

    } else {
      /*
       * LL_ESTABLISH_REQ or LL_XID_REQ pending.
       * LL_RELEASE_REQ may not be sent.
       */
      sndcp_set_sapi_state(sapi, MG_REL_NEC_LOC);

    }
  } /* if (!another_ack)  */


} /* mg_rel_nsapi_nec() */

/*
+------------------------------------------------------------------------------
| Function    : mg_send_empty_xid_req
+------------------------------------------------------------------------------
| Description : This procedure sets the pending-states of the affected sapi
|               and nsapi to MG_XID_PENDING and sends an LL_XID_REQ with
|               the sapi from the given snsm_activate_ind and an empty XID
|               block.
|
| Parameters  : the SNSM_ACTIVATE_IND
|
+------------------------------------------------------------------------------
*/
#ifdef SNDCP_UPM_INCLUDED
GLOBAL void mg_send_empty_xid_req (T_SN_ACTIVATE_REQ* snsm_activate_ind)
#else
GLOBAL void mg_send_empty_xid_req (T_SNSM_ACTIVATE_IND* snsm_activate_ind)
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
{
  TRACE_FUNCTION( "mg_send_empty_xid_req" );
  {
    PALLOC_SDU(ll_xid_req, LL_XID_REQ, SNDCP_XID_BLOCK_BIT_LEN);
    /*
     * Set sapi in ll_xid_req.
     */
    ll_xid_req->sapi = snsm_activate_ind->sapi;
    ll_xid_req->sdu.l_buf = 0;

    /*
     * Mark sapi as pending.
     */
    sndcp_set_sapi_state(snsm_activate_ind->sapi, MG_XID);
    /*
     * Send the XID block to LLC.
     */

    sndcp_unset_sapi_state(ll_xid_req->sapi, MG_XID_NEC);
    sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID);
    PSEND(hCommLLC, ll_xid_req);
  }
} /* mg_send_xid_req() */

/*
+------------------------------------------------------------------------------
| Function    : mg_send_snsm_activate_res
+------------------------------------------------------------------------------
| Description : Allocates prim, sets parameters and sends prim
|
| Parameters  : the affected nsapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_send_snsm_activate_res (UBYTE nsapi)
{

  TRACE_FUNCTION( "mg_send_snsm_activate_res" );
  {
    UBYTE sapi_index = 0;
    UBYTE sapi = 0;

#ifdef SNDCP_UPM_INCLUDED 
    PALLOC(snsm_activate_res, SN_ACTIVATE_CNF);
#else
    PALLOC(snsm_activate_res, SNSM_ACTIVATE_RES); 
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/

    sndcp_get_nsapi_sapi(nsapi, &sapi);
    sndcp_get_sapi_index(sapi, &sapi_index);

    snsm_activate_res->nsapi = nsapi;

    /*
     * If nsapi uses data compressor, set dcomp parameter
     * in snsm_activate_res.
     */
    if (sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set &&
        ((sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis &
         (1 << nsapi)) > 0)) {

#ifdef SNDCP_UPM_INCLUDED 
      snsm_activate_res->comp_params.dcomp = 
        sndcp_data->mg.cur_xid_block[sapi_index].v42.p0;
#else
      snsm_activate_res->dcomp =
        sndcp_data->mg.cur_xid_block[sapi_index].v42.p0; 
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
    } else
    {
#ifdef SNDCP_UPM_INCLUDED 
    snsm_activate_res->comp_params.dcomp = 0;
#else
    snsm_activate_res->dcomp = 0; 
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
    } 

    /*
     * If nsapi uses header compressor, set hcomp parameter
     * and msid field in snsm_activate_res.
     */

#ifdef SNDCP_UPM_INCLUDED 
    if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set &&
        ((sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis &
         (1 << nsapi)) > 0)) {
      snsm_activate_res->comp_params.msid = 
        sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1 + 1;
      /*
       * How is that one negotiated?
       * Missing in VJ XID block.
       */
      snsm_activate_res->comp_params.hcomp = 
        sndcp_data->mg.cur_xid_block[sapi_index].vj.direction;
    } else {
      snsm_activate_res->comp_params.hcomp = 0;
      snsm_activate_res->comp_params.msid = 0;
    }

    PSEND(hCommUPM, snsm_activate_res);
#else  /*#ifdef SNDCP_UPM_INCLUDED*/
      if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set &&
        ((sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis &
         (1 << nsapi)) > 0)) {
      snsm_activate_res->msid =
        sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1 + 1; 
      /*
       * How is that one negotiated?
       * Missing in VJ XID block.
       */
      snsm_activate_res->hcomp =
        sndcp_data->mg.cur_xid_block[sapi_index].vj.direction;
    } else {
      snsm_activate_res->hcomp = 0;
      snsm_activate_res->msid = 0;
    }
    PSEND(hCommSM, snsm_activate_res); 
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
}
  } /* mg_send_snsm_activate_res() */



/*
+------------------------------------------------------------------------------
| Function    : mg_send_xid_req
+------------------------------------------------------------------------------
| Description : This procedure sets the pending-states of the affected sapi
|               and nsapi to MG_XID_PENDING and sends an LL_XID_REQ with
|               parameters set according to the compression informations in
|               the given snsm_activate_ind and according to constants that
|               determine the capabilities of the data compression entity.
|               The part of this procedure that deals with the constant
|               compressor capabilities is implementation dependent.
|
| Parameters  : the SNSM_ACTIVATE_IND
|
+------------------------------------------------------------------------------
*/
#ifdef SNDCP_UPM_INCLUDED 
GLOBAL void mg_send_xid_req (T_SN_ACTIVATE_REQ* snsm_activate_ind)
#else
GLOBAL void mg_send_xid_req (T_SNSM_ACTIVATE_IND* snsm_activate_ind)
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
{
  UBYTE sapi_index = 0;
  TRACE_FUNCTION( "mg_send_xid_req" );
  sndcp_get_sapi_index(snsm_activate_ind->sapi, &sapi_index);
  {
    PALLOC_SDU(ll_xid_req, LL_XID_REQ, SNDCP_XID_BLOCK_BIT_LEN);
    /*
     * Set sapi in ll_xid_req.
     */
    ll_xid_req->sapi = snsm_activate_ind->sapi;
    /*
     * Write data from snsm_activate_ind to service variable req_xid_block.
     */

    mg_set_req_xid_block(snsm_activate_ind);
    /*
     * Fill the XID block. Implementation dependent.
     */
    mg_set_xid_params(ll_xid_req->sapi,
                      &ll_xid_req->sdu,
                      sndcp_data->mg.req_xid_block[sapi_index]);
    /*
     * Mark the affected sapi as xid pending
     */

    sndcp_set_sapi_state(snsm_activate_ind->sapi, MG_XID);

    /*
     * Trace xid block.
     */
#ifdef SNDCP_TRACE_ALL
    TRACE_EVENT("outcoming xid block:");
    sndcp_trace_sdu(&ll_xid_req->sdu);
#endif
    /*
     * Send the XID block to LLC.
     */

    sndcp_unset_sapi_state(ll_xid_req->sapi, MG_XID_NEC);
    sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID);
    PSEND(hCommLLC, ll_xid_req);
  }
} /* mg_send_xid_req() */

/*
+------------------------------------------------------------------------------
| Function    : mg_send_xid_req_del
+------------------------------------------------------------------------------
| Description : If mg_get_sapi_pntt_rej() or mg_get_sapi_dntt_rej() indicate
|               that compressors must be removed, this function will
|               send an LL_XID_REQ which does this, or if an XID is pending,
|               the information about the rejected compressors will be stored
|               to new_xid_block and the MG_XID_NEC will be set.
|
| Parameters  : the SNSM_ACTIVATE_IND
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_send_xid_req_del (UBYTE sapi)
{
  UBYTE sapi_index = 0;
  UBYTE ntt = 0;
  T_XID_BLOCK mt_xid_block;
  /*
   * Only length of parameter type 0.
   */
  USHORT res_sdu_bit_len = 24;
  BOOL v42_rej = FALSE;
  BOOL vj_rej = FALSE;

  TRACE_FUNCTION( "mg_send_xid_req_del" );

  sndcp_reset_xid_block(&mt_xid_block);

  sndcp_get_sapi_index(sapi, &sapi_index);
  /*
   * How long will xid_block be?
   */
  /*
   * Add the extra space for ntts with nsapis == 0.
   */
  for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
    BOOL rej = FALSE;
    mg_get_sapi_dntt_rej(sapi, ntt, &rej);
    if (rej) {
      /*
       * length of ntt octet and nsapis.
       */
      res_sdu_bit_len += 32;
      v42_rej = TRUE;
      /*
       * Change new_xid_block.
       */
      sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis = 0;
      sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis_set = TRUE;
      sndcp_data->mg.new_xid_block[sapi_index].v42.is_set = TRUE;
    }

    mg_get_sapi_pntt_rej(sapi, ntt, &rej);
    if (rej) {
      /*
       * length of ntt octet and nsapis.
       */
      res_sdu_bit_len += 32;
      vj_rej = TRUE;
      /*
       * Change req_xid_block.
       */
      sndcp_data->mg.new_xid_block[sapi_index].vj.nsapis = 0;
      sndcp_data->mg.new_xid_block[sapi_index].vj.nsapis_set = TRUE;
      sndcp_data->mg.new_xid_block[sapi_index].vj.is_set = TRUE;

    }
  }
  if (v42_rej) {
    /*
     * Add length of parameter type and length.
     */
    res_sdu_bit_len += 16;
  }
  if (vj_rej) {
    /*
     * Add length of parameter type and length.
     */
    res_sdu_bit_len += 16;
  }

  if (v42_rej || vj_rej) {

    USHORT state = MG_IDLE;

    sndcp_get_sapi_state(sapi, &state);
    if ((state & MG_XID) == 0) {

      PALLOC_SDU(ll_xid_req, LL_XID_REQ, res_sdu_bit_len);

      sndcp_data->mg.req_xid_block[sapi_index] =
        sndcp_data->mg.new_xid_block[sapi_index];
      /*
       * Set sapi in ll_xid_req.
       */
      ll_xid_req->sapi = sapi;
      /*
       * Write data from snsm_activate_ind to service variable req_xid_block.
       */
      sndcp_reset_xid_block(&mt_xid_block);
      sndcp_reset_xid_block(&sndcp_data->mg.new_xid_block[sapi_index]);
      /*
       * Fill the XID block. Implementation dependent.
       */
      mg_set_xid_params(ll_xid_req->sapi,
                        &ll_xid_req->sdu,
                        mt_xid_block);
      /*
       * Mark the affected sapi as MG_DEL_XID_PENDING.
       */
      sndcp_set_sapi_state(sapi, MG_XID);
      /*
       * Send the XID block to LLC.
       */

      sndcp_unset_sapi_state(sapi, MG_XID_NEC);
      sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID);
      PSEND(hCommLLC, ll_xid_req);
    } else {
      sndcp_set_sapi_state(sapi, MG_XID_NEC);
    }
  }
} /* mg_send_xid_req_del() */


/*
+------------------------------------------------------------------------------
| Function    : mg_set_cur_xid_block
+------------------------------------------------------------------------------
| Description : This procedure sets the cur_xid_block service variable
| according to the values given in req_xid_block and cnf_xid_block.
| It also sets the unassigned, selected, assigned states of the affected
| dcomp, pcomp, ntt.
| The p bit in the req_xid_block is unset, if affected.
| See GSM 4.65, 6.8.2.
|
| Parameters  : the affected sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_set_cur_xid_block (UBYTE sapi) {
  UBYTE sapi_index = 0;
  T_XID_BLOCK* cur_xid_block;
  T_XID_BLOCK* req_xid_block;
  T_XID_BLOCK* cnf_xid_block;
  TRACE_FUNCTION( "mg_set_cur_xid_block" );
  sndcp_get_sapi_index(sapi, &sapi_index);
  cur_xid_block = &sndcp_data->mg.cur_xid_block[sapi_index];
  req_xid_block = &sndcp_data->mg.req_xid_block[sapi_index];
  cnf_xid_block = &sndcp_data->mg.cnf_xid_block[sapi_index];
  /*
   * SNDCP version has been tested to be SNDCP_XID_VERSION.
   */
  cur_xid_block->version = SNDCP_XID_VERSION;

  /*
   * V42bis parameters.
   */
  if (req_xid_block->v42.is_set) {
    cur_xid_block->v42.is_set = TRUE;
    cur_xid_block->v42.ntt = req_xid_block->v42.ntt;
    mg_set_sapi_dntt_state(sapi,
                           req_xid_block->v42.ntt,
                           MG_ASSIGNED);
    req_xid_block->v42.p_bit = SNDCP_P_BIT_0;

    /*
     * Algorithm type and DCOMP are only set in req.
     */
    cur_xid_block->v42.algo_type = req_xid_block->v42.algo_type;
    cur_xid_block->v42.dcomp = req_xid_block->v42.dcomp;
    mg_set_sapi_dcomp_state(sapi,
                            req_xid_block->v42.dcomp,
                            MG_ASSIGNED);

    if (cnf_xid_block->v42.is_set) {

      if (cnf_xid_block->v42.nsapis_set) {
        cur_xid_block->v42.nsapis = cnf_xid_block->v42.nsapis;
        cur_xid_block->v42.nsapis_set = TRUE;
      } else if (req_xid_block->v42.nsapis_set) {
        cur_xid_block->v42.nsapis = req_xid_block->v42.nsapis;
        cur_xid_block->v42.nsapis_set = TRUE;
      }
      if (cnf_xid_block->v42.p0_set) {
        cur_xid_block->v42.p0 = cnf_xid_block->v42.p0;
        cur_xid_block->v42.p0_set = TRUE;
      } else if (req_xid_block->v42.p0_set) {
        cur_xid_block->v42.p0 = req_xid_block->v42.p0;
        cur_xid_block->v42.p0_set = TRUE;
      }
      if (cnf_xid_block->v42.p1_set) {
        cur_xid_block->v42.p1 = cnf_xid_block->v42.p1;
        cur_xid_block->v42.p1_set = TRUE;
      } else if (req_xid_block->v42.p1_set) {
        cur_xid_block->v42.p1 = req_xid_block->v42.p1;
        cur_xid_block->v42.p1_set = TRUE;
      }
      if (cnf_xid_block->v42.p2_set) {
        cur_xid_block->v42.p2 = cnf_xid_block->v42.p2;
        cur_xid_block->v42.p2_set = TRUE;
      } else if (req_xid_block->v42.p2_set) {
        cur_xid_block->v42.p2 = req_xid_block->v42.p2;
        cur_xid_block->v42.p2_set = TRUE;
      }

    } else {
      /*
       * NOT cnf_xid_block->v42.is_set.
       */

      if (req_xid_block->v42.nsapis_set) {
        cur_xid_block->v42.nsapis = req_xid_block->v42.nsapis;
        cur_xid_block->v42.nsapis_set = TRUE;
      }
      if (req_xid_block->v42.p0_set) {
        cur_xid_block->v42.p0 = req_xid_block->v42.p0;
        cur_xid_block->v42.p0_set = TRUE;
      }
      if (req_xid_block->v42.p1_set) {
        cur_xid_block->v42.p1 = req_xid_block->v42.p1;
        cur_xid_block->v42.p1_set = TRUE;
      }
      if (req_xid_block->v42.p2_set) {
        cur_xid_block->v42.p2 = req_xid_block->v42.p2;
        cur_xid_block->v42.p2_set = TRUE;
      }

    }
  } else {
    /*
     * NOT req_xid_block->v42.is_set.
     */
    if (cnf_xid_block->v42.is_set) {

      cur_xid_block->v42.is_set = TRUE;
      if (cnf_xid_block->v42.nsapis_set) {
        cur_xid_block->v42.nsapis = cnf_xid_block->v42.nsapis;
        cur_xid_block->v42.nsapis_set = TRUE;
      }
      if (cnf_xid_block->v42.p0_set) {
        cur_xid_block->v42.p0 = cnf_xid_block->v42.p0;
        cur_xid_block->v42.p0_set = TRUE;
      }
      if (cnf_xid_block->v42.p1_set) {
        cur_xid_block->v42.p1 = cnf_xid_block->v42.p1;
        cur_xid_block->v42.p1_set = TRUE;
      }
      if (cnf_xid_block->v42.p2_set) {
        cur_xid_block->v42.p2 = cnf_xid_block->v42.p2;
        cur_xid_block->v42.p2_set = TRUE;
      }

    } else {
      /*
       * Req and cnf are not set, cur_xid_block keeps its values.
       */
    }
  }


  /*
   * VJ parameters.
   */
  if (req_xid_block->vj.is_set) {
    cur_xid_block->vj.is_set = TRUE;
    cur_xid_block->vj.ntt = req_xid_block->vj.ntt;
    mg_set_sapi_pntt_state(sapi,
                           req_xid_block->vj.ntt,
                           MG_ASSIGNED);
    req_xid_block->vj.p_bit = SNDCP_P_BIT_0;
    /*
     * Algorithm type and PCOMPs are only set in req.
     * The direction is only set in req.
     */
    cur_xid_block->vj.algo_type = req_xid_block->vj.algo_type;
    cur_xid_block->vj.pcomp1 = req_xid_block->vj.pcomp1;
    mg_set_sapi_pcomp_state(sapi,
                            req_xid_block->vj.pcomp1,
                            MG_ASSIGNED);
    cur_xid_block->vj.pcomp2 = req_xid_block->vj.pcomp2;
    mg_set_sapi_pcomp_state(sapi,
                            req_xid_block->vj.pcomp2,
                            MG_ASSIGNED);
    cur_xid_block->vj.direction = req_xid_block->vj.direction;
    if (cnf_xid_block->vj.is_set) {
      if (cnf_xid_block->vj.nsapis_set) {
        cur_xid_block->vj.nsapis = cnf_xid_block->vj.nsapis;
        cur_xid_block->vj.nsapis_set = TRUE;
      } else {
        cur_xid_block->vj.nsapis = req_xid_block->vj.nsapis;
        cur_xid_block->vj.nsapis_set = TRUE;
      }
      if (cnf_xid_block->vj.s0_m_1_set) {
        cur_xid_block->vj.s0_m_1 = cnf_xid_block->vj.s0_m_1;
        cur_xid_block->vj.s0_m_1_set = TRUE;
      } else {
        cur_xid_block->vj.s0_m_1 = req_xid_block->vj.s0_m_1;
        cur_xid_block->vj.s0_m_1_set = TRUE;
      }
    } else {
      if (req_xid_block->vj.nsapis_set) {
        cur_xid_block->vj.nsapis = req_xid_block->vj.nsapis;
        cur_xid_block->vj.nsapis_set = TRUE;
      }
      if (req_xid_block->vj.s0_m_1_set) {
        cur_xid_block->vj.s0_m_1 = req_xid_block->vj.s0_m_1;
        cur_xid_block->vj.s0_m_1_set = TRUE;
      }
    }
  } else {
    /*
     * NOT req_xid_block->vj.es_set.
     */
    if (cnf_xid_block->vj.is_set) {
      cur_xid_block->vj.is_set = TRUE;
      if (cnf_xid_block->vj.nsapis_set) {
        cur_xid_block->vj.nsapis = cnf_xid_block->vj.nsapis;
        cur_xid_block->vj.nsapis_set = TRUE;
      }
      if (cnf_xid_block->vj.s0_m_1_set) {
        cur_xid_block->vj.s0_m_1 = cnf_xid_block->vj.s0_m_1;
        cur_xid_block->vj.s0_m_1_set = TRUE;
      }
    } else {
      /*
       * Req and cnf are not set, cur_xid_block keeps it's values.
       */
    }
  }

  /*
   * If nsapis are 0, deactivate compressor.
   */
  if (cur_xid_block->v42.nsapis == 0 ||
      cur_xid_block->v42.nsapis_set == FALSE) {

    /*
     * Find the affected compressor entity.
     */
    UBYTE dntt = 0;
    mg_get_sapi_dcomp_dntt(sapi, req_xid_block->v42.dcomp, &dntt);

    cur_xid_block->v42.is_set = FALSE;
    mg_set_sapi_dcomp_state(sapi,
                            req_xid_block->v42.dcomp,
                            MG_UNASSIGNED);
    mg_set_sapi_dntt_state(sapi,
                           dntt,
                           MG_UNASSIGNED);
    /*
     * One compressor less, something like sndcp_data->v42_count--;
     * should come here!
     */

  }
  if (cur_xid_block->vj.nsapis == 0 ||
      cur_xid_block->vj.nsapis_set == FALSE) {

    /*
     * Find the affected compressor entity.
     */
    UBYTE pntt = 0;
    mg_get_sapi_pcomp_pntt(sapi, req_xid_block->vj.pcomp1, &pntt);
    mg_get_sapi_pcomp_pntt(sapi, req_xid_block->vj.pcomp2, &pntt);
    cur_xid_block->vj.is_set = FALSE;
    mg_set_sapi_pcomp_state(sapi,
                            req_xid_block->vj.pcomp1,
                            MG_UNASSIGNED);
    mg_set_sapi_pcomp_state(sapi,
                            req_xid_block->vj.pcomp2,
                            MG_UNASSIGNED);
    mg_set_sapi_pntt_state(sapi,
                           pntt,
                           MG_UNASSIGNED);
    /*
     * One compressor less.
     */
    if (sndcp_data->vj_count > 0) {
      sndcp_data->vj_count--;
    }
  }


  /*
   * Send new block to service cia.
   */
  sig_mg_cia_new_xid(cur_xid_block);

} /* mg_set_cur_xid_block() */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_new_xid_block
+------------------------------------------------------------------------------
| Description : This procedure reads data from the given snsm_activate_ind and
|               from the already requested xid block and
|               writes them to the service variable new_xid_block.
|               When the pending establishment or xid negotiation is finished
|               this new_xid_block will be newly evaluated.
|
| Parameters  :
|               the new SNSM_ACTIVATE_IND
|
+------------------------------------------------------------------------------
*/
#ifdef SNDCP_UPM_INCLUDED
GLOBAL void mg_set_new_xid_block (T_SN_ACTIVATE_REQ* snsm_activate_ind)
#else
GLOBAL void mg_set_new_xid_block (T_SNSM_ACTIVATE_IND* snsm_activate_ind)
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
{
  UBYTE sapi_index = 0;
  TRACE_FUNCTION( "mg_set_new_xid_block" );
  sndcp_get_sapi_index(snsm_activate_ind->sapi, &sapi_index);
  /*
   * Set the version number.
   */
  sndcp_data->mg.new_xid_block[sapi_index].version = SNDCP_XID_VERSION;
  /*
   * Set the V42.bis parameters,
   */
#ifdef TI_PS_FF_V42BIS
  sndcp_data->mg.new_xid_block[sapi_index].v42.is_set =
#ifdef SNDCP_UPM_INCLUDED
    (snsm_activate_ind->comp_params.dcomp != NAS_DCOMP_NEITHER_DIRECT);
#else
    (snsm_activate_ind->dcomp != SNSM_COMP_NEITHER_DIRECT);
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
  sndcp_data->mg.new_xid_block[sapi_index].v42.p_bit = SNDCP_P_BIT_1;
  sndcp_data->mg.new_xid_block[sapi_index].v42.ntt = SNDCP_NTT_0;
  sndcp_data->mg.new_xid_block[sapi_index].v42.algo_type = SNDCP_XID_V42;
  sndcp_data->mg.new_xid_block[sapi_index].v42.dcomp = SNDCP_DCOMP1;
  sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis =
    1 << (snsm_activate_ind->nsapi);
  sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis_set = TRUE;
#ifdef SNDCP_UPM_INCLUDED
  sndcp_data->mg.new_xid_block[sapi_index].v42.p0 = snsm_activate_ind->comp_params.dcomp;
#else
  sndcp_data->mg.new_xid_block[sapi_index].v42.p0 = snsm_activate_ind->dcomp;
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
  sndcp_data->mg.new_xid_block[sapi_index].v42.p0_set = TRUE;

  /*
   * Set p1 and p2 to default values.
   */
  sndcp_data->mg.new_xid_block[sapi_index].v42.p1 = SNDCP_V42_DEFAULT_P1;
  sndcp_data->mg.new_xid_block[sapi_index].v42.p1_set = TRUE;
  sndcp_data->mg.new_xid_block[sapi_index].v42.p2 =
    SNDCP_V42_DEFAULT_P2;
  sndcp_data->mg.new_xid_block[sapi_index].v42.p2_set = TRUE;

  /*
   * Set affected entities and dcomp/pcomp values.
   */
  mg_set_ntt_comp(snsm_activate_ind->sapi);

#else /* !TI_PS_FF_V42BIS */


  sndcp_data->mg.new_xid_block[sapi_index].v42.is_set = FALSE;

  sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis = 0;

  sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis_set = FALSE;
  sndcp_data->mg.new_xid_block[sapi_index].v42.p0_set = FALSE;

  /*
   * Set p1 and p2 to default values.
   */
  sndcp_data->mg.new_xid_block[sapi_index].v42.p1 = SNDCP_V42_DEFAULT_P1;
  sndcp_data->mg.new_xid_block[sapi_index].v42.p1_set = TRUE;
  sndcp_data->mg.new_xid_block[sapi_index].v42.p2 =
    SNDCP_V42_DEFAULT_P2;
  sndcp_data->mg.new_xid_block[sapi_index].v42.p2_set = TRUE;

#endif /* TI_PS_FF_V42BIS */

  /*
   * Set the Van Jacobson parameters,
   */
  sndcp_data->mg.new_xid_block[sapi_index].vj.is_set =
#ifdef SNDCP_UPM_INCLUDED 
    (snsm_activate_ind->comp_params.hcomp != NAS_HCOMP_OFF) ||
#else
    (snsm_activate_ind->hcomp != SNSM_COMP_NEITHER_DIRECT) ||
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
    sndcp_data->mg.new_xid_block[sapi_index].vj.is_set ||
    sndcp_data->mg.req_xid_block[sapi_index].vj.is_set;

  if (! sndcp_data->mg.req_xid_block[sapi_index].vj.is_set) {
    sndcp_data->mg.new_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_1;
  } else {
    sndcp_data->mg.new_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_0;
  }

  sndcp_data->mg.new_xid_block[sapi_index].vj.ntt = SNDCP_NTT_0;
  sndcp_data->mg.new_xid_block[sapi_index].vj.algo_type = SNDCP_XID_VJ;
  sndcp_data->mg.new_xid_block[sapi_index].vj.pcomp1 = SNDCP_PCOMP1;
  sndcp_data->mg.new_xid_block[sapi_index].vj.pcomp2 = SNDCP_PCOMP2;

  sndcp_data->mg.new_xid_block[sapi_index].vj.nsapis |=
    (sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis |
     1 << (snsm_activate_ind->nsapi));
  sndcp_data->mg.new_xid_block[sapi_index].vj.nsapis_set = TRUE;
  
#ifdef SNDCP_UPM_INCLUDED
  sndcp_data->mg.new_xid_block[sapi_index].vj.s0_m_1 = 
    snsm_activate_ind->comp_params.msid - 1;
#else
  sndcp_data->mg.new_xid_block[sapi_index].vj.s0_m_1 =
    snsm_activate_ind->msid - 1;
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
  sndcp_data->mg.new_xid_block[sapi_index].vj.s0_m_1_set = TRUE;
  /*
   * Only used internally, not in XID block.
   * Not: it is assumed that the indicated values match the existing ones!
   */
#ifdef SNDCP_UPM_INCLUDED
  sndcp_data->mg.new_xid_block[sapi_index].vj.direction = 
    snsm_activate_ind->comp_params.hcomp;
#else
  sndcp_data->mg.new_xid_block[sapi_index].vj.direction = 
    snsm_activate_ind->hcomp;
#endif /*#ifdef SNDCP_UPM_INCLUDED*/

} /* mg_set_new_xid_block() */



/*
+------------------------------------------------------------------------------
| Function    : mg_set_req_xid_block
+------------------------------------------------------------------------------
| Description : This procedure reads data from the given snsm_activate_ind and
|               writes it to the service variable req_xid_block.
|
| Parameters  :
|               the SNSM_ACTIVATE_IND that caused the negotiation.
|
+------------------------------------------------------------------------------
*/
#ifdef SNDCP_UPM_INCLUDED
GLOBAL void mg_set_req_xid_block (T_SN_ACTIVATE_REQ* snsm_activate_ind)
#else
GLOBAL void mg_set_req_xid_block (T_SNSM_ACTIVATE_IND* snsm_activate_ind)
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
{
  UBYTE sapi_index = 0;
  BOOL vio;
  TRACE_FUNCTION( "mg_set_req_xid_block" );
  sndcp_get_sapi_index(snsm_activate_ind->sapi, &sapi_index);
  /*
   * Set the version number.
   */
  sndcp_data->mg.req_xid_block[sapi_index].version = SNDCP_XID_VERSION;
  /*
   * Set the V42.bis parameters,
   */
#ifdef TI_PS_FF_V42BIS

#ifdef SNDCP_UPM_INCLUDED
    sndcp_data->mg.req_xid_block[sapi_index].v42.is_set =
      (snsm_activate_ind->comp_params.dcomp != NAS_DCOMP_NEITHER_DIRECT);
#else
    sndcp_data->mg.req_xid_block[sapi_index].v42.is_set = 
      (snsm_activate_ind->dcomp != SNSM_COMP_NEITHER_DIRECT);
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
    sndcp_data->mg.req_xid_block[sapi_index].v42.p_bit = SNDCP_P_BIT_1;
    sndcp_data->mg.req_xid_block[sapi_index].v42.ntt = SNDCP_NTT_0;
    sndcp_data->mg.req_xid_block[sapi_index].v42.algo_type = SNDCP_XID_V42;
    sndcp_data->mg.req_xid_block[sapi_index].v42.dcomp = SNDCP_DCOMP1;

    sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis =
      1 << (snsm_activate_ind->nsapi);
    sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis_set = TRUE;
#ifdef SNDCP_UPM_INCLUDED
    sndcp_data->mg.req_xid_block[sapi_index].v42.p0 = snsm_activate_ind->comp_params.dcomp;
#else
    sndcp_data->mg.req_xid_block[sapi_index].v42.p0 = snsm_activate_ind->dcomp;
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
    sndcp_data->mg.req_xid_block[sapi_index].v42.p0_set = TRUE;

    /*
     * Set p1 and p2 to default values.
     */
    sndcp_data->mg.req_xid_block[sapi_index].v42.p1 = SNDCP_V42_DEFAULT_P1;
    sndcp_data->mg.req_xid_block[sapi_index].v42.p1_set = TRUE;
    sndcp_data->mg.req_xid_block[sapi_index].v42.p2 =
      SNDCP_V42_DEFAULT_P2;
    sndcp_data->mg.req_xid_block[sapi_index].v42.p2_set = TRUE;
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.is_set =
  #ifdef SNDCP_UPM_INCLUDED
      (snsm_activate_ind->comp_params.dcomp != NAS_DCOMP_NEITHER_DIRECT);
  #else
      (snsm_activate_ind->dcomp != SNSM_COMP_NEITHER_DIRECT);
  #endif /*#ifdef SNDCP_UPM_INCLUDED*/
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p_bit = SNDCP_P_BIT_1;
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.ntt = SNDCP_NTT_0;
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.algo_type = SNDCP_XID_V42;
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.dcomp = SNDCP_DCOMP1;
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.nsapis =
      1 << (snsm_activate_ind->nsapi);
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.nsapis_set = TRUE;
  #ifdef SNDCP_UPM_INCLUDED
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p0 = snsm_activate_ind->comp_params.dcomp;
  #else
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p0 = snsm_activate_ind->dcomp;
  #endif /*#ifdef SNDCP_UPM_INCLUDED*/
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p0_set = TRUE;

    /*
     * Set p1 and p2 to default values.
     */
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p1 = SNDCP_V42_DEFAULT_P1;
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p1_set = TRUE;
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p2 =
      SNDCP_V42_DEFAULT_P2;
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p2_set = TRUE;

    /*
     * Set affected entities and dcomp/pcomp values.
     */
    mg_set_ntt_comp(snsm_activate_ind->sapi);


#else /* !TI_PS_FF_V42BIS */

    sndcp_data->mg.req_xid_block[sapi_index].v42.is_set = FALSE;

    sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis = 0;

    sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis_set = FALSE;
    sndcp_data->mg.req_xid_block[sapi_index].v42.p0_set = FALSE;

    /*
     * Set p1 and p2 to default values.
     */
    sndcp_data->mg.req_xid_block[sapi_index].v42.p1 = SNDCP_V42_DEFAULT_P1;
    sndcp_data->mg.req_xid_block[sapi_index].v42.p1_set = TRUE;
    sndcp_data->mg.req_xid_block[sapi_index].v42.p2 =
      SNDCP_V42_DEFAULT_P2;
    sndcp_data->mg.req_xid_block[sapi_index].v42.p2_set = TRUE;

#endif /* TI_PS_FF_V42BIS */

  /*
   * Set the Van Jacobson parameters.
   * Note:
   * If number of state slots is set to 0, do not request VJ in XID request.
   */
#ifdef SNDCP_UPM_INCLUDED
  if (snsm_activate_ind->comp_params.msid == 0) {
#else
  if (snsm_activate_ind->msid == 0) {
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
    sndcp_data->mg.req_xid_block[sapi_index].vj.is_set = FALSE;
    return;
  }

  sndcp_data->mg.req_xid_block[sapi_index].vj.is_set =
  #ifdef SNDCP_UPM_INCLUDED 
    (snsm_activate_ind->comp_params.hcomp != NAS_HCOMP_OFF);
  #else
    (snsm_activate_ind->hcomp != SNSM_COMP_NEITHER_DIRECT);
  #endif  /*#ifdef SNDCP_UPM_INCLUDED*/
  if (!sndcp_data->mg.req_xid_block[sapi_index].vj.is_set) {
    return;
  }
  /*
   * This function will only be called after snsm_activate_ind. So the
   * user_xid_block will be set for the affected nsapi.
   */
  if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) {
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.p_bit = 
      SNDCP_P_BIT_0;
  } else {
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.p_bit = 
      SNDCP_P_BIT_1;
  }
    
  sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.ntt = 
    SNDCP_NTT_0;
  sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.algo_type = 
    SNDCP_XID_VJ;
  sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.pcomp1 = 
    SNDCP_PCOMP1;
  sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.pcomp2 = 
    SNDCP_PCOMP2;
  sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.nsapis +=
    1 << (snsm_activate_ind->nsapi);
  sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.nsapis_set = TRUE;
#ifdef SNDCP_UPM_INCLUDED
  if (snsm_activate_ind->comp_params.msid > SNDCP_MAX_NUMBER_OF_VJ_SLOTS) { 
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1 = 
      SNDCP_MAX_NUMBER_OF_VJ_SLOTS - 1;
  } else {
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1 = 
      snsm_activate_ind->comp_params.msid - 1;
  }
#else
  if (snsm_activate_ind->msid > SNDCP_MAX_NUMBER_OF_VJ_SLOTS) {
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1 =
      SNDCP_MAX_NUMBER_OF_VJ_SLOTS - 1;
  } else {
    sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1 =
      snsm_activate_ind->msid - 1;
  }
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
  sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1_set = TRUE;
  /*
   * Only used internally, not in XID block.
   */
#ifdef SNDCP_UPM_INCLUDED
  sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.direction = 
    snsm_activate_ind->comp_params.hcomp;
#else
   sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.direction = 
   snsm_activate_ind->hcomp;
#endif /*#ifdef SNDCP_UPM_INCLUDED*/

  /*
   * Set affected entities and dcomp/pcomp values.
   */
  mg_set_ntt_comp(snsm_activate_ind->sapi);

  mg_detect_mode_clash ((USHORT)
                         (sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis +
                         (1 << (snsm_activate_ind->nsapi))),
                        &vio);
  if (vio) {
    return;
  }

  if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) {
    sndcp_data->mg.req_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_0;
  } else {
    sndcp_data->mg.req_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_1;
  }
  sndcp_data->mg.req_xid_block[sapi_index].vj.ntt = SNDCP_NTT_0;
  sndcp_data->mg.req_xid_block[sapi_index].vj.algo_type = SNDCP_XID_VJ;
  sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp1 = SNDCP_PCOMP1;
  sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp2 = SNDCP_PCOMP2;

  /*
   * All the nsapis that currently use the compressor and the new one
   * shall be set in the nsapis field of the XID block.
   */
  sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis = 
    (sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis | 
     (1 << (snsm_activate_ind->nsapi)));

  sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis_set = TRUE;
#ifdef SNDCP_UPM_INCLUDED
  if (snsm_activate_ind->comp_params.msid > SNDCP_MAX_NUMBER_OF_VJ_SLOTS) { 
    sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1 = 
      SNDCP_MAX_NUMBER_OF_VJ_SLOTS - 1;
  } else {
    sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1 = 
      snsm_activate_ind->comp_params.msid - 1;
  }
#else
  if (snsm_activate_ind->msid > SNDCP_MAX_NUMBER_OF_VJ_SLOTS) {
    sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1 =
      SNDCP_MAX_NUMBER_OF_VJ_SLOTS - 1;
  } else {
    sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1 =
      snsm_activate_ind->msid - 1;
  }
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
  sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1_set = TRUE;
  /*
   * Only used internally, not in XID block.
   */
#ifdef SNDCP_UPM_INCLUDED
  sndcp_data->mg.req_xid_block[sapi_index].vj.direction = 
    snsm_activate_ind->comp_params.hcomp;
#else
  sndcp_data->mg.req_xid_block[sapi_index].vj.direction = 
    snsm_activate_ind->hcomp;
#endif /*#ifdef SNDCP_UPM_INCLUDED*/
  /*
   * Set affected entities and dcomp/pcomp values.
   */
  mg_set_ntt_comp(snsm_activate_ind->sapi);

} /* mg_set_req_xid_block() */


/*
+------------------------------------------------------------------------------
| Function    : mg_set_res_cur_xid_block
+------------------------------------------------------------------------------
| Description : This procedure sets the service variables res_xid_block and
| cur_xid_block. The needed data comes from the service variable ind_xid_block,
| and from default settings.
| Note: if the indicated compressors do not match with compressors requested
| or currently used then they will be unset by adding them to the list of
| rejected compressors.
|
|
| Parameters  :
|               the affected sapi,
|               the necessary bit length of an sdu that will later store the
|               xid block derived from res_xid_block.
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_set_res_cur_xid_block (UBYTE sapi, USHORT* res_sdu_bit_len)
{
  UBYTE sapi_index = 0;
  UBYTE nsapi = 0;
  /*
   * Which compressors are indicated?
   */
  BOOL v42_ind, vj_ind;
  /*
   * Which compressors are possible?
   * (The indicated set of nsapis must overlap with the
   * currently used one.)
   */
  BOOL v42_possible, vj_possible;
  /*
   * Is compressor going to rejected? In this case the compressor should not
   * be requested.
   */
  BOOL v42_rejected, vj_rejected;

  TRACE_FUNCTION( "mg_set_res_cur_xid_block" );

  sndcp_get_sapi_index(sapi, &sapi_index);
  sndcp_reset_xid_block(&(sndcp_data->mg.res_xid_block[sapi_index]));

  /*
   * Set bit length to "only version", 3 bytes.
   */
  *res_sdu_bit_len = 24;
  /*
   * Set the version number.
   */
  sndcp_data->mg.res_xid_block[sapi_index].version = SNDCP_XID_VERSION;

  v42_ind = sndcp_data->mg.ind_xid_block[sapi_index].v42.is_set;
  v42_possible = FALSE;
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    if ((sndcp_data->mg.user_xid_block[nsapi].v42.nsapis & 
        sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0) {

      U8 local_sapi = 0;
      sndcp_get_nsapi_sapi(nsapi, &local_sapi);
      if (local_sapi == sapi) {
        v42_possible = TRUE;
      }
    }
  }


  if (v42_ind && ! v42_possible) {
    sndcp_data->mg.res_xid_block[sapi_index].v42.is_set = FALSE;
    mg_set_sapi_dntt_rej (sapi,
                          sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt,
                          TRUE);
  }

  mg_get_sapi_dntt_rej (sapi,
                        sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt,
                        &v42_rejected);


  if (v42_ind && ! v42_rejected) {
    /*
     * Data compression will be included, increment bit len (+ 10 bytes).
     */
    *res_sdu_bit_len += 80;

    /*
     * Set the V42.bis parameters,
     */
    sndcp_data->mg.res_xid_block[sapi_index].v42.is_set = TRUE;

    sndcp_data->mg.res_xid_block[sapi_index].v42.p_bit = SNDCP_P_BIT_0;

    sndcp_data->mg.res_xid_block[sapi_index].v42.ntt =
      sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt;


    sndcp_data->mg.res_xid_block[sapi_index].v42.algo_type = SNDCP_XID_V42;

    sndcp_data->mg.res_xid_block[sapi_index].v42.dcomp =
      sndcp_data->mg.ind_xid_block[sapi_index].v42.dcomp;

    /*
     * Set the 'nsapis' parameter in res_xid_block:
     * Check rules in 4.65, subclause 6.8.1, compare with cur_xid_block.
     */
    mg_set_xid_nsapis(sapi, MG_XID_V42_NSAPIS);

    /*
     * It is assumed that the values desired by the user / the
     * values possible with the current implementation are written in
     * req_xid_block, the responded values are then the minimum of
     * req and ind values:
     */
    /*
     * For the direction parameter p0 take the logical AND:
     */
    sndcp_data->mg.res_xid_block[sapi_index].v42.p0 =
      (sndcp_data->mg.req_xid_block[sapi_index].v42.p0 &
       sndcp_data->mg.ind_xid_block[sapi_index].v42.p0);
    sndcp_data->mg.res_xid_block[sapi_index].v42.p0_set = TRUE;

    /*
     * For p1 and p2 take minimum.
     */
    sndcp_data->mg.res_xid_block[sapi_index].v42.p1 =
      (sndcp_data->mg.req_xid_block[sapi_index].v42.p1 <
       sndcp_data->mg.ind_xid_block[sapi_index].v42.p1)?
       sndcp_data->mg.req_xid_block[sapi_index].v42.p1 :
        sndcp_data->mg.ind_xid_block[sapi_index].v42.p1;
    sndcp_data->mg.res_xid_block[sapi_index].v42.p1_set = TRUE;

    sndcp_data->mg.res_xid_block[sapi_index].v42.p2 =
      (sndcp_data->mg.req_xid_block[sapi_index].v42.p2 <
       sndcp_data->mg.ind_xid_block[sapi_index].v42.p2)?
       sndcp_data->mg.req_xid_block[sapi_index].v42.p2 :
        sndcp_data->mg.ind_xid_block[sapi_index].v42.p2;
    sndcp_data->mg.res_xid_block[sapi_index].v42.p2_set = TRUE;

  } /* v42.is_set */


  /*
   * Header compression,
   */

  
  vj_ind = sndcp_data->mg.ind_xid_block[sapi_index].vj.is_set;
  vj_possible = FALSE;
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    if ((sndcp_data->mg.user_xid_block[nsapi].vj.nsapis & 
        sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis) > 0) {

      U8 local_sapi = 0;
      sndcp_get_nsapi_sapi(nsapi, &local_sapi);
      if (local_sapi == sapi) {
        vj_possible = TRUE;
      }
    }
  }

  if (vj_ind && ! vj_possible) {
    sndcp_data->mg.res_xid_block[sapi_index].vj.is_set = FALSE;
    mg_set_sapi_pntt_rej (sapi,
                          sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt,
                          TRUE);
  }

  mg_get_sapi_pntt_rej (sapi,
                        sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt,
                        &vj_rejected);

  if (vj_ind && ! vj_rejected) {
    /*
     * Header compression will be included, increment bit len (+ 7 bytes).
     */
    *res_sdu_bit_len += 56;

    /*
     * Set the VJ parameters,
     */
    sndcp_data->mg.res_xid_block[sapi_index].vj.is_set = TRUE;

    sndcp_data->mg.res_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_0;

    sndcp_data->mg.res_xid_block[sapi_index].vj.ntt =
      sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt;

    sndcp_data->mg.res_xid_block[sapi_index].vj.algo_type = SNDCP_XID_VJ;

    if (sndcp_data->mg.ind_xid_block[sapi_index].vj.p_bit == SNDCP_P_BIT_1) {
      sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1 =
        sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1;
      sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2 =
        sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp2;
    } else {
      sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1 =
        sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp1;
      sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2 =
        sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp2;
    }

    /*
     * Set the 'nsapis' parameter in res_xid_block:
     * Check rules in 4.65, subclause 6.8.1, compare with cur_xid_block.
     * State slots and direction are also set here.
     */
    mg_set_xid_nsapis(sapi, MG_XID_VJ_NSAPIS);


  } /* vj.is_set */


  /*
   * Set affected entities and dcomp/pcomp values.
   */
  if (v42_ind && v42_possible) {
    mg_set_sapi_dntt_state(sapi,
                           sndcp_data->mg.res_xid_block[sapi_index].v42.ntt,
                           MG_ASSIGNED);

    mg_set_sapi_dcomp_state(sapi,
                            sndcp_data->mg.res_xid_block[sapi_index].v42.dcomp,
                            MG_ASSIGNED);
    mg_set_sapi_dcomp_dntt(sapi,
                           sndcp_data->mg.res_xid_block[sapi_index].v42.dcomp,
                           sndcp_data->mg.res_xid_block[sapi_index].v42.ntt);
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if (((1 << nsapi) & sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0) {
        mg_set_sapi_dntt_nsapi(sapi,
                              sndcp_data->mg.res_xid_block[sapi_index].v42.ntt,
                               nsapi,
                               TRUE);
      } /* if nsapi is selected */
    } /* for loop over all nsapis */

  }
  /*
   * If VJ is indicated and possible, switch on compressor.
   */
  if (vj_ind && vj_possible) {
    mg_set_sapi_pntt_state(sapi,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.ntt,
                           MG_ASSIGNED);
    mg_set_sapi_pcomp_state(sapi,
                            sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1,
                            MG_ASSIGNED);
    mg_set_sapi_pcomp_state(sapi,
                            sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2,
                            MG_ASSIGNED);
    mg_set_sapi_pcomp_pntt(sapi,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.ntt);
    mg_set_sapi_pcomp_pntt(sapi,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.ntt);
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if (((1 << nsapi) & sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0) {
        mg_set_sapi_pntt_nsapi(sapi,
                             sndcp_data->mg.res_xid_block[sapi_index].vj.ntt,
                             nsapi,
                             TRUE);
      } /* if nsapi is selected */
    } /* for loop over all nsapis */
  }

  /*
   * If VJ has been switched on and is now indicated to be switched off:
   * switch off compressor.
   */
  if (vj_ind
      &&
      sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis == 0
      &&
      sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis > 0)
  {
    mg_set_sapi_pntt_state(sapi,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.ntt,
                           MG_UNASSIGNED);
    mg_set_sapi_pcomp_state(sapi,
                            sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1,
                            MG_UNASSIGNED);
    mg_set_sapi_pcomp_state(sapi,
                            sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2,
                            MG_UNASSIGNED);
/*    mg_set_sapi_pcomp_pntt(sapi,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.ntt);
    mg_set_sapi_pcomp_pntt(sapi,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2,
                           sndcp_data->mg.res_xid_block[sapi_index].vj.ntt);
*/
    for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
      if (((1 << nsapi) & sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0) {
        mg_set_sapi_pntt_nsapi(sapi,
                             sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt,
                             nsapi,
                             FALSE);
      } /* if nsapi is selected */
    } /* for loop over all nsapis */
  }


  /*
   * Add same values for cur_xid_block.
   */

  if (sndcp_data->mg.res_xid_block[sapi_index].v42.is_set) {
    if (sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set) {
      sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis =
        sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis;
      if (sndcp_data->mg.cur_xid_block[sapi_index].v42.p0_set) {
        sndcp_data->mg.cur_xid_block[sapi_index].v42.p0 =
          sndcp_data->mg.res_xid_block[sapi_index].v42.p0;
      }
      if (sndcp_data->mg.cur_xid_block[sapi_index].v42.p1_set) {
        sndcp_data->mg.cur_xid_block[sapi_index].v42.p1 =
          sndcp_data->mg.res_xid_block[sapi_index].v42.p1;
      }
      if (sndcp_data->mg.cur_xid_block[sapi_index].v42.p2_set) {
        sndcp_data->mg.cur_xid_block[sapi_index].v42.p2 =
          sndcp_data->mg.res_xid_block[sapi_index].v42.p2;
      }
    } else {
      sndcp_data->mg.cur_xid_block[sapi_index].v42 =
        sndcp_data->mg.res_xid_block[sapi_index].v42;
    }
  }

  if (sndcp_data->mg.res_xid_block[sapi_index].vj.is_set) {
    if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) {
      sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis =
        sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis;
      if (sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1_set) {
        sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1 =
          sndcp_data->mg.res_xid_block[sapi_index].vj.s0_m_1;
      }
    } else {
      sndcp_data->mg.cur_xid_block[sapi_index].vj =
        sndcp_data->mg.res_xid_block[sapi_index].vj;
    }
  }


  if (vj_rejected) {
    sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis = 0;
  }
  if (sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis == 0) {
    sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set = FALSE;
  }

  if (v42_rejected) {
    sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis = 0;
  }
  if (sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis == 0) {
    sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set = FALSE;
  }

  sig_mg_cia_new_xid(& sndcp_data->mg.cur_xid_block[sapi_index]);


} /* mg_set_res_cur_xid_block */

/*
+------------------------------------------------------------------------------
| Function    : mg_set_res_xid_params
+------------------------------------------------------------------------------
| Description : This procedure fills the XID block. It is implementation
|               dependent. In the current version V42bis and VanJacobson
|               header compression are applied.
|
| Parameters  :
|               the sdu that will be filled,
| Post        : Reset arrays with reject information to all FALSE.
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_set_res_xid_params (T_sdu* sdu, UBYTE sapi)
{
  /*
   * Byte index in destination sdu.
   */
  UBYTE index = 3;
  UBYTE type_2_header_index = 0;
  UBYTE sapi_index = 0;
  UBYTE ntt = 0;
  BOOL type_1_header_set = FALSE;
  BOOL type_2_header_set = FALSE;
  TRACE_FUNCTION( "mg_set_res_xid_params" );
  sndcp_get_sapi_index(sapi, &sapi_index);
  /*
   * Set the values for parameter type 0 (version number).
   */
  sdu->buf[0] = SNDCP_XID_PARAM_TYPE_0;
  /*lint -e{415} (Warning -- access of out-of-bounds pointer)*/
  sdu->buf[1] = SNDCP_XID_0_LEN;
  /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/
  sdu->buf[2] =
    sndcp_data->mg.res_xid_block[sapi_index].version;

  sdu->l_buf = 3 * 8;
  sdu->o_buf = 0;
  /*
   * Set the values for data compression, if necessary.
   */
  /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/
  if (sndcp_data->mg.res_xid_block[sapi_index].v42.is_set) {
    sdu->buf[3] = SNDCP_XID_PARAM_TYPE_1;
    sdu->buf[4] = SNDCP_XID_1_LEN_RES;
    sdu->buf[5] =
      (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.p_bit << 7) +
            sndcp_data->mg.res_xid_block[sapi_index].v42.ntt;
    sdu->buf[6] = SNDCP_XID_V42_LEN_RES;
    sdu->buf[7] =
      (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis >> 8);
    sdu->buf[8] =
      (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis & 0xff);
    sdu->buf[9] = sndcp_data->mg.res_xid_block[sapi_index].v42.p0;
    sdu->buf[10] =
      (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.p1 >> 8);
    sdu->buf[11] =
      (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.p1 & 0xff);
    sdu->buf[12] = sndcp_data->mg.res_xid_block[sapi_index].v42.p2;

    index = 13;
    sdu->l_buf = 13 * 8;

    type_1_header_set = TRUE;
  }
  /*
   * Add rejected data compression entities.
   */
  for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
    BOOL rej = FALSE;
    mg_get_sapi_dntt_rej(sapi, ntt, &rej);
    /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/
    if (rej) {
      if (! type_1_header_set) {
        sdu->buf[index] = SNDCP_XID_PARAM_TYPE_1;
        index++;
        sdu->buf[index] = 0;
        index++;
        type_1_header_set = TRUE;
        sdu->l_buf += 16;
      }

      sdu->buf[index] = ntt;
      index++;
      /*
       * Length of field.
       */
      sdu->buf[index] = 2;
      index++;
      /*
       * Set 2 'nsapis' octets to 0.
       */
      sdu->buf[index] = 0;
      index++;
      sdu->buf[index] = 0;
      index++;
      /*
       * Increment sdu length.
       */
      sdu->l_buf = sdu->l_buf + 32;
      /*
       * Increment parameter type 1 length octet.
       */
       /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/
      sdu->buf[4] += 4;
    }
  }
  type_2_header_index = index;

  /*
   * Set the values for header compression, if requested.
   */
   /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/
  if (sndcp_data->mg.res_xid_block[sapi_index].vj.is_set) {
    sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2;
    index++;
    sdu->buf[index] = SNDCP_XID_2_LEN_RES;
    index++;
    sdu->buf[index] =
      (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].vj.p_bit << 7) +
       sndcp_data->mg.res_xid_block[sapi_index].vj.ntt;
    index++;
    sdu->buf[index] = SNDCP_XID_VJ_LEN_RES;
    index++;
    sdu->buf[index] =
      (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis >> 8);
    index++;
    sdu->buf[index] =
      (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis & 0xff);
    index++;
    sdu->buf[index] =
      sndcp_data->mg.res_xid_block[sapi_index].vj.s0_m_1;
    index++;

    sdu->l_buf = sdu->l_buf + 7 * 8;

    type_2_header_set = TRUE;
  }
  /*
   * Add rejected header compression entities.
   */
   /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/
  for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
    BOOL rej = FALSE;
    mg_get_sapi_pntt_rej(sapi, ntt, &rej);
    if (rej) {
      if (! type_2_header_set) {
        sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2;
        index++;
        sdu->buf[index] = 0;
        index++;
        type_2_header_set = TRUE;
        sdu->l_buf += 16;
      }
      sdu->buf[index] = ntt;
      index++;
      /*
       * Length of field.
       */
      sdu->buf[index] = 2;
      index++;
      /*
       * Set 2 'nsapis' octets to 0.
       */
      sdu->buf[index] = 0;
      index++;
      sdu->buf[index] = 0;
      index++;
      /*
       * Increment sdu length.
       */
      sdu->l_buf = sdu->l_buf + 32;
      /*
       * Increment parameter type 2 length octet.
       */
      sdu->buf[type_2_header_index + 1] += 4;
    }
  }
  /*
   * Set sdu offset to 0.
   */
  sdu->o_buf = 0;
  /*
   * Reset the arrays with rejected params to all FALSE.
   */
  for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
    sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][ntt] = FALSE;
    sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][ntt] = FALSE;
  }

} /* mg_set_res_xid_params() */


/*
+------------------------------------------------------------------------------
| Function    : mg_set_xid_params
+------------------------------------------------------------------------------
| Description : This procedure fills the XID block. It is implementation
|               dependent. In the current version V42bis and VanJacobson
|               header compression are applied.
|
| Parameters  :
|               sapi and sdu from the LL_XID_REQ that will be filled and
|               xid_block that defines the desired compressors
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_set_xid_params (UBYTE sapi, T_sdu* sdu, T_XID_BLOCK xid_block)
{
  /*
   * Byte index in destination sdu.
   */
  UBYTE index = 3;
  UBYTE sapi_index = 0;
  UBYTE ntt = 0;
  BOOL type_1_header_set = FALSE;
  BOOL type_2_header_set = FALSE;
  UBYTE type_2_header_index = 0;
  UBYTE type_1_header_index = 3;
  USHORT p1 = SNDCP_V42_DEFAULT_P1;
  TRACE_FUNCTION( "mg_set_xid_params" );
  sndcp_get_sapi_index(sapi, &sapi_index);
  /*
   * Set the values for parameter type 0 (version number).
   */
  sdu->buf[0] = SNDCP_XID_PARAM_TYPE_0;
  /*lint -e{415} (Warning -- access of out-of-bounds pointer)*/
  sdu->buf[1] = SNDCP_XID_0_LEN;
  /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/
  sdu->buf[2] = SNDCP_XID_VERSION;

  sdu->l_buf = 24; /* 3 * 8 */
  sdu->o_buf = 0;
  /*
   * Set the values for data compression, if necessary.
   */
   /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/
  if (xid_block.v42.is_set &&
      #ifdef SNDCP_UPM_INCLUDED 
       xid_block.v42.p0 != NAS_DCOMP_OFF &&
      #else
       xid_block.v42.p0 != SNSM_COMP_NEITHER_DIRECT &&
      #endif  /*#ifdef SNDCP_UPM_INCLUDED*/
      xid_block.v42.nsapis_set &&
      xid_block.v42.nsapis > 0) {

    if (xid_block.v42.p_bit > 0) {
      sdu->buf[3] = SNDCP_XID_PARAM_TYPE_1;
      sdu->buf[4] = SNDCP_XID_1_LEN;
      sdu->buf[5] = (UBYTE)(xid_block.v42.p_bit << 7) + xid_block.v42.ntt;
      sdu->buf[6] = xid_block.v42.algo_type;
      sdu->buf[7] = SNDCP_XID_V42_LEN;
      sdu->buf[8] = (UBYTE)(xid_block.v42.dcomp << 4);
      sdu->buf[9] = (UBYTE)(xid_block.v42.nsapis >> 8);
      sdu->buf[10] = (UBYTE)(xid_block.v42.nsapis & 0xff);
      sdu->buf[11] = xid_block.v42.p0;
      /*
       * P1, P2
       */
      sdu->buf[12] = (p1 & 0xff00) >> 8;
      sdu->buf[13] = p1 & 0x00ff;
      sdu->buf[14] = SNDCP_V42_DEFAULT_P2;

      index = 15;
      sdu->l_buf = 15 * 8;
    } else {
      sdu->buf[3] = SNDCP_XID_PARAM_TYPE_1;
      sdu->buf[4] = SNDCP_XID_1_LEN_RES;
      sdu->buf[5] = xid_block.v42.ntt;
      sdu->buf[6] = SNDCP_XID_V42_LEN_RES;
      sdu->buf[7] = (UBYTE)(xid_block.v42.nsapis >> 8);
      sdu->buf[8] = (UBYTE)(xid_block.v42.nsapis & 0xff);
      sdu->buf[9] = xid_block.v42.p0;
      /*
       * P1, P2
       */
      sdu->buf[10] = (p1 & 0xff00) >> 8;
      sdu->buf[11] = p1 & 0x00ff;
      sdu->buf[12] = SNDCP_V42_DEFAULT_P2;

      index = 13;
      sdu->l_buf = 13 * 8;

    }
  }
  type_2_header_index = index;
  /*
   * Set the values for header compression, if requested.
   */
   /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/
  if (xid_block.vj.is_set &&
      #ifdef SNDCP_UPM_INCLUDED
       xid_block.vj.direction != NAS_HCOMP_OFF &&
      #else
       xid_block.vj.direction != SNSM_COMP_NEITHER_DIRECT &&
      #endif  /*#ifdef SNDCP_UPM_INCLUDED*/
      xid_block.vj.nsapis_set &&
      xid_block.vj.nsapis > 0) {

    if (xid_block.vj.p_bit > 0) {

      sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2;
      sdu->buf[index + 1] = SNDCP_XID_2_LEN;
      sdu->buf[index + 2] =
        (UBYTE)(xid_block.vj.p_bit << 7) + xid_block.vj.ntt;
      sdu->buf[index + 3] = SNDCP_XID_VJ;
      sdu->buf[index + 4] = SNDCP_XID_VJ_LEN;
      sdu->buf[index + 5] =
        (UBYTE)(xid_block.vj.pcomp1 << 4) + xid_block.vj.pcomp2;
      sdu->buf[index + 6] =
        (UBYTE)(xid_block.vj.nsapis >> 8);
      sdu->buf[index + 7] =
        (UBYTE)(xid_block.vj.nsapis & 0xff);
      sdu->buf[index + 8] = xid_block.vj.s0_m_1;

      sdu->l_buf = sdu->l_buf + 9 * 8;

      type_2_header_set = TRUE;
    } else {
      sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2;
      sdu->buf[index + 1] = SNDCP_XID_2_LEN_RES;
      sdu->buf[index + 2] = xid_block.vj.ntt;

      sdu->buf[index + 3] = SNDCP_XID_VJ_LEN_RES;

      sdu->buf[index + 4] =
        (UBYTE)(xid_block.vj.nsapis >> 8);
      sdu->buf[index + 5] =
        (UBYTE)(xid_block.vj.nsapis & 0xff);
      sdu->buf[index + 6] = xid_block.vj.s0_m_1;

      sdu->l_buf = sdu->l_buf + 7 * 8;

      type_2_header_set = TRUE;
    }
  }
  /*
   * Add rejected data compression entities.
   */
   /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/
  for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
    BOOL rej = FALSE;
    mg_get_sapi_dntt_rej(sapi, ntt, &rej);
    if (rej) {
      if (! type_1_header_set) {
        sdu->buf[index] = SNDCP_XID_PARAM_TYPE_1;
        index++;
        sdu->buf[index] = 0;
        index++;
        type_1_header_set = TRUE;
        sdu->l_buf += 16;
      }
      sdu->buf[index] = ntt;
      index++;
      /*
       * Length of field.
       */
      sdu->buf[index] = 2;
      index++;
      /*
       * Set 2 'nsapis' octets to 0.
       */
      sdu->buf[index] = 0;
      index++;
      sdu->buf[index] = 0;
      index++;
      /*
       * Increment sdu length.
       */
      sdu->l_buf = sdu->l_buf + 32;
      /*
       * Increment parameter type 2 length octet.
       */
       /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/
      sdu->buf[type_1_header_index + 1] += 4;
    }
  } /* for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++)  */
  /*
   * Add rejected header compression entities.
   */
   /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/
  for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
    BOOL rej = FALSE;
    mg_get_sapi_pntt_rej(sapi, ntt, &rej);
    if (rej) {
      if (! type_2_header_set) {
        sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2;
        index++;
        sdu->buf[index] = 0;
        index++;
        type_2_header_set = TRUE;
        sdu->l_buf += 16;
      }
      sdu->buf[index] = ntt;
      index++;
      /*
       * Length of field.
       */
      sdu->buf[index] = 2;
      index++;
      /*
       * Set 2 'nsapis' octets to 0.
       */
      sdu->buf[index] = 0;
      index++;
      sdu->buf[index] = 0;
      index++;
      /*
       * Increment sdu length.
       */
      sdu->l_buf = sdu->l_buf + 32;
      /*
       * Increment parameter type 2 length octet.
       */
      sdu->buf[type_2_header_index + 1] += 4;
    }
  } /* for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++)  */
  /*
   * Set sdu offset to 0.
   */
  sdu->o_buf = 0;
  /*
   * Reset the arrays with rejected params to all FALSE.
   */
  for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) {
    sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][ntt] = FALSE;
    sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][ntt] = FALSE;
  }

} /* mg_set_xid_params() */



/*
+------------------------------------------------------------------------------
| Function    : mg_del_comp_pdus_ack
+------------------------------------------------------------------------------
| Description : The function mg_del_comp_pdus_ack()
|               GSM 4.65, 5.1.2.7:
|               "compressed N-PDUs queuing to be forwarded to the affected
|               SAPI are deleted from the SNDCP layer."
|               Assumption: It is assumed here that acknowledged and
|               unacknowledged npdus are deleted the same.
|
| Parameters  : UBYTE sapi: the affected sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_del_comp_pdus_ack (UBYTE sapi)
{
  UBYTE nsapi = 0;

  TRACE_FUNCTION( "mg_del_comp_pdus_ack" );

  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    UBYTE sp = 0;
    sndcp_get_nsapi_sapi(nsapi, &sp);
    if (sp == sapi) {
      sig_mg_cia_delete_npdus(nsapi);
      sig_mg_su_delete_pdus(nsapi, sapi);
      sig_mg_sua_delete_pdus(nsapi, sapi, TRUE);
      sig_mg_sd_delete_npdus(nsapi, sapi);
      sig_mg_sda_delete_npdus(nsapi, sapi);
    }
  }
} /* mg_del_comp_pdus_ack() */

/*
+------------------------------------------------------------------------------
| Function    : mg_delete_npdus
+------------------------------------------------------------------------------
| Description : The function mg_delete_npdus() sends signals to all affected
|               services to delete the buffered npdus.
|
| Parameters  : UBYTE nsapi: the affected nsapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_delete_npdus (UBYTE nsapi)
{
  UBYTE sapi = 0;
  TRACE_FUNCTION( "mg_delete_npdus" );
  sndcp_get_nsapi_sapi(nsapi, &sapi);

  sig_mg_cia_delete_npdus(nsapi);
  sig_mg_su_delete_pdus(nsapi, sapi);
  sig_mg_sua_delete_pdus(nsapi, sapi, TRUE);
  sig_mg_sd_delete_npdus(nsapi, sapi);
  sig_mg_sda_delete_npdus(nsapi, sapi);

  sig_mg_nu_delete_npdus(nsapi);

} /* mg_delete_npdus() */


/*
+------------------------------------------------------------------------------
| Function    : mg_suspend_affected_nus
+------------------------------------------------------------------------------
| Description : Suspends all nu service instances affected by XID negotiation
|               Sets service variable 'suspended_nsapis'.
|
| Parameters  : sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_suspend_affected_nus (UBYTE sapi) {
  UBYTE nsapi = 0;
  UBYTE sapi_index = 0;
  TRACE_FUNCTION( "mg_resume_affected_nus" );
  sndcp_get_sapi_index(sapi, &sapi_index);
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    if (1 << nsapi & sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis ||
        1 << nsapi & sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis ||
        1 << nsapi & sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis ||
        1 << nsapi & sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis) {

      sndcp_data->mg.suspended_nsapis |= (1 << nsapi);
      sig_mg_nu_suspend(nsapi);
    }
  }
} /* mg_suspend_affected_nus() */






/*
 * Getters and setters for the organizing arrays.
 */
/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_dntt_rej
+------------------------------------------------------------------------------
| Description : The procedures informs about if a given data
|               compression entity on a given SAPI is to be rejected in
|               LL_XID_REQ because it cannot be set up.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN dntt UBYTE,
|               IN/OUT rej BOOL
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_get_sapi_dntt_rej (UBYTE sapi, UBYTE dntt, BOOL* rej)
{
  TRACE_FUNCTION( "mg_get_sapi_dntt_rej" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *rej = sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][dntt];
  }
} /* mg_get_sapi_dntt_rej() */

/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_pntt_rej
+------------------------------------------------------------------------------
| Description : The procedures informs about if a given header
|               compression entity on a given SAPI is to be rejected in
|               LL_XID_REQ because it cannot be set up.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pntt UBYTE,
|               IN/OUT rej BOOL
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_get_sapi_pntt_rej (UBYTE sapi, UBYTE pntt, BOOL* rej)
{
  TRACE_FUNCTION( "mg_get_sapi_pntt_rej" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *rej = sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][pntt];
  }
} /* mg_get_sapi_pntt_rej() */




/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_pntt_nsapi
+------------------------------------------------------------------------------
| Description : The procedure informs if a given nsapi uses a given pntt on a
|               given sapi.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pntt UBYTE,
|               IN nsapi UBYTE,
|               IN/OUT used BOOL
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_get_sapi_pntt_nsapi (UBYTE sapi, UBYTE pntt, UBYTE nsapi, BOOL* used)
{
  TRACE_FUNCTION( "mg_get_sapi_pntt_nsapi" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *used = sndcp_data->mg.sapi_pntt_nsapi_set_ra[sapi_index][pntt][nsapi];
  }
} /* mg_get_sapi_pntt_nsapi() */




/*
+------------------------------------------------------------------------------
| Function    : mg_get_sapi_pcomp_pntt
+------------------------------------------------------------------------------
| Description : The procedures indicates the pntt assigned to a given pcomp
|               for a given sapi.
|
| Parameters  : FPAR IN sapi UBYTE,
|               IN pcomp UBYTE,
|               IN/OUT dntt UBYTE
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_get_sapi_pcomp_pntt (UBYTE sapi, UBYTE pcomp, UBYTE* pntt)
{
  TRACE_FUNCTION( "mg_get_sapi_pcomp_pntt" );
  {
    UBYTE sapi_index = 0;
    sndcp_get_sapi_index(sapi, &sapi_index);
    *pntt = sndcp_data->mg.sapi_pcomp_pntt_ra[sapi_index][pcomp];
  }
} /* mg_get_sapi_pcomp_pntt() */



/*
+------------------------------------------------------------------------------
| Function    : mg_xid_cnf_ok_res
+------------------------------------------------------------------------------
| Description :
| After an LL_XID_REQ has been sent there are contexts in state MG_XID.
| These are now reset after reception of the LL_XID_CNF.
| The "applicable nsapis" in req_xid_block.v42 and req_xid_block.vj, each one
| only once.
| SIG_MG_NU_RESET(nsapi, discard_ready) is used.
| In every nu instance: N-PDU number is set to 0 for this instance and an
| SN_UNITREADY_IND is sent. State is set to NU_UNACK_SU_RECEPTIVE
| Then the SNSM_ACTIVATE_RES is sent for each one of these.
|
| Parameters  : affected sapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_xid_cnf_ok_res (UBYTE sapi)
{
  UBYTE nsapi = 0;

  TRACE_FUNCTION( "mg_xid_cnf_ok_res" );
  for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) {
    USHORT nsapi_state = MG_IDLE;
    USHORT sapi_state = MG_IDLE;
    UBYTE sapi_index = 0;
    UBYTE func_sapi = 0;
    sndcp_get_nsapi_sapi(nsapi, &func_sapi);
    if (func_sapi != sapi) {
      continue;
    }
    sndcp_get_sapi_index(sapi, &sapi_index);
    sndcp_get_nsapi_state(nsapi, &nsapi_state);
    sndcp_get_sapi_state(func_sapi, &sapi_state);


    if (((sapi_state & MG_XID_NEC) > 0)
        &&
        ((sapi_state & MG_REL) == 0)) {
      mg_resend_xid_if_nec(sapi);

      sndcp_get_sapi_state(func_sapi, &sapi_state);
      /*
       * If now XID is sent, no further actions for this nsapi.
       */
      if ((sapi_state & MG_XID) > 0) {
        continue;
      }

    } else if ((nsapi_state & MG_ACT) > 0 &&
        (sapi_state & MG_EST) == 0) {

      BOOL ack = FALSE;

      sndcp_get_nsapi_ack(nsapi, &ack);
      /*
       * Open DTI connection.
       */
#ifndef SNDCP_UPM_INCLUDED 
      mg_dti_open(nsapi);
#endif 
      if (ack) {
        sig_mg_nu_reset_ack(nsapi, 0, 0, FALSE);
        sig_mg_sda_getdata(sapi, nsapi);
      } else {
        sig_mg_nu_reset(nsapi, FALSE);
        sig_mg_sd_getunitdata(sapi, nsapi);
      }

      if ((sapi_state & MG_XID) == 0) {
        mg_send_snsm_activate_res(nsapi);
        /*
         * Set nsapi state to MG_IDLE.
         */
        sndcp_unset_nsapi_state(nsapi, MG_ACT);
      }
    } /* if state is MG_ACT and not MG_EST  */

    if ((nsapi_state & MG_DEACT) > 0) {

      USHORT local_sapi_state = MG_IDLE;

      sndcp_get_sapi_state(sapi, &local_sapi_state);

      if ((local_sapi_state &
            (MG_REL_NEC_LOC + MG_REL_NEC_PEER + MG_XID_NEC + MG_XID))
          == 0)
      {
        /*
         * No LL_RELEASE_REQ necessary. Notify sndcp.
         */
#ifdef SNDCP_UPM_INCLUDED 
        PALLOC(snsm_deactivate_res, SN_DEACTIVATE_CNF);
#else
        PALLOC(snsm_deactivate_res, SNSM_DEACTIVATE_RES);
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
        /*
         * Now the NSAPI is not in use anymore:
         */
        sndcp_set_nsapi_used(nsapi, FALSE);
        sndcp_set_nsapi_ack(nsapi, FALSE);

        snsm_deactivate_res->nsapi = nsapi;
        sndcp_unset_nsapi_state(nsapi, MG_DEACT);
#ifdef SNDCP_UPM_INCLUDED 
        PSEND(hCommUPM, snsm_deactivate_res);
#else
        PSEND(hCommSM, snsm_deactivate_res);
#endif  /*#ifdef SNDCP_UPM_INCLUDED*/
        /*
         * Resume nsapi.
         */
        mg_resume_affected_nus(sapi);

      } else if ((local_sapi_state & (MG_REL_NEC_LOC + MG_REL_NEC_PEER)) > 0) {
        /*
         * LL_RELEASE_REQ must be sent.
         */

        PALLOC(ll_release_req, LL_RELEASE_REQ);

        sndcp_unset_sapi_state(sapi, MG_REL_NEC_LOC);
        ll_release_req->sapi = sapi;
        ll_release_req->local = TRUE;
        /*
         * Set the "state" for the affected and sapi to MG_REL_PENDING.
         */
        sndcp_set_sapi_state(sapi, MG_REL);

        PSEND(hCommLLC, ll_release_req);
      } else {

        UBYTE local_sapi = 0;
        UBYTE local_nsapi = 0;
        BOOL local_nec = FALSE;
        for (local_nsapi = 0;
             local_nsapi < SNDCP_NUMBER_OF_NSAPIS;
             local_nsapi++) {

          sndcp_get_nsapi_sapi(local_nsapi, &local_sapi);
          if (sapi == local_sapi) {
            /*
             * is compressor deactivation necessary?
             */
            sndcp_get_nsapi_state(local_nsapi, &nsapi_state);
            if ((nsapi_state & MG_DEACT) > 0) {
              mg_is_rel_comp_nec(local_nsapi, &local_nec);
            }
          }
        }

        /*
         * Negotiate possible deactivation of compressors.
         */
        if (local_nec) {
          mg_send_xid_req_del(sapi);
        }
      }

    }

  }

} /* mg_xid_cnf_ok_res */


#ifdef TI_DUAL_MODE
/*
+------------------------------------------------------------------------------
| Function    : mg_get_unsent_unconfirmed_npdus
+------------------------------------------------------------------------------
| Description : This procedure retrieves any unsent or unconfirmed acknowledged
|               NPDU from SNDCP's internal buffers. ANY retrieved NPDU is packed
|               the primitive SN_GET_PENDING_PDU_CNF data.
|
| Parameters  : nsapi, pointer to the primitive.
|
+------------------------------------------------------------------------------
*/
GLOBAL T_SN_GET_PENDING_PDU_CNF* mg_get_unsent_unconfirmed_npdus
                             (U8 nsapi, 
                              T_SN_GET_PENDING_PDU_CNF* sn_get_pending_pdu_cnf)
{

  int count = 0;
  U8 used_sapi=0, sapi_index=0;
  T_NPDU_BUFFER* help = NULL;

  TRACE_FUNCTION( "mg_get_unsent_unconfirmed_npdus" );

  /*
   * set service instance according to nsapi in primitive
   */
  sndcp_data->nu = & sndcp_data->nu_base[nsapi];

  /*
   * Find number of unconfirmed NPDUs
   */
  help = sndcp_data->nu->first_buffered_npdu;
  while(help != NULL)
  {
    count++;
    help = help->next;
  }

  sn_get_pending_pdu_cnf->ul_pdus[nsapi].ptr_desc_list2 = 
           (T_SN_desc_list2*)DRP_ALLOC( count * sizeof( T_SN_desc_list2 ), 0 );

  sn_get_pending_pdu_cnf->ul_pdus[nsapi].nsapi = nsapi;
  sn_get_pending_pdu_cnf->ul_pdus[nsapi].dl_sequence_number = 
                                           sndcp_data->nu->rec_npdu_number_ack;
  sn_get_pending_pdu_cnf->ul_pdus[nsapi].c_desc_list2 = count;

  count = 0;

  /*
   * Check if there are buffered any acknowledged type NPDUs.
   */
  help = sndcp_data->nu->first_buffered_npdu;
  while(help != NULL)
  {

    sn_get_pending_pdu_cnf->ul_pdus[nsapi].ptr_desc_list2[count].first = 
                                        help->sn_data_req->desc_list2.first;
    sn_get_pending_pdu_cnf->ul_pdus[nsapi].ptr_desc_list2[count].list_len = 
                                        help->sn_data_req->desc_list2.list_len;
    count++;
    help = help->next;
  }
  return sn_get_pending_pdu_cnf;
}

/*
+------------------------------------------------------------------------------
| Function    : mg_clean_ack_npdu_queues_leave_data
+------------------------------------------------------------------------------
| Description : This procedure deletes SNDCP's internal buffers containing
|               unconfirmed acknowledged type NPDU's.
|               The data stored in the queues are not deleted.
|
| Parameters  : nsapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_clean_ack_npdu_queues_leave_data(U8 nsapi)
{

  U8 used_sapi=0, sapi_index=0;
  T_NPDU_BUFFER* help = NULL;
  T_SN_DATA_REQ* sn_data_req = NULL;

  TRACE_FUNCTION( "mg_clean_ack_npdu_queues_leave_data" );

   /*
    * set service instance according to sapi
    */
  sndcp_get_nsapi_sapi(nsapi, &used_sapi);
  sndcp_get_sapi_index(used_sapi, &sapi_index);
  sndcp_data->sua = & sndcp_data->sua_base[sapi_index];

  if (sndcp_data->sua->sn_data_q_write != sndcp_data->sua->sn_data_q_read) 
  {
    /*
     * remove unhandled sn_data_req from queue.
     */
    sn_data_req = sndcp_data->sua->sn_data_q[sndcp_data->sua->sn_data_q_read];
    FREE(sn_data_req);
  }

  /*
   * set service instance according to nsapi
   */

  sndcp_data->nu = & sndcp_data->nu_base[nsapi];

  /*
   * clean buffer with unconfirmed NPDUs
   */

  while(sndcp_data->nu->first_buffered_npdu != NULL)
  {
    help = sndcp_data->nu->first_buffered_npdu;
    sndcp_data->nu->first_buffered_npdu = help->next;
    MFREE(help->sn_data_req);
    MFREE(help);
  }
}


/*
+------------------------------------------------------------------------------
| Function    : mg_clean_unack_npdu_queues_including_data
+------------------------------------------------------------------------------
| Description : This procedure deletes SNDCP's internal buffers containing
|               unacknowledged type NPDU's.
|               The data stored in the queues are also deleted.
|
| Parameters  : nsapi
|
+------------------------------------------------------------------------------
*/
GLOBAL void mg_clean_unack_npdu_queues_including_data(U8 nsapi)
{
  /*
   * Delete affected N-PDUS from sn_unitdata_q.
   */
  BOOL still = TRUE;
  U8 index = sndcp_data->su->sn_unitdata_q_read;

  while (still) 
  {
    if (index == sndcp_data->su->sn_unitdata_q_write) {
      break;
    }
    if (sndcp_data->su->sn_unitdata_q[index]->nsapi == nsapi) {
      /*
       * The index for the prims to be shifted when 1 entry is deleted.
       */
      U8 i = 0;

      if (sndcp_data->su->sn_unitdata_q[index] != NULL) {
        PFREE_DESC2(sndcp_data->su->sn_unitdata_q[index]);
        sndcp_data->su->sn_unitdata_q[index] = NULL;
      }

      for (i = index;
           i != sndcp_data->su->sn_unitdata_q_write;
           i = (i + 1) % SN_UNITDATA_Q_LEN) 
           {
              sndcp_data->su->sn_unitdata_q[i] =
                sndcp_data->su->sn_unitdata_q[(i + 1) % SN_UNITDATA_Q_LEN];

              sndcp_data->su->sn_unitdata_q[(i + 1) % SN_UNITDATA_Q_LEN]=NULL;
           }
      sndcp_data->su->sn_unitdata_q_write =
        (sndcp_data->su->sn_unitdata_q_write - 1
         + SN_UNITDATA_Q_LEN) % SN_UNITDATA_Q_LEN;
    } 
    else 
    {
      index = (index + 1) % SN_UNITDATA_Q_LEN;
    } /* else (sndcp_data->su->sn_unitdata_q[index]->nsapi == nsapi) */
  }
}

/*
+------------------------------------------------------------------------------
| Function    : sm_make_test_pending_pdu_cnf
+------------------------------------------------------------------------------
| Description : Initialize SN_TEST_GET_PENDING_PDU_CNF primitive
| Parameters  : sn_get_pending_pdu_cnf - primitive  
|               sn_test_get_pending_pdu_cnf - primitive 
|
+------------------------------------------------------------------------------
*/

GLOBAL void sm_make_test_pending_pdu_cnf
                   (T_SN_GET_PENDING_PDU_CNF* sn_get_pending_pdu_cnf,
                    T_SN_TEST_GET_PENDING_PDU_CNF* sn_test_get_pending_pdu_cnf)
{
  int i,j;

  for (i = 0; i < SN_SIZE_NSAPI; i++) {
    sn_test_get_pending_pdu_cnf->c_test_ul_pdus = 
                         sn_get_pending_pdu_cnf->c_ul_pdus;
    sn_test_get_pending_pdu_cnf->test_ul_pdus[i].nsapi = 
                         sn_get_pending_pdu_cnf->ul_pdus[i].nsapi;
    sn_test_get_pending_pdu_cnf->test_ul_pdus[i].test_dl_sequence_number = 
                         sn_get_pending_pdu_cnf->ul_pdus[i].dl_sequence_number;
    sn_test_get_pending_pdu_cnf->test_ul_pdus[i].c_test_desc_list2 = 
                         sn_get_pending_pdu_cnf->ul_pdus[i].c_desc_list2;

    if (sn_get_pending_pdu_cnf->ul_pdus[i].c_desc_list2) {
      for(j = 0; j < sn_get_pending_pdu_cnf->ul_pdus[i].c_desc_list2; j++) {
        sn_test_get_pending_pdu_cnf->test_ul_pdus[i].c_test_desc_list2 = 
                 sn_get_pending_pdu_cnf->ul_pdus[i].c_desc_list2;
        sn_test_get_pending_pdu_cnf->test_ul_pdus[i].test_desc_list2[j].c_test_pending_pdu = 
             (U8)sn_get_pending_pdu_cnf->ul_pdus[i].ptr_desc_list2[j].list_len;
        memcpy(
          sn_test_get_pending_pdu_cnf->test_ul_pdus[i].test_desc_list2[j].test_pending_pdu,
          ((T_desc2 *)sn_get_pending_pdu_cnf->ul_pdus[i].ptr_desc_list2[j].first)->buffer, 
          sn_get_pending_pdu_cnf->ul_pdus[i].ptr_desc_list2[j].list_len);
      }
    }
  }
}

#endif /*#ifdef TI_DUAL_MODE*/