FreeCalypso > hg > fc-tourmaline
view src/g23m-gsm/sms/sms_tlf.c @ 231:7b71cbbc140b
rvf_pool_size.h: add FCBM
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sat, 01 May 2021 10:09:47 +0000 |
| parents | fa8dc04885d8 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : GSM-F&D (8411) | Modul : SMS_TLF +----------------------------------------------------------------------------- | 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 Modul defines the functions for the transfer layer | capability of the module Short Message Service. +----------------------------------------------------------------------------- */ #ifndef SMS_TLF_C #define SMS_TLF_C #define ENTITY_SMS /*==== INCLUDES ===================================================*/ #include <string.h> #include <stdlib.h> #include <stddef.h> #include "typedefs.h" #include "pcm.h" #include "vsi.h" #include "custom.h" #include "gsm.h" #include "message.h" #include "ccdapi.h" #include "prim.h" #include "cus_sms.h" #include "cnf_sms.h" #include "mon_sms.h" #include "pei.h" #include "tok.h" #include "sms.h" #include "gdi.h" #include "sms_em.h" /*==== EXPORT ======================================================*/ /*==== PRIVAT ======================================================*/ static const UBYTE ref_nr_23430[] = { 0xE, 0x3, 0x8, 0x7, 0x9, 0x5, 0xE, 0x3, 0x7}; /*==== VARIABLES ===================================================*/ /* Implements Measure#32: Row 84, 96, 87, 89, 95, 97, 104, 109 & 113 */ const char * const ef_sms_id = EF_SMS_ID; /*==== FUNCTIONS ===================================================*/ /* Implements Measure# 14 */ /* +---------------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_send_sim_update_req | +---------------------------------------------------------------------------+ PURPOSE : This routine process SIM update request and SMS memo resume request */ LOCAL void tl_send_sim_update_req(UBYTE trans_data, USHORT offset) { GET_INSTANCE_DATA; UBYTE sim_acc_ix; TRACE_FUNCTION("tl_send_sim_update_req()"); /* * update sim notification flag */ if (sms_data->sim_phase >= PHASE_2_SIM) { if (tl_sms_reserve_req_id(&sim_acc_ix)) { PALLOC (update_req, SIM_UPDATE_REQ); update_req->source = SRC_SMS; update_req->req_id = sim_acc_ix; update_req->v_path_info = FALSE; update_req->datafield = sms_data->sms_sim_access_info[sim_acc_ix].datafield = SIM_SMSS; update_req->length = 1; update_req->trans_data[0] = trans_data; update_req->offset = offset; PSENDX (SIM, update_req); if(sms_data->inst == INST_MO) tl_set_access_fifo (ACCESS_BY_MMI); else tl_set_access_fifo (ACCESS_BY_NET); } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_get_octet_len | | ROUTINE : tl_adjust_message_len | +--------------------------------------------------------------------+ PURPOSE : Derive the number of octets of TP-User-Data and the whole message regarding the Data Coding Scheme. */ LOCAL BOOL tl_udl_count_septet (UBYTE dcs) { BOOL isSeptet = TRUE; switch (dcs & 0xF0) { case 0x00: case 0x10: if ((dcs & 0xC) EQ 0x4 OR /* 8-bit data */ (dcs & 0xC) EQ 0x8) /* UCS2 data */ isSeptet = FALSE; break; case 0x20: /* compressed data */ case 0x30: /* compressed data */ case 0xE0: /* UCS2 data */ isSeptet = FALSE; break; case 0xF0: if ((dcs & 0x4) NEQ 0) /* 8-bit data */ isSeptet = FALSE; break; } return isSeptet; } LOCAL USHORT tl_get_octet_len (USHORT tp_udl, UBYTE dcs) { if (tl_udl_count_septet (dcs)) /* convert number of septets */ return (USHORT)((tp_udl + 1) * 7 / 8); return tp_udl; } GLOBAL void tl_adjust_message_len (UBYTE tp_vt_mti, BUF_tpdu *tpdu) { USHORT oct_len, pre_len; UBYTE dcs; UBYTE *tp_data, *tp_msg; if (tp_vt_mti EQ SMS_VT_SIM_PDU) { pre_len = tpdu->b_tpdu[0] + 1; tp_msg = &tpdu->b_tpdu[pre_len]; switch (*tp_msg & 0x3) { case SMS_SUBMIT: tp_vt_mti = SMS_VT_SUBMIT; break; case SMS_DELIVER: tp_vt_mti = SMS_VT_DELIVER; break; case SMS_STATUS_REPORT: tp_vt_mti = SMS_VT_STATUS; break; default: return; } } else { pre_len = 0; tp_msg = &tpdu->b_tpdu[0]; } switch (tp_vt_mti) { case SMS_VT_SUBMIT: oct_len = (tp_msg[2] + 1)/2; tp_data = &tp_msg[5 + oct_len]; dcs = *tp_data; switch ((tp_msg[0] >> 3) & 0x3) /* TP-VPF */ { /* point to TP-UDL */ case SMS_VPF_RELATIVE: tp_data += 2; oct_len += 8; break; case SMS_VPF_ENHANCED: case SMS_VPF_ABSOLUTE: tp_data += 8; oct_len += 14; break; default: tp_data++; oct_len += 7; break; } oct_len += tl_get_octet_len (*tp_data, dcs); tpdu->l_tpdu = (oct_len + pre_len) << 3; break; case SMS_VT_DELIVER: oct_len = (tp_msg[1] + 1)/2; tp_data = &tp_msg[4 + oct_len]; dcs = *tp_data; tp_data += 8; /* point to TP-UDL */ oct_len += (13 + tl_get_octet_len (*tp_data, dcs)); tpdu->l_tpdu = (oct_len + pre_len) << 3; break; case SMS_VT_STATUS: oct_len = (tp_msg[2] + 1)/2 + 19; tp_data = &tp_msg[oct_len]; /* tp_data points to PI */ if(*tp_data NEQ NOT_PRESENT_8BIT) { dcs = *(tp_data+2); tp_data += 3; /* point to TP-UDL */ oct_len += (3 + tl_get_octet_len (*tp_data, dcs)); tpdu->l_tpdu = (oct_len + pre_len) << 3; } else { tpdu->l_tpdu = (oct_len + pre_len) << 3; } break; default: break; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_establish_connection | +--------------------------------------------------------------------+ PURPOSE : Initiate the Establishment of a new connection */ GLOBAL void tl_establish_connection ( BOOL incr /* true if reference nr increment needed */) { GET_INSTANCE_DATA; UBYTE ti; TRACE_FUNCTION ("tl_establish_connection()"); /* * new instance */ GET_NEW_SMS_INSTANCE(0); /* * increment TI */ ti = csf_get_new_mo_ti(); #if defined (GPRS) /* * Set downlink according to prefs, * in case of LL it has to be checked first if up */ if ( ( (sms_data->mo_dst_pref EQ GPRS_SMS_GPRS_PREF) || (sms_data->mo_dst_pref EQ GPRS_SMS_GPRS_ONLY) ) /*&& ( sms_data->llc_flow NEQ SMS_LLC_UNKNOWN )*/ ) { SMS_INST.downlink = SMS_DOWNLINK_LL_CHECK; TRACE_EVENT("downlink = SMS_DOWNLINK_LL_CHECK"); } else { SMS_INST.downlink = SMS_DOWNLINK_MMSMS; TRACE_EVENT("downlink = SMS_DOWNLINK_MMSMS"); } #endif /* GPRS */ if (incr) { /* * increment reference */ ++SMS_INST.tp_mr; /* * SIM_UPDATE_REQ */ tl_build_sim_update_req(); } TRACE_EVENT_P2("TI=%u TP_MR=%u", ti, SMS_INST.tp_mr); /* * RL_ESTABLISH_REQ */ rl_establish_req(ti); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_build_status_rep | +--------------------------------------------------------------------+ PURPOSE : Processing the function TL_BUILD_STATUS_REP. */ GLOBAL void tl_build_status_rep (T_rp_data_dl *rp_data_dl, T_MNSMS_STATUS_IND *status_ind) { T_SIM_PDU *sim_pdu; TRACE_FUNCTION ("tl_build_status_rep()"); memset (&status_ind->sms_sdu, 0, sizeof(T_sms_sdu)); if (rp_data_dl NEQ NULL) { MALLOC (sim_pdu, sizeof(T_SIM_PDU)); sim_pdu->rp_addr = rp_data_dl->rp_addr; sim_pdu->tpdu = rp_data_dl->rp_user_data.tpdu; sim_pdu->tp_mti = SMS_STATUS_REPORT; sim_pdu->v_tpdu = TRUE; sim_pdu->tp_vt_mti = SMS_VT_SIM_PDU; ccd_codeMsg (CCDENT_SMS, DOWNLINK, (T_MSGBUF *)&status_ind->sms_sdu, (UBYTE *)sim_pdu, SMS_VT_SIM_PDU); MFREE (sim_pdu); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_modify_submit | +--------------------------------------------------------------------+ PURPOSE : The SM taken from storage (rec_data) is modified with certain values from parameter 'sms_sdu' according to parameter 'modify'. The resulting message is returned in parameter 'sim_pdu'. */ LOCAL void tl_translate_mt_to_mo (T_TP_SUBMIT *submit, T_TP_DELIVER *deliver) { submit->tp_vt_mti = SMS_VT_SUBMIT; submit->tp_udhi = deliver->tp_udhi; submit->tp_mti = SMS_SUBMIT; submit->tp_mr = NOT_PRESENT_8BIT; submit->tp_pid = deliver->tp_pid; submit->tp_dcs = deliver->tp_dcs; if ((submit->v_tp_ud = deliver->v_tp_ud) NEQ 0) { submit->tp_ud = deliver->tp_ud; submit->v_tp_udh_inc = FALSE; } else if (submit->v_tp_udh_inc= deliver->v_tp_udh_inc) submit->tp_udh_inc= deliver->tp_udh_inc; } GLOBAL BOOL tl_modify_submit (T_SIM_PDU *sim_pdu, UBYTE modify, T_sms_sdu *sms_sdu, UBYTE *rec_data) { T_TP_SUBMIT *submit; T_sms_sdu *rec_sdu; union { T_TP_SUBMIT *submit; T_TP_DELIVER *deliver; } rec_msg; T_rp_addr rp_addr; TRACE_FUNCTION ("tl_modify_submit()"); if (modify >= SMS_MODIFY_ALL) return TRUE; /* ignore message from storage */ if ((rec_data[0] & 1) EQ SMS_RECORD_FREE) return FALSE; /* empty or invalid record */ if (ccd_decodeMsg (CCDENT_SMS, BOTH, (T_MSGBUF *)sms_sdu, (UBYTE *)sim_pdu, SMS_VT_SIM_PDU) EQ ccdError) return FALSE; rp_addr = sim_pdu->rp_addr; /* keep SCA */ MALLOC (submit, sizeof(T_TP_SUBMIT)); memset (submit, 0, sizeof(T_TP_SUBMIT)); if (ccd_decodeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&sim_pdu->tpdu, (UBYTE *)submit, SMS_VT_SUBMIT) EQ ccdError) { MFREE (submit); return FALSE; } MALLOC (rec_sdu, sizeof(T_sms_sdu)); rec_sdu->o_buf = 0; rec_sdu->l_buf = SIM_PDU_LEN<<3; memcpy (rec_sdu->buf, &rec_data[1], SIM_PDU_LEN); tl_adjust_message_len (SMS_VT_SIM_PDU, (BUF_tpdu *)rec_sdu); if (ccd_decodeMsg (CCDENT_SMS, BOTH, (T_MSGBUF *)rec_sdu, (UBYTE *)sim_pdu, SMS_VT_SIM_PDU) EQ ccdError) { MFREE (rec_sdu); return FALSE; } MFREE (rec_sdu); switch (modify) { case SMS_MODIFY_SCA: sim_pdu->rp_addr = rp_addr; /* SCA from SUBMIT_REQ */ /*FALLTHROUGH*/ /*lint -fallthrough*/ case SMS_MODIFY_NON: switch (rec_data[0] & 7) { case SMS_RECORD_REC_UNREAD: case SMS_RECORD_REC_READ: if (sim_pdu->tp_mti NEQ SMS_DELIVER OR !sim_pdu->v_tpdu) { MFREE (submit); return FALSE; } MALLOC (rec_msg.deliver, sizeof(T_TP_DELIVER)); memset (rec_msg.deliver, 0, sizeof(T_TP_DELIVER)); if (ccd_decodeMsg (CCDENT_SMS, DOWNLINK, (T_MSGBUF *)&sim_pdu->tpdu, (UBYTE *)rec_msg.deliver, SMS_VT_DELIVER) EQ ccdError) { MFREE (rec_msg.deliver); return FALSE; } tl_translate_mt_to_mo (submit, rec_msg.deliver); memcpy (&submit->tp_da, &rec_msg.deliver->tp_oa, sizeof(T_tp_da)); MFREE (rec_msg.deliver); sim_pdu->tpdu.o_tpdu = 0; sim_pdu->tpdu.l_tpdu = TPDU_BIT_LEN; if (ccd_codeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&sim_pdu->tpdu, (UBYTE *)submit, SMS_VT_SUBMIT) NEQ ccdOK) { MFREE (submit); return FALSE; } MFREE (submit); break; /* sim_pdu shall contain a SMS_SUBMIT message */ default: MFREE (submit); if (sim_pdu->tp_mti NEQ SMS_SUBMIT OR !sim_pdu->v_tpdu) { return FALSE; } break; } break; case SMS_MODIFY_TPOA_SCA: sim_pdu->rp_addr = rp_addr; /* SCA from SUBMIT_REQ */ /* no break */ case SMS_MODIFY_TPOA: switch (rec_data[0] & 7) { case SMS_RECORD_REC_UNREAD: case SMS_RECORD_REC_READ: if (sim_pdu->tp_mti NEQ SMS_DELIVER OR !sim_pdu->v_tpdu) { MFREE (submit); return FALSE; } MALLOC (rec_msg.deliver, sizeof(T_TP_DELIVER)); memset (rec_msg.deliver, 0, sizeof(T_TP_DELIVER)); if (ccd_decodeMsg (CCDENT_SMS, DOWNLINK, (T_MSGBUF *)&sim_pdu->tpdu, (UBYTE *)rec_msg.deliver, SMS_VT_DELIVER) EQ ccdError) { MFREE (rec_msg.deliver); return FALSE; } tl_translate_mt_to_mo (submit, rec_msg.deliver); MFREE (rec_msg.deliver); sim_pdu->tpdu.o_tpdu = 0; sim_pdu->tpdu.l_tpdu = TPDU_BIT_LEN; if (ccd_codeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&sim_pdu->tpdu, (UBYTE *)submit, SMS_VT_SUBMIT) NEQ ccdOK) { MFREE (submit); return FALSE; } MFREE (submit); break; /* sim_pdu shall contain a SMS_SUBMIT message */ default: if (sim_pdu->tp_mti NEQ SMS_SUBMIT OR !sim_pdu->v_tpdu) { MFREE (submit); return FALSE; } MALLOC (rec_msg.submit, sizeof(T_TP_SUBMIT)); memset (rec_msg.submit, 0, sizeof(T_TP_SUBMIT)); if (ccd_decodeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&sim_pdu->tpdu, (UBYTE *)rec_msg.submit, SMS_VT_SUBMIT) EQ ccdError) { MFREE (rec_msg.submit); MFREE (submit); return FALSE; } rec_msg.submit->tp_da = submit->tp_da; MFREE (submit); sim_pdu->tpdu.o_tpdu = 0; sim_pdu->tpdu.l_tpdu = TPDU_BIT_LEN; if (ccd_codeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&sim_pdu->tpdu, (UBYTE *)rec_msg.submit, SMS_VT_SUBMIT) NEQ ccdOK) { MFREE (rec_msg.submit); return FALSE; } MFREE (rec_msg.submit); break; } break; default: MFREE (submit); break; } sim_pdu->tp_mti = SMS_SUBMIT; tl_adjust_message_len (SMS_VT_SUBMIT, &sim_pdu->tpdu); return TRUE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_prepare_submit | +--------------------------------------------------------------------+ PURPOSE : Fills 'cp_data' with required parameters and returns TRUE. If the parameter check fails nothing is changed and FALSE is returned. */ GLOBAL BOOL tl_prepare_submit ( T_SIM_PDU *sim_pdu, T_U_CP_DATA *cp_data) { GET_INSTANCE_DATA; TRACE_FUNCTION ("tl_prepare_submit()"); if (sim_pdu->tp_mti EQ SMS_SUBMIT AND sim_pdu->v_tpdu) { // ++SMS_INST.tp_mr; sim_pdu->tpdu.b_tpdu[1] = SMS_INST.tp_mr; SMS_TP_REF_RET(sms_data) = SMS_INST.tp_mr; cp_data->cp_user_data_ul.v_rp_error = FALSE; cp_data->cp_user_data_ul.v_rp_ack = FALSE; memset (&cp_data->cp_user_data_ul.rp_data_ul, 0, sizeof (T_rp_data_ul)); memcpy (&cp_data->cp_user_data_ul.rp_data_ul.rp_addr, &sim_pdu->rp_addr, sizeof (T_rp_addr)); cp_data->cp_user_data_ul.rp_data_ul.rp_user_data.tp_mti = sim_pdu->tp_mti; memcpy (&cp_data->cp_user_data_ul.rp_data_ul.rp_user_data.tpdu, &sim_pdu->tpdu, sizeof (BUF_tpdu)); cp_data->cp_user_data_ul.rp_data_ul.rp_user_data.v_tpdu = TRUE; cp_data->cp_user_data_ul.v_rp_data_ul = TRUE; return TRUE; } TRACE_EVENT ("tl_prepare_submit() failed"); return FALSE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_init_complete | +--------------------------------------------------------------------+ PURPOSE : tasks at initialisation (sim read record loop) completion DESCRIPTION: - set init_done flag - send smma message if necessary - send report indication to user if applicable */ GLOBAL void tl_init_complete (void) { GET_INSTANCE_DATA; BOOL notification_flag; BOOL memory_available; BOOL mem_avail_msg; TRACE_FUNCTION ("tl_init_complete()"); /* * check whether memory available message must be sent */ mem_avail_msg = FALSE; notification_flag = !sms_data->mem_cap_avail; if ( (notification_flag == TRUE) AND (sms_data->pr_cntrl.delivery_state == SMS_DELIVER_STATUS_RESUME) ) { memory_available = (tl_get_free_space (MEM_SM) OR tl_get_free_space (MEM_ME)); if (memory_available == TRUE) { /* * initiate the sending of memory available message */ mem_avail_msg = TRUE; GET_MO_INSTANCE(sms_data); /* * TL state transition TL_ESTABLISH * EST state transition EST_SMMA */ SMS_INST_SET_STATE (STATE_TL, TL_ESTABLISH); SET_STATE (STATE_EST, EST_SMMA); /* * 1st shot */ SMS_INST.retrans = FALSE; /* * establish connection */ tl_establish_connection(FALSE); } } if (mem_avail_msg == FALSE) { #ifdef GPRS cp_send_getunitdata_req (); #endif /* * set state: READY */ sms_data->ent_state = SMS_STATE_READY; /* * report ind to user */ tl_mnsms_report_ind (SMS_STATE_READY); } /* * init done */ sms_data->init_done = TRUE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_convert_sim_error | +--------------------------------------------------------------------+ PURPOSE : Converts a SIM error to the appropriate SMS failure code. */ GLOBAL USHORT tl_convert_sim_error (USHORT sim_error) { #if 0 switch (sim_error) { case SIM_INVALID_PIN_1: return SMS_ERR_SIM_PIN1_REQ; case SIM_INVALID_PUK_1: return SMS_ERR_SIM_PUK1_REQ; case SIM_INVALID_PIN_2: return SMS_ERR_SIM_PIN2_REQ; case SIM_INVALID_PUK_2: return SMS_ERR_SIM_PUK2_REQ; case SIM_INVALID_OFFSET: return SMS_ERR_INV_INDEX; case SIM_FATAL_ERROR: return SMS_ERR_SIM_MISSING; default: return SMS_ERR_SIM_FAIL; } #else return sim_error; // prelimary #endif } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_convert_mo_to_mem | +--------------------------------------------------------------------+ PURPOSE : Prepare a MO-SM to be stored. */ GLOBAL BOOL tl_convert_mo_to_mem (T_MMSMS_DATA_REQ *data_req, UBYTE *data) { T_SIM_PDU *sim_pdu; T_sms_sdu *sms_sdu; MCAST (cp_data, U_CP_DATA); TRACE_FUNCTION ("tl_convert_mo_to_mem()"); data_req->sdu.l_buf -= 8; // point to CP message type! data_req->sdu.o_buf += 8; if (ccd_decodeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&data_req->sdu, (UBYTE *)cp_data, NOT_PRESENT_8BIT) EQ ccdError) { return FALSE; } if (cp_data->msg_type NEQ U_CP_DATA OR cp_data->cp_user_data_ul.rp_mti NEQ RP_DATA_UL) { return FALSE; } MALLOC (sim_pdu, sizeof(T_SIM_PDU)); MALLOC (sms_sdu, sizeof(T_sms_sdu)); sms_sdu->o_buf = 0; sms_sdu->l_buf = SIM_PDU_LEN<<3; sim_pdu->rp_addr = cp_data->cp_user_data_ul.rp_data_ul.rp_addr; sim_pdu->tpdu = cp_data->cp_user_data_ul.rp_data_ul.rp_user_data.tpdu; sim_pdu->tp_mti = SMS_SUBMIT; sim_pdu->v_tpdu = TRUE; sim_pdu->tp_vt_mti = SMS_VT_SIM_PDU; ccd_codeMsg (CCDENT_SMS, DOWNLINK, (T_MSGBUF *)sms_sdu, (UBYTE *)sim_pdu, SMS_VT_SIM_PDU); /* set status byte */ data[0] = SMS_RECORD_STO_SENT; memcpy (&data[1], sms_sdu->buf, sms_sdu->l_buf >> 3); memset (&data[(sms_sdu->l_buf >> 3) + 1], NOT_PRESENT_8BIT, (SIZE_EF_SMS-1) - (sms_sdu->l_buf >> 3)); MFREE (sim_pdu); MFREE (sms_sdu); // CCD_END; return TRUE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_convert_mt_to_mem | +--------------------------------------------------------------------+ PURPOSE : Prepare a MT-SM to be stored. */ GLOBAL void tl_convert_mt_to_mem (T_rp_data_dl *rp_data_dl, UBYTE *data) { T_SIM_PDU *sim_pdu; T_sms_sdu *sms_sdu; TRACE_FUNCTION ("tl_convert_mt_to_mem()"); MALLOC (sim_pdu, sizeof(T_SIM_PDU)); MALLOC (sms_sdu, sizeof(T_sms_sdu)); sms_sdu->o_buf = 0; sms_sdu->l_buf = SIM_PDU_LEN<<3; sim_pdu->rp_addr = rp_data_dl->rp_addr; sim_pdu->tpdu = rp_data_dl->rp_user_data.tpdu; sim_pdu->tp_mti = SMS_DELIVER; sim_pdu->v_tpdu = TRUE; sim_pdu->tp_vt_mti = SMS_VT_SIM_PDU; ccd_codeMsg (CCDENT_SMS, DOWNLINK, (T_MSGBUF *)sms_sdu, (UBYTE *)sim_pdu, SMS_VT_SIM_PDU); data[0] = SMS_RECORD_REC_UNREAD; memcpy (&data[1], sms_sdu->buf, sms_sdu->l_buf >> 3); memset (&data[(sms_sdu->l_buf >> 3) + 1], NOT_PRESENT_8BIT, (SIZE_EF_SMS-1) - (sms_sdu->l_buf >> 3)); MFREE (sim_pdu); MFREE (sms_sdu); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_get_free_space | +--------------------------------------------------------------------+ PURPOSE : Checks the first not used record for SMS messages. Returns the index of the first free record in the range 1..max_record, if no free record exists 0 is returned. */ GLOBAL UBYTE tl_get_free_space (UBYTE mem_type) { UBYTE i; GET_INSTANCE_DATA; T_BACKUP * backup; TRACE_FUNCTION ("tl_get_free_space()"); if (mem_type EQ MEM_ME) backup = &SMS_ME_PROP(sms_data); else if (mem_type EQ MEM_SM) backup = &SMS_SIM_PROP(sms_data); else return 0; for (i = 1; i <= backup->max_record; i++) { if ((tl_get_status (backup, i-1) & 1) EQ 0) return i; } return 0; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_find_first | +--------------------------------------------------------------------+ PURPOSE : Checks availability of SMS memory on SIM or ME memory. */ GLOBAL void tl_find_first (UBYTE mem_type) { GET_INSTANCE_DATA; TRACE_FUNCTION ("tl_find_first()"); if (mem_type EQ MEM_SM) { /* * Start with index 1 on SIM card */ tl_set_access_fifo (ACCESS_BY_MMI); SET_STATE (STATE_MMI, MMI_FIND_FIRST); tl_sim_read_record_req (1); sms_data->sim_backup.any_valid = FALSE; } else { USHORT max_record; UBYTE version; UBYTE *sim_msg; MALLOC (sim_msg, SIZE_EF_SMS); sms_data->me_backup.any_valid = FALSE; /* * look at Mobile Memory */ /* Implements Measure#32: Row 84 */ if (pcm_ReadRecord ((UBYTE *)ef_sms_id, 1, SIZE_EF_SMS, sim_msg, &version, &max_record) EQ PCM_OK) { if (max_record > MAX_RECORD_ME) max_record = MAX_RECORD_ME; else if (max_record EQ 0) max_record = 1; sms_data->me_backup.max_record = (UBYTE)max_record; if (tl_find_status_pid (MEM_ME, 1, sim_msg, &sms_data->me_backup)) { tl_message_ind_from_sim (MEM_ME, 1, (UBYTE)max_record, sim_msg); } } else { /* * No SMS in mobile memory */ sms_data->me_backup.max_record = 0; } MFREE (sim_msg); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_find_next | +--------------------------------------------------------------------+ PURPOSE : Creates a copy of the status and protocol identifier for the next entry. */ GLOBAL void tl_find_next (UBYTE mem_type, UBYTE index) { GET_INSTANCE_DATA; TRACE_FUNCTION ("tl_find_next()"); if (mem_type EQ MEM_SM) { /* * Start with index on SIM card */ tl_set_access_fifo (ACCESS_BY_MMI); SET_STATE (STATE_MMI, MMI_FIND_NEXT); tl_sim_read_record_req (index); } else { USHORT max_record; UBYTE version; UBYTE *sim_msg; MALLOC (sim_msg, SIZE_EF_SMS); /* * look at Mobile Memory */ /* Implements Measure#32: Row 86 */ if (pcm_ReadRecord ((UBYTE *)ef_sms_id, index, SIZE_EF_SMS, sim_msg, &version, &max_record) EQ PCM_OK) { if (tl_find_status_pid (MEM_ME, index, sim_msg, &sms_data->me_backup)) tl_message_ind_from_sim (MEM_ME, index, (UBYTE)max_record, sim_msg); } else { /* * declare only the successfull records * from previous attempts as available */ sms_data->me_backup.max_record = index - 1; } MFREE (sim_msg); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_get_pid_dcs | +--------------------------------------------------------------------+ PURPOSE : Gets TP-PID and/or TP-DCS from any message type. If something is not available, nothing is written to *pid and *dcs. */ GLOBAL void tl_get_pid_dcs (UBYTE status, T_sms_sdu *sms_sdu, UBYTE *pid, UBYTE *dcs) { UBYTE *ptr; int step, rpl; TRACE_FUNCTION ("tl_get_pid_dcs()"); ptr = &sms_sdu->buf[rpl = sms_sdu->buf[0] + 1]; /* points to TP-MTI */ switch (status) { case SMS_RECORD_STO_UNSENT: case SMS_RECORD_STO_SENT: /* MO-SM */ switch (*ptr & 3) { case SMS_SUBMIT: ptr += (*(ptr + 2) + 1) / 2 + 4; if (pid NEQ NULL) *pid = *ptr; if (dcs NEQ NULL) *dcs = *(ptr + 2); break; case SMS_COMMAND: if (pid NEQ NULL) *pid = *(ptr + 2); break; default: break; } break; case SMS_RECORD_REC_UNREAD: case SMS_RECORD_REC_READ: /* MT-SM */ switch (*ptr & 3) { case SMS_DELIVER: ptr += (*(ptr + 1) + 1) / 2 + 3; if (pid NEQ NULL) *pid = *ptr; if (dcs NEQ NULL) *dcs = *(ptr + 2); break; case SMS_STATUS_REPORT: if ((step = (*(ptr + 2) + 1) / 2 + 19) + rpl < (sms_sdu->l_buf >> 3)) { ptr += step; /* TP-PI */ if (pid NEQ NULL AND *ptr & 1) *pid = *(ptr + 1); if (dcs NEQ NULL AND *ptr & 2) *dcs = *(ptr + 2); } break; default: break; } break; default: break; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_find_status_pid | +--------------------------------------------------------------------+ PURPOSE : Calculates status and protocol identifier of a SMS record and stores the values. Returns TRUE, when a valid message is recognized. */ GLOBAL BOOL tl_find_status_pid (UBYTE mem_type, UBYTE index, UBYTE * data, T_BACKUP * backup) { UBYTE *ptr; BOOL is_valid = FALSE; TRACE_FUNCTION ("tl_find_status_pid()"); /* * Store status and clear pid */ tl_store_status (backup, index-1, data[0]); tl_store_pid (backup, index-1, 0); /* * mobile terminated message (bit 3 = 0) and used (bit 1 = 1) * check first byte with mask 00000101 = bit 3+1 = 5 must * be 1, that means bit 3 = 0 and bit 1 = 1. * skip service centre address and set to message type */ ptr = &data[1] + data[1] + 1; switch (data[0] & 5) { case 1: // MT-SM /* * check message type to be a SMS-DELIVER */ if ((*ptr & 3) EQ SMS_DELIVER) { /* * skip message type and originator address, * *(ptr+1) contains the number of digits of the * originator address. The term (*p+1)/2 indicates * the number of bytes used for the digits. Plus 3 for * message type, the length field and TON/NPI field. */ ptr += (*(ptr + 1) + 1) / 2 + 3; /* * store protocol identifier */ tl_store_pid (backup, index-1, *ptr); /* * valid message found */ backup->any_valid = TRUE; is_valid = TRUE; } else if((*ptr & 3) EQ SMS_STATUS_REPORT) { /* * Indicate that valid Status Report message is found in ME or SIM. * No need to store status & pid as only reading and delelting of * Status Report Message is allowed and not replacing of the message. * */ backup->any_valid = TRUE; is_valid = TRUE; } else { /* * consider the record as free */ tl_store_status (backup, index-1, 0); } break; case 5: // MO-SM /* * mobile originated messages are not to be replaced, * but it is checked whether there is really a SMS-SUBMIT * stored on the SIM */ if ((*ptr & 3) NEQ SMS_SUBMIT) { /* * consider the record as free */ tl_store_status (backup, index-1, 0); } else { /* * valid message found */ backup->any_valid = TRUE; is_valid = TRUE; } break; default: break; } return is_valid; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_cphs_voice_mail | +--------------------------------------------------------------------+ PURPOSE : Checking whether a CPHS Voice Mail Indication is given, which shall not be stored. */ #ifdef FF_CPHS LOCAL BOOL tl_cphs_voice_mail (T_TP_DELIVER *sms_deliver) { if (sms_deliver->tp_oa.digits NEQ 4 OR sms_deliver->tp_oa.ton NEQ SMS_TON_ALPHANUMERIC) return FALSE; switch (sms_deliver->tp_dcs & 0xF0) { case SMS_DCS_GRP_DEF: case SMS_DCS_GRP_CLASS: if ((sms_deliver->tp_dcs & 0xC) EQ 0 OR (sms_deliver->tp_dcs & 0xC) EQ 0xC) break; /* GSM Default Alphabet */ /*FALLTHROUGH*/ /*lint -fallthrough*/ case SMS_DCS_GRP_COMPR: case SMS_DCS_GRP_CLASS_COMPR: case SMS_DCS_GRP_MW_STORE_UCS2: return FALSE; /* no GSM Default Alphabet */ case SMS_DCS_DATA_CLASS: if (sms_deliver->tp_dcs & 0x4) return FALSE; /* no GSM Default Alphabet */ } if (!sms_deliver->v_tp_ud) return FALSE; /* not only text present */ if (sms_deliver->tp_ud.length NEQ 1 OR (sms_deliver->tp_ud.data[0] & 0x7F) NEQ ' ') return FALSE; /* no single space */ TRACE_FUNCTION ("CPHS VMS: do not store"); return TRUE; } #endif /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_check_network_on_sim | +--------------------------------------------------------------------+ PURPOSE : Checks the PLMN code as part of the IMSI and notices whether a certain network operator is present. */ #ifdef FF_SMS_NW_RCG_SIM GLOBAL void tl_check_network_on_sim (UBYTE *data) { GET_INSTANCE_DATA; if (data NEQ NULL AND data[0] >= 3 AND (data[1] & 0xF7) EQ 0x21 /* ignore parity bit */ AND data[2] EQ 0x43 AND data[3] EQ 0x03) SMS_NETWORK(sms_data) = NW_SIM_23430; else SMS_NETWORK(sms_data) = NW_SIM_NONE; } #endif /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_handle_23430 | +--------------------------------------------------------------------+ PURPOSE : Special handling of an income Short Message according to specifications of operator 23430 */ #ifdef FF_SMS_23430 GLOBAL BOOL tl_handle_23430 (T_TP_DELIVER *sms_deliver) { GET_INSTANCE_DATA; UBYTE record; if (SMS_NETWORK(sms_data) NEQ NW_SIM_23430) return FALSE; if ((sms_deliver->tp_dcs EQ 0 OR sms_deliver->tp_dcs EQ 0xF2) AND (int)sms_deliver->tp_oa.digits EQ sizeof(ref_nr_23430) AND sms_deliver->tp_oa.ton EQ SMS_TON_ALPHANUMERIC AND memcmp (sms_deliver->tp_oa.num, ref_nr_23430, sizeof(ref_nr_23430)) EQ 0) { record = tl_get_free_space (MEM_SM); if (record) { tl_store_status (&SMS_SIM_PROP(sms_data), record-1, SIM_SMS_PENDING); tl_sim_conv_update_req (record, SMS_RP_RCVD(sms_data)); tl_set_access_fifo (ACCESS_BY_NET); SET_STATE (STATE_NET, NET_23430_WRITE); MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; } else { tl_sms_memo_exceeded (FALSE); } return TRUE; /* the message has been handled */ } switch (sms_deliver->tp_dcs & 0xF0) { case SMS_DCS_GRP_CLASS: case SMS_DCS_GRP_CLASS_COMPR: case SMS_DCS_DATA_CLASS: if ((sms_deliver->tp_dcs & 3) EQ 2 AND /* Class 2 */ ((sms_deliver->v_tp_ud AND sms_deliver->tp_ud.length EQ 0) OR (sms_deliver->v_tp_udh_inc AND sms_deliver->tp_udh_inc.length EQ 0))) { if (tl_get_free_space (MEM_SM) NEQ 0) rl_report_req_ack (NULL); else tl_sms_memo_exceeded (FALSE); return TRUE; /* the message has been handled */ } break; default: break; } return FALSE; /* no SIM specific message */ } #endif /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_store_special_sms | +--------------------------------------------------------------------+ PURPOSE : Checking the presence of a special message indication requiring the message to be stored. */ LOCAL BOOL tl_store_special_sms (T_TP_DELIVER *sms_deliver) { UBYTE *udh; int udh_len; if (!sms_deliver->tp_udhi OR !sms_deliver->v_tp_udh_inc) return FALSE; udh = &sms_deliver->tp_udh_inc.tp_udh.data[0]; udh_len = (int)sms_deliver->tp_udh_inc.tp_udh.c_data; while (udh_len > 0) { if (udh[0] EQ 0x01) /* tag Special Message Indication? */ { if (udh[2] & 0x80) /* storing required? */ { TRACE_FUNCTION ("tl_store_special_sms: found"); return TRUE; } } udh_len -= (int)udh[1] + 2; udh += udh[1] + 2; /* next tag */ } return FALSE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_handle_message | +--------------------------------------------------------------------+ PURPOSE : Standard handling of an income Short Message according to GSM 03.40 and 03.38 */ /* * DISPLAY display * MEM_ME store in ME * MEM_SM store in SIM * NOTHING do nothing */ static const UBYTE me_table_A [5][7] = { /* mt no class class 0 class 1 class 2 class 3 discard store */ /* 0 */ { MEM_ME, MEM_ME, MEM_ME, MEM_SM, MEM_ME, MEM_ME, MEM_ME }, /* 1 */ { MEM_ME, DISPLAY, MEM_ME, MEM_SM, MEM_ME, MEM_ME, MEM_ME }, /* 2 */ { DISPLAY, DISPLAY, DISPLAY, MEM_SM, DISPLAY, DISPLAY, MEM_ME }, /* 3 */ { MEM_ME, DISPLAY, MEM_ME, MEM_SM, DISPLAY, MEM_ME, MEM_ME }, /* 4 */ { MEM_ME, DISPLAY, MEM_ME, MEM_SM, MEM_SM, DISPLAY, MEM_ME } }; static const UBYTE me_table_B [5][7] = { /* mt no class class 0 class 1 class 2 class 3 discard store */ /* 0 */ { MEM_SM, DISPLAY, MEM_SM, NOTHING, NOTHING, DISPLAY, NOTHING }, /* 1 */ { MEM_SM, IGNORE, MEM_SM, NOTHING, NOTHING, DISPLAY, NOTHING }, /* 2 */ { NOTHING, IGNORE, NOTHING, NOTHING, NOTHING, NOTHING, NOTHING }, /* 3 */ { MEM_SM, IGNORE, MEM_SM, NOTHING, NOTHING, DISPLAY, NOTHING }, /* 4 */ { MEM_SM, IGNORE, MEM_SM, NOTHING, MEM_ME, NOTHING, MEM_SM } }; static const UBYTE sm_table_A [5][7] = { /* mt no class class 0 class 1 class 2 class 3 discard store */ /* 0 */ { MEM_SM, MEM_SM, MEM_SM, MEM_SM, MEM_SM, MEM_SM, MEM_SM }, /* 1 */ { MEM_SM, DISPLAY, MEM_SM, MEM_SM, MEM_SM, MEM_SM, MEM_SM }, /* 2 */ { DISPLAY, DISPLAY, DISPLAY, MEM_SM, DISPLAY, DISPLAY, MEM_SM }, /* 3 */ { MEM_SM, DISPLAY, MEM_SM, MEM_SM, DISPLAY, MEM_SM, MEM_SM }, /* 4 */ { MEM_SM, DISPLAY, MEM_ME, MEM_SM, MEM_SM, DISPLAY, MEM_SM } }; static const UBYTE sm_table_B [5][7] = { /* mt no class class 0 class 1 class 2 class 3 discard store */ /* 0 */ { MEM_ME, DISPLAY, MEM_ME, NOTHING, NOTHING, DISPLAY, NOTHING }, /* 1 */ { MEM_ME, IGNORE, MEM_ME, NOTHING, NOTHING, DISPLAY, NOTHING }, /* 2 */ { NOTHING, IGNORE, NOTHING, NOTHING, NOTHING, NOTHING, NOTHING }, /* 3 */ { MEM_ME, IGNORE, MEM_ME, NOTHING, NOTHING, DISPLAY, NOTHING }, /* 4 */ { MEM_ME, IGNORE, MEM_SM, NOTHING, MEM_ME, NOTHING, MEM_ME } }; GLOBAL void tl_handle_message (T_TP_DELIVER *sms_deliver) { GET_INSTANCE_DATA; UBYTE dcs_class; UBYTE record; UBYTE data[SIZE_EF_SMS]; TRACE_FUNCTION ("tl_handle_message()"); if (sms_data->pr_cntrl.delivery_state == SMS_DELIVER_STATUS_PAUSE) { /* user has blocked message receiption */ TRACE_EVENT("User has paused MT message delivery"); tl_sms_memo_pause(); SMS_INST_SET_STATE (STATE_TL, TL_IDLE); return; } #ifdef FF_CPHS if (SMS_CPHS(sms_data) AND tl_cphs_voice_mail (sms_deliver)) dcs_class = 5; /* discard message */ else #endif if (tl_store_special_sms (sms_deliver)) dcs_class = 6; /* store message */ else if (sms_deliver->tp_pid EQ SMS_PID_ME_DOWNLOAD) dcs_class = 1 + 1; /* class 1 */ else if (sms_deliver->tp_pid EQ SMS_PID_SIM_DOWNLOAD) dcs_class = 2 + 1; /* class 2 */ else switch (sms_deliver->tp_dcs & 0xF0) { case SMS_DCS_GRP_CLASS: case SMS_DCS_GRP_CLASS_COMPR: case SMS_DCS_DATA_CLASS: dcs_class = (sms_deliver->tp_dcs & 3) + 1; break; case SMS_DCS_GRP_MW_DISCD: dcs_class = 5; /* discard message */ break; case SMS_DCS_GRP_MW_STORE: case SMS_DCS_GRP_MW_STORE_UCS2: dcs_class = 6; /* store message */ break; default: dcs_class = 0; // no class break; } if (sms_data->mem3 EQ MEM_ME) { sms_data->use_mem_a = me_table_A [sms_data->mt][dcs_class]; sms_data->use_mem_b = me_table_B [sms_data->mt][dcs_class]; } else { sms_data->use_mem_a = sm_table_A [sms_data->mt][dcs_class]; sms_data->use_mem_b = sm_table_B [sms_data->mt][dcs_class]; } /* * try alternative A */ switch (sms_data->use_mem_a) { case DISPLAY: /* * Only display of the message */ TRACE_EVENT("TABLE A: DISPLAY"); SMS_EM_DISPLAY_MT_SHORT_MESSAGE; tl_message_ind_from_net (NOT_PRESENT_8BIT, 0, 0, SMS_RP_RCVD(sms_data)); { if (SMS_MT_ACK_MODE(sms_data) NEQ SMS_MHC_PH2PLUS) { rl_report_req_ack (NULL); SMS_INST_SET_STATE (STATE_TL, TL_IDLE); } } MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; return; case MEM_ME: /* * memory type is mobile memory */ TRACE_EVENT("TABLE A: MEM_ME"); record = tl_get_free_space (MEM_ME); if (record NEQ 0) { tl_convert_mt_to_mem (SMS_RP_RCVD(sms_data), data); /* * store in mobile memory */ /* Implements Measure#32: Row 87 */ if (pcm_WriteRecord ((UBYTE *)ef_sms_id, record, SIZE_EF_SMS, data) NEQ PCM_OK) break; /* * update status byte and protocol identifier */ tl_store_status (&SMS_ME_PROP(sms_data), record-1, SMS_RECORD_REC_UNREAD); tl_store_pid (&SMS_ME_PROP(sms_data), record-1, sms_deliver->tp_pid); /* * send indication to MMI */ tl_message_ind_from_net (MEM_ME, record, sms_data->me_backup.max_record, SMS_RP_RCVD(sms_data)); /* * acknowledge to the infrastructure */ rl_report_req_ack (NULL); SMS_INST_SET_STATE (STATE_TL, TL_IDLE); MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; return; } break; case MEM_SM: /* * memory type is SIM card */ TRACE_EVENT("TABLE A: MEM_SM"); record = tl_get_free_space (MEM_SM); if (record) { tl_store_status (&SMS_SIM_PROP(sms_data), record-1, SIM_SMS_PENDING); tl_sim_conv_update_req (record, SMS_RP_RCVD(sms_data)); tl_set_access_fifo (ACCESS_BY_NET); SET_STATE (STATE_NET, NET_WRITE); return; } break; } /* * try alternative B */ switch (sms_data->use_mem_b) { case DISPLAY: /* * Only display of the message */ TRACE_EVENT("TABLE B: DISPLAY"); tl_message_ind_from_net (NOT_PRESENT_8BIT, 0, 0, sms_data->rp_data_dl); { if (SMS_MT_ACK_MODE(sms_data) NEQ SMS_MHC_PH2PLUS) { rl_report_req_ack (NULL); SMS_INST_SET_STATE (STATE_TL, TL_IDLE); } } MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; break; case MEM_ME: /* * memory type is mobile memory */ TRACE_EVENT("TABLE B: MEM_ME"); record = tl_get_free_space (MEM_ME); if (record) { tl_convert_mt_to_mem (SMS_RP_RCVD(sms_data), data); /* * store in mobile memory */ /* Implements Measure#32: Row 89 */ if (pcm_WriteRecord ((UBYTE *)ef_sms_id, record, SIZE_EF_SMS, data) EQ PCM_OK) { /* * update status byte */ tl_store_status (&SMS_ME_PROP(sms_data), record-1, SMS_RECORD_REC_UNREAD); tl_store_pid (&SMS_ME_PROP(sms_data), record-1, sms_deliver->tp_pid); /* * send indication to MMI */ tl_message_ind_from_net (MEM_ME, record, sms_data->me_backup.max_record, SMS_RP_RCVD(sms_data)); /* * acknowledge to the infrastructure */ rl_report_req_ack (NULL); SMS_INST_SET_STATE (STATE_TL, TL_IDLE); SET_STATE (STATE_NET, NET_IDLE); MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; break; } } if (tl_get_free_space (MEM_SM)) /* SIM memory available? */ { /* * RP_ERROR => */ rl_report_req_error (SMS_RP_CS_PROTOCOL_ERROR, NULL); /* * RL_RELEASE_REQ ==> */ rl_release_req(SMS_INST.ti); /* * free instance */ // FREE_SMS_INSTANCE (SMS_INST.ti); } else { /* change mem_cap_avail flag on SIM and return error */ tl_sms_memo_exceeded (FALSE); } SMS_INST_SET_STATE (STATE_TL, TL_IDLE); SET_STATE (STATE_NET, NET_IDLE); MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; break; case MEM_SM: /* * memory type is SIM card */ TRACE_EVENT("TABLE B: MEM_SM"); record = tl_get_free_space (MEM_SM); if (record) { tl_store_status (&SMS_SIM_PROP(sms_data), record-1, SIM_SMS_PENDING); tl_sim_conv_update_req (record, SMS_RP_RCVD(sms_data)); tl_set_access_fifo (ACCESS_BY_NET); SET_STATE (STATE_NET, NET_WRITE); break; } if (tl_get_free_space (MEM_ME)) /* other memory available? */ { /* * RP_ERROR => */ rl_report_req_error (SMS_RP_CS_PROTOCOL_ERROR, NULL); /* * RL_RELEASE_REQ ==> */ rl_release_req(SMS_INST.ti); /* * free instance */ // FREE_SMS_INSTANCE (SMS_INST.ti); } else { /* change mem_cap_avail flag on SIM and return error */ tl_sms_memo_exceeded (FALSE); } SMS_INST_SET_STATE (STATE_TL, TL_IDLE); SET_STATE (STATE_NET, NET_IDLE); MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; break; case IGNORE: TRACE_EVENT("TABLE B: IGNORE"); rl_report_req_ack (NULL); SMS_INST_SET_STATE (STATE_TL, TL_IDLE); MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; break; default: /* other memory available? */ TRACE_EVENT("TABLE B: OTHER?"); if (tl_get_free_space (MEM_ME) OR tl_get_free_space (MEM_SM)) { /* * RP_ERROR => */ rl_report_req_error (SMS_RP_CS_PROTOCOL_ERROR, NULL); /* * RL_RELEASE_REQ ==> */ rl_release_req(SMS_INST.ti); /* * free instance */ // FREE_SMS_INSTANCE (SMS_INST.ti); } else { /* change mem_cap_avail flag on SIM and return error */ tl_sms_memo_exceeded (FALSE); } SMS_INST_SET_STATE (STATE_TL, TL_IDLE); MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; break; } sms_data->use_mem_b = NOTHING; // not reached if alternative B in progress } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_sms_reserve_req_id | +--------------------------------------------------------------------+ PURPOSE : Finds a free entry in for SIM accesses and reserves it for use. */ GLOBAL BOOL tl_sms_reserve_req_id (UBYTE *acc_ix_ptr) { GET_INSTANCE_DATA; UBYTE sim_acc_ix; for (sim_acc_ix = 0; sim_acc_ix < SMS_MAX_SIM_ACCESS AND sms_data->sms_sim_access_info[sim_acc_ix].entry_used; ++sim_acc_ix); if (sim_acc_ix < SMS_MAX_SIM_ACCESS) { *acc_ix_ptr = sim_acc_ix; sms_data->sms_sim_access_info[sim_acc_ix].entry_used = TRUE; return TRUE; } else { TRACE_ERROR("SMS SIM Access entries used up"); return FALSE; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_build_sim_update_req | +--------------------------------------------------------------------+ PURPOSE : Build and send the SIM_UPDATE_REQ. */ GLOBAL void tl_build_sim_update_req (void) { GET_INSTANCE_DATA; TRACE_FUNCTION ("tl_build_sim_update_req()"); /* Implements Measure# 14 */ tl_send_sim_update_req (SMS_INST.tp_mr, 0); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TL | | STATE : code ROUTINE : tl_message_ind_from_net | +--------------------------------------------------------------------+ PURPOSE : Builds from SIM data and sends the primitive MNSMS_MESSAGE_IND to ACI. A NULL pointer for parameter 'data' generates an empty indication, which shall interpreted as existent but empty memory. */ GLOBAL void tl_message_ind_from_net (UBYTE mem_type, UBYTE record, UBYTE max_record, T_rp_data_dl *rp_data_dl) { T_SIM_PDU *sim_pdu; TRACE_FUNCTION ("tl_message_ind_from_net"); if (rp_data_dl NEQ NULL) { PALLOC (message_ind, MNSMS_MESSAGE_IND); MALLOC (sim_pdu, sizeof(T_SIM_PDU)); message_ind->sms_sdu.o_buf = 0; message_ind->sms_sdu.l_buf = SIM_PDU_LEN<<3; message_ind->status = SMS_RECORD_REC_UNREAD; message_ind->mem_type = mem_type; message_ind->rec_num = record; message_ind->rec_max = max_record; SMS_EM_STORE_MT_MESSAGE; sim_pdu->rp_addr = rp_data_dl->rp_addr; sim_pdu->tpdu = rp_data_dl->rp_user_data.tpdu; sim_pdu->tp_mti = SMS_DELIVER; sim_pdu->v_tpdu = TRUE; sim_pdu->tp_vt_mti = SMS_VT_SIM_PDU; ccd_codeMsg (CCDENT_SMS, DOWNLINK, (T_MSGBUF *)&message_ind->sms_sdu, (UBYTE *)sim_pdu, SMS_VT_SIM_PDU); PSENDX (MMI, message_ind); MFREE (sim_pdu); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TL | | STATE : code ROUTINE : tl_message_ind_from_sim | +--------------------------------------------------------------------+ PURPOSE : Builds from SIM data and sends the primitive MNSMS_MESSAGE_IND to ACI. A NULL pointer for parameter 'data' generates an empty indication, which shall interpreted as existent but empty memory. */ GLOBAL void tl_message_ind_from_sim (UBYTE mem_type, UBYTE record, UBYTE max_record, UBYTE *data) { PALLOC (message_ind, MNSMS_MESSAGE_IND); TRACE_FUNCTION ("tl_message_ind_from_sim"); memset (message_ind, 0, sizeof (T_MNSMS_MESSAGE_IND)); message_ind->mem_type = mem_type; message_ind->rec_max = max_record; if (data NEQ NULL) { message_ind->rec_num = record; message_ind->status = data[0]; memcpy (message_ind->sms_sdu.buf, &data[1], SIZE_EF_SMS-1); message_ind->sms_sdu.l_buf = (SIZE_EF_SMS-1) << 3; tl_adjust_message_len (SMS_VT_SIM_PDU, (BUF_tpdu *)&message_ind->sms_sdu); } PSENDX (MMI, message_ind); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_read_access_fifo | +--------------------------------------------------------------------+ PURPOSE : Processing the function TL_READ_ACCESS_FIFO. */ GLOBAL UBYTE tl_read_access_fifo (void) { GET_INSTANCE_DATA; UBYTE id; TRACE_FUNCTION ("tl_read_access_fifo()"); if (sms_data->access_fifo [1] NEQ ACCESS_EMPTY) { id = sms_data->access_fifo [1]; sms_data->access_fifo [1] = ACCESS_EMPTY; } else { id = sms_data->access_fifo [0]; sms_data->access_fifo [0] = ACCESS_EMPTY; } return id; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_read_me_memory | +--------------------------------------------------------------------+ PURPOSE : Processing the function TL_READ_ME_MEMORY. */ GLOBAL void tl_read_me_memory (USHORT rec_num, UBYTE status) { GET_INSTANCE_DATA; int index; TRACE_FUNCTION ("tl_read_me_memory()"); if (rec_num <= SMS_ME_PROP(sms_data).max_record) { SMS_REC_STATUS(sms_data) = tl_check_status_value (status); if (rec_num EQ SMS_RECORD_NOT_EXIST) { /* * find first record of given status */ index = tl_search_record (&SMS_ME_PROP(sms_data), 1, SMS_REC_STATUS(sms_data)); } else index = (int)rec_num; if ((index NEQ SMS_RECORD_NOT_EXIST) AND (tl_get_status (&SMS_ME_PROP(sms_data), index-1) & 1)) { USHORT max_record; UBYTE misc; UBYTE sim_msg[SIZE_EF_SMS]; /* * valid index */ /* Implements Measure#32: Row 84 */ if (pcm_ReadRecord ((UBYTE *)ef_sms_id, (USHORT)index, SIZE_EF_SMS, sim_msg, &misc, &max_record) NEQ PCM_OK) { tl_mnsms_read_cnf (MEM_ME, (UBYTE)rec_num, NULL, SMS_CAUSE_MEM_FAIL); SMS_ME_PROP(sms_data).max_record = 0; return; } tl_store_status (&SMS_ME_PROP(sms_data), index-1, sim_msg[0]); if (sim_msg[0] & 1) { SMS_EM_READ_SHORT_MESSAGE; switch (sim_msg[0] & 7) { case SMS_RECORD_REC_UNREAD: /* * entry is changeable */ switch (SMS_READ_MODE(sms_data)) { case READ_STATUS_CHANGE: sim_msg[0] = SMS_RECORD_REC_READ; /* Implements Measure#32: Row 84 */ pcm_WriteRecord ((UBYTE *)ef_sms_id, (USHORT)index, SIZE_EF_SMS, sim_msg); tl_store_status (&SMS_ME_PROP(sms_data), index-1, sim_msg[0]); tl_mnsms_read_cnf (MEM_ME, (UBYTE)index, NULL, SIM_NO_ERROR); break; default: misc = sim_msg[0]; sim_msg[0] = SMS_RECORD_REC_READ; /* Implements Measure#32: Row 84 */ pcm_WriteRecord ((UBYTE *)ef_sms_id, (USHORT)index, SIZE_EF_SMS, sim_msg); tl_store_status (&SMS_ME_PROP(sms_data), index-1, sim_msg[0]); sim_msg[0] = misc; /*FALLTHROUGH*/ /*lint -fallthrough*/ case READ_PREVIEW: tl_mnsms_read_cnf (MEM_ME, (UBYTE)index, sim_msg, SIM_NO_ERROR); break; } break; case SMS_RECORD_STO_SENT: case SMS_RECORD_STO_UNSENT: /* * no status change for STORE_UNSENT! */ if (SMS_READ_MODE(sms_data) EQ READ_STATUS_CHANGE) { tl_mnsms_read_cnf (MEM_ME, (UBYTE)rec_num, NULL, SMS_CAUSE_OPER_NOT_ALLW); return; } /*FALLTHROUGH*/ /*lint -fallthrough*/ default: /* * Status Change is obsolete */ tl_mnsms_read_cnf (MEM_ME, (UBYTE)index, sim_msg, SIM_NO_ERROR); break; } return; } } } else index = (int)rec_num; /* * index is wrong or other error */ tl_mnsms_read_cnf (MEM_ME, (UBYTE)index, NULL, (USHORT)((SMS_ME_PROP(sms_data).max_record EQ 0)? SMS_CAUSE_MEM_FAIL: SMS_CAUSE_INV_INDEX)); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_read_sim_memory | +--------------------------------------------------------------------+ PURPOSE : Processing the function TL_READ_SIM_MEMORY. */ GLOBAL void tl_read_sim_memory ( USHORT rec_num, UBYTE status) { GET_INSTANCE_DATA; int index; TRACE_FUNCTION ("tl_read_sim_memory()"); if (rec_num <= (USHORT)SMS_SIM_PROP(sms_data).max_record) { SMS_REC_STATUS(sms_data) = tl_check_status_value (status); if (rec_num EQ SMS_RECORD_NOT_EXIST) { /* * find first record of given status */ index = tl_search_record (&SMS_SIM_PROP(sms_data), 1, SMS_REC_STATUS(sms_data)); } else index = (int)rec_num; if ((index NEQ SMS_RECORD_NOT_EXIST) AND (tl_get_status (&SMS_SIM_PROP(sms_data), index-1) & 1)) { /* * valid index */ if (SMS_READ_MODE(sms_data) EQ READ_STATUS_CHANGE) { switch (tl_get_status (&SMS_SIM_PROP(sms_data), index-1) & 7) { case SMS_RECORD_REC_UNREAD: /* * entry is changeable */ break; case SMS_RECORD_STO_SENT: case SMS_RECORD_STO_UNSENT: /* * no status change for STORE_UNSENT! */ tl_mnsms_read_cnf (MEM_SM, (UBYTE)rec_num, NULL, SMS_CAUSE_OPER_NOT_ALLW); return; default: /* * Status Change is obsolete */ tl_mnsms_read_cnf (MEM_SM, (UBYTE)rec_num, NULL, SIM_NO_ERROR); return; } } SMS_SEL_REC(sms_data) = (UBYTE)index; tl_set_access_fifo (ACCESS_BY_MMI); SET_STATE (STATE_MMI, MMI_READ); SMS_INST_SET_STATE (STATE_TL, TL_OTHER); tl_sim_read_record_req ((UBYTE)index); return; } } /* * index is wrong or other error */ tl_mnsms_read_cnf (MEM_SM, (UBYTE)rec_num, NULL, (USHORT)((SMS_SIM_PROP(sms_data).max_record EQ 0)? SMS_CAUSE_MEM_FAIL: SMS_CAUSE_INV_INDEX)); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_sim_read_req | +--------------------------------------------------------------------+ PURPOSE : Prepares and sends the primitive SIM_READ_REQ to read a binary file from SIM. */ GLOBAL void tl_sim_read_req (USHORT datafield, UBYTE length) { GET_INSTANCE_DATA; UBYTE sim_acc_ix; if (tl_sms_reserve_req_id(&sim_acc_ix)) { PALLOC (sim_read_req, SIM_READ_REQ); sim_read_req->source = SRC_SMS; sim_read_req->req_id = sim_acc_ix; sim_read_req->datafield = sms_data->sms_sim_access_info[sim_acc_ix].datafield = datafield; sim_read_req->v_path_info = FALSE; sim_read_req->offset = 0; sim_read_req->length = length; sim_read_req->max_length = 0; PSENDX (SIM, sim_read_req); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_sim_read_record_req | +--------------------------------------------------------------------+ PURPOSE : Prepares and sends the primitive SIM_READ_RECORD_REQ to read the given record from EF(SMS). */ GLOBAL void tl_sim_read_record_req (UBYTE record) { GET_INSTANCE_DATA; UBYTE sim_acc_ix; if (tl_sms_reserve_req_id(&sim_acc_ix)) { PALLOC (sim_read_record_req, SIM_READ_RECORD_REQ); sim_read_record_req->source = SRC_SMS; sim_read_record_req->req_id = sim_acc_ix; sim_read_record_req->v_path_info = FALSE; sim_read_record_req->datafield = sms_data->sms_sim_access_info[sim_acc_ix].datafield = SIM_SMS; sim_read_record_req->record = sms_data->sms_sim_access_info[sim_acc_ix].rec_num = record; sim_read_record_req->length = SIM_LENGTH_SMS_RECORD; PSENDX (SIM, sim_read_record_req); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_sim_update_req | +--------------------------------------------------------------------+ PURPOSE : Prepares and sends the primitive SIM_READ_UPDATE_REQ to update the given record of EF(SMS). Parameter 'status' is written to the first byte of the record, the remaining bytes are filled with the parameter '*data'. When parameter 'data' is NULL, then the remaining bytes are filled with pattern NOT_PRESENT_8BIT (0xFF). */ GLOBAL void tl_sim_update_req (UBYTE record, UBYTE status, UBYTE *data) { GET_INSTANCE_DATA; UBYTE sim_acc_ix; if (tl_sms_reserve_req_id(&sim_acc_ix)) { PALLOC (update_record_req, SIM_UPDATE_RECORD_REQ); update_record_req->source = SRC_SMS; update_record_req->req_id = sim_acc_ix; update_record_req->v_path_info = FALSE; update_record_req->datafield = sms_data->sms_sim_access_info[sim_acc_ix].datafield = SIM_SMS; update_record_req->record = sms_data->sms_sim_access_info[sim_acc_ix].rec_num = record; update_record_req->length = SIM_LENGTH_SMS_RECORD; if (data NEQ NULL) { update_record_req->linear_data[0] = status; memcpy (&update_record_req->linear_data[1], data, SIM_LENGTH_SMS_RECORD-1); } else { update_record_req->linear_data[0] = SMS_RECORD_FREE; memset (&update_record_req->linear_data[1], NOT_PRESENT_8BIT, SIM_LENGTH_SMS_RECORD-1); } PSENDX (SIM, update_record_req); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_sim_conv_update_req | +--------------------------------------------------------------------+ PURPOSE : Prepares and sends the primitive SIM_READ_UPDATE_REQ to update the given record of EF(SMS). The data is extracted from the RP-DATA IE. */ GLOBAL void tl_sim_conv_update_req (UBYTE record, T_rp_data_dl *rp_data_dl) { GET_INSTANCE_DATA; UBYTE sim_acc_ix; if (tl_sms_reserve_req_id(&sim_acc_ix)) { PALLOC (update_record_req, SIM_UPDATE_RECORD_REQ); update_record_req->source = SRC_SMS; update_record_req->req_id = sim_acc_ix; update_record_req->v_path_info = FALSE; update_record_req->datafield = sms_data->sms_sim_access_info[sim_acc_ix].datafield = SIM_SMS; update_record_req->record = sms_data->sms_sim_access_info[sim_acc_ix].rec_num = record; update_record_req->length = SIM_LENGTH_SMS_RECORD; tl_convert_mt_to_mem (rp_data_dl, update_record_req->linear_data); PSENDX (SIM, update_record_req); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_check_replace_entry | +--------------------------------------------------------------------+ PURPOSE : Compares the service centre address and the originator address for two sms messages during replace procedure. */ GLOBAL BOOL tl_check_replace_entry (UBYTE /*T_TP_DELIVER*/ *sms_addr, UBYTE /*T_TP_DELIVER*/ *sms_storage) { TRACE_FUNCTION ("tl_check_replace_entry()"); /* * skip service centre address */ sms_storage += *sms_storage + 1; /* * check TP-MTI */ if ((sms_storage[0] & 0x3) NEQ SMS_DELIVER) { return FALSE; } /* * compare originator address and protocol identifier */ if (memcmp (sms_addr, &sms_storage[1], (*sms_addr + 1) / 2 + 3) EQ 0) { return TRUE; } return FALSE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_replace_message | +--------------------------------------------------------------------+ PURPOSE : Checks the ME and SIM memory for replacing a short message. If protocol identifier, service centre address and originator address are equal the message will be replaced. Else normal handling is processed. */ GLOBAL void tl_replace_message (T_TP_DELIVER *sms_deliver) { GET_INSTANCE_DATA; int i; TRACE_FUNCTION ("tl_replace_message()"); /* * first check mobile memory */ i = tl_check_mt_pid (&sms_data->me_backup, 1, sms_deliver->tp_pid); { if (i > 0) /* possible record found */ { USHORT max_record; UBYTE version; UBYTE data[SIZE_EF_SMS]; /* * look at Mobile Memory */ /* Implements Measure#32: Row 84 */ if (pcm_ReadRecord ((UBYTE *)ef_sms_id, (USHORT)i, SIZE_EF_SMS, data, &version, &max_record) EQ PCM_OK) { if (tl_check_replace_entry (&SMS_RP_RCVD(sms_data)->rp_user_data.tpdu.b_tpdu[1], &data[1])) { /* *record shall be replaced, store new one */ tl_convert_mt_to_mem (sms_data->rp_data_dl, data); /* Implements Measure#32: Row 84 */ pcm_WriteRecord ((UBYTE *)ef_sms_id, (USHORT)i, SIZE_EF_SMS, data); /* * send indication to MMI */ tl_message_ind_from_net (MEM_ME, (UBYTE)i, SMS_ME_PROP(sms_data).max_record, SMS_RP_RCVD(sms_data)); /* * acknowledge to the infrastructure */ rl_report_req_ack (NULL); SMS_EM_REPLACE_SMS_IN_ME; MFREE (SMS_RP_RCVD(sms_data)); SMS_RP_RCVD(sms_data) = NULL; return; } } } } /* * now look at the SIM card */ i = tl_check_mt_pid (&sms_data->sim_backup, 1, sms_deliver->tp_pid); if (i > 0) { tl_set_access_fifo (ACCESS_BY_NET); SET_STATE (STATE_NET, NET_READ); tl_sim_read_record_req ((UBYTE)i); } else { tl_handle_message (sms_deliver); } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_check_replace_pid | +--------------------------------------------------------------------+ PURPOSE : This function checks whether a given PID for a replacement message could match the entry described by backup and index. */ LOCAL BOOL tl_check_replace_pid (T_BACKUP *backup, unsigned index, UBYTE pid) { if (backup->pid_field EQ NULL) return TRUE; /* Maybe of replacement type, further checks needed */ return ((backup->pid_field[index >> 3] & (1 << (index & 0x7))) NEQ 0); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_store_pid | +--------------------------------------------------------------------+ PURPOSE : This function stores the information wheter the given MT PID is of the replacement type in compressed form. */ GLOBAL void tl_store_pid (T_BACKUP *backup, unsigned index, UBYTE pid) { UBYTE mask; #ifdef WIN32 if (backup->mem_type EQ MEM_ME) assert (index < MAX_RECORD_ME); else if (backup->mem_type EQ MEM_SM) assert (index < MAX_RECORD_SIM); #endif /* #ifdef WIN32 */ if (backup->pid_field EQ NULL) return; /* No caching here */ mask = 1 << (index & 0x7); switch (pid) { case SMS_PID_REP_SM_TYPE_1: case SMS_PID_REP_SM_TYPE_2: case SMS_PID_REP_SM_TYPE_3: case SMS_PID_REP_SM_TYPE_4: case SMS_PID_REP_SM_TYPE_5: case SMS_PID_REP_SM_TYPE_6: case SMS_PID_REP_SM_TYPE_7: case SMS_PID_RET_CALL_MSG: backup->pid_field[index >> 3] |= mask; break; default: backup->pid_field[index >> 3] &= ~mask; break; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_store_status | +--------------------------------------------------------------------+ PURPOSE : This function stores the status into the backup data in compressed form. */ GLOBAL void tl_store_status (T_BACKUP *backup, unsigned index, UBYTE status) { #ifdef WIN32 if (backup->mem_type EQ MEM_ME) assert (index < MAX_RECORD_ME); else if (backup->mem_type EQ MEM_SM) assert (index < MAX_RECORD_SIM); #endif /* #ifdef WIN32 */ if (backup->status_field EQ NULL) return; /* No caching here */ backup->status_field[index] = status; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_get_status | +--------------------------------------------------------------------+ PURPOSE : This function gets the status. For the asynchronous interface to the SIM the presence of backup data is mandatory, for the synchronous (and fast) interface to the FFS the presence of backup data is optional. */ GLOBAL UBYTE tl_get_status (T_BACKUP *backup, unsigned index) { USHORT max_record; UBYTE version; #ifdef WIN32 if (backup->mem_type EQ MEM_ME) assert (index < MAX_RECORD_ME); else if (backup->mem_type EQ MEM_SM) assert (index < MAX_RECORD_SIM); #endif /* #ifdef WIN32 */ switch (backup->mem_type) { case MEM_ME: if (backup->status_field EQ NULL) { UBYTE status = SMS_RECORD_FREE; UBYTE *sim_msg; MALLOC (sim_msg, SIZE_EF_SMS); /* Implements Measure#32: Row 84 */ if (pcm_ReadRecord ((UBYTE *)ef_sms_id, (USHORT)(index + 1), SIZE_EF_SMS, sim_msg, &version, &max_record) EQ PCM_OK) status = sim_msg[0]; MFREE (sim_msg); return status; } /*FALLTHROUGH*/ /*lint -fallthrough*/ case MEM_SM: return backup->status_field[index]; default: return SMS_RECORD_FREE; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_check_mt_pid | +--------------------------------------------------------------------+ PURPOSE : Checks the memory for replacing candidates. If protocol identifier and status (mt message) are okay the index of the record is returned. */ GLOBAL int tl_check_mt_pid (T_BACKUP *backup, unsigned index, UBYTE pid) { int i; for (i = (int)index; i <= (int)backup->max_record; i++) { if (((tl_get_status (backup, i - 1) & 5) EQ 1) AND /* mt message */ tl_check_replace_pid (backup, i - 1, pid)) /* replacement type pid */ return i; } return 0; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_check_status_value | +--------------------------------------------------------------------+ PURPOSE : Checks and maps the parameter <status> according to the following rule: - SMS_RECORD_REC_UNREAD as is - SMS_RECORD_REC_READ as is - SMS_RECORD_STO_UNSENT as is - SMS_RECORD_STO_SENT as is - SMS_RECORD_STAT_UNRCVD to SMS_RECORD_STO_SENT - SMS_RECORD_STAT_UNSTRD to SMS_RECORD_STO_SENT - SMS_RECORD_STAT_STRD to SMS_RECORD_STO_SENT - any other value to NOT_PRESENT_8BIT In conjunction with 'tl_search_record' a memory location with comparable properties can be found */ GLOBAL UBYTE tl_check_status_value (UBYTE status) { switch (status) { case SMS_RECORD_REC_UNREAD: case SMS_RECORD_REC_READ: case SMS_RECORD_STO_UNSENT: case SMS_RECORD_STO_SENT: return status; case SMS_RECORD_STAT_UNRCVD: case SMS_RECORD_STAT_UNSTRD: case SMS_RECORD_STAT_STRD: return SMS_RECORD_STO_SENT; default: break; } return NOT_PRESENT_8BIT; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_search_record | +--------------------------------------------------------------------+ PURPOSE : Searches the memory for the next message with the given status. The following codes for parameter <status> are supported: - SMS_RECORD_FREE: next free record - SMS_RECORD_REC_UNREAD - SMS_RECORD_REC_READ - SMS_RECORD_STO_UNSENT - SMS_RECORD_STO_SENT: next record with any sent message - NOT_PRESENT_8BIT: any occupied record The index of the record is returned. */ GLOBAL int tl_search_record (T_BACKUP *backup, USHORT index, UBYTE status) { int i; TRACE_FUNCTION ("tl_search_record()"); for (i = (int)index; i <= (int)backup->max_record; i++) { if (status EQ NOT_PRESENT_8BIT) { /* next occupied record */ if ((tl_get_status (backup, i - 1) & 1) NEQ SMS_RECORD_FREE) return i; } else if ((status & 1) EQ SMS_RECORD_FREE) { /* next free record */ if ((tl_get_status (backup, i - 1) & 1) EQ SMS_RECORD_FREE) return i; } else if ((status & 7) EQ (tl_get_status (backup, i - 1) & 7)) return i; } return 0; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_search_record_for_delete| +--------------------------------------------------------------------+ PURPOSE : Searches the SMS DataBase for the next message to be deleted with the given status. The following codes for parameter <status> are supported: - CMGD_DEL_INDEX delete message only for the index given - CMGD_DEL_READ - CMGD_DEL_READ_SENT - CMGD_DEL_READ_SENT_UNSENT - CMGD_DEL_ALL next occupied record The index of the record is returned. */ GLOBAL UBYTE tl_search_record_for_delete (T_BACKUP *backup, UBYTE index, UBYTE status) { UBYTE i; UBYTE file_status; TRACE_FUNCTION ("tl_search_record_for_delete()"); for (i = index; i <= backup->max_record; i++) { file_status = backup->status_field[i - 1] & 7; switch(status) { case CMGD_DEL_ALL: { if ((file_status & 1) NEQ SMS_RECORD_FREE) { return i; } break; } case CMGD_DEL_READ: { if (file_status EQ SMS_RECORD_REC_READ) { return i; } break; } case CMGD_DEL_READ_SENT: { if (file_status EQ SMS_RECORD_REC_READ || file_status EQ SMS_RECORD_STO_SENT) { return i; } break; } case CMGD_DEL_READ_SENT_UNSENT: { if (file_status EQ SMS_RECORD_REC_READ || file_status EQ SMS_RECORD_STO_SENT || file_status EQ SMS_RECORD_STO_UNSENT) { return i; } break; } } } return SMS_RECORD_NOT_EXIST; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_set_access_fifo | +--------------------------------------------------------------------+ PURPOSE : Processing the function TL_SET_ACCESS_FIFO. */ GLOBAL void tl_set_access_fifo (UBYTE access) { GET_INSTANCE_DATA; TRACE_FUNCTION ("tl_set_access_fifo()"); sms_data->access_fifo[1] = sms_data->access_fifo[0]; sms_data->access_fifo[0] = access; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_sms_memo_exceeded | +--------------------------------------------------------------------+ PURPOSE : Checks the SIM memory availability. If an update of EF(SMSS) is required, then TRUE is returned. If the memory has become full, then the appropriate RP-ERROR is generated. */ GLOBAL BOOL tl_sms_memo_exceeded (BOOL avail) { GET_INSTANCE_DATA; BOOL sim_update = FALSE; UBYTE sim_acc_ix; TRACE_FUNCTION ("tl_sms_memo_exceeded()"); if ((sms_data->sim_phase >= 2) AND (sms_data->mem_cap_avail NEQ avail)) { if (tl_sms_reserve_req_id(&sim_acc_ix)) { PALLOC (update_req, SIM_UPDATE_REQ); update_req->source = SRC_SMS; update_req->req_id = sim_acc_ix; update_req->v_path_info = FALSE; update_req->datafield = sms_data->sms_sim_access_info[sim_acc_ix].datafield = SIM_SMSS; update_req->length = 1; update_req->trans_data[0] = (avail)? 0xFF: 0xFE; update_req->offset = 1; PSENDX (SIM, update_req); if(sms_data->inst == INST_MO) tl_set_access_fifo (ACCESS_BY_MMI); else tl_set_access_fifo (ACCESS_BY_NET); sim_update = TRUE; } } if (!(sms_data->mem_cap_avail = avail)) { /* * RP_ERROR => */ rl_report_req_error (SMS_RP_CS_MEM_CAP_EXCEEDED, NULL); /* * RL_RELEASE_REQ ==> */ rl_release_req(SMS_INST.ti); /* * no memory */ } /* inform the ACI about SIM-full/avail via SMS error indication */ tl_mnsms_error_ind(avail ? SMS_CAUSE_MEM_AVAIL : SMS_CAUSE_MEM_FULL); return sim_update; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_sms_memo_pause | +--------------------------------------------------------------------+ PURPOSE : used for <<user intiated memory full condition>> (by the MNSMS_PAUSE_REQ). - update sim notification flag (if not done already) - send RP-ERROR (MEM_CAPAPCITY_EXCEEDED) to network - release connection */ GLOBAL void tl_sms_memo_pause (void) { GET_INSTANCE_DATA; UBYTE sim_acc_ix; TRACE_FUNCTION ("tl_sms_memo_pause()"); /* * generate RP_ERROR(MEM_CAP_EXCEEDED) */ rl_report_req_error (SMS_RP_CS_MEM_CAP_EXCEEDED, NULL); /* * RL_RELEASE_REQ ==> */ rl_release_req(SMS_INST.ti); /* * update sim notification flag if necessary */ if(sms_data->pr_cntrl.mem_full_sent EQ FALSE) { sms_data->pr_cntrl.mem_full_sent = TRUE; if (sms_data->sim_phase >= 2) { if (tl_sms_reserve_req_id(&sim_acc_ix)) { PALLOC (update_req, SIM_UPDATE_REQ); update_req->req_id = sim_acc_ix; update_req->v_path_info = FALSE; update_req->source = SRC_SMS; update_req->datafield = sms_data->sms_sim_access_info[sim_acc_ix].datafield = SIM_SMSS; update_req->length = 1; update_req->trans_data[0] = 0xFE; /* Notification Flag = TRUE */ update_req->offset = 1; PSENDX (SIM, update_req); if(sms_data->inst == INST_MO) tl_set_access_fifo (ACCESS_BY_MMI); else tl_set_access_fifo (ACCESS_BY_NET); } } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_sms_memo_resume | +--------------------------------------------------------------------+ PURPOSE : used for release of <<user intiated memory full condition>> (by the MNSMS_RESUME_REQ). - update sim notification flag (set to false) */ GLOBAL void tl_sms_memo_resume (void) { TRACE_FUNCTION ("tl_sms_memo_resume()"); /* Implements Measure# 14 */ tl_send_sim_update_req(0xFF, 1); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_mnsms_report_ind | +--------------------------------------------------------------------+ PURPOSE : Processing the function TL_MNSMS_REPORT_IND. */ GLOBAL void tl_mnsms_report_ind (UBYTE ent_state) { PALLOC (report_ind, MNSMS_REPORT_IND); report_ind->state = ent_state; /* * Disable the v_cmms_mode flag as we are not sending current value of the * mode value for CMMS operation. */ report_ind->v_cmms_mode = FALSE; PSENDX (MMI, report_ind); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_pause | +--------------------------------------------------------------------+ PURPOSE : execute sms delivery pause DESCRIPTION: set marker for pause so that the next incoming sms will be responded with RP_ERROR (Cause: Memory Capacity Exceeded). */ GLOBAL void tl_pause (void) { GET_INSTANCE_DATA; TRACE_FUNCTION ("tl_pause()"); if (sms_data->pr_cntrl.delivery_state NEQ SMS_DELIVER_STATUS_PAUSE) { sms_data->pr_cntrl.delivery_state = SMS_DELIVER_STATUS_PAUSE; sms_data->pr_cntrl.mem_full_sent = FALSE; } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_resume | +--------------------------------------------------------------------+ PURPOSE : execute sms delivery resumption DESCRIPTION: reset marker for pause and initiate the sending of memory available message (SMMA) to network to indicate that we can receive sms again. */ GLOBAL void tl_resume (void) { GET_INSTANCE_DATA; TRACE_FUNCTION ("tl_resume()"); if ( sms_data->pr_cntrl.delivery_state != SMS_DELIVER_STATUS_PAUSE ) { tl_mnsms_resume_cnf(SMS_NO_ERROR); return; } if ( sms_data->pr_cntrl.mem_full_sent == FALSE ) { sms_data->pr_cntrl.delivery_state = SMS_DELIVER_STATUS_RESUME; tl_mnsms_resume_cnf(SMS_NO_ERROR); return; } if (GET_STATE (STATE_MMI) NEQ MMI_IDLE) { TRACE_ERROR("Unable to process resume request"); tl_mnsms_resume_cnf(SMS_CAUSE_ENTITY_BUSY); return; } GET_MO_INSTANCE(sms_data); /* * TL state transition TL_ESTABLISH * EST state transition EST_SMMA * MMI state transition MMI_RESUME * */ SET_STATE (STATE_MMI, MMI_RESUME); SET_STATE (STATE_EST, EST_SMMA); SMS_INST_SET_STATE (STATE_TL, TL_ESTABLISH); /* * 1st shot */ SMS_INST.retrans = FALSE; /* * establish connection */ tl_establish_connection(FALSE); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_query_deliver_status | +--------------------------------------------------------------------+ PURPOSE : handle sms status query for deliver state */ GLOBAL void tl_query_deliver_status (void) { GET_INSTANCE_DATA; TRACE_FUNCTION ("tl_query_deliver_status()"); tl_mnsms_query_cnf(SMS_QUERY_DELIVER_STATUS,sms_data->pr_cntrl.delivery_state); } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_concat_check | +--------------------------------------------------------------------+ PURPOSE : check for concatenated sms */ GLOBAL BOOL tl_concat_check ( T_sms_sdu *sms_sdu) { BYTE ccd_result; T_SIM_PDU *sim_pdu; T_TP_SUBMIT *submit; T_SMS_PDU_IE_HDR *ie_hdr; T_SMS_PDU_CONCAT_8BIT_HDR *concat_8_hdr; /* T_SMS_PDU_CONCAT_16BIT_HDR *concat_16_hdr; */ T_SMS_CONCAT_HDR *concat_hdr = NULL; MALLOC (sim_pdu, sizeof(*sim_pdu)); MALLOC (submit, sizeof(*submit)); //CCD_START; /* * CCD: SMS SDU -> SIM PDU */ ccd_result = ccd_decodeMsg (CCDENT_SMS, BOTH, (T_MSGBUF *)sms_sdu, (UBYTE *)sim_pdu, SMS_VT_SIM_PDU); if (ccd_result NEQ ccdOK) { /* * error understanding the sdu */ TRACE_ERROR ("ccd error decoding sim pdu"); /* * give up */ // CCD_END; MFREE (sim_pdu); MFREE (submit); return FALSE; } if (sim_pdu->tp_mti NEQ SMS_SUBMIT) { /* * error understanding the sdu */ TRACE_ERROR ("error not a <submit> in sim pdu"); /* * give up */ // CCD_END; MFREE (sim_pdu); MFREE (submit); return FALSE; } /* * CCD: SIM PDU -> SUBMIT */ ccd_result = ccd_decodeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&sim_pdu->tpdu, (UBYTE *)submit, SMS_VT_SUBMIT); if (ccd_result NEQ ccdOK) { /* * error understanding the sdu */ TRACE_ERROR ("ccd error decoding submit"); //TISH, patch for ASTec32699,OMAPS00135322 //start if (ccd_result NEQ ccdWarning) { /* * give up */ // CCD_END; MFREE (sim_pdu); MFREE (submit); return FALSE; } //end } if (submit->tp_udhi EQ SMS_UDHI_INCLUDED) { TRACE_EVENT("UDH INCLUDED"); ie_hdr = (T_SMS_PDU_IE_HDR *)((UBYTE *)&submit->tp_udh_inc.tp_udh.data[0]); if (ie_hdr->iei EQ 0x00 ) /* SMS_IEI_CONC_8BIT */ { /* * Concatenation header for 8 bit ref nr */ concat_8_hdr = (T_SMS_PDU_CONCAT_8BIT_HDR *) ((UBYTE *)&submit->tp_udh_inc.tp_udh.data[2]); TRACE_EVENT_P3("Concatenated: Ref %#x Seq %u Of %u", concat_8_hdr->ref_nr, concat_8_hdr->seq_nr, concat_8_hdr->max_nr); /* * safe contents of header in common header structure */ MALLOC (concat_hdr, sizeof(*concat_hdr)); concat_hdr->ref_nr = concat_8_hdr->ref_nr; concat_hdr->seq_nr = concat_8_hdr->seq_nr; concat_hdr->max_nr = concat_8_hdr->max_nr; } else { TRACE_ERROR ("could not find concat header"); } } // CCD_END; /* * concat control */ tl_concat_cntrl(concat_hdr); /* * clean up */ if (concat_hdr) MFREE(concat_hdr); MFREE (sim_pdu); MFREE (submit); return TRUE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_concat_cntrl | +--------------------------------------------------------------------+ PURPOSE : control of concatenated sms */ GLOBAL void tl_concat_cntrl ( T_SMS_CONCAT_HDR *concat_hdr /* may be NULL */) { GET_INSTANCE_DATA; if (sms_data->concat_cntrl.concatenation EQ FALSE) { /* * Concatenation currently not active */ if (concat_hdr EQ NULL) { /* * nothing to be done */ return; } else { if ((concat_hdr->seq_nr EQ 1) AND (concat_hdr->seq_nr < concat_hdr->max_nr)) { /* * begin of concatenation series */ TRACE_EVENT("concatenation series begin"); sms_data->concat_cntrl.concatenation = TRUE; sms_data->concat_cntrl.release_pending = FALSE; sms_data->concat_cntrl.nr = *concat_hdr; } else { TRACE_ERROR("concatenation series implausible nr"); } } } else { /* * Concatenation currently active */ if (concat_hdr EQ NULL) { TRACE_ERROR("concatenation series ends unexpected"); sms_data->concat_cntrl.release_pending = TRUE; sms_data->concat_cntrl.end = TRUE; } else if ((concat_hdr->seq_nr == concat_hdr->max_nr) AND (concat_hdr->seq_nr EQ sms_data->concat_cntrl.nr.seq_nr+1)) { TRACE_EVENT("concatenation series end"); sms_data->concat_cntrl.release_pending = TRUE; sms_data->concat_cntrl.end = TRUE; sms_data->concat_cntrl.nr = *concat_hdr; } else if (concat_hdr->seq_nr EQ sms_data->concat_cntrl.nr.seq_nr+1) { /* * plausible */ TRACE_EVENT("concatenation series continued"); sms_data->concat_cntrl.release_pending = TRUE; sms_data->concat_cntrl.end = FALSE; sms_data->concat_cntrl.nr = *concat_hdr; } else { TRACE_ERROR("concatenation series implausible nr"); sms_data->concat_cntrl.release_pending = TRUE; sms_data->concat_cntrl.end = TRUE; sms_data->concat_cntrl.nr = *concat_hdr; } } } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_check_class_2 | +--------------------------------------------------------------------+ PURPOSE : Checks whether the data coding scheme is class 2. */ #ifdef SIM_TOOLKIT GLOBAL UBYTE tl_check_class_2 (UBYTE dcs) { TRACE_FUNCTION ("tl_class_check()"); /* * check 00x1xx10 */ if ((dcs & 0xD3) EQ 0x12) return TRUE; /* * check 1111xx10 */ if ((dcs & 0xF3) EQ 0xF2) return TRUE; return FALSE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_build_envelope_sms_download | +--------------------------------------------------------------------+ PURPOSE : Builds an envelope command to the SIM card for SMS download. */ GLOBAL BOOL tl_build_envelope_sms_download (T_rp_data_dl *rp_data_dl) { GET_INSTANCE_DATA; int ber_len, tpdu_len; int start_addr, start_tpdu; T_stk_cmd *stk_cmd; UBYTE *env; MCAST (sim_pdu, SIM_PDU); PALLOC (sim_toolkit_req, SIM_TOOLKIT_REQ); TRACE_FUNCTION ("tl_build_envelope_sms_download()"); if (rp_data_dl EQ NULL) { PFREE (sim_toolkit_req); return FALSE; } /* * make SIM PDU */ sim_pdu->rp_addr = rp_data_dl->rp_addr; sim_pdu->tpdu = rp_data_dl->rp_user_data.tpdu; sim_pdu->tp_mti = SMS_DELIVER; sim_pdu->v_tpdu = TRUE; sim_pdu->tp_vt_mti = SMS_VT_SIM_PDU; MALLOC (stk_cmd, sizeof(T_stk_cmd)); stk_cmd->o_cmd = 0; stk_cmd->l_cmd = MAX_STK_CMD<<3; ccd_codeMsg (CCDENT_SMS, DOWNLINK, (T_MSGBUF *)stk_cmd, (UBYTE *)sim_pdu, SMS_VT_SIM_PDU); /* * calculate variable length items of ENVELOPE */ ber_len = 4; /* length of TLV device id */ /* * find RP-ADDR (Service Centre) in SIM_PDU */ start_addr = (int)stk_cmd->o_cmd >> 3; /* position of RP-ADDR length */ ber_len += (int)stk_cmd->cmd[start_addr] + 2; /* add length of TLV address */ /* * find TPDU in SIM PDU */ start_tpdu = start_addr + (int)stk_cmd->cmd[start_addr] + 1; /* skip RP-Orig Address */ tpdu_len = ((int)stk_cmd->l_cmd >> 3) - start_tpdu; /* length of RP-User-Data */ ber_len += tpdu_len + 2; /* add length of TLV SMS-TPDU */ if (tpdu_len >= 128) /* 2 byte length coding required? */ ber_len++; /* adjust */ /* * prepare the primitive */ sim_toolkit_req -> source = SRC_SMS; sim_toolkit_req -> req_id = 0; sim_toolkit_req -> stk_cmd.o_cmd = 0; /* * BER-TLV Envelope SMS-PP Download */ env = sim_toolkit_req -> stk_cmd.cmd; *env++ = 0xD1; if (ber_len >= 128) /* 2 byte length coding required */ { *env++ = 0x81; sim_toolkit_req -> stk_cmd.l_cmd = (USHORT)((ber_len + 3) << 3); } else sim_toolkit_req -> stk_cmd.l_cmd = (USHORT)((ber_len + 2) << 3); *env++ = (UBYTE)ber_len; /* * TLV Device Identities */ *env++ = 0x82; /* Tag */ *env++ = 2; /* Length */ *env++ = 0x83; /* Source Network */ *env++ = 0x81; /* Destination SIM */ /* * TLV Address */ *env++ = 0x06; /* address tag, optional */ memcpy (env, &stk_cmd->cmd[start_addr], /* copy length and content of RP-Orig Address */ stk_cmd->cmd[start_addr] + 1); env += stk_cmd->cmd[start_addr] + 1; /* tag plus content */ /* * env now points to the tag of the TLV SMS-TPDU */ *env++ = 0x8B; /* SMS TPDU tag, mandatory */ if (tpdu_len >= 128) *env++ = 0x81; *env++ = (UBYTE)tpdu_len; memcpy (env, &stk_cmd->cmd[start_tpdu], /* copy content of TPDU */ tpdu_len); /* * Send to SIM card */ PSENDX (SIM, sim_toolkit_req); MFREE (stk_cmd); /* * Set instance to assign answer from SIM card. */ tl_set_access_fifo (ACCESS_BY_NET); SET_STATE (STATE_NET, NET_WRITE); return TRUE; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_sim_toolkit_confirm | +--------------------------------------------------------------------+ PURPOSE : Getting the terminal response to a SMS - Download. */ GLOBAL void tl_sim_toolkit_confirm (T_SIM_TOOLKIT_CNF *toolkit_cnf) { GET_INSTANCE_DATA; T_rp_user_data *rp_ud; union { T_TP_DLVR_REP_ACK *ack; T_TP_DLVR_REP_ERR *err; } dlvr_rep; TRACE_FUNCTION ("tl_sim_toolkit_confirm()"); CCD_START; switch (toolkit_cnf->cause) { case SIM_NO_ERROR: /* * The SIM responds with "90 00", the ME shall acknowledge the receipt * of the short message to the network using an RP-ACK message. * * or * * The SIM responds with "9F XX", the ME shall use the GET RESPONSE * command to the response data. The response data will be supplied by * the ME in the TP-User-Data Element of the RP-ACK message. It will be * send back to the network. The values of protocol identifier and data * coding scheme in RP-ACK shall be as in the original message. */ { if (toolkit_cnf->stk_cmd.l_cmd > 0) { MALLOC (rp_ud, sizeof(T_rp_user_data)); MALLOC (dlvr_rep.ack, sizeof(T_TP_DLVR_REP_ACK)); dlvr_rep.ack->tp_vt_mti = SMS_VT_DLVR_REP_ACK; dlvr_rep.ack->tp_udhi = SMS_UDHI_NOT_INCLUDED; dlvr_rep.ack->tp_mti = SMS_DELIVER_REPORT; dlvr_rep.ack->v_tp_udh_inc = FALSE; memcpy (dlvr_rep.ack->tp_ud.data, &toolkit_cnf->stk_cmd.cmd[toolkit_cnf->stk_cmd.o_cmd >> 3], (size_t)(toolkit_cnf->stk_cmd.l_cmd >> 3)); dlvr_rep.ack->tp_ud.c_data = (UBYTE)(toolkit_cnf->stk_cmd.l_cmd >> 3); dlvr_rep.ack->tp_ud.length = (tl_udl_count_septet (SMS_DCS(sms_data)))? (UBYTE)(dlvr_rep.ack->tp_ud.c_data * 8 / 7): dlvr_rep.ack->tp_ud.c_data; dlvr_rep.ack->tp_ext = SMS_EXT_NOT_INCLUDED; dlvr_rep.ack->v_tp_ud = TRUE; dlvr_rep.ack->tp_udl_p = SMS_UD_INCLUDED; dlvr_rep.ack->tp_dcs = SMS_DCS(sms_data); dlvr_rep.ack->v_tp_dcs = TRUE; dlvr_rep.ack->tp_dcs_p = SMS_DCS_INCLUDED; dlvr_rep.ack->tp_pid = SMS_PID(sms_data); dlvr_rep.ack->v_tp_pid = TRUE; dlvr_rep.ack->tp_pid_p = SMS_PID_INCLUDED; rp_ud->tpdu.o_tpdu = 0; rp_ud->tpdu.l_tpdu = TPDU_BIT_LEN; rp_ud->v_tpdu = (ccd_codeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&rp_ud->tpdu, (UBYTE *)dlvr_rep.ack, SMS_VT_DLVR_REP_ACK) EQ ccdOK); rp_ud->tp_mti = SMS_DELIVER_REPORT; MFREE (dlvr_rep.ack); } else rp_ud = NULL; rl_report_req_ack (rp_ud); SET_STATE (STATE_NET, NET_IDLE); SMS_EM_RECEIVE_SIM_TOOLKIT_DATA_DOWNLOAD; if (rp_ud NEQ NULL) { MFREE (rp_ud); } } break; case SIM_CAUSE_SAT_BUSY: /* * The SIM responds with "93 00", the ME shall either retry the command or * send back an RP-ERROR message to the network with the TP-FCS value * indicating "SIM Application Toolkit Busy). */ { MALLOC (rp_ud, sizeof(T_rp_user_data)); rp_ud->tpdu.l_tpdu = 40; /* 5 bytes */ rp_ud->tpdu.o_tpdu = 0; rp_ud->tpdu.b_tpdu[0] = SMS_DELIVER_REPORT; /* MTI, no UDHI */ rp_ud->tpdu.b_tpdu[1] = SMS_FCS_SAT_BUSY; /* SAT busy */ rp_ud->tpdu.b_tpdu[2] = 0x03; /* PI: DCS and PID will follow, no UD */ rp_ud->tpdu.b_tpdu[3] = SMS_PID(sms_data); /* set PID */ rp_ud->tpdu.b_tpdu[4] = SMS_DCS(sms_data); /* set DCS */ rp_ud->tp_mti = SMS_DELIVER_REPORT; rp_ud->v_tpdu = TRUE; /* * RP_ERROR */ rl_report_req_error (SMS_RP_CS_PROTOCOL_ERROR, rp_ud); /* * RL_RELEASE_REQ ==> */ rl_release_req(SMS_INST.ti); SET_STATE (STATE_NET, NET_IDLE); MFREE (rp_ud); } break; case SIM_CAUSE_DNL_ERROR: /* * The ME has indicated in TERMINAL PROFILE that it supports the status * word "9E XX" and if the SIM responds with "9E XX", the ME shall use * the GET RESPONSE command to get the response data. The response data * from the SIM will be supplied by the ME in the TP-User data element * of the RP-ERROR message. It will be sent back to the network. The * values of protocol identifier and data coding scheme in RP-ERROR * shall be as in the original message. The value of TP-FCS element * of the RP-ERROR shall be "SIM data download error". */ { MALLOC (rp_ud, sizeof(T_rp_user_data)); MALLOC (dlvr_rep.err, sizeof(T_TP_DLVR_REP_ERR)); dlvr_rep.err->tp_vt_mti = SMS_VT_DLVR_REP_ERR; dlvr_rep.err->tp_udhi = SMS_UDHI_NOT_INCLUDED; dlvr_rep.err->tp_mti = SMS_DELIVER_REPORT; dlvr_rep.err->tp_fcs = SMS_FCS_SAT_DNL_ERROR; dlvr_rep.err->v_tp_udh_inc = FALSE; memcpy (dlvr_rep.err->tp_ud.data, &toolkit_cnf->stk_cmd.cmd[toolkit_cnf->stk_cmd.o_cmd >> 3], (size_t)(toolkit_cnf->stk_cmd.l_cmd >> 3)); dlvr_rep.err->tp_ud.c_data = (UBYTE)(toolkit_cnf->stk_cmd.l_cmd >> 3); dlvr_rep.err->tp_ud.length = (tl_udl_count_septet (SMS_DCS(sms_data)))? (UBYTE)(dlvr_rep.err->tp_ud.c_data * 8 / 7): dlvr_rep.err->tp_ud.c_data; dlvr_rep.err->tp_ext = SMS_EXT_NOT_INCLUDED; dlvr_rep.err->v_tp_ud = TRUE; dlvr_rep.err->tp_udl_p = SMS_UD_INCLUDED; dlvr_rep.err->tp_dcs = SMS_DCS(sms_data); dlvr_rep.err->v_tp_dcs = TRUE; dlvr_rep.err->tp_dcs_p = SMS_DCS_INCLUDED; dlvr_rep.err->tp_pid = SMS_PID(sms_data); dlvr_rep.err->v_tp_pid = TRUE; dlvr_rep.err->tp_pid_p = SMS_PID_INCLUDED; rp_ud->tpdu.o_tpdu = 0; rp_ud->tpdu.l_tpdu = TPDU_BIT_LEN; rp_ud->v_tpdu = (ccd_codeMsg (CCDENT_SMS, UPLINK, (T_MSGBUF *)&rp_ud->tpdu, (UBYTE *)dlvr_rep.err, SMS_VT_DLVR_REP_ERR) EQ ccdOK); rp_ud->tp_mti = SMS_DELIVER_REPORT; MFREE (dlvr_rep.err); /* * RP_ERROR */ rl_report_req_error (SMS_RP_CS_PROTOCOL_ERROR, rp_ud); /* * RL_RELEASE_REQ ==> */ rl_release_req(SMS_INST.ti); SET_STATE (STATE_NET, NET_IDLE); MFREE (rp_ud); } break; default: break; } CCD_END; } #endif /* +--------------------------------------------------------------------+ | PROJECT : GSM-PS (8410) MODULE : SMS_TLF | | STATE : code ROUTINE : tl_cmms_start | +--------------------------------------------------------------------+ PURPOSE : Function used for starting the Timer TMMS and continuing the CMMS mode. */ GLOBAL void tl_cmms_start(void) { TRACE_FUNCTION ("tl_cmms_start()"); if(sms_timer_check(TMMS)) { sms_timer_stop(TMMS); } sms_timer_start(TMMS); } #endif