+
−/*
+
−+-----------------------------------------------------------------------------
+
−|  Project :  GSM-PS (6147)
+
−|  Modul   :  CMH_SMSF
+
−+-----------------------------------------------------------------------------
+
−|  Copyright 2002 Texas Instruments Berlin, AG
+
−|                 All rights reserved.
+
−|
+
−|                 This file is confidential and a trade secret of Texas
+
−|                 Instruments Berlin, AG
+
−|                 The receipt of or possession of this file does not convey
+
−|                 any rights to reproduce or disclose its contents or to
+
−|                 manufacture, use, or sell anything it may describe, in
+
−|                 whole, or in part, without the specific written consent of
+
−|                 Texas Instruments Berlin, AG.
+
−+-----------------------------------------------------------------------------
+
−|  Purpose :  This module defines the functions used by the command
+
−|             handler for the short message service.
+
−+-----------------------------------------------------------------------------
+
−*/
+
−
+
−#ifndef CMH_SMSF_C 
+
−#define CMH_SMSF_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 */
+
−
+
−#include "aci.h"
+
−#include "aci_lst.h"
+
−#include "aci_mem.h"
+
−#include "psa.h"
+
−#include "psa_cc.h"
+
−#ifdef SIM_TOOLKIT
+
−#include "psa_sat.h"
+
−#endif
+
−#include "psa_sms.h"
+
−#include "psa_sim.h"
+
−#include "psa_mmi.h"
+
−#include "psa_util.h"
+
−#include "phb.h"
+
−#include "cmh.h"
+
−#include "cmh_sms.h"
+
−#include "pcm.h"
+
−
+
−#include "aci_lst.h"
+
−
+
−#if (defined (MFW) AND !defined (FF_MMI_RIV)) OR defined (_CONC_TESTING_)
+
−#include "conc_sms.h"
+
−#endif /* ##if (defined (MFW) AND !defined (FF_MMI_RIV)) OR defined (_CONC_TESTING_)*/
+
−
+
−
+
−#ifdef UART
+
−#include "dti_conn_mng.h"
+
−#endif
+
−
+
−#include "cmh_sim.h"
+
−#ifndef _SIMULATION_
+
−
+
−/* temporary solution to get ffs.h included without GPRS to be set ! */
+
−#ifdef GPRS
+
−#include "ffs/ffs.h"
+
−#else
+
−#include "ffs/ffs.h"
+
−#undef GPRS
+
−#endif /* GPRS */
+
−
+
−#include "ffs_coat.h"
+
−
+
−#endif /* !_SIMULATION_ */
+
−
+
−#ifdef FF_CPHS
+
−#include "cphs.h"
+
−#endif /* FF_CPHS */
+
−
+
−/*==== CONSTANTS ==================================================*/
+
−#define CMMS_MODE_TIMER_VAL (5000)
+
−#define SMS_CMH_YEAR_MAX   (99) /* maximum value for year in   */
+
−                                /* absolute validity period    */
+
−#define SMS_CMH_YEAR_MIN   (0)  /* minimum value for year in   */
+
−                                /* absolute  validity period   */
+
−#define SMS_CMH_MONTH_MAX  (12) /* maximum value for month in  */
+
−                                /* absolute validity period    */
+
−#define SMS_CMH_MONTH_MIN  (1)  /* minimum value for month in  */
+
−                                /* absolute  validity period   */
+
−#define SMS_CMH_DAY_MAX    (31) /* maximum value for day in    */
+
−                                /* absolute validity period    */
+
−#define SMS_CMH_DAY_MIN    (1)  /* minimum value for day in    */
+
−                                /* absolute  validity period   */
+
−#define SMS_CMH_HOUR_MAX   (23) /* maximum value for hour in   */
+
−                                /* absolute validity period    */
+
−#define SMS_CMH_HOUR_MIN   (0)  /* minimum value for hour in   */
+
−                                /* absolute  validity period   */
+
−#define SMS_CMH_MINUTE_MAX (59) /* maximum value for minute in */
+
−                                /* absolute validity period    */
+
−#define SMS_CMH_MINUTE_MIN (0)  /* minimum value for minute in */
+
−                                /* absolute  validity period   */
+
−#define SMS_CMH_SECOND_MAX (59) /* maximum value for second in */
+
−                                /* absolute validity period    */
+
−#define SMS_CMH_SECOND_MIN (0)  /* minimum value for second in */
+
−                                /* absolute  validity period   */
+
−
+
−#define SMS_CMH_TZ_MAX    (47)  /* maximum value for a time  */
+
−                                /* zone in absolute validity */
+
−                                /* period                    */
+
−#define SMS_CMH_TZ_MIN    (-47) /* minimum value for a time  */
+
−                                /* zone in absolute validity */
+
−                                /* period                    */
+
−
+
−
+
−/* macro for converting a two digit BCD into an UBYTE */
+
−#define BCD2UBYTE(bcd) (UBYTE)(10 * bcd[0] + bcd[1])
+
−
+
−/* macro for testing whether any digit of a two digit */
+
−/* BCD lies outside of a predefined value range       */
+
−#define NOTBCD(bcd) (bcd[0] > 9 OR\
+
−                     bcd[1] > 9 )
+
−
+
−
+
−#define L_MAX_UD      140
+
−#define L_MAX_UD_CONC 134
+
−
+
−#ifdef FF_CPHS_REL4
+
−typedef enum 
+
−{
+
−  MSG_WAITING_TYPE_INVALID = -1,
+
−  MSG_WAITING_TYPE_VOICE,
+
−  MSG_WAITING_TYPE_FAX,
+
−  MSG_WAITING_TYPE_EMAIL,
+
−  MSG_WAITING_TYPE_OTHER
+
−} T_MSG_WAITING_TYPE;
+
−#endif
+
−
+
−/*==== TYPES ======================================================*/
+
−
+
−/*==== EXPORT =====================================================*/
+
−EXTERN T_ACI_LIST *set_prm_list;
+
−
+
−/*==== PROTOTYPES==================================================*/
+
−/* Implements Measure # 73 */
+
−LOCAL BOOL cmhSMS_findMessageIds (USHORT lower_mid, USHORT upper_mid);
+
−/* Implements Measure # 126 */
+
−LOCAL void cmhSMS_processOrigDestAddr (T_ACI_CMGL_SM  *sm, 
+
−                                       T_rp_addr      *rp_addr,
+
−                                       T_tp_da        *tp_addr );
+
−/* Implements Measure # 9 */
+
−LOCAL void cmhSMS_clearCbmPrm (void);
+
−
+
−
+
−/*==== VARIABLES ==================================================*/
+
−
+
−const char * const ffs_smsprfl_fname[] = { FFS_SMSPRFL_FNAME01,
+
−                                    FFS_SMSPRFL_FNAME02,
+
−                                    FFS_SMSPRFL_FNAME03,
+
−                                    FFS_SMSPRFL_FNAME04 };
+
−
+
−/*==== FUNCTIONS ==================================================*/
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+
−| STATE   : code                        ROUTINE : aci_encodeVpenh    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function encodes a given T_ACI_VP_ENH type to a
+
−            string.
+
−*/
+
−GLOBAL void aci_encodeVpenh ( CHAR*         vpenh_str,
+
−                              T_ACI_VP_ENH* vpenh )
+
−{
+
−  UBYTE pos;
+
−
+
−  /* functionality indicator */
+
−  utl_binToHex (&vpenh->func_ind, 1, vpenh_str);
+
−  pos = 2;
+
−
+
−  /* extension octet */
+
−  if (vpenh->func_ind & TP_VPF_ENH_EXT_BIT_MASK)
+
−  {
+
−    utl_binToHex (&vpenh->ext_oct, 1, vpenh_str+pos);
+
−    pos += 2;
+
−  }
+
−
+
−  /* process validity period values */
+
−  if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_REL)
+
−  {
+
−    utl_binToHex (&vpenh->val.vpenh_relative, 1, vpenh_str+pos );
+
−    pos += 2;
+
−  }
+
−  else if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_SEC)
+
−  {
+
−    utl_binToHex (&vpenh->val.vpenh_seconds, 1, vpenh_str+pos );
+
−    pos += 2;
+
−  }
+
−  else if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_HRS)
+
−  {
+
−    vpenh_str[pos++] = vpenh->val.vpenh_hours.hour[1] + '0';
+
−    vpenh_str[pos++] = vpenh->val.vpenh_hours.hour[0] + '0';
+
−
+
−    vpenh_str[pos++] = vpenh->val.vpenh_hours.minute[1] + '0';
+
−    vpenh_str[pos++] = vpenh->val.vpenh_hours.minute[0] + '0';
+
−
+
−    vpenh_str[pos++] = vpenh->val.vpenh_hours.second[1] + '0';
+
−    vpenh_str[pos++] = vpenh->val.vpenh_hours.second[0] + '0';
+
−  }
+
−
+
−  /* fill the rest with zeros */
+
−  while (pos < 14)
+
−  {
+
−    vpenh_str[pos++] = '0';
+
−  }
+
−
+
−  /* string terminator */
+
−  vpenh_str[pos] = '\0';
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_getNType         |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function calculates the 'numbering type' out of the
+
−            current 'type of numbering'.
+
−*/
+
−GLOBAL UBYTE cmhSMS_getNType ( T_ACI_TOA_TON ton )
+
−{
+
−  switch( ton )
+
−  {
+
−    case( TON_International ):
+
−    case( TON_National      ):
+
−    case( TON_NetSpecific   ):
+
−    case( TON_DedAccess     ):
+
−    case( TON_Alphanumeric  ):
+
−    case( TON_Abbreviated   ): return (UBYTE)ton;
+
−    default:                   return SMS_TON_UNKNOWN;
+
−  }
+
−}
+
−
+
−
+
−GLOBAL BOOL cmhSMS_findPrflId ( UBYTE critrerium, void* elem )
+
−{
+
−  T_SMS_SET_PRM *compared = (T_SMS_SET_PRM*)elem;
+
−  if ( compared->prflId == critrerium )
+
−    return TRUE;
+
−  else
+
−    return FALSE;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_getTon           |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function calculates the 'type of numbering' out of
+
−            the current 'numbering type'.
+
−*/
+
−GLOBAL T_ACI_TOA_TON cmhSMS_getTon ( UBYTE ntype )
+
−{
+
−  switch( ntype )
+
−  {
+
−    case( SMS_TON_UNKNOWN       ):
+
−    case( SMS_TON_INTERNATIONAL ):
+
−    case( SMS_TON_NATIONAL      ):
+
−    case( SMS_TON_NETWORK_SPEC  ):
+
−    case( SMS_TON_SUBSCRIBER    ):
+
−    case( SMS_TON_ALPHANUMERIC  ):
+
−    case( SMS_TON_ABBREVIATED   ): return (T_ACI_TOA_TON)ntype;
+
−    default:                       return TON_NotPresent;
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_getNPlan         |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function calculates the 'numbering plan' out of the
+
−            current 'numbering plan identification'.
+
−*/
+
−GLOBAL UBYTE cmhSMS_getNPlan ( T_ACI_TOA_NPI npi )
+
−{
+
−  switch( npi )
+
−  {
+
−    case( NPI_IsdnTelephony ):
+
−    case( NPI_Data          ):
+
−    case( NPI_Telex         ):
+
−    case( NPI_National      ):
+
−    case( NPI_Private       ): return (UBYTE)npi;
+
−    default:                   return NPI_Unknown;
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_getNpi           |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function calculates the 'numbering plan
+
−            identification' out of the current 'numbering plan'.
+
−*/
+
−GLOBAL T_ACI_TOA_NPI cmhSMS_getNpi ( UBYTE nplan )
+
−{
+
−  switch( nplan )
+
−  {
+
−    case( SMS_TON_UNKNOWN  ):
+
−    case( SMS_NPI_ISDN     ):
+
−    case( SMS_NPI_X121     ):
+
−    case( SMS_NPI_F69      ):
+
−    case( SMS_NPI_NATIONAL ):
+
−    case( SMS_NPI_PRIVATE  ): return (T_ACI_TOA_NPI)nplan;
+
−    default:                  return NPI_NotPresent;
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_getStatCmh       |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function converts the message status from
+
−            PSA type to CMH type.
+
−*/
+
−GLOBAL void cmhSMS_getStatCmh ( UBYTE           inStat,
+
−                                T_ACI_SMS_STAT* outStat )
+
−{
+
−  switch( inStat & STAT_MASK )
+
−  {
+
−    case( REC_UNREAD ): *outStat = SMS_STAT_RecUnread; break;
+
−    case( REC_READ   ): *outStat = SMS_STAT_RecRead;   break;
+
−    case( STO_UNSENT ): *outStat = SMS_STAT_StoUnsent; break;
+
−    case( STO_SENT   ): *outStat = SMS_STAT_StoSent;   break;
+
−    default:            *outStat = SMS_STAT_NotPresent;
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_getStatPsa       |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function converts the message status from
+
−            CMH type to PSA type.
+
−*/
+
−GLOBAL BOOL cmhSMS_getStatPsa ( T_ACI_SMS_STAT inStat,
+
−                                UBYTE*         outStat )
+
−{
+
−  switch( inStat )
+
−  {
+
−    case( SMS_STAT_RecUnread ): *outStat = REC_UNREAD; break;
+
−    case( SMS_STAT_RecRead   ): *outStat = REC_READ;   break;
+
−    case( SMS_STAT_StoUnsent ): *outStat = STO_UNSENT; break;
+
−    case( SMS_STAT_StoSent   ): *outStat = STO_SENT;   break;
+
−    default                   : return (FALSE);
+
−  }
+
−
+
−  return ( TRUE );
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_isVpabsVld       |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to process whether the given
+
−            absolute validity period is valid.
+
−
+
−            Note: This function checks whether every individual
+
−                  time value is within a valid range. It does not
+
−                  check whether the whole expression is valid.
+
−*/
+
−GLOBAL BOOL cmhSMS_isVpabsVld ( T_ACI_VP_ABS* vpabs )
+
−{
+
−  if ( BCD2UBYTE ( vpabs -> year   ) > SMS_CMH_YEAR_MAX   OR
+
−       BCD2UBYTE ( vpabs -> month  ) < SMS_CMH_MONTH_MIN  OR
+
−       BCD2UBYTE ( vpabs -> month  ) > SMS_CMH_MONTH_MAX  OR
+
−       BCD2UBYTE ( vpabs -> day    ) < SMS_CMH_DAY_MIN    OR
+
−       BCD2UBYTE ( vpabs -> day    ) > SMS_CMH_DAY_MAX    OR
+
−       BCD2UBYTE ( vpabs -> hour   ) > SMS_CMH_HOUR_MAX   OR
+
−       BCD2UBYTE ( vpabs -> minute ) > SMS_CMH_MINUTE_MAX OR
+
−       BCD2UBYTE ( vpabs -> second ) > SMS_CMH_SECOND_MAX OR
+
−       vpabs -> timezone             < SMS_CMH_TZ_MIN     OR
+
−       vpabs -> timezone             > SMS_CMH_TZ_MAX     OR
+
−       NOTBCD ( vpabs -> year   )                         OR
+
−       NOTBCD ( vpabs -> month  )                         OR
+
−       NOTBCD ( vpabs -> day    )                         OR
+
−       NOTBCD ( vpabs -> hour   )                         OR
+
−       NOTBCD ( vpabs -> minute )                         OR
+
−       NOTBCD ( vpabs -> second )                            )
+
−
+
−        return ( FALSE );
+
−
+
−  return ( TRUE );
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_isVpenhVld       |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to process whether the given
+
−            enhanced validity period is valid.
+
−
+
−            Note: This function checks whether every individual
+
−                  time value is within a valid range. It does not
+
−                  check whether the whole expression is valid.
+
−*/
+
−GLOBAL BOOL cmhSMS_isVpenhVld ( T_ACI_VP_ENH* vpenh )
+
−{
+
−  if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) > TP_VPF_ENH_HRS)
+
−  {
+
−    return FALSE;
+
−  }
+
−
+
−  if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_HRS)
+
−  {
+
−    if ( BCD2UBYTE ( vpenh->val.vpenh_hours.minute ) > SMS_CMH_MINUTE_MAX OR
+
−         BCD2UBYTE ( vpenh->val.vpenh_hours.second ) > SMS_CMH_SECOND_MAX OR
+
−         NOTBCD ( vpenh->val.vpenh_hours.hour   )                         OR
+
−         NOTBCD ( vpenh->val.vpenh_hours.minute )                         OR
+
−         NOTBCD ( vpenh->val.vpenh_hours.second )                            )
+
−    {
+
−      return ( FALSE );
+
−    }
+
−  }
+
−
+
−  return ( TRUE );
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_setVpabsPsa      |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to copy the elements of the
+
−            absolute validity period structure of the ACI to the
+
−            corresponding structure of the PSA.
+
−
+
−            Note: Copying of the structure elements might be
+
−                  dangerous when array size of time elements differ
+
−                  from MAX_VP_ABS_DIGIT due to changes in PSA
+
−                  declaration.
+
−*/
+
−GLOBAL void cmhSMS_setVpabsPsa ( T_tp_vp_abs*     psaVp,
+
−                                 T_ACI_VP_ABS* cmhVp )
+
−{
+
−  USHORT i; /* used for counting */
+
−
+
−  BOOL  isNegative = ( cmhVp->timezone & 0x8000 );
+
−  SHORT tz   = ( UBYTE ) cmhVp->timezone;
+
−
+
−  for (i = 0; i < MAX_VP_ABS_DIGITS; i++)
+
−  {
+
−    psaVp -> year  [i] = cmhVp -> year  [i];
+
−    psaVp -> month [i] = cmhVp -> month [i];
+
−    psaVp -> day   [i] = cmhVp -> day   [i];
+
−    psaVp -> hour  [i] = cmhVp -> hour  [i];
+
−    psaVp -> minute[i] = cmhVp -> minute[i];
+
−    psaVp -> second[i] = cmhVp -> second[i];
+
−  }
+
−
+
−  if ( isNegative )
+
−  {
+
−    tz = -tz;
+
−    psaVp -> tz_sign = 1;
+
−  }
+
−  else
+
−  {
+
−    psaVp -> tz_sign = 0;
+
−  }
+
−
+
−  psaVp -> tz_lsb = tz & 0x000F;
+
−  psaVp -> tz_msb = tz & 0x00F0;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_setVpenhPsa      |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to copy the elements of the
+
−            enhanced validity period structure of the ACI to the
+
−            corresponding structure of the PSA.
+
−*/
+
−GLOBAL void cmhSMS_setVpenhPsa ( T_tp_vp_enh*  psaVp,
+
−                                 T_ACI_VP_ENH* cmhVp )
+
−{
+
−  memset(psaVp, 0, sizeof(T_tp_vp_enh));
+
−
+
−  if (cmhVp->func_ind & TP_VPF_ENH_EXT_BIT_MASK)
+
−  {
+
−    psaVp->tp_ext = SMS_EXT_INCLUDED;
+
−    psaVp->v_tp_rsrvd = 1;
+
−    psaVp->tp_rsrvd = cmhVp->ext_oct;
+
−  }
+
−
+
−  if (cmhVp->func_ind & TP_VPF_ENH_SINGLE_SHOT_MASK)
+
−  {
+
−    psaVp->tp_ss = SMS_SS_SET;
+
−  }
+
−
+
−  if ((cmhVp->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_NOT_PRESENT)
+
−  {
+
−    psaVp->tvpf = SMS_TVPF_NOT_PRESENT;
+
−  }
+
−  else if ((cmhVp->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_REL)
+
−  {
+
−    psaVp->tvpf = SMS_TVPF_RELATIVE;
+
−    psaVp->v_tp_vp_rel = 1;
+
−    psaVp->tp_vp_rel = cmhVp->val.vpenh_relative;
+
−  }
+
−  else if ((cmhVp->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_SEC)
+
−  {
+
−    psaVp->tvpf = SMS_TVPF_SECONDS;
+
−    psaVp->v_tp_vp_sec = 1;
+
−    psaVp->tp_vp_sec = cmhVp->val.vpenh_seconds;
+
−  }
+
−  else if ((cmhVp->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_HRS)
+
−  {
+
−    psaVp->tvpf = SMS_TVPF_HOURS;
+
−    psaVp->v_hour = 1;
+
−    psaVp->hour[0] = cmhVp->val.vpenh_hours.hour[0];
+
−    psaVp->hour[1] = cmhVp->val.vpenh_hours.hour[1];
+
−    psaVp->v_minute = 1;
+
−    psaVp->minute[0] = cmhVp->val.vpenh_hours.minute[0];
+
−    psaVp->minute[1] = cmhVp->val.vpenh_hours.minute[1];
+
−    psaVp->v_second = 1;
+
−    psaVp->second[0] = cmhVp->val.vpenh_hours.second[0];
+
−    psaVp->second[1] = cmhVp->val.vpenh_hours.second[1];
+
−  }
+
−  else
+
−  {
+
−    TRACE_EVENT("[ERR] cmhSMS_setVpenhPsa: wrong type of validity period format");
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_setVpabsCmh      |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to copy the elements of the
+
−            absolute validity period structure of the PSA to the
+
−            corresponding structure of the ACI.
+
−
+
−            Note: Copying of the structure elements might be
+
−                  dangerous when array size of time elements differ
+
−                  from MAX_VP_ABS_DIGIT due to changes in PSA
+
−                  declaration.
+
−*/
+
−GLOBAL void cmhSMS_setVpabsCmh ( T_ACI_VP_ABS* cmhVp,
+
−                                 T_tp_vp_abs*  psaVp )
+
−{
+
−  USHORT i; /* used for counting */
+
−  SHORT tz;
+
−
+
−  for (i = 0; i < MAX_VP_ABS_DIGITS; i++)
+
−  {
+
−    cmhVp -> year  [i] = psaVp -> year  [i];
+
−    cmhVp -> month [i] = psaVp -> month [i];
+
−    cmhVp -> day   [i] = psaVp -> day   [i];
+
−    cmhVp -> hour  [i] = psaVp -> hour  [i];
+
−    cmhVp -> minute[i] = psaVp -> minute[i];
+
−    cmhVp -> second[i] = psaVp -> second[i];
+
−  }
+
−
+
−  tz = ((psaVp->tz_msb & 0x07) * 10) +  psaVp->tz_lsb;  /* BCD */
+
−
+
−  if (psaVp->tz_sign)
+
−    cmhVp -> timezone = -tz;
+
−  else
+
−    cmhVp -> timezone = tz;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_setVpenhCmh      |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to copy the elements of the
+
−            enhanced validity period structure of the PSA to the
+
−            corresponding structure of the ACI.
+
−
+
−*/
+
−GLOBAL void cmhSMS_setVpenhCmh ( T_ACI_VP_ENH* cmhVp,
+
−                                 T_tp_vp_enh*  psaVp )
+
−{
+
−  memset(cmhVp, 0, sizeof(T_ACI_VP_ENH));
+
−
+
−  cmhVp->func_ind = psaVp->tvpf;
+
−
+
−  if ((psaVp->tp_ext EQ SMS_EXT_INCLUDED) AND (psaVp->v_tp_rsrvd))
+
−  {
+
−    cmhVp->func_ind |= TP_VPF_ENH_EXT_BIT_MASK;
+
−    cmhVp->ext_oct = psaVp->tp_rsrvd;
+
−  }
+
−
+
−  if (psaVp->tp_ss EQ SMS_SS_SET)
+
−  {
+
−    cmhVp->func_ind |= TP_VPF_ENH_SINGLE_SHOT_MASK;
+
−  }
+
−
+
−  if (psaVp->tvpf EQ SMS_TVPF_NOT_PRESENT)
+
−  {
+
−    /* do nothing */
+
−  }
+
−  else if ((psaVp->tvpf EQ SMS_TVPF_RELATIVE) AND (psaVp->v_tp_vp_rel))
+
−  {
+
−    cmhVp->val.vpenh_relative = psaVp->tp_vp_rel;
+
−  }
+
−  else if ((psaVp->tvpf EQ SMS_TVPF_SECONDS) AND (psaVp->v_tp_vp_sec))
+
−  {
+
−    cmhVp->val.vpenh_seconds = psaVp->tp_vp_sec;
+
−  }
+
−  else if (psaVp->tvpf EQ SMS_TVPF_HOURS)
+
−  {
+
−    if (psaVp->v_hour)
+
−    {
+
−      cmhVp->val.vpenh_hours.hour[0] = psaVp->hour[0];
+
−      cmhVp->val.vpenh_hours.hour[1] = psaVp->hour[1];
+
−    }
+
−    if (psaVp->v_minute)
+
−    {
+
−      cmhVp->val.vpenh_hours.minute[0] = psaVp->minute[0];
+
−      cmhVp->val.vpenh_hours.minute[1] = psaVp->minute[1];
+
−    }
+
−    if (psaVp->v_second)
+
−    {
+
−      cmhVp->val.vpenh_hours.second[0] = psaVp->second[0];
+
−      cmhVp->val.vpenh_hours.second[1] = psaVp->second[1];
+
−    }
+
−  }
+
−  else
+
−  {
+
−    TRACE_EVENT("[ERR] cmhSMS_setVpenhCmh: wrong type of validity period format");
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                 |
+
−| STATE   : code                  ROUTINE : cmhSMS_getAdrStr         |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to convert the service center
+
−            address in BCD to the service center address as a string.
+
−*/
+
−GLOBAL UBYTE cmhSMS_getAdrStr ( CHAR*  pStr,
+
−                                UBYTE  maxIdx,
+
−                                UBYTE* pBcd,
+
−                                UBYTE  numDigits )
+
−{
+
−  UBYTE bcdIdx;
+
−  UBYTE strIdx = 0;
+
−
+
−  memset(pStr, 0x00, maxIdx);
+
−
+
−  for(bcdIdx = 0; bcdIdx < numDigits AND strIdx < maxIdx; bcdIdx++)
+
−  {
+
−    switch (pBcd[bcdIdx])
+
−    {
+
−      case 0:
+
−      case 1:
+
−      case 2:
+
−      case 3:
+
−      case 4:
+
−      case 5:
+
−      case 6:
+
−      case 7:
+
−      case 8:
+
−      case 9:
+
−        pStr[strIdx++] = pBcd[bcdIdx] + '0';
+
−        break;
+
−
+
−      case BCD_ASTSK:
+
−        pStr[strIdx++] = '*';
+
−        break;
+
−
+
−      case BCD_PND:
+
−        pStr[strIdx++] = '#';
+
−        break;
+
−
+
−      case BCD_A:
+
−        pStr[strIdx++] = 'A';
+
−        break;
+
−
+
−      case BCD_B:
+
−        pStr[strIdx++] = 'B';
+
−        break;
+
−
+
−      case BCD_C:
+
−        pStr[strIdx++] = 'C';
+
−        break;
+
−    }
+
−  }
+
−
+
−  pStr[strIdx] = '\0';
+
−
+
−  return ( strIdx );
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                 |
+
−| STATE   : code                  ROUTINE : cmhSMS_getAdrBcd         |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to convert the service center
+
−            address as a string to the service center address in BCD.
+
−*/
+
−GLOBAL void cmhSMS_getAdrBcd ( UBYTE* pBcd,
+
−                               UBYTE* pNumDigits,
+
−                               UBYTE  maxDigits,
+
−                               CHAR*  pStr )
+
−{
+
−  UBYTE bcdIdx = 0;
+
−  UBYTE strIdx;
+
−
+
−  for(strIdx = 0; bcdIdx < maxDigits AND pStr[strIdx] NEQ '\0'; strIdx++)
+
−  {
+
−    switch (pStr[strIdx])
+
−    {
+
−      case '0':
+
−      case '1':
+
−      case '2':
+
−      case '3':
+
−      case '4':
+
−      case '5':
+
−      case '6':
+
−      case '7':
+
−      case '8':
+
−      case '9':
+
−        pBcd[bcdIdx++] = pStr[strIdx] - '0';
+
−        break;
+
−
+
−      case '*':
+
−        pBcd[bcdIdx++] = BCD_ASTSK;
+
−        break;
+
−
+
−      case '#':
+
−        pBcd[bcdIdx++] = BCD_PND;
+
−        break;
+
−
+
−      case 'A':
+
−        pBcd[bcdIdx++] = BCD_A;
+
−        break;
+
−
+
−      case 'B':
+
−        pBcd[bcdIdx++] = BCD_B;
+
−        break;
+
−
+
−      case 'C':
+
−        pBcd[bcdIdx++] = BCD_C;
+
−        break;
+
−    }
+
−  }
+
−
+
−  *pNumDigits = bcdIdx;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                 |
+
−| STATE   : code                  ROUTINE : cmhSMS_getAdrAlphaNum    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to pack the Alphanumeric 
+
−  Destination Adress according to 23.038
+
−*/
+
−GLOBAL T_ACI_RETURN cmhSMS_packAlphaNumAddr( CHAR*          da, 
+
−                                            T_tp_da*       da_addr)
+
−{
+
−  UBYTE dest[((MAX_SMS_ADDR_DIG/2) * 8) / 7];
+
−  UBYTE dest_len;
+
−  USHORT dalen;
+
−  
+
−  if( (da NEQ NULL) AND (da_addr NEQ NULL) )
+
−  {
+
−    dalen = strlen(da);
+
−    
+
−    dest_len = utl_cvt8To7( (UBYTE*)da, (UBYTE)dalen, dest, 0);
+
−    
+
−    if( dest_len > (MAX_SMS_ADDR_DIG/2) )
+
−    {
+
−      TRACE_EVENT("DA length is greater then the supported length");
+
−      ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_UnknownErr );
+
−      return(AT_FAIL);
+
−    }
+
−    if( ((dalen + 3) %7) <= 3 )
+
−    {
+
−      da_addr->c_num = (dest_len*2) - 1;  /* odd number of usefull nibbles */
+
−    }
+
−    else
+
−    {
+
−      da_addr->c_num = dest_len*2; /* even number of usefull nibbles */
+
−    }
+
−    
+
−    cmh_unpackBCD(da_addr->num, dest, dest_len );
+
−    da_addr->digits = da_addr->c_num;
+
−  }
+
−  
+
−  return(AT_CMPL);
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_getMemCmh        |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function converts the preferred memory from
+
−            PSA type to CMH type.
+
−*/
+
−GLOBAL void cmhSMS_getMemCmh ( UBYTE inMem, T_ACI_SMS_STOR* outMem )
+
−{
+
−  switch( inMem )
+
−  {
+
−    case( MEM_ME ): *outMem = SMS_STOR_Me; break;
+
−    case( MEM_SM ): *outMem = SMS_STOR_Sm; break;
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_getMemPsa        |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function converts the preferred memory from
+
−            CMH type to PSA type.
+
−
+
−            returns: TRUE if conversion was successfull,
+
−                     otherwise FALSE
+
−*/
+
−GLOBAL BOOL cmhSMS_getMemPsa ( T_ACI_SMS_STOR inMem, UBYTE* outMem )
+
−{
+
−  switch( inMem )
+
−  {
+
−    case( SMS_STOR_Me ): *outMem = MEM_ME; break;
+
−    case( SMS_STOR_Sm ): *outMem = MEM_SM; break;
+
−    default            : return ( FALSE );
+
−  }
+
−
+
−  return ( TRUE );
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_getAlphabetPp       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is used to extract the used alphabet out
+
−            of the data coding scheme for point-to-point SMS.
+
−*/
+
−GLOBAL UBYTE cmhSMS_getAlphabetPp ( UBYTE dcs )
+
−{
+
−  UBYTE alphabet = 0;  /* means 7 bit default alphabet */
+
−
+
−  switch (dcs & 0xF0)
+
−  {
+
−    case( 0x30 ):
+
−    case( 0x20 ):
+
−      alphabet = 0x01; /* compressed, counts as 8 bit data */
+
−      break;
+
−    case( 0x10 ):
+
−    case( 0x00 ):
+
−      alphabet = (dcs & 0x0C) >> 2;
+
−      if (alphabet EQ 3)
+
−        alphabet = 0;  /* reserved coding */
+
−      break;
+
−    case( 0xE0 ):
+
−      alphabet = 0x02; /* UCS2 */
+
−      break;
+
−    case( 0xF0 ):
+
−      alphabet = (dcs & 0x04) >> 2;
+
−      break;
+
−  }
+
−
+
−  return alphabet;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_expdSmsPp        |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function expands a point-to-point SMS from
+
−            7 to 8 bit.
+
−*/
+
−GLOBAL void cmhSMS_expdSmsPp ( UBYTE  byte_offset,
+
−                               UBYTE  dcs,
+
−                               UBYTE* source,
+
−                               UBYTE  source_len,
+
−                               UBYTE* dest,
+
−                               UBYTE* dest_len )
+
−{
+
−  UBYTE  alphabet;
+
−  UBYTE  bit_offset = 0;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_expdSmsPp ()");
+
−
+
−
+
−  alphabet = cmhSMS_getAlphabetPp ( dcs );
+
−
+
−  switch (alphabet)
+
−  {
+
−    case( 0 ): /* 7 bit alphabet */
+
−
+
−      if ( byte_offset % 7 NEQ 0 )
+
−      {
+
−         bit_offset = 7 - ((byte_offset*8) % 7);
+
−      }
+
−
+
−      *dest_len = source_len - ((byte_offset*8+6)/7); /* adjust byte_offset to septets */
+
−
+
−      /* In 7-Bit mode we get number of septets but we need octets */
+
−      source_len = (source_len*7+7)/8; /* round up to next octet*/
+
−      source_len -= byte_offset;
+
−
+
−      utl_cvt7To8 ( source, source_len, dest, bit_offset);
+
−      
+
−
+
−      break;
+
−
+
−    default:   /* 8 bit alphabet, UCS2, reserved */
+
−
+
−      *dest_len = source_len-byte_offset;
+
−      memcpy ( (CHAR*) dest, (CHAR*)source, *dest_len );
+
−      break;
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−| STATE   : code                  ROUTINE : cmhSMS_rdcSmsPp         |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function reduces a point-to-point SMS from
+
−            8 to 7 bit.
+
−*/
+
−GLOBAL void cmhSMS_rdcSmsPp ( UBYTE  byte_offset,
+
−                              UBYTE  dcs,
+
−                              UBYTE* source,
+
−                              UBYTE  source_len,
+
−                              UBYTE* dest,
+
−                              UBYTE* dest_len )
+
−{
+
−  UBYTE  data_len;
+
−  UBYTE  alphabet;
+
−  UBYTE  bit_offset = 0;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_rdcSmsPp ()");
+
−
+
−  if (source_len EQ 0)
+
−  {
+
−    *dest_len = source_len;
+
−    return;
+
−  }
+
−
+
−  alphabet = cmhSMS_getAlphabetPp ( dcs );
+
−
+
−  switch (alphabet)
+
−  {
+
−    case( 0 ): /* 7 bit alphabet */
+
−
+
−      if ( byte_offset % 7 NEQ 0 )
+
−      {
+
−         bit_offset = 7 - ((byte_offset*8) % 7);
+
−      }
+
−
+
−      data_len = MINIMUM (source_len, (SMS_MSG_LEN * 8) / 7);
+
−
+
−      data_len = utl_cvt8To7 ( source, data_len, dest, bit_offset );
+
−      break;
+
−
+
−    default:   /* 8 bit alphabet, UCS2, reserved */
+
−      data_len = MINIMUM ( source_len, SMS_MSG_LEN );
+
−
+
−      memcpy ( ( CHAR * ) dest, ( CHAR * ) source, data_len );
+
−      break;
+
−  }
+
−
+
−  *dest_len = data_len;
+
−}
+
−/* Implements Measure 25. This function is replaced by cmh_getAlphabetCb*/
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_expdSmsCb           |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function expands a cell broadcast SMS from
+
−            7 to 8 bit.
+
−*/
+
−GLOBAL void cmhSMS_expdSmsCb ( UBYTE      dcs,
+
−                               UBYTE     *source,
+
−                               UBYTE      source_len,
+
−                               UBYTE     *dest,
+
−                               UBYTE     *dest_len )
+
−{
+
−  UBYTE  alphabet;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_expdSmsCb()");
+
−  alphabet = cmh_getAlphabetCb ( dcs );
+
−
+
−  switch (alphabet)
+
−  {
+
−    case( 0 ):  /* 7 bit alphabet */
+
−/* PATCH Add bit_offset parameter to function cvt7To8 */
+
−/*      utl_cvt7To8 ( source, source_len, dest ); */
+
−      utl_cvt7To8 ( source, source_len, dest, 0);
+
−/* PATCH END */
+
−
+
−      *dest_len = ( source_len * 8 ) / 7;
+
−      break;
+
−
+
−    default: /* 8 bit alphabet, UCS2, reserved */
+
−      memcpy ( ( CHAR * ) dest, ( CHAR * ) source, source_len );
+
−
+
−      *dest_len = source_len;
+
−      break;
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_setToaDef           |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function sets the type of address to default values
+
−            (when the first character of address is '+' or the first
+
−            two characters are '0' default is 145 otherwise default
+
−            is 129)
+
−*/
+
−GLOBAL CHAR* cmhSMS_setToaDef ( CHAR*  number,
+
−                                UBYTE* ntype,
+
−                                UBYTE* nplan )
+
−{
+
−  *nplan = SMS_NPI_ISDN;
+
−
+
−  if ( *number EQ '+' )
+
−  {
+
−    *ntype = SMS_TON_INTERNATIONAL;
+
−    return number+1;
+
−  }
+
−  else
+
−  {
+
−    *ntype = SMS_TON_UNKNOWN;
+
−    return number;
+
−  }
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_setTimezone         |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Codes the timezone format used in entity SMS.
+
−
+
−*/
+
−GLOBAL UBYTE cmhSMS_setTimezone (SHORT timezone)
+
−{
+
−  UBYTE local_tz   = ( UBYTE ) timezone;
+
−  BOOL  isNegative = ( local_tz & 0x80 );
+
−
+
−  if ( isNegative )
+
−    local_tz = ~local_tz + 1;
+
−
+
−  local_tz = ( local_tz / 10 ) + ( ( local_tz % 10 ) << 4 );
+
−
+
−  return ( ( isNegative ) ? local_tz | 0x08 : local_tz );
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_getTimezone         |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Decodes the timezone format used in entity SMS.
+
−
+
−*/
+
−GLOBAL SHORT cmhSMS_getTimezone (UBYTE timezone)
+
−{
+
−  signed char local_tz;
+
−
+
−  local_tz = ( timezone & 0x07 ) * 10 + ( ( timezone & 0xF0 ) >> 4 );
+
−
+
−  return ( SHORT ) (( timezone & 0x08 ) ? -local_tz : local_tz );
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_setStorOcc          |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : Fills the T_ACI_SMS_STOR_OCC structure with data from the
+
−            shared parameter buffer.
+
−
+
−*/
+
−GLOBAL void cmhSMS_setStorOcc  ( T_ACI_SMS_STOR_OCC* outMem,
+
−                                 UBYTE               inMem   )
+
−{
+
−  cmhSMS_getMemCmh ( inMem, &outMem -> mem );
+
−
+
−  if ( outMem -> mem EQ SMS_STOR_Sm )
+
−  {
+
−    outMem -> used  = smsShrdPrm.aci_sms_parameter.simUsed;
+
−    outMem -> total = smsShrdPrm.aci_sms_parameter.simTotal;
+
−  }
+
−  else
+
−  {
+
−    outMem -> used  = smsShrdPrm.aci_sms_parameter.meUsed;
+
−    outMem -> total = smsShrdPrm.aci_sms_parameter.meTotal;
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−|                                 ROUTINE : cmhSMS_GetCmsFromSim    |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : Mapping of SIM error code to ACI error code.
+
−
+
−*/
+
−GLOBAL T_ACI_CMS_ERR cmhSMS_GetCmsFromSim ( USHORT errCode )
+
−{
+
−  switch ( errCode )
+
−  {
+
−    case SIM_NO_ERROR:
+
−      return CMS_ERR_NotPresent;
+
−
+
−    case SIM_CAUSE_PIN1_EXPECT:
+
−      return CMS_ERR_SimPinReq;
+
−
+
−    case SIM_CAUSE_PIN2_EXPECT:
+
−      return CMS_ERR_SimPin2Req;
+
−
+
−    case SIM_CAUSE_PUK1_EXPECT:
+
−    case SIM_CAUSE_PIN1_BLOCKED:
+
−      return CMS_ERR_SimPukReq;
+
−
+
−    case SIM_CAUSE_PUK2_EXPECT:
+
−    case SIM_CAUSE_PIN2_BLOCKED:
+
−      return CMS_ERR_SimPuk2Req;
+
−
+
−    case SIM_CAUSE_PUK1_BLOCKED:
+
−    case SIM_CAUSE_PUK2_BLOCKED:
+
−      return CMS_ERR_SimWrong;
+
−
+
−    case SIM_CAUSE_UNKN_FILE_ID:
+
−    case SIM_CAUSE_DNL_ERROR:
+
−      return CMS_ERR_UnknownErr;
+
−
+
−    case SIM_CAUSE_EF_INVALID:
+
−      return CMS_ERR_OpNotSup;
+
−
+
−    case SIM_CAUSE_ADDR_WRONG:
+
−      return CMS_ERR_InValMemIdx;
+
−
+
−    case SIM_CAUSE_CMD_INCONSIST:
+
−    case SIM_CAUSE_MAX_INCREASE:
+
−    case SIM_CAUSE_CHV_NOTSET:
+
−    case SIM_CAUSE_CHV_VALIDATED:
+
−    case SIM_CAUSE_ACCESS_PROHIBIT:
+
−      return CMS_ERR_OpNotAllowed;
+
−
+
−    case SIM_CAUSE_CARD_REMOVED:
+
−    case SIM_CAUSE_DRV_NOCARD:
+
−      return CMS_ERR_SimNotIns;
+
−
+
−    case SIM_CAUSE_NO_SELECT:
+
−    case SIM_CAUSE_CLA_WRONG:
+
−    case SIM_CAUSE_INS_WRONG:
+
−    case SIM_CAUSE_P1P2_WRONG:
+
−    case SIM_CAUSE_P3_WRONG:
+
−    case SIM_CAUSE_PARAM_WRONG:
+
−      return CMS_ERR_MeFail;
+
−
+
−    case SIM_CAUSE_SAT_BUSY:
+
−      return CMS_ERR_SimBsy;
+
−
+
−    case SIM_CAUSE_DRV_TEMPFAIL:
+
−      return CMS_ERR_SimFail;
+
−
+
−    default:
+
−      if (GET_CAUSE_DEFBY(errCode) EQ DEFBY_CONDAT AND
+
−          GET_CAUSE_ORIGSIDE(errCode) EQ ORIGSIDE_MS)
+
−      {
+
−        return CMS_ERR_UnknownErr;
+
−      }
+
−      return CMS_ERR_UnknownErr;
+
−  }
+
−}
+
−
+
−
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                |
+
−|                                 ROUTINE : cmhSMS_GetCmsFromSms    |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : Mapping of SMS causes (MNSMS.doc) to ACI error code.
+
−
+
−*/
+
−GLOBAL T_ACI_CMS_ERR cmhSMS_GetCmsFromSms ( USHORT errCode )
+
−{
+
−  switch ( errCode )
+
−  {
+
−    case SMS_NO_ERROR:              /* No error                           */
+
−      return CMS_ERR_NotPresent;
+
−
+
−    case SMS_CAUSE_PARAM_WRONG:     /* Wrong parameter in primitive       */
+
−
+
−    case SMS_CAUSE_ENTITY_BUSY:     /* Entity is busy                     */
+
−      return CMS_ERR_SimBsy;
+
−
+
−    case SMS_CAUSE_OPER_NOT_ALLW:   /* Operation not allowed              */
+
−      return CMS_ERR_OpNotAllowed;
+
−
+
−    case SMS_CAUSE_OPER_NOT_SUPP:   /* Operation not supported            */
+
−      return CMS_ERR_OpNotSup;
+
−
+
−    case SMS_CAUSE_SIM_BUSY:        /* SIM busy                           */
+
−      return CMS_ERR_SimBsy;
+
−    default:
+
−      break;
+
−  }
+
−      
+
−      /*
+
−       *    The switch must be splitted because of a compiler bug
+
−       *    - asm files can not compiled
+
−       *
+
−       *    TMS470 ANSI C Compiler       Version 1.22e
+
−       *
+
−       *    brz, 2004.02.14
+
−       */
+
−      
+
−  switch(errCode) {
+
−    case SMS_CAUSE_MEM_FAIL:        /* Memory failure                     */
+
−      return CMS_ERR_MemFail;
+
−
+
−    case SMS_CAUSE_INV_INDEX:       /* Invalid memory index               */
+
−      return CMS_ERR_InValMemIdx;
+
−
+
−    case SMS_CAUSE_MEM_FULL:        /* Memory full                        */
+
−      return CMS_ERR_MemFull;
+
−
+
−    case SMS_CAUSE_NO_SERVICE:      /* No network service                 */
+
−      return CMS_ERR_NoNetServ;
+
−
+
−    case SMS_CAUSE_NET_TIMEOUT:     /* Network timeout                    */
+
−      return CMS_ERR_NetTimeOut;
+
−
+
−    case SMS_CAUSE_UNEXP_CNMA:      /* No +CNMA acknowledgement expected  */
+
−      return CMS_ERR_NoCnmaAckExpect;
+
−
+
−    case SMS_CAUSE_OTHER_ERROR:     /* Any other error                    */
+
−      return CMS_ERR_UnknownErr;
+
−
+
−    default:
+
−      return ((T_ACI_CMS_ERR) errCode); /* cmdCmsError(errCode) will figure out other error values from the first byte of the error code */
+
−  }
+
−}
+
−
+
−
+
−
+
−
+
−
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_ready                 |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function notifies SMS_READY to all sources.
+
−*/
+
−GLOBAL void cmhSMS_ready ( void )
+
−{
+
−  int idx;
+
−  T_opl_field * ptr_opl;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_ready()");
+
−
+
−  {
+
−    PALLOC (sim_sync_req, SIM_SYNC_REQ);
+
−    sim_sync_req -> synccs = SYNC_MMI_FINISHED_READING;
+
−    simShrdPrm.synCs = SYNC_MMI_FINISHED_READING;
+
−    PSENDX (SIM, sim_sync_req);
+
−  }
+
−
+
−  smsShrdPrm.accessEnabled = TRUE;
+
−  ptr_opl = cmhSIM_GetOPL();
+
−  ptr_opl->opl_status = FALSE;
+
−
+
−  cmhSIM_UpdateOperatorName(NOT_PRESENT_16BIT);  /* start EF_PNN and EF_OPL reading */
+
−
+
−  pb_start_build(FALSE);     /* start phonebook reading, no guarantees */
+
−
+
−  percentCSTAT_indication(STATE_MSG_SMS, ENTITY_STATUS_Ready);
+
−
+
−  for( idx = 0; idx < CMD_SRC_MAX; idx++ )
+
−  {
+
−    R_AT( RAT_SMS_READY, (T_ACI_CMD_SRC)idx )();
+
−  }
+
−
+
−}
+
−
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_disableAccess         |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function disables access to all SMS functions.
+
−*/
+
−GLOBAL void cmhSMS_disableAccess (void)
+
−{
+
−  smsShrdPrm.accessEnabled = FALSE;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_checkSIM              |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function checks if SMS is initialized. If not, the
+
−            SIM state is checked. AN error code dependent of the
+
−            SIM state is stored.
+
−*/
+
−GLOBAL BOOL cmhSMS_checkSIM (void)
+
−{
+
−  if (smsShrdPrm.accessEnabled)
+
−    return TRUE;                /* SMS is accessible*/
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * check SIM status
+
−   *-----------------------------------------------------------------
+
−   */
+
−
+
−  switch (simShrdPrm.SIMStat)
+
−  {
+
−  case NO_VLD_SS:
+
−    ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimNotIns );
+
−    break;
+
−  case SS_INV:
+
−    ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimFail );
+
−    break;
+
−/*  case SS_BLKD: 
+
−    ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPukReq );
+
−    break; */
+
−  case SS_URCHB:
+
−    ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimWrong );
+
−    break;
+
−  case SS_OK:
+
−    switch (simShrdPrm.PINStat)
+
−    {
+
−      case PS_PIN1:
+
−        ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPinReq);
+
−        break;
+
−
+
−      case PS_PIN2:
+
−        ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPin2Req);
+
−        break;
+
−
+
−      case PS_PUK1:
+
−        ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPukReq);
+
−        break;
+
−
+
−      case PS_PUK2:
+
−        ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPuk2Req);
+
−        break;
+
−
+
−      default:
+
−        ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimBsy );
+
−        break;
+
−    }
+
−    break;
+
−  default:
+
−    ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimBsy );
+
−    break;
+
−  }
+
−  return FALSE;
+
−}
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_checkAccess           |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function checks if SMS is accessible. If an error
+
−            condition is found, then *ret is set to either AT_FAIL or
+
−            AT_BUSY, otherwise it remains unaffected. The error code
+
−            is stored.
+
−*/
+
−GLOBAL BOOL cmhSMS_checkAccess (T_ACI_CMD_SRC srcId,
+
−                                T_ACI_RETURN *ret)
+
−{
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * check command source
+
−   *-----------------------------------------------------------------
+
−   */
+
−  if(srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT)
+
−  {
+
−    if(!cmh_IsVldCmdSrc (srcId))
+
−    {
+
−    TRACE_ERROR ("[cmhSMS_checkAccess]: Cmd Src not valid");
+
−    *ret = AT_FAIL;
+
−    return FALSE;
+
−  }
+
−  }
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * check entity status
+
−   *-----------------------------------------------------------------
+
−   */
+
−  if( smsShrdPrm.smsEntStat.curCmd NEQ AT_CMD_NONE )
+
−  {
+
−    ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
+
−    TRACE_ERROR ("[cmhSMS_checkAccess]: Entity is busy");
+
−    *ret = AT_BUSY;
+
−    return FALSE;
+
−  }
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * check SMS access status
+
−   *-----------------------------------------------------------------
+
−   */
+
−  if (cmhSMS_checkSIM ())
+
−    return TRUE;
+
−
+
−  TRACE_ERROR ("[cmhSMS_checkAccess]: Wrong SIM status");
+
−
+
−  *ret = AT_FAIL;
+
−  return FALSE;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_getPrfRge             |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function gets the number of available profiles for
+
−            SMS related parameters. First, the SIM is checked. If
+
−            there is no space, then PCM ist checked.
+
−*/
+
−GLOBAL SHORT cmhSMS_getPrfRge ( void )
+
−{
+
−  /* TEMPORARY, ONLY FOR TEST PURPOSES: Pretend that the SIM has no SMSP !!! */
+
−  /* smsShrdPrm.aci_sms_parameter.smsParamMaxRec = 0;*/
+
−
+
−  if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec > 0)
+
−  {
+
−    return (SHORT)smsShrdPrm.aci_sms_parameter.smsParamMaxRec;
+
−  }
+
−  else
+
−  {
+
−    return (MAX_FFS_SMSPRFLS);
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_ReadPrmFFS            |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function reads one record of EF_SMSPRFL_ID from FFS.
+
−            The processed parameters are controlled by bits in
+
−            'access'.
+
−*/
+
−static T_ACI_RETURN cmhSMS_ReadPrmFFS (T_ACI_CMD_SRC  srcId,
+
−                                       SHORT          recNr,
+
−                                       int            access)
+
−{
+
−  T_SMS_SET_PRM     *pSMSSetPrm;  /* points to SMS parameter set */
+
−  int               i;
+
−  T_SMS_SET_PRM     *elem;
+
−  T_ACI_FFS_SMSPRFL smsPrfl;
+
−#ifndef _SIMULATION_
+
−  T_FFS_SIZE        ffs_size;
+
−#endif
+
−
+
−  TRACE_FUNCTION ("cmhSMS_ReadPrmFFS()");
+
−
+
−#ifdef _SIMULATION_
+
−  smsPrfl.vldFlag = FFS_SMSPRFL_INVLD;          /* trigger a failure since nothing can be read in simulation */
+
−#else
+
−  ffs_size = FFS_fread(ffs_smsprfl_fname[recNr-1], (void*)&smsPrfl, SIZE_FSS_SMSPRFL);
+
−  /*
+
−    Don't check FFS return for only specif ERRORS, as ACI will not know what 
+
−    ERROR FFS may send. So, it's walyws better to check for ERROR OK
+
−    i.e EFFS_OK  Considering this in mind the below condition is changes to 
+
−    do the same.
+
−  */
+
−  if ( ffs_size < EFFS_OK )
+
−  {
+
−    TRACE_EVENT_P1("error when reading FFS object \"%s\"", ffs_smsprfl_fname[recNr-1]);
+
−    ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_MemFail );
+
−    return AT_FAIL;
+
−  }
+
−#endif
+
−
+
−  if ( smsPrfl.vldFlag EQ FFS_SMSPRFL_INVLD )
+
−  {
+
−    ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_OpNotAllowed );
+
−    return AT_FAIL;
+
−  }
+
−
+
−  if (access & ACI_PCM_ACCESS_SMSP)
+
−  {
+
−    if (srcId >= CMD_SRC_MAX)
+
−    {
+
−      ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_UnknownErr );
+
−      return AT_FAIL;
+
−    }
+
−    else
+
−    {
+
−      if (set_prm_list EQ NULL)
+
−      {
+
−        set_prm_list = new_list();
+
−      }
+
−
+
−      elem = find_element(set_prm_list, (UBYTE)recNr, 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);
+
−      }
+
−      if (srcId <= CMD_SRC_NONE)
+
−      {
+
−        elem->numOfRefs = OWN_SRC_MAX;
+
−        for (i=0; i < OWN_SRC_MAX; i++)
+
−        {
+
−          smsShrdPrm.pSetPrm[i] = (T_SMS_SET_PRM*) elem;
+
−        }
+
−      }
+
−      else
+
−      {
+
−        smsShrdPrm.pSetPrm[srcId] = (T_SMS_SET_PRM*) elem;
+
−        (smsShrdPrm.pSetPrm[srcId])->numOfRefs++;
+
−      }
+
−    }
+
−
+
−    pSMSSetPrm = (T_SMS_SET_PRM*) elem;
+
−    pSMSSetPrm->prflId = (UBYTE)recNr;
+
−
+
−#ifndef _SIMULATION_
+
−    /*
+
−     *-------------------------------------------------------------
+
−     * restore the service center address
+
−     *-------------------------------------------------------------
+
−     */
+
−    pSMSSetPrm->sca.c_num = MINIMUM (smsPrfl.CSCAlenSca, MAX_SMS_ADDR_DIG);
+
−    memcpy ( pSMSSetPrm->sca.num, smsPrfl.CSCAsca, pSMSSetPrm->sca.c_num);
+
−    pSMSSetPrm->sca.ton = smsPrfl.CSCAton;
+
−    pSMSSetPrm->sca.npi = smsPrfl.CSCAnpi;
+
−    pSMSSetPrm->sca.v_ton = TRUE;
+
−    pSMSSetPrm->sca.v_npi = TRUE;
+
−
+
−    /*
+
−     *-------------------------------------------------------------
+
−     * restore the text mode parameters
+
−     *-------------------------------------------------------------
+
−     */
+
−    pSMSSetPrm->vpRel = smsPrfl.CSMPvprel;
+
−    memcpy ( &pSMSSetPrm->vpAbs, smsPrfl.CSMPvpabs, SIZE_FFS_SMSPRFL_VPABS );
+
−    memcpy ( &pSMSSetPrm->vpEnh, smsPrfl.CSMPvpenh, SIZE_FFS_SMSPRFL_VPENH );
+
−
+
−    pSMSSetPrm->msgType = smsPrfl.CSMPfo;
+
−    pSMSSetPrm->pid = smsPrfl.CSMPpid;
+
−    pSMSSetPrm->dcs = smsPrfl.CSMPdcs;
+
−#endif
+
−  }
+
−
+
−#ifndef _SIMULATION_
+
−  if (access & ACI_PCM_ACCESS_CBMP)
+
−  {
+
−      /*
+
−       *-------------------------------------------------------------
+
−       * restore the cell broadcast message types and data coding
+
−       * schemes
+
−       *-------------------------------------------------------------
+
−       */
+
−      smsShrdPrm.cbmPrm.cbmMode = smsPrfl.CSCBmode;
+
−
+
−      {                         /* default setting */
+
−        memset (smsShrdPrm.cbmPrm.msgId, DEF_MID_RANGE, sizeof (smsShrdPrm.cbmPrm.msgId));
+
−        memset (smsShrdPrm.cbmPrm.dcsId, DEF_DCS_RANGE, sizeof(smsShrdPrm.cbmPrm.dcsId));
+
−      }
+
−
+
−      for ( i = 0; i < MINIMUM(MAX_IDENTS,SIZE_FFS_SMSPRFL_MIDS/2); i++ )
+
−      {
+
−        smsShrdPrm.cbmPrm.msgId[i]  = ( USHORT )smsPrfl.CSCBmids[2*i] << 8;
+
−        smsShrdPrm.cbmPrm.msgId[i] |= ( USHORT )smsPrfl.CSCBmids[2*i+1];
+
−      }
+
−
+
−      memcpy ( smsShrdPrm.cbmPrm.dcsId, smsPrfl.CSCBdcss,
+
−               MINIMUM(MAX_IDENTS,SIZE_FFS_SMSPRFL_DCSS) );
+
−
+
−      memcpy (smsShrdPrm.cbmPrm.IMSI, smsPrfl.IMSI, MAX_IMSI);
+
−  }
+
−#endif
+
−  return AT_CMPL;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_WritePrmFFS           |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function writes one record of EF_SMSPRFL_ID to FFS.
+
−            The processed parameters are controlled by bits in
+
−            'access'.
+
−*/
+
−static T_ACI_RETURN cmhSMS_WritePrmFFS (T_ACI_CMD_SRC  srcId,
+
−                                        SHORT          recNr,
+
−                                        int            access)
+
−{
+
−  T_SMS_SET_PRM     *pSMSSetPrm;  /* points to SMS parameter set */
+
−  T_ACI_FFS_SMSPRFL smsPrfl;
+
−  int               i;
+
−#ifndef _SIMULATION_
+
−  T_FFS_RET         ffs_ret;
+
−#endif
+
−
+
−  TRACE_FUNCTION ("cmhSMS_WritePrmFFS()");
+
−
+
−  if (access & ACI_PCM_ACCESS_SMSP)
+
−  {
+
−    if (srcId > CMD_SRC_NONE AND srcId < CMD_SRC_MAX)
+
−    {
+
−      pSMSSetPrm = smsShrdPrm.pSetPrm[srcId];
+
−
+
−      /*
+
−       *-------------------------------------------------------------
+
−       * save the service center address
+
−       *-------------------------------------------------------------
+
−       */
+
−      smsPrfl.CSCAlenSca = MINIMUM ( pSMSSetPrm->sca.c_num, SIZE_FFS_SMSPRFL_SCA );
+
−      memcpy ( smsPrfl.CSCAsca, pSMSSetPrm->sca.num, smsPrfl.CSCAlenSca );
+
−
+
−      i = (int)smsPrfl.CSCAlenSca;
+
−      while ( i < SIZE_FFS_SMSPRFL_SCA )
+
−        smsPrfl.CSCAsca[i++] = 0xFF;
+
−
+
−      smsPrfl.CSCAton = pSMSSetPrm->sca.ton;
+
−      smsPrfl.CSCAnpi = pSMSSetPrm->sca.npi;
+
−
+
−      /*
+
−       *-------------------------------------------------------------
+
−       * store the text mode parameters
+
−       *-------------------------------------------------------------
+
−       */
+
−      smsPrfl.CSMPfo    = pSMSSetPrm->msgType;
+
−
+
−      smsPrfl.CSMPvprel = pSMSSetPrm->vpRel;
+
−      memcpy ( smsPrfl.CSMPvpabs, &pSMSSetPrm->vpAbs, SIZE_FFS_SMSPRFL_VPABS );
+
−      memcpy ( smsPrfl.CSMPvpenh, &pSMSSetPrm->vpEnh, SIZE_FFS_SMSPRFL_VPENH );
+
−
+
−      smsPrfl.CSMPpid   = pSMSSetPrm->pid;
+
−      smsPrfl.CSMPdcs   = pSMSSetPrm->dcs;
+
−
+
−      /*
+
−       *-------------------------------------------------------------
+
−       * set the valid flag
+
−       *-------------------------------------------------------------
+
−       */
+
−      smsPrfl.vldFlag = FFS_SMSPRFL_VLD;
+
−    }
+
−    else
+
−    {
+
−      ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_UnknownErr );
+
−      return AT_FAIL;
+
−    }
+
−  }
+
−  if (access & ACI_PCM_ACCESS_CBMP)
+
−  {
+
−      /*
+
−       *-------------------------------------------------------------
+
−       * save the cell broadcast message types
+
−       *-------------------------------------------------------------
+
−       */
+
−      smsPrfl.CSCBmode = smsShrdPrm.cbmPrm.cbmMode;
+
−
+
−      {                         /* default setting */
+
−        memset (smsPrfl.CSCBmids, 0xFF, sizeof(smsPrfl.CSCBmids));
+
−        memset (smsPrfl.CSCBdcss, 0xFF, sizeof(smsPrfl.CSCBdcss));
+
−      }
+
−
+
−      for ( i = 0; i < MINIMUM(MAX_IDENTS*2,SIZE_FFS_SMSPRFL_MIDS)-1; i += 2 )
+
−      {
+
−        smsPrfl.CSCBmids[i]   = (UBYTE)(smsShrdPrm.cbmPrm.msgId[i/2] >> 8);
+
−        smsPrfl.CSCBmids[i+1] = (UBYTE)smsShrdPrm.cbmPrm.msgId[i/2];
+
−      }
+
−
+
−      memcpy ( smsPrfl.CSCBdcss, smsShrdPrm.cbmPrm.dcsId,
+
−               MINIMUM(MAX_IDENTS,SIZE_FFS_SMSPRFL_DCSS) );
+
−
+
−      /*
+
−       * Save IMSI also in FFS 
+
−       */
+
−      memcpy (smsPrfl.IMSI, simShrdPrm.imsi.field, simShrdPrm.imsi.c_field);
+
−      smsPrfl.vldFlag = FFS_SMSPRFL_VLD;
+
−  }
+
−
+
−#ifndef _SIMULATION_
+
−  ffs_ret = FFS_mkdir(FFS_SMSPRFL_PATH);
+
−  if (ffs_ret EQ EFFS_OK)
+
−  {
+
−    TRACE_EVENT_P1("FFS directory \"%s\" successfully created", FFS_SMSPRFL_PATH);
+
−  }
+
−  else if (ffs_ret EQ EFFS_EXISTS)
+
−  {
+
−    TRACE_EVENT_P1("FFS directory \"%s\" already exists", FFS_SMSPRFL_PATH);
+
−  }
+
−  else
+
−  {
+
−    TRACE_EVENT_P1("error when creating FFS directory \"%s\"", FFS_SMSPRFL_PATH);
+
−  }
+
−
+
−  ffs_ret = FFS_fwrite(ffs_smsprfl_fname[recNr-1], (void*)&smsPrfl, SIZE_FSS_SMSPRFL);
+
−  if (ffs_ret NEQ EFFS_OK)
+
−  {
+
−    ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_MemFail );
+
−    TRACE_EVENT_P1("error when writing FFS object \"%s\"", ffs_smsprfl_fname[recNr-1]);
+
−    return AT_FAIL;
+
−  }
+
−#endif
+
−
+
−  return AT_CMPL;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_ReadParams            |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function reads parameters from SIM and/or PCM.
+
−            In case of AT command +CFUN the first record is read to
+
−            be informed about storage capability of SIM.
+
−*/
+
−GLOBAL T_ACI_RETURN cmhSMS_ReadParams (T_ACI_CMD_SRC  srcId,
+
−                                       T_ACI_AT_CMD   cmd,
+
−                                       SHORT          recNr)
+
−{
+
−  T_ACI_RETURN ret = AT_CMPL;
+
−  int access = 0;
+
−  
+
−  TRACE_FUNCTION ("cmhSMS_ReadParams()");
+
−
+
−  smsShrdPrm.smsEntStat.curCmd = cmd;
+
−  smsShrdPrm.owner = (T_OWN)srcId; 
+
−  smsShrdPrm.smsEntStat.entOwn = srcId;
+
−
+
−
+
−  if (cmd EQ AT_CMD_CFUN)
+
−  {  
+
−    /* initialization */
+
−  
+
−   /*
+
−    * Always read CSCB params from FFS so that previously stored mode and dcss
+
−    *  can also be restored from FFS
+
−    */
+
−    access |= ACI_PCM_ACCESS_CBMP;
+
−    /*if (!psaSIM_ChkSIMSrvSup( SRV_SMS_Parms ))*/
+
−    access |= ACI_PCM_ACCESS_SMSP;
+
−
+
−      ret = cmhSMS_ReadPrmFFS (CMD_SRC_NONE, 1, access);
+
−
+
−    if (psaSIM_ChkSIMSrvSup( SRV_SMS_Parms ))
+
−    {
+
−      smsShrdPrm.prmRdSeq = SMS_READ_SIM_SMSP;
+
−      ret = cmhSIM_ReadRecordEF (CMD_SRC_NONE, cmd, FALSE, NULL,
+
−                                  SIM_SMSP, 1, 255,
+
−                                  NULL, cmhSMS_InitSMSP);
+
−    }
+
−    else if (psaSIM_ChkSIMSrvSup( SRV_CBMIdRnge ))
+
−    {
+
−      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMIR;
+
−      ret = cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL,
+
−                                  SIM_CBMIR, 0, 255,
+
−                                  NULL, cmhSMS_InitSMSP);
+
−    }
+
−    else if (psaSIM_ChkSIMSrvSup( SRV_CBM_Ident ))
+
−    {
+
−      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMI;
+
−      ret = cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL,
+
−                                  SIM_CBMI, 0, 255,
+
−                                  NULL, cmhSMS_InitSMSP);
+
−    }
+
−#ifdef SIM_TOOLKIT
+
−    else if ((psaSIM_ChkSIMSrvSup( SRV_DtaDownlCB )) AND 
+
−             smsShrdPrm.owner EQ OWN_SRC_SAT )
+
−    {
+
−      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMID;
+
−      ret = cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL,
+
−                                  SIM_CBMID, 0, 255,
+
−                                  NULL, cmhSMS_InitSMSP);
+
−    }
+
−#endif /* of SIM_TOOLKIT */
+
−  }
+
−  else
+
−  {
+
−
+
−    /* TEMPORARY, ONLY FOR TEST PURPOSES: Pretend that the SIM has no SMSP !!! */
+
−    /* smsShrdPrm.aci_sms_parameter.smsParamMaxRec = 0; */
+
−    
+
−    /*
+
−     * Always read CSCB params from FFS so that previously stored mode and dcss
+
−     *  can also be restored from FFS
+
−     */
+
−    /* normal operation */
+
−    access |= ACI_PCM_ACCESS_CBMP;
+
−   /* if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec EQ 0)*/
+
−      access |= ACI_PCM_ACCESS_SMSP;
+
−      ret = cmhSMS_ReadPrmFFS (srcId, recNr, access);
+
−
+
−    if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec > 0)
+
−    {
+
−      if (recNr <= 0
+
−          OR recNr > (SHORT)smsShrdPrm.aci_sms_parameter.smsParamMaxRec)
+
−      {
+
−        ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx );
+
−        ret= AT_FAIL;
+
−      }
+
−      else
+
−      {
+
−        smsShrdPrm.prmRdSeq = SMS_READ_SIM_SMSP;
+
−        return cmhSIM_ReadRecordEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_SMSP,
+
−                                    (UBYTE)(recNr),
+
−                                    smsShrdPrm.aci_sms_parameter.smsParamRecLen,
+
−                                    NULL, cmhSMS_RdCnfCRES);
+
−      }
+
−    }
+
−    if (smsShrdPrm.cbmPrm.cbmSIMmaxIdRge > 0)
+
−    {
+
−      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMIR;
+
−      return cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_CBMIR,
+
−                                  0, smsShrdPrm.cbmPrm.cbmSIMmaxIdRge,
+
−                                  NULL, cmhSMS_RdCnfCRES);
+
−    }
+
−    if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0)
+
−    { 
+
−      smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMI;
+
−      return cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_CBMI,
+
−                                  0, smsShrdPrm.cbmPrm.cbmSIMmaxId,
+
−                                  NULL, cmhSMS_RdCnfCRES);
+
−    }
+
−  }
+
−  if (ret NEQ AT_EXCT)
+
−  {
+
−    smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+
−    smsShrdPrm.owner             = (T_OWN)CMD_SRC_NONE;
+
−    smsShrdPrm.smsEntStat.entOwn =CMD_SRC_NONE;
+
−
+
−    smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)srcId;
+
−    psaMMI_Cbch();
+
−    smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)CMD_SRC_NONE;
+
−  }
+
−  return ret;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_WriteParams           |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function reads parameters from SIM and/or PCM.
+
−            In case of AT command +CFUN the first record is read to
+
−            be informed about storage capability of SIM.
+
−*/
+
−GLOBAL T_ACI_RETURN cmhSMS_WriteParams (T_ACI_CMD_SRC  srcId,
+
−                                        T_ACI_AT_CMD   cmd,
+
−                                        SHORT          recNr)
+
−{
+
−  T_ACI_RETURN ret = AT_CMPL;
+
−  int access = 0;
+
−  UBYTE data[MAX_SIM_CMD];
+
−
+
−  TRACE_FUNCTION ("cmhSMS_WriteParams()");
+
−
+
−  smsShrdPrm.smsEntStat.curCmd = cmd;
+
−  smsShrdPrm.owner = (T_OWN)srcId;
+
−  smsShrdPrm.smsEntStat.entOwn = srcId;
+
−
+
−  /* TEMPORARY, ONLY FOR TEST PURPOSES: Pretend that the SIM has no SMSP !!! */
+
−  /* smsShrdPrm.aci_sms_parameter.smsParamMaxRec = 0; */
+
−
+
−  /*
+
−   * Always write CSCB params to FFS so that mode and dcss
+
−   *  can later be restored from FFS
+
−   */
+
−  access |= ACI_PCM_ACCESS_CBMP;
+
−  /*if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec EQ 0)*/
+
−    access |= ACI_PCM_ACCESS_SMSP;
+
−
+
−    ret = cmhSMS_WritePrmFFS (srcId, recNr, access);
+
−
+
−  if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec > 0)
+
−  {
+
−    if (recNr <= 0 OR recNr > (SHORT)smsShrdPrm.aci_sms_parameter.smsParamMaxRec)
+
−    {
+
−      ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx );
+
−      ret= AT_FAIL;
+
−    }
+
−    else
+
−    {
+
−      smsShrdPrm.prmRdSeq = SMS_READ_SIM_SMSP;
+
−      cmhSMS_PutPrmSIM (srcId, data,
+
−                        (int)smsShrdPrm.aci_sms_parameter.smsParamRecLen);
+
−      return cmhSIM_WriteRecordEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_SMSP,
+
−                                   (UBYTE)(recNr),
+
−                                   smsShrdPrm.aci_sms_parameter.smsParamRecLen,
+
−                                   data, cmhSMS_WrCnfCSAS);
+
−    }
+
−  }
+
−  if (smsShrdPrm.cbmPrm.cbmSIMmaxIdRge > 0)
+
−  {
+
−    smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMIR;
+
−    cmhSMS_PutCbmirSIM (srcId, data,
+
−                        (int)smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4);
+
−
+
−    return cmhSIM_WriteTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_CBMIR,
+
−                                 0, (UBYTE)(smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4),
+
−                                 data, cmhSMS_WrCnfCSAS);
+
−  }
+
−  if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0)
+
−  {
+
−    smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMI;
+
−    cmhSMS_PutCbmiSIM (srcId, data,
+
−                       (int)smsShrdPrm.cbmPrm.cbmSIMmaxId * 2);
+
−    
+
−    return cmhSIM_WriteTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_CBMI,
+
−                                 0, (UBYTE)(smsShrdPrm.cbmPrm.cbmSIMmaxId * 2),
+
−                                 data, cmhSMS_WrCnfCSAS);
+
−  }
+
−  if (ret NEQ AT_EXCT)
+
−  {
+
−    smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE;
+
−    smsShrdPrm.owner             = (T_OWN)CMD_SRC_NONE;
+
−    smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE;
+
−  }
+
−  return ret;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_GetPrmSIM             |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function extracts the parameters of one record of
+
−            EF(SMSP) read from SIM.
+
−*/
+
−GLOBAL BOOL cmhSMS_GetPrmSIM (T_ACI_CMD_SRC srcId,
+
−                              UBYTE         *data,
+
−                              int           dataLen)
+
−{
+
−  T_SMS_SET_PRM *pSMSSetPrm;    /* points to SMS parameter set */
+
−  T_ACI_SMS_SIM_PARAMS *smsprm;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_GetPrmSIM ()");
+
−
+
−  if (data NEQ NULL)
+
−  {    
+
−    pSMSSetPrm = smsShrdPrm.pSetPrm[srcId];
+
−    
+
−    smsprm = (T_ACI_SMS_SIM_PARAMS *)&data[(dataLen <= MIN_SMS_PRM_LEN)?
+
−                                            0: dataLen - MIN_SMS_PRM_LEN];
+
−
+
−    if (smsprm->par_ind EQ NOT_PRESENT_8BIT)
+
−    {
+
−    
+
−      /* ACI-SPR-16431: reset sca number */
+
−      pSMSSetPrm->sca.c_num = 0;
+
−      memset(pSMSSetPrm->sca.num, 0xFF, sizeof(pSMSSetPrm->sca.num)); 
+
−      /* end of ACI-SPR-16431: reset sca number */
+
−      
+
−      return TRUE;              /* record is empty */
+
−    }
+
−
+
−    if ((smsprm->par_ind & SIM_SMSP_V_SCA) EQ 0)
+
−    {
+
−       cmh_demergeTOA (smsprm->sca_ton_npi, &pSMSSetPrm->sca.ton,
+
−                      &pSMSSetPrm->sca.npi);
+
−      pSMSSetPrm->sca.c_num = (UBYTE)cmh_unpackBCD (pSMSSetPrm->sca.num,
+
−                                                     smsprm->sca_addr,
+
−                                                     (USHORT)(smsprm->sca_length - 1));
+
−      pSMSSetPrm->sca.v_ton = TRUE;
+
−      pSMSSetPrm->sca.v_npi = TRUE;
+
−
+
−    }
+
−    if ((smsprm->par_ind & SIM_SMSP_V_PID) EQ 0)
+
−      pSMSSetPrm->pid = smsprm->pid;
+
−
+
−    if ((smsprm->par_ind & SIM_SMSP_V_DCS) EQ 0)
+
−      pSMSSetPrm->dcs = smsprm->dcs;
+
−
+
−    if ((smsprm->par_ind & SIM_SMSP_V_VPREL) EQ 0)
+
−    {
+
−      pSMSSetPrm->vpRel = smsprm->vp_rel;
+
−      pSMSSetPrm->msgType &= ~TP_VPF_MASK;
+
−      pSMSSetPrm->msgType |= TP_VPF_RELATIVE;
+
−    }
+
−    else if ((pSMSSetPrm->msgType & TP_VPF_MASK) EQ TP_VPF_RELATIVE)
+
−      pSMSSetPrm->msgType &= ~TP_VPF_MASK;
+
−
+
−    return TRUE;
+
−  }
+
−  return FALSE;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_PutPrmSIM             |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function conbiness the parameters for one record of
+
−            EF(SMSP) to be written to SIM.
+
−*/
+
−GLOBAL BOOL cmhSMS_PutPrmSIM (T_ACI_CMD_SRC srcId,
+
−                              UBYTE         *data,
+
−                              int           maxDataLen)
+
−{
+
−  T_SMS_SET_PRM *pSMSSetPrm;    /* points to SMS parameter set */
+
−  T_ACI_SMS_SIM_PARAMS *smsprm;
+
−  size_t datalen;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_PutPrmSIM ()");
+
−
+
−  if (data NEQ NULL)
+
−  {
+
−    pSMSSetPrm = smsShrdPrm.pSetPrm[srcId];
+
−
+
−    if (maxDataLen < MIN_SMS_PRM_LEN)
+
−    {
+
−      datalen = MIN_SMS_PRM_LEN;
+
−      smsprm = (T_ACI_SMS_SIM_PARAMS *)data;
+
−    }
+
−    else
+
−    {
+
−      datalen = (size_t)maxDataLen;
+
−      smsprm = (T_ACI_SMS_SIM_PARAMS *)&data[datalen - MIN_SMS_PRM_LEN];
+
−    }
+
−    memset (data, NOT_PRESENT_8BIT, datalen);
+
−
+
−  /*
+
−   *-------------------------------------------------------------
+
−   * set the service center address
+
−   *-------------------------------------------------------------
+
−   */
+
−    if (pSMSSetPrm->sca.c_num > 0)
+
−    {
+
−      smsprm->sca_ton_npi = cmh_mergeTOA (pSMSSetPrm->sca.ton,
+
−                                          pSMSSetPrm->sca.npi);
+
−      smsprm->sca_length = (UBYTE)cmh_packBCD (smsprm->sca_addr,
+
−                                               pSMSSetPrm->sca.num,
+
−                                               (USHORT)MINIMUM(pSMSSetPrm->sca.c_num,
+
−                                                MAX_SMS_ADDR_DIG)) + 1;
+
−      smsprm->par_ind &= ~SIM_SMSP_V_SCA;
+
−    }
+
−
+
−  /*
+
−   *-------------------------------------------------------------
+
−   * set PID, DCS and VP-REL
+
−   *-------------------------------------------------------------
+
−   */
+
−
+
−    smsprm->pid = pSMSSetPrm->pid;
+
−    smsprm->par_ind &= ~SIM_SMSP_V_PID;
+
−
+
−    smsprm->dcs = pSMSSetPrm->dcs;
+
−    smsprm->par_ind &= ~SIM_SMSP_V_DCS;
+
−
+
−    if ((pSMSSetPrm->msgType & TP_VPF_MASK) EQ TP_VPF_RELATIVE)
+
−    {
+
−      smsprm->vp_rel = pSMSSetPrm->vpRel;
+
−      smsprm->par_ind &= ~SIM_SMSP_V_VPREL;
+
−    }
+
−    return TRUE;
+
−  }
+
−  return FALSE;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_GetCbmirSIM           |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function extracts the parameters of EF(CBMIR)
+
−            read from SIM.
+
−*/
+
−GLOBAL BOOL cmhSMS_GetCbmirSIM (T_ACI_CMD_SRC srcId,
+
−                                UBYTE         *data,
+
−                                int           dataLen)
+
−{
+
−  T_ACI_CBM_SIM_MID_RANGE *mid_range;
+
−  USHORT lower_mid, upper_mid;
+
−  int mid_entry;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_GetCbmirSIM ()");
+
−
+
−  if (data NEQ NULL)
+
−  {
+
−/* Please be aware that to keep simulation test cases as less changed as 
+
−   possible lets assume that IMSI and CBMs stored in the FFS and from SIM 
+
−   card are the same, since we cannot access  FFS under SIMULATION*/
+
−#ifndef _SIMULATION_
+
−    /*
+
−     * The CSCB parameters read from FFS should be restored only if the same SIM
+
−     * is inserted ( check IMSI to ensure the same SIM), otherwise reset the CSCB
+
−     * parameters to default values
+
−     */
+
−    if (memcmp (smsShrdPrm.cbmPrm.IMSI, simShrdPrm.imsi.field, simShrdPrm.imsi.c_field) NEQ 0)
+
−    {
+
−    /* Implements Measure # 9 */
+
−      cmhSMS_clearCbmPrm();     
+
−      return FALSE;
+
−    }
+
−#endif
+
−    mid_range = (T_ACI_CBM_SIM_MID_RANGE *)data;
+
−    mid_entry = 0;
+
−
+
−    while (smsShrdPrm.cbmPrm.cbmFoundIds < MAX_IDENTS/2 AND
+
−           mid_entry < dataLen)
+
−    {
+
−      lower_mid = (USHORT)mid_range->lowerLSB |
+
−                  ((USHORT)mid_range->lowerMSB << 8);
+
−      upper_mid = (USHORT)mid_range->upperLSB |
+
−                  ((USHORT)mid_range->upperMSB << 8);
+
−      mid_range++;
+
−      mid_entry += 4;
+
−
+
−      if (lower_mid NEQ NOT_PRESENT_16BIT OR
+
−          upper_mid NEQ NOT_PRESENT_16BIT)
+
−      {
+
−/* Please be aware that to keep simulation test cases as less changed as 
+
−   possible lets assume that  CBMs stored in the FFS and from SIM 
+
−   card are the same, since we cannot access  FFS under SIMULATION*/
+
−#ifndef _SIMULATION_
+
−   
+
−        /* Implements Measure # 73 */ 
+
−        if (!cmhSMS_findMessageIds (lower_mid, upper_mid))
+
−        {
+
−          return FALSE;
+
−        }
+
−
+
−#else /* Just for simulation - copy data, received from SIM */
+
−      smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2] = lower_mid;
+
−      smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1] = upper_mid;
+
−      smsShrdPrm.cbmPrm.cbmFoundIds++;
+
−#endif
+
−      }
+
−    }
+
−    return TRUE;
+
−  }
+
−  return FALSE;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_PutCbmirSIM           |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function conbines the parameters of EF(CBMIR)
+
−            to be written to SIM.
+
−*/
+
−GLOBAL BOOL cmhSMS_PutCbmirSIM (T_ACI_CMD_SRC srcId,
+
−                                UBYTE         *data,
+
−                                int           maxDataLen)
+
−{
+
−  T_ACI_CBM_SIM_MID_RANGE *mid_range;
+
−  USHORT lower_mid, upper_mid;
+
−  int mid_entry;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_PutCbmirSIM ()");
+
−
+
−  if (data NEQ NULL)
+
−  {
+
−    memset (data, NOT_PRESENT_8BIT, maxDataLen);
+
−
+
−    mid_range = (T_ACI_CBM_SIM_MID_RANGE *)data;
+
−    mid_entry = 0;
+
−
+
−    while (smsShrdPrm.cbmPrm.cbmFoundIds < MAX_IDENTS/2 AND
+
−           mid_entry < maxDataLen)
+
−    {
+
−      lower_mid = smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2];
+
−      upper_mid = smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1];
+
−      smsShrdPrm.cbmPrm.cbmFoundIds++;
+
−
+
−      if (lower_mid NEQ NOT_PRESENT_16BIT OR
+
−          upper_mid NEQ NOT_PRESENT_16BIT)
+
−      {
+
−        mid_range->lowerLSB = (UBYTE)lower_mid;
+
−        mid_range->lowerMSB = (UBYTE)(lower_mid >> 8);
+
−        mid_range->upperLSB = (UBYTE)upper_mid;
+
−        mid_range->upperMSB = (UBYTE)(upper_mid >> 8);
+
−        mid_range++;
+
−        mid_entry += 4;
+
−      }
+
−    }
+
−    return TRUE;
+
−  }
+
−  return FALSE;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_GetCbmiSIM            |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function extracts the parameters of one record of
+
−            EF(SMSP) read from SIM.
+
−*/
+
−GLOBAL BOOL cmhSMS_GetCbmiSIM  (T_ACI_CMD_SRC srcId,
+
−                                UBYTE         *data,
+
−                                int           dataLen)
+
−{
+
−  T_ACI_CBM_SIM_MID_LIST **mid_list;
+
−  USHORT mid;
+
−  int mid_entry;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_GetCbmiSIM ()");
+
−
+
−  if (data NEQ NULL)
+
−  {
+
−
+
−  /* Please be aware that to keep simulation test cases as less changed as 
+
−   possible lets assume that IMSI and CBMs stored in the FFS and from SIM 
+
−   card are the same, since we cannot access  FFS under SIMULATION*/
+
−#ifndef _SIMULATION_
+
−    /*
+
−     * The CSCB parameters read from FFS should be restored only if the same SIM
+
−     * is inserted ( check IMSI to ensure the same SIM), otherwise reset the CSCB
+
−     * parameters to default values
+
−     */
+
−    if (memcmp (smsShrdPrm.cbmPrm.IMSI, simShrdPrm.imsi.field, simShrdPrm.imsi.c_field) NEQ 0)
+
−    {
+
−    /* Implements Measure # 9 */
+
−      cmhSMS_clearCbmPrm();     
+
−      return FALSE;
+
−    }
+
−#endif
+
−    mid_list = (T_ACI_CBM_SIM_MID_LIST **)&data;
+
−    mid_entry = 0;
+
−
+
−    while (smsShrdPrm.cbmPrm.cbmFoundIds < MAX_IDENTS/2 AND
+
−           mid_entry < dataLen)
+
−    {
+
−      mid = (USHORT)(*mid_list)->LSB |
+
−            ((USHORT)(*mid_list)->MSB << 8);
+
−      data += 2;           /* overcome TI alignment problem */
+
−      mid_entry += 2;
+
−
+
−      if (mid NEQ NOT_PRESENT_16BIT)
+
−      {
+
−/* Please be aware that to keep simulation test cases as less changed as 
+
−   possible lets assume that  CBMs stored in the FFS and from SIM 
+
−   card are the same, since we cannot access  FFS under SIMULATION*/
+
−#ifndef _SIMULATION_
+
−
+
−        /* Implements Measure # 73 */
+
−        if (!cmhSMS_findMessageIds (mid, mid))
+
−        {
+
−          return FALSE;
+
−        }
+
−
+
−#else /* Just for simulation - copy data, received from SIM */
+
−      smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2] = 
+
−      smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1] = mid;
+
−      smsShrdPrm.cbmPrm.cbmFoundIds++;
+
−#endif
+
−      }
+
−    }
+
−    return TRUE;
+
−  }
+
−  return FALSE;
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_PutCbmiSIM            |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function conbines the parameters of EF(CBMI)
+
−            to be written to SIM.
+
−*/
+
−GLOBAL BOOL cmhSMS_PutCbmiSIM (T_ACI_CMD_SRC srcId,
+
−                               UBYTE         *data,
+
−                               int           maxDataLen)
+
−{
+
−  T_ACI_CBM_SIM_MID_LIST **mid_list;
+
−  USHORT lower_mid, upper_mid;
+
−  UBYTE  mid_entry;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_PutCbmiSIM ()");
+
−
+
−  if (data NEQ NULL)
+
−  {
+
−    memset (data, NOT_PRESENT_8BIT, maxDataLen);
+
−
+
−    mid_list = (T_ACI_CBM_SIM_MID_LIST **)&data;
+
−    mid_entry = 0;
+
−
+
−    while (smsShrdPrm.cbmPrm.cbmFoundIds < MAX_IDENTS/2 AND
+
−           mid_entry < maxDataLen)
+
−    {
+
−      lower_mid = smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2];
+
−      upper_mid = smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1];
+
−      smsShrdPrm.cbmPrm.cbmFoundIds++;
+
−
+
−      if (lower_mid NEQ NOT_PRESENT_16BIT OR
+
−          upper_mid NEQ NOT_PRESENT_16BIT)
+
−      {
+
−        while (lower_mid <= upper_mid AND mid_entry < maxDataLen)
+
−        {
+
−          (*mid_list)->LSB = (UBYTE)lower_mid;
+
−          (*mid_list)->MSB = (UBYTE)(lower_mid >> 8);
+
−          lower_mid++;
+
−          data += 2;           /* overcome TI alignment problem */
+
−          mid_entry += 2;
+
−        }
+
−      }
+
−    }
+
−    return TRUE;
+
−  }
+
−  return FALSE;
+
−}
+
−
+
−#ifdef SIM_TOOLKIT
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_FileUpdate            |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function processes the primitive SIM_FILE_UPDATE_IND
+
−            to update the SMS parameters stored on the SIM.
+
−*/
+
−GLOBAL BOOL cmhSMS_FileUpdate (int ref, T_SIM_FILE_UPDATE_IND *fu)
+
−{
+
−  BOOL found = FALSE;
+
−  int i;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_FileUpdate ()");
+
−
+
−  for (i = 0; i < (int)fu->val_nr; i++)
+
−  {
+
−    if (!found AND
+
−        (fu->file_info[i].v_path_info EQ TRUE AND
+
−         fu->file_info[i].path_info.df_level1 EQ SIM_DF_GSM AND
+
−         fu->file_info[i].path_info.v_df_level2 EQ FALSE AND
+
−         (fu->file_info[i].datafield EQ SIM_CBMI OR
+
−          fu->file_info[i].datafield EQ SIM_CBMIR OR
+
−          fu->file_info[i].datafield EQ SIM_CBMID)) OR
+
−
+
−         (fu->file_info[i].v_path_info EQ TRUE AND
+
−          fu->file_info[i].path_info.df_level1 EQ SIM_DF_TELECOM AND
+
−          fu->file_info[i].path_info.v_df_level2 EQ FALSE AND
+
−          fu->file_info[i].datafield EQ SIM_SMSP))
+
−    {
+
−      found = TRUE;
+
−    }
+
−    if (fu->file_info[i].v_path_info EQ TRUE AND
+
−        fu->file_info[i].path_info.df_level1   EQ SIM_DF_TELECOM AND
+
−        fu->file_info[i].path_info.v_df_level2 EQ FALSE AND
+
−        fu->file_info[i].datafield   EQ SIM_SMS)
+
−    {
+
−      smsShrdPrm.aci_sms_parameter.simTotal = 0;
+
−      smsShrdPrm.aci_sms_parameter.simUsed  = 0;
+
−    }
+
−  }
+
−  if (found)
+
−  {
+
−    smsShrdPrm.cbmPrm.cbmFoundIds = 0; /* new CBMI(R) */
+
−
+
−    if (cmhSMS_ReadParams ((T_ACI_CMD_SRC)OWN_SRC_SAT, AT_CMD_CFUN, 1) EQ AT_EXCT)
+
−    {
+
−      smsShrdPrm.accessEnabled = FALSE;
+
−
+
−      simShrdPrm.fuRef = ref;
+
−      return FALSE;           /* reading files */
+
−    }
+
−    else
+
−      return TRUE;            /* nothing to do */
+
−  }
+
−  else
+
−  {
+
−    simShrdPrm.fuRef = -1;    /* nothing to do */
+
−    return TRUE;
+
−  }
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−| STATE   : code             ROUTINE : cmhSMS_GetCbDtaDwnlSIM       |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function extracts the parameters of CBMID record of
+
−            EF(CBMID) read from SIM.
+
−*/
+
−GLOBAL BOOL cmhSMS_GetCbDtaDwnlSIM  (T_ACI_CMD_SRC srcId,
+
−                                     UBYTE         *data,
+
−                                     int           dataLen)
+
−{
+
−  T_ACI_CBM_SIM_MID_LIST **mid_list;
+
−  USHORT mid;
+
−  int mid_entry;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_GetCbDtaDwnlSIM ()");
+
−
+
−  if (data NEQ NULL)
+
−  {
+
−    smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds = 0;
+
−    memset (smsShrdPrm.cbmPrm.CBDtaDwnlIdent, NOT_PRESENT_8BIT,
+
−            sizeof (smsShrdPrm.cbmPrm.CBDtaDwnlIdent));
+
−
+
−    mid_list = (T_ACI_CBM_SIM_MID_LIST **)&data;
+
−    mid_entry = 0;
+
−
+
−    while (smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds < MAX_IDENTS_SAT AND
+
−           mid_entry < dataLen)
+
−    {
+
−      mid = (USHORT)(*mid_list)->LSB |
+
−            ((USHORT)(*mid_list)->MSB << 8);
+
−      data += 2;           /* overcome TI alignment problem */
+
−      mid_entry += 2;
+
−
+
−      if (mid NEQ NOT_PRESENT_16BIT)
+
−      {
+
−        smsShrdPrm.cbmPrm.CBDtaDwnlIdent[smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds] = mid;
+
−        smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds++;
+
−      }
+
−    }
+
−    return TRUE;
+
−  }
+
−  return FALSE;
+
−}
+
−
+
−#endif  /*of SIM_TOOLKIT */
+
−
+
−
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : cmhSMS_decodeMsg   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : decodes a SM in two steps
+
−
+
−*/
+
−GLOBAL UBYTE* cmhSMS_decodeMsg (T_sms_sdu *sms_sdu, T_rp_addr* rp_addr,
+
−                                UBYTE vt_mti)
+
−{
+
−  UBYTE ccdRet;
+
−  UBYTE direction;
+
−  UBYTE recover_from_error;
+
−
+
−  BUF_tpdu   sim_buf;   /* source for the second decoding */
+
−
+
−  TRACE_FUNCTION("cmhSMS_decodeMsg ()");
+
−
+
−  if( sms_sdu->l_buf EQ 0)
+
−  {
+
−    TRACE_EVENT("empty SDU: no decoding");
+
−    return(NULL);
+
−  }
+
−
+
−  CCD_START;
+
−  {
+
−
+
−    MCAST( sim_pdu, SIM_PDU ); /* sim_pdu points to _decodedMsg */
+
−    /*memset( sim_pdu, 0, sizeof (T_SIM_PDU) ); */
+
−
+
−    /* 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 NULL;
+
−    }
+
−
+
−    memcpy(rp_addr, &sim_pdu->rp_addr, sizeof(T_rp_addr) );
+
−
+
−    memcpy(&sim_buf, &sim_pdu->tpdu, sizeof(BUF_tpdu) );
+
−
+
−    /*memset( _decodedMsg, 0, sizeof (T_TP_SUBMIT) ); */
+
−
+
−    if (vt_mti EQ SMS_VT_SUBMIT)
+
−    {
+
−      /* for decoding of SMS-SUBMIT (in response to +CMGR, +CMGL) */
+
−      direction = UPLINK;
+
−    }
+
−    else
+
−    {
+
−      direction = DOWNLINK;
+
−    }
+
−
+
−    /* decoding inner layer */
+
−    ccdRet = ccd_decodeMsg ( CCDENT_SMS,
+
−                             direction,
+
−                             (T_MSGBUF *) &sim_buf,
+
−                             (UBYTE    *) _decodedMsg,  /* target */
+
−                             vt_mti );
+
−
+
−    if (ccdRet EQ ccdWarning)
+
−      recover_from_error = TRUE;  /* Try to recover if a ccdWarning occoured */
+
−    else
+
−      recover_from_error = FALSE;
+
−
+
−    if ((ccdRet EQ ccdError) OR (ccdRet EQ ccdWarning))
+
−    {
+
−      UBYTE ccd_err;
+
−      USHORT parlist [6];
+
−
+
−      TRACE_EVENT_P1 ("ccd_decodeMsg(): %02x", ccdRet);
+
−      /*
+
−       * get the first error
+
−       */
+
−      ccd_err = ccd_getFirstError (CCDENT_SMS, parlist);
+
−
+
−      /*
+
−       * Error Handling
+
−       */
+
−      do
+
−      {
+
−#ifndef NTRACE /* save some ROM */
+
−/* Implements Measure#32: Row 1080,...,1093 */
+
−        if (ccdRet EQ ccdError)
+
−        {
+
−          TRACE_EVENT_P1 ("ERR: %u ", ccd_err);
+
−        }
+
−        else if (ccdRet EQ ccdWarning)
+
−        {
+
−          TRACE_EVENT_P1 ("WRN: %u ", ccd_err);
+
−        }
+
−        switch (ccd_err)
+
−        {
+
−          case ERR_NO_MORE_ERROR:   
+
−            TRACE_EVENT("the end of the error list is reached");
+
−            break;
+
−          case ERR_INVALID_CALC:    
+
−            TRACE_EVENT("calculation of the element repeat value failed");
+
−            break;
+
−          case ERR_PATTERN_MISMATCH:
+
−            TRACE_EVENT("a bit pattern was not expected");
+
−            break;
+
−          case ERR_COMPREH_REQUIRED:
+
−            TRACE_EVENT("check for comprehension required failed");
+
−            break;
+
−          case ERR_IE_NOT_EXPECTED: 
+
−            TRACE_EVENT("an information element was not expected");
+
−            break;
+
−          case ERR_IE_SEQUENCE:     
+
−            TRACE_EVENT("wrong sequence of information elements");
+
−            break;
+
−          case ERR_MAX_IE_EXCEED:   
+
−            TRACE_EVENT("maximum amount of repeatable information elements has exceeded");
+
−            break;
+
−          case ERR_MAX_REPEAT:      
+
−            TRACE_EVENT("a repeatable element occurs too often in the message");
+
−            break;
+
−          case ERR_MAND_ELEM_MISS:  
+
−            TRACE_EVENT("a mandatory information element is missing");
+
−            break;
+
−          case ERR_INVALID_MID:     
+
−            TRACE_EVENT("the message ID is not correct");
+
−            break;
+
−          case ERR_INVALID_TYPE:    
+
−            TRACE_EVENT("the information element is not a spare padding");
+
−            break;
+
−          case ERR_EOC_TAG_MISSING: 
+
−            TRACE_EVENT("indefinite length is specified for the ASN.1-BER but the end tag is missing");
+
−            break;
+
−          case ERR_INTERNAL_ERROR:  
+
−            TRACE_EVENT("an internal CCD error occured ");
+
−            break;
+
−          default:                  
+
−            TRACE_EVENT("unknown error");
+
−            break;
+
−        }
+
−#endif /* NTRACE */
+
−
+
−        if (ccdRet EQ ccdWarning)
+
−        {
+
−          switch (ccd_err)
+
−          {
+
−            case ERR_PATTERN_MISMATCH:     /* recoverable warnings */
+
−            case ERR_COMPREH_REQUIRED:
+
−            case ERR_INTERNAL_ERROR:
+
−              break;                       
+
−            default:
+
−              recover_from_error = FALSE;  /* in all other cases reset the recover flag */
+
−          }
+
−        }
+
−
+
−        ccd_err = ccd_getNextError (CCDENT_SMS, parlist);
+
−      }while (ccd_err NEQ ERR_NO_MORE_ERROR);
+
−    }
+
−
+
−    if ( (ccdRet EQ ccdError) OR
+
−        ((ccdRet EQ ccdWarning) AND (recover_from_error EQ FALSE)) OR  /* not possible to recover */
+
−         (_decodedMsg[0] NEQ vt_mti) )
+
−    {
+
−      TRACE_EVENT_P1("CCD Decoding Error Stage 2: %d", ccdRet);
+
−      CCD_END;
+
−      return NULL;
+
−    }
+
−    else if ((ccdRet EQ ccdWarning) AND (recover_from_error EQ TRUE))
+
−    {
+
−      TRACE_EVENT ("recovered from warning");
+
−    }
+
−  }
+
−  CCD_END;
+
−
+
−  return _decodedMsg;
+
−}
+
−
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : cmhSMS_codeMsg     |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : encodes a SM in two steps
+
−
+
−*/
+
−GLOBAL void cmhSMS_codeMsg (T_sms_sdu *sms_sdu, UBYTE tp_vt_mti,
+
−                            T_rp_addr* sc_addr, UBYTE tp_mti,
+
−                            UBYTE* decoded_pdu )
+
−{
+
−  BUF_tpdu  sim_buf;      /* target for first coding  */
+
−  UBYTE direction;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_codeMsg()");
+
−
+
−
+
−  CCD_START;
+
−  {
+
−    UBYTE ccdRet;
+
−
+
−    MCAST( sim_pdu, SIM_PDU );
+
−
+
−    /* source of outer encoding */
+
−    memset( sim_pdu, 0, sizeof (T_SIM_PDU) );
+
−
+
−    /* target of outer encoding */
+
−    /* memset( sms_sdu, 0, sizeof (T_sms_sdu) ); */
+
−    sms_sdu->o_buf = 0;
+
−    sms_sdu->l_buf = SIM_PDU_LEN << 3;
+
−
+
−    sim_pdu->tp_vt_mti = SMS_VT_SIM_PDU;
+
−    sim_pdu->tp_mti    = tp_mti;
+
−
+
−    /* service center address exists */
+
−    if (sc_addr)
+
−    {
+
−      memcpy(&sim_pdu->rp_addr, sc_addr, sizeof(T_rp_addr));
+
−      sim_pdu->rp_addr.v_ton = 1;
+
−      sim_pdu->rp_addr.v_npi = 1;
+
−    }
+
−
+
−    /* pdu data exists */
+
−    if (decoded_pdu)
+
−    {
+
−      /* target of inner encoding */
+
−      /* memset(sim_buf, 0, sizeof(BUF_tpdu)); */
+
−      sim_buf.o_tpdu = 0;
+
−//TISH modified for MSIM
+
−//TISH: l_tpdu should be lenth of sim_buf.b_tpdu not BUF_tpdu.
+
−//      sim_buf.l_tpdu = (sizeof(BUF_tpdu)) << 3;
+
−      sim_buf.l_tpdu = (sizeof(sim_buf.b_tpdu)) << 3;
+
−
+
−      if (tp_vt_mti EQ SMS_VT_DELIVER)
+
−      {
+
−        /* for encoding of SMS-DELIVER (only in +CMGW) */
+
−        direction = DOWNLINK;
+
−      }
+
−      else
+
−      {
+
−        direction = UPLINK;
+
−      }
+
−
+
−      /* encoding inner layer */
+
−      ccdRet = ccd_codeMsg (CCDENT_SMS,
+
−                            direction,
+
−                            (T_MSGBUF *) &sim_buf,  /* target */
+
−                            (UBYTE *) decoded_pdu,
+
−                            tp_vt_mti);
+
−
+
−      if ( ccdRet NEQ ccdOK )
+
−      {
+
−        TRACE_EVENT_P1("CCD Coding Error: %d", ccdRet);
+
−        CCD_END;
+
−        return;
+
−      }
+
−      if (sim_buf.l_tpdu EQ 0)
+
−      {
+
−         TRACE_EVENT("Encoded length is zero");
+
−      }
+
−
+
−      memcpy(&sim_pdu->tpdu, &sim_buf, sizeof(BUF_tpdu));
+
−      sim_pdu->v_tpdu = 1; /* set validy flag */      
+
−    }
+
−
+
−    /* encoding outer layer */
+
−    ccdRet = ccd_codeMsg (CCDENT_SMS,
+
−                          UPLINK,
+
−                          (T_MSGBUF *) sms_sdu,  /* target */
+
−                          (UBYTE *) sim_pdu,
+
−                          SMS_VT_SIM_PDU);
+
−
+
−    if ( ccdRet NEQ ccdOK )
+
−    {
+
−      TRACE_EVENT_P1("CCD Coding Error: %d", ccdRet);
+
−      CCD_END;
+
−      return;
+
−    }
+
−    if (sms_sdu->l_buf EQ 0)
+
−    {
+
−       TRACE_EVENT("Encoded length is zero");
+
−    }
+
−  }
+
−  CCD_END;
+
−}
+
−
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : cmhSMS_cpyDeliver  |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : converts a SMS-DELIVER message to the T_ACI_CMGL_SM 
+
−            structure
+
−
+
−*/
+
−GLOBAL BOOL cmhSMS_cpyDeliver ( T_ACI_CMGL_SM * sm, T_sms_sdu * sms_sdu )
+
−{
+
−  T_rp_addr rp_addr;
+
−  UBYTE* message;
+
−  T_TP_DELIVER *sms_deliver;
+
−  UBYTE alphabet;
+
−
+
−  TRACE_FUNCTION("cmhSMS_cpyDeliver()");
+
−
+
−  message = cmhSMS_decodeMsg(sms_sdu, &rp_addr, SMS_VT_DELIVER);
+
−
+
−  if (message EQ NULL)
+
−  {
+
−    sm->stat = SMS_STAT_Invalid;
+
−    return (FALSE);
+
−  }
+
−
+
−  if ( message[0] NEQ SMS_VT_DELIVER)
+
−  {
+
−    TRACE_EVENT_P1("wrong VTI = %x", message[0]);
+
−  }
+
−
+
−  sms_deliver = (T_TP_DELIVER*)message;
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process originator address
+
−   *-----------------------------------------------------------------
+
−   */
+
−  /* Implements Measure # 126 */
+
−  /* Since T_tp_oa and T_tp_da are of same type, there is no problem in 
+
−     passing sms_deliver->tp_oa */
+
−  cmhSMS_processOrigDestAddr (sm,
+
−                              &rp_addr,
+
−                              &sms_deliver->tp_oa);
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process first octet
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> fo = sms_sdu->buf[sms_sdu->buf[0] + 1];
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process protocol identifier
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> pid = sms_deliver->tp_pid;
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process data coding scheme
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> dcs = sms_deliver->tp_dcs;
+
−
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process short message data, expanding from 7 to 8 bit
+
−   *-----------------------------------------------------------------
+
−   */
+
−
+
−  if (sms_deliver->v_tp_ud)
+
−  {
+
−    /* user data */
+
−    cmhSMS_expdSmsPp ( 0,
+
−                       sms_deliver->tp_dcs,
+
−                       sms_deliver->tp_ud.data,
+
−                       sms_deliver->tp_ud.length,
+
−                       sm -> data.data,
+
−                       &sm->data.len );
+
−
+
−    sm->udh.len = 0;
+
−  }
+
−  else
+
−  {
+
−    alphabet = cmhSMS_getAlphabetPp ( sms_deliver->tp_dcs );
+
−
+
−    /* user data header */
+
−    memcpy (sm->udh.data, sms_deliver->tp_udh_inc.tp_udh.data,
+
−            sms_deliver->tp_udh_inc.tp_udh.c_data);
+
−    sm->udh.len = sms_deliver->tp_udh_inc.tp_udh.c_data;
+
−
+
−    /* user data (only user data can be 7bit data!!!) */
+
−    cmhSMS_expdSmsPp ( (UBYTE)(sm->udh.len+1),
+
−                       sms_deliver->tp_dcs,
+
−                       sms_deliver->tp_udh_inc.data,
+
−                       sms_deliver->tp_udh_inc.length,    /* ACI-SPR-9440 */
+
−                       sm->data.data,
+
−                       &sm->data.len );
+
−
+
−    /* 7-bit data */
+
−    if (alphabet EQ 0x00)
+
−    {
+
−      sm->data.len = sms_deliver->tp_udh_inc.length - ((sm->udh.len+1)*8)/7;
+
−
+
−      /* minus space for the fill bits */
+
−      if (((sm->udh.len+1)*8)%7 NEQ 0) sm->data.len--;
+
−    }
+
−    /* 8-bit data */
+
−    else
+
−    {
+
−      sm->data.len = sms_deliver->tp_udh_inc.length-(sm->udh.len+1);
+
−    }
+
−  }
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process service center time stamp
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> vp_rel = 0;
+
−  memset ( &sm->vp_enh, 0, sizeof(T_ACI_VP_ENH) );
+
−
+
−  cmhSMS_setVpabsCmh ( &sm -> scts,
+
−                       (T_tp_vp_abs*) &sms_deliver->tp_scts );
+
−
+
−  return (TRUE);
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : cmhSMS_cpySubmit   |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : converts a SMS-SUBMIT message to the T_ACI_CMGL_SM
+
−            structure
+
−
+
−*/
+
−GLOBAL BOOL cmhSMS_cpySubmit ( T_ACI_CMGL_SM * sm, T_sms_sdu * sms_sdu )
+
−{
+
−  T_rp_addr rp_addr;
+
−  UBYTE* message;
+
−  T_TP_SUBMIT *sms_submit;
+
−  UBYTE alphabet;
+
−
+
−  TRACE_FUNCTION("cmhSMS_cpySubmit()");
+
−
+
−  message = cmhSMS_decodeMsg(sms_sdu, &rp_addr, SMS_VT_SUBMIT);
+
−
+
−  if (message EQ NULL)
+
−  {
+
−    sm->stat = SMS_STAT_Invalid;  
+
−    return (FALSE);
+
−  }
+
−
+
−  if ( message[0] NEQ SMS_VT_SUBMIT)
+
−  {
+
−    TRACE_EVENT_P1("wrong VTI = %x", message[0]);
+
−  }
+
−
+
−  sms_submit = (T_TP_SUBMIT*)message;
+
−
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process recepient address
+
−   *-----------------------------------------------------------------
+
−   */
+
−  /* Implements Measure # 126 */
+
−  cmhSMS_processOrigDestAddr (sm,
+
−                              &rp_addr,
+
−                              &sms_submit->tp_da);
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process first octet
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> fo = sms_sdu->buf[sms_sdu->buf[0] + 1];
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process protocol identifier
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> pid = sms_submit->tp_pid;
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process data coding scheme
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> dcs = sms_submit->tp_dcs;
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process short message data, expanding from 7 to 8 bit
+
−   *-----------------------------------------------------------------
+
−   */
+
−
+
−  if (sms_submit->v_tp_ud)
+
−  {
+
−    /* user data */
+
−    cmhSMS_expdSmsPp ( 0,
+
−                       sms_submit->tp_dcs,
+
−                       sms_submit->tp_ud.data,
+
−                       sms_submit->tp_ud.length,   /* ACI-SPR-9440 */
+
−                       sm->data.data,
+
−                       &sm->data.len );
+
−
+
−    sm->udh.len = 0;
+
−  }
+
−  else
+
−  {
+
−    alphabet = cmhSMS_getAlphabetPp ( sms_submit->tp_dcs );
+
−
+
−    /* user data header */
+
−    memcpy (sm->udh.data, sms_submit->tp_udh_inc.tp_udh.data,
+
−            sms_submit->tp_udh_inc.tp_udh.c_data);
+
−    sm->udh.len = sms_submit->tp_udh_inc.tp_udh.c_data;
+
−
+
−    /* user data (only user data can be 7bit data!!!) */
+
−    cmhSMS_expdSmsPp ( (UBYTE)(sm->udh.len+1),
+
−                       sms_submit->tp_dcs,
+
−                       sms_submit->tp_udh_inc.data,
+
−                       sms_submit->tp_udh_inc.length,  /* ACI-SPR-9440 */
+
−                       sm->data.data,
+
−                       &sm->data.len );
+
−
+
−    /* 7-bit data */
+
−    if (alphabet EQ 0x00)
+
−    {
+
−      sm->data.len = sms_submit->tp_udh_inc.length - ((sm->udh.len+1)*8)/7;
+
−
+
−      /* minus space for the fill bits */
+
−      if (((sm->udh.len+1)*8)%7 NEQ 0) sm->data.len--;
+
−    }
+
−    /* 8-bit data */
+
−    else
+
−    {
+
−      sm->data.len = sms_submit->tp_udh_inc.length-(sm->udh.len+1);
+
−    }
+
−  }
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process validity period
+
−   *-----------------------------------------------------------------
+
−   */
+
−  if (sms_submit->v_tp_vp_abs)
+
−  {
+
−    cmhSMS_setVpabsCmh ( &sm->scts, &sms_submit->tp_vp_abs );
+
−    sm -> vp_rel = 0;
+
−    memset ( &sm->vp_enh, 0, sizeof(T_ACI_VP_ENH) );
+
−  }
+
−  else if (sms_submit->v_tp_vp_enh)
+
−  {
+
−    cmhSMS_setVpenhCmh ( &sm->vp_enh, &sms_submit->tp_vp_enh );
+
−    sm -> vp_rel = 0;
+
−    memset ( &sm->scts, 0, sizeof(T_ACI_VP_ABS) );
+
−  }
+
−  else
+
−  {
+
−    sm -> vp_rel = sms_submit->tp_vp_rel;
+
−    memset ( &sm -> scts, 0, sizeof(T_ACI_VP_ABS) );
+
−    memset ( &sm -> vp_enh, 0, sizeof(T_ACI_VP_ENH) );
+
−  }
+
−  return (TRUE);
+
−}
+
−
+
−/* Implements Measure # 110 */
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : cmhSMS_cpyStatInd  |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : handles a status indication
+
−
+
−*/
+
−GLOBAL BOOL cmhSMS_cpyStatInd ( T_ACI_CDS_SM  * sm, 
+
−                                T_MNSMS_STATUS_IND *mnsms_status_ind )
+
−{
+
−  T_rp_addr rp_addr;
+
−  UBYTE* message;
+
−  T_TP_STATUS *sms_status;
+
−  
+
−  TRACE_FUNCTION("cmhSMS_cpyStatInd()");
+
−
+
−  message = cmhSMS_decodeMsg(&mnsms_status_ind->sms_sdu, &rp_addr, SMS_VT_STATUS);
+
−
+
−  if (message EQ NULL)
+
−  {
+
−    return (FALSE);
+
−  }
+
−
+
−  if ( message[0] NEQ SMS_VT_STATUS)
+
−  {
+
−    TRACE_EVENT_P1("wrong VTI = %x", message[0]);
+
−  }
+
−
+
−  sms_status = (T_TP_STATUS*)message;
+
−
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process message type
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> fo = mnsms_status_ind->sms_sdu.buf[mnsms_status_ind->sms_sdu.buf[0]+1];
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process message reference
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> msg_ref = sms_status->tp_mr;
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process recipient address
+
−   *-----------------------------------------------------------------
+
−   */
+
−  cmhSMS_getAdrStr ( sm->addr,
+
−                     MAX_SMS_ADDR_DIG - 1,
+
−                     sms_status->tp_ra.num,
+
−                     sms_status->tp_ra.digits);
+
−
+
−  sm->toa.ton = cmhSMS_getTon ( sms_status->tp_ra.ton );
+
−  sm->toa.npi = cmhSMS_getNpi ( sms_status->tp_ra.npi );
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process service center time stamp
+
−   *-----------------------------------------------------------------
+
−   */
+
−  cmhSMS_setVpabsCmh ( &sm->vpabs_scts, (T_tp_vp_abs*) &sms_status->tp_scts );
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process discharge time
+
−   *-----------------------------------------------------------------
+
−   */
+
−  cmhSMS_setVpabsCmh ( &sm->vpabs_dt, (T_tp_vp_abs*) &sms_status->tp_dt );
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process status
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> tp_status = sms_status->tp_st;
+
−
+
−  return (TRUE);
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : cmhSMS_getPhbEntry |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : gets phone book entry from coded SM
+
−
+
−*/
+
−GLOBAL void cmhSMS_getPhbEntry( UBYTE *buf,
+
−                                T_ACI_PB_TEXT *alpha,
+
−                                T_ACI_SMS_STAT status )
+
−{
+
−  UBYTE *p_data;
+
−  UBYTE sca_len;
+
−  UBYTE nplan;
+
−  UBYTE no_bcd;
+
−  UBYTE bcd[MAX_SMS_ADDR_DIG];
+
−  CHAR  addr[MAX_SMS_ADDR_DIG+1];   /* for '\0' */
+
−  USHORT octets;
+
−
+
−  alpha->len = 0;
+
−
+
−  p_data =  &buf[0];
+
−  sca_len = buf[0];
+
−
+
−  switch (status)
+
−  {
+
−    case SMS_STAT_RecUnread:
+
−    case SMS_STAT_RecRead:
+
−      if ((*(p_data+sca_len+1) & TP_MTI_MASK) EQ TP_MTI_SMS_STATUS_REP)
+
−      {
+
−        p_data++;
+
−      }
+
−      p_data += (sca_len+1) + 1;  /* sms-deliver */
+
−      break;
+
−    case SMS_STAT_StoUnsent:
+
−    case SMS_STAT_StoSent:
+
−      p_data += (sca_len+1) + 2;  /* sms-submit */
+
−      break;
+
−    default:
+
−      return;
+
−  }
+
−
+
−  /* process originator/destination address */
+
−  no_bcd = *p_data++;
+
−  no_bcd = MINIMUM(no_bcd, MAX_SMS_ADDR_DIG);
+
−
+
−  nplan  = *p_data++ & 0x0F; /* npi */
+
−
+
−  octets = (no_bcd+1)/2;
+
−
+
−  no_bcd = (UBYTE)cmh_unpackBCD (bcd, p_data, octets);
+
−
+
−  if (nplan EQ 0x05) /* VO patch - if (patch) else ... */
+
−  {
+
−    UBYTE i,j = 0;
+
−    for (i = 0 ; i < no_bcd; i=i+2)
+
−    {
+
−      addr[j] = (UBYTE)(bcd[i+1] << 4) + (UBYTE)(bcd[i]);
+
−      j++;
+
−    }
+
−    addr[j] = '\0';
+
−  }
+
−  else
+
−  {
+
−    cmhSMS_getAdrStr ( addr,
+
−                       MAX_SMS_ADDR_DIG,
+
−                       bcd,
+
−                       no_bcd );
+
−  }
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process alphanumerical phonebook entry
+
−   *-----------------------------------------------------------------
+
−   */
+
−  psaCC_phbMfwSrchNumPlnTxt ( addr, alpha );
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : cmhSMS_codeDelRep  |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : codes RP-ACK for SMS-DELIVER-REPORT (without PID, DCS, UD)
+
−
+
−*/
+
−GLOBAL void cmhSMS_codeDelRep(T_sms_sdu *sms_sdu, T_rp_addr *sc_addr)
+
−{
+
−  UBYTE sca_len;  /* SCA len incl. length byte and toa */
+
−  UBYTE sca_buf[MAX_SMS_ADDR_DIG/2 + 2];
+
−
+
−  sca_len = CodeRPAddress( sca_buf,
+
−                           sc_addr->c_num,
+
−                           sc_addr->ton,
+
−                           sc_addr->npi,
+
−                           sc_addr->num );
+
−
+
−  sms_sdu->l_buf = (sca_len+2)<<3;
+
−  sms_sdu->o_buf = 0;
+
−
+
−  memcpy ( sms_sdu->buf, sca_buf, sca_len);
+
−  memset ( sms_sdu->buf+sca_len, 0, 2);
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : CodeRPAddress      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : converts address (in BCD format) to semi-octet representation
+
−            (including address-length, ton and npi),
+
−            for RP addresses (e.g SCA)
+
−
+
−            returns number of octets including address-length,
+
−            ton and npi
+
−
+
−*/
+
−GLOBAL UBYTE CodeRPAddress( UBYTE *buf, UBYTE  numDigits, UBYTE ton,
+
−                      UBYTE npi,  UBYTE *bcd )
+
−{
+
−  UBYTE length;
+
−
+
−  if (numDigits EQ 0)
+
−  {
+
−    length = 1;
+
−    *buf = 0x00;
+
−  }
+
−  else
+
−  {
+
−    *buf++ = (numDigits+1)/2 + 1;
+
−    *buf++ = (ton << 4) + npi + 0x80;
+
−
+
−    length = (UBYTE)cmh_packBCD ( buf, bcd, numDigits );
+
−
+
−    /* add length of length field, ton and npi */
+
−    length += 2;
+
−  }
+
−
+
−  return length;
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : CodeTPAddress      |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : converts address (in BCD format) to semi-octet representation
+
−            (including address-length, ton and npi),
+
−            for TP addresses (e.g OA or DA)
+
−
+
−            returns number of octets including including address-length,
+
−            ton and npi
+
−
+
−*/
+
−GLOBAL UBYTE CodeTPAddress( UBYTE *buf, UBYTE  numDigits, UBYTE ton,
+
−                      UBYTE npi,  UBYTE *bcd )
+
−{
+
−  UBYTE length;
+
−
+
−  *buf++ = numDigits;
+
−  *buf++ = (ton << 4) + npi + 0x80;
+
−
+
−  length = (UBYTE)cmh_packBCD ( buf, bcd, numDigits );
+
−
+
−  /* add length of length field, to and npi */
+
−  length += 2;
+
−
+
−  return length;
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : DecodeRPAddress    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : converts RP address (SC address) from semi-octet
+
−            representation to address in BCD format (including
+
−            address-length, ton and npi)
+
−
+
−            returns number of processed octets in buf
+
−
+
−*/
+
−GLOBAL UBYTE DecodeRPAddress(UBYTE *c_num, UBYTE *ton,
+
−                       UBYTE *npi,  UBYTE *bcd, UBYTE *buf)
+
−{
+
−  UBYTE sca_length;  /* sca length is lenth in bytes plus TOA-octet */
+
−  UBYTE processed_octets;
+
−
+
−  sca_length = *buf++;
+
−  *ton = (*buf & 0x70)>>4;
+
−  *npi = *buf++ & 0x0F;
+
−
+
−  *c_num = (UBYTE)cmh_unpackBCD (bcd, buf, (USHORT)(sca_length-1));
+
−
+
−  processed_octets = (*c_num+1)/2 + 2;
+
−
+
−  return processed_octets;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF           |
+
−| STATE   : code                        ROUTINE : DecodeTPAddress    |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : converts TP address (DA, OA)from semi-octet
+
−            representation to address in BCD format (including
+
−            address-length, ton and npi)
+
−
+
−            returns number of processed octets in buf
+
−
+
−*/
+
−GLOBAL UBYTE DecodeTPAddress(UBYTE *c_num, UBYTE *ton,
+
−                       UBYTE *npi,  UBYTE *bcd, UBYTE *buf)
+
−{
+
−  UBYTE digits;
+
−  UBYTE processed_octets;
+
−
+
−  digits = *buf++;
+
−  *ton = (*buf & 0x70)>>4;
+
−  *npi = *buf++ & 0x0F;
+
−
+
−  *c_num = (UBYTE)cmh_unpackBCD (bcd, buf, (USHORT)((digits+1)/2));
+
−
+
−  processed_octets = (*c_num+1)/2 + 2;
+
−
+
−  return processed_octets;
+
−}
+
−
+
−
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT :                     MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_fillTpSubmit        |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : fills a T_TP_SUBMIT
+
−
+
−*/
+
−GLOBAL void cmhSMS_fillTpSubmit  (T_TP_SUBMIT*    tp_submit,
+
−                                  T_ACI_CMD_SRC   srcId,
+
−                                  UBYTE           msgType,
+
−                                  UBYTE           mr,
+
−                                  T_tp_da*        da_addr,
+
−                                  T_ACI_SM_DATA*  data,
+
−                                  UBYTE           septets,
+
−                                  T_ACI_UDH_DATA* udh )
+
−{
+
−  T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set     */
+
−  UBYTE  alphabet;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_fillTpSubmit()");
+
−
+
−  pSMSSetPrm = smsShrdPrm.pSetPrm[srcId];
+
−
+
−  memset(tp_submit, 0, sizeof(T_TP_SUBMIT));
+
−
+
−  tp_submit->tp_vt_mti = SMS_VT_SUBMIT;
+
−  tp_submit->tp_rp = (msgType & TP_RP_MASK) ? 1 : 0;
+
−  tp_submit->tp_mti = SMS_SUBMIT;
+
−  tp_submit->tp_mr = mr;
+
−  tp_submit->tp_srr  = (msgType & TP_SRR_MASK) ? 1 : 0;
+
−
+
−  if (da_addr->digits NEQ 0x00)
+
−    memcpy(&tp_submit->tp_da, da_addr, sizeof(T_tp_da));
+
−
+
−  tp_submit->tp_pid = pSMSSetPrm -> pid;
+
−  tp_submit->tp_dcs = pSMSSetPrm -> dcs;
+
−
+
−  switch (msgType & VPF_MASK)
+
−  {
+
−
+
−    case VPF_RELATIVE:  /* validity period relative */
+
−      tp_submit->v_tp_vp_rel = 1;
+
−      tp_submit->tp_vpf = SMS_VPF_RELATIVE;
+
−      tp_submit->tp_vp_rel = pSMSSetPrm -> vpRel;
+
−      break;
+
−
+
−    case VPF_ABSOLUTE:  /* validity period absolute */
+
−      tp_submit->v_tp_vp_abs = 1;
+
−      tp_submit->tp_vpf = SMS_VPF_ABSOLUTE;
+
−      memcpy(&tp_submit->tp_vp_abs, &pSMSSetPrm -> vpAbs, sizeof(T_tp_vp_abs));
+
−      break;
+
−
+
−    case VPF_ENHANCED:  /* validity period enhanced */
+
−      tp_submit->v_tp_vp_enh = 1;
+
−      tp_submit->tp_vpf = SMS_VPF_ENHANCED;
+
−      memcpy(&tp_submit->tp_vp_enh, &pSMSSetPrm -> vpEnh, sizeof(T_tp_vp_enh));
+
−      break;
+
−
+
−    default:  /* validity period not present */
+
−      break;
+
−  }
+
−
+
−  
+
−  alphabet = cmhSMS_getAlphabetPp ( pSMSSetPrm -> dcs );
+
−
+
−  if ((udh) AND (udh->len))
+
−  {
+
−    tp_submit->tp_udhi = 1;
+
−    tp_submit->v_tp_udh_inc = 1;
+
−    tp_submit->tp_udh_inc.tp_udh.c_data = udh->len;
+
−    memcpy(tp_submit->tp_udh_inc.tp_udh.data, udh->data, udh->len);
+
−
+
−    /* copy user data */
+
−    if ((data) AND (data->len))
+
−    {
+
−      tp_submit->tp_udh_inc.c_data = data->len;
+
−      memcpy(tp_submit->tp_udh_inc.data, data->data, data->len);
+
−    }
+
−
+
−    /* 7-bit data */
+
−    if (alphabet EQ 0x00)
+
−    {
+
−      tp_submit->tp_udh_inc.length = septets + (((udh->len+1)*8)/7);
+
−
+
−      /* space for the fill bits */
+
−      if (((udh->len+1)*8)%7 NEQ 0) 
+
−      {
+
−        tp_submit->tp_udh_inc.length++;
+
−        if ((data EQ NULL) OR (data->len EQ 0))
+
−        {
+
−          tp_submit->tp_udh_inc.c_data = 1;
+
−          tp_submit->tp_udh_inc.data[0] = 0; /* redundant  */
+
−        }
+
−      }
+
−    }
+
−    /* 8-bit data */
+
−    else
+
−    {
+
−      tp_submit->tp_udh_inc.length = tp_submit->tp_udh_inc.c_data+udh->len+1; /* UDH length should be also added */
+
−    }
+
−  }
+
−  else
+
−  {
+
−    /* validity flag set for both normal SMS and empty SMS */
+
−      tp_submit->v_tp_ud = 1;
+
−
+
−    if ((data) AND (data->len))
+
−    {
+
−      tp_submit->tp_ud.length = septets;
+
−      tp_submit->tp_ud.c_data = data->len;
+
−      memcpy(tp_submit->tp_ud.data, data->data, data->len); 
+
−    }
+
−    else 
+
−    {
+
−      /* enters when zero character SMS to be sent */
+
−    }
+
−  }
+
−}
+
−
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT :                     MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_fillTpDeliver       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : fills a T_TP_DELIVER (only used by +CMGW)
+
−
+
−*/
+
−GLOBAL void cmhSMS_fillTpDeliver (T_TP_DELIVER*   tp_deliver,
+
−                                  T_ACI_CMD_SRC   srcId,
+
−                                  UBYTE           msgType,
+
−                                  T_tp_oa*        oa_addr,
+
−                                  T_ACI_SM_DATA*  data,
+
−                                  UBYTE           septets,
+
−                                  T_ACI_UDH_DATA* udh )
+
−{
+
−  T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set     */
+
−  UBYTE  alphabet;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_fillTpDeliver()");
+
−
+
−  pSMSSetPrm = smsShrdPrm.pSetPrm[srcId];
+
−
+
−  memset(tp_deliver, 0, sizeof(T_TP_DELIVER));
+
−
+
−  tp_deliver->tp_vt_mti = SMS_VT_DELIVER;
+
−  tp_deliver->tp_rp = (msgType & TP_RP_MASK) ? 1 : 0;
+
−  tp_deliver->tp_mti = SMS_DELIVER;
+
−
+
−  if (oa_addr->digits NEQ 0x00)
+
−    memcpy(&tp_deliver->tp_oa, oa_addr, sizeof(T_tp_oa));
+
−
+
−  tp_deliver->tp_pid = pSMSSetPrm -> pid;
+
−  tp_deliver->tp_dcs = pSMSSetPrm -> dcs;
+
−
+
−  memcpy(&tp_deliver->tp_scts, &pSMSSetPrm -> vpAbs, sizeof(T_tp_scts));
+
−
+
−  if ((data) AND (data->len))
+
−  {
+
−    alphabet = cmhSMS_getAlphabetPp ( pSMSSetPrm -> dcs );
+
−
+
−    if ((udh) AND (udh->len))
+
−    {
+
−      tp_deliver->tp_udhi = 1;
+
−      tp_deliver->v_tp_udh_inc = 1;
+
−      tp_deliver->tp_udh_inc.tp_udh.c_data = udh->len;
+
−      memcpy(tp_deliver->tp_udh_inc.tp_udh.data, udh->data, udh->len);
+
−
+
−      /* copy user data */
+
−      tp_deliver->tp_udh_inc.c_data = data->len;
+
−      memcpy(tp_deliver->tp_udh_inc.data, data->data, data->len);
+
−
+
−      /* 7-bit data */
+
−      if (alphabet EQ 0x00)
+
−      {
+
−        tp_deliver->tp_udh_inc.length = septets + (((udh->len+1)*8)/7);
+
−
+
−        /* space for the fill bits */
+
−        if (((udh->len+1)*8)%7 NEQ 0) tp_deliver->tp_udh_inc.length++;
+
−      }
+
−      /* 8-bit data */
+
−      else
+
−      {
+
−        tp_deliver->tp_udh_inc.length = tp_deliver->tp_udh_inc.c_data;
+
−      }
+
−    }
+
−    else
+
−    {
+
−      tp_deliver->v_tp_ud = 1;
+
−      tp_deliver->tp_ud.length = septets;
+
−      tp_deliver->tp_ud.c_data = data->len;
+
−      memcpy(tp_deliver->tp_ud.data, data->data, data->len);
+
−    }
+
−  }
+
−  else /* if ((data) AND (data->len)) */
+
−  {
+
−    tp_deliver->v_tp_ud = 1;
+
−    tp_deliver->tp_ud.length = 0;
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT :                     MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_fillTpCommand       |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE : fills a T_TP_COMMAND
+
−
+
−*/
+
−GLOBAL void cmhSMS_fillTpCommand ( T_TP_COMMAND*   tp_command,
+
−                                   UBYTE           fo,
+
−                                   UBYTE           ct,
+
−                                   UBYTE           mr,
+
−                                   UBYTE           pid,
+
−                                   UBYTE           mn,
+
−                                   T_tp_da*        da_addr,
+
−                                   T_ACI_CMD_DATA* data,
+
−                                   T_ACI_UDH_DATA* udh)
+
−
+
−{
+
−  TRACE_FUNCTION ("cmhSMS_fillTpCommand()");
+
−
+
−  memset(tp_command, 0, sizeof(T_TP_COMMAND));
+
−
+
−  tp_command->tp_vt_mti = SMS_VT_COMMAND;
+
−  tp_command->tp_srr  = (fo & TP_SRR_MASK) ? 1 : 0;
+
−  tp_command->tp_mti = SMS_COMMAND;
+
−  tp_command->tp_mr = mr;
+
−  tp_command->tp_pid = pid;
+
−  tp_command->tp_ct = ct;
+
−  tp_command->tp_mn = mn;
+
−
+
−  if (da_addr->digits NEQ 0x00)
+
−    memcpy(&tp_command->tp_da, da_addr, sizeof(T_tp_da));
+
−
+
−  if ((data) AND (data->len))
+
−  {
+
−    if ((udh) AND (udh->len))
+
−    {
+
−      tp_command->tp_udhi = 1;
+
−      tp_command->v_tp_cdh_inc = 1;
+
−      tp_command->tp_cdh_inc.tp_udh.c_data = udh->len;
+
−      memcpy(tp_command->tp_cdh_inc.tp_udh.data, udh->data, udh->len);
+
−      tp_command->tp_cdh_inc.c_data = data->len;
+
−      memcpy(tp_command->tp_cdh_inc.data, data->data, data->len);
+
−    }
+
−    else
+
−    {
+
−      tp_command->v_tp_cd = 1;
+
−      tp_command->tp_cd.c_data = data->len;
+
−      memcpy(tp_command->tp_cd.data, data->data, data->len);
+
−    }
+
−  }
+
−  else
+
−  {
+
−    /* command length field must be present */
+
−    tp_command->v_tp_cd = 1;
+
−    tp_command->tp_cd.c_data = 0;
+
−  }
+
−
+
−}
+
−#ifdef FF_CPHS
+
−
+
−/*
+
−+----------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                   |
+
−|                                 ROUTINE : cmhSMS_check_voice_mail_ind|
+
−+----------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−*/
+
−
+
−LOCAL BOOL cmhSMS_check_voice_mail_ind( T_TP_DELIVER *sms_deliver )
+
−{
+
−  TRACE_FUNCTION("cmhSMS_check_voice_mail_ind()");
+
−
+
−  if ( sms_deliver->tp_oa.digits NEQ 4 OR
+
−       sms_deliver->tp_oa.ton NEQ SMS_TON_ALPHANUMERIC )
+
−  {
+
−    TRACE_EVENT_P2("no vmi -> oa... digits:%d ton:%d", 
+
−                    sms_deliver->tp_oa.digits, sms_deliver->tp_oa.ton);
+
−    return FALSE;
+
−  }
+
−
+
−  switch (sms_deliver->tp_dcs & 0xF0)
+
−  {
+
−    case SMS_DCS_GRP_DEF:
+
−    case SMS_DCS_GRP_CLASS:
+
−      if ( (sms_deliver->tp_dcs & 0xF) EQ 0 OR
+
−           (sms_deliver->tp_dcs & 0xF) EQ 0xC )
+
−      {
+
−        break;            /* GSM Default Alphabet */
+
−      }
+
−      /* no break, if FALSE */
+
−      /*lint -fallthrough*/
+
−    case SMS_DCS_GRP_COMPR:
+
−    case SMS_DCS_GRP_CLASS_COMPR:
+
−    case SMS_DCS_GRP_MW_STORE_UCS2:
+
−      TRACE_EVENT_P1("no vmi -> dcs: %d", sms_deliver->tp_dcs);
+
−      return FALSE;       /* no GSM Default Alphabet */
+
−    case SMS_DCS_DATA_CLASS:
+
−      if (sms_deliver->tp_dcs & 0x4)
+
−      {
+
−        TRACE_EVENT_P1("no vmi -> dcs: %d", sms_deliver->tp_dcs);
+
−        return FALSE;     /* no GSM Default Alphabet */
+
−      }
+
−  }
+
−
+
−  if (!sms_deliver->v_tp_ud)
+
−  {
+
−    TRACE_EVENT("no vmi -> no ud");
+
−    return FALSE;       /* not only text present */
+
−  }
+
−  if ( ( sms_deliver->tp_ud.length NEQ 1 ) OR
+
−       ( (sms_deliver->tp_ud.data[0] & 0x7F) NEQ ' ') )
+
−  {
+
−    TRACE_EVENT_P2("no vmi -> ud... length:%d data[0]:%d", 
+
−                    sms_deliver->tp_ud.length, sms_deliver->tp_ud.data[0]);
+
−    return FALSE;       /* no single space */
+
−  }
+
−  
+
−  TRACE_FUNCTION ("CPHS VWI: send to cphs module");
+
−
+
−  return TRUE;
+
−}
+
−
+
−
+
−/*
+
−+-------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                      |
+
−|                                 ROUTINE : cmhSMS_voice_mail_ind_get_line|
+
−+-------------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−*/
+
−LOCAL void cmhSMS_voice_mail_ind_get_data( T_TP_DELIVER *sms_deliver, 
+
−                                           UBYTE        *flag_set,
+
−                                           T_CPHS_LINES *line )
+
−{
+
−  TRACE_FUNCTION("cmhSMS_voice_mail_ind_get_line()");
+
−
+
−  /* get flag set, which is send in the first bit of the first
+
−     byte of the originating address number. Due to the decoding
+
−     each byte of the originating address number is now splitted
+
−     into 2 bytes, so that the first 4 bits of the former first 
+
−     byte can be found in byte 1 */
+
−  *flag_set = sms_deliver->tp_oa.num[0] & 0x1;
+
−
+
−  /* line is coded in character 1 bit 1 of second byte of GSM originating 
+
−     address based on 7bit default alphabet. In the message indication we 
+
−     get the data in the last bit of the first byte of the orginating address.
+
−     Due to the decoding each byte of the originating address number is now 
+
−     splitted into 2 bytes, so that the last 4 bits of the former first 
+
−     byte can be found in byte 2 */
+
−     
+
−  if (sms_deliver->tp_oa.num[1] & 0x8)
+
−
+
−  {
+
−    *line = CPHS_LINE2;
+
−  }
+
−  else
+
−  {
+
−    *line = CPHS_LINE1;
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                   |
+
−|                                 ROUTINE : cmhSMS_voice_mail_ind      |
+
−+----------------------------------------------------------------------+
+
−
+
−  PURPOSE : 
+
−*/
+
−
+
−GLOBAL BOOL cmhSMS_voice_mail_ind( T_sms_sdu *sms_sdu)
+
−{
+
−  T_TP_DELIVER *sms_deliver;
+
−  T_rp_addr rp_addr;
+
−  T_CPHS_LINES line;
+
−  UBYTE flag_set;
+
−  UBYTE *message;
+
−  
+
−  TRACE_FUNCTION("cmhSMS_voice_mail_ind()");
+
−
+
−  /* check if cphs is active */
+
−  
+
−
+
−  /* check if indication is voice mail indication */
+
−  if ( sms_sdu )
+
−  {   
+
−    message = cmhSMS_decodeMsg(sms_sdu, &rp_addr, SMS_VT_DELIVER);
+
−                 
+
−    if (message EQ NULL) 
+
−      return FALSE;
+
−
+
−    if ( message[0] NEQ SMS_VT_DELIVER)
+
−    {
+
−      TRACE_EVENT_P1("wrong VTI = %x", message[0]);
+
−    }
+
−
+
−    sms_deliver = (T_TP_DELIVER*)message;
+
−
+
−    if ( cphs_check_status() EQ CPHS_OK )
+
−    {
+
−      if ( cmhSMS_check_voice_mail_ind(sms_deliver) )
+
−      {
+
−        cmhSMS_voice_mail_ind_get_data(sms_deliver, &flag_set, &line);
+
−
+
−        cphs_voice_mail_ind(flag_set, line);
+
−
+
−        return TRUE;
+
−      }
+
−    }
+
−  }
+
−  return FALSE;
+
−}
+
−
+
−#endif /* FF_CPHS*/
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)         MODULE  : CMH_SMSF                   |
+
−|                                 ROUTINE : cmhSMS_resetMtDsCnmiParam  |
+
−+----------------------------------------------------------------------+
+
−  PURPOSE : this function resets the <mt> and <ds> parameter for the
+
−            SMS acknowledge in Phase2+ mode (+CNMA).
+
−*/
+
−GLOBAL void cmhSMS_resetMtDsCnmiParam(void)
+
−{
+
−    smsShrdPrm.mtHndl = 0; /* reset <mt> and <ds> param in error case */
+
−    smsShrdPrm.srHndl = 0;
+
−
+
−    smsShrdPrm.CNMImt = CNMI_MT_NoSmsDeliverInd;
+
−    smsShrdPrm.CNMIds = CNMI_DS_NoSmsStatRpt;
+
−    /* Implements measure 149 */
+
−    cmhSMS_sendConfigureReq (FALSE);
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSS                     |
+
−| STATE   : code             ROUTINE : sAT_PlusCMGWPdu              |
+
−+-------------------------------------------------------------------+
+
−
+
−  PURPOSE : This is the internal function which is responsible for 
+
−            storing messages into the mobile station or SIM card.
+
−            AT command which is responsible for writing a short
+
−            message to memory in PDU mode.
+
−*/
+
−GLOBAL BOOL cmhSMS_storePduToSim( T_ACI_CMD_SRC  srcId,
+
−                                      UBYTE          stat,
+
−                                      T_ACI_SM_DATA  *pdu )
+
−{
+
−  T_ACI_RETURN  ret;
+
−
+
−  TRACE_FUNCTION ("cmhSMS_storePduToSim()");
+
−
+
−  /* check if command executable */
+
−  if(!cmhSMS_checkAccess (srcId, &ret))
+
−  {
+
−    return FALSE;
+
−  }
+
−
+
−  {
+
−    PALLOC (mnsms_store_req, MNSMS_STORE_REQ);
+
−
+
−    mnsms_store_req -> mem_type  = smsShrdPrm.mem2;
+
−    mnsms_store_req -> rec_num   = CMGW_IDX_FREE_ENTRY;
+
−    mnsms_store_req -> condx     = SMS_CONDX_OVR_NON;
+
−    mnsms_store_req -> status    = stat;
+
−
+
−    if ( (pdu->len > 0) AND (pdu->len <= SIM_PDU_LEN) )
+
−    {
+
−      mnsms_store_req->sms_sdu.l_buf = pdu->len * 8;
+
−      mnsms_store_req->sms_sdu.o_buf = 0;
+
−      memcpy (mnsms_store_req->sms_sdu.buf, pdu->data, pdu->len);
+
−    }
+
−    else
+
−    {
+
−      TRACE_FUNCTION ("cmhSMS_storePduToSim() : wrong PDU len");
+
−      PFREE (mnsms_store_req);
+
−      return FALSE;
+
−    }
+
−
+
−    PSENDX (SMS, mnsms_store_req);
+
−  }
+
−
+
−  smsShrdPrm.smsEntStat.curCmd    = AT_CMD_CMGW;
+
−  smsShrdPrm.owner = (T_OWN)srcId;
+
−  smsShrdPrm.smsEntStat.entOwn    = srcId;
+
−  smsShrdPrm.uiInternalSmsStorage = srcId;
+
−
+
−  return TRUE;
+
−}
+
−
+
−/*
+
−+--------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                   |
+
−| STATE   : code                ROUTINE : cmhSMS_removeStatusRFUBits |
+
−+--------------------------------------------------------------------+
+
−
+
−  PURPOSE :  ACI-SPR-17004: Method for removing of SMS RFU status 
+
−  bits as defined by GSM 11.11 section 9.3
+
−  
+
−*/
+
−GLOBAL void cmhSMS_removeStatusRFUBits  ( UBYTE* status )
+
−{
+
−  TRACE_FUNCTION("cmhSMS_removeStatusRFUBits()");
+
−
+
−  /* See GSM 11.11 section 10.5.3 for position of RFU bits in status */
+
−
+
−  /* test the pattern of the three lowest bits, match for "101" */ 
+
−  if ((*status & 0x07) EQ 0x05)
+
−  {
+
−    /* set the highest three bits to 0 */
+
−    *status &= 0x1F; 
+
−  } 
+
−  else
+
−  {
+
−    /* set the highest five bits to 0 */
+
−    *status &= 0x07; 
+
−  }
+
−
+
−}
+
−
+
−/*
+
−+-------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                        |
+
−| STATE   : code                ROUTINE : cmhSMS_convertDeliverStatusToACI|
+
−+-------------------------------------------------------------------------+
+
−
+
−  PURPOSE :  converts the SMS delivery status to ACI CPRSM status.
+
−  
+
−*/
+
−GLOBAL  T_ACI_CPRSM_MOD cmhSMS_convertDeliverStatusToACI ( UBYTE status )
+
−{
+
−  T_ACI_CPRSM_MOD mode;
+
−  
+
−  TRACE_FUNCTION("cmhSMS_convertDeliverStatusToACI()");
+
−
+
−  switch (status)
+
−  {
+
−    case SMS_DELIVER_STATUS_PAUSE:
+
−      mode = CPRSM_MOD_Pause;
+
−      break;
+
−    case SMS_DELIVER_STATUS_RESUME:      
+
−      mode = CPRSM_MOD_Resume;
+
−      break;
+
−    default:
+
−      mode = CPRSM_MOD_NotPresent;
+
−  }  
+
−  return mode;
+
−}
+
−
+
−#ifdef FF_CPHS_REL4
+
−/*
+
−+-------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                        |
+
−| STATE   : code                ROUTINE : cmhSMS_chk_WtngInd              |
+
−+-------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function expect an already decoded SMS in the T_TP_DELIVER 
+
−            format and checks if it is a "special SMS" (refer to TS 23.040, 
+
−            chpt. 9.2.3.24.2).
+
−
+
−*/
+
−LOCAL BOOL cmhSMS_chk_WtngInd( T_TP_DELIVER *pSms )
+
−{
+
−
+
− TRACE_FUNCTION("cmhSMS_chk_WtngInd");
+
−  return ( (pSms->tp_udhi)                        AND /* it is an UDH message */
+
−           (pSms->v_tp_udh_inc)                   AND /* UDH successfuly decoded */
+
−           (pSms->tp_udh_inc.tp_udh.c_data >= 4)  AND /* min len of special SMS */
+
−           (pSms->tp_udh_inc.tp_udh.data[0] EQ 0x01)
+
−         ); 
+
−}
+
−
+
−
+
−/*
+
−+-------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : CMH_SMSF                        |
+
−| STATE   : code                ROUTINE : cmhSMS_chk_SpclMsg              |
+
−+-------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function checks if the received SMS is a special sms which
+
−  indicates the message waiting status.If so,the message will be  processed
+
−  and TRUE will be returned,indicating that the message was already handled.
+
−  If it is no special message , the function will returns FALSE causing the
+
−  SMS to be treated in the common way.
+
−
+
−*/
+
−
+
−GLOBAL BOOL cmhSMS_chk_SpclMsg( T_MNSMS_MESSAGE_IND *mnsms_message_ind )
+
−{
+
−  BOOL res    = FALSE ;
+
−  T_MSG_WAITING_TYPE msgType = MSG_WAITING_TYPE_INVALID;
+
−  U8 *ptr;
+
−  T_TP_DELIVER *smDlvr;
+
−
+
−  TRACE_FUNCTION( "cmhSMS_chk_SpclMsg()" );
+
−
+
−  if(!psaSIM_ChkSIMSrvSup( SRV_No_54 ))
+
−  {
+
−    return res;
+
−  }
+
−
+
−  if (&mnsms_message_ind->sms_sdu)
+
−  {
+
−    T_rp_addr rpAddr;
+
−    UBYTE     *pMsg;
+
−
+
−    pMsg = cmhSMS_decodeMsg( &mnsms_message_ind->sms_sdu, &rpAddr, SMS_VT_DELIVER );
+
−    smDlvr = (T_TP_DELIVER *)pMsg;
+
−
+
−    if (pMsg)
+
−    {
+
−      if (pMsg[0] NEQ SMS_VT_DELIVER)
+
−      {
+
−        TRACE_EVENT_P1( "wrong VTI = %x", (int)pMsg[0] );
+
−      }
+
−      
+
−      /* Check the reqired fields in the SMS to qaulify for Special Message */
+
−
+
−      if (cmhSMS_chk_WtngInd( smDlvr ))
+
−      {
+
−
+
−        /* For Loop: Decode the SMS properly as ,more than one type of message
+
−           can   be   indicated    within   one   SMS  message. A  varible for 
+
−           tp_udh_inc.tp_udh.data  has  been  avoided ,   therefore  For  loop 
+
−           seems to be lengthy,
+
−        */
+
−        for( ptr = smDlvr->tp_udh_inc.tp_udh.data ;
+
−             ptr < &smDlvr->tp_udh_inc.tp_udh.data[smDlvr->tp_udh_inc.tp_udh.c_data ];
+
−             ptr +=(ptr[1] + 2 ))
+
−             {
+
−               /* Filling the Message Type */
+
−
+
−               msgType  = (ptr[2] & 0x03);             /* see TS 23.040 */
+
−
+
−               /* Update Status field in EF-MWIS according to the values already
+
−                  present in the SIM and the current values in the recieved  SMS.
+
−                  Also  if  the count for any type of Special SMS is  ZERO  then
+
−                  also update the status.
+
−               */
+
−               if( (!(smsShrdPrm.MWISdata.mwiStat >> msgType & 1U)) OR (ptr[3] EQ 0) )
+
−                 {
+
−                   smsShrdPrm.MWISdata.mwiStat ^= 1U << msgType;
+
−                 }
+
−
+
−               /* Filling the count for specfic type of SMS  */
+
−
+
−               switch ( msgType )
+
−               {
+
−                 case MSG_WAITING_TYPE_VOICE :
+
−                   smsShrdPrm.MWISdata.mwis_count_voice = ptr[3];
+
−                   break;
+
−                 case MSG_WAITING_TYPE_FAX :
+
−                   smsShrdPrm.MWISdata.mwis_count_fax = ptr[3];
+
−                   break;
+
−                 case MSG_WAITING_TYPE_EMAIL :
+
−                   smsShrdPrm.MWISdata.mwis_count_email = ptr[3];
+
−                   break;
+
−                 case MSG_WAITING_TYPE_OTHER :
+
−                   smsShrdPrm.MWISdata.mwis_count_other = ptr[3];
+
−                   break;
+
−                 default:
+
−                   TRACE_EVENT("INVALID MESSAGE TYPE");
+
−                   return FALSE;
+
−               }
+
−             }
+
−
+
−             /* Writing decoded data to EF-MWIS  */
+
−
+
−             if(cmhSIM_WrMwis(CMD_SRC_NONE,MWIS_MOD_Write,1,
+
−                &smsShrdPrm.MWISdata) NEQ AT_EXCT )
+
−             {
+
−               TRACE_EVENT(" Error in Sending the Sim Update Request ");
+
−             }
+
−
+
−        /* If message was stored we need to indicate this, too */
+
−
+
−        if (mnsms_message_ind->rec_num NEQ SMS_RECORD_NOT_EXIST) 
+
−        {
+
−          cmhSMS_SMSMemory( mnsms_message_ind );
+
−        }  
+
−        res = TRUE; /* message processed, nothing left to do */
+
−      }
+
−    }
+
−  }
+
−  return res;
+
−}
+
−#endif
+
−/* Implements Measure # 73 */
+
−
+
−/*
+
−+-------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)    MODULE  : CMH_SMSF                     |
+
−|                            ROUTINE : cmhSMS_findMessageIds        |
+
−+-------------------------------------------------------------------+
+
−  PARAMETERS  : lower_mid - lower message id
+
−                upper_mid - upper message id
+
−  RETURN      : TRUE if message has been found, else FALSE
+
−
+
−  PURPOSE : Find message ids based on the mids given as parameters and 
+
−            update smsShrdPrm.cbmPrm.cbmFoundIds based on the same.
+
−
+
−*/
+
−LOCAL BOOL cmhSMS_findMessageIds (USHORT lower_mid, USHORT upper_mid)
+
−{
+
−  TRACE_FUNCTION("cmhSMS_findMessageIds()");
+
−  /*
+
−   * If the msg ids are same that in FFS and SIM, then restore else reset
+
−   * to default values
+
−   */
+
−  if (smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2] EQ lower_mid
+
−    AND smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1] EQ upper_mid)
+
−  {
+
−    smsShrdPrm.cbmPrm.cbmFoundIds++;
+
−  }
+
−  else
+
−  {
+
−    cmhSMS_clearCbmPrm();     
+
−    return FALSE;
+
−  }
+
−  return TRUE;
+
−}
+
−
+
−/* Implements Measure # 126 */
+
−/*
+
−+---------------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF                  |
+
−| STATE   : code                        ROUTINE : cmhSMS_processOrigDestAddr|
+
−+---------------------------------------------------------------------------+
+
−  PARAMETERS  : sm - Structure into which the data is filled. 
+
−                rp_addr - RP Address used for filling sm
+
−                tp_addr - destination or origination address that has to be 
+
−                          filled in sm  
+
−  RETURN      : None
+
−
+
−  PURPOSE : Processes originator address and converts it into 8 bit or string
+
−            format as requried
+
−
+
−*/
+
−LOCAL void cmhSMS_processOrigDestAddr (T_ACI_CMGL_SM  *sm, 
+
−                                       T_rp_addr      *rp_addr,
+
−                                       T_tp_da        *tp_addr)
+
−{
+
−  TRACE_FUNCTION("cmhSMS_processOrigDestAddr()");
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process address
+
−   *-----------------------------------------------------------------
+
−   */
+
−  if (tp_addr->ton EQ SMS_TON_ALPHANUMERIC)
+
−  {
+
−    UBYTE i,j = 0;
+
−    UBYTE dest_len;
+
−    CHAR address_buf[MAX_SMS_ADDR_DIG/2];
+
−
+
−    for (i = 0 ; i < tp_addr->digits ; i=i+2)
+
−    {
+
−      address_buf[j] = (UBYTE)(tp_addr->num[i+1] << 4) + (UBYTE)(tp_addr->num[i]);
+
−      j++;
+
−    }
+
−
+
−    if( tp_addr->digits % 2 )
+
−    {
+
−      address_buf[j-1] = address_buf[j-1] & 0x0f;
+
−    }
+
−
+
−    dest_len = utl_cvt7To8 ( (UBYTE*)address_buf, j, (UBYTE*)sm->adress, 0);
+
−    sm -> adress[dest_len] = '\0';
+
−
+
−    if( (tp_addr->digits % 2) AND (dest_len + 3) % 8 >= 4 )
+
−      sm -> adress[dest_len--] = '\0';
+
−    else
+
−      sm -> adress[dest_len] = '\0';
+
−
+
−  }
+
−  else
+
−  {
+
−    cmhSMS_getAdrStr ( sm -> adress,
+
−                       MAX_SMS_NUM_LEN - 1,
+
−                       tp_addr->num,
+
−                       tp_addr->digits );
+
−  }
+
−  sm -> toa.ton = cmhSMS_getTon ( tp_addr->ton );
+
−  sm -> toa.npi = cmhSMS_getNpi ( tp_addr->npi );
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process service center address
+
−   *-----------------------------------------------------------------
+
−   */
+
−  cmhSMS_getAdrStr ( sm -> sca,
+
−                     MAX_SMS_NUM_LEN - 1,
+
−                     rp_addr->num,
+
−                     rp_addr->c_num);
+
−
+
−  sm -> tosca.ton = cmhSMS_getTon ( rp_addr->ton );
+
−  sm -> tosca.npi = cmhSMS_getNpi ( rp_addr->npi );
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process alphanumerical phonebook entry
+
−   *-----------------------------------------------------------------
+
−   */
+
−  psaCC_phbMfwSrchNumPlnTxt ( sm -> adress, &sm -> alpha );
+
−}
+
−
+
−/* Implements Measure # 149 */
+
−/*
+
−+---------------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF                  |
+
−| STATE   : code                        ROUTINE : cmhSMS_sendConfigureReq   |
+
−+---------------------------------------------------------------------------+
+
−  PARAMETERS  : v_cmms_val - Set to TRUE if cmms_mode and tmms_val has to be 
+
−                             filled.
+
−  RETURN      : None
+
−
+
−  PURPOSE : Sends mnsms_configure_req to inform the SMS entity 
+
−            about the parameter changes. v_cmms_val is TRUE if cmms_mode and 
+
−            tmms_val has to be filled.
+
−
+
−*/
+
−GLOBAL void cmhSMS_sendConfigureReq (BOOL v_cmms_val)
+
−{
+
−  TRACE_FUNCTION("cmhSMS_sendConfigureReq()");
+
−  { /* inform the SMS entity about the parameter changes */
+
−    PALLOC (mnsms_configure_req, MNSMS_CONFIGURE_REQ);
+
−
+
−    /* fill in primitive parameter: command request */
+
−    mnsms_configure_req -> pref_mem_3 = smsShrdPrm.mem3;
+
−    mnsms_configure_req -> mt         = smsShrdPrm.mtHndl;
+
−    mnsms_configure_req -> ds         = smsShrdPrm.srHndl;
+
−    mnsms_configure_req -> mhc        = (smsShrdPrm.CSMSservice NEQ CSMS_SERV_GsmPh2Plus)
+
−                                        ? SMS_MHC_PH2 : SMS_MHC_PH2PLUS;
+
−    mnsms_configure_req->v_cmms_mode = mnsms_configure_req->v_tmms_val = 
+
−                                                              v_cmms_val;
+
−    if(v_cmms_val)
+
−    {
+
−      mnsms_configure_req -> cmms_mode = smsShrdPrm.CMMSmode;
+
−      mnsms_configure_req->tmms_val = CMMS_MODE_TIMER_VAL;
+
−    }
+
−
+
−    PSENDX (SMS, mnsms_configure_req);
+
−  }
+
−}
+
−
+
−/* Implements Measure # 110 */
+
−/*
+
−+---------------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF                  |
+
−| STATE   : code                        ROUTINE : cmhSMS_cpyMsgIndReadCnf   |
+
−+---------------------------------------------------------------------------+
+
−  PARAMETERS  : sm - Structure into which the data is filled.
+
−                status - SMS record status
+
−                sms_sdu - SMS SDU from which data has to be filled in sm
+
−                rec_num - Record number of the SMS
+
−  RETURN      : BOOL value indicating the status returned by cmhSMS_cpyDeliver 
+
−                or cmhSMS_cpySubmit
+
−
+
−  PURPOSE : handles a message indication or a read cnf
+
−
+
−*/
+
−GLOBAL BOOL cmhSMS_cpyMsgIndReadCnf (T_ACI_CMGL_SM  * sm, 
+
−                                     UBYTE          *status, 
+
−                                     T_sms_sdu      *sms_sdu,
+
−                                     UBYTE          rec_num)
+
−{
+
−  BOOL ret = FALSE;
+
−  TRACE_FUNCTION("cmhSMS_cpyMsgIndReadCnf()");
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * decode SMS-DELIVER or SMS-SUBMIT
+
−   *-----------------------------------------------------------------
+
−   */
+
−
+
−  /* 
+
−   * 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( status );  
+
−   
+
−  switch (*status)
+
−  {
+
−    case SMS_RECORD_REC_UNREAD:
+
−    case SMS_RECORD_REC_READ:
+
−      ret = cmhSMS_cpyDeliver ( sm, sms_sdu );
+
−      break;
+
−    case SMS_RECORD_STO_UNSENT:
+
−    case SMS_RECORD_STO_SENT:
+
−    /* ACI-SPR-17003: Handle unsupported statuses */  
+
−    case SMS_RECORD_STAT_UNRCVD: 
+
−    case SMS_RECORD_STAT_UNSTRD:
+
−    case SMS_RECORD_STAT_STRD:            
+
−      ret = cmhSMS_cpySubmit ( sm, sms_sdu );
+
−      break;
+
−    /* 21.Mar.2003 currently not used by SMS entity */
+
−    /* 
+
−     * case SMS_RECORD_INVALID: 
+
−     *  ret = FALSE;
+
−     *  break;
+
−     */
+
−    default:
+
−      TRACE_EVENT("incorrect status");
+
−  }
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process status (convert from PSA type to CMH type)
+
−   *-----------------------------------------------------------------
+
−   */
+
−  if (sm->stat NEQ SMS_STAT_Invalid)
+
−  {
+
−     cmhSMS_getStatCmh ( *status, &sm -> stat );
+
−  }
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process message reference
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm -> msg_ref = rec_num;
+
−
+
−  /*
+
−   *-----------------------------------------------------------------
+
−   * process tp_status
+
−   *-----------------------------------------------------------------
+
−   */
+
−  sm ->tp_status = (UBYTE) -1;
+
−  
+
−  return (ret);
+
−}
+
−
+
−/* Implements Measure # 9 */
+
−/*
+
−+---------------------------------------------------------------------------+
+
−| PROJECT : GSM-F&D (8411)              MODULE  : CMH_SMSF                  |
+
−| STATE   : code                        ROUTINE : cmhSMS_clearCbmPrm        |
+
−+---------------------------------------------------------------------------+
+
−  PARAMETERS  : None
+
−  RETURN      : None
+
−
+
−  PURPOSE : Resets smsShrdPrm.cbmPrm to default values
+
−
+
−*/
+
−LOCAL void cmhSMS_clearCbmPrm (void)
+
−{
+
−  TRACE_FUNCTION("cmhSMS_clearCbmPrm()");
+
−
+
−  smsShrdPrm.cbmPrm.cbmMode = CBCH_ACCEPT;
+
−  memset (smsShrdPrm.cbmPrm.msgId, DEF_MID_RANGE,
+
−          sizeof (smsShrdPrm.cbmPrm.msgId));
+
−  memset (smsShrdPrm.cbmPrm.dcsId, DEF_DCS_RANGE, 
+
−          sizeof(smsShrdPrm.cbmPrm.dcsId));
+
−}
+
−/*==== EOF ========================================================*/