+
−/* 
+
−+----------------------------------------------------------------------------- 
+
−|  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);
+
−
+
−/* send CMS error code for SMS memory full */
+
−  if(mnsms_error_ind->cause == SMS_CAUSE_MEM_FULL)
+
−  {
+
−    char *sa;
+
−    ACI_MALLOC(sa,KEY + BYTE_LTH);
+
−    sprintf(sa,"+CMS ERROR: %d",CMS_ERR_MemFull);
+
−    io_sendMessage(3, sa, ATI_NORMAL_OUTPUT);
+
−    ACI_MFREE(sa);
+
−    rCI_PlusCMS ( 0, CMS_ERR_MemFull, NULL );
+
−  }
+
−
+
−  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 ========================================================*/