freecalypso-citrine: g23m-gsm/sms/sms

comparison g23m-gsm/sms/sms_tlf.c @ 0:75a11d740a02

initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7

author	Mychaela Falconia <falcon@freecalypso.org>
date	Thu, 09 Jun 2016 00:02:41 +0000
parents
children

comparison

equal deleted inserted replaced

--1:000000000000
+:75a11d740a02
+/*
++-----------------------------------------------------------------------------
+|  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
+#include "config.h"
+#include "fixedconf.h"
+#include "condat-features.h"
+#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

FreeCalypso > hg > freecalypso-citrine

comparison g23m-gsm/sms/sms_tlf.c @ 0:75a11d740a02