FreeCalypso > hg > tcs211-fcmodem
diff g23m/condat/ms/src/aci/cmh_smsr.c @ 0:509db1a7b7b8
initial import: leo2moko-r1
| author | Space Falcon <falcon@ivan.Harhan.ORG> |
|---|---|
| date | Mon, 01 Jun 2015 03:24:05 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/g23m/condat/ms/src/aci/cmh_smsr.c Mon Jun 01 03:24:05 2015 +0000 @@ -0,0 +1,2873 @@ +/* ++----------------------------------------------------------------------------- +| Project : GSM-PS (6147) +| Modul : CMH_SMSR ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : This module defines the functions which are responsible +| for the responses of the protocol stack adapter for +| the short message service. ++----------------------------------------------------------------------------- +*/ + +#ifndef CMH_SMSR_C +#define CMH_SMSR_C +#endif + +#include "aci_all.h" +/*==== INCLUDES ===================================================*/ +#include "aci_cmh.h" +#include "ati_cmd.h" +#include "aci_cmd.h" + +#ifdef FAX_AND_DATA +#include "aci_fd.h" +#endif /* of #ifdef FAX_AND_DATA */ + +#ifdef UART +#include "dti.h" +#include "dti_conn_mng.h" +#endif + +#include "aci.h" +#include "aci_lst.h" +#include "aci_mem.h" +#include "psa.h" +#include "psa_sms.h" +#include "psa_mmi.h" +#include "psa_cc.h" + +#include "cmh.h" +#include "cmh_sms.h" +#include "psa_sim.h" +#include "cmh_sim.h" +#include "psa_util.h" +#include "Phb.h" + +#ifdef SIM_TOOLKIT +#include "psa_sat.h" +#include "cmh_sat.h" +#endif /* of SIM_TOOLKIT */ + +#if (defined (MFW) AND !defined (FF_MMI_RIV)) OR defined (_CONC_TESTING_) OR defined (SMI) +#include "conc_sms.h" +#endif /* ##if (defined (MFW) AND !defined (FF_MMI_RIV)) OR defined (_CONC_TESTING_) OR defined (SMI)*/ + +#ifdef _CONC_TESTING_ +#include "aci_mfw.h" +#endif + + +/*==== CONSTANTS ==================================================*/ + +/* TP-User-Data-Header-Indicator (TP-UDHI) */ +#define UDHI_MASK 0x40 +#define UDHI_PRESENT 0x40 +#define UDHI_ABSENT 0x00 + +/*==== TYPES ======================================================*/ + +/*==== EXPORT =====================================================*/ + +/*==== VARIABLES ==================================================*/ + +EXTERN T_ACI_LIST *set_prm_list; + +/*==== FUNCTIONS ==================================================*/ +LOCAL BOOL cmhSMS_cpySTtoSM(T_ACI_CMGL_SM *p_sm,T_MNSMS_READ_CNF * mnsms_read_cnf); + +/* help function for cmhSMS_SMRead to inform user in case of + * CCD decoding error with SMS + * for this case the T_ACI_SMS_STAT has been extended with a value + * of SMS_STAT_Invalid = -2 (e.g to tell BMI to emit "INVALID MESSAGE") */ +LOCAL void cmhSMS_invalidSMS_notification_to_user(T_MNSMS_READ_CNF * mnsms_read_cnf) +{ + UBYTE idx = 0; + T_ACI_AT_CMD cmdBuf = smsShrdPrm.smsEntStat.curCmd; + T_ACI_CMD_SRC ownBuf = smsShrdPrm.smsEntStat.entOwn; + + TRACE_FUNCTION ("cmhSMS_SMRead_invalidSMS_notification_to_user()"); + if (smsShrdPrm.pDecMsg->stat EQ SMS_STAT_Invalid) + { + switch( smsShrdPrm.smsEntStat.curCmd ) + { + case ( AT_CMD_CMGR ): + { + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + if (smsShrdPrm.rplyCB.cmgr NEQ NULL) + { + smsShrdPrm.rplyCB.cmgr( smsShrdPrm.pDecMsg, NULL ); + } + R_AT ( RAT_OK, ownBuf) ( cmdBuf ); + break; + } + case ( AT_CMD_CMGL ): + { + R_AT ( RAT_CMGL, smsShrdPrm.smsEntStat.entOwn ) ( smsShrdPrm.pDecMsg ); /* intermediate result */ + if (mnsms_read_cnf->rec_next NEQ SMS_RECORD_NOT_EXIST) + { + psaSMS_ReadReq ( smsShrdPrm.mem1, mnsms_read_cnf->rec_next, + smsShrdPrm.rdMode, cmglStat ); + } + break; + } + } + } + else + { + /* + * SMS decoding failed, but the status has not been set to SMS_STAT_Invalid + */ + TRACE_FUNCTION ("cmhSMS_SMRead_invalidSMS_notification_to_MFW(): [ERR] status not SMS_STAT_Invalid !"); + } +} + + +#ifdef SIM_TOOLKIT +LOCAL void cmhSMS_SATResult (T_ACI_SAT_TERM_RESP *p_resp_data, + USHORT cause) +{ + if (GET_CAUSE_ORIGIN_ENTITY(cause) EQ SMSCP_ORIGINATING_ENTITY) + { /* CP-CAUSE */ + p_resp_data->add_content = GET_CAUSE_VALUE(cause) | 0x80; + psaSAT_SendTrmResp( RSLT_NTW_UNAB_PROC, p_resp_data ); + } + else + { /* RP-CAUSE or other */ + if (GET_CAUSE_ORIGIN_ENTITY(cause) EQ SMSRP_ORIGINATING_ENTITY) + p_resp_data->add_content = GET_CAUSE_VALUE(cause); + else + p_resp_data->add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_SMS_ERR, p_resp_data); + } +} +#endif /* #ifdef SIM_TOOLKIT */ + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_CBMIndication | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to notify the command handler of + the receiving of a cell broadcast message. +*/ +GLOBAL SHORT cmhSMS_CBMIndication ( T_MMI_CBCH_IND * mmi_cbch_ind ) +{ + USHORT sn; /* serial number */ + USHORT mid; /* message identifier */ + UBYTE dcs; /* data coding scheme */ + UBYTE page; /* actual page number */ + UBYTE pages; /* total number of pages */ + T_ACI_CBM_DATA msg; /* cell broadcast message data */ + UBYTE idx; + + TRACE_FUNCTION ("cmhSMS_CBMIndication ()"); + + /* + *----------------------------------------------------------------- + * process parameters for new message indication + *----------------------------------------------------------------- + */ + sn = ( ( SHORT )mmi_cbch_ind->cbch_msg[0] << 8 ) + + mmi_cbch_ind->cbch_msg[1]; + mid = ( ( SHORT )mmi_cbch_ind->cbch_msg[2] << 8 ) + + mmi_cbch_ind->cbch_msg[3]; + dcs = mmi_cbch_ind->cbch_msg[4]; + page = ( mmi_cbch_ind->cbch_msg[5] & 0xF0 ) >> 4; + pages = ( mmi_cbch_ind->cbch_msg[5] & 0x0F ); + + /* + *----------------------------------------------------------------- + * process message data, expanding from 7 to 8 bit + *----------------------------------------------------------------- + */ + cmhSMS_expdSmsCb ( dcs, + &mmi_cbch_ind->cbch_msg[CBCH_HEAD_LEN], + (UBYTE)(mmi_cbch_ind->cbch_len - CBCH_HEAD_LEN), + msg.data, &msg.len ); + + /* + *----------------------------------------------------------------- + * new message indication + *----------------------------------------------------------------- + */ + #ifdef FF_MMI_RIV + { + T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent; + + qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode); + if (sms_input_mode EQ CMGF_MOD_Pdu) + { + rAT_PlusCBMPdu (mmi_cbch_ind); + } + else + { + R_AT( RAT_CBM, CMD_SRC_LCL ) + ( sn, mid, dcs, page, pages, &msg ); + } + } +#else + R_AT( RAT_CBM, CMD_SRC_LCL ) + ( sn, mid, dcs, page, pages, &msg ); +#endif + + /* If the SMS shared params indicate no valid source interested in + * the SMS indications, the indication is buffered */ /* Issue 25033 */ + if( smsShrdPrm.smsSrcId EQ CMD_SRC_NONE ) + { +#ifdef DTI + T_CNMI_IND ind; + + memcpy (&ind.cbm, mmi_cbch_ind, sizeof(T_MMI_CBCH_IND)); + cmd_addCnmiNtry ( CNMI_CBM, &ind ); +#endif + } + else + { +#ifdef FF_ATI + /* tell any remote source */ + for( idx = CMD_SRC_LCL+1; idx < CMD_SRC_MAX; idx++ ) + { + if (IS_SRC_USED (idx)) + { + R_AT( RAT_CBM, idx ) ( mmi_cbch_ind ); + } + } +#endif + } + + return 0; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSInitState | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to handle the + SMS_STATE_INITIALISING state. +*/ +GLOBAL SHORT cmhSMS_SMSInitState ( T_MNSMS_MESSAGE_IND * mnsms_message_ind ) +{ +#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + T_ACI_CMGL_SM sm; + T_ACI_SMS_STOR mem; /* holds message storage */ + UBYTE retCode = TRUE; + UBYTE msg_type; +#endif /* SMI OR defined MFW */ + +#ifdef _CONC_TESTING_ +#ifndef NTRACE + char trcBuf[80]; + char *writeP; + int count; + USHORT offset; + + TRACE_EVENT_P1("initstate:rec_num: %d", mnsms_message_ind->rec_num); + TRACE_EVENT_P1("initstate:status: %d", mnsms_message_ind->status); + offset = mnsms_message_ind->sms_sdu.o_buf>>3; + writeP = trcBuf; + for (count=offset; count<offset+20; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]); + } + TRACE_EVENT("buf: "); + *writeP = '\0'; + TRACE_EVENT(trcBuf); + + writeP = trcBuf; + for (; count<offset+40; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]); + } + *writeP = '\0'; + TRACE_EVENT(trcBuf); +#endif +#endif + + + TRACE_FUNCTION ("cmhSMS_SMSInitState()"); + + + switch (mnsms_message_ind->mem_type) + { + case MEM_ME: + if (mnsms_message_ind->rec_num NEQ SMS_RECORD_NOT_EXIST) + { + smsShrdPrm.aci_sms_parameter.meUsed++; + } + if (smsShrdPrm.aci_sms_parameter.meTotal EQ 0) + { + smsShrdPrm.aci_sms_parameter.meTotal = mnsms_message_ind->rec_max; + } + break; + case MEM_SM: + if (mnsms_message_ind->rec_num NEQ SMS_RECORD_NOT_EXIST) + { + smsShrdPrm.aci_sms_parameter.simUsed++; + TRACE_EVENT_P1("simUsed: %d", smsShrdPrm.aci_sms_parameter.simUsed); + } + if (smsShrdPrm.aci_sms_parameter.simTotal EQ 0) + { + smsShrdPrm.aci_sms_parameter.simTotal = mnsms_message_ind->rec_max; + TRACE_EVENT_P1("simTotal: %d", smsShrdPrm.aci_sms_parameter.simTotal); + } + break; + default: + TRACE_EVENT("wrong memtype"); + } + +#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + cmhSMS_getMemCmh ( mnsms_message_ind->mem_type, &mem ); + cmhSMS_SMSQueryType (&mnsms_message_ind->sms_sdu , &msg_type); + memset(&sm,0,sizeof(T_ACI_CMGL_SM) ); + if(msg_type NEQ TP_MTI_SMS_STATUS_REP) + { + retCode = cmhSMS_cpyMsgInd ( &sm, mnsms_message_ind); + } + if (retCode EQ FALSE) + { + TRACE_EVENT("cmhSMS_SMSInitState():[ERR] decoding of SMS"); + if (sm.stat NEQ SMS_STAT_Invalid) + { + TRACE_EVENT("cmhSMS_SMSInitState():[ERR] SMS decoding failed, but status not SMS_STAT_Invalid"); + } + } + +#if defined FF_MMI_RIV + /* in case of RIV MMI: check if SMBS is enabled for sending also PDU data */ + if(smsShrdPrm.perccmgf_smbs_mode EQ PERC_SMBS_MOD_ENABLE) + { + rAT_PlusCMTPdu (mnsms_message_ind); + } +#endif /* FF_MMI_RIV */ + + R_AT( RAT_CMTI, CMD_SRC_LCL ) + (mem, sm.msg_ref, &sm); +#endif /* defined SMI OR defined MFW OR defined FF_MMI_RIV */ + + return 0; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSDelCnf | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to handle MNSMS_DELETE_CNF primitive. +*/ +GLOBAL SHORT cmhSMS_SMSDelCnf ( T_MNSMS_DELETE_CNF * mnsms_delete_cnf ) +{ + T_ACI_AT_CMD cmdBuf; /* buffers current command */ + T_ACI_CMD_SRC ownBuf; /* buffers current owner */ + T_ACI_CMD_SRC srcId; /* Hold the request Source ID */ + +#ifdef _CONC_TESTING_ + + T_CONC_INIT_RETURN ret; + +#endif + + TRACE_FUNCTION ("cmhSMS_SMSDelCnf()"); + + /*-------------------------------------------------------------------------* + * In R99 one more flag is added in CMGD command which is used to delete * + * multiple messages of the same status ( READ, UNSENT, SENT etc ). * + * For this purpose the setting of global variables are done, once * + * the it is confirmed that all the messages of the same status are * + * deleted. * + *-------------------------------------------------------------------------*/ + + cmdBuf = smsShrdPrm.smsEntStat.curCmd; + ownBuf = smsShrdPrm.smsEntStat.entOwn; + srcId = smsShrdPrm.smsEntStat.entOwn; + +#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + SET_OWNBUF_CONC; +#endif /*#if defined SMI OR defined MFW*/ + + + if(smsShrdPrm.status > CMGD_DEL_INDEX) + { + ownBuf = smsShrdPrm.smsEntStat.entOwn; + } + + if (IS_CAUSE_INVALID(mnsms_delete_cnf->cause)) /* no error */ + { + /* Check if the mnsms_delete_req for deleting messages of particular + status returned indicating no messages of requested status. Note + that in this case also we return OK to the user */ + if(mnsms_delete_cnf->rec_num NEQ 0) + { + switch (mnsms_delete_cnf->mem_type) + { + case MEM_ME: + smsShrdPrm.aci_sms_parameter.meUsed--; + break; + case MEM_SM: + smsShrdPrm.aci_sms_parameter.simUsed--; + break; + default: + TRACE_EVENT("wrong memtype"); + return AT_FAIL; + } + } +/*-----------------------------------------------------------------------* + * The below code is the new code added on 07/08/2003 due to the new * + * flag for CMGD command as mentioned in R99. This flag handles the * + * deletion of multiple messages. The deletion of concatination is * + * handled with different way other than handling normal indexed * + * messages. The deletion of normal concatination messages is done as * + * in the exiting code. But deletion of concatination message is handled * + * in the different way when delete flag is greater than ZERO. If the * + * delete flag in CMGD command is greater than ZERO, then there is no * + * concatination check is done. After receiving the response from SMS * + * with the deleted messages number, then we will do the concatination * + * check. If CONC_NEEDED flag is set, then we will clear the * + * concatinated list from the ACI. If CONC_NOT_NEEDED is set then check * + * for the next record values, if it is greater than ZERO then send one * + * more request for SMS to delete that message and repeat the above * + * process untill ACI recive's the next record values as ZERO. * + *-----------------------------------------------------------------------*/ + + if( smsShrdPrm.status > CMGD_DEL_INDEX AND + mnsms_delete_cnf->rec_num NEQ 0) + { +#ifdef _CONC_TESTING_ + /*-----------------------------------------------------------------* + * Check for the concatination * + *-----------------------------------------------------------------*/ + + ret= concSMS_initDeleteFromMem (srcId, mnsms_delete_cnf->rec_num); + + if( ret EQ CONC_NEEDED ) + { + SET_CONC; + concSMS_DeleteConcList(); + } +#endif + if ( mnsms_delete_cnf->delete_rec_next NEQ 0 ) + { + cmhSMS_SendDelete_Req (mnsms_delete_cnf->delete_rec_next, + smsShrdPrm.status); + return 0; + } + } + /*-----------------------------------------------------------------------* + * Reset the command context * + *-----------------------------------------------------------------------*/ + + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; + smsShrdPrm.owner = OWN_NONE; + + /*-----------------------------------------------------------------------* + * The below code is used to handle the existing way where there is no * + * delete falg is set ( i.e. delete flag == 0 ) * + *-----------------------------------------------------------------------*/ + +#if defined SMI OR defined MFW OR defined FF_MMI_RIV + if (ownBuf EQ CMD_SRC_LCL) + { + if( smsShrdPrm.status EQ CMGD_DEL_INDEX ) + { +#ifdef _CONC_TESTING_ + if (!ISSET_CONC) + { +#endif /* _CONC_TESTING_ */ + TRACE_EVENT("you just erased a normal SMS !"); + if(smsShrdPrm.rplyCB.cmgd NEQ NULL) + { + smsShrdPrm.rplyCB.cmgd( ); + } + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); +#ifdef _CONC_TESTING_ + } + else + { + /*-----------------------------------------------------------------* + * Looks just about the same BUT: ISSET_CONC could be unsent * + * in RAT_CMGD, so let this after checking ISSET_CONC * + *-----------------------------------------------------------------*/ + + if(smsShrdPrm.rplyCB.cmgd NEQ NULL) + { + smsShrdPrm.rplyCB.cmgd( ); + } + } +#endif /* _CONC_TESTING_ */ + } + else + { + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + if(smsShrdPrm.rplyCB.cmgd NEQ NULL) + { + smsShrdPrm.rplyCB.cmgd( ); + } + +#if defined FF_MMI_RIV + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); +#else + /* GPF-MMI */ +#ifdef _CONC_TESTING_ + if (!ISSET_CONC) +#endif /* _CONC_TESTING_ */ + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + } +#endif + } + else /* if (ownBuf EQ CMD_SRC_LCL) */ +#endif /*defined MFW OR defined FF_MMI_RIV*/ + { + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + } + } + else + { + /*-----------------------------------------------------------------------* + * Reset the command context * + *-----------------------------------------------------------------------*/ + + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; + smsShrdPrm.owner = OWN_NONE; + + if (smsShrdPrm.errorCB NEQ NULL) + { + smsShrdPrm.errorCB + ( + cmdBuf, + cmhSMS_GetCmsFromSms(mnsms_delete_cnf->cause), + NULL + ); + } + else + { + R_AT ( RAT_CMS, ownBuf ) ( cmdBuf, cmhSMS_GetCmsFromSms(mnsms_delete_cnf->cause), NULL ); + } + } + /* Reset status flag to CMGD_DEL_INDEX = 0 */ + smsShrdPrm.status = CMGD_DEL_INDEX; + return 0; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSStoCnf | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to handle MNSMS_STORE_CNF primitive. +*/ +GLOBAL SHORT cmhSMS_SMSStoCnf ( T_MNSMS_STORE_CNF * mnsms_store_cnf ) +{ + T_ACI_AT_CMD cmdBuf; /* buffers current command */ + T_ACI_CMD_SRC ownBuf; /* buffers current owner */ + + TRACE_FUNCTION ("cmhSMS_SMSStoCnf()"); + + /* + *----------------------------------------------------------------- + * reset the command context + *----------------------------------------------------------------- + */ + cmdBuf = smsShrdPrm.smsEntStat.curCmd; + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + ownBuf = smsShrdPrm.smsEntStat.entOwn; + +#ifdef _CONC_TESTING_ + /* this is only for testing */ + SET_OWNBUF_CONC; +#endif + + smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; + smsShrdPrm.owner = OWN_NONE; + + /* Check for current cmd is CMGMDU */ + if ( cmdBuf EQ AT_CMD_P_CMGMDU ) + { + if (IS_CAUSE_INVALID(mnsms_store_cnf->cause)) + { +#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + if (ownBuf EQ CMD_SRC_LCL) + { + if(smsShrdPrm.rplyCB.cmgmdu NEQ NULL) + { + smsShrdPrm.rplyCB.cmgmdu(); + } + } + else +#endif /*#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ */ + { + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + } + } + else + { + if ( ownBuf NEQ CMD_SRC_LCL ) + R_AT ( RAT_CMS, ownBuf ) + ( + cmdBuf, + cmhSMS_GetCmsFromSms(mnsms_store_cnf->cause), + NULL + ); + return -1; + } + } + else if (IS_CAUSE_INVALID(mnsms_store_cnf->cause)) + { + switch (mnsms_store_cnf->mem_type) + { + case MEM_ME: + smsShrdPrm.aci_sms_parameter.meUsed++; + break; + case MEM_SM: + smsShrdPrm.aci_sms_parameter.simUsed++; + break; + default: + TRACE_EVENT("incorrect memtype"); + return AT_FAIL; + } +#ifdef FF_ATI + /* "internal storage" handling -> storing from CNMI-buf to SIM/MS */ + if( smsShrdPrm.uiInternalSmsStorage NEQ CMD_SRC_NONE ) + { + if(mnsms_store_cnf->cause NEQ SMS_NO_ERROR) + { + TRACE_EVENT("cmhSMS_SMSStoCnf() : error at internal SMS storaging"); + cmd_clearCnmiBuf(); /* clear CNMI buffer */ + smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; + return -1; + } + + /* storing was succesful -> clear the stored msg. in CNMI buf */ + cmd_clearFirstCnmiMessage(); + + /* try with the next msg. in CNMI-buf */ + if( cmd_storeNextCnmiBufMsgToSim() NEQ TRUE ) /* do nothing if no more Msg's in CNMI buffer */ + { /* no more messagees could be sent */ + smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; + } + return 0; /* returns immediately if internal storage is running */ + } +#endif /* FF_ATI */ +#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + if (ownBuf EQ CMD_SRC_LCL) + { + if(smsShrdPrm.rplyCB.cmgw NEQ NULL) + { + smsShrdPrm.rplyCB.cmgw( mnsms_store_cnf->rec_num, 1 ); + } +#if defined FF_MMI_RIV + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); +#else + /* GPF-MMI */ + if (!ISSET_CONC) + { + TRACE_EVENT("you just wrote a normal SMS !"); + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + } +#endif /*#if !defined FF_MMI_RIV*/ + } + else +#endif /*#if defined MFW OR defined FF_MMI_RIV*/ + { + R_AT ( RAT_CMGW, ownBuf ) ( mnsms_store_cnf->rec_num ); + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + /* inform BMI */ + cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMGW, mnsms_store_cnf->rec_num, -1, -1 ); + } + } + else + { + if( smsShrdPrm.uiInternalSmsStorage NEQ CMD_SRC_NONE ) + { + smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; + return 0; + } + + if (ownBuf EQ CMD_SRC_LCL) + { + if (smsShrdPrm.errorCB NEQ NULL) + { + smsShrdPrm.errorCB + ( + cmdBuf, + cmhSMS_GetCmsFromSms(mnsms_store_cnf->cause), + NULL + ); + } + } + else + { + R_AT ( RAT_CMS, ownBuf ) + ( + cmdBuf, + cmhSMS_GetCmsFromSms(mnsms_store_cnf->cause), + NULL + ); + } + } + return 0; +} + + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSSbmCnf | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to handle MNSMS_SUBMIT_CNF primitive. +*/ +GLOBAL SHORT cmhSMS_SMSSbmCnf ( T_MNSMS_SUBMIT_CNF * mnsms_submit_cnf ) +{ + T_ACI_AT_CMD cmdBuf; /* buffers current command */ + T_ACI_CMD_SRC ownBuf; /* buffers current owner */ +#ifdef SIM_TOOLKIT + T_ACI_SAT_TERM_RESP resp_data; +#endif + + +#ifdef _CONC_TESTING_ +#ifndef NTRACE + char trcBuf[80]; + char *writeP; + int count; + USHORT offset; + + TRACE_EVENT_P1("cause: %d", mnsms_submit_cnf->cause); + offset = mnsms_submit_cnf->sms_sdu.o_buf>>3; + writeP = trcBuf; + for (count=offset; count<offset+20; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_submit_cnf->sms_sdu.buf[count]); + } + TRACE_EVENT("buf: "); + *writeP = '\0'; + TRACE_EVENT(trcBuf); + + writeP = trcBuf; + for (; count<offset+40; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_submit_cnf->sms_sdu.buf[count]); + } + *writeP = '\0'; + TRACE_EVENT(trcBuf); +#endif +#endif + + TRACE_FUNCTION ("cmhSMS_SMSSbmCnf()"); + + /* + *----------------------------------------------------------------- + * reset the command context + *----------------------------------------------------------------- + */ + cmdBuf = smsShrdPrm.smsEntStat.curCmd; + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + + ownBuf = smsShrdPrm.smsEntStat.entOwn; + +#ifdef _CONC_TESTING_ + /* this is only for testing */ + SET_OWNBUF_CONC; +#endif + smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; + smsShrdPrm.owner = OWN_NONE; + +#ifdef SIM_TOOLKIT + psaSAT_InitTrmResp( &resp_data ); +#endif + + if (IS_CAUSE_INVALID(mnsms_submit_cnf->cause)) + { + smsShrdPrm.aci_sms_parameter.snd_msg_ref = mnsms_submit_cnf->tp_mr; + switch (cmdBuf) + { + case( AT_CMD_CMSS ): +#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + if (ownBuf EQ CMD_SRC_LCL) + { + if(smsShrdPrm.rplyCB.cmss NEQ NULL) + { + smsShrdPrm.rplyCB.cmss( mnsms_submit_cnf->tp_mr, 1 ); + } +#if defined FF_MMI_RIV + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); +#else + if (!ISSET_CONC) + { + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + } +#endif /* FF_MMI_RIV */ + } + else /* if (ownBuf EQ CMD_SRC_LCL) */ +#endif /*#if defined MFW OR defined FF_MMI_RIV*/ + { + R_AT ( RAT_CMSS, ownBuf ) ( mnsms_submit_cnf ); + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + /* inform BMI */ + cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMSS, mnsms_submit_cnf->rec_num, -1, -1 ); + } + break; + case( AT_CMD_CMGS ): +#if defined (SIM_TOOLKIT) + if (ownBuf EQ OWN_SAT) + { + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + break; + } +#endif + if (mnsms_submit_cnf->rec_num NEQ SMS_RECORD_NOT_EXIST) + { + switch (mnsms_submit_cnf->mem_type) + { + case MEM_ME: + smsShrdPrm.aci_sms_parameter.meUsed++; + break; + case MEM_SM: + smsShrdPrm.aci_sms_parameter.simUsed++; + break; + default: + TRACE_EVENT("incorrect memtype"); + return AT_FAIL; + } + } +#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + if (ownBuf EQ CMD_SRC_LCL) + { + if(smsShrdPrm.rplyCB.cmgs NEQ NULL) + { + smsShrdPrm.rplyCB.cmgs( mnsms_submit_cnf->tp_mr, 1 ); + } +#if defined FF_MMI_RIV + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); +#else + if (!ISSET_CONC) + { + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + } +#endif /* FF_MMI_RIV */ + } + else /* if (ownBuf EQ CMD_SRC_LCL) */ +#endif /*#if defined MFW OR defined FF_MMI_RIV*/ + { + R_AT ( RAT_CMGS, ownBuf ) ( mnsms_submit_cnf ); + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + /* inform BMI */ + cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMGS, mnsms_submit_cnf->rec_num, -1, -1 ); + } + } /* switch */ + } + else /* if (mnsms_submit_cnf->rslt_type EQ SMS_RT_NON) */ + { +#if defined (SIM_TOOLKIT) + if (ownBuf EQ OWN_SAT) + { + cmhSMS_SATResult (&resp_data, mnsms_submit_cnf->cause); + } +#endif + /* MSMSMS */ + if (ownBuf EQ CMD_SRC_LCL) + { + if (smsShrdPrm.errorCB NEQ NULL) + { + smsShrdPrm.errorCB + ( + cmdBuf, + cmhSMS_GetCmsFromSms(mnsms_submit_cnf->cause), + NULL + ); + } + } + else + { + R_AT ( RAT_CMS, ownBuf ) + ( + cmdBuf, + cmhSMS_GetCmsFromSms(mnsms_submit_cnf->cause), + NULL + ); + } + } + return 0; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSCmdCnf | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to handle MNSMS_COMMAND_CNF primitive. +*/ +GLOBAL SHORT cmhSMS_SMSCmdCnf ( T_MNSMS_COMMAND_CNF * mnsms_command_cnf ) +{ + T_ACI_AT_CMD cmdBuf; /* buffers current command */ + T_ACI_CMD_SRC ownBuf; /* buffers current owner */ +#ifdef SIM_TOOLKIT + T_ACI_SAT_TERM_RESP resp_data; + psaSAT_InitTrmResp( &resp_data ); +#endif + + TRACE_FUNCTION ("cmhSMS_SMSCmdCnf()"); + + + /* + *----------------------------------------------------------------- + * reset the command context + *----------------------------------------------------------------- + */ + cmdBuf = smsShrdPrm.smsEntStat.curCmd; + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + + ownBuf = smsShrdPrm.smsEntStat.entOwn; + + smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; + smsShrdPrm.owner = OWN_NONE; + + if (IS_CAUSE_INVALID(mnsms_command_cnf->cause)) + { +#ifdef _CONC_TESTING_ + /* this is only for testing */ + SET_OWNBUF_CONC; +#endif + +#if defined (SIM_TOOLKIT) + if (ownBuf EQ OWN_SAT) + { + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + } +#endif +#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + if (ownBuf EQ CMD_SRC_LCL) + { + if(smsShrdPrm.rplyCB.cmgc NEQ NULL) + { + smsShrdPrm.rplyCB.cmgc( mnsms_command_cnf->tp_mr ); + } +#if defined FF_MMI_RIV + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); +#else + if (!ISSET_CONC) + { + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + } +#endif /*!defined FF_MMI_RIV*/ + } + else /* if (ownBuf EQ CMD_SRC_LCL) */ +#endif /*defined MFW OR defined FF_MMI_RIV*/ + { + R_AT ( RAT_CMGC, ownBuf ) ( mnsms_command_cnf ); + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + /* inform BMI */ + /* This does not make much sense, but nice to have it for future requests */ +/* cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMGC, -1, -1, -1 ); */ + } + + } + else + { +#if defined (SIM_TOOLKIT) + if (ownBuf EQ OWN_SAT) + { + cmhSMS_SATResult (&resp_data, mnsms_command_cnf->cause); + } +#endif + + R_AT ( RAT_CMS, ownBuf ) + ( + cmdBuf, + cmhSMS_GetCmsFromSms(mnsms_command_cnf->cause), + NULL + ); + } + return 0; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSErrorInd | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to handle MNSMS_ERROR_IND primitive. +*/ +GLOBAL SHORT cmhSMS_SMSErrorInd ( T_MNSMS_ERROR_IND * mnsms_error_ind ) +{ + T_ACI_MM_CIND_VAL_TYPE sIndValues; + int i; + + TRACE_FUNCTION ("cmhSMS_SMSErrorInd()"); + + TRACE_EVENT_P1("MNSMS_ERROR_IND: 0x%4.4X", (int)mnsms_error_ind->cause); + +/* send CMS error code for SMS memory full */ + if(mnsms_error_ind->cause == SMS_CAUSE_MEM_FULL) + { + char *sa; + ACI_MALLOC(sa,KEY + BYTE_LTH); + sprintf(sa,"+CMS ERROR: %d",CMS_ERR_MemFull); + io_sendMessage(3, sa, ATI_NORMAL_OUTPUT); + ACI_MFREE(sa); + rCI_PlusCMS ( 0, CMS_ERR_MemFull, NULL ); + } + + if( (mnsms_error_ind->cause != SMS_CAUSE_MEM_FULL) && + (mnsms_error_ind->cause != SMS_CAUSE_MEM_AVAIL) ) + { + smsShrdPrm.cnma_ack_expected = FALSE; + cmhSMS_resetMtDsCnmiParam(); + } + else + { /* process the SMS memory full/avail indication */ + sIndValues.sCindSmsFullParam = (mnsms_error_ind->cause EQ SMS_CAUSE_MEM_AVAIL) + ? CIND_SMSFULL_INDICATOR_MEMAVAIL + : CIND_SMSFULL_INDICATOR_MEMFULL; + sIndValues.sCindSignalParam = CIND_SIGNAL_INDICATOR_INVALID; + + for( i = CMD_SRC_LCL; i < CMD_SRC_MAX; i++) + { + if( ((cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCINDSettings.sCindSmsFullParam EQ CIND_SMSFULL_INDICATOR_MEMFULL) AND + (cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCMERSettings.sCmerIndParam EQ CMER_INDICATOR_2)) OR + ((cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCINDSettings.sCindSmsFullParam <= CIND_SMSFULL_INDICATOR_MEMAVAIL) AND + (cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCMERSettings.sCmerIndParam EQ CMER_INDICATOR_1)) ) + { /* process the service of +CIEV */ + TRACE_EVENT("send +CIEV (SMS-full/avail)"); + R_AT (RAT_CIEV, i) ( sIndValues, cmhPrm[i].mmCmdPrm.sIndicationParam.sMmCMERSettings ); + } + } + } + return 0; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSDeliver | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to notify the command handler of + the receiving of a SMS-DELIVER. +*/ +#ifndef NTRACE +LOCAL void trace_SMSDeliver ( T_MNSMS_MESSAGE_IND * mnsms_message_ind ) +{ +#ifdef _CONC_TESTING_ + + char trcBuf[80]; + char *writeP; + int count; + USHORT offset; + + TRACE_FUNCTION ("trace_SMSDeliver"); + + TRACE_EVENT_P1("cmt:bitoffset:%d", mnsms_message_ind->sms_sdu.o_buf); + TRACE_EVENT_P1("cmt:lenght:%d", mnsms_message_ind->sms_sdu.l_buf); + offset = mnsms_message_ind->sms_sdu.o_buf>>3; + writeP = trcBuf; + for (count=offset; count<offset+20; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]); + } + TRACE_EVENT("buf: "); + *writeP = '\0'; + TRACE_EVENT(trcBuf); + + writeP = trcBuf; + for (; count<offset+40; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]); + } + *writeP = '\0'; + TRACE_EVENT(trcBuf); +#endif +} +#endif + +#if defined SMI OR defined MFW OR defined FF_MMI_RIV +LOCAL void rAT_SMS_Deliver(T_MNSMS_MESSAGE_IND * mnsms_message_ind, T_ACI_CMGL_SM *p_sm) +{ +#ifdef FF_MMI_RIV + T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent; +#endif /* FF_MMI_RIV */ + + TRACE_FUNCTION ("rAT_SMS_Deliver"); + +#ifdef FF_MMI_RIV + if(smsShrdPrm.perccmgf_smbs_mode EQ PERC_SMBS_MOD_ENABLE) + { + /*send both formats*/ + rAT_PlusCMTPdu (mnsms_message_ind); + R_AT( RAT_CMT, CMD_SRC_LCL ) (p_sm); + return; + } + + /* else: no SMBS enabled, CMGF mode decides */ + qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode); + if (sms_input_mode EQ CMGF_MOD_Pdu) + { + rAT_PlusCMTPdu (mnsms_message_ind); + } + else + { + R_AT( RAT_CMT, CMD_SRC_LCL ) (p_sm); + } + return; +#endif /* FF_MMI_RIV */ + + /* if GPF MMI call usual callback */ + R_AT( RAT_CMT, CMD_SRC_LCL ) (p_sm); +} +#endif /* SMI OR defined MFW OR defined FF_MMI_RIV */ + +GLOBAL SHORT cmhSMS_SMSDeliver ( T_MNSMS_MESSAGE_IND * mnsms_message_ind ) +{ + UBYTE idx; +#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + T_ACI_CMGL_SM *p_sm; +#endif /* SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_*/ + + TRACE_FUNCTION ("cmhSMS_SMSDeliver"); + +#ifndef NTRACE + trace_SMSDeliver ( mnsms_message_ind ); +#endif + + if( smsShrdPrm.CNMImt EQ 0 ) + { + TRACE_EVENT("cmhSMS_SMSDeliver():[ERR] <mt>==0 -> SMS will not be routed "); + return 0; + } + +#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) ); + p_sm = smsShrdPrm.pDecMsg; + if (cmhSMS_cpyMsgInd ( p_sm, mnsms_message_ind) EQ FALSE) + { + TRACE_EVENT("cmhSMS_SMSDeliver():[ERR] decoding of SMS"); + if (p_sm->stat NEQ SMS_STAT_Invalid) + { + TRACE_EVENT("cmhSMS_SMSDeliver():[ERR] SMS decoding failed, but status not SMS_STAT_Invalid"); + } + } +#endif /* SMI OR defined MFW OR defined FF_MMI_RIV */ + + + if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus) + smsShrdPrm.cnma_ack_expected = TRUE; + + /* + *----------------------------------------------------------------- + * new message indication + *----------------------------------------------------------------- + */ + + /* inform LOCAL MMI of new message */ +#if defined SMI OR defined MFW OR defined FF_MMI_RIV + rAT_SMS_Deliver(mnsms_message_ind, p_sm); +#endif /* SMI OR defined MFW OR defined FF_MMI_RIV */ + + /* If the SMS shared params indicate no valid source interested in + * the SMS indications, the indication is buffered */ /* Issue 25033 */ + if( smsShrdPrm.smsSrcId EQ CMD_SRC_NONE ) + { + T_CNMI_IND ind; + + TRACE_EVENT("cmhSMS_SMSDeliver(): No registered source for "); + memcpy ( &ind.cmt, mnsms_message_ind, sizeof ( T_MNSMS_MESSAGE_IND) ); +#ifdef DTI + cmd_addCnmiNtry ( CNMI_CMT, &ind ); +#endif + if ( smsShrdPrm.cnma_ack_expected EQ TRUE ) + { /* the acknowledge must be send automatically, because terminal is busy */ + PALLOC (mnsms_ack_res, MNSMS_ACK_RES); + + TRACE_EVENT("rCI_PlusCMT(): send 'automatic' acknowledge (Phase2+ mode and buffer)"); + + mnsms_ack_res->resp = SMS_RP_ACK; + mnsms_ack_res->sms_sdu.o_buf = 0; + mnsms_ack_res->sms_sdu.l_buf = 0; + + PSENDX (SMS, mnsms_ack_res); + + smsShrdPrm.cnma_ack_expected = FALSE; + } + } + else + { + /* tell any remote source */ + for( idx = CMD_SRC_LCL+1; idx < CMD_SRC_MAX; idx++ ) + { +#if defined _SIMULATION_ AND defined _CONC_TESTING_ + /* don't display "+CMT: ..." in simulation if conc testing */ + if (!concShrdPrm.concTesting) +#endif + { + R_AT( RAT_CMT, idx ) ( mnsms_message_ind ); + } + } + } + + if (smsShrdPrm.pDecMsg) + { + ACI_MFREE(smsShrdPrm.pDecMsg); + smsShrdPrm.pDecMsg = NULL; + } + + return 0; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSMemory | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to notify the command handler of + an incoming SMS written to preferred message storage. +*/ +GLOBAL SHORT cmhSMS_SMSMemory ( T_MNSMS_MESSAGE_IND * mnsms_message_ind) +{ + USHORT idx; /* holds command source id */ + T_ACI_SMS_STOR mem; /* holds message storage */ + T_ACI_CMGL_SM sm; + +#ifdef _CONC_TESTING_ +#ifndef NTRACE + char trcBuf[80]; + char *writeP; + int count; + USHORT offset; + + TRACE_EVENT_P1("cmti:rec_num: %d", mnsms_message_ind->rec_num); + TRACE_EVENT_P1("cmti:status: %d", mnsms_message_ind->status); + offset = mnsms_message_ind->sms_sdu.o_buf>>3; + writeP = trcBuf; + for (count=offset; count<offset+20; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]); + } + TRACE_EVENT("buf: "); + *writeP = '\0'; + TRACE_EVENT(trcBuf); + + writeP = trcBuf; + for (; count<offset+40; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_message_ind->sms_sdu.buf[count]); + } + *writeP = '\0'; + TRACE_EVENT(trcBuf); +#endif +#endif + + TRACE_FUNCTION ("cmhSMS_SMSMemory ()"); + + cmhSMS_getMemCmh ( mnsms_message_ind->mem_type, &mem ); + + switch (mnsms_message_ind->mem_type) + { + case MEM_ME: + smsShrdPrm.aci_sms_parameter.meUsed++; + break; + case MEM_SM: + smsShrdPrm.aci_sms_parameter.simUsed++; + break; + default: + TRACE_EVENT("wrong memtype"); + return AT_FAIL; + } + +#if defined SMI OR defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + if (cmhSMS_cpyMsgInd ( &sm, mnsms_message_ind ) EQ FALSE) + { + TRACE_EVENT("cmhSMS_SMSMemory ():[ERR] decoding of SMS"); + if (sm.stat NEQ SMS_STAT_Invalid) + { + TRACE_EVENT("cmhSMS_SMSMemory():[ERR] SMS decoding failed, but status not SMS_STAT_Invalid"); + } + } +#endif + + + /* + *----------------------------------------------------------------- + * new message indication + *----------------------------------------------------------------- + */ + + +#if defined FF_MMI_RIV + /* in case of RIV MMI: check if SMBS is enabled for sending also PDU data */ + if(smsShrdPrm.perccmgf_smbs_mode EQ PERC_SMBS_MOD_ENABLE) + { + rAT_PlusCMTPdu (mnsms_message_ind); + } +#endif /* FF_MMI_RIV */ + + R_AT( RAT_CMTI, CMD_SRC_LCL ) (mem, sm.msg_ref, &sm); + + /* If the SMS shared params indicate no valid source interested in + * the SMS indications, the indication is buffered */ /* Issue 25033 */ + if( smsShrdPrm.smsSrcId EQ CMD_SRC_NONE ) + { + T_CNMI_IND ind; + + ind.cmti.mem = mem; + ind.cmti.index = mnsms_message_ind->rec_num; +#ifdef DTI + cmd_addCnmiNtry ( CNMI_CMTI, &ind ); +#endif + } + else + { + for( idx = CMD_SRC_LCL+1; idx < CMD_SRC_MAX; idx++ ) + { +#if defined _SIMULATION_ AND defined _CONC_TESTING_ + /* don't display "+CMT: ..." in simulation if conc testing */ + if (!concShrdPrm.concTesting) +#endif + { + /* don't need the decoded message for Command Interpreter */ + R_AT( RAT_CMTI, idx ) ( mem, mnsms_message_ind->rec_num ); + } + } + } + + return AT_CMPL; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSStatRpt | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to notify the command handler of + the receiving of a SMS-STATUS-REPORT. +*/ +GLOBAL SHORT cmhSMS_SMSStatRpt ( T_MNSMS_STATUS_IND * mnsms_status_ind ) +{ + USHORT idx; /* holds command source id */ + T_ACI_CDS_SM* p_st; + + TRACE_FUNCTION ("cmhSMS_SMSStatRpt ()"); + + +#if defined SMI OR defined MFW OR defined FF_MMI_RIV + ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CDS_SM) ); + p_st = (T_ACI_CDS_SM*)smsShrdPrm.pDecMsg; + cmhSMS_cpyStatInd ( p_st, mnsms_status_ind); +#endif + + + if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus) + smsShrdPrm.cnma_ack_expected = TRUE; + + /* + *----------------------------------------------------------------- + * new message indication + *----------------------------------------------------------------- + */ + { + T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent; + + /* If the SMS shared params indicate no valid source interested in + * the SMS indications, the indication is buffered */ /* Issue 25033 */ + if( smsShrdPrm.smsSrcId EQ CMD_SRC_NONE ) + { + T_CNMI_IND ind; + + memcpy ( &ind.cds, mnsms_status_ind, sizeof ( T_MNSMS_STATUS_IND) ); +#ifdef DTI + cmd_addCnmiNtry ( CNMI_CDS, &ind ); +#endif + } + + for( idx = 0; idx < CMD_SRC_MAX; idx++ ) + { + if (idx EQ CMD_SRC_LCL) + { + #ifdef FF_MMI_RIV + qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode); + if (sms_input_mode EQ CMGF_MOD_Pdu) + { + rAT_PlusCDSPdu (mnsms_status_ind); + } + else + { + R_AT( RAT_CDS, idx ) ( p_st ); + } + #else + R_AT( RAT_CDS, idx ) ( p_st ); + #endif + } + else + { + R_AT( RAT_CDS, idx ) ( mnsms_status_ind ); + } + + } + } + + if (smsShrdPrm.pDecMsg) + { + ACI_MFREE(smsShrdPrm.pDecMsg); + smsShrdPrm.pDecMsg = NULL; + } + + return 0; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_cpyLstData | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to copy the data read from memory. + It sends a notification using the callback mechanism of + ACI if necessary. +*/ +GLOBAL void cmhSMS_cpyLstData ( T_ACI_AT_CMD curCmd, + T_ACI_CMD_SRC entOwn, + T_MNSMS_READ_CNF * mnsms_read_cnf ) +{ + SHORT nextIdx; /* index of next short message */ + + TRACE_FUNCTION ("cmhSMS_cpyLstData ()"); + + nextIdx = mnsms_read_cnf->rec_next; + + if ( entOwn EQ CMD_SRC_LCL) + { +#ifdef FF_MMI_RIV + { + T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent; + + qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode); + if (sms_input_mode EQ CMGF_MOD_Pdu ) + { + if (curCmd EQ AT_CMD_CMGL) + { + rAT_PlusCMGLPdu (mnsms_read_cnf); + } + else if (curCmd EQ AT_CMD_P_CMGL) + { + rAT_PercentCMGLPdu (mnsms_read_cnf); + } + } + else if (curCmd EQ AT_CMD_CMGL) + { + R_AT ( RAT_CMGL, entOwn ) ( smsShrdPrm.pDecMsg ); + } + else if (curCmd EQ AT_CMD_P_CMGL) + { + R_AT ( RAT_P_CMGL, entOwn ) ( smsShrdPrm.pDecMsg ); + } + } +#else + if (curCmd EQ AT_CMD_CMGL) + { + R_AT ( RAT_CMGL, entOwn ) ( smsShrdPrm.pDecMsg ); + } + else if (curCmd EQ AT_CMD_P_CMGL) + { + R_AT ( RAT_P_CMGL, entOwn ) ( smsShrdPrm.pDecMsg ); + } + +#endif + } + else if (curCmd EQ AT_CMD_CMGL) + { + R_AT ( RAT_CMGL, entOwn ) ( mnsms_read_cnf ); + /* inform BMI */ + cmh_logRslt ( entOwn, RAT_OK, AT_CMD_CMGL, mnsms_read_cnf->rec_num, -1, -1 ); + } + else if (curCmd EQ AT_CMD_P_CMGL) + { + /* the message shall not be displayed for ReadMode as Status Change */ + if (smsShrdPrm.rdMode NEQ SMS_READ_StatusChange) + { + R_AT ( RAT_P_CMGL, entOwn ) ( mnsms_read_cnf ); + /* inform BMI */ + cmh_logRslt ( entOwn, RAT_OK, AT_CMD_P_CMGL, mnsms_read_cnf->rec_num, -1, -1 ); + } + } + + if (nextIdx NEQ SMS_RECORD_NOT_EXIST) + { + /* + *----------------------------------------------------------- + * request the next list elements of given cmglStat state + *----------------------------------------------------------- + */ + psaSMS_ReadReq ( smsShrdPrm.mem1, nextIdx, + smsShrdPrm.rdMode, cmglStat ); + } + else + { + /* + *----------------------------------------------------------- + * no more messages are available + *----------------------------------------------------------- + */ + + /* reset the command context */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + R_AT ( RAT_OK, entOwn ) ( curCmd ); + } +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMReadCMSS | ++-------------------------------------------------------------------+ + + PURPOSE : This function processes the mnsms_read_cnf which was + triggered by +CMSS. +*/ +GLOBAL void cmhSMS_SMReadCMSS ( T_MNSMS_READ_CNF * mnsms_read_cnf) +{ + T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ + UBYTE srcId; + UBYTE fo; + T_ACI_CMGL_SM *p_sm; + T_tp_da da_addr; + T_ACI_RETURN ret=AT_CMPL; + UBYTE modify=SMS_MODIFY_NON; + +#ifdef _CONC_TESTING_ + char trcBuf[80]; + char *writeP; + int count; +#endif + + TRACE_FUNCTION ("cmhSMS_SMReadCMSS ()"); + + + srcId = smsShrdPrm.smsEntStat.entOwn; + pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; + + if (smsShrdPrm.pDecMsg EQ NULL) + { + ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) ); + p_sm = smsShrdPrm.pDecMsg; + /* decode message */ + cmhSMS_cpyReadCnf ( p_sm, mnsms_read_cnf ); + } + else + p_sm = smsShrdPrm.pDecMsg; + + memset (&da_addr, 0, sizeof(T_tp_da)); + + /* start: check FDN if enabled */ + if (pb_get_fdn_mode () EQ FDN_ENABLE AND + pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms ) + { + + TRACE_EVENT_P1("cmhSMS_SMReadCMSS: FDN check: %s", p_sm->adress ); + + if (pb_check_fdn (0, (const UBYTE*) p_sm->adress) EQ PHB_OK) + { + TRACE_EVENT("cmhSMS_SMReadCMSS: Found match in FDN!"); + } + else + { + TRACE_EVENT("cmhSMS_SMReadCMSS: No match in FDN found, SMS rejected!"); + /* error notification */ + R_AT( RAT_CMS, smsShrdPrm.smsEntStat.entOwn ) + ( smsShrdPrm.smsEntStat.curCmd, CMS_ERR_OpNotAllowed, NULL ); + /* release context */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = CMD_SRC_NONE; + return; + } + } + /* end: check FDN if enabled */ + + /* + * ACI-SPR-17004: set RFU bits of status to 0 if present since these + * should be ignored in a GSM session (GSM 11.11 section 9.3) + */ + cmhSMS_removeStatusRFUBits( &mnsms_read_cnf->status ); + + ACI_MALLOC(smsShrdPrm.tpdu.tp_submit, sizeof(T_TP_SUBMIT)); + + /* SMS-SUBMIT received */ + if ((mnsms_read_cnf->status EQ SMS_RECORD_STO_UNSENT) OR + (mnsms_read_cnf->status EQ SMS_RECORD_STO_SENT) OR + (mnsms_read_cnf->status EQ SMS_RECORD_STAT_UNRCVD) OR + (mnsms_read_cnf->status EQ SMS_RECORD_STAT_UNSTRD) OR + (mnsms_read_cnf->status EQ SMS_RECORD_STAT_STRD) ) + { + + /* destination address from stored message */ + if (p_sm->adress[0] NEQ '\0') + { + cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, MAX_SMS_ADDR_DIG, p_sm->adress); + da_addr.ton = p_sm->toa.ton; + da_addr.npi = p_sm->toa.npi; + da_addr.digits = da_addr.c_num; + } + + /* service center address from shared parameter */ + if (pSMSSetPrm->sca.c_num NEQ 0) + { + memcpy (&smsShrdPrm.tpdu.sc_addr, &pSMSSetPrm->sca, sizeof(T_rp_addr)); + modify |= SMS_MODIFY_SCA; + + } + + /* ACI-SPR-22528.The memory is allocated for smsShrdPrm.tpdu.tp_submit + only when it is necessary*/ + + + cmhSMS_fillTpSubmit (smsShrdPrm.tpdu.tp_submit, + srcId, + 0, /* fo */ + 0, + &da_addr, + NULL, + 0, + NULL ); + } + else + { + /* SMS-DELIVER received */ + + T_ACI_SM_DATA packedData; + UBYTE byte_offset=0; + + /* service center address from shared parameter */ + if (pSMSSetPrm->sca.c_num NEQ 0) + { + memcpy (&smsShrdPrm.tpdu.sc_addr, &pSMSSetPrm->sca, sizeof(T_rp_addr)); + } + else + { + if (p_sm->sca[0] NEQ '\0') + { + cmhSMS_getAdrBcd( smsShrdPrm.tpdu.sc_addr.num, + &smsShrdPrm.tpdu.sc_addr.c_num, + MAX_SMS_ADDR_DIG, p_sm->sca); + smsShrdPrm.tpdu.sc_addr.ton = p_sm->tosca.ton; + smsShrdPrm.tpdu.sc_addr.npi = p_sm->tosca.npi; + smsShrdPrm.tpdu.sc_addr.v_ton = TRUE; + smsShrdPrm.tpdu.sc_addr.v_npi = TRUE; + } + } + + fo = (pSMSSetPrm->msgType & (~TP_MTI_MASK)) | TP_MTI_SMS_SUBMIT; + + if (p_sm->udh.len) + byte_offset = p_sm->udh.len+1; + + /* ACI-SPR-22528.The memory is allocated for smsShrdPrm.tpdu.tp_submit + only when it is necessary*/ + + cmhSMS_rdcSmsPp ( byte_offset, + p_sm -> dcs, + ( UBYTE * ) p_sm->data.data, ( UBYTE ) p_sm->data.len, + packedData.data, &packedData.len); + + if (p_sm->adress[0] NEQ '\0') + { + cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, MAX_SMS_ADDR_DIG, p_sm->adress); + da_addr.ton = p_sm->toa.ton; + da_addr.npi = p_sm->toa.npi; + da_addr.digits = da_addr.c_num; + } + + cmhSMS_fillTpSubmit (smsShrdPrm.tpdu.tp_submit, + srcId, + fo, + 0, + &da_addr, + &packedData, + p_sm->data.len, + &p_sm->udh ); + + modify = SMS_MODIFY_ALL; + } + + { + PALLOC (mnsms_submit_req, MNSMS_SUBMIT_REQ); + mnsms_submit_req->rec_num = mnsms_read_cnf->rec_num; + mnsms_submit_req->mem_type = smsShrdPrm.mem2; + mnsms_submit_req->condx = SMS_CONDX_OVR_ANY; + mnsms_submit_req->modify = modify; + +#ifdef SIM_TOOLKIT + if (psaSIM_ChkSIMSrvSup( SRV_MOSMCtrlSIM )) + { + if (simShrdPrm.setPrm[srcId].sat_cc_mode EQ SATCC_CONTROL_BY_SIM_ACTIVE) + { + ret = cmhSAT_MoSmCntr( smsShrdPrm.tpdu.sc_addr, + da_addr, + srcId); + } + else + { + simShrdPrm.setPrm[srcId].sat_cc_mode = SATCC_CONTROL_BY_SIM_ACTIVE; + } + + } + + if (ret NEQ AT_CMPL) + { + /* save primitive address for SIM_TOOLKIT response */ + sat_mnsms_submit_req = mnsms_submit_req; + return; + } +#endif + /* code SMS-SUBMIT here */ + cmhSMS_codeMsg (&mnsms_submit_req->sms_sdu, SMS_VT_SUBMIT, + &smsShrdPrm.tpdu.sc_addr, SMS_SUBMIT, + (UBYTE*)smsShrdPrm.tpdu.tp_submit); + + PSENDX (SMS, mnsms_submit_req); +#ifdef _CONC_TESTING_ +#ifndef NTRACE + writeP = trcBuf; + for (count=0; count<20; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_submit_req->sms_sdu.buf[count]); + } + TRACE_EVENT("buf: "); + *writeP = '\0'; + TRACE_EVENT(trcBuf); + + writeP = trcBuf; + for (; count<40; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_submit_req->sms_sdu.buf[count]); + } + *writeP = '\0'; + TRACE_EVENT(trcBuf); +#endif +#endif + if (smsShrdPrm.tpdu.tp_submit NEQ NULL) + { + ACI_MFREE(smsShrdPrm.tpdu.tp_submit); + smsShrdPrm.tpdu.tp_submit = NULL; + } + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMRead | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to notify the command handler of + a successfull reading of a short message from preferred + message storage. +*/ +#ifndef NTRACE +LOCAL void trace_read_sms( T_MNSMS_READ_CNF * mnsms_read_cnf) +{ + char trcBuf[80]; + char *writeP; + int count; + + TRACE_FUNCTION ("trace_read_sms ()"); + + TRACE_EVENT_P1(" rec_num: %u", mnsms_read_cnf->rec_num); + TRACE_EVENT_P1(" rec_next: %u", mnsms_read_cnf->rec_next); + TRACE_EVENT_P1(" rec_max: %u", mnsms_read_cnf->rec_max); + TRACE_EVENT_P1(" status %u", mnsms_read_cnf->status); + TRACE_EVENT_P1(" cause 0x%04x", mnsms_read_cnf->cause); + writeP = trcBuf; + for (count=0; count<20; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_read_cnf->sms_sdu.buf[count]); + } + TRACE_EVENT("buf: "); + *writeP = '\0'; + TRACE_EVENT(trcBuf); + + writeP = trcBuf; + for (; count<40; count++) + { + writeP += sprintf (writeP, " %02X", mnsms_read_cnf->sms_sdu.buf[count]); + } + *writeP = '\0'; + TRACE_EVENT(trcBuf); +} +#endif + + + +GLOBAL SHORT cmhSMS_SMRead ( T_MNSMS_READ_CNF * mnsms_read_cnf) +{ + T_ACI_AT_CMD cmdBuf; /* buffers current command */ + T_ACI_CMD_SRC ownBuf; /* buffers current owner */ + T_ACI_CMGL_SM *p_sm; + T_rp_addr rp_addr; + UBYTE* message; + T_TP_DELIVER *sms_deliver, decoded_mesg; + BOOL retCode = FALSE; + UBYTE msg_type; + + TRACE_FUNCTION ("cmhSMS_SMRead ()"); + +#ifndef NTRACE + trace_read_sms(mnsms_read_cnf); +#endif + + cmdBuf = smsShrdPrm.smsEntStat.curCmd; + ownBuf = smsShrdPrm.smsEntStat.entOwn; + + /* (SIM) error occurred */ + if (!IS_CAUSE_INVALID(mnsms_read_cnf->cause)) + { + if (mnsms_read_cnf->cause NEQ SMS_NO_ERROR) + { + /* reset the command context */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + if( ownBuf NEQ CMD_SRC_LCL OR cmdBuf NEQ AT_CMD_P_CMGMDU ) + { + R_AT ( RAT_CMS, ownBuf ) + ( + cmdBuf, + cmhSMS_GetCmsFromSms(mnsms_read_cnf->cause), + NULL + ); + } + return 1; + } + } + +#ifdef _CONC_TESTING_ + /* this is only for testing */ + SET_OWNBUF_CONC; +#endif + + /* + *----------------------------------------------------------------- + * ignore primitives with incorrect message status + *----------------------------------------------------------------- + */ + TRACE_EVENT_P1("mnsms_read_cnf->status: %d", mnsms_read_cnf->status); + + if ( (mnsms_read_cnf->status EQ SMS_RECORD_FREE) OR + (mnsms_read_cnf->status EQ SMS_RECORD_INVALID) ) + { + /* reset the command context */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + TRACE_EVENT("incorrect message status"); + return 1; + } + + /* always decode for local source */ + if (ownBuf EQ CMD_SRC_LCL) /* ACI-SPR-9528 */ + { /* pass dummy p_sm to CB */ + if (((cmdBuf EQ AT_CMD_CMGL OR cmdBuf EQ AT_CMD_CMGR) OR + (cmdBuf EQ AT_CMD_P_CMGR OR cmdBuf EQ AT_CMD_P_CMGL)) + AND smsShrdPrm.rdMode NEQ READ_STATUS_CHANGE) /* ACI-FIX-9510 */ + { + retCode = cmhSMS_SMSQueryType (&mnsms_read_cnf->sms_sdu, &msg_type); + if (retCode EQ FALSE) + { + /* reset the command context */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + TRACE_EVENT("Error decoding message type"); + return 1; + } + ACI_MALLOC(smsShrdPrm.pDecMsg, sizeof(T_ACI_CMGL_SM) ); + memset(smsShrdPrm.pDecMsg,0,sizeof(T_ACI_CMGL_SM) ); + p_sm = smsShrdPrm.pDecMsg; + if (msg_type EQ TP_MTI_SMS_STATUS_REP) + { + retCode=cmhSMS_cpySTtoSM(p_sm ,mnsms_read_cnf); + } + else + { + retCode = cmhSMS_cpyReadCnf ( p_sm, mnsms_read_cnf ); + } + if (retCode EQ FALSE) + { + TRACE_EVENT("cmhSMS_SMRead ():[ERR] decoding of SMS"); + cmhSMS_invalidSMS_notification_to_user (mnsms_read_cnf); + + ACI_MFREE(smsShrdPrm.pDecMsg); + + /* reset the command context */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + smsShrdPrm.pDecMsg = NULL; + if (mnsms_read_cnf->rec_next EQ SMS_RECORD_NOT_EXIST) + { + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + if( cmdBuf NEQ AT_CMD_P_CMGMDU ) + { + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + } + } + return 1; + } + } + } + else + p_sm = smsShrdPrm.pDecMsg; + + /* + *----------------------------------------------------------------- + * check for command context + *----------------------------------------------------------------- + */ + switch( smsShrdPrm.smsEntStat.curCmd ) + { + case ( AT_CMD_CMGR ): + case ( AT_CMD_P_CMGR ): + { + /* + *------------------------------------------------------------- + * process event for +CGMR + *------------------------------------------------------------- + */ + + /* reset the command context */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + /* The message need not be displayed for Status Change */ + if (cmdBuf EQ AT_CMD_P_CMGR + AND smsShrdPrm.rdMode EQ READ_STATUS_CHANGE) + { + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + /* inform BMI */ + cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_P_CMGR, mnsms_read_cnf->rec_num, -1, -1 ); + break; + } + + +#if defined MFW OR defined FF_MMI_RIV OR defined _CONC_TESTING_ + if (ownBuf EQ CMD_SRC_LCL) /* AND /* ACI-FIX-9510 */ + /* smsShrdPrm.rdMode NEQ READ_STATUS_CHANGE) */ /* call rplyCB (with invalid p_sm) anyway + to touch all segments while in + READ_STATUS_CHANGE */ + { +#if defined FF_MMI_RIV + T_ACI_CMGF_MOD sms_input_mode = CMGF_MOD_NotPresent; + qAT_PlusCMGF (CMD_SRC_LCL, &sms_input_mode); + if (sms_input_mode EQ CMGF_MOD_Pdu ) + { + if (cmdBuf EQ AT_CMD_CMGR ) + { + rAT_PlusCMGRPdu (mnsms_read_cnf); + } + else if (cmdBuf EQ AT_CMD_P_CMGR ) + { + rAT_PercentCMGRPdu (mnsms_read_cnf); + } + } + else + { + if (smsShrdPrm.rplyCB.cmgr NEQ NULL) + { + smsShrdPrm.rplyCB.cmgr( p_sm, NULL ); + } + } + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); +#else + /* GPF-MMI */ + if (smsShrdPrm.rplyCB.cmgr NEQ NULL) + { + smsShrdPrm.rplyCB.cmgr( p_sm, NULL ); + } + if (!ISSET_CONC) + { + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + } +#endif + } + else /* if (ownBuf EQ CMD_SRC_LCL) */ +#endif /*#if defined MFW OR defined FF_MMI_RIV*/ + { + if (cmdBuf EQ AT_CMD_CMGR ) + { + R_AT ( RAT_CMGR, ownBuf ) ( mnsms_read_cnf, NULL ); + } + else if (cmdBuf EQ AT_CMD_P_CMGR ) + { + R_AT ( RAT_P_CMGR, ownBuf ) ( mnsms_read_cnf, NULL ); + } + + R_AT ( RAT_OK, ownBuf ) ( cmdBuf ); + /* inform BMI */ + cmh_logRslt ( ownBuf, RAT_OK, AT_CMD_CMGR, mnsms_read_cnf->rec_num, -1, -1 ); + } + + break; + } + + case ( AT_CMD_P_CMGL ): + case ( AT_CMD_CMGL ): + { + /* + *------------------------------------------------------------- + * process event for +CMGL + *------------------------------------------------------------- + */ + cmhSMS_cpyLstData ( cmdBuf, ownBuf, mnsms_read_cnf ); + + break; + } + + case ( AT_CMD_P_CMGMDU ): + { + /* + *------------------------------------------------------------- + * process event for %CMGMDU + *------------------------------------------------------------- + */ + message = cmhSMS_decodeMsg(&mnsms_read_cnf->sms_sdu, &rp_addr, SMS_VT_DELIVER); + sms_deliver = (T_TP_DELIVER*)message; + sms_deliver->tp_rp = 0; + memcpy(&decoded_mesg, sms_deliver, sizeof(T_TP_DELIVER)); + + { + PALLOC (mnsms_store_req, MNSMS_STORE_REQ); + + mnsms_store_req -> mem_type = smsShrdPrm.mem1; + mnsms_store_req -> condx = SMS_CONDX_OVR_ANY; + mnsms_store_req -> rec_num = mnsms_read_cnf->rec_num; + mnsms_store_req -> status = mnsms_read_cnf->status; + + cmhSMS_codeMsg ( &mnsms_store_req->sms_sdu, + SMS_VT_DELIVER, + &rp_addr, + SMS_DELIVER, + (UBYTE*) &decoded_mesg); + + PSENDX (SMS, mnsms_store_req); + } + break; + } +#if defined (SIM_TOOLKIT) + case ( AT_CMD_CMSS ): + { + /* + *------------------------------------------------------------- + * process event for +CMSS (only for SAT) + *------------------------------------------------------------- + */ + cmhSMS_SMReadCMSS (mnsms_read_cnf); + + break; + } +#endif + + default: + { + TRACE_EVENT("error in command context"); + } + } + + if (smsShrdPrm.pDecMsg) + { + ACI_MFREE(smsShrdPrm.pDecMsg); + smsShrdPrm.pDecMsg = NULL; + } + + return 0; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_Result | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to notify the command handler of + a successfull transaction concerning the short message + service. +*/ +GLOBAL SHORT cmhSMS_Result ( T_MNSMS_REPORT_IND * mnsms_report_ind ) +{ + T_ACI_AT_CMD cmdBuf; /* buffers current command */ + T_ACI_CMD_SRC ownBuf; /* buffers current owner */ + + + TRACE_FUNCTION ("cmhSMS_Result ()"); + + if (mnsms_report_ind->v_cmms_mode) + { + smsShrdPrm.CMMSmode = mnsms_report_ind->cmms_mode; + return 0; + } + + cmdBuf = AT_CMD_NONE; + ownBuf = CMD_SRC_LCL; + + smsShrdPrm.smsStat = mnsms_report_ind->state; + + + if (mnsms_report_ind->state EQ SMS_STATE_READY) + { + /* reading of SMs from SIM is completed, + * read SMSP, CBMIR, CMBI fields now + */ + if (cmhSMS_ReadParams (NO_VLD_OWN, AT_CMD_CFUN, 1) NEQ AT_EXCT) + { + cmhSMS_ready (); + } + R_AT ( RAT_SIG_SMS, ownBuf ) ( SMS_STATE_READY ); + } + else if (mnsms_report_ind->state EQ SMS_STATE_INITIALISING) + { + { /*ACI-FIX-18055 resetting total and used storage counters of SIM and ME storages which will be updated by cmhSMS_SMSInitState */ + smsShrdPrm.aci_sms_parameter.simTotal = 0; + smsShrdPrm.aci_sms_parameter.simUsed = 0; + smsShrdPrm.aci_sms_parameter.meTotal = 0; + smsShrdPrm.aci_sms_parameter.meUsed = 0; + } /*ACI-FIX-18055 Changes end here */ + R_AT ( RAT_SIG_SMS, ownBuf ) ( SMS_STATE_INITIALISING ); + } + else if (mnsms_report_ind->state > SMS_STATE_INITIALISING) + { + R_AT ( RAT_CMS, ownBuf ) ( cmdBuf, CMS_ERR_UnknownErr, NULL ); + } + + return 0; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_WrCnfCSAS | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to notify the command handler of + the usage of SIM and ME memory. +*/ +GLOBAL void cmhSMS_WrCnfCSAS (SHORT aId) +{ + T_ACI_AT_CMD cmdBuf; /* buffers current command */ + T_ACI_CMD_SRC ownBuf; /* buffers current owner */ + USHORT errCode; + USHORT dataField = 0xFF; + UBYTE dataLen = 0; + UBYTE data[MAX_SIM_CMD]; + + TRACE_FUNCTION ("cmhSMS_WrCnfCSAS ()"); + + cmdBuf = smsShrdPrm.smsEntStat.curCmd; + ownBuf = smsShrdPrm.smsEntStat.entOwn; + + /* + *----------------------------------------------------------------- + * check for next SIM access + *----------------------------------------------------------------- + */ + switch (smsShrdPrm.prmRdSeq) + { + case SMS_READ_SIM_SMSP: /* EF(SMSP) written */ + errCode = simShrdPrm.atb[aId].errCode; + + if (smsShrdPrm.cbmPrm.cbmSIMmaxIdRge > 0 AND + cmhSMS_PutCbmirSIM (ownBuf, data, + (int)smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4)) /* write CBMIR */ + { + dataField = SIM_CBMIR; + dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4; + break; + } + else + smsShrdPrm.prmRdSeq--; + + if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0 AND + cmhSMS_PutCbmiSIM (ownBuf, data, + (int)smsShrdPrm.cbmPrm.cbmSIMmaxId * 2)) /* write CBMI */ + { + dataField = SIM_CBMI; + dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxId * 2; + } + else /* nothing else to write */ + { + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; + } + break; + + case SMS_READ_SIM_CBMIR: /* CBMIR written */ + errCode = simShrdPrm.atb[aId].errCode; + + if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0 AND /* write CBMI */ + cmhSMS_PutCbmiSIM (ownBuf, data, + (int)smsShrdPrm.cbmPrm.cbmSIMmaxId * 2)) + { + dataField = SIM_CBMI; + dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxId * 2; + } + else /* nothing else to write */ + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; + break; + + case SMS_READ_SIM_CBMI: /* CBMI written */ + errCode = simShrdPrm.atb[aId].errCode; + + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; /* nothing else to write */ + break; + + default: /* nothing else to write */ + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; + errCode = SIM_CAUSE_OTHER_ERROR; + break; + } + if ( smsShrdPrm.prmRdSeq EQ SMS_READ_SIM_CMPL) + { + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + if (errCode EQ SIM_NO_ERROR) + { + R_AT( RAT_OK, ownBuf ) ( cmdBuf ); + } + else + { + R_AT( RAT_CMS, ownBuf ) /* unsuccessful SIM write */ + ( + cmdBuf, + cmhSMS_GetCmsFromSim ( errCode ), + NULL + ); + } + } + else + { + if (cmhSIM_WriteTranspEF (CMD_SRC_NONE, cmdBuf, + dataField, 0, dataLen, + data, cmhSMS_WrCnfCSAS) EQ AT_FAIL) + { + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; + + R_AT( RAT_CMS, ownBuf ) ( cmdBuf, CMS_ERR_UnknownErr, NULL ); + } + else + smsShrdPrm.prmRdSeq--; + } + + simShrdPrm.atb[aId].ntryUsdFlg = FALSE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_RdCnfCRES | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to notify the command handler of + the usage of SIM and ME memory. +*/ +GLOBAL void cmhSMS_RdCnfCRES (SHORT aId) +{ + T_ACI_AT_CMD cmdBuf; /* buffers current command */ + T_ACI_CMD_SRC ownBuf; /* buffers current owner */ + + USHORT errCode; + USHORT dataField = 0xFF; + UBYTE dataLen = 0; + UBYTE profile; + + TRACE_FUNCTION ("cmhSMS_RdCnfCRES ()"); + + cmdBuf = smsShrdPrm.smsEntStat.curCmd; + ownBuf = smsShrdPrm.smsEntStat.entOwn; + + /* + *----------------------------------------------------------------- + * check for next SIM access + *----------------------------------------------------------------- + */ + switch (smsShrdPrm.prmRdSeq) + { + case SMS_READ_SIM_SMSP: + if ((errCode = simShrdPrm.atb[aId].errCode) EQ SIM_NO_ERROR) + { + /* successful EF(SMSP) read */ + + profile = simShrdPrm.atb[aId].recNr; + + if (!cmhSMS_GetPrmSIM (ownBuf, + simShrdPrm.atb[aId].exchData, + simShrdPrm.atb[aId].dataLen)) + { + errCode = SIM_CAUSE_OTHER_ERROR; + } + } + if (smsShrdPrm.cbmPrm.cbmSIMmaxIdRge > 0) + { + dataField = SIM_CBMIR; + dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4; + break; + } + else + smsShrdPrm.prmRdSeq--; + + if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0) + { + dataField = SIM_CBMI; + dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxId * 2; + break; + } + else + smsShrdPrm.prmRdSeq--; + + smsShrdPrm.cbmPrm.cbchOwner = ownBuf; + psaMMI_Cbch(); + smsShrdPrm.cbmPrm.cbchOwner = OWN_NONE; + +#ifdef SIM_TOOLKIT + smsShrdPrm.prmRdSeq--; /* when SAT is on, then SMS_READ_CBMID is defined + which is irrelevant for +CRES */ +#endif /* of SIM_TOOLKIT */ + + break; + + case SMS_READ_SIM_CBMIR: + if ((errCode = simShrdPrm.atb[aId].errCode) EQ SIM_NO_ERROR) + { /* successful EF(CBMIR) read */ + if (!cmhSMS_GetCbmirSIM (ownBuf, + simShrdPrm.atb[aId].exchData, + simShrdPrm.atb[aId].dataLen)) + { + errCode = SIM_CAUSE_OTHER_ERROR; + } + } + if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0) + { + dataField = SIM_CBMI; + dataLen = smsShrdPrm.cbmPrm.cbmSIMmaxId * 2; + } + else + { + smsShrdPrm.prmRdSeq--; + + smsShrdPrm.cbmPrm.cbchOwner = ownBuf; + psaMMI_Cbch(); + smsShrdPrm.cbmPrm.cbchOwner = OWN_NONE; + +#ifdef SIM_TOOLKIT + smsShrdPrm.prmRdSeq--; /* when SAT is on, then SMS_READ_CBMID is defined + which is irrelevant for +CRES */ +#endif /* of SIM_TOOLKIT */ + + } + break; + + case SMS_READ_SIM_CBMI: + if ((errCode = simShrdPrm.atb[aId].errCode) EQ SIM_NO_ERROR) + { /* successful EF(CBMI) read */ + if (!cmhSMS_GetCbmiSIM (ownBuf, + simShrdPrm.atb[aId].exchData, + simShrdPrm.atb[aId].dataLen)) + { + errCode = SIM_CAUSE_OTHER_ERROR; + } + } + smsShrdPrm.cbmPrm.cbchOwner = ownBuf; + psaMMI_Cbch(); + smsShrdPrm.cbmPrm.cbchOwner = OWN_NONE; + +#ifdef SIM_TOOLKIT + smsShrdPrm.prmRdSeq--; /* when SAT is on, then SMS_READ_CBMID is defined + which is irrelevant for +CRES */ +#endif /* of SIM_TOOLKIT */ + + break; + + default: + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; + errCode = SIM_CAUSE_OTHER_ERROR; + break; + } + if (--smsShrdPrm.prmRdSeq <= SMS_READ_SIM_CMPL) + { + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + if (errCode EQ SIM_NO_ERROR) + { + R_AT( RAT_OK, ownBuf ) ( cmdBuf ); + } + else + { + R_AT( RAT_CMS, ownBuf ) /* unsuccessful SIM read */ + ( + cmdBuf, + cmhSMS_GetCmsFromSim ( errCode ), + NULL + ); + } + } + else + if (cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmdBuf, + dataField, 0, dataLen, + NULL, cmhSMS_RdCnfCRES) EQ AT_FAIL) + { + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; + + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; + +#ifdef SIM_TOOLKIT + if (ownBuf EQ OWN_SAT /*smsShrdPrm.fuRef >= 0*/) + { + psaSAT_FUConfirm ((int)simShrdPrm.fuRef, SIM_FU_ERROR); + } + else + { +#endif + R_AT( RAT_CMS, ownBuf ) ( cmdBuf, CMS_ERR_UnknownErr, NULL ); +#ifdef SIM_TOOLKIT + } +#endif + } + + simShrdPrm.atb[aId].ntryUsdFlg = FALSE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_InitSMSP | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to store the parameters of EF(SMSP). +*/ +GLOBAL void cmhSMS_InitSMSP (SHORT aId) +{ + T_ACI_CMD_SRC srcId; + T_SMS_SET_PRM * elem ; /* points to SMS parameter set */ + UBYTE idx; + UBYTE profile; + + TRACE_FUNCTION ("cmhSMS_InitSMSP ()"); + + /* + *----------------------------------------------------------------- + * process SIM result + *----------------------------------------------------------------- + */ + srcId = smsShrdPrm.owner; + + switch (smsShrdPrm.prmRdSeq) + { + case SMS_READ_SIM_SMSP: + if (simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR) + { /* successful EF(SMSP) read */ + smsShrdPrm.aci_sms_parameter.smsParamMaxRec = simShrdPrm.atb[aId].recMax; + smsShrdPrm.aci_sms_parameter.smsParamRecLen = simShrdPrm.atb[aId].dataLen; + + if (set_prm_list EQ NULL) + { + set_prm_list = new_list(); + } + profile = simShrdPrm.atb[aId].recNr; + elem = find_element(set_prm_list, profile, cmhSMS_findPrflId); + + if (elem EQ NULL) + { + ACI_MALLOC(elem, sizeof(T_SMS_SET_PRM)); + memset(elem, 0, sizeof(T_SMS_SET_PRM)); + insert_list(set_prm_list, elem); + elem->prflId = profile; + elem->numOfRefs = OWN_MAX; + for( idx = 0; idx < OWN_MAX; idx++ ) + { + smsShrdPrm.pSetPrm[idx] = (T_SMS_SET_PRM*) elem; + } + + } + else + { + smsShrdPrm.pSetPrm[0] = (T_SMS_SET_PRM*) elem; + } + + cmhSMS_GetPrmSIM (0, + simShrdPrm.atb[aId].exchData, + simShrdPrm.atb[aId].dataLen); + } + else + { + smsShrdPrm.aci_sms_parameter.smsParamMaxRec = 0; + smsShrdPrm.aci_sms_parameter.smsParamRecLen = 0; + } + if( !psaSIM_ChkSIMSrvSup( SRV_CBMIdRnge )) + { + smsShrdPrm.prmRdSeq--; + goto CBMIR; + } + if (cmhSIM_ReadTranspEF (CMD_SRC_NONE, smsShrdPrm.smsEntStat.curCmd, + SIM_CBMIR, 0, 255, + NULL, cmhSMS_InitSMSP) NEQ AT_FAIL) + smsShrdPrm.prmRdSeq--; + else + { + goto CBMIR; + } + break; + + case SMS_READ_SIM_CBMIR: + if (simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR) + { + smsShrdPrm.cbmPrm.cbmSIMmaxIdRge = simShrdPrm.atb[aId].dataLen / 4; + cmhSMS_GetCbmirSIM (CMD_SRC_NONE, + simShrdPrm.atb[aId].exchData, + simShrdPrm.atb[aId].dataLen); + } + else + smsShrdPrm.cbmPrm.cbmSIMmaxIdRge = 0; + + CBMIR: + if( !psaSIM_ChkSIMSrvSup( SRV_CBM_Ident )) + { + smsShrdPrm.prmRdSeq--; + goto CBMI; + } + if (cmhSIM_ReadTranspEF (CMD_SRC_NONE, smsShrdPrm.smsEntStat.curCmd, + SIM_CBMI, 0, 255, + NULL, cmhSMS_InitSMSP) NEQ AT_FAIL) + smsShrdPrm.prmRdSeq--; + else + { +#ifdef SIM_TOOLKIT + goto CBMI; +#else + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; + + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = simShrdPrm.owner = OWN_NONE; +#endif /* of SIM_TOOLKIT */ + } + break; + + case SMS_READ_SIM_CBMI: + if (simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR) + { + smsShrdPrm.cbmPrm.cbmSIMmaxId = simShrdPrm.atb[aId].dataLen / 2; + cmhSMS_GetCbmiSIM (CMD_SRC_NONE, + simShrdPrm.atb[aId].exchData, + simShrdPrm.atb[aId].dataLen); + } + else + smsShrdPrm.cbmPrm.cbmSIMmaxId = 0; + +#ifdef SIM_TOOLKIT + CBMI: + if( (!psaSIM_ChkSIMSrvSup( SRV_DtaDownlCB )) OR + smsShrdPrm.owner NEQ OWN_SAT) + { + smsShrdPrm.prmRdSeq--; + goto CBMID; + } + if (cmhSIM_ReadTranspEF (CMD_SRC_NONE, smsShrdPrm.smsEntStat.curCmd, + SIM_CBMID, 0, 255, + NULL, cmhSMS_InitSMSP) NEQ AT_FAIL) + smsShrdPrm.prmRdSeq--; + else + { + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; + + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = simShrdPrm.owner = OWN_NONE; + } + break; + + case SMS_READ_SIM_CBMID: + if (simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR) + { + smsShrdPrm.cbmPrm.cbmSIMmaxSATId = simShrdPrm.atb[aId].dataLen / 2; + cmhSMS_GetCbDtaDwnlSIM (CMD_SRC_NONE, + simShrdPrm.atb[aId].exchData, + simShrdPrm.atb[aId].dataLen); + { + PALLOC (sat_cbch_req, MMI_SAT_CBCH_DWNLD_REQ); + + sat_cbch_req->count = (USHORT)smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds; + memset (sat_cbch_req->msg_id, NOT_PRESENT_16BIT, + sizeof (sat_cbch_req->msg_id)); + memcpy (sat_cbch_req->msg_id, smsShrdPrm.cbmPrm.CBDtaDwnlIdent, + (size_t)smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds * 2); + + PSENDX (PL, sat_cbch_req); + } + } + else + smsShrdPrm.cbmPrm.cbmSIMmaxSATId = 0; + + default: + CBMID: + +#else + /*lint -fallthrough*/ + default: + CBMI: +#endif /*SIM_TOOLKIT */ + + smsShrdPrm.cbmPrm.cbchOwner = srcId; + psaMMI_Cbch(); + smsShrdPrm.cbmPrm.cbchOwner = OWN_NONE; + { + smsShrdPrm.prmRdSeq = SMS_READ_SIM_CMPL; + + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = simShrdPrm.owner = OWN_NONE; + } +#ifdef SIM_TOOLKIT + if (srcId EQ OWN_SAT /*smsShrdPrm.fuRef >= 0*/) + { + smsShrdPrm.accessEnabled = TRUE; + psaSAT_FUConfirm (simShrdPrm.fuRef,(USHORT) + ((simShrdPrm.atb[aId].errCode EQ SIM_NO_ERROR)? + SIM_FU_SUCC_ADD: SIM_FU_ERROR)); + } + else +#endif + cmhSMS_ready (); + break; + } + + simShrdPrm.atb[aId].ntryUsdFlg = FALSE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSResumeCnf | ++-------------------------------------------------------------------+ + + PURPOSE : This function processes the MNSMS_RESUME_CNF primitive. + +*/ +GLOBAL void cmhSMS_SMSResumeCnf (T_MNSMS_RESUME_CNF * mnsms_resume_cnf) +{ + UBYTE cmdBuf; + UBYTE ownBuf; + + TRACE_FUNCTION("cmhSMS_ResumeCnf()"); + + cmdBuf = smsShrdPrm.smsEntStat.curCmd; + ownBuf = smsShrdPrm.smsEntStat.entOwn; + + /* check whether resume has been successfully processed */ + if (mnsms_resume_cnf->cause EQ SMS_NO_ERROR) + { + R_AT( RAT_OK, ownBuf ) ( cmdBuf ); + } + else + { + /* command unsuccessful */ + R_AT ( RAT_CMS, ownBuf ) + ( + cmdBuf, + cmhSMS_GetCmsFromSms(mnsms_resume_cnf->cause), + NULL + ); + } + + /* reset command */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSQueryCnf | ++-------------------------------------------------------------------+ + + PURPOSE : This function processes the MNSMS_QUERY_CNF primitive. + +*/ +GLOBAL void cmhSMS_SMSQueryCnf (T_MNSMS_QUERY_CNF * mnsms_query_cnf) +{ + UBYTE cmdBuf; + UBYTE ownBuf; + + TRACE_FUNCTION("cmhSMS_SMSQueryCnf()"); + + cmdBuf = smsShrdPrm.smsEntStat.curCmd; + ownBuf = smsShrdPrm.smsEntStat.entOwn; + + /* check type of query request and process it */ + switch (mnsms_query_cnf->query_type) + { + case SMS_QUERY_DELIVER_STATUS: + { + if ( mnsms_query_cnf->v_deliver_status ) + { + R_AT ( RAT_CPRSM, ownBuf ) + ( cmhSMS_convertDeliverStatusToACI(mnsms_query_cnf->deliver_status ) ); + R_AT( RAT_OK, ownBuf ) ( cmdBuf ); + } + else /* paramter inalid - unspecified protocol error */ + { + TRACE_EVENT("cmhSMS_QueryCnf: ERROR: paramter invalid"); + R_AT ( RAT_CMS, ownBuf )( cmdBuf, CMS_ERR_InValManInfo, NULL ); + } + break; + } + default: /* unsupported query type - ME failure */ + { + TRACE_EVENT("cmhSMS_QueryCnf: ERROR: unsupported query type"); + R_AT ( RAT_CMS, ownBuf )( cmdBuf, CMS_ERR_MeFail, NULL ); + } + } /* end switch */ + + /* reset command */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = OWN_NONE; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_ReadCbDtaDwnl | ++-------------------------------------------------------------------+ + + PURPOSE : This function processes the T_SIM_MMI_INSERT_IND primitive. + +*/ +GLOBAL void cmhSMS_ReadCbDtaDwnl (T_SIM_MMI_INSERT_IND *sim_mmi_insert_ind) +{ + + TRACE_FUNCTION("cmhSMS_ReadCbDtaDwnl()"); + + if (sim_mmi_insert_ind->cbmid_rec.c_rec NEQ 0) + { + smsShrdPrm.cbmPrm.cbmSIMmaxSATId = sim_mmi_insert_ind->cbmid_rec.c_rec / 2; + cmhSMS_GetCbDtaDwnlSIM (CMD_SRC_NONE, + (UBYTE *) sim_mmi_insert_ind->cbmid_rec.rec, + sim_mmi_insert_ind->cbmid_rec.c_rec); + { + PALLOC (sat_cbch_req, MMI_SAT_CBCH_DWNLD_REQ); + + sat_cbch_req->count = (USHORT)smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds; + memset (sat_cbch_req->msg_id, NOT_PRESENT_16BIT, + sizeof (sat_cbch_req->msg_id)); + memcpy (sat_cbch_req->msg_id, smsShrdPrm.cbmPrm.CBDtaDwnlIdent, + (size_t)smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds * 2); + + PSENDX (PL, sat_cbch_req); + } + } + else + { + TRACE_EVENT(" CBMID records zero"); + smsShrdPrm.cbmPrm.cbmSIMmaxSATId = 0; + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH_SMSR | +| STATE : code ROUTINE : cmhSMS_SMSQueryType | ++-------------------------------------------------------------------+ + + PURPOSE : This function queries the message type of the T_MNSMS_MESSAGE_IND. + +*/ +GLOBAL BOOL cmhSMS_SMSQueryType (T_sms_sdu *sms_sdu, + UBYTE *msg_type) +{ + UBYTE ccdRet; + + TRACE_FUNCTION("cmhSMS_SMSQueryType()"); + + if (sms_sdu->l_buf EQ 0) + { + TRACE_EVENT("empty SDU: no decoding"); + return FALSE; + } + + CCD_START; + { + + MCAST( sim_pdu, SIM_PDU ); /* sim_pdu points to _decodedMsg */ + + /* decoding outer layer */ + ccdRet = ccd_decodeMsg ( CCDENT_SMS, + BOTH /* doesn't work with DOWNLINK!!! */, + (T_MSGBUF *) sms_sdu, + (UBYTE *) _decodedMsg, /* target */ + SMS_VT_SIM_PDU); + + if ((ccdRet NEQ ccdOK) OR (!sim_pdu->v_tpdu) + OR (_decodedMsg[0] NEQ SMS_VT_SIM_PDU)) + { + TRACE_EVENT_P1("CCD Decoding Error: %d", ccdRet); + CCD_END; + return FALSE; + } + *msg_type = sim_pdu->tp_mti; + } + CCD_END; + + return TRUE; + +} + +LOCAL BOOL cmhSMS_cpySTtoSM(T_ACI_CMGL_SM *p_sm,T_MNSMS_READ_CNF * mnsms_read_cnf) +{ + T_ACI_CDS_SM p_st; + T_MNSMS_STATUS_IND mnsms_status_ind; + BOOL retCode = FALSE; + + memcpy (&mnsms_status_ind.sms_sdu, &mnsms_read_cnf->sms_sdu, + sizeof (T_sms_sdu)); + retCode = cmhSMS_cpyStatInd ( &p_st, &mnsms_status_ind); + memcpy(p_sm->adress, p_st.addr, MAX_SMS_ADDR_DIG - 1 ); + cmhSMS_getStatCmh ( mnsms_read_cnf->status, &p_sm->stat ); + p_sm->msg_ref = mnsms_read_cnf->rec_num ; + p_sm->tp_status=p_st.tp_status ; + p_sm->toa .ton = p_st.toa .ton ; + p_sm->toa.npi = p_st.toa.npi; + p_sm->fo = p_st.fo; + p_sm->scts =p_st.vpabs_scts ; + + return (retCode); +} +/*==== EOF ========================================================*/