+
−/* 
+
−+----------------------------------------------------------------------------- 
+
−|  Project :  MMI-Framework (8417)
+
−|  Modul   :  PHB
+
−+----------------------------------------------------------------------------- 
+
−|  Copyright 2002 Texas Instruments Berlin, AG 
+
−|                 All rights reserved. 
+
−| 
+
−|                 This file is confidential and a trade secret of Texas 
+
−|                 Instruments Berlin, AG 
+
−|                 The receipt of or possession of this file does not convey 
+
−|                 any rights to reproduce or disclose its contents or to 
+
−|                 manufacture, use, or sell anything it may describe, in 
+
−|                 whole, or in part, without the specific written consent of 
+
−|                 Texas Instruments Berlin, AG. 
+
−+----------------------------------------------------------------------------- 
+
−|  Purpose :  This modul contains the functions to establish the phone book.
+
−+----------------------------------------------------------------------------- 
+
−*/
+
−
+
−#ifdef TI_PS_FFS_PHB
+
−
+
−#include "aci_all.h"
+
−#include "aci_cmh.h"
+
−#include "aci_mem.h"
+
−
+
−#include "phb_aci.h"
+
−
+
−#ifdef _SIMULATION_
+
−  /*
+
−   * Unfortunately we have a double definition of some preprocessor definitions
+
−   * within windows.h and within the protocol stack, so we undefine here.
+
−   */
+
−  #undef PARITY_NONE
+
−  #undef PARITY_ODD
+
−  #undef PARITY_EVEN
+
−  #undef DRV_OK
+
−  #include "ffs_pc_api.h"
+
−  #undef PARITY_NONE
+
−  #undef PARITY_ODD
+
−  #undef PARITY_EVEN
+
−  #undef DRV_OK
+
−#else
+
−  #include "ffs/ffs.h"
+
−#endif
+
−
+
−#ifdef SIM_TOOLKIT
+
−#include "psa.h"
+
−#include "psa_sim.h"
+
−#include "psa_cc.h"
+
−#include "psa_sat.h"
+
−#endif /* #ifdef SIM_TOOLKIT */
+
−
+
−#include "cmh.h"
+
−#include "cmh_phb.h"
+
−
+
−#ifdef DTI
+
−#include "dti_conn_mng.h"
+
−#endif
+
−#include "cmh_sim.h"
+
−
+
−
+
−/*
+
− * Constants and enumerations
+
− */
+
−/* #define NR_EF_ICI             20   LRN, LMN */
+
−/* #define SIZE_EF_ICI           (28+16)  alpha id 16 bytes, 31.102 clause 4.2.33 */
+
−
+
−#define NR_EF_OCI             10  /* Arbitrary, LDN */
+
−#define SIZE_EF_OCI           (27+16)  /* alpha id 16 bytes, 31.102 clause 4.2.34 */
+
−
+
−#define NR_EF_EXT5            10  /* Arbitrary */
+
−#define SIZE_EF_EXT5          13  /* 31.102 clause 4.2.37 */
+
−
+
−#define NR_EF_LRN             10  /* Arbitrary, LRN */
+
−#define SIZE_EF_LRN           SIZE_EF_OCI
+
−
+
−#define NR_EF_LMN             10  /* Arbitrary, LMN */
+
−#define SIZE_EF_LMN           SIZE_EF_OCI
+
−
+
−#define NR_EF_EXT_LRN         10  /* Arbitrary */
+
−#define SIZE_EF_EXT_LRN       SIZE_EF_EXT5
+
−
+
−#define NR_EF_EXT_LMN         10  /* Arbitrary */
+
−#define SIZE_EF_EXT_LMN       SIZE_EF_EXT5
+
−
+
−#define PHB_MAX_QUEUE         4   /* Queued LDN entries */
+
−#define SIM_MAX_RECORD_SIZE   256 /* Maximum size of a SIM record */
+
−
+
−#define PHB_STATE_NULL        0   /* NULL state before reading phonebook    */
+
−#define PHB_STATE_IDLE        1   /* IDLE state, phonebook has been read    */
+
−#define PHB_STATE_VERIFY      2   /* Verify SIM (Initialization, SAT)       */
+
−#define PHB_STATE_READ        3   /* Reading from SIM (Initialization, SAT) */
+
−#define PHB_STATE_WRITE       4   /* Write/Delete single record to SIM      */
+
−#define PHB_STATE_DELETE_BOOK 5   /* Delete a whole SIM phonebook           */
+
−
+
−#define SET_PHB_STATE(n)  pba_data.state = n;
+
−#define GET_PHB_STATE()   pba_data.state
+
−
+
−typedef struct 
+
−{
+
−  USHORT        index;
+
−  T_PHB_RECORD  entry;
+
−} T_PHB_QUEUE;
+
−
+
−/*
+
− * Type definitions
+
− */
+
−typedef struct
+
−{
+
−  /* Fixed Dialling Numbers mode */
+
−  T_PHB_FDN_MODE fdn_mode;
+
−
+
−  /* Fixed Dialling Number class type */
+
−  T_ACI_CLASS fdn_classtype;
+
−
+
−  /* T_PHB_STATE of the phonebook */
+
−  T_PHB_STAT phb_stat;
+
−  
+
−  /* Current state of the phonebook PHB_STATE_XXX */
+
−  UBYTE state;
+
−
+
−  /* SIM data */
+
−  UBYTE *data;
+
−  
+
−  /* SIM service table */
+
−  UBYTE sim_service_table[MAX_SRV_TBL];
+
−
+
−  /* Database has to be recreated (IMSI changed or DB unclean) */
+
−  BOOL db_recreate;
+
−
+
−  /* Paused elementary file if reading extension record, otherwise 0 */
+
−  USHORT paused_ef;
+
−
+
−  /* Paused record number if reading extension record, otherwise 0 */
+
−  UBYTE paused_no;
+
−
+
−  /* Delete all: Book to delete, Read: Current book reading */
+
−  T_PHB_TYPE current_book;
+
−  
+
−  /* Delete all: current record */
+
−  UBYTE del_record;
+
−
+
−  /* Book created */
+
−  BOOL book_created[MAX_PHONEBOOK];
+
−
+
−  /* Extension created */
+
−  BOOL ext_created[MAX_PHB_EXT];
+
−
+
−  /* We are reading the 1st ext record only to get the number of records */
+
−  BOOL ext_dummy_read;
+
−
+
−  /* Read flags for SIM phonebooks. Set to TRUE when reading has started */
+
−  BOOL book_read[MAX_PHONEBOOK];
+
−
+
−  /* Maximum number of phonebook records */
+
−  UBYTE phb_record_max[MAX_PHONEBOOK];
+
−  /* Maximum number of extension records */
+
−  UBYTE ext_record_max[MAX_PHB_EXT];
+
−
+
−  /* Record sizes of phonebook records */
+
−  UBYTE phb_record_len[MAX_PHONEBOOK];
+
−  /* Record sizes of extension records */
+
−  UBYTE ext_record_len[MAX_PHB_EXT];
+
−
+
−  /* Queued LDN entries during startup */
+
−  UBYTE c_queued;
+
−  T_PHB_QUEUE *queued[PHB_MAX_QUEUE];
+
−  
+
−  /* Records to be synchronized to the SIM */
+
−  T_DB_CHANGED records_changed;
+
−
+
−  /* To keep track of read extension records */
+
−  BOOL *read_ext_record;
+
−
+
−} T_PHB_ACI_DATA;
+
−
+
−/* We pack all internal data into one data structure */
+
−LOCAL T_PHB_ACI_DATA pba_data;
+
−
+
−
+
−/* 
+
− * Prototypes for local functions
+
− */
+
−LOCAL UBYTE pb_get_max_num_len          (T_PHB_TYPE type);
+
−LOCAL BOOL pb_sim_service               (UBYTE nr);
+
−LOCAL BOOL pb_read_sim_record           (USHORT data_id,
+
−                                         UBYTE rcd_num,
+
−                                         UBYTE len);
+
−LOCAL BOOL pb_read_sim (USHORT data_id, UBYTE len, UBYTE max_length);
+
−LOCAL void pb_read_next_sim_book        (void);
+
−LOCAL void pb_read_sim_record_cb        (SHORT table_id);
+
−LOCAL void pb_read_sim_cb               (SHORT table_id);
+
−LOCAL void pb_sat_update_reset          (USHORT ef);
+
−LOCAL T_PHB_RETURN pb_sync_next_sim_record (BOOL first);
+
−LOCAL T_PHB_RETURN pb_write_sim_record  (USHORT ef,
+
−                                         UBYTE phy_recno,
+
−                                         UBYTE entry_size,
+
−                                   const UBYTE *buffer);
+
−LOCAL void pb_write_sim_record_cb       (SHORT table_id);
+
−T_EXT_TYPE pb_get_ext_type_from_ef      (USHORT ef);
+
−LOCAL void pb_status_ind                (T_PHB_STAT phb_stat,
+
−                                         SHORT cmeError);
+
−LOCAL T_PHB_RETURN pb_write_queue       (const T_PHB_RECORD *entry);
+
−LOCAL void pb_clear_queue               (void);
+
−LOCAL T_PHB_RETURN pb_read_queue        (void);
+
−
+
−/*
+
− * Functions - Interface functions to external modules
+
− */
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_init                            |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : Power-on initialization of the phonebook module. This function
+
−            is called at a point in time by pei_init() when it cannot be 
+
−            expected that the protocol stack has been booted up completely,
+
−            so it is undesirable to do anything here which might rely on
+
−            a module still not started up like the PCM or the FFS.
+
−  
+
−*/
+
−GLOBAL void pb_init (void)
+
−{
+
−  TRACE_FUNCTION ("pb_init()");
+
−
+
−  memset (&pba_data, 0, sizeof (T_PHB_ACI_DATA));
+
−
+
−  pba_data.fdn_mode = NO_OPERATION;
+
−  pba_data.fdn_classtype = CLASS_VceDatFaxSms;
+
−
+
−  pb_sim_init();
+
−
+
−#ifdef SIM_TOOLKIT
+
−  simShrdPrm.fuRef= - 1;
+
−  psaSAT_FURegister (pb_update);
+
−#endif /* #ifdef SIM_TOOLKIT */
+
−
+
−  SET_PHB_STATE (PHB_STATE_NULL);
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_exit_phb                        |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function synchronizes, if necessary, all unwritten data,
+
−            shuts down the SIM phonebook layer and deallocates all 
+
−            resources. The SIM itself is not deactivated here.
+
−            
+
−
+
−*/
+
−LOCAL void pb_exit_phb (void)
+
−{
+
−  TRACE_FUNCTION ("pb_exit_phb()");
+
−
+
−  /* 
+
−   * Flush everything which has not yet been written.
+
−   * Note: It's a good idea if everything is written immediately
+
−   * so that we don't need to flush anything here. Competitor phones
+
−   * do the job in this way, this has the advantage that even after
+
−   * a phone crash immediately after dialling a number or missing
+
−   * a call nothing is lost.
+
−   */
+
−  (void)pb_sim_flush_data ();
+
−
+
−  /* Shutdown the lower layers */
+
−  pb_sim_exit ();
+
−
+
−  /*
+
−   * Free all allocated resources
+
−   */
+
−  if (pba_data.data NEQ NULL)
+
−  {
+
−    ACI_MFREE (pba_data.data);
+
−    pba_data.data = NULL;
+
−  }
+
−
+
−  if (pba_data.read_ext_record NEQ NULL)
+
−  {
+
−    ACI_MFREE (pba_data.read_ext_record);
+
−    pba_data.read_ext_record = NULL;
+
−  }
+
−
+
−
+
−  pb_clear_queue ();
+
−
+
−  /*
+
−   * Set phonebook to no operation 
+
−   */
+
−  pba_data.fdn_mode = NO_OPERATION;
+
−  pba_data.phb_stat = PHB_UNKNOWN;  
+
−  SET_PHB_STATE (PHB_STATE_NULL);
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_exit                            |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : Shutdown phonebook and the SIM itself also.
+
−
+
−*/
+
−GLOBAL void pb_exit (void)
+
−{
+
−  TRACE_FUNCTION ("pb_exit()");
+
−
+
−  /* Shutdown SIM phonebook */
+
−  pb_exit_phb ();
+
−
+
−  /* Shutdown the SIM itself */
+
−  simShrdPrm.synCs = SYNC_DEACTIVATE;
+
−  psaSIM_SyncSIM();
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_reset                           |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : Resets the phonebook, basically pb_exit() / pb_init().
+
−  
+
−*/
+
−GLOBAL void pb_reset (void)
+
−{
+
−  TRACE_FUNCTION ("pb_reset()");
+
−
+
−  if (GET_PHB_STATE() EQ PHB_STATE_NULL)
+
−    return;
+
−
+
−  pb_exit_phb();
+
−  pb_init();
+
−}
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_set_sim_ecc                     |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function set's the emergency call numbers.
+
−            This can only happen at startup time when the SIM when
+
−            a SIM_ACTIVATE_CNF / SIM_ACTIVATE_IND is received.
+
−            At this point in time the entering of PIN may be outstanding,
+
−            the only information we may have gotten are the emergency call
+
−            numbers.
+
−
+
−*/
+
−GLOBAL void pb_set_sim_ecc (USHORT cause,
+
−                            UBYTE ecc_len,
+
−                            const UBYTE *sim_ecc)
+
−{
+
−  TRACE_FUNCTION ("pb_set_sim_ecc()");
+
−
+
−  if (pba_data.fdn_mode NEQ NO_OPERATION)
+
−  {
+
−     /* 
+
−      * Setting of the emergency call numbers after having gotten the
+
−      * IMSI of the SIM is ignored.
+
−      */
+
−    return;
+
−  }
+
−
+
−  if ((cause EQ SIM_CAUSE_OTHER_ERROR) OR
+
−      (cause EQ SIM_CAUSE_CARD_REMOVED) OR
+
−      (cause >= SIM_CAUSE_PARAM_WRONG AND cause <= SIM_CAUSE_DRV_TEMPFAIL))
+
−  {
+
−    /* 
+
−     * Some error from the SIM. Indicate a fallback to the PCM/FFS.
+
−     */
+
−    (void)pb_sim_set_ecc (0, NULL);
+
−  }
+
−  else
+
−  {
+
−    (void)pb_sim_set_ecc (ecc_len, sim_ecc);
+
−  }
+
−
+
−
+
−
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_inserted_sim                    |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is called when the PIN has been entered and we have
+
−            the IMSI and full access on the SIM phonebook. Reading/Verifying
+
−            of phonebook data is not started at this point except for the 
+
−            ECC phonebook.
+
−
+
−*/
+
−GLOBAL void pb_inserted_sim (UBYTE c_sim_serv,
+
−                             UBYTE *sim_serv,
+
−                             const T_imsi_field *imsi_field,
+
−                             UBYTE adn_bdn_fdn_func,
+
−                             UBYTE phase)       /* For further study */
+
−{
+
−  T_FFS_SIZE ffs_size;                /* FFS result code */
+
−  T_ACI_CLASS classFDN;               /* FDN class */
+
−  UBYTE ub_class = (UBYTE)CLASS_None; /* T_ACI_CLASS */
+
−
+
−  TRACE_FUNCTION ("pb_inserted_sim()");
+
−
+
−  /* Store SIM service table */
+
−  if (c_sim_serv > MAX_SRV_TBL)
+
−    c_sim_serv = MAX_SRV_TBL; /* Garbage protection */
+
−  memcpy (pba_data.sim_service_table, sim_serv, c_sim_serv);
+
−
+
−  /* 
+
−   * Open SIM phonebook. Remember whether the database has to be recreated 
+
−   * for some reason (SIM changed, database unclean).
+
−   */
+
−  if (pb_sim_open (imsi_field, &pba_data.db_recreate) NEQ PHB_OK)
+
−  {
+
−    /* We're here in really big trouble and can do nothing about it */
+
−    TRACE_ERROR ("Fatal: pb_sim_open() NEQ PHB_OK");
+
−  }
+
−
+
−  /*
+
−   * Update ECC phonebook
+
−   */
+
−  pba_data.book_read[ECC] = TRUE;
+
−  if (!pb_read_sim (SIM_ECC, NOT_PRESENT_8BIT, (UBYTE)SIM_MAX_RECORD_SIZE))
+
−  {
+
−    /* Unexpected problem. Live with previously read values */
+
−    TRACE_ERROR ("Unexpected: No free SIM slot");
+
−  }
+
−
+
−  switch (adn_bdn_fdn_func)
+
−  {
+
−    case SIM_ADN_ENABLED:
+
−    case SIM_ADN_BDN_ENABLED:
+
−      pba_data.fdn_mode = FDN_DISABLE;
+
−      break;
+
−
+
−    case SIM_FDN_ENABLED:
+
−    case SIM_FDN_BDN_ENABLED:
+
−      pba_data.fdn_mode = FDN_ENABLE;
+
−
+
−      /* read last fdn_classtype from FFS */
+
−      ffs_size = ffs_file_read ("/mmi/fdnClassType", &ub_class, sizeof(ub_class));
+
−      
+
−      if (ffs_size EQ sizeof(ub_class)) /* successful read */
+
−      {
+
−        classFDN = (T_ACI_CLASS)ub_class;
+
−        
+
−        /* only these two classes are currently supported */
+
−        if (classFDN EQ CLASS_VceDatFax OR 
+
−            classFDN EQ CLASS_VceDatFaxSms)
+
−        {
+
−          pba_data.fdn_classtype = classFDN;
+
−        }
+
−      }
+
−      break;
+
−
+
−    default: /* SIM_NO_OPERATION or trash */
+
−      pba_data.fdn_mode = NO_OPERATION;
+
−      break;
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_start_build                     |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is called when the flash phonebook has to be 
+
−            read/verified from/against the phonebook stored on the SIM card.
+
−            This is triggered by the reception of the 
+
−            MNSMS_REPORT_IND (SMS_STATE_READY) primitive.
+
−
+
−*/
+
−GLOBAL void pb_start_build (BOOL unchanged)
+
−{
+
−  TRACE_FUNCTION ("pb_start_build()");
+
−  
+
−  if (pba_data.db_recreate)
+
−  {
+
−    /* 
+
−     * Indicate a busy phonebook. We have to re-read all from scratch 
+
−     */
+
−    pb_status_ind (PHB_BUSY, CME_ERR_NotPresent);
+
−    SET_PHB_STATE (PHB_STATE_READ);
+
−  }
+
−  else
+
−  {
+
−    /* 
+
−     * SIM (IMSI) not changed and database clean,
+
−     * allow reading from the SIM phonebook by the MMI.
+
−     */
+
−    pb_status_ind (PHB_READY, CME_ERR_NotPresent);
+
−    SET_PHB_STATE (PHB_STATE_VERIFY);
+
−  }
+
−
+
−  pba_data.ext_dummy_read = FALSE;
+
−
+
−#ifdef _SIMULATION_
+
−  TRACE_EVENT_P1 ("SRV_ADN: %s",  pb_sim_service (SRV_ADN)  ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_FDN: %s",  pb_sim_service (SRV_FDN)  ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_CCP: %s",  pb_sim_service (SRV_CCP)  ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_MSISDN: %s",pb_sim_service (SRV_MSISDN) ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_EXT1: %s", pb_sim_service (SRV_EXT1) ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_EXT2: %s", pb_sim_service (SRV_EXT2) ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_LDN: %s",  pb_sim_service (SRV_LDN)  ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_SDN: %s",  pb_sim_service (SRV_SDN)  ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_EXT3: %s", pb_sim_service (SRV_EXT3) ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_BDN: %s",  pb_sim_service (SRV_BDN)  ? "YES" : "NO");
+
−  TRACE_EVENT_P1 ("SRV_EXT4: %s", pb_sim_service (SRV_EXT4) ? "YES" : "NO");
+
−#endif
+
−
+
−  pb_read_next_sim_book();
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_update                          |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is called when the SIM wants to inform the 
+
−            phonebook that some elementary files have been changed.
+
−            Returns TRUE if no files aere changed affecting the phonebook,
+
−            otherwise FALSE.
+
−
+
−*/
+
−GLOBAL BOOL pb_update (int ref,
+
−                       T_SIM_FILE_UPDATE_IND *fu)
+
−{
+
−  unsigned i;           /* Index variable */
+
−  T_PHB_TYPE phb_type;  /* Phonebook type */ 
+
−  T_EXT_TYPE ext_type;  /* Extension type */ 
+
−  USHORT ef;            /* Elementary file number */
+
−
+
−  TRACE_FUNCTION ("pb_update()");
+
−
+
−  simShrdPrm.fuRef = -1;  /* Assume phonebook is not affected */
+
−
+
−  for (i = 0; i < fu->val_nr; i++)
+
−  {
+
−    ef = fu->file_info[i].datafield;
+
−
+
−    if (ef EQ SIM_SST)
+
−    {
+
−      /*
+
−       * When SIM service table is changed, then all SIM phonebooks
+
−       * will be updated.
+
−       */
+
−
+
−      /* Mark all phonebooks as unread */
+
−      pb_sat_update_reset (SIM_ECC);
+
−      pb_sat_update_reset (SIM_ADN);
+
−      pb_sat_update_reset (SIM_FDN);
+
−      pb_sat_update_reset (SIM_BDN);
+
−#ifdef SIM_LND_SUPPORT
+
−      pb_sat_update_reset (SIM_LND);
+
−#endif
+
−      pb_sat_update_reset (SIM_MSISDN);
+
−      pb_sat_update_reset (SIM_SDN);
+
−
+
−      /* Mark all extensions as unread */
+
−      pb_sat_update_reset (EXT1);
+
−      pb_sat_update_reset (EXT2);
+
−      pb_sat_update_reset (EXT3);
+
−      pb_sat_update_reset (EXT4);
+
−
+
−      if (!pb_read_sim (SIM_SST, NOT_PRESENT_8BIT, (UBYTE)SIM_MAX_RECORD_SIZE))
+
−      {
+
−        /*
+
−         * We could not get an empty slot and are in trouble now as there is
+
−         * no good error handling possible here. On the other hand, it is 
+
−         * not expected ever that an error occurs here.
+
−         */
+
−        TRACE_ERROR ("Internal problem getting a SIM slot");
+
−        return TRUE;  /* No update in progress */
+
−      }
+
−
+
−      simShrdPrm.fuRef = ref;   /* Something to do */
+
−
+
−      SET_PHB_STATE (PHB_STATE_READ);
+
−      return FALSE; /* Update in progress */
+
−    }
+
−  }
+
−
+
−  /*
+
−   * At least the SIM service table has not been changed, check now for
+
−   * single phonebooks and extension records.
+
−   */
+
−  
+
−  for (i = 0; i < fu->val_nr; i++)
+
−  {
+
−    ef = fu->file_info[i].datafield;
+
−    phb_type = pb_get_phb_type_from_ef (ef);
+
−    ext_type = pb_get_ext_type_from_ef (ef);
+
−
+
−    if (phb_type NEQ INVALID_PHB)
+
−    {
+
−      /* Phonebook affected by change */
+
−      simShrdPrm.fuRef = ref;
+
−
+
−      /* Reset respective field */
+
−      pb_sat_update_reset (ef);
+
−
+
−      switch (phb_type)
+
−      {
+
−        case ADN:
+
−          pb_sat_update_reset (SIM_FDN);
+
−          break;
+
−
+
−        case FDN:
+
−          pb_sat_update_reset (SIM_ADN);
+
−          break;
+
−        
+
−        default:
+
−          break;
+
−      }
+
−    } 
+
−    else if (ext_type NEQ INVALID_EXT)
+
−    {
+
−      /* Phonebook affected by change */
+
−      simShrdPrm.fuRef = ref;
+
−
+
−      /* Reset respective field */
+
−      pb_sat_update_reset (ef);
+
−
+
−      /* Mark also the appropriate book itself as unread */
+
−      switch (ext_type)
+
−      {
+
−        case EXT1:
+
−          pb_sat_update_reset (SIM_ADN);
+
−          pb_sat_update_reset (SIM_MSISDN);
+
−#ifdef SIM_LND_SUPPORT
+
−          pb_sat_update_reset (SIM_LND);
+
−#endif
+
−          break;
+
−
+
−        case EXT2:
+
−          pb_sat_update_reset (SIM_FDN);
+
−          break;
+
−
+
−        case EXT3:
+
−          pb_sat_update_reset (SIM_SDN);
+
−          break;
+
−
+
−        case EXT4:
+
−          pb_sat_update_reset (SIM_EXT4);
+
−          break;
+
−
+
−        default:
+
−          TRACE_ERROR ("Unexpected default"); /* Everything caught */
+
−          break;
+
−      }
+
−    }
+
−  }
+
−
+
−  if (simShrdPrm.fuRef NEQ -1)
+
−  {
+
−    pb_start_build (FALSE);
+
−    return FALSE; /* FALSE means update in progress */
+
−  }
+
−
+
−  return TRUE; /* TRUE means nothing to do */
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_flush_data                      |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function is called when someone wants to flush some pending
+
−            data to persistent memory. Probably a bad concept, it's always
+
−            better to flush always internally if some operation is finished
+
−            and to synchronize also to the SIM immediately. This has the
+
−            advantage that even after a crash nothing is lost.
+
−
+
−*/
+
−T_PHB_RETURN pb_flush_data (void)
+
−{
+
−  TRACE_FUNCTION ("pb_flush_data()");
+
−
+
−  /* This function is empty, and this should remain this way if possible */
+
−  return PHB_OK;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_add_record                      |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function adds or replaces a phonebook entry.
+
−
+
−*/
+
−GLOBAL T_PHB_RETURN pb_add_record (T_PHB_TYPE type,
+
−                                   USHORT phy_recno,
+
−                                   const T_PHB_RECORD *entry)
+
−{
+
−  T_PHB_RETURN phb_result;
+
−  T_DB_CHANGED dummy_changed;
+
−
+
−  TRACE_FUNCTION ("pb_add_record()");
+
−
+
−#ifdef _SIMULATION_
+
−  {
+
−    char name [PHB_MAX_TAG_LEN + 1];
+
−    char number[MAX_PHB_NUM_LEN];
+
−
+
−    memset (name, 0, PHB_MAX_TAG_LEN + 1);
+
−    memcpy (name, entry->tag, entry->tag_len);
+
−    cmhPHB_getAdrStr (number,
+
−                      MAX_PHB_NUM_LEN - 1,
+
−                      entry->number,
+
−                      entry->len);
+
−    if ((UBYTE)(name[0]) >= 0x80)
+
−      strcpy (name, "<Some UCS2 coding>");
+
−
+
−    TRACE_EVENT_P4 ("Adding number %s with name '%s' to book %d record %d",
+
−                    number, name, type, phy_recno);
+
−  }
+
−#endif
+
−
+
−  /* Fix phy_recno parameter for circular books */
+
−  if ((type EQ LDN) OR (type EQ LMN) OR (type EQ LRN))
+
−  {
+
−    if (phy_recno EQ 0)
+
−      phy_recno = 1;
+
−  }
+
−
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_IDLE:
+
−
+
−      /* Add the data in the database */
+
−      phb_result = pb_sim_add_record (type, 
+
−                                      phy_recno, 
+
−                                      entry, 
+
−                                      &pba_data.records_changed);
+
−      if (phb_result NEQ PHB_OK)
+
−        return phb_result;  /* Record could not be added to the database */
+
−
+
−      if (pba_data.records_changed.entries NEQ 0)
+
−      {
+
−        SET_PHB_STATE (PHB_STATE_WRITE);
+
−      }
+
−
+
−      /* Start synchronizing record(s) to the SIM */
+
−      return pb_sync_next_sim_record (TRUE);
+
−
+
−    case PHB_STATE_VERIFY:
+
−    case PHB_STATE_READ:
+
−      if ((type EQ LRN) OR (type EQ LMN))
+
−      {
+
−        /* 
+
−         * In Release 1998- there is no counterpart on the SIM here,
+
−         * we can write immediately as we don't have to synch to the SIM.
+
−         */
+
−        return (pb_sim_add_record (type, 
+
−                                   phy_recno, 
+
−                                   entry, 
+
−                                   &dummy_changed));
+
−      }
+
−      else if (type EQ LDN)
+
−      {
+
−        /* We have to queue the LDN entry and will write later */
+
−        return pb_write_queue (entry);
+
−      }
+
−      return PHB_FAIL;
+
−
+
−    default:
+
−      return PHB_FAIL;
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_del_record                      |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function deletes a phonebook entry.
+
−
+
−*/
+
−GLOBAL T_PHB_RETURN pb_del_record (T_PHB_TYPE type,
+
−                                   USHORT phy_recno)
+
−{
+
−  T_PHB_RETURN phb_result;
+
−
+
−  TRACE_FUNCTION ("pb_del_record()");
+
−
+
−  if (GET_PHB_STATE() NEQ PHB_STATE_IDLE)
+
−    return PHB_FAIL;
+
−
+
−  /* Delete the data in the database */
+
−  phb_result = pb_sim_del_record (type,
+
−                                  phy_recno,
+
−                                  &pba_data.records_changed);
+
−  if (phb_result NEQ PHB_OK)
+
−    return phb_result;  /* Record could not be deleted from the database */
+
−
+
−  if (pba_data.records_changed.entries NEQ 0)
+
−  {
+
−    SET_PHB_STATE (PHB_STATE_WRITE);
+
−  }
+
−
+
−  /* Start synchronizing record(s) to the SIM */
+
−  return pb_sync_next_sim_record (TRUE);
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_check_fdn                       |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function checks whether a phone number is in FDN phonebook.
+
−
+
−*/
+
−#define RETURN(x) { retVal = x; goto cleanup_exit; }
+
−/*lint -e{801} Use of goto*/
+
−GLOBAL T_PHB_RETURN pb_check_fdn (UBYTE toa,
+
−                                  const UBYTE *number)
+
−{
+
−  T_PHB_RETURN retVal;
+
−  T_PHB_RECORD *phb_record;
+
−  CHAR cur_number[MAX_PHB_NUM_LEN];
+
−  UBYTE cur_num_len;
+
−  USHORT phy_recno;
+
−  SHORT max_rcd;
+
−  SHORT dummy_used_rcd;
+
−  UBYTE dummy_tag_len;
+
−  SHORT dummy_max_ext, dummy_used_ext;
+
−
+
−  ACI_MALLOC (phb_record, sizeof (T_PHB_RECORD));
+
−
+
−  TRACE_FUNCTION ("pb_check_fdn()");
+
−
+
−  retVal = pb_sim_read_sizes (FDN, 
+
−                              &max_rcd, 
+
−                              &dummy_used_rcd, 
+
−                              &dummy_tag_len,
+
−                              &dummy_max_ext,
+
−                              &dummy_used_ext);
+
−  if (retVal NEQ PHB_OK)
+
−  {
+
−    TRACE_ERROR ("Unexpected return from pb_sim_read_sizes()");
+
−    RETURN (retVal)
+
−  }
+
−  
+
−  /* 
+
−   * Do a linear search through all the records applying the number comparision
+
−   * rules which make us pass 51.010 test case 27.18.1.1.4.2.
+
−   * Those rules are different from those which are to be applied if a matching
+
−   * record has to be found for an incoming call, therefore we cannot use 
+
−   * pb_sim_search_number() here.
+
−   * As normally FDN phonebooks have not more than 10 entries (max_rcd) a 
+
−   * simple linear search will fulfill here all timing requirements.
+
−   */
+
−  
+
−  for (phy_recno = 1; phy_recno <= max_rcd; phy_recno++)
+
−  {
+
−    retVal = pb_sim_read_record (FDN, phy_recno, phb_record);
+
−    if (retVal EQ PHB_OK)
+
−    {
+
−      cmhPHB_getAdrStr (cur_number,
+
−                        MAX_PHB_NUM_LEN - 1,
+
−                        phb_record->number,
+
−                        phb_record->len);
+
−      cur_num_len = strlen (cur_number);
+
−
+
−      /* Compare number strings considering Wild card */ 
+
−       if (pb_sim_cmpWild((char*)cur_number, (char *) number, cur_num_len) EQ 0)
+
−      {
+
−        /* Number matches. ACI-SPR-11927: check type of address */ 
+
−        if ((toa EQ 0) OR
+
−          (toa EQ phb_record->ton_npi) OR
+
−          (phb_record->ton_npi EQ 0xFF))
+
−        {
+
−            RETURN (PHB_OK)
+
−        }
+
−        
+
−      }
+
−    }
+
−  }
+
−  RETURN (PHB_FAIL) /* Not found */
+
−
+
−cleanup_exit:
+
−  ACI_MFREE (phb_record);
+
−  return retVal;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_switch_adn_fdn                  |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function switches FDN and ADN phonebooks (sAT_PlusCLCK()).
+
−
+
−*/
+
−GLOBAL T_PHB_RETURN pb_switch_adn_fdn (T_PHB_FDN_MODE mode,
+
−                                       T_ACI_CLASS classFDN)
+
−{
+
−  TRACE_FUNCTION ("pb_switch_adn_fdn()");
+
−
+
−  if (GET_PHB_STATE() NEQ PHB_STATE_IDLE)
+
−    return PHB_FAIL;
+
−
+
−  /* Check parameters */
+
−  switch (mode)
+
−  {
+
−    case FDN_DISABLE:
+
−    case FDN_ENABLE:
+
−      break;
+
−
+
−    default:
+
−      return PHB_FAIL;
+
−  }
+
−
+
−  if (classFDN NEQ pba_data.fdn_classtype)
+
−  {  
+
−    pba_data.fdn_classtype = classFDN;
+
−
+
−#ifndef _SIMULATION_
+
−    if (ffs_fwrite("/mmi/fdnClassType", &classFDN, sizeof(UBYTE)) < 1)
+
−    {
+
−      TRACE_ERROR ("sAT_PlusCLCK: failed to write /mmi/fdnClassType");
+
−    }
+
−#endif /* #ifndef _SIMULATION_ */
+
−  }
+
−
+
−#if 1
+
−
+
−  pba_data.fdn_mode = mode;
+
−
+
−  /* Remove ADN from database */
+
−  (void)pb_sim_remove_ef (SIM_ADN);
+
−  pba_data.book_created[ADN] = FALSE;
+
−  pba_data.book_read[ADN] = FALSE;
+
−
+
−  /* Remove MSISDN database */
+
−  (void)pb_sim_remove_ef (SIM_MSISDN);
+
−  pba_data.book_created[UPN] = FALSE;
+
−  pba_data.book_read[UPN] = FALSE;
+
−
+
−#ifdef SIM_LND_SUPPORT
+
−  /* Remove LND from database */
+
−  (void)pb_sim_remove_ef (SIM_LND);
+
−  pba_data.book_created[LDN] = FALSE;
+
−  pba_data.book_read[LDN] = FALSE;
+
−#endif
+
−
+
−  /* Remove EXT1 from database */
+
−  (void)pb_sim_remove_ef (SIM_EXT1);
+
−  pba_data.ext_created[EXT1] = FALSE;
+
−  
+
−  /* Remove FDN from database */
+
−  (void)pb_sim_remove_ef (SIM_FDN);
+
−  pba_data.book_created[FDN] = FALSE;
+
−  pba_data.book_read[FDN] = FALSE;
+
−
+
−  /* Remove EXT2 from database */
+
−  (void)pb_sim_remove_ef (SIM_EXT2);
+
−  pba_data.ext_created[EXT2] = FALSE;
+
−
+
−  /* Force cmhPHB_StatIndication (PHB_BUSY, CME_ERR_NotPresent) */
+
−  pba_data.db_recreate = TRUE;
+
−
+
−  SET_PHB_STATE (PHB_STATE_READ);
+
−
+
−  /* Start reading changed books */
+
−  pb_start_build (FALSE);
+
−#else
+
−  // This optimization does not comply with current test cases,
+
−  // not understood perfectly whether the test cases can be
+
−  // changed, so kept old behaviour.
+
−  if (pba_data.fdn_mode NEQ mode)
+
−  {
+
−    pba_data.fdn_mode = mode;
+
−
+
−    if (mode EQ FDN_ENABLE)
+
−    {
+
−      /* Remove ADN from database */
+
−      (void)pb_sim_remove_ef (SIM_ADN);
+
−      pba_data.book_created[ADN] = FALSE;
+
−      pba_data.book_read[ADN] = FALSE;
+
−    }
+
−    else
+
−    {
+
−      /* Remove FDN from database */
+
−      (void)pb_sim_remove_ef (SIM_FDN);
+
−      pba_data.book_created[FDN] = FALSE;
+
−      pba_data.book_read[FDN] = FALSE;
+
−
+
−      /* Remove EXT2 from database */
+
−      (void)pb_sim_remove_ef (SIM_EXT2);
+
−      pba_data.ext_created[EXT2] = FALSE;
+
−    }
+
−
+
−    /* Force cmhPHB_StatIndication (PHB_BUSY, CME_ERR_NotPresent) */
+
−    pba_data.db_recreate = TRUE;
+
−
+
−    SET_PHB_STATE (PHB_STATE_READ);
+
−
+
−    /* Start reading changed books */
+
−    pb_start_build (FALSE);
+
−  }
+
−#endif
+
−  return PHB_OK;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_del_book                        |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function deletes a whole SIM phonebook
+
−
+
−*/
+
−GLOBAL T_PHB_RETURN pb_del_book (T_PHB_TYPE book)
+
−{
+
−  T_PHB_RETURN phb_result;
+
−  UBYTE max_record;
+
−
+
−  TRACE_FUNCTION ("pb_del_book()");
+
−
+
−  if (GET_PHB_STATE() NEQ PHB_STATE_IDLE)
+
−    return PHB_FAIL;
+
−
+
−  /* Remember book to delete, initialize record to delete */
+
−  pba_data.current_book = book;
+
−  pba_data.del_record = 1;
+
−  max_record = pba_data.phb_record_max[pba_data.current_book];
+
−
+
−  do
+
−  {
+
−    /* Delete the record in the database */
+
−    phb_result = pb_sim_del_record (pba_data.current_book, 
+
−                                    pba_data.del_record,
+
−                                    &pba_data.records_changed);
+
−
+
−    if ((phb_result NEQ PHB_OK) AND (phb_result NEQ PHB_EMPTY_RECORD))
+
−      return phb_result;
+
−
+
−    pba_data.del_record++;
+
−  } 
+
−  while ((pba_data.del_record <= max_record) AND 
+
−         (pba_data.records_changed.entries EQ 0));
+
−
+
−  if (pba_data.records_changed.entries NEQ 0)
+
−  {
+
−    /* Synchronize to SIM */
+
−    SET_PHB_STATE (PHB_STATE_DELETE_BOOK);
+
−  
+
−    /* Start synchronizing record(s) to the SIM */
+
−    return pb_sync_next_sim_record (TRUE);
+
−  }
+
−
+
−  return PHB_OK;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_get_fdn_classtype               |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function gets the FDN class type
+
−
+
−*/
+
−GLOBAL T_ACI_CLASS pb_get_fdn_classtype (void)
+
−{
+
−  TRACE_FUNCTION ("pb_get_fdn_classtype()");
+
−
+
−  return pba_data.fdn_classtype;
+
−
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_get_fdn_mode                    |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function gets the FDN mode
+
−
+
−*/
+
−GLOBAL T_PHB_FDN_MODE pb_get_fdn_mode (void)
+
−{
+
−  TRACE_FUNCTION ("pb_get_fdn_mode()");
+
−
+
−  return pba_data.fdn_mode;
+
−
+
−}
+
−
+
−
+
−/*
+
− * Wrapper functions. Wrapper functions don't define own functionality 
+
− * except of routing to a different block which is the SIM part of 
+
− * the phonebook here. For a description of these functions have
+
− * a look into the SIM part of the phonebook.
+
− */
+
−
+
−GLOBAL T_PHB_RETURN pb_read_record (T_PHB_TYPE type,
+
−                                    SHORT phy_recno,
+
−                                    T_PHB_RECORD *entry)
+
−{
+
−  T_PHB_RETURN phb_result;
+
−
+
−  TRACE_FUNCTION ("pb_read_record()");
+
−
+
−  if (phy_recno EQ 0)
+
−    return PHB_FAIL;
+
−
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_VERIFY:
+
−      /* 
+
−       * For LDN records, first have a look into the queue
+
−       */
+
−      if ((type EQ LDN) AND (phy_recno - 1 < pba_data.c_queued))
+
−      {
+
−        /* Entry freshly dialled and still in the queue */
+
−        *entry = pba_data.queued[phy_recno - 1]->entry;
+
−        return PHB_OK;
+
−      }
+
−      phb_result = pb_sim_read_record (type, 
+
−                                       (USHORT)(phy_recno - pba_data.c_queued),
+
−                                       entry);
+
−      TRACE_EVENT_P3 ("type = %d, phy_recno = %d, phb_result = %d",
+
−                      type, phy_recno, phb_result);
+
−      return phb_result;
+
−
+
−    case PHB_STATE_READ:
+
−      /* 
+
−       * For LDN records, first have a look into the queue
+
−       */
+
−      if ((type EQ LDN) AND (phy_recno - 1 < pba_data.c_queued))
+
−      {
+
−        /* Entry freshly dialled and still in the queue */
+
−        *entry = pba_data.queued[phy_recno - 1]->entry;
+
−        return PHB_OK;
+
−      }
+
−      return PHB_FAIL; /* We already know the SIM was changed */
+
−
+
−    case PHB_STATE_IDLE:
+
−      phb_result = pb_sim_read_record (type, phy_recno, entry);
+
−      TRACE_EVENT_P3 ("type = %d, phy_recno = %d, phb_result = %d",
+
−                      type, phy_recno, phb_result);
+
−      return phb_result;
+
−
+
−    default:
+
−      return PHB_FAIL;
+
−  }
+
−}
+
−
+
−
+
−GLOBAL T_PHB_RETURN pb_read_alpha_record (T_PHB_TYPE type,
+
−                                          SHORT order_num,
+
−                                          T_PHB_RECORD *entry)
+
−{
+
−  TRACE_FUNCTION ("pb_read_alpha_record()");
+
−
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_IDLE:
+
−    case PHB_STATE_VERIFY:
+
−      /* Implements Measure #30 */
+
−      return pb_sim_read_alpha_num_record (type, order_num, entry, NAME_IDX);
+
−    default:
+
−      return PHB_FAIL;
+
−  }
+
−}
+
−
+
−
+
−GLOBAL T_PHB_RETURN pb_read_number_record (T_PHB_TYPE type,
+
−                                           SHORT order_num,
+
−                                           T_PHB_RECORD *entry)
+
−{
+
−  TRACE_FUNCTION ("pb_read_number_record()");
+
−
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_IDLE:
+
−    case PHB_STATE_VERIFY:
+
−      /* Implements Measure #30 */
+
−      return pb_sim_read_alpha_num_record (type, order_num, entry, NUMBER_IDX);
+
−    default:
+
−      return PHB_FAIL;
+
−  }
+
−}
+
−
+
−
+
−GLOBAL T_PHB_RETURN pb_search_name (T_PHB_TYPE type,
+
−                                    T_PHB_MATCH match,
+
−                                    const T_ACI_PB_TEXT *search_tag,
+
−                                    SHORT *order_num)
+
−{
+
−  T_PHB_RETURN phb_result;
+
−
+
−  TRACE_FUNCTION ("pb_search_name()");
+
−
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_IDLE:
+
−    case PHB_STATE_VERIFY:
+
−      TRACE_EVENT_P1 ("order_num = %d", *order_num);
+
−      phb_result = pb_sim_search_name (type, match, search_tag, order_num);
+
−      if (phb_result EQ PHB_OK)         /* #HM# Remove before production */
+
−      {
+
−        TRACE_EVENT ("Entry found");
+
−      }
+
−      else
+
−      {
+
−        TRACE_EVENT ("Entry not found");
+
−      }
+
−      return phb_result;
+
−
+
−    default:
+
−      return PHB_FAIL;
+
−  }
+
−}
+
−
+
−
+
−GLOBAL T_PHB_RETURN pb_search_number (T_PHB_TYPE type,
+
−                                      const UBYTE *number,
+
−                                      SHORT *order_num)
+
−{
+
−  TRACE_FUNCTION ("pb_search_number()");
+
−
+
−  if(type EQ ECC)
+
−  {
+
−    return pb_sim_search_number (type, number, order_num);
+
−  }
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_IDLE:
+
−    case PHB_STATE_VERIFY:
+
−      return pb_sim_search_number (type, number, order_num);
+
−    default:
+
−      return PHB_FAIL;
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_get_max_num_len                 |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function gets the maximum length of a number within a
+
−            given phonebook. The length depends on the given phonebook and
+
−            the availability of extension records (SIM service table).
+
−
+
−            Question: The case that the extension records are present but 
+
−            exhausted on the SIM is not considered here. Should this be done?
+
−
+
−            Question: From an architectural point of view, belongs this into
+
−            the ACI part of the phonebook or more into the SIM part of the 
+
−            phonebook? SIM part until now has no information about SIM service
+
−            table.
+
−
+
−*/
+
−LOCAL UBYTE pb_get_max_num_len (T_PHB_TYPE type)
+
−{
+
−  TRACE_FUNCTION ("pb_get_max_num_len()");
+
−
+
−  switch (type)
+
−  {
+
−    case ECC:
+
−      return 3;
+
−
+
−    case ADN:
+
−    case UPN:
+
−    case ADN_ME:
+
−      if (pb_sim_service (SRV_EXT1))
+
−        return 2 * PHB_PACKED_NUM_LEN;
+
−      break;
+
−
+
−    case FDN:
+
−      if (pb_sim_service (SRV_EXT2))
+
−        return 2 * PHB_PACKED_NUM_LEN;
+
−      break;
+
−
+
−    case SDN:
+
−      if (pb_sim_service (SRV_EXT3))
+
−        return 2 * PHB_PACKED_NUM_LEN;
+
−      break;
+
−    
+
−    case BDN:
+
−      if (pb_sim_service (SRV_EXT4))
+
−        return 2 * PHB_PACKED_NUM_LEN;
+
−      break;
+
−
+
−    case LDN:
+
−    case LRN:
+
−    case LMN:
+
−    case ME:
+
−      return 2 * PHB_PACKED_NUM_LEN;
+
−    
+
−    default:
+
−      TRACE_ERROR ("Invalid phonebook type");
+
−      return 0;
+
−  }
+
−  return 20; /* Default according to 11.11 if no EXT records and not ECC */
+
−}
+
−
+
−
+
−GLOBAL T_PHB_RETURN pb_read_sizes (T_PHB_TYPE type, /* IN */
+
−                                   SHORT *max_rcd,  /* OUT */
+
−                                   SHORT *used_rcd, /* OUT */
+
−                                   UBYTE *num_len,  /* OUT */
+
−                                   UBYTE *tag_len,  /* OUT */
+
−                                   SHORT *max_ext,  /* OUT */
+
−                                   SHORT *used_ext) /* OUT */
+
−{
+
−  T_PHB_RETURN phb_result;
+
−
+
−  TRACE_FUNCTION ("pb_read_sizes()");
+
−
+
−  if(type EQ ECC)
+
−  {
+
−    *num_len = pb_get_max_num_len (type);
+
−    phb_result = pb_sim_read_sizes (type, max_rcd, used_rcd, tag_len, 
+
−                                    max_ext, used_ext);
+
−    if (phb_result NEQ PHB_OK)
+
−    {
+
−      *max_rcd  = 0;
+
−      *used_rcd = 0;
+
−      *num_len  = 0;
+
−      *tag_len  = 0;
+
−      *max_ext  = 0;
+
−      *used_ext = 0;
+
−    }
+
−    return PHB_OK;
+
−  }
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_IDLE:
+
−    case PHB_STATE_VERIFY:
+
−
+
−      /* 
+
−       * For a valid phonebook type, set all parameters to zero instead of 
+
−       * reporting an error.
+
−       */
+
−      switch (type)
+
−      {
+
−        case ADN:
+
−        case FDN:
+
−        case BDN:
+
−        case LDN:
+
−        case LRN:
+
−        case SDN:
+
−        case LMN:
+
−        case UPN:
+
−      /*case ME:
+
−        case ADN_ME:*/
+
−          *num_len = pb_get_max_num_len (type);
+
−          phb_result = pb_sim_read_sizes (type, max_rcd, used_rcd, tag_len, 
+
−                                          max_ext, used_ext);
+
−          if (phb_result NEQ PHB_OK)
+
−          {
+
−            *max_rcd  = 0;
+
−            *used_rcd = 0;
+
−            *num_len  = 0;
+
−            *tag_len  = 0;
+
−            *max_ext  = 0;
+
−            *used_ext = 0;
+
−          }
+
−#ifdef _SIMULATION_
+
−          TRACE_EVENT_P7 ("pb_read_sizes(): type=%d, "
+
−                          "max_rcd=%d, used_rcd=%d, "
+
−                          "num_len=%d, tag_len=%d, "
+
−                          "max_ext=%d, used_ext=%d", 
+
−                          type,
+
−                          *max_rcd, *used_rcd, 
+
−                          *num_len, *tag_len, 
+
−                          *max_ext, *used_ext);
+
−#endif /* #ifdef _SIMULATION_ */
+
−          return PHB_OK;
+
−
+
−        default: 
+
−          break;
+
−      }
+
−      return PHB_FAIL;  /* Invalid phonebook */
+
−
+
−    default:
+
−      return PHB_FAIL;  /* Invalid state */
+
−  }
+
−}
+
−
+
−
+
−GLOBAL int pb_get_entry_len (const UBYTE *pb_tag,
+
−                             UBYTE max_pb_len)
+
−{
+
−  TRACE_FUNCTION ("pb_get_entry_len()");
+
−
+
−  return pb_sim_get_entry_len (pb_tag, max_pb_len);
+
−}
+
−
+
−
+
−GLOBAL int pb_find_free_record (T_PHB_TYPE type)
+
−{
+
−  /* 
+
−   * This function finds the number of the first free record in 
+
−   * a given phonebook. This is new functionality as from S621.
+
−   */
+
−  TRACE_FUNCTION ("pb_find_free_record()");
+
−
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_IDLE:
+
−    case PHB_STATE_VERIFY:
+
−      return pb_sim_find_free_record (type);
+
−    default:
+
−      return PHB_FAIL;
+
−  }
+
−}
+
−
+
−
+
−GLOBAL int pb_find_ext_free_record ()
+
−{
+
−  /* 
+
−   * This function finds the number of the first free record in 
+
−   * a given phonebook. This is new functionality as from S621.
+
−   */
+
−  TRACE_FUNCTION ("pb_find_free_record()");
+
−
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_IDLE:
+
−    case PHB_STATE_VERIFY:
+
−      return pb_sim_find_free_ext_record ();
+
−    default:
+
−      return PHB_FAIL;
+
−  }
+
−}
+
−
+
−GLOBAL void  pb_update_ext_bitmap (UBYTE recu_num,BOOL flag)
+
−{
+
−    pb_sim_update_ext_bitmap(recu_num, flag); 
+
−}
+
−
+
−
+
−
+
−
+
−
+
−/* 
+
− * Internal functions, not part of the interface
+
− */
+
−
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_sim_service                     |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function checks whether a given service is
+
−            "allocated and activated" on the SIM, if so TRUE is returned, 
+
−            otherwise the function returns FALSE.
+
−
+
−            No, using psaSIM_ChkSIMSrvSup() is not a good alternative here
+
−            as we may have to handle the situation where the SIM service 
+
−            table itself has been changed, in this case we are not signalled
+
−            by the ACI when we have again a valid SIM service table, therefore
+
−            this function exist here within the phonebook.
+
−
+
−*/
+
−LOCAL BOOL pb_sim_service (UBYTE nr)
+
−{
+
−  UBYTE byte_offset;
+
−  UBYTE bit_offset;
+
−  UBYTE service;
+
−
+
−  TRACE_FUNCTION ("pb_sim_service()");
+
−
+
−  if (nr > MAX_SRV_TBL * 4)
+
−    return FALSE; /* Table overflow */
+
−
+
−  byte_offset =  (nr - 1) / 4;
+
−  bit_offset  = ((nr - 1) & 0x03) * 2;
+
−  service = (pba_data.sim_service_table[byte_offset] >> bit_offset) & 0x03;
+
−  return (service EQ ALLOCATED_AND_ACTIVATED);
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_read_sim_record                 |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function sends a SIM_READ_RECORD_REQ to the SIM card.
+
−              On success this function returns TRUE, otherwise FALSE.
+
−
+
−*/
+
−LOCAL BOOL pb_read_sim_record (USHORT data_id, UBYTE rcd_num, UBYTE len)
+
−{
+
−  SHORT table_id;
+
−
+
−  TRACE_FUNCTION ("pb_read_sim_record()");
+
−
+
−  table_id = psaSIM_atbNewEntry();
+
−
+
−  if (table_id NEQ NO_ENTRY)
+
−  {
+
−    /* Allocate room for the SIM data */
+
−    if (pba_data.data EQ NULL)
+
−    {
+
−      ACI_MALLOC (pba_data.data, SIM_MAX_RECORD_SIZE);
+
−    }
+
−    simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
+
−    simShrdPrm.atb[table_id].v_path_info  = FALSE;
+
−    simShrdPrm.atb[table_id].accType    = ACT_RD_REC;
+
−    simShrdPrm.atb[table_id].reqDataFld = data_id;
+
−    simShrdPrm.atb[table_id].recNr      = rcd_num;
+
−    simShrdPrm.atb[table_id].dataLen    = len;
+
−    simShrdPrm.atb[table_id].exchData   = pba_data.data;
+
−    simShrdPrm.atb[table_id].rplyCB     = pb_read_sim_record_cb;
+
−
+
−    simShrdPrm.aId = table_id;
+
−
+
−    if (psaSIM_AccessSIMData() < 0)
+
−    {
+
−      TRACE_EVENT("FATAL ERROR");
+
−      return FALSE;
+
−    }
+
−    return TRUE;
+
−  }
+
−
+
−  return FALSE;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_read_sim                        |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function sends a SIM_READ_REQ to the SIM card.
+
−              On success this function returns TRUE, otherwise FALSE.
+
−
+
−*/
+
−LOCAL BOOL pb_read_sim (USHORT data_id, UBYTE len, UBYTE max_length)
+
−{
+
−  SHORT table_id;
+
−
+
−  TRACE_FUNCTION ("pb_read_sim()");
+
−
+
−  table_id = psaSIM_atbNewEntry();
+
−
+
−  if (table_id NEQ NO_ENTRY)
+
−  {
+
−    /* Allocate room for the SIM data */
+
−    if (pba_data.data EQ NULL)
+
−    {
+
−      ACI_MALLOC (pba_data.data, SIM_MAX_RECORD_SIZE);
+
−    }
+
−
+
−    simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
+
−    simShrdPrm.atb[table_id].accType    = ACT_RD_DAT;
+
−    simShrdPrm.atb[table_id].v_path_info  = FALSE;
+
−    simShrdPrm.atb[table_id].reqDataFld = data_id;
+
−    simShrdPrm.atb[table_id].dataOff    = 0;
+
−    simShrdPrm.atb[table_id].dataLen    = len;
+
−    simShrdPrm.atb[table_id].recMax     = max_length;
+
−    simShrdPrm.atb[table_id].exchData   = NULL;
+
−    simShrdPrm.atb[table_id].rplyCB     = pb_read_sim_cb;
+
−
+
−    simShrdPrm.aId = table_id;
+
−
+
−    if (psaSIM_AccessSIMData() < 0)
+
−    {
+
−      TRACE_EVENT("FATAL ERROR");
+
−      return FALSE;
+
−    }
+
−    return TRUE;
+
−  }
+
−  return FALSE;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_read_next_sim_book              |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function starts reading the phonebooks based on the 
+
−              information whether the phonebook is activated and allocated
+
−              and still has to be read at all.
+
−
+
−*/
+
−LOCAL void pb_read_next_sim_book (void)
+
−{
+
−  TRACE_FUNCTION("pb_read_next_sim_book()");
+
−
+
−  /*
+
−   * The next three phonebooks ADN, MSISDN and LND share EXT1 records
+
−   */
+
−  if ((pba_data.fdn_mode NEQ FDN_ENABLE) AND
+
−      pb_sim_service (SRV_ADN) AND !pba_data.book_read[ADN])
+
−  {
+
−    /* Read ADN from SIM card */
+
−    pba_data.current_book = ADN;
+
−    pba_data.book_read[ADN] = TRUE;
+
−    pb_read_sim_record (SIM_ADN, 1, NOT_PRESENT_8BIT);
+
−    return;
+
−  }
+
−
+
−  if (pb_sim_service (SRV_MSISDN) AND !pba_data.book_read[UPN])
+
−  {
+
−    /* Read MSISDN from SIM card */
+
−    pba_data.current_book = UPN;
+
−    pba_data.book_read[UPN] = TRUE;
+
−    pb_read_sim_record (SIM_MSISDN, 1, NOT_PRESENT_8BIT);
+
−    return;
+
−  }
+
−
+
−#ifdef SIM_LND_SUPPORT
+
−  if (pb_sim_service (SRV_LDN) AND !pba_data.book_read[LDN])
+
−  {
+
−    /* Read LND from SIM card */
+
−    pba_data.current_book = LDN;
+
−    pba_data.book_read[LDN] = TRUE;
+
−    pb_read_sim_record (SIM_LND, 1, NOT_PRESENT_8BIT);
+
−    return;
+
−  }
+
−#endif
+
−
+
−#ifdef SIM_LND_SUPPORT
+
−  if (!pb_sim_service (SRV_LDN) AND !pba_data.book_read[LDN])
+
−#else
+
−  if (!pba_data.book_read[LDN])
+
−#endif
+
−  {
+
−    /* 
+
−     * SIM card without LDN service. Create SIM_ICI and SIM_OCI here.
+
−     * Don't create obsolete SIM_LND
+
−     */
+
−    pba_data.book_read[LDN] = TRUE;
+
−
+
−    /* Create now also some helper elementary files as of R99+ */
+
−    /* (void)pb_sim_create_ef (SIM_ICI, SIZE_EF_ICI, NR_EF_ICI); */
+
−    (void)pb_sim_create_ef (FFS_LRN, SIZE_EF_LRN, NR_EF_LRN);
+
−    (void)pb_sim_create_ef (FFS_EXT_LRN, SIZE_EF_EXT_LRN, NR_EF_EXT_LRN);
+
−    (void)pb_sim_create_ef (FFS_LMN, SIZE_EF_LMN, NR_EF_LMN);
+
−    (void)pb_sim_create_ef (FFS_EXT_LMN, SIZE_EF_EXT_LMN, NR_EF_EXT_LMN);
+
−
+
−    (void)pb_sim_create_ef (SIM_OCI, SIZE_EF_OCI, NR_EF_OCI);
+
−    (void)pb_sim_create_ef (SIM_EXT5, SIZE_EF_EXT5, NR_EF_EXT5);
+
−
+
−    pba_data.phb_record_max[LDN] = NR_EF_OCI;
+
−    pba_data.phb_record_len[LDN] = SIZE_EF_OCI;
+
−    pba_data.book_created[LDN] = TRUE;
+
−
+
−    /* pba_data.phb_record_max[LRN] = NR_EF_ICI;  Shared! */
+
−    /* pba_data.phb_record_len[LRN] = SIZE_EF_ICI; */
+
−    pba_data.phb_record_max[LRN] = NR_EF_LRN;
+
−    pba_data.phb_record_len[LRN] = SIZE_EF_LRN;
+
−    pba_data.book_created[LRN] = TRUE;
+
−
+
−    /* pba_data.phb_record_max[LMN] = NR_EF_ICI;  Shared! */
+
−    /* pba_data.phb_record_len[LMN] = SIZE_EF_ICI; */
+
−    pba_data.phb_record_max[LMN] = NR_EF_LMN;
+
−    pba_data.phb_record_len[LMN] = SIZE_EF_LMN;
+
−    pba_data.book_created[LMN] = TRUE;
+
−
+
−    pba_data.ext_record_max[EXT5]    = NR_EF_EXT5;
+
−    pba_data.ext_record_max[EXT_LRN] = NR_EF_EXT_LRN;
+
−    pba_data.ext_record_max[EXT_LMN] = NR_EF_EXT_LMN;
+
−
+
−    pba_data.ext_record_max[EXT5]    = SIZE_EF_EXT5;
+
−    pba_data.ext_record_max[EXT_LRN] = SIZE_EF_EXT_LRN;
+
−    pba_data.ext_record_max[EXT_LMN] = SIZE_EF_EXT_LMN;
+
−  }
+
−
+
−#ifdef SIM_LND_SUPPORT
+
−  if (pba_data.book_read[ADN] OR
+
−      pba_data.book_read[UPN] OR
+
−      pba_data.book_read[LDN])
+
−#else
+
−  if (pba_data.book_read[ADN] OR
+
−      pba_data.book_read[UPN])
+
−#endif
+
−  {
+
−    /* At least one of the books referencing EXT1 has been read */
+
−    if (!pba_data.ext_created[EXT1] AND
+
−        pb_sim_service (SRV_EXT1))
+
−    {
+
−      /* Reading to get the number of records only */
+
−      pba_data.ext_dummy_read = TRUE;
+
−      pb_read_sim_record (SIM_EXT1, 1, NOT_PRESENT_8BIT);
+
−      return;
+
−    }
+
−  }
+
−
+
−  /*
+
−   * FDN phonebook only to be read if ADN is blocked
+
−   */
+
−  if ((pba_data.fdn_mode EQ FDN_ENABLE) AND 
+
−      pb_sim_service (SRV_FDN) AND !pba_data.book_read[FDN])
+
−  {
+
−    /* Read FDN from SIM card */
+
−    pba_data.current_book = FDN;
+
−    pba_data.book_read[FDN] = TRUE;
+
−    pb_read_sim_record (SIM_FDN, 1, NOT_PRESENT_8BIT);
+
−    return;
+
−  }
+
−
+
−  if (pba_data.book_read[FDN] AND
+
−      !pba_data.ext_created[EXT2] AND
+
−      pb_sim_service (SRV_EXT2))
+
−  {
+
−    /* Reading to get the number of records only */
+
−    pba_data.ext_dummy_read = TRUE;
+
−    pb_read_sim_record (SIM_EXT2, 1, NOT_PRESENT_8BIT);
+
−    return;
+
−  }
+
−
+
−  if (pb_sim_service (SRV_BDN) AND !pba_data.book_read[BDN])
+
−  {
+
−    /* Read BDN from SIM card */
+
−    pba_data.current_book = BDN;
+
−    pba_data.book_read[BDN] = TRUE;
+
−    pb_read_sim_record (SIM_BDN, 1, NOT_PRESENT_8BIT);
+
−    return;
+
−  }
+
−
+
−  if (pba_data.book_read[BDN] AND 
+
−      !pba_data.ext_created[EXT4] AND
+
−      pb_sim_service (SRV_EXT4))
+
−  {
+
−    /* Reading to get the number of records only */
+
−    pba_data.ext_dummy_read = TRUE;
+
−    pb_read_sim_record (SIM_EXT4, 1, NOT_PRESENT_8BIT);
+
−    return;
+
−  }
+
−
+
−  if (pb_sim_service (SRV_SDN) AND !pba_data.book_read[SDN])
+
−  {
+
−    /* Read SDN from SIM card */
+
−    pba_data.current_book = SDN;
+
−    pba_data.book_read[SDN] = TRUE;
+
−    pb_read_sim_record (SIM_SDN, 1, NOT_PRESENT_8BIT);
+
−    return;
+
−  }
+
−
+
−  if (pba_data.book_read[SDN] AND
+
−      !pba_data.ext_created[EXT3] AND
+
−      pb_sim_service (SRV_EXT3))
+
−  {
+
−    /* Reading to get the number of records only */
+
−    pba_data.ext_dummy_read = TRUE;
+
−    pb_read_sim_record (SIM_EXT3, 1, NOT_PRESENT_8BIT);
+
−    return;
+
−  }
+
−
+
−  /* Update the CPHS extension1 records*/
+
−	 pb_update_cphs_mb_ext_record(); 
+
−
+
−
+
−
+
−  /*
+
−   * For the phonebook entries which reside on SIM but don't have 
+
−   * timestamps some checks could be done here.
+
−   * For example, we could read based on EF_LDN, subsequently we
+
−   * could read the informations solely stored in the flash and
+
−   * then we could decide whether we through away the last dialled 
+
−   * numbers or don't.
+
−   * Probably this is overkill, old Nokia 5110 and more recent Nokia 6330i 
+
−   * simply does not support EF_LND at all but stores the last dialled 
+
−   * numbers in the flash.
+
−   */
+
−
+
−#ifdef SIM_TOOLKIT
+
−  if (simShrdPrm.fuRef >= 0)
+
−  {
+
−    psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_SUCC_ADD);
+
−  }
+
−#endif
+
−
+
−  /* Free SIM exchange data */
+
−  if (pba_data.data NEQ NULL)
+
−  {
+
−    ACI_MFREE (pba_data.data);
+
−    pba_data.data = NULL;
+
−  }
+
−
+
−  SET_PHB_STATE (PHB_STATE_IDLE);
+
−
+
−  if (pb_read_queue() EQ PHB_EXCT)
+
−    return; /* Queued LDN entry is written */
+
−
+
−  /* Finished reading phonebooks. Flush data. */
+
−  (void)pb_sim_flush_data ();
+
−
+
−  /* Inform ACI that we're ready */
+
−  pb_status_ind (PHB_READY, CME_ERR_NotPresent);
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_read_sim_record_cb              |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function is the callback when a SIM record has been read
+
−              (SIM_READ_RECORD_CNF).
+
−
+
−*/
+
−#define PHB_INCREMENTAL_SORT // Only locally and temporary, HM 18-Oct-2006
+
−LOCAL void pb_read_sim_record_cb (SHORT table_id)
+
−{
+
−  T_PHB_RETURN phb_result;  /* Phonebook result code */
+
−  T_PHB_TYPE phb_type;      /* Phonebook type */
+
−  T_EXT_TYPE ext_type;      /* Extension record type */
+
−  T_PHB_TYPE next_phb_type; /* Phonebook type of record to read */
+
−  T_EXT_TYPE next_ext_type; /* Extension record type of record to read */
+
−  USHORT  reqDataFld;       /* requested datafield identifier */
+
−  UBYTE   recNr;            /* record number */
+
−  UBYTE   dataLen;          /* Length of data */
+
−  UBYTE   recMax;           /* Maximum number of records */
+
−  USHORT  errCode;          /* Error code from the SIM */
+
−  USHORT  ext_record_ef;    /* Extension record elementary file id */
+
−  UBYTE   ext_record_no;    /* Extension record number */
+
−  BOOL    changed;          /* Record changed by pb_sim_write_ef() */
+
−  BOOL    write_record;     /* Write the record */
+
−
+
−  TRACE_FUNCTION ("pb_read_sim_record_cb()");
+
−
+
−  /* 
+
−   * Currently we have a limitation of 254 records in the code.
+
−   * This is because there is a note in 11.11 version 8.3.0 clause 6.4.2
+
−   * that there is a limit of 254 records for linear fixed.
+
−   * Same for USIM looking into 31.102 Annex G.
+
−   * However this constraint is not valid for cyclic, and also this
+
−   * note has not been present in 11.11 version 7.4.0 clause 6.2.4, 
+
−   * there is a limit of 255 records mentioned.
+
−   * Not supporting the 255th record is a minor issue for now.
+
−   * To avoid crashing, we have to limit here for now to 254.
+
−   * This is not a theoretical issue only as there exists SIMs
+
−   * which have 255 ADN entries.
+
−   */
+
−  if (simShrdPrm.atb[table_id].recMax EQ 255)
+
−    simShrdPrm.atb[table_id].recMax = 254;
+
−
+
−  /* Get the important information from the read record from T_SIM_ACC_PRM */
+
−  reqDataFld = simShrdPrm.atb[table_id].reqDataFld;
+
−  recNr      = simShrdPrm.atb[table_id].recNr;
+
−  dataLen    = simShrdPrm.atb[table_id].dataLen;
+
−  recMax     = simShrdPrm.atb[table_id].recMax;
+
−  errCode    = simShrdPrm.atb[table_id].errCode;
+
−
+
−  phb_type = pb_get_phb_type_from_ef (reqDataFld);
+
−  ext_type = pb_get_ext_type_from_ef (reqDataFld);
+
−
+
−  if (phb_type EQ INVALID_PHB AND
+
−      ext_type EQ INVALID_EXT)
+
−  {
+
−    TRACE_ERROR ("Invalid reqDataFld!");
+
−    simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
−    return;
+
−  }
+
−
+
−  /* We assume we write the record until we have certain errors */
+
−  write_record = TRUE;
+
−
+
−  if (errCode NEQ SIM_NO_ERROR)
+
−  {
+
−    TRACE_EVENT_P1 ("SIM indicated problem code %04x", errCode);
+
−    /* 
+
−     * At least use cleanly deleted data instead of trash.
+
−     * Do memset only if pba_data.data is not equal to NULL.       
+
−     */
+
−    if (pba_data.data NEQ NULL)
+
−    {
+
−      memset (pba_data.data, 0xff, SIM_MAX_RECORD_SIZE);
+
−    }
+
−    else
+
−    {
+
−      TRACE_EVENT("PHB data has been cleared");
+
−      simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
−      return;
+
−    }
+
−  }
+
−
+
−  if (ext_type NEQ INVALID_EXT) 
+
−  {
+
−    /*
+
−     * Got an extension record. 
+
−     */
+
−    if (!pba_data.ext_created[ext_type])
+
−    {
+
−      if (errCode NEQ SIM_NO_ERROR)
+
−      {
+
−        /* We won't create a field on invalid data and won't write */
+
−        write_record = FALSE;
+
−        
+
−        /* 
+
−         * When SIM returns an error case when tried to read Extension
+
−         * file, then set the ext_created field to TRUE so that further 
+
−         * reading of Phonebook continues 
+
−         */
+
−        pba_data.ext_created[ext_type] = TRUE;
+
−      }
+
−      else
+
−      {
+
−        pba_data.ext_record_max[ext_type] = recMax;
+
−        pba_data.ext_record_len[ext_type] = dataLen;
+
−
+
−        /* Shadow field for extension record not yet created */
+
−        (void)pb_sim_create_ef (reqDataFld, dataLen, recMax);
+
−        pba_data.ext_created[ext_type] = TRUE;
+
−      }
+
−
+
−      if (pba_data.ext_dummy_read)
+
−      {
+
−        /* 
+
−         * We are reading the first extension record which is assumed 
+
−         * to be not used just to get the number of respective extension 
+
−         * records.
+
−         */
+
−        write_record = FALSE;
+
−        pba_data.ext_dummy_read = FALSE;
+
−      }
+
−    }
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * Got a normal phonebook record
+
−     */
+
−    if (!pba_data.book_created[phb_type])
+
−    {
+
−      if (errCode NEQ SIM_NO_ERROR)
+
−      {
+
−        /* We won't create a field on invalid data */
+
−        write_record = FALSE;
+
−      }
+
−      else
+
−      {
+
−        pba_data.phb_record_max[phb_type] = recMax;
+
−        pba_data.phb_record_len[phb_type] = dataLen;
+
−
+
−        /* Shadow field for normal phonebook record not yet created */
+
−        (void)pb_sim_create_ef (reqDataFld, dataLen, recMax);
+
−        pba_data.book_created[phb_type] = TRUE;
+
−
+
−#ifdef SIM_LND_SUPPORT
+
−        if (phb_type EQ LDN)
+
−        {
+
−          /* Create now also some helper elementary files as of R99+ */
+
−          (void)pb_sim_create_ef (SIM_OCI, (USHORT)(dataLen + 14), recMax);
+
−          pba_data.phb_record_max[LDN] = recMax;
+
−          pba_data.phb_record_len[LDN] = dataLen;
+
−          pba_data.book_created[LDN] = TRUE;
+
−
+
−          (void)pb_sim_create_ef (SIM_ICI, (USHORT)(dataLen + 14), recMax);
+
−          pba_data.phb_record_max[LRN] = recMax;
+
−          pba_data.phb_record_len[LRN] = dataLen;
+
−          pba_data.book_created[LRN] = TRUE;
+
−
+
−          pba_data.phb_record_max[LMN] = recMax;
+
−          pba_data.phb_record_len[LMN] = dataLen;
+
−          pba_data.book_created[LMN] = TRUE;
+
−        }
+
−#endif
+
−      }
+
−    }
+
−  }
+
−
+
−  /* 
+
−   * Write raw record. The SIM layer is aware about the data structures
+
−   * and gives us the information whether we have to read an/another
+
−   * extension record now or whether we can continue reading normal
+
−   * phonebook entries.
+
−   */
+
−  if (write_record)
+
−  {
+
−    phb_result = pb_sim_write_ef(reqDataFld,
+
−                                 recNr,
+
−                                 dataLen,
+
−                                 pba_data.data,
+
−                                 &changed,
+
−                                 &ext_record_ef,
+
−                                 &ext_record_no);
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * New field, record was trash, don't write it, continue reading
+
−     * phonebook entries.
+
−     */
+
−    TRACE_EVENT ("Record not written (trash/dummy ext)");
+
−
+
−    phb_result = PHB_OK;
+
−    changed = FALSE;
+
−    ext_record_ef = 0;
+
−    ext_record_no = 0;
+
−  }
+
−
+
−  /* Mark SIM table as free now */
+
−  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
−
+
−  if ((GET_PHB_STATE() EQ PHB_STATE_VERIFY) AND
+
−      (phb_result EQ PHB_OK) AND changed)
+
−  {
+
−    /* We have a change detected. Prevent further reading until all read */
+
−    SET_PHB_STATE (PHB_STATE_READ);
+
−  }
+
−
+
−  /*
+
−   * Here an optimization is possible. This is, if an extension record
+
−   * and already has been read we could skip reading the extension record
+
−   * here. The optimization is not worth the effort, so we simply don't do
+
−   * it.
+
−   */
+
−
+
−  /*
+
−   * Do some protection against garbage
+
−   */
+
−  if (ext_record_ef NEQ 0)
+
−  {
+
−    /* Current record references an extension record */
+
−    next_ext_type = pb_get_ext_type_from_ef (ext_record_ef);
+
−
+
−    if ((next_ext_type EQ INVALID_EXT) OR
+
−        (ext_record_no < 1) OR
+
−        (ext_record_no > 254))
+
−    {
+
−      TRACE_ERROR ("pb_sim_write_ef() for ext delivered garbage EXT record");
+
−      ext_record_ef = 0; /* Try to proceed without this garbage */
+
−    }
+
−    else if (ext_type NEQ INVALID_EXT)
+
−    {
+
−      /* We have read an extension record */
+
−      if (pba_data.read_ext_record EQ NULL)
+
−      {
+
−        /* 1st extension record in the chain */
+
−        ACI_MALLOC (pba_data.read_ext_record, pba_data.ext_record_max[ext_type]);
+
−        memset (pba_data.read_ext_record, FALSE, pba_data.ext_record_max[ext_type]);
+
−      }
+
−
+
−      /* Mark current extension record as read */
+
−      pba_data.read_ext_record[recNr - 1] = TRUE;
+
−     
+
−      if (pba_data.read_ext_record[ext_record_no - 1] EQ TRUE)
+
−      {
+
−        /* We've already read the next extension record */
+
−        TRACE_ERROR ("EXT record already seen");
+
−        ext_record_ef = 0; /* Mark as garbage */
+
−      }
+
−    }
+
−  }
+
−  
+
−  if (ext_record_ef NEQ 0)
+
−  {
+
−    /* Current record references an extension record */
+
−    next_ext_type = pb_get_ext_type_from_ef (ext_record_ef);
+
−
+
−    /* 
+
−     * We have to read an extension record.
+
−     */
+
−    if (phb_type NEQ INVALID_PHB) // Patch HM 21-Sep-2006
+
−    {
+
−      /*
+
−       * It's the first extension record. Remember the paused phonebook.
+
−       */
+
−      TRACE_EVENT_P4 ("PHB EF %04x record %d references EXT EF %04x record %d",
+
−                      reqDataFld,
+
−                      recNr,
+
−                      ext_record_ef,
+
−                      ext_record_no);
+
−      pba_data.paused_ef = reqDataFld;
+
−      pba_data.paused_no = recNr;
+
−    }
+
−
+
−    /* Read the extension record. */
+
−    if (pba_data.ext_created[next_ext_type])
+
−    {
+
−      (void)pb_read_sim_record (ext_record_ef,
+
−                                ext_record_no, 
+
−                                pba_data.ext_record_len[next_ext_type]);
+
−    }
+
−    else
+
−    {
+
−      (void)pb_read_sim_record (ext_record_ef,
+
−                                ext_record_no, 
+
−                                NOT_PRESENT_8BIT);
+
−    }
+
−  }
+
−  else if (ext_type NEQ INVALID_EXT)
+
−  {
+
−    /* 
+
−     * The record read was the last extension record in the chain.
+
−     * Come back reading normal phonebook entries.
+
−     */
+
−
+
−    /* Free memory allocated for 
+
−     * tracking EXT records in chain 
+
−     * since EXT reading is over */
+
−    if(pba_data.read_ext_record NEQ NULL)
+
−    {
+
−      ACI_MFREE(pba_data.read_ext_record);
+
−      pba_data.read_ext_record = NULL;
+
−    }
+
−
+
−     if (!pba_data.ext_dummy_read)
+
−    {
+
−      next_phb_type = pb_get_phb_type_from_ef (pba_data.paused_ef);
+
−      if (pba_data.paused_no < pba_data.phb_record_max[next_phb_type])
+
−      {
+
−        /* Continue reading the current phonebook */
+
−        (void)pb_read_sim_record (pba_data.paused_ef,
+
−                                  (UBYTE)(pba_data.paused_no + 1),
+
−                                  pba_data.phb_record_len[next_phb_type]);
+
−
+
−#ifdef PHB_INCREMENTAL_SORT
+
−        /* Sort while reading the next record from the SIM */
+
−        (void)pb_sim_build_index (next_phb_type);
+
−#endif
+
−
+
−      }
+
−      else
+
−      {
+
−        (void)pb_sim_build_index (next_phb_type); /* Sort last entry of this book */
+
−
+
−        /* Next book */
+
−        pb_read_next_sim_book ();
+
−      }
+
−    }
+
−    else
+
−    {
+
−      /* Next book after having read dummy extension record */
+
−      pba_data.ext_dummy_read = FALSE;
+
−      pb_read_next_sim_book ();
+
−    }
+
−    pba_data.paused_ef  = 0;
+
−    pba_data.paused_no  = 0;
+
−
+
−  }
+
−  else if (simShrdPrm.atb[table_id].recNr < simShrdPrm.atb[table_id].recMax)
+
−  {
+
−    /*
+
−     * Normal phonebook record read, no extension referenced and not
+
−     * finished. Continue reading the current phonebook 
+
−     */
+
−    
+
−
+
−    (void)pb_read_sim_record (simShrdPrm.atb[table_id].reqDataFld,
+
−                              (UBYTE)(simShrdPrm.atb[table_id].recNr + 1),
+
−                              simShrdPrm.atb[table_id].dataLen);
+
−#ifdef PHB_INCREMENTAL_SORT
+
−    /* Sort while reading the next record from the SIM */
+
−    (void)pb_sim_build_index (phb_type);
+
−#endif
+
−
+
−  }
+
−  else
+
−  {
+
−    /*
+
−     * Normal phonebook record read, no extension referenced and finished
+
−     * reading this book. Continue reading the next book.
+
−     */
+
−    (void)pb_sim_build_index (phb_type); /* Sort last entry of this book */
+
−
+
−    /* Next book */
+
−    pb_read_next_sim_book ();
+
−  }
+
−}
+
−#undef PHB_INCREMENTAL_SORT // Only locally and temporary, HM 18-Oct-2006
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_sat_update_reset                |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function marks the given elementary file as unread.
+
−    
+
−*/
+
−LOCAL void pb_sat_update_reset (USHORT ef)
+
−{
+
−  T_PHB_TYPE phb_type;
+
−
+
−  TRACE_FUNCTION ("pb_sat_update_reset()");
+
−
+
−  phb_type = pb_get_phb_type_from_ef (ef);
+
−
+
−  if (phb_type NEQ INVALID_PHB)
+
−  {
+
−    /* Mark book as unread */
+
−    pba_data.book_read[phb_type] = FALSE;
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_read_sim_cb                     |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function is the callback when a SIM elementary file has 
+
−              been read (SIM_READ_CNF).
+
−              There are two fields which can have been read here, those are
+
−              the emergency call numbers and the SIM service table.
+
−
+
−*/
+
−
+
−
+
−LOCAL void pb_read_sim_cb (SHORT table_id)
+
−{
+
−  TRACE_FUNCTION ("pb_read_sim_cb()");
+
−
+
−  switch (simShrdPrm.atb[table_id].reqDataFld)
+
−  {
+
−    case SIM_ECC:
+
−      if (simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)
+
−      {
+
−        (void)pb_sim_set_ecc (simShrdPrm.atb[table_id].dataLen,
+
−                              simShrdPrm.atb[table_id].exchData);
+
−
+
−#ifdef SIM_TOOLKIT
+
−        if (simShrdPrm.fuRef >= 0)
+
−        {
+
−          psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_SUCCESS);
+
−        }
+
−#endif /* #ifdef SIM_TOOLKIT */
+
−
+
−      }        
+
−      else
+
−      {
+
−        /* 
+
−         * Some error from the SIM. Indicate a fallback to the PCM/FFS.
+
−         */
+
−        (void)pb_sim_set_ecc (0, NULL);
+
−
+
−#ifdef SIM_TOOLKIT
+
−        if (simShrdPrm.fuRef >= 0)
+
−        {
+
−          psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_ERROR);
+
−        }
+
−#endif
+
−
+
−      }
+
−
+
−      if (pba_data.data NEQ NULL)
+
−      {
+
−        ACI_MFREE (pba_data.data);
+
−        pba_data.data = NULL;
+
−      }
+
−      break;
+
−
+
−    case SIM_SST:
+
−      if (simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR)
+
−      {
+
−        /* copy SIM service table */
+
−        memset(pba_data.sim_service_table, 0, MAX_SRV_TBL);
+
−        memcpy(pba_data.sim_service_table, 
+
−               simShrdPrm.atb[table_id].exchData, 
+
−               MINIMUM(MAX_SRV_TBL, simShrdPrm.atb[table_id].dataLen));
+
−
+
−        /* start reading SIM phonebook */
+
−        simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
−        pb_start_build (FALSE);
+
−      }
+
−      else
+
−      {
+
−        TRACE_ERROR ("Cannot read SIM service table, using old table");
+
−
+
−#ifdef SIM_TOOLKIT
+
−        if (simShrdPrm.fuRef >= 0)
+
−        {
+
−          psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_ERROR);
+
−        }
+
−#endif
+
−
+
−        /* start reading SIM phonebook (fallback action, best effort) */
+
−        simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
−        pb_start_build (FALSE);
+
−      }
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR ("Unexpected SIM_READ_CNF");
+
−      break;
+
−  }
+
−  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_is_sim_field                    |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function determines wheter an elementary file has to 
+
−              be synchronized to the SIM or only exists locally in the FFS.
+
−
+
−*/
+
−LOCAL BOOL pb_is_sim_field (USHORT ef)
+
−{
+
−  TRACE_FUNCTION ("pb_is_sim_field()");
+
−
+
−  switch (ef)
+
−  {
+
−    /* case SIM_ICI: */
+
−    case FFS_LRN:
+
−    case FFS_LMN:
+
−    case FFS_EXT_LRN:
+
−    case FFS_EXT_LMN:
+
−    case SIM_OCI:
+
−    case SIM_EXT5:
+
−      return FALSE; /* Only in FFS */
+
−
+
−    default:
+
−      return TRUE;  /* Counterpart in SIM exists */
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_sync_next_sim_record            |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function synchronizes a changed record to the SIM.
+
−              
+
−              The first parameter is given to determine whether it's the first
+
−              record to be synchronized, in this case ACI has to be informed.
+
−  
+
−              If there was no record to synchronize, PHB_OK is returned.
+
−              If there is a record to synchronize, PHB_EXCT is returned.
+
−              If there was an internal failure we get PHB_FAIL 
+
−              (which is unexpected).
+
−
+
−*/
+
−
+
−LOCAL T_PHB_RETURN pb_sync_next_sim_record (BOOL first)
+
−{
+
−  T_PHB_RETURN phb_result;
+
−  USHORT field_id;
+
−  USHORT record;
+
−  USHORT entry_size;
+
−
+
−  TRACE_FUNCTION ("pb_sync_next_sim_record()");
+
−
+
−  do
+
−  {
+
−    if (pba_data.records_changed.entries EQ 0)
+
−    {
+
−      if (pb_read_queue() EQ PHB_EXCT)
+
−        return PHB_EXCT; /* Queued LDN entry is written */
+
−
+
−      /* Inform SIM layer we're done synchronizing */
+
−      (void)pb_sim_flush_data ();
+
−
+
−      /* Don't change the state if phb_state is PHB_STATE_DELETE_BOOK
+
−       * since state will be changed in pb_write_sim_record_cb after
+
−       * all the records are deleted */
+
−      if(GET_PHB_STATE() NEQ PHB_STATE_DELETE_BOOK)
+
−      {
+
−        SET_PHB_STATE (PHB_STATE_IDLE);
+
−      
+
−        /* Inform ACI that we're ready */
+
−        pb_status_ind (PHB_READY, CME_ERR_NotPresent);
+
−      }
+
−
+
−      return PHB_OK; /* No record to synchronize to the SIM */
+
−    }
+
−
+
−    /* Get the next record from the list */
+
−    pba_data.records_changed.entries--;
+
−    field_id = pba_data.records_changed.field_id[0];
+
−    record   = pba_data.records_changed.record[0];
+
−
+
−    /* Remove the record from the list */
+
−    memmove (&pba_data.records_changed.field_id[0],
+
−             &pba_data.records_changed.field_id[1],
+
−             sizeof (USHORT) * (DB_MAX_AFFECTED - 1));
+
−    memmove (&pba_data.records_changed.record[0],
+
−             &pba_data.records_changed.record[1],
+
−             sizeof (USHORT) * (DB_MAX_AFFECTED - 1));
+
−  } 
+
−  while (!pb_is_sim_field(field_id));
+
−
+
−  TRACE_EVENT_P3 ("Synch ef %04X record %d, still %d entries to do",
+
−                  field_id, record, pba_data.records_changed.entries);
+
−
+
−  /* Allocate room for the SIM data  #HM# Check for free */
+
−  if (pba_data.data EQ NULL)
+
−  {
+
−    ACI_MALLOC (pba_data.data, SIM_MAX_RECORD_SIZE);
+
−  }
+
−
+
−  /* Fetch record in raw form from the database */
+
−  phb_result = pb_sim_read_ef (field_id,
+
−                               record,
+
−                               &entry_size,
+
−                               pba_data.data);
+
−
+
−  if (phb_result EQ PHB_OK)
+
−  {
+
−    /* And write it to the SIM */
+
−    phb_result = pb_write_sim_record (field_id,
+
−                                      (UBYTE)record, 
+
−                                      (UBYTE)entry_size,
+
−                                      pba_data.data);
+
−
+
−    if (phb_result NEQ PHB_EXCT)
+
−    {
+
−      /* Inform ACI that we've had a problem */
+
−      pb_status_ind ( PHB_WRITE_FAIL, CME_ERR_NotPresent );
+
−      return phb_result; /* Some unexpected internal failure */
+
−    }
+
−
+
−    if (first)
+
−    {
+
−      /* Inform ACI that we're busy synchronizing SIM entries */
+
−      pb_status_ind ( PHB_BUSY, CME_ERR_NotPresent );
+
−    }
+
−
+
−    return PHB_EXCT;
+
−  }
+
−  return phb_result;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_write_sim_record                |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function writes a SIM record to the SIM.
+
−
+
−*/
+
−
+
−LOCAL T_PHB_RETURN pb_write_sim_record (USHORT ef,
+
−                                        UBYTE phy_recno,
+
−                                        UBYTE entry_size,
+
−                                  const UBYTE *buffer)
+
−{
+
−  SHORT           table_id;
+
−
+
−
+
−  TRACE_FUNCTION("pb_write_sim_record()");
+
−
+
−  table_id = psaSIM_atbNewEntry();
+
−  if (table_id EQ NO_ENTRY)
+
−  {
+
−    TRACE_ERROR ("pb_write_sim_record(): no more table entries");
+
−    return (PHB_FAIL);
+
−  }
+
−
+
−  simShrdPrm.atb[table_id].ntryUsdFlg = TRUE;
+
−  simShrdPrm.atb[table_id].accType    = ACT_WR_REC;
+
−  simShrdPrm.atb[table_id].v_path_info  = FALSE;
+
−  simShrdPrm.atb[table_id].reqDataFld = ef;
+
−  simShrdPrm.atb[table_id].recNr      = phy_recno;
+
−  simShrdPrm.atb[table_id].dataLen    = entry_size;
+
−  simShrdPrm.atb[table_id].exchData   = (UBYTE *)buffer;
+
−  simShrdPrm.atb[table_id].rplyCB     = pb_write_sim_record_cb;
+
−
+
−  simShrdPrm.aId = table_id;
+
−
+
−  if (psaSIM_AccessSIMData() < 0)
+
−  {
+
−    TRACE_EVENT("pb_write_sim_record(): psaSIM_AccessSIMData() failed");
+
−    return (PHB_FAIL);
+
−  }
+
−
+
−  return (PHB_EXCT);
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_write_sim_record_cb             |
+
−+----------------------------------------------------------------------------+
+
−
+
−    PURPOSE : This function is the callback when a SIM record has been
+
−              written to the SIM.
+
−
+
−*/
+
−
+
−LOCAL void pb_write_sim_record_cb (SHORT table_id)
+
−{
+
−  UBYTE max_record;
+
−  T_PHB_RETURN phb_result;
+
−
+
−  TRACE_FUNCTION("pb_write_sim_record_cb()");
+
−
+
−  simShrdPrm.atb[table_id].ntryUsdFlg = FALSE;
+
−
+
−  if (simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR)
+
−  {
+
−    /* 
+
−     * Data in the database and on the SIM probably now differ,
+
−     * we can do not much about this.
+
−     */
+
−    TRACE_ERROR("pb_write_cb(): error for writing");
+
−    pb_status_ind (PHB_WRITE_FAIL,
+
−                   (SHORT)cmhSIM_GetCmeFromSim (simShrdPrm.atb[table_id].errCode));
+
−    return;
+
−  }
+
−
+
−  switch (GET_PHB_STATE())
+
−  {
+
−    case PHB_STATE_WRITE:
+
−      /* Synchronize next SIM record */
+
−      switch (pb_sync_next_sim_record (FALSE))
+
−      {
+
−        case PHB_OK:
+
−          /* PHB_READY has been already indicated in pb_sync_next_sim_record */
+
−          break;
+
−
+
−        case PHB_EXCT:
+
−          break; /* Next record => SIM */
+
−
+
−        case PHB_FAIL:
+
−        default:
+
−          TRACE_ERROR ("Unexpected phb_result");      
+
−          SET_PHB_STATE (PHB_STATE_IDLE);
+
−          pb_status_ind (PHB_WRITE_FAIL, CME_ERR_NotPresent);
+
−          break;
+
−      }
+
−      break;
+
−
+
−    case PHB_STATE_DELETE_BOOK:
+
−      /* Synchronize next SIM record */
+
−      switch (pb_sync_next_sim_record (FALSE))
+
−      {
+
−        case PHB_OK:
+
−          /* 
+
−           * Record synched. Delete next record of phonebook, if available
+
−           */
+
−          max_record = pba_data.phb_record_max[pba_data.current_book];
+
−          while ((pba_data.del_record <= max_record) AND
+
−                 (pba_data.records_changed.entries EQ 0))
+
−          {
+
−            /* Delete the record in the database */
+
−            phb_result = pb_sim_del_record (pba_data.current_book, 
+
−                                   pba_data.del_record,
+
−                                   &pba_data.records_changed); 
+
−            
+
−            if ((phb_result NEQ PHB_OK) AND (phb_result NEQ PHB_EMPTY_RECORD))
+
−            {
+
−              TRACE_ERROR ("Unexpected problem from pb_sim_del_record()");
+
−
+
−              /* Inform SIM layer we're done synchronizing.
+
−               * Should we indicate also there was a problem? */
+
−              (void)pb_sim_flush_data ();
+
−
+
−              pb_status_ind (PHB_WRITE_FAIL, CME_ERR_NotPresent);
+
−
+
−              SET_PHB_STATE (PHB_STATE_IDLE);
+
−              return;
+
−            }
+
−            pba_data.del_record++;
+
−          } 
+
−
+
−          if (pba_data.records_changed.entries NEQ 0)
+
−          {
+
−            /* Synchronizing record(s) to the SIM */
+
−            if (pb_sync_next_sim_record (FALSE) NEQ PHB_EXCT)
+
−            {
+
−              TRACE_ERROR ("Unexpected problem from pb_sync_next_sim_record()");
+
−
+
−              /* Inform SIM layer we're done synchronizing.
+
−               * Should we indicate also there was a problem? */
+
−              (void)pb_sim_flush_data ();
+
−
+
−              pb_status_ind (PHB_WRITE_FAIL, CME_ERR_NotPresent);
+
−
+
−              SET_PHB_STATE (PHB_STATE_IDLE);
+
−              return;
+
−            }
+
−          }
+
−
+
−          /* 
+
−           * We're through
+
−           */
+
−          if(pba_data.del_record > max_record)
+
−          {
+
−            (void)pb_sim_flush_data ();
+
−
+
−            SET_PHB_STATE (PHB_STATE_IDLE);
+
−	    
+
−            /* Inform the ACI that we're done */
+
−            pb_status_ind (PHB_READY, CME_ERR_NotPresent);
+
−          }
+
−          break;
+
−
+
−        case PHB_EXCT:
+
−          break; /* Next record => SIM */
+
−
+
−        case PHB_FAIL:
+
−        default:
+
−          TRACE_ERROR ("Unexpected problem synching SIM");      
+
−
+
−          (void)pb_sim_flush_data ();
+
−
+
−          pb_status_ind (PHB_WRITE_FAIL, CME_ERR_NotPresent);
+
−          /* Inform SIM layer we're done synchronizing.
+
−           * Should we indicate also there was a problem? */
+
−
+
−          SET_PHB_STATE (PHB_STATE_IDLE);
+
−          break;
+
−      }
+
−      break;
+
−
+
−    default:
+
−      TRACE_ERROR ("Unexpected default");
+
−      break;
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_get_phb_type_from_ef            |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function converts a SIM elementary file number to the 
+
−            appropriate constant of type T_PHB_TYPE, if applicable.
+
−            Non applicable => INVALID_PHB
+
−
+
−*/
+
−T_PHB_TYPE pb_get_phb_type_from_ef (USHORT ef)
+
−{
+
−  TRACE_FUNCTION ("pb_get_phb_type_from_ef()");
+
−
+
−  switch (ef)
+
−  {
+
−    case SIM_ECC:
+
−      return ECC;
+
−
+
−    case SIM_ADN:
+
−      return ADN;
+
−
+
−    case SIM_FDN:
+
−      return FDN;
+
−
+
−    case SIM_BDN:
+
−      return BDN;
+
−
+
−    case SIM_LND:
+
−      return LDN;
+
−
+
−    case SIM_MSISDN:
+
−      return UPN;
+
−
+
−    case SIM_SDN:
+
−      return SDN;
+
−
+
−    default:
+
−      return INVALID_PHB;
+
−  }
+
−}
+
−
+
− 
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_get_ext_type_from_ef            |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function converts a SIM elementary file number to the
+
−            appropriate constant of T_PHB_EXT_TYPE, if applicable.
+
−            Non applicable => INVALID_EXT
+
−
+
−*/
+
−T_EXT_TYPE pb_get_ext_type_from_ef (USHORT ef)
+
−{
+
−  TRACE_FUNCTION ("pb_get_ext_type_from_ef()");
+
−
+
−  switch (ef)
+
−  {
+
−    case SIM_EXT1:
+
−      return EXT1;
+
−
+
−    case SIM_EXT2:
+
−      return EXT2;
+
−
+
−    case SIM_EXT3:
+
−      return EXT3;
+
−
+
−    case SIM_EXT4:
+
−      return EXT4;
+
−
+
−    case SIM_EXT5:
+
−      return EXT5;
+
−
+
−    default:
+
−      return INVALID_EXT;
+
−  }
+
−}
+
−
+
−
+
−/* ------------------------------------------------------------------------ */
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_search_number_ex                |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : At some places a more sohisticated number searching function 
+
−            is desirable which can be based on existing phonebook 
+
−            functionality.
+
−
+
−*/
+
−GLOBAL T_PHB_RETURN pb_search_number_ex (T_PHB_TYPE type,
+
−                                         const UBYTE *number,
+
−                                         SHORT *order_num,
+
−                                         SHORT *found,
+
−                                         T_PHB_RECORD *entry)
+
−{
+
−  T_PHB_RETURN phb_result;
+
−  SHORT index;
+
−
+
−  TRACE_FUNCTION ("pb_search_number_ex()");
+
−
+
−  /* Search for first entry */
+
−  phb_result = pb_search_number (type,
+
−                                 number,
+
−                                 order_num);
+
−  if (phb_result NEQ PHB_OK)
+
−    return phb_result;
+
−
+
−  /* 
+
−   * Determine number of found entries. We are doing a linear algorithm, 
+
−   * a binary algorithm is possible here to speed up things.
+
−   */
+
−  if (found NEQ NULL)
+
−  {
+
−    *found = 1;
+
−    index = *order_num;
+
−
+
−    while (pb_search_number (type, number, &index) EQ PHB_OK)
+
−    { 
+
−      ++(*found);
+
−      /* index should not be incremented as lower layer (DB) will take
+
−         care of it */
+
−    }
+
−  }
+
−
+
−  /* Read the first found entry, if desired */
+
−  if (entry NEQ NULL)
+
−    return (pb_read_number_record (type, *order_num, entry));
+
−  return PHB_OK;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_search_name_ex                  |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : At some places a more sohisticated name searching function 
+
−            is desirable which can be based on existing phonebook 
+
−            functionality.
+
−
+
−*/
+
−GLOBAL T_PHB_RETURN pb_search_name_ex (T_PHB_TYPE type,
+
−                                       T_PHB_MATCH match,
+
−                                       const T_ACI_PB_TEXT *search_tag,
+
−                                       SHORT *order_num,
+
−                                       SHORT *found,
+
−                                       T_PHB_RECORD *entry)
+
−{
+
−  T_PHB_RETURN phb_result;
+
−  SHORT index;
+
−
+
−  TRACE_FUNCTION ("pb_search_name_ex()");
+
−
+
−  /* Search for first entry */
+
−  phb_result = pb_search_name (type,
+
−                               match,
+
−                               search_tag,
+
−                               order_num);
+
−  if (phb_result NEQ PHB_OK)
+
−    return phb_result;
+
−
+
−  /* 
+
−   * Determine number of found entries. We are doing a linear algorithm, 
+
−   * a binary algorithm is possible here to speed up things.
+
−   */
+
−  if (found NEQ NULL)
+
−  {
+
−    *found = 1;
+
−    index = *order_num;
+
−
+
−    while (pb_search_name (type, match, search_tag, &index) EQ PHB_OK)
+
−    { 
+
−      ++(*found);
+
−      /* index should not be incremented as lower layer (DB) will take
+
−         care of it */
+
−    }
+
−      
+
−  }
+
−
+
−  /* Read the first found entry, if desired */
+
−  if (entry NEQ NULL)
+
−    return (pb_read_alpha_record (type, *order_num, entry));
+
−  return PHB_OK;
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_status_ind                      |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function indicates the new phonebook status to the ACI 
+
−            preventing we're indication twice PHB_READY or PHB_BUSY.
+
−
+
−*/
+
−LOCAL void pb_status_ind (T_PHB_STAT phb_stat, SHORT cmeError)
+
−{
+
−  TRACE_FUNCTION ("pb_status_ind()");
+
−
+
−  /* Avoid to indicate twice busy or ready */
+
−  if ((pba_data.phb_stat NEQ phb_stat) OR
+
−      ((phb_stat NEQ PHB_READY) AND
+
−       (phb_stat NEQ PHB_BUSY)))
+
−  {
+
−    pba_data.phb_stat = phb_stat;
+
−    cmhPHB_StatIndication (phb_stat, cmeError,TRUE);
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_write_queue                     |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function writes a LDN entry to the queue if the SIM is busy.
+
−
+
−*/
+
−LOCAL T_PHB_RETURN pb_write_queue (const T_PHB_RECORD *entry)
+
−{
+
−  TRACE_FUNCTION ("pb_write_queue()");
+
−
+
−  if (pba_data.c_queued < PHB_MAX_QUEUE)
+
−  {
+
−    memmove (&pba_data.queued[1],
+
−             &pba_data.queued[0],
+
−             pba_data.c_queued * sizeof (T_PHB_QUEUE *));
+
−    ACI_MALLOC (pba_data.queued[pba_data.c_queued], 
+
−                sizeof (T_PHB_QUEUE));
+
−    pba_data.queued[0]->entry = *entry;
+
−    pba_data.c_queued++;
+
−    return PHB_EXCT;
+
−  }
+
−  
+
−  return PHB_FAIL; /* Queue full */
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_clear_queue                     |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function clears the LDN queue.
+
−
+
−*/
+
−LOCAL void pb_clear_queue (void)
+
−{
+
−  TRACE_FUNCTION ("pb_clear_queue()");
+
−
+
−  while (pba_data.c_queued NEQ 0)
+
−  {
+
−    pba_data.c_queued--;
+
−    ACI_MFREE (pba_data.queued[pba_data.c_queued]);
+
−    pba_data.queued[pba_data.c_queued] = NULL;
+
−  }
+
−}
+
−
+
−
+
−/*
+
−+----------------------------------------------------------------------------+
+
−| PROJECT : GSM-PS (6147)       MODULE  : PHB                                |
+
−| STATE   : code                ROUTINE : pb_read_queue                      |
+
−+----------------------------------------------------------------------------+
+
−
+
−  PURPOSE : This function reads the queue and adds the queued phonebook 
+
−            entries.
+
−
+
−*/
+
−LOCAL T_PHB_RETURN pb_read_queue (void)
+
−{
+
−  T_PHB_RETURN phb_result;
+
−
+
−  TRACE_FUNCTION ("pb_write_queue()");
+
−
+
−  while (pba_data.c_queued NEQ 0)
+
−  {
+
−    /*
+
−     * LDN entries have been queued. Write them now.
+
−     */
+
−    pba_data.c_queued--;
+
−    phb_result = pb_add_record (LDN,
+
−                                pba_data.queued[pba_data.c_queued]->index,
+
−                                &pba_data.queued[pba_data.c_queued]->entry);
+
−    ACI_MFREE (pba_data.queued[pba_data.c_queued]);
+
−    pba_data.queued[pba_data.c_queued] = NULL;
+
−    switch (phb_result)
+
−    {
+
−      case PHB_EXCT:
+
−        return phb_result;
+
−      case PHB_OK:
+
−        break;
+
−      default:
+
−        pb_clear_queue();
+
−        return phb_result;
+
−    }
+
−  }
+
−  return PHB_OK;
+
−}
+
−
+
−/*
+
−+------------------------------------------------------------------+
+
−| PROJECT : MMI-Framework (8417)         MODULE: PHB               |
+
−| STATE   : code                         ROUTINE : pb_status_req |
+
−+------------------------------------------------------------------+
+
−
+
−  PURPOSE : To update status of Phonebook to MMI
+
−
+
−*/
+
−void pb_status_req(UBYTE *pb_stat)
+
−{
+
− 
+
−  *pb_stat = pba_data.phb_stat;
+
−}
+
−
+
−#endif /* #ifdef TI_PS_FFS_PHB */