--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-aci/aci/cmh_ssf.c	Tue Oct 11 02:02:43 2016 +0000
@@ -0,0 +1,3096 @@
+/*
++-----------------------------------------------------------------------------
+|  Project :  GSM-PS (6147)
+|  Modul   :  CMH_SSF
++-----------------------------------------------------------------------------
+|  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 defines the functions used by the command
+|             handler for the supplementary service module.
++-----------------------------------------------------------------------------
+*/
+#ifndef CMH_SSF_C
+#define CMH_SSF_C
+#endif
+#include "aci_all.h"
+/*==== INCLUDES ===================================================*/
+#include "aci_cmh.h"
+#include "ati_cmd.h"
+#include "aci_cmd.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 "pcm.h"
+#include "ksd.h"
+#include "aci.h"
+#include "psa.h"
+#include "psa_ss.h"
+#include "psa_sim.h"
+#include "psa_util.h"
+#include "cmh.h"
+#include "cmh_ss.h"
+#include "cmh_sim.h"
+#include "psa_cc.h"
+#include "psa_sat.h"
+
+#include "cl_imei.h"
+
+/* For SAT and FDN check */
+#include "cmh_cc.h"
+#include "cmh_sat.h"
+#include "phb.h"
+#include "aci_ext_pers.h"
+
+
+/*==== CONSTANTS ==================================================*/
+#ifdef SIM_TOOLKIT
+ /* cModMapTable maps Mode into SS Mode Code. */
+const T_IDX_TO_STR_MAP cModMapTable[]   = 
+                                  {{CCFC_MOD_Disable, "#"}, {CCFC_MOD_Enable, "*"}, {CCFC_MOD_Register, "**"}, 
+                                    {CCFC_MOD_Erasure, "##"}, {CCFC_MOD_Query, "*#"}, {NULL, NULL}}; 
+
+/* Call Forwarding */
+ /* cRsnMapTable maps Reason into SS Service Code. Must correspond to T_ACI_CCFC_RSN*/
+const T_IDX_TO_STR_MAP cCFRsnMapTable[] = 
+                                  {{CCFC_RSN_Uncond, "21"}, {CCFC_RSN_Busy, "67"}, {CCFC_RSN_NoReply, "61"},
+                                    {CCFC_RSN_NotReach, "62"}, {CCFC_RSN_Forward, "002"}, {CCFC_RSN_CondForward, "004"},
+                                    {NULL, NULL}};
+
+/* Call Barring */
+ /* cRsnMapTable maps Reason into SS Service Code. Must correspond to T_ACI_CLCK_FAC*/
+const T_IDX_TO_STR_MAP cCBRsnMapTable[] = 
+                                  {{FAC_Ao, "33"}, {FAC_Oi, "331"}, {FAC_Ox, "332"},
+                                    {FAC_Ai, "35"}, {FAC_Ir, "351"}, {FAC_Ab, "330"},
+                                    {FAC_Ag, "333"}, {FAC_Ac, "353"},
+                                    {NULL, NULL}};
+                                    
+
+const T_IDX_TO_DIG_MAP cCFBSMapTable[] = 
+                               {{CLASS_Vce, KSD_BS_Telephony}, {CLASS_Dat, KSD_BS_AllBearer}, {CLASS_VceDat, KSD_BS_Telephony},
+                                 {CLASS_Fax, KSD_BS_AllFax}, {CLASS_VceFax, KSD_BS_AllTeleXcptSMS}, {CLASS_DatFax, KSD_BS_AllFax}, 
+                                 {CLASS_VceDatFax, KSD_BS_AllTeleXcptSMS}, {CLASS_Sms, KSD_BS_SMS}, {CLASS_DatSms, KSD_BS_SMS},
+                                 {CLASS_VceDatFaxSms, KSD_BS_AllTele}, {CLASS_DatCirSync, KSD_BS_AllDataCircSync},
+                                 {CLASS_DatCirAsync, KSD_BS_AllDataCircAsync}, {CLASS_AllSync, KSD_BS_AllSync}, {CLASS_AllAsync, KSD_BS_AllAsync},
+                                 {CLASS_DedPacAccess, KSD_BS_AllDedPackAcc}, {CLASS_DedPADAcess, KSD_BS_AllDedPADAcc},
+                                 {CLASS_AuxVce, KSD_BS_PLMN1}, {NULL, NULL}};
+
+const T_IDX_TO_DIG_MAP cCFBSAllBearMapTable[] = 
+                               {{CLASS_VceDat, KSD_BS_AllBearer}, {CLASS_DatFax, KSD_BS_AllBearer}, {CLASS_VceDatFax, KSD_BS_AllBearer},
+                                 {CLASS_Sms, KSD_BS_AllBearer}, {CLASS_VceDatFaxSms, KSD_BS_AllBearer}, {NULL, NULL}};
+#endif /* SIM_TOOLKIT */
+
+/*==== TYPES ======================================================*/
+
+LOCAL UBYTE cmhSS_getSumOf2Digits ( UBYTE       digits );
+
+#if defined (SIM_PERS) || defined (FF_PHONE_LOCK)
+ T_ACI_RETURN cmhSS_check_oper_result(T_OPER_RET_STATUS result); 
+#endif
+
+/*==== EXPORT =====================================================*/
+
+
+/*==== VARIABLES ==================================================*/
+
+EXTERN T_PCEER causeMod;
+EXTERN SHORT causeCeer;
+
+/*==== FUNCTIONS ==================================================*/
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_GetClass               |
++-------------------------------------------------------------------+
+
+  PURPOSE : Get class value out of a basic service type.
+
+*/
+
+GLOBAL T_ACI_CLASS cmhSS_GetClass( T_basicService * bs )
+{
+  TRACE_FUNCTION ("cmhSS_GetClass()");
+
+  if( bs -> v_bearerService )
+  {
+    return( CLASS_Dat );
+  }
+
+  else if( bs -> v_teleservice )
+  {
+    switch( bs -> teleservice )
+    {
+      case( TS_CD_ALL_SPCH ):     return( CLASS_Vce );
+      case( TS_CD_ALL_FAX ):      return( CLASS_Fax );
+      case( TS_CD_ALL_XCPT_SMS ): return( CLASS_VceFax );
+      case( TS_CD_PLMN1 ):        return( CLASS_AuxVce );
+      default:                    return( CLASS_None );
+    }
+  }
+
+  else
+
+    return( CLASS_None );
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_GetClassLst            |
++-------------------------------------------------------------------+
+
+  PURPOSE : Get combined class value out of a basic service list.
+
+*/
+
+GLOBAL T_ACI_CLASS cmhSS_GetClassLst( T_basicServiceGroupList * bs )
+{
+  T_ACI_CLASS class_type = CLASS_None;
+  UBYTE       idx;
+
+  TRACE_FUNCTION ("cmhSS_GetClassLst()");
+
+  for (idx = 0; idx < bs -> c_basicServiceGroupList_value; idx++)
+  {
+    if( bs -> basicServiceGroupList_value[idx].v_bearerService )
+    {
+      switch(bs-> basicServiceGroupList_value[idx].bearerService)
+      {
+        case( BS_CD_ALL_DC_SYN ):     class_type |= CLASS_DatCirSync; break;
+        case( BS_CD_ALL_DC_ASYN ):    class_type |= CLASS_DatCirAsync; break;
+        case( BS_CD_ALL_DATA_PDS ):   class_type |= CLASS_DedPacAccess; break;
+        case( BS_CD_ALL_DATA_PAD ):   class_type |= CLASS_DedPADAcess; break;
+        default:                      class_type |= CLASS_Dat; break;
+      }
+    }
+  }
+
+  for (idx = 0; idx < bs -> c_basicServiceGroupList_value; idx++)
+  {
+    if( bs -> basicServiceGroupList_value[idx].v_teleservice )
+    {
+      switch( bs -> basicServiceGroupList_value[idx].teleservice )
+      {
+
+        case( TS_CD_ALL_SPCH ):     class_type |= CLASS_Vce; break;
+        case( TS_CD_ALL_FAX ):      class_type |= CLASS_Fax; break;
+        case( TS_CD_ALL_XCPT_SMS ): class_type |= CLASS_VceFax; break;
+        case( TS_CD_ALL_SMS ):
+        case( TS_CD_SMS_MT ):
+        case( TS_CD_SMS_MO ):       class_type |= CLASS_Sms; break;
+        case( TS_CD_PLMN1 ):        class_type |= CLASS_AuxVce; break;
+      }
+    }
+  }
+
+  return( class_type );
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_CheckClass             |
++-------------------------------------------------------------------+
+
+  PURPOSE : Check class value.
+
+*/
+
+GLOBAL BOOL cmhSS_CheckClassInterr( T_ACI_CLASS class_type)
+{
+  TRACE_FUNCTION ("cmhSS_CheckClassInterr()");
+
+  switch( class_type )
+  {
+  case( CLASS_None ):
+  case( CLASS_Vce ):
+  case( CLASS_Dat ):
+  case( CLASS_VceDat ):
+  case( CLASS_Fax ):
+  case( CLASS_VceFax ):
+  case( CLASS_DatFax ):
+  case( CLASS_NotPresent ):
+  case( CLASS_VceDatFax  ):
+  case( CLASS_DatCirSync ):
+  case( CLASS_DatCirAsync ):
+  case( CLASS_DedPacAccess ):
+  case( CLASS_AllSync ):
+  case( CLASS_AllAsync ):
+  case( CLASS_DedPADAcess ):
+  case( CLASS_AuxVce ):
+    return( TRUE );
+
+  default:
+    return( FALSE );
+  }
+}
+
+GLOBAL BOOL cmhSS_CheckCbClassInterr( T_ACI_CLASS class_type)
+{
+  TRACE_FUNCTION ("cmhSS_CheckClassInterr()");
+
+  switch( class_type )
+  {
+  case( CLASS_None ):
+  case( CLASS_Vce ):
+  case( CLASS_Dat ):
+  case( CLASS_VceDat ):
+  case( CLASS_Fax ):
+  case( CLASS_VceFax ):
+  case( CLASS_DatFax ):
+  case( CLASS_NotPresent ):
+  case( CLASS_VceDatFax  ):
+  case( CLASS_Sms ):
+  case( CLASS_VceSms ):
+  case( CLASS_DatSms ):
+  case( CLASS_VceDatSms ):
+  case( CLASS_FaxSms ):
+  case( CLASS_VceFaxSms ):
+  case( CLASS_DatFaxSms ):
+  case( CLASS_VceDatFaxSms ):
+  case( CLASS_DatCirSync ):
+  case( CLASS_DatCirAsync ):
+  case( CLASS_DedPacAccess ):
+  case( CLASS_AllSync ):
+  case( CLASS_AllAsync ):
+  case( CLASS_DedPADAcess ):
+  case( CLASS_AuxVce) :
+    return( TRUE );
+
+  default:
+    return( FALSE );
+  }
+}
+
+GLOBAL BOOL cmhSS_CheckClass( T_ACI_CLASS class_type,
+                              UBYTE *bs1, UBYTE *bst1,
+                              UBYTE *bs2, UBYTE *bst2,
+                              BOOL  *mltyTrnFlg )
+{
+  TRACE_FUNCTION ("cmhSS_CheckClass()");
+
+  *bs1 = *bs2 = *bst1 = *bst2 = SS_NO_PRM;
+  *mltyTrnFlg = FALSE;
+
+  switch( class_type )
+  {
+    case( CLASS_NotPresent ):
+    case( CLASS_None ):          *bs1 =                     *bst1 = SS_NO_PRM;
+      break;
+    case( CLASS_Vce ):           *bs1 = TS_CD_ALL_SPCH;     *bst1 = BS_TELE_SRV;
+      break;
+    case( CLASS_AuxVce ):        *bs1 = TS_CD_PLMN1;        *bst1 = BS_TELE_SRV;
+      break;
+    case( CLASS_Dat ):           *bs1 = BS_CD_ALL_BS;       *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_VceDat ):        *bs1 = TS_CD_ALL_SPCH;     *bst1 = BS_TELE_SRV;
+                                 *bs2 = BS_CD_ALL_BS;       *bst2 = BS_BEAR_SRV;
+                                 *mltyTrnFlg = TRUE;
+      break;
+    case( CLASS_Fax ):           *bs1 = TS_CD_ALL_FAX;      *bst1 = BS_TELE_SRV;
+      break;
+    case( CLASS_VceFax ):        *bs1 = TS_CD_ALL_XCPT_SMS; *bst1 = BS_TELE_SRV;
+      break;
+    case( CLASS_DatFax ):        *bs1 = TS_CD_ALL_FAX;      *bst1 = BS_TELE_SRV;
+                                 *bs2 = BS_CD_ALL_BS;       *bst2 = BS_BEAR_SRV;
+                                 *mltyTrnFlg = TRUE;
+      break;
+
+    case( CLASS_VceDatFax  ):    *bs1 = TS_CD_ALL_XCPT_SMS; *bst1 = BS_TELE_SRV;
+                                 *bs2 = BS_CD_ALL_BS;       *bst2 = BS_BEAR_SRV;
+                                 *mltyTrnFlg = TRUE;
+      break;
+    case( CLASS_DatCirSync ):
+                                 *bs1 = BS_CD_ALL_DC_SYN;   *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_DatCirAsync ):
+                                 *bs1 = BS_CD_ALL_DC_ASYN;  *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_DedPacAccess ):
+                                 *bs1 = BS_CD_ALL_DATA_PDS; *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_AllSync ):
+                                 *bs1 = BS_CD_ALL_SYN;      *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_AllAsync ):
+                                 *bs1 = BS_CD_ALL_ASYN;     *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_DedPADAcess ):
+                                 *bs1 = BS_CD_ALL_DATA_PAD; *bst1 = BS_BEAR_SRV;
+      break;
+  default:
+    return( FALSE );
+  }
+
+  return( TRUE );
+}
+
+GLOBAL BOOL cmhSS_CheckCbClass( T_ACI_CLASS class_type,
+                                UBYTE *bs1, UBYTE *bst1,
+                                UBYTE *bs2, UBYTE *bst2,
+                                BOOL  *mltyTrnFlg )
+{
+  TRACE_FUNCTION ("cmhSS_CheckCBClass()");
+
+  *bs1 = *bs2 = *bst1 = *bst2 = SS_NO_PRM;
+  *mltyTrnFlg = FALSE;
+
+  switch( class_type )
+  {
+    case CLASS_NotPresent:
+    case CLASS_None:             *bs1 =                     *bst1 = SS_NO_PRM;
+      break;
+    case CLASS_Vce:              *bs1 = TS_CD_ALL_SPCH;     *bst1 = BS_TELE_SRV;
+      break;
+    case CLASS_AuxVce:           *bs1 = TS_CD_PLMN1;        *bst1 = BS_TELE_SRV;
+      break;
+    case CLASS_Dat :             *bs1 = BS_CD_ALL_BS;       *bst1 = BS_BEAR_SRV;
+      break;
+    case CLASS_VceDat:           *bs1 = TS_CD_ALL_SPCH;     *bst1 = BS_TELE_SRV;
+                                 *bs2 = BS_CD_ALL_BS;       *bst2 = BS_BEAR_SRV;
+                                 *mltyTrnFlg = TRUE;
+      break;
+    case CLASS_Fax:              *bs1 = TS_CD_ALL_FAX;      *bst1 = BS_TELE_SRV;
+      break;
+    case CLASS_VceFax:           *bs1 = TS_CD_ALL_XCPT_SMS; *bst1 = BS_TELE_SRV;
+      break;
+    case CLASS_DatFax:           *bs1 = TS_CD_ALL_FAX;      *bst1 = BS_TELE_SRV;
+                                 *bs2 = BS_CD_ALL_BS;       *bst2 = BS_BEAR_SRV;
+                                 *mltyTrnFlg = TRUE;
+      break;
+    case CLASS_VceDatFax:        *bs1 = TS_CD_ALL_XCPT_SMS; *bst1 = BS_TELE_SRV;
+                                 *bs2 = BS_CD_ALL_BS;       *bst2 = BS_BEAR_SRV;
+                                 *mltyTrnFlg = TRUE;
+      break;
+    case CLASS_Sms:              *bs1 = TS_CD_ALL_SMS;      *bst1 = BS_TELE_SRV;
+      break;
+    case CLASS_DatSms:           *bs1 = TS_CD_ALL_SMS;     *bst1 = BS_TELE_SRV;
+                                 *bs2 = BS_CD_ALL_BS;       *bst2 = BS_BEAR_SRV;
+                                 *mltyTrnFlg = TRUE;
+      break;
+    case CLASS_VceDatFaxSms:     *bs1 = TS_CD_ALL_TS;       *bst1 = BS_TELE_SRV;
+                                 *bs2 = BS_CD_ALL_BS;       *bst2 = BS_BEAR_SRV;
+                                 *mltyTrnFlg = TRUE;
+      break;
+    case( CLASS_DatCirSync ):
+                                 *bs1 = BS_CD_ALL_DC_SYN;   *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_DatCirAsync ):
+                                 *bs1 = BS_CD_ALL_DC_ASYN;  *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_DedPacAccess ):
+                                 *bs1 = BS_CD_ALL_DATA_PDS; *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_AllSync ):
+                                 *bs1 = BS_CD_ALL_SYN;      *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_AllAsync ):
+                                 *bs1 = BS_CD_ALL_ASYN;     *bst1 = BS_BEAR_SRV;
+      break;
+    case( CLASS_DedPADAcess ):
+                                 *bs1 = BS_CD_ALL_DATA_PAD; *bst1 = BS_BEAR_SRV;
+      break;
+    
+    case CLASS_VceSms:
+    case CLASS_VceDatSms:
+    case CLASS_FaxSms:
+    case CLASS_VceFaxSms:
+    case CLASS_DatFaxSms:
+      return( FALSE );
+
+    default:
+      return( FALSE );
+  }
+
+
+  return( TRUE );
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_CheckBscSrv            |
++-------------------------------------------------------------------+
+
+  PURPOSE : Check basic service value.
+
+*/
+
+GLOBAL BOOL cmhSS_CheckBscSrv ( UBYTE bsCd,
+                                UBYTE *bs, UBYTE *bst, T_ACI_CLASS *class_type )
+{
+  T_ACI_CLASS dummy_class;
+
+  TRACE_FUNCTION ("cmhSS_CheckBscSrv()");
+
+  if(class_type EQ NULL)
+  {
+    class_type = &dummy_class;
+  }
+
+  *bs = *bst = SS_NO_PRM;
+  *class_type = CLASS_None;
+
+  switch( bsCd )
+  {
+  case( KSD_BS_None ):
+  case( KSD_BS_AllTeleAllBearer ): /* no code required */
+    *class_type = (T_ACI_CLASS)(CLASS_VceDatFaxSms + CLASS_AuxVce);
+    break;
+  case( KSD_BS_AllTele ):          *bs = TS_CD_ALL_TS;       *bst = BS_TELE_SRV;  
+    *class_type =(T_ACI_CLASS)( CLASS_VceFaxSms + CLASS_AuxVce);
+    break;
+  /* For MMI service Code Telephony, use the corresponding Service Group
+     "Speech"... The MS shall always send the Service Group... See GSM: 03.11 */
+  case( KSD_BS_Telephony ):        *bs = TS_CD_ALL_SPCH;     *bst = BS_TELE_SRV;  
+    *class_type =(T_ACI_CLASS) (CLASS_Vce + CLASS_AuxVce);
+    break;
+  case( KSD_BS_AllData ):          *bs = TS_CD_ALL_DATA;     *bst = BS_TELE_SRV;  *class_type = CLASS_Dat;
+    break;
+  case( KSD_BS_AllFax ):           *bs = TS_CD_ALL_FAX;      *bst = BS_TELE_SRV;  *class_type = CLASS_Fax;
+    break;
+  case( KSD_BS_SMS ):              *bs = TS_CD_ALL_SMS;      *bst = BS_TELE_SRV;  *class_type = CLASS_Sms;
+    break;
+  case( KSD_BS_VoiceGroup ):       *bs = TS_CD_ALL_SPCH;     *bst = BS_TELE_SRV;  
+    *class_type = (T_ACI_CLASS)(CLASS_Vce + CLASS_AuxVce);
+    break;
+  case( KSD_BS_AllTeleXcptSMS ):   *bs = TS_CD_ALL_XCPT_SMS; *bst = BS_TELE_SRV; 
+    *class_type = (T_ACI_CLASS)(CLASS_VceFax  + CLASS_AuxVce);
+    break;
+  case( KSD_BS_AllBearer ):        *bs = BS_CD_ALL_BS;       *bst = BS_BEAR_SRV;  *class_type = CLASS_Dat;
+    break;
+  case( KSD_BS_AllAsync ):         *bs = BS_CD_ALL_ASYN;     *bst = BS_BEAR_SRV;  *class_type = CLASS_Dat;
+    break;
+  case( KSD_BS_AllSync ):          *bs = BS_CD_ALL_SYN;      *bst = BS_BEAR_SRV;  *class_type = CLASS_Dat;
+    break;
+  case( KSD_BS_AllDataCircSync ):  *bs = BS_CD_ALL_DC_SYN;   *bst = BS_BEAR_SRV;  *class_type = CLASS_Dat;
+    break;
+  case( KSD_BS_AllDataCircAsync ): *bs = BS_CD_ALL_DC_ASYN;  *bst = BS_BEAR_SRV;  *class_type = CLASS_Dat;
+    break;
+  case( KSD_BS_AllDedPackAcc ):    *bs = BS_CD_ALL_DATA_PDS; *bst = BS_BEAR_SRV;  *class_type = CLASS_Dat;
+    break;
+  case( KSD_BS_AllDedPADAcc ):     *bs = BS_CD_ALL_DATA_PAD; *bst = BS_BEAR_SRV;  *class_type = CLASS_Dat;
+    break;
+  case( KSD_BS_AllPLMNSpecTele ):  *bs = TS_CD_ALL_PSSS; *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele1 ):    *bs = TS_CD_PLMN1;    *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele2 ):    *bs = TS_CD_PLMN2;    *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele3 ):    *bs = TS_CD_PLMN3;    *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele4 ):    *bs = TS_CD_PLMN4;    *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele5 ):    *bs = TS_CD_PLMN5;    *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele6 ):    *bs = TS_CD_PLMN6;    *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele7 ):    *bs = TS_CD_PLMN7;    *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele8 ):    *bs = TS_CD_PLMN8;    *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele9 ):    *bs = TS_CD_PLMN9;    *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele10 ):   *bs = TS_CD_PLMNA;   *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele11 ):   *bs = TS_CD_PLMNB;   *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele12 ):   *bs = TS_CD_PLMNC;   *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele13 ):   *bs = TS_CD_PLMND;   *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele14 ):   *bs = TS_CD_PLMNE;   *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_PLMNSpecTele15 ):   *bs = TS_CD_PLMNF;   *bst = BS_TELE_SRV;
+    break;
+  case( KSD_BS_AllPLMNSpecBearer ):*bs = BS_CD_ALL_PSSS; *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer1 ):  *bs = BS_CD_PLMN1;    *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer2 ):  *bs = BS_CD_PLMN2;    *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer3 ):  *bs = BS_CD_PLMN3;    *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer4 ):  *bs = BS_CD_PLMN4;    *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer5 ):  *bs = BS_CD_PLMN5;    *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer6 ):  *bs = BS_CD_PLMN6;    *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer7 ):  *bs = BS_CD_PLMN7;    *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer8 ):  *bs = BS_CD_PLMN8;    *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer9 ):  *bs = BS_CD_PLMN9;    *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer10 ): *bs = BS_CD_PLMNA;   *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer11 ): *bs = BS_CD_PLMNB;   *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer12 ): *bs = BS_CD_PLMNC;   *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer13 ): *bs = BS_CD_PLMND;   *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer14 ): *bs = BS_CD_PLMNE;   *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_PLMNSpecBearer15 ): *bs = BS_CD_PLMNF;   *bst = BS_BEAR_SRV;
+    break;
+  case( KSD_BS_AuxTelephony     ): *bs = TS_CD_PLMN1;   *bst = BS_TELE_SRV;  *class_type = CLASS_AuxVce;
+    break;
+
+  default:
+
+    return( FALSE );
+  }
+
+
+  return( TRUE );
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_GetBscSrv              |
++-------------------------------------------------------------------+
+
+  PURPOSE : Get basic service code out of a basic service type.
+
+*/
+
+GLOBAL void cmhSS_GetBscSrv( T_basicService * p, UBYTE * bs,
+                             UBYTE * bst )
+{
+  TRACE_FUNCTION ("cmhSS_GetBscSrv()");
+
+  if( p -> v_bearerService )
+  {
+    *bst = KSD_BS_TP_Bearer;
+    *bs  = p -> bearerService;
+  }
+
+  else if( p -> v_teleservice )
+  {
+    *bst = KSD_BS_TP_Tele;
+    *bs  = p -> teleservice;
+  }
+
+  else
+  {
+    *bst = KSD_BS_None;
+    *bs  = KSD_BS_TeleBearerUnknown;
+  }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmhSS_flagTrn           |
++-------------------------------------------------------------------+
+
+  PURPOSE : flag a call for multy-transaction operation
+
+*/
+
+GLOBAL void cmhSS_flagTrn ( SHORT sId, USHORT * flags )
+{
+  *flags |= (0x1 << sId);
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_F                   |
+|                                 ROUTINE : cmhSS_tstAndUnflagTrn   |
++-------------------------------------------------------------------+
+
+  PURPOSE : test and unflag a call for multy-transaction operation.
+            Return the test result.
+
+*/
+
+GLOBAL BOOL cmhSS_tstAndUnflagTrn ( SHORT sId, USHORT * flags )
+{
+  if( *flags & (1u << sId))
+  {
+    *flags &= ~(1u << sId);
+    return( TRUE );
+  }
+  return( FALSE );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdCF              |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function invokes the operation for key sequence
+            command for call forwarding supplementary services.
+*/
+
+GLOBAL T_ACI_RETURN cmhSS_ksdCF  ( T_ACI_CMD_SRC srcId,
+                                   T_ACI_KSD_CF_PRM * cfPrm )
+{
+  SHORT sId;                /* holds service id */
+  UBYTE bst;                /* holds basic service type */
+  UBYTE bs;                 /* holds basic service */
+  T_ACI_CLASS user_class;
+
+  TRACE_FUNCTION ("cmhSS_ksdCF");
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter ss code
+ *-------------------------------------------------------------------
+ */
+  switch( cfPrm->ssCd )
+  {
+    case( KSD_SS_CFU       ):
+    case( KSD_SS_CFB       ):
+    case( KSD_SS_CFNRY     ):
+    case( KSD_SS_CFNRC     ):
+    case( KSD_SS_ALL_FWSS  ):
+    case( KSD_SS_ALL_CFWSS ):
+
+      break;
+
+    default:
+
+      return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter basic service code
+ *-------------------------------------------------------------------
+ */
+  if( !cmhSS_CheckBscSrv( cfPrm->bsCd, &bs, &bst, &user_class ))
+
+    return( AT_FAIL );
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter <class> against possible ALS-Lock
+ *-------------------------------------------------------------------
+ */
+  if ((ALSlock EQ ALS_MOD_SPEECH     AND user_class EQ  CLASS_AuxVce) OR
+      (ALSlock EQ ALS_MOD_AUX_SPEECH AND user_class NEQ CLASS_AuxVce))
+  {
+    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_AlsLock );
+    return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * get a new service table entry
+ *-------------------------------------------------------------------
+ */
+  sId = psaSS_stbNewEntry();
+
+  if( sId EQ NO_ENTRY )
+  {
+    return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter operation code
+ *-------------------------------------------------------------------
+ */
+  CCD_START;
+
+  switch( cfPrm->opCd )
+  {
+    /* interrogate call forwarding service */
+    case( KSD_OP_IRGT  ):
+      psaSS_asmInterrogateSS( cfPrm->ssCd, bst, bs );
+      break;
+
+    /* register call forwarding service */
+    case( KSD_OP_REG   ):
+
+      psaSS_asmRegisterSS( cfPrm->ssCd, bst, bs,
+                           cfPrm->ton, cfPrm->npi, cfPrm->num,
+                           cfPrm->tos, cfPrm->oe,  cfPrm->sub,
+                           cfPrm->time );
+      break;
+
+    /* erase call forwarding service */
+    case( KSD_OP_ERS   ):
+      psaSS_asmEraseSS( cfPrm->ssCd, bst, bs );
+      break;
+
+    /* activate call forwarding service */
+    case( KSD_OP_ACT   ):
+      psaSS_asmActivateSS( cfPrm->ssCd, bst, bs );
+      break;
+
+    /* deactivate call forwarding service */
+    case( KSD_OP_DEACT ):
+      psaSS_asmDeactivateSS( cfPrm->ssCd, bst, bs );
+      break;
+
+    /* unexpected operation code */
+    default:
+
+      CCD_END;
+      return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * start transaction
+ *-------------------------------------------------------------------
+ */
+  ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
+  ssShrdPrm.stb[sId].ssCode     = cfPrm->ssCd;
+  ssShrdPrm.stb[sId].orgOPC     = cfPrm->opCd;
+  ssShrdPrm.stb[sId].opCode     = cfPrm->opCd;
+  ssShrdPrm.stb[sId].srvOwn     = (T_OWN)srcId;
+  ssShrdPrm.stb[sId].ClassType  = user_class;
+
+  TRACE_EVENT_P1("USER_CLASS: %d", user_class);
+
+  ssShrdPrm.stb[sId].curCmd     = (T_ACI_AT_CMD)KSD_CMD_CF;
+
+  psaSS_NewTrns(sId);
+
+  CCD_END;
+/*
+ *-------------------------------------------------------------------
+ * log command execution
+ *-------------------------------------------------------------------
+ */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
+  {
+  T_ACI_CLOG cmdLog;        /* holds logging info */
+
+  cmdLog.atCmd                = (T_ACI_AT_CMD) KSD_CMD_CF;
+  cmdLog.cmdType              = CLOG_TYPE_Set;
+  cmdLog.retCode              = AT_EXCT;
+  cmdLog.cId                  = ACI_NumParmNotPresent;
+  cmdLog.sId                  = sId+1;
+  cmdLog.cmdPrm.sKSCF.srcId   = srcId;
+  cmdLog.cmdPrm.sKSCF.opCd    = cfPrm->opCd;
+  cmdLog.cmdPrm.sKSCF.ssCd    = cfPrm->ssCd;
+  cmdLog.cmdPrm.sKSCF.bsTp    = bst;
+  cmdLog.cmdPrm.sKSCF.bsCd    = bs;
+  cmdLog.cmdPrm.sKSCF.num     = cfPrm->num;
+  cmdLog.cmdPrm.sKSCF.ton     = cfPrm->ton;
+  cmdLog.cmdPrm.sKSCF.npi     = cfPrm->npi;
+  cmdLog.cmdPrm.sKSCF.sub     = cfPrm->sub;
+  cmdLog.cmdPrm.sKSCF.tos     = cfPrm->tos;
+  cmdLog.cmdPrm.sKSCF.oe      = cfPrm->oe;
+  cmdLog.cmdPrm.sKSCF.time    = cfPrm->time;
+
+  rAT_PercentCLOG( &cmdLog );
+  }
+#endif
+
+  return( AT_EXCT );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdPW              |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function invokes the operation for key sequence
+            command for password registration supplementary services.
+*/
+
+GLOBAL T_ACI_RETURN cmhSS_ksdPW  ( T_ACI_CMD_SRC srcId,
+                                   T_ACI_KSD_PWD_PRM * pwPrm )
+{
+  SHORT sId=NO_ENTRY;           /* holds service id */
+
+  TRACE_FUNCTION ("cmhSS_ksdPW");
+
+/*
+ *-------------------------------------------------------------------
+ * check password parameter
+ *-------------------------------------------------------------------
+ */
+  if( !pwPrm->oldPwd OR !pwPrm->newPwd )
+  {
+    TRACE_EVENT("parameters are missing");
+    return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter ss code
+ *-------------------------------------------------------------------
+ */
+  switch( pwPrm->ssCd )
+  {
+    /*
+     *-------------------------------------------------------------------
+     * if password relates to SS
+     *-------------------------------------------------------------------
+     */
+    case( KSD_SS_BOC      ):
+    case( KSD_SS_BOICXH   ):
+    case( KSD_SS_BOIC     ):
+    case( KSD_SS_ALL_CBSS ):
+    case( KSD_SS_BAOC     ):
+    case( KSD_SS_BIC      ):
+    case( KSD_SS_BAIC     ):
+    case( KSD_SS_BICRM    ):
+    case( KSD_SS_NONE     ):
+    case( KSD_SS_ALL_SERV ):
+
+
+    /*
+     *-------------------------------------------------------------------
+     * check password length
+     *-------------------------------------------------------------------
+     */
+      if( strlen( (char *) pwPrm->oldPwd ) > MAX_PWD_NUM  OR
+          strlen( (char *) pwPrm->newPwd ) > MAX_PWD_NUM  OR
+          strlen( (char *) pwPrm->newPwd2) > MAX_PWD_NUM     )
+      {
+        TRACE_EVENT("password too long");
+        return( AT_FAIL );
+      }
+
+    /*
+     *-------------------------------------------------------------------
+     * get a new service table entry
+     *-------------------------------------------------------------------
+     */
+      sId = psaSS_stbNewEntry();
+
+      if( sId EQ NO_ENTRY )
+      {
+        return( AT_FAIL );
+      }
+
+    /*
+     *-------------------------------------------------------------------
+     * check parameter operation code
+     *-------------------------------------------------------------------
+     */
+      CCD_START;
+
+      psaSS_asmRegisterPWD( pwPrm->ssCd );
+
+    /*
+     *-------------------------------------------------------------------
+     * start transaction
+     *-------------------------------------------------------------------
+     */
+      ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
+      ssShrdPrm.stb[sId].ssCode     = pwPrm->ssCd;
+      ssShrdPrm.stb[sId].orgOPC     = KSD_OP_REG;
+      ssShrdPrm.stb[sId].opCode     = KSD_OP_REG;
+      ssShrdPrm.stb[sId].srvOwn     = (T_OWN)srcId;
+
+      ssShrdPrm.stb[sId].curCmd     = (T_ACI_AT_CMD)KSD_CMD_PWD;
+
+      psaSS_NewTrns(sId);
+
+      CCD_END;
+
+    /*
+     *-------------------------------------------------------------------
+     * store passwords for later use
+     *-------------------------------------------------------------------
+     */
+      strncpy
+      (
+        (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
+        (char *) pwPrm->oldPwd,
+        MAX_PWD_NUM
+      );
+      cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
+
+      strncpy
+      (
+        (char *) cmhPrm[srcId].ssCmdPrm.CXXXnewPwd,
+        (char *) pwPrm->newPwd,
+        MAX_PWD_NUM
+      );
+      cmhPrm[srcId].ssCmdPrm.CXXXnewPwd[MAX_PWD_NUM] = '\0';
+
+      strncpy
+      (
+        (char *) cmhPrm[srcId].ssCmdPrm.CXXXnewPwd2,
+        (char *) pwPrm->newPwd2,
+        MAX_PWD_NUM
+      );
+      cmhPrm[srcId].ssCmdPrm.CXXXnewPwd2[MAX_PWD_NUM] = '\0';
+      break;
+
+    /*
+     *-------------------------------------------------------------------
+     * if password relates to SIM
+     *-------------------------------------------------------------------
+     */
+    case( KSD_SS_PIN1     ):
+    case( KSD_SS_PIN2     ):
+
+      if( simEntStat.curCmd NEQ AT_CMD_NONE )
+
+        return( AT_BUSY );
+
+      if( strlen( (char *) pwPrm->oldPwd ) > PIN_LEN  OR
+          strlen( (char *) pwPrm->newPwd ) > PIN_LEN     )
+
+        return( AT_FAIL );
+
+      /* Marcus: Issue 1589: 28/01/2003: Start */
+      if( strlen( (char *) pwPrm->oldPwd ) < MIN_PIN_LEN  OR
+          strlen( (char *) pwPrm->newPwd ) < MIN_PIN_LEN     )
+
+        return( AT_FAIL );
+      /* Marcus: Issue 1589: 28/01/2003: End */
+
+      /* if newPwd2 (verify new PIN ) is given, then check if
+         newPwd2 is identical with newPwd */
+      if( strlen( (char *) pwPrm->newPwd2 ) > 0 )
+      {
+        if( strlen( (char *) pwPrm->newPwd ) > PIN_LEN )
+        {
+          return( AT_FAIL );
+        }
+        if( strcmp((char *)pwPrm->newPwd, (char *)pwPrm->newPwd2) )
+        {
+          TRACE_EVENT_P2("new PIN (%s) differs from verify new PIN (%s)",
+            (char *)pwPrm->newPwd, (char *)pwPrm->newPwd2 );
+          ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd);
+          return( AT_FAIL );
+        }
+      }
+
+      cmhSIM_FillInPIN ( (char *) pwPrm->oldPwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );
+      cmhSIM_FillInPIN ( (char *) pwPrm->newPwd, simShrdPrm.setPrm[srcId].newPIN, PIN_LEN );
+
+      simShrdPrm.setPrm[srcId].PINType = (pwPrm->ssCd EQ KSD_SS_PIN1)?
+                                 PHASE_2_PIN_1:PHASE_2_PIN_2;
+
+      if ( simShrdPrm.setPrm[srcId].PINType EQ PHASE_2_PIN_1 AND
+           simShrdPrm.PEDStat               EQ PEDS_DIS )
+      {
+        TRACE_EVENT( "FATAL RETURN PIN not enabled" );
+        return( AT_FAIL );
+      }
+
+      simEntStat.curCmd     = (T_ACI_AT_CMD)KSD_CMD_PWD;
+      simShrdPrm.owner     = (T_OWN)srcId;
+      simEntStat.entOwn     =  srcId;
+
+      if( psaSIM_ChangePIN() < 0 )  /* change PIN */
+      {
+        TRACE_EVENT( "FATAL RETURN psaSIM in key sequence" );
+        return( AT_FAIL );
+      }
+      break;
+
+    default:
+      TRACE_EVENT("unexpected SS code");
+      return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * log command execution
+ *-------------------------------------------------------------------
+ */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
+  {
+  T_ACI_CLOG cmdLog;        /* holds logging info */
+
+  cmdLog.atCmd                = (T_ACI_AT_CMD)KSD_CMD_PWD;
+  cmdLog.cmdType              = CLOG_TYPE_Set;
+  cmdLog.retCode              = AT_EXCT;
+  cmdLog.cId                  = ACI_NumParmNotPresent;
+  cmdLog.sId                  = sId+1;
+  cmdLog.cmdPrm.sKSPW.srcId   = srcId;
+  cmdLog.cmdPrm.sKSPW.ssCd    = pwPrm->ssCd;
+  cmdLog.cmdPrm.sKSPW.oldPwd  = pwPrm->oldPwd;
+  cmdLog.cmdPrm.sKSPW.newPwd  = pwPrm->newPwd;
+
+  rAT_PercentCLOG( &cmdLog );
+  }
+#endif
+
+  return( AT_EXCT );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdUSSD            |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function invokes the operation for key sequence
+            command for unstructured supplementary services.
+*/
+
+GLOBAL T_ACI_RETURN cmhSS_ksdUSSD  ( T_ACI_CMD_SRC srcId,
+                                     T_ACI_KSD_USSD_PRM * ussdPrm )
+{
+  SHORT sId;                /* holds service id */
+  T_ACI_RETURN retCd;       /* holds return code */
+  UBYTE ussdLen;
+  UBYTE *ussdString;
+  UBYTE src_len;
+
+  TRACE_FUNCTION ("cmhSS_ksdUSSD");
+
+/*
+ *-------------------------------------------------------------------
+ * check for ussd string
+ *-------------------------------------------------------------------
+ */
+  if( !ussdPrm->ussd )
+
+    return( AT_FAIL );
+
+/*
+ *-------------------------------------------------------------------
+ * get a new service table entry
+ *-------------------------------------------------------------------
+ */
+  sId = psaSS_stbNewEntry();
+
+  if( sId EQ NO_ENTRY )
+  {
+    return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter operation code
+ *-------------------------------------------------------------------
+ */
+  sId = psaSS_stbFindUssdReq();
+
+  if( sId EQ NO_ENTRY )
+  {
+    /* check if there is another service in progress */
+    if( psaSS_stbFindActSrv( sId ) NEQ NO_ENTRY )
+      return( AT_FAIL );
+
+    /* get new service table entry */
+    sId = psaSS_stbNewEntry();
+    if( sId EQ NO_ENTRY ) return( AT_FAIL );
+
+    ssShrdPrm.ussdLen = strlen((char *)ussdPrm->ussd);
+
+    if( !utl_cvtGsmIra ( ussdPrm->ussd,
+                         ssShrdPrm.ussdLen,
+                         ssShrdPrm.ussdBuf,
+                         MAX_USSD_DATA,
+                         CSCS_DIR_IraToGsm ) ) return( AT_FAIL );
+    CCD_START;
+
+    MALLOC(ussdString, MAX_USSD_STRING);
+
+    src_len = (UBYTE)MINIMUM( MAX_USSD_STRING, ssShrdPrm.ussdLen); 
+    /* to be sent as dcs = 0x0F: so always pack */
+    ussdLen = utl_cvt8To7( ssShrdPrm.ussdBuf,
+                           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);
+    }
+
+    psaSS_asmProcUSSDReq( 0x0F, ussdString, ussdLen );
+
+    MFREE(ussdString);
+
+    /* start new transaction */
+    ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
+    ssShrdPrm.stb[sId].curCmd     = (T_ACI_AT_CMD)KSD_CMD_USSD;
+    ssShrdPrm.stb[sId].srvOwn     = (T_OWN)srcId;
+    psaSS_NewTrns(sId);
+
+    CCD_END;
+
+    if(satShrdPrm.SIMCCParm.owner EQ OWN_SRC_SAT)
+    {
+      TRACE_EVENT("OWN_SRC_SAT in ksdUSSD");
+      /* some more info needed if sat initiated USSD*/
+      satShrdPrm.SentUSSDid = sId;
+    }
+    retCd = AT_CMPL;
+  }
+  else
+  {
+    ssShrdPrm.ussdLen = strlen((char *)ussdPrm->ussd);
+
+    if( !utl_cvtGsmIra ( ussdPrm->ussd,
+                         ssShrdPrm.ussdLen,
+                         ssShrdPrm.ussdBuf,
+                         MAX_USSD_DATA,
+                         CSCS_DIR_IraToGsm ) ) return( AT_FAIL );
+
+    CCD_START;
+
+    psaSS_asmCnfUSSDReq( 0x0F, ssShrdPrm.ussdBuf, ssShrdPrm.ussdLen );
+
+    ssShrdPrm.stb[sId].ussdReqFlg = FALSE;
+
+    /* continue existing transaction */
+    psaSS_CntTrns(sId);
+
+    CCD_END;
+
+    retCd = AT_CMPL;
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * log command execution
+ *-------------------------------------------------------------------
+ */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
+  {
+  T_ACI_CLOG cmdLog;        /* holds logging info */
+
+  cmdLog.atCmd                = (T_ACI_AT_CMD)KSD_CMD_USSD;
+  cmdLog.cmdType              = CLOG_TYPE_Set;
+  cmdLog.retCode              = retCd;
+  cmdLog.cId                  = ACI_NumParmNotPresent;
+  cmdLog.sId                  = sId+1;
+  cmdLog.cmdPrm.sKSUS.srcId   = srcId;
+  cmdLog.cmdPrm.sKSUS.ussd    = ussdPrm->ussd;
+
+  rAT_PercentCLOG( &cmdLog );
+  }
+#endif
+
+  return( retCd );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdUBLK            |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function invokes the operation for key sequence
+            command for unblocking PIN.
+*/
+
+GLOBAL T_ACI_RETURN cmhSS_ksdUBLK  ( T_ACI_CMD_SRC srcId,
+                                     T_ACI_KSD_UBLK_PRM * ublkPrm )
+{
+  TRACE_FUNCTION ("cmhSS_ksdUBLK");
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter puk
+ *-------------------------------------------------------------------
+ */
+  if( !ublkPrm->puk OR strlen( (char *) ublkPrm->puk ) NEQ PUK_LEN )
+
+    return( AT_FAIL );
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter pin
+ *-------------------------------------------------------------------
+ */
+  if( !ublkPrm->pin OR strlen( (char *) ublkPrm->pin ) > PIN_LEN
+                    OR strlen( (char *) ublkPrm->pin ) < MIN_PIN_LEN)
+
+    return( AT_FAIL );
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter ss code
+ *-------------------------------------------------------------------
+ */
+  switch( ublkPrm->ssCd )
+  {
+    case( KSD_SS_PIN1     ):
+    case( KSD_SS_PIN2     ):
+
+      break;
+
+    default:
+
+      return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * unblock PIN
+ *-------------------------------------------------------------------
+ */
+  if( simEntStat.curCmd NEQ AT_CMD_NONE )
+
+    return( AT_BUSY );
+
+  cmhSIM_FillInPIN ( (char *) ublkPrm->puk, simShrdPrm.setPrm[srcId].unblkKey, PUK_LEN );
+  cmhSIM_FillInPIN ( (char *) ublkPrm->pin, simShrdPrm.setPrm[srcId].curPIN,   PIN_LEN );
+
+  simShrdPrm.setPrm[srcId].PINType = (ublkPrm->ssCd EQ KSD_SS_PIN1)?
+                                        PHASE_2_PUK_1:PHASE_2_PUK_2;
+
+  simEntStat.curCmd     = (T_ACI_AT_CMD)KSD_CMD_UBLK;
+  simShrdPrm.owner = (T_OWN)srcId;
+  simEntStat.entOwn     = srcId;
+
+  if( psaSIM_UnblockCard( ) < 0 )  /* verify PIN */
+  {
+    TRACE_EVENT( "FATAL RETURN psaSIM in KSD" );
+    return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * log command execution
+ *-------------------------------------------------------------------
+ */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
+  {
+  T_ACI_CLOG cmdLog;        /* holds logging info */
+
+  cmdLog.atCmd                = (T_ACI_AT_CMD)KSD_CMD_UBLK;
+  cmdLog.cmdType              = CLOG_TYPE_Set;
+  cmdLog.retCode              = AT_EXCT;
+  cmdLog.cId                  = ACI_NumParmNotPresent;
+  cmdLog.sId                  = ACI_NumParmNotPresent;
+  cmdLog.cmdPrm.sKSUB.srcId   = srcId;
+  cmdLog.cmdPrm.sKSUB.ssCd    = ublkPrm->ssCd;
+  cmdLog.cmdPrm.sKSUB.puk     = ublkPrm->puk;
+  cmdLog.cmdPrm.sKSUB.pin     = ublkPrm->pin;
+
+  rAT_PercentCLOG( &cmdLog );
+  }
+#endif
+
+  return( AT_EXCT );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdCL              |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function invokes the operation for key sequence
+            command for calling line supplementary services.
+*/
+
+GLOBAL T_ACI_RETURN cmhSS_ksdCL  ( T_ACI_CMD_SRC srcId,
+                                   T_ACI_KSD_CL_PRM * clPrm )
+{
+  SHORT sId;                /* holds service id */
+
+  TRACE_FUNCTION ("cmhSS_ksdCL");
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter ss code
+ *-------------------------------------------------------------------
+ */
+  switch( clPrm->ssCd )
+  {
+    case( KSD_SS_CLIP ):
+    case( KSD_SS_CLIR ):
+    case( KSD_SS_COLP ):
+    case( KSD_SS_COLR ):
+    case( KSD_SS_CNAP ):		
+
+      break;
+
+    default:
+
+      return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * get a new service table entry
+ *-------------------------------------------------------------------
+ */
+  sId = psaSS_stbNewEntry();
+
+  if( sId EQ NO_ENTRY )
+  {
+    return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter operation code
+ *-------------------------------------------------------------------
+ */
+  CCD_START;
+
+  switch( clPrm->opCd )
+  {
+    /* interrogate call forwarding service */
+    case( KSD_OP_IRGT  ):
+      psaSS_asmInterrogateSS( clPrm->ssCd, SS_NO_PRM, SS_NO_PRM );
+      break;
+
+    /* activate call forwarding service */
+    case( KSD_OP_ACT   ):
+    /* deactivate call forwarding service */
+    case( KSD_OP_DEACT ):
+    /* register call forwarding service */
+    case( KSD_OP_REG   ):
+    /* erase call forwarding service */
+    case( KSD_OP_ERS   ):
+    /* unexpected operation code */
+    default:
+
+      CCD_END;
+      return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * start transaction
+ *-------------------------------------------------------------------
+ */
+  ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
+  ssShrdPrm.stb[sId].ssCode     = clPrm->ssCd;
+  ssShrdPrm.stb[sId].orgOPC     = clPrm->opCd;
+  ssShrdPrm.stb[sId].opCode     = clPrm->opCd;
+  ssShrdPrm.stb[sId].srvOwn     = (T_OWN)srcId;
+
+  if (clPrm->ssCd EQ KSD_SS_CNAP)
+  {
+    ssShrdPrm.stb[sId].curCmd     = AT_CMD_CNAP;
+  }
+  else
+  {
+    ssShrdPrm.stb[sId].curCmd     = (T_ACI_AT_CMD)KSD_CMD_CL;
+  }
+
+  psaSS_NewTrns(sId);
+
+  CCD_END;
+
+/*
+ *-------------------------------------------------------------------
+ * log command execution
+ *-------------------------------------------------------------------
+ */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
+  {
+  T_ACI_CLOG cmdLog;        /* holds logging info */
+
+  cmdLog.atCmd                = (T_ACI_AT_CMD)KSD_CMD_CW;
+  cmdLog.cmdType              = CLOG_TYPE_Set;
+  cmdLog.retCode              = AT_EXCT;
+  cmdLog.cId                  = ACI_NumParmNotPresent;
+  cmdLog.sId                  = sId+1;
+  cmdLog.cmdPrm.sKSCL.srcId   = srcId;
+  cmdLog.cmdPrm.sKSCL.opCd    = clPrm->opCd;
+  cmdLog.cmdPrm.sKSCL.ssCd    = clPrm->ssCd;
+
+  rAT_PercentCLOG( &cmdLog );
+  }
+#endif
+
+  return( AT_EXCT );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdCCBS            |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function invokes the operation for key sequence
+            command for call completion to busy subscriber
+            supplementary services.
+*/
+
+GLOBAL T_ACI_RETURN cmhSS_ksdCCBS  ( T_ACI_CMD_SRC srcId,
+                                     T_ACI_KSD_CCBS_PRM * ccbsPrm )
+{
+  SHORT sId;                /* holds service id */
+
+  TRACE_FUNCTION ("cmhSS_ksdCCBS");
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter ccbs index
+ *-------------------------------------------------------------------
+ */
+  if( ccbsPrm->idx NEQ KSD_IDX_NONE AND
+      (ccbsPrm->idx < 1 OR ccbsPrm->idx > 5 ))
+
+    return( AT_FAIL );
+
+/*
+ *-------------------------------------------------------------------
+ * get a new service table entry
+ *-------------------------------------------------------------------
+ */
+  sId = psaSS_stbNewEntry();
+
+  if( sId EQ NO_ENTRY )
+  {
+    return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * check parameter operation code
+ *-------------------------------------------------------------------
+ */
+  CCD_START;
+
+  switch( ccbsPrm->opCd )
+  {
+#if 0  /* For further study, so not yet used */
+    case( KSD_OP_ACT ):
+      psaSS_asmActivateCCBS( );
+      break;
+#endif
+
+    /* interrogate CCBS */
+    case( KSD_OP_IRGT ):
+      psaSS_asmInterrogateSS( SS_CD_CCBS, SS_NO_PRM, SS_NO_PRM );
+      ssShrdPrm.stb[sId].SSver = MNCC_SS_VERSION_2;
+      break;
+
+    /* deactivate CCBS */
+    case( KSD_OP_DEACT ):
+      psaSS_asmDeactivateCCBS( ccbsPrm -> idx );
+      ssShrdPrm.stb[sId].SSver = MNCC_SS_VERSION_3;
+      break;
+
+    default:
+
+      CCD_END;
+      return( AT_FAIL );
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * start transaction
+ *-------------------------------------------------------------------
+ */
+  ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
+  ssShrdPrm.stb[sId].ssCode     = KSD_SS_CCBS;
+  ssShrdPrm.stb[sId].orgOPC     = ccbsPrm->opCd;
+  ssShrdPrm.stb[sId].opCode     = ccbsPrm->opCd;
+  ssShrdPrm.stb[sId].srvOwn     = (T_OWN)srcId;
+
+  ssShrdPrm.stb[sId].curCmd     = (T_ACI_AT_CMD)KSD_CMD_CCBS;
+
+  psaSS_NewTrns(sId);
+
+  CCD_END;
+
+/*
+ *-------------------------------------------------------------------
+ * log command execution
+ *-------------------------------------------------------------------
+ */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
+  {
+  T_ACI_CLOG cmdLog;        /* holds logging info */
+
+  cmdLog.atCmd                = (T_ACI_AT_CMD)KSD_CMD_CCBS;
+  cmdLog.cmdType              = CLOG_TYPE_Set;
+  cmdLog.retCode              = AT_EXCT;
+  cmdLog.cId                  = ACI_NumParmNotPresent;
+  cmdLog.sId                  = sId+1;
+  cmdLog.cmdPrm.sKSCC.srcId   = srcId;
+  cmdLog.cmdPrm.sKSCC.opCd    = ccbsPrm->opCd;
+  cmdLog.cmdPrm.sKSCC.ssCd    = KSD_SS_CCBS;
+  cmdLog.cmdPrm.sKSCC.idx     = ccbsPrm->idx;
+
+  rAT_PercentCLOG( &cmdLog );
+  }
+#endif
+
+  return( AT_EXCT );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_getSumOf2Digits    |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to compute the sum of an even and
+            an odd labeled digit acc. to GSM 02.16. Only used for
+            computing the CD for an IMEI.
+*/
+
+LOCAL UBYTE cmhSS_getSumOf2Digits ( UBYTE digits )
+{
+  UBYTE dval;
+
+  /* compute odd labeled digit */
+  dval = 2 * ( digits & 0x0F );
+  dval = dval - ( dval < 10 ? 0 : 9 );
+
+  /*
+     return sum of even labeled digit and
+     already processed odd labeled digit
+  */
+  return dval + ( ( digits >> 4 ) & 0x0F );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_getCdFromImei      |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function is used to compute the CD for an IMEI
+            according to GSM 02.16.
+*/
+
+GLOBAL UBYTE cmhSS_getCdFromImei ( T_ACI_IMEI* imei )
+{
+  UBYTE sum = 0; /* sum of step 2    */
+  UBYTE cd;      /* Luhn Check Digit */
+
+  /* Step 1 and 2 of CD computation acc. GSM 02.16 */
+  sum += cmhSS_getSumOf2Digits ( imei -> tac1 );
+  sum += cmhSS_getSumOf2Digits ( imei -> tac2 );
+  sum += cmhSS_getSumOf2Digits ( imei -> tac3 );
+  sum += cmhSS_getSumOf2Digits ( imei -> fac  );
+  sum += cmhSS_getSumOf2Digits ( imei -> snr1 );
+  sum += cmhSS_getSumOf2Digits ( imei -> snr2 );
+  sum += cmhSS_getSumOf2Digits ( imei -> snr3 );
+
+  /* Step 3 of CD computation acc. GSM 02.16 */
+  cd = 10 - ( sum % 10 );
+  cd = ( cd EQ 10 ? 0 : cd );
+
+  return ( cd );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdIMEI            |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function invokes the operation for key sequence
+            command for getting the IMEI.
+*/
+
+GLOBAL T_ACI_RETURN cmhSS_ksdIMEI( T_ACI_CMD_SRC srcId )
+{
+  UBYTE        IMEIBuf[CL_IMEI_SIZE];      /* IMEI buffer */
+  EF_IMEI     *pIMEI;                      /* points to IMEI */
+  BYTE        retVal;                      /* holds return value */
+  T_ACI_KSIR   ksStat;                     /* ksd status */
+
+  pIMEI = (EF_IMEI *)IMEIBuf;
+  /*
+   * ACI-SPR-19706: Get IMEISV from IMEI common library
+   */
+  retVal = cl_get_imeisv(CL_IMEI_SIZE, IMEIBuf, CL_IMEI_GET_STORED_IMEI);
+  if(retVal != CL_IMEI_OK)
+  {
+    TRACE_ERROR("ACI ERROR: no IMEISV available!");
+    return( AT_FAIL );
+  }  
+  TRACE_EVENT("ACI INFO IMEI: got IMEI");
+  TRACE_EVENT_P8("%02x%02x%02x%02x %02x%02x%02x %02x",
+                 IMEIBuf[0], IMEIBuf[1], IMEIBuf[2], IMEIBuf[3],
+                 IMEIBuf[4], IMEIBuf[5], IMEIBuf[6], IMEIBuf[7]);
+
+  ksStat.ksdCmd          = KSD_CMD_IMEI;
+  ksStat.ir.rKSIMEI.tac1 = pIMEI->tac1;
+  ksStat.ir.rKSIMEI.tac2 = pIMEI->tac2;
+  ksStat.ir.rKSIMEI.tac3 = pIMEI->tac3;
+  ksStat.ir.rKSIMEI.fac  = pIMEI->fac;
+  ksStat.ir.rKSIMEI.snr1 = pIMEI->snr1;
+  ksStat.ir.rKSIMEI.snr2 = pIMEI->snr2;
+  ksStat.ir.rKSIMEI.snr3 = pIMEI->snr3;
+  ksStat.ir.rKSIMEI.svn  = pIMEI->svn;
+  ksStat.ir.rKSIMEI.cd   = cmhSS_getCdFromImei ( &ksStat.ir.rKSIMEI );
+
+  /*
+  ** CQ12314 : NDH : 23/9/2003
+  ** Added srcID field to ksStat to enable called entity to determine the originator of the command
+  ** and take appropriate action.  (eg to Activate Call Forwarding Icon)
+  */
+  ksStat.srcId = srcId;
+
+#if defined (MFW)
+  if (srcId NEQ CMD_SRC_LCL)
+  {
+    R_AT( RAT_KSIR, CMD_SRC_LCL)( &ksStat );
+  }
+#endif
+
+  R_AT( RAT_KSIR, srcId )( &ksStat );
+
+  return( AT_CMPL );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdGetOpCd         |
++--------------------------------------------------------------------+
+
+  PURPOSE : Transforms SS operation code into KSD operation code.
+            Returns KSD operation code.
+*/
+#if(0)
+GLOBAL UBYTE cmhSS_ksdGetOpCd  ( UBYTE opcSS )
+{
+  switch( opcSS )
+  {
+    case( OPC_REGISTER_SS ):        return( KSD_OP_REG );
+    case( OPC_ERASE_SS ):           return( KSD_OP_ERS );
+    case( OPC_ACTIVATE_SS ):        return( KSD_OP_ACT );
+    case( OPC_DEACTIVATE_SS ):      return( KSD_OP_DEACT );
+    case( OPC_INTERROGATE_SS ):     return( KSD_OP_IRGT );
+    case( OPC_REGISTER_PASSWORD ):  return( KSD_OP_REG );
+  }
+
+  return( KSD_OP_NONE );
+}
+#endif
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdBuildErrRslt    |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function build an error result for a failed KSD
+            action.
+*/
+
+GLOBAL void cmhSS_ksdBuildErrRslt  ( SHORT sId, T_ACI_KSIR * ksStat, UBYTE err )
+{
+
+/*
+ *-------------------------------------------------------------------
+ * find error value
+ *-------------------------------------------------------------------
+ */
+  if( err EQ KSD_NO_ERROR )
+  {
+    switch( ssShrdPrm.stb[sId].failType )
+    {
+      case( SSF_SS_ERR ):
+
+        err = ssShrdPrm.stb[sId].errCd;
+        break;
+
+      case( SSF_GEN_PRB ):
+
+        err = ssShrdPrm.stb[sId].rejPrb + 0xA0;
+        break;
+
+      case( SSF_INV_PRB ):
+
+        err = ssShrdPrm.stb[sId].rejPrb + 0xB0;
+        break;
+
+      case( SSF_RSL_PRB ):
+
+        err = ssShrdPrm.stb[sId].rejPrb + 0xC0;
+        break;
+
+      case( SSF_ERR_PRB ):
+
+        err = ssShrdPrm.stb[sId].rejPrb + 0xD0;
+        break;
+
+      case( SSF_CCD_DEC ):
+
+        err = KSD_ERR_FATAL_CCD_DEC;
+        break;
+
+      case( SSF_SS_ENT ):
+
+        err = KSD_ERR_FATAL_SS_ENT;
+        break;
+    }
+  }
+
+/*
+ *-------------------------------------------------------------------
+ * check for command context
+ *-------------------------------------------------------------------
+ */
+  switch((T_ACI_KSD_CMD) ssShrdPrm.stb[sId].curCmd )
+  {
+   /*
+    *----------------------------------------------------------------
+    * process result for KSD CF command
+    *----------------------------------------------------------------
+    */
+    case( KSD_CMD_CF  ):
+
+      ksStat->ksdCmd = KSD_CMD_CF;
+      ksStat->ir.rKSCF.opCd  = ssShrdPrm.stb[sId].orgOPC;
+      ksStat->ir.rKSCF.ssCd  = ssShrdPrm.stb[sId].ssCode;
+      ksStat->ir.rKSCF.ssErr = err;
+      break;
+   /*
+    *----------------------------------------------------------------
+    * process result for KSD CB command
+    *----------------------------------------------------------------
+    */
+    case( KSD_CMD_CB  ):
+
+      ksStat->ksdCmd = KSD_CMD_CB;
+      ksStat->ir.rKSCB.opCd  = ssShrdPrm.stb[sId].orgOPC;
+      ksStat->ir.rKSCB.ssCd  = ssShrdPrm.stb[sId].ssCode;
+      ksStat->ir.rKSCB.ssErr = err;
+      break;
+   /*
+    *----------------------------------------------------------------
+    * process result for KSD CL command
+    *----------------------------------------------------------------
+    */
+    case( KSD_CMD_CL  ):
+
+      ksStat->ksdCmd = KSD_CMD_CL;
+      ksStat->ir.rKSCL.opCd  = ssShrdPrm.stb[sId].orgOPC;
+      ksStat->ir.rKSCL.ssCd     = ssShrdPrm.stb[sId].ssCode;
+      ksStat->ir.rKSCL.ssErr    = err;
+      ksStat->ir.rKSCL.ssSt     = KSD_ST_NOT_VALID;
+      ksStat->ir.rKSCL.clirOpt  = KSD_CO_NOT_VALID;
+      ksStat->ir.rKSCL.ovrdCtg  = KSD_OVR_CAT_NOT_VALID;
+      break;
+   /*
+    *----------------------------------------------------------------
+    * process result for KSD CW command
+    *----------------------------------------------------------------
+    */
+    case( KSD_CMD_CW  ):
+
+      ksStat->ksdCmd = KSD_CMD_CW;
+      ksStat->ir.rKSCW.opCd  = ssShrdPrm.stb[sId].orgOPC;
+      ksStat->ir.rKSCW.ssCd  = ssShrdPrm.stb[sId].ssCode;
+      ksStat->ir.rKSCW.ssErr = err;
+      ksStat->ir.rKSCW.ssSt  = KSD_ST_NOT_VALID;
+      break;
+   /*
+    *----------------------------------------------------------------
+    * process result for KSD PW command
+    *----------------------------------------------------------------
+    */
+    case( KSD_CMD_PWD  ):
+
+      ksStat->ksdCmd = KSD_CMD_PWD;
+      ksStat->ir.rKSPW.opCd  = ssShrdPrm.stb[sId].orgOPC;
+      ksStat->ir.rKSPW.ssCd  = ssShrdPrm.stb[sId].ssCode;
+      ksStat->ir.rKSPW.ssErr = err;
+      if(ssShrdPrm.stb[sId].errPrms NEQ NOT_PRESENT_8BIT)
+        ksStat->ir.rKSPW.errPrms = ssShrdPrm.stb[sId].errPrms;
+
+      break;
+   /*
+    *----------------------------------------------------------------
+    * process result for KSD USSD command
+    *----------------------------------------------------------------
+    */
+    case( KSD_CMD_USSD  ):
+
+      ksStat->ksdCmd = KSD_CMD_USSD;
+      ksStat->ir.rKSUS.ssErr = err;
+      break;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdFillFwdFeatList |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function fills in the values of a forwarding
+            feature list and returns the number of filled entries.
+*/
+
+GLOBAL UBYTE cmhSS_ksdFillFwdFeatList( T_forwardingFeatureList * ffSS,
+                                        T_CF_FEAT * cfFeat )
+{
+  UBYTE idx;          /* holds list index */
+
+  for( idx=0;
+       idx < MINIMUM( ffSS->c_ff, MAX_CF_FEAT_NR );
+       idx++, cfFeat++ )
+  {
+    cmhSS_GetBscSrv( &ffSS->ff[idx].basicService,
+                     &cfFeat->bsCd,
+                     &cfFeat->bsTp  );
+
+    if( !ffSS->ff[idx].v_ssStatus )
+      cfFeat->ssSt  = KSD_ST_NOT_VALID;
+    else
+      cfFeat->ssSt  = ffSS->ff[idx].ssStatus;
+
+    if( ffSS->ff[idx].v_forwardedToNumber AND
+        ffSS->ff[idx].forwardedToNumber.c_bcdDigit )
+    {
+      utl_BCD2DialStr
+        (ffSS->ff[idx].forwardedToNumber.bcdDigit,
+         (char*)cfFeat->num,
+         ffSS->ff[idx].forwardedToNumber.c_bcdDigit);
+
+      cfFeat->npi = ffSS->ff[idx].forwardedToNumber.npi;
+      cfFeat->ton = ffSS->ff[idx].forwardedToNumber.noa;
+    }
+    else
+    {
+      cfFeat->npi = 0xFF;
+      cfFeat->ton = 0xFF;
+    }
+
+    if( ffSS->ff[idx].v_forwardedToSubaddress AND
+        ffSS->ff[idx].forwardedToSubaddress.c_subadr_str )
+    {
+      utl_BCD2DialStr
+        (ffSS->ff[idx].forwardedToSubaddress.subadr_str,
+         (char*)cfFeat->sub,
+         ffSS->ff[idx].forwardedToSubaddress.c_subadr_str);
+
+      cfFeat->tos = ffSS->ff[idx].forwardedToSubaddress.tos;
+      cfFeat->oe  = ffSS->ff[idx].forwardedToSubaddress.oei;
+    }
+    else
+    {
+      cfFeat->tos = 0xFF;
+      cfFeat->oe  = 0xFF;
+    }
+
+    if( ffSS->ff[idx].v_noReplyConditionTime )
+      cfFeat->time = ffSS->ff[idx].noReplyConditionTime;
+    else
+      cfFeat->time = 0xFF;
+  }
+
+  return( idx );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdFillCbFeatList  |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function fills in the values of a call barring
+            feature list and returns the number of filled entries.
+*/
+
+GLOBAL UBYTE cmhSS_ksdFillCbFeatList( T_callBarringFeatureList * bfSS,
+                                      T_CB_INFO * cbInfo )
+{
+  UBYTE idx;          /* holds list index */
+
+  for( idx=0;
+       idx < MINIMUM( bfSS->c_cbf, MAX_CB_INFO_NR);
+       idx++, cbInfo++ )
+  {
+    cbInfo->ssSt = (bfSS->cbf[idx].v_ssStatus)?
+                    bfSS->cbf[idx].ssStatus :
+                    (UBYTE)KSD_ST_NOT_VALID;
+
+    cmhSS_GetBscSrv(&bfSS->cbf[idx].basicService,
+                    &cbInfo->bsCd,
+                    &cbInfo->bsTp  );
+  }
+
+  return( idx );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdFillBSGList     |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function fills in the values of a basic service
+            group list and returns the number of filled entries.
+*/
+
+GLOBAL UBYTE cmhSS_ksdFillBSGList( T_basicServiceGroupList * bsgSS,
+                                   T_Cx_BSG * cxBSG )
+{
+  UBYTE idx;          /* holds list index */
+  UBYTE lstSpce;      /* holds list space */
+
+  lstSpce = MAX_CW_BSG_NR;
+
+  for( idx=0;
+       idx < bsgSS->c_basicServiceGroupList_value AND lstSpce;
+       idx++ )
+  {
+    if (bsgSS->basicServiceGroupList_value[idx].v_teleservice)
+    {
+      cxBSG->bsCd = bsgSS->basicServiceGroupList_value[idx].teleservice;
+      cxBSG->bsTp = KSD_BS_TP_Tele;
+      cxBSG++;
+      lstSpce--;
+    }
+    if (bsgSS->basicServiceGroupList_value[idx].v_bearerService)
+    {
+      cxBSG->bsCd = bsgSS->basicServiceGroupList_value[idx].bearerService;
+      cxBSG->bsTp = KSD_BS_TP_Bearer;
+      cxBSG++;
+      lstSpce--;
+    }
+  }
+
+  return( MAX_CW_BSG_NR - lstSpce );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdFillCCBSFeatList|
++--------------------------------------------------------------------+
+
+  PURPOSE : This function fills in the values of a forwarding
+            feature list and returns the number of filled entries.
+*/
+
+GLOBAL UBYTE cmhSS_ksdFillCCBSFeatList( T_ccbsFeatureList * ccbsfSS,
+                                        T_CC_FEAT * ccFeat )
+{
+  UBYTE idx;          /* holds list index */
+
+  for( idx=0;
+       idx < MINIMUM( ccbsfSS->c_ccbsf, MAX_CC_FEAT_NR );
+       idx++, ccFeat++ )
+  {
+    cmhSS_GetBscSrv( (T_basicService*)&ccbsfSS->ccbsf[idx].basicServiceGroup,
+                     &ccFeat->bsCd,
+                     &ccFeat->bsTp  );
+
+    if( ccbsfSS->ccbsf[idx].v_b_subscriberNumber AND
+        ccbsfSS->ccbsf[idx].b_subscriberNumber.c_bcdDigit )
+    {
+      utl_BCD2DialStr
+        (ccbsfSS->ccbsf[idx].b_subscriberNumber.bcdDigit,
+         (char*)ccFeat->num,
+         ccbsfSS->ccbsf[idx].b_subscriberNumber.c_bcdDigit);
+
+      ccFeat->npi = ccbsfSS->ccbsf[idx].b_subscriberNumber.npi;
+      ccFeat->ton = ccbsfSS->ccbsf[idx].b_subscriberNumber.noa;
+    }
+    else
+    {
+      ccFeat->npi = 0xFF;
+      ccFeat->ton = 0xFF;
+    }
+
+    if( ccbsfSS->ccbsf[idx].v_b_subscriberSubaddress AND
+        ccbsfSS->ccbsf[idx].b_subscriberSubaddress.c_subadr_str )
+    {
+      utl_BCD2DialStr
+        (ccbsfSS->ccbsf[idx].b_subscriberSubaddress.subadr_str,
+         (char*)ccFeat->sub,
+         ccbsfSS->ccbsf[idx].b_subscriberSubaddress.c_subadr_str);
+
+      ccFeat->tos = ccbsfSS->ccbsf[idx].b_subscriberSubaddress.tos;
+      ccFeat->oe  = ccbsfSS->ccbsf[idx].b_subscriberSubaddress.oei;
+    }
+    else
+    {
+      ccFeat->tos = 0xFF;
+      ccFeat->oe  = 0xFF;
+    }
+
+    if( ccbsfSS->ccbsf[idx].v_ccbsIndex )
+      ccFeat->idx = ccbsfSS->ccbsf[idx].ccbsIndex;
+    else
+      ccFeat->idx = 0xFF;
+  }
+
+  return( idx );
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdFillFwdRes      |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function fills in a forwarding info
+            into a forwarding result structure.
+*/
+
+GLOBAL void cmhSS_ksdFillFwdRes( T_forwardingInfo * fiSS,
+                                 T_ACI_KSIR *ksStat,
+                                 T_CF_FEAT * cfFeat )
+{
+  /* if SS code is present */
+  ksStat->ir.rKSCF.ssCd= (fiSS->v_ssCode)?
+                          fiSS->ssCode:
+                          (UBYTE)KSD_SS_NONE;
+
+  /* if forwarding feature list is present, decode the forwarding
+     information */
+  if( fiSS->v_forwardingFeatureList )
+  {
+    /* no forwarding features present */
+    if( fiSS->forwardingFeatureList.c_ff EQ 0 )
+    {
+      TRACE_EVENT("UNEXP: NO FORWARDING FEATURE IN FEATURE LIST");
+    }
+
+    /* fowarding feature list present */
+    else
+    {
+      ksStat->ir.rKSCF.cfFeatLst   = cfFeat;
+
+      ksStat->ir.rKSCF.c_cfFeatLst =
+        cmhSS_ksdFillFwdFeatList( &fiSS->forwardingFeatureList, cfFeat );
+    }
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdFillCbRes       |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function fills in a barring info
+            into a barring result structure.
+*/
+
+GLOBAL void cmhSS_ksdFillCbRes( T_callBarringInfo * biSS,
+                                T_ACI_KSIR *ksStat,
+                                T_CB_INFO * cbInfo )
+{
+  /* if SS code is present */
+  ksStat->ir.rKSCB.ssCd= (biSS->v_ssCode)?
+                          biSS->ssCode:
+                          (UBYTE)KSD_SS_NONE;
+
+  /* if barring feature list is present, decode the barring
+     information */
+  if( biSS->v_callBarringFeatureList )
+  {
+    /* no forwarding features present */
+    if( biSS->callBarringFeatureList.c_cbf EQ 0 )
+    {
+      TRACE_EVENT("UNEXP: NO BARRING FEATURE IN FEATURE LIST");
+    }
+
+    /* fowarding feature list present */
+    else
+    {
+      ksStat->ir.rKSCB.cbInfoLst = cbInfo;
+
+      ksStat->ir.rKSCB.c_cbInfoLst =
+        cmhSS_ksdFillCbFeatList( &biSS->callBarringFeatureList, cbInfo );
+    }
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)         MODULE  : CMH_SSS                  |
+| STATE   : code                  ROUTINE : cmhSS_ksdFillCwRes       |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function fills in a SS data
+            into a waiting result structure.
+*/
+
+GLOBAL void cmhSS_ksdFillCwRes( T_ssData   *datSS,
+                                T_ACI_KSIR *ksStat,
+                                T_Cx_BSG   *cwBSG )
+{
+  /* if SS code is present */
+  ksStat->ir.rKSCW.ssCd= (datSS->v_ssCode)?
+                          datSS->ssCode:
+                          (UBYTE)KSD_SS_NONE;
+
+  /* if SS status is present */
+  ksStat->ir.rKSCW.ssSt= (datSS->v_ssStatus)?
+                          datSS->ssStatus:
+                          (UBYTE)KSD_ST_NONE;
+
+  /* if basic service list is present, decode the basic service
+     information */
+  if( datSS->v_basicServiceGroupList )
+  {
+    /* no forwarding features present */
+    if( datSS->basicServiceGroupList.c_basicServiceGroupList_value EQ 0 )
+    {
+      TRACE_EVENT("UNEXP: NO BASIC SERVICE IN SERVICE LIST");
+    }
+
+    /* fowarding feature list present */
+    else
+    {
+      ksStat->ir.rKSCW.cwBSGLst = cwBSG;
+
+      ksStat->ir.rKSCW.c_cwBSGLst =
+        cmhSS_ksdFillBSGList( &datSS->basicServiceGroupList, cwBSG );
+    }
+  }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_GetClassType           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Convert class type value.
+
+*/
+
+GLOBAL T_ACI_CLASS cmhSS_GetClassType( UBYTE bsTp, UBYTE bsCd )
+{
+  TRACE_FUNCTION ("cmhSS_GetClassType()");
+
+  if ( bsTp EQ KSD_BS_TP_None           AND
+       bsCd EQ KSD_BS_TeleBearerUnknown     )
+    return CLASS_VceDatFax;
+
+  if (bsTp EQ KSD_BS_TP_Bearer)
+  {
+    return( CLASS_Dat );
+  }
+  if (bsTp EQ KSD_BS_TP_Tele)
+  {
+    switch( bsCd )
+    {
+      case( TS_CD_TLPHNY ):        /* no break */
+      case( TS_CD_ALL_SPCH ):
+        return( CLASS_Vce );
+      case( TS_CD_PLMN1 ):
+        return( CLASS_AuxVce);
+
+      case( TS_CD_ALL_FAX ):
+        return( CLASS_Fax );
+
+      case( TS_CD_ALL_TS ):        /* no break */
+      case( TS_CD_ALL_XCPT_SMS ):
+        return( CLASS_VceFax );
+
+      default:
+        return( CLASS_None );
+    }
+  }
+  return( CLASS_None );
+}
+
+GLOBAL T_ACI_CLASS cmhSS_GetCbClassType( UBYTE bsTp, UBYTE bsCd )
+{
+  TRACE_FUNCTION ("cmhSS_GetCbClassType()");
+
+  if ( bsTp EQ KSD_BS_TP_None           AND
+       bsCd EQ KSD_BS_TeleBearerUnknown     )
+    return CLASS_VceDatFaxSms;
+
+  if (bsTp EQ KSD_BS_TP_Bearer)
+  {
+    return( CLASS_Dat );
+  }
+  if (bsTp EQ KSD_BS_TP_Tele)
+  {
+    switch( bsCd )
+    {
+      case( TS_CD_TLPHNY ):        /* no break */
+      case( TS_CD_ALL_SPCH ):     return( CLASS_Vce );
+      case( TS_CD_PLMN1 ):        return( CLASS_AuxVce);
+
+      case( TS_CD_ALL_FAX ):      return( CLASS_Fax );
+
+      case( TS_CD_ALL_XCPT_SMS ): return( CLASS_VceFax );
+
+      case( TS_CD_ALL_SMS ):
+      case( TS_CD_SMS_MT ):
+      case( TS_CD_SMS_MO ):       return (CLASS_Sms );
+
+      case( TS_CD_ALL_TS ):       return (CLASS_VceFaxSms );
+
+      default:                    return( CLASS_None );
+    }
+  }
+  return( CLASS_None );
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : checkSSforFDN           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Check, if SS string exists in FDN phone book
+                   Returns FALSE if not found
+
+*/
+BOOL checkSSforFDN(char *cSSString)
+{
+
+  T_CLPTY_PRM ssCldPty;
+
+    if(cSSString NEQ NULL)
+    {
+      cmhCC_init_cldPty( &ssCldPty );
+      cmh_bldCalPrms ( cSSString, &ssCldPty );
+      /*
+        *-------------------------------------------------------------------
+        * check fixed dialing phonebook if enabled
+        *-------------------------------------------------------------------
+        */
+      if((simShrdPrm.crdFun EQ SIM_FDN_ENABLED OR
+          simShrdPrm.crdFun EQ SIM_FDN_BDN_ENABLED) )
+      {
+        if( ksd_isFDNCheckSeq ( ssCldPty.num ) )
+         {
+            if(!psaCC_phbNtryFnd( FDN, &ssCldPty ))
+            {
+              TRACE_EVENT ( "SS FDN check failed" );
+              return FALSE;
+            }
+        }
+      }
+    }
+    return TRUE;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : checkFDNSendSS           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Check, if SS string exists in FDN phone book and send to STK if allowed
+                   Returns AT_FAIL if FDN is not allowed or send to STK fails
+
+*/
+T_ACI_RETURN checkFDNSendSS(T_ACI_CMD_SRC srcId, CHAR *pSSString)
+{
+    /* If SS string should be checked, but not found in FDN - return error */
+    if (!checkSSforFDN(pSSString)) 
+    {
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_FdnCheck );
+      return AT_FAIL; 
+    }
+#ifdef SIM_TOOLKIT
+    return cmhSS_SendToSAT(srcId, pSSString);
+#else /* SIM_TOOLKIT */
+    return AT_CMPL;
+#endif /* SIM_TOOLKIT */
+
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : mapIdxToString           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Find the occurence of the record of type T_IDX_TO_STR_MAP with "idx" field 
+                    equal index and returns field "cod"
+                    If NULL is reurned, no record with correct "idx" has been found
+
+*/
+char *mapIdxToString(const T_IDX_TO_STR_MAP *table, BYTE index)
+{
+  int i=0;
+  while (table[i].cod NEQ NULL)
+  {
+    if (table[i].idx EQ index)
+      return table[i].cod;
+    i++;
+  }
+  return NULL;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : mapIdxToDigit           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Find the occurence of the record of type T_IDX_TO_STR_MAP with "idx" field 
+                    equal index and returns field "cod"
+
+*/
+
+BYTE mapIdxToDigit(const T_IDX_TO_DIG_MAP *table, BYTE index, BYTE * result)
+{
+  int i=0;
+  while (table[i].cod NEQ NULL || table[i].idx NEQ NULL)
+  {
+    if (table[i].idx EQ index)
+    {
+      *result = table[i].cod;
+      return 0;
+    }
+    i++;
+  }    
+  return(BYTE)-1;
+}
+
+#ifdef SIM_TOOLKIT
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_SendToSAT           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Send SS string to SIM
+
+*/
+T_ACI_RETURN cmhSS_SendToSAT(T_ACI_CMD_SRC srcId, CHAR *pSSString)
+{
+   T_CLPTY_PRM *cldPty_sim;
+   T_ACI_RETURN   retVal;
+
+    TRACE_EVENT_P1("cmhSS_SendToSAT SS String = %s", pSSString);
+    
+    retVal = AT_CMPL;
+    
+    MALLOC(cldPty_sim, sizeof(T_CLPTY_PRM));
+    
+    cmhCC_init_cldPty( cldPty_sim );
+    cmh_bldCalPrms ( pSSString, cldPty_sim );
+
+    if( ksd_isSATSscs (cldPty_sim->num) )
+    {   
+      retVal = cmhSAT_SSCntrlBySIM( cldPty_sim, (UBYTE)srcId );
+    }
+
+    MFREE(cldPty_sim);
+    
+    switch (retVal)
+    {
+      case AT_FAIL: 
+        ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+        break;
+
+      case AT_BUSY:
+        ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimBusy);
+        break;
+
+      default:
+        break;
+    }
+    return( retVal );
+
+}
+#endif /* SIM_TOOLKIT */
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_CF_SAT_Handle           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Builds SS string from parameters of AT+CCFC command
+                  and sends to SIM
+
+*/
+T_ACI_RETURN cmhSS_CF_SAT_Handle(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)
+{
+
+  int ii;
+  BYTE bMapResult;
+ 
+  CHAR cSIString[MAX_DIAL_LEN];
+  CHAR cSIbuf[MAX_DIAL_LEN];
+  CHAR cSSString[MAX_DIAL_LEN];
+  
+
+  char *stReason;
+  char *stMode;
+  BYTE bBaseService;
+
+ 
+  cSIString[0]= '\0';
+
+  TRACE_EVENT("cmhSS_CF_SAT_Handle()");
+ 
+
+  stReason = mapIdxToString(cCFRsnMapTable/*lint -e40 */, reason); 
+  stMode = mapIdxToString(cModMapTable, mode);
+  bMapResult = mapIdxToDigit(cCFBSMapTable, class_type, &bBaseService);
+
+
+  if (stMode NEQ NULL AND stReason NEQ NULL) 
+  {
+    /* Build SI string */
+    for (ii=0; ii<3; ii++)
+    {
+      cSIbuf[0] = '\0';
+      if (ii EQ 0) /* Step 1 - check Time */ 
+      {
+        if (time NEQ 0 AND reason NEQ CCFC_RSN_Uncond 
+            AND reason NEQ CCFC_RSN_Busy AND reason NEQ CCFC_RSN_NotReach) /*No time for these Service code*/ 
+        {
+          sprintf(cSIbuf, "%d", time);
+        }
+      }
+      else if(ii EQ 1) /* Step 2 - check BS */
+      {
+        if (bMapResult EQ NULL)
+          sprintf(cSIbuf, "%d", bBaseService);
+      }
+      else if(ii EQ 2) /* Step 3 - check DN */
+      {
+        if (number NEQ NULL)
+          sprintf(cSIbuf, "%s", number);
+      }
+      strcat(cSIbuf, cSIString);
+      if (strlen(cSIbuf) NEQ 0)  /* If some parameters are already filled...*/
+      {
+        sprintf(cSIString, "*%s", cSIbuf);
+      }
+    }
+
+    sprintf(cSSString,"%s%s%s#",stMode, stReason, cSIString); /* Build SS string */
+    
+    /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
+    return checkFDNSendSS(srcId, cSSString);
+  }
+  else
+  {
+    ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+    return AT_FAIL;
+  }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_CW_SAT_Handle           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Builds SS string from parameters of AT+CCWA command
+                  and sends to SIM
+
+*/
+T_ACI_RETURN cmhSS_CW_SAT_Handle(T_ACI_CMD_SRC srcId,
+                                    T_ACI_CCFC_MOD mode,
+                                    T_ACI_CLASS    class_type)
+{
+
+  BYTE bMapResult;
+  CHAR cSSString[MAX_DIAL_LEN];
+  
+  char *stMode;
+  BYTE bBaseService;
+
+  TRACE_EVENT("cmhSS_CW_SAT_Handle()");
+  stMode = mapIdxToString(cModMapTable, mode); 
+  bMapResult = mapIdxToDigit(cCFBSMapTable, class_type, &bBaseService); 
+
+
+  if (stMode NEQ NULL) 
+  {
+    /* Build SS string */
+    if (bMapResult NEQ 0)
+      sprintf(cSSString,"%s43#",stMode); 
+    else
+      sprintf(cSSString,"%s43*%d#",stMode, bBaseService);
+
+    /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
+    return checkFDNSendSS(srcId, cSSString);
+  }
+  else
+  {
+    ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+    return AT_FAIL;
+  }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_CLIP_SAT_Handle           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Builds SS string from parameters of AT+CLIP command
+                  and sends to SIM
+
+*/
+T_ACI_RETURN cmhSS_CLIP_SAT_Handle(T_ACI_CMD_SRC srcId)
+{
+    CHAR cSSString[] = "*#30#"; /* Only Query */ 
+    
+    TRACE_EVENT("cmhSS_CLIP_SAT_Handle()");
+    
+    /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
+    return checkFDNSendSS(srcId, cSSString);
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_CLIR_SAT_Handle           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Builds SS string from parameters of AT+CLIR command
+                  and sends to SIM
+
+*/
+T_ACI_RETURN cmhSS_CLIR_SAT_Handle(T_ACI_CMD_SRC srcId)
+{
+    CHAR cSSString[] = "*#31#"; /* Only Query */
+     
+    TRACE_EVENT("cmhSS_CLIR_SAT_Handle()");
+
+    /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
+    return checkFDNSendSS(srcId, cSSString);
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_COLP_SAT_Handle           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Builds SS string from parameters of AT+COLP command
+                  and sends to SIM
+
+*/
+T_ACI_RETURN cmhSS_COLP_SAT_Handle(T_ACI_CMD_SRC srcId)
+{
+    CHAR cSSString[] = "*#76#"; /* Only Query */
+    
+    TRACE_EVENT("cmhSS_COLP_SAT_Handle()");
+
+    /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
+    return checkFDNSendSS(srcId, cSSString);
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_COLR_SAT_Handle           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Builds SS string from parameters of AT+COLR command
+                  and sends to SIM
+
+*/
+T_ACI_RETURN cmhSS_COLR_SAT_Handle(T_ACI_CMD_SRC srcId)
+{
+    CHAR cSSString[] = "*#77#"; /* Only Query */
+    
+    TRACE_EVENT("cmhSS_COLR_SAT_Handle()");
+
+    /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
+    return checkFDNSendSS(srcId, cSSString);
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_CCBS_SAT_Handle           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Builds SS string from parameters of AT+CCBS command
+                  and sends to SIM
+
+*/
+T_ACI_RETURN cmhSS_CCBS_SAT_Handle(T_ACI_CMD_SRC srcId, T_ACI_CCBS_MOD mode, SHORT idx)
+{
+    char *stMode;
+    CHAR cSSString[MAX_DIAL_LEN];
+    
+    TRACE_EVENT("cmhSS_CCBS_SAT_Handle()");
+    
+    stMode = mapIdxToString(cModMapTable, mode);
+
+    if (stMode NEQ NULL) 
+    {
+      /* Build SS string */
+      if (idx EQ -1) /* According to GSM 02.30 Index can vary 1..5*/
+        sprintf(cSSString,"%s37#",stMode); 
+      else
+        sprintf(cSSString,"%s37*%d#",stMode, idx);
+
+      /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
+      return checkFDNSendSS(srcId, cSSString);
+    }
+    else
+    {
+      ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+      return AT_FAIL;
+    }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_CNAP_SAT_Handle           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Builds SS string from parameters of AT+CNAP command
+                  and sends to SIM
+
+*/
+T_ACI_RETURN cmhSS_CNAP_SAT_Handle(T_ACI_CMD_SRC srcId)
+{
+    CHAR cSSString[] = "*#300#"; /* Only Query */
+    
+    TRACE_EVENT("cmhSS_CNAP_SAT_Handle()");
+
+    /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
+    return checkFDNSendSS(srcId, cSSString);
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SSF                      |
+|                            ROUTINE : cmhSS_Call_Barr_SAT_Handle           |
++-------------------------------------------------------------------+
+
+  PURPOSE : Builds SS string from parameters of AT+CLCK command
+                  and sends to SIM
+
+*/
+T_ACI_RETURN cmhSS_Call_Barr_SAT_Handle(T_ACI_CMD_SRC srcId, 
+                        T_ACI_CLCK_MOD mode, 
+                        T_ACI_FAC fac, 
+                        CHAR  *passwd, 
+                        T_ACI_CLASS    class_type)
+{
+    int ii;
+    BYTE bBaseService;
+    BYTE bMapResult;
+
+    char *stMode;
+    char *stFac;
+  
+    CHAR cSIString[MAX_DIAL_LEN];
+    CHAR cSIbuf[MAX_DIAL_LEN];
+    CHAR cSSString[MAX_DIAL_LEN];
+
+    
+    TRACE_EVENT("cmhSS_Call_Barr_SAT_Handle()");
+    
+    cSIString[0]= '\0';
+    
+    stMode = mapIdxToString(cModMapTable, mode);
+    stFac = mapIdxToString(cCBRsnMapTable, fac); 
+    bMapResult = mapIdxToDigit(cCFBSMapTable, class_type, &bBaseService);
+
+    if (stFac EQ NULL ) return AT_CMPL; /* If no call barring facility - continue executing sAT_PlusCLCK*/
+
+    if (stMode NEQ NULL) 
+    {
+      for (ii=0; ii<2; ii++)
+      {
+        cSIbuf[0] = '\0';
+        if(ii EQ 0) /* Step 2 - check BS */
+        {
+          if (bMapResult EQ NULL)
+            sprintf(cSIbuf, "%d", bBaseService);
+        }
+        else if(ii EQ 1) /* Step 2 - check PW */
+        {
+          if (passwd NEQ NULL)
+            sprintf(cSIbuf, "%s", passwd);
+        }
+        strcat(cSIbuf, cSIString);
+        if (strlen(cSIbuf) NEQ 0)  /* If some parameters are already filled...*/
+        {
+          sprintf(cSIString, "*%s", cSIbuf);
+        }
+      }
+      
+      /* Build SS string */
+      sprintf(cSSString,"%s%s%s#",stMode, stFac, cSIString); /* Build SS string */
+
+    /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
+    return checkFDNSendSS(srcId, cSSString);
+    
+    }
+    else
+    {
+      ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
+      return AT_FAIL;
+    }
+}
+
+/* Implements Measure # 166 */
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SS                       |
+| STATE   : code             ROUTINE : cmhSMS_getSSCd               |
++-------------------------------------------------------------------+
+  PARAMETERS  : fac - CLCK facility for which SS code has to be 
+                      returned.
+                ssCd - SS Code is filled in this variable. 
+  RETURN      : FALSE if unknown CLCK facility is passed 
+
+  PURPOSE     : This function returns the SS code for CLCK functions
+  
+*/
+
+GLOBAL BOOL cmhSS_getSSCd(T_ACI_FAC fac, UBYTE *ssCd)
+{
+/*
+ *-------------------------------------------------------------------
+ * check parameter <fac>
+ *-------------------------------------------------------------------
+ */  
+  switch( fac )
+  {
+    case( FAC_Ao ): *ssCd = SS_CD_BAOC;     break;
+    case( FAC_Oi ): *ssCd = SS_CD_BOIC;     break;
+    case( FAC_Ox ): *ssCd = SS_CD_BOICXH;   break;
+    case( FAC_Ai ): *ssCd = SS_CD_BAIC;     break;
+    case( FAC_Ir ): *ssCd = SS_CD_BICRM;    break;
+    case( FAC_Ab ): *ssCd = SS_CD_ALL_CBSS; break;
+    case( FAC_Ag ): *ssCd = SS_CD_BOC;      break;
+    case( FAC_Ac ): *ssCd = SS_CD_BIC;      break;
+
+    case( FAC_Sc ):
+    case( FAC_Fd ):
+    case( FAC_Al ):
+#ifdef SIM_PERS
+    case( FAC_Pn ):
+    case( FAC_Pu ):
+    case( FAC_Pc ):
+    case( FAC_Pp ):
+    case( FAC_Ps ):
+    case( FAC_Pf ):
+    case( FAC_Bl ):
+    case( FAC_Mu ):
+    case( FAC_Mum ):
+#endif
+#ifdef FF_PHONE_LOCK
+    case( FAC_Pl ):
+    case( FAC_Apl):
+#endif
+      *ssCd = NOT_PRESENT_8BIT; break;
+
+    case( FAC_NotPresent  ):
+    default:
+
+      ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
+      return( FALSE );
+  }
+  return TRUE;
+}
+
+#if defined (SIM_PERS) || defined (FF_PHONE_LOCK)
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SS                       |
+| STATE   : code             ROUTINE : cmhSS_check_oper_result               |
++-------------------------------------------------------------------+
+  PARAMETERS  : result - CLCK operation result for SIMP and Phone Lock .
+
+   RETURN      :  AT_CMPL for success and AT_FAIL for Failure case
+
+  PURPOSE     : This function returns AT_CMPL for success case and 
+                        returns  AT_FAIL for Failure cases  with proper  Error code
+  
+*/
+
+ T_ACI_RETURN cmhSS_check_oper_result(T_OPER_RET_STATUS result)
+  {
+
+    switch( result )
+      { 
+       case( OPER_SUCCESS ): 
+        return ( AT_CMPL );
+			
+       case( OPER_WRONG_PASSWORD ): 
+      {
+        ACI_ERR_DESC( ACI_ERR_CLASS_Cme,CME_ERR_WrongPasswd );
+        return( AT_FAIL );  
+      }
+       case( OPER_BUSY ): 
+     {
+            ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Busy );
+            return( AT_FAIL );
+     }
+  	 
+       default:
+       ACI_ERR_DESC( ACI_ERR_CLASS_Cme,CME_ERR_Unknown );
+       return( AT_FAIL );
+     
+     }
+     
+  }
+
+#endif
+
+/* Implements Measure # 38 */
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SS                       |
+| STATE   : code             ROUTINE : cmhSS_ksdCWCBStartTrans      |
++-------------------------------------------------------------------+
+  PARAMETERS  : srcId - source of AT Command
+                ksdCmd- Contains KSD command identifier. Used to 
+                        identify whether to operate on key sequence 
+                        command for CB or for CW supplementary services
+
+                seqPrm - T_KSD_SEQPARAM structure containing the CB 
+                         and CW parameter information 
+  RETURN      : Status of operation
+  PURPOSE     : This function invokes the operation for key sequence
+                command for CB and CW supplementary services.
+*/
+
+GLOBAL T_ACI_RETURN cmhSS_ksdCWCBStartTrans(T_ACI_CMD_SRC  srcId,  
+                                           T_ACI_KSD_CMD  ksdCmd,
+                                           T_KSD_SEQPARAM *seqPrm)
+{
+  SHORT sId;                /* holds service id */
+  UBYTE bst,bs, opCd, ssCd, bsCd;
+
+  if(ksdCmd EQ KSD_CMD_CB)
+  {
+   /*
+    *-------------------------------------------------------------------
+    * check parameter ss code
+    *-------------------------------------------------------------------
+    */
+    switch( seqPrm->cb.ssCd )
+    {
+      case( KSD_SS_BOC      ):
+      case( KSD_SS_BOICXH   ):
+      case( KSD_SS_BOIC     ):
+      case( KSD_SS_ALL_CBSS ):
+      case( KSD_SS_BAOC     ):
+      case( KSD_SS_BIC      ):
+      case( KSD_SS_BAIC     ):
+      case( KSD_SS_BICRM    ):
+
+        break;
+
+      default:
+
+        return( AT_FAIL );
+    }
+    opCd = seqPrm->cb.opCd;
+    ssCd = seqPrm->cb.ssCd;  
+    bsCd = seqPrm->cb.bsCd;  
+  }
+  else if(ksdCmd EQ KSD_CMD_CW)
+  {
+    opCd = seqPrm->cw.opCd;
+    ssCd = KSD_SS_CW;  
+    bsCd = seqPrm->cw.bsCd; 
+  }
+  else
+  {
+    return( AT_FAIL );
+  }
+  /*
+   *-------------------------------------------------------------------
+   * check parameter basic service code
+   *-------------------------------------------------------------------
+   */
+  if( !cmhSS_CheckBscSrv( bsCd, &bs, &bst, NULL ))
+  {
+    return( AT_FAIL );
+  }
+  /*
+   *-------------------------------------------------------------------
+   * get a new service table entry
+   *-------------------------------------------------------------------
+   */
+  sId = psaSS_stbNewEntry();
+
+  if( sId EQ NO_ENTRY )
+  {
+    return( AT_FAIL );
+  }
+
+  /*
+   *-------------------------------------------------------------------
+   * check parameter operation code
+   *-------------------------------------------------------------------
+   */
+  CCD_START;
+
+  switch( opCd )
+  {
+    /* interrogate call forwarding service */
+    case( KSD_OP_IRGT  ):
+      psaSS_asmInterrogateSS( ssCd, bst, bs );
+      break;
+
+    /* activate call forwarding service */
+    case( KSD_OP_ACT   ):
+      psaSS_asmActivateSS( ssCd, bst, bs );
+      break;
+
+    /* deactivate call forwarding service */
+    case( KSD_OP_DEACT ):
+      psaSS_asmDeactivateSS( ssCd, bst, bs );
+      break;
+
+    /* register call forwarding service */
+    case( KSD_OP_REG   ):
+    /* erase call forwarding service */
+    case( KSD_OP_ERS   ):
+    /* unexpected operation code */
+    default:
+
+      CCD_END;
+      return( AT_FAIL );
+  }
+
+  /*
+   *-------------------------------------------------------------------
+   * start transaction
+   *-------------------------------------------------------------------
+   */
+  ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
+  ssShrdPrm.stb[sId].ssCode     = ssCd;
+  ssShrdPrm.stb[sId].orgOPC     = opCd;
+  ssShrdPrm.stb[sId].opCode     = opCd;
+  ssShrdPrm.stb[sId].srvOwn     = (T_OWN)srcId;
+  ssShrdPrm.stb[sId].curCmd     = (T_ACI_AT_CMD)ksdCmd;
+
+  psaSS_NewTrns(sId);
+
+  CCD_END;
+  /*
+   *-------------------------------------------------------------------
+   * store password for later use
+   *-------------------------------------------------------------------
+   */
+  if(ksdCmd EQ KSD_CMD_CB)
+  {
+    if( seqPrm->cb.pwd )
+    {
+      strncpy
+      (
+        (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
+        (char *) seqPrm->cb.pwd,
+        MAX_PWD_NUM
+      );
+      cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
+    }
+    else
+    {
+      /* No password was given reset to default */
+/* Implements Measure#32: Row 1115 */
+      strncpy
+      (
+        (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
+        ffff_str,
+        MAX_PWD_NUM
+      );
+      cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
+    }
+  }
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  if( srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT )
+  {
+    T_ACI_CLOG cmdLog;        /* holds logging info */
+    cmdLog.cmdType              = CLOG_TYPE_Set;
+    cmdLog.retCode              = AT_EXCT;
+    cmdLog.cId                  = ACI_NumParmNotPresent;
+    cmdLog.sId                  = sId+1;  
+    cmdLog.atCmd                = (T_ACI_AT_CMD)ksdCmd;
+
+    if(ksdCmd EQ KSD_CMD_CB)
+    {
+      cmdLog.cmdPrm.sKSCB.srcId   = srcId;
+      cmdLog.cmdPrm.sKSCB.opCd    = seqPrm->cb.opCd;
+      cmdLog.cmdPrm.sKSCB.ssCd    = seqPrm->cb.ssCd;
+      cmdLog.cmdPrm.sKSCB.bsTp    = bst;
+      cmdLog.cmdPrm.sKSCB.bsCd    = bs;
+      cmdLog.cmdPrm.sKSCB.pwd     = seqPrm->cb.pwd;
+    }
+    else
+    {
+      cmdLog.cmdPrm.sKSCW.srcId   = srcId;
+      cmdLog.cmdPrm.sKSCW.opCd    = seqPrm->cw.opCd;
+      cmdLog.cmdPrm.sKSCW.bsTp    = bst;
+      cmdLog.cmdPrm.sKSCW.bsCd    = bs;
+    }
+    rAT_PercentCLOG( &cmdLog );
+  }
+#endif
+
+  return AT_EXCT;
+}
+/* Implements Measure # 85 */
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SS                       |
+| STATE   : code             ROUTINE : cmhSS_checkCCFC_RSN          |
++-------------------------------------------------------------------+
+  PARAMETERS  : reason - T_ACI_CCFC_RSN that has to be converted to 
+                appropriate SS code
+                ssCd - Parameter in which SS Code is filled
+  RETURN      : Boolean value indicates FALSE if unknown T_ACI_CCFC_RSN 
+                is sent
+  PURPOSE     : This function converts the T_ACI_CCFC_RSN to the 
+                appropriate ss Code.  
+*/
+
+GLOBAL BOOL cmhSS_checkCCFC_RSN(T_ACI_CCFC_RSN reason, UBYTE *ssCd)
+{
+/*
+ *-------------------------------------------------------------------
+ * 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( FALSE );
+  }
+  return TRUE;
+}
+
+/*==== EOF ========================================================*/