+
−/*
+
−+-----------------------------------------------------------------------------
+
−|  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 "config.h"
+
−#include "fixedconf.h"
+
−#include "condat-features.h"
+
−#include "aci_conf.h"
+
−
+
−#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;
+
−}