/* 
+----------------------------------------------------------------------------- 
|  Project :  GSM-PS (6147)
|  Modul   :  CMH_SSS
+----------------------------------------------------------------------------- 
|  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 module provides the set functions related to the
|             protocol stack adapter for SS.
+----------------------------------------------------------------------------- 
*/ 

#ifndef CMH_SSS_C
#define CMH_SSS_C
#endif

#include "aci_all.h"
/*==== INCLUDES ===================================================*/
#include "aci.h"
#include "aci_cmh.h"

#ifdef FAX_AND_DATA
#include "aci_fd.h"
#endif    /* of #ifdef FAX_AND_DATA */

#ifdef UART
#include "dti.h"
#include "dti_conn_mng.h"
#endif

#include "ksd.h"
#include "psa.h"
#include "psa_ss.h"
#include "psa_sim.h"
#include "psa_sms.h"
#include "psa_cc.h"
#include "cmh.h"
#include "cmh_ss.h"
#include "cmh_sim.h"
#include "cmh_sms.h"
#include "cmh_cc.h"

#ifdef SIM_TOOLKIT
#include "psa_cc.h"
#include "psa_sat.h"
#include "cmh_sat.h"
#include "ati_cmd.h"
#include "aci_cmd.h"
#include "cmh_cc.h"
#endif /* of SIM_TOOLKIT */

#include "psa_util.h"
#ifdef GPRS
#include "gaci_cmh.h"
#endif /* GPRS */
#include "phb.h"


#include "aci_ext_pers.h"
#include "aci_slock.h"

#ifdef SIM_PERS
#include "general.h"  // inluded for UINT8 compilation error in sec_drv.h
#include "sec_drv.h"

EXTERN T_SEC_DRV_CONFIGURATION *cfg_data;
EXTERN T_SIM_MMI_INSERT_IND *last_sim_mmi_insert_ind;
#endif

/*==== CONSTANTS ==================================================*/
#define AT_TOA_DEF_INT    (129)  /* toa default for international no.*/
#define AT_TOA_DEF_NAT    (145)  /* toa default for national no.*/
#define AT_TOS_DEF        (128)  /* tos default */
#define AT_CFNRY_DEF_TIME (20)   /* default no reply time */




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

/*==== VARIABLES ==================================================*/
EXTERN T_ACI_CUSCFG_PARAMS cuscfgParams;
GLOBAL SHORT Ext_USSD_Res_Pending_sId;
GLOBAL T_CUSDR_EXT_USSD_RES Ext_USSD_Res_Pending = CUSDR_EXT_USSD_RES_Not_Pending;

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

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
| STATE   : code                  ROUTINE : sAT_PlusCCFC             |
+--------------------------------------------------------------------+

  PURPOSE : This is the functional counterpart to the +CCFC AT command
            which is responsible to set the parameters for call
            forwarding supplementary services.

            <reason> : reason for CF.
            <mode>   : CF mode.
            <number> : number to be forwarded to.
            <type>   : type of number.
            <class>  : class of calls.
            <subaddr>: subaddress of number.
            <satype> : type of subaddress.
            <time>   : no reply time.
*/

GLOBAL T_ACI_RETURN sAT_PlusCCFC  ( T_ACI_CMD_SRC srcId,
                                    T_ACI_CCFC_RSN reason,
                                    T_ACI_CCFC_MOD mode,
                                    CHAR*          number,
                                    T_ACI_TOA*     type,
                                    T_ACI_CLASS    class_type,
                                    CHAR*          subaddr,
                                    T_ACI_TOS*     satype,
                                    SHORT          time)
{
  SHORT sId1, sId2;         /* holds service id */
  UBYTE ssCd;               /* holds ss code */
  UBYTE bst1, bst2;         /* holds basic service type */
  UBYTE bs1, bs2;           /* holds basic service */
  UBYTE ton, tos;           /* holds type of number/subaddress */
  UBYTE npi, oe;            /* holds numbering plan/odd.even indicator */
  BOOL  mltyTrnFlg = FALSE; /* flags for multi transaction */
  T_CLPTY_PRM *ccfc_cldPty;

 #ifdef SIM_TOOLKIT
  T_ACI_RETURN   retVal;
 #endif /* of SIM_TOOLKIT */
 
  TRACE_FUNCTION ("sAT_PlusCCFC");

/*
 *-------------------------------------------------------------------
 * check command source
 *-------------------------------------------------------------------
 */
  if(!cmh_IsVldCmdSrc (srcId))
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

  if( cmhPrm[srcId].ssCmdPrm.mltyTrnFlg NEQ 0 )
  {
    TRACE_EVENT("ssCmdPrm.mltyTrnFlg NEQ 0 !!! CCFC busy");
    return( AT_BUSY );
  }

/*
 *-------------------------------------------------------------------
 * check parameter <time>
 *-------------------------------------------------------------------
 */
  if( time EQ ACI_NumParmNotPresent )
  {
    time = AT_CFNRY_DEF_TIME;
  }
  else if (time < CCFC_TIME_MIN AND time >= 1)
  {
    /* 07.07 allows [1...30] for time while
       09.02 allows [5...30]. So map [1..4] to 5 */
    time = CCFC_TIME_MIN;
  }
  else if( time > CCFC_TIME_MAX OR time < CCFC_TIME_MIN )
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * check parameter <reason>
 *-------------------------------------------------------------------
 */
  switch( reason )
  {
    case( CCFC_RSN_Uncond      ): ssCd = SS_CD_CFU;       break;
    case( CCFC_RSN_Busy        ): ssCd = SS_CD_CFB;       break;
    case( CCFC_RSN_NoReply     ): ssCd = SS_CD_CFNRY;     break;
    case( CCFC_RSN_NotReach    ): ssCd = SS_CD_CFNRC;     break;
    case( CCFC_RSN_Forward     ): ssCd = SS_CD_ALL_FWSS;  break;
    case( CCFC_RSN_CondForward ): ssCd = SS_CD_ALL_CFWSS; break;

    case( CCFC_RSN_NotPresent  ):
    default:
      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
      return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * check parameter <class>
 *-------------------------------------------------------------------
 */
  if( !cmhSS_CheckClass( class_type, &bs1, &bst1, &bs2, &bst2, &mltyTrnFlg ))
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

/* SIM TOOLKIT & FDN HANDLING */

    retVal = cmhSS_CF_SAT_Handle( srcId, reason, mode, number, type, class_type, subaddr, satype, time);

    if( retVal NEQ AT_CMPL )
        return( retVal );
  




/*
 *-------------------------------------------------------------------
 * check parameter <class> against possible ALS-Lock
 *-------------------------------------------------------------------
 */
  if ((ALSlock EQ ALS_MOD_SPEECH     AND class_type EQ  CLASS_AuxVce) OR
      (ALSlock EQ ALS_MOD_AUX_SPEECH AND class_type NEQ CLASS_AuxVce))
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_AlsLock );
    return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * get a new service table entry
 *-------------------------------------------------------------------
 */
  sId1 = psaSS_stbNewEntry();

  if( sId1 EQ NO_ENTRY )
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
    return( AT_FAIL );
  }

  sId2 = NO_ENTRY;

  if( mltyTrnFlg )
  {
    ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;

    sId2 = psaSS_stbNewEntry();

    if( sId2 EQ NO_ENTRY )
    {
      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
      return( AT_FAIL );
    }
  }

/*
 *-------------------------------------------------------------------
 * check parameter <mode>
 *-------------------------------------------------------------------
 */
  switch( mode )
  {
    /*
     *---------------------------------------------------------------
     * enable, disable and erase call forwarding service
     *---------------------------------------------------------------
     */
    case( CCFC_MOD_Disable    ):
    case( CCFC_MOD_Enable     ):
    case( CCFC_MOD_Erasure    ):

      CCD_START;

      if( mode EQ CCFC_MOD_Disable )
        psaSS_asmDeactivateSS( ssCd, bst1, bs1 );

      else if( mode EQ CCFC_MOD_Enable )
        psaSS_asmActivateSS( ssCd, bst1, bs1 );

      else if( mode EQ CCFC_MOD_Erasure )
        psaSS_asmEraseSS( ssCd, bst1, bs1 );

      ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
      ssShrdPrm.stb[sId1].ssCode     = ssCd;
      ssShrdPrm.stb[sId1].srvOwn     = srcId;
      ssShrdPrm.stb[sId1].ClassType  = class_type;  /* the complete classes defined by the user */

      /* start first transaction */
      ssShrdPrm.stb[sId1].curCmd        = AT_CMD_CCFC;

      cmhSS_flagTrn( sId1, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
      psaSS_NewTrns(sId1);

      if( mltyTrnFlg )
      {
        if( mode EQ CCFC_MOD_Disable )
          psaSS_asmDeactivateSS( ssCd, bst2, bs2 );

        else if( mode EQ CCFC_MOD_Enable )
          psaSS_asmActivateSS( ssCd, bst2, bs2 );

        else if( mode EQ CCFC_MOD_Erasure )
          psaSS_asmEraseSS( ssCd, bst2, bs2 );

        ssShrdPrm.stb[sId2].ntryUsdFlg = TRUE;
        ssShrdPrm.stb[sId2].ssCode     = ssCd;
        ssShrdPrm.stb[sId2].srvOwn     = srcId;
        ssShrdPrm.stb[sId2].ClassType  = class_type;  /* the complete classes defined by the user */

        /* start second transaction */
        ssShrdPrm.stb[sId2].curCmd = AT_CMD_CCFC;

        cmhSS_flagTrn( sId2, &(ssShrdPrm.mltyTrnFlg)); /* only for the second one */
        cmhSS_flagTrn( sId2, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));

        psaSS_NewTrns(sId2);
      }

      CCD_END;
      break;

    /*
     *---------------------------------------------------------------
     * register call forwarding service
     *---------------------------------------------------------------
     */
    case( CCFC_MOD_Register   ):

      if(number EQ NULL)
      {
        TRACE_EVENT("ERROR: cannot register CCFC without a number");
        ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
        return( AT_FAIL );
      }
      MALLOC(ccfc_cldPty, sizeof(T_CLPTY_PRM));
      cmhCC_init_cldPty( ccfc_cldPty );

      cmh_bldCalPrms( number, ccfc_cldPty );

      /* check for TOA default */
      if(type EQ NULL)
      {
        ton = ccfc_cldPty->ton;
        npi = ccfc_cldPty->npi;
      }
      else if(type->ton EQ TON_NotPresent OR
              type->npi EQ NPI_NotPresent)
      {
        ton = ccfc_cldPty->ton;
        npi = ccfc_cldPty->npi;
      }
      else
      {
        ton = type->ton;
        npi = type->npi;
      }

      /* check for TOS default */
      if(satype EQ NULL)
      {
        tos = TOS_X213;
        oe  = OEI_EVEN;
      }
      else if(satype->tos EQ TOS_NotPresent OR
              satype->oe  EQ OE_NotPresent)
      {
        tos = TOS_X213;
        oe  = OEI_EVEN;
      }
      else
      {
        tos = satype -> tos;
        oe  = satype -> oe;
      }

      if(subaddr EQ NULL           AND
         ccfc_cldPty->sub[0] NEQ 0) /* if not set by user AND number contained a subaddress */
      {
        subaddr = (CHAR *)ccfc_cldPty->sub;
      }

      CCD_START;

      psaSS_asmRegisterSS( ssCd, bst1, bs1,
                           ton, npi, (UBYTE*)ccfc_cldPty->num, tos, oe, (UBYTE *)subaddr, (UBYTE)time );

      ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
      ssShrdPrm.stb[sId1].ssCode     = ssCd;
      ssShrdPrm.stb[sId1].srvOwn     = srcId;

      /* start first transaction */
      ssShrdPrm.stb[sId1].curCmd        = AT_CMD_CCFC;
      cmhSS_flagTrn( sId1, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
      psaSS_NewTrns(sId1);

      if( mltyTrnFlg )
      {
        psaSS_asmRegisterSS( ssCd, bst2, bs2,
                             ton, npi, (UBYTE*)ccfc_cldPty->num, tos, oe, (UBYTE *)subaddr, (UBYTE)time );

        ssShrdPrm.stb[sId2].ntryUsdFlg = TRUE;
        ssShrdPrm.stb[sId2].ssCode     = ssCd;
        ssShrdPrm.stb[sId2].srvOwn     = srcId;

        /* start second transaction */
        ssShrdPrm.stb[sId2].curCmd = AT_CMD_CCFC;
        cmhSS_flagTrn( sId2, &(ssShrdPrm.mltyTrnFlg)); /* only for the second one */
        cmhSS_flagTrn( sId2, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
        psaSS_NewTrns(sId2);
      }
      MFREE(ccfc_cldPty);
      CCD_END;
      break;

    /*
     *---------------------------------------------------------------
     * unexpected mode
     *---------------------------------------------------------------
     */
    case( CCFC_MOD_NotPresent ):
    default:

      ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
      if( sId2 NEQ NO_ENTRY ) ssShrdPrm.stb[sId2].ntryUsdFlg = FALSE;

      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
      return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * log command execution
 *-------------------------------------------------------------------
 */
#if defined SMI OR defined MFW OR defined FF_MMI_RIV
  {
  T_ACI_CLOG cmdLog;        /* holds logging info */

  cmdLog.atCmd                = AT_CMD_CCFC;
  cmdLog.cmdType              = CLOG_TYPE_Set;
  cmdLog.retCode              = AT_EXCT;
  cmdLog.cId                  = ACI_NumParmNotPresent;
  cmdLog.sId                  = sId1+1;
  cmdLog.cmdPrm.sCCFC.srcId   = srcId;
  cmdLog.cmdPrm.sCCFC.reason  = reason;
  cmdLog.cmdPrm.sCCFC.mode    = mode;
  cmdLog.cmdPrm.sCCFC.number  = number;
  cmdLog.cmdPrm.sCCFC.type    = type;
  cmdLog.cmdPrm.sCCFC.class_type = class_type;
  cmdLog.cmdPrm.sCCFC.subaddr = subaddr;
  cmdLog.cmdPrm.sCCFC.satype  = satype;
  cmdLog.cmdPrm.sCCFC.time    = time;

  rAT_PercentCLOG( &cmdLog );
  }
#endif

  return( AT_EXCT );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
| STATE   : code                  ROUTINE : sAT_PlusCLCK             |
+--------------------------------------------------------------------+

  PURPOSE : This is the functional counterpart to the +CLCK AT command
            which is responsible to set the parameters for call
            barring supplementary services.

            <fac>    : CB facility.
            <mode>   : CB mode.
            <passwd> : password for CB facility.
            <class_type>: class of calls.
*/
LOCAL BOOL check_sat_cb_pwd_required(UBYTE ssCd, CHAR  *passwd)
{
#ifdef SIM_TOOLKIT
  SHORT ss_id = NO_ENTRY;
  T_OWN owner;

  /* Special case: there was an SS (by STK) transaction running. 
     It returned get password, handle the password for this transaction */

  TRACE_FUNCTION ("check_sat_ss_pwd_required ()");

  /* satShrdPrm.sId_pwd_requested will be reset by any mnss_end_ind
  to be sure it has been reset.
  This means: user has to give password right after error has been
  shown. */
  ss_id = satShrdPrm.sId_pwd_requested;
  if( ss_id EQ NO_ENTRY)
  {
    return(FALSE);
  }

  if( ssShrdPrm.stb[ss_id].srvOwn NEQ OWN_SAT )
  {
    satShrdPrm.sId_pwd_requested = NO_ENTRY;
    return(FALSE);
  }
  TRACE_EVENT("Password required during a SAT session");
  
  if( ssShrdPrm.stb[ss_id].curCmd NEQ KSD_CMD_CB )
  {
    TRACE_EVENT_P1("Wrong command context: %d", ssShrdPrm.stb[ss_id].curCmd);
    satShrdPrm.sId_pwd_requested = NO_ENTRY;
    return(FALSE);
  }
  owner = ssShrdPrm.stb[ss_id].srvOwn;

  if(ssShrdPrm.stb[ss_id].ssCode EQ ssCd)
  { 
    /* store for later use (as usual)*/
    strncpy
    (
      (char *) cmhPrm[owner].ssCmdPrm.CXXXpwd,
      (char *) passwd,
      MAX_PWD_NUM
    );
    cmhPrm[owner].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
    psaSS_asmVerifyPWD( cmhPrm[owner].ssCmdPrm.CXXXpwd);
    psaSS_CntTrns(ss_id);
    satShrdPrm.sId_pwd_requested = NO_ENTRY;
    return(TRUE); /* as pwd only needed for SAT session*/
  }
  else
  {
    TRACE_EVENT_P1("Wrong Service type: %d", ssCd);
  }
  satShrdPrm.sId_pwd_requested = NO_ENTRY;
#endif /* SIM_TOOLKIT */
  return(FALSE);
}

/*
+------------------------------------------------------------------------------
|  Function    : sAT_PlusCLCK
+------------------------------------------------------------------------------
|  Description : This is the functional counterpart to the +CLCK AT command
|            which is responsible to set the parameters for call
|            barring supplementary services. also fo locking and unlocking ME for categories 
|            Networl lock, Network Subset lock, Service Provider Lock, Corporate Lock, SIM Lock
|
|  Parameters  : <fac>    : CB facility.
|                      <mode>   : CB mode.
|                      <passwd> : password for CB facility.
|                      <class_type>: class of calls.
|
|  Return      :  AT_FAIL    -      execution of command failed 
|         AT_CMPL   -      execution of command completed 
|         AT_EXCT   -      execution of command is in progress 
|         AT_BUSY   -      execution of command is rejected due
|
+------------------------------------------------------------------------------
*/

GLOBAL T_ACI_RETURN sAT_PlusCLCK  ( T_ACI_CMD_SRC srcId,
                                    T_ACI_CLCK_FAC fac,
                                    T_ACI_CLCK_MOD mode,
                                    CHAR  *        passwd,
                                    T_ACI_CLASS    class_type)
{
  SHORT sId1, sId2;        /* holds service id  */
  UBYTE ssCd;                  /* holds ss code     */
  UBYTE bst1, bst2;         /* holds basic service type */
  UBYTE bs1,  bs2;           /* holds basic service */
  BOOL  mltyTrnFlg = FALSE; /* flags for multi transaction */
  #ifdef SIM_PERS
  T_SIMLOCK_TYPE slocktype;
  T_SIMLOCK_STATUS rlockstatus;
  T_SIMLOCK_TYPE lock_type; 
  T_SIMLOCK_TYPE last_lock_type; 
  #endif
  SHORT psasim_ret;
  BOOL  done = FALSE;
#ifdef SIM_PERS
  T_ACI_CME_ERR err_code = CME_ERR_NotPresent; /* code holding the correct error code calculated */
  UBYTE cmdBuf;                 /* buffers current command */
#endif
#ifdef SIM_PERS
  T_OPER_RET_STATUS fcResetStat;  /*holds Failure Counter Reset Return Status Introduced on 11/03/2005*/
  T_SIMLOCK_STATUS retSlStatus; /* holds return code */
#endif
  T_ACI_RETURN   retVal;

  TRACE_FUNCTION ("sAT_PlusCLCK ()");
   
/*
 *-------------------------------------------------------------------
 * check command source
 *-------------------------------------------------------------------
 */
  if(!cmh_IsVldCmdSrc (srcId))
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * check parameter <fac>
 *-------------------------------------------------------------------
 */
  switch( fac )
  {
    case( CLCK_FAC_Ao ): ssCd = SS_CD_BAOC;     break;
    case( CLCK_FAC_Oi ): ssCd = SS_CD_BOIC;     break;
    case( CLCK_FAC_Ox ): ssCd = SS_CD_BOICXH;   break;
    case( CLCK_FAC_Ai ): ssCd = SS_CD_BAIC;     break;
    case( CLCK_FAC_Ir ): ssCd = SS_CD_BICRM;    break;
    case( CLCK_FAC_Ab ): ssCd = SS_CD_ALL_CBSS; break;
    case( CLCK_FAC_Ag ): ssCd = SS_CD_BOC;      break;
    case( CLCK_FAC_Ac ): ssCd = SS_CD_BIC;      break;

    case( CLCK_FAC_Sc ):
    case( CLCK_FAC_Fd ):
#ifdef SIM_PERS
    case( CLCK_FAC_Pn ):
    case( CLCK_FAC_Pu ):
    case( CLCK_FAC_Pc ):
    case( CLCK_FAC_Pp ):
    case( CLCK_FAC_Pf ):
    case( CLCK_FAC_Ps ):
#endif
    case( CLCK_FAC_Al ):
#ifdef SIM_PERS
    case( CLCK_FAC_Fc ):
    case(CLCK_FAC_Fcm): 
#endif
      ssCd = NOT_PRESENT_8BIT; break;

    case( CLCK_FAC_NotPresent  ):
    default:

      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
      return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * if action is related to SS
 *-------------------------------------------------------------------
 */
  if( ssCd NEQ NOT_PRESENT_8BIT )
  {
  /*
   *-------------------------------------------------------------------
   * check parameter <passwd>
   *-------------------------------------------------------------------
   */
    if( passwd AND strlen( passwd ) > MAX_PWD_NUM )
    {
      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
      return( AT_FAIL );
    }

  /*
   *-------------------------------------------------------------------
   * check parameter <class>
   *-------------------------------------------------------------------
   */
    if( !cmhSS_CheckCbClass( class_type, &bs1, &bst1, &bs2, &bst2, &mltyTrnFlg ))
    {
      ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
      return( AT_FAIL );
    }

    if( cmhPrm[srcId].ssCmdPrm.mltyTrnFlg NEQ 0 )
      return( AT_BUSY );

  /*
   *-------------------------------------------------------------------
   * check combination of <mode> and <fac>
   *-------------------------------------------------------------------
   */
    if((fac EQ CLCK_FAC_Ab OR fac EQ CLCK_FAC_Ag OR fac EQ CLCK_FAC_Ac)
       AND mode NEQ CLCK_MOD_Unlock )
    {
      ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
      return( AT_FAIL );
    }

    /*** Shangai's labs tessession fix: adapted to this version from 1.3.3 (TCS 2.0) ****/
      /* Special case: there was an SS (by STK) transaction running. 
         It returned get password, handle the password for this transaction */
    done = check_sat_cb_pwd_required(ssCd, passwd);
    if(done)
    {
      return(AT_CMPL); /* as pwd only needed for SAT session*/
    }
    /* End fix */


/* SIM TOOLKIT & FDN HANDLING */
    retVal = cmhSS_Call_Barr_SAT_Handle( srcId, mode, fac, passwd, class_type);

    if( retVal NEQ AT_CMPL )
        return( retVal );
  
  /*
   *-------------------------------------------------------------------
   * get a new service table entry
   *-------------------------------------------------------------------
   */
    sId1 = psaSS_stbNewEntry();

    if( sId1 EQ NO_ENTRY )
    {
      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
      return( AT_FAIL );
    }

    sId2 = NO_ENTRY;

    if( mltyTrnFlg )
    {
      ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
      sId2 = psaSS_stbNewEntry();

      if( sId2 EQ NO_ENTRY )
      {
        ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
        ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
        return( AT_FAIL );
      }
    }

  /*
   *-------------------------------------------------------------------
   * check parameter <mode>
   *-------------------------------------------------------------------
   */
    switch( mode  )
    {
      /*
       *---------------------------------------------------------------
       * lock and unlock call barring service
       *---------------------------------------------------------------
       */
      case( CLCK_MOD_Unlock ):
      case( CLCK_MOD_Lock   ):

        CCD_START;

        if( mode EQ CLCK_MOD_Unlock )
          psaSS_asmDeactivateSS( ssCd, bst1, bs1 );

        else if( mode EQ CLCK_MOD_Lock )
          psaSS_asmActivateSS( ssCd, bst1, bs1 );

        ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
        ssShrdPrm.stb[sId1].ssCode     = ssCd;
        ssShrdPrm.stb[sId1].srvOwn     = srcId;

        /* start first transaction */
        ssShrdPrm.stb[sId1].curCmd        = AT_CMD_CLCK;
        cmhSS_flagTrn( sId1, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
        psaSS_NewTrns(sId1);

        if( mltyTrnFlg )
        {
          if( mode EQ CLCK_MOD_Unlock )
            psaSS_asmDeactivateSS( ssCd, bst2, bs2 );

          else if( mode EQ CLCK_MOD_Lock )
            psaSS_asmActivateSS( ssCd, bst2, bs2 );

          ssShrdPrm.stb[sId2].ntryUsdFlg = TRUE;
          ssShrdPrm.stb[sId2].ssCode      = ssCd;
          ssShrdPrm.stb[sId2].srvOwn     = srcId;

          /* start second transaction */
          ssShrdPrm.stb[sId2].curCmd = AT_CMD_CLCK;
          cmhSS_flagTrn( sId2, &(ssShrdPrm.mltyTrnFlg)); /* only for the second one */
          cmhSS_flagTrn( sId2, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
          psaSS_NewTrns(sId2);
        }
        CCD_END;
        break;

      /*
       *---------------------------------------------------------------
       * unexpected mode
       *---------------------------------------------------------------
       */
      case( CLCK_MOD_NotPresent ):
      default:

        ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
        if( sId2 NEQ NO_ENTRY ) ssShrdPrm.stb[sId2].ntryUsdFlg = FALSE;

        ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
        return( AT_FAIL );
    }

  /*
   *-------------------------------------------------------------------
   * store password for later use
   *-------------------------------------------------------------------
   */
    if( passwd )
    {
      strncpy
      (
        (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
        (char *) passwd,
        MAX_PWD_NUM
      );
      cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
    }
  }

  /*
   *-------------------------------------------------------------------
   * if action is related to SIM
   *-------------------------------------------------------------------
   */
  else
  {
      if( simEntStat.curCmd NEQ AT_CMD_NONE )
      return( AT_BUSY );

    switch (fac)
    {
      /*
       *---------------------------------------------------------------
       * access PIN 1
       *---------------------------------------------------------------
       */
      case CLCK_FAC_Sc:
        switch( mode )
        {
          case( CLCK_MOD_Unlock ):
          case( CLCK_MOD_Lock   ):
            if (simShrdPrm.PINStat EQ PS_PUK1)
            {
              ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimPukReq);
              return( AT_FAIL );
            }
            if (!psaSIM_ChkSIMSrvSup(SRV_CHV1_Disable))
            {
              ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow);
              return( AT_FAIL );
            }
            if( !passwd OR (strlen( passwd ) > PIN_LEN) )
            {
              ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
              return( AT_FAIL );
            }
            if( strlen( passwd ) < MIN_PIN_LEN OR   
                strlen( passwd ) > PIN_LEN        )
            {
              ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
              return( AT_FAIL );
            }
            cmhSIM_FillInPIN ( passwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );
            simShrdPrm.setPrm[srcId].PINType = PHASE_2_PIN_1;
            simEntStat.curCmd     = AT_CMD_CLCK;
            simEntStat.entOwn     = simShrdPrm.owner = srcId;

            if( mode EQ CLCK_MOD_Lock )
            {
              psasim_ret = psaSIM_EnablePIN( );
            }
            else /* if( mode EQ CLCK_MOD_Unlock ) */
            {
              psasim_ret = psaSIM_DisablePIN( );
            }

            if(psasim_ret < 0)
            {
              TRACE_EVENT( "FATAL RETURN psaSIM in +CLCK" );
              ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
              return( AT_FAIL );
            }
            break;

          default:

            ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
            return( AT_FAIL );
        }
        break;

      /*
       *---------------------------------------------------------------
       * access fixed dialling feature
       *---------------------------------------------------------------
       */
      case CLCK_FAC_Fd:
    if (!psaSIM_ChkSIMSrvSup(SRV_FDN))
        {
          ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow);
          return( AT_FAIL );
        }
        /* 
          Check the SIM PIN States before sending any request to SIM 
        */
        if ( simShrdPrm.PINStat EQ PS_PUK2 )
        {
          TRACE_EVENT("sAT_PlusCLCK_ME(): SIM PIN-2 Bolcked PUK-2 Required");
          ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimPuk2Req );
          return( AT_FAIL );
        }
       
        /* 
          According to the standards 27.007 Sec 7.4 for facility "FDN": 
          if PIN2 authentication has not been done during the current session,
          PIN2 is required as <passwd>; Below condition will do the
          same to check to see whether <passwd> is required / not. 
        */

        if ( simShrdPrm.pn2Stat EQ PS_PIN2  OR 
             simShrdPrm.pn2Stat EQ NO_VLD_PS )
        { 
          if ( simShrdPrm.PINStat EQ PS_RDY OR
               simShrdPrm.PINStat EQ PS_PIN2 )
          {
            simShrdPrm.PINStat = PS_PIN2;          
          }
          else
          {
            TRACE_EVENT("sAT_PlusCLCK_ME(): SIM PIN State is NOT Valid");
            ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimFail );
            return( AT_FAIL );
          }
        
          if( !passwd OR ( strlen( passwd ) > PIN_LEN OR
               strlen( passwd ) < MIN_PIN_LEN ) )
          {
            TRACE_EVENT("sAT_PlusCLCK_ME(): SIM PIN-2 Password is Omitted");
            ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimPin2Req );
            return( AT_FAIL );
          }
        }

         /* 
         * test class_type whether it is supported and store it temporarily for further use 
         */      
        if( class_type EQ CLASS_NotPresent OR    /* default case */
            class_type EQ CLASS_VceDatFax     )  /* case 7       */
        {
          simShrdPrm.classFDN = CLASS_VceDatFax;
        }
        else if ( class_type EQ CLASS_VceDatFaxSms  ) /* case 15 */
        {
          simShrdPrm.classFDN = CLASS_VceDatFaxSms;  /* set global class type */
        }
        else  /* parameter not supported */
        {
          TRACE_EVENT( "class type not supported, +CLCK rejected" );
          ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotSupp );
          return( AT_FAIL );        
        }
        simShrdPrm.setPrm[srcId].actProc = (mode EQ CLCK_MOD_Lock)?
                                             SIM_FDN_ENABLE:SIM_FDN_DISABLE;

        simEntStat.curCmd = AT_CMD_CLCK;
        simEntStat.entOwn = simShrdPrm.owner = srcId;

        if( psaSIM_ActivateSIM() < 0 )   /* activate SIM card */
        {
          TRACE_EVENT( "FATAL RETURN psaSIM in +CLCK" );
          ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
          return( AT_FAIL );
        }

        /* store PIN 2 for later use */
        /* if( passwd )  ... already checked in the beginning! */
        cmhSIM_FillInPIN ( passwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );

        break;

      /*
       *---------------------------------------------------------------
       * lock ALS setting with PIN2
       *---------------------------------------------------------------
       */
      case CLCK_FAC_Al:

        if( !passwd OR ( strlen( passwd ) > PIN_LEN     OR
                         strlen( passwd ) < MIN_PIN_LEN ) )
        {
          ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
          return( AT_FAIL );
        }

        cmhSIM_FillInPIN ( passwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );

        simShrdPrm.setPrm[srcId].actProc = (mode EQ CLCK_MOD_Lock)?
                                             SIM_ALS_LOCK:SIM_ALS_UNLOCK;

        simShrdPrm.setPrm[srcId].PINType = PHASE_2_PIN_2;

        simEntStat.curCmd = AT_CMD_CLCK;
        simEntStat.entOwn = simShrdPrm.owner = srcId;

        if( psaSIM_VerifyPIN() < 0 )   /* check PIN2 card */
        {
          TRACE_EVENT( "FATAL RETURN psaSIM in +CLCK" );
          ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
          return( AT_FAIL );
        }

        break;

      /*
       *---------------------------------------------------------------
       * ME Personalisation
       *---------------------------------------------------------------
       */
  #ifdef SIM_PERS
      case CLCK_FAC_Pn:
      case CLCK_FAC_Pu:
      case CLCK_FAC_Pp:
      case CLCK_FAC_Pc:
      case CLCK_FAC_Ps:
      case CLCK_FAC_Pf:
                
        switch (fac)
        {
          case CLCK_FAC_Pn: slocktype = SIMLOCK_NETWORK;          break;
          case CLCK_FAC_Pu: slocktype = SIMLOCK_NETWORK_SUBSET;   break;
          case CLCK_FAC_Pp: slocktype = SIMLOCK_SERVICE_PROVIDER; break;
          case CLCK_FAC_Pc: slocktype = SIMLOCK_CORPORATE;        break;
          case CLCK_FAC_Ps: slocktype = SIMLOCK_SIM;              break;
          case CLCK_FAC_Pf: slocktype = SIMLOCK_FIRST_SIM;        break;
          default: slocktype = SIMLOCK_NETWORK;
        }

       /* 
        * Check whether sim is inserted or not before trying to lock/Unlock 
        */
       
       if(simShrdPrm.SIMStat EQ SS_OK) 
        {
          rlockstatus = (mode EQ CLCK_MOD_Lock)?
          aci_slock_lock(slocktype, passwd):
          aci_slock_unlock(slocktype, passwd);
       }
      else 
       {
          /*
           * Sim is not present: unlocking is allowed if No_SIM_Unlock flag is OFF
          */
         aci_slock_set_CFG();
         if(cfg_data EQ NULL)
         {
            ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_Unknown);    
           return( AT_FAIL );
         }
         if( (mode EQ CLCK_MOD_Unlock) AND !(cfg_data->Flags & SEC_DRV_HDR_FLAG_No_SIM_Unlock))
         {
            MFREE(cfg_data);
            rlockstatus = aci_slock_unlock(slocktype, passwd);        
         }
        else
        {
           MFREE(cfg_data);
           ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimNotIns);    
           return( AT_FAIL );
        }
      }
      cmdBuf = AT_CMD_CLCK ; 
      if ( ( (mode EQ CLCK_MOD_Lock) AND (rlockstatus EQ SIMLOCK_ENABLED) ) OR
              ( (mode EQ CLCK_MOD_Unlock) AND (rlockstatus EQ SIMLOCK_DISABLED) ) )
        {
            return (AT_CMPL);
        }
        else
        {
          if (rlockstatus EQ SIMLOCK_BLOCKED) /* Special error description on blocked personalisation */
           {
               aci_slock_set_CFG();
	        if(cfg_data EQ NULL)
                {
                  ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_Unknown);    
                  return( AT_FAIL );
                }
               aci_set_cme_error(slocktype);
               MFREE(cfg_data);
           }
          else if(rlockstatus EQ SIMLOCK_WAIT)
            {
               simEntStat.curCmd = AT_CMD_CLCK;
               simEntStat.entOwn = simShrdPrm.owner = srcId;
              AciSLockShrd.check_lock = SIMLOCK_CHECK_LOCK;
              AciSLockShrd.lock_type = slocktype;
              AciSLockShrd.lock_passwd = passwd;
              
              return( AT_EXCT);
            }
           else 
            {
              err_code =CME_ERR_WrongPasswd; 
              ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd );
            }
          
            return( AT_FAIL );
        }

/*
       *---------------------------------------------------------------
       * FC RESET Handling
       Added on 11/03/2005
       *---------------------------------------------------------------
*/
     case CLCK_FAC_Fc:
      fcResetStat=aci_slock_reset_fc(passwd);
      simEntStat.curCmd     = AT_CMD_CLCK;     
      if (fcResetStat EQ OPER_SUCCESS)
      {
             aci_slock_set_CFG();
		if(cfg_data EQ NULL)
              {
                ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_Unknown);    
                return( AT_FAIL );
              }
             aci_slock_init();
             AciSLockShrd.check_lock = SIMLOCK_CHECK_RESET_FC;           
             retSlStatus = aci_slock_checkpersonalisation(AciSLockShrd.current_lock);

             switch(retSlStatus)
             {
               case  SIMLOCK_ENABLED  :
			     return( AT_CMPL);
               case  SIMLOCK_BLOCKED :
			   	return( AT_FAIL);
               case  SIMLOCK_WAIT :
                         return (AT_EXCT);
                         
             }
            
            
      }
      else if (fcResetStat EQ OPER_FAIL)
      {
         cmdBuf = simEntStat.curCmd;
         simEntStat.curCmd = AT_CMD_NONE;
         err_code =CME_ERR_WrongPasswd;
         R_AT( RAT_CME, simEntStat.entOwn )
         ( cmdBuf, err_code );
         cmh_logRslt ( simEntStat.entOwn, RAT_CME, cmdBuf, -1, -1, err_code );
         return( AT_FAIL );
      }
      
    case CLCK_FAC_Fcm:
           fcResetStat=aci_slock_reset_fc(passwd);
      if (fcResetStat EQ OPER_SUCCESS)
      {
        TRACE_FUNCTION(" AT_CMPL");
        return( AT_CMPL );
      }
      else 
      {
        TRACE_FUNCTION(" AT_FAIL");
        ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd );
        return( AT_FAIL );
      }
#endif  //SIM_PERS
      /*
       *---------------------------------------------------------------
       * Error handling
       *---------------------------------------------------------------
       */
      default:
        ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_Unknown );
        return( AT_FAIL );
    }
  }

/*
 *-------------------------------------------------------------------
 * log command execution
 *-------------------------------------------------------------------
 */
#if defined SMI OR defined MFW OR defined FF_MMI_RIV
  {
  T_ACI_CLOG cmdLog;        /* holds logging info */

  cmdLog.atCmd                = AT_CMD_CLCK;
  cmdLog.cmdType              = CLOG_TYPE_Set;
  cmdLog.retCode              = AT_EXCT;
  cmdLog.cId                  = ACI_NumParmNotPresent;
  cmdLog.sId                  = (ssCd EQ NOT_PRESENT_8BIT)?
                                   ACI_NumParmNotPresent:/*lint -e(644)*/sId1+1;
  cmdLog.cmdPrm.sCLCK.srcId   = srcId;
  cmdLog.cmdPrm.sCLCK.fac     = fac;
  cmdLog.cmdPrm.sCLCK.mode    = mode;
  cmdLog.cmdPrm.sCLCK.passwd  = passwd;
  cmdLog.cmdPrm.sCLCK.class_type = class_type;

  rAT_PercentCLOG( &cmdLog );
  }
#endif

  return( AT_EXCT );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
| STATE   : code                  ROUTINE : sAT_PlusCPWD             |
+--------------------------------------------------------------------+

  PURPOSE : This is the functional counterpart to the +CPWD AT command
            which is responsible to change the password for call
            barring supplementary services.

            <fac>    : CB facility.
            <oldpwd> : current password.
            <newpwd> : new password.
*/

GLOBAL T_ACI_RETURN sAT_PlusCPWD  ( T_ACI_CMD_SRC srcId,
                                    T_ACI_CPWD_FAC fac,
                                    CHAR  *        oldpwd,
                                    CHAR  *        newpwd)
{
  T_ACI_RETURN retCd = AT_FAIL;   /* holds return code */
  UBYTE ssCd;                     /* holds ss code */
  SHORT sId;                      /* holds service id */
#ifdef SIM_PERS
   T_SIMLOCK_TYPE slocktype;
   T_OPER_RET_STATUS status;
#endif
  TRACE_FUNCTION ("sAT_PlusCPWD");

/*
 *-------------------------------------------------------------------
 * check password parameter
 *-------------------------------------------------------------------
 */
  if( !newpwd OR !oldpwd )
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * check parameter <fac>
 *-------------------------------------------------------------------
 */
  switch( fac )
  {
    /* All Baring Services share the same password so only SS_CD_ALL_CBSS is valid,
       everything else will be rejected by the network! */
    case( CPWD_FAC_Ao ):
    case( CPWD_FAC_Oi ):
    case( CPWD_FAC_Ox ):
    case( CPWD_FAC_Ai ):
    case( CPWD_FAC_Ir ):
    case( CPWD_FAC_Ab ):
    case( CPWD_FAC_Ag ):
    case( CPWD_FAC_Ac ): ssCd = SS_CD_ALL_CBSS;   break;

    case( CPWD_FAC_Sc ):
    case( CPWD_FAC_P2 ):
#ifdef SIM_PERS
    case( CPWD_FAC_Pn ):
    case( CPWD_FAC_Pu ):
    case( CPWD_FAC_Pc ):
    case( CPWD_FAC_Pp ):
    case( CPWD_FAC_Pf ):
    case( CPWD_FAC_Ps ):
#endif
                                        ssCd = NOT_PRESENT_8BIT; break;


    case( CPWD_FAC_NotPresent  ):
    default:

      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
      return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * if password relates to SS
 *-------------------------------------------------------------------
 */
  if( ssCd NEQ NOT_PRESENT_8BIT )
  {
  /*
   *-------------------------------------------------------------------
   * check parameter <oldpwd>
   *-------------------------------------------------------------------
   */
    if( strlen( newpwd ) > MAX_PWD_NUM OR
        strlen( oldpwd ) > MAX_PWD_NUM    )
    {
      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
      return( AT_FAIL );
    }

  /*
   *-----------------------------------------------------------------
   * get a new service table entry to interrogate SS
   *-----------------------------------------------------------------
   */
    sId = psaSS_stbNewEntry();

    if( sId EQ NO_ENTRY )
    {
      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
      return( AT_FAIL );
    }

  /*
   *-----------------------------------------------------------------
   * set up  facility information element
   *-----------------------------------------------------------------
   */
    CCD_START;

    psaSS_asmRegisterPWD( ssCd );
  /*
   *---------------------------------------------------------------
   * declare service table entry as used and the owner of the service
   *---------------------------------------------------------------
   */
    ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
    ssShrdPrm.stb[sId].ssCode     = ssCd;
    ssShrdPrm.stb[sId].srvOwn     = srcId;

  /*
   *-----------------------------------------------------------------
   * start a new transaction
   *-----------------------------------------------------------------
   */
    ssShrdPrm.stb[sId].curCmd = AT_CMD_CPWD;
    psaSS_NewTrns(sId);

    CCD_END;

  /*
   *-----------------------------------------------------------------
   * store passwords for later use
   *-----------------------------------------------------------------
   */
    strncpy
    (
      (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
      (char *) oldpwd,
      MAX_PWD_NUM
    );
    cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';

    strncpy
    (
      (char *) cmhPrm[srcId].ssCmdPrm.CXXXnewPwd,
      (char *) newpwd,
      MAX_PWD_NUM
    );
    cmhPrm[srcId].ssCmdPrm.CXXXnewPwd[MAX_PWD_NUM] = '\0';

    strncpy
    (
      (char *) cmhPrm[srcId].ssCmdPrm.CXXXnewPwd2,
      (char *) newpwd,
      MAX_PWD_NUM
    );
    cmhPrm[srcId].ssCmdPrm.CXXXnewPwd2[MAX_PWD_NUM] = '\0';
    retCd = AT_EXCT;
  }
  else
  {
    /*
     *-------------------------------------------------------------------
     * if password relates to SIM
     *-------------------------------------------------------------------
     */
    switch (fac)
    {
      /*
       *---------------------------------------------------------------
       * change PIN 1 / PIN 2
       *---------------------------------------------------------------
       */
      case( CPWD_FAC_Sc ):
      case( CPWD_FAC_P2 ):
        if( simEntStat.curCmd NEQ AT_CMD_NONE )
          return( AT_BUSY );

        if( strlen( newpwd ) > PIN_LEN     OR
            strlen( newpwd ) < MIN_PIN_LEN OR
            strlen( oldpwd ) > PIN_LEN     OR
            strlen( oldpwd ) < MIN_PIN_LEN    )
        {
          ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
          return( AT_FAIL );
        }

        if( simEntStat.curCmd NEQ AT_CMD_NONE )
          return( AT_BUSY );

        cmhSIM_FillInPIN ( oldpwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );
        cmhSIM_FillInPIN ( newpwd, simShrdPrm.setPrm[srcId].newPIN, PIN_LEN );

        simShrdPrm.setPrm[srcId].PINType = (fac EQ CPWD_FAC_Sc)?
                                   PHASE_2_PIN_1:PHASE_2_PIN_2;

        simEntStat.curCmd     = AT_CMD_CPWD;
        simEntStat.entOwn     = simShrdPrm.owner = srcId;

        if( psaSIM_ChangePIN() < 0 )  /* change PIN */
        {
          TRACE_EVENT( "FATAL RETURN psaSIM in +CPWD" );
          ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
          return( AT_FAIL );
        }
        retCd = AT_EXCT;
        break;

#ifdef SIM_PERS
      case( CPWD_FAC_Pn ):
      case( CPWD_FAC_Pu ):
      case( CPWD_FAC_Pc ):
      case( CPWD_FAC_Pp ):
      case( CPWD_FAC_Pf ):
      case( CPWD_FAC_Ps ):
      {
        T_SIMLOCK_TYPE slocktype;
        T_SIMLOCK_STATUS status;

        switch (fac)
        {
          case CLCK_FAC_Pn: slocktype = SIMLOCK_NETWORK;          break;
          case CLCK_FAC_Pu: slocktype = SIMLOCK_NETWORK_SUBSET;   break;
          case CLCK_FAC_Pp: slocktype = SIMLOCK_SERVICE_PROVIDER; break;
          case CLCK_FAC_Pc: slocktype = SIMLOCK_CORPORATE;        break;
          case CLCK_FAC_Ps: slocktype = SIMLOCK_SIM;              break;
          case CLCK_FAC_Pf: slocktype = SIMLOCK_FIRST_SIM;        break;
          default: slocktype = SIMLOCK_NETWORK;                   break;
        }

        status = aci_slock_change_password( slocktype, oldpwd, newpwd );
        if (status EQ OPER_SUCCESS)
          return(AT_CMPL);
        else if(status EQ OPER_FAIL )
        {
          ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd );
          return( AT_FAIL );
        }
        else if (status EQ SIMLOCK_BLOCKED)
        {
          switch (fac)
          {
            case CLCK_FAC_Pn: ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_NetworkPersPukReq ); break;
            case CLCK_FAC_Pu: ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_NetworkSubsetPersPukReq ); break;
            case CLCK_FAC_Pp: ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_ProviderPersPukReq ); break;
            case CLCK_FAC_Pc: ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_CorporatePersPukReq ); break;
            case CLCK_FAC_Ps: ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_PhoneFail ); break;
            case CLCK_FAC_Pf: ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_PhFSimPukReq ); break;
          }
          return( AT_FAIL );
        }
      }
      retCd = AT_CMPL;
      break;
#endif
    }
  }

/*
 *-------------------------------------------------------------------
 * log command execution
 *-------------------------------------------------------------------
 */
#if defined SMI OR defined MFW OR defined FF_MMI_RIV
  {
    T_ACI_CLOG cmdLog;        /* holds logging info */

    cmdLog.atCmd                = AT_CMD_CPWD;
    cmdLog.cmdType              = CLOG_TYPE_Set;
    cmdLog.retCode              = retCd;
    cmdLog.cId                  = ACI_NumParmNotPresent;
    cmdLog.sId                  = (ssCd EQ NOT_PRESENT_8BIT)?
                                     ACI_NumParmNotPresent:/*lint -e(644)*/sId+1;
    cmdLog.cmdPrm.sCPWD.srcId   = srcId;
    cmdLog.cmdPrm.sCPWD.fac     = fac;
    cmdLog.cmdPrm.sCPWD.oldpwd  = oldpwd;
    cmdLog.cmdPrm.sCPWD.newpwd  = newpwd;
  
    rAT_PercentCLOG( &cmdLog );
  }
#endif

  return( retCd );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
| STATE   : code                  ROUTINE : sAT_PlusCCWA             |
+--------------------------------------------------------------------+

  PURPOSE : This is the functional counterpart to the +CCWA AT command
            which is responsible to set the parameters for call
            waiting supplementary services.

            <mode>   : CW mode.
            <class_type>: class of call.
*/

GLOBAL T_ACI_RETURN sAT_PlusCCWA  ( T_ACI_CMD_SRC     srcId,
                                    T_ACI_CCWA_MOD    mode,
                                    T_ACI_CLASS       class_type)
{
  SHORT sId1, sId2;         /* holds service id */
  UBYTE bst1, bst2;         /* holds basic service type */
  UBYTE bs1,  bs2;          /* holds basic service */
  BOOL  mltyTrnFlg = FALSE; /* flags for multi transaction */

   T_ACI_RETURN   retVal;
 
  TRACE_FUNCTION ("sAT_PlusCCWA ()");

/*
 *-------------------------------------------------------------------
 * check command source
 *-------------------------------------------------------------------
 */
  if(!cmh_IsVldCmdSrc (srcId))
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

  if( cmhPrm[srcId].ssCmdPrm.mltyTrnFlg NEQ 0 )

    return( AT_BUSY );

/*
 *-------------------------------------------------------------------
 * check parameter <class>
 *-------------------------------------------------------------------
 */
  if( !cmhSS_CheckClass( class_type, &bs1, &bst1, &bs2, &bst2, &mltyTrnFlg ))
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

/* SIM TOOLKIT & FDN HANDLING */
  if (mode NEQ CCWA_MOD_NotInterrogate)  /* mode should be valid */
  {
    retVal = cmhSS_CW_SAT_Handle( srcId, mode, class_type);

    if( retVal NEQ AT_CMPL )
        return( retVal );
  }


/*
 *-------------------------------------------------------------------
 * get a new service table entry to interrogate SS
 *-------------------------------------------------------------------
 */
  sId1 = psaSS_stbNewEntry();

  if( sId1 EQ NO_ENTRY )
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
    return( AT_FAIL );
  }

  sId2 = NO_ENTRY;

  if( mltyTrnFlg )
  {
    ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;

    sId2 = psaSS_stbNewEntry();

    if( sId2 EQ NO_ENTRY )
    {
      ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
      return( AT_FAIL );
    }
  }

/*
 *-------------------------------------------------------------------
 * check parameter <mode>
 *-------------------------------------------------------------------
 */
  switch( mode )
  {
    /*
     *---------------------------------------------------------------
     * lock and unlock call barring service
     *---------------------------------------------------------------
     */
    case( CCWA_MOD_Disable ):
    case( CCWA_MOD_Enable  ):

      CCD_START;

      if( mode EQ CCWA_MOD_Disable )
        psaSS_asmDeactivateSS( SS_CD_CW, bst1, bs1 );

      else if( mode EQ CCWA_MOD_Enable )
        psaSS_asmActivateSS( SS_CD_CW, bst1, bs1 );

      ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
      ssShrdPrm.stb[sId1].ssCode     = SS_CD_CW;
      ssShrdPrm.stb[sId1].srvOwn     = srcId;

      /* start first transaction */
      ssShrdPrm.stb[sId1].curCmd        = AT_CMD_CCWA;
      cmhSS_flagTrn( sId1, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
      psaSS_NewTrns(sId1);

      if( mltyTrnFlg )
      {
        if( mode EQ CCWA_MOD_Disable )
          psaSS_asmDeactivateSS( SS_CD_CW, bst2, bs2 );

        else if( mode EQ CCWA_MOD_Enable )
          psaSS_asmActivateSS( SS_CD_CW, bst2, bs2 );

        ssShrdPrm.stb[sId2].ntryUsdFlg = TRUE;
        ssShrdPrm.stb[sId2].ssCode     = SS_CD_CW;
        ssShrdPrm.stb[sId2].srvOwn     = srcId;

        /* start second transaction */
        ssShrdPrm.stb[sId2].curCmd = AT_CMD_CCWA;
        cmhSS_flagTrn( sId2, &(ssShrdPrm.mltyTrnFlg)); /* only for the second one */
        cmhSS_flagTrn( sId2, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
        psaSS_NewTrns(sId2);
      }
      CCD_END;
      break;

    /*
     *---------------------------------------------------------------
     * unexpected mode
     *---------------------------------------------------------------
     */
    case( CCWA_MOD_NotInterrogate ):

      ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
      return( AT_CMPL );

    default:

      ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
      if( sId2 NEQ NO_ENTRY ) ssShrdPrm.stb[sId2].ntryUsdFlg = FALSE;

      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
      return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * log command execution
 *-------------------------------------------------------------------
 */
#if defined SMI OR defined MFW OR defined FF_MMI_RIV
  {
  T_ACI_CLOG cmdLog;        /* holds logging info */

  cmdLog.atCmd                = AT_CMD_CCWA;
  cmdLog.cmdType              = CLOG_TYPE_Set;
  cmdLog.retCode              = AT_EXCT;
  cmdLog.cId                  = ACI_NumParmNotPresent;
  cmdLog.sId                  = sId1+1;
  cmdLog.cmdPrm.sCCWA.srcId   = srcId;
  cmdLog.cmdPrm.sCCWA.mode    = mode;
  cmdLog.cmdPrm.sCCWA.class_type = class_type;

  rAT_PercentCLOG( &cmdLog );
  }
#endif

  return( AT_EXCT );
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
| STATE   : code                  ROUTINE : sAT_PlusCUSD             |
+--------------------------------------------------------------------+

  PURPOSE : This is the functional counterpart to the +CUSD AT command
            which is responsible to invoke an unstructured
            supplementary services.

            <str> : USSD string.
            <dcs> : data coding scheme.
*/
LOCAL T_ACI_RETURN ussd_call_control_by_sim(T_ACI_CMD_SRC    srcId,
                                            T_ACI_USSD_DATA *str,
                                            SHORT            dcs)
{
  T_ACI_RETURN retCd = AT_CMPL;   /* holds return code */

#ifdef SIM_TOOLKIT
  T_sat_ussd    SATussd; /* to hold USSD string in case of SAT Control */
  T_CLPTY_PRM   *sat_ss_cldPty;

  if(!psaSIM_ChkSIMSrvSup( SRV_CalCntrl ))   /* call control by SAT enabled */
  {
    return(AT_CMPL);
  }

  if (psaSIM_ChkSIMSrvSup(SRV_USSDsupportInCC))
  {
    SATussd.dcs        = (UBYTE)dcs;
    SATussd.c_ussd_str = str->len;
    SATussd.ussd_str   = str->data;

    retCd = cmhSAT_USSDCntrlBySIM( &SATussd, (UBYTE)srcId );
  }
  else       /* USSD structure not known by SAT */
  {
    MALLOC(sat_ss_cldPty, sizeof(T_CLPTY_PRM));
    cmhCC_init_cldPty( sat_ss_cldPty );

    if( !utl_cvtGsmIra ( str -> data,
                         str->len,
                         (UBYTE *)sat_ss_cldPty->num,
                         MAX_USSD_DATA,
                         CSCS_DIR_IraToGsm ) )
    {
      TRACE_EVENT("utl_cvtGsmIra( ) returned FALSE");
      MFREE(sat_ss_cldPty);
      return( AT_FAIL );
    }
    retCd = cmhSAT_SSCntrlBySIM( sat_ss_cldPty, (UBYTE)srcId );
    MFREE(sat_ss_cldPty);
  }
  return( retCd );
#else
  return( AT_CMPL);
#endif /* of SIM_TOOLKIT */
}

GLOBAL T_ACI_RETURN sAT_PlusCUSD  ( T_ACI_CMD_SRC    srcId,
                                    T_ACI_USSD_DATA *str,
                                    SHORT            dcs)
{
  SHORT sId;            /* holds service id */
  T_ACI_RETURN retCd = AT_CMPL;   /* holds return code */
  UBYTE ussdLen;
  UBYTE *ussdString;
  UBYTE src_len;

  TRACE_FUNCTION ("sAT_PlusCUSD ()");

/*
 *-------------------------------------------------------------------
 * check command source
 *-------------------------------------------------------------------
 */
  if(!cmh_IsVldCmdSrc (srcId))
  {
    TRACE_EVENT_P1("Wrong source: %d", srcId);
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * check parameter str
 *-------------------------------------------------------------------
 */
  if( !str )
  {
    TRACE_EVENT("Empty string");
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * check parameter dcs
 *-------------------------------------------------------------------
 */
  if( dcs EQ ACI_NumParmNotPresent )

    dcs = 0;

/*
 *-------------------------------------------------------------------
 * check if there is a USSD request pending
 *-------------------------------------------------------------------
 */
  sId = psaSS_stbFindUssdReq();

  if( sId EQ NO_ENTRY )
  {
    /* check if there is another service in progress */
    if( psaSS_stbFindActSrv( sId ) NEQ NO_ENTRY )
    {
      TRACE_EVENT("Parallel USSD Transaction not allowed");
      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_ParallelUSSD );
      return( AT_FAIL );
    }

    /* get new service table entry */
    sId = psaSS_stbNewEntry();
    if( sId EQ NO_ENTRY )
    {
      TRACE_EVENT("Service table is full");
      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
      return( AT_FAIL );
    }

    /* check ussd call control by sim */
    retCd = ussd_call_control_by_sim(srcId, str, dcs);
    if(retCd NEQ AT_CMPL)
    {
      TRACE_EVENT_P1("ussd_call_control_by_sim() returned with %d", retCd);

      return( retCd );
    }

    CCD_START;

    MALLOC(ussdString, MAX_USSD_STRING);

    if( utl_getAlphabetCb( (UBYTE)dcs ) EQ 0 ) /* 7bit alphabet */
    {
      src_len = (UBYTE)MINIMUM( MAX_USSD_STRING, str->len);
      ussdLen = utl_cvt8To7( str->data,
                             src_len,
                             ussdString, 0 );
      /* According to spec 23.038 section 6.1.2.3 for USSD packing, for bytes end with
       * (8*n)-1 i.e where n is 1,2,3....i.e byte 7, 15, 23 ... to be padded 
       * with carriage return <CR>(0xD) 
       */
      if ((src_len+1)%8 EQ 0)
      {
        ussdString[ussdLen-1] |= (0xD << 1);
      }
    }
    else
    {
      ussdLen = str->len;
      memcpy(ussdString, str->data, MAX_USSD_STRING);
    }

    psaSS_asmProcUSSDReq( (UBYTE)dcs, ussdString, ussdLen );

    MFREE(ussdString);

    /* start new transaction */
    ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
    ssShrdPrm.stb[sId].curCmd     = AT_CMD_CUSD;
    ssShrdPrm.stb[sId].srvOwn     = srcId;
    psaSS_NewTrns(sId);

    CCD_END;

    retCd = AT_CMPL;


  }
  else
  {
    CCD_START;

    psaSS_asmCnfUSSDReq( (UBYTE)dcs, str->data, str->len );

    ssShrdPrm.stb[sId].ussdReqFlg = FALSE;

    /* continue existing transaction */
    psaSS_CntTrns(sId);

    CCD_END;

    retCd = AT_CMPL;
  }

  ssShrdPrm.ussdLen = 0;

  /* save ussd string for possible version 1 retry */
  if( cmhSMS_getAlphabetCb( (UBYTE)dcs ) EQ 0 )
  {
    if( str->len <= MAX_USSD_STRING )
    {
      ssShrdPrm.ussdLen = str->len;
      memcpy( ssShrdPrm.ussdBuf, str->data, str->len );
    }
  }

/*
 *-------------------------------------------------------------------
 * log command execution
 *-------------------------------------------------------------------
 */
#if defined SMI OR defined MFW OR defined FF_MMI_RIV
  {
  T_ACI_CLOG   cmdLog;  /* holds logging info */

  cmdLog.atCmd                = AT_CMD_CUSD;
  cmdLog.cmdType              = CLOG_TYPE_Set;
  cmdLog.retCode              = retCd;
  cmdLog.cId                  = ACI_NumParmNotPresent;
  cmdLog.sId                  = sId+1;
  cmdLog.cmdPrm.sCUSD.srcId   = srcId;
  cmdLog.cmdPrm.sCUSD.dcs     = dcs;
  cmdLog.cmdPrm.sCUSD.str     = str;

  rAT_PercentCLOG( &cmdLog );
  }
#endif

  return( retCd );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
| STATE   : code                  ROUTINE : sAT_PercentCCBS          |
+--------------------------------------------------------------------+

  PURPOSE : This is the functional counterpart to the %CCBS AT command
            which is responsible to clear CCBS entries. Index value set
            to 0 indicates clear all entries.

            <idx>   : ccbs index
*/

GLOBAL T_ACI_RETURN sAT_PercentCCBS( T_ACI_CMD_SRC srcId,
                                     SHORT         idx  )
{
  SHORT sId;         /* holds service id */

  T_ACI_RETURN   retVal;
 
  TRACE_FUNCTION ("sAT_PercentCCBS ()");

/*
 *-------------------------------------------------------------------
 * check command source
 *-------------------------------------------------------------------
 */
  if(!cmh_IsVldCmdSrc (srcId))
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * check parameter idx
 *-------------------------------------------------------------------
 */
  if( idx EQ ACI_NumParmNotPresent OR idx > 5 OR idx < 0 )
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

/* SIM TOOLKIT & FDN HANDLING */
    retVal = cmhSS_CCBS_SAT_Handle( srcId, CCFC_MOD_Erasure, idx);

    if( retVal NEQ AT_CMPL )
        return( retVal );
  

/*
 *-------------------------------------------------------------------
 * get a new service table entry to interrogate SS
 *-------------------------------------------------------------------
 */
  sId = psaSS_stbNewEntry();

  if( sId EQ NO_ENTRY )
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
    return( AT_FAIL );
  }

/*
 *-------------------------------------------------------------------
 * check parameter <mode>
 *-------------------------------------------------------------------
 */
  CCD_START;

  if( idx EQ 0 ) idx = KSD_IDX_NONE;

  psaSS_asmDeactivateCCBS((UBYTE)idx);

  ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
  ssShrdPrm.stb[sId].ssCode     = SS_CD_CCBS;
  ssShrdPrm.stb[sId].SSver      = SS_VERSION_3;

  ssShrdPrm.stb[sId].srvOwn     = srcId;

  ssShrdPrm.stb[sId].curCmd     = AT_CMD_CCBS;

  psaSS_NewTrns(sId);

  CCD_END;

/*
 *-------------------------------------------------------------------
 * log command execution
 *-------------------------------------------------------------------
 */
#if defined SMI OR defined MFW OR defined FF_MMI_RIV
  {
  T_ACI_CLOG cmdLog;        /* holds logging info */

  cmdLog.atCmd                = AT_CMD_CCBS;
  cmdLog.cmdType              = CLOG_TYPE_Set;
  cmdLog.retCode              = AT_EXCT;
  cmdLog.cId                  = ACI_NumParmNotPresent;
  cmdLog.sId                  = sId+1;
  cmdLog.cmdPrm.sCCBS.srcId   = srcId;
  cmdLog.cmdPrm.sCCBS.idx     = idx;

  rAT_PercentCLOG( &cmdLog );
  }
#endif

  return( AT_EXCT );
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
| STATE   : code                  ROUTINE : sAT_PercentCSCN          |
+--------------------------------------------------------------------+

  PURPOSE : This is the functional counterpart to the %CSCN AT command
            which is responsible to set the switches for debugging 
            mode at terminal interface.
*/
GLOBAL T_ACI_RETURN sAT_PercentCSCN ( T_ACI_CMD_SRC srcId,
                                   T_ACI_SS_CSCN_MOD_STATE     ss_switch,
                                   T_ACI_SS_CSCN_MOD_DIRECTION ss_direction,
                                   T_ACI_CC_CSCN_MOD_STATE     cc_switch,
                                   T_ACI_CC_CSCN_MOD_DIRECTION cc_direction )
{
  TRACE_FUNCTION ("sAT_PercentCSCN ()");

  if(!cmh_IsVldCmdSrc (srcId))  /* check command source */
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

  if (ss_switch NEQ SS_CSCN_MOD_STATE_INVALID)
    cmhPrm[srcId].ssCmdPrm.CSCNss_mode.SsCSCNModeState     = ss_switch;

  if (ss_direction NEQ SS_CSCN_MOD_DIR_INVALID)
    cmhPrm[srcId].ssCmdPrm.CSCNss_mode.SsCSCNModeDirection = ss_direction;

  if (cc_switch NEQ CC_CSCN_MOD_STATE_INVALID)
    cmhPrm[srcId].ccCmdPrm.CSCNcc_mode.CcCSCNModeState     = cc_switch;

  if (cc_direction NEQ CC_CSCN_MOD_DIR_INVALID)
    cmhPrm[srcId].ccCmdPrm.CSCNcc_mode.CcCSCNModeDirection = cc_direction;

  return( AT_CMPL );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
| STATE   : code                  ROUTINE : sAT_PercentCUSDR         |
+--------------------------------------------------------------------+

  PURPOSE : This is the functional counterpart to the %CUSDR AT command
            which is responsible for extended user/MMI response to n/w
            initaiated USSD.
*/
GLOBAL T_ACI_RETURN sAT_PercentCUSDR(T_ACI_CMD_SRC srcId, T_ACI_CUSDR_RES response)
{
  TRACE_FUNCTION ("sAT_PercentCUSDR()");

  if(!cmh_IsVldCmdSrc (srcId))  /* check command source */
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );
  }

  if(cuscfgParams.Ext_USSD_Response EQ CUSCFG_STAT_Disabled)
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
    return( AT_FAIL );
  }

  if(Ext_USSD_Res_Pending EQ CUSDR_EXT_USSD_RES_Not_Pending OR Ext_USSD_Res_Pending_sId EQ NOT_PRESENT_16BIT)
  {
    ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
    return( AT_FAIL );
  }

  switch(response)
  {
  case CUSDR_RES_Ok:
    if(Ext_USSD_Res_Pending NEQ CUSDR_EXT_USSD_RES_Request)
    {
      psaSS_asmEmptyRslt();
      psaSS_CntTrns(Ext_USSD_Res_Pending_sId);
    }
      Ext_USSD_Res_Pending = CUSDR_EXT_USSD_RES_Not_Pending;
      Ext_USSD_Res_Pending_sId = NOT_PRESENT_8BIT;
      return(AT_CMPL);

  case CUSDR_RES_Unknown_Alphabet:
    psaSS_asmErrorRslt( Ext_USSD_Res_Pending_sId, ERR_UNKNOWN_ALPHA );
    psaSS_CntTrns(Ext_USSD_Res_Pending_sId);
    ssShrdPrm.stb[Ext_USSD_Res_Pending_sId].ntryUsdFlg = FALSE;
    Ext_USSD_Res_Pending = CUSDR_EXT_USSD_RES_Not_Pending;
    Ext_USSD_Res_Pending_sId = NOT_PRESENT_8BIT;
    return(AT_CMPL);

  case CUSDR_RES_Busy:
    psaSS_asmErrorRslt( Ext_USSD_Res_Pending_sId, ERR_USSD_BUSY );
    psaSS_EndTrns(Ext_USSD_Res_Pending_sId);
    ssShrdPrm.stb[Ext_USSD_Res_Pending_sId].ntryUsdFlg = FALSE;
    Ext_USSD_Res_Pending = CUSDR_EXT_USSD_RES_Not_Pending;
    Ext_USSD_Res_Pending_sId = NOT_PRESENT_8BIT;
    return(AT_CMPL);

  default:
    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
    return( AT_FAIL );

  }

}


/*==== EOF ========================================================*/