FreeCalypso > hg > fc-tourmaline
view src/g23m-aci/aci/conc_sms.c @ 291:a72feaed133a
PWT buzzer driver: conditionalize on TARGET_HAS_BUZZER
Here we add a new target config preprocessor symbol TARGET_HAS_BUZZER,
currently defined for c11x and c139; later we also expect to have it
on for FC Venus, and in FC Magnetite we are going to turn it on for
target dsample, just for the sake of completeness and philosophical
correctness.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sat, 26 Mar 2022 19:31:18 +0000 |
parents | fa8dc04885d8 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : $Workfile:: | Modul : CONC_SMS +----------------------------------------------------------------------------- | 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 : SMS Concatenation Handler +----------------------------------------------------------------------------- */ #ifndef CONC_SMS_C #define CONC_SMS_C #endif /*==== INCLUDES ===================================================*/ #include "aci_all.h" #include "aci_cmh.h" #include "ati_cmd.h" #include "aci_cmd.h" #include "aci_fd.h" #include "aci_mem.h" #include "psa.h" #include "psa_sms.h" #include "cmh.h" #include "cmh_sms.h" #include "psa_cc.h" #include "typedefs.h" #include "aci_lst.h" #include "psa_util.h" #include "conc_sms.h" #ifdef _CONC_TESTING_ #include "aci_io.h" #include "aci_mfw.h" #endif /*==== VARIABLES ==================================================*/ GLOBAL T_SM_ASSEMBLY assembly_list[MAX_BUF_ELEMS]; GLOBAL T_SEG_BUF segBuf_list [MAX_BUF_ELEMS]; GLOBAL T_CONC_BUF concBuf_list [MAX_CONC_BUF_ELEMS]; LOCAL USHORT RefNum_Del = 0xFF; LOCAL BOOL dFLAG = FALSE; LOCAL CHAR Addres[MAX_SMS_ADDR_DIG]; /*==== FUNCTIONS ==================================================*/ LOCAL void concSMS_printConcatList (); LOCAL USHORT concSMS_findMaxRefNum(void); // Marcus: Issue 872: 03/10/2002 /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_findSeqNumSB | +--------------------------------------------------------------------+ PURPOSE : find 'seq_num' in segment buffer */ LOCAL BOOL concSMS_findSeqNumSB ( UBYTE critrerium, void *elem ) { T_SEG_BUF_ELEM *compared = (T_SEG_BUF_ELEM *)elem; if ( compared->seq_num == critrerium ) return TRUE; else return FALSE; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_findSeqNumElemCB | +--------------------------------------------------------------------+ PURPOSE : find 'seq_num' in concatenation buffer */ LOCAL BOOL concSMS_findSeqNumElemCB ( UBYTE critrerium, void *elem ) { T_CONC_BUF_ELEM *compared = (T_CONC_BUF_ELEM *)elem; if ( compared->seq_num == critrerium ) return TRUE; else return FALSE; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_findRecNumElemCB | +--------------------------------------------------------------------+ PURPOSE : find 'rec_num' in concatenation buffer */ LOCAL BOOL concSMS_findRecNumElemCB ( UBYTE critrerium, void *elem ) { T_CONC_BUF_ELEM *compared = (T_CONC_BUF_ELEM *)elem; if ( compared->rec_num == critrerium ) return TRUE; else return FALSE; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_getAsBuffer | +--------------------------------------------------------------------+ PURPOSE : This functions searchs the assembly buffer for ref_num and address. */ LOCAL T_SM_ASSEMBLY* concSMS_getAsBuffer( USHORT ref_num, CHAR *address ) { UBYTE i; TRACE_FUNCTION ("concSMS_getAsBuffer()"); /* search for the element */ for (i=0; i<MAX_BUF_ELEMS; i++) { if ( (assembly_list[i].ref_num EQ ref_num) AND (assembly_list[i].in_use) ) { if ((address NEQ NULL) /* AND (address[0] NEQ '\0') */) { if (!strcmp(assembly_list[i].address, address)) { return &assembly_list[i]; } } else { return &assembly_list[i]; } } } return NULL; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_addToAsBuffer | +--------------------------------------------------------------------+ PURPOSE : This function adds data to the assembly buffer. It returns NULL if buffer is full. */ LOCAL T_SM_ASSEMBLY* concSMS_addToAsBuffer ( USHORT ref_num, CHAR *address, UBYTE max_num, T_SM_DATA_EXT *data ) { UBYTE i; T_SM_ASSEMBLY *assembly_elem = NULL; TRACE_FUNCTION ("concSMS_addToAsBuffer()"); /* search for the element */ assembly_elem = concSMS_getAsBuffer( ref_num, address ); #ifdef _CONC_TESTING_ TRACE_EVENT_P1("addToAsBuffer:[0].in_use: %d", assembly_list[0].in_use); TRACE_EVENT_P1("addToAsBuffer:[1].in_use: %d", assembly_list[1].in_use); #endif /* element not found */ if (assembly_elem EQ NULL) { /* search for an unused list entry */ for (i=0; i<MAX_BUF_ELEMS; i++) { if (assembly_list[i].in_use EQ FALSE) { assembly_elem = &assembly_list[i]; break; } } /* buffer is full */ if (assembly_elem EQ NULL) return NULL; /* create new assembly buffer for this ref_num*/ assembly_elem->in_use = TRUE; assembly_elem->ref_num = ref_num; if ( (address NEQ NULL) AND (address[0] NEQ '\0') ) strcpy(assembly_elem->address, address); else assembly_elem->address[0] = '\0'; assembly_elem->next_exp_num = 1; assembly_elem->segs_left = max_num; assembly_elem->seg_count = 0; } /* if (assembly_elem EQ NULL) */ if (assembly_elem->seg_count EQ 0) { /* alloc memory for data to assemble */ UBYTE segs; segs = MINIMUM(assembly_elem->segs_left, CONC_MAX_SEGS); ACI_MALLOC(assembly_elem->data.data, (USHORT)(MAX_SM_LEN*segs)); assembly_elem->segs_left -= segs; assembly_elem->data.len = 0; } memcpy(assembly_elem->data.data+assembly_elem->data.len, data->data, data->len); assembly_elem->data.len += data->len; assembly_elem->data.data[assembly_elem->data.len] = '\0'; assembly_elem->next_exp_num++; assembly_elem->seg_count++; #ifdef _CONC_TESTING_ if (assembly_elem->data.len < TTRACE_LEN) { TRACE_EVENT_P1("addToAsBuffer:data.data: %s", assembly_elem->data.data); } TRACE_EVENT_P1("addToAsBuffer:data.len: %d", assembly_elem->data.len); TRACE_EVENT_P1("addToAsBuffer:next_exp_num: %d", assembly_elem->next_exp_num); TRACE_EVENT_P1("addToAsBuffer:seg_count: %d", assembly_elem->seg_count); #endif return assembly_elem; } /* +---------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_removeFromAsBuffer | +---------------------------------------------------------------------+ PURPOSE : This functions gets data from the assembly buffer and sets it to 'unused'. The assembly is completed. */ LOCAL UBYTE concSMS_removeFromAsBuffer(T_SM_DATA_EXT *data_conc, USHORT ref_num, CHAR *address) { T_SM_ASSEMBLY *assembly_buf; TRACE_FUNCTION ("concSMS_removeFromAsBuffer()"); /* search for the element */ assembly_buf = concSMS_getAsBuffer( ref_num, address ); if (assembly_buf EQ NULL) return FALSE; assembly_buf->in_use = FALSE; data_conc->data = assembly_buf->data.data; data_conc->len = assembly_buf->data.len; return TRUE; } /* +---------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_getFromAsBuffer | +---------------------------------------------------------------------+ PURPOSE : This functions gets data from the assembly buffer and resets the seg_count. The assembly buffer is still in use and the assembly is not completed. */ LOCAL UBYTE concSMS_getFromAsBuffer(T_SM_DATA_EXT *data_conc, USHORT ref_num, CHAR *address) { T_SM_ASSEMBLY *assembly_buf; TRACE_FUNCTION ("concSMS_getFromAsBuffer()"); /* search for the element */ assembly_buf = concSMS_getAsBuffer( ref_num, address ); /* assemlby buffer not found */ if (assembly_buf EQ NULL) return FALSE; assembly_buf->seg_count = 0; data_conc->data = assembly_buf->data.data; data_conc->len = assembly_buf->data.len; return TRUE; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_getSegBuffer | +--------------------------------------------------------------------+ PURPOSE : This functions searchs the segment buffer for ref_num and address. */ LOCAL T_SEG_BUF* concSMS_getSegBuffer( USHORT ref_num, CHAR *address ) { UBYTE i; TRACE_FUNCTION ("concSMS_getSegBuffer()"); /* search for the element */ for (i=0; i<MAX_BUF_ELEMS; i++) { if ((segBuf_list[i].ref_num EQ ref_num) AND (segBuf_list[i].in_use)) { if ((address NEQ NULL) /* AND (address[0] NEQ '\0') */) { if (!strcmp(segBuf_list[i].address, address)) return &segBuf_list[i]; } else { return &segBuf_list[i]; } } } return NULL; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_addToSegBuffer | +--------------------------------------------------------------------+ PURPOSE : This functions adds one segment to the buffer and returns FALSE if no segment buffer is available or the current seg buffer is full. */ LOCAL UBYTE concSMS_addToSegBuffer ( USHORT ref_num, CHAR *address, UBYTE seq_num, UBYTE rec_num, T_ACI_SMS_STAT status, T_SM_DATA_EXT *data ) { T_SEG_BUF *segBuf = NULL; T_SEG_BUF_ELEM *segBufElem; USHORT count; UBYTE i; TRACE_FUNCTION ("concSMS_addToSegBuffer()"); /* search for the segment buffer */ segBuf = concSMS_getSegBuffer( ref_num, address ); /* element not found */ if (segBuf EQ NULL) { /* search for an unused list entry */ for (i=0; i<MAX_BUF_ELEMS; i++) { if (segBuf_list[i].in_use EQ FALSE) { segBuf = &segBuf_list[i]; break; } } /* no segment buffer available */ if ( segBuf EQ NULL) return FALSE; /* initialise new buffer */ segBuf->in_use = TRUE; segBuf->ref_num = ref_num; if ( (address) AND (address[0] NEQ '\0') ) strcpy(segBuf->address, address); else segBuf->address[0] = '\0'; segBuf->list = new_list(); } count = get_list_count(segBuf->list); if ( count >= CONC_MAX_SEGS ) { /* clean segment buffer before it overflows */ while (1) { segBufElem = remove_first_element(segBuf->list); if (segBufElem EQ NULL) break; ACI_MFREE(segBufElem->data.data); ACI_MFREE(segBufElem); } segBuf->in_use = FALSE; return FALSE; } /* create new segment buffer element */ ACI_MALLOC(segBufElem, sizeof(T_SEG_BUF_ELEM)); memset(segBufElem, 0, sizeof(T_SEG_BUF_ELEM)); /* fill new buffer element */ segBufElem->seq_num = seq_num; segBufElem->rec_num = rec_num; segBufElem->status = status; /* alloc memory and copy user data to segment buffer */ ACI_MALLOC(segBufElem->data.data, data->len); segBufElem->data.len = data->len; memcpy(segBufElem->data.data, data->data, data->len); /* insert element (segment) into the segment buffer */ insert_list(segBuf->list, segBufElem); return TRUE; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_removeFromSegBuffer| +--------------------------------------------------------------------+ PURPOSE : This function finds and removes the segment with 'seq_num' from the segment buffer. */ LOCAL T_SEG_BUF_ELEM* concSMS_removeFromSegBuffer ( USHORT ref_num, CHAR* address, UBYTE seq_num ) { T_SEG_BUF *segBuf = NULL; T_SEG_BUF_ELEM *segBufElem; USHORT count; TRACE_FUNCTION ("concSMS_removeFromSegBuffer()"); /* search for the segment buffer */ segBuf = concSMS_getSegBuffer( ref_num, address ); /* segment buffer not found */ if (segBuf EQ NULL) return NULL; segBufElem = remove_element(segBuf->list, seq_num, concSMS_findSeqNumSB); if (segBufElem EQ NULL) { return NULL; /* didn't find the segment buffer element for this seq_num */ } count = get_list_count(segBuf->list); if (count EQ 0) { ACI_MFREE (segBuf->list); segBuf->list = NULL; segBuf->in_use = FALSE; } return segBufElem; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_getConcBuffer | +--------------------------------------------------------------------+ PURPOSE : This functions searchs the concatenations buffer for ref_num and address. */ LOCAL T_CONC_BUF* concSMS_getConcBuffer( USHORT ref_num, CHAR *address ) { UBYTE i; TRACE_FUNCTION ("concSMS_getConcBuffer()"); /* search for the element */ for (i=0; i<MAX_CONC_BUF_ELEMS; i++) { if ((concBuf_list[i].ref_num EQ ref_num) AND (concBuf_list[i].in_use)) { if ((address NEQ NULL) /* AND (address[0] NEQ '\0') */) { if (!strcmp(concBuf_list[i].address, address)) { return &concBuf_list[i]; } } else { return &concBuf_list[i]; } } } return NULL; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_addToConcatList | +--------------------------------------------------------------------+ PURPOSE : */ LOCAL BOOL concSMS_addToConcatList ( USHORT ref_num, CHAR *address, UBYTE max_num, UBYTE seq_num, UBYTE rec_num, T_ACI_SMS_STAT status, UBYTE mem) { T_CONC_BUF *concBuf; T_CONC_BUF_ELEM *concBufElem; UBYTE i; TRACE_FUNCTION ("concSMS_addToConcatList()"); /* search for concatenation buffer */ concBuf = concSMS_getConcBuffer( ref_num, address ); /* element not found */ if (concBuf EQ NULL) { /* search for an unused list entry */ for (i=0; i<MAX_CONC_BUF_ELEMS; i++) { if (concBuf_list[i].in_use EQ FALSE) { concBuf = &concBuf_list[i]; break; } } /* buffer is full */ if ( concBuf EQ NULL) return FALSE; concBuf->in_use = TRUE; concBuf->ref_num = ref_num; if ( (address) AND (address[0] NEQ '\0') ) strcpy(concBuf->address, address); else concBuf->address[0] = '\0'; concBuf->max_num = max_num; concBuf->list = new_list(); } /* don't add elements with same seq_num to the Concatenation Buffer */ concBufElem = find_element(concBuf->list,seq_num,concSMS_findSeqNumElemCB); if (concBufElem) return FALSE; /* create new conc. buffer element */ ACI_MALLOC(concBufElem, sizeof(T_CONC_BUF_ELEM)); /* increase total count of stored CSMS segments by 1*/ concShrdPrm.elem_count++; concBufElem->seq_num = seq_num; concBufElem->rec_num = rec_num; concBufElem->status = status; concBufElem->mem = mem; /* insert element into the conc. buffer */ insert_list(concBuf->list, concBufElem); concSMS_printConcatList(); return TRUE; } /* +---------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_removeFromConcatList| +---------------------------------------------------------------------+ PURPOSE : This function removes and FREES the memory for the element. */ LOCAL T_ACI_LIST *concSMS_removeFromConcatList ( USHORT ref_num, CHAR *address, UBYTE rec_num ) { T_CONC_BUF *concBuf = NULL; T_CONC_BUF_ELEM *concBufElem; USHORT count; TRACE_FUNCTION ("concSMS_removeFromConcatList()"); /* search for concatenation buffer */ concBuf = concSMS_getConcBuffer( ref_num, address ); /* concatenation buffer not found */ if (concBuf EQ NULL) { TRACE_EVENT_P1("conc_buf NULL: rec: %d", rec_num); return NULL; } concBufElem = remove_element(concBuf->list, rec_num, concSMS_findRecNumElemCB); if (concBufElem EQ NULL) { TRACE_EVENT_P1("concBufElem NULL: rec: %d", rec_num); return NULL; } /* free memory for this element */ ACI_MFREE(concBufElem); /* decrease total count of stored CSMS segments by 1*/ concShrdPrm.elem_count--; count = get_list_count(concBuf->list); if (count EQ 0) { ACI_MFREE (concBuf->list); concBuf->list = NULL; concBuf->in_use = FALSE; return NULL; } return concBuf->list; } /* +---------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_sortConcatList | +---------------------------------------------------------------------+ PURPOSE : This function sorts the concat. buffer acc. to its seq_num. */ LOCAL void concSMS_sortConcatList ( USHORT ref_num, CHAR *address ) { T_CONC_BUF *concBuf = NULL; T_CONC_BUF_ELEM *concBufElem; UBYTE seq_num; UBYTE rec_num = 0; T_ACI_LIST *oldlist, *newlist, *current; USHORT count; TRACE_FUNCTION ("concSMS_sortConcatList()"); /* search for concatenation buffer */ concBuf = concSMS_getConcBuffer( ref_num, address ); /* concatenation buffer not found */ if (concBuf EQ NULL) return; newlist = new_list(); oldlist = concBuf->list; count = get_list_count(oldlist); while (count) { seq_num = 255; current = oldlist; while (current) { concBufElem = (T_CONC_BUF_ELEM*)current->msg; if ( concBufElem->seq_num < seq_num ) { seq_num = concBufElem->seq_num; rec_num = concBufElem->rec_num; } current = current->next; } concBufElem = remove_element(oldlist, rec_num, concSMS_findRecNumElemCB); insert_list(newlist, concBufElem); count = get_list_count(oldlist); } if (concBuf->list) { ACI_MFREE (concBuf->list); concBuf->list = NULL; } concBuf->list = newlist; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_split | +--------------------------------------------------------------------+ PURPOSE : return TRUE if splitting was done, otherwise FALSE */ LOCAL UBYTE concSMS_split ( T_ACI_SM_DATA* tar_data, T_SM_DATA_EXT* src_data, UBYTE alphabet, T_EXT_CMS_CMD_ID id) { #ifndef _SIMULATION_ T_TIME time_val; /* Used for input to random generator */ #endif TRACE_FUNCTION ("concSMS_split ()"); if (alphabet EQ 0x00) { /* 7-bit data coding scheme */ if (src_data->len <= concShrdPrm.l_uncomp7bit_data) { tar_data->len = (UBYTE)src_data->len; memcpy ( tar_data->data, src_data->data, tar_data->len ); return FALSE; } else { tar_data->len = concShrdPrm.l_uncomp7bit_data_conc; concShrdPrm.max_sms_len = concShrdPrm.l_uncomp7bit_data_conc; } } else { /* 8-bit data coding scheme */ if (src_data->len <= concShrdPrm.l_uncomp8bit_data) { tar_data->len = (UBYTE)src_data->len; memcpy ( tar_data->data, src_data->data, tar_data->len ); return FALSE; } else { tar_data->len = concShrdPrm.l_uncomp8bit_data_conc; concShrdPrm.max_sms_len = concShrdPrm.l_uncomp8bit_data_conc; } } /* copy first segment to 'tar_data' */ memcpy ( tar_data->data, src_data->data, tar_data->len ); concShrdPrm.udh.ref_num = (UBYTE)concSMS_findMaxRefNum(); /* Marcus: Issue 872: 03/10/2002 */ concShrdPrm.udh.ref_num++; concShrdPrm.udh.max_num = (src_data->len+(concShrdPrm.max_sms_len-1)) / concShrdPrm.max_sms_len; concShrdPrm.udh.seq_num = 1; if (id EQ CMGS_CONC) { #ifndef _SIMULATION_ vsi_t_time (VSI_CALLER &time_val); srand((USHORT) time_val); /* initialize random generator */ /* For every conc sms going out, generate a random reference number and * send it. Also when power cycled it will generate a new random number. */ concShrdPrm.udh.ref_num = (UBYTE)rand(); #endif concShrdPrm.specPrm.concCMGS.data.len = src_data->len; concShrdPrm.specPrm.concCMGS.data.data = src_data->data; concShrdPrm.specPrm.concCMGS.offset = tar_data->len; return TRUE; } if (id EQ CMGW_CONC) { concShrdPrm.specPrm.concCMGW.data.len = src_data->len; concShrdPrm.specPrm.concCMGW.data.data = src_data->data; concShrdPrm.specPrm.concCMGW.offset = tar_data->len; return TRUE; } return FALSE; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_fillUDH | +--------------------------------------------------------------------+ PURPOSE : */ LOCAL void concSMS_fillUDH ( T_ACI_UDH_DATA* udh, UBYTE ref_num, UBYTE max_num, UBYTE seq_num ) { /* fill user data header structure for 8-bit ref number */ udh->len = 0x05; /* Information Element Identifier */ udh->data[0] = SMS_IEI_CONC_8BIT; /* Information Element Identifier Length */ udh->data[1] = 0x03; /* Information Element Data */ udh->data[2] = (UBYTE)(ref_num & 0x00FF); /* since we use only 8-Bit ref number */ udh->data[3] = max_num; udh->data[4] = seq_num; } #ifdef TI_PS_FF_CONC_SMS /********************** Init Functions *********************************/ /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_retrieveConcBuf | +--------------------------------------------------------------------+ PURPOSE : This function searches for the concatenation buffer which has 'index' in its first element. Returns 'CONC_ERROR' if index is not the first element or list is incomplete. */ LOCAL T_CONC_INIT_RETURN concSMS_retrieveConcBuf ( T_CONC_BUF **concBuf, UBYTE index, UBYTE mem) { UBYTE i; T_CONC_BUF_ELEM *concBufElem; TRACE_FUNCTION ("concSMS_retrieveConcBuf ()"); *concBuf = NULL; for (i=0; i<MAX_CONC_BUF_ELEMS; i++) { concSMS_printConcatList(); /* find conc. buffer element for this rec number */ concBufElem = find_element(concBuf_list[i].list, index, concSMS_findRecNumElemCB); /* element was found and check if memory type of the first segment * equals to the set memory type (mem1 or mem2) */ if ((concBufElem NEQ NULL) AND (concBufElem->mem EQ mem)) { break; } } if (concBufElem EQ NULL) { /* no concatenation handler needed */ return CONC_NOT_NEEDED; } *concBuf = &concBuf_list[i]; /* check if rec number is the first segment (with seq_num == 1) */ if ( ( concBufElem->seq_num EQ 1 ) AND ( smsShrdPrm.status EQ CMGD_DEL_INDEX ) ) { *concBuf = &concBuf_list[i]; return CONC_NEEDED; } else if( smsShrdPrm.status > CMGD_DEL_INDEX ) { /* The below check needs to be changed for deleting all the concatmessages in case of DELET FLAG > 0. */ *concBuf = &concBuf_list[i]; return CONC_NEEDED; } /* rec number is not the first element in conc. buffer * allow reading of incomplete segments and tread them like "normal" SMS */ return CONC_NOT_NEEDED; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_initSendFromMem | +--------------------------------------------------------------------+ PURPOSE : This function initialises shared parameter for CMSS. */ GLOBAL T_CONC_INIT_RETURN concSMS_initSendFromMem ( T_ACI_CMD_SRC srcId, UBYTE *index, CHAR *da, T_ACI_TOA *toda ) { T_CONC_BUF *concBuf = NULL; T_CONC_BUF_ELEM* elem = NULL; T_CONC_INIT_RETURN ret = CONC_ERROR; T_CONC_CMSS *prm = &concShrdPrm.specPrm.concCMSS; TRACE_FUNCTION ("concSMS_initSendFromMem ()"); ret = concSMS_retrieveConcBuf ( &concBuf, *index, smsShrdPrm.mem2); if (ret EQ CONC_ERROR) { /* Error: segment is not the first segment of the SM */ return CONC_ERROR; } if (ret EQ CONC_NOT_NEEDED) { /* no conatenation handler needed */ return CONC_NOT_NEEDED; } concShrdPrm.sentSegs = 0; concShrdPrm.srcId = srcId; if (da) { memcpy(prm->da, da, strlen(da)); prm->da[strlen(da)] = '\0'; prm->p_da = prm->da; } else { prm->p_da = NULL; } if (toda) { memcpy(&prm->toda, toda, sizeof(T_ACI_TOA)); prm->p_toda = &prm->toda; } else { prm->p_toda = NULL; } /* save the first concatenated buffer element */ prm->currConcBufListElem = concBuf->list; prm->skipStoSent = TRUE; /* skip segments with status SMS_STAT_StoSent */ while (prm->currConcBufListElem) { elem = (T_CONC_BUF_ELEM*)prm->currConcBufListElem->msg; if (elem->status EQ SMS_STAT_StoSent) { prm->currConcBufListElem = prm->currConcBufListElem->next; } else { break; } } /* * All elements were set to SMS_STAT_StoSent. Assume that this message was * sent completly and should be sent for the second time. */ if (prm->currConcBufListElem EQ NULL) { prm->skipStoSent = FALSE; /* save the first concatenated buffer element */ prm->currConcBufListElem = concBuf->list; elem = (T_CONC_BUF_ELEM*)prm->currConcBufListElem->msg; } *index = elem ? elem->rec_num : NULL; if (elem NEQ NULL) { elem->status = SMS_STAT_StoSent; } return CONC_NEEDED; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_initReadFromMem | +--------------------------------------------------------------------+ PURPOSE : This function initialises shared parameter for CMGR. */ GLOBAL T_CONC_INIT_RETURN concSMS_initReadFromMem ( T_ACI_CMD_SRC srcId, UBYTE index, T_ACI_SMS_READ rdMode ) { T_CONC_BUF *concBuf; T_CONC_INIT_RETURN ret; TRACE_FUNCTION ("concSMS_initReadFromMem ()"); ret = concSMS_retrieveConcBuf ( &concBuf, index, smsShrdPrm.mem2); if (ret EQ CONC_ERROR) { /* Error: segment is not the first segment of the SM */ return CONC_ERROR; } if (ret EQ CONC_NOT_NEEDED) { /* no conatenation handler needed */ return CONC_NOT_NEEDED; } concShrdPrm.srcId = srcId; concShrdPrm.specPrm.concCMGR.rdMode = rdMode; /* save the second concatenated buffer element */ concShrdPrm.specPrm.concCMGR.currConcBufListElem = concBuf->list->next; return CONC_NEEDED; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_initDeleteFromMem | +--------------------------------------------------------------------+ PURPOSE : This function initialises shared parameter for CMGD. */ GLOBAL T_CONC_INIT_RETURN concSMS_initDeleteFromMem ( T_ACI_CMD_SRC srcId, UBYTE index ) { T_CONC_BUF *concBuf; T_CONC_INIT_RETURN ret; TRACE_FUNCTION ("concSMS_initDeleteFromMem ()"); ret = concSMS_retrieveConcBuf ( &concBuf, index, smsShrdPrm.mem1); if (ret EQ CONC_ERROR) { /* Error: segment is not the first segment of the SM */ return CONC_ERROR; } if (ret EQ CONC_NOT_NEEDED) { if (concBuf NEQ NULL) { RefNum_Del = concBuf->ref_num; } /*else if (*/ else if (dFLAG EQ TRUE) { TRACE_EVENT("BUFFER FULL"); } else { RefNum_Del = 0xFF; } /* no conatenation handler needed */ return CONC_NOT_NEEDED; } /* save the concatenation list */ concShrdPrm.specPrm.concCMGD.currConcBufListElem = concBuf->list; concShrdPrm.specPrm.concCMGD.ref_num = concBuf->ref_num; concShrdPrm.specPrm.concCMGD.address = concBuf->address; concShrdPrm.srcId = srcId; concShrdPrm.specPrm.concCMGD.error_count = 0; return CONC_NEEDED; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_initSend | +--------------------------------------------------------------------+ PURPOSE : This function initialises shared parameter for CMGS. */ GLOBAL T_CONC_INIT_RETURN concSMS_initSend ( T_ACI_SM_DATA* tar_data, T_ACI_UDH_DATA* udh, T_ACI_CMD_SRC srcId, CHAR* da, T_ACI_TOA* toda, T_SM_DATA_EXT* src_data, CHAR* sca, T_ACI_TOA* tosca, SHORT isReply, UBYTE alphabet ) { UBYTE ret; T_CONC_CMGS *prm = &concShrdPrm.specPrm.concCMGS; TRACE_FUNCTION ("concSMS_initSend ()"); ret = concSMS_split ( tar_data, src_data, alphabet, CMGS_CONC ); if ( ret EQ FALSE ) return CONC_NOT_NEEDED; concShrdPrm.srcId = srcId; if (da) { memcpy(prm->da, da, strlen(da)); prm->da[strlen(da)] = '\0'; prm->p_da = prm->da; } else { prm->p_da = NULL; } if (toda) { memcpy(&prm->toda, toda, sizeof(T_ACI_TOA)); prm->p_toda = &prm->toda; } else { prm->p_toda = NULL; } prm->data.len = src_data->len; prm->data.data = src_data->data; if (sca) { memcpy(prm->sca, sca, strlen(sca)); prm->sca[strlen(sca)] = '\0'; prm->p_sca = prm->sca; } else { prm->p_sca = NULL; } if (tosca) { memcpy(&prm->tosca, tosca, sizeof(T_ACI_TOA)); prm->p_tosca = &prm->tosca; } else { prm->p_tosca = NULL; } prm->isReply = isReply; prm->sent_bytes = 0; concShrdPrm.sentSegs = 0; /* fill user data header structure */ concSMS_fillUDH ( udh, concShrdPrm.udh.ref_num, concShrdPrm.udh.max_num, concShrdPrm.udh.seq_num ); return CONC_NEEDED; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_initStoreInMem | +--------------------------------------------------------------------+ PURPOSE : This function initialises shared parameter for CMGW. */ GLOBAL T_CONC_INIT_RETURN concSMS_initStoreInMem ( T_ACI_SM_DATA* tar_data, T_ACI_UDH_DATA* udh, T_ACI_CMD_SRC srcId, SHORT index, CHAR* address, T_ACI_TOA* toa, T_ACI_SMS_STAT stat, UBYTE msg_ref, T_SM_DATA_EXT* src_data, CHAR* sca, T_ACI_TOA* tosca, SHORT isReply, UBYTE alphabet ) { T_CONC_INIT_RETURN ret; T_CONC_CMGW *prm = &concShrdPrm.specPrm.concCMGW; TRACE_FUNCTION ("concSMS_initStoreInMem ()"); ret = (T_CONC_INIT_RETURN)concSMS_split ( tar_data, src_data, alphabet, CMGW_CONC ); if ( ret EQ FALSE ) { return CONC_NOT_NEEDED; } concShrdPrm.srcId = srcId; if (address) { memcpy(prm->da, address, strlen(address)); prm->da[strlen(address)] = '\0'; prm->p_da = prm->da; } else { prm->p_da = NULL; } if (toa) { memcpy(&prm->toda, toa, sizeof(T_ACI_TOA)); prm->p_toda = &prm->toda; } else { prm->p_toda = NULL; } if ( stat NEQ SMS_STAT_NotPresent) { prm->stat = stat; } else { prm->stat = SMS_STAT_StoUnsent; } prm->msg_ref = msg_ref; prm->data.len = src_data->len; prm->data.data = src_data->data; if (sca) { memcpy(prm->sca, sca, strlen(sca)); prm->sca[strlen(sca)] = '\0'; prm->p_sca = prm->sca; } else { prm->p_sca = NULL; } if (tosca) { memcpy(&prm->tosca, tosca, sizeof(T_ACI_TOA)); prm->p_tosca = &prm->tosca; } else { prm->p_tosca = NULL; } prm->isReply = isReply; /* fill user data header structure */ concSMS_fillUDH ( udh, concShrdPrm.udh.ref_num, concShrdPrm.udh.max_num, concShrdPrm.udh.seq_num ); return CONC_NEEDED; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_initCommand | +--------------------------------------------------------------------+ PURPOSE : This function initialises shared parameter for CMGC. */ GLOBAL T_CONC_INIT_RETURN concSMS_initCommand ( T_ACI_CMD_SRC srcId, SHORT fo, SHORT ct, SHORT pid, SHORT mn, CHAR* da, T_ACI_TOA* toda, T_ACI_CMD_DATA* data ) { T_CONC_CMGC *prm = &concShrdPrm.specPrm.concCMGC; TRACE_FUNCTION ("concSMS_initCommand ()"); if ( ct NEQ COMMAND_TYPE_DELETE) return CONC_NOT_NEEDED; if ((mn < concShrdPrm.first_mr) OR (mn > concShrdPrm.first_mr + concShrdPrm.sentSegs-1)) return CONC_NOT_NEEDED; if ( mn NEQ concShrdPrm.first_mr) { /* Error: segment is not the first segment of the SM */ return CONC_ERROR; } else { concShrdPrm.srcId = srcId; prm->command_count = 0; prm->fo = (UBYTE)fo; prm->ct = (UBYTE)ct; prm->pid = (UBYTE)pid; if (da) { memcpy(prm->da, da, strlen(da)); prm->da[strlen(da)] = '\0'; prm->p_da = prm->da; } else { prm->p_da = NULL; } if (toda) { memcpy(&prm->toda, toda, sizeof(T_ACI_TOA)); prm->p_toda = &prm->toda; } else { prm->p_toda = NULL; } ACI_MALLOC(prm->data.data, MAX_SM_CMD_LEN); memcpy ( prm->data.data, data->data, data->len ); prm->data.len = data->len; } return CONC_NEEDED; } /********************** RAT Callback Fucntions ****************************/ GLOBAL void rConcSMS_PlusCMSS (UBYTE mr, UBYTE numSeg) { UBYTE index; T_CONC_BUF_ELEM* elem; T_CONC_CMSS *prm = &concShrdPrm.specPrm.concCMSS; TRACE_FUNCTION ("rConcSMS_PlusCMSS()"); /* save the first message reference */ if (concShrdPrm.sentSegs EQ 0) { concShrdPrm.first_mr = mr; } /* increment number of successfully sent elements */ concShrdPrm.sentSegs++; /* get next concat. list element */ prm->currConcBufListElem = prm->currConcBufListElem->next; if (prm->skipStoSent) { /* skip segments with status SMS_STAT_StoSent */ while (prm->currConcBufListElem) { elem = (T_CONC_BUF_ELEM*)prm->currConcBufListElem->msg; if (elem->status EQ SMS_STAT_StoSent) { prm->currConcBufListElem = prm->currConcBufListElem->next; } else { break; } } /* while */ } if (prm->currConcBufListElem NEQ NULL) { elem = (T_CONC_BUF_ELEM*)prm->currConcBufListElem->msg; index = elem->rec_num; /* set mem2 (memory to which writing and sending operations are made) temporary to the value stored in conc buffer */ smsShrdPrm.mem2 = elem->mem; sAT_PlusCMSS_Gl((T_ACI_CMD_SRC)concShrdPrm.srcId, index, prm->p_da, prm->p_toda, rConcSMS_PlusCMSS, rConcSMS_PlusCMS_CMSS); elem->status = SMS_STAT_StoSent; } else /* if (concShrdPrm.currConcBufListElem NEQ NULL) */ { #ifdef _CONC_TESTING_ char *sa; ACI_MALLOC(sa,KEY + BYTE_LTH); sprintf(sa,"+CMSS: %d,%d",concShrdPrm.first_mr, concShrdPrm.sentSegs); io_sendMessage(concShrdPrm.srcId, sa, ATI_NORMAL_OUTPUT); ACI_MFREE(sa); #endif rAT_PlusCMSS(concShrdPrm.first_mr, (UBYTE)(concShrdPrm.sentSegs)); /* restore value for mem2 */ smsShrdPrm.mem2 = concShrdPrm.mem_store; R_AT ( RAT_OK, (T_ACI_CMD_SRC) concShrdPrm.srcId ) ( AT_CMD_CMSS ); UNSET_CONC; } } GLOBAL void rConcSMS_PlusCMGS (UBYTE mr, UBYTE numSeg) { T_ACI_SM_DATA data; T_ACI_UDH_DATA udh; USHORT len_left; T_CONC_CMGS *prm = &concShrdPrm.specPrm.concCMGS; TRACE_FUNCTION ("rConcSMS_PlusCMGS()"); /* save the first message reference */ if (concShrdPrm.udh.seq_num EQ 1) { concShrdPrm.first_mr = mr; } /* increment number of successfully sent elements */ len_left = prm->data.len - prm->offset; concShrdPrm.sentSegs++; if (len_left NEQ 0) { prm->sent_bytes += concShrdPrm.max_sms_len; if ( len_left > concShrdPrm.max_sms_len ) { data.len = concShrdPrm.max_sms_len; } else { data.len = (UBYTE)len_left; } memcpy (data.data, prm->data.data+prm->offset, data.len); prm->offset += data.len; concShrdPrm.udh.seq_num++; /* fill user data header structure */ concSMS_fillUDH ( &udh, concShrdPrm.udh.ref_num, concShrdPrm.udh.max_num, concShrdPrm.udh.seq_num ); sAT_PlusCMGS_Gl((T_ACI_CMD_SRC)concShrdPrm.srcId, prm->p_da, prm->p_toda, &data, &udh, prm->p_sca, prm->p_tosca, prm->isReply, rConcSMS_PlusCMGS, rConcSMS_PlusCMS_CMGS); } else { #ifdef _CONC_TESTING_ char *sa; ACI_MALLOC(sa,KEY + BYTE_LTH); sprintf(sa,"+CMGS: %d,%d",concShrdPrm.first_mr, concShrdPrm.udh.seq_num); io_sendMessage(concShrdPrm.srcId, sa, ATI_NORMAL_OUTPUT); ACI_MFREE(sa); ACI_MFREE(prm->data.data); #endif rAT_PlusCMGS (concShrdPrm.first_mr, (UBYTE)(concShrdPrm.udh.seq_num)); R_AT ( RAT_OK, (T_ACI_CMD_SRC)concShrdPrm.srcId ) ( AT_CMD_CMGS ); UNSET_CONC; } } GLOBAL void rConcSMS_PlusCMGR ( T_ACI_CMGL_SM* sm, T_ACI_CMGR_CBM* cbm ) { T_CONC_CMGR *prm = &concShrdPrm.specPrm.concCMGR; TRACE_FUNCTION ("rConcSMS_PlusCMGR ()"); if (prm->currConcBufListElem NEQ NULL) { T_CONC_BUF_ELEM *elem; elem = (T_CONC_BUF_ELEM *)prm->currConcBufListElem->msg; /* set mem1 (memory from which messages are read and deleted) * temporary to the value stored in conc buffer */ smsShrdPrm.mem1 = elem->mem; sAT_PlusCMGR_Gl((T_ACI_CMD_SRC)concShrdPrm.srcId, elem->rec_num, (T_ACI_SMS_READ)concShrdPrm.specPrm.concCMGR.rdMode, rConcSMS_PlusCMGR); prm->currConcBufListElem = prm->currConcBufListElem->next; #ifdef _CONC_TESTING_ rAT_PlusCMGR_Ext (sm, cbm); #else rAT_PlusCMGR (sm, cbm); #endif } else /* if (concShrdPrm.currConcBufListElem NEQ NULL) */ { #ifdef _CONC_TESTING_ rAT_PlusCMGR_Ext (sm, cbm); #else rAT_PlusCMGR (sm, cbm); #endif /* restore value for mem1 */ smsShrdPrm.mem1 = concShrdPrm.mem_store; R_AT ( RAT_OK, (T_ACI_CMD_SRC) concShrdPrm.srcId ) ( AT_CMD_CMGR ); UNSET_CONC; } } GLOBAL void rConcSMS_PercentCMGMDU (void) { T_CONC_CMGR *prm = &concShrdPrm.specPrm.concCMGR; TRACE_FUNCTION ("rConcSMS_PercentCMGMDU ()"); if (prm->currConcBufListElem NEQ NULL) { T_CONC_BUF_ELEM *elem; elem = (T_CONC_BUF_ELEM *)prm->currConcBufListElem->msg; sAT_PercentCMGMDU_Gl((T_ACI_CMD_SRC)concShrdPrm.srcId, elem->rec_num, rConcSMS_PercentCMGMDU); prm->currConcBufListElem = prm->currConcBufListElem->next; } else /* if (concShrdPrm.currConcBufListElem NEQ NULL) */ { if( concShrdPrm.srcId NEQ CMD_SRC_LCL ) R_AT ( RAT_OK, (T_ACI_CMD_SRC) concShrdPrm.srcId ) ( AT_CMD_P_CMGMDU ); UNSET_CONC; } } GLOBAL void rConcSMS_PlusCMGW ( UBYTE index, UBYTE numSeg, UBYTE mem) { T_ACI_SM_DATA data; T_ACI_UDH_DATA udh; USHORT len_left; T_CONC_CMGW *prm = &concShrdPrm.specPrm.concCMGW; static UBYTE first_rec; TRACE_FUNCTION ("rConcSMS_PlusCMGW ()"); /* save the first index */ if (concShrdPrm.udh.seq_num EQ 1) { first_rec = index; } concSMS_addToConcatList((USHORT)concShrdPrm.udh.ref_num, prm->p_da, concShrdPrm.udh.max_num, concShrdPrm.udh.seq_num, index, (T_ACI_SMS_STAT)prm->stat, mem); concSMS_printConcatList(); len_left = prm->data.len - prm->offset; if (len_left NEQ 0) { prm->sent_bytes += concShrdPrm.max_sms_len; if ( len_left > concShrdPrm.max_sms_len ) { data.len = concShrdPrm.max_sms_len; } else { data.len = (UBYTE)len_left; } memcpy (data.data, prm->data.data+prm->offset, data.len); prm->offset += data.len; concShrdPrm.udh.seq_num++; /* fill user data header structure */ concSMS_fillUDH ( &udh, concShrdPrm.udh.ref_num, concShrdPrm.udh.max_num, concShrdPrm.udh.seq_num ); sAT_PlusCMGW_Gl((T_ACI_CMD_SRC)concShrdPrm.srcId, CMGW_IDX_FREE_ENTRY, prm->p_da, prm->p_toda, (T_ACI_SMS_STAT)prm->stat, prm->msg_ref, &data, &udh, prm->p_sca, prm->p_tosca, prm->isReply, rConcSMS_PlusCMGW, rConcSMS_PlusCMS_CMGW); } else { #ifdef _CONC_TESTING_ char *sa; ACI_MALLOC(sa,KEY + BYTE_LTH); sprintf(sa,"+CMGW: %d,%d",first_rec, concShrdPrm.udh.seq_num); io_sendMessage(concShrdPrm.srcId, sa, ATI_NORMAL_OUTPUT); ACI_MFREE(sa); #endif rAT_PlusCMGW (first_rec, concShrdPrm.udh.seq_num, mem); R_AT ( RAT_OK, (T_ACI_CMD_SRC)concShrdPrm.srcId ) ( AT_CMD_CMGW ); UNSET_CONC; } } GLOBAL void rConcSMS_PlusCMGD ( ) { T_CONC_CMGD *prm = &concShrdPrm.specPrm.concCMGD; T_CONC_BUF_ELEM *elem; T_ACI_LIST *conc_list; TRACE_FUNCTION ("rConcSMS_PlusCMGD ()"); elem = (T_CONC_BUF_ELEM *)prm->currConcBufListElem->msg; /* remove the old element from concatenation list and free its memory */ conc_list = concSMS_removeFromConcatList(prm->ref_num, prm->address, elem->rec_num); concSMS_printConcatList(); if (conc_list NEQ NULL) { TRACE_EVENT("conc_list not null"); elem = (T_CONC_BUF_ELEM *)conc_list->msg; /* save the concatenation list */ prm->currConcBufListElem= conc_list; /* set mem1 (memory from which messages are read and deleted) temporary to the value stored in conc buffer */ smsShrdPrm.mem1 = elem->mem; sAT_PlusCMGD_Gl((T_ACI_CMD_SRC)concShrdPrm.srcId, elem->rec_num, smsShrdPrm.status, rConcSMS_PlusCMGD, rConcSMS_PlusCMS_CMGD); } else /* if (concShrdPrm.currConcBufListElem NEQ NULL) */ { if (concShrdPrm.full.Conc_Full EQ TRUE) { concSMS_AddtoconcBuff(); concShrdPrm.full.Conc_Full = FALSE; } /* restore value for mem1 */ smsShrdPrm.mem1 = concShrdPrm.mem_store; TRACE_EVENT("RAT_OK in rConcSMS_PlusCMGD"); R_AT ( RAT_OK, (T_ACI_CMD_SRC) concShrdPrm.srcId ) ( AT_CMD_CMGD ); UNSET_CONC; } } GLOBAL void rConcSMS_PlusCMGC ( UBYTE mr ) { UBYTE mn; T_CONC_CMGC *prm = &concShrdPrm.specPrm.concCMGC; TRACE_FUNCTION ("rConcSMS_PlusCMGC ()"); /* save the first message reference */ if (concShrdPrm.udh.seq_num EQ 1) { concShrdPrm.first_mr = mr; } prm->command_count++; if (prm->command_count < concShrdPrm.sentSegs) { mn = concShrdPrm.first_mr + prm->command_count; sAT_PlusCMGC_Gl((T_ACI_CMD_SRC)concShrdPrm.srcId, prm->fo, prm->ct, prm->pid, mn, prm->p_da, prm->p_toda, (T_ACI_CMD_DATA*)&prm->data, rConcSMS_PlusCMGC); } else { #ifdef _CONC_TESTING_ char *sa; ACI_MALLOC(sa,KEY + BYTE_LTH); sprintf(sa,"+CMGC: %d",concShrdPrm.first_mr /*, prm->command_count*/); io_sendMessage(concShrdPrm.srcId, sa, ATI_NORMAL_OUTPUT); ACI_MFREE(sa); #endif ACI_MFREE( prm->data.data ); rAT_PlusCMGC (concShrdPrm.first_mr/*, prm->command_count*/); R_AT ( RAT_OK,(T_ACI_CMD_SRC) concShrdPrm.srcId ) ( AT_CMD_CMGC ); UNSET_CONC; } } GLOBAL void rConcSMS_PlusCMS_CMSS (T_ACI_AT_CMD cmdId, T_ACI_CMS_ERR err, T_EXT_CMS_ERROR *ce) { T_EXT_CMS_ERROR conc_error; #ifdef _CONC_TESTING_ char *sa; #endif TRACE_FUNCTION ("rConcSMS_PlusCMS_CMSS ()"); conc_error.id = CMSS_CONC; conc_error.specErr.errConcCMSS.segs = concShrdPrm.udh.max_num - concShrdPrm.sentSegs; #ifdef _CONC_TESTING_ ACI_MALLOC(sa,KEY + BYTE_LTH); sprintf(sa,"+CMS ERROR: %d,%d",err, conc_error.specErr.errConcCMSS.segs); io_sendMessage(concShrdPrm.srcId, sa, ATI_NORMAL_OUTPUT); ACI_MFREE(sa); rCI_PlusCMS ( cmdId, err, NULL ); #endif /* restore value for mem2 */ smsShrdPrm.mem2 = concShrdPrm.mem_store; rAT_PlusCMS (cmdId, err, &conc_error); UNSET_CONC; } GLOBAL void rConcSMS_PlusCMS_CMGS (T_ACI_AT_CMD cmdId, T_ACI_CMS_ERR err, T_EXT_CMS_ERROR *ce) { T_EXT_CMS_ERROR conc_error; #ifdef _CONC_TESTING_ char *sa; #endif TRACE_FUNCTION ("rConcSMS_PlusCMS_CMGS ()"); conc_error.id = CMGS_CONC; conc_error.specErr.errConcCMGS.sent_chars = concShrdPrm.specPrm.concCMGS.sent_bytes; conc_error.specErr.errConcCMGS.ref_num = concShrdPrm.udh.ref_num; conc_error.specErr.errConcCMGS.next_seg = concShrdPrm.udh.seq_num; conc_error.specErr.errConcCMGS.max_num = concShrdPrm.udh.max_num; #ifdef _CONC_TESTING_ ACI_MALLOC(sa,KEY + BYTE_LTH); sprintf(sa,"+CMS ERROR: %d,%d,%d,%d,%d",err, conc_error.specErr.errConcCMGS.sent_chars, conc_error.specErr.errConcCMGS.ref_num, conc_error.specErr.errConcCMGS.next_seg, conc_error.specErr.errConcCMGS.max_num); io_sendMessage(concShrdPrm.srcId, sa, ATI_NORMAL_OUTPUT); ACI_MFREE(sa); rCI_PlusCMS ( cmdId, err, NULL ); #endif rAT_PlusCMS (cmdId, err, &conc_error); UNSET_CONC; } GLOBAL void rConcSMS_PlusCMS_CMGW (T_ACI_AT_CMD cmdId, T_ACI_CMS_ERR err, T_EXT_CMS_ERROR *ce) { T_EXT_CMS_ERROR conc_error; #ifdef _CONC_TESTING_ char *sa; #endif TRACE_FUNCTION ("rConcSMS_PlusCMS_CMGW ()"); conc_error.id = CMGW_CONC; conc_error.specErr.errConcCMGW.sent_chars = concShrdPrm.specPrm.concCMGW.sent_bytes; conc_error.specErr.errConcCMGW.ref_num = concShrdPrm.udh.ref_num; conc_error.specErr.errConcCMGW.next_seg = concShrdPrm.udh.seq_num; conc_error.specErr.errConcCMGW.max_num = concShrdPrm.udh.max_num; #ifdef _CONC_TESTING_ ACI_MALLOC(sa,KEY + BYTE_LTH); sprintf(sa,"+CMS ERROR: %d,%d,%d,%d,%d",err, conc_error.specErr.errConcCMGW.sent_chars, conc_error.specErr.errConcCMGW.ref_num, conc_error.specErr.errConcCMGW.next_seg, conc_error.specErr.errConcCMGW.max_num); io_sendMessage(concShrdPrm.srcId, sa, ATI_NORMAL_OUTPUT); ACI_MFREE(sa); rCI_PlusCMS ( cmdId, err, NULL ); #endif rAT_PlusCMS (cmdId, err, &conc_error); UNSET_CONC; } GLOBAL void rConcSMS_PlusCMS_CMGD (T_ACI_AT_CMD cmdId, T_ACI_CMS_ERR err, T_EXT_CMS_ERROR *ce) { T_CONC_CMGD *prm = &concShrdPrm.specPrm.concCMGD; T_CONC_BUF_ELEM *elem; T_EXT_CMS_ERROR conc_error; TRACE_FUNCTION ("rConcSMS_PlusCMS_CMGD ()"); conc_error.id = EMPTY; prm->error_count++; if (prm->error_count EQ concShrdPrm.udh.max_num) { #ifdef _CONC_TESTING_ char *sa; ACI_MALLOC(sa,KEY + BYTE_LTH); sprintf(sa,"+CMS ERROR: %d",err); io_sendMessage(concShrdPrm.srcId, sa, ATI_NORMAL_OUTPUT); ACI_MFREE(sa); rCI_PlusCMS ( cmdId, err, NULL ); #endif elem = (T_CONC_BUF_ELEM *)prm->currConcBufListElem->msg; /* remove the old element from concatenation list and free its memory */ concSMS_removeFromConcatList(prm->ref_num, prm->address, elem->rec_num); concSMS_printConcatList(); /* restore value for mem1 */ smsShrdPrm.mem1 = concShrdPrm.mem_store; rAT_PlusCMS ( cmdId, err, &conc_error); UNSET_CONC; } else { /* continue with the next segment */ rConcSMS_PlusCMGD(); } } #endif /* TI_PS_FF_CONC_SMS */ /*************** Functions which must be called by MFW ***************/ /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : SMS_getSMSType | +--------------------------------------------------------------------+ PURPOSE : This function must be called by the MFW to detect the SMS type from the information element identifier. */ GLOBAL T_SMS_TYPE SMS_getSMSType( T_ACI_UDH_DATA* udh, char *address, UBYTE detMode) { USHORT ref_num = 0; UBYTE seq_num = 0; UBYTE max_num = 0; USHORT count; T_CONC_BUF* concBuf; TRACE_FUNCTION ("SMS_getSMSType()"); TRACE_EVENT_P1("SMS_getSMSType, mode: %d", detMode); if (udh->len EQ 0) { /* SMS does not contain UDH --> normal SMS */ return NORMAL; } /* check if IE is conc SMS */ if ((udh->data[0] EQ SMS_IEI_CONC_8BIT) OR (udh->data[0] EQ SMS_IEI_CONC_16BIT)) { if (udh->data[0] EQ SMS_IEI_CONC_8BIT) { ref_num = udh->data[2]; max_num = udh->data[3]; seq_num = udh->data[4]; } if (udh->data[0] EQ SMS_IEI_CONC_16BIT) { ref_num = (udh->data[2] & 0x00FF) << 8u; ref_num += udh->data[3]; max_num = udh->data[4]; seq_num = udh->data[5]; } switch (detMode) { case MODE1: /* This mode is for rAT_PlusCMT. No Concatenation buffer is needed at all */ break; case MODE2: /* This mode is for rAT_PlusCMTI. This mode requires the allocation of a new * Concatenation buffer (later in concSMS_Collect). Make sure that in case * the conc buffer is full no new CSMS is handled anymore */ concBuf = concSMS_getConcBuffer( ref_num, address ); /* if a new conc buffer is be needed, check if available */ if (concBuf EQ NULL) { if (concSMS_concBufferAvail() EQ FALSE) { return NORMAL_IND_CSMS; } /* Limit the maximum number of CSMS segments to MAX_SEG_TOTAL. Check * only if a new Concatenation buffer is required. */ if (concShrdPrm.elem_count+max_num > MAX_SEG_TOTAL) { return NORMAL_IND_CSMS; } } break; case MODE3: /* This mode is for rAT_PlusCMGL, rAT_PlusCMGR, sms_store_new_msg_info and * sms_store_new_msg_info. Only segments that have been previously stored * in the Concatenation buffer can be handled as CSMS. */ concBuf = concSMS_getConcBuffer( ref_num, address ); if (concBuf EQ NULL) { return NORMAL_IND_CSMS; } /* check if conc buffer is incomplete */ count = get_list_count(concBuf->list); if ((count < concBuf->max_num) AND (count < CONC_MAX_SEGS)) { return NORMAL_IND_CSMS; } break; default: TRACE_ERROR("Wrong detection mode in SMS_getSMSType"); return UNKNOWN; } /* check if sequence number is in range */ if (seq_num <= CONC_MAX_SEGS) { return CONCATE; } else { return NORMAL_IND_CSMS; } } else { /* unknown IE in UDH --> no CSMS */ return UNKNOWN; } } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_GetFirstIndex | +--------------------------------------------------------------------+ PURPOSE : This function provides MFW with the first index of a given concatenated SMS (identified by its message reference). returns first index: (0 means no message found...) */ #define FIRST_SEQ_NUM (1) GLOBAL T_CONC_BUF_ELEM *concSMS_GetFirstIndex_ext ( USHORT msg_ref, char *address ) { T_CONC_BUF *concBuf; T_CONC_BUF_ELEM *concBufElem; TRACE_FUNCTION ("concSMS_GetFirstIndex()"); /* search for concatenation buffer */ concBuf = concSMS_getConcBuffer( msg_ref, address ); if( concBuf EQ NULL ) { TRACE_EVENT_P1("ERROR: unknown msg_ref: 0x%04x", msg_ref); return( NULL ); } /* search for the first sequence */ concBufElem = find_element(concBuf->list, FIRST_SEQ_NUM, concSMS_findSeqNumElemCB); if( concBufElem EQ NULL ) { TRACE_EVENT("ERROR: first sequence not found"); return( NULL ); } TRACE_EVENT_P1("first rec_num: %d", concBufElem->rec_num); TRACE_EVENT_P1 ("concSMS_GetFirstIndex_ext(), rec_num=%d", concBufElem->rec_num); /* return index of first segment */ return(concBufElem); } GLOBAL UBYTE concSMS_GetFirstIndex ( USHORT msg_ref, char *address ) { T_CONC_BUF_ELEM *concBufElem = concSMS_GetFirstIndex_ext(msg_ref, address); if( concBufElem EQ NULL ) { TRACE_EVENT("ERROR: first sequence not found"); return(0); } else return(concBufElem->rec_num); } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_GetMsgRef | +--------------------------------------------------------------------+ PURPOSE : This function provides MFW with the message reference of a given concatenated SMS (decoded from the header). returns msg ref. */ GLOBAL USHORT concSMS_GetMsgRef ( T_ACI_CMGL_SM *sm ) { USHORT ref_num; TRACE_FUNCTION ("concSMS_GetMsgRef()"); if( sm EQ NULL ) { TRACE_ERROR("sm is NULL"); return 0; } /* 8-bit reference number */ if (sm->udh.data[0] EQ SMS_IEI_CONC_8BIT) { ref_num = sm->udh.data[2]; } /* 16-bit reference number */ else if (sm->udh.data[0] EQ SMS_IEI_CONC_16BIT) { /* MSB */ ref_num = (sm->udh.data[2] & 0x00FF) << 8u; /* 23.040 9.1.2.1 */ /* LSB */ ref_num |= sm->udh.data[3]; } else { TRACE_ERROR("sm->udh.data unknown"); return 0; } TRACE_EVENT_P1("ref_num: 0x%04x", ref_num); return(ref_num); } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_Collect | +--------------------------------------------------------------------+ PURPOSE : This function must be called by the MFW. The function reassembles the received SM segments. Set 'isStored' to: TRUE, if rAT_PlusCMTI() was called FALSE, if rAT_PlusCMT() was called FALSE, if rAT_PlusCMGR() was called */ GLOBAL T_CONC_ASSEMBLY_RETURN concSMS_Collect ( T_SM_DATA_EXT *data_conc, T_ACI_CMGL_SM *sm, UBYTE isStored, T_ACI_SMS_STOR mem_aci) { USHORT ref_num = 0; UBYTE max_num = 0; UBYTE seq_num = 0; UBYTE rec_num; T_SM_ASSEMBLY *assembly_elem; T_SEG_BUF_ELEM *segBufElem; T_SM_DATA_EXT data; T_ACI_SMS_STAT status; UBYTE next_exp_num; UBYTE ret; static UBYTE i = 0; UBYTE mem_psa; CHAR *address; TRACE_FUNCTION ("concSMS_Collect()"); /* initialize data_conc->len */ data_conc->len = 0; /* ACI-SPR-16372 */ /* extract parameters from user data header */ /* 8-bit reference number */ if (sm->udh.data[0] EQ SMS_IEI_CONC_8BIT) { ref_num = sm->udh.data[2]; max_num = sm->udh.data[3]; seq_num = sm->udh.data[4]; } /* 16-bit reference number */ else if (sm->udh.data[0] EQ SMS_IEI_CONC_16BIT) { /* MSB */ ref_num = (sm->udh.data[2] & 0x00FF) << 8u; /* 23.040 9.1.2.1 */ /* LSB */ ref_num += sm->udh.data[3]; max_num = sm->udh.data[4]; seq_num = sm->udh.data[5]; } rec_num = sm->msg_ref; status = sm->stat; address = sm->adress; data.data = sm->data.data; data.len = sm->data.len; TRACE_EVENT_P1("rec_num:%d", rec_num); TRACE_EVENT_P1("concSMS_GetFirstIndex():%d", concSMS_GetFirstIndex (ref_num, sm->adress)); TRACE_EVENT_P1("ref_num:0x%04x", ref_num); TRACE_EVENT_P1("concSMS_GetMsgRef():0x%04x", concSMS_GetMsgRef ( sm )); TRACE_EVENT_P1("max_num:%d", max_num); TRACE_EVENT_P1("seq_num:%d", seq_num); /* try to get an existing assembly buffer */ assembly_elem = concSMS_getAsBuffer(ref_num, address); /* if no assembly buffer found, then assume that is a new conc. SM */ if (assembly_elem EQ NULL) { next_exp_num = 1; } else { next_exp_num = assembly_elem->next_exp_num; } /* the received seq_num is not valid */ if ( (seq_num EQ 0) OR (seq_num > max_num) OR (seq_num < next_exp_num) ) { return CONC_ERR_UNKN; } /* * If CMTI, then add every received segment to concatenation buffer. * The segments in the concatenation buffer were also stored in non-volatile * memory. */ if (isStored) { if (cmhSMS_getMemPsa(mem_aci, &mem_psa) EQ FALSE) { return CONC_ERR_UNKN; } ret = concSMS_addToConcatList(ref_num, address, max_num, seq_num, rec_num, status, mem_psa); if (ret EQ FALSE) { dFLAG = TRUE; RefNum_Del = ref_num; concShrdPrm.full.Conc_Full = TRUE; concShrdPrm.full.RefNum = ref_num; memcpy(Addres,address,sizeof(Addres)); concShrdPrm.full.MaxNum = max_num; concShrdPrm.full.SeqNum[i] = seq_num; concShrdPrm.full.RecNum[i] = rec_num; concShrdPrm.full.MemType[i] = mem_psa; i++; concShrdPrm.full.Numsegs = i; /* error: concatenation buffer full */ return CONC_ERR_BUF_FULL; } } i = 0; if ( seq_num > next_exp_num ) { /* * the received segment is not in sequence * -> add it to the segment buffer */ ret = concSMS_addToSegBuffer(ref_num, address, seq_num, rec_num, status, &data); if (ret EQ FALSE) { /* error: segment buffer full */ return CONC_ERR_BUF_FULL; } return CONC_CONTINUED; } else { /* * the received segment is in sequence */ while (1) { /* add segment to assembly buffer */ assembly_elem = concSMS_addToAsBuffer (ref_num, address, max_num, &data); /* free data memory only for data from segment buffer */ if (data.data NEQ sm->data.data) { ACI_MFREE (data.data); } /* error: no assembly buffer available */ if (assembly_elem EQ NULL) { return CONC_ERR_BUF_FULL; } /* assembly of concatenated SM is completed */ if (assembly_elem->next_exp_num EQ max_num+1) { concSMS_removeFromAsBuffer(data_conc, ref_num, address); concSMS_sortConcatList(ref_num, address); return CONC_COMPLETED; } /* maximum reached in assembly buffer , assembly is NOT completed */ if (assembly_elem->seg_count EQ CONC_MAX_SEGS) { concSMS_getFromAsBuffer(data_conc, ref_num, address); concSMS_sortConcatList(ref_num, address); return CONC_COMPLETED; } /* search and remove the next segment from segment buffer */ segBufElem = concSMS_removeFromSegBuffer(ref_num, address, assembly_elem->next_exp_num); if ( segBufElem EQ NULL ) { /* no segment found */ return CONC_CONTINUED; } /* for adding to concatenation list */ rec_num = segBufElem->rec_num; status = (T_ACI_SMS_STAT)segBufElem->status; /* for adding to assembly buffer */ data.data = segBufElem->data.data; data.len = segBufElem->data.len; ACI_MFREE(segBufElem); } /* while */ } /* if ( seq_num EQ next_exp_num ) */ } GLOBAL void concSMS_Init() { concShrdPrm.isConcatenated = FALSE; memset (&concShrdPrm, 0, sizeof(T_CONC_SHRD_PRM) ); memset (&assembly_list, 0, sizeof(T_SM_ASSEMBLY)*MAX_BUF_ELEMS); memset (&segBuf_list, 0, sizeof(T_SEG_BUF) *MAX_BUF_ELEMS); memset (&concBuf_list, 0, sizeof(T_CONC_BUF) *MAX_CONC_BUF_ELEMS); concShrdPrm.l_uncomp8bit_data = L_UNCOMP_8BIT_DATA; concShrdPrm.l_uncomp7bit_data = L_UNCOMP_7BIT_DATA; concShrdPrm.l_uncomp8bit_data_conc = L_UNCOMP_8BIT_DATA_CONC; concShrdPrm.l_uncomp7bit_data_conc = L_UNCOMP_7BIT_DATA_CONC; concShrdPrm.elem_count = 0; #ifdef _CONC_TESTING_ #ifndef _SIMULATION_ concSMS_InitForTesting(); #endif #endif } /* only for test purposes */ GLOBAL void concSMS_InitForTesting() { concShrdPrm.concTesting = TRUE; concShrdPrm.l_uncomp8bit_data = L_UNCOMP_8BIT_DATA_TST; concShrdPrm.l_uncomp7bit_data = L_UNCOMP_7BIT_DATA_TST; concShrdPrm.l_uncomp8bit_data_conc = L_UNCOMP_8BIT_DATA_CONC_TST; concShrdPrm.l_uncomp7bit_data_conc = L_UNCOMP_7BIT_DATA_CONC_TST; } /* +--------------------------------------------------------------------+ | PROJECT : MODULE : CONC_SMS | | STATE : code ROUTINE : concSMS_delAllIncompleteMsg| +--------------------------------------------------------------------+ PURPOSE : This function must be called by the MFW to clean all segment buffers, assembly buffers and remove all incompleted SM from concat. buffer and non-volatile memory. */ GLOBAL void concSMS_delAllIncompleteMsg( ) { T_SEG_BUF *segBuf = NULL; T_SEG_BUF_ELEM *segBufElem; T_CONC_BUF *concBuf = NULL; T_CONC_BUF_ELEM *concBufElem; T_SM_ASSEMBLY *assembly_elem; USHORT count; UBYTE i; TRACE_FUNCTION ("concSMS_delAllIncompleteMsg()"); concShrdPrm.srcId = CMD_SRC_LCL; for (i=0; i<MAX_BUF_ELEMS; i++) { /* delete assembly buffer */ if (assembly_list[i].in_use) { assembly_elem = &assembly_list[i]; assembly_elem->in_use = FALSE; ACI_MFREE(assembly_elem->data.data); } /* delete segment buffer */ if (segBuf_list[i].in_use) { segBuf = &segBuf_list[i]; /* remove element from segment buffer */ segBufElem = remove_first_element(segBuf->list); if (segBufElem NEQ NULL) { /* free memory */ ACI_MFREE(segBufElem->data.data); ACI_MFREE(segBufElem); } else { segBuf->in_use = FALSE; } } } /* for */ for (i=0; i<MAX_CONC_BUF_ELEMS; i++) { /* find concat. buffer in use */ if (concBuf_list[i].in_use) { /* get number of segments in this concat. buffer */ count = get_list_count(concBuf_list[i].list); /* conc buffer is incomplete */ if ((count < concBuf_list[i].max_num) AND (count < CONC_MAX_SEGS)) { if (count EQ 0) { /* last element of one conc buffer was deleted */ concBuf_list[i].in_use = FALSE; R_AT ( RAT_OK,(T_ACI_CMD_SRC) concShrdPrm.srcId ) ( AT_CMD_CMGC ); continue; } concBuf = &concBuf_list[i]; break; } } } if (concBuf) { /* remove element from concat. buffer */ concBufElem = remove_first_element(concBuf->list); if (concBufElem) { /* delete segment from non-volatile memory */ #ifdef TI_PS_FF_CONC_SMS sAT_PlusCMGD_Gl((T_ACI_CMD_SRC)concShrdPrm.srcId, concBufElem->rec_num, smsShrdPrm.status, concSMS_delAllIncompleteMsg, rConcSMS_PlusCMS_CMGD); #else sAT_PlusCMGD_Gl(concShrdPrm.srcId, concBufElem->rec_num, smsShrdPrm.status, concSMS_delAllIncompleteMsg, rAT_PlusCMS); #endif /* TI_PS_FF_CONC_SMS */ /* free memory */ ACI_MFREE(concBufElem); /* decrease total count of stored CSMS segments by 1*/ concShrdPrm.elem_count--; } } } /************** Help Functions ******************************/ /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CONC_SMS | | ROUTINE : concSMS_printConcatList | +-------------------------------------------------------------------+ PURPOSE : */ LOCAL void concSMS_printConcatList () { T_ACI_LIST *current; UBYTE i; T_CONC_BUF *concBuf; T_CONC_BUF_ELEM *elem; TRACE_EVENT("Concatenation List:"); for (i=0; i<MAX_CONC_BUF_ELEMS; i++) { if (concBuf_list[i].in_use EQ TRUE) { concBuf = &concBuf_list[i]; TRACE_EVENT_P2(" ref_num: 0x%04x , max_num: %u", concBuf->ref_num, concBuf->max_num); current = concBuf->list; while (current) { elem = (T_CONC_BUF_ELEM*) current->msg; TRACE_EVENT_P4(" seq_num: %d , rec_num: %d , status: %d, mem= %d", elem->seq_num, elem->rec_num, elem->status, elem->mem); current = current->next; } } } } /* Marcus: Issue 872: 03/10/2002 +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CONC_SMS | | ROUTINE : concSMS_findMaxRefNum | +-------------------------------------------------------------------+ PURPOSE : Find the highest value of concBuf_list[i].ref_num */ LOCAL USHORT concSMS_findMaxRefNum(void) { UBYTE i; USHORT ref_num = 0; TRACE_FUNCTION("concSMS_findMaxRefNum()"); for (i=0; i<MAX_CONC_BUF_ELEMS; i++) { if (concBuf_list[i].in_use EQ TRUE) { if ((concBuf_list[i].ref_num & 0x00ff)> ref_num) /* since we use only 8-Bit ref_num */ ref_num = concBuf_list[i].ref_num & 0x00ff; } } return ref_num; } GLOBAL void concSMS_clearIncompleteMsg() { T_SEG_BUF *segBuf = NULL; T_SEG_BUF_ELEM *segBufElem; T_SM_ASSEMBLY *assembly_elem; T_CONC_BUF *concBuf = NULL; T_CONC_BUF_ELEM *concBufElem; UBYTE i; TRACE_FUNCTION ("concSMS_clearIncompleteMsg()"); if (RefNum_Del EQ concShrdPrm.full.RefNum) { concShrdPrm.full.Conc_Full = FALSE; concShrdPrm.full.RefNum = 0xFF; } for (i=0; i<MAX_BUF_ELEMS; i++) { /* delete assembly buffer */ if (assembly_list[i].in_use AND assembly_list[i].ref_num EQ RefNum_Del) { assembly_elem = &assembly_list[i]; assembly_elem->in_use = FALSE; ACI_MFREE(assembly_elem->data.data); break; } /* delete segment buffer */ if (segBuf_list[i].in_use AND segBuf_list[i].ref_num EQ RefNum_Del) { segBuf = &segBuf_list[i]; /*remove element from segment buffer */ segBufElem = remove_first_element(segBuf->list); if (segBufElem NEQ NULL) { segBuf->in_use = FALSE; /* free memory */ ACI_MFREE(segBufElem->data.data); ACI_MFREE(segBufElem); } else { segBuf->in_use = FALSE; } break; } } for (i=0; i<MAX_CONC_BUF_ELEMS; i++) { /* find concat. buffer in use */ if (concBuf_list[i].in_use AND concBuf_list[i].ref_num EQ RefNum_Del) { concBuf_list[i].in_use = FALSE; concBuf = &concBuf_list[i]; break; } } if (concBuf) { /* remove element from concat. buffer */ concBufElem = remove_first_element(concBuf->list); if (concBufElem) { /* free memory */ ACI_MFREE(concBufElem); /* decrease total count of stored CSMS segments by 1*/ concShrdPrm.elem_count--; } } } GLOBAL void concSMS_AddtoconcBuff(void) { UBYTE i; TRACE_FUNCTION("concSMS_AddtoconcBuff()"); for (i=0;i<concShrdPrm.full.Numsegs;i++) { concSMS_addToConcatList(concShrdPrm.full.RefNum,Addres, concShrdPrm.full.MaxNum,concShrdPrm.full.SeqNum[i], concShrdPrm.full.RecNum[i],SMS_STAT_RecRead,concShrdPrm.full.MemType[i]); } } /* +-------------------------------------------------------------------+ | PROJECT : GSM-PS (6147) MODULE : CONC_SMS | | ROUTINE : concSMS_DeleteConcList | +-------------------------------------------------------------------+ PURPOSE : This function is used to delete the concatinated SMS, when the CMGD command contails the delete flag greater than ZERO. */ GLOBAL void concSMS_DeleteConcList ( ) { T_CONC_CMGD *prm = &concShrdPrm.specPrm.concCMGD; T_CONC_BUF_ELEM *elem; T_ACI_LIST *conc_list; TRACE_FUNCTION ("concSMS_DeleteConcList()"); elem = (T_CONC_BUF_ELEM *)prm->currConcBufListElem->msg; /* remove the old element from concatenation list and free its memory */ conc_list = concSMS_removeFromConcatList(prm->ref_num, prm->address, elem->rec_num); concSMS_printConcatList(); if (conc_list NEQ NULL) { TRACE_EVENT("conc_list not null"); elem = (T_CONC_BUF_ELEM *)conc_list->msg; /* save the concatenation list */ prm->currConcBufListElem= conc_list; } else /* if (concShrdPrm.currConcBufListElem NEQ NULL) */ { TRACE_EVENT("Concat List is NULL : concSMS_DeleteConcList"); UNSET_CONC; } } #ifdef TI_PS_FF_CONC_SMS GLOBAL void rConcSMS_PercentCMGR ( T_ACI_CMGL_SM* sm, T_ACI_CMGR_CBM* cbm ) { T_CONC_CMGR *prm = &concShrdPrm.specPrm.concCMGR; TRACE_FUNCTION ("rConcSMS_PercentCMGR ()"); if (prm->currConcBufListElem NEQ NULL) { T_CONC_BUF_ELEM *elem; elem = (T_CONC_BUF_ELEM *)prm->currConcBufListElem->msg; sAT_PercentCMGR_Gl((T_ACI_CMD_SRC)concShrdPrm.srcId, elem->rec_num, (T_ACI_SMS_READ) concShrdPrm.specPrm.concCMGR.rdMode, rConcSMS_PercentCMGR); prm->currConcBufListElem = prm->currConcBufListElem->next; #ifdef _CONC_TESTING_ rAT_PercentCMGR_Ext (sm, cbm); #else rAT_PercentCMGR (sm, cbm); #endif } else /* if (concShrdPrm.currConcBufListElem NEQ NULL) */ { #ifdef _CONC_TESTING_ rAT_PercentCMGR_Ext (sm, cbm); #else rAT_PercentCMGR (sm, cbm); #endif R_AT ( RAT_OK, (T_ACI_CMD_SRC)concShrdPrm.srcId ) ( AT_CMD_P_CMGR ); UNSET_CONC; } } #endif /* TI_PS_FF_CONC_SMS */ /* * This functions checks if the conc can be extended. If the maximum * capacity is reached the CSMS will be handled as normal (single) SMS. */ BOOL concSMS_concBufferAvail() { USHORT count=0; int i; TRACE_FUNCTION("concSMS_concBufferAvail"); /* check if there is a free conc buffer available */ for (i=0; i<MAX_CONC_BUF_ELEMS; i++) { if (concBuf_list[i].in_use EQ TRUE) { count++; } } if (count >= MAX_CONC_BUF_ELEMS) { return FALSE; /* all conc buffer in use, no free available */ } return TRUE; }