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

initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/g23m/condat/ms/src/aci/ati_sms.c	Mon Jun 01 03:24:05 2015 +0000
@@ -0,0 +1,3765 @@
+/*
++----------------------------------------------------------------------------- 
+|  Project :  GSM-F&D (8411)
+|  Modul   :  ATI
++----------------------------------------------------------------------------- 
+|  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 :  AT Command Interpreter: SMS related functions.
++----------------------------------------------------------------------------- 
+*/ 
+
+#ifndef ATI_SMS_C
+#define ATI_SMS_C
+
+#undef DUMMY_ATI_STRINGS
+
+#include "aci_all.h"
+
+#include "aci_cmh.h"
+#include "ati_cmd.h"
+#include "aci_io.h"
+#include "aci_cmd.h"
+#include "l4_tim.h"
+
+#include "aci_mem.h"
+
+#include "aci_lst.h"
+#include "conc_sms.h"
+#include "aci_prs.h"
+
+#include "ati_int.h"
+
+#include "cmh_sms.h"
+#include "psa.h"
+#include "psa_sms.h"
+#include "aci.h"
+
+#ifdef FF_ATI_BAT
+
+#include "typedefs.h"
+#include "gdd.h"
+#include "bat.h"
+
+#include "ati_bat.h"
+
+#endif /*FF_ATI_BAT*/
+
+EXTERN T_SMS_SHRD_PRM smsShrdPrm;
+
+const SMS_Memory sms_mem [] =
+{
+  {"ME",  SMS_STOR_Me},
+  {"SM",  SMS_STOR_Sm},
+  {0,0}
+};
+
+#if defined (SMS_PDU_SUPPORT)
+LOCAL T_ATI_RSLT atPlusCMGSText (char *cl, UBYTE srcId);
+LOCAL T_ATI_RSLT atPlusCMGWText (char *cl, UBYTE srcId);
+LOCAL T_ATI_RSLT atPlusCMGCText (char *cl, UBYTE srcId);
+LOCAL T_ATI_RSLT atPlusCNMAText (char *cl, UBYTE srcId);
+#endif
+
+/* move the define into aci_cmd.h */
+
+GLOBAL void         cmd_clearCnmiBuf    (void);
+
+LOCAL  T_CNMI_BUFFER    cnmiBuf;
+GLOBAL BOOL             cnmiFlushInProgress   = FALSE;
+GLOBAL S16              waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE;
+LOCAL  CHAR daBuf[MAX_SMS_NUM_LEN];
+
+EXTERN SHORT  cmhSMS_getPrfRge ( void );
+EXTERN BOOL check_str(char * string,char * sample);
+
+#ifdef _SIMULATION_
+GLOBAL char subBuf[MAX_SUBADDR_LEN];
+#endif /* _SIMULATION_ */
+
+GLOBAL SHORT  toda_val;
+GLOBAL SHORT  fo, ct, pid, mn;
+
+GLOBAL UBYTE  cpmsCallType = NONE_CALL;
+
+/*
+ *
+ ----------------------------SMS Commands-----------------------------------
+ *
+ */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCSMS         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CSMS command (Select Message Service)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCSMS (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN ret = AT_FAIL;
+  T_ACI_CSMS_SERV service;
+
+  TRACE_FUNCTION("atPlusCSMS()");
+
+  /*input functionality*/
+  cl = parse (cl,"d",&service);
+  if ( !cl OR service > 1)
+  {
+    cmdCmsError(CMS_ERR_OpNotAllowed);
+    return (ATI_FAIL);
+  }
+  ret = sAT_PlusCSMS(srcId,service);
+  if (ret EQ AT_FAIL)
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+  return (ATI_CMPL);
+}
+
+GLOBAL T_ATI_RSLT queatPlusCSMS (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN ret = AT_FAIL;
+  T_ACI_CSMS_SERV service;
+  T_ACI_CSMS_SUPP mt;
+  T_ACI_CSMS_SUPP mo;
+  T_ACI_CSMS_SUPP bm;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+
+  ret = qAT_PlusCSMS(srcId,&service,&mt,&mo,&bm);
+  if (ret EQ AT_CMPL)
+  {
+    sprintf(g_sa,"+CSMS: %d,%d,%d,%d",service,mt,mo,bm);
+    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
+    return (ATI_CMPL);
+  }
+  if (ret EQ AT_EXCT)
+  {
+    src_params->curAtCmd    = AT_CMD_CSMS;
+    return (ATI_EXCT);
+  }
+  else
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCPMS         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CPMS command (Select Preferred Message Storage)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCPMS (char *cl, UBYTE srcId)
+{
+  CHAR*              me         = "+CPMS: ";
+  CHAR               memstr1[3] = {0};
+  CHAR               memstr2[3] = {0};
+  CHAR               memstr3[3] = {0};
+  T_ACI_RETURN       ret = AT_FAIL;
+  T_ACI_SMS_STOR_OCC mem1;
+  T_ACI_SMS_STOR_OCC mem2;
+  T_ACI_SMS_STOR_OCC mem3;
+  BOOL               f1         = TRUE;
+  BOOL               f2         = TRUE;
+  BOOL               f3         = TRUE;
+  SHORT              i;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("atPlusCPMS()");
+
+  mem1.mem = SMS_STOR_NotPresent;
+  mem2.mem = SMS_STOR_NotPresent;
+  mem3.mem = SMS_STOR_NotPresent;
+
+  /*input functionality*/
+  cl = parse ( cl, "sss", (LONG)3, memstr1,
+                          (LONG)3, memstr2,
+                          (LONG)3, memstr3 );
+
+  strupper ( memstr1 );
+  strupper ( memstr2 );
+  strupper ( memstr3 );
+
+  for ( i=0; sms_mem[i].name NEQ NULL; i++ )
+  {
+    if ( ( strcmp ( sms_mem[i].name, memstr1 ) EQ 0 ) AND f1 )
+    {
+      mem1.mem = sms_mem[i].stor;
+      f1       = FALSE;
+    }
+
+    if ( ( strcmp ( sms_mem[i].name, memstr2 ) EQ 0 ) AND f2 )
+    {
+      mem2.mem = sms_mem[i].stor;
+      f2       = FALSE;
+    }
+
+    if ( ( strcmp ( sms_mem[i].name, memstr3 ) EQ 0 ) AND f3 )
+    {
+      mem3.mem = sms_mem[i].stor;
+      f3       = FALSE;
+    }
+  }
+
+  if (!cl OR f1 /*OR f2 OR f3*/ )
+  {
+    cmdCmsError ( CMS_ERR_OpNotAllowed );
+    return (ATI_FAIL);
+  }
+
+#ifdef FF_ATI_BAT
+{
+  T_BAT_cmd_send     cmd;
+  T_BAT_cmd_set_plus_cpms cpms;
+  cmd.ctrl_params              = BAT_CMD_SET_PLUS_CPMS;
+  cmd.params.ptr_set_plus_cpms = &cpms;
+
+  cpms.mem1 = (T_BAT_plus_cpms_mem1)mem1.mem;
+  cpms.mem2 = (T_BAT_plus_cpms_mem2)mem2.mem;
+  cpms.mem3 = (T_BAT_plus_cpms_mem3)mem3.mem;
+  
+  TRACE_FUNCTION("atPlusCPMS() calls bat_send() <=== as APPLICATION");
+  bat_send(ati_bat_get_client(srcId), &cmd);
+
+  return (AT_EXCT);
+}
+#else /* FF_ATI_BAT */
+
+  ret = sAT_PlusCPMS ( srcId, mem1.mem, mem2.mem, mem3.mem );
+
+  switch(ret)
+  {
+    case(AT_CMPL):
+    {
+      src_params->curAtCmd     = AT_CMD_NONE;
+      return (ATI_CMPL);
+    }
+    default:
+    {
+      cmdCmsError (CMS_ERR_NotPresent);  // use aciErrDesc
+      return (ATI_FAIL);
+    }
+  }
+  #endif /* FF_ATI_BAT */
+}
+
+GLOBAL T_ATI_RSLT queatPlusCPMS (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN       ret;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  /*returns current Memory setting*/
+  ret = qAT_PlusCPMS ( srcId );
+
+  if ( ret EQ AT_CMPL )
+  {
+    src_params->curAtCmd     = AT_CMD_NONE;
+    return (ATI_CMPL);
+  }
+  else if ( ret EQ AT_EXCT )
+  {
+    src_params->curAtCmd     = AT_CMD_CPMS;
+    return (ATI_EXCT);
+  }
+  else
+  {
+    cmdCmsError ( CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCMGF         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMGF command (Select Message Format)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCMGF (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN ret = AT_FAIL;
+  T_ACI_CMGF_MOD mode=CMGF_MOD_NotPresent;
+
+  TRACE_FUNCTION("atPlusCMGF()");
+
+  /*
+   * input functionality
+   */
+  cl = parse(cl,"d",&mode);
+  if ( cl)
+  {
+    switch (mode)
+    {
+      case CMGF_MOD_Pdu:  /* PDU mode */
+#if !defined (SMS_PDU_SUPPORT)
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return (ATI_FAIL);
+#else
+         break;
+#endif
+       case CMGF_MOD_Txt:  /* Text Mode */
+       default:
+         break;
+     }
+   }
+   else
+   {
+     /*
+      * parse problems
+      */
+     cmdCmsError(CMS_ERR_OpNotAllowed);
+     return (ATI_FAIL);
+   }
+   /*
+    * Parameter is allowed then set
+    */
+   ret = sAT_PlusCMGF (srcId,mode);
+   if (ret EQ AT_FAIL)
+   {
+     cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+     return (ATI_FAIL);
+   }
+   return (map_aci_2_ati_rslt(ret));
+}
+
+GLOBAL T_ATI_RSLT queatPlusCMGF (char *cl, UBYTE srcId)
+{
+  char *me="+CMGF: ";
+  T_ACI_RETURN ret = AT_FAIL;
+  T_ACI_CMGF_MOD mode=CMGF_MOD_NotPresent;
+
+  TRACE_FUNCTION("queatPlusCMGF()");
+
+  /*
+   * returns current message format PDU/TEXT
+   */
+  ret = qAT_PlusCMGF(srcId, &mode);
+  if (ret EQ AT_CMPL)
+  {
+    sprintf(g_sa,"%s%d",me,mode);
+    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
+    return (ATI_CMPL);
+  }
+  else
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCSCA         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CSCA command (Select Message Service Centre)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCSCA (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN  ret = ATI_FAIL;
+  T_ACI_TOA     tosca;
+  T_ACI_TOA    *p_tosca;
+  SHORT         octet=0;
+  CHAR          sca[MAX_SMS_NUM_LEN];
+
+  memset (sca, 0, sizeof(sca));
+  p_tosca=&tosca;
+
+  TRACE_FUNCTION("atPlusCSCA()");
+
+  /*input functionality*/
+  cl = parse (cl,"sr",(LONG)MAX_SMS_NUM_LEN,sca,&octet);
+  if ( !cl OR octet > 0xC9 OR sca[0] EQ '\0')
+    {
+      cmdCmsError(CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+    }
+  if(octet EQ 0)
+    p_tosca=NULL;
+  else
+  {
+    tosca=toa_demerge(octet);
+    if (tosca.ton < 0 OR tosca.npi < 0)
+    {
+      cmdCmsError(CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+    }
+  }
+#ifdef FF_ATI_BAT
+{
+  T_BAT_cmd_send     cmd;
+  T_BAT_cmd_set_plus_csca csca;
+  
+  cmd.ctrl_params              = BAT_CMD_SET_PLUS_CSCA;
+  cmd.params.ptr_set_plus_csca = &csca;
+
+  csca.c_sca = strlen(sca);  
+  memcpy(csca.sca, sca, csca.c_sca);
+  csca.tosca = octet;  
+
+  TRACE_FUNCTION("atPlusCSCA() calls bat_send() <=== as APPLICATION");
+  bat_send(ati_bat_get_client(srcId), &cmd);
+
+  return (AT_EXCT);
+}
+#else /* FF_ATI_BAT */
+ 
+  ret = sAT_PlusCSCA(srcId,sca,p_tosca);
+  if (ret EQ AT_FAIL)
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+  return (map_aci_2_ati_rslt(ret));
+#endif /* FF_ATI_BAT */
+}
+
+GLOBAL T_ATI_RSLT queatPlusCSCA (char *cl, UBYTE srcId)
+{
+#ifdef FF_ATI_BAT
+  T_BAT_cmd_send     cmd;
+  T_BAT_no_parameter dummy;
+  
+  cmd.ctrl_params              = BAT_CMD_QUE_PLUS_CSCA;
+  dummy.bat_dummy              = 0xFF;
+  cmd.params.ptr_que_plus_csca = &dummy;
+
+  TRACE_FUNCTION("queatPlusCSCA() calls bat_send() <=== as APPLICATION");
+  bat_send(ati_bat_get_client(srcId), &cmd);
+
+  return (AT_EXCT);
+
+#else /* FF_ATI_BAT */
+
+  T_ACI_RETURN  ret = AT_FAIL;
+  T_ACI_TOA     tosca;
+  SHORT         octet=0;
+  CHAR          sca[MAX_SMS_NUM_LEN];
+
+  ret = qAT_PlusCSCA (srcId,sca,&tosca);
+  if (ret EQ AT_CMPL)
+  {
+    octet=toa_merge(tosca);
+    sprintf(g_sa, "+CSCA: \"%s%s\",%d", (tosca.ton EQ TON_International)?"+":"", sca, octet);
+    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
+    return (ATI_CMPL);
+  }
+  else
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+#endif /* FF_ATI_BAT */  
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : aci_decodeVpabs    |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function decodes a given string to the T_ACI_VP_ABS
+            enumeration type.
+*/
+LOCAL BOOL aci_decodeVpabs ( CHAR*         vpabs_str,
+                             T_ACI_VP_ABS* vpabs_enum )
+{
+  if ( strlen( vpabs_str ) NEQ 20 OR
+
+       vpabs_str[2]  NEQ '/' OR vpabs_str[5]  NEQ '/' OR
+       vpabs_str[8]  NEQ ',' OR vpabs_str[11] NEQ ':' OR
+       vpabs_str[14] NEQ ':' OR
+
+       ( vpabs_str[17] NEQ '+' AND vpabs_str[17] NEQ '-' ) OR
+
+       vpabs_str[18] < '0' OR vpabs_str[18] > '9' OR
+       vpabs_str[19] < '0' OR vpabs_str[19] > '9'             )
+
+    return FALSE;
+
+  vpabs_enum->year  [0] = vpabs_str[0]  - 0x30;
+  vpabs_enum->year  [1] = vpabs_str[1]  - 0x30;
+
+  vpabs_enum->month [0] = vpabs_str[3]  - 0x30;
+  vpabs_enum->month [1] = vpabs_str[4]  - 0x30;
+
+  vpabs_enum->day   [0] = vpabs_str[6]  - 0x30;
+  vpabs_enum->day   [1] = vpabs_str[7]  - 0x30;
+
+  vpabs_enum->hour  [0] = vpabs_str[9]  - 0x30;
+  vpabs_enum->hour  [1] = vpabs_str[10] - 0x30;
+
+  vpabs_enum->minute[0] = vpabs_str[12] - 0x30;
+  vpabs_enum->minute[1] = vpabs_str[13] - 0x30;
+
+  vpabs_enum->second[0] = vpabs_str[15] - 0x30;
+  vpabs_enum->second[1] = vpabs_str[16] - 0x30;
+
+  vpabs_enum->timezone  = (SHORT) atoi( &vpabs_str[17] );
+
+  return TRUE;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : aci_decodeVpenh    |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function decodes a given string to the T_ACI_VP_ENH
+            type.
+*/
+LOCAL BOOL aci_decodeVpenh ( CHAR*         vpenh_str,
+                             T_ACI_VP_ENH* vpenh )
+{
+  UBYTE shift_byte = 0;
+
+  if (vpenh_str[0] EQ '\0')
+  {
+    return FALSE;
+  }
+
+  /* functionality indicator */
+  vpenh->func_ind = (vpenh_str[0]  - 0x30) << 4;
+  vpenh->func_ind += (vpenh_str[1]  - 0x30);
+
+  /* extension octet */
+  if (vpenh->func_ind & TP_VPF_ENH_EXT_BIT_MASK)
+  {
+    shift_byte = 2;
+    vpenh->ext_oct = (vpenh_str[2]  - 0x30) << 4;
+    vpenh->ext_oct += (vpenh_str[3]  - 0x30);
+  }
+
+  if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) > TP_VPF_ENH_HRS)
+  {
+    return FALSE;
+  }
+
+  /* process validity period values */
+  if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_REL)
+  {
+    utl_HexStrToBin ((UBYTE*)&vpenh_str[2+shift_byte], 2, &vpenh->val.vpenh_relative, 1);
+  }
+  else if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_SEC)
+  {
+    utl_HexStrToBin ((UBYTE*)&vpenh_str[2+shift_byte], 2, &vpenh->val.vpenh_seconds, 1);
+  }
+  else if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_HRS)
+  {
+    vpenh->val.vpenh_hours.hour  [0] = vpenh_str[3+shift_byte] - 0x30;
+    vpenh->val.vpenh_hours.hour  [1] = vpenh_str[2+shift_byte] - 0x30;
+
+    vpenh->val.vpenh_hours.minute[0] = vpenh_str[5+shift_byte] - 0x30;
+    vpenh->val.vpenh_hours.minute[1] = vpenh_str[4+shift_byte] - 0x30;
+
+    vpenh->val.vpenh_hours.second[0] = vpenh_str[7+shift_byte] - 0x30;
+    vpenh->val.vpenh_hours.second[1] = vpenh_str[6+shift_byte] - 0x30;
+  }
+
+  return TRUE;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCSMP         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CSMP command (Select Text Mode Parameters)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCSMP (char *cl, UBYTE srcId)
+{
+
+  char*         me            = "+CSMP: ";
+  T_ACI_RETURN  ret           = AT_FAIL;
+  SHORT         fo            = ACI_NumParmNotPresent,
+                vprel         = ACI_NumParmNotPresent,
+                pid           = ACI_NumParmNotPresent,
+                dcs           = ACI_NumParmNotPresent;
+  USHORT        i             = 0;
+  char          vpabs_str[25] = {'\0'},
+                vpenh_str[15] = {'\0'},
+                fo_str[4];
+
+  T_ACI_VP_ABS  vpabs;
+  T_ACI_VP_ABS* pVpabs        = NULL;
+  T_ACI_VP_ENH  vpenh;
+
+  TRACE_FUNCTION("atPlusCSMP()");
+
+   /*input functionality*/
+   while (*cl NEQ ',' AND *cl NEQ '\0' AND i < sizeof(fo_str) - 1)
+   {
+     fo_str[i]=*cl;
+     cl++;
+     i++;
+   }
+   if (*cl)
+   {
+     cl++;
+   }
+   fo_str[i]='\0';
+   if (strlen (fo_str) > 0)
+   {
+     fo=atoi(fo_str);
+   }
+   if (fo > 255)
+   {
+     cmdCmsError(CMS_ERR_OpNotAllowed);
+     return 0;
+   }
+   if (fo NEQ ACI_NumParmNotPresent AND
+       (fo & TP_VPF_MASK) EQ TP_VPF_ABSOLUTE)
+   {
+     pVpabs = &vpabs;
+
+     cl = parse(cl,"srr",(LONG)25,vpabs_str,&pid,&dcs);
+
+     if (!cl OR strlen(vpabs_str) > 20 OR pid > 255 OR
+         dcs > 255 OR !aci_decodeVpabs (vpabs_str, &vpabs))
+     {
+       cmdCmsError(CMS_ERR_OpNotAllowed);
+       return (ATI_FAIL);
+     }
+   }
+   else if (fo NEQ ACI_NumParmNotPresent AND
+       (fo & TP_VPF_MASK) EQ TP_VPF_ENHANCED)
+   {
+     cl = parse(cl,"srr",(LONG)19,vpenh_str,&pid,&dcs);
+     if (!cl OR strlen(vpenh_str) > 14 OR pid > 255 OR
+         dcs > 255 OR !aci_decodeVpenh (vpenh_str, &vpenh))
+     {
+       cmdCmsError(CMS_ERR_OpNotAllowed);
+       return (ATI_FAIL);
+     }
+   }
+   else if (fo NEQ ACI_NumParmNotPresent AND
+       (fo & TP_VPF_MASK) EQ TP_VPF_RELATIVE)
+   {
+     cl = parse(cl,"rrr",&vprel,&pid,&dcs);
+   }
+   else
+   {
+     if (*cl EQ '\"')
+     {
+       pVpabs = &vpabs;
+
+       cl = parse(cl,"srr",(LONG)25,vpabs_str,&pid,&dcs);
+
+       if (!cl OR strlen(vpabs_str) > 20 OR pid > 255 OR
+           dcs > 255 OR !aci_decodeVpabs (vpabs_str, &vpabs))
+       {
+         cmdCmsError(CMS_ERR_OpNotAllowed);
+         return (ATI_FAIL);
+       }
+     }
+     else
+     {
+       cl = parse(cl,"rrr",&vprel,&pid,&dcs);
+
+       if ( !cl OR vprel > 255 OR pid > 255 OR dcs > 255)
+       {
+         cmdCmsError(CMS_ERR_OpNotAllowed);
+         return (ATI_FAIL);
+       }
+     }
+   }
+   ret = sAT_PlusCSMP(srcId,fo,vprel,pVpabs,&vpenh,pid,dcs);
+   if (ret EQ AT_FAIL)
+   {
+     cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+     return (ATI_FAIL);
+   }
+   return (map_aci_2_ati_rslt(ret));
+}
+
+GLOBAL T_ATI_RSLT queatPlusCSMP (char *cl, UBYTE srcId)
+{
+  char*         me            = "+CSMP: ";
+  T_ACI_RETURN  ret           = AT_FAIL;
+  SHORT         fo            = ACI_NumParmNotPresent,
+                vprel         = ACI_NumParmNotPresent,
+                pid           = ACI_NumParmNotPresent,
+                dcs           = ACI_NumParmNotPresent,
+                i             = 0;
+  char          vpabs_str[25] = {'\0'};
+  char          vpenh_str[15] = {'\0'};
+  T_ACI_VP_ABS  vpabs;
+  T_ACI_VP_ENH  vpenh;
+
+  TRACE_FUNCTION("queatPlusCSMP()");
+
+  ret = qAT_PlusCSMP(srcId,&fo,&vprel,&vpabs,&vpenh,&pid,&dcs);
+  if (ret EQ AT_CMPL)
+  {
+    if ((fo & TP_VPF_MASK) EQ TP_VPF_ABSOLUTE)   /*Bits 4,3 -> 11*/
+    {
+      sprintf(vpabs_str,"\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
+              vpabs.year  [0], vpabs.year  [1],
+              vpabs.month [0], vpabs.month [1],
+              vpabs.day   [0], vpabs.day   [1],
+              vpabs.hour  [0], vpabs.hour  [1],
+              vpabs.minute[0], vpabs.minute[1],
+              vpabs.second[0], vpabs.second[1],
+              vpabs.timezone);
+      sprintf(g_sa,"%s%d,%s,%d,%d",me,fo,vpabs_str,pid,dcs);
+    }
+    else if ((fo & TP_VPF_MASK) EQ TP_VPF_ENHANCED)
+    {
+      aci_encodeVpenh ( vpenh_str, &vpenh );
+      sprintf(g_sa,"%s%d,\"%s\",%d,%d",me,fo,vpenh_str,pid,dcs);
+    }
+    else if ((fo & TP_VPF_MASK) EQ TP_VPF_RELATIVE) /*Bits 4,3 -> 10*/
+    {
+      sprintf(g_sa,"%s%d,%d,%d,%d",me,fo,vprel,pid,dcs);
+    }
+    else
+    {
+      sprintf(g_sa,"%s%d,,%d,%d",me,fo,pid,dcs);
+    }
+    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
+    return (ATI_CMPL);
+  }
+  else
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCSDH         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CSDH command (Show Text Mode Parameters)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCSDH (char *cl, UBYTE srcId)
+{
+
+  T_ACI_CSDH_SHOW ena = CSDH_SHOW_Disable;
+
+  TRACE_FUNCTION("atPlusCSDH()");
+
+   /*input functionality*/
+   cl = parse(cl,"d",&ena);
+   if ( !cl )
+   {
+     cmdCmsError(CMS_ERR_OpNotAllowed);
+     return (ATI_FAIL);
+   }
+   ati_user_output_cfg[srcId].CSDH_stat=ena;
+   return (ATI_CMPL);
+}
+
+GLOBAL T_ATI_RSLT tesatPlusCSDH (char *cl, UBYTE srcId)
+{
+  return(atPlusCSDH (cl, srcId));
+}
+
+GLOBAL T_ATI_RSLT queatPlusCSDH (char *cl, UBYTE srcId)
+{
+  sprintf(g_sa,"+CSDH: %d",ati_user_output_cfg[srcId].CSDH_stat);
+  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
+  return (ATI_CMPL);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCSCB         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CSCB command (select cell broadcast message type)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCSCB (char *cl, UBYTE srcId)
+{
+  char            *me="+CSCB: ";
+  T_ACI_RETURN    ret = AT_FAIL;
+  T_ACI_CSCB_MOD  mode;
+  char            mids_str[6*MAX_CBM_TYPES]={0};    /* CHECK IF LONG ENOUGH !!*/
+  char            dcss_str[4*MAX_CBM_TYPES]={0};
+  CHAR            buf[6]={0};
+  USHORT          mids[MAX_CBM_TYPES];
+  UBYTE           dcss[MAX_CBM_TYPES];
+  SHORT           pos=0,i=0,j=0;
+
+#ifdef FF_ATI_BAT
+  T_BAT_cmd_set_plus_cscb cscb;
+#endif
+
+
+  TRACE_FUNCTION("atPlusCSCB()");
+
+   /*input functionality*/
+   cl = parse(cl,"dss",&mode,(LONG)sizeof(mids_str),mids_str,(LONG)sizeof(dcss_str),dcss_str);
+   if ( !cl )
+   {
+     cmdCmsError(CMS_ERR_OpNotAllowed);
+     return (ATI_FAIL);
+   }
+   i = j = 0;
+   memset (mids, NOT_PRESENT_8BIT, sizeof (mids));
+   while (mids_str[i] NEQ '\0' AND j < MAX_CBM_TYPES - 1)
+   {
+     pos=0;
+     while (mids_str[i] >= '0'  AND  mids_str[i] <= '9')
+     {
+       if (pos >= 5)
+       {
+         cmdCmsError(CMS_ERR_OpNotAllowed);
+         return (ATI_FAIL);
+       }
+       buf[pos++]=mids_str[i];
+       i++;
+     }
+     buf[pos]='\0';
+     if (mids_str[i] NEQ ','  AND  mids_str[i] NEQ '-'  AND  mids_str[i] NEQ '\0')
+     {
+       cmdCmsError(CMS_ERR_OpNotAllowed);
+       return (ATI_FAIL);
+     }
+     else
+     {
+       if (mids_str[i] EQ ',' OR mids_str[i] EQ '\0')
+       {
+         i++;
+         mids[j++]=atoi(buf);
+         mids[j++]=atoi(buf);
+       }
+       else
+       {
+         i++;
+         mids[j++]=atoi(buf);
+         pos=0;
+         while (mids_str[i] NEQ ','  AND  mids_str[i] NEQ '\0')
+         {
+           if (pos >= 5)
+           {
+             cmdCmsError(CMS_ERR_OpNotAllowed);
+             return (ATI_FAIL);
+           }
+           buf[pos++]=mids_str[i];
+           i++;
+         }
+         i++;
+         mids[j++]=atoi(buf);
+       }
+     }
+   }
+ 
+   if (compact(&mids_str[i],(USHORT)strlen(&mids_str[i])) NEQ 0)
+   {
+     cmdCmsError(CMS_ERR_OpNotAllowed);
+     return (ATI_FAIL);
+   }
+
+#ifdef FF_ATI_BAT
+   memset(cscb.mids, NOT_PRESENT_8BIT, sizeof(cscb.mids));
+   cscb.v_mids = j ? TRUE : FALSE;
+   cscb.c_mids = (U8)j;
+   memcpy(cscb.mids, mids, j*2);
+#endif
+
+   i = j = 0;
+   memset (dcss, NOT_PRESENT_8BIT, sizeof (dcss));
+   while (dcss_str[i] NEQ '\0' AND j < MAX_CBM_TYPES - 1)
+   {
+     pos=0;
+     while (dcss_str[i] >= '0'  AND  dcss_str[i] <= '9')
+     {
+       if (pos >= 3)
+       {
+         cmdCmsError(CMS_ERR_OpNotAllowed);
+         return (ATI_FAIL);
+       }
+       buf[pos++]=dcss_str[i];
+       i++;
+     }
+     buf[pos]='\0';
+     if (dcss_str[i] NEQ ','  AND  dcss_str[i] NEQ '-'  AND  dcss_str[i] NEQ '\0')
+     {
+       cmdCmsError(CMS_ERR_OpNotAllowed);
+       return (ATI_FAIL);
+     }
+     else
+     {
+       if (dcss_str[i] EQ ',' OR dcss_str[i] EQ '\0')
+       {
+         i++;
+         dcss[j++]=atoi(buf);
+         dcss[j++]=atoi(buf);
+       }
+       else
+       {
+         i++;
+         dcss[j++]=atoi(buf);
+         pos=0;
+         while (dcss_str[i] NEQ ','  AND  dcss_str[i] NEQ '\0')
+         {
+           if (pos >= 3)
+           {
+             cmdCmsError(CMS_ERR_OpNotAllowed);
+             return (ATI_FAIL);
+           }
+           buf[pos++]=dcss_str[i];
+           i++;
+         }
+         i++;
+         dcss[j++]=atoi(buf);
+       }
+     }
+   }
+   if (compact(&dcss_str[i],(USHORT)strlen(&dcss_str[i])) NEQ 0)
+   {
+     cmdCmsError(CMS_ERR_OpNotAllowed);
+     return (ATI_FAIL);
+   }
+   
+#ifdef FF_ATI_BAT
+   {
+      T_BAT_cmd_send cmd;
+
+      cmd.ctrl_params = BAT_CMD_SET_PLUS_CSCB;
+      cmd.params.ptr_set_plus_cscb = &cscb;
+
+      cscb.mode = (T_BAT_VAL_plus_cscb_mode)mode;
+            
+      memset(cscb.dcss, NOT_PRESENT_8BIT, sizeof(cscb.dcss));
+      cscb.v_dcss = j ? TRUE : FALSE;;
+      cscb.c_dcss = (U8)j;
+      memcpy(cscb.dcss, dcss, cscb.c_dcss);
+      
+      
+      TRACE_FUNCTION("atPlusCSCB() calls bat_send() <=== as APPLICATION");
+      bat_send(ati_bat_get_client(srcId), &cmd);
+      return (AT_EXCT);
+   }
+#else /* FF_ATI_BAT */
+   ret=sAT_PlusCSCB(srcId,mode,mids,dcss);
+   if (ret EQ AT_FAIL)
+   {
+     cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+     return (ATI_FAIL);
+   }
+   return (map_aci_2_ati_rslt(ret));
+#endif /* FF_ATI_BAT */
+}
+
+GLOBAL T_ATI_RSLT queatPlusCSCB (char *cl, UBYTE srcId)
+{
+#ifdef FF_ATI_BAT
+  T_BAT_cmd_send     cmd;
+  T_BAT_no_parameter dummy;
+  
+  cmd.ctrl_params              = BAT_CMD_QUE_PLUS_CSCB;
+  dummy.bat_dummy              = 0xFF;
+  cmd.params.ptr_que_plus_cscb = &dummy;
+
+  TRACE_FUNCTION("queatPlusCSCB() calls bat_send() <=== as APPLICATION");
+  bat_send(ati_bat_get_client(srcId), &cmd);
+
+  return (AT_EXCT);
+
+#else /* FF_ATI_BAT */
+  T_ACI_CSCB_MOD  mode;
+  char            mids_str[6*MAX_CBM_TYPES+1]={'\0'}; /* +1 for '\0' */  /* CHECK IF LONG ENOUGH !!*/
+  char            dcss_str[4*MAX_CBM_TYPES+1]={'\0'};
+  USHORT          mids[MAX_CBM_TYPES];
+  UBYTE           dcss[MAX_CBM_TYPES];
+  SHORT           pos=0,i=0;
+  T_ACI_RETURN    ret = AT_FAIL;
+
+  TRACE_FUNCTION("queatPlusCSCB()");
+
+  ret = qAT_PlusCSCB(srcId, &mode,mids,dcss);
+  if (ret EQ AT_CMPL)
+  {
+    /*
+     *-----------------------------------------------------------
+     * assemble the string for message identifiers
+     *-----------------------------------------------------------
+     */
+    pos = i = 0;
+    while( mids[i]   NEQ 0xFFFF   AND
+           mids[i+1] NEQ 0xFFFF   AND
+           i < MAX_CBM_TYPES - 1    )
+    {
+      if ( mids[i] EQ mids[i+1] )
+        pos += sprintf ( mids_str + pos, "%d,", mids[i] );
+      else
+        pos += sprintf ( mids_str + pos, "%d-%d,", mids[i], mids[i+1] );  /* "65534-65535," max 12 chars */
+
+      i += 2;
+    }
+
+    /*lint -e(661) -e(662) */   /* lint 7.5 has here some problems ... */
+    if ( pos > 0 )              /* remove the last ',' */
+    {
+        mids_str[pos-1] = '\0';
+    }
+
+    /*
+     *-----------------------------------------------------------
+     * assemble the string for data coding schemes
+     *-----------------------------------------------------------
+     */
+    pos = i = 0;
+    while( dcss[i]   NEQ 0xFF    AND
+           dcss[i+1] NEQ 0xFF    AND
+           i < MAX_CBM_TYPES - 1     )
+    {
+      if ( dcss[i] EQ dcss[i+1] )
+        pos += sprintf ( dcss_str + pos, "%d,", dcss[i] );
+      else
+        pos += sprintf ( dcss_str + pos, "%d-%d,", dcss[i], dcss[i+1] );
+
+      i += 2;
+    }
+
+    /*lint -e(661) -e(662) */
+    if ( pos > 0 )    /* remove the last ',' */
+    {
+      dcss_str[pos-1] = '\0';
+    }
+
+    sprintf(g_sa,"+CSCB: %d,\"%s\",\"%s\"",mode,mids_str,dcss_str);
+    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
+    return (ATI_CMPL);
+  }
+  else
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+#endif /* FF_ATI_BAT */
+}
+
+#ifdef FF_HOMEZONE
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPercentCBHZ      |
++--------------------------------------------------------------------+
+
+  PURPOSE : %CBHZ command (set homezone activity)
+*/
+
+GLOBAL T_ATI_RSLT setatPercentCBHZ (char *cl, UBYTE srcId)
+{
+  T_ACI_CBHZ_MOD  mode    = CBHZ_MOD_NotPresent;
+  T_ACI_CS        dcs     = CS_NotPresent;
+  UBYTE           timeout = NOT_PRESENT_8BIT;
+  T_ACI_RETURN    ret     = AT_FAIL;
+
+  TRACE_FUNCTION("setatPercentCBHZ()");
+
+
+  /*input functionality*/
+
+  /*check first parameter */
+  switch (*cl)
+  {
+    case '0':
+    case '1':
+      mode = *cl - 0x30;
+      cl++;
+      break;
+
+    default:
+      cmdCmsError(CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+  }
+
+  /* check second parameter */
+  if  ( *cl NEQ '\0' )
+  {
+    if ( *cl NEQ ',')
+    {
+      cmdCmsError(CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+    }
+    cl++;
+
+    if ( (*cl >= '0') AND (*cl <= '9') )
+    {
+      dcs = *cl -0x30;
+      cl++;
+    }
+
+    /* check third parameter */
+    if  ( *cl NEQ '\0' )
+    {
+      if ( *cl NEQ ',')
+      {
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return (ATI_FAIL);
+      }
+      cl++;
+
+      cl = parse(cl,"d",&timeout);
+      if  ( *cl NEQ '\0' )
+      {
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return (ATI_FAIL);
+      }
+    }
+  }
+
+  /* parameters ok... process homezone request */
+  ret = sAT_PercentCBHZ(srcId,mode,dcs,timeout);
+  if (ret EQ AT_FAIL)
+  {
+    cmdCmeError(CME_ERR_Unknown);
+    return (ATI_FAIL);
+  }
+
+  return (ATI_CMPL);
+}
+
+
+GLOBAL T_ATI_RSLT tesatPercentCBHZ (char *cl, UBYTE srcId)
+{
+  TRACE_FUNCTION("tesatPercentCBHZ()");
+
+  sprintf( g_sa, "%s: (%d,%d),(%d-%d),(%d-%d)",
+             "%CBHZ", CBHZ_MOD_NotActive, CBHZ_MOD_Active,
+             CS_GsmDef, CS_Ascii, CBHZ_MIN_TIMEOUT, CBHZ_MAX_TIMEOUT);
+
+
+  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
+
+  return (ATI_CMPL);
+}
+
+GLOBAL T_ATI_RSLT queatPercentCBHZ (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN    ret;
+  T_ACI_CBHZ_MOD  mode;
+  T_ACI_CS        dcs;
+  UBYTE           timeout;
+
+  TRACE_FUNCTION("queatPercentCBSHZ()");
+
+  ret = qAT_PercentCBHZ(srcId, &mode, &dcs, &timeout);
+
+  if (ret EQ AT_FAIL)
+  {
+    cmdCmeError(CME_ERR_Unknown);
+    return (ATI_FAIL);
+  }
+
+  /*
+   *-----------------------------------------------------------
+   * assemble the string for output
+   *-----------------------------------------------------------
+   */
+
+  sprintf( g_sa, "%s: %d,%d,%d", "%CBHZ", mode, dcs, timeout);
+
+  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
+
+  return (ATI_CMPL);
+}
+#endif /* FF_HOMEZONE */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCSAS         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CSAS command (Save SMS Profile)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCSAS (char *cl, UBYTE srcId)
+{
+  SHORT        profile  = -1;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("atPlusCSAS()");
+
+  if ( *cl EQ '\0' )
+  {
+    profile = 1;
+  }
+  else
+  {
+    cl = parse ( cl, "r", &profile );
+    if ( !cl )
+    {
+      cmdCmsError ( CMS_ERR_MemFail );
+      return (ATI_FAIL);
+    }
+    profile++;
+  }
+#ifdef FF_ATI_BAT
+  {
+    T_BAT_cmd_send cmd;
+    T_BAT_cmd_set_plus_csas csas;
+
+    cmd.ctrl_params = BAT_CMD_SET_PLUS_CSAS;
+    cmd.params.ptr_set_plus_csas = &csas;
+
+    csas.profile = profile;
+
+    TRACE_FUNCTION("atPlusCSAS() calls bat_send() <=== as APPLICATION");
+    bat_send(ati_bat_get_client(srcId), &cmd);
+    return (AT_EXCT);
+  }
+#else /* FF_ATI_BAT */
+  switch (sAT_PlusCSAS (srcId, profile))
+  {
+    case AT_EXCT:
+      src_params->curAtCmd    = AT_CMD_CSAS;
+      return (ATI_EXCT);
+
+    case AT_BUSY:
+      return (ATI_BUSY);
+
+    case AT_CMPL:
+      return (ATI_CMPL_NO_OUTPUT);
+
+    case AT_FAIL:           /* execution of command failed */
+    default:
+      cmdCmsError ( CMS_ERR_NotPresent);  /* use aciErrDesc */
+      return (ATI_FAIL);
+  }
+#endif /* FF_ATI_BAT */
+}
+
+GLOBAL T_ATI_RSLT tesatPlusCSAS (char *cl, UBYTE srcId)
+{
+  SHORT        profile  = -1;
+
+  if ((profile = cmhSMS_getPrfRge ()) < 1)
+  {
+    cmdCmsError ( CMS_ERR_MemFail );
+    return (ATI_FAIL);
+  }
+  else
+  {
+    sprintf ( g_sa, "+CSAS: (0-%d)", profile - 1 );
+    io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
+    return (ATI_CMPL);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCRES         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CRES command (Load SMS Profile)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCRES (char *cl, UBYTE srcId)
+{
+  SHORT        profile  = -1;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("atPlusCRES()");
+
+  if ( *cl EQ '\0' )
+  {
+    profile = 1;
+  }
+  else
+  {
+    cl = parse ( cl, "r", &profile );
+
+    if ( !cl )
+    {
+      cmdCmsError ( CMS_ERR_MemFail );
+      return (ATI_FAIL);
+    }
+    profile++;
+  }
+
+  switch (sAT_PlusCRES (srcId, profile))
+  {
+    case AT_EXCT:
+      src_params->curAtCmd    = AT_CMD_CRES;
+      return (ATI_EXCT);
+
+    case AT_BUSY:
+      return (ATI_BUSY);
+
+    case AT_CMPL:
+      io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+      return (ATI_CMPL_NO_OUTPUT);
+
+    case AT_FAIL:
+    default:
+      cmdCmsError ( CMS_ERR_NotPresent);  // use aciErrDesc
+      return (ATI_FAIL);
+  }
+}
+
+GLOBAL T_ATI_RSLT tesatPlusCRES (char *cl, UBYTE srcId)
+{
+  T_ACI_CRES    profile;
+  T_ACI_RETURN  result;
+
+  result = tAT_PlusCRES (srcId, &profile);
+  switch (result)
+  {
+    case AT_FAIL:
+      cmdCmsError ( CMS_ERR_MemFail );
+      return (ATI_FAIL);
+
+    case AT_CMPL:
+      break;
+
+    default:
+      cmdCmsError ( CMS_ERR_MemFail );
+      return (ATI_FAIL); 
+  }
+
+  sprintf ( g_sa, "+CRES: (%d-%d)", profile.min, profile.max);
+  io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
+  return (ATI_CMPL);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCMGR         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMGR command (Read Message)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCMGR (char *cl, UBYTE srcId)
+{
+  char *me="+CMGR: ";
+  T_ACI_RETURN ret = AT_FAIL;
+  SHORT idx=-1;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("atPlusCMGR()");
+
+#ifndef WIN32
+   cl = parse(cl,"r",&idx);
+#else
+   cl = parse(cl,"rd",&idx, &smsReadMode );
+#endif
+  if ( !cl OR idx > 255 OR idx < 0)
+  {
+    cmdCmsError(CMS_ERR_OpNotAllowed);
+    return (ATI_FAIL);
+  }
+
+#ifdef FF_ATI_BAT
+
+  {
+    T_BAT_cmd_send cmd;
+    T_BAT_cmd_set_plus_cmgr cmgr;
+
+    cmd.ctrl_params=BAT_CMD_SET_PLUS_CMGR;
+    cmd.params.ptr_set_plus_cmgr=&cmgr;
+
+    cmgr.sms_index=(U16)idx;
+
+    bat_send(ati_bat_get_client(srcId), &cmd);
+
+    src_params->curAtCmd=AT_CMD_CMGR;
+    return(ATI_EXCT);
+  }
+
+#else
+
+#ifndef _CONC_TESTING_
+#ifndef _SIMULATION_
+  ret = sAT_PlusCMGR_Gl(srcId, (UBYTE)idx, SMS_READ_Normal, NULL);
+#else
+  ret = sAT_PlusCMGR_Gl(srcId, (UBYTE)idx, smsReadMode , NULL);
+#endif
+#else
+#ifndef _SIMULATION_
+  ret = sAT_PlusCMGR (srcId, (UBYTE)idx, SMS_READ_Normal);
+#else
+  ret = sAT_PlusCMGR (srcId, (UBYTE)idx, smsReadMode );
+#endif
+#endif
+ if ( ret EQ AT_CMPL )
+ {
+   return (ATI_CMPL);
+ }
+ else if (ret EQ AT_EXCT)
+ {
+   src_params->curAtCmd    = AT_CMD_CMGR;
+   return (ATI_EXCT);
+ }
+ else
+ {
+   cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+   return (ATI_FAIL);
+ }
+
+#endif /*FF_ATI_BAT*/
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCMGS         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMGS command (SEND Message)
+*/
+
+GLOBAL T_ATI_RSLT tesatPlusCMGS (char *cl, UBYTE srcId)
+{
+  io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+  return ATI_CMPL_NO_OUTPUT;
+}
+
+GLOBAL T_ATI_RSLT queatPlusCMGS (char *cl, UBYTE srcId)
+{
+  cmdCmsError(CMS_ERR_OpNotAllowed); /* querying CMGS not specified in 07.05 */
+  return (ATI_FAIL);
+}
+
+
+GLOBAL T_ATI_RSLT atPlusCMGS (char *cl, UBYTE srcId)
+#if defined (SMS_PDU_SUPPORT)
+{
+  T_ACI_CMGF_MOD mode;
+  
+  TRACE_FUNCTION("atPlusCMGS()");
+  /*
+   * request current mode
+   */
+  qAT_PlusCMGF(srcId, &mode);
+  if (mode EQ 0)
+  {
+    /*
+     * handle PDU mode
+     */
+    return (atPlusCMGSPdu (cl, srcId));
+  }
+  else
+  {
+    /*
+     * handle Text mode
+     */
+    return (atPlusCMGSText (cl, srcId));
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)            MODULE  : ACI_CMD              |
+| STATE   : code                      ROUTINE : str_to_bcd           |
++--------------------------------------------------------------------+
+
+  PURPOSE : A very specialised routine for converting a 2-byte string
+            into one byte of BCD, intended to be used by atPlusCMGSText()
+            only.
+*/
+LOCAL UBYTE str_to_bcd(
+  CHAR *str)
+{
+  UBYTE bcd;
+  UBYTE n;
+
+  for (n=0;n<2;n++)
+  {
+    bcd>>=4;
+
+    if ((str[n]<'0') || (str[n]>'9'))
+      bcd+=0xF0;
+    else
+      bcd+=(str[n]-'0')<<4;
+  }
+
+  return(bcd);
+}
+
+
+LOCAL T_ATI_RSLT atPlusCMGSText(char *cl, UBYTE srcId)
+#endif /* (SMS_PDU_SUPPORT) */
+{
+         T_ACI_VP_ABS  vpabs;
+         SHORT         fo,
+                       vprel,
+                       pid,
+                       dcs;
+         CHAR*         me        = "+CMGS: ";
+         T_ACI_RETURN  ret       = AT_FAIL;
+         T_ACI_TOA     toda;
+         T_ACI_TOA*    p_toda;
+  GLOBAL SHORT         toda_val  = 0;
+         T_ACI_SM_DATA msg;
+         USHORT        lenMsg;
+         CHAR*         da = daBuf;
+
+  static T_ACI_TOA     tosca;
+  static T_ACI_TOA    *p_tosca;
+#ifdef _SIMULATION_
+  CHAR         *sca =subBuf;
+#endif /* _SIMULATION_ */
+  SHORT         octet=0;
+  static SHORT         isReply;
+
+#ifdef _CONC_TESTING_
+  T_SM_DATA_EXT msg_conc;
+#endif
+
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  if (src_params->text_mode EQ CMD_MODE)
+  {
+    TRACE_FUNCTION("atPlusCMGSText() CMD_MODE");
+    memset (da, 0, MAX_SMS_NUM_LEN);
+    /* input functionality */
+    da[0]='\0';
+#ifndef WIN32
+    cl = parse (cl,"sr",(LONG)MAX_SMS_NUM_LEN,da,&toda_val);
+    if ( !cl OR da[0] EQ '\0')
+    {
+      cmdCmsError (CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+    }
+#else
+    *sca    ='\0';
+    isReply = -1;
+    cl = parse (cl,"srsrb",(LONG)MAX_SMS_NUM_LEN,da,&toda_val,
+                           (LONG)MAX_SMS_NUM_LEN,sca,&octet,&isReply);
+    if ( !cl OR da[0] EQ '\0')
+    {
+      cmdCmsError (CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+    }
+    if (octet EQ 0)
+    {
+      p_tosca=NULL;
+    }
+    else
+    {
+      tosca=toa_demerge(octet);
+      if (tosca.ton < 0 OR tosca.npi < 0)
+      {
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return (ATI_FAIL);
+      }
+    }
+#endif
+    if (toda_val)
+    {
+      toda=toa_demerge(toda_val);
+      if (toda.ton < 0 OR toda.npi < 0)
+      {
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return (ATI_FAIL);
+      }
+    }
+
+    src_params->text_mode = TXT_MODE;
+    return (ATI_EXCT);
+  } /* end of if (src_params->text_mode EQ CMD_MODE) */
+  else
+  {
+    TRACE_FUNCTION("atPlusCMGSText() TXT_MODE");
+
+    src_params->text_mode = CMD_MODE;
+    /* if the character sent is ESC, then abort command CLB 16.11.00 */
+    if (*cl EQ 0x1B)
+    {
+      TRACE_EVENT("Send message command cancelled by user");
+
+      return ATI_CMPL_NO_OUTPUT;
+    }
+
+    if ( toda_val EQ 0 )
+    {
+#ifndef _SIMULATION_
+#endif /* ndef _SIMULATION_ */
+      p_toda = NULL;
+    }
+    else
+    {
+      toda   = toa_demerge ( toda_val );
+      p_toda = &toda;
+    }
+
+    qAT_PlusCSMP  ( srcId, &fo, &vprel, &vpabs, NULL, &pid, &dcs );
+
+    srcId_cb = srcId;
+    if (ati_user_output_cfg[srcId].cscsChset EQ CSCS_CHSET_Ucs2 )
+    {
+      utl_smDtaFromTe ((UBYTE*)cl,
+                       (USHORT)MINIMUM(strlen(cl),sizeof(msg.data)*4),
+                       msg.data,
+                       &lenMsg,
+                       (UBYTE)fo,
+                       (UBYTE)dcs );
+    }
+    else if (ati_user_output_cfg[srcId].cscsChset EQ CSCS_CHSET_Hex )
+    {
+      utl_smDtaFromTe ((UBYTE*)cl,
+                       (USHORT)MINIMUM(strlen(cl),sizeof(msg.data)*2),
+                       msg.data,
+                       &lenMsg,
+                       (UBYTE)fo,
+                       (UBYTE)dcs );
+    }
+    else
+    {
+      utl_smDtaFromTe ((UBYTE*)cl,
+                       (USHORT)MINIMUM(strlen(cl),sizeof(msg.data)),
+                       msg.data,
+                       &lenMsg,
+                       (UBYTE)fo,
+                       (UBYTE)dcs );
+    }
+    msg.len = (UBYTE)lenMsg;
+
+#if 0  /* #ifdef FF_ATI_BAT */
+
+    {
+      T_BAT_cmd_send cmd;
+      T_BAT_cmd_set_plus_cmgs cmgs;
+      UBYTE len;
+      UBYTE i;
+      U8 *p;
+      CHAR clean_da[MAX_SMS_NUM_LEN+1];
+
+      cmd.ctrl_params=BAT_CMD_SET_PLUS_CMGS;
+      cmd.params.ptr_set_plus_cmgs=&cmgs;
+
+      /*
+      *   The BAT uses only PDU format, so we must convert the data.
+      *   This code is sufficient to allow tests ACIPHB75-78 to pass - at
+      *   the time of writing, these are the only tests we have available
+      *   for +CMGS. When it comes to other tests, some enhancements will
+      *   certainly be required.
+      */
+
+      p=cmgs.pdu;
+
+      /*
+      *   SCA - Service Centre Address
+      */
+      len=(UBYTE)strlen(sca);
+
+      if (len==0)
+      {
+        /*
+        *   No service centre address indicated. If we use a zero length
+        *   to indicate the default SCA, we will have problems later in
+        *   DecodeRPAddress(). The version below seems to be fine.
+        */
+        *p++=0x01;
+        *p++=0x80;        
+      }
+      else
+      {
+        /*
+        *   The length is the number of octets in the parameter, not
+        *   the number of address digits.
+        */
+        *p++=(U8)((len+1)/2)+1;
+
+        /*
+        *   Type of number.
+        */
+        *p++=(tosca.ton==TON_International) ? 0x91:0x81;
+
+        /*
+        *   Convert the address from string format to BCD format.
+        */
+        for (i=0;i<len;i+=2)
+          *p++=str_to_bcd(&sca[i]);
+      }
+
+      /*
+      *   PDU type
+      */
+      *p++=0x01;
+
+      /*
+      *   MR - Message reference
+      */
+      *p++=0x00;
+
+      /*
+      *   DA - Destination Address
+      *   The length is the number of address digits, not the number of
+      *   octets in the parameter.
+      */
+
+      /*
+      *   First, make a clean version of the string, getting rid of
+      *   any unwanted characters.
+      */
+      {
+        SHORT cctr,dctr;
+        CHAR c;
+
+        memset(clean_da,0,sizeof(clean_da));
+
+        cctr=0;
+
+        for (dctr=0;dctr<MAX_SMS_NUM_LEN;dctr++)
+        {
+          c=da[dctr];
+
+          if ((c>='0') && (c<='9'))
+            clean_da[cctr++]=c;
+        }
+      }
+      
+      len=(UBYTE)strlen(clean_da);
+
+      *p++=(U8)len;
+
+      /*
+      *   Type of number.
+      */
+      *p++=(toda.ton==TON_International) ? 0x91:0x81;
+
+      /*
+      *   Convert the address from string format to BCD format.
+      */
+      for (i=0;i<len;i+=2)
+        *p++=str_to_bcd(&clean_da[i]);
+
+      /*
+      *   PID - Protocol Identifier
+      */
+      *p++=(U8)pid;
+
+      /*
+      *   DCS - Data Coding Scheme
+      */
+      *p++=(U8)dcs;
+
+      /*
+      *   VP - Validity Period
+      *   Not included here.
+      */
+
+      /*
+      *   UDL - User Data Length
+      */
+      *p++=0x00;
+
+      /*
+      *   UD - User Data
+      *   Not included here.
+      */
+      
+      /*
+      *   Length calculated by seeing how far the pointer has come
+      *   from where it started.
+      */
+      cmgs.c_pdu=(U8)(p-cmgs.pdu);
+
+      bat_send(ati_bat_get_client(srcId), &cmd);
+    }
+
+#else
+
+#ifndef _CONC_TESTING_
+#ifndef _SIMULATION_
+    ret = sAT_PlusCMGS_Gl(srcId, da, p_toda, &msg, NULL, NULL, NULL, -1, NULL, NULL);
+#else
+    ret = sAT_PlusCMGS_Gl(srcId, da, p_toda, &msg, NULL, sca, p_tosca, isReply, NULL, NULL);
+#endif
+#else
+    ACI_MALLOC(msg_conc.data, msg.len);
+    memcpy ( msg_conc.data, msg.data, msg.len);
+    msg_conc.len = msg.len;
+#ifndef _SIMULATION_
+    ret = sAT_PlusCMGS (srcId, da, p_toda, &msg_conc, NULL, NULL, -1);
+#else
+    ret = sAT_PlusCMGS (srcId, da, p_toda, &msg_conc, sca, p_tosca, isReply);
+#endif
+#endif
+
+    if ( ret NEQ AT_EXCT )
+    {
+      cmdCmsError (CMS_ERR_NotPresent);  // use aciErrDesc
+      return (ATI_FAIL);
+    }
+    /*
+     *  rCI_OK will emitting +CMGS: <mr>[,<scts>]
+     */
+#endif
+
+    return (ATI_EXCT);
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCMSS         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMSS command (send message from storage)
+*/
+
+GLOBAL T_ATI_RSLT atPlusCMSS (char *cl, UBYTE srcId)
+{
+  CHAR         *me="+CMSS: ",
+               *p_da;
+  T_ACI_RETURN  ret = AT_FAIL;
+  T_ACI_TOA     toda;
+  T_ACI_TOA    *p_toda;
+  SHORT         index=-1,
+                toda_val=0;
+  CHAR          da[MAX_SMS_NUM_LEN];
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("atPlusCMSS()");
+
+  p_toda=&toda;
+  p_da=da;
+  /*input functionality*/
+  da[0]='\0';
+  cl = parse(cl,"rsr",&index,(LONG)MAX_SMS_NUM_LEN,da,&toda_val);
+  if ( !cl OR toda_val > 0xC9 OR index > 255 OR index < 0)
+  {
+    cmdCmsError(CMS_ERR_OpNotAllowed);
+    return (ATI_FAIL);
+  }
+  p_toda=&toda;
+  if(toda_val EQ 0)
+  {
+    p_toda=NULL;
+  }
+  else
+  {
+    toda=toa_demerge(toda_val);
+    if (toda.ton < 0 OR toda.npi < 0)
+    {
+      cmdCmsError(CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+    }
+  }
+  if(!da[0])
+    p_da=NULL;
+
+#ifdef _CONC_TESTING_
+  ret = sAT_PlusCMSS(srcId,(UBYTE)index,p_da,p_toda);
+#else
+  ret = sAT_PlusCMSS_Gl(srcId, (UBYTE)index, p_da, p_toda, NULL, NULL);
+#endif
+  if (ret EQ AT_EXCT)
+  {
+    src_params->curAtCmd    = AT_CMD_CMSS;
+    return (ATI_EXCT);
+  }
+  else
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCNMA         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CNMA command (new message acknowledgement)
+*/
+GLOBAL T_ATI_RSLT queatPlusCNMA (char *cl, UBYTE srcId)
+{
+  cmdCmsError(CMS_ERR_OpNotAllowed); /* querying CNMA not specified in 07.05 */
+  return (ATI_FAIL);
+}
+
+GLOBAL T_ATI_RSLT tesatPlusCNMA (char *cl, UBYTE srcId)
+{
+  T_ACI_CMGF_MOD mode;
+
+  /*
+   * request current mode
+   */
+  qAT_PlusCMGF(srcId, &mode);
+  if (mode EQ 0)
+  {
+    /*
+     * handle PDU mode: response is +CNMA: (list of supported <n>s)
+     */
+    io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+    return ATI_CMPL_NO_OUTPUT;
+  }
+  else
+  {
+    /*
+     * handle Text mode: there is no response
+     */
+    io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+    return ATI_CMPL_NO_OUTPUT;
+  }
+}
+
+
+GLOBAL T_ATI_RSLT atPlusCNMA (char *cl, UBYTE srcId)
+#if defined (SMS_PDU_SUPPORT)
+{
+  T_ACI_CMGF_MOD         mode;
+  T_CNMI_BUFFER_ELEMENT *psMsgInCnmiBuffer = NULL;
+
+  if(srcId NEQ smsShrdPrm.smsSrcId)
+  {
+    cmdCmsError(CMS_ERR_NoCnmaAckExpect);
+    return ( ATI_FAIL );
+  }
+  
+  if( waitForCnmaFromBuffer_SrcId NEQ CMD_SRC_NONE )
+  { /* incomming +CNMA acknowledges an +CMT from CNMI buffer 
+       -> acknowledge has been sent to SMS entity */
+    TIMERSTOP( ACI_CNMA_TIMER_HANDLE );
+    cmd_clearFirstCnmiMessage(); /* The first message in CNMI buffer is cleared */
+    waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE;
+    /* look for more messages in CNMI buffer for this srcId */
+    cmd_flushCnmiBufOneByOne();
+    return(ATI_CMPL);
+  }
+  /*
+   * request current mode
+   */
+  qAT_PlusCMGF(srcId, &mode);
+  if (mode EQ 0)
+    /*
+     * handle PDU mode
+     */
+    return atPlusCNMAPdu (cl,srcId);
+  else
+    /*
+     * handle Text mode
+     */
+    return atPlusCNMAText (cl,srcId);
+}
+
+LOCAL T_ATI_RSLT atPlusCNMAText (char *cl, UBYTE srcId)
+#endif /* (SMS_PDU_SUPPORT) */
+{
+  TRACE_FUNCTION("atPlusCNMAText()");
+
+  switch (*cl)
+  {
+    case(0x0):
+      switch (sAT_PlusCNMA(srcId))
+      {
+        case( AT_CMPL ):
+          cmdAtError ( atOk );
+          return (ATI_CMPL);
+
+        default:
+          cmdCmsError (CMS_ERR_NotPresent);  // use aciErrDesc
+          return (ATI_FAIL);
+      }
+    default:
+      cmdCmeError(CME_ERR_Unknown);
+      return (ATI_FAIL);
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCMGW         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMGW command (Write message to memory)
+*/
+
+GLOBAL T_ATI_RSLT tesatPlusCMGW (char *cl, UBYTE srcId)
+{
+  io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+  return ATI_CMPL_NO_OUTPUT;
+}
+
+GLOBAL T_ATI_RSLT queatPlusCMGW (char *cl, UBYTE srcId)
+{
+  cmdCmsError(CMS_ERR_OpNotAllowed); /* querying CMGW not specified in 07.05 */
+  return (ATI_FAIL);
+}
+
+
+GLOBAL T_ATI_RSLT atPlusCMGW (char *cl, UBYTE srcId)
+#if defined (SMS_PDU_SUPPORT)
+{
+  T_ACI_CMGF_MOD mode;
+
+  /*
+   * request current mode
+   */
+  qAT_PlusCMGF(srcId, &mode);
+  if (mode EQ 0)
+    /*
+     * handle PDU mode
+     */
+    return atPlusCMGWPdu (cl, srcId);
+  else
+    /*
+     * handle Text mode
+     */
+    return atPlusCMGWText (cl, srcId);
+}
+LOCAL T_ATI_RSLT atPlusCMGWText(char *cl, UBYTE srcId)
+#endif /* (SMS_PDU_SUPPORT) */
+{
+  T_ACI_VP_ABS  vpabs;
+  SHORT         fo,
+                vprel,
+                pid,
+                dcs;
+  CHAR*         me = "+CMGW: ";
+  T_ACI_RETURN  ret;
+  T_ACI_TOA     toa;
+  T_ACI_TOA*    p_toa;
+  CHAR          txtStat[15] = {0x00};
+  USHORT        i;
+  T_ACI_SM_DATA msg;
+  USHORT        lenMsg;
+  static T_ACI_SMS_STAT stat;
+
+  static T_ACI_TOA     tosca;
+  static T_ACI_TOA    *p_tosca;
+#ifdef _SIMULATION_
+  CHAR         *sca =subBuf;
+#endif /* ndef _SIMULATION_ */
+  SHORT         octet=0;
+  static SHORT         isReply;
+#ifdef _CONC_TESTING_
+  T_SM_DATA_EXT msg_conc;
+#endif
+  CHAR         *da = daBuf;
+
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("atPlusCMGWText()");
+
+  p_toa=&toa;
+  toda_val=0;
+
+  if (src_params->text_mode EQ CMD_MODE)
+  {
+    memset(da, 0, MAX_SMS_NUM_LEN);
+    stat = SMS_STAT_NotPresent;
+    /*input functionality*/
+    *da='\0';                      /*sets global destination address to empty string*/
+#ifndef WIN32
+    cl = parse(cl,"srs",(LONG)MAX_SMS_NUM_LEN,
+                        da,
+                        &toda_val,
+                        (LONG)sizeof(txtStat),
+                        txtStat);
+    if ( !cl )
+    {
+      cmdCmsError(CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+    }
+#else
+    *sca='\0';
+    isReply = -1;
+    cl = parse(cl,"srssrb",(LONG)MAX_SMS_NUM_LEN,
+                       da,
+                       &toda_val,
+                       (LONG)sizeof(txtStat),
+                       txtStat,
+                       (LONG)MAX_SMS_NUM_LEN,sca,&octet,&isReply);
+    if ( !cl )
+    {
+      cmdCmsError(CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+    }
+    if(octet EQ 0)
+      p_tosca = NULL;
+    else
+    {
+      tosca=toa_demerge(octet);
+      if (tosca.ton < 0 OR tosca.npi < 0)
+      {
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return 0;
+      }
+      p_tosca = &tosca;
+    }
+#endif
+    if (toda_val)
+    {
+      toa = toa_demerge(toda_val);
+      if (toa.ton < 0 OR toa.npi < 0)
+      {
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return (ATI_FAIL);
+      }
+    }
+    i = 0;
+    while ( sms_stat[i].name                     NEQ NULL AND
+            strcmp ( sms_stat[i].name, txtStat ) NEQ 0        )
+    {
+      i++;
+    }
+    stat = sms_stat[i].stat;
+
+    src_params->text_mode = TXT_MODE;
+    return (ATI_EXCT);
+  } /* end of if (src_params->text_mode EQ CMD_MODE) */
+  else
+  {
+    src_params->text_mode = CMD_MODE;
+    /* if the character sent is ESC, then abort command CLB 16.11.00 */
+    if (*cl EQ 0x1B)
+    {
+      TRACE_EVENT("Send message command cancelled by user");
+
+      return ATI_CMPL_NO_OUTPUT;
+    }
+
+    if ( toda_val EQ 0 )
+      p_toa = NULL;
+    else
+    {
+      toa   = toa_demerge ( toda_val );
+      p_toa = &toa;
+    }
+
+    qAT_PlusCSMP  ( srcId, &fo, &vprel, &vpabs, NULL, &pid, &dcs );
+
+    srcId_cb = srcId;
+    utl_smDtaFromTe ( (UBYTE*)cl,
+                      (USHORT)strlen(cl),
+                      (UBYTE*)msg.data,
+                      &lenMsg,
+                      (UBYTE)fo,
+                      (UBYTE)dcs );
+
+    msg.len = (UBYTE)lenMsg;
+
+#ifndef _CONC_TESTING_
+#ifndef _SIMULATION_
+    ret = sAT_PlusCMGW_Gl( srcId,
+                           CMGW_IDX_FREE_ENTRY,
+                           da, p_toa, stat, NOT_PRESENT_8BIT,
+                           &msg, NULL, NULL, NULL, -1,
+                           NULL, NULL);
+#else
+    ret = sAT_PlusCMGW_Gl( srcId,
+                           CMGW_IDX_FREE_ENTRY,
+                           da, p_toa, stat, NOT_PRESENT_8BIT,
+                           &msg, NULL, sca, p_tosca, isReply,
+                           NULL, NULL);
+#endif
+#else
+    ACI_MALLOC(msg_conc.data, msg.len);
+    memcpy ( msg_conc.data, msg.data, msg.len);
+    msg_conc.len = msg.len;
+#ifndef _SIMULATION_
+    ret = sAT_PlusCMGW ( srcId,
+                         CMGW_IDX_FREE_ENTRY,
+                         da, p_toa, stat, NOT_PRESENT_8BIT,
+                         &msg_conc, NULL, NULL, -1 );
+#else
+    ret = sAT_PlusCMGW ( srcId,
+                         CMGW_IDX_FREE_ENTRY,
+                         da, p_toa, stat, NOT_PRESENT_8BIT,
+                         &msg_conc, sca, p_tosca, isReply );
+#endif
+#endif
+
+    if ( ret NEQ AT_EXCT )
+    {
+      cmdCmsError (CMS_ERR_NotPresent);  // use aciErrDesc
+      return (ATI_FAIL);
+    }
+    /*
+     *  rCI_OK will emitting +CMGW: <index>
+     */
+    return (ATI_EXCT);
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCMGD         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMGD command (delete message from storage)
+*/
+
+GLOBAL T_ATI_RSLT setatPlusCMGD (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN ret = ATI_FAIL;
+  SHORT index=-1;
+  UBYTE status = CMGD_DEL_INDEX;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  src_params->curAtCmd = AT_CMD_CMGD;
+
+  /*input functionality*/
+  if(!cl OR !*cl)
+  {
+    cmdCmsError(CMS_ERR_OpNotAllowed);
+    return ret;
+  }
+
+  cl=parse(cl,"rr",&index,&status);
+  if ( !cl OR (index > 255) OR (index < 0) OR
+    ((status < CMGD_DEL_INDEX) OR (status > CMGD_DEL_ALL)))
+  {
+    cmdCmsError(CMS_ERR_OpNotAllowed);
+    return ret;
+  }
+
+#ifdef FF_ATI_BAT
+  {
+  T_BAT_cmd_send cmd;
+  T_BAT_cmd_set_plus_cmgd my_bat_set_plus_cmgd;
+
+  TRACE_FUNCTION("setatPlusCMGD() calls bat_send() <=== as APPLICATION");
+
+  memset(&my_bat_set_plus_cmgd, 0, sizeof(my_bat_set_plus_cmgd));
+  cmd.ctrl_params = BAT_CMD_SET_PLUS_CMGD;
+  cmd.params.ptr_set_plus_cmgd = &my_bat_set_plus_cmgd;
+
+  my_bat_set_plus_cmgd.index = (U8)index;
+  my_bat_set_plus_cmgd.status = status;
+
+  bat_send(ati_bat_get_client(srcId), &cmd);
+
+  return ATI_EXCT; /* executing, because response is passed by callback function */
+  }
+#else /* OLD FUNCTION BODY */
+
+  TRACE_FUNCTION("setatPlusCMGD()");
+  /*-----------------------------------------------------------------------
+   *  Del flag is greater than zero, set index as Zero so that SMS module 
+   *  starts searching for records satisfying the status from first record
+   *-----------------------------------------------------------------------
+   */
+  if ( status > CMGD_DEL_INDEX )
+  {
+    index = 0;
+  }
+#ifdef _CONC_TESTING_
+  ret = sAT_PlusCMGD(srcId,(UBYTE)index, status);
+#else
+  ret = sAT_PlusCMGD_Gl(srcId, (UBYTE)index, status, NULL, NULL);
+#endif
+
+  if (ret EQ AT_EXCT)
+  {
+    return (ATI_EXCT);
+  }
+  else
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+
+#endif /* no FF_ATI_BAT*/
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCMGC         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMGC command (Send SMS command)
+*/
+
+GLOBAL T_ATI_RSLT tesatPlusCMGC (char *cl, UBYTE srcId)
+{
+  io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+  return ATI_CMPL_NO_OUTPUT;
+}
+
+GLOBAL T_ATI_RSLT queatPlusCMGC (char *cl, UBYTE srcId)
+{
+  cmdCmsError(CMS_ERR_OpNotAllowed); /* querying CMGC not specified in 07.05 */
+  return (ATI_FAIL);
+}
+
+GLOBAL T_ATI_RSLT atPlusCMGC (char *cl, UBYTE srcId)
+#if defined (SMS_PDU_SUPPORT)
+{
+  T_ACI_CMGF_MOD mode;
+
+  /*
+   * request current mode
+   */
+  qAT_PlusCMGF(srcId, &mode);
+  if (mode EQ 0)
+    /*
+     * handle PDU mode
+     */
+    return atPlusCMGCPdu (cl, srcId);
+  else
+    /*
+     * handle Text mode
+     */
+    return atPlusCMGCText (cl, srcId);
+}
+
+LOCAL T_ATI_RSLT atPlusCMGCText(char *cl, UBYTE srcId)
+#endif /* (SMS_PDU_SUPPORT) */
+{
+/*  char           buf[80]; */
+  T_ACI_RETURN   ret = AT_FAIL;
+  T_ACI_TOA      toa;
+  T_ACI_TOA*     p_toa;
+  T_ACI_CMD_DATA cmd;
+  USHORT         lenCmd;
+  CHAR*          da = daBuf;
+
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("atPlusCMGCText()");
+  p_toa=&toa;
+  if (src_params->text_mode EQ CMD_MODE)
+  {
+    memset(da, 0, MAX_SMS_NUM_LEN);
+    fo=-1;
+    ct=-1;
+    pid=-1;
+    mn=-1;
+    toda_val=0;
+    /*input functionality*/
+    da[0]='\0';
+    cl = parse(cl,"rrrrsr",&fo,&ct,&pid,&mn,(LONG)MAX_SMS_NUM_LEN,da,&toda_val);
+
+    if ( !cl OR  fo > 255 OR ct > 255 OR
+          pid > 255 OR mn > 255 OR toda_val > 0xC9 OR da[0] EQ '\0')
+      {
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return (ATI_FAIL);
+      }
+    if(toda_val)
+    {
+      toa = toa_demerge(toda_val);
+      if (toa.ton < 0 OR toa.npi < 0)
+      {
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return (ATI_FAIL);
+      }
+    }
+
+    src_params->text_mode = TXT_MODE;
+    return (ATI_EXCT);
+  } /* end of if (src_params->text_mode EQ CMD_MODE) */
+  else
+  {
+    src_params->text_mode = CMD_MODE;
+    p_toa=&toa;
+    if(toda_val EQ 0)
+    {
+      p_toa = NULL;
+    }
+    else
+    {
+      toa = toa_demerge(toda_val);
+    }
+    if (!(check_str(cl,"0123456789ABCDEF")))
+    {
+      cmdCmsError(CMS_ERR_OpNotAllowed);
+      return (ATI_FAIL);
+    }
+    utl_hexToGsm ( (UBYTE*)cl,
+                   (USHORT)strlen(cl),
+                   (UBYTE*)cmd.data,
+                   &lenCmd,
+                   GSM_ALPHA_Def,
+                   CSCS_ALPHA_8_Bit);
+    cmd.len = (UBYTE)lenCmd;
+
+#ifndef _CONC_TESTING_
+    ret = sAT_PlusCMGC_Gl (srcId,fo,ct,pid,mn,da,p_toa,&cmd,NULL);
+#else
+    ret= sAT_PlusCMGC(srcId,fo,ct,pid,mn,da,p_toa,&cmd);
+#endif
+
+    if ( ret NEQ AT_EXCT )
+    {
+      cmdCmsError (CMS_ERR_NotPresent);  // use aciErrDesc
+      return (ATI_FAIL);
+    }
+    /*
+     *  rCI_OK will emitting +CMGC: <mr>[,<scts>]
+     */
+    return (ATI_EXCT);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCMGL         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMGL command (List Messages)
+*/
+
+GLOBAL T_ATI_RSLT queatPlusCMGL (char *cl, UBYTE srcId)
+{
+  TRACE_FUNCTION("queatPlusCMGL()");
+    cmdCmsError ( CMS_ERR_OpNotAllowed );
+    return (ATI_FAIL);
+}
+
+GLOBAL T_ATI_RSLT tesatPlusCMGL (char *cl, UBYTE srcId)
+{
+#ifdef SMS_PDU_SUPPORT
+  T_ACI_CMGF_MOD mode;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("tesatPlusCMGL()");
+  /*
+   * request current mode
+   */
+  qAT_PlusCMGF(srcId, &mode);
+  if (mode EQ 0)
+  /*
+   * handle PDU mode
+   */
+    io_sendMessage(srcId, "+CMGL: (0,1,2,3,4)", ATI_NORMAL_OUTPUT);
+  else
+  /*
+   * handle Text mode
+   */
+#endif
+   io_sendMessage(srcId, "+CMGL: (\"REC UNREAD\",\"REC READ\",\"STO UNSENT\",\"STO SENT\",\"ALL\")", ATI_NORMAL_OUTPUT);
+
+  return (ATI_CMPL);
+}
+
+GLOBAL T_ATI_RSLT atPlusCMGL (char *cl, UBYTE srcId)
+{
+#ifndef FF_ATI_BAT
+  T_ACI_RETURN   ret;
+#endif
+
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+#ifdef SMS_PDU_SUPPORT
+  T_ACI_CMGF_MOD mode;
+#endif
+  CHAR           txtStat[15];
+  USHORT         i;
+
+  TRACE_FUNCTION("atPlusCMGL()");
+
+
+  if (*cl EQ '\0')
+  {
+    cmglStat = SMS_STAT_NotPresent;
+#ifdef WIN32
+    smsReadMode  = SMS_READ_Normal;
+#endif
+  }
+  else
+  {
+    /*
+     * Request of a list of stored SMS messages
+     * Parameter stat is optional
+     */
+#ifdef SMS_PDU_SUPPORT
+    /*
+     * request current mode
+     */
+    qAT_PlusCMGF(srcId, &mode);
+    if (mode EQ 0)
+    {
+#ifndef WIN32
+      /*
+       * On the target is the definition according GSM 7.05 CMGL=[stat]
+       */
+      cmglStat = SMS_STAT_All;
+      cl = parse (cl, "d", &cmglStat);
+      if ( !cl OR cmglStat < SMS_STAT_RecUnread OR cmglStat > SMS_STAT_All)
+      {
+        cmdCmsError ( CMS_ERR_OpNotAllowed );
+        return NULL;
+      }
+#else
+      /*
+       * Under Windows the definition is CMGL=[stat],[preview]
+       * to test the capabilities of the functional interface
+       */
+      cl = parse (cl, "dd", &cmglStat, &smsReadMode );
+      if ( !cl OR ((cmglStat < SMS_STAT_RecUnread OR cmglStat > SMS_STAT_All)
+           AND smsReadMode  EQ SMS_READ_NotPresent))
+      {
+        cmdCmsError ( CMS_ERR_OpNotAllowed );
+        return (ATI_FAIL);
+      }
+#endif
+    }
+    else
+#endif
+    {
+#ifndef WIN32
+      /*
+       * On the target is the definition according GSM 7.05 CMGL=[stat]
+       */
+      cl = parse (cl, "s", (LONG)sizeof(txtStat), txtStat);
+      if ( !cl OR txtStat[0] EQ '\0')
+      {
+        cmdCmsError ( CMS_ERR_OpNotAllowed );
+        return (ATI_FAIL);
+      }
+#else
+      /*
+       * Under Windows the definition is CMGL=[stat],[preview]
+       * to test the capabilities of the functional interface
+       */
+      cl = parse (cl, "sd", (LONG)sizeof(txtStat), txtStat, &smsReadMode );
+      if ( !cl OR (txtStat[0] EQ '\0' AND smsReadMode  EQ SMS_READ_NotPresent))
+      {
+        cmdCmsError ( CMS_ERR_OpNotAllowed );
+        return (ATI_FAIL);
+      }
+      if (txtStat[0] EQ '\0')
+        strcpy (txtStat, sms_stat[4].name); /* ALL as default */
+#endif
+      i = 0;
+      while ( sms_stat[i].name NEQ NULL            AND
+              strcmp ( sms_stat[i].name, txtStat ) NEQ 0 )
+        i++;
+
+      if ( sms_stat[i].name EQ NULL )
+      {
+        cmdCmsError ( CMS_ERR_OpNotAllowed );
+        return (ATI_FAIL);
+      }
+
+      cmglStat = sms_stat[i].stat;
+    }
+  }
+
+#ifdef FF_ATI_BAT
+
+  {
+    T_BAT_cmd_send cmd;
+    T_BAT_cmd_set_plus_cmgl cmgl;
+
+    cmd.ctrl_params=BAT_CMD_SET_PLUS_CMGL;
+    cmd.params.ptr_set_plus_cmgl=&cmgl;
+
+    /*
+    *   T_ACI_SMS_STAT and T_BAT_plus_cmgl_stat are not quite
+    *   identical - the ACI version has the extra value
+    *   SMS_STAT_Invalid.
+    */
+    if (cmglStat EQ SMS_STAT_Invalid)
+      cmgl.stat=BAT_CMGL_STAT_NOT_PRESENT;
+    else
+      cmgl.stat=(T_BAT_plus_cmgl_stat)cmglStat;
+
+    bat_send(ati_bat_get_client(srcId),&cmd);
+
+    src_params->curAtCmd=AT_CMD_CMGL;
+    return(ATI_EXCT);
+  }
+
+#else
+
+  /*
+   * Request the first five SMS messages
+   */
+#ifndef WIN32
+  ret = sAT_PlusCMGL ( srcId, cmglStat, 0, SMS_READ_Normal );
+#else
+  ret = sAT_PlusCMGL ( srcId, cmglStat, 0, smsReadMode  );
+#endif
+
+  if ( ret EQ AT_EXCT )
+  {
+    src_params->curAtCmd = AT_CMD_CMGL;
+    return (ATI_EXCT);
+  }
+  else
+  {
+    cmdCmsError ( CMS_ERR_NotPresent );  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+
+#endif /*FF_ATI_BAT*/
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPlusCNMI         |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CNMI command (new messgae indication settings )
+*/
+
+GLOBAL T_ATI_RSLT  atPlusCNMI (char *cl, UBYTE srcId)
+{
+  T_ACI_CNMI_MT  mt   = CNMI_MT_NotPresent;
+  T_ACI_CNMI_BM  bm   = CNMI_BM_NotPresent;
+  T_ACI_CNMI_DS  ds   = CNMI_DS_NotPresent;
+  T_ACI_CNMI_MOD mode = CNMI_MOD_NotPresent;
+  T_ACI_CNMI_BFR bfr  = CNMI_BFR_NotPresent;
+  T_ACI_RETURN   ret  = AT_FAIL;
+
+  TRACE_FUNCTION("atPlusCNMI()");
+
+  /* input functionality */
+  cl = parse ( cl, "ddddd", &mode, &mt, &bm, &ds, &bfr );
+
+  if ( !cl                              OR
+        mode <  CNMI_MOD_NotPresent     OR
+        mode >  CNMI_MOD_BufferAndFlush OR
+        bfr  <  CNMI_BFR_NotPresent     OR
+        bfr  >  CNMI_BFR_Clear          OR
+      ( bfr  EQ CNMI_BFR_Flush          AND
+        strlen ( cl ) > 0                   ) )
+  {
+      io_sendConfirm ( srcId, cmdCmsError ( CMS_ERR_OpNotAllowed ), ATI_ERROR_OUTPUT );
+      cmdErrStr = NULL;
+      return ATI_FAIL_NO_OUTPUT;
+  }
+
+  ret = sAT_PlusCNMI ( srcId, mt, bm, ds );
+  if ( (ret EQ AT_FAIL) OR (ret EQ AT_BUSY) )
+  {
+    io_sendConfirm ( srcId, cmdCmsError ( CMS_ERR_NotPresent ), ATI_ERROR_OUTPUT );
+    cmdErrStr = NULL;
+    return ATI_FAIL_NO_OUTPUT;
+  }
+
+  /* 
+   *----------------------Issue 25033--------------------------------
+   * The source ID issuing the CNMI command is stored and henceforth 
+   * all the unsolicited SMS indications are sent to this source 
+   *-----------------------------------------------------------------
+   */
+  if(srcId NEQ CMD_SRC_LCL)
+	  smsShrdPrm.smsSrcId = srcId;
+
+  if ( bfr  NEQ CNMI_BFR_NotPresent )
+    at.CNMI_bfr  = ( UBYTE ) bfr;
+
+  if ( mode NEQ CNMI_MOD_NotPresent )
+    at.CNMI_mode = ( UBYTE ) mode;
+
+  if (mode EQ CNMI_MOD_DiscardOrForward OR  /* 07.05:3.4.1: check for <mode> 1...3  */
+      mode EQ CNMI_MOD_BufferAndFlush)
+  {
+    if ( at.CNMI_bfr EQ CNMI_BFR_Flush )
+    {
+      io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+      cmdErrStr = NULL;
+
+      if( smsShrdPrm.CSMSservice NEQ CSMS_SERV_GsmPh2Plus )
+      {
+        cmd_flushCnmiBuf();
+      }
+      else
+      {
+        cmd_flushCnmiBufOneByOne();
+      }
+      return ATI_CMPL_NO_OUTPUT;
+    }
+    else
+    {
+      cmd_clearCnmiBuf ();
+    }
+  }
+
+  io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+  cmdErrStr = NULL;
+
+  return ATI_CMPL_NO_OUTPUT;
+}
+
+GLOBAL T_ATI_RSLT  tesatPlusCNMI (char *cl, UBYTE srcId)
+{
+  /* query parameter ranges */
+  io_sendMessage ( srcId, "+CNMI: (0-2),(0-3),(0,2),(0,1),(0,1)", ATI_NORMAL_OUTPUT );
+  io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+  cmdErrStr = NULL;
+
+  return ATI_CMPL_NO_OUTPUT;
+}
+
+GLOBAL T_ATI_RSLT  queatPlusCNMI (char *cl, UBYTE srcId)
+{
+  char*          me   = "+CNMI: ";
+  T_ACI_CNMI_MT  mt   = CNMI_MT_NotPresent;
+  T_ACI_CNMI_BM  bm   = CNMI_BM_NotPresent;
+  T_ACI_CNMI_DS  ds   = CNMI_DS_NotPresent;
+  T_ACI_CNMI_MOD mode = CNMI_MOD_NotPresent;
+  T_ACI_CNMI_BFR bfr  = CNMI_BFR_NotPresent;
+
+  if ( qAT_PlusCNMI ( srcId, &mt, &bm, &ds ) EQ AT_CMPL )
+  {
+    sprintf ( g_sa,"%s%d,%d,%d,%d,%d", me, at.CNMI_mode,
+                                     mt, bm, ds, at.CNMI_bfr );
+    io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
+  }
+  else
+  {
+    io_sendConfirm ( srcId, cmdCmsError ( CMS_ERR_NotPresent ), ATI_ERROR_OUTPUT );
+    cmdErrStr = NULL;
+    return ATI_FAIL_NO_OUTPUT;
+  }
+
+  io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT );
+  cmdErrStr = NULL;
+  return ATI_CMPL_NO_OUTPUT;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : setatPercentCPRSM  |
++--------------------------------------------------------------------+
+
+  PURPOSE : %CPRSM set command 
+            set the receiving of SMS to 
+            1 -- Pause    or  
+            2 -- Resume
+           
+*/
+
+GLOBAL T_ATI_RSLT setatPercentCPRSM (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN ret     = AT_FAIL;
+  T_ACI_CPRSM_MOD mode = CPRSM_MOD_NotPresent;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  src_params->curAtCmd = AT_CMD_CPRSM;
+  
+  /* parse command */
+  cl = parse (cl, "d", &mode);
+
+  /* check whether parsing has been successful */ 
+  if (!cl)
+  {
+    /* undefined value for mode */
+    TRACE_EVENT("+CPRSM ERROR: parse cmd failed!");
+    cmdCmsError(CMS_ERR_OpNotAllowed);
+    return ATI_FAIL;    
+  }
+
+#ifdef FF_ATI_BAT
+  {
+  T_BAT_cmd_send cmd;
+  T_BAT_cmd_set_percent_cprsm my_bat_set_percent_cprsm;
+
+  TRACE_FUNCTION("setatPercentCPRSM() calls bat_send() <=== as APPLICATION");
+
+  memset(&my_bat_set_percent_cprsm, 0, sizeof(my_bat_set_percent_cprsm));
+  cmd.ctrl_params = BAT_CMD_SET_PERCENT_CPRSM;
+  cmd.params.ptr_set_percent_cprsm = &my_bat_set_percent_cprsm;
+
+  my_bat_set_percent_cprsm.mode = mode;
+
+  bat_send(ati_bat_get_client(srcId), &cmd);
+
+  return ATI_EXCT; /* executing, because response is passed by callback function */
+  }
+#else /* OLD FUNCTION BODY */
+
+  TRACE_FUNCTION("setatPercentCPRSM()");
+
+  switch (mode) /* check which mode has to be set and set it */ 
+  {
+    case(CPRSM_MOD_Resume):
+    case(CPRSM_MOD_Pause):
+    {     
+      /* AT interface function called */
+      ret = sAT_PercentCPRSM(srcId, mode);
+      break;
+    }
+    default:
+      /* undefined value for mode */
+      TRACE_EVENT_P1("+CPRSM ERROR: undefined value for mode: %d", mode);
+      cmdCmsError(CMS_ERR_OpNotSup);
+      return ATI_FAIL;
+  }
+
+  /* check result */
+  switch (ret)
+  {
+    case (AT_CMPL):
+      /* operation successfully completed */
+      break;
+    case (AT_EXCT):
+      /* operation still executing */
+      src_params->curAtCmd = AT_CMD_COPS;
+      break;
+    default:
+      /* unknown result type */
+      TRACE_EVENT_P1("+CPRSM ERROR: undefined result: %d", ret);
+      cmdCmsError(CMS_ERR_UnknownErr);  /*Command failed*/
+      return ATI_FAIL;
+  }
+
+  /* map error to ATI type and return */ 
+  return (map_aci_2_ati_rslt(ret)); 
+
+#endif /* no FF_ATI_BAT*/
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : queatPercentCPRSM  |
++--------------------------------------------------------------------+
+
+  PURPOSE : %CPRSM query command 
+            request the current state of the pause flag for receiving SMS
+*/
+
+GLOBAL T_ATI_RSLT queatPercentCPRSM (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN ret = ATI_FAIL;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("queatPercentCPRSM()");
+
+  ret = qAT_PercentCPRSM( srcId );
+
+
+  if (ret EQ AT_EXCT)
+  {
+    src_params->curAtCmd = AT_CMD_CPRSM;
+    return (ATI_EXCT);
+  }
+  else
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+    return (ATI_FAIL);
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : cmd_clearCnmiBuf   |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function clears the buffer for storing new message
+            indications while the serial interface is reserved for
+            data transmission.
+*/
+GLOBAL void cmd_clearCnmiBuf (void)
+{
+  UBYTE i;
+
+  for ( i = 0; i < CNMI_BUF_SIZE; i++ )
+    cnmiBuf.sCnmiElement[i].type = CNMI_NONE;
+
+  cnmiBuf.next = 0;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : cmd_flushCnmiBuf   |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function flushes the buffer for storing new message
+            indications while the serial interface is released from
+            data transmission.
+*/
+GLOBAL void cmd_flushCnmiBuf (void)
+{
+  UBYTE i            = cnmiBuf.next;
+  UBYTE entries_read = 0;
+
+  TRACE_FUNCTION("cmd_flushCnmiBuf");
+
+  if ( cnmiBuf.sCnmiElement[0].type EQ CNMI_NONE )
+  {
+    entries_read = CNMI_BUF_SIZE; /* no need to read anything at all */
+    //moreEntries = FALSE;
+  }
+  else if ( cnmiBuf.next                            EQ CNMI_BUF_SIZE OR
+            cnmiBuf.sCnmiElement[cnmiBuf.next].type EQ CNMI_NONE )
+  {
+    i = 0;
+  }
+
+  cnmiFlushInProgress = TRUE;
+
+  while ( entries_read < CNMI_BUF_SIZE /*moreEntries*/ )
+  {
+    if (smsShrdPrm.pDecMsg)
+    { /* clear p_sm buffer */
+      ACI_MFREE(smsShrdPrm.pDecMsg);
+      smsShrdPrm.pDecMsg = NULL;
+    }
+
+    switch ( cnmiBuf.sCnmiElement[i].type )
+    {
+      
+      case ( CNMI_CMT ):
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCMT ( &cnmiBuf.sCnmiElement[i].indct.cmt );
+        break;
+
+      case ( CNMI_CMTI ):
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCMTI ( cnmiBuf.sCnmiElement[i].indct.cmti.mem,
+                       cnmiBuf.sCnmiElement[i].indct.cmti.index );
+        break;
+
+      case ( CNMI_CBM ):
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCBM (  &cnmiBuf.sCnmiElement[i].indct.cbm );
+        break;
+
+      case ( CNMI_CDS ):
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCDS (  &cnmiBuf.sCnmiElement[i].indct.cds );
+        break;
+
+      default:
+//      moreEntries = FALSE;
+        break;
+    }
+
+    cnmiBuf.sCnmiElement[i].type = CNMI_NONE;
+    i++;
+    entries_read++;
+
+    if ( i EQ CNMI_BUF_SIZE )
+      i = 0;
+  }
+
+  cnmiFlushInProgress = FALSE;
+  cnmiBuf.next        = 0;
+}
+
+/*
++--------------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD                  |
+| STATE   : code                        ROUTINE : cmd_flushCnmiBufOneByOne |
++--------------------------------------------------------------------------+
+
+  PURPOSE : This function flushes the CNMI buffer in case of Phase2+ mode,
+            while the serial interface is released from
+            data transmission or an +CNMI <bfr>==Flush is requested.
+*/
+
+GLOBAL void cmd_flushCnmiBufOneByOne(void)
+{ /* flushing +CMT one by one, because acknowledge is necessary */
+  T_CNMI_BUFFER_ELEMENT* psMsgInCnmiBuffer = NULL;
+  UINT16                 uiCnmiMsgCounter  = 0;
+  BOOL                   bEndLoop          = FALSE;
+
+  for( uiCnmiMsgCounter=0;
+       (uiCnmiMsgCounter<cmd_getNumberOfCnmiEntrys()) && 
+       (waitForCnmaFromBuffer_SrcId EQ CMD_SRC_NONE); 
+       uiCnmiMsgCounter++ )
+  { /* there are entrys in the CNMI buffer --> read it */
+    psMsgInCnmiBuffer = cmd_getCnmiMessage(uiCnmiMsgCounter); /* FIFO */
+
+    if( psMsgInCnmiBuffer EQ NULL )
+    {
+      TRACE_EVENT("ati_switch_mode() : Error at CNMI-buffer handling: NULL-pointer access!!");
+      return;
+    }
+    
+    cnmiFlushInProgress = TRUE; /* needed for the rCI_...commands */
+
+    if (smsShrdPrm.pDecMsg)
+    { /* clear p_sm buffer */
+      ACI_MFREE(smsShrdPrm.pDecMsg);
+      smsShrdPrm.pDecMsg = NULL;
+    }
+
+    switch ( psMsgInCnmiBuffer->type )
+    {
+      case ( CNMI_CMTI ) :
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCMTI ( psMsgInCnmiBuffer->indct.cmti.mem, psMsgInCnmiBuffer->indct.cmti.index );
+        cmd_clearCnmiMessage(uiCnmiMsgCounter);
+        uiCnmiMsgCounter--;
+        break;
+
+      case ( CNMI_CBM ) :
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCBM (  &psMsgInCnmiBuffer->indct.cbm );
+        cmd_clearCnmiMessage(uiCnmiMsgCounter);
+        uiCnmiMsgCounter--;
+        break;
+
+      case ( CNMI_CDS ) :
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCDS (  &psMsgInCnmiBuffer->indct.cds );
+        cmd_clearCnmiMessage(uiCnmiMsgCounter);
+        uiCnmiMsgCounter--;
+        break;
+
+      /* special handling for +CMT --> acknowledge needed */
+      case ( CNMI_CMT ) :
+      {
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCMT ( &psMsgInCnmiBuffer->indct.cmt );
+        TIMERSTART(ACI_CNMA_TIMER_VALUE, ACI_CNMA_TIMER_HANDLE);
+        waitForCnmaFromBuffer_SrcId = smsShrdPrm.smsSrcId;
+        break;
+      }
+      default:
+        TRACE_EVENT("ati_switch_mode() : wrong CNMI-buffer handling: wrong Msg. type");
+    }
+  }
+  cnmiFlushInProgress = FALSE;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : cmd_addCnmiNtry    |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function add a new entry to the buffer for storing
+            new message indications while the serial interface is
+            reserved for data transmission.
+*/
+GLOBAL void cmd_addCnmiNtry ( UBYTE type, T_CNMI_IND* newInd )
+{
+  TRACE_FUNCTION("cmd_addCnmiNtry");
+
+  if ( type > CNMI_CDS OR type < CNMI_CMT )
+    return;
+
+  if ( cnmiBuf.next EQ CNMI_BUF_SIZE )
+  {
+    cnmiBuf.next = 0;
+  }
+
+  switch ( type )
+  {
+    case ( CNMI_CMT ):
+      cnmiBuf.sCnmiElement[cnmiBuf.next].indct.cmt  = newInd -> cmt;
+      break;
+
+    case ( CNMI_CMTI ):
+      cnmiBuf.sCnmiElement[cnmiBuf.next].indct.cmti = newInd -> cmti;
+      break;
+
+
+    case ( CNMI_CBM ):
+      cnmiBuf.sCnmiElement[cnmiBuf.next].indct.cbm  = newInd -> cbm;
+      break;
+
+    case ( CNMI_CDS ):
+      cnmiBuf.sCnmiElement[cnmiBuf.next].indct.cds  = newInd -> cds;
+      break;
+  }
+
+  cnmiBuf.sCnmiElement[cnmiBuf.next].type  = type;
+  cnmiBuf.next++;
+}
+
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD               |
+| STATE   : code                        ROUTINE : getNumberOfCnmiEntrys |
++-----------------------------------------------------------------------+
+
+  PURPOSE : This function is the responsible to get the count 
+            of CNMI entrys in the CNMI buffer.
+*/
+GLOBAL UINT16 cmd_getNumberOfCnmiEntrys(void)
+{
+  return cnmiBuf.next;
+}
+
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD               |
+| STATE   : code                        ROUTINE : getCnmiMessage        |
++-----------------------------------------------------------------------+
+
+  PURPOSE : This function is the responsible to get an entire Msg.
+            from the CNMI buffer. That means, this function only returns
+            the pointer to the beginning of the CNMI buffer element.
+            If the buffer is empty or if the uiIndex parameter is bigger
+            than allowed, the return pointer will be NULL.
+*/
+GLOBAL T_CNMI_BUFFER_ELEMENT* cmd_getCnmiMessage(UINT16 uiIndex)
+{
+  T_CNMI_BUFFER_ELEMENT* psCnmiBufferElement = NULL;
+
+  if( (cnmiBuf.next EQ 0) OR
+      (cnmiBuf.sCnmiElement[0].type EQ CNMI_NONE) OR
+      (uiIndex >= CNMI_BUF_SIZE ) )
+  {
+    return NULL;
+  }
+
+  psCnmiBufferElement = &cnmiBuf.sCnmiElement[uiIndex];
+  return psCnmiBufferElement; /* returns the pointer to the element */
+}
+
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD               |
+| STATE   : code                        ROUTINE : clearFirstCnmiMessage |
++-----------------------------------------------------------------------+
+
+  PURPOSE : This function is the responsible to clear an entire Msg.
+            specified by uiIndex from the CNMI buffer.
+            After succesful return, the message was delete from the CNMI
+            buffer and the buffer has been resorted.
+*/
+GLOBAL BOOL cmd_clearCnmiMessage(UINT16 uiIndex)
+{
+  UINT16 uiBufCount;
+
+  if( (cnmiBuf.next EQ 0) OR
+      (cnmiBuf.sCnmiElement[0].type EQ CNMI_NONE))
+  {
+    return FALSE; /* CNMI buffer is empty or flushing is in progress */
+  }
+
+  /* delete first entry while resorting the buffer */
+  for( uiBufCount = uiIndex; uiBufCount<(CNMI_BUF_SIZE-1); uiBufCount++ )
+  {
+    memcpy( &cnmiBuf.sCnmiElement[uiBufCount], &cnmiBuf.sCnmiElement[uiBufCount+1], sizeof(T_CNMI_BUFFER_ELEMENT) );
+  }
+
+  cnmiBuf.next--;
+
+  return TRUE;
+}
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD               |
+| STATE   : code                        ROUTINE : getCnmiMessage        |
++-----------------------------------------------------------------------+
+
+  PURPOSE : This function is the responsible to get the first entire Msg.
+            from the CNMI buffer. That means, this function only returns
+            the pointer to the beginning of the CNMI buffer.
+            If the buffer is empty, the return pointer will be NULL.
+*/
+GLOBAL T_CNMI_BUFFER_ELEMENT* cmd_getFirstCnmiMessage(void)
+{
+  return cmd_getCnmiMessage(0);
+}
+
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD               |
+| STATE   : code                        ROUTINE : clearFirstCnmiMessage |
++-----------------------------------------------------------------------+
+
+  PURPOSE : This function is the responsible to clear the first entire Msg.
+            from the CNMI buffer. After succesful return, the 
+            message was delete from the CNMI buffer.
+*/
+GLOBAL BOOL cmd_clearFirstCnmiMessage(void)
+{
+  return cmd_clearCnmiMessage(0);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : rCI_IoMode         |
++--------------------------------------------------------------------+
+
+  PURPOSE : This function will be called when IO mode of serial
+            interface has changed.
+*/
+GLOBAL void rCI_IoMode ( void )
+{
+  TRACE_FUNCTION ( "rCI_IoMode (): actually not awaited !!" );
+
+/*  if ( io_getIoMode () EQ IO_MODE_CMD AND
+       at.CNMI_mode    EQ CNMI_MOD_Buffer )
+    cmd_flushCnmiBuf (CMD_SRC_ATI);*/
+}
+
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD               |
+| STATE   : code                        ROUTINE : cmd_handleCnmaTimeout |
++-----------------------------------------------------------------------+
+
+  PURPOSE : This function will be called when the +CNMA Timer has expired.
+            Now all to be acknowledged +CMT messages whithin the CNMI
+            buffer must be stored in the non-volatile buffer e.g. SIM...
+            Note: all other Msgs. different from +CMT will be deliver
+            to the source and remove from buffer. */
+
+GLOBAL void cmd_handleCnmaTimeout( void )
+{
+  UINT16                 uiCnmiMsgCounter  = 0;
+  T_CNMI_BUFFER_ELEMENT *psMsgInCnmiBuffer = NULL;
+
+  TRACE_FUNCTION ( "cmd_handleCnmaTimeout()" );
+
+  cmhSMS_resetMtDsCnmiParam();
+
+  if( waitForCnmaFromBuffer_SrcId EQ CMD_SRC_NONE OR 
+      waitForCnmaFromBuffer_SrcId NEQ smsShrdPrm.smsSrcId)
+  {
+    TRACE_EVENT("cmd_handleCnmaTimeout() : Error at CNMI-buffer handling: No +CNMA acknowledge expected!!");
+    waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE;
+    return;
+  }
+
+  for( uiCnmiMsgCounter=0; uiCnmiMsgCounter<cmd_getNumberOfCnmiEntrys(); uiCnmiMsgCounter++ )
+  { /* there are entrys in the CNMI buffer --> read it */
+    psMsgInCnmiBuffer = cmd_getCnmiMessage(uiCnmiMsgCounter); /* FIFO */
+
+    if( psMsgInCnmiBuffer EQ NULL )
+    {
+      TRACE_EVENT("cmd_handleCnmaTimeout() : Error at CNMI-buffer handling: NULL-pointer access!!");
+      waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE;
+      return;
+    }
+    
+    cnmiFlushInProgress = TRUE;
+
+    switch ( psMsgInCnmiBuffer->type )
+    {
+      case ( CNMI_CMTI ) :
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCMTI ( psMsgInCnmiBuffer->indct.cmti.mem, psMsgInCnmiBuffer->indct.cmti.index );
+        cmd_clearCnmiMessage(uiCnmiMsgCounter);
+        uiCnmiMsgCounter--;
+        break;
+
+      case ( CNMI_CBM ) :
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCBM (  &psMsgInCnmiBuffer->indct.cbm );
+        cmd_clearCnmiMessage(uiCnmiMsgCounter);
+        uiCnmiMsgCounter--;
+        break;
+
+      case ( CNMI_CDS ) :
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCDS (  &psMsgInCnmiBuffer->indct.cds );
+        cmd_clearCnmiMessage(uiCnmiMsgCounter);
+        uiCnmiMsgCounter--;
+        break;
+
+      /* special handling for +CMT --> acknowledge needed */
+      case ( CNMI_CMT ) :
+      {
+        T_ACI_SM_DATA sPduData;
+
+        waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE; /* clear CNMA waiting flag */
+        srcId_cb = smsShrdPrm.smsSrcId;
+        sPduData.len = psMsgInCnmiBuffer->indct.cmt.sms_sdu.l_buf / 8; /* l_buf is in BIT !! */
+        memcpy( &sPduData.data, &psMsgInCnmiBuffer->indct.cmt.sms_sdu.buf, SIM_PDU_LEN );
+        cmhSMS_storePduToSim( smsShrdPrm.smsSrcId, SMS_RECORD_REC_UNREAD, &sPduData );
+        cnmiFlushInProgress = FALSE;
+        return; /* only one SMS can be stored at the SIM here */
+      }
+
+      default:
+        TRACE_EVENT("cmd_handleCnmaTimeout() : wrong CNMI-buffer handling: wrong Msg. type");
+    }
+    cnmiFlushInProgress = FALSE;
+  }
+}
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD               |
+| STATE   : code                        ROUTINE : cmd_handleCnmaTimeout |
++-----------------------------------------------------------------------+
+
+  PURPOSE : This function stores the next message - correxponding
+            to a specified source - into the non volatile memory.
+            Note: all other Msgs. different from +CMT will be deliver
+            to the source and remove from buffer.
+*/
+GLOBAL BOOL cmd_storeNextCnmiBufMsgToSim( void )
+{
+  UINT16                 uiCnmiMsgCounter  = 0;
+  T_CNMI_BUFFER_ELEMENT *psMsgInCnmiBuffer = NULL;
+
+  TRACE_FUNCTION ( "cmd_storeNextCnmiBufMsgToSim()" );
+
+  if( smsShrdPrm.uiInternalSmsStorage EQ CMD_SRC_NONE OR
+      smsShrdPrm.uiInternalSmsStorage NEQ smsShrdPrm.smsSrcId)
+  {
+    TRACE_EVENT("cmd_storeNextCnmiBufMsgToSim() : no valid source -> abort !!");
+    smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE;
+    return(FALSE);
+  }
+
+  for( uiCnmiMsgCounter=0; uiCnmiMsgCounter<cmd_getNumberOfCnmiEntrys(); uiCnmiMsgCounter++ )
+  { /* there are entrys in the CNMI buffer --> read it */
+    psMsgInCnmiBuffer = cmd_getCnmiMessage(uiCnmiMsgCounter); /* FIFO */
+
+    if( psMsgInCnmiBuffer EQ NULL )
+    {
+      TRACE_EVENT("cmd_storeNextCnmiBufMsgToSim() : Error at CNMI-buffer handling: NULL-pointer access!!");
+      smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE;
+      return(FALSE);
+    }
+    
+    cnmiFlushInProgress = TRUE;
+
+    switch ( psMsgInCnmiBuffer->type )
+    {
+      case ( CNMI_CMTI ) :
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCMTI ( psMsgInCnmiBuffer->indct.cmti.mem, psMsgInCnmiBuffer->indct.cmti.index );
+        cmd_clearCnmiMessage(uiCnmiMsgCounter);
+        uiCnmiMsgCounter--;
+        break;
+
+      case ( CNMI_CBM ) :
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCBM (  &psMsgInCnmiBuffer->indct.cbm );
+        cmd_clearCnmiMessage(uiCnmiMsgCounter);
+        uiCnmiMsgCounter--;
+        break;
+
+      case ( CNMI_CDS ) :
+        srcId_cb = smsShrdPrm.smsSrcId;
+        rCI_PlusCDS (  &psMsgInCnmiBuffer->indct.cds );
+        cmd_clearCnmiMessage(uiCnmiMsgCounter);
+        uiCnmiMsgCounter--;
+        break;
+
+      /* special handling for +CMT --> acknowledge needed */
+      case ( CNMI_CMT ) :
+      {
+        T_ACI_SM_DATA sPduData;
+
+        srcId_cb = smsShrdPrm.smsSrcId;
+        sPduData.len = psMsgInCnmiBuffer->indct.cmt.sms_sdu.l_buf / 8; /* l_buf is in BIT !! */
+        memcpy( &sPduData.data, &psMsgInCnmiBuffer->indct.cmt.sms_sdu.buf, SIM_PDU_LEN );
+        cmhSMS_storePduToSim( smsShrdPrm.smsSrcId, SMS_RECORD_REC_UNREAD, &sPduData );
+        cnmiFlushInProgress = FALSE;
+        return(TRUE); /* only one SMS can be stored at the SIM here */
+      }
+
+      default:
+        TRACE_EVENT("cmd_handleCnmaTimeout() : wrong CNMI-buffer handling: wrong Msg. type");
+    }
+    cnmiFlushInProgress = FALSE;
+  }
+  smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; /* no more +CMT has to be store */
+  return(FALSE);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : setatPlusCMMS      |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMMS command (More Messages To Send)
+*/
+
+GLOBAL T_ATI_RSLT setatPlusCMMS (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN ret = AT_FAIL;
+  UBYTE        mode = 0;
+
+  TRACE_FUNCTION("setatPlusCMMS()");
+
+  cl = parse (cl,"r",&mode);
+
+  /*
+   * no mode values allowed other than 0-2
+   */
+  if ( !cl OR (mode < CMMS_MODE_DEF OR mode > CMMS_MODE_TWO))
+  {
+    cmdCmsError(CMS_ERR_OpNotAllowed);
+    return (ATI_FAIL);
+  }
+  ret = sAT_PlusCMMS(srcId,mode);
+  if (ret NEQ AT_CMPL)
+  {
+    cmdCmsError(CMS_ERR_UnknownErr);  
+    return (ret);
+  }
+  return (map_aci_2_ati_rslt(ret));
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : queatPlusCMMS      |
++--------------------------------------------------------------------+
+
+  PURPOSE : +CMMS query command 
+*/
+GLOBAL T_ATI_RSLT queatPlusCMMS (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN  ret = AT_FAIL;
+  UBYTE         mode = CMMS_MODE_DEF;
+  
+  TRACE_FUNCTION("queatPlusCMMS()");
+
+  ret = qAT_PlusCMMS (srcId,&mode);
+  if (ret EQ AT_CMPL)
+  {
+    sprintf(g_sa, "+CMMS: %d",  mode);
+    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
+    return (ATI_CMPL);
+  }
+  else
+  {
+    cmdCmsError(CMS_ERR_NotPresent);  
+    return (ATI_FAIL);
+  }
+}
+
+/*
++-------------------------------------------------------------------------+
+| PROJECT : GSM-F&D                      MODULE  : ATI_SMS                |
+| STATE   : finished                     ROUTINE : txt_rdmode_to_smsrdmode|
++-------------------------------------------------------------------------+
+
+  PURPOSE : converts the text read mode to smsReadMode.
+
+*/
+GLOBAL T_ATI_RSLT txt_rdmode_to_smsrdmode(char *txt_rdmode)
+{
+  UBYTE i = 0;
+
+   if (txt_rdmode[0] EQ '\0')
+   {
+     strcpy (txt_rdmode, sms_rdmode[0].name); /* NORMAL as default */
+   }
+   while ( sms_rdmode[i].name NEQ NULL      AND
+              strcmp ( sms_rdmode[i].name, txt_rdmode ) NEQ 0 )
+   {
+      i++;
+   }
+
+   if ( sms_rdmode[i].name EQ NULL )
+   {
+      cmdCmsError ( CMS_ERR_OpNotAllowed );
+      return (ATI_FAIL);
+   }
+   smsReadMode  = sms_rdmode[i].rdmode;
+   return ATI_CMPL;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPercentCMGL      |
++--------------------------------------------------------------------+
+
+  PURPOSE : %CMGL command (List Message)
+*/
+
+GLOBAL T_ATI_RSLT atPercentCMGL (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN   ret;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+#ifdef SMS_PDU_SUPPORT
+  T_ACI_CMGF_MOD mode;
+#endif
+  CHAR           txtStat[15]= {0};
+  CHAR           txtRdMode[20] = {0};
+  USHORT         i;
+
+  TRACE_FUNCTION("atPercentCMGL()");
+
+  cmglStat = SMS_STAT_NotPresent;
+  smsReadMode  = SMS_READ_NotPresent;
+
+  if (*cl EQ '\0')
+  {
+    smsReadMode  = SMS_READ_Normal;
+  }
+  else
+  {
+    /*
+     * Request of a list of stored SMS messages
+     * Parameter stat is optional
+     */
+#ifdef SMS_PDU_SUPPORT
+    /*
+     * request current mode
+     */
+    qAT_PlusCMGF(srcId, &mode);
+    if (mode EQ 0)
+    {
+
+      /*
+       * %CMGL=[stat],[preview]
+       */
+      cl = parse (cl, "dd", &cmglStat, &smsReadMode );
+      if ( !cl 
+            OR ((cmglStat < SMS_STAT_RecUnread OR cmglStat > SMS_STAT_All)
+                  AND smsReadMode  EQ SMS_READ_NotPresent) 
+            OR (cmglStat < SMS_STAT_RecUnread AND smsReadMode > SMS_READ_NotPresent) 
+            OR (smsReadMode  > SMS_READ_StatusChange))
+      {
+        cmdCmsError ( CMS_ERR_OpNotAllowed );
+        return (ATI_FAIL);
+      }
+    }
+    else
+#endif
+    {
+
+      /*
+       * %CMGL=[stat],[preview]
+       */
+      cl = parse (cl, "ss", (LONG)sizeof(txtStat), txtStat, 
+                  (LONG)sizeof(txtRdMode), txtRdMode);
+      if ( !cl OR (txtStat[0] EQ '\0' AND txtRdMode[0] NEQ '\0'))
+      {
+        cmdCmsError ( CMS_ERR_OpNotAllowed );
+        return (ATI_FAIL);
+      }
+      if (txtStat[0] EQ '\0')
+        strcpy (txtStat, sms_stat[4].name); /* ALL as default */
+
+      i = 0;
+      while ( sms_stat[i].name NEQ NULL            AND
+              strcmp ( sms_stat[i].name, txtStat ) NEQ 0 )
+        i++;
+
+      if ( sms_stat[i].name EQ NULL )
+      {
+        cmdCmsError ( CMS_ERR_OpNotAllowed );
+        return (ATI_FAIL);
+      }
+      cmglStat = sms_stat[i].stat;
+
+      ret = txt_rdmode_to_smsrdmode(txtRdMode);
+      if (ret EQ ATI_FAIL)
+      {
+        return (ret);
+      }
+    }
+  }
+
+#ifdef FF_ATI_BAT
+  {
+    T_BAT_cmd_send cmd;
+    T_BAT_cmd_set_percent_cmgl cmgl;
+
+    cmd.ctrl_params=BAT_CMD_SET_PERCENT_CMGL;
+    cmd.params.ptr_set_percent_cmgl=&cmgl;
+
+    /*
+    *   T_ACI_SMS_STAT and T_BAT_percent_cmgl_stat are not quite
+    *   identical - the ACI version has the extra value
+    *   SMS_STAT_Invalid.
+    */
+    if (cmglStat EQ SMS_STAT_Invalid)
+      cmgl.stat=BAT_CMGL_STAT_NOT_PRESENT;
+    else
+      cmgl.stat=(T_BAT_percent_cmgl_stat)cmglStat;
+
+    cmgl.rdmode = smsReadMode ;
+
+    bat_send(ati_bat_get_client(srcId),&cmd);
+
+    src_params->curAtCmd=AT_CMD_P_CMGL;
+    return(ATI_EXCT);
+  }
+
+#else
+
+  ret = sAT_PercentCMGL ( srcId, cmglStat, smsReadMode  );
+
+  if ( ret EQ AT_EXCT )
+  {
+    src_params->curAtCmd = AT_CMD_P_CMGL;
+    return (ATI_EXCT);
+  }
+  else
+  {
+    cmdCmsError ( CMS_ERR_NotPresent );  
+    return (ATI_FAIL);
+  }
+#endif
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-F&D (8411)              MODULE  : ACI_CMD            |
+| STATE   : code                        ROUTINE : atPercentCMGR         |
++--------------------------------------------------------------------+
+
+  PURPOSE : %CMGR command (Read Message)
+*/
+
+GLOBAL T_ATI_RSLT atPercentCMGR (char *cl, UBYTE srcId)
+{
+  T_ACI_RETURN ret = AT_FAIL;
+  SHORT idx=-1;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+#ifdef SMS_PDU_SUPPORT
+  T_ACI_CMGF_MOD mode;
+#endif
+  CHAR           txtRdMode[20]={0};
+
+
+  TRACE_FUNCTION("atPercentCMGR()");
+
+  smsReadMode  = SMS_READ_Normal;
+
+#ifdef SMS_PDU_SUPPORT
+    /*
+     * request current mode
+     */
+    qAT_PlusCMGF(srcId, &mode);
+    if (mode EQ 0)
+    {
+      /*
+       * %CMGR=[index],[preview]
+       */
+      cl = parse (cl, "rd", &idx, &smsReadMode );
+      if ( !cl OR idx > 255 OR idx < 0 OR smsReadMode  > SMS_READ_StatusChange)
+      {
+        cmdCmsError ( CMS_ERR_OpNotAllowed );
+        return (ATI_FAIL);
+      }
+    }
+    else
+#endif
+    {
+      /*
+       * %CMGR=[index],[preview]
+       */
+      cl = parse (cl, "rs", &idx, 
+                  (LONG)sizeof(txtRdMode), txtRdMode);
+  
+      if ( !cl OR idx > 255 OR idx < 0)
+      {
+        cmdCmsError(CMS_ERR_OpNotAllowed);
+        return (ATI_FAIL);
+      }
+      ret = txt_rdmode_to_smsrdmode(txtRdMode);
+      if (ret EQ ATI_FAIL)
+      {
+        return (ret);
+      }
+    }
+
+#ifdef FF_ATI_BAT
+  {
+    T_BAT_cmd_send cmd;
+    T_BAT_cmd_set_percent_cmgr cmgr;
+
+    cmd.ctrl_params=BAT_CMD_SET_PERCENT_CMGR;
+    cmd.params.ptr_set_percent_cmgr=&cmgr;
+
+    cmgr.sms_index=(U16)idx;
+    
+    cmgr.rdmode = smsReadMode ;
+
+    bat_send(ati_bat_get_client(srcId), &cmd);
+
+    src_params->curAtCmd=AT_CMD_P_CMGR;
+    return(ATI_EXCT);
+  }
+
+#else
+
+#ifndef _CONC_TESTING_
+  ret = sAT_PercentCMGR_Gl(srcId, (UBYTE)idx, smsReadMode , NULL);
+#else
+  ret = sAT_PercentCMGR (srcId, (UBYTE)idx, smsReadMode );
+#endif
+ if ( ret EQ AT_CMPL )
+ {
+   return (ATI_CMPL);
+ }
+ else if (ret EQ AT_EXCT)
+ {
+   src_params->curAtCmd    = AT_CMD_P_CMGR;
+   return (ATI_EXCT);
+ }
+ else
+ {
+   cmdCmsError(CMS_ERR_NotPresent);  // use aciErrDesc
+   return (ATI_FAIL);
+ }
+
+#endif /*FF_ATI_BAT*/
+}
+
+GLOBAL T_ATI_RSLT tesatPercentCMGL (char *cl, UBYTE srcId)
+{
+#ifdef SMS_PDU_SUPPORT
+  T_ACI_CMGF_MOD mode;
+  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
+
+  TRACE_FUNCTION("tesatPercentCMGL()");
+  /*
+   * request current mode
+   */
+  qAT_PlusCMGF(srcId, &mode);
+  if (mode EQ 0)
+  /*
+   * handle PDU mode
+   */
+    io_sendMessage(srcId, "+CMGL: (0,1,2,3,4), (0,1,2)", ATI_NORMAL_OUTPUT);
+  else
+  /*
+   * handle Text mode
+   */
+#endif
+   io_sendMessage(srcId, "+CMGL: (\"REC UNREAD\",\"REC READ\",\"STO UNSENT\",\"STO SENT\",\"ALL\"), \
+                                 (\"READ NORMAL\",\"READ PREVIEW\",\"STATUS CHANGE\")", ATI_NORMAL_OUTPUT);
+
+  return (ATI_CMPL);
+}
+
+#endif /* ATI_SMS_C */