diff g23m/condat/ms/src/aci/cmh_smsr.c.orig @ 0:509db1a7b7b8

initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/g23m/condat/ms/src/aci/cmh_smsr.c.orig	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,2862 @@
+/* 
++----------------------------------------------------------------------------- 
+|  Project :  GSM-PS (6147)
+|  Modul   :  CMH_SMSR
++----------------------------------------------------------------------------- 
+|  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 which are responsible
+|             for the responses of the protocol stack adapter for
+|             the short message service.
++----------------------------------------------------------------------------- 
+*/ 
+
+#ifndef CMH_SMSR_C
+#define CMH_SMSR_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 "aci.h"
+#include "aci_lst.h"
+#include "aci_mem.h"
+#include "psa.h"
+#include "psa_sms.h"
+#include "psa_mmi.h"
+#include "psa_cc.h"
+
+#include "cmh.h"
+#include "cmh_sms.h"
+#include "psa_sim.h"
+#include "cmh_sim.h"
+#include "psa_util.h"
+#include "Phb.h"
+
+#ifdef SIM_TOOLKIT
+#include "psa_sat.h"
+#include "cmh_sat.h"
+#endif /* of SIM_TOOLKIT */
+
+#if (defined (MFW) AND !defined (FF_MMI_RIV)) OR defined (_CONC_TESTING_) OR defined (SMI)
+#include "conc_sms.h"
+#endif /* ##if (defined (MFW) AND !defined (FF_MMI_RIV)) OR defined (_CONC_TESTING_) OR defined (SMI)*/
+
+#ifdef _CONC_TESTING_
+#include "aci_mfw.h"
+#endif
+
+
+/*==== CONSTANTS ==================================================*/
+
+/* TP-User-Data-Header-Indicator (TP-UDHI) */
+#define UDHI_MASK      0x40
+#define UDHI_PRESENT   0x40
+#define UDHI_ABSENT    0x00
+
+/*==== TYPES ======================================================*/
+
+/*==== EXPORT =====================================================*/
+
+/*==== VARIABLES ==================================================*/
+
+EXTERN T_ACI_LIST *set_prm_list;
+
+/*==== FUNCTIONS ==================================================*/
+LOCAL BOOL cmhSMS_cpySTtoSM(T_ACI_CMGL_SM *p_sm,T_MNSMS_READ_CNF * mnsms_read_cnf);
+
+/* help function for cmhSMS_SMRead to inform user in case of
+ * CCD decoding error with SMS
+ * for this case the T_ACI_SMS_STAT has been extended with a value
+ * of SMS_STAT_Invalid = -2 (e.g to tell BMI to emit "INVALID MESSAGE") */
+LOCAL void cmhSMS_invalidSMS_notification_to_user(T_MNSMS_READ_CNF * mnsms_read_cnf)
+{
+  UBYTE idx = 0;
+  T_ACI_AT_CMD  cmdBuf = smsShrdPrm.smsEntStat.curCmd;
+  T_ACI_CMD_SRC ownBuf = smsShrdPrm.smsEntStat.entOwn;
+
+  TRACE_FUNCTION ("cmhSMS_SMRead_invalidSMS_notification_to_user()");
+  if (smsShrdPrm.pDecMsg->stat EQ SMS_STAT_Invalid)
+  {
+    switch( smsShrdPrm.smsEntStat.curCmd )
+    {
+      case ( AT_CMD_CMGR ):
+      {
+        smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+        smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; 
+        if (smsShrdPrm.rplyCB.cmgr NEQ NULL)
+        {
+          smsShrdPrm.rplyCB.cmgr( smsShrdPrm.pDecMsg, NULL );
+        }
+        R_AT ( RAT_OK, ownBuf) ( cmdBuf );
+        break;
+      }
+      case ( AT_CMD_CMGL ):
+      {
+        R_AT ( RAT_CMGL, smsShrdPrm.smsEntStat.entOwn ) ( smsShrdPrm.pDecMsg ); /* intermediate result */
+        if (mnsms_read_cnf->rec_next NEQ SMS_RECORD_NOT_EXIST)
+        {
+          psaSMS_ReadReq ( smsShrdPrm.mem1, mnsms_read_cnf->rec_next,
+                           smsShrdPrm.rdMode, cmglStat );
+        }
+        break;
+      }
+    }  
+  }
+  else
+  {
+    /*
+     * SMS decoding failed, but the status has not been set to SMS_STAT_Invalid
+     */
+    TRACE_FUNCTION ("cmhSMS_SMRead_invalidSMS_notification_to_MFW(): [ERR] status not SMS_STAT_Invalid !");
+  }
+}
+
+
+#ifdef SIM_TOOLKIT
+LOCAL void cmhSMS_SATResult (T_ACI_SAT_TERM_RESP *p_resp_data,
+                             USHORT              cause)
+{
+  if (GET_CAUSE_ORIGIN_ENTITY(cause) EQ SMSCP_ORIGINATING_ENTITY)
+  { /* CP-CAUSE */
+    p_resp_data->add_content = GET_CAUSE_VALUE(cause) | 0x80;
+    psaSAT_SendTrmResp( RSLT_NTW_UNAB_PROC, p_resp_data );
+  }
+  else
+  { /* RP-CAUSE or other */
+    if (GET_CAUSE_ORIGIN_ENTITY(cause) EQ SMSRP_ORIGINATING_ENTITY)
+      p_resp_data->add_content = GET_CAUSE_VALUE(cause);
+    else
+      p_resp_data->add_content = ADD_NO_CAUSE;
+    psaSAT_SendTrmResp( RSLT_SMS_ERR, p_resp_data);
+  }
+}
+#endif /* #ifdef SIM_TOOLKIT */
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_CBMIndication         |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to notify the command handler of
+            the receiving of a cell broadcast message.
+*/
+GLOBAL SHORT cmhSMS_CBMIndication ( T_MMI_CBCH_IND * mmi_cbch_ind )
+{
+  USHORT         sn;       /* serial number               */
+  USHORT         mid;      /* message identifier          */
+  UBYTE          dcs;      /* data coding scheme          */
+  UBYTE          page;     /* actual page number          */
+  UBYTE          pages;    /* total number of pages       */
+  T_ACI_CBM_DATA msg;      /* cell broadcast message data */
+  UBYTE          idx;
+
+  TRACE_FUNCTION ("cmhSMS_CBMIndication ()");
+
+  /*
+   *-----------------------------------------------------------------
+   * process parameters for new message indication
+   *-----------------------------------------------------------------
+   */
+  sn    = ( ( SHORT )mmi_cbch_ind->cbch_msg[0] << 8 ) +
+                     mmi_cbch_ind->cbch_msg[1];
+  mid   = ( ( SHORT )mmi_cbch_ind->cbch_msg[2] << 8 ) +
+                     mmi_cbch_ind->cbch_msg[3];
+  dcs   = mmi_cbch_ind->cbch_msg[4];
+  page  = ( mmi_cbch_ind->cbch_msg[5] & 0xF0 ) >> 4;
+  pages = ( mmi_cbch_ind->cbch_msg[5] & 0x0F );
+
+  /*
+   *-----------------------------------------------------------------
+   * process message data, expanding from 7 to 8 bit
+   *-----------------------------------------------------------------
+   */
+  cmhSMS_expdSmsCb ( dcs,
+                     &mmi_cbch_ind->cbch_msg[CBCH_HEAD_LEN],
+                     (UBYTE)(mmi_cbch_ind->cbch_len - CBCH_HEAD_LEN),
+                     msg.data, &msg.len );
+
+  /*
+   *-----------------------------------------------------------------
+   * new message indication
+   *-----------------------------------------------------------------
+   */
+  #ifdef FF_MMI_RIV
+  {
+    T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent;
+
+    qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode);
+    if (sms_input_mode EQ CMGF_MOD_Pdu)
+    {
+      rAT_PlusCBMPdu (mmi_cbch_ind);
+    }
+    else
+    {
+      R_AT( RAT_CBM, CMD_SRC_LCL )
+          ( sn, mid, dcs, page, pages, &msg );
+    }
+  }
+#else 
+  R_AT( RAT_CBM, CMD_SRC_LCL )
+    ( sn, mid, dcs, page, pages, &msg );
+#endif
+
+  /* If the SMS shared params indicate no valid source interested in 
+   * the SMS indications, the indication is buffered */ /* Issue 25033 */
+  if( smsShrdPrm.smsSrcId EQ CMD_SRC_NONE )
+  {
+#ifdef DTI
+    T_CNMI_IND ind;
+
+    memcpy (&ind.cbm, mmi_cbch_ind, sizeof(T_MMI_CBCH_IND));
+    cmd_addCnmiNtry ( CNMI_CBM, &ind );
+#endif
+  }
+  else
+  {
+#ifdef FF_ATI
+    /* tell any remote source */
+    for( idx = CMD_SRC_LCL+1; idx < CMD_SRC_MAX; idx++ )
+    {
+      if (IS_SRC_USED (idx))
+      {
+        R_AT( RAT_CBM, idx ) ( mmi_cbch_ind );
+      }
+    }
+#endif
+  }
+
+  return 0;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSInitState          |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to handle the
+            SMS_STATE_INITIALISING state.
+*/
+GLOBAL SHORT cmhSMS_SMSInitState ( T_MNSMS_MESSAGE_IND * mnsms_message_ind )
+{
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+  T_ACI_CMGL_SM  sm;
+  T_ACI_SMS_STOR mem; /* holds message storage   */
+  UBYTE retCode = TRUE;
+  UBYTE msg_type;
+#endif /* SMI OR defined MFW */
+
+#ifdef _CONC_TESTING_
+#ifndef NTRACE
+  char trcBuf[80];
+  char *writeP;
+  int count;
+  USHORT offset;
+
+  TRACE_EVENT_P1("initstate:rec_num: %d", mnsms_message_ind->rec_num);
+  TRACE_EVENT_P1("initstate:status:  %d", mnsms_message_ind->status);
+  offset = mnsms_message_ind->sms_sdu.o_buf>>3;
+  writeP = trcBuf;
+  for (count=offset; count<offset+20; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]);
+  }
+  TRACE_EVENT("buf: ");
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+
+  writeP = trcBuf;
+  for (; count<offset+40; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]);
+  }
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+#endif
+#endif
+
+
+  TRACE_FUNCTION ("cmhSMS_SMSInitState()");
+
+
+  switch (mnsms_message_ind->mem_type)
+  {
+    case MEM_ME:
+      if (mnsms_message_ind->rec_num NEQ SMS_RECORD_NOT_EXIST)
+      {
+        smsShrdPrm.aci_sms_parameter.meUsed++;
+      }
+      if (smsShrdPrm.aci_sms_parameter.meTotal EQ 0)
+      {
+        smsShrdPrm.aci_sms_parameter.meTotal = mnsms_message_ind->rec_max;
+      }
+      break;
+    case MEM_SM:
+      if (mnsms_message_ind->rec_num NEQ SMS_RECORD_NOT_EXIST)
+      {
+        smsShrdPrm.aci_sms_parameter.simUsed++;
+        TRACE_EVENT_P1("simUsed: %d", smsShrdPrm.aci_sms_parameter.simUsed);
+      }
+      if (smsShrdPrm.aci_sms_parameter.simTotal EQ 0)
+      {
+        smsShrdPrm.aci_sms_parameter.simTotal = mnsms_message_ind->rec_max;
+        TRACE_EVENT_P1("simTotal: %d", smsShrdPrm.aci_sms_parameter.simTotal);
+      }
+      break;
+    default:
+      TRACE_EVENT("wrong memtype");
+  }
+
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+  cmhSMS_getMemCmh ( mnsms_message_ind->mem_type, &mem );
+  cmhSMS_SMSQueryType (&mnsms_message_ind->sms_sdu , &msg_type);
+  memset(&sm,0,sizeof(T_ACI_CMGL_SM) );
+  if(msg_type NEQ TP_MTI_SMS_STATUS_REP)
+  {
+    retCode = cmhSMS_cpyMsgInd ( &sm, mnsms_message_ind);
+  }
+  if (retCode EQ FALSE)
+  {
+    TRACE_EVENT("cmhSMS_SMSInitState():[ERR] decoding of SMS");
+    if (sm.stat NEQ SMS_STAT_Invalid)
+    {
+       TRACE_EVENT("cmhSMS_SMSInitState():[ERR] SMS decoding failed, but status not SMS_STAT_Invalid");
+    }
+  }
+
+#if defined FF_MMI_RIV
+  /* in case of RIV MMI: check if SMBS is enabled for sending also PDU data */
+  if(smsShrdPrm.perccmgf_smbs_mode EQ PERC_SMBS_MOD_ENABLE)
+  {
+    rAT_PlusCMTPdu (mnsms_message_ind);
+  }
+#endif /* FF_MMI_RIV */
+
+  R_AT( RAT_CMTI, CMD_SRC_LCL )
+         (mem, sm.msg_ref, &sm);
+#endif /* defined SMI OR defined MFW OR defined FF_MMI_RIV */
+
+  return 0;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSDelCnf             |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to handle MNSMS_DELETE_CNF primitive.
+*/
+GLOBAL SHORT cmhSMS_SMSDelCnf ( T_MNSMS_DELETE_CNF * mnsms_delete_cnf )
+{
+  T_ACI_AT_CMD  cmdBuf; /* buffers current command */
+  T_ACI_CMD_SRC ownBuf; /* buffers current owner   */
+  T_ACI_CMD_SRC srcId;  /* Hold the request Source ID */
+
+#ifdef _CONC_TESTING_
+
+  T_CONC_INIT_RETURN ret;
+
+#endif
+
+  TRACE_FUNCTION ("cmhSMS_SMSDelCnf()");
+
+  /*-------------------------------------------------------------------------*
+   * In R99 one more flag is added in CMGD command which is used to delete   *
+   * multiple messages of the same status ( READ, UNSENT, SENT etc ).        * 
+   * For this purpose the setting of global variables are done, once         *
+   * the it is confirmed that all the messages of the same status are        * 
+   * deleted.                                                                *
+   *-------------------------------------------------------------------------*/
+
+   cmdBuf = smsShrdPrm.smsEntStat.curCmd;
+   ownBuf = smsShrdPrm.smsEntStat.entOwn;
+   srcId  = smsShrdPrm.smsEntStat.entOwn;
+
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+  SET_OWNBUF_CONC;
+#endif /*#if defined SMI OR defined MFW*/
+
+    
+  if(smsShrdPrm.status > CMGD_DEL_INDEX)
+  {
+    ownBuf = smsShrdPrm.smsEntStat.entOwn;
+  }
+
+  if (IS_CAUSE_INVALID(mnsms_delete_cnf->cause))  /* no error */
+  {
+    /* Check if the mnsms_delete_req for deleting messages of particular 
+       status returned indicating no messages of requested status. Note 
+       that in this case also we return OK to the user */ 
+    if(mnsms_delete_cnf->rec_num NEQ 0)
+    {
+      switch (mnsms_delete_cnf->mem_type)
+      {
+        case MEM_ME:
+          smsShrdPrm.aci_sms_parameter.meUsed--;
+          break;
+        case MEM_SM:
+          smsShrdPrm.aci_sms_parameter.simUsed--;
+          break;
+        default:
+          TRACE_EVENT("wrong memtype");
+          return AT_FAIL;
+      }
+    }
+/*-----------------------------------------------------------------------*
+   * The below code is the new code added on 07/08/2003 due to the new     *
+   * flag for CMGD command as mentioned in R99. This flag handles the      *
+   * deletion of multiple messages. The deletion of concatination is       * 
+   * handled with different way other than handling normal indexed         *
+   * messages. The deletion of normal concatination messages is done as    *
+   * in the exiting code. But deletion of concatination message is handled *
+   * in the different way when delete flag is greater than ZERO. If the    *
+   * delete flag in CMGD command is greater than ZERO, then there is no    * 
+   * concatination check is done. After receiving the response from SMS    *
+   * with the deleted messages number, then we will do the concatination   *
+   * check. If CONC_NEEDED flag is set, then we will clear the             *
+   * concatinated list from the ACI. If CONC_NOT_NEEDED is set then check  *
+   * for the next record values, if it is greater than ZERO then send one  *
+   * more request for SMS to delete that message and repeat the above      *
+   * process untill ACI recive's the next record values as ZERO.           *
+   *-----------------------------------------------------------------------*/
+
+     if( smsShrdPrm.status > CMGD_DEL_INDEX AND 
+         mnsms_delete_cnf->rec_num NEQ 0)
+     {
+#ifdef _CONC_TESTING_
+       /*-----------------------------------------------------------------*
+        *                  Check for the concatination                    *
+        *-----------------------------------------------------------------*/
+       
+       ret= concSMS_initDeleteFromMem (srcId, mnsms_delete_cnf->rec_num);
+               
+       if( ret EQ CONC_NEEDED )
+       {
+         SET_CONC;   
+         concSMS_DeleteConcList();
+       }
+#endif
+       if ( mnsms_delete_cnf->delete_rec_next NEQ 0 )
+       {
+         cmhSMS_SendDelete_Req (mnsms_delete_cnf->delete_rec_next,
+                                smsShrdPrm.status);
+         return 0;
+       }
+     }
+    /*-----------------------------------------------------------------------*
+     *                    Reset the command context                          * 
+     *-----------------------------------------------------------------------*/
+
+    smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+    smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE;
+    smsShrdPrm.owner  = OWN_NONE;
+
+    /*-----------------------------------------------------------------------*
+     * The below code is used to handle the existing way where there is no   *
+     * delete falg is set ( i.e. delete flag == 0 )                          *
+     *-----------------------------------------------------------------------*/
+
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+    if (ownBuf EQ CMD_SRC_LCL)
+    {
+      if( smsShrdPrm.status EQ CMGD_DEL_INDEX )
+      {
+#ifdef _CONC_TESTING_
+        if (!ISSET_CONC) 
+        {
+#endif /* _CONC_TESTING_ */
+          TRACE_EVENT("you just erased a normal SMS !");
+          if(smsShrdPrm.rplyCB.cmgd NEQ NULL)
+          {
+            smsShrdPrm.rplyCB.cmgd( );
+          }
+          R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+#ifdef _CONC_TESTING_
+        }
+        else
+        {
+          /*-----------------------------------------------------------------*
+           *   Looks just about the same BUT: ISSET_CONC could be unsent     * 
+           *   in RAT_CMGD, so let this after checking ISSET_CONC            *
+           *-----------------------------------------------------------------*/
+
+          if(smsShrdPrm.rplyCB.cmgd NEQ NULL)
+          {
+            smsShrdPrm.rplyCB.cmgd( );
+          }
+        }
+#endif /* _CONC_TESTING_ */
+      }
+      else
+      {
+        R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+      if(smsShrdPrm.rplyCB.cmgd NEQ NULL)
+      {
+        smsShrdPrm.rplyCB.cmgd( );
+      }
+
+#if defined FF_MMI_RIV
+      R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+#else 
+      /* GPF-MMI */
+#ifdef _CONC_TESTING_
+      if (!ISSET_CONC)
+#endif /* _CONC_TESTING_ */
+        R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+      }
+#endif
+    }
+    else /* if (ownBuf EQ CMD_SRC_LCL) */
+#endif /*defined MFW OR defined FF_MMI_RIV*/
+    {
+      R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+    }
+  }
+  else
+  {
+    /*-----------------------------------------------------------------------*
+     *                    Reset the command context                          * 
+     *-----------------------------------------------------------------------*/
+
+    smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+    smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE;
+    smsShrdPrm.owner  = OWN_NONE;
+
+    if (smsShrdPrm.errorCB NEQ NULL)
+    {
+      smsShrdPrm.errorCB
+      (
+        cmdBuf,
+        cmhSMS_GetCmsFromSms(mnsms_delete_cnf->cause),
+        NULL
+      );
+    }
+    else
+    {
+      R_AT ( RAT_CMS, ownBuf ) ( cmdBuf, cmhSMS_GetCmsFromSms(mnsms_delete_cnf->cause), NULL );
+    }
+  }
+  /* Reset status flag to CMGD_DEL_INDEX = 0 */
+  smsShrdPrm.status = CMGD_DEL_INDEX;
+  return 0;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSStoCnf             |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to handle MNSMS_STORE_CNF primitive.
+*/
+GLOBAL SHORT cmhSMS_SMSStoCnf ( T_MNSMS_STORE_CNF * mnsms_store_cnf )
+{
+  T_ACI_AT_CMD  cmdBuf; /* buffers current command */
+  T_ACI_CMD_SRC ownBuf; /* buffers current owner   */
+
+  TRACE_FUNCTION ("cmhSMS_SMSStoCnf()");
+
+  /*
+   *-----------------------------------------------------------------
+   * reset the command context
+   *-----------------------------------------------------------------
+   */
+  cmdBuf                       = smsShrdPrm.smsEntStat.curCmd;
+  smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+  ownBuf                       = smsShrdPrm.smsEntStat.entOwn;
+
+#ifdef _CONC_TESTING_
+  /* this is only for testing */
+  SET_OWNBUF_CONC;
+#endif
+
+  smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE;
+  smsShrdPrm.owner  = OWN_NONE;
+
+  /* Check for current cmd is CMGMDU */
+  if ( cmdBuf EQ AT_CMD_P_CMGMDU )
+  {
+    if (IS_CAUSE_INVALID(mnsms_store_cnf->cause))
+    {
+#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+      if (ownBuf EQ CMD_SRC_LCL)
+      {
+        if(smsShrdPrm.rplyCB.cmgmdu NEQ NULL)
+        {
+          smsShrdPrm.rplyCB.cmgmdu();
+        }
+      }
+      else
+#endif /*#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ */
+      {
+         R_AT ( RAT_OK,   ownBuf ) ( cmdBuf );
+      }
+    }
+    else
+    {
+      if ( ownBuf NEQ CMD_SRC_LCL )
+        R_AT ( RAT_CMS, ownBuf )
+        (
+          cmdBuf,
+          cmhSMS_GetCmsFromSms(mnsms_store_cnf->cause),
+          NULL
+        );
+      return -1;
+    }
+  }
+  else if (IS_CAUSE_INVALID(mnsms_store_cnf->cause))
+  {
+    switch (mnsms_store_cnf->mem_type)
+    {
+      case MEM_ME:
+        smsShrdPrm.aci_sms_parameter.meUsed++;
+        break;
+      case MEM_SM:
+        smsShrdPrm.aci_sms_parameter.simUsed++;
+        break;
+      default:
+        TRACE_EVENT("incorrect memtype");
+        return AT_FAIL;
+    }
+#ifdef FF_ATI
+  /* "internal storage" handling -> storing from CNMI-buf to SIM/MS */
+  if( smsShrdPrm.uiInternalSmsStorage NEQ CMD_SRC_NONE )
+  {
+    if(mnsms_store_cnf->cause NEQ SMS_NO_ERROR)
+    {
+      TRACE_EVENT("cmhSMS_SMSStoCnf() : error at internal SMS storaging");
+      cmd_clearCnmiBuf(); /* clear CNMI buffer */
+      smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE;
+      return -1;
+    }
+
+    /* storing was succesful -> clear the stored msg. in CNMI buf */
+    cmd_clearFirstCnmiMessage();
+
+    /* try with the next msg. in CNMI-buf */
+    if( cmd_storeNextCnmiBufMsgToSim() NEQ TRUE ) /* do nothing if no more Msg's in CNMI buffer */
+    { /* no more messagees could be sent */
+      smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE;
+    }
+    return 0; /* returns immediately if internal storage is running */
+  }
+#endif /* FF_ATI */
+#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+    if (ownBuf EQ CMD_SRC_LCL)
+    {
+      if(smsShrdPrm.rplyCB.cmgw NEQ NULL)
+      {
+        smsShrdPrm.rplyCB.cmgw( mnsms_store_cnf->rec_num, 1 );
+      }
+#if defined FF_MMI_RIV
+      R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+#else
+      /* GPF-MMI */
+      if (!ISSET_CONC) 
+      {
+        TRACE_EVENT("you just wrote a normal SMS !");
+        R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+      }
+#endif /*#if !defined FF_MMI_RIV*/
+    }
+    else
+#endif /*#if defined MFW OR defined FF_MMI_RIV*/
+    {
+      R_AT ( RAT_CMGW, ownBuf ) ( mnsms_store_cnf->rec_num );
+      R_AT ( RAT_OK,   ownBuf ) ( cmdBuf );
+      /* inform BMI */
+      cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMGW, mnsms_store_cnf->rec_num, -1, -1 );
+    }
+  }
+  else
+  {
+    if( smsShrdPrm.uiInternalSmsStorage NEQ CMD_SRC_NONE )
+    {
+      smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE;
+      return 0;
+    }
+
+    if (ownBuf EQ CMD_SRC_LCL)
+    {
+      if (smsShrdPrm.errorCB NEQ NULL)
+      {
+        smsShrdPrm.errorCB
+        (
+          cmdBuf,
+          cmhSMS_GetCmsFromSms(mnsms_store_cnf->cause),
+          NULL
+        );
+      }
+    }
+    else
+    {
+      R_AT ( RAT_CMS, ownBuf )
+      (
+        cmdBuf,
+        cmhSMS_GetCmsFromSms(mnsms_store_cnf->cause),
+        NULL
+      );
+    }
+  }
+  return 0;
+}
+
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSSbmCnf             |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to handle MNSMS_SUBMIT_CNF primitive.
+*/
+GLOBAL SHORT cmhSMS_SMSSbmCnf ( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf )
+{
+  T_ACI_AT_CMD  cmdBuf; /* buffers current command */
+  T_ACI_CMD_SRC ownBuf; /* buffers current owner   */
+#ifdef SIM_TOOLKIT
+  T_ACI_SAT_TERM_RESP resp_data;
+#endif
+
+
+#ifdef _CONC_TESTING_
+#ifndef NTRACE
+  char trcBuf[80];
+  char *writeP;
+  int count;
+  USHORT offset;
+
+  TRACE_EVENT_P1("cause: %d", mnsms_submit_cnf->cause);
+  offset = mnsms_submit_cnf->sms_sdu.o_buf>>3;
+  writeP = trcBuf;
+  for (count=offset; count<offset+20; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_submit_cnf->sms_sdu.buf[count]);
+  }
+  TRACE_EVENT("buf: ");
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+
+  writeP = trcBuf;
+  for (; count<offset+40; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_submit_cnf->sms_sdu.buf[count]);
+  }
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+#endif
+#endif
+
+  TRACE_FUNCTION ("cmhSMS_SMSSbmCnf()");
+
+  /*
+   *-----------------------------------------------------------------
+   * reset the command context
+   *-----------------------------------------------------------------
+   */
+  cmdBuf                       = smsShrdPrm.smsEntStat.curCmd;
+  smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+
+  ownBuf                       = smsShrdPrm.smsEntStat.entOwn;
+
+#ifdef _CONC_TESTING_
+  /* this is only for testing */
+  SET_OWNBUF_CONC;
+#endif
+  smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE;
+  smsShrdPrm.owner             = OWN_NONE;
+
+#ifdef SIM_TOOLKIT
+  psaSAT_InitTrmResp( &resp_data );
+#endif
+
+  if (IS_CAUSE_INVALID(mnsms_submit_cnf->cause))
+  {
+    smsShrdPrm.aci_sms_parameter.snd_msg_ref = mnsms_submit_cnf->tp_mr;
+    switch (cmdBuf)
+    {
+      case( AT_CMD_CMSS ):
+#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+        if (ownBuf EQ CMD_SRC_LCL)
+        {
+          if(smsShrdPrm.rplyCB.cmss NEQ NULL)
+          {
+            smsShrdPrm.rplyCB.cmss( mnsms_submit_cnf->tp_mr, 1 );
+          }
+#if defined FF_MMI_RIV
+          R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+#else
+          if (!ISSET_CONC) 
+          {
+            R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+          }
+#endif /* FF_MMI_RIV */
+        }
+        else /* if (ownBuf EQ CMD_SRC_LCL) */
+#endif /*#if defined MFW OR defined FF_MMI_RIV*/
+        {
+          R_AT ( RAT_CMSS, ownBuf ) ( mnsms_submit_cnf );
+          R_AT ( RAT_OK,   ownBuf ) ( cmdBuf );
+          /* inform BMI */
+          cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMSS, mnsms_submit_cnf->rec_num, -1, -1 );
+        }
+        break;
+      case( AT_CMD_CMGS ):
+#if defined (SIM_TOOLKIT)
+        if (ownBuf EQ OWN_SAT)
+        {
+          psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
+          break;
+        }
+#endif
+        if (mnsms_submit_cnf->rec_num NEQ SMS_RECORD_NOT_EXIST)
+        {
+          switch (mnsms_submit_cnf->mem_type)
+          {
+            case MEM_ME:
+              smsShrdPrm.aci_sms_parameter.meUsed++;
+              break;
+            case MEM_SM:
+              smsShrdPrm.aci_sms_parameter.simUsed++;
+              break;
+            default:
+              TRACE_EVENT("incorrect memtype");
+              return AT_FAIL;
+          }
+        }
+#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+        if (ownBuf EQ CMD_SRC_LCL)
+        {
+          if(smsShrdPrm.rplyCB.cmgs NEQ NULL)
+          {
+            smsShrdPrm.rplyCB.cmgs( mnsms_submit_cnf->tp_mr, 1 );
+          }
+#if defined FF_MMI_RIV
+          R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+#else
+          if (!ISSET_CONC)
+          {
+            R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+          }
+#endif /* FF_MMI_RIV */
+        }
+        else /* if (ownBuf EQ CMD_SRC_LCL) */
+#endif /*#if defined MFW OR defined FF_MMI_RIV*/
+        {
+          R_AT ( RAT_CMGS, ownBuf ) ( mnsms_submit_cnf );
+          R_AT ( RAT_OK,   ownBuf ) ( cmdBuf );
+          /* inform BMI */
+          cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMGS, mnsms_submit_cnf->rec_num, -1, -1 );
+        }
+    } /* switch */
+  }
+  else /* if (mnsms_submit_cnf->rslt_type EQ SMS_RT_NON) */
+  {
+#if defined (SIM_TOOLKIT)
+    if (ownBuf EQ OWN_SAT)
+    {
+      cmhSMS_SATResult (&resp_data, mnsms_submit_cnf->cause);
+    }
+#endif
+  /* MSMSMS */
+    if (ownBuf EQ CMD_SRC_LCL)
+    {
+      if (smsShrdPrm.errorCB NEQ NULL)
+      {
+        smsShrdPrm.errorCB
+        (
+          cmdBuf,
+          cmhSMS_GetCmsFromSms(mnsms_submit_cnf->cause),
+          NULL
+        );
+      }
+    }
+    else
+    {
+      R_AT ( RAT_CMS, ownBuf )
+      (
+        cmdBuf,
+        cmhSMS_GetCmsFromSms(mnsms_submit_cnf->cause),
+        NULL
+      );
+    }
+  }
+  return 0;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSCmdCnf             |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to handle MNSMS_COMMAND_CNF primitive.
+*/
+GLOBAL SHORT cmhSMS_SMSCmdCnf ( T_MNSMS_COMMAND_CNF * mnsms_command_cnf )
+{
+  T_ACI_AT_CMD  cmdBuf; /* buffers current command */
+  T_ACI_CMD_SRC ownBuf; /* buffers current owner   */
+#ifdef SIM_TOOLKIT
+  T_ACI_SAT_TERM_RESP resp_data;
+  psaSAT_InitTrmResp( &resp_data );
+#endif
+
+  TRACE_FUNCTION ("cmhSMS_SMSCmdCnf()");
+
+
+  /*
+   *-----------------------------------------------------------------
+   * reset the command context
+   *-----------------------------------------------------------------
+   */
+  cmdBuf                       = smsShrdPrm.smsEntStat.curCmd;
+  smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+
+  ownBuf                       = smsShrdPrm.smsEntStat.entOwn;
+
+  smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE;
+  smsShrdPrm.owner  = OWN_NONE;
+
+  if (IS_CAUSE_INVALID(mnsms_command_cnf->cause))
+  {
+#ifdef _CONC_TESTING_
+    /* this is only for testing */
+    SET_OWNBUF_CONC;
+#endif
+
+#if defined (SIM_TOOLKIT)
+    if (ownBuf EQ OWN_SAT)
+    {
+      psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data );
+    }
+#endif
+#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+    if (ownBuf EQ CMD_SRC_LCL)
+    {
+      if(smsShrdPrm.rplyCB.cmgc NEQ NULL)
+      {
+        smsShrdPrm.rplyCB.cmgc( mnsms_command_cnf->tp_mr );
+      }
+#if defined FF_MMI_RIV
+      R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+#else
+      if (!ISSET_CONC) 
+      {
+        R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+      }
+#endif /*!defined FF_MMI_RIV*/
+    }
+    else /* if (ownBuf EQ CMD_SRC_LCL) */
+#endif /*defined MFW OR defined FF_MMI_RIV*/
+    {
+      R_AT ( RAT_CMGC, ownBuf ) ( mnsms_command_cnf );
+      R_AT ( RAT_OK,   ownBuf ) ( cmdBuf );
+      /* inform BMI */
+      /* This does not make much sense, but nice to have it for future requests */
+/*    cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMGC, -1, -1, -1 ); */
+    }
+
+  }
+  else
+  {
+#if defined (SIM_TOOLKIT)
+    if (ownBuf EQ OWN_SAT)
+    {
+      cmhSMS_SATResult (&resp_data, mnsms_command_cnf->cause);
+    }
+#endif
+
+    R_AT ( RAT_CMS, ownBuf )
+    (
+      cmdBuf,
+      cmhSMS_GetCmsFromSms(mnsms_command_cnf->cause),
+      NULL
+    );
+  }
+  return 0;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSErrorInd           |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to handle MNSMS_ERROR_IND primitive.
+*/
+GLOBAL SHORT cmhSMS_SMSErrorInd ( T_MNSMS_ERROR_IND * mnsms_error_ind )
+{
+  T_ACI_MM_CIND_VAL_TYPE sIndValues;
+  int i;
+
+  TRACE_FUNCTION ("cmhSMS_SMSErrorInd()");
+
+  TRACE_EVENT_P1("MNSMS_ERROR_IND: 0x%4.4X", (int)mnsms_error_ind->cause);
+
+  if( (mnsms_error_ind->cause != SMS_CAUSE_MEM_FULL) && 
+      (mnsms_error_ind->cause != SMS_CAUSE_MEM_AVAIL) )
+  {
+    smsShrdPrm.cnma_ack_expected = FALSE;
+    cmhSMS_resetMtDsCnmiParam();
+  }
+  else
+  { /* process the SMS memory full/avail indication */
+    sIndValues.sCindSmsFullParam = (mnsms_error_ind->cause EQ SMS_CAUSE_MEM_AVAIL)
+                                   ? CIND_SMSFULL_INDICATOR_MEMAVAIL
+                                   : CIND_SMSFULL_INDICATOR_MEMFULL;
+    sIndValues.sCindSignalParam  = CIND_SIGNAL_INDICATOR_INVALID;
+
+    for( i = CMD_SRC_LCL; i < CMD_SRC_MAX; i++)
+    {
+      if( ((cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCINDSettings.sCindSmsFullParam EQ CIND_SMSFULL_INDICATOR_MEMFULL) AND
+           (cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCMERSettings.sCmerIndParam EQ CMER_INDICATOR_2)) OR
+          ((cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCINDSettings.sCindSmsFullParam <= CIND_SMSFULL_INDICATOR_MEMAVAIL) AND
+           (cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCMERSettings.sCmerIndParam EQ CMER_INDICATOR_1)) )
+      { /* process the service of +CIEV */
+        TRACE_EVENT("send +CIEV (SMS-full/avail)");
+        R_AT (RAT_CIEV, i) ( sIndValues, cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCMERSettings );
+      }
+    }
+  }
+  return 0;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSDeliver            |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to notify the command handler of
+            the receiving of a SMS-DELIVER.
+*/
+#ifndef NTRACE
+LOCAL void trace_SMSDeliver ( T_MNSMS_MESSAGE_IND * mnsms_message_ind )
+{
+#ifdef _CONC_TESTING_
+
+  char trcBuf[80];
+  char *writeP;
+  int count;
+  USHORT offset;
+
+  TRACE_FUNCTION ("trace_SMSDeliver");
+
+  TRACE_EVENT_P1("cmt:bitoffset:%d", mnsms_message_ind->sms_sdu.o_buf);
+  TRACE_EVENT_P1("cmt:lenght:%d", mnsms_message_ind->sms_sdu.l_buf);
+  offset = mnsms_message_ind->sms_sdu.o_buf>>3;
+  writeP = trcBuf;
+  for (count=offset; count<offset+20; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]);
+  }
+  TRACE_EVENT("buf: ");
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+
+  writeP = trcBuf;
+  for (; count<offset+40; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]);
+  }
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+#endif
+}
+#endif
+
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+LOCAL void rAT_SMS_Deliver(T_MNSMS_MESSAGE_IND * mnsms_message_ind, T_ACI_CMGL_SM *p_sm)
+{
+#ifdef FF_MMI_RIV
+  T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent;
+#endif  /* FF_MMI_RIV */ 
+
+  TRACE_FUNCTION ("rAT_SMS_Deliver");
+
+#ifdef FF_MMI_RIV
+  if(smsShrdPrm.perccmgf_smbs_mode EQ PERC_SMBS_MOD_ENABLE)
+  {
+    /*send both formats*/
+    rAT_PlusCMTPdu (mnsms_message_ind);    
+    R_AT( RAT_CMT, CMD_SRC_LCL ) (p_sm);
+    return;  
+  }
+
+  /* else: no SMBS enabled, CMGF mode decides */
+  qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode);
+  if (sms_input_mode EQ CMGF_MOD_Pdu)
+  {
+    rAT_PlusCMTPdu (mnsms_message_ind);
+  }
+  else
+  {
+    R_AT( RAT_CMT, CMD_SRC_LCL ) (p_sm);
+  }
+  return;
+#endif   /* FF_MMI_RIV */ 
+
+  /* if GPF MMI call usual callback */
+  R_AT( RAT_CMT, CMD_SRC_LCL ) (p_sm);
+}
+#endif /* SMI OR defined MFW OR defined FF_MMI_RIV */
+
+GLOBAL SHORT cmhSMS_SMSDeliver ( T_MNSMS_MESSAGE_IND * mnsms_message_ind )
+{
+  UBYTE         idx;
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+  T_ACI_CMGL_SM *p_sm;
+#endif /* SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_*/
+
+  TRACE_FUNCTION ("cmhSMS_SMSDeliver");
+
+#ifndef NTRACE
+  trace_SMSDeliver ( mnsms_message_ind );
+#endif
+
+  if( smsShrdPrm.CNMImt EQ 0 )
+  {
+    TRACE_EVENT("cmhSMS_SMSDeliver():[ERR] <mt>==0 -> SMS will not be routed ");
+    return 0;
+  }
+
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+  ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) );
+  p_sm = smsShrdPrm.pDecMsg;
+  if (cmhSMS_cpyMsgInd ( p_sm, mnsms_message_ind) EQ FALSE)
+  {
+    TRACE_EVENT("cmhSMS_SMSDeliver():[ERR] decoding of SMS");
+    if (p_sm->stat NEQ SMS_STAT_Invalid)
+    {
+       TRACE_EVENT("cmhSMS_SMSDeliver():[ERR] SMS decoding failed, but status not SMS_STAT_Invalid");
+    }
+  }
+#endif /* SMI OR defined MFW OR defined FF_MMI_RIV */
+
+
+  if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus)
+    smsShrdPrm.cnma_ack_expected = TRUE;
+
+  /*
+   *-----------------------------------------------------------------
+   * new message indication
+   *-----------------------------------------------------------------
+   */
+
+  /* inform LOCAL MMI of new message */
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  rAT_SMS_Deliver(mnsms_message_ind, p_sm);
+#endif /* SMI OR defined MFW OR defined FF_MMI_RIV */
+
+  /* If the SMS shared params indicate no valid source interested in 
+   * the SMS indications, the indication is buffered */ /* Issue 25033 */
+  if( smsShrdPrm.smsSrcId EQ CMD_SRC_NONE )
+  {
+    T_CNMI_IND ind;
+
+    TRACE_EVENT("cmhSMS_SMSDeliver(): No registered source for ");
+    memcpy ( &ind.cmt, mnsms_message_ind, sizeof ( T_MNSMS_MESSAGE_IND) );
+#ifdef DTI
+    cmd_addCnmiNtry ( CNMI_CMT, &ind );
+#endif
+    if ( smsShrdPrm.cnma_ack_expected EQ TRUE )
+    { /* the acknowledge must be send automatically, because terminal is busy */
+      PALLOC (mnsms_ack_res, MNSMS_ACK_RES);
+
+      TRACE_EVENT("rCI_PlusCMT(): send 'automatic' acknowledge (Phase2+ mode and buffer)");
+
+      mnsms_ack_res->resp          = SMS_RP_ACK;
+      mnsms_ack_res->sms_sdu.o_buf = 0;
+      mnsms_ack_res->sms_sdu.l_buf = 0;
+
+      PSENDX (SMS, mnsms_ack_res);
+
+      smsShrdPrm.cnma_ack_expected = FALSE;
+    }
+  }
+  else
+  {
+    /* tell any remote source */
+    for( idx = CMD_SRC_LCL+1; idx < CMD_SRC_MAX; idx++ )
+    {
+#if defined _SIMULATION_ AND defined _CONC_TESTING_
+      /* don't display "+CMT: ..." in simulation if conc testing */
+      if (!concShrdPrm.concTesting)
+#endif
+      {
+        R_AT( RAT_CMT, idx ) ( mnsms_message_ind );
+      }
+    }
+  }
+
+  if (smsShrdPrm.pDecMsg)
+  {
+    ACI_MFREE(smsShrdPrm.pDecMsg);
+    smsShrdPrm.pDecMsg = NULL;
+  }
+
+  return 0;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSMemory             |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to notify the command handler of
+            an incoming SMS written to preferred message storage.
+*/
+GLOBAL SHORT cmhSMS_SMSMemory ( T_MNSMS_MESSAGE_IND * mnsms_message_ind)
+{
+  USHORT          idx; /* holds command source id */
+  T_ACI_SMS_STOR  mem; /* holds message storage   */
+  T_ACI_CMGL_SM  sm;
+
+#ifdef _CONC_TESTING_
+#ifndef NTRACE
+  char trcBuf[80];
+  char *writeP;
+  int count;
+  USHORT offset;
+
+  TRACE_EVENT_P1("cmti:rec_num: %d", mnsms_message_ind->rec_num);
+  TRACE_EVENT_P1("cmti:status:  %d", mnsms_message_ind->status);
+  offset = mnsms_message_ind->sms_sdu.o_buf>>3;
+  writeP = trcBuf;
+  for (count=offset; count<offset+20; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]);
+  }
+  TRACE_EVENT("buf: ");
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+
+  writeP = trcBuf;
+  for (; count<offset+40; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]);
+  }
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+#endif
+#endif
+
+  TRACE_FUNCTION ("cmhSMS_SMSMemory ()");
+
+  cmhSMS_getMemCmh ( mnsms_message_ind->mem_type, &mem );
+
+  switch (mnsms_message_ind->mem_type)
+  {
+    case MEM_ME:
+      smsShrdPrm.aci_sms_parameter.meUsed++;
+      break;
+    case MEM_SM:
+      smsShrdPrm.aci_sms_parameter.simUsed++;
+      break;
+    default:
+      TRACE_EVENT("wrong memtype");
+      return AT_FAIL;
+  }
+
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+  if (cmhSMS_cpyMsgInd ( &sm, mnsms_message_ind ) EQ FALSE)
+  {
+    TRACE_EVENT("cmhSMS_SMSMemory ():[ERR] decoding of SMS");
+    if (sm.stat NEQ SMS_STAT_Invalid)
+    {
+       TRACE_EVENT("cmhSMS_SMSMemory():[ERR] SMS decoding failed, but status not SMS_STAT_Invalid");
+    }
+  }
+#endif
+
+
+  /*
+   *-----------------------------------------------------------------
+   * new message indication
+   *-----------------------------------------------------------------
+   */
+
+
+#if defined FF_MMI_RIV
+  /* in case of RIV MMI: check if SMBS is enabled for sending also PDU data */
+  if(smsShrdPrm.perccmgf_smbs_mode EQ PERC_SMBS_MOD_ENABLE)
+  {
+    rAT_PlusCMTPdu (mnsms_message_ind);
+  }
+#endif /* FF_MMI_RIV */
+
+  R_AT( RAT_CMTI, CMD_SRC_LCL ) (mem, sm.msg_ref, &sm);
+
+  /* If the SMS shared params indicate no valid source interested in 
+   * the SMS indications, the indication is buffered */ /* Issue 25033 */
+  if( smsShrdPrm.smsSrcId EQ CMD_SRC_NONE )
+  {
+    T_CNMI_IND ind;
+
+    ind.cmti.mem   = mem;
+    ind.cmti.index = mnsms_message_ind->rec_num;
+#ifdef DTI
+    cmd_addCnmiNtry ( CNMI_CMTI, &ind );
+#endif
+  }
+  else
+  {
+    for( idx = CMD_SRC_LCL+1; idx < CMD_SRC_MAX; idx++ )
+    {
+#if defined _SIMULATION_ AND defined _CONC_TESTING_
+      /* don't display "+CMT: ..." in simulation if conc testing */
+      if (!concShrdPrm.concTesting)
+#endif
+      {
+        /* don't need the decoded message for Command Interpreter */
+        R_AT( RAT_CMTI, idx ) ( mem, mnsms_message_ind->rec_num );
+      }
+    }
+  }
+
+  return AT_CMPL;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSStatRpt            |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to notify the command handler of
+            the receiving of a SMS-STATUS-REPORT.
+*/
+GLOBAL SHORT cmhSMS_SMSStatRpt ( T_MNSMS_STATUS_IND * mnsms_status_ind )
+{
+  USHORT idx;                   /* holds command source id   */
+  T_ACI_CDS_SM* p_st;
+
+  TRACE_FUNCTION ("cmhSMS_SMSStatRpt ()");
+
+
+#if defined SMI OR defined MFW OR defined FF_MMI_RIV
+  ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CDS_SM) );
+  p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
+  cmhSMS_cpyStatInd ( p_st, mnsms_status_ind);
+#endif
+
+
+  if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus)
+    smsShrdPrm.cnma_ack_expected = TRUE;
+
+  /*
+   *-----------------------------------------------------------------
+   * new message indication
+   *-----------------------------------------------------------------
+   */
+ {
+   T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent;
+
+   /* If the SMS shared params indicate no valid source interested in 
+    * the SMS indications, the indication is buffered */ /* Issue 25033 */
+   if( smsShrdPrm.smsSrcId EQ CMD_SRC_NONE )
+   {
+     T_CNMI_IND ind;
+
+     memcpy ( &ind.cds, mnsms_status_ind, sizeof ( T_MNSMS_STATUS_IND) );
+#ifdef DTI
+     cmd_addCnmiNtry ( CNMI_CDS, &ind );
+#endif
+   }
+
+   for( idx = 0; idx < CMD_SRC_MAX; idx++ )
+   {
+     if (idx EQ CMD_SRC_LCL)
+     {
+   #ifdef FF_MMI_RIV
+       qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode);
+       if (sms_input_mode EQ CMGF_MOD_Pdu)
+       {
+         rAT_PlusCDSPdu (mnsms_status_ind);
+       }
+       else
+       {
+         R_AT( RAT_CDS, idx ) ( p_st );
+       }
+   #else
+       R_AT( RAT_CDS, idx ) ( p_st );
+   #endif 
+     }
+     else
+     {
+       R_AT( RAT_CDS, idx ) ( mnsms_status_ind );
+     }
+            
+    }
+  }
+
+  if (smsShrdPrm.pDecMsg)
+  {
+    ACI_MFREE(smsShrdPrm.pDecMsg);
+    smsShrdPrm.pDecMsg = NULL;
+  }
+
+  return 0;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_cpyLstData            |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to copy the data read from memory.
+            It sends a notification using the callback mechanism of
+            ACI if necessary.
+*/
+GLOBAL void cmhSMS_cpyLstData  ( T_ACI_AT_CMD     curCmd,
+                                 T_ACI_CMD_SRC    entOwn,
+                                 T_MNSMS_READ_CNF * mnsms_read_cnf )
+{
+  SHORT                 nextIdx;     /* index of next short message */
+
+  TRACE_FUNCTION ("cmhSMS_cpyLstData ()");
+
+  nextIdx = mnsms_read_cnf->rec_next;
+
+  if ( entOwn EQ CMD_SRC_LCL)
+  {
+#ifdef FF_MMI_RIV    
+    {
+      T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent;
+
+      qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode);
+      if (sms_input_mode EQ CMGF_MOD_Pdu )
+      {
+        if (curCmd EQ AT_CMD_CMGL)
+        {
+          rAT_PlusCMGLPdu (mnsms_read_cnf);
+        }
+        else if (curCmd EQ AT_CMD_P_CMGL)
+        {
+          rAT_PercentCMGLPdu (mnsms_read_cnf);
+        }
+      }
+      else if (curCmd EQ AT_CMD_CMGL)
+      {
+        R_AT ( RAT_CMGL, entOwn ) ( smsShrdPrm.pDecMsg );
+      }
+      else if (curCmd EQ AT_CMD_P_CMGL)
+      {
+        R_AT ( RAT_P_CMGL, entOwn ) ( smsShrdPrm.pDecMsg );
+      }
+    }
+#else
+    if (curCmd EQ AT_CMD_CMGL)
+    {
+      R_AT ( RAT_CMGL, entOwn ) ( smsShrdPrm.pDecMsg );
+    }
+    else if (curCmd EQ AT_CMD_P_CMGL)
+    {
+      R_AT ( RAT_P_CMGL, entOwn ) ( smsShrdPrm.pDecMsg );
+    }
+    
+#endif
+  }
+  else if (curCmd EQ AT_CMD_CMGL)
+  {
+    R_AT ( RAT_CMGL, entOwn ) ( mnsms_read_cnf );
+    /* inform BMI */
+    cmh_logRslt ( entOwn, RAT_OK, AT_CMD_CMGL, mnsms_read_cnf->rec_num, -1, -1 );
+  }
+  else if (curCmd EQ AT_CMD_P_CMGL)
+  {
+    /* the message shall not be displayed for ReadMode as Status Change */
+    if (smsShrdPrm.rdMode NEQ SMS_READ_StatusChange)
+    {
+      R_AT ( RAT_P_CMGL, entOwn ) ( mnsms_read_cnf );
+      /* inform BMI */  
+      cmh_logRslt ( entOwn, RAT_OK, AT_CMD_P_CMGL, mnsms_read_cnf->rec_num, -1, -1 );
+    }
+  }
+
+  if (nextIdx NEQ SMS_RECORD_NOT_EXIST)
+  {
+    /*
+     *-----------------------------------------------------------
+     * request the next list elements of given cmglStat state
+     *-----------------------------------------------------------
+     */
+     psaSMS_ReadReq ( smsShrdPrm.mem1, nextIdx,
+                               smsShrdPrm.rdMode, cmglStat );
+  }
+  else
+  {
+    /*
+     *-----------------------------------------------------------
+     * no more messages are available
+     *-----------------------------------------------------------
+     */
+
+    /* reset the command context */
+    smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+    smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+
+    R_AT ( RAT_OK,   entOwn ) ( curCmd );
+  }
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMReadCMSS            |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function processes the mnsms_read_cnf which was
+            triggered by +CMSS.
+*/
+GLOBAL void cmhSMS_SMReadCMSS ( T_MNSMS_READ_CNF * mnsms_read_cnf)
+{
+  T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set       */
+  UBYTE srcId;
+  UBYTE fo;
+  T_ACI_CMGL_SM *p_sm;
+  T_tp_da da_addr;
+  T_ACI_RETURN ret=AT_CMPL;
+  UBYTE modify=SMS_MODIFY_NON;
+
+#ifdef _CONC_TESTING_
+  char trcBuf[80];
+  char *writeP;
+  int  count;
+#endif
+
+  TRACE_FUNCTION ("cmhSMS_SMReadCMSS ()");
+
+
+  srcId = smsShrdPrm.smsEntStat.entOwn;
+  pSMSSetPrm = smsShrdPrm.pSetPrm[srcId];
+
+  if (smsShrdPrm.pDecMsg EQ NULL)
+  {
+    ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) );
+    p_sm = smsShrdPrm.pDecMsg;
+    /* decode message */
+    cmhSMS_cpyReadCnf ( p_sm, mnsms_read_cnf );
+  }
+  else
+    p_sm = smsShrdPrm.pDecMsg;
+
+  memset (&da_addr, 0, sizeof(T_tp_da));
+
+  /* start: check FDN if enabled */
+   if (pb_get_fdn_mode () EQ FDN_ENABLE AND
+       pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms  )
+  {
+
+    TRACE_EVENT_P1("cmhSMS_SMReadCMSS: FDN check: %s", p_sm->adress );
+
+    if (pb_check_fdn (0, (const UBYTE*) p_sm->adress) EQ PHB_OK)
+    {
+      TRACE_EVENT("cmhSMS_SMReadCMSS: Found match in FDN!");
+    }
+    else 
+    {
+      TRACE_EVENT("cmhSMS_SMReadCMSS: No match in FDN found, SMS rejected!");
+      /* error notification */
+      R_AT( RAT_CMS, smsShrdPrm.smsEntStat.entOwn )
+        ( smsShrdPrm.smsEntStat.curCmd, CMS_ERR_OpNotAllowed, NULL );
+      /* release context */
+      smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+      smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = CMD_SRC_NONE; 
+      return;
+    }
+  } 
+    /* end: check FDN if enabled */
+
+  /* 
+   * ACI-SPR-17004: set RFU bits of status to 0 if present since these 
+   * should be ignored in a GSM session (GSM 11.11 section 9.3)
+   */
+  cmhSMS_removeStatusRFUBits( &mnsms_read_cnf->status );
+
+  ACI_MALLOC(smsShrdPrm.tpdu.tp_submit, sizeof(T_TP_SUBMIT));
+
+  /* SMS-SUBMIT received */
+  if ((mnsms_read_cnf->status EQ SMS_RECORD_STO_UNSENT)  OR
+      (mnsms_read_cnf->status EQ SMS_RECORD_STO_SENT)    OR
+      (mnsms_read_cnf->status EQ SMS_RECORD_STAT_UNRCVD) OR
+      (mnsms_read_cnf->status EQ SMS_RECORD_STAT_UNSTRD) OR
+      (mnsms_read_cnf->status EQ SMS_RECORD_STAT_STRD)      )
+  {
+
+    /* destination address from stored message */
+    if (p_sm->adress[0] NEQ '\0')
+    {
+      cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, MAX_SMS_ADDR_DIG, p_sm->adress);
+      da_addr.ton = p_sm->toa.ton;
+      da_addr.npi = p_sm->toa.npi;
+      da_addr.digits = da_addr.c_num;
+    }
+
+    /* service center address from shared parameter */
+    if (pSMSSetPrm->sca.c_num NEQ 0)
+    {
+      memcpy (&smsShrdPrm.tpdu.sc_addr, &pSMSSetPrm->sca, sizeof(T_rp_addr));
+      modify |= SMS_MODIFY_SCA;
+
+    }
+
+    /* ACI-SPR-22528.The memory is allocated for smsShrdPrm.tpdu.tp_submit 
+     only when it is necessary*/
+
+    
+    cmhSMS_fillTpSubmit (smsShrdPrm.tpdu.tp_submit,
+                         srcId,
+                         0, /* fo */
+                         0,
+                         &da_addr,
+                         NULL,
+                         0,
+                         NULL );
+  }
+  else
+  {
+    /* SMS-DELIVER received */
+
+    T_ACI_SM_DATA packedData;
+    UBYTE byte_offset=0;
+
+    /* service center address from shared parameter */
+    if (pSMSSetPrm->sca.c_num NEQ 0)
+    {
+      memcpy (&smsShrdPrm.tpdu.sc_addr, &pSMSSetPrm->sca, sizeof(T_rp_addr));
+    }
+    else
+    {
+      if (p_sm->sca[0] NEQ '\0')
+      {
+        cmhSMS_getAdrBcd( smsShrdPrm.tpdu.sc_addr.num,
+                          &smsShrdPrm.tpdu.sc_addr.c_num,
+                          MAX_SMS_ADDR_DIG, p_sm->sca);
+        smsShrdPrm.tpdu.sc_addr.ton = p_sm->tosca.ton;
+        smsShrdPrm.tpdu.sc_addr.npi = p_sm->tosca.npi;
+        smsShrdPrm.tpdu.sc_addr.v_ton = TRUE;
+        smsShrdPrm.tpdu.sc_addr.v_npi = TRUE;
+      }
+    }
+
+    fo = (pSMSSetPrm->msgType & (~TP_MTI_MASK)) | TP_MTI_SMS_SUBMIT;
+
+    if (p_sm->udh.len)
+      byte_offset = p_sm->udh.len+1;
+
+    /* ACI-SPR-22528.The memory is allocated for smsShrdPrm.tpdu.tp_submit 
+     only when it is necessary*/
+
+    cmhSMS_rdcSmsPp ( byte_offset,
+                      p_sm -> dcs,
+                      ( UBYTE * ) p_sm->data.data, ( UBYTE ) p_sm->data.len,
+                      packedData.data, &packedData.len);
+
+    if (p_sm->adress[0] NEQ '\0')
+    {
+      cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, MAX_SMS_ADDR_DIG, p_sm->adress);
+      da_addr.ton = p_sm->toa.ton;
+      da_addr.npi = p_sm->toa.npi;
+      da_addr.digits = da_addr.c_num;
+    }
+    
+    cmhSMS_fillTpSubmit (smsShrdPrm.tpdu.tp_submit,
+                         srcId,
+                         fo,
+                         0,
+                         &da_addr,
+                         &packedData,
+                         p_sm->data.len,
+                         &p_sm->udh );
+   
+    modify = SMS_MODIFY_ALL;
+  }
+
+  {
+    PALLOC (mnsms_submit_req, MNSMS_SUBMIT_REQ);
+    mnsms_submit_req->rec_num  = mnsms_read_cnf->rec_num;
+    mnsms_submit_req->mem_type = smsShrdPrm.mem2;
+    mnsms_submit_req->condx    = SMS_CONDX_OVR_ANY;
+    mnsms_submit_req->modify   = modify;
+
+#ifdef SIM_TOOLKIT
+    if (psaSIM_ChkSIMSrvSup( SRV_MOSMCtrlSIM ))
+    {
+        if (simShrdPrm.setPrm[srcId].sat_cc_mode EQ SATCC_CONTROL_BY_SIM_ACTIVE)
+        {
+            ret = cmhSAT_MoSmCntr( smsShrdPrm.tpdu.sc_addr,
+                                 da_addr,
+                                 srcId);
+        }
+        else
+        {
+            simShrdPrm.setPrm[srcId].sat_cc_mode = SATCC_CONTROL_BY_SIM_ACTIVE;
+        }
+
+    }
+
+    if (ret NEQ AT_CMPL)
+    {
+      /* save primitive address for SIM_TOOLKIT response */
+      sat_mnsms_submit_req = mnsms_submit_req;
+      return;
+    }
+#endif
+    /* code SMS-SUBMIT here */
+    cmhSMS_codeMsg (&mnsms_submit_req->sms_sdu, SMS_VT_SUBMIT,
+                    &smsShrdPrm.tpdu.sc_addr, SMS_SUBMIT,
+                    (UBYTE*)smsShrdPrm.tpdu.tp_submit);
+
+    PSENDX (SMS, mnsms_submit_req);
+#ifdef _CONC_TESTING_
+#ifndef NTRACE
+    writeP = trcBuf;
+    for (count=0; count<20; count++)
+    {
+      writeP += sprintf (writeP, " %02X", mnsms_submit_req->sms_sdu.buf[count]);
+    }
+    TRACE_EVENT("buf: ");
+    *writeP = '\0';
+    TRACE_EVENT(trcBuf);
+
+    writeP = trcBuf;
+    for (; count<40; count++)
+    {
+      writeP += sprintf (writeP, " %02X", mnsms_submit_req->sms_sdu.buf[count]);
+    }
+    *writeP = '\0';
+    TRACE_EVENT(trcBuf);
+#endif
+#endif
+    if (smsShrdPrm.tpdu.tp_submit NEQ NULL)
+    {
+      ACI_MFREE(smsShrdPrm.tpdu.tp_submit);
+      smsShrdPrm.tpdu.tp_submit = NULL;
+    }
+  }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMRead                |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to notify the command handler of
+            a successfull reading of a short message from preferred
+            message storage.
+*/
+#ifndef NTRACE
+LOCAL void trace_read_sms( T_MNSMS_READ_CNF * mnsms_read_cnf)
+{
+  char trcBuf[80];
+  char *writeP;
+  int count;
+
+  TRACE_FUNCTION ("trace_read_sms ()");
+
+  TRACE_EVENT_P1(" rec_num:  %u", mnsms_read_cnf->rec_num);
+  TRACE_EVENT_P1(" rec_next: %u", mnsms_read_cnf->rec_next);
+  TRACE_EVENT_P1(" rec_max:  %u", mnsms_read_cnf->rec_max);
+  TRACE_EVENT_P1(" status    %u", mnsms_read_cnf->status);
+  TRACE_EVENT_P1(" cause     0x%04x", mnsms_read_cnf->cause);
+  writeP = trcBuf;
+  for (count=0; count<20; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_read_cnf->sms_sdu.buf[count]);
+  }
+  TRACE_EVENT("buf: ");
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+
+  writeP = trcBuf;
+  for (; count<40; count++)
+  {
+    writeP += sprintf (writeP, " %02X", mnsms_read_cnf->sms_sdu.buf[count]);
+  }
+  *writeP = '\0';
+  TRACE_EVENT(trcBuf);
+}
+#endif
+
+
+
+GLOBAL SHORT cmhSMS_SMRead ( T_MNSMS_READ_CNF * mnsms_read_cnf)
+{
+  T_ACI_AT_CMD  cmdBuf;       /* buffers current command          */
+  T_ACI_CMD_SRC ownBuf;       /* buffers current owner            */
+  T_ACI_CMGL_SM *p_sm;
+  T_rp_addr rp_addr;
+  UBYTE* message;
+  T_TP_DELIVER *sms_deliver, decoded_mesg;
+  BOOL  retCode = FALSE;
+  UBYTE  msg_type;
+
+  TRACE_FUNCTION ("cmhSMS_SMRead ()");
+
+#ifndef NTRACE
+  trace_read_sms(mnsms_read_cnf);
+#endif
+
+  cmdBuf = smsShrdPrm.smsEntStat.curCmd;
+  ownBuf = smsShrdPrm.smsEntStat.entOwn;
+
+  /* (SIM) error occurred */
+  if (!IS_CAUSE_INVALID(mnsms_read_cnf->cause))
+  {
+    if (mnsms_read_cnf->cause NEQ SMS_NO_ERROR)
+    {
+      /* reset the command context */
+      smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+      smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+      
+      if( ownBuf NEQ CMD_SRC_LCL OR cmdBuf NEQ AT_CMD_P_CMGMDU )
+      {
+        R_AT ( RAT_CMS, ownBuf )
+          (
+            cmdBuf,
+            cmhSMS_GetCmsFromSms(mnsms_read_cnf->cause),
+            NULL
+          );
+      }
+      return 1;
+    }
+  }
+
+#ifdef _CONC_TESTING_
+  /* this is only for testing */
+  SET_OWNBUF_CONC;
+#endif
+
+  /*
+   *-----------------------------------------------------------------
+   * ignore primitives with incorrect message status
+   *-----------------------------------------------------------------
+   */
+  TRACE_EVENT_P1("mnsms_read_cnf->status:  %d", mnsms_read_cnf->status);
+
+  if ( (mnsms_read_cnf->status EQ SMS_RECORD_FREE) OR
+       (mnsms_read_cnf->status EQ SMS_RECORD_INVALID) )
+  {
+    /* reset the command context */
+    smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+    smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+
+    TRACE_EVENT("incorrect message status");
+    return 1;
+  }
+
+  /* always decode for local source */
+  if (ownBuf EQ  CMD_SRC_LCL)                                    /* ACI-SPR-9528 */
+  {                                                              /* pass dummy p_sm to CB */
+    if (((cmdBuf EQ AT_CMD_CMGL OR cmdBuf EQ AT_CMD_CMGR) OR 
+          (cmdBuf EQ AT_CMD_P_CMGR OR cmdBuf EQ AT_CMD_P_CMGL))
+          AND smsShrdPrm.rdMode NEQ READ_STATUS_CHANGE)                /* ACI-FIX-9510 */
+    {
+      retCode = cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type);
+      if (retCode EQ FALSE)
+      {
+        /* reset the command context */
+        smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+        smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+
+        TRACE_EVENT("Error decoding message type");
+        return 1;
+      }
+      ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) );
+      memset(smsShrdPrm.pDecMsg,0,sizeof(T_ACI_CMGL_SM) );
+      p_sm = smsShrdPrm.pDecMsg;
+      if (msg_type EQ TP_MTI_SMS_STATUS_REP)
+      {
+        retCode=cmhSMS_cpySTtoSM(p_sm ,mnsms_read_cnf);
+      }
+      else
+      {
+          retCode = cmhSMS_cpyReadCnf ( p_sm, mnsms_read_cnf );
+      }
+      if (retCode EQ FALSE)
+      {
+        TRACE_EVENT("cmhSMS_SMRead ():[ERR] decoding of SMS");
+        cmhSMS_invalidSMS_notification_to_user (mnsms_read_cnf);
+      
+        ACI_MFREE(smsShrdPrm.pDecMsg);
+
+        /* reset the command context */
+        smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+        smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+
+        smsShrdPrm.pDecMsg = NULL;
+        if (mnsms_read_cnf->rec_next EQ SMS_RECORD_NOT_EXIST)
+        {
+          smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+          smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+          if( cmdBuf NEQ AT_CMD_P_CMGMDU )
+          {
+            R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+          }
+        }    
+        return 1;
+      }
+    }
+  }
+  else
+    p_sm = smsShrdPrm.pDecMsg;
+
+  /*
+   *-----------------------------------------------------------------
+   * check for command context
+   *-----------------------------------------------------------------
+   */
+  switch( smsShrdPrm.smsEntStat.curCmd )
+  {
+    case ( AT_CMD_CMGR ):
+    case ( AT_CMD_P_CMGR ):
+    {
+      /*
+       *-------------------------------------------------------------
+       * process event for +CGMR
+       *-------------------------------------------------------------
+       */
+
+      /* reset the command context */
+      smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+      smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+
+      /* The message need not be displayed for Status Change */
+      if (cmdBuf EQ AT_CMD_P_CMGR 
+            AND smsShrdPrm.rdMode EQ READ_STATUS_CHANGE)
+      {
+        R_AT ( RAT_OK,   ownBuf ) ( cmdBuf );
+        /* inform BMI */
+        cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_P_CMGR, mnsms_read_cnf->rec_num, -1, -1 );
+        break;
+      }
+
+
+#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_
+      if (ownBuf            EQ CMD_SRC_LCL) /* AND       /* ACI-FIX-9510 */
+       /* smsShrdPrm.rdMode NEQ READ_STATUS_CHANGE) */   /* call rplyCB (with invalid p_sm) anyway
+                                                            to touch all segments while in
+                                                            READ_STATUS_CHANGE */
+      {
+#if defined FF_MMI_RIV
+        T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent;
+        qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode);
+        if (sms_input_mode EQ CMGF_MOD_Pdu )
+        {
+          if (cmdBuf EQ AT_CMD_CMGR )
+          {
+            rAT_PlusCMGRPdu (mnsms_read_cnf);
+          }
+          else if (cmdBuf EQ AT_CMD_P_CMGR )
+          {
+            rAT_PercentCMGRPdu (mnsms_read_cnf);
+          }
+        }
+        else
+        {
+          if (smsShrdPrm.rplyCB.cmgr NEQ NULL)
+          {
+            smsShrdPrm.rplyCB.cmgr( p_sm, NULL );
+          }
+        }
+        R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+#else
+        /* GPF-MMI */
+        if (smsShrdPrm.rplyCB.cmgr NEQ NULL)
+        {
+          smsShrdPrm.rplyCB.cmgr( p_sm, NULL );
+        }
+        if (!ISSET_CONC)
+        {
+          R_AT ( RAT_OK, ownBuf ) ( cmdBuf );
+        }
+#endif
+      }
+      else /* if (ownBuf EQ CMD_SRC_LCL) */
+#endif /*#if defined MFW OR defined FF_MMI_RIV*/
+      {
+        if (cmdBuf EQ AT_CMD_CMGR )
+        {
+          R_AT ( RAT_CMGR, ownBuf ) ( mnsms_read_cnf, NULL );
+        }
+        else if (cmdBuf EQ AT_CMD_P_CMGR )
+        {
+          R_AT ( RAT_P_CMGR, ownBuf ) ( mnsms_read_cnf, NULL );
+        }
+
+        R_AT ( RAT_OK,   ownBuf ) ( cmdBuf );
+        /* inform BMI */
+        cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMGR, mnsms_read_cnf->rec_num, -1, -1 );
+      }
+
+      break;
+    }
+
+    case ( AT_CMD_P_CMGL ):
+    case ( AT_CMD_CMGL ):
+    {
+      /*
+       *-------------------------------------------------------------
+       * process event for +CMGL
+       *-------------------------------------------------------------
+       */
+      cmhSMS_cpyLstData ( cmdBuf, ownBuf, mnsms_read_cnf );
+
+      break;
+    }
+
+    case ( AT_CMD_P_CMGMDU ):
+    {
+      /*
+       *-------------------------------------------------------------
+       * process event for %CMGMDU
+       *-------------------------------------------------------------
+       */
+      message = cmhSMS_decodeMsg(&mnsms_read_cnf->sms_sdu, &rp_addr, SMS_VT_DELIVER);
+      sms_deliver = (T_TP_DELIVER*)message;
+      sms_deliver->tp_rp = 0;  
+      memcpy(&decoded_mesg, sms_deliver, sizeof(T_TP_DELIVER));
+      
+      {
+        PALLOC (mnsms_store_req, MNSMS_STORE_REQ);
+      
+        mnsms_store_req -> mem_type  = smsShrdPrm.mem1;
+        mnsms_store_req -> condx     = SMS_CONDX_OVR_ANY;
+        mnsms_store_req -> rec_num   = mnsms_read_cnf->rec_num;
+        mnsms_store_req -> status    = mnsms_read_cnf->status;
+
+        cmhSMS_codeMsg ( &mnsms_store_req->sms_sdu,
+                         SMS_VT_DELIVER,
+                         &rp_addr,
+                         SMS_DELIVER,
+                         (UBYTE*) &decoded_mesg);
+
+        PSENDX (SMS, mnsms_store_req);
+      }
+      break;
+    }
+#if defined (SIM_TOOLKIT)
+    case ( AT_CMD_CMSS ):
+    {
+      /*
+       *-------------------------------------------------------------
+       * process event for +CMSS (only for SAT)
+       *-------------------------------------------------------------
+       */
+      cmhSMS_SMReadCMSS (mnsms_read_cnf);
+
+      break;
+    }
+#endif
+
+    default:
+    {
+      TRACE_EVENT("error in command context");
+    }
+  }
+
+  if (smsShrdPrm.pDecMsg)
+  {
+    ACI_MFREE(smsShrdPrm.pDecMsg);
+    smsShrdPrm.pDecMsg = NULL;
+  }
+
+  return 0;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_Result                |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to notify the command handler of
+            a successfull transaction concerning the short message
+            service.
+*/
+GLOBAL SHORT cmhSMS_Result ( T_MNSMS_REPORT_IND * mnsms_report_ind )
+{
+  T_ACI_AT_CMD  cmdBuf; /* buffers current command */
+  T_ACI_CMD_SRC ownBuf; /* buffers current owner   */
+
+
+  TRACE_FUNCTION ("cmhSMS_Result ()");
+
+  if (mnsms_report_ind->v_cmms_mode)
+  {
+    smsShrdPrm.CMMSmode = mnsms_report_ind->cmms_mode;
+    return 0;
+  }
+  
+  cmdBuf            = AT_CMD_NONE;
+  ownBuf            = CMD_SRC_LCL;
+
+  smsShrdPrm.smsStat = mnsms_report_ind->state;
+
+
+  if (mnsms_report_ind->state EQ SMS_STATE_READY)
+  {
+    /* reading of SMs from SIM is completed,
+     * read SMSP, CBMIR, CMBI fields now
+     */
+    if (cmhSMS_ReadParams (NO_VLD_OWN, AT_CMD_CFUN, 1) NEQ AT_EXCT)
+    {
+      cmhSMS_ready ();
+    }
+    R_AT ( RAT_SIG_SMS, ownBuf ) ( SMS_STATE_READY );
+  }
+  else if (mnsms_report_ind->state EQ SMS_STATE_INITIALISING)
+  {
+    {     /*ACI-FIX-18055 resetting total and used storage counters of SIM and ME storages which will be updated by cmhSMS_SMSInitState */
+      smsShrdPrm.aci_sms_parameter.simTotal = 0;
+      smsShrdPrm.aci_sms_parameter.simUsed  = 0;
+      smsShrdPrm.aci_sms_parameter.meTotal  = 0;
+      smsShrdPrm.aci_sms_parameter.meUsed   = 0;
+    } /*ACI-FIX-18055 Changes end here */
+    R_AT ( RAT_SIG_SMS, ownBuf ) ( SMS_STATE_INITIALISING );
+  }
+  else if (mnsms_report_ind->state > SMS_STATE_INITIALISING)
+  {
+    R_AT ( RAT_CMS, ownBuf ) ( cmdBuf, CMS_ERR_UnknownErr, NULL );
+  }
+
+  return 0;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_WrCnfCSAS             |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to notify the command handler of
+            the usage of SIM and ME memory.
+*/
+GLOBAL void cmhSMS_WrCnfCSAS (SHORT aId)
+{
+  T_ACI_AT_CMD  cmdBuf;       /* buffers current command     */
+  T_ACI_CMD_SRC ownBuf;       /* buffers current owner       */
+  USHORT errCode;
+  USHORT dataField = 0xFF;
+  UBYTE  dataLen = 0;
+  UBYTE  data[MAX_SIM_CMD];
+
+  TRACE_FUNCTION ("cmhSMS_WrCnfCSAS ()");
+
+  cmdBuf = smsShrdPrm.smsEntStat.curCmd;
+  ownBuf = smsShrdPrm.smsEntStat.entOwn;
+
+  /*
+   *-----------------------------------------------------------------
+   * check for next SIM access
+   *-----------------------------------------------------------------
+   */
+  switch (smsShrdPrm.prmRdSeq)
+  {
+  case SMS_READ_SIM_SMSP:       /* EF(SMSP) written */
+    errCode = simShrdPrm.atb[aId].errCode;
+
+    if (smsShrdPrm.cbmPrm.cbmSIMmaxIdRge > 0 AND
+        cmhSMS_PutCbmirSIM (ownBuf, data,
+                            (int)smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4)) /* write CBMIR */
+    {
+      dataField = SIM_CBMIR;
+      dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4;
+      break;
+    }
+    else
+      smsShrdPrm.prmRdSeq--;
+
+    if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0 AND
+        cmhSMS_PutCbmiSIM (ownBuf, data,
+                           (int)smsShrdPrm.cbmPrm.cbmSIMmaxId * 2))   /* write CBMI */
+    {
+      dataField = SIM_CBMI;
+      dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxId * 2;
+    }
+    else     /* nothing else to write */
+    {
+      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL;
+    }
+    break;
+
+  case SMS_READ_SIM_CBMIR:           /* CBMIR written */
+    errCode = simShrdPrm.atb[aId].errCode;
+
+    if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0 AND    /* write CBMI */
+        cmhSMS_PutCbmiSIM (ownBuf, data,
+                           (int)smsShrdPrm.cbmPrm.cbmSIMmaxId * 2))
+    {
+      dataField = SIM_CBMI;
+      dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxId * 2;
+    }
+    else           /* nothing else to write */
+      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL;
+    break;
+
+  case SMS_READ_SIM_CBMI:  /* CBMI written */
+    errCode = simShrdPrm.atb[aId].errCode;
+
+    smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; /* nothing else to write */
+    break;
+
+  default:      /* nothing else to write */
+    smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL;
+    errCode = SIM_CAUSE_OTHER_ERROR;
+    break;
+  }
+  if ( smsShrdPrm.prmRdSeq EQ SMS_READ_SIM_CMPL)
+  {
+    smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+    smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+
+    if (errCode EQ SIM_NO_ERROR)
+    {
+      R_AT( RAT_OK, ownBuf ) ( cmdBuf );
+    }
+    else
+    {
+      R_AT( RAT_CMS, ownBuf )  /* unsuccessful SIM write */
+        (
+          cmdBuf,
+          cmhSMS_GetCmsFromSim ( errCode ),
+          NULL
+        );
+    }
+  }
+  else
+  {
+    if (cmhSIM_WriteTranspEF (CMD_SRC_NONE, cmdBuf,
+                              dataField, 0, dataLen,
+                              data, cmhSMS_WrCnfCSAS) EQ AT_FAIL)
+    {
+      smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+      smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+
+      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL;
+
+      R_AT( RAT_CMS, ownBuf ) ( cmdBuf, CMS_ERR_UnknownErr, NULL );
+    }
+    else
+      smsShrdPrm.prmRdSeq--;
+  }
+
+  simShrdPrm.atb[aId].ntryUsdFlg = FALSE;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_RdCnfCRES             |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to notify the command handler of
+            the usage of SIM and ME memory.
+*/
+GLOBAL void cmhSMS_RdCnfCRES (SHORT aId)
+{
+  T_ACI_AT_CMD  cmdBuf;       /* buffers current command     */
+  T_ACI_CMD_SRC ownBuf;       /* buffers current owner       */
+
+  USHORT errCode;
+  USHORT dataField = 0xFF;
+  UBYTE  dataLen = 0;
+  UBYTE profile;
+
+  TRACE_FUNCTION ("cmhSMS_RdCnfCRES ()");
+
+  cmdBuf = smsShrdPrm.smsEntStat.curCmd;
+  ownBuf = smsShrdPrm.smsEntStat.entOwn;
+
+  /*
+   *-----------------------------------------------------------------
+   * check for next SIM access
+   *-----------------------------------------------------------------
+   */
+  switch (smsShrdPrm.prmRdSeq)
+  {
+  case SMS_READ_SIM_SMSP:
+    if ((errCode = simShrdPrm.atb[aId].errCode) EQ SIM_NO_ERROR)
+    {
+      /* successful EF(SMSP) read */
+
+      profile = simShrdPrm.atb[aId].recNr;
+      
+      if (!cmhSMS_GetPrmSIM (ownBuf,
+                             simShrdPrm.atb[aId].exchData,
+                             simShrdPrm.atb[aId].dataLen))
+      {
+        errCode = SIM_CAUSE_OTHER_ERROR;
+      }
+    }
+    if (smsShrdPrm.cbmPrm.cbmSIMmaxIdRge > 0)
+    {
+      dataField = SIM_CBMIR;
+      dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4;
+      break;
+    }
+    else
+      smsShrdPrm.prmRdSeq--;
+
+    if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0)
+    {
+      dataField = SIM_CBMI;
+      dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxId * 2;
+      break;
+    }
+    else
+      smsShrdPrm.prmRdSeq--;
+
+    smsShrdPrm.cbmPrm.cbchOwner = ownBuf;
+    psaMMI_Cbch();
+    smsShrdPrm.cbmPrm.cbchOwner = OWN_NONE;
+
+#ifdef SIM_TOOLKIT
+    smsShrdPrm.prmRdSeq--; /* when SAT is on, then SMS_READ_CBMID is defined
+                            which is irrelevant for +CRES */
+#endif /* of SIM_TOOLKIT */
+    
+      break;
+
+  case SMS_READ_SIM_CBMIR:
+    if ((errCode = simShrdPrm.atb[aId].errCode) EQ SIM_NO_ERROR)
+    {                          /* successful EF(CBMIR) read */
+      if (!cmhSMS_GetCbmirSIM (ownBuf,
+                               simShrdPrm.atb[aId].exchData,
+                               simShrdPrm.atb[aId].dataLen))
+      {
+        errCode = SIM_CAUSE_OTHER_ERROR;
+      }
+    }
+    if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0)
+    {
+      dataField = SIM_CBMI;
+      dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxId * 2;
+    }
+    else
+    {
+      smsShrdPrm.prmRdSeq--;
+
+      smsShrdPrm.cbmPrm.cbchOwner = ownBuf;
+      psaMMI_Cbch();
+      smsShrdPrm.cbmPrm.cbchOwner = OWN_NONE;
+
+#ifdef SIM_TOOLKIT
+      smsShrdPrm.prmRdSeq--; /* when SAT is on, then SMS_READ_CBMID is defined
+                            which is irrelevant for +CRES */
+#endif /* of SIM_TOOLKIT */
+
+    }
+    break;
+
+  case SMS_READ_SIM_CBMI:
+    if ((errCode = simShrdPrm.atb[aId].errCode) EQ SIM_NO_ERROR)
+    {                          /* successful EF(CBMI) read */
+      if (!cmhSMS_GetCbmiSIM (ownBuf,
+                              simShrdPrm.atb[aId].exchData,
+                              simShrdPrm.atb[aId].dataLen))
+      {
+        errCode = SIM_CAUSE_OTHER_ERROR;
+      }
+    }
+    smsShrdPrm.cbmPrm.cbchOwner = ownBuf;
+    psaMMI_Cbch();
+    smsShrdPrm.cbmPrm.cbchOwner = OWN_NONE;
+
+#ifdef SIM_TOOLKIT
+    smsShrdPrm.prmRdSeq--; /* when SAT is on, then SMS_READ_CBMID is defined
+                            which is irrelevant for +CRES */
+#endif /* of SIM_TOOLKIT */
+
+    break;
+
+  default:
+    smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL;
+    errCode = SIM_CAUSE_OTHER_ERROR;
+    break;
+  }
+  if (--smsShrdPrm.prmRdSeq <= SMS_READ_SIM_CMPL)
+  {
+    smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+    smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+
+    if (errCode EQ SIM_NO_ERROR)
+    {
+      R_AT( RAT_OK, ownBuf ) ( cmdBuf );
+    }
+    else
+    {
+      R_AT( RAT_CMS, ownBuf )  /* unsuccessful SIM read */
+        (
+          cmdBuf,
+          cmhSMS_GetCmsFromSim ( errCode ),
+          NULL
+        );
+    }
+  }
+  else
+    if (cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmdBuf,
+                             dataField, 0, dataLen,
+                             NULL, cmhSMS_RdCnfCRES) EQ AT_FAIL)
+    {
+      smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+      smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+
+      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL;
+
+#ifdef SIM_TOOLKIT
+      if (ownBuf EQ OWN_SAT /*smsShrdPrm.fuRef >= 0*/)
+      {
+        psaSAT_FUConfirm ((int)simShrdPrm.fuRef, SIM_FU_ERROR);
+      }
+      else
+      {
+#endif
+        R_AT( RAT_CMS, ownBuf ) ( cmdBuf, CMS_ERR_UnknownErr, NULL );
+#ifdef SIM_TOOLKIT
+      }
+#endif
+    }
+
+  simShrdPrm.atb[aId].ntryUsdFlg = FALSE;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_InitSMSP              |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function is used to store the parameters of EF(SMSP).
+*/
+GLOBAL void cmhSMS_InitSMSP (SHORT aId)
+{
+  T_ACI_CMD_SRC srcId;
+  T_SMS_SET_PRM * elem      ; /* points to SMS parameter set    */
+  UBYTE          idx;
+  UBYTE          profile;
+
+  TRACE_FUNCTION ("cmhSMS_InitSMSP ()");
+
+  /*
+   *-----------------------------------------------------------------
+   * process SIM result
+   *-----------------------------------------------------------------
+   */
+  srcId = smsShrdPrm.owner;
+
+  switch (smsShrdPrm.prmRdSeq)
+  {
+  case SMS_READ_SIM_SMSP:
+    if (simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR)
+    {                            /* successful EF(SMSP) read */
+      smsShrdPrm.aci_sms_parameter.smsParamMaxRec = simShrdPrm.atb[aId].recMax;
+      smsShrdPrm.aci_sms_parameter.smsParamRecLen = simShrdPrm.atb[aId].dataLen;
+
+      if (set_prm_list EQ NULL)
+      {
+        set_prm_list = new_list();
+      }
+      profile = simShrdPrm.atb[aId].recNr;
+      elem = find_element(set_prm_list, profile, cmhSMS_findPrflId);
+
+      if (elem EQ NULL)
+      {
+        ACI_MALLOC(elem, sizeof(T_SMS_SET_PRM));
+        memset(elem, 0, sizeof(T_SMS_SET_PRM));
+        insert_list(set_prm_list, elem);
+        elem->prflId = profile;
+        elem->numOfRefs = OWN_MAX;
+        for( idx = 0; idx < OWN_MAX; idx++ )
+        {
+          smsShrdPrm.pSetPrm[idx] = (T_SMS_SET_PRM*) elem;
+        }
+
+      }
+      else
+      {
+        smsShrdPrm.pSetPrm[0] = (T_SMS_SET_PRM*) elem;
+      }
+
+      cmhSMS_GetPrmSIM (0,
+                        simShrdPrm.atb[aId].exchData,
+                        simShrdPrm.atb[aId].dataLen);
+    }
+    else
+    {
+      smsShrdPrm.aci_sms_parameter.smsParamMaxRec = 0;
+      smsShrdPrm.aci_sms_parameter.smsParamRecLen = 0;
+    }
+    if( !psaSIM_ChkSIMSrvSup( SRV_CBMIdRnge ))
+    {
+      smsShrdPrm.prmRdSeq--;
+      goto CBMIR;
+    }
+    if (cmhSIM_ReadTranspEF (CMD_SRC_NONE, smsShrdPrm.smsEntStat.curCmd,
+                             SIM_CBMIR, 0, 255,
+                             NULL, cmhSMS_InitSMSP) NEQ AT_FAIL)
+      smsShrdPrm.prmRdSeq--;
+    else
+    {
+      goto CBMIR;
+    }
+    break;
+
+  case SMS_READ_SIM_CBMIR:
+    if (simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR)
+    {
+      smsShrdPrm.cbmPrm.cbmSIMmaxIdRge = simShrdPrm.atb[aId].dataLen / 4;
+      cmhSMS_GetCbmirSIM (CMD_SRC_NONE,
+                          simShrdPrm.atb[aId].exchData,
+                          simShrdPrm.atb[aId].dataLen);
+    }
+    else
+      smsShrdPrm.cbmPrm.cbmSIMmaxIdRge = 0;
+
+  CBMIR:
+    if( !psaSIM_ChkSIMSrvSup( SRV_CBM_Ident ))
+    {
+      smsShrdPrm.prmRdSeq--;
+      goto CBMI;
+    }
+    if (cmhSIM_ReadTranspEF (CMD_SRC_NONE, smsShrdPrm.smsEntStat.curCmd,
+                             SIM_CBMI, 0, 255,
+                             NULL, cmhSMS_InitSMSP) NEQ AT_FAIL)
+      smsShrdPrm.prmRdSeq--;
+    else
+    {
+#ifdef SIM_TOOLKIT
+      goto CBMI;
+#else
+      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL;
+
+      smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+      smsShrdPrm.smsEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
+#endif /* of SIM_TOOLKIT */
+    }
+    break;
+
+  case SMS_READ_SIM_CBMI:
+    if (simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR)
+    {
+      smsShrdPrm.cbmPrm.cbmSIMmaxId = simShrdPrm.atb[aId].dataLen / 2;
+      cmhSMS_GetCbmiSIM (CMD_SRC_NONE,
+                         simShrdPrm.atb[aId].exchData,
+                         simShrdPrm.atb[aId].dataLen);
+    }
+    else
+      smsShrdPrm.cbmPrm.cbmSIMmaxId = 0;
+
+#ifdef SIM_TOOLKIT
+  CBMI:
+    if( (!psaSIM_ChkSIMSrvSup( SRV_DtaDownlCB )) OR 
+            smsShrdPrm.owner NEQ OWN_SAT)
+    {
+      smsShrdPrm.prmRdSeq--;
+      goto CBMID;
+    }
+    if (cmhSIM_ReadTranspEF (CMD_SRC_NONE, smsShrdPrm.smsEntStat.curCmd,
+                             SIM_CBMID, 0, 255,
+                             NULL, cmhSMS_InitSMSP) NEQ AT_FAIL)
+      smsShrdPrm.prmRdSeq--;
+    else
+    {
+      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL;
+
+      smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+      smsShrdPrm.smsEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
+    }
+    break;
+    
+  case SMS_READ_SIM_CBMID:
+    if (simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR)
+    {
+      smsShrdPrm.cbmPrm.cbmSIMmaxSATId = simShrdPrm.atb[aId].dataLen / 2;
+      cmhSMS_GetCbDtaDwnlSIM (CMD_SRC_NONE,
+                              simShrdPrm.atb[aId].exchData,
+                              simShrdPrm.atb[aId].dataLen);
+      {
+        PALLOC (sat_cbch_req, MMI_SAT_CBCH_DWNLD_REQ);
+
+        sat_cbch_req->count = (USHORT)smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds;
+        memset (sat_cbch_req->msg_id, NOT_PRESENT_16BIT,
+                sizeof (sat_cbch_req->msg_id));
+        memcpy (sat_cbch_req->msg_id, smsShrdPrm.cbmPrm.CBDtaDwnlIdent,
+                (size_t)smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds * 2);
+
+        PSENDX (PL, sat_cbch_req);
+      }
+    }
+    else
+      smsShrdPrm.cbmPrm.cbmSIMmaxSATId = 0;
+
+  default:
+  CBMID:
+
+#else
+  /*lint -fallthrough*/
+  default:
+  CBMI:
+#endif /*SIM_TOOLKIT */
+
+    smsShrdPrm.cbmPrm.cbchOwner = srcId;
+    psaMMI_Cbch();
+    smsShrdPrm.cbmPrm.cbchOwner = OWN_NONE;
+    {
+      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL;
+
+      smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+      smsShrdPrm.smsEntStat.entOwn = simShrdPrm.owner = OWN_NONE;
+    }
+#ifdef SIM_TOOLKIT
+    if (srcId EQ OWN_SAT /*smsShrdPrm.fuRef >= 0*/)
+    {
+      smsShrdPrm.accessEnabled = TRUE;
+      psaSAT_FUConfirm (simShrdPrm.fuRef,(USHORT)
+            ((simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR)?
+            SIM_FU_SUCC_ADD: SIM_FU_ERROR));
+    }
+    else
+#endif
+      cmhSMS_ready ();
+    break;
+  }
+
+  simShrdPrm.atb[aId].ntryUsdFlg = FALSE;
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSResumeCnf          |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function processes the MNSMS_RESUME_CNF primitive. 
+  
+*/
+GLOBAL void cmhSMS_SMSResumeCnf (T_MNSMS_RESUME_CNF * mnsms_resume_cnf)
+{
+  UBYTE cmdBuf;
+  UBYTE ownBuf;
+
+  TRACE_FUNCTION("cmhSMS_ResumeCnf()");
+  
+  cmdBuf = smsShrdPrm.smsEntStat.curCmd;
+  ownBuf = smsShrdPrm.smsEntStat.entOwn;
+
+  /* check whether resume has been successfully processed */ 
+  if (mnsms_resume_cnf->cause EQ SMS_NO_ERROR) 
+  {
+    R_AT( RAT_OK, ownBuf ) ( cmdBuf );
+  }
+  else 
+  {
+    /* command unsuccessful */
+    R_AT ( RAT_CMS, ownBuf )
+    (
+      cmdBuf,
+      cmhSMS_GetCmsFromSms(mnsms_resume_cnf->cause),
+      NULL
+    );
+  }
+  
+  /* reset command */
+  smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+  smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;    
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSQueryCnf           |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function processes the MNSMS_QUERY_CNF primitive. 
+  
+*/
+GLOBAL void cmhSMS_SMSQueryCnf (T_MNSMS_QUERY_CNF * mnsms_query_cnf)
+{
+  UBYTE cmdBuf;
+  UBYTE ownBuf;
+
+  TRACE_FUNCTION("cmhSMS_SMSQueryCnf()");
+  
+  cmdBuf = smsShrdPrm.smsEntStat.curCmd;
+  ownBuf = smsShrdPrm.smsEntStat.entOwn;
+
+  /* check type of query request and process it */
+  switch (mnsms_query_cnf->query_type)
+  {
+    case SMS_QUERY_DELIVER_STATUS:
+    {
+      if ( mnsms_query_cnf->v_deliver_status )
+      {
+        R_AT ( RAT_CPRSM, ownBuf )
+        ( cmhSMS_convertDeliverStatusToACI(mnsms_query_cnf->deliver_status ) );
+        R_AT( RAT_OK, ownBuf ) ( cmdBuf );
+      }
+      else /* paramter inalid - unspecified protocol error */ 
+      {
+        TRACE_EVENT("cmhSMS_QueryCnf: ERROR: paramter invalid");
+        R_AT ( RAT_CMS, ownBuf )( cmdBuf, CMS_ERR_InValManInfo, NULL );    
+      }
+      break;
+    }
+    default: /* unsupported query type - ME failure */
+    {
+      TRACE_EVENT("cmhSMS_QueryCnf: ERROR: unsupported query type");
+      R_AT ( RAT_CMS, ownBuf )( cmdBuf, CMS_ERR_MeFail, NULL );
+    }
+  } /* end switch */
+
+  /* reset command */
+  smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+  smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE;
+}
+
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_ReadCbDtaDwnl         |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function processes the T_SIM_MMI_INSERT_IND primitive. 
+  
+*/
+GLOBAL void cmhSMS_ReadCbDtaDwnl (T_SIM_MMI_INSERT_IND *sim_mmi_insert_ind)
+{
+
+  TRACE_FUNCTION("cmhSMS_ReadCbDtaDwnl()");
+
+  if (sim_mmi_insert_ind->cbmid_rec.c_rec NEQ 0)
+  {
+    smsShrdPrm.cbmPrm.cbmSIMmaxSATId = sim_mmi_insert_ind->cbmid_rec.c_rec / 2;
+    cmhSMS_GetCbDtaDwnlSIM (CMD_SRC_NONE,
+                            (UBYTE *) sim_mmi_insert_ind->cbmid_rec.rec,
+                            sim_mmi_insert_ind->cbmid_rec.c_rec);
+    {
+      PALLOC (sat_cbch_req, MMI_SAT_CBCH_DWNLD_REQ);
+
+      sat_cbch_req->count = (USHORT)smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds;
+      memset (sat_cbch_req->msg_id, NOT_PRESENT_16BIT,
+              sizeof (sat_cbch_req->msg_id));
+      memcpy (sat_cbch_req->msg_id, smsShrdPrm.cbmPrm.CBDtaDwnlIdent,
+              (size_t)smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds * 2);
+
+      PSENDX (PL, sat_cbch_req);
+    }
+  }
+  else
+  {
+    TRACE_EVENT(" CBMID records zero"); 
+    smsShrdPrm.cbmPrm.cbmSIMmaxSATId = 0;
+  }
+}
+
+/*
++-------------------------------------------------------------------+
+| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSR                     |
+| STATE   : code             ROUTINE : cmhSMS_SMSQueryType          |
++-------------------------------------------------------------------+
+
+  PURPOSE : This function queries the message type of the T_MNSMS_MESSAGE_IND. 
+  
+*/
+GLOBAL BOOL cmhSMS_SMSQueryType (T_sms_sdu *sms_sdu,
+                                UBYTE *msg_type)
+{
+  UBYTE ccdRet;
+
+  TRACE_FUNCTION("cmhSMS_SMSQueryType()");
+
+   if (sms_sdu->l_buf EQ 0)
+   {
+     TRACE_EVENT("empty SDU: no decoding");
+     return FALSE;
+   }
+
+  CCD_START;
+  {
+
+    MCAST( sim_pdu, SIM_PDU ); /* sim_pdu points to _decodedMsg */
+
+    /* decoding outer layer */
+    ccdRet = ccd_decodeMsg ( CCDENT_SMS,
+                             BOTH /* doesn't work with DOWNLINK!!! */,
+                             (T_MSGBUF *) sms_sdu,
+                             (UBYTE    *) _decodedMsg, /* target */
+                             SMS_VT_SIM_PDU);
+
+    if ((ccdRet NEQ ccdOK) OR (!sim_pdu->v_tpdu)
+         OR (_decodedMsg[0] NEQ SMS_VT_SIM_PDU))
+    {
+      TRACE_EVENT_P1("CCD Decoding Error: %d", ccdRet);
+      CCD_END;
+      return FALSE;
+    }
+    *msg_type = sim_pdu->tp_mti;
+  }
+  CCD_END;
+
+  return TRUE;
+  
+}
+
+LOCAL BOOL cmhSMS_cpySTtoSM(T_ACI_CMGL_SM *p_sm,T_MNSMS_READ_CNF * mnsms_read_cnf)
+{
+  T_ACI_CDS_SM   p_st;
+  T_MNSMS_STATUS_IND mnsms_status_ind;
+  BOOL          retCode = FALSE;
+
+  memcpy (&mnsms_status_ind.sms_sdu, &mnsms_read_cnf->sms_sdu, 
+   sizeof (T_sms_sdu));
+  retCode = cmhSMS_cpyStatInd ( &p_st, &mnsms_status_ind);
+  memcpy(p_sm->adress, p_st.addr, MAX_SMS_ADDR_DIG - 1 );
+  cmhSMS_getStatCmh ( mnsms_read_cnf->status, &p_sm->stat );
+  p_sm->msg_ref = mnsms_read_cnf->rec_num ;
+  p_sm->tp_status=p_st.tp_status ;
+  p_sm->toa .ton = p_st.toa .ton ;
+  p_sm->toa.npi = p_st.toa.npi;
+  p_sm->fo = p_st.fo;
+  p_sm->scts =p_st.vpabs_scts ; 
+
+  return (retCode);
+}
+/*==== EOF ========================================================*/