fc-magnetite: src/aci2/aci/ati

comparison src/aci2/aci/ati_sms.c @ 3:93999a60b835

src/aci2, src/condat2: import of g23m/condat source pieces from TCS211

author	Mychaela Falconia <falcon@freecalypso.org>
date	Mon, 26 Sep 2016 00:29:36 +0000
parents
children

comparison

equal deleted inserted replaced

-:c41a534f33c6
+:93999a60b835
+/*
++-----------------------------------------------------------------------------
+|  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 */

FreeCalypso > hg > fc-magnetite

comparison src/aci2/aci/ati_sms.c @ 3:93999a60b835