/*
+-----------------------------------------------------------------------------
|  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 Call-Back Functions
+-----------------------------------------------------------------------------
*/

#ifndef ATI_RET_C
#define ATI_RET_C

#include "aci_all.h"  /* defines FF_TIMEZONE */

#include "line_edit.h"
#include "aci_cmh.h"  /* uses FF_TIMEZONE    */
#include "ati_cmd.h"
#include "aci_cmd.h"
#include "aci_io.h"
#include "p_aci.h"
#include "aci.h"
#include "l4_tim.h"
#include "ksd.h"

#include "psa.h"
#include "psa_sms.h"
#include "psa_sim.h"
#include "cmh.h"
#include "cmh_sms.h"
#include "psa_cc.h"
#include "psa_ss.h"
#include "cmh_ss.h"
#include "cmh_cc.h"
#include "cmh_mm.h"

#include "psa_util.h"
#include "cmh_mm.h"

#ifdef DTI
#include "dti.h"      /* functionality of the dti library */
#endif
#include "dti_conn_mng.h"

#ifdef GPRS
  #include "gaci.h"
  #include "gaci_cmh.h"
  #include "psa_sm.h"
  #include "cmh_sm.h"
#endif  /* GPRS */

#include "aci_mem.h"

#include "aci_lst.h"
#ifdef UART
#include "psa_uart.h"
#include "cmh_uart.h"
#endif
#include "conc_sms.h"

#ifdef FF_PSI
#include "psa_psi.h"
#include "cmh_psi.h"
#endif /*FF_PSI*/

#ifdef GPRS
#include "gaci_cmd.h"
#endif
#include "aci_cmd.h"

#if defined FF_EOTD
#include "cmh_lc.h"
#endif

#include "ati_int.h"

#ifdef ACI
#include "cmh_mmi.h"
#endif /* ACI */

#ifdef FF_ATI

GLOBAL  T_CIEV_SIGNAL_BUFFER  asCievSignalBuf;
GLOBAL  T_CIEV_SMSFULL_BUFFER asCievSmsFullBuf;

EXTERN CHAR *CPIN_RESULT(T_ACI_CPIN_RSLT code);
EXTERN UBYTE src_id_ext; /* this source runs currently an extension command */

EXTERN T_ATI_IO_MODE ati_get_mode  (UBYTE srcId );
EXTERN T_ATI_RSLT ati_execute_cmd_line (T_ATI_SRC_PARAMS *src_params);

/* 
 *  needed for rCI_Z 
 */
EXTERN void ati_cmd_reset          (UBYTE srcId);
EXTERN void ati_zn_retrieve_params ( UBYTE srcId );


LOCAL UBYTE aci_writeCnumMsisdn (UBYTE srcId, T_ACI_CNUM_MSISDN* msisdn );
LOCAL void aci_frmtOutput  ( UBYTE fo,
                             UBYTE dcs,
                             T_ACI_SM_DATA *data );

LOCAL  void  r_Plus_Percent_COPS( T_ACI_AT_CMD cmd,
                            SHORT lastIdx,
                            T_ACI_COPS_OPDESC * operLst);
/*
typedef struct
{
  char *name;
  T_ACI_CPWD_FAC fac;
} net_fac; */

LOCAL BOOL  allowCCCM = TRUE;
LOCAL UBYTE callTime  = 0;

LOCAL const SMS_Memory sms_mem [] =

{
  {"ME",  SMS_STOR_Me},
  {"me",  SMS_STOR_Me},
  {"SM",  SMS_STOR_Sm},
  {"sm",  SMS_STOR_Sm},
  {0,0}
};

#if defined (SMS_PDU_SUPPORT)

LOCAL void rCI_PlusCMTText  ( T_MNSMS_MESSAGE_IND * mnsms_message_ind);
LOCAL void rCI_PlusCDSText ( T_MNSMS_STATUS_IND * mnsms_status_ind );
LOCAL void rCI_PlusCBMText ( T_MMI_CBCH_IND     * mmi_cbch_ind );
LOCAL void rCI_PlusCMGSText( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf);
LOCAL void rCI_PlusCMSSText( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf);
LOCAL void rCI_PlusCMGCText( T_MNSMS_COMMAND_CNF * mnsms_command_cnf);


#endif

LOCAL void rCI_Plus_Percent_CMGLText ( T_MNSMS_READ_CNF *mnsms_read_cnf,
                                       T_ACI_AT_CMD cmd);
LOCAL void rCI_Plus_Percent_CMGRText ( T_MNSMS_READ_CNF  * mnsms_read_cnf,
                                       T_ACI_CMGR_CBM * cbm,
                                       T_ACI_AT_CMD cmd);
LOCAL void rCI_Plus_Percent_CMGLTextSP ( T_MNSMS_READ_CNF* mnsms_read_cnf,
                                        T_ACI_AT_CMD cmdId);
LOCAL void rCI_Plus_Percent_CMGRTextSP ( T_MNSMS_READ_CNF* mnsms_read_cnf,
                                        T_ACI_AT_CMD cmdId);

GLOBAL CHAR *sms_status (T_ACI_SMS_STAT stat) /* used in text mode by CMGL and CMGR */
{
  switch(stat)
  {
  case(SMS_STAT_Invalid):   return "INVALID MESSAGE";
  case(SMS_STAT_RecUnread): return "REC UNREAD";
  case(SMS_STAT_RecRead):   return "REC READ";
  case(SMS_STAT_StoUnsent): return "STO UNSENT";
  case(SMS_STAT_StoSent):   return "STO SENT";
  case(SMS_STAT_All):       return "ALL";
  default:                  return 0;
  }
}

GLOBAL char *ring_stat(T_ACI_CRING_TYP type)
{
  switch(type)
  {
  case(CRING_TYP_NotPresent): return  "Not Present";
  case(CRING_TYP_Async):      return  "ASYNC";
  case(CRING_TYP_Sync):       return  "SYNC";
  case(CRING_TYP_RelAsync):   return  "REL ASYNC";
  case(CRING_TYP_RelSync):    return  "REL SYNC";
  case(CRING_TYP_Fax):        return  "FAX";
  case(CRING_TYP_Voice):      return  "VOICE";
  case(CRING_TYP_AuxVoice):   return  "AUX VOICE";
  default:                    return  "Error";
  }
}
#define RING_STAT_LTH 15
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_OK             |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_OK call back

*/

GLOBAL void rCI_OK ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId )
{
  UBYTE          srcId  = srcId_cb;
  T_ATI_RSLT     rv_ati = ATI_FAIL;

  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_OK()");

  src_params->curAtCmd = AT_CMD_NONE;

  switch (cmdId)
  {
  case (AT_CMD_D):
    TRACE_EVENT("AT command line successfully processed") ;
    /*lint -fallthrough*/
  case (AT_CMD_NONE):
  case (AT_CMD_EXT):
#if FF_FAX
  case (AT_CMD_FDR):
  case (AT_CMD_FDT):
  case (AT_CMD_FKS):
#endif
    /*
     * tell line edit that the cmd line is finished/aborted
     * and to be able to receive a new one
     */
    ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
    io_sendConfirm (srcId, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
    curAbrtCmd = AT_CMD_NONE;
    cmdErrStr  = NULL;
    break;

  default:
    /*
     * there are possibly further AT cmds after re-entering the ACI context
     */
    /* this is only a bypass for ATI sources which uses the functional interface */
    if (src_params->cmd_state EQ CMD_IDLE)
    {
      io_sendConfirm (src_params->src_id, cmdAtError(atOk), ATI_NORMAL_OUTPUT);
    }
    else
    {
      /*
       * there are possibly further AT cmds after re-entering the ACI context
       */
      rv_ati = ati_execute_cmd_line (src_params);
    }
    break;
  }
#ifdef ACI /* for ATI only version */
  cmhMMI_handleAudioTone ( cmdId, RAT_OK, CPI_MSG_NotPresent );
#endif
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_NO_CARRIER     |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_NO_CARRIER call back

*/

GLOBAL void rCI_NO_CARRIER ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, SHORT cId )
{
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_NO_CARRIER()");

  if (   src_params->curAtCmd EQ AT_CMD_D
      OR src_params->curAtCmd EQ AT_CMD_A
      OR src_params->curAtCmd EQ AT_CMD_H
      OR src_params->curAtCmd EQ AT_CMD_CGDATA
      OR src_params->curAtCmd EQ AT_CMD_CGANS
#ifdef FF_FAX
      OR src_params->curAtCmd EQ AT_CMD_FDR
      OR src_params->curAtCmd EQ AT_CMD_FDT
#endif
      )
  {
    ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
    src_params->curAtCmd = AT_CMD_NONE;
    io_sendConfirm(srcId, cmdAtError(atNoCarrier), ATI_ERROR_OUTPUT | ATI_RESULT_CODE_OUTPUT);
  }
  else
  {
    /*
     *  According to the v25ter NO CARRIER is stated as a final result code.
     *
     *  This implementation differ in this case from the standard.
     *  There are two differnt reasons:
     *     - Data transfer on a different source than the transfer was started
     *     - NO CARRIER if the other peer of a CS call hangs up
     *
     *  For the first reason the CONNECT will be the final result code (standard: intermediate)
     *  For the second reason the ATD resuts an OK.
     */
    io_sendIndication(srcId, cmdAtError(atNoCarrier), ATI_FORCED_OUTPUT | ATI_RESULT_CODE_OUTPUT);
  }

  cmdErrStr   = NULL;

#ifdef ACI /* for ATI only version */
	cmhMMI_handleAudioTone ( cmdId, RAT_NO_CARRIER, CPI_MSG_NotPresent );
#endif
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_BUSY           |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_BUSY call back

*/

GLOBAL void rCI_BUSY ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, SHORT cId )
{
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_BUSY()");

  src_params->curAtCmd    = AT_CMD_NONE;

  ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);

  io_sendConfirm(srcId, cmdAtError(atBusy), ATI_ERROR_OUTPUT);

#ifdef ACI /* for ATI only version */
  cmhMMI_handleAudioTone ( cmdId, RAT_BUSY, CPI_MSG_NotPresent );
#endif

  cmdErrStr   = NULL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_NO_ANSWER      |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_NO_ANSWER call back

*/

GLOBAL void rCI_NO_ANSWER ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, SHORT cId )
{
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_NO_ANSWER()");

  src_params->curAtCmd    = AT_CMD_NONE;

  ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);

  io_sendConfirm(srcId, cmdAtError(atNoAnswer), ATI_ERROR_OUTPUT);

  cmdErrStr   = NULL;

#ifdef ACI /* for ATI only version */
	cmhMMI_handleAudioTone ( cmdId, RAT_NO_ANSWER, CPI_MSG_NotPresent );
#endif
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_CONNECT        |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_CONNECT call back.
            flow_cntr = TRUE flow control active.
            flow_cntr = FALSE  "       "  inactive.

*/

GLOBAL void rCI_CONNECT   ( /*UBYTE srcId,*/
                            T_ACI_AT_CMD   cmdId,
                            T_ACI_BS_SPEED speed,
                            SHORT          cId,
                            BOOL           flow_cntr )
{
  LONG val;
  LONG val_nv=-1;
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
  CHAR  *cmd_key = "";

  TRACE_FUNCTION("rCI_CONNECT()");

  src_params->curAtCmd = AT_CMD_NONE;

  switch(speed)
  {
  case(BS_SPEED_300_V110): val=300;     val_nv = 10; break;
  case(BS_SPEED_1200_V110): val=1200;   val_nv = 11; break;
  case(BS_SPEED_2400_V110): val=2400;   val_nv = 13; break;
  case(BS_SPEED_4800_V110): val=4800;   val_nv = 14; break;
  case(BS_SPEED_9600_V110): val=9600;   val_nv = 15; break;
  case(BS_SPEED_14400_V110): val=14400; val_nv = 16; break;
  case(BS_SPEED_19200_V110): val=19200; break;
  case(BS_SPEED_38400_V110): val=38400; break;
  default:  val=-1;
  }

  if (src_params EQ NULL)
  {
    TRACE_EVENT_P1 ("[ERR] rCI_CONNECT(): srcId=%d not found", srcId);
    return;
  }
#ifdef UART  
  if (src_params->src_type EQ ATI_SRC_TYPE_UART)
  {
    T_ACI_DTI_PRC *uart_infos;

    uart_infos = find_element (uart_src_params,
                               (UBYTE)srcId,
                               cmhUARTtest_srcId);
    if( flow_cntr )
    {
      /* this is in case of fax sending */
      BITFIELD_SET (uart_infos->data_cntr, UART_DTI_FLOW_OFF);
    }
    else
    {
      BITFIELD_CLEAR (uart_infos->data_cntr, UART_DTI_FLOW_OFF);
    }
  }
#endif
#ifdef FF_PSI
  if (src_params->src_type EQ ATI_SRC_TYPE_PSI)
  {
    T_ACI_DTI_PRC_PSI *psi_infos;

    psi_infos = find_element (psi_src_params,
                               (UBYTE)srcId,
                               cmhPSItest_srcId);
    if( flow_cntr )
    {
      /* this is in case of fax sending */
      BITFIELD_SET (psi_infos->data_cntr, PSI_DTI_FLOW_OFF);
    }
    else
    {
      BITFIELD_CLEAR (psi_infos->data_cntr, PSI_DTI_FLOW_OFF);
    }
  }
#endif /*FF_PSI*/

  if(val > 0 AND ati_user_output_cfg[srcId].atX > 0)
  {
    if(at.s1415.atV NEQ 0)          /*Verbose case*/
    {
      sprintf(g_sa,"CONNECT %d",val);
      io_sendConfirm(srcId, g_sa, (ATI_NORMAL_OUTPUT | ATI_CONNECT_OUTPUT));
    }
    else if(val_nv > 0)             /*Nonverbose case*/
    {
      sprintf(g_sa,"%d",val_nv);
      io_sendConfirm(srcId, g_sa, (ATI_NORMAL_OUTPUT | ATI_CONNECT_OUTPUT) );
    }
    else
      io_sendConfirm(srcId, cmdAtError(atConnect), (ATI_NORMAL_OUTPUT | ATI_CONNECT_OUTPUT));
  }
  else
  {
    io_sendConfirm(srcId, cmdAtError(atConnect), (ATI_NORMAL_OUTPUT | ATI_CONNECT_OUTPUT));
  }

  /*
   * tell line edit that the cmd line is finished/aborted
   * and to be able to receive a new one
   */
  ati_get_cmds_key(cmdId, &cmd_key, NULL);
  TRACE_EVENT_P1("%s completed", cmd_key);
  ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);

  cmdErrStr   = NULL;

#ifdef ACI /* for ATI only version */
	cmhMMI_handleAudioTone ( cmdId, RAT_CONNECT, CPI_MSG_NotPresent );
#endif
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCME        |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCME call back

*/

GLOBAL void rCI_PlusCME ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, T_ACI_CME_ERR err )
{
  UBYTE srcId = srcId_cb;

  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_PLusCME()");
  /*
   * tell line edit that the cmd line is finished/aborted
   * and to be able to receive a new one
   */
  ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);
  /*
   * if (asynchroniously) extension command, reset the global src_id_ext
   */
  if (src_id_ext EQ src_params->src_id)
  {
    src_id_ext = 0xFF;
  }
  if ( curAbrtCmd EQ AT_CMD_NONE )
  {
    src_params->curAtCmd    = AT_CMD_NONE;

    io_sendConfirm(srcId, cmdCmeError(err), ATI_ERROR_OUTPUT);

    cmdErrStr   = NULL;

#ifdef ACI /* for ATI only version */
		cmhMMI_handleAudioTone ( cmdId, RAT_CME, CPI_MSG_NotPresent );
#endif
  }
  else
  {
    curAbrtCmd = AT_CMD_NONE;

    io_sendMessage ( srcId, cmdCmeError ( CME_ERR_FailedToAbort ),
                            ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCPIN       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCPIN call back

*/

GLOBAL void rCI_PlusCPIN (/*UBYTE srcId,*/ T_ACI_CPIN_RSLT rslt )
{
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PLusCPIN()");

  src_params->curAtCmd = AT_CMD_NONE;

  sprintf(g_sa,"%s%s","+CPIN: ",CPIN_RESULT(rslt));
  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}

typedef enum
{
  STAT_NotPresent = -1,
  STAT_Other,           /* other than registered and Roaming */
  STAT_Reg,
  STAT_Roam
} T_ACI_NTW_STATUS;

LOCAL T_ACI_NTW_STATUS get_raw_stat_among_CREG( T_ACI_CREG_STAT status )
{
  switch(status)
  {
  case(CREG_STAT_NotPresent):
    return(STAT_NotPresent);

  case(CREG_STAT_Reg):
    return(STAT_Reg);

  case(CREG_STAT_Roam):
    return(STAT_Roam);

  default:
    return(STAT_Other);
   }
}

#ifdef GPRS
LOCAL T_ACI_NTW_STATUS get_raw_stat_among_CGREG( T_CGREG_STAT status )
{
  switch(status)
  {
  case(CGREG_STAT_REG_HOME):
    return(STAT_Reg);

  case(CGREG_STAT_REG_ROAM):
    return(STAT_Roam);

  default:
    return(STAT_Other);
   }
}

LOCAL T_ACI_NTW_STATUS get_raw_stat_among_P_CGREG( T_P_CGREG_STAT status )
{
  switch(status)
  {
  case(P_CGREG_STAT_REG_HOME):
    return(STAT_Reg);

  case(P_CGREG_STAT_REG_ROAM):
    return(STAT_Roam);

  default:
    return(STAT_Other);
   }
}
#endif /* GPRS */

/* function fills up registration status parameters according to type of
user notification (+CREG/+CGREG/%CGREG)
returns whether network status has changed or not: BOOL */
LOCAL BOOL get_registration_data_among_cmd( UBYTE                  srcId,
                                            int                    status,
                                            T_ATI_REG_MOD_LAC_CID *mod_lac_cid,
                                            T_ACI_NTW_STATUS      *raw_status,
                                            CHAR                  *cmd_string,
                                            T_ACI_CREG_CMD         cmd)
{
  USHORT  previous_status,
          current_status;

  current_status = previous_status = status;

  switch(cmd)
  {
  case(CREG_CMD):
    *mod_lac_cid    = ati_user_output_cfg[srcId].creg.mod_lac_cid;
    previous_status = ati_user_output_cfg[srcId].creg.last_presented_state;

    *raw_status = get_raw_stat_among_CREG((T_ACI_CREG_STAT) current_status);
    strcpy(cmd_string, "+CREG: ");
    break;

  case(PercentCREG_CMD):
    *mod_lac_cid    = ati_user_output_cfg[srcId].percent_creg.mod_lac_cid;
    previous_status = ati_user_output_cfg[srcId].percent_creg.last_presented_state;

    *raw_status = get_raw_stat_among_CREG((T_ACI_CREG_STAT) current_status);
    strcpy(cmd_string, "%CREG: ");
    break;


#if defined (GPRS) AND defined (DTI)
  case(PlusCGREG_CMD):
    *mod_lac_cid    = ati_gprs_user_output_cfg[srcId].plus_cgreg.mod_lac_cid;
    previous_status = ati_gprs_user_output_cfg[srcId].plus_cgreg.last_presented_state;

    *raw_status = get_raw_stat_among_CGREG((T_CGREG_STAT) current_status);
    strcpy(cmd_string, "+CGREG: ");
    break;

  case(PercentCGREG_CMD):
    *mod_lac_cid    = ati_gprs_user_output_cfg[srcId].percent_cgreg.mod_lac_cid;
    previous_status = ati_gprs_user_output_cfg[srcId].percent_cgreg.last_presented_state;

    *raw_status = get_raw_stat_among_P_CGREG((T_P_CGREG_STAT) current_status);
    strcpy(cmd_string, "%CGREG: ");
    break;
#endif
  }

  if( current_status NEQ previous_status)
  {
    return TRUE;
  }

  return FALSE;
}

LOCAL void update_last_presented_datas_among_cmd( UBYTE           srcId,
                                                  int             status,
                                                  USHORT          lac,
                                                  USHORT          cid,
                                                  T_ACI_CREG_CMD  cmd)
{
  T_ATI_REG_MOD_LAC_CID *mod_lac_cid;

  switch(cmd)
  {
  case(CREG_CMD):
    ati_user_output_cfg[srcId].creg.last_presented_state = (T_ACI_CREG_STAT)status;
    mod_lac_cid = &ati_user_output_cfg[srcId].creg.mod_lac_cid;
    break;

  case(PercentCREG_CMD):
    ati_user_output_cfg[srcId].percent_creg.last_presented_state = (T_ACI_CREG_STAT)status;
    mod_lac_cid = &ati_user_output_cfg[srcId].percent_creg.mod_lac_cid;
    break;

#if defined (GPRS) AND defined (DTI)
  case(PlusCGREG_CMD):
    ati_gprs_user_output_cfg[srcId].plus_cgreg.last_presented_state = (T_CGREG_STAT)status;
    mod_lac_cid = &ati_gprs_user_output_cfg[srcId].plus_cgreg.mod_lac_cid;
    break;

  case(PercentCGREG_CMD):
    ati_gprs_user_output_cfg[srcId].percent_cgreg.last_presented_state = (T_P_CGREG_STAT)status;
    mod_lac_cid = &ati_gprs_user_output_cfg[srcId].percent_cgreg.mod_lac_cid;
    break;
#endif /* GPRS */

  default:
    return;
  }

  if( lac NEQ NOT_PRESENT_16BIT )
  {
    mod_lac_cid->last_presented_lac = lac;
  }
  if( cid NEQ NOT_PRESENT_16BIT )
  {
    mod_lac_cid->last_presented_cid = cid;
  }

}

/* function sends notification to user about network registration status.
Functionnality centralised for either +CREG/+CGREG/%CGREG... */
GLOBAL void r_plus_percent_CREG  ( UBYTE                 srcId,
                                   int                   status,
                                   USHORT                lac,
                                   USHORT                cid,
                                   T_ACI_CREG_CMD        cmd, 
                                   T_ACI_P_CREG_GPRS_IND gprs_ind,
                                   BOOL                  bActiveContext )
{
  T_ATI_CREG_MOD        mode;
  T_ATI_REG_MOD_LAC_CID mod_lac_cid;
  USHORT                previous_lac,
                        previous_cid;
  BOOL                  network_status_has_changed = FALSE;
  BOOL                  cell_has_changed           = FALSE;
  CHAR                  loc_info[LOC_INFO_STRLTH] = ""; /* enough to get e.g. ",A1F4, F4D0" */
  CHAR                  gprs_info[GPRS_INFO_STRLTH] = ""; /* enough to get e.g. ", 2" */
  CHAR                  *ctxtInfo = "";
  T_ACI_NTW_STATUS      raw_status;
  CHAR                  cmd_key[KEY];
  USHORT                presented_lac = NOT_PRESENT_16BIT,
                        presented_cid = NOT_PRESENT_16BIT;

  /* check whether cell has changed */
  network_status_has_changed = get_registration_data_among_cmd( srcId,
                                                                status,
                                                                &mod_lac_cid,
                                                                &raw_status,
                                                                cmd_key,
                                                                cmd );
  if( network_status_has_changed )
  {
    TRACE_EVENT_P3("cmd: %d, source: %d, new network status: %d !", cmd, srcId, status);
  }

  mode            = mod_lac_cid.pres_mode;
  previous_lac    = mod_lac_cid.last_presented_lac;
  previous_cid    = mod_lac_cid.last_presented_cid;

  /* check whether cell has changed */
  if( ((lac NEQ NOT_PRESENT_16BIT) AND (lac NEQ previous_lac))
      OR
      ((cid NEQ NOT_PRESENT_16BIT) AND (cid NEQ previous_cid)) )
  {
    if(raw_status EQ STAT_Reg  OR  raw_status EQ STAT_Roam)
    {
      /* cell info is only relevant when registered or in roaming */
      TRACE_EVENT_P2("cell has changed !, lac: %04X, cId: %04X", lac, cid);
      cell_has_changed = TRUE;
    }
  }

  /* comma always needed */
  if (cmd EQ PercentCREG_CMD OR
      mode EQ CREG_MOD_LOC_INF_ON_CTXACT)
  {
    strcat(loc_info,",,");
  }

  /* check if presentation should occur */
  switch( mode )
  {
    case(CREG_MOD_NotPresent):
    case(CREG_MOD_OFF):
      /* no presentation to user */
      return;

    case(CREG_MOD_ON):
      if( !network_status_has_changed )
      {
        return;
      }
      /* network status is available and has changed */
      break;

    case(CREG_MOD_LOC_INF_ON_CTXACT):
    case(CREG_MOD_LOC_INF_ON):
      if( (raw_status EQ STAT_Reg OR
           raw_status EQ STAT_Roam)   AND

           cell_has_changed )
      {
        presented_lac = lac;
        presented_cid = cid;
      }
      else if( (raw_status EQ STAT_Reg OR
                raw_status EQ STAT_Roam)   AND

                network_status_has_changed )
      {
        /* show last presented lac/cid */
        presented_lac = mod_lac_cid.last_presented_lac;
        presented_cid = mod_lac_cid.last_presented_cid;
      }
      else if( network_status_has_changed )
      {
        /* mobile is not registered: do not show location information
        parameters have already been initialized, so no need to set them */
      }
      else
      {
        TRACE_EVENT_P3("%s presentation denied. mode: %d, network status: %d", cmd_key, mode, status);
        return;
      }

      if( presented_lac NEQ NOT_PRESENT_16BIT AND
          presented_cid NEQ NOT_PRESENT_16BIT )
      {
        sprintf(loc_info, ",\"%04X\",\"%04X\"", presented_lac, presented_cid);
      }
      else if (mode EQ CREG_MOD_LOC_INF_ON_CTXACT)
        sprintf(loc_info, ",,");
      break;
  }

  /* ACI-SPR-17218: attach gprs information for %CREG */
  if ( cmd EQ PercentCREG_CMD )
  {
    sprintf(gprs_info, ",%01X", gprs_ind ); 
  }

#ifdef GPRS
  if ( (cmd  EQ PercentCGREG_CMD) AND 
       (mode EQ CREG_MOD_LOC_INF_ON_CTXACT) )
  {
    if( bActiveContext EQ TRUE )
      ctxtInfo = ",1";
    else
      ctxtInfo = ",0";
  }
#endif /* GPRS */

  sprintf(g_sa,"%s%d%s%s%s", cmd_key, status, loc_info, gprs_info, ctxtInfo );
  io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);

  update_last_presented_datas_among_cmd( srcId,
                                         status,
                                         presented_lac,
                                         presented_cid,
                                         cmd );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCREG       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCREG call backs(change in network registration status)

*/

GLOBAL void rCI_PlusCREG  ( T_ACI_CREG_STAT status,
                            USHORT          lac,
                            USHORT          cid )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PlusCREG()");

  r_plus_percent_CREG  ( srcId,
                         status,
                         lac,
                         cid,
                         CREG_CMD,
                         P_CREG_GPRS_Support_Unknown, /*ACI-SPR-17218: ignored*/ 
                         FALSE );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCREG    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCREG call backs(change in network registration status)

*/

GLOBAL void rCI_PercentCREG  ( T_ACI_CREG_STAT       status,
                               USHORT                lac,
                               USHORT                cid,
                               T_ACI_P_CREG_GPRS_IND gprs_ind)
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentCREG()");

  r_plus_percent_CREG  ( srcId,
                         status,
                         lac,
                         cid,
                         PercentCREG_CMD, /*ACI-SPR-17218: introduced for %CREG*/  
                         gprs_ind,
                         FALSE );
}



/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCRING      |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCRING call back

*/
/* should be called when ringing indications should stop */
GLOBAL void ati_stop_ring(void)
{
  TRACE_FUNCTION("ati_stop_ring()");

  at.rngPrms.rngCnt = 1;
  at.rngPrms.isRng  = FALSE;
  at.S[1] = 0; /* S1 register will hold the ring counts */
  
  /* Reset the CLIP parameters to default values */
  at.clipPrms.stat = CLIP_STAT_NotPresent;
  memset( at.clipPrms.number, 0, sizeof(at.clipPrms.number));
  memset(&at.clipPrms.type, 0, sizeof(T_ACI_TOA));
  at.clipPrms.validity = PRES_NOT_PRES;
  memset( at.clipPrms.subaddr, 0, sizeof(at.clipPrms.subaddr));
  memset(&at.clipPrms.satype, 0, sizeof(T_ACI_TOS));
#ifdef NO_ASCIIZ
  memset(&at.clipPrms.alpha, 0, sizeof(T_ACI_PB_TEXT));
#else
  memset(at.clipPrms.alpha, 0, sizeof(at.clipPrms.alpha));
#endif

  TIMERSTOP( ACI_TRING );
}

GLOBAL void rCI_PlusCRING ( /*UBYTE srcId,*/
                            T_ACI_CRING_MOD mode,
                            T_ACI_CRING_TYP type1,
                            T_ACI_CRING_TYP type2 )
{
  static T_ACI_CMD_SRC first_ringing_srcId = CMD_SRC_NONE;  /* Source which will handle the ringing-timer */
  UBYTE            srcId           = srcId_cb,
                   autoAnswerSrcId = at.rngPrms.srcID_S0;

  T_ACI_AT_CMD     autoanswer_command;
  T_ACI_RETURN     ret;
  int              DTR=0;
  UBYTE            DTR_behaviour = DTR_BEHAVIOUR_Ignore;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_PlusCRING()");

  if (first_ringing_srcId EQ CMD_SRC_NONE)
    first_ringing_srcId = srcId;    /* catch the first source id for setting up the ring timer */

  /* save ringing parameter at the first call to rCI_PlusCRING */
  if( !at.rngPrms.isRng       AND
       at.rngPrms.rngCnt EQ 1 AND     /* this is only done on the first ring, not on any subsequent*/
       srcId EQ first_ringing_srcId)  /* only first source will reach the setting of "at.rngPrms.isRng = TRUE" */
  {
    at.rngPrms.mode  = mode;
    at.rngPrms.type1 = type1;
    at.rngPrms.type2 = type2;
    at.rngPrms.isRng = TRUE;
  }

  if (!at.rngPrms.isRng)
  {
    return; /* dont emmit any "RING" but escape here if ringing has been stopped
               in a multi-source configuration on any source in rhe RAT_CRING loop */
  }

  at.S[1] = at.rngPrms.rngCnt; /* S1 register will return the ring counts */

  /* check for automatic reject of an network initiated context activation */
#if defined (GPRS) AND defined (DTI)
  if( at.rngPrms.mode EQ CRING_MOD_Gprs   AND
      first_ringing_srcId EQ srcId            AND       /* it is sufficent to check this only for one ringing source */
      cmhSM_call_reject(at.rngPrms.rngCnt, mode) )
  {
    TRACE_EVENT_P2("PDP context is to be automatically rejected: RING count: %d, srcId %d", at.rngPrms.rngCnt, srcId_cb);

    ati_stop_ring();

    ret=sAT_PlusCGANS(srcId, 0, NULL, GPRS_CID_OMITTED);
    if( ret EQ AT_CMPL )
      return;

    TRACE_EVENT_P1("auto reject return error: %d", ret);
    cmdAtError(atError);
    return;
  }
#endif

#ifdef UART  
  if (src_params->src_type EQ ATI_SRC_TYPE_UART)
  {
    T_ACI_DTI_PRC *uart_infos;

    uart_infos = find_element (uart_src_params,
                               (UBYTE)srcId,
                               cmhUARTtest_srcId);

    if (BITFIELD_CHECK (uart_infos->data_cntr, UART_DTI_SA_BIT))
      DTR=1;
  }
#endif
#if defined (FF_PSI) AND defined (DTI)
  if (src_params->src_type EQ ATI_SRC_TYPE_PSI)
  {
    T_ACI_DTI_PRC_PSI *psi_infos;

    psi_infos = find_element (psi_src_params,
                               (UBYTE)srcId,
                               cmhPSItest_srcId);

    if (BITFIELD_CHECK (psi_infos->data_cntr, PSI_DTI_SA_BIT))
      DTR=1;
  }
#endif

  qAT_AndD ( srcId, &DTR_behaviour);

  if(DTR EQ 0 AND
     DTR_behaviour EQ DTR_BEHAVIOUR_ClearCall)
  {
     /* V.250 6.2.9 Circuit 108 (Data terminal ready) behaviour:
        Automatic answer is disabled while circuit 108/2 remains off. */
    ;
    /*  Also don't emit any RING while 108/2 remains off */
  }
  else
  {
    if (at.rngPrms.rngCnt EQ 1 OR
        !check_should_buffer_ind(src_params))      /* Ring indications are not buffered, except of the first one */
    {
      if(ati_user_output_cfg[srcId].CRC_stat)
      {
        switch(mode)
        {
          case CRING_MOD_Direct:
            sprintf(g_sa,"+CRING: %s",ring_stat(at.rngPrms.type1));
            break;
          case CRING_MOD_Alternate:
            sprintf(g_sa,"+CRING: %s/%s",ring_stat(at.rngPrms.type1),ring_stat(at.rngPrms.type2));
            break;
#if defined (GPRS) AND defined (DTI)
          case CRING_MOD_Gprs:
            sprintf(g_sa,"+CRING: %s", cmhSM_ring_gprs_par());
            break;
#endif  /* GPRS && DTI */
        }
      }
      else
      {
        strcpy(g_sa, cmdAtError(atRing));
        cmdErrStr = NULL;
      }

      io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
    }

    /* check for automatic answer */
#ifdef GPRS
    if( at.rngPrms.mode EQ CRING_MOD_Gprs )
    {
      autoAnswerSrcId = at.rngPrms.srcID_CGAUTO NEQ CMD_SRC_NONE ?
                        at.rngPrms.srcID_CGAUTO : at.rngPrms.srcID_S0;
    }
#endif

    if( srcId EQ autoAnswerSrcId                AND  /* Caution !!!                                  */
        at.rngPrms.type1 NEQ CRING_TYP_Fax      AND  /* Never auto answer FAX calls !!!              */
        at.rngPrms.type1 NEQ CRING_TYP_AuxVoice AND  /* Instead continue ringing!                    */
#if defined (GPRS) AND defined (DTI)
        cmhSM_call_answer(at.rngPrms.rngCnt, at.rngPrms.mode) EQ TRUE
#else /* GPRS */
        (at.S[0] AND at.rngPrms.rngCnt >= at.S[0])
#endif /* GPRS */
      )
    {
      TRACE_EVENT_P2("Call is to be automatically answered: RING count: %d, srcId %d", at.rngPrms.rngCnt, srcId_cb);

      ati_stop_ring();

#if defined (GPRS) AND defined (DTI)
      if ( at.rngPrms.mode EQ CRING_MOD_Gprs )
      {
        ret = sAT_PlusCGANS(autoAnswerSrcId, 1, "PPP", INVALID_CID);
        autoanswer_command = AT_CMD_CGANS;
      }
      else
#endif
      {
        ret = sAT_A(autoAnswerSrcId);
        autoanswer_command = AT_CMD_A;
      }

      if( ret EQ AT_EXCT )
      {
        src_params->curAtCmd = autoanswer_command;
        return;
      }

      TRACE_EVENT_P1("auto answer return error: %d", ret);
      cmdAtError(atError);
      return;
    }
  }

  if( first_ringing_srcId EQ srcId AND    /* only the first source will start the ringing timer */
      at.rngPrms.isRng             AND    /* ringing is still valid? */
      at.rngPrms.rngCnt EQ 1       )      /* since Timer is self-retriggering */
  {
    TRACE_EVENT_P1("start RING timer on Source: %d", srcId);
    PTIMERSTART( TRING_VALUE, TRING_VALUE, ACI_TRING );
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCRING_OFF  |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCRING off call back

*/

GLOBAL void rCI_PlusCRING_OFF ( /*UBYTE srcId,*/ SHORT cId )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PlusCRING_OFF()");

  if( at.rngPrms.isRng )
  {
    ati_stop_ring();
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentSIMREM  |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentSIMREM call back

*/

GLOBAL void rCI_PercentSIMREM ( /*UBYTE srcId,*/ T_ACI_SIMREM_TYPE srType )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentSIMREM()");

  if (ati_user_output_cfg[srcId].SIMIND_stat)
  {
    sprintf (g_sa, "%s%d", "%SIMREM: ", srType);
    io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentSIMINS  |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentSIMINS call back

*/

GLOBAL void rCI_PercentSIMINS ( /*UBYTE srcId,*/ T_ACI_CME_ERR err )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentSIMINS()");

  if (ati_user_output_cfg[srcId].SIMIND_stat)
  {
    sprintf (g_sa, "%s%d", "%SIMINS: ", err);
    io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentKSIR    |
+--------------------------------------------------------------------+

  PURPOSE : handles PercentKSIR call back.
            Code is in aci_util.c to share the code with BAT
*/
GLOBAL void rCI_PercentKSIR ( /*UBYTE srcId,*/ T_ACI_KSIR * ksStat )
{
  TRACE_FUNCTION("rCI_PercentKSIR()");
  
  utl_cb_percentKSIR (srcId_cb, ksStat);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCLIR       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCLIR call back

*/

GLOBAL void rCI_PlusCLIR  ( /*UBYTE srcId,*/
                            T_ACI_CLIR_MOD  mode,
                            T_ACI_CLIR_STAT stat)
{
  UBYTE srcId = srcId_cb;

  sprintf(g_sa,"+CLIR: %d,%d",mode,stat);
  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}



/*
+--------------------------------------------------------------------+
| PROJECT : ACI/MMI             MODULE  : ACI_RET                    |
| STATE   : code                ROUTINE : rCI_PercentCSQ             |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCSQ call back

  Shen,Chao

*/

GLOBAL void rCI_PercentCSQ(UBYTE rssi, UBYTE ber, UBYTE actlevel)
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentCSQ()");


  sprintf (g_sa, "%s %d, %d, %d", "%CSQ: ",rssi, ber, actlevel);
  io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);

}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusClip       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCLIP call back

*/
#ifdef NO_ASCIIZ
GLOBAL void rCI_PlusCLIP  ( /*UBYTE srcId,*/
                            T_ACI_CLIP_STAT stat,
                            CHAR          * number,
                            T_ACI_TOA     * type,
                            U8              validity,
                            CHAR          * subaddr,
                            T_ACI_TOS     * satype,
                            T_ACI_PB_TEXT * alpha)
#else  /* ifdef NO_ASCIIZ */
GLOBAL void rCI_PlusCLIP  ( /*UBYTE srcId,    */
                            T_ACI_CLIP_STAT stat,
                            CHAR*           number,
                            T_ACI_TOA*      type,
                            U8              validity,
                            CHAR*           subaddr,
                            T_ACI_TOS*      satype,
                            CHAR*           alpha)
#endif /* ifdef NO_ASCIIZ */
{
  char*  me                          = "+CLIP: ";
  SHORT  pos                         = 0;
  CHAR   cvtdAlpha[2*MAX_ALPHA_LEN];
  USHORT lenCvtdAlpha;
  UBYTE  *uniAlpha = NULL;
  UBYTE  uniAlphaLen = 0;
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PLusCLIP()");
  
  /* save CLIP parameter */

  at.clipPrms.stat = stat;
  if ( number )
    memcpy(at.clipPrms.number, number, strlen(number));
  if ( type )
    memcpy(&at.clipPrms.type, type, sizeof(T_ACI_TOA));
  at.clipPrms.validity = validity;
  if ( subaddr )
    memcpy(at.clipPrms.subaddr, subaddr, strlen(subaddr));
  if ( satype )
    memcpy(&at.clipPrms.satype, satype, sizeof(T_ACI_TOS));
#ifdef NO_ASCIIZ
  if ( alpha )
    memcpy(&at.clipPrms.alpha, alpha, sizeof(T_ACI_PB_TEXT));
#else
  if ( alpha )
    memcpy(at.clipPrms.alpha, alpha, strlen(alpha));
#endif

#ifdef NO_ASCIIZ
  if ( alpha NEQ NULL )
  {
    uniAlpha = alpha->data;
    uniAlphaLen = alpha->len;
  }
#else  /* ifdef NO_ASCIIZ */
  if ( alpha NEQ NULL )
  {
    uniAlpha = (UBYTE *)alpha;
    uniAlphaLen = strlen(alpha);
  }
#endif /* ifdef NO_ASCIIZ */

  pos = sprintf(g_sa,"%s",me);

  if ( stat EQ CLIP_STAT_NotPresent )       /*Function call when connection is made*/
  {
    if ( ati_user_output_cfg[srcId].CLIP_stat
/*         AND
         (
           io_getIoMode ( ) EQ IO_MODE_CMD OR
           io_getIoMode ( ) EQ IO_MODE_RUN
         )*/
       )
    {
      if (number)
      {
        pos += sprintf(g_sa+pos,"\"%s\",",number);
        if (type)
          pos += sprintf(g_sa+pos,"%d,",toa_merge(*type));
        else
          pos += sprintf(g_sa+pos,",");
      }
      else
        pos += sprintf(g_sa+pos,"\"\",128,");
      if (subaddr)
      {
        pos += sprintf(g_sa+pos,"\"%s\",",subaddr);
        if (satype)
          pos += sprintf(g_sa+pos,"%d,",tos_merge(*satype));
        else
          pos += sprintf(g_sa+pos,",");
      }
      else if (alpha)
        pos += sprintf(g_sa+pos,"\"\",,");
      else if (validity NEQ PRES_NOT_PRES)
        pos += sprintf(g_sa+pos,",");

      if (alpha)
      {
        utl_chsetFromSim ( uniAlpha,
                           uniAlphaLen,
                           (UBYTE*)cvtdAlpha,
                           sizeof(cvtdAlpha),
                           &lenCvtdAlpha,
                           GSM_ALPHA_Def );
        pos+=sprints(g_sa+pos,cvtdAlpha,lenCvtdAlpha);
      }
      else if (validity NEQ PRES_NOT_PRES)
        pos += sprintf(g_sa+pos,",");

      if (validity NEQ PRES_NOT_PRES)
        pos += sprintf(g_sa+pos,",%d",validity);

      ci_remTrailCom(g_sa, pos);
      io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
    }
  }
  else                                  /* Answer for qA_PlusCLIP*/
  {
    src_params->curAtCmd = AT_CMD_NONE;

    sprintf(g_sa+pos,"%d,%d",ati_user_output_cfg[srcId].CLIP_stat,stat);
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCdip       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCDIP call back

*/
GLOBAL void rCI_PlusCDIP  (CHAR          * number,
                            T_ACI_TOA     * type,
                            CHAR          * subaddr,
                            T_ACI_TOS     * satype)
{
  char*  me                          = "+CDIP: ";
  SHORT  pos                         = 0;
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PlusCDIP()");

  pos = sprintf(g_sa,"%s",me);

  if ( ati_user_output_cfg[srcId].CDIP_stat)
  {
    if (number)
    {
      pos += sprintf(g_sa+pos,"\"%s\",",number);
      if (type)
      {
        pos += sprintf(g_sa+pos,"%d,",toa_merge(*type));

        if (subaddr)   /* Only check to display subaddr if Number and Type are present */
        {
          pos += sprintf(g_sa+pos,"\"%s\",",subaddr);
          if (satype)
              pos += sprintf(g_sa+pos,"%d",tos_merge(*satype));
        }
      }
      else  /* No Number Type present */
      {
        pos += sprintf(g_sa+pos,",");
      }
    }
    else    /* No Number present */
    {
      pos += sprintf(g_sa+pos,"\"\",128,");
    }

    ci_remTrailCom(g_sa, pos); 
    io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCOLP       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCOLP call back

*/
#ifdef NO_ASCIIZ
GLOBAL void rCI_PlusCOLP  ( /*UBYTE srcId,*/
                            T_ACI_COLP_STAT stat,
                            CHAR            *number,
                            T_ACI_TOA       *type,
                            CHAR            *subaddr,
                            T_ACI_TOS       *satype,
                            T_ACI_PB_TEXT   *alpha)
#else  /* ifdef NO_ASCIIZ */
GLOBAL void rCI_PlusCOLP  ( /*UBYTE srcId,    */
                            T_ACI_COLP_STAT stat,
                            CHAR            *number,
                            T_ACI_TOA       *type,
                            CHAR            *subaddr,
                            T_ACI_TOS       *satype,
                            CHAR            *alpha)
#endif /* ifdef NO_ASCIIZ */
{
  char*  me                          = "+COLP: ";
  int    pos                         = 0;
  CHAR   cvtdAlpha[2*MAX_ALPHA_LEN];
  USHORT lenCvtdAlpha;
  UBYTE  *uniAlpha = NULL;
  UBYTE  uniAlphaLen = 0;
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PLusCOLP()");

#ifdef NO_ASCIIZ
  if ( alpha NEQ NULL )
  {
    uniAlpha = alpha->data;
    uniAlphaLen = alpha->len;
  }
#else  /* ifdef NO_ASCIIZ */
  if ( alpha NEQ NULL )
  {
    uniAlpha = (UBYTE *)alpha;
    uniAlphaLen = strlen(alpha);
  }
#endif /* ifdef NO_ASCIIZ */

  pos = sprintf(g_sa,"%s",me);
  if (stat==COLP_STAT_NotPresent) /* Function call if connection is made*/
  {
    if ( at.flags.COLP_stat
/*         AND
         (
           io_getIoMode ( ) EQ IO_MODE_CMD OR
           io_getIoMode ( ) EQ IO_MODE_RUN
         ) */
       )
    {
      if (number)
      {
        pos += sprintf(g_sa+pos,"\"%s\",",number);
        if (type)
          pos += sprintf(g_sa+pos,"%d,",toa_merge(*type));
        else
          pos += sprintf(g_sa+pos,"128,");
      }
      else
        pos += sprintf(g_sa+pos,"\"\",128,");

      if (subaddr)
      {
        pos += sprintf(g_sa+pos,"\"%s\",",subaddr);
        if (satype)
          pos += sprintf(g_sa+pos,"%d,",tos_merge(*satype));
        else  pos += sprintf(g_sa+pos,",");
      }
      else
        pos += sprintf(g_sa+pos,",,");

      if (alpha)
      {
        utl_chsetFromSim ( uniAlpha,
                           uniAlphaLen,
                           (UBYTE*)cvtdAlpha,
                           sizeof(cvtdAlpha),
                           &lenCvtdAlpha,
                           GSM_ALPHA_Def );
        pos+=sprints(g_sa+pos,cvtdAlpha,lenCvtdAlpha);
      }

      ci_remTrailCom(g_sa,(USHORT)pos);
      io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
    }
  }
  else /* Answer for qAT_PlusCOLP*/
  {
   src_params->curAtCmd = AT_CMD_NONE;

   if (at.flags.COLP_stat)
     sprintf(g_sa+pos,"1,%d",stat);
    else
     sprintf(g_sa+pos,"0,%d",stat);

    ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCOLR    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCOLR call back

*/

GLOBAL void rCI_PercentCOLR  ( /*UBYTE srcId,*/ T_ACI_COLR_STAT stat)
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentCOLR()");

  sprintf(g_sa, "%s: %d", "%COLR", stat);
  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_DR             |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_DR call back

*/

GLOBAL void rCI_PlusDR    ( /*UBYTE srcId,*/ T_ACI_DR_TYP type )
{
  UBYTE srcId = srcId_cb;


  TRACE_FUNCTION("rCI_PLusDR()");

  if ( ati_user_output_cfg[srcId].DR_stat
/*       AND
       (
         io_getIoMode ( ) EQ IO_MODE_CMD OR
         io_getIoMode ( ) EQ IO_MODE_RUN
       )*/
     )
  {
    sprintf(g_sa,"+DR: %d",type);
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_CR             |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_CR call back

*/

GLOBAL void rCI_PlusCR    ( /*UBYTE srcId,*/ T_ACI_CR_SERV service )
{
  UBYTE srcId = srcId_cb;


  TRACE_FUNCTION("rCI_PLusCR()");


  if ( ati_user_output_cfg[srcId].CR_stat
/*       AND
       (
         io_getIoMode ( ) EQ IO_MODE_CMD OR
         io_getIoMode ( ) EQ IO_MODE_RUN
       ) */
     )
  {
    sprintf(g_sa,"+CR: %s",ring_stat(service));
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCOPS       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCOPS call back

*/
GLOBAL  void  rCI_PlusCOPS(/*UBYTE srcId, */
                            SHORT lastIdx,
                            T_ACI_COPS_OPDESC * operLst)
{
  TRACE_FUNCTION("rCI_PLusCOPS()");

  r_Plus_Percent_COPS(AT_CMD_COPS, lastIdx, operLst);

}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCOPS       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PecentCOPS call back

*/
GLOBAL  void  rCI_PercentCOPS(/*UBYTE srcId, */
                            SHORT lastIdx,
                            T_ACI_COPS_OPDESC * operLst)
{
  TRACE_FUNCTION("rCI_PercentCOPS()");

  r_Plus_Percent_COPS(AT_CMD_P_COPS, lastIdx, operLst);

}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_Plus_Percent_COPS       |
+--------------------------------------------------------------------+

  PURPOSE : common functioality for rCI_PlusCOPS and rCI_PercentCOPS

*/
LOCAL  void  r_Plus_Percent_COPS  ( T_ACI_AT_CMD cmd,
                                     SHORT lastIdx,
                                     T_ACI_COPS_OPDESC * operLst)
{
  char          *format;
  USHORT i;
  BOOL          END_OF_LIST = FALSE;
  T_ACI_RETURN  ret;
  SHORT         startIdx=0;
  int           pos=0;
  UBYTE srcId = srcId_cb;

  char longName[MAX_ALPHA_OPER_LEN] = { '\0' };
  char shrtName[MAX_ALPHA_OPER_LEN] = { '\0' };

  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("r_Plus_Percent_COPS()");



  if (lastIdx < 0)   /* no operLst available */
  {
    TRACE_EVENT("No operator list available");
    return;
  }

  if (lastIdx < MAX_OPER)
  {
    if(cmd EQ AT_CMD_P_COPS)
    {
       pos=sprintf(g_sa,"%s","%COPS: ");
  }
    else
    {
      pos=sprintf(g_sa,"%s","+COPS: ");
    }
     
  }

  src_params->curAtCmd = AT_CMD_NONE;

  for(i=0; i < MAX_OPER; i++)
  {
    if (operLst[i].status < 0)
    {
      END_OF_LIST = TRUE;
      break;
    }
    
    format = ",(%d,\"%s\",\"%s\",\"%s\")";
    if (i EQ 0)
      format++;   /* the first recond begins without a comma */

    if (operLst[i].pnn)
    {
      if (operLst[i].long_len)
      {
        switch (operLst[i].long_ext_dcs>>4 & 0x07)
        {
          case 0x00:  /* GSM default alphabet */
            utl_cvtPnn7To8((UBYTE *)operLst[i].longOper,
                                    operLst[i].long_len,
                                    operLst[i].long_ext_dcs,
                           (UBYTE *)longName);
            break;
          case 0x01:  /* UCS2 */
            TRACE_ERROR ("Unhandled UCS2 in PNN entry");
            break;
          default:
            TRACE_ERROR ("Unknown DCS in PNN entry");
            break;
        }
      }
      if (operLst[i].shrt_len)
      {
        switch (operLst[i].shrt_ext_dcs>>4 & 0x07)
        {
          case 0x00:  /* GSM default alphabet */
            utl_cvtPnn7To8((UBYTE *)operLst[i].shortOper,
                                    operLst[i].shrt_len,
                                    operLst[i].shrt_ext_dcs,
                           (UBYTE *)shrtName);
            break;
          case 0x01:  /* UCS2 */
            TRACE_ERROR ("ERROR: Unhandled UCS2");
            break;
          default:
            TRACE_ERROR ("ERROR: Unknown DCS");
            break;
        }
      }
      pos+=sprintf(g_sa+pos, format, operLst[i].status, longName, shrtName, operLst[i].numOper);
    }
    else
    {
      pos+=sprintf(g_sa+pos, format, operLst[i].status, operLst[i].longOper, operLst[i].shortOper, operLst[i].numOper);
    }

    /* Beware of overwriting of g_sa */
#ifdef _SIMULATION_   /* Option for line by line output in simulation */
    if (pos > 1)                  /* line-by-line in simulation */
    {
      io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
      g_sa[0]='\0';
      pos=0;
    }
#else
    if (pos > sizeof(g_sa)-80)    /* a single plmn should not exceed 80 bytes */
    {
      io_sendMessageEx(srcId, g_sa, ATI_ECHO_OUTPUT);
      g_sa[0]='\0';
      pos=0;
    }
#endif /* _SIMULATION_ */

  }

  if (i EQ MAX_PLMN_ID)
    END_OF_LIST = TRUE;

  if (!END_OF_LIST)
  {
    startIdx=lastIdx+1;
    do
    {
      if(cmd EQ AT_CMD_P_COPS)
      {
        ret=tAT_PercentCOPS(srcId,startIdx,&lastIdx,&operLst[0]);
      }
      else
      {
      ret=tAT_PlusCOPS(srcId,startIdx,&lastIdx,&operLst[0]);
      }
      
      if (ret EQ AT_CMPL)
      {
        END_OF_LIST=FALSE;
        for(i=0;i<MAX_OPER;i++)
        {
          if (operLst[i].status < 0)
          {
            END_OF_LIST = TRUE;
            break;
          }
          pos+=sprintf(g_sa+pos,",(%d,\"%s\",\"%s\",\"%s\")",
                       operLst[i].status,operLst[i].longOper,
                       operLst[i].shortOper,operLst[i].numOper);

          /* Beware of overwriting of g_sa */
#ifdef _SIMULATION_
          if (pos > 1)                  /* line-by-line in simulation */
          {
            io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
            g_sa[0]='\0';
            pos=0;
          }
#else
          if (pos > sizeof(g_sa)-80)    /* a single plmn should not exceed 80 bytes */
          {
            io_sendMessageEx(srcId, g_sa, ATI_ECHO_OUTPUT);
            g_sa[0]='\0';
            pos=0;
          }
#endif /* _SIMULATION_ */

        }
      }
      if (ret EQ AT_EXCT)
      {
        src_params->curAtCmd = cmd;
        break;
      }
      if (ret EQ AT_FAIL)
      {
        cmdCmeError(CME_ERR_Unknown);
        break;
      }
    }
    while(!END_OF_LIST);
  }
  if (END_OF_LIST)
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);

}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_CCWA           |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_CCWA call back

*/
#ifdef NO_ASCIIZ
GLOBAL void rCI_PlusCCWA  ( /*UBYTE srcId,*/
                            T_ACI_CLSSTAT * clsStat,
                            CHAR          * number,
                            T_ACI_TOA     * type,
                            U8              validity,
                            T_ACI_CLASS     class_type,
                            T_ACI_PB_TEXT * alpha )
#else  /* ifdef NO_ASCIIZ */
GLOBAL void rCI_PlusCCWA  (/*UBYTE srcId,     */
                           T_ACI_CLSSTAT  * clsStat,
                           CHAR           * number,
                           T_ACI_TOA      * type,
                           U8               validity,
                           T_ACI_CLASS      class_type,
                           CHAR           * alpha )
#endif /* ifdef NO_ASCIIZ */
{
  char*  me                        = "+CCWA: ";
  int    i                         = 0;
  CHAR   cvtdAlpha[2*MAX_ALPHA_LEN];
  USHORT lenCvtdAlpha;
  UBYTE  *uniAlpha = NULL;
  UBYTE  uniAlphaLen = 0;
  UBYTE srcId = srcId_cb;
  T_ACI_CLASS test_class;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PlusCCWA()");

#ifdef NO_ASCIIZ
  if ( alpha NEQ NULL )
  {
    uniAlpha = alpha->data;
    uniAlphaLen = alpha->len;
  }
#else  /* ifdef NO_ASCIIZ */
  if ( alpha NEQ NULL )
  {
    uniAlpha = (UBYTE *)alpha;
    uniAlphaLen = strlen(alpha);
  }
#endif /* ifdef NO_ASCIIZ */

  if(clsStat)          /*Callback for q_AT_PlusCCWA*/
  {

    if (clsStat->status EQ STATUS_Active)
    {
      src_params->curAtCmd = AT_CMD_NONE;
      test_class = 1;
      while( test_class < 2*CLASS_Fax )
      {
        if( clsStat->class_type & test_class )
        {
          TRACE_EVENT_P1("test_class: %d", test_class);

          sprintf(g_sa,"%s%d,%d", me, clsStat->status, test_class);
          io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
        }
        test_class *= 2; /* test next class */
      }
    }
    else
    {
      sprintf ( g_sa, "%s0,%d",me, clsStat->class_type );
      io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
    }
  }
  else                    /*call waiting indication*/
  {
    if ( at.flags.CCWA_stat
/*         AND
         (
           io_getIoMode ( ) EQ IO_MODE_CMD OR
           io_getIoMode ( ) EQ IO_MODE_RUN
         )*/
       )
    {
      i=sprintf(g_sa,"%s",me);
      if (number)
      {
        i+=sprintf(g_sa+i,"\"%s\",",number);
        if (type)
          i+=sprintf(g_sa+i,"%d,",toa_merge(*type));
        else
          i+=sprintf(g_sa+i,"128,");
      }
      else
        i+=sprintf(g_sa+i,"\"\",128,");

      if (class_type >=0)
        i+=sprintf(g_sa+i,"%d,",class_type);
      else
        i+=sprintf(g_sa+i,",");

      if (alpha)
      {
        utl_chsetFromSim ( uniAlpha,
                           uniAlphaLen,
                           (UBYTE*)cvtdAlpha,
                           sizeof(cvtdAlpha),
                           &lenCvtdAlpha,
                           GSM_ALPHA_Def );
        i+=sprints(g_sa+i,cvtdAlpha,lenCvtdAlpha);
      }

      if (validity NEQ PRES_NOT_PRES)
      {
        i += sprintf(g_sa+i,",%d",validity);
      }

      ci_remTrailCom(g_sa, (USHORT)i);
      io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);

#ifdef ACI /* for ATI only version */
      cmhMMI_handleAudioTone ( AT_CMD_NONE, RAT_CCWA, CPI_MSG_NotPresent );
#endif
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_CCFC           |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_CCFC call back

*/

GLOBAL void rCI_PlusCCFC  (/*UBYTE srcId,*/ T_ACI_CCFC_SET* setting)
{
  char *me="+CCFC: ";
  int i=0;
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_PlusCCFC()");

  src_params->curAtCmd = AT_CMD_NONE;

  if (setting)          /*Callback for qAT_PlusCCFC*/
  {
    if (setting->clsstat.status EQ STATUS_Active)
    {
      i=sprintf(g_sa,"%s",me);

      if (setting->clsstat.status NEQ STATUS_NotPresent)
        i+=sprintf(g_sa+i,"%d,",setting->clsstat.status);
      else
        i+=sprintf(g_sa+i,",");
      if (setting->clsstat.class_type NEQ CLASS_NotPresent)
        i+=sprintf(g_sa+i,"%d,",setting->clsstat.class_type);
      else
        i+=sprintf(g_sa+i,",");
      if (setting->number[0] NEQ 0x0 )
        i+=sprintf(g_sa+i,"\"%s\",",setting->number);
      else
        i+=sprintf(g_sa+i,",");
      if (setting->type.npi NEQ NPI_NotPresent )
        i+=sprintf(g_sa+i,"%d,",toa_merge(setting->type));
      else
        i+=sprintf(g_sa+i,",");
      if (setting->subaddr[0] NEQ 0x0 )
        i+=sprintf(g_sa+i,"\"%s\",",setting->subaddr);
      else
        i+=sprintf(g_sa+i,",");
      if (setting->satype.tos NEQ TOS_NotPresent )
        i+=sprintf(g_sa+i,"%d,",tos_merge(setting->satype));
      else
        i+=sprintf(g_sa+i,",");
      if (setting->time NEQ ACI_NumParmNotPresent)
        i+=sprintf(g_sa+i,"%d",setting->time);

      ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
      io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
    }
    else
    {
      sprintf ( g_sa, "%s0,%d",me, setting->clsstat.class_type );
      io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_CLCK           |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_CLCK call back

*/

GLOBAL void rCI_PlusCLCK  (/*UBYTE srcId,*/ T_ACI_CLSSTAT  * clsStat)

{
  char *me="+CLCK: ";
  int i=0;
  UBYTE srcId = srcId_cb;
  T_ACI_CLASS test_class;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);



  TRACE_FUNCTION("rCI_PlusCLCK()");

  src_params->curAtCmd = AT_CMD_NONE;

  if(clsStat)          /*Callback for qAT_PlusCLCK*/
  {
    if (clsStat->status EQ STATUS_Active)
    {
      test_class = 1;

      while( test_class < 2*CLASS_Sms )
      {
        if( clsStat->class_type & test_class )
        {
          sprintf(g_sa,"%s%d,%d",me,clsStat->status,test_class);
          io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
        }
        test_class *= 2; /* test next class */
      }
    }
    else
    {
      sprintf ( g_sa, "%s0,%d", me, clsStat->class_type );
      io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_CRSM           |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_CRSM call back

*/

GLOBAL void rCI_PlusCRSM  ( /*UBYTE srcId,*/
                            SHORT           sw1,
                            SHORT           sw2,
                            SHORT           rspLen,
                            UBYTE          *rsp    )
{
  int    i=0;
  UBYTE srcId = srcId_cb;


  TRACE_FUNCTION("rCI_PlusCRSM()");

  i=sprintf(g_sa,"%s","+CRSM: ");

  if (sw1 NEQ ACI_NumParmNotPresent)
    i+=sprintf(g_sa+i,"%d,",sw1);
  else
    i+=sprintf(g_sa+i,",");
  if (sw2 NEQ ACI_NumParmNotPresent)
    i+=sprintf(g_sa+i,"%d,",sw2);
  else
    i+=sprintf(g_sa+i,",");
  if (rspLen AND rsp)
  {
    utl_binToHex( rsp, rspLen, g_sa+i );
  }

  ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_CSIM           |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_CSIM call back

*/

GLOBAL void rCI_PlusCSIM  ( /*UBYTE srcId,*/
                            SHORT           len,
                            UBYTE          *rsp    )
{
  UBYTE i;
  UBYTE srcId = srcId_cb;
  SHORT rstLen = 0;
  SHORT tmpLen;

  TRACE_FUNCTION("rCI_PlusCSIM()");

  i=sprintf(g_sa,"%s%d,","+CSIM: ",len*2);

  if (len AND rsp)
  {
    if( len*2+i > (MAX_CMD_LEN-1) ) rstLen = (len*2+i) - (MAX_CMD_LEN-1);

    tmpLen = (rstLen)?len-rstLen/2:len;

    utl_binToHex( rsp, tmpLen, g_sa+i );
    io_sendMessageEx(srcId, g_sa, ATI_NORMAL_OUTPUT|ATI_BEGIN_CRLF_OUTPUT );
    while( rstLen )
    {
      rsp    += tmpLen;
      tmpLen  = rstLen/2;

      rstLen =( tmpLen*2 > (MAX_CMD_LEN-1))?tmpLen*2 - (MAX_CMD_LEN-1):0;

      if(rstLen) tmpLen = tmpLen-rstLen/2;

      utl_binToHex( rsp, tmpLen, g_sa );
      io_sendMessageEx(srcId, g_sa, ATI_NORMAL_OUTPUT);
    }
    g_sa[0] = '\0';
    io_sendMessageEx(srcId, g_sa, ATI_NORMAL_OUTPUT|ATI_END_CRLF_OUTPUT);
  }
  else
  {
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_CSMS           |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_CSMS call back

*/

GLOBAL void rCI_PlusCSMS  ( /*UBYTE srcId,*/
                            T_ACI_CSMS_SERV service,
                            T_ACI_CSMS_SUPP mt,
                            T_ACI_CSMS_SUPP mo,
                            T_ACI_CSMS_SUPP bm)

{
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  char *me="+CSMS: ";
  int i=0;

  TRACE_FUNCTION("rCI_PlusCSMS()");

  src_params->curAtCmd = AT_CMD_NONE;
  if (service < 0)
    sprintf(g_sa,"%s%d,%d,%d",me,mt,mo,bm);
  else
    sprintf(g_sa,"%s%d,%d,%d,%d",me,service,mt,mo,bm);
  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_CPMS           |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_CPMS call back

*/

GLOBAL void rCI_PlusCPMS  ( /*UBYTE srcId,*/
                            T_ACI_SMS_STOR_OCC * mem1,
                            T_ACI_SMS_STOR_OCC * mem2,
                            T_ACI_SMS_STOR_OCC * mem3 )

{
  CHAR* me         = "+CPMS: ";
  CHAR  memstr1[3] = {0};
  CHAR  memstr2[3] = {0};
  CHAR  memstr3[3] = {0};
  BOOL  f1         = TRUE;
  BOOL  f2         = TRUE;
  BOOL  f3         = TRUE;
  int   i          = 0;
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PlusCPMS()");

  src_params->curAtCmd = AT_CMD_NONE;

  if ( cpmsCallType EQ QAT_CALL )
  {
    for ( i=0; sms_mem[i].name != NULL; i++ )
    {
      if ( ( sms_mem[i].stor EQ mem1->mem ) AND f1 )
      {
        strcpy ( memstr1, sms_mem[i].name );
        f1 = FALSE;
      }

      if ( ( sms_mem[i].stor EQ mem2->mem ) AND f2 )
      {
        strcpy ( memstr2, sms_mem[i].name );
        f2 = FALSE;
      }

      if ( ( sms_mem[i].stor EQ mem3->mem ) AND f3 )
      {
        strcpy ( memstr3, sms_mem[i].name );
        f3 = FALSE;
      }

    }
    sprintf ( g_sa, "%s\"%s\",%d,%d,\"%s\",%d,%d,\"%s\",%d,%d",
              me, memstr1, mem1->used, mem1->total,
                  memstr2, mem2->used, mem2->total,
                  memstr3, mem3->used, mem3->total );
  }
  else
  {
    sprintf ( g_sa, "%s%d,%d,%d,%d,%d,%d",
              me, mem1->used, mem1->total,
                  mem2->used, mem2->total,
                  mem3->used, mem3->total );
  }

  io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );

  cpmsCallType = NONE_CALL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMS        |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCMS call back
*/

GLOBAL void rCI_PlusCMS ( /*UBYTE srcId,*/ T_ACI_AT_CMD cmdId, T_ACI_CMS_ERR err,
                         T_EXT_CMS_ERROR *conc_error)
{
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PLusCMS()");

  ledit_ctrl (srcId,LEDIT_CTRL_CMPL, NULL);

  if ( curAbrtCmd EQ AT_CMD_NONE )
  {
    src_params->curAtCmd    = AT_CMD_NONE;
    io_sendConfirm(srcId, cmdCmsError(err), ATI_NORMAL_OUTPUT);
    cmdErrStr   = NULL;
  }
  else
  {
    curAbrtCmd = AT_CMD_NONE;
    io_sendMessage ( srcId, cmdCmsError ( CMS_ERR_FailedToAbort ),
                            ATI_NORMAL_OUTPUT | ATI_RESULT_CODE_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCBM        |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCBM call back
*/

GLOBAL void rCI_PlusCBM   ( T_MMI_CBCH_IND * mmi_cbch_ind )
{

  UBYTE srcId = srcId_cb;
  T_ATI_IO_MODE  ioMode;
#if defined (SMS_PDU_SUPPORT)
  T_ACI_CMGF_MOD mode;
#endif

  TRACE_FUNCTION("rCI_PlusCBM()");

  /* Check if the source invoking this function is the same as the one 
   * interested in SMS indications */ /* Issue 25033 */
  if (srcId NEQ smsShrdPrm.smsSrcId)
    return;

  ioMode = ati_get_mode( srcId_cb );

  if ( !cnmiFlushInProgress
       AND (ioMode NEQ ATI_UNKN_MODE)
       AND ( (at.CNMI_mode EQ CNMI_MOD_Buffer)
             OR
             ((ioMode EQ ATI_DATA_MODE) AND (at.CNMI_mode EQ CNMI_MOD_BufferAndFlush)) ) )
  {
    T_CNMI_IND ind;

    memcpy (&ind.cbm, mmi_cbch_ind, sizeof(T_MMI_CBCH_IND));
    cmd_addCnmiNtry ( CNMI_CBM, &ind );
  }
  else if ( cnmiFlushInProgress             OR
            ( ioMode EQ ATI_CMD_MODE        AND
              at.CNMI_mode NEQ CNMI_MOD_Buffer ) )
#if defined (SMS_PDU_SUPPORT)
  {
    /*
     * request current mode
     */
    qAT_PlusCMGF(srcId, &mode);
    if (mode EQ 0)
    {
      /*
       * handle PDU mode
       */
      rCI_PlusCBMPdu (mmi_cbch_ind);
    }
    else
    {
      /*
       * handle Text mode
       */
      rCI_PlusCBMText (mmi_cbch_ind);
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCBM        |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCBM call back
*/

LOCAL void rCI_PlusCBMText   ( T_MMI_CBCH_IND * mmi_cbch_ind )
#endif  /* SMS_PDU_SUPPORT */
{
  USHORT pos;
  USHORT lenCvtdData             = 0;
  CHAR   cvtdData[2*MAX_CBM_LEN] = {0x00};
  UBYTE  srcId = srcId_cb;
  USHORT         sn;       /* serial number               */
  USHORT         mid;      /* message identifier          */
  UBYTE          dcs;      /* data coding scheme          */
  UBYTE          page;     /* actual page number          */
  UBYTE          pages;    /* total number of pages       */
  T_ACI_CBM_DATA msg;      /* cell broadcast message data */

  TRACE_FUNCTION("rCI_PLusCBMText()");


  /*
   *-----------------------------------------------------------------
   * process parameters for new message indication
   *-----------------------------------------------------------------
   */
  sn    = ( ( SHORT )mmi_cbch_ind->cbch_msg[0] << 8 ) +
                     mmi_cbch_ind->cbch_msg[1];
  mid   = ( ( SHORT )mmi_cbch_ind->cbch_msg[2] << 8 ) +
                     mmi_cbch_ind->cbch_msg[3];
  dcs   = mmi_cbch_ind->cbch_msg[4];
  page  = ( mmi_cbch_ind->cbch_msg[5] & 0xF0 ) >> 4;
  pages = ( mmi_cbch_ind->cbch_msg[5] & 0x0F );

  /*
   *-----------------------------------------------------------------
   * process message data, expanding from 7 to 8 bit
   *-----------------------------------------------------------------
   */
  cmhSMS_expdSmsCb ( dcs,
                     &mmi_cbch_ind->cbch_msg[CBCH_HEAD_LEN],
                     (UBYTE)(mmi_cbch_ind->cbch_len - CBCH_HEAD_LEN),
                     msg.data, &msg.len );

  pos=sprintf(g_sa,"+CBM: %d,%d,%d,%d,%d",sn,mid,dcs,page,pages);
  io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
  if (msg.len > 0)
  {
    pos = 0;

    utl_cbmDtaToTe((UBYTE*)msg.data,
                   msg.len,
                   (UBYTE*)cvtdData,
                   sizeof(cvtdData),
                   &lenCvtdData,
                   0,
                   (UBYTE)dcs);

    pos+=sprintq(g_sa+pos,cvtdData,lenCvtdData);

    io_sendMessageEx(srcId, g_sa, ATI_INDICATION_OUTPUT +
                                ATI_FORCED_OUTPUT +
                                ATI_END_CRLF_OUTPUT);
  }
}
#if !defined (SMS_PDU_SUPPORT)
} /* rCI_PlusCBM */
#endif

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCDS        |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCDS call back
*/

GLOBAL void rCI_PlusCDS   ( T_MNSMS_STATUS_IND * mnsms_status_ind )
{

  UBYTE srcId = srcId_cb;
  T_ATI_IO_MODE  ioMode;
#if defined (SMS_PDU_SUPPORT)
  T_ACI_CMGF_MOD mode;
#endif

  TRACE_FUNCTION("rCI_PLusCDS()");

  /* Check if the source invoking this function is the same as the one 
   * interested in SMS indications */ /* Issue 25033 */
  if (srcId NEQ smsShrdPrm.smsSrcId)
    return;

  ioMode = ati_get_mode( srcId_cb );

  if ( !cnmiFlushInProgress
       AND (ioMode NEQ ATI_UNKN_MODE)
       AND ( (at.CNMI_mode EQ CNMI_MOD_Buffer)
             OR
             ((ioMode EQ ATI_DATA_MODE) AND (at.CNMI_mode EQ CNMI_MOD_BufferAndFlush)) ) )
  {
    T_CNMI_IND ind;

    memcpy ( &ind.cds, mnsms_status_ind, sizeof ( T_MNSMS_STATUS_IND) );
    cmd_addCnmiNtry ( CNMI_CDS, &ind );
  }
  else if ( cnmiFlushInProgress             OR
            ( ioMode EQ ATI_CMD_MODE        AND
              at.CNMI_mode NEQ CNMI_MOD_Buffer ) )
#if defined (SMS_PDU_SUPPORT)
  {
    /*
     * request current mode
     */
    qAT_PlusCMGF(srcId, &mode);
    if (mode EQ 0)
    {
      /*
       * handle PDU mode
       */
      rCI_PlusCDSPdu (mnsms_status_ind);
    }
    else
    {
      /*
       * handle Text mode
       */
      rCI_PlusCDSText (mnsms_status_ind);
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCDSText    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCDS call back for text mode
*/

LOCAL void rCI_PlusCDSText   (T_MNSMS_STATUS_IND * mnsms_status_ind)
#endif /* SMS_PDU_SUPPORT */
{

  UBYTE srcId = srcId_cb;
  T_ACI_CDS_SM* p_st;
  SHORT pos   = 0;

  TRACE_FUNCTION("rCI_PLusCDSText()");



  /* is the SM already decoded ? */
  if (smsShrdPrm.pDecMsg)
    p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
  else
  {
    ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CDS_SM) );
    p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
    cmhSMS_cpyStatInd ( p_st, mnsms_status_ind);
  }

  pos=sprintf(g_sa,"+CDS: %d,%d,",p_st->fo, p_st->msg_ref);
  if (strlen(p_st->addr))
    pos+=sprintf(g_sa+pos,"\"%s\"",p_st->addr);
  else
    pos+=sprintf(g_sa+pos,",");
  if( (p_st->toa.ton NEQ TON_NotPresent) AND (p_st->toa.npi NEQ NPI_NotPresent) )
    pos+=sprintf(g_sa+pos,",%d",toa_merge(p_st->toa));
  else
    pos+=sprintf(g_sa+pos,",");

  pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
    p_st->vpabs_scts.year  [0], p_st->vpabs_scts.year  [1],
    p_st->vpabs_scts.month [0], p_st->vpabs_scts.month [1],
    p_st->vpabs_scts.day   [0], p_st->vpabs_scts.day   [1],
    p_st->vpabs_scts.hour  [0], p_st->vpabs_scts.hour  [1],
    p_st->vpabs_scts.minute[0], p_st->vpabs_scts.minute[1],
    p_st->vpabs_scts.second[0], p_st->vpabs_scts.second[1],
    p_st->vpabs_scts.timezone);

  pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\",%d",
    p_st->vpabs_dt.year  [0], p_st->vpabs_dt.year  [1],
    p_st->vpabs_dt.month [0], p_st->vpabs_dt.month [1],
    p_st->vpabs_dt.day   [0], p_st->vpabs_dt.day   [1],
    p_st->vpabs_dt.hour  [0], p_st->vpabs_dt.hour  [1],
    p_st->vpabs_dt.minute[0], p_st->vpabs_dt.minute[1],
    p_st->vpabs_dt.second[0], p_st->vpabs_dt.second[1],
    p_st->vpabs_dt.timezone , p_st->tp_status);

  io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
}
#if !defined (SMS_PDU_SUPPORT)
} /* rCI_PlusCDS */
#endif

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMT        |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCMT call back
*/

GLOBAL void rCI_PlusCMT (T_MNSMS_MESSAGE_IND* mnsms_message_ind)
{
  UBYTE srcId = srcId_cb;
  T_ATI_IO_MODE  ioMode;
#if defined (SMS_PDU_SUPPORT)
  T_ACI_CMGF_MOD mode;
#endif

  TRACE_EVENT_P1("rCI_PlusCMT(): source Id: %d", srcId);

  /* Check if the source invoking this function is the same as the one 
   * interested in SMS indications */ /* Issue 25033 */
  if (srcId NEQ smsShrdPrm.smsSrcId)
    return;

  ioMode = ati_get_mode( srcId );
  if( ioMode EQ ATI_UNKN_MODE )
  {
    TRACE_EVENT("rCI_PlusCMT(): unused source (unknown ioMode) -> return");
    return;
  }

  if ( !cnmiFlushInProgress       AND
       ( (at.CNMI_mode EQ CNMI_MOD_Buffer)
          OR
         ( (ioMode       EQ ATI_DATA_MODE) AND 
           (at.CNMI_mode EQ CNMI_MOD_BufferAndFlush)) ) )
  { /* terminal is busy --> store data into CNMI buffer */
    T_CNMI_IND ind;

    TRACE_EVENT("rCI_PlusCMT(): terminal busy or buffer mode --> store data into CNMI buffer");
    memcpy ( &ind.cmt, mnsms_message_ind, sizeof ( T_MNSMS_MESSAGE_IND) );
    cmd_addCnmiNtry ( CNMI_CMT, &ind );
    if ( smsShrdPrm.cnma_ack_expected EQ TRUE )
    { /* the acknowledge must be send automatically, because terminal is busy */
      PALLOC (mnsms_ack_res, MNSMS_ACK_RES);

      TRACE_EVENT("rCI_PlusCMT(): send 'automatic' acknowledge (Phase2+ mode and buffer)");

      mnsms_ack_res->resp          = SMS_RP_ACK;
      mnsms_ack_res->sms_sdu.o_buf = 0;
      mnsms_ack_res->sms_sdu.l_buf = 0;

      PSENDX (SMS, mnsms_ack_res);

      smsShrdPrm.cnma_ack_expected = FALSE;
    }
  }
  else
  { /* flush in progress or terminal is not busy */
    TRACE_EVENT("rCI_PlusCMT(): flush in progress or command mode --> show +CMT on terminal");
    if ( cnmiFlushInProgress               OR
         ( (ioMode        EQ ATI_CMD_MODE) AND
           (at.CNMI_mode NEQ CNMI_MOD_Buffer) ) )
#if defined (SMS_PDU_SUPPORT)
    { /* request current mode (text or PDU) */
      if( smsShrdPrm.CNMImt EQ 0 )
      {
        TRACE_EVENT("rCI_PlusCMT(): +CNMI <mt>=0 --> no routing to terminal (error in SMS entity)");
        return;
      }
      qAT_PlusCMGF(srcId, &mode);
      if (mode EQ 0)
      {
        /*
         * handle PDU mode
         */
        rCI_PlusCMTPdu (mnsms_message_ind);
      }
      else
      {
        /*
         * handle Text mode
         */
        rCI_PlusCMTText (mnsms_message_ind);
      }
    }
    else
    {
      TRACE_EVENT_P3("rCI_PlusCMT(): cannot display the +CMT --> flushInProgess?: %d, ioMode: %d, CNMI Mode: % d",
                     cnmiFlushInProgress, ioMode, at.CNMI_mode);
    }
  }
}


LOCAL void rCI_PlusCMTText (T_MNSMS_MESSAGE_IND* mnsms_message_ind)
#endif  /* SMS_PDU_SUPPORT */
{
  SHORT     pos                         = 0;
  CHAR      cvtdAlpha[2*MAX_ALPHA_LEN];
  USHORT    lenCvtdAlpha;
  CHAR      cvtdData[2*MAX_SM_LEN];
  USHORT    lenCvtdData;
  UBYTE srcId = srcId_cb;
  T_ACI_CMGL_SM* p_sm;
#if defined FF_EOTD
  T_LOC_MLC_ADDRESS* lc_orig_addr_ptr;
  int i = 0;
#endif

  TRACE_FUNCTION("rCI_PlusCMTText()");

  pos=sprintf(g_sa,"+CMT: ");

  /* is the SM already decoded ? */
  if (smsShrdPrm.pDecMsg)
    p_sm = smsShrdPrm.pDecMsg;
  else
  {
    ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) );
    p_sm = smsShrdPrm.pDecMsg;
    cmhSMS_cpyMsgInd ( p_sm, mnsms_message_ind);
  }

#if defined FF_EOTD
    memset(&lc_orig_addr,0,sizeof(T_LOC_MLC_ADDRESS));
    lc_orig_addr_ptr = &lc_orig_addr;
    lc_orig_addr_ptr->toa.npi = p_sm->toa.npi;
    lc_orig_addr_ptr->toa.ton = p_sm->toa.ton;
    if(lc_orig_addr_ptr->toa.ton EQ TON_International)
    {
          lc_orig_addr_ptr->address[i] = '+';
          i++;
    }
    strncpy(lc_orig_addr_ptr->address+i,p_sm->adress,sizeof(p_sm->adress)-(size_t)i);
#endif /* FF_EOTD */

  pos+=sprintf(g_sa+pos,"\"%s\",",p_sm->adress);

#ifdef FF_ATI_BAT

  /*
  *   Extracting the alphanumeric data from the phonebook at this point
  *   would defeat the object (testing the BAT message). Having this
  *   data stored globally represents an easier solution to the
  *   problem of conveying it here.
  */
  if (smsShrdPrm.alpha_len)
  {
    pos+=sprints(g_sa+pos,smsShrdPrm.alpha,smsShrdPrm.alpha_len);
  }

#else

  if( p_sm->alpha.len > 0 )
  {
    utl_chsetFromGsm((UBYTE*)p_sm->alpha.data,
                     p_sm->alpha.len,
                     (UBYTE*)cvtdAlpha,
                     sizeof(cvtdAlpha),
                     &lenCvtdAlpha,
                     GSM_ALPHA_Def);
    pos+=sprints(g_sa+pos,cvtdAlpha,lenCvtdAlpha);
  }

#endif

  pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",  /* SCTS */
    p_sm->scts.year  [0], p_sm->scts.year  [1],
    p_sm->scts.month [0], p_sm->scts.month [1],
    p_sm->scts.day   [0], p_sm->scts.day   [1],
    p_sm->scts.hour  [0], p_sm->scts.hour  [1],
    p_sm->scts.minute[0], p_sm->scts.minute[1],
    p_sm->scts.second[0], p_sm->scts.second[1],
    p_sm->scts.timezone);

  if (ati_user_output_cfg[srcId].CSDH_stat)
  {
    if(strlen(p_sm->adress))
      pos+=sprintf(g_sa+pos,",%d",toa_merge(p_sm->toa));
    else
      pos+=sprintf(g_sa+pos,",");
    pos+=sprintf(g_sa+pos,",%d,%d,%d",p_sm->fo,p_sm->pid,p_sm->dcs);  /*FO, PID, DCS*/

    if(strlen(p_sm->sca))
    {
      pos+=sprintf(g_sa+pos,",\"%s\"",p_sm->sca);
      pos+=sprintf(g_sa+pos,",%d",toa_merge(p_sm->tosca));
    }
    else
      pos+=sprintf(g_sa+pos,",,");
  }

  if (((UBYTE)p_sm->fo & TP_UDHI_MASK) EQ TP_UDHI_WITH_HEADER)
  {
    T_ACI_SM_DATA data;

    aci_frmtOutput(p_sm->fo, p_sm->dcs, &data);

    utl_smDtaToTe((UBYTE*)data.data,
                  data.len,
                  (UBYTE*)cvtdData,
                  sizeof(cvtdData),
                  &lenCvtdData,
                  (UBYTE)p_sm->fo,
                  (UBYTE)p_sm->dcs);

    if (ati_user_output_cfg[srcId].CSDH_stat)
      pos+=sprintf(g_sa+pos,",%d",data.len);

    io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);

    pos=sprintq(g_sa,cvtdData,lenCvtdData);
    io_sendMessageEx(srcId, g_sa, ATI_INDICATION_OUTPUT +
                                ATI_FORCED_OUTPUT +
                                ATI_END_CRLF_OUTPUT);
  }
  else
  {
    if (ati_user_output_cfg[srcId].CSDH_stat)
      pos+=sprintf(g_sa+pos,",%d",p_sm->data.len);

    io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);

    if (p_sm->data.len > 0)
    {
      utl_smDtaToTe((UBYTE*)p_sm->data.data,
                    p_sm->data.len,
                    (UBYTE*)cvtdData,
                    sizeof(cvtdData),
                    &lenCvtdData,
                    (UBYTE)p_sm->fo,
                    (UBYTE)p_sm->dcs);
      pos=sprintq(g_sa,cvtdData,lenCvtdData);
    }
    else
    {
      g_sa[0]='\0';
    }
    io_sendMessageEx(srcId, g_sa, ATI_INDICATION_OUTPUT +
                                  ATI_FORCED_OUTPUT +
                                  ATI_END_CRLF_OUTPUT);
  }
}
#if !defined (SMS_PDU_SUPPORT)
} /* else in previous function */
} /* rCI_PlusCMT */
#endif

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMGR       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCMGR call back (Read Message)
*/

GLOBAL void rCI_PlusCMGR  ( T_MNSMS_READ_CNF* mnsms_read_cnf,
                            T_ACI_CMGR_CBM * cbm)
{
  UBYTE msg_type;
#if defined (SMS_PDU_SUPPORT)
  UBYTE srcId = srcId_cb;
  T_ACI_CMGF_MOD mode;

  /*
   * request current mode
   */
  qAT_PlusCMGF(srcId, &mode);
  if (mode EQ 0)
    /*
     * handle PDU mode
     */
    rCI_Plus_Percent_CMGRPdu (mnsms_read_cnf, AT_CMD_CMGR);
  else
#endif
    /*
     * handle Text mode
     */
  {
   /* querying the type of the SM */
   cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type);

   if (msg_type EQ TP_MTI_SMS_STATUS_REP)
     rCI_Plus_Percent_CMGRTextSP (mnsms_read_cnf, AT_CMD_CMGR);
   else
     rCI_Plus_Percent_CMGRText (mnsms_read_cnf, cbm, AT_CMD_CMGR);
  }
}

LOCAL void rCI_Plus_Percent_CMGRText (T_MNSMS_READ_CNF* mnsms_read_cnf,
                                      T_ACI_CMGR_CBM * cbm,
                                      T_ACI_AT_CMD cmd )
{
  CHAR*      buf;
  SHORT      pos      = 0;

  CHAR       cvtdAlpha[2*MAX_ALPHA_LEN];
  USHORT     lenCvtdAlpha;
  CHAR       cvtdData[2*MAX_SM_LEN];
  USHORT     lenCvtdData;
  UBYTE srcId = srcId_cb;
  T_ACI_CMGL_SM* p_sm;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);
  char       vpenh_str[15];

  TRACE_FUNCTION("rCI_Plus_Percent_CMGRText()");

  src_params->curAtCmd = AT_CMD_NONE;

  /* is the SM already decoded ? */
  if (smsShrdPrm.pDecMsg)
    p_sm = smsShrdPrm.pDecMsg;
  else
  {
    ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) );
    p_sm = smsShrdPrm.pDecMsg;
    cmhSMS_cpyReadCnf (p_sm, mnsms_read_cnf);
  }

  buf=sms_status(p_sm->stat);

  if (buf) /* STATUS */
  {
    if (cmd EQ AT_CMD_CMGR)
    {
      pos=sprintf(g_sa,"+CMGR: \"%s\"",buf);
    }
    else
    {
      pos=sprintf (g_sa, " %s:  \"%s\"", "%CMGR", buf);
    }
  }
  else
  {
    if (cmd EQ AT_CMD_CMGR)
    {
      pos=sprintf(g_sa,"+CMGR: ,");
    }
    else
    {
      pos=sprintf (g_sa, " %s", "%CMGR: ,");
    }
  }
  pos+=sprintf(g_sa+pos,",\"%s\"",p_sm->adress); /*Destination Address*/

#ifdef FF_ATI_BAT

  /*
  *   Extracting the alphanumeric data from the phonebook at this point
  *   would defeat the object (testing the BAT message). Having this
  *   data stored globally represents a quick and dirty solution to the
  *   problem of conveying it here.
  */
  if (smsShrdPrm.alpha_len)
  {
    pos+=sprints(g_sa+pos,smsShrdPrm.alpha,smsShrdPrm.alpha_len);
  }
  else
  {
    pos+=sprintf(g_sa+pos,",");
  }

#else

  if (p_sm->alpha.len > 0) /*ALPHA*/
  {
    pos+=sprintf(g_sa+pos,",");
    utl_chsetFromGsm((UBYTE*)p_sm->alpha.data,
                     p_sm->alpha.len,
                     (UBYTE*)cvtdAlpha,
                     sizeof(cvtdAlpha),
                     &lenCvtdAlpha,
                     GSM_ALPHA_Def);
    pos+=sprints(g_sa+pos,cvtdAlpha,lenCvtdAlpha);
  }
  else
    pos+=sprintf(g_sa+pos,",");

#endif /*FF_ATI_BAT*/

  if ((p_sm->fo & TP_MTI_MASK) EQ TP_MTI_SMS_DELIVER)
  {
    pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
        p_sm->scts.year  [0], p_sm->scts.year  [1],
        p_sm->scts.month [0], p_sm->scts.month [1],
        p_sm->scts.day   [0], p_sm->scts.day   [1],
        p_sm->scts.hour  [0], p_sm->scts.hour  [1],
        p_sm->scts.minute[0], p_sm->scts.minute[1],
        p_sm->scts.second[0], p_sm->scts.second[1],
        p_sm->scts.timezone);
  }

  if(ati_user_output_cfg[srcId].CSDH_stat)
  {
    if(strlen(p_sm->adress)) /*TOA Destination*/
      pos+=sprintf(g_sa+pos,",%d",toa_merge(p_sm->toa));
    else
      pos+=sprintf(g_sa+pos,",");
    pos+=sprintf(g_sa+pos,",%d,%d,%d",p_sm->fo,p_sm->pid,p_sm->dcs); /*FO, PID, DCS*/

    if ((p_sm->fo & TP_MTI_MASK) EQ TP_MTI_SMS_SUBMIT)
    {
      if ((p_sm->fo & TP_VPF_MASK) EQ TP_VPF_ABSOLUTE)
      {
        pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
          p_sm->scts.year  [0], p_sm->scts.year  [1],
          p_sm->scts.month [0], p_sm->scts.month [1],
          p_sm->scts.day   [0], p_sm->scts.day   [1],
          p_sm->scts.hour  [0], p_sm->scts.hour  [1],
          p_sm->scts.minute[0], p_sm->scts.minute[1],
          p_sm->scts.second[0], p_sm->scts.second[1],
          p_sm->scts.timezone);
      }
      else if ((p_sm->fo & TP_VPF_MASK) EQ TP_VPF_ENHANCED)
      {
        aci_encodeVpenh ( vpenh_str, &p_sm->vp_enh );
        pos+=sprintf(g_sa+pos,",\"%s\"",vpenh_str);
      }
      else if ((p_sm->fo & TP_VPF_MASK) EQ TP_VPF_RELATIVE)
        pos+=sprintf(g_sa+pos,",%d",p_sm->vp_rel);
      else
        pos+=sprintf(g_sa+pos,",");
    }
    if(strlen(p_sm->sca)) /*Destination Address*/
    {
      pos+=sprintf(g_sa+pos,",\"%s\"",p_sm->sca);
      pos+=sprintf(g_sa+pos,",%d",toa_merge(p_sm->tosca));
    }
    else
      pos+=sprintf(g_sa+pos,",,");
  }

  if (((UBYTE)p_sm->fo & TP_UDHI_MASK) EQ TP_UDHI_WITH_HEADER)
  {
    T_ACI_SM_DATA data;

    aci_frmtOutput (p_sm->fo, p_sm->dcs, &data);

    utl_smDtaToTe((UBYTE*)data.data,
                  data.len,
                  (UBYTE*)cvtdData,
                  sizeof(cvtdData),
                  &lenCvtdData,
                  (UBYTE)p_sm->fo,
                  (UBYTE)p_sm->dcs);

    if(ati_user_output_cfg[srcId].CSDH_stat)
      pos+=sprintf(g_sa+pos,",%d",data.len);

    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);

    pos=sprintq(g_sa,cvtdData,lenCvtdData);
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
  else
  {
    if(ati_user_output_cfg[srcId].CSDH_stat)
      pos+=sprintf(g_sa+pos,",%d",p_sm->data.len);

    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);

    if (p_sm->data.len > 0)
    {
      utl_smDtaToTe( (UBYTE*)p_sm->data.data,
                     p_sm->data.len,
                     (UBYTE*)cvtdData,
                     sizeof(cvtdData),
                     &lenCvtdData,
                     (UBYTE)p_sm->fo,
                     (UBYTE)p_sm->dcs);
      pos=sprintq(g_sa,cvtdData,lenCvtdData);
    }
    else /* empty SMS passed */
    {
      g_sa[0]='\0';
    }
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMTI       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCMTI call back
*/

GLOBAL void rCI_PlusCMTI   ( /*UBYTE srcId,*/ T_ACI_SMS_STOR mem, UBYTE index)
{
  UBYTE srcId = srcId_cb;
  char      mem_str[3];
  SHORT     i;
  T_ATI_IO_MODE ioMode;

  /* Check if the source invoking this function is the same as the one 
   * interested in SMS indications */ /* Issue 25033 */
  if (srcId NEQ smsShrdPrm.smsSrcId)
    return;

  TRACE_EVENT_P1("rCI_PlusCMTI(): source Id: %d", srcId);
  ioMode = ati_get_mode( srcId_cb );

  if ( !cnmiFlushInProgress
       AND (ioMode NEQ ATI_UNKN_MODE)
       AND ( (at.CNMI_mode EQ CNMI_MOD_Buffer)
             OR
             ((ioMode EQ ATI_DATA_MODE) AND (at.CNMI_mode EQ CNMI_MOD_BufferAndFlush)) ) )
  {
    T_CNMI_IND ind;

    ind.cmti.mem   = mem;
    ind.cmti.index = index;

    cmd_addCnmiNtry ( CNMI_CMTI, &ind );
  }
  else if ( cnmiFlushInProgress             OR
            ( ioMode EQ ATI_CMD_MODE        AND
              at.CNMI_mode NEQ CNMI_MOD_Buffer ) )
  {
    for (i=0;sms_mem[i].name != 0;i++)
    {
      if (sms_mem[i].stor EQ mem)
      {
        strcpy(mem_str,sms_mem[i].name);
        break;
      }
    }
    sprintf(g_sa,"+CMTI: \"%s\",%d",mem_str,index);
    io_sendIndication(srcId, g_sa, ATI_FORCED_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMGS       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCMGS call back
*/

GLOBAL void rCI_PlusCMGS (T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf)
#if defined (SMS_PDU_SUPPORT)
{
  UBYTE srcId = srcId_cb;

  T_ACI_CMGF_MOD mode;

  /*
   * request current mode
   */
  qAT_PlusCMGF(srcId, &mode);
  if (mode EQ 0)
    /*
     * handle PDU mode
     */
    rCI_PlusCMGSPdu (mnsms_submit_cnf);
  else
    /*
     * handle Text mode
     */
    rCI_PlusCMGSText (mnsms_submit_cnf);
}

LOCAL void rCI_PlusCMGSText ( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf )
#endif
{
  SHORT pos = 0;
  T_ACI_VP_ABS scts;
  UBYTE srcId = srcId_cb;
  UBYTE *buf;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_PlusCMGSText()");

  src_params->curAtCmd = AT_CMD_NONE;

  pos=sprintf(g_sa,"+CMGS: %d", mnsms_submit_cnf->tp_mr);

  if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus)
  {
    if (mnsms_submit_cnf->sms_sdu.l_buf)
    {
      /* skip SCA in SIM-PDU, buf points to SMS-SUBMIT-REPORT */
      buf = mnsms_submit_cnf->sms_sdu.buf + mnsms_submit_cnf->sms_sdu.buf[0] + 1;

      /* advance to TP-SCTS */
      if (mnsms_submit_cnf->cause EQ SMS_NO_ERROR)
        buf += 2;  /* offset in SMS-SUBMIT-REPORT for RP-ACK */
      else
        buf += 3;  /* offset in SMS-SUBMIT-REPORT for RP-ERROR */

      cmh_unpackSCTS (&scts, buf);

      pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",  /* SCTS */
      scts.year  [0], scts.year  [1],
      scts.month [0], scts.month [1],
      scts.day   [0], scts.day   [1],
      scts.hour  [0], scts.hour  [1],
      scts.minute[0], scts.minute[1],
      scts.second[0], scts.second[1],
      scts.timezone);
    }
  }

  io_sendMessageEx( srcId, g_sa,
                    ATI_NORMAL_OUTPUT | ATI_BEGIN_CRLF_OUTPUT | ATI_END_CRLF_OUTPUT);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMSS       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCMSS call back
*/

GLOBAL void rCI_PlusCMSS (T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf)
#if defined (SMS_PDU_SUPPORT)
{
  UBYTE srcId = srcId_cb;

  T_ACI_CMGF_MOD mode;

  /*
   * request current mode
   */
  qAT_PlusCMGF(srcId, &mode);
  if (mode EQ 0)
    /*
     * handle PDU mode
     */
    rCI_PlusCMSSPdu (mnsms_submit_cnf);
  else
    /*
     * handle Text mode
     */
    rCI_PlusCMSSText (mnsms_submit_cnf);
}

LOCAL void rCI_PlusCMSSText ( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf )
#endif
{
  SHORT pos = 0;
  T_ACI_VP_ABS scts;
  UBYTE srcId = srcId_cb;
  UBYTE *buf;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_PlusCMSSText()");

  src_params->curAtCmd = AT_CMD_NONE;

  pos=sprintf(g_sa,"+CMSS: %d", mnsms_submit_cnf->tp_mr);

  if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus)
  {
    if (mnsms_submit_cnf->sms_sdu.l_buf)
    {
      /* skip SCA in SIM-PDU, buf points to SMS-SUBMIT-REPORT */
      buf = mnsms_submit_cnf->sms_sdu.buf + mnsms_submit_cnf->sms_sdu.buf[0] + 1;

      /* advance to TP-SCTS */
      if (mnsms_submit_cnf->cause EQ SMS_NO_ERROR)
        buf += 2;  /* offset in SMS-SUBMIT-REPORT for RP-ACK */
      else
        buf += 3;  /* offset in SMS-SUBMIT-REPORT for RP-ERROR */

      cmh_unpackSCTS (&scts, buf);

      pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",  /* SCTS */
      scts.year  [0], scts.year  [1],
      scts.month [0], scts.month [1],
      scts.day   [0], scts.day   [1],
      scts.hour  [0], scts.hour  [1],
      scts.minute[0], scts.minute[1],
      scts.second[0], scts.second[1],
      scts.timezone);
    }
  }

  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMGW       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCMGW call back
*/

GLOBAL void rCI_PlusCMGW ( /*UBYTE srcId,*/ UBYTE index)
{
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PLusCMGW()");

  src_params->curAtCmd = AT_CMD_NONE;

  sprintf(g_sa,"+CMGW: %d",index);
  io_sendMessageEx( srcId, g_sa,
                    ATI_NORMAL_OUTPUT | ATI_BEGIN_CRLF_OUTPUT | ATI_END_CRLF_OUTPUT);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMGC       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCMGC call back
*/

GLOBAL void rCI_PlusCMGC (T_MNSMS_COMMAND_CNF * mnsms_command_cnf)
#if defined (SMS_PDU_SUPPORT)
{
  UBYTE srcId = srcId_cb;

  T_ACI_CMGF_MOD mode;

  /*
   * request current mode
   */
  qAT_PlusCMGF(srcId, &mode);
  if (mode EQ 0)
    /*
     * handle PDU mode
     */
    rCI_PlusCMGCPdu (mnsms_command_cnf);
  else
    /*
     * handle Text mode
     */
    rCI_PlusCMGCText (mnsms_command_cnf);
}

LOCAL void rCI_PlusCMGCText ( T_MNSMS_COMMAND_CNF * mnsms_command_cnf )
#endif
{
  SHORT pos = 0;
  T_ACI_VP_ABS scts;
  UBYTE srcId = srcId_cb;
  UBYTE *buf;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_PlusCMGCText()");

  src_params->curAtCmd = AT_CMD_NONE;

  pos=sprintf(g_sa,"+CMGC: %d", mnsms_command_cnf->tp_mr);

  if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus)
  {
    if (mnsms_command_cnf->sms_sdu.l_buf)
    {
      /* skip SCA in SIM-PDU, buf points to SMS-STATUS-REPORT */
      buf = mnsms_command_cnf->sms_sdu.buf + mnsms_command_cnf->sms_sdu.buf[0] + 1;

      /* advance to to TP-RA */
      buf += 2;

      /* skip variable TP-RA and advance to TP-SCTS */
      buf += (*buf+1)/2 + 2;  /* length is in BCD digits! TON/NPI is also skipped */

      cmh_unpackSCTS (&scts, buf);

      pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",  /* SCTS */
      scts.year  [0], scts.year  [1],
      scts.month [0], scts.month [1],
      scts.day   [0], scts.day   [1],
      scts.hour  [0], scts.hour  [1],
      scts.minute[0], scts.minute[1],
      scts.second[0], scts.second[1],
      scts.timezone);
    }
  }

  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}



/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusILRR       |
+--------------------------------------------------------------------+

  PURPOSE : handles CI_PlusILRR call back
*/

GLOBAL void rCI_PlusILRR( /*UBYTE srcId, */
                          T_ACI_BS_SPEED  speed,
                          T_ACI_BS_FRM    format,
                          T_ACI_BS_PAR    parity)

{
  LONG val;
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PlusILRR()");

  if ( ati_user_output_cfg[srcId].ILRR_stat )
  {
    switch(speed)
    {
      case(BS_SPEED_300_V110):   val=  300; break;
      case(BS_SPEED_1200_V110):  val= 1200; break;
      case(BS_SPEED_2400_V110):  val= 2400; break;
      case(BS_SPEED_4800_V110):  val= 4800; break;
      case(BS_SPEED_9600_V110):  val= 9600; break;
      case(BS_SPEED_14400_V110): val=14400; break;
      case(BS_SPEED_19200_V110): val=19200; break;
      case(BS_SPEED_38400_V110): val=38400; break;
      default:                   val=    1; break;
    }
    sprintf(g_sa,"+ILRR: %d,%d,%d",val,format,parity);
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentBC      |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_OK call back

*/

GLOBAL void rCI_PercentBC (BYTE segm);

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentDRV     |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_OK call back

*/

GLOBAL void rCI_PercentDRV( T_ACI_DRV_DEV device,
                            T_ACI_DRV_FCT function,
                            UBYTE         val1,
                            UBYTE         val2);

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMGL       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCMGL call back

*/

GLOBAL void rCI_PlusCMGL  (T_MNSMS_READ_CNF *mnsms_read_cnf)
{
  UBYTE msg_type;
#if defined (SMS_PDU_SUPPORT)
  UBYTE srcId = srcId_cb;
  T_ACI_CMGF_MOD mode;

  /*
   * request current mode
   */
  qAT_PlusCMGF(srcId, &mode);
  if (mode EQ 0)
    /*
     * handle PDU mode
     */
    rCI_Plus_Percent_CMGLPdu (mnsms_read_cnf, AT_CMD_CMGL);
  else
#endif
    /*
     * handle Text mode
     */
  {
   /* querying the type of the SM */
   cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type);

   if (msg_type EQ TP_MTI_SMS_STATUS_REP)
     rCI_Plus_Percent_CMGLTextSP (mnsms_read_cnf, AT_CMD_CMGL);
   else
     rCI_Plus_Percent_CMGLText (mnsms_read_cnf, AT_CMD_CMGL);
  }
}


LOCAL void rCI_Plus_Percent_CMGLText (T_MNSMS_READ_CNF *mnsms_read_cnf,
                                      T_ACI_AT_CMD cmd)
{
  SHORT  i = 0;
  SHORT  pos = 0;
  CHAR*  buf;

  CHAR   cvtdAlpha[2*MAX_ALPHA_LEN];
  USHORT lenCvtdAlpha;
  CHAR   cvtdData[2*MAX_SM_LEN];
  USHORT lenCvtdData;
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  T_ACI_CMGL_SM* p_sm;

  TRACE_FUNCTION("rCI_Plus_Percent_CMGLText()");

  src_params->curAtCmd = AT_CMD_NONE;


  /* is the SM already decoded ? */
  if (smsShrdPrm.pDecMsg)
    p_sm = smsShrdPrm.pDecMsg;
  else
  {
    ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) );
    p_sm = smsShrdPrm.pDecMsg;
    cmhSMS_cpyReadCnf (p_sm, mnsms_read_cnf);
  }

  buf = sms_status ( p_sm->stat );

  if (cmd EQ AT_CMD_CMGL )
  {
    pos = sprintf ( g_sa, "+CMGL: %d", p_sm->msg_ref);
  }
  else
  {
    pos=sprintf (g_sa, " %s:  %d", "%CMGL", p_sm->msg_ref);
  }
  if ( buf )
  {
    pos += sprintf ( g_sa + pos, ",\"%s\"", buf );   /* STATUS */
  }
  else
  {
    pos += sprintf ( g_sa + pos, "," );
  }

  if (p_sm->stat EQ SMS_STAT_Invalid)
  {
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); /* emit "INVALID MESSAGE" only */
    return;
  }
  pos += sprintf ( g_sa + pos, ",\"%s\",", p_sm->adress);

#ifdef FF_ATI_BAT

  /*
  *   Extracting the alphanumeric data from the phonebook at this point
  *   would defeat the object (testing the BAT message). Having this
  *   data stored globally represents a quick and dirty solution to the
  *   problem of conveying it here.
  */
  if (smsShrdPrm.alpha_len)
  {
    pos+=sprints(g_sa+pos,smsShrdPrm.alpha,smsShrdPrm.alpha_len);
  }

#else

  if ( p_sm->alpha.len NEQ 0 )
  {
    utl_chsetFromGsm ( (UBYTE*)p_sm->alpha.data,
                       p_sm->alpha.len,
                       (UBYTE*)cvtdAlpha,
                       sizeof(cvtdAlpha),
                       &lenCvtdAlpha,
                       GSM_ALPHA_Def );
    pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
  }

#endif /*FF_ATI_BAT*/

  if ((p_sm->fo & TP_MTI_MASK) NEQ TP_MTI_SMS_DELIVER)
  {
    pos += sprintf ( g_sa + pos, "," );
  }
  else
  {
    pos += sprintf ( g_sa + pos, ",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
      p_sm->scts.year  [0], p_sm->scts.year  [1],
      p_sm->scts.month [0], p_sm->scts.month [1],
      p_sm->scts.day   [0], p_sm->scts.day   [1],
      p_sm->scts.hour  [0], p_sm->scts.hour  [1],
      p_sm->scts.minute[0], p_sm->scts.minute[1],
      p_sm->scts.second[0], p_sm->scts.second[1],
      p_sm->scts.timezone);
  }

  if (((UBYTE)p_sm->fo & TP_UDHI_MASK) EQ TP_UDHI_WITH_HEADER)
  {
    T_ACI_SM_DATA data;

    aci_frmtOutput(p_sm->fo, p_sm->dcs, &data);

    utl_smDtaToTe((UBYTE*)data.data,
                  data.len,
                  (UBYTE*)cvtdData,
                  sizeof(cvtdData),
                  &lenCvtdData,
                  (UBYTE)p_sm->fo,
                  (UBYTE)p_sm->dcs);

    if(ati_user_output_cfg[srcId].CSDH_stat)
      pos += sprintf ( g_sa + pos, ",%d,%d",toa_merge ( p_sm->toa ), data.len );

    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);

    pos=sprintq(g_sa,cvtdData,lenCvtdData);
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
  else
  {
    if(ati_user_output_cfg[srcId].CSDH_stat)
      pos += sprintf ( g_sa + pos, ",%d,%d",
                       toa_merge ( p_sm->toa ), p_sm->data.len );

    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);

    if (p_sm->data.len > 0)
    {
      utl_smDtaToTe( (UBYTE*)p_sm->data.data,
                     p_sm->data.len,
                     (UBYTE*)cvtdData,
                     sizeof(cvtdData),
                     &lenCvtdData,
                     (UBYTE)p_sm->fo,
                     (UBYTE)p_sm->dcs);
      pos=sprintq(g_sa,cvtdData,lenCvtdData);
    }
    else
    {
      g_sa[0]='\0';
    }
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCSSI       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCSSI call back

*/
GLOBAL void rCI_PlusCSSI  ( T_ACI_CSSI_CODE code,
                            SHORT           index)
{
  SHORT pos=0;
  char *me="+CSSI: ";
  UBYTE srcId = srcId_cb;


  TRACE_FUNCTION("rCI_PLusCSSI()");

  if ( ati_user_output_cfg[srcId].CSSI_stat
/*       AND
       (
         io_getIoMode ( ) EQ IO_MODE_CMD OR
         io_getIoMode ( ) EQ IO_MODE_RUN
       )   */
     )
  {

    pos = sprintf(g_sa,"%s",me);

    if (code NEQ CSSI_CODE_NotPresent)   pos += sprintf(g_sa+pos,"%d,",code);
    else  pos += sprintf(g_sa+pos,",");
    if (index NEQ ACI_NumParmNotPresent) sprintf(g_sa+pos,"%d",index);

    ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCSSU       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCSSU call back

*/

GLOBAL void rCI_PlusCSSU  ( /*UBYTE srcId,*/
                            T_ACI_CSSU_CODE code,
                            SHORT           index,
                            CHAR           *number,
                            T_ACI_TOA      *type,
                            CHAR           *subaddr,
                            T_ACI_TOS      *satype)
{
  char *me="+CSSU: ";
  SHORT pos=0;
  UBYTE srcId = srcId_cb;


  TRACE_FUNCTION("rCI_PLusCSSU()");

  if ( ati_user_output_cfg[srcId].CSSU_stat
/*       AND
       (
         io_getIoMode ( ) EQ IO_MODE_CMD OR
         io_getIoMode ( ) EQ IO_MODE_RUN
       )  */
     )
  {

    pos = sprintf(g_sa,"%s",me);
    if (code NEQ CSSI_CODE_NotPresent)   pos += sprintf(g_sa+pos,"%d,",code);
    else  pos += sprintf(g_sa+pos,",");
    if (index NEQ ACI_NumParmNotPresent) pos += sprintf(g_sa+pos,"%d,",index);
    else  pos += sprintf(g_sa+pos,",");
    if (number)
    {
      pos += sprintf(g_sa+pos,"\"%s\",",number);
      if (type)
        pos += sprintf(g_sa+pos,"%d,",toa_merge(*type));
      else
        pos += sprintf(g_sa+pos,"128,");
    }
    else
      pos += sprintf(g_sa+pos,"\"\",128,");

    if (subaddr)
    {
      pos += sprintf(g_sa+pos,"\"%s\",",subaddr);
      if (satype)
        pos += sprintf(g_sa+pos,"%d",tos_merge(*satype));
    }

    ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));
    io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCUSD       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCUSD call back

*/

GLOBAL void rCI_PlusCUSD  ( /*UBYTE srcId,*/
                            T_ACI_CUSD_MOD   m,
                            T_ACI_USSD_DATA  *ussd,
                            SHORT            dcs)
{
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_PlusCUSD()");

  src_params->curAtCmd = AT_CMD_NONE;

  if ( ati_user_output_cfg[srcId].CUSD_stat )
  {
    if (ussd != NULL)
    {
#ifdef FF_ATI_BAT
      rci_display_USSD( srcId, m, ussd->data, ussd->len, FALSE, dcs );
#else
      rci_display_USSD( srcId, m, ussd->data, ussd->len, CONVERT_STRING, dcs );
#endif
    }
    else
    {
#ifdef FF_ATI_BAT
      rci_display_USSD( srcId, m, NULL, 0, FALSE, dcs );
#else
      rci_display_USSD( srcId, m, NULL, 0, CONVERT_STRING, dcs );
#endif
    }

  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCIMI       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCIMI call back

*/

GLOBAL void rCI_PlusCIMI  ( /*UBYTE srcId,*/ CHAR *imsi)
{
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PlusCIMI()");

  src_params->curAtCmd = AT_CMD_NONE;
  if (imsi)
  {
    sprintf(g_sa,"%s",imsi);
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCNUM       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCNUM call back

*/

GLOBAL void rCI_PlusCNUM ( /*UBYTE srcId,*/ T_ACI_CNUM_MSISDN *msisdn,
                           UBYTE             num )
{
  UBYTE        count = 0;
  UBYTE        i;
  T_ACI_RETURN ret;
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);


  TRACE_FUNCTION("rCI_PlusCNUM()");

  for ( i = 0; i < MAX_MSISDN; i++ )
  {
    count += aci_writeCnumMsisdn ( srcId, &msisdn[i] );
  }

  if ( count EQ MAX_MSISDN )
  {
    ret = qAT_PlusCNUM ( srcId, CNUM_MOD_NextRead ) ;

    if ( ret EQ AT_EXCT )
    {
      src_params->curAtCmd    = AT_CMD_CNUM;
    }
    else if ( ret EQ AT_CMPL )
    {
      src_params->curAtCmd    = AT_CMD_NONE;
      cmdErrStr   = NULL;
    }
    else
    {
      src_params->curAtCmd    = AT_CMD_NONE;
      cmdErrStr   = NULL;
    }
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCPOL       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCPOL call back

*/
GLOBAL void rCI_PlusCPOL  ( /*UBYTE srcId,*/ SHORT              startIdx,
                            SHORT              lastIdx,
                            T_ACI_CPOL_OPDESC *operLst,
                            SHORT              usdNtry )
{
  UBYTE idx;
  BOOL  loop;
  UBYTE srcId = srcId_cb;


  TRACE_FUNCTION("rCI_PlusCPOL()");

  loop     = TRUE;

  /* if oper list is present, reply to read command */
  if( operLst )
  {
    do
    {
      for( idx=0; idx < MAX_OPER; idx++ )
      {
        if( operLst[idx].index EQ ACI_NumParmNotPresent )
        {
          loop = FALSE;
          break;
        }
        sprintf(g_sa,"+CPOL: %d,%d,\"%s\"", operLst[idx].index,
                                          operLst[idx].format,
                                          operLst[idx].oper );
        io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
      }

      if( lastIdx EQ ACI_NumParmNotPresent ) break;

      startIdx = lastIdx+1;

#ifdef WIN32
      if( qAT_PlusCPOL(srcId, startIdx, &lastIdx, operLst,
                       cpolMode )
#else
      if( qAT_PlusCPOL(srcId, startIdx, &lastIdx, operLst,
                       CPOL_MOD_NotPresent )
#endif
          EQ AT_FAIL OR !loop)
        break;

    }
    while( loop );
  }
  /* else, reply to test command */
  else
  {
    sprintf(g_sa,"+CPOL: (1-%d),(0-2)", lastIdx);
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCLAN       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCLAN call back

*/
GLOBAL void rCI_PlusCLAN  ( T_ACI_LAN_SUP  *CLang)

{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PlusCLAN()");

  sprintf(g_sa,"+CLAN: %s",CLang->str );
  io_sendMessage(srcId,g_sa, ATI_NORMAL_OUTPUT);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCLAE       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCLAE call back

*/
GLOBAL void rCI_PlusCLAE  (T_ACI_LAN_SUP  *CLang)

{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PlusCLAE()");

  sprintf(g_sa,"+CLAV: %s",CLang->str );
  io_sendMessage(srcId,g_sa, ATI_NORMAL_OUTPUT);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCCCM       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCCCM call back

*/

GLOBAL void rCI_PlusCCCM  ( /*UBYTE srcId,*/ LONG *ccm )
{
  static LONG oldCCM = 0;
  UBYTE srcId = srcId_cb;


  TRACE_FUNCTION("rCI_PlusCCCM()");

  if( *ccm < oldCCM )
  {
    allowCCCM = TRUE;
    callTime  = 0;
  }

  if (ccm AND allowCCCM AND ati_user_output_cfg[srcId].CAOC_stat)
  {
    allowCCCM = FALSE;
    sprintf(g_sa,"+CCCM: \"%6X\"",*ccm);
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCCWV       |
+--------------------------------------------------------------------+

  PURPOSE : handles unsolicited result code +CCWV

*/

GLOBAL void rCI_PlusCCWV ( /*UBYTE srcId,*/ T_ACI_CCWV_CHRG charging )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PlusCCWV()");

  if ( charging NEQ CCWV_CHRG_NotPresent )
  {
    ati_user_output_cfg[srcId].CCWV_charging = charging;
  }
  else
  {
    charging = ati_user_output_cfg[srcId].CCWV_charging;
  }

  if ( charging           EQ CCWV_CHRG_Shortage AND
       ati_user_output_cfg[srcId].CCWE_stat EQ 1               /*   AND
       (
         io_getIoMode ( ) EQ IO_MODE_CMD OR
         io_getIoMode ( ) EQ IO_MODE_RUN
       ) */
     )
  {
    io_sendIndication(srcId, "+CCWV", ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCPI     |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCPI call back

*/

GLOBAL void rCI_PercentCPI   ( /*UBYTE srcId,*/ SHORT           cId,
                              T_ACI_CPI_MSG   msgType,
                              T_ACI_CPI_IBT   ibt,
                              T_ACI_CPI_TCH   tch,
                              USHORT          cause)
{
  SHORT               pos  = 0;
  UBYTE               srcId = srcId_cb;
  SHORT               idx;
  T_ACI_CLCC_CALDESC *calLst;
  CHAR                cvtdAlpha[2*MAX_ALPHA_LEN];
  USHORT              lenCvtdAlpha;
  UBYTE               type;

  TRACE_FUNCTION("rCI_PercentCPI()");
  TRACE_EVENT_P1("msgType: %d", msgType);

#ifdef ACI
  if (ibt NEQ CPI_IBT_NotPresent)
    ibt_params.ati_currIbt = ibt;

  if (tch NEQ CPI_TCH_NotPresent)
    ibt_params.ati_currTch = tch;
#endif

  if ( (ati_user_output_cfg[srcId].CPI_stat > 0) )
  {
    pos = sprintf(g_sa,"%s: ","%CPI");

    if (cId NEQ ACI_NumParmNotPresent)
      pos += sprintf(g_sa+pos,"%d,",cId);
    else
      pos += sprintf(g_sa+pos,",");
    if (msgType NEQ CPI_MSG_NotPresent)
      pos += sprintf(g_sa+pos,"%d,",msgType);
    else
      pos += sprintf(g_sa+pos,",");
    if (ibt NEQ CPI_IBT_NotPresent)
      pos += sprintf(g_sa+pos,"%d,",ibt);
    else
      pos += sprintf(g_sa+pos,",");
    if (tch NEQ CPI_TCH_NotPresent)
      pos += sprintf(g_sa+pos,"%d",tch);
    else
      pos += sprintf(g_sa+pos,",");

    ACI_MALLOC (calLst, MAX_CALL_NR * sizeof (T_ACI_CLCC_CALDESC));
    if ((ati_user_output_cfg[srcId].CPI_stat > 1) AND
      (qAT_PlusCLCC(srcId, calLst) EQ AT_CMPL))
    {


      for (idx = 0; idx < MAX_CALL_NR; idx++)
      {
        if( calLst[idx].idx EQ ACI_NumParmNotPresent )
        {
          if (ati_user_output_cfg[srcId].CPI_stat > 2)
          {
            pos += sprintf(g_sa + pos,",,,,,");
          }
          break;
        }
        else
        {
          if (calLst[idx].idx NEQ cId)
          {
            //continue;
          }
          else /* if (calLst[idx].idx NEQ cId) */
          {
            if (calLst[idx].dir NEQ CLCC_DIR_NotPresent)
              pos += sprintf(g_sa+pos,",%d",calLst[idx].dir);
            else
              pos += sprintf(g_sa+pos,",");
            if (calLst[idx].mode NEQ CLCC_MODE_NotPresent)
              pos += sprintf(g_sa+pos,",%d",calLst[idx].mode);
            else
              pos += sprintf(g_sa+pos,",");
            if (calLst[idx].number[0] NEQ 0x0)
            {
              pos += sprintf(g_sa+pos,",\"%s\"",calLst[idx].number);
              if (calLst[idx].type.ton NEQ TON_NotPresent)
              {
                type = toa_merge(calLst[idx].type);
                pos += sprintf(g_sa+pos,",%d",(int)type);
              }
              else
                pos += sprintf(g_sa+pos,",");
#ifdef NO_ASCIIZ
              if (calLst[idx].alpha.len NEQ 0x0)
              {
                pos += sprintf(g_sa+pos,",");
                utl_chsetFromGsm ( calLst[idx].alpha.data,
                  calLst[idx].alpha.len,
                  (UBYTE*)cvtdAlpha,
                  sizeof(cvtdAlpha),
                  &lenCvtdAlpha,
                  GSM_ALPHA_Def );
                pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
              }
#else  /* #ifdef NO_ASCIIZ */
              if (calLst[idx].alpha[0] NEQ 0x0)
              {
                pos += sprintf(g_sa+pos,",");
                utl_chsetFromGsm ( (UBYTE*)calLst[idx].alpha,
                  0,
                  (UBYTE*)cvtdAlpha,
                  sizeof(cvtdAlpha),
                  &lenCvtdAlpha,
                  GSM_ALPHA_Int );
                pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
              }
#endif /* #ifdef NO_ASCIIZ */
              else if(ati_user_output_cfg[srcId].CPI_stat > 2)
              {
                pos += sprintf(g_sa + pos,",");
              }
            } /* if (calLst[idx].number[0] NEQ 0x0) */
            else
            {
              pos += sprintf(g_sa + pos,",,,");
            }
            break;
          } /* else of - if (calLst[idx].idx NEQ cId) */

        } /* else of - if( calLst[idx].idx EQ ACI_NumParmNotPresent ) */

      } /*for (idx = 0; idx < MAX_CALL_NR; idx++) */

      
      if (ati_user_output_cfg[srcId].CPI_stat > 2)
      {
        if (ati_user_output_cfg[srcId].CPI_stat EQ 4)
        {
          pos += sprintf(g_sa + pos,",0x%4x", cause);
        }
        else
        {
          if(( GET_CAUSE_ORIGIN_ENTITY(cause) EQ CC_ORIGINATING_ENTITY  AND 
              GET_CAUSE_DEFBY(cause)         EQ DEFBY_STD )
              OR (cause EQ MNCC_CAUSE_REEST_STARTED OR cause EQ MNCC_CAUSE_REEST_FINISHED))
          {
            TRACE_EVENT_P2("cause: %d pos: %d",cId, cause);
            pos += sprintf ( g_sa + pos,",%d", GET_CAUSE_VALUE(cause) );
          }
          else
          {
            pos += sprintf(g_sa + pos,",");
          }
        }

        /* Report the the ALS bearer */
        if(calLst[idx].class_type EQ CLCC_CLASS_Line2)
        {
          pos += sprintf ( g_sa + pos,",1");
        }
        else
        {
          pos += sprintf ( g_sa + pos,",0");
        }

      }


    }//if ( (ati_user_output_cfg[srcId].CPI_stat > 0) )

    ACI_MFREE (calLst);
    ci_remTrailCom(g_sa, pos);
    io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
#ifdef ACI /* for ATI only version */
  cmhMMI_handleAudioTone ( AT_CMD_NONE, RAT_CPI, msgType );
#endif
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCTYI    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCTYI call back

*/

GLOBAL void rCI_PercentCTYI (T_ACI_CTTY_NEG neg,
                             T_ACI_CTTY_TRX trx)
{
  int pos = 0;

  TRACE_FUNCTION ("rCI_PercentCTYI()");

  if (cmhPrm[srcId_cb].ccCmdPrm.CTTYmode EQ CTTY_MOD_Enable)
  {
    pos = sprintf (g_sa, "%s: %d", "%CTYI", (int)neg);

    if (trx NEQ CTTY_TRX_Unknown)
      pos += sprintf (g_sa + pos, ",%d", trx);

    io_sendMessage (srcId_cb, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCTV     |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCTV call back

*/

GLOBAL void rCI_PercentCTV  ( /*UBYTE srcId*/ void )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentCTV()");

  callTime++;

  if( callTime EQ 10 )
  {
    callTime = 0;
    allowCCCM = TRUE;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : sAT_URC            |
+--------------------------------------------------------------------+

  PURPOSE : this function handles unsolicited result codes generated
            using the extension mechanism for unknown AT commands.

*/

GLOBAL T_ACI_RETURN sAT_URC ( CHAR * out )
{
  T_ACI_RETURN retCode = AT_FAIL;

  TRACE_FUNCTION("sAT_URC ()");

  if (ati_get_mode( src_id_ext ) NEQ ATI_UNKN_MODE)        /* Send only to "serial" sources, no SAT etc. */
  {
    aci_sendPString( src_id_ext, out );
  }

  return AT_CMPL;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : sAT_FRI            |
+--------------------------------------------------------------------+

  PURPOSE : this function handles final result codes generated
            using the extension mechanism for unknown AT commands.

*/

GLOBAL T_ACI_RETURN sAT_FRI ( USHORT cmdLen )
{
  T_ACI_RETURN rslt = AT_FAIL;
  UBYTE srcId = srcId_cb;
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  if ( src_params->curAtCmd EQ AT_CMD_EXT )
  {
    rslt = AT_CMPL;
  }

  return ( rslt );
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCCBS    |
+--------------------------------------------------------------------+

  PURPOSE : handles rCI_PercentCCBS call back

*/

GLOBAL void rCI_PercentCCBS  ( /*UBYTE srcId,*/ T_ACI_CCBS_IND  ind,
                               T_ACI_CCBS_STAT status,
                               T_ACI_CCBS_SET *setting,
                               BOOL           intermediate_result )
{
  SHORT pos   = 0;
  UBYTE srcId = srcId_cb;


  TRACE_FUNCTION("rCI_PercentCCBS()");

  if ( at.flags.CCBS_stat         OR
       ind EQ CCBS_IND_IrgtResult )
  {
    pos=sprintf(g_sa,"%s: ","%CCBS");

    /* 1st param */
    switch(ind)
    {
    case(CCBS_IND_NotPresent):
      pos+=sprintf(g_sa+pos,",");
      break;

    case(CCBS_IND_IrgtResult):
      if(status NEQ CCBS_STAT_NotPresent)
      {
        pos+=sprintf(g_sa+pos,"%d,",ind);
      }
      break;

    default:
      pos+=sprintf(g_sa+pos,"%d,",ind);
      break;
    }

    if(setting EQ NULL)
    {
      /* do nothing: if later a parameter is added, extra commas may be needed...*/
    }
    else
    {
      /* 2nd param: CCBS index */
      if(setting->idx NEQ ACI_NumParmNotPresent)
        pos+=sprintf(g_sa+pos,"%d,",setting->idx);
      else
        pos+=sprintf(g_sa+pos,",");

      /* 3rd param: Number */
      if (setting->number[0] NEQ 0x0 )
        pos+=sprintf(g_sa+pos,"\"%s\",",setting->number);
      else
        pos+=sprintf(g_sa+pos,",");

      /* 4th param: Type of number */
      if (setting->type.npi NEQ NPI_NotPresent )
        pos+=sprintf(g_sa+pos,"%d,",toa_merge(setting->type));
      else
        pos+=sprintf(g_sa+pos,",");

      /* 5th param: sub address */
      if (setting->subaddr[0] NEQ 0x0 )
        pos+=sprintf(g_sa+pos,"\"%s\",",setting->subaddr);
      else
        pos+=sprintf(g_sa+pos,",");

      /* 6th param: type of subaddress */
      if (setting->satype.tos NEQ TOS_NotPresent )
        pos+=sprintf(g_sa+pos,"%d,",tos_merge(setting->satype));
      else
        pos+=sprintf(g_sa+pos,",");

      /* 7th param:  CCBS class */
      if (setting->class_type NEQ CLASS_NotPresent)
        pos+=sprintf(g_sa+pos,"%d,",setting->class_type);
      else
        pos+=sprintf(g_sa+pos,",");

      /* 8th param: ALPT */
      if (setting->alrtPtn NEQ ALPT_NotPresent)
        pos+=sprintf(g_sa+pos,"%d",setting->alrtPtn);
    }

    ci_remTrailCom(g_sa, pos);

    if(intermediate_result)
    {
      io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
    }
    else
      io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);

  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_sms_ready      |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_sms_ready call back

*/

GLOBAL void rCI_sms_ready  ( /*UBYTE srcId*/ void )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_sms_ready()");
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_phb_status     |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_phb_status call back

*/

GLOBAL void rCI_phb_status ( /*UBYTE srcId,*/ T_ACI_PB_STAT status )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_phb_status()");

}


GLOBAL void rCI_PlusCMGD ()
{
  /* dummy function */
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : aci_writeCnumMsisdn|
+--------------------------------------------------------------------+

  PURPOSE : This function writes the formatted string to AT command
            interface.
*/
LOCAL UBYTE aci_writeCnumMsisdn ( UBYTE srcId, T_ACI_CNUM_MSISDN* msisdn )
{
  USHORT pos = 0;

#ifndef FF_ATI_BAT
  CHAR   cvtdAlpha[2*MAX_ALPHA_LEN];
  USHORT lenCvtdAlpha;
#endif

  TRACE_FUNCTION ("aci_writeCnumMsisdn()");

  if ( msisdn -> vldFlag EQ FALSE )
  {
    return 0;
  }

  pos = sprintf ( g_sa, "+CNUM: " );

  /*
   *-----------------------------------------------------------------
   * process parameter <alpha>
   *-----------------------------------------------------------------
   */

  if ( msisdn -> alpha[0] NEQ '\0' )
  {
#ifdef FF_ATI_BAT
    pos += sprints ( g_sa + pos, (char *)msisdn->alpha, (USHORT)strlen(msisdn->alpha) );
#else
    utl_chsetFromGsm((UBYTE*)msisdn->alpha,
                     strlen(msisdn->alpha),
                     (UBYTE*)cvtdAlpha,
                     sizeof(cvtdAlpha),
                     &lenCvtdAlpha,
                     GSM_ALPHA_Int);
    pos += sprints ( g_sa + pos, cvtdAlpha, lenCvtdAlpha );
#endif
  }

  /*
   *-----------------------------------------------------------------
   * process parameter <number> and <type>
   *-----------------------------------------------------------------
   */
  pos += sprintf ( g_sa + pos, ",\"%s\",%d",
                   msisdn -> number,
                   toa_merge ( msisdn -> type ) );

  /*
   *-----------------------------------------------------------------
   * process parameter <speed>
   *-----------------------------------------------------------------
   */
  if ( msisdn -> speed NEQ BS_SPEED_NotPresent )
  {
    pos += sprintf ( g_sa + pos, ",%d", msisdn -> speed );
  }
  else
  {
    pos += sprintf ( g_sa + pos, "," );
  }

  /*
   *-----------------------------------------------------------------
   * process parameter <service>
   *-----------------------------------------------------------------
   */
  if ( msisdn -> service NEQ CNUM_SERV_NotPresent )
  {
    pos += sprintf ( g_sa + pos, ",%d", msisdn -> service );
  }
  else
  {
    pos += sprintf ( g_sa + pos, "," );
  }

  /*
   *-----------------------------------------------------------------
   * process parameter <itc>
   *-----------------------------------------------------------------
   */
  if ( msisdn -> itc NEQ CNUM_ITC_NotPresent )
  {
    pos += sprintf ( g_sa + pos, ",%d", msisdn -> itc );
  }

  ci_remTrailCom ( g_sa, ( USHORT ) strlen ( g_sa ) );

  io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT );

  return 1;
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCNAP    |
+--------------------------------------------------------------------+

  PURPOSE : handles rCI_PercentCNAP call back

*/
typedef enum
{
  CNAP_PRES_ALLOWED = 0,
  CNAP_PRES_RESTRICTED,
  CNAP_NAME_UNAVAILABLE,
  CNAP_NAME_PRES_RESTRICTED
} T_ATI_CNAP_PRESENTATION;

LOCAL void send_cnap_name_information(UBYTE srcId,
                                      T_ATI_CNAP_PRESENTATION pres_mode,
                                      T_callingName *NameId)
{
  T_namePresentationAllowed *cnap_name_info = NULL;
  UBYTE number_of_chars = 0;
  CHAR  *cnap_name = NULL;
  int pos = 0;

  TRACE_FUNCTION("send_cnap_name_information()");

  switch(pres_mode)
  {
    case(CNAP_PRES_ALLOWED):
      TRACE_EVENT("CNAP: name presentation is allowed");
      cnap_name_info = &(NameId->namePresentationAllowed);
      break;

    case(CNAP_NAME_PRES_RESTRICTED):
      TRACE_EVENT("CNAP: name presentation is restricted");
      cnap_name_info = &(NameId->namePresentationRestricted);
      break;

    default:
      TRACE_ERROR("CNAP: wrong presentation mode");
      return;
  }
  if(cnap_name_info EQ NULL)
  {
    TRACE_ERROR("CNAP cnap_name_info is NULL");
    return;
  }

  pos += sprintf(g_sa+pos,"%s%d,", "%CNAP: ", pres_mode);

  if(cnap_name_info->v_dataCodingScheme)
  {
    pos += sprintf(g_sa+pos,"%d,", cnap_name_info->dataCodingScheme);
  }
  if(cnap_name_info->v_lengthInCharacters)
  {
    number_of_chars = cnap_name_info->lengthInCharacters;
    pos += sprintf(g_sa+pos,"%d,", number_of_chars);
    number_of_chars = MINIMUM(number_of_chars, sizeof(g_sa)-(size_t)pos);
  }
  if(cnap_name_info->v_nameString AND
     number_of_chars NEQ 0)
  {
     ACI_MALLOC(cnap_name, number_of_chars+3); /* 1 char for \0 and 2 chars for " */
     memcpy(cnap_name, &(cnap_name_info->nameString.b_nameString), number_of_chars);
     cnap_name[number_of_chars] = 0;  /* Null terminated */
     pos += sprintf(g_sa+pos,"\"%s\"", cnap_name);
  }
  ci_remTrailCom(g_sa,(USHORT)strlen(g_sa));

  io_sendIndication( srcId, g_sa, ATI_NORMAL_OUTPUT );

  if(cnap_name NEQ NULL)
  {
    ACI_MFREE(cnap_name);
  }
}

LOCAL void unsolicited_rci_percent_cnap(UBYTE srcId, T_callingName *NameId)
{
  TRACE_FUNCTION("unsolicited_rci_percent_cnap()");

  if(ati_user_output_cfg[srcId].cnap_mode EQ CNAP_DISABLED)
  {
    TRACE_EVENT_P1("unsolicited message CNAP ignored: CNAP not enable for source: %d", srcId);
    return;
  }

  if(NameId->v_namePresentationAllowed)
  {
    send_cnap_name_information(srcId, CNAP_PRES_ALLOWED, NameId);
    return;
  }

  if(NameId->v_presentationRestricted)
  {
    sprintf(g_sa, "%s%d", "%CNAP: ", CNAP_PRES_RESTRICTED);
    io_sendIndication( srcId, g_sa, ATI_NORMAL_OUTPUT );
    return;
  }

  if(NameId->v_nameUnavailable)
  {
    sprintf(g_sa, "%s%d", "%CNAP: ", CNAP_NAME_UNAVAILABLE);
    io_sendIndication( srcId, g_sa, ATI_NORMAL_OUTPUT );
    return;
  }

  if(NameId->v_namePresentationRestricted)
  {
    send_cnap_name_information(srcId, CNAP_NAME_PRES_RESTRICTED, NameId);
    return;
  }
}

LOCAL void intermediate_result_rci_percent_cnap(UBYTE srcId, T_ACI_CNAP_STATUS status)
{
  TRACE_FUNCTION("intermediate_result_rci_percent_cnap()");

  sprintf(g_sa, "%s%d,%d", "%CNAP: ", ati_user_output_cfg[srcId].cnap_mode, status);
  io_sendMessage( srcId, g_sa, ATI_NORMAL_OUTPUT );
}

GLOBAL void rCI_PercentCNAP  ( T_callingName *NameId, T_ACI_CNAP_STATUS status )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentCNAP()");

  if(NameId NEQ NULL)
  {
    unsolicited_rci_percent_cnap(srcId, NameId);
    return;
  }

  if(status NEQ CNAP_SERVICE_STATUS_NOT_PRESENT)
  {
    intermediate_result_rci_percent_cnap(srcId, status);
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCMS_Conc   |
+--------------------------------------------------------------------+

  PURPOSE : handles new rCI_PlusCMS call back for concatenated SMS

*/
GLOBAL void rCI_PlusCMS_Conc ( T_ACI_AT_CMD     cmdId,
                               T_ACI_CMS_ERR    err,
                               T_EXT_CMS_ERROR *conc_error )
{
  TRACE_FUNCTION("rCI_PlusCMS_Conc()");
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_SignalSMS      |
+--------------------------------------------------------------------+

  PURPOSE : handles rCI_SignalSMS call back for concatenated SMS

*/
GLOBAL void rCI_SignalSMS ( UBYTE state )
{
  TRACE_FUNCTION("rCI_SignalSMS()");
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCIEV       |
+--------------------------------------------------------------------+

  PURPOSE : handles rCI_SignalCIEV call back for signal strength
            and SIM-full indications

*/
GLOBAL void rCI_PlusCIEV ( T_ACI_MM_CIND_VAL_TYPE sCindValues,
                          T_ACI_MM_CMER_VAL_TYPE sCmerSettings )
{
  CHAR*  me                       = "+CIEV: ";
  SHORT  pos                      = 0;

  UBYTE          srcId = srcId_cb;
  T_ATI_IO_MODE  sIoMode;
  char          *acTempString = "";
  UINT           uiCount;

  TRACE_FUNCTION("rCI_PlusCIEV()");

  pos = sprintf(g_sa,"%s",me);

  /* check settings in 'cmhCmdPrm' and depends on, send the indication or buffer it */
  sIoMode = ati_get_mode(srcId_cb);
  if( sIoMode == ATI_UNKN_MODE )
  {
    acTempString = "internal ACI error at rCI_PlusCIEV() ->> ATI unknown mode !!";
    sprintf( g_sa+pos, "%s, 0", acTempString );
    io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
    return;
  }
  if( (sIoMode == ATI_CMD_MODE) &&
      (sCmerSettings.sCmerModeParam != CMER_MODE_INVALID) && /* 'invalid' == 'mode_0' */
      (sCmerSettings.sCmerModeParam != CMER_MODE_0) )
    /* ---------------------------------------------------------------------------------- */
  { /* ----------- UART is in command mode --> send the +CIEV to terminal --------------- */
    /* ---------------------------------------------------------------------------------- */
    if( sCindValues.sCindSignalParam != CIND_SIGNAL_INDICATOR_INVALID )
    {
      acTempString = "1"; /* the 'signal' indicator has the order number '1' in +CIND */
      sprintf( g_sa+pos, "%s, %d", acTempString, sCindValues.sCindSignalParam );
    }
    else
    {
      if( sCindValues.sCindSmsFullParam != CIND_SMSFULL_INDICATOR_INVALID )
      {
        acTempString = "2"; /* the 'smsfull' indicator has the order number '2' in +CIND */
        sprintf( g_sa+pos, "%s, %d", acTempString, sCindValues.sCindSmsFullParam );
      }
      else
      { /* error!! --> no signal has to be send */
        acTempString = "internal ACI error at rCI_PlusCIEV() !!";
        sprintf( g_sa+pos, "%s, 0", acTempString);
      }
    }
    io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
       /* -------------------------------------------------------------------------------- */
  else /* -- UART is in data mode or CMER-mode == '0' --> buffer the +CIEV if necessary -- */
  {    /* -------------------------------------------------------------------------------- */
    if( sCmerSettings.sCmerModeParam != CMER_MODE_1 )
    { /* discard message in case of MODE=='1' */
      if( sCindValues.sCindSignalParam != CIND_SIGNAL_INDICATOR_INVALID )
      { /* storing of SIGNAL Value */
        if( asCievSignalBuf.uiLastIndex < CIEV_BUF_SIZE )
        { /* free space in buffer -> store +CIEV indication for further purpose */
          asCievSignalBuf.asBufferValues[asCievSignalBuf.uiLastIndex] = sCindValues.sCindSignalParam;
          asCievSignalBuf.uiLastIndex++;
        }
        else /* = buffer is full (uiLastIndex == CIEV_BUF_SIZE) = */
        {    /* -> drop the oldest one and try to store it again  */
          uiCount = 0;
          while( uiCount < (CIEV_BUF_SIZE-1) )
          { /* drop the oldes one */
            asCievSignalBuf.asBufferValues[uiCount] = asCievSignalBuf.asBufferValues[uiCount+1];
            uiCount++;
          }
          asCievSignalBuf.asBufferValues[asCievSignalBuf.uiLastIndex-1] = sCindValues.sCindSignalParam;
        }
      }
      else
      { /* storing of SMS full Value */
        if( asCievSmsFullBuf.uiLastIndex < CIEV_BUF_SIZE )
        { /* free space in buffer -> store +CIEV indication for further purpose */
          asCievSmsFullBuf.asBufferValues[asCievSmsFullBuf.uiLastIndex] = sCindValues.sCindSmsFullParam;
          asCievSmsFullBuf.uiLastIndex++;
        }
        else /* = buffer is full (uiLastIndex == CIEV_BUF_SIZE) = */
        {    /* -> drop the oldest one and try to store it again  */
          uiCount = 0;
          while( uiCount < (CIEV_BUF_SIZE-1) )
          { /* drop the oldes one */
            asCievSmsFullBuf.asBufferValues[uiCount] = asCievSmsFullBuf.asBufferValues[uiCount+1];
            uiCount++;
          }
          asCievSmsFullBuf.asBufferValues[asCievSmsFullBuf.uiLastIndex-1] = sCindValues.sCindSmsFullParam;
        }
      }
    }
  }
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : ACI_RET                  |
| STATE   : code                  ROUTINE : aci_frmtOutput           |
+--------------------------------------------------------------------+

  PURPOSE : fills T_ACI_SM_DATA data structure for UD with UDHI
*/
LOCAL void aci_frmtOutput ( UBYTE fo,
                            UBYTE dcs,
                            T_ACI_SM_DATA *data )
{
  switch (fo & TP_MTI_MASK)
  {
  case TP_MTI_SMS_DELIVER:
    {
      T_TP_DELIVER *sms_deliver = (T_TP_DELIVER*)_decodedMsg;
      data->data[0] = sms_deliver->tp_udh_inc.tp_udh.c_data;
      memcpy(data->data+1,
             sms_deliver->tp_udh_inc.tp_udh.data,
             sms_deliver->tp_udh_inc.tp_udh.c_data);

      memcpy(data->data+sms_deliver->tp_udh_inc.tp_udh.c_data+1,
             sms_deliver->tp_udh_inc.data,
             sms_deliver->tp_udh_inc.c_data);

      /*
      data->len = sms_deliver->tp_udh_inc.tp_udh.c_data +
                 sms_deliver->tp_udh_inc.c_data + 1;
      */

      if (cmhSMS_getAlphabetPp (dcs) EQ 0)
        data->len = (sms_deliver->tp_udh_inc.length * 7 + 7)/8;
      else
        data->len = sms_deliver->tp_udh_inc.length;
    }
    break;

  case TP_MTI_SMS_SUBMIT:
    {
      T_TP_SUBMIT *sms_submit = (T_TP_SUBMIT*)_decodedMsg;
      data->data[0] = sms_submit->tp_udh_inc.tp_udh.c_data;
      memcpy(data->data+1,
             sms_submit->tp_udh_inc.tp_udh.data,
             sms_submit->tp_udh_inc.tp_udh.c_data);

      memcpy(data->data+sms_submit->tp_udh_inc.tp_udh.c_data+1,
             sms_submit->tp_udh_inc.data,
             sms_submit->tp_udh_inc.c_data);

      /*
      data->len = sms_submit->tp_udh_inc.tp_udh.c_data +
                  sms_submit->tp_udh_inc.c_data + 1;
      */

      if (cmhSMS_getAlphabetPp (dcs) EQ 0)
        data->len = (sms_submit->tp_udh_inc.length * 7 + 7)/8;
      else
        data->len = sms_submit->tp_udh_inc.length;
    }
    break;

  case TP_MTI_SMS_COMMAND:
    {
      T_TP_COMMAND *sms_command = (T_TP_COMMAND*)_decodedMsg;
      data->data[0] = sms_command->tp_cdh_inc.tp_udh.c_data;
      memcpy(data->data+1,
             sms_command->tp_cdh_inc.tp_udh.data,
             sms_command->tp_cdh_inc.tp_udh.c_data);

      memcpy(data->data+sms_command->tp_cdh_inc.tp_udh.c_data+1,
             sms_command->tp_cdh_inc.data,
             sms_command->tp_cdh_inc.c_data);

      /*
      data->len = sms_command->tp_cdh_inc.tp_udh.c_data +
                  sms_command->tp_cdh_inc.c_data + 1;
      */

      data->len = sms_command->tp_cdh_inc.c_data;
    }
    break;
/*
  case TP_MTI_SMS_STATUS_REP:
    {
      T_TP_STATUS *sms_status = (T_TP_STATUS*)_decodedMsg;
      data->data[0] = sms_status->tp_udh_inc.tp_udh.c_data;
      memcpy(data->data+1,
             sms_status->tp_udh_inc.tp_udh.data,
             sms_status->tp_udh_inc.tp_udh.c_data);

      memcpy(data->data+sms_status->tp_udh_inc.tp_udh.c_data+1,
             sms_status->tp_udh_inc.data,
             sms_status->tp_udh_inc.c_data);

      data->len = sms_status->tp_udh_inc.tp_udh.c_data +
                  sms_status->tp_udh_inc.c_data + 1;
    }
    break;
*/
  default:
    data->data[0] = '\0';
    data->len = 0;
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCPRI    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCPRI call back
*/

GLOBAL void rCI_PercentCPRI   ( UBYTE gsm_ciph, UBYTE gprs_ciph )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PLusCPRI()");

  /* %CPRI notification is sent only to the source through which the status is enabled */
  if (ati_user_output_cfg[srcId].CPRI_stat EQ CI_SHOW)
  {
    sprintf(g_sa, "%s: %d,%d", "%CPRI", gsm_ciph, gprs_ciph);
    io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCTZR       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCTZV call back.
            timezone is a range from -48..0..+48 and expresses the deviation
            from GMT in steps of 15 minutes.
*/
#ifdef FF_TIMEZONE
GLOBAL void rCI_PlusCTZV ( S32 timezone )
{
  UBYTE srcId = srcId_cb;
  TRACE_FUNCTION("rCI_PlusCTZV()");
  
  sprintf (g_sa, "%s\"%+02d\"", "+CTZV: ", timezone);

  /* Send response to AT interface */
  io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
#else
GLOBAL void rCI_PlusCTZV ( UBYTE* timezone )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PlusCTZV()");

  sprintf (g_sa, "%s%d", "+CTZV: ", *timezone);

  /* Send response to AT interface */
  io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
#endif


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCTZV    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCTZV call back, the parameter mmr_info_ind
            includes time and time zone information. 

*/

GLOBAL void rCI_PercentCTZV (T_MMR_INFO_IND *mmr_info_ind, S32 timezone)
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentCTZV()");

 /*Report the network time in time zone 0*/
  sprintf (g_sa, "%s\"%02d/%02d/%02d,%02d:%02d:%02d%+02d\"", "%CTZV: ", 
                   mmr_info_ind->time.year, 
                   mmr_info_ind->time.month,
                   mmr_info_ind->time.day, 
                   mmr_info_ind->time.hour, 
                   mmr_info_ind->time.minute,
                   mmr_info_ind->time.second,
                   timezone);

  /* Send response to AT interface */
  io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCNIV    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCNIV call back

*/

GLOBAL void rCI_PercentCNIV (T_MMR_INFO_IND *mmr_info_ind)
{
  UBYTE srcId = srcId_cb;
  char  buf1[33]; /* be prepared for 16 UCS2 full names */
  char  buf2[33]; /* be prepared for 16 UCS2 full names */
  char  plmn[7] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00};
  SHORT mcc = 0; 
  SHORT mnc = 0;

  TRACE_FUNCTION("rCI_PercentCNIV()");

  memset(buf1, 0, 33);
  memset(buf2, 0, 33);

  if (mmr_info_ind->plmn.v_plmn)
  {
    cmhMM_CnvrtPLMN2INT( mmr_info_ind->plmn.mcc,
                         mmr_info_ind->plmn.mnc,
                         &mcc, &mnc );
  }

  /* build numeric plmn representation */
  if ((mnc & 0x000F) EQ 0x000F)
  {
    sprintf (plmn, "\"%03X%02X\"", mcc, (mnc & 0x0FF0) >> 4);
  }
  else
  {
    sprintf (plmn, "\"%03X%03X\"", mcc, mnc);
  }

  if (mmr_info_ind->short_name.v_name AND /* short name only */
     !mmr_info_ind->full_name.v_name)
  { 
    strncpy (buf2, (char *)mmr_info_ind->short_name.text, mmr_info_ind->short_name.c_text);
    sprintf (g_sa, "%s\"\",\"%s\",%s", "%CNIV: ", buf2, plmn);
  }
  else
  if (!mmr_info_ind->short_name.v_name AND
       mmr_info_ind->full_name.v_name)    /* full name only */
  {  
    strncpy (buf1, (char *)mmr_info_ind->full_name.text, mmr_info_ind->full_name.c_text);
    sprintf (g_sa, "%s\"%s\",\"\",%s", "%CNIV: ", buf1, plmn);
  }
  else
  if (mmr_info_ind->short_name.v_name AND /* both given */
      mmr_info_ind->full_name.v_name)
  {
    strncpy (buf1, (char *)mmr_info_ind->full_name.text, mmr_info_ind->full_name.c_text);
    strncpy (buf2, (char *)mmr_info_ind->short_name.text, mmr_info_ind->short_name.c_text);
    sprintf (g_sa, "%s\"%s\",\"%s\",%s", "%CNIV: ", buf1, buf2, plmn);  
  }
  else
  {
    TRACE_EVENT("rCI_PercentCNIV(): no network name given");
    sprintf (g_sa, "%s\"\",\"\",%s", "%CNIV: ", plmn);
  }
  
  /* Send response to AT interface */
  io_sendIndication(srcId, g_sa, ATI_NORMAL_OUTPUT);
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : ACI_RET                  |
| STATE   : code                  ROUTINE : rCI_Z                    |
+--------------------------------------------------------------------+

  PURPOSE : RAT callback for ATZ, for abstraction of ATI and CMH.
*/
GLOBAL void rCI_Z ( void )
{
  UBYTE srcId = srcId_cb;

  ati_cmd_reset( srcId );
  ati_zn_retrieve_params( srcId );
}

#endif /* FF_ATI */


#if defined FF_EOTD
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PlusCLPS       |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusCLPS call back
*/

GLOBAL void rCI_PlusCLPS   ( UBYTE srcId, T_LOC_POS_DATA * p_aci_lc_data )
{
  TRACE_FUNCTION("rCI_PlusCLPS()");

  io_sendIndication(srcId, "%CLPS:", ATI_NORMAL_OUTPUT);
}
#endif /* FF_EOTD */

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentALS     |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PlusALS call back
*/

GLOBAL void rCI_PercentALS ( T_ACI_ALS_MOD ALSmode )
{
  UBYTE srcId = srcId_cb;
  char *me = "%ALS";

  TRACE_FUNCTION("rCI_PlusALS()");

  if (ALSmode EQ ALS_MOD_SPEECH)
    sprintf(g_sa,"%s: (0)", me);
  if (ALSmode EQ ALS_MOD_AUX_SPEECH)
    sprintf(g_sa,"%s: (1)", me);
  if (ALSmode EQ (ALS_MOD_SPEECH | ALS_MOD_AUX_SPEECH))
    sprintf(g_sa,"%s: (0,1)", me);
  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}
/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentRDL     |
+--------------------------------------------------------------------+

  PURPOSE : handles AT%RDL call back
*/
GLOBAL void rCI_PercentRDL ( T_ACI_CC_REDIAL_STATE state )
{
  UBYTE srcId = srcId_cb;
  char *me = "%RDL:";

  TRACE_FUNCTION("rCI_PercentRDL()");

  if(rdlPrm.rdlModN EQ NOTIF_USER)
  {
    sprintf(g_sa,"%s %d",me,state);
    io_sendMessage(srcId, g_sa, ATI_INDICATION_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentRDLB    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT%RDLB call back
*/
GLOBAL void rCI_PercentRDLB ( T_ACI_CC_RDL_BLACKL_STATE state )
{
  UBYTE srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentRDLB()");

  if(rdlPrm.rdlBlN EQ NOTIF_USER)
  {
    sprintf(g_sa,"%s: %d","%RDLB",state);
    io_sendMessage(srcId, g_sa, ATI_INDICATION_OUTPUT);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCSTAT   |
+--------------------------------------------------------------------+

  PURPOSE : handles rCI_PercentCSTAT call back

*/
GLOBAL void rCI_PercentCSTAT ( T_ACI_STATE_MSG msgType )
{
  SHORT     pos   = 0;
  UBYTE   srcId = srcId_cb;

  TRACE_FUNCTION("rCI_PercentCSTAT()");

   if (ati_user_output_cfg[srcId].CSTAT_stat == 1)
  {
    pos = sprintf(g_sa,"%s: ","%CSTAT");
    
    switch(msgType.entityId)
    {
    case STATE_MSG_PBOOK:
      pos += sprintf(g_sa+pos,"PHB, %d",msgType.entityState);
      break;
    case STATE_MSG_SMS:
      pos += sprintf(g_sa+pos,"SMS, %d",msgType.entityState);
      break;
    case STATE_MSG_EONS:
      pos += sprintf(g_sa+pos,"EONS, %d",msgType.entityState);
      break;
    case STATE_MSG_RDY:
      pos += sprintf(g_sa+pos,"RDY, %d",msgType.entityState);
      break;
    default:
      return;
    }
    
    io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
    
  }

} 

/*
+------------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET                |
| STATE   : code                        ROUTINE : ati_printRemainFieElem |
+------------------------------------------------------------------------+

  PURPOSE : this function prints all remained FIE-elemnts onto terminal
*/
LOCAL void ati_printRemainFieElem( T_fac_inf *fie,
                                   UBYTE srcId )
{
  UBYTE       uTotalCharCounter = 0;
  USHORT      uLineCounter   = 0;
  UBYTE const cuNbrOfMsgElem = fie->l_fac >> 3;

  TRACE_FUNCTION("ati_printRemainFieElem()");

  /* print FIE elements */
  while(uTotalCharCounter < cuNbrOfMsgElem)
  {
    uLineCounter += sprintf(g_sa+uLineCounter, "%02X", fie->fac[uTotalCharCounter++]);
    if ( uLineCounter > (MAX_CMD_LEN-((MAX_CMD_LEN*95)/100)) )  /* only 5% of g_sa buffer used */
    {                                                           /* allows better sim test */
      g_sa[++uLineCounter] = 0x00; /* terminate g_sa after last char */
#ifdef _SIMULATION_
      io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);  /* and send the data in chunks with CRLF */
#else /* _SIMULATION_ */
      io_sendMessage(srcId, g_sa, ATI_ECHO_OUTPUT);
#endif
      uLineCounter=0; /* go to beginning of g_sa for next chunk */
    }
  }
  g_sa[++uLineCounter] = 0x00; /* terminate g_sa after last char in last chunk */
#ifdef _SIMULATION_
  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);  /* and send the data in chunks with CRLF */
#else /* _SIMULATION_ */
  io_sendMessage(srcId, g_sa, ATI_ECHO_OUTPUT);
  g_sa[0] = 0x0; /* print CR/LF after last chunk only on target */
  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
#endif
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCCCN    |
+--------------------------------------------------------------------+

  PURPOSE : handles unsolicited CC-network changes callback
*/

GLOBAL void rCI_PercentCCCN ( T_ACI_FAC_DIR tDirection,
                              SHORT         cId,
                              T_fac_inf    *fie )
{
  UBYTE srcId           = srcId_cb;
  char *me              = "%CCCN";

  TRACE_FUNCTION("rCI_PercentCCCN()");

  /* no output in case of empty FIE-string */
  if( (fie->l_fac >> 3) EQ 0)
  {
    TRACE_FUNCTION("rCI_PercentCCCN() : Empty FIE-string");
    return;
  }

  sprintf(g_sa, "%s: %d,%d,", me, tDirection, cId); /* Preamble */

#ifdef _SIMULATION_ /* 'ATI_ECHO_OUTPUT' doesn't work while Windows simulation */
  io_sendMessage( srcId, g_sa, ATI_NORMAL_OUTPUT ); /* print preamble while SIM-test */
#else /* _SIMULATION_ */
  io_sendMessage( srcId, g_sa, ATI_ECHO_OUTPUT ); /* print preamble to target */
#endif

  ati_printRemainFieElem( fie, srcId );
}


/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCSSN    |
+--------------------------------------------------------------------+

  PURPOSE : handles unsolicited CC-network changes callback
*/

GLOBAL void rCI_PercentCSSN ( T_ACI_FAC_DIR        tDirection,
                              T_ACI_FAC_TRANS_TYPE tType,
                              T_fac_inf    *fie )
{
  UBYTE srcId = srcId_cb;
  char *me = "%CSSN";

  TRACE_FUNCTION("rCI_PercentCSSN()");

  /* no output in case of empty FIE-string */
  if( (fie->l_fac >> 3) EQ 0)
  {
    TRACE_FUNCTION("rCI_PercentCSSN() : Empty FIE-string");
    return;
  }

  sprintf(g_sa, "%s: %d,%d,", me, tDirection, tType); /* Preamble */

#ifdef _SIMULATION_ /* 'ATI_ECHO_OUTPUT' doesn't work while Windows simulation */
  io_sendMessage( srcId, g_sa, ATI_NORMAL_OUTPUT); /* print preamble while SIM-test */
#else /* _SIMULATION_ */
  io_sendMessage( srcId, g_sa, ATI_ECHO_OUTPUT ); /* print preamble to target */
#endif

  ati_printRemainFieElem( fie, srcId );
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCPRSM   |
+--------------------------------------------------------------------+

  PURPOSE : handles callback for %CPRSM? querying the SMS delivery status
            which can be either PAUSE or RESUME 
*/

GLOBAL void rCI_PercentCPRSM ( T_ACI_CPRSM_MOD mode )
{
  UBYTE srcId = srcId_cb;
  char *me = "%CPRSM";
  T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id);

  TRACE_FUNCTION("rCI_PercentCPRSM()");

  sprintf(g_sa,"%s: %d", me, mode);
  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentSIMEF   |
+--------------------------------------------------------------------+

  PURPOSE : 
*/
GLOBAL void rCI_PercentSIMEF(
  SHORT *ef,
  UBYTE count)
{
  UBYTE srcId=srcId_cb;
  SHORT pos;
  UBYTE n;

  TRACE_FUNCTION("rCI_PercentSIMEF()");

  pos=sprintf(g_sa,"%s: ","%SIMEF");

  for (n=0;n<count;n++)
  {
    pos+=sprintf(g_sa+pos,"%04X",ef[n]);

    if (n NEQ count-1)
      *(g_sa+pos++)=',';
  }

  io_sendMessage(srcId,g_sa,ATI_NORMAL_OUTPUT);
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-PS (6147)         MODULE  : ACI_RET                  |
| STATE   : code                  ROUTINE : mfwExtOut                |
+--------------------------------------------------------------------+

  PURPOSE : This function is used as a dummy to fullfill display
            driver calls.
*/
#ifndef MFW

int mfwExtOut (char *cmd)
{
  TRACE_FUNCTION ("mfwExtOut");

  return 1;
}

#endif /* no MFW */

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCMGR    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCMGR call back (Read Message)
*/

GLOBAL void rCI_PercentCMGR  ( T_MNSMS_READ_CNF* mnsms_read_cnf,
                               T_ACI_CMGR_CBM * cbm)

{
  UBYTE msg_type;
#if defined (SMS_PDU_SUPPORT)
  UBYTE srcId = srcId_cb;
  T_ACI_CMGF_MOD mode;
  

  /*
   * request current mode
   */
  qAT_PlusCMGF(srcId, &mode);
  if (mode EQ 0)
    /*
     * handle PDU mode
     */
    rCI_Plus_Percent_CMGRPdu (mnsms_read_cnf, AT_CMD_P_CMGR);
  else
#endif
    /*
     * handle Text mode
     */
  { 
     /* querying the type of the SM */
     cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type);

     if (msg_type EQ TP_MTI_SMS_STATUS_REP)
      rCI_Plus_Percent_CMGRTextSP (mnsms_read_cnf, AT_CMD_P_CMGR);
     else
      rCI_Plus_Percent_CMGRText (mnsms_read_cnf, cbm, AT_CMD_P_CMGR);
  }
}

/*
+--------------------------------------------------------------------+
| PROJECT : GSM-F&D (8411)              MODULE  : ACI_RET            |
| STATE   : code                        ROUTINE : rCI_PercentCMGL    |
+--------------------------------------------------------------------+

  PURPOSE : handles AT_PercentCMGL call back

*/

GLOBAL void rCI_PercentCMGL  (T_MNSMS_READ_CNF *mnsms_read_cnf)
{
  UBYTE msg_type;
#if defined (SMS_PDU_SUPPORT)
  UBYTE srcId = srcId_cb;
  T_ACI_CMGF_MOD mode;
  
  /*
   * request current mode
   */
  qAT_PlusCMGF(srcId, &mode);
  if (mode EQ 0)
    /*
     * handle PDU mode
     */
    rCI_Plus_Percent_CMGLPdu (mnsms_read_cnf, AT_CMD_P_CMGL);
  else
#endif
    /*
     * handle Text mode
     */
   
  {
    /* querying the type of the SM */
    cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type);

    if (msg_type EQ TP_MTI_SMS_STATUS_REP)
      rCI_Plus_Percent_CMGLTextSP (mnsms_read_cnf, AT_CMD_P_CMGL);
    else
     rCI_Plus_Percent_CMGLText (mnsms_read_cnf, AT_CMD_P_CMGL);
  }
}

LOCAL void rCI_Plus_Percent_CMGLTextSP (T_MNSMS_READ_CNF* mnsms_read_cnf,
                                        T_ACI_AT_CMD cmdId)
{
  UBYTE srcId = srcId_cb;
  T_ACI_CDS_SM* p_st;
  SHORT pos   = 0;
  CHAR*      buf;
  T_MNSMS_STATUS_IND mnsms_status_ind;
  
  TRACE_FUNCTION("rCI_Plus_Percent_CMGLTextSP()");

  /* is the SM already decoded ? */
  if (smsShrdPrm.pDecMsg)
     p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
  else
  {
    ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CDS_SM) );
    p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
    memcpy (&mnsms_status_ind.sms_sdu, &mnsms_read_cnf->sms_sdu, 
            sizeof (T_sms_sdu));
    cmhSMS_cpyStatInd ( p_st, &mnsms_status_ind);
  }

  buf=sms_status(mnsms_read_cnf->status );
  if (cmdId EQ AT_CMD_CMGL )
  {
    pos = sprintf ( g_sa, "+CMGL: %d", mnsms_read_cnf->rec_num);
  }
  else
  {
    pos=sprintf (g_sa, " %s:  %d", "%CMGL", mnsms_read_cnf->rec_num);
  }
  if ( buf )
  {
    pos += sprintf ( g_sa + pos, ",\"%s\"", buf );   /* STATUS */
  }
  else
  {
    pos += sprintf ( g_sa + pos, "," );
  }
  pos+=sprintf(g_sa+pos,",%d,%d,",p_st->fo, p_st->msg_ref);
  if(strlen(p_st->addr))
    pos+=sprintf(g_sa+pos,"\"%s\"",p_st->addr);
  else
   pos+=sprintf(g_sa+pos,",");
  if( (p_st->toa.ton NEQ TON_NotPresent) AND (p_st->toa.npi NEQ NPI_NotPresent) )
    pos+=sprintf(g_sa+pos,",%d",toa_merge(p_st->toa));
  else
   pos+=sprintf(g_sa+pos,",");

  pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
   p_st->vpabs_scts.year  [0], p_st->vpabs_scts.year  [1],
   p_st->vpabs_scts.month [0], p_st->vpabs_scts.month [1],
   p_st->vpabs_scts.day   [0], p_st->vpabs_scts.day   [1],
   p_st->vpabs_scts.hour  [0], p_st->vpabs_scts.hour  [1],
   p_st->vpabs_scts.minute[0], p_st->vpabs_scts.minute[1],
   p_st->vpabs_scts.second[0], p_st->vpabs_scts.second[1],
   p_st->vpabs_scts.timezone);

  pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\",%d",
   p_st->vpabs_dt.year  [0], p_st->vpabs_dt.year  [1],
   p_st->vpabs_dt.month [0], p_st->vpabs_dt.month [1],
   p_st->vpabs_dt.day   [0], p_st->vpabs_dt.day   [1],
   p_st->vpabs_dt.hour  [0], p_st->vpabs_dt.hour  [1],
   p_st->vpabs_dt.minute[0], p_st->vpabs_dt.minute[1],
   p_st->vpabs_dt.second[0], p_st->vpabs_dt.second[1],
   p_st->vpabs_dt.timezone , p_st->tp_status);

  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}

LOCAL void rCI_Plus_Percent_CMGRTextSP (T_MNSMS_READ_CNF* mnsms_read_cnf,
                                        T_ACI_AT_CMD cmdId)
{
  UBYTE srcId = srcId_cb;
  T_ACI_CDS_SM* p_st;
  SHORT pos   = 0;
  CHAR*      buf;
  T_MNSMS_STATUS_IND mnsms_status_ind;
  
  TRACE_FUNCTION("rCI_Plus_Percent_CMGRTextSP()");

  /* is the SM already decoded ? */
  if (smsShrdPrm.pDecMsg)
     p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
  else
  {
    ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CDS_SM) );
    p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg;
    memcpy (&mnsms_status_ind.sms_sdu, &mnsms_read_cnf->sms_sdu, 
            sizeof (T_sms_sdu));
    cmhSMS_cpyStatInd ( p_st, &mnsms_status_ind);
  }

  buf=sms_status(mnsms_read_cnf->status );
  if (buf) /* STATUS */
  {
    if (cmdId EQ AT_CMD_CMGR)
    {
      pos=sprintf(g_sa,"+CMGR: \"%s\"",buf);
    }
    else
    {
      pos=sprintf (g_sa, " %s:  \"%s\"", "%CMGR", buf);
    }
  }
  else
  {
    if (cmdId EQ AT_CMD_CMGR)
    {
      pos=sprintf(g_sa,"+CMGR: ,");
    }
    else
    {
      pos=sprintf (g_sa, " %s", "%CMGR: ,");
    }
  }
  pos+=sprintf(g_sa+pos,",%d,%d,",p_st->fo, p_st->msg_ref);
  if(strlen(p_st->addr))
    pos+=sprintf(g_sa+pos,"\"%s\"",p_st->addr);
  else
   pos+=sprintf(g_sa+pos,",");
  if( (p_st->toa.ton NEQ TON_NotPresent) AND (p_st->toa.npi NEQ NPI_NotPresent) )
    pos+=sprintf(g_sa+pos,",%d",toa_merge(p_st->toa));
  else
   pos+=sprintf(g_sa+pos,",");

  pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"",
   p_st->vpabs_scts.year  [0], p_st->vpabs_scts.year  [1],
   p_st->vpabs_scts.month [0], p_st->vpabs_scts.month [1],
   p_st->vpabs_scts.day   [0], p_st->vpabs_scts.day   [1],
   p_st->vpabs_scts.hour  [0], p_st->vpabs_scts.hour  [1],
   p_st->vpabs_scts.minute[0], p_st->vpabs_scts.minute[1],
   p_st->vpabs_scts.second[0], p_st->vpabs_scts.second[1],
   p_st->vpabs_scts.timezone);

  pos+=sprintf(g_sa+pos,",\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\",%d",
   p_st->vpabs_dt.year  [0], p_st->vpabs_dt.year  [1],
   p_st->vpabs_dt.month [0], p_st->vpabs_dt.month [1],
   p_st->vpabs_dt.day   [0], p_st->vpabs_dt.day   [1],
   p_st->vpabs_dt.hour  [0], p_st->vpabs_dt.hour  [1],
   p_st->vpabs_dt.minute[0], p_st->vpabs_dt.minute[1],
   p_st->vpabs_dt.second[0], p_st->vpabs_dt.second[1],
   p_st->vpabs_dt.timezone , p_st->tp_status);

  io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT);
}

#endif /* ATI_RET_C */