FreeCalypso > hg > fc-tourmaline
view src/g23m-aci/aci/phb.c @ 247:12b20090b46a
ETM: add phone-on command to FCBM
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 09 May 2021 21:04:52 +0000 |
| parents | fa8dc04885d8 |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | 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 books. +----------------------------------------------------------------------------- */ #ifndef TI_PS_FFS_PHB #include "aci_all.h" #include "aci_cmh.h" #include "ati_cmd.h" #include "aci_cmd.h" #include "aci.h" #include "p_sim.h" #include "pcm.h" #include "gdi.h" #include "phb.h" #include "psa.h" #include "psa_sim.h" #include "psa_cc.h" #ifdef SIM_TOOLKIT #include "psa_sat.h" #endif #ifdef FAX_AND_DATA #include "aci_fd.h" #endif /* of #ifdef FAX_AND_DATA */ #include "cmh.h" #include "cmh_phb.h" #include "dti_conn_mng.h" #include "cmh_sim.h" #include "psa_mm.h" #include "psa_ss.h" #ifndef _SIMULATION_ #include "ffs/ffs.h" #endif /********* current define *******************************************/ static T_PHB_EXT_CMP_FCT ext_compare_fct = NULL; /* external compare function */ static T_PHB_CTB phb_ctb[MAX_PHONEBOOK]; static T_PHB_AFB_ELEMENT phb_element[MAX_AFB_RECORDS]; static T_PHB_RDM_ELEMENT phb_l_element[MAX_RDM_RECORDS]; static UBYTE adn_bitmap[MAX_ADN_BITMAP]; static UBYTE fdn_bitmap[MAX_FDN_BITMAP]; static UBYTE bdn_bitmap[MAX_BDN_BITMAP]; static UBYTE sdn_bitmap[MAX_SDN_BITMAP]; static UBYTE ecc_bitmap[MAX_ECC_BITMAP]; static UBYTE upn_bitmap[MAX_UPN_BITMAP]; #ifdef PHONEBOOK_EXTENSION static T_PHB_EXT_RECORDS phb_ext_records[MAX_PHB_EXT]; static UBYTE ext1_bitmap[MAX_EXT1_BITMAP]; static UBYTE ext2_bitmap[MAX_EXT2_BITMAP]; static UBYTE ext3_bitmap[MAX_EXT3_BITMAP]; static UBYTE ext4_bitmap[MAX_EXT4_BITMAP]; #endif static UBYTE sim_service_table[MAX_SRV_TBL]; /* SIM service table */ static UBYTE data [256]; static SHORT ext_index; static UBYTE max_ext_chain_reads=0; static UBYTE phb_stat; static UBYTE fdn_mode; static T_ACI_CLASS fdn_classtype; static T_ACI_CLASS fdn_input_classtype; static UBYTE read_flag = 0; static SHORT db_index = UNUSED_INDEX; /* memory index for delete whole phonebook */ static BOOL sstUpdateId = FALSE; /* SIM service table update indication (SAT) */ static UBYTE max_sim_LDN_records = 0; /* to ensure that every physical record is written */ static int cmpString (UBYTE *s1, UBYTE *s2, UBYTE len); static int pb_cmp_phb_entry ( UBYTE *pb_tag, UBYTE pb_len, T_ACI_PB_TEXT *search_tag ); static int pb_cmp2Bytes(UBYTE *s1, UBYTE *s2, UBYTE len, UBYTE flag); static void pb_cvt_alpha_for_cmp ( UBYTE *src, UBYTE *dst, UBYTE len ); static BOOL imsiFlag; static BOOL pause_pb_reading_while_EXT_reading = FALSE; /* pauses the loop while reading EXT-Records */ static SHORT paused_table_id = 0; /* the paused record */ EXTERN T_PCEER causeMod; EXTERN SHORT causeCeer; #ifdef SIM_TOOLKIT BOOL pb_update (int ref, T_SIM_FILE_UPDATE_IND *fu); BOOL pb_update_ecc_fu (int ref, T_SIM_FILE_UPDATE_IND *fu); #endif void pb_copy_ecc_entry (UBYTE *ecc, UBYTE num); void pb_read_sim_ecc ( void ); void pb_read_eeprom_ecc (void); T_PHB_RETURN pb_read_eeprom_req(void); BOOL pb_read_sim_dat(USHORT data_id, UBYTE len, UBYTE max_length); void pb_read_sim_dat_cb(SHORT table_id); void pb_read_sim_req(void); void pb_sat_update_reset (USHORT data_id); void pb_init_afb(void); void pb_init_ctb (T_PHB_TYPE book); void pb_init_element (UBYTE book); void pb_init_l_element (UBYTE book); /*CQ16301: Added support for LND Refresh*/ BOOL pb_init_sync_sim(UBYTE type); BOOL pb_prepare_sync_sim(UBYTE type, UBYTE rcd_num); BOOL pb_sync_sim(UBYTE type, UBYTE rcd_num); void pb_sync_sim_cb(SHORT table_id); void pb_finish_sync_sim(void); void copy_phb_element ( T_PHB_RECORD *entry, T_PHB_AFB_ELEMENT phb_element ); void copy_phb_l_element ( T_PHB_RECORD *entry, T_PHB_RDM_ELEMENT phb_l_element ); LOCAL USHORT pb_get_ext_file_id (UBYTE pb_type); LOCAL void pb_prepare_ext_data(UBYTE *number, UBYTE no_len, UBYTE *subaddr, UBYTE sub_len, USHORT file_id); LOCAL void pb_free_used_record(UBYTE type, SHORT index, UBYTE rec_num); /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_sat_update_reset | +--------------------------------------------------------------------+ PURPOSE : Initialisation of phonebook field for SAT REFRESH */ void pb_sat_update_reset (USHORT data_id) { TRACE_FUNCTION("pb_sat_update_reset()"); #ifdef SIM_TOOLKIT switch (data_id) { /* ACI-ENH-17240: Subissue of CQ 16303, ADN and FDN are updated if one of them has changed */ case SIM_ADN: /* * pb_init_element (ADN); * pb_init_ctb (ADN); * phb_ctb[ADN].rcd_bitmap = adn_bitmap; * memset(phb_ctb[ADN].rcd_bitmap, 0, MAX_ADN_BITMAP); * break; */ case SIM_FDN: /* * pb_init_element (FDN); * pb_init_ctb (FDN); * phb_ctb[FDN].rcd_bitmap = fdn_bitmap; * memset(phb_ctb[FDN].rcd_bitmap, 0, MAX_FDN_BITMAP); */ pb_init_afb(); break; case SIM_BDN: pb_init_element (BDN); pb_init_ctb (BDN); phb_ctb[BDN].rcd_bitmap = bdn_bitmap; memset(phb_ctb[BDN].rcd_bitmap, 0, MAX_BDN_BITMAP); break; case SIM_SDN: pb_init_element (SDN); pb_init_ctb (SDN); phb_ctb[SDN].rcd_bitmap = sdn_bitmap; memset(phb_ctb[SDN].rcd_bitmap, 0, MAX_SDN_BITMAP); break; case SIM_MSISDN: pb_init_element (UPN); pb_init_ctb (UPN); phb_ctb[UPN].rcd_bitmap = upn_bitmap; memset(phb_ctb[UPN].rcd_bitmap, 0, MAX_UPN_BITMAP); break; /* CQ16301: Added support for LND refresh triggered by SAT */ case SIM_LND: pb_init_l_element (LDN); pb_init_ctb (LDN); break; default: break; } #endif } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_init_ctb | +--------------------------------------------------------------------+ PURPOSE : Initialisation of the phonebook control block, but not for bitmap field */ void pb_init_ctb (T_PHB_TYPE book) { TRACE_FUNCTION("pb_init_ctb()"); phb_ctb[book].mem = NO_PHB_ENTRY; phb_ctb[book].alpha_len = 0; phb_ctb[book].max_rcd = 0; phb_ctb[book].used_rcd = 0; phb_ctb[book].first_rcd = UNUSED_INDEX; phb_ctb[book].first_trcd = UNUSED_INDEX; phb_ctb[book].first_nrcd = UNUSED_INDEX; phb_ctb[book].first_mtrcd = UNUSED_INDEX; phb_ctb[book].first_mnrcd = UNUSED_INDEX; } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_init_element | +--------------------------------------------------------------------+ PURPOSE : Initialisation of the saved phonebook element */ void pb_init_element (UBYTE book) { SHORT index; TRACE_FUNCTION("pb_init_element()"); index = phb_ctb[book].first_rcd; while (index NEQ UNUSED_INDEX) { phb_element[index].free = PHB_ELEMENT_FREE; index = phb_element[index].next_rcd; } } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_init_l_element | +--------------------------------------------------------------------+ PURPOSE : Initialisation of the saved phonebook element (ME) */ void pb_init_l_element (UBYTE book) { SHORT index; TRACE_FUNCTION("pb_init_l_element()"); index = phb_ctb[book].first_rcd; while (index NEQ UNUSED_INDEX) { phb_l_element[index].free = PHB_ELEMENT_FREE; index = phb_element[index].next_rcd; } } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: phb_Init | +--------------------------------------------------------------------+ PURPOSE : Power-on initialisation of the phonebook module */ void phb_Init (void) { fdn_mode = NO_OPERATION; /* set fdn_classtype to default value */ fdn_classtype = CLASS_VceDatFaxSms; fdn_input_classtype = fdn_classtype; #ifdef SIM_TOOLKIT simShrdPrm.fuRef=-1; if (!psaSAT_FURegister (pb_update)) { TRACE_EVENT ("FAILED to register the handler pb_update() for FU"); } if (!psaSAT_FURegister (pb_update_ecc_fu)) { TRACE_EVENT ("FAILED to register the handler pb_update_ecc_fu() for FU"); } #endif } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_init | +--------------------------------------------------------------------+ PURPOSE : */ void pb_init (void) { TRACE_FUNCTION ("pb_init()"); if (fdn_mode EQ NO_OPERATION) { { T_PHB_TYPE i; /* Initiate the bitmap in control block */ for (i=0; i<MAX_PHONEBOOK; i++) { pb_init_ctb(i); switch(i) { case ECC: phb_ctb[i].rcd_bitmap = ecc_bitmap; memset(phb_ctb[i].rcd_bitmap, 0, MAX_ECC_BITMAP); break; case ADN: phb_ctb[i].rcd_bitmap = adn_bitmap; memset(phb_ctb[i].rcd_bitmap, 0, MAX_ADN_BITMAP); break; case FDN: phb_ctb[i].rcd_bitmap = fdn_bitmap; memset(phb_ctb[i].rcd_bitmap, 0, MAX_FDN_BITMAP); break; case BDN: phb_ctb[i].rcd_bitmap = bdn_bitmap; memset(phb_ctb[i].rcd_bitmap, 0, MAX_BDN_BITMAP); break; case SDN: phb_ctb[i].rcd_bitmap = sdn_bitmap; memset(phb_ctb[i].rcd_bitmap, 0, MAX_SDN_BITMAP); break; case UPN: phb_ctb[i].rcd_bitmap = upn_bitmap; memset(phb_ctb[i].rcd_bitmap, 0, MAX_UPN_BITMAP); break; } } } #ifdef PHONEBOOK_EXTENSION { T_PHB_EXT_TYPE i; /* Initiate the bitmap for the phonebook extention records */ for (i = 0; i < MAX_PHB_EXT; i++) { phb_ext_records[i].mem = NO_PHB_ENTRY; phb_ext_records[i].max_rcd = 0; switch (i) { case EXT1: phb_ext_records[i].rcd_bitmap = ext1_bitmap; memset(phb_ext_records[i].rcd_bitmap, 0, MAX_EXT1_BITMAP); /* ADN; LDN */ break; case EXT2: phb_ext_records[i].rcd_bitmap = ext2_bitmap; memset(phb_ext_records[i].rcd_bitmap, 0, MAX_EXT2_BITMAP); /* FDN */ break; case EXT3: phb_ext_records[i].rcd_bitmap = ext3_bitmap; memset(phb_ext_records[i].rcd_bitmap, 0, MAX_EXT3_BITMAP); /* SDN */ break; case EXT4: phb_ext_records[i].rcd_bitmap = ext4_bitmap; memset(phb_ext_records[i].rcd_bitmap, 0, MAX_EXT4_BITMAP); /* BDN */ break; } } } #endif { int i; /* Initiate the free element */ for (i=0; i<MAX_AFB_RECORDS; i++) phb_element[i].free = PHB_ELEMENT_FREE; for (i=0; i<MAX_RDM_RECORDS; i++) phb_l_element[i].free = PHB_ELEMENT_FREE; } phb_stat = PHB_UNKNOWN; cmhPHB_StatIndication ( PHB_UNKNOWN, CME_ERR_NotPresent, TRUE ); } } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_init_afb | +--------------------------------------------------------------------+ PURPOSE : */ void pb_init_afb(void) { T_PHB_TYPE i; SHORT index; SHORT cur_index; TRACE_FUNCTION ("pb_init_afb()"); /* Initiate the bitmap in control block */ for (i=0; i<MAX_PHONEBOOK; i++) { switch (i) { case ADN: case FDN: index = phb_ctb[i].first_rcd; while (index != UNUSED_INDEX) { cur_index = index; index = phb_element[cur_index].next_rcd; phb_element[cur_index].free = PHB_ELEMENT_FREE; phb_element[cur_index].prev_rcd = UNUSED_INDEX; phb_element[cur_index].next_rcd = UNUSED_INDEX; } pb_init_ctb(i); switch(i) { case ADN: phb_ctb[i].rcd_bitmap = adn_bitmap; memset(phb_ctb[i].rcd_bitmap, 0, MAX_ADN_BITMAP); break; case FDN: phb_ctb[i].rcd_bitmap = fdn_bitmap; memset(phb_ctb[i].rcd_bitmap, 0, MAX_FDN_BITMAP); break; } break; case ADN_FDN: pb_init_ctb(i); break; default: break; } } } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_reset | +--------------------------------------------------------------------+ PURPOSE : Invalidate phonebook buffered in RAM */ void pb_reset (void) { TRACE_FUNCTION("pb_reset()"); pb_write_eeprom(); fdn_mode = NO_OPERATION; /* some more stuff may be needed */ /* set fdn_classtype to default value */ fdn_classtype = CLASS_VceDatFaxSms; fdn_input_classtype = fdn_classtype; cmhPHB_StatIndication ( PHB_UNKNOWN, CME_ERR_NotPresent, TRUE ); } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_create_memory | +--------------------------------------------------------------------+ PURPOSE : Find the next free entry */ T_PHB_RETURN pb_create_memory(SHORT *index) { int i; /* TRACE_FUNCTION("pb_create_memory()"); */ for (i=0; i<MAX_AFB_RECORDS; i++) { if (phb_element[i].free EQ PHB_ELEMENT_FREE) { memset ((char *)&phb_element[i].entry, 0xff, sizeof (T_AFB_RECORD)); phb_element[i].free = PHB_ELEMENT_USED; *index = i; return PHB_OK; } } return PHB_FULL; } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_create_l_memory | +--------------------------------------------------------------------+ PURPOSE : Find the next free entry */ T_PHB_RETURN pb_create_l_memory(SHORT *index) { SHORT i; /* TRACE_FUNCTION("pb_create_l_memory()"); */ for (i=0; i<MAX_RDM_RECORDS; i++) { if (phb_l_element[i].free EQ PHB_ELEMENT_FREE) { memset ((char *)&phb_l_element[i].entry, 0xff, sizeof (T_RDM_RECORD)); phb_l_element[i].free = PHB_ELEMENT_USED; *index = i; return PHB_OK; } } return PHB_FULL; } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_ecc | +--------------------------------------------------------------------+ PURPOSE : Build emergency call phonebook. */ T_PHB_RETURN pb_read_ecc (USHORT error, UBYTE ecc_len, UBYTE *sim_ecc) { UBYTE *data_ptr; int i; TRACE_FUNCTION ("pb_read_ecc()"); if (fdn_mode != NO_OPERATION) return PHB_OK; /* If SIM card is not active, the emergency call numbers are read from EEPROM */ if ( ( error EQ SIM_CAUSE_OTHER_ERROR ) OR ( error EQ SIM_CAUSE_CARD_REMOVED) OR ( error >= SIM_CAUSE_PARAM_WRONG AND error <= SIM_CAUSE_DRV_TEMPFAIL) ) { pb_read_eeprom_ecc(); } /* SIM card is active, the emergency call numbers are read from SIM card */ else { /* if SIM ECC data is not empty, copy SIM ECC data to phonebook */ if ( strcmp((CHAR*)sim_ecc,"") ) { phb_ctb[ECC].mem = SIM_MEMORY; data_ptr = sim_ecc; phb_ctb[ECC].max_rcd = (SHORT)((ecc_len/3) > MAX_ECC_RCD)? MAX_ECC_RCD: ecc_len/3; phb_ctb[ECC].type = ECC; phb_ctb[ECC].first_trcd = UNUSED_INDEX; /* Read emergency call number */ for (i=0; i<MAX_ECC_RCD; i++) { pb_copy_ecc_entry (data_ptr, (UBYTE)i); data_ptr += 3; } } } return PHB_OK; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_sim | +----------------------------------------------------------------------+ PURPOSE : SIM card informs the numbers of phonebook record. */ BOOL pb_read_sim(USHORT data_id, UBYTE rcd_num, UBYTE len) { SHORT table_id; TRACE_FUNCTION ("pb_read_sim()"); table_id = psaSIM_atbNewEntry(); if(table_id NEQ NO_ENTRY) { simShrdPrm.atb[table_id].ntryUsdFlg = TRUE; simShrdPrm.atb[table_id].accType = ACT_RD_REC; simShrdPrm.atb[table_id].v_path_info = FALSE; simShrdPrm.atb[table_id].reqDataFld = data_id; simShrdPrm.atb[table_id].recNr = rcd_num; if (rcd_num EQ 1) simShrdPrm.atb[table_id].dataLen = NOT_PRESENT_8BIT; else simShrdPrm.atb[table_id].dataLen = len; simShrdPrm.atb[table_id].exchData = data; simShrdPrm.atb[table_id].rplyCB = pb_read_cb; simShrdPrm.aId = table_id; if (pause_pb_reading_while_EXT_reading EQ TRUE) /* Read request must be paused while EXT is read */ { paused_table_id = simShrdPrm.aId; /* save the aId for later SIM Access */ } else { if(psaSIM_AccessSIMData() < 0) { TRACE_EVENT("FATAL ERROR"); return FALSE; } } } else return FALSE; return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_sim_ext | +----------------------------------------------------------------------+ PURPOSE : SIM card informs the numbers of phonebook record. */ #ifdef PHONEBOOK_EXTENSION void pb_read_sim_ext(USHORT data_id, UBYTE rcd_num) { SHORT table_id; TRACE_FUNCTION ("pb_read_sim_ext()"); table_id = psaSIM_atbNewEntry(); if(table_id NEQ NO_ENTRY) { simShrdPrm.atb[table_id].ntryUsdFlg = TRUE; simShrdPrm.atb[table_id].accType = ACT_RD_REC; simShrdPrm.atb[table_id].v_path_info = FALSE; simShrdPrm.atb[table_id].reqDataFld = data_id; simShrdPrm.atb[table_id].recNr = rcd_num; simShrdPrm.atb[table_id].dataLen = 13; simShrdPrm.atb[table_id].exchData = data; simShrdPrm.atb[table_id].rplyCB = pb_read_ext_cb; simShrdPrm.aId = table_id; pause_pb_reading_while_EXT_reading = TRUE; /* Suspend further ADN reading while EXT is read */ if(psaSIM_AccessSIMData() < 0) { TRACE_EVENT("pb_read_sim_ext (): FATAL ERROR"); } } } #endif /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_init_sync_sim | +----------------------------------------------------------------------+ PURPOSE : Sync the local LDN entries to SIM */ BOOL pb_init_sync_sim(UBYTE type) { TRACE_FUNCTION ("pb_init_sync_sim()"); switch (type) { case LDN: break; default: /* Only supported for LDN */ return FALSE; } if (phb_ctb[type].service EQ ALLOCATED_AND_ACTIVATED AND phb_ctb[type].mem != NO_PHB_ENTRY) { if (max_sim_LDN_records) /* start with oldest record */ return (pb_prepare_sync_sim(type, max_sim_LDN_records)); } return FALSE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_prepare_sync_sim | +----------------------------------------------------------------------+ PURPOSE : Sync the local LDN entries to SIM */ BOOL pb_prepare_sync_sim(UBYTE type, UBYTE rcd_num) { T_PHB_RECORD entry; T_PHB_RETURN sim_result; UBYTE tag_len; TRACE_FUNCTION ("pb_prepare_sync_sim()"); switch (type) { case LDN: break; default: return FALSE; } memset(data, 0xFF, sizeof(data)); if (pb_read_phys_record( type, rcd_num, &entry) NEQ PHB_OK) { sim_result = pb_sync_sim(type, rcd_num); /* Write an empty record */ } else { tag_len = MINIMUM ( phb_ctb[type].alpha_len, entry.tag_len ); memcpy(data, entry.tag, tag_len); data[phb_ctb[type].alpha_len] = entry.len+1; /*#if PHONEBOOK_EXTENSION*/ #if 0 if (entry.number[10] NEQ 0xFF) { data[phb_ctb[type].alpha_len] = 11; /* max. length */ } else { data[phb_ctb[type].alpha_len] = entry.len+1; } #else data[phb_ctb[type].alpha_len] = entry.len+1; #endif data[phb_ctb[type].alpha_len+1] = entry.ton_npi; memcpy((char *)&data[phb_ctb[type].alpha_len+2], (char *)entry.number, 10); data[phb_ctb[type].alpha_len+12] = entry.cc_id; /*#ifdef PHONEBOOK_EXTENSION*/ #if 0 if (entry->number[10] NEQ 0xFF) { file_id = pb_get_ext_file_id (type); if (old_ext_rcd_num NEQ 0xFF) { /* use the old extention record */ phb_element[new_index].entry.ext_rcd_num = old_ext_rcd_num; } else { phb_element[new_index].entry.ext_rcd_num = pb_get_ext_record_number (type); } data[phb_ctb[type].alpha_len+13] = phb_element[new_index].entry.ext_rcd_num; } /* only number extention or subaddress could be store */ else if (entry->subaddr[0] NEQ 0xFF) { file_id = pb_get_ext_file_id (type); if (old_ext_rcd_num NEQ 0xFF) { /* use the old extention record */ phb_element[new_index].entry.ext_rcd_num = old_ext_rcd_num; } else { phb_element[new_index].entry.ext_rcd_num = pb_get_ext_record_number (0xFF); } data[phb_ctb[type].alpha_len+13] = phb_element[new_index].entry.ext_rcd_num; } #endif sim_result = pb_sync_sim(type, rcd_num); /* Record is always 1 for cyclic files */ /*#ifdef PHONEBOOK_EXTENSION*/ #if 0 if (sim_result NEQ PHB_FAIL) { if (phb_element[new_index].entry.ext_rcd_num NEQ 0xFF) { pb_prepare_ext_data (phb_element[new_index].entry.number, phb_element[new_index].entry.len, phb_element[new_index].entry.subaddr, 10, file_id); sim_result = pb_write_sim_ext(file_id, phb_element[new_index].entry.ext_rcd_num); } else if (old_ext_rcd_num NEQ 0xFF) { /* delete the old extention record */ pb_rem_ext_record_flag (type, old_ext_rcd_num); pb_prepare_ext_data (NULL, 0, NULL, 0, file_id); sim_result = pb_write_sim_ext(SIM_EXT1, old_ext_rcd_num); } } #endif /* PHONEBOOK_EXTENSION */ } if (sim_result NEQ PHB_FAIL) return (TRUE); return TRUE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_sync_sim | +----------------------------------------------------------------------+ PURPOSE : Sync the local LDN entries to SIM */ BOOL pb_sync_sim (UBYTE type, UBYTE rcd_num) { SHORT table_id; USHORT data_id; TRACE_FUNCTION ("pb_sync_sim()"); switch (type) { case LDN: data_id = SIM_LND; break; default: return FALSE; } table_id = psaSIM_atbNewEntry(); if (table_id EQ NO_ENTRY) { TRACE_ERROR ("pb_sync_sim(): no more table entries"); return (FALSE); } 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 = data_id; simShrdPrm.atb[table_id].recNr = rcd_num; simShrdPrm.atb[table_id].dataLen = phb_ctb[type].alpha_len + 14; simShrdPrm.atb[table_id].exchData = data; simShrdPrm.atb[table_id].rplyCB = pb_sync_sim_cb; simShrdPrm.aId = table_id; if(psaSIM_AccessSIMData() < 0) { return (FALSE); } phb_stat = PHB_BUSY; cmhPHB_StatIndication ( PHB_BUSY, CME_ERR_NotPresent, TRUE ); /* return (PHB_EXCT);*/ return (TRUE); } /* +------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_sync_sim_cb | +------------------------------------------------------------------+ PURPOSE : Call back for sync phonebook in SIM card. */ void pb_sync_sim_cb(SHORT table_id) { UBYTE type; USHORT type_id; UBYTE rcd_num; TRACE_FUNCTION("pb_sync_sim_cb()"); simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; if (simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR) { TRACE_ERROR("pb_sync_sim_cb(): error for writing"); /* return; */ /* dont stop writing here if one record fails since must reach? pb_finish_sync_sim to deactivate the sim */ } /* Inform the data of record */ switch (simShrdPrm.atb[table_id].reqDataFld) { case SIM_LND: /* Up to now only LDN supported */ type = LDN; type_id = SIM_LND; break; default: TRACE_FUNCTION("pb_sync_sim_cb() invalid callback"); return; } rcd_num = simShrdPrm.atb[table_id].recNr; if (--rcd_num) { pb_prepare_sync_sim(type, rcd_num); /* sync next record */ return; } else /* Last record copied to SIM */ { pb_finish_sync_sim(); } return; } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_finish_sync_sim | +---------------------------------------------------------------------+ PURPOSE : Call back for sync phonebook in SIM card. */ void pb_finish_sync_sim() { phb_stat = PHB_READY; cmhPHB_StatIndication ( PHB_READY, CME_ERR_NotPresent, TRUE ); pb_reset(); pb_init(); simShrdPrm.synCs = SYNC_DEACTIVATE; /* This was moved from pb_sync_sim_ldn */ psaSIM_SyncSIM(); return; } /* +-------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_copy_sim_entry| +-------------------------------------------------------------------+ PURPOSE : SIM card informs the numbers of phonebook record. */ void pb_copy_sim_entry(SHORT cur_index) { UBYTE *ptr; UBYTE max_tag_len; #ifdef PHONEBOOK_EXTENSION USHORT file_id; #endif TRACE_FUNCTION ("pb_copy_sim_entry()"); ptr = data; max_tag_len = MINIMUM (phb_ctb[phb_element[cur_index].type].alpha_len, PHB_MAX_TAG_LEN); phb_element[cur_index].entry.tag_len = (UBYTE)pb_get_entry_len(ptr, max_tag_len); memset(phb_element[cur_index].entry.tag, 0xFF, PHB_MAX_TAG_LEN); /* init the tag value */ memcpy ( (char*)phb_element[cur_index].entry.tag, (char*)ptr, phb_element[cur_index].entry.tag_len ); ptr += phb_ctb[phb_element[cur_index].type].alpha_len; phb_element[cur_index].entry.len = *(ptr++) - 1; phb_element[cur_index].entry.ton_npi = *ptr++; /* * This error handling is done to avoid the accidental incorrect * record length stored in the test SIMs */ if (phb_element[cur_index].entry.len > PHB_PACKED_NUM_LEN) { phb_element[cur_index].entry.len = PHB_PACKED_NUM_LEN; } memset(phb_element[cur_index].entry.number, 0xFF, PHB_PACKED_NUM_LEN); memcpy( (char*)phb_element[cur_index].entry.number, (char*)ptr, phb_element[cur_index].entry.len ); ptr += 10; phb_element[cur_index].entry.cc_id = *ptr++; #ifdef PHONEBOOK_EXTENSION if (*ptr != 0xFF) /* check for extention records */ { file_id = pb_get_ext_file_id(phb_element[cur_index].type); if (file_id != 0xFFFF) { phb_element[cur_index].entry.ext_rcd_num = (UBYTE)*ptr; ext_index = cur_index; max_ext_chain_reads=5; /* Limit the number of additional EXT reads per ADN record to avoid a possible endless loop */ pb_read_sim_ext(file_id, phb_element[cur_index].entry.ext_rcd_num); } } else { phb_element[cur_index].entry.ext_rcd_num = 0xFF; } #endif } /* +-------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_copy_sim_entry| +-------------------------------------------------------------------+ PURPOSE : SIM card informs the numbers of phonebook record. */ void pb_copy_sim_ldn_entry(SHORT cur_index) { UBYTE *ptr; UBYTE max_tag_len; #ifdef PHONEBOOK_EXTENSION /* USHORT file_id;*/ #endif TRACE_FUNCTION ("pb_copy_sim_ldn_entry()"); ptr = data; max_tag_len = MINIMUM (phb_ctb[phb_l_element[cur_index].type].alpha_len, PHB_MAX_TAG_LEN); phb_l_element[cur_index].entry.tag_len = (UBYTE)pb_get_entry_len(ptr, max_tag_len); memset(phb_l_element[cur_index].entry.tag, 0xFF, PHB_MAX_TAG_LEN); /* init the tag value */ memcpy ( (char*)phb_l_element[cur_index].entry.tag, (char*)ptr, phb_l_element[cur_index].entry.tag_len ); ptr += phb_ctb[phb_l_element[cur_index].type].alpha_len; phb_l_element[cur_index].entry.len = *(ptr++) - 1; phb_l_element[cur_index].entry.ton_npi = *ptr++; memset(phb_l_element[cur_index].entry.number, 0xFF, PHB_PACKED_NUM_LEN); memcpy( (char*)phb_l_element[cur_index].entry.number, (char*)ptr, 10 ); ptr += 10; phb_l_element[cur_index].entry.cc_id = *ptr++; phb_l_element[cur_index].entry.year = 0xff; /* This is not on SIM */ phb_l_element[cur_index].entry.month = 0xff; phb_l_element[cur_index].entry.day = 0xff; phb_l_element[cur_index].entry.hour = 0xff; phb_l_element[cur_index].entry.minute = 0xff; phb_l_element[cur_index].entry.second = 0xff; /*#ifdef PHONEBOOK_EXTENSION */ #if 0 if (*ptr != 0xFF) /* check for extention records */ { file_id = pb_get_ext_file_id(phb_l_element[cur_index].type); if (file_id != 0xFFFF) { phb_l_element[cur_index].entry.ext_rcd_num = (UBYTE)*ptr; ext_index = cur_index; pb_read_sim_ext(file_id, phb_l_element[cur_index].entry.ext_rcd_num); } } else { phb_l_element[cur_index].entry.ext_rcd_num = 0xFF; } #endif } /* +---------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_sim_record | +---------------------------------------------------------------------+ PURPOSE : Build emergency call phonebook. */ T_PHB_RETURN pb_read_sim_record(UBYTE type, USHORT type_id, UBYTE rcd_num) { SHORT index; UBYTE n,m; /* TRACE_FUNCTION ("pb_read_sim_record()");*/ if (phb_ctb[type].used_rcd >= phb_ctb[type].max_rcd) { TRACE_FUNCTION("Used rcd full!"); return PHB_FULL; } if (type NEQ LDN) { /* search a free element in phonebook element table */ if (pb_create_memory(&index) NEQ PHB_OK) { TRACE_FUNCTION("Memory full"); pb_read_eeprom_req(); return PHB_FULL; } phb_ctb[type].used_rcd++; n = (UBYTE)(rcd_num-1)/8; m = (rcd_num-1)%8; phb_ctb[type].rcd_bitmap[n] |= 0x01 << m; phb_element[index].type = type; phb_element[index].entry.index = rcd_num; pb_copy_sim_entry(index); pb_record_sort(index); pb_alpha_sort(index); pb_num_sort(index); if ((type EQ ADN) OR (type EQ FDN)) { pb_malpha_sort(index); pb_mnum_sort(index); } } else /* special handling for LDN entries from SIM */ { if (pb_create_l_memory(&index) NEQ PHB_OK) { TRACE_FUNCTION("Memory full"); pb_read_eeprom_req(); return PHB_OK; } phb_ctb[type].used_rcd++; phb_l_element[index].type = type; phb_l_element[index].entry.index = rcd_num; pb_copy_sim_ldn_entry(index); pb_l_record_sort(index); /* pb_l_alpha_sort(index);*//* not possible with RDM Structure */ /* pb_l_num_sort(index);*/ } return PHB_OK; } /* +---------------------------------------------------------------------+ | PROJECT: MODULE: PHB | | STATE : code ROUTINE: pb_get_ext_file_id | +---------------------------------------------------------------------+ PURPOSE : Find and gives the extention SIM file ID for the phonebook entry. */ #ifdef PHONEBOOK_EXTENSION LOCAL USHORT pb_get_ext_file_id (UBYTE pb_type) { switch (pb_type) { case 0xFF: case ADN: case LDN: //TISH, EXT1 is also used to save UPN extension number. See 11.11 10.5.10 case UPN: return (SIM_EXT1); case FDN: return (SIM_EXT2); case SDN: return (SIM_EXT3); case BDN: return (SIM_EXT4); default: TRACE_ERROR ("pb_get_free_ext_record(): invalid type"); return (0xFFFF); } } /* +-----------------------------------------------------------------------+ | PROJECT: MODULE: PHB | | STATE : code ROUTINE: pb_rem_ext_record_flag | +-----------------------------------------------------------------------+ PURPOSE : Removes the flag for the extention record. */ LOCAL void pb_rem_ext_record_flag (UBYTE pb_type, UBYTE rcd_num) { UBYTE *rcd_bitmap; UBYTE pos, bit, len; switch (pb_type) { case 0xFF: case ADN: //TISH, EXT1 is also used to save UPN extension number. See 11.11 10.5.10 case UPN: rcd_bitmap = phb_ext_records[EXT1].rcd_bitmap; len = MAX_EXT1_BITMAP; break; case FDN: rcd_bitmap = phb_ext_records[EXT2].rcd_bitmap; len = MAX_EXT2_BITMAP; break; case SDN: rcd_bitmap = phb_ext_records[EXT3].rcd_bitmap; len = MAX_EXT3_BITMAP; break; case BDN: rcd_bitmap = phb_ext_records[EXT4].rcd_bitmap; len = MAX_EXT4_BITMAP; break; default: TRACE_ERROR ("pb_rem_free_ext_record(): invalid type"); return; } pos = (UBYTE)(rcd_num - 1) / 8; bit = (rcd_num - 1) % 8; rcd_bitmap[pos] &= (UBYTE)(~(1u << bit)); } //TISH set extension rcd_bitmap flag LOCAL void pb_set_ext_record_flag (UBYTE pb_type, UBYTE rcd_num) { UBYTE *rcd_bitmap; UBYTE pos, bit, len; switch (pb_type) { case 0xFF: case ADN: case UPN: rcd_bitmap = phb_ext_records[EXT1].rcd_bitmap; len = MAX_EXT1_BITMAP; break; case FDN: rcd_bitmap = phb_ext_records[EXT2].rcd_bitmap; len = MAX_EXT2_BITMAP; break; case BDN: case SDN: default: TRACE_ERROR ("pb_rem_free_ext_record(): invalid type"); return; } pos = (UBYTE)(rcd_num - 1) / 8; bit = (rcd_num - 1) % 8; rcd_bitmap[pos] |= (UBYTE)((1u << bit)); } /* +-------------------------------------------------------------------------+ | PROJECT: MODULE: PHB | | STATE : code ROUTINE: pb_rem_ext_record_number | +-------------------------------------------------------------------------+ PURPOSE : Gives the extention record number for the phonebook entry. */ LOCAL UBYTE pb_get_ext_record_number (UBYTE pb_type) { UBYTE *rcd_bitmap; UBYTE len, pos, bit, rcd_num, max_rcd; switch (pb_type) { case 0xFF: case ADN: //TISH, EXT1 is also used to save UPN extension number. See 11.11 10.5.10 case UPN: rcd_bitmap = phb_ext_records[EXT1].rcd_bitmap; len = MAX_EXT1_BITMAP; max_rcd = phb_ext_records[EXT1].max_rcd; break; case FDN: rcd_bitmap = phb_ext_records[EXT2].rcd_bitmap; len = MAX_EXT2_BITMAP; max_rcd = phb_ext_records[EXT2].max_rcd; break; case SDN: rcd_bitmap = phb_ext_records[EXT3].rcd_bitmap; len = MAX_EXT3_BITMAP; max_rcd = phb_ext_records[EXT3].max_rcd; break; case BDN: rcd_bitmap = phb_ext_records[EXT4].rcd_bitmap; len = MAX_EXT4_BITMAP; max_rcd = phb_ext_records[EXT4].max_rcd; break; default: TRACE_ERROR ("pb_get_free_ext_number(): invalid type"); return (0xFF); } for (pos = 0; pos < len; pos++) { if ((UBYTE)~(rcd_bitmap[pos])) { int flag; for(bit=0;bit<8;bit++) { flag = rcd_bitmap[pos] & (0x01 << bit); rcd_num = (pos * 8) + bit + 1; if(flag)continue; /* Check for maximum extension records supported */ if (rcd_num > max_rcd ) { return (0xFF); } return (rcd_num); } } } TRACE_ERROR ("pb_get_free_ext_record(): no more extention records free"); return (0xFF); } /* +-----------------------------------------------------------------------+ | PROJECT: MODULE: PHB | | STATE : code ROUTINE: pb_read_ext_records | +-----------------------------------------------------------------------+ PURPOSE : Store the extention record flag and read the next record. */ LOCAL void pb_read_ext_records (T_PHB_EXT_TYPE type, USHORT sim_id, SHORT table_id) { UBYTE rcd_num; // UBYTE n, m; rcd_num = simShrdPrm.atb[table_id].recNr; if (rcd_num EQ 1) { phb_ext_records[type].max_rcd = simShrdPrm.atb[table_id].recMax; } /* If this record is not empty EQ> set used flag */ //TISH: the ext record flag will be set at pb_read_ext_cb. /* if (data[0] NEQ 0xFF) { n = (UBYTE)(rcd_num - 1) / 8; m = (rcd_num - 1) % 8; phb_ext_records[type].rcd_bitmap[n] |= (0x01 << m); } */ simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; if (rcd_num < phb_ext_records[type].max_rcd) { pb_read_sim(sim_id, ++rcd_num, simShrdPrm.atb[table_id].dataLen); } else { pb_read_sim_req(); } } /* +-----------------------------------------------------------------------+ | PROJECT: MODULE: PHB | | STATE : code ROUTINE: pb_get_ext_type | +-----------------------------------------------------------------------+ PURPOSE : gives the extention type for the phonebook entry. */ LOCAL UBYTE pb_get_ext_type(UBYTE type) { switch (type) { case 0xFF: case ADN: case LDN: return ((UBYTE)EXT1); case FDN: return ((UBYTE)EXT2); case SDN: return ((UBYTE)EXT3); case BDN: return ((UBYTE)EXT4); default: TRACE_ERROR ("pb_get_free_ext_record(): invalid type"); return (0xFF); } } /* +-----------------------------------------------------------------------+ | PROJECT: MODULE: PHB | | STATE : code ROUTINE: pb_read_ext_records | +-----------------------------------------------------------------------+ PURPOSE : Gives the value of maximum extension records and used extension records */ LOCAL void pb_read_ext_status(UBYTE ext_type, SHORT * max_ext, SHORT * used_ext) { UBYTE rec_num; UBYTE *rcd_bitmap; UBYTE bit, pos; TRACE_FUNCTION ("pb_read_ext_status()"); *max_ext = phb_ext_records[ext_type].max_rcd; rcd_bitmap = phb_ext_records[ext_type].rcd_bitmap; for(rec_num=1; rec_num<= *max_ext; rec_num++) { /* if bit is set to 1 then it is used record else if bit is set to 0 then it is free record */ pos = (UBYTE)(rec_num-1)/8; bit = (rec_num - 1) % 8; if(rcd_bitmap[pos] & (0x01 << bit)) *used_ext +=1; } } #endif /* +---------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_cb | +---------------------------------------------------------------------+ PURPOSE : read sim callback function */ void pb_read_cb(SHORT table_id) { UBYTE type = NOT_PRESENT_8BIT; USHORT type_id; UBYTE rcd_num; /* record number */ TRACE_FUNCTION ("pb_read_cb()"); /* Inform the data of record */ switch (simShrdPrm.atb[table_id].reqDataFld) { #ifdef PHONEBOOK_EXTENSION case SIM_EXT1: pb_read_ext_records (EXT1, SIM_EXT1, table_id); return; case SIM_EXT2: pb_read_ext_records (EXT2, SIM_EXT2, table_id); return; case SIM_EXT3: pb_read_ext_records (EXT3, SIM_EXT3, table_id); return; case SIM_EXT4: pb_read_ext_records (EXT4, SIM_EXT4, table_id); return; #endif case SIM_ADN: type = ADN; type_id = SIM_ADN; break; case SIM_FDN: type = FDN; type_id = SIM_FDN; break; case SIM_LND: /* Support for SIM_LDN */ type = LDN; /* Caution: different identifiers LDN and LND */ type_id = SIM_LND; break; case SIM_SDN: type = SDN; type_id = SIM_SDN; break; case SIM_BDN: type = BDN; type_id = SIM_BDN; break; case SIM_MSISDN: type = UPN; type_id = SIM_MSISDN; break; default: TRACE_ERROR ("Invalid reqDataFld!"); return; } TRACE_EVENT_P1("Callback of SIM reading Phonebook: %d", type); rcd_num = simShrdPrm.atb[table_id].recNr; if (rcd_num EQ 1) { if (type EQ LDN) { /* remember physical count for writing of correct number of LND on CFUN=0 */ max_sim_LDN_records = simShrdPrm.atb[table_id].recMax; } phb_ctb[type].alpha_len = simShrdPrm.atb[table_id].dataLen - 14; phb_ctb[type].max_rcd = simShrdPrm.atb[table_id].recMax; } simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; /* * workaround for invalid phonebook entries (the entire entry is filled with 0x00) * this entries have been received which a very slow SIM * check if the Length of BCD number/SSC contents is 0x00 then discard */ /* If this record is not empty, this record is written in phonebook. */ if((phb_ctb[type].max_rcd NEQ 0) AND ((*data NEQ 0xff) OR (*(data + phb_ctb[type].alpha_len + 2) NEQ 0xff)) AND (*(data + phb_ctb[type].alpha_len) NEQ 0x00)) { if (pb_read_sim_record(type, type_id, rcd_num) EQ PHB_FULL) { #ifdef SIM_TOOLKIT if (simShrdPrm.fuRef >= 0) { psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_SUCC_ADD); } #endif phb_stat = PHB_READY; cmhPHB_StatIndication ( PHB_READY, CME_ERR_NotPresent, TRUE ); return; } } if (rcd_num < phb_ctb[type].max_rcd) { if(simShrdPrm.atb[table_id].reqDataFld != type_id) //TISH: if last field id is not current field id pb_read_sim(type_id, ++rcd_num, NOT_PRESENT_8BIT); else pb_read_sim(type_id, ++rcd_num, simShrdPrm.atb[table_id].dataLen); } else pb_read_sim_req(); } /* +---------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_nibblecopy | +---------------------------------------------------------------------+ PURPOSE : appends a packed BCD number to an existing entry. */ #ifdef PHONEBOOK_EXTENSION int pb_nibblecopy (UBYTE dest[], int destlen, UBYTE src[], int count) { int i; int nibble; int destnibble=destlen*2; if (destnibble) { if ((dest[destlen-1] & 0xF0) EQ 0xF0) /* check if there is space in last nibble */ destnibble--; } for ( i=0; i<count*2; i++ ) { /* check if we access out of bounds */ if (destnibble/2 >= PHB_PACKED_NUM_LEN) return PHB_PACKED_NUM_LEN; /* get nibble */ if (i%2 EQ 0) nibble = src[i/2] & 0x0F; else nibble = (src[i/2] & 0xF0) >> 4; if (nibble EQ 0xF) /* end of number detected */ break; /* put nibble */ if (destnibble%2 EQ 0) { dest[destnibble/2] &= 0xF0; dest[destnibble/2] |= nibble; } else { dest[destnibble/2] &= 0x0F; dest[destnibble/2] |= nibble << 4; } destnibble++; } return destnibble/2 + destnibble%2; /* round up */ } #endif /* +---------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_ext_cb | +---------------------------------------------------------------------+ PURPOSE : read sim callback function */ #ifdef PHONEBOOK_EXTENSION void pb_read_ext_cb(SHORT table_id) { USHORT type_id; /* UBYTE buf[11];*/ UBYTE data_len; UBYTE data_type; TRACE_FUNCTION ("pb_read_ext_cb()"); simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; if (simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR) { TRACE_EVENT_P1 ("SIM returned error 0x%04X", simShrdPrm.atb[table_id].errCode); } else { type_id = simShrdPrm.atb[table_id].reqDataFld; /* If this extension record is not empty, it is written in phonebook. */ data_type = data[0]; data_len = data[1]; //TISH set extension rcd_bitmap flag pb_set_ext_record_flag(phb_element[ext_index].type, simShrdPrm.atb[table_id].recNr); switch (data_type) { case 1: /* Called Party Subaddress */ { int sa_len = 0; while (sa_len<PHB_PACKED_NUM_LEN) /* get length of possible already stored subaddr if more than one EXT is used */ { if (phb_element[ext_index].entry.subaddr[sa_len] EQ 0xFF) break; else if ((phb_element[ext_index].entry.subaddr[sa_len] & 0xF0) EQ 0xF0) { sa_len++; break; } else sa_len++; } pb_nibblecopy (phb_element[ext_index].entry.subaddr, sa_len, data + 2, data_len); } break; case 2: /* Additional data */ phb_element[ext_index].entry.len = pb_nibblecopy (phb_element[ext_index].entry.number, phb_element[ext_index].entry.len, data + 2, data_len); break; default: /* unknown type */ break; } if (data[12] != 0xFF) /* check if a further EXT entry exists */ { if (max_ext_chain_reads) /* limit reached? */ { max_ext_chain_reads--; pb_read_sim_ext(type_id, data[12]); return; } } } /* Continue reading the last by EXT interrupted phonebook */ pause_pb_reading_while_EXT_reading = FALSE; if (paused_table_id) { simShrdPrm.aId = paused_table_id; paused_table_id = 0; if(psaSIM_AccessSIMData() < 0) { TRACE_EVENT("FATAL ERROR"); return; } } } #endif /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_eeprom_req | +--------------------------------------------------------------------+ PURPOSE : Request to build phonebook. */ T_PHB_RETURN pb_read_eeprom_req(void) { UBYTE version; UBYTE i, n, m; SHORT index; USHORT max_rcd; EF_UPN *efupn; TRACE_FUNCTION ("pb_read_eeprom_req()"); phb_ctb[ADN_FDN].mem = SIM_MEMORY; phb_ctb[ADN_FDN].type = ADN_FDN; if (phb_ctb[ADN].alpha_len) phb_ctb[ADN_FDN].alpha_len = phb_ctb[ADN].alpha_len; else phb_ctb[ADN_FDN].alpha_len = phb_ctb[FDN].alpha_len; phb_ctb[ADN_FDN].max_rcd = phb_ctb[ADN].max_rcd + phb_ctb[FDN].max_rcd; phb_ctb[ADN_FDN].used_rcd = phb_ctb[ADN].used_rcd + phb_ctb[FDN].used_rcd; if (read_flag) { phb_stat = PHB_READY; cmhPHB_StatIndication ( PHB_READY, CME_ERR_NotPresent, TRUE ); return PHB_OK; } /* Read Last Dialing Numbers */ if (phb_ctb[LDN].mem EQ NO_PHB_ENTRY) /* No phonebook loaded from SIM? */ { phb_ctb[LDN].mem = TE_MEMORY; phb_ctb[LDN].type = LDN; phb_ctb[LDN].max_rcd = MAX_RDM_RECORDS/3; phb_ctb[LDN].used_rcd = 0; phb_ctb[LDN].first_rcd = UNUSED_INDEX; phb_ctb[LDN].first_trcd = UNUSED_INDEX; phb_ctb[LDN].first_nrcd = UNUSED_INDEX; phb_ctb[LDN].first_mtrcd = UNUSED_INDEX; phb_ctb[LDN].first_mnrcd = UNUSED_INDEX; } else { /* either: */ /* phb_ctb[LDN].max_rcd = MAX_RDM_RECORDS/3;*//* adjust in case SIM_max_record was smaller than PCM_max_rcd */ /* or: */ ; /* use max_rcd as read from SIM. */ } if (imsiFlag EQ FALSE ) /* SIM has changed? */ { memset (data, 0xFF, SIZE_EF_LDN); i=0; while (i < NR_EF_LDN) { if (pcm_WriteRecord((UBYTE *)EF_LDN_ID, /* Wipe entire LDN-PCM */ (USHORT)(i+1), SIZE_EF_LDN, data) NEQ DRV_OK) break; i++; } } else { /* Merge timestamp with existing SIM-entries */ BOOL all_records_match = TRUE; SHORT records_from_sim = phb_ctb[LDN].used_rcd; /* =0 in case of no records from SIM read */ EF_LDN *p = (EF_LDN *)data; index = phb_ctb[LDN].first_rcd; for (i=0; i<(UBYTE)phb_ctb[LDN].max_rcd; i++) { if ((i+1) > NR_EF_LDN) break; /* end of phonebook */ if (pcm_ReadRecord((UBYTE *)EF_LDN_ID, (USHORT)(i+1), SIZE_EF_LDN, (UBYTE *)&data[0], &version, &max_rcd) NEQ DRV_OK) break; /* read error */ else { if (p->len NEQ 0 AND p->len NEQ 0xFF) { if ((i+1) <= records_from_sim) { if (index EQ UNUSED_INDEX) { all_records_match = FALSE; break; } if ( !memcmp((char *)phb_l_element[index].entry.number, (char *)&p->dldNum, 10) AND phb_l_element[index].entry.ton_npi EQ p->numTp AND phb_l_element[index].entry.len EQ p->len AND phb_l_element[index].entry.cc_id EQ p->ccp) /* Number matches? */ { pb_copy_ldn_record(index, 0); /* then update the record with Timestamps and cc_id from PCM */ } else { all_records_match = FALSE; /* one (or more) record failed */ break; /* stop processing of further records */ } index = phb_l_element[index].next_rcd; } else /* PCM has more entries than on SIM */ { /* search a free element in phonebook element table */ if (pb_create_l_memory(&index) NEQ PHB_OK) return PHB_FULL; phb_ctb[LDN].used_rcd++; phb_l_element[index].type = LDN; phb_l_element[index].entry.index = i+1; pb_copy_ldn_record((SHORT)index, 0); pb_l_record_sort(index); } } } } if (all_records_match NEQ TRUE) /* some elements did not match */ { index = phb_ctb[LDN].first_rcd; for (i=0; i<phb_ctb[LDN].used_rcd; i++) { if (index EQ UNUSED_INDEX) { break; } phb_l_element[index].entry.year = phb_l_element[index].entry.month = phb_l_element[index].entry.day = phb_l_element[index].entry.hour = phb_l_element[index].entry.minute = phb_l_element[index].entry.second = 0xFF; /* remove previous merged data from PCM */ index = phb_l_element[index].next_rcd; } } } /* Read Last received Numbers from EEPROM */ phb_ctb[LRN].mem = TE_MEMORY; phb_ctb[LRN].type = LRN; phb_ctb[LRN].max_rcd = MAX_RDM_RECORDS/3; phb_ctb[LRN].used_rcd = 0; phb_ctb[LRN].first_rcd = UNUSED_INDEX; phb_ctb[LRN].first_trcd = UNUSED_INDEX; phb_ctb[LRN].first_nrcd = UNUSED_INDEX; phb_ctb[LRN].first_mtrcd = UNUSED_INDEX; phb_ctb[LRN].first_mnrcd = UNUSED_INDEX; if (imsiFlag EQ FALSE ) { memset (data, 0xFF, SIZE_EF_LRN); i=0; while (i < NR_EF_LRN) { if (pcm_WriteRecord((UBYTE *)EF_LRN_ID, /* Wipe entire LRN-PCM */ (USHORT)(i+1), SIZE_EF_LRN, data) NEQ DRV_OK) break; i++; } } else { EF_LRN *p = (EF_LRN *)data; for (i=0; i<(UBYTE)phb_ctb[LRN].max_rcd; i++) { if ((i+1) > NR_EF_LRN) break; if (pcm_ReadRecord((UBYTE *)EF_LRN_ID, (USHORT)(i+1), SIZE_EF_LRN, (UBYTE *)&data[0], &version, &max_rcd) NEQ DRV_OK) break; else { if (p->len NEQ 0 AND p->len NEQ 0xFF) { /* search a free element in phonebook element table */ if (pb_create_l_memory(&index) NEQ PHB_OK) return PHB_FULL; phb_ctb[LRN].used_rcd++; phb_l_element[index].type = LRN; phb_l_element[index].entry.index = i+1; pb_copy_lrn_record(index, 0); pb_l_record_sort(index); } } } } /* Read Last missed Numbers from EEPROM */ phb_ctb[LMN].mem = TE_MEMORY; phb_ctb[LMN].type = LMN; phb_ctb[LMN].max_rcd = MAX_RDM_RECORDS/3; phb_ctb[LMN].used_rcd = 0; phb_ctb[LMN].first_rcd = UNUSED_INDEX; phb_ctb[LMN].first_trcd = UNUSED_INDEX; phb_ctb[LMN].first_nrcd = UNUSED_INDEX; phb_ctb[LMN].first_mtrcd = UNUSED_INDEX; phb_ctb[LMN].first_mnrcd = UNUSED_INDEX; if (imsiFlag EQ FALSE ) { memset (data, 0xFF, SIZE_EF_LMN); i=0; while (i < NR_EF_LMN) { if (pcm_WriteRecord((UBYTE *)EF_LMN_ID, /* Wipe entire LMN-PCM */ (USHORT)(i+1), SIZE_EF_LMN, data) NEQ DRV_OK) break; i++; } } else { EF_LMN *p = (EF_LMN *)data; for (i=0; i<(UBYTE)phb_ctb[LMN].max_rcd; i++) { if ((i+1) > NR_EF_LMN) break; if (pcm_ReadRecord((UBYTE *)EF_LMN_ID, (USHORT)(i+1), SIZE_EF_LMN, (UBYTE *)&data[0], &version, &max_rcd) NEQ DRV_OK) break; else { if (p->len NEQ 0 AND p->len NEQ 0xFF) { /* search a free element in phonebook element table */ if (pb_create_l_memory(&index) NEQ PHB_OK) return PHB_FULL; phb_ctb[LMN].used_rcd++; phb_l_element[index].type = LMN; phb_l_element[index].entry.index = i+1; pb_copy_lmn_record(index, 0); pb_l_record_sort(index); } } } } if (phb_ctb[UPN].mem EQ NO_PHB_ENTRY) { phb_ctb[UPN].mem = TE_MEMORY; phb_ctb[UPN].type = UPN; phb_ctb[UPN].max_rcd = NR_EF_UPN; phb_ctb[UPN].used_rcd = 0; phb_ctb[UPN].first_rcd = UNUSED_INDEX; phb_ctb[UPN].first_trcd = UNUSED_INDEX; phb_ctb[UPN].first_nrcd = UNUSED_INDEX; phb_ctb[UPN].first_mtrcd = UNUSED_INDEX; phb_ctb[UPN].first_mnrcd = UNUSED_INDEX; for (i=0; i<NR_EF_UPN; i++) { if (pcm_ReadRecord((UBYTE *)EF_UPN_ID, (USHORT)(i+1), SIZE_EF_UPN, (UBYTE *)&data[0], &version, &max_rcd) NEQ DRV_OK) { phb_ctb[UPN].mem = NO_PHB_ENTRY; phb_ctb[UPN].max_rcd = 0; } else { efupn = (EF_UPN *)&data[0]; if (efupn->usrNum[0] NEQ 0xff) { /* search a free element in phonebook element table */ if (pb_create_memory(&index) NEQ PHB_OK) return PHB_FULL; phb_ctb[UPN].used_rcd++; n = (UBYTE)i/8; m = i%8; phb_ctb[UPN].rcd_bitmap[n] |= 0x01 << m; phb_element[index].type = UPN; phb_element[index].entry.index = i+1; /* copy record */ memset(phb_element[index].entry.tag, 0xFF, sizeof(phb_element[index].entry.tag)); memset(phb_element[index].entry.number, 0xFF, sizeof(phb_element[index].entry.number)); memcpy(phb_element[index].entry.tag, efupn->alphId, 10*sizeof(UBYTE)); phb_element[index].entry.tag_len = pb_get_entry_len(efupn->alphId, 10); phb_element[index].entry.len = efupn->len; phb_element[index].entry.ton_npi = efupn->numTp; memcpy(phb_element[index].entry.number, efupn->usrNum, 10*sizeof(UBYTE)); phb_element[index].entry.cc_id = efupn->ccp; pb_record_sort(index); pb_alpha_sort(index); pb_num_sort(index); } } } } phb_stat = PHB_READY; cmhPHB_StatIndication ( PHB_READY, CME_ERR_NotPresent, TRUE ); read_flag = 1; return PHB_OK; } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_sim_req | +--------------------------------------------------------------------+ PURPOSE : Request to build phonebook. */ void pb_read_sim_req(void) { UBYTE serv_stat; TRACE_FUNCTION("pb_read_sim_req()"); /* Read Fixed Dialing Numbers from SIM card */ if ((serv_stat = pb_ssc(SRV_FDN,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED AND phb_ctb[FDN].mem EQ NO_PHB_ENTRY) { phb_ctb[FDN].mem = SIM_MEMORY; phb_ctb[FDN].type = FDN; phb_ctb[FDN].service = serv_stat; pb_read_sim(SIM_FDN, 1, NOT_PRESENT_8BIT); return; } if (read_flag) { pb_read_eeprom_req(); return; } /* Read MSISDN from SIM card */ if ((serv_stat = pb_ssc(SRV_MSISDN,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED AND phb_ctb[UPN].mem EQ NO_PHB_ENTRY) { phb_ctb[UPN].mem = SIM_MEMORY; phb_ctb[UPN].type = UPN; phb_ctb[UPN].service = serv_stat; pb_read_sim(SIM_MSISDN, 1, NOT_PRESENT_8BIT); return; } /* Read Barred Dialing Numbers from SIM card */ if ((serv_stat = pb_ssc(SRV_BDN,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED AND phb_ctb[BDN].mem EQ NO_PHB_ENTRY) { phb_ctb[BDN].mem = SIM_MEMORY; phb_ctb[BDN].type = BDN; phb_ctb[BDN].service = serv_stat; pb_read_sim(SIM_BDN, 1, NOT_PRESENT_8BIT); return; } /* Read Service Dialing Numbers from SIM card */ if ((serv_stat = pb_ssc(SRV_SDN,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED AND phb_ctb[SDN].mem EQ NO_PHB_ENTRY) { phb_ctb[SDN].mem = SIM_MEMORY; phb_ctb[SDN].type = SDN; phb_ctb[SDN].service = serv_stat; pb_read_sim(SIM_SDN, 1, NOT_PRESENT_8BIT); return; } /* Read Last Numbers Dialed from SIM card */ if ((serv_stat = pb_ssc(SRV_LDN,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED AND phb_ctb[LDN].mem EQ NO_PHB_ENTRY) { phb_ctb[LDN].mem = TE_MEMORY; phb_ctb[LDN].type = LDN; phb_ctb[LDN].service = serv_stat; phb_ctb[LDN].max_rcd = MAX_RDM_RECORDS/3; phb_ctb[LDN].used_rcd = 0; phb_ctb[LDN].first_rcd = UNUSED_INDEX; phb_ctb[LDN].first_trcd = UNUSED_INDEX; phb_ctb[LDN].first_nrcd = UNUSED_INDEX; phb_ctb[LDN].first_mtrcd = UNUSED_INDEX; phb_ctb[LDN].first_mnrcd = UNUSED_INDEX; pb_read_sim(SIM_LND, 1, NOT_PRESENT_8BIT); return; } #ifdef PHONEBOOK_EXTENSION /* Read Ext1 Records from SIM card */ if ((serv_stat = pb_ssc(SRV_EXT1,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED AND phb_ext_records[EXT1].mem EQ NO_PHB_ENTRY) { TRACE_EVENT ("Start reading EXT1"); phb_ext_records[EXT1].mem = SIM_MEMORY; pb_read_sim(SIM_EXT1, 1, NOT_PRESENT_8BIT); return; } /* Read Ext2 Records from SIM card */ if ((serv_stat = pb_ssc(SRV_EXT2,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED AND phb_ext_records[EXT2].mem EQ NO_PHB_ENTRY) { TRACE_EVENT ("Start reading EXT2"); phb_ext_records[EXT2].mem = SIM_MEMORY; pb_read_sim(SIM_EXT2, 1, NOT_PRESENT_8BIT); return; } /* Read Ext3 Records from SIM card */ if ((serv_stat = pb_ssc(SRV_EXT3,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED AND phb_ext_records[EXT3].mem EQ NO_PHB_ENTRY) { TRACE_EVENT ("Start reading EXT3"); phb_ext_records[EXT3].mem = SIM_MEMORY; pb_read_sim(SIM_EXT3, 1, NOT_PRESENT_8BIT); return; } /* Read Ext4 Records from SIM card */ if ((serv_stat = pb_ssc(SRV_EXT4,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED AND phb_ext_records[EXT4].mem EQ NO_PHB_ENTRY) { TRACE_EVENT ("Start reading EXT4"); phb_ext_records[EXT4].mem = SIM_MEMORY; pb_read_sim(SIM_EXT4, 1, NOT_PRESENT_8BIT); return; } #endif /* Read phonebook from EEPROM */ pb_read_eeprom_req(); #ifdef SIM_TOOLKIT if (simShrdPrm.fuRef >= 0) { psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_SUCC_ADD); } #endif } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_build_req | +--------------------------------------------------------------------+ PURPOSE : Request to build phonebook. */ void pb_build_req(T_SIM_MMI_INSERT_IND *sim_mmi_insert_ind) { UBYTE simIMSI[MAX_IMSI_LEN+1]; UBYTE pcmIMSI[MAX_IMSI_LEN+1]; EF_IMSI imsi; UBYTE version; #ifndef _SIMULATION_ UBYTE classFDN = (UBYTE) CLASS_None; T_FFS_RET ret_ffs; /* FFS handle */ #endif TRACE_FUNCTION ("pb_build_req()"); if (fdn_mode EQ NO_OPERATION) { /* Read SIM service table from SIM card */ memcpy(sim_service_table, sim_mmi_insert_ind -> sim_serv, MAX_SRV_TBL); /* Compare IMSI field between SIM and PCM */ imsiFlag = FALSE; psaSIM_decodeIMSI (sim_mmi_insert_ind->imsi_field.field, sim_mmi_insert_ind->imsi_field.c_field, (char *)simIMSI); if (pcm_ReadFile((UBYTE *) EF_IMSI_ID,SIZE_EF_IMSI, (UBYTE *) &imsi, &version) EQ PCM_OK) { psaSIM_decodeIMSI (imsi.IMSI, imsi.len, (char *)pcmIMSI); if (!strcmp((char *)simIMSI, (char *)pcmIMSI)) imsiFlag = TRUE; else { /* write the IMSI in PCM */ imsi.len = sim_mmi_insert_ind->imsi_field.c_field; memcpy(imsi.IMSI, sim_mmi_insert_ind->imsi_field.field, MAX_IMSI-1); pcm_WriteFile((UBYTE *) EF_IMSI_ID,SIZE_EF_IMSI, (UBYTE *) &imsi); } } switch (sim_mmi_insert_ind -> func) { case SIM_ADN_ENABLED: case SIM_ADN_BDN_ENABLED: fdn_mode = FDN_DISABLE; break; case SIM_FDN_ENABLED: case SIM_FDN_BDN_ENABLED: fdn_mode = FDN_ENABLE; #ifndef _SIMULATION_ /* read last fdn_classtype from FFS */ ret_ffs = ffs_fread("/mmi/fdnClassType", &classFDN, sizeof(classFDN)); if(!(ret_ffs < 1)) /* successful read */ { /* only these two classes are currently supported */ if ( classFDN EQ (UBYTE) CLASS_VceDatFax OR classFDN EQ (UBYTE) CLASS_VceDatFaxSms ) { fdn_classtype = classFDN; fdn_input_classtype = fdn_classtype; } } #endif break; default: fdn_mode = NO_OPERATION; break; } } } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_start_build | +--------------------------------------------------------------------+ PURPOSE : Start reading the phonebook. */ T_PHB_RETURN pb_start_build (BOOL unchanged) { UBYTE serv_stat; TRACE_FUNCTION ("pb_start_build()"); read_flag = 0; phb_stat = PHB_BUSY; cmhPHB_StatIndication ( PHB_BUSY, CME_ERR_NotPresent, TRUE ); /* Read Abbreviated Dialing Numbers */ if ((serv_stat = pb_ssc(SRV_ADN,sim_service_table)) EQ ALLOCATED_AND_ACTIVATED) { if (fdn_mode EQ FDN_ENABLE) { pb_read_sim_req(); return PHB_OK; } if ( phb_ctb[ADN].mem EQ NO_PHB_ENTRY ) { phb_ctb[ADN].mem = SIM_MEMORY; phb_ctb[ADN].type = ADN; phb_ctb[ADN].service = serv_stat; pb_read_sim(SIM_ADN, 1, NOT_PRESENT_8BIT); } else pb_read_sim_req(); } else { pb_read_sim_req(); } return PHB_OK; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_update | +--------------------------------------------------------------------+ PURPOSE : Phonebook update on File Change Notification. */ #ifdef SIM_TOOLKIT BOOL pb_update (int ref, T_SIM_FILE_UPDATE_IND *fu) { BOOL found = FALSE; int i; TRACE_FUNCTION ("pb_update ()"); for (i = 0; i < (int)fu->val_nr; i++) { if ( (fu->file_info[i].v_path_info EQ TRUE AND fu->file_info[i].path_info.df_level1 EQ SIM_DF_TELECOM AND fu->file_info[i].path_info.v_df_level2 EQ FALSE AND (fu->file_info[i].datafield EQ SIM_ADN OR /* the extension datafields */ fu->file_info[i].datafield EQ SIM_FDN OR /* have to be added, when */ fu->file_info[i].datafield EQ SIM_BDN OR /* they are really used */ fu->file_info[i].datafield EQ SIM_SDN OR fu->file_info[i].datafield EQ SIM_MSISDN OR fu->file_info[i].datafield EQ SIM_LND)) OR /* CQ16301: Added support for LND refresh */ (fu->file_info[i].v_path_info EQ TRUE AND fu->file_info[i].path_info.df_level1 EQ SIM_DF_GSM AND fu->file_info[i].path_info.v_df_level2 EQ FALSE AND fu->file_info[i].datafield EQ SIM_SST) ) { found = TRUE; /* when SIM service table is changed, the all SIM-phonebooks will be updated. */ if (fu->file_info[i].datafield EQ SIM_SST) { sstUpdateId = TRUE; break; } pb_sat_update_reset(fu->file_info[i].datafield); } } if (found) { simShrdPrm.fuRef = ref; if (sstUpdateId) { sstUpdateId = FALSE; /* Update SIM service table */ if (pb_read_sim_dat(SIM_SST, NOT_PRESENT_8BIT, (UBYTE)256) EQ FALSE ) pb_start_build (FALSE); } else pb_start_build (FALSE); return FALSE; } else { simShrdPrm.fuRef = -1; /* no update needed */ return TRUE; } } #endif /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_ssc | +--------------------------------------------------------------------+ PURPOSE : Check SIM service status. */ UBYTE pb_ssc (UBYTE nr, UBYTE * serv_table) { TRACE_FUNCTION ("pb_ssc()"); if (nr > MAX_SRV_TBL*4) { TRACE_ERROR ("serv_table overflow in pb_ssc()"); return NO_ALLOCATED; } /* SDN and BDN are not used */ /* if ((nr EQ 18) || (nr EQ31)) */ /* return(NO_ALLOCATED);*/ return ( *(serv_table+(nr-1)/4) >> (((nr-1)&3)*2) & 0x03); } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_record_sort | +---------------------------------------------------------------------+ PURPOSE : */ void pb_record_sort(SHORT cur_index) { SHORT ref_index; SHORT ptr_index; UBYTE flag; /* TRACE_FUNCTION ("pb_record_sort()"); */ if (phb_ctb[phb_element[cur_index].type].used_rcd EQ 1) { phb_element[cur_index].prev_rcd = UNUSED_INDEX; phb_element[cur_index].next_rcd = UNUSED_INDEX; phb_ctb[phb_element[cur_index].type].first_rcd = cur_index; } else { flag = 0; ref_index = phb_ctb[phb_element[cur_index].type].first_rcd; phb_ctb[phb_element[cur_index].type].first_rcd = cur_index; phb_element[cur_index].prev_rcd = UNUSED_INDEX; phb_element[cur_index].next_rcd = ref_index; phb_element[ref_index].prev_rcd = cur_index; while (ref_index NEQ UNUSED_INDEX) { if (phb_element[cur_index].entry.index > phb_element[ref_index].entry.index) { ptr_index = phb_element[ref_index].next_rcd; if (ptr_index != UNUSED_INDEX) phb_element[ptr_index].prev_rcd = cur_index; phb_element[cur_index].next_rcd = ptr_index; ptr_index = phb_element[cur_index].prev_rcd; if (ptr_index != UNUSED_INDEX) phb_element[ptr_index].next_rcd = ref_index; phb_element[ref_index].prev_rcd = phb_element[cur_index].prev_rcd; phb_element[ref_index].next_rcd = cur_index; phb_element[cur_index].prev_rcd = ref_index; /* set the first record in control block */ if(!flag) { phb_ctb[phb_element[cur_index].type].first_rcd = ref_index; flag = 1; } ref_index = phb_element[cur_index].next_rcd; } else ref_index = phb_element[ref_index].next_rcd; } } } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_l_record_sort | +---------------------------------------------------------------------+ PURPOSE : */ void pb_l_record_sort(SHORT cur_index) { SHORT ref_index; SHORT ptr_index; UBYTE flag; TRACE_FUNCTION ("pb_l_record_sort()"); if (phb_ctb[phb_l_element[cur_index].type].used_rcd EQ 1) { phb_l_element[cur_index].prev_rcd = UNUSED_BYTE_INDEX; phb_l_element[cur_index].next_rcd = UNUSED_BYTE_INDEX; phb_ctb[phb_l_element[cur_index].type].first_rcd = cur_index; } else { flag = 0; ref_index = phb_ctb[phb_l_element[cur_index].type].first_rcd; phb_ctb[phb_l_element[cur_index].type].first_rcd = cur_index; phb_l_element[cur_index].prev_rcd = UNUSED_BYTE_INDEX; phb_l_element[cur_index].next_rcd = (UBYTE)ref_index; phb_l_element[ref_index].prev_rcd = (UBYTE)cur_index; while ((UBYTE)ref_index NEQ UNUSED_BYTE_INDEX) { if (phb_l_element[cur_index].entry.index > phb_l_element[ref_index].entry.index) { ptr_index = (SHORT)phb_l_element[ref_index].next_rcd; if ((UBYTE)ptr_index != UNUSED_BYTE_INDEX) phb_l_element[ptr_index].prev_rcd = (UBYTE)cur_index; phb_l_element[cur_index].next_rcd = (UBYTE)ptr_index; ptr_index = (SHORT)phb_l_element[cur_index].prev_rcd; if ((UBYTE)ptr_index != UNUSED_BYTE_INDEX) phb_l_element[ptr_index].next_rcd = (UBYTE)ref_index; phb_l_element[ref_index].prev_rcd = phb_l_element[cur_index].prev_rcd; phb_l_element[ref_index].next_rcd = (UBYTE)cur_index; phb_l_element[cur_index].prev_rcd = (UBYTE)ref_index; /* set the first record in control block */ if(!flag) { phb_ctb[phb_l_element[cur_index].type].first_rcd = ref_index; flag = 1; } ref_index = (SHORT)phb_l_element[cur_index].next_rcd; } else ref_index = (SHORT)phb_l_element[ref_index].next_rcd; } } } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_cvt_alpha_for_cmp | +---------------------------------------------------------------------+ PURPOSE : convert alpha to lower case when not unicode */ static void pb_cvt_alpha_for_cmp ( UBYTE *src, UBYTE *dst, UBYTE len ) { int i; if ( *src NEQ 0x80 ) { for ( i = 0; i < len; i++ ) dst[i] = (UBYTE)tolower((int)src[i]); return; } for ( i = 0; i < len; i++ ) dst[i] = src[i]; } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_alpha_sort | +---------------------------------------------------------------------+ PURPOSE : Insert a new record to alpha sorted chain. */ void pb_alpha_sort(SHORT cur_index) { SHORT ref_index; SHORT ptr_index; UBYTE flag, cmpLen = 0; UBYTE cur_tag[PHB_MAX_TAG_LEN], check_tag[PHB_MAX_TAG_LEN]; int cmp_res; /* set the new record as first element */ if (phb_ctb[phb_element[cur_index].type].used_rcd EQ 1) { phb_element[cur_index].prev_trcd = UNUSED_INDEX; phb_element[cur_index].next_trcd = UNUSED_INDEX; phb_ctb[phb_element[cur_index].type].first_trcd = cur_index; } if (phb_ctb[phb_element[cur_index].type].used_rcd > 1) { ref_index = phb_ctb[phb_element[cur_index].type].first_trcd; phb_ctb[phb_element[cur_index].type].first_trcd = cur_index; phb_element[cur_index].prev_trcd = UNUSED_INDEX; phb_element[cur_index].next_trcd = ref_index; phb_element[ref_index].prev_trcd = cur_index; /* insert the new record in the alpha order */ flag = 0; while (ref_index NEQ UNUSED_INDEX) { memset(cur_tag, 0, sizeof ( cur_tag ) ); memset(check_tag, 0, sizeof ( check_tag ) ); /* this should not cause problems, because in both alphabets (GSM and ASCII) the most important chars are at the same positions (A-Z: 65-90 a-z:97-122) */ if( ext_compare_fct != NULL ) { cmp_res = ext_compare_fct ( phb_element[cur_index].entry.tag, phb_element[cur_index].entry.tag_len, phb_element[ref_index].entry.tag, phb_element[ref_index].entry.tag_len ); } else { pb_cvt_alpha_for_cmp ( phb_element[cur_index].entry.tag, cur_tag, phb_element[cur_index].entry.tag_len ); pb_cvt_alpha_for_cmp ( phb_element[ref_index].entry.tag, check_tag, phb_element[ref_index].entry.tag_len ); cmpLen = MINIMUM ( phb_element[cur_index].entry.tag_len, phb_element[ref_index].entry.tag_len ); cmp_res = cmpString ( cur_tag, check_tag, cmpLen ); } if (cmp_res EQ 0) /* MINIMUM character match, so check if one string is longer */ { /* ABC should come after AB */ if (phb_element[cur_index].entry.tag_len NEQ phb_element[ref_index].entry.tag_len) { if ((phb_element[cur_index].entry.tag_len - phb_element[ref_index].entry.tag_len) > 0) cmp_res = cmpLen + 1; else cmp_res = -cmpLen - 1; } } if(cmp_res > 0) { ptr_index = phb_element[ref_index].next_trcd; if (ptr_index != UNUSED_INDEX) { phb_element[ptr_index].prev_trcd = cur_index; } phb_element[cur_index].next_trcd = ptr_index; ptr_index = phb_element[cur_index].prev_trcd; if (ptr_index != UNUSED_INDEX) { phb_element[ptr_index].next_trcd = ref_index; } phb_element[ref_index].prev_trcd = phb_element[cur_index].prev_trcd; phb_element[ref_index].next_trcd = cur_index; phb_element[cur_index].prev_trcd = ref_index; /* set the first record in control block */ if(!flag) { phb_ctb[phb_element[cur_index].type].first_trcd = ref_index; flag = 1; } ref_index = phb_element[cur_index].next_trcd; } else { ref_index = phb_element[ref_index].next_trcd; } } } } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_num_sort | +---------------------------------------------------------------------+ PURPOSE : */ void pb_num_sort(SHORT cur_index) { SHORT ref_index; SHORT ptr_index; UBYTE flag; CHAR cur_number[MAX_PHB_NUM_LEN]; CHAR ref_number[MAX_PHB_NUM_LEN]; /* TRACE_FUNCTION ("pb_num_sort()");*/ /* set the new record as first element */ if (phb_ctb[phb_element[cur_index].type].used_rcd EQ 1) { phb_element[cur_index].prev_nrcd = UNUSED_INDEX; phb_element[cur_index].next_nrcd = UNUSED_INDEX; phb_ctb[phb_element[cur_index].type].first_nrcd = cur_index; } if (phb_ctb[phb_element[cur_index].type].used_rcd > 1) { ref_index = phb_ctb[phb_element[cur_index].type].first_nrcd; phb_ctb[phb_element[cur_index].type].first_nrcd = cur_index; phb_element[cur_index].prev_nrcd = UNUSED_INDEX; phb_element[cur_index].next_nrcd = ref_index; phb_element[ref_index].prev_nrcd = cur_index; /* insert the new record in the number order */ flag = 0; while (ref_index NEQ UNUSED_INDEX) { /* convert the number in BCD to string */ cmhPHB_getAdrStr(cur_number, MAX_PHB_NUM_LEN - 1, phb_element[cur_index].entry.number, phb_element[cur_index].entry.len); cmhPHB_getAdrStr(ref_number, MAX_PHB_NUM_LEN - 1, phb_element[ref_index].entry.number, phb_element[ref_index].entry.len); if (strcmp((char *)cur_number, (char *)ref_number) > 0) { ptr_index = phb_element[ref_index].next_nrcd; if (ptr_index != UNUSED_INDEX) phb_element[ptr_index].prev_nrcd = cur_index; phb_element[cur_index].next_nrcd = ptr_index; ptr_index = phb_element[cur_index].prev_nrcd; if (ptr_index != UNUSED_INDEX) phb_element[ptr_index].next_nrcd = ref_index; phb_element[ref_index].prev_nrcd = phb_element[cur_index].prev_nrcd; phb_element[ref_index].next_nrcd = cur_index; phb_element[cur_index].prev_nrcd = ref_index; /* set the first logic number record in control block */ if(!flag) { phb_ctb[phb_element[cur_index].type].first_nrcd = ref_index; flag = 1; } ref_index = phb_element[cur_index].next_nrcd; } else { ref_index = phb_element[ref_index].next_nrcd; } } } } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_malpha_sort | +---------------------------------------------------------------------+ PURPOSE : Insert a new record to alpha sorted chain. */ void pb_malpha_sort(SHORT cur_index) { SHORT ref_index; SHORT ptr_index; UBYTE flag, cmpLen = 0; UBYTE cur_tag[PHB_MAX_TAG_LEN], check_tag[PHB_MAX_TAG_LEN]; int cmp_res; if (((phb_ctb[ADN].used_rcd EQ 1) AND (phb_ctb[FDN].used_rcd EQ 0)) OR ((phb_ctb[ADN].used_rcd EQ 0) AND (phb_ctb[FDN].used_rcd EQ 1))) { phb_element[cur_index].prev_mtrcd = UNUSED_INDEX; phb_element[cur_index].next_mtrcd = UNUSED_INDEX; phb_ctb[phb_element[cur_index].type].first_mtrcd = cur_index; return; } else { if (phb_ctb[ADN].used_rcd NEQ 0) { /* Test whether ADN's first_mtrcd index is already in use or not. If not and FDN entries exist, take FDN's first_mtrcd. */ if ((phb_ctb[ADN].first_mtrcd EQ UNUSED_INDEX) AND (phb_ctb[FDN].used_rcd NEQ 0)) ref_index = phb_ctb[FDN].first_mtrcd; else ref_index = phb_ctb[ADN].first_mtrcd; phb_ctb[ADN].first_mtrcd = cur_index; } else { ref_index = phb_ctb[FDN].first_mtrcd; phb_ctb[FDN].first_mtrcd = cur_index; } } phb_element[cur_index].prev_mtrcd = UNUSED_INDEX; phb_element[cur_index].next_mtrcd = ref_index; phb_element[ref_index].prev_mtrcd = cur_index; /* insert the new record in the alpha order */ flag = 0; while (ref_index NEQ UNUSED_INDEX) { memset(cur_tag, 0, sizeof ( cur_tag ) ); memset(check_tag, 0, sizeof ( check_tag ) ); /* this should not cause problems, because in both alphabets (GSM and ASCII) the most important chars are at the same positions (A-Z: 65-90 a-z:97-122) */ if( ext_compare_fct != NULL ) { cmp_res = ext_compare_fct ( phb_element[cur_index].entry.tag, phb_element[cur_index].entry.tag_len, phb_element[ref_index].entry.tag, phb_element[ref_index].entry.tag_len ); } else { pb_cvt_alpha_for_cmp ( phb_element[cur_index].entry.tag, cur_tag, phb_element[cur_index].entry.tag_len ); pb_cvt_alpha_for_cmp ( phb_element[ref_index].entry.tag, check_tag, phb_element[ref_index].entry.tag_len ); cmpLen = MINIMUM ( phb_element[cur_index].entry.tag_len, phb_element[ref_index].entry.tag_len ); cmp_res = cmpString ( cur_tag, check_tag, cmpLen ); } if (cmp_res EQ 0) /* MINIMUM character match, so check if one string is longer */ { /* ABC should come after AB */ if (phb_element[cur_index].entry.tag_len NEQ phb_element[ref_index].entry.tag_len) { if ((phb_element[cur_index].entry.tag_len - phb_element[ref_index].entry.tag_len) > 0) cmp_res = cmpLen + 1; else cmp_res = -cmpLen - 1; } } if (cmp_res > 0) { ptr_index = phb_element[ref_index].next_mtrcd; if (ptr_index != UNUSED_INDEX) phb_element[ptr_index].prev_mtrcd = cur_index; phb_element[cur_index].next_mtrcd = ptr_index; ptr_index = phb_element[cur_index].prev_mtrcd; if (ptr_index != UNUSED_INDEX) phb_element[ptr_index].next_mtrcd = ref_index; phb_element[ref_index].prev_mtrcd = phb_element[cur_index].prev_mtrcd; phb_element[ref_index].next_mtrcd = cur_index; phb_element[cur_index].prev_mtrcd = ref_index; /* set the first record in control block */ if(!flag) { if (phb_ctb[ADN].used_rcd != 0) phb_ctb[ADN].first_mtrcd = ref_index; else phb_ctb[FDN].first_mtrcd = ref_index; flag = 1; } ref_index = phb_element[cur_index].next_mtrcd; } else ref_index = phb_element[ref_index].next_mtrcd; } } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_mnum_sort | +---------------------------------------------------------------------+ PURPOSE : */ void pb_mnum_sort(SHORT cur_index) { SHORT ref_index; SHORT ptr_index; UBYTE flag; CHAR cur_number[MAX_PHB_NUM_LEN]; CHAR ref_number[MAX_PHB_NUM_LEN]; /* TRACE_FUNCTION ("pb_num_sort()");*/ if (((phb_ctb[ADN].used_rcd EQ 1) AND (phb_ctb[FDN].used_rcd EQ 0)) OR ((phb_ctb[ADN].used_rcd EQ 0) AND (phb_ctb[FDN].used_rcd EQ 1))) { phb_element[cur_index].prev_mnrcd = UNUSED_INDEX; phb_element[cur_index].next_mnrcd = UNUSED_INDEX; phb_ctb[phb_element[cur_index].type].first_mnrcd = cur_index; return; } else { if (phb_ctb[ADN].used_rcd != 0) { /* Test whether ADN's first_mtrcd index is already in use or not. If not and FDN entries exist, take FDN's first_mtrcd. */ if ((phb_ctb[ADN].first_mnrcd EQ UNUSED_INDEX) AND (phb_ctb[FDN].used_rcd NEQ 0)) ref_index = phb_ctb[FDN].first_mnrcd; else ref_index = phb_ctb[ADN].first_mnrcd; phb_ctb[ADN].first_mnrcd = cur_index; } else { ref_index = phb_ctb[FDN].first_mnrcd; phb_ctb[FDN].first_mnrcd = cur_index; } } phb_element[cur_index].prev_mnrcd = UNUSED_INDEX; phb_element[cur_index].next_mnrcd = ref_index; phb_element[ref_index].prev_mnrcd = cur_index; /* insert the new record in the number order */ flag = 0; while (ref_index NEQ UNUSED_INDEX) { /* convert the number in BCD to string */ cmhPHB_getAdrStr(cur_number, MAX_PHB_NUM_LEN - 1, phb_element[cur_index].entry.number, phb_element[cur_index].entry.len); cmhPHB_getAdrStr(ref_number, MAX_PHB_NUM_LEN - 1, phb_element[ref_index].entry.number, phb_element[ref_index].entry.len); if (strcmp((char *)cur_number, (char *)ref_number) > 0) { ptr_index = phb_element[ref_index].next_mnrcd; if (ptr_index != UNUSED_INDEX) phb_element[ptr_index].prev_mnrcd = cur_index; phb_element[cur_index].next_mnrcd = ptr_index; ptr_index = phb_element[cur_index].prev_mnrcd; if (ptr_index != UNUSED_INDEX) phb_element[ptr_index].next_mnrcd = ref_index; phb_element[ref_index].prev_mnrcd = phb_element[cur_index].prev_mnrcd; phb_element[ref_index].next_mnrcd = cur_index; phb_element[cur_index].prev_mnrcd = ref_index; /* set the first logic number record in control block */ if(!flag) { if (phb_ctb[ADN].used_rcd != 0) phb_ctb[ADN].first_mnrcd = ref_index; else phb_ctb[FDN].first_mnrcd = ref_index; flag = 1; } ref_index = phb_element[cur_index].next_mnrcd; } else ref_index = phb_element[ref_index].next_mnrcd; } } /* +---------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_add_record | +---------------------------------------------------------------------+ PURPOSE : */ T_PHB_RETURN pb_add_record(UBYTE type, UBYTE index, T_PHB_RECORD *entry) { UBYTE bit = 0; UBYTE tag_len; SHORT new_index; SHORT cur_index; SHORT first_id; SHORT result; T_PHB_RECORD found_entry; UBYTE n,m; UBYTE number[MAX_PHB_NUM_LEN]; T_PHB_RETURN sim_result; UBYTE old_ext_rcd_num = 0xFF; int entrylen; #ifdef PHONEBOOK_EXTENSION USHORT file_id = 0; #endif TRACE_FUNCTION ("pb_add_record()"); /* check whether this phonebook exists */ if (phb_ctb[type].mem EQ NO_PHB_ENTRY) return PHB_FAIL; if (type EQ ECC OR type EQ ADN OR type EQ FDN OR type EQ BDN OR type EQ UPN) { /* Phonebook is full. */ if (phb_ctb[type].used_rcd >= phb_ctb[type].max_rcd AND !index) { return PHB_FULL; } //TI-SH-TEST-PATCH for CSR OMAPS00168884 tag_len = entry->tag_len;//pb_get_entry_len( entry->tag, PHB_MAX_TAG_LEN ); /* tag_len = MINIMUM ( tag_len, phb_ctb[type].alpha_len); */ /* Don't truncate a tag if it does not fit onto SIM but raise an error */ if (tag_len > phb_ctb[type].alpha_len) { return PHB_TAG_EXCEEDED; } /* Search the free record number for this record */ if (!index) { T_PHB_RETURN ret; SHORT first_free; switch (type) { case ADN: case FDN: case BDN: case UPN: /* * Use the function pb_first_free() to determine * the index of the first free record. */ ret=pb_first_free(type,&first_free); /* * Get out if there was a problem, or the phonebook * is full. */ if (ret NEQ PHB_OK) return(ret); bit=(UBYTE)(first_free-1); break; default: bit=0; } } /* Delete the information in the record, in order to overwrite */ if (index) { bit = index - 1; pb_delete_record(type, index, &old_ext_rcd_num, FALSE); } /* search a free element in phonebook element table */ if (pb_create_memory(&new_index) NEQ PHB_OK) return PHB_FULL; phb_element[new_index].type = type; #ifdef PHONEBOOK_EXTENSION phb_element[new_index].entry.ext_rcd_num = 0xFF; #endif phb_ctb[type].used_rcd++; if (type EQ ADN OR type EQ FDN) phb_ctb[ADN_FDN].used_rcd++; n = (UBYTE)bit/8; m = bit%8; phb_ctb[type].rcd_bitmap[n] |= 0x01 << m; phb_element[new_index].entry.index = bit + 1; /* Copy entry */ phb_element[new_index].entry.tag_len = tag_len; phb_element[new_index].entry.len = entry->len; phb_element[new_index].entry.ton_npi = entry->ton_npi; memset(phb_element[new_index].entry.tag, 0xFF, PHB_MAX_TAG_LEN); memcpy((char *)phb_element[new_index].entry.tag, (char *)entry->tag, tag_len); memcpy((char *)phb_element[new_index].entry.number, (char *)entry->number, PHB_PACKED_NUM_LEN); /* allow number (10 bytes) + a extension (11 bytes) */ #ifdef PHONEBOOK_EXTENSION memcpy((char *)phb_element[new_index].entry.subaddr, (char *)entry->subaddr, PHB_PACKED_NUM_LEN); #endif phb_element[new_index].entry.cc_id = entry->cc_id; pb_record_sort(new_index); pb_alpha_sort(new_index); pb_num_sort(new_index); if ((type EQ ADN) OR (type EQ FDN)) { pb_malpha_sort(new_index); pb_mnum_sort(new_index); } if (phb_ctb[type].mem EQ SIM_MEMORY) { /* write this record in SIM card */ memset(data, 0xFF, sizeof(data)); memcpy(data, entry->tag, tag_len); #if PHONEBOOK_EXTENSION if (entry->number[10] != 0xFF) { data[phb_ctb[type].alpha_len] = 11; /* max. length */ } else { data[phb_ctb[type].alpha_len] = entry->len+1; } #else data[phb_ctb[type].alpha_len] = entry->len+1; #endif data[phb_ctb[type].alpha_len+1] = entry->ton_npi; memcpy((char *)&data[phb_ctb[type].alpha_len+2], (char *)entry->number, 10); data[phb_ctb[type].alpha_len+12] = entry->cc_id; #ifdef PHONEBOOK_EXTENSION if (entry->number[10] != 0xFF) { file_id = pb_get_ext_file_id (type); if (old_ext_rcd_num NEQ 0xFF) { /* use the old extention record */ phb_element[new_index].entry.ext_rcd_num = old_ext_rcd_num; } else { phb_element[new_index].entry.ext_rcd_num = pb_get_ext_record_number (type); } /* Not able to find free record in extension file */ if(phb_element[new_index].entry.ext_rcd_num EQ 0xff) { /* Free the used record for normal phonebook * since unable to find free record for extension data */ pb_free_used_record(type, new_index, bit); return PHB_EXT_FULL; } data[phb_ctb[type].alpha_len+13] = phb_element[new_index].entry.ext_rcd_num; } /* only number extention or subaddress could be store */ else if (entry->subaddr[0] NEQ 0xFF) { file_id = pb_get_ext_file_id (type); if (old_ext_rcd_num NEQ 0xFF) { /* use the old extention record */ phb_element[new_index].entry.ext_rcd_num = old_ext_rcd_num; } else { phb_element[new_index].entry.ext_rcd_num = pb_get_ext_record_number (0xFF); } /* Not able to find free record in extension file */ if(phb_element[new_index].entry.ext_rcd_num EQ 0xff) { /* Free the used record for normal phonebook * since unable to find free record for extension data */ pb_free_used_record(type, new_index, bit); return PHB_EXT_FULL; } data[phb_ctb[type].alpha_len+13] = phb_element[new_index].entry.ext_rcd_num; } #endif sim_result = pb_write_sim(type, phb_element[new_index].entry.index); #ifdef PHONEBOOK_EXTENSION if (sim_result NEQ PHB_FAIL) { if (phb_element[new_index].entry.ext_rcd_num != 0xFF) { pb_prepare_ext_data (phb_element[new_index].entry.number, phb_element[new_index].entry.len, phb_element[new_index].entry.subaddr, 10, file_id); sim_result = pb_write_sim_ext(file_id, phb_element[new_index].entry.ext_rcd_num); //TISH set ext record flag if(sim_result NEQ PHB_FAIL) pb_set_ext_record_flag(type, phb_element[new_index].entry.ext_rcd_num); } else if (old_ext_rcd_num NEQ 0xFF) { /* delete the old extention record */ pb_rem_ext_record_flag (type, old_ext_rcd_num); pb_prepare_ext_data (NULL, 0, NULL, 0, file_id); sim_result = pb_write_sim_ext(SIM_EXT1, old_ext_rcd_num); } } #endif /* PHONEBOOK_EXTENSION */ return(sim_result); } return PHB_OK; } else if ((type EQ LDN) OR (type EQ LRN) OR (type EQ LMN)) { cmhPHB_getAdrStr((char *)number, MAX_PHB_NUM_LEN - 1, entry->number, entry->len); if (pb_search_number(type, number, PHB_NEW_SEARCH, &first_id, &result, &found_entry) EQ PHB_OK) { if (result) pb_delete_record(type, (UBYTE)found_entry.index, &old_ext_rcd_num, FALSE); } if (phb_ctb[type].used_rcd >= phb_ctb[type].max_rcd) { if ((cur_index = phb_ctb[type].first_rcd) EQ UNUSED_INDEX) return PHB_FAIL; while (phb_l_element[cur_index].next_rcd NEQ UNUSED_BYTE_INDEX) cur_index = phb_l_element[cur_index].next_rcd; if (phb_l_element[cur_index].prev_rcd != UNUSED_BYTE_INDEX) phb_l_element[phb_l_element[cur_index].prev_rcd].next_rcd = UNUSED_BYTE_INDEX; } else { if (pb_create_l_memory(&new_index) NEQ PHB_OK) return PHB_FAIL; phb_ctb[type].used_rcd++; cur_index = new_index; } phb_l_element[cur_index].type = type; /* copy record */ /* if ((type EQ LDN) OR (type EQ LRN)) */ /* copy call duration - not jet done */ /* if ((type EQ LRN) OR (type EQ LMN)) */ /* copy call identifier - not jet done */ memcpy((char *)phb_l_element[cur_index].entry.tag, (char *)entry->tag, PHB_MAX_TAG_LEN); phb_l_element[cur_index].entry.tag_len = entry->tag_len; phb_l_element[cur_index].entry.year = entry->year; phb_l_element[cur_index].entry.month = entry->month; phb_l_element[cur_index].entry.day = entry->day; phb_l_element[cur_index].entry.hour = entry->hour; phb_l_element[cur_index].entry.minute = entry->minute; phb_l_element[cur_index].entry.second = entry->second; phb_l_element[cur_index].entry.len = entry->len; phb_l_element[cur_index].entry.ton_npi = entry->ton_npi; phb_l_element[cur_index].entry.line = entry->line; memcpy((char *)phb_l_element[cur_index].entry.number, (char *)entry->number, PHB_PACKED_NUM_LEN); phb_l_element[cur_index].entry.cc_id = entry->cc_id; phb_l_element[cur_index].prev_rcd = UNUSED_BYTE_INDEX; if (phb_ctb[type].first_rcd EQ cur_index) { phb_l_element[cur_index].next_rcd = UNUSED_BYTE_INDEX; } else { phb_l_element[cur_index].next_rcd = (UBYTE)phb_ctb[type].first_rcd; } /* If it is -1, gardening ! This is possible for the 1rst time a entry is added ??? */ if (phb_ctb[type].first_rcd != UNUSED_BYTE_INDEX) { phb_l_element[phb_ctb[type].first_rcd].prev_rcd = (UBYTE)cur_index; } phb_ctb[type].first_rcd = cur_index; new_index = 1; while (cur_index NEQ UNUSED_BYTE_INDEX) { phb_l_element[cur_index].entry.index = (UBYTE)new_index; new_index++; cur_index = phb_l_element[cur_index].next_rcd; } if ( type EQ LDN ) { /* ACI-SPR-16301: Write LND entry to 1 record of SIM, to keep it up to date Actually, the SIM entries will be overwritten by the LND data in RAM during switch off of the ME. This mechanism here is just to ensure the we retrieve more current data in the case of a SAT REFRESH or unexpected RESET. */ /* prepare entry */ entrylen = pb_get_entry_len( entry->tag, PHB_MAX_TAG_LEN ); tag_len = MINIMUM ( phb_ctb[type].alpha_len, entrylen) ; memset(data, 0xFF, sizeof(data)); memcpy(data, entry->tag, tag_len); data[phb_ctb[type].alpha_len] = entry->len+1; data[phb_ctb[type].alpha_len+1] = entry->ton_npi; memcpy((char *)&data[phb_ctb[type].alpha_len+2], (char *)entry->number, 10); data[phb_ctb[type].alpha_len+12] = entry->cc_id; /* always update the first entry */ sim_result = pb_write_sim(type, 1); return sim_result; } else { return PHB_OK; } } else /* unknown type */ return PHB_FAIL; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_delete_record | +------------------------------------------------------------------------+ PURPOSE : Delete a record from phonebook. */ T_PHB_RETURN pb_delete_record(UBYTE type, UBYTE index, UBYTE *ext_rcd_num, BOOL permanent) { SHORT cur_index; UBYTE cur_byte_index, new_byte_index; UBYTE m,n; T_PHB_RETURN sim_result; TRACE_FUNCTION ("pb_delete_record()"); /* check whether this phonebook exists */ if (phb_ctb[type].mem EQ NO_PHB_ENTRY) return PHB_FAIL; if ((type EQ LDN) OR (type EQ LRN) OR (type EQ LMN)) { cur_byte_index = (UBYTE)phb_ctb[type].first_rcd; while (cur_byte_index != UNUSED_BYTE_INDEX) { if (phb_l_element[cur_byte_index].entry.index EQ index) { phb_l_element[cur_byte_index].free = PHB_ELEMENT_FREE; pb_l_rcd_chain(type, (SHORT)phb_l_element[cur_byte_index].prev_rcd, (SHORT)cur_byte_index, (SHORT)phb_l_element[cur_byte_index].next_rcd); phb_ctb[type].used_rcd--; /* * Delete Record in PCM, else the * record is back after restart */ if (phb_ctb[type].mem EQ TE_MEMORY) { UBYTE data[SIZE_EF_LDN]; memset (data, 0xFF, SIZE_EF_LDN); switch (type) { case LDN: TRACE_EVENT ("Delete LDN entry"); pcm_WriteRecord((UBYTE *)EF_LDN_ID, (USHORT)(cur_byte_index+1), SIZE_EF_LDN, data); break; case LRN: TRACE_EVENT ("Delete LRN entry"); pcm_WriteRecord((UBYTE *)EF_LRN_ID, (USHORT)(cur_byte_index+1), SIZE_EF_LRN, data); break; case LMN: TRACE_EVENT ("Delete LMN entry"); pcm_WriteRecord((UBYTE *)EF_LMN_ID, (USHORT)(cur_byte_index+1), SIZE_EF_LMN, data); break; } } cur_byte_index = (UBYTE)phb_ctb[type].first_rcd; new_byte_index = 1; while (cur_byte_index != UNUSED_BYTE_INDEX) { phb_l_element[cur_byte_index].entry.index = new_byte_index; new_byte_index++; cur_byte_index = phb_l_element[cur_byte_index].next_rcd; } return PHB_OK; } cur_byte_index = phb_l_element[cur_byte_index].next_rcd; } } else /* SIM related phonebooks */ { cur_index = phb_ctb[type].first_rcd; while (cur_index NEQ UNUSED_INDEX) { if (phb_element[cur_index].entry.index EQ index) { phb_element[cur_index].free = PHB_ELEMENT_FREE; pb_rcd_chain(type, phb_element[cur_index].prev_rcd, cur_index, phb_element[cur_index].next_rcd); pb_name_chain(type, phb_element[cur_index].prev_trcd, cur_index, phb_element[cur_index].next_trcd); pb_num_chain(type, phb_element[cur_index].prev_nrcd, cur_index, phb_element[cur_index].next_nrcd); if ((type EQ ADN) OR (type EQ FDN)) { pb_mname_chain(type, phb_element[cur_index].prev_mtrcd, cur_index, phb_element[cur_index].next_mtrcd); pb_mnum_chain(type, phb_element[cur_index].prev_mnrcd, cur_index, phb_element[cur_index].next_mnrcd); phb_ctb[ADN_FDN].used_rcd--; } phb_ctb[type].used_rcd--; n = (UBYTE)(phb_element[cur_index].entry.index - 1)/8; m = (UBYTE)(phb_element[cur_index].entry.index - 1)%8; phb_ctb[type].rcd_bitmap[n] ^= 0x01 << m; if (phb_ctb[type].mem EQ SIM_MEMORY) { #ifdef PHONEBOOK_EXTENSION /* store the extention record */ *ext_rcd_num = phb_element[cur_index].entry.ext_rcd_num; #endif /* write this record in SIM card */ memset(data, 0xFF, sizeof(data)); if (permanent) { sim_result = pb_write_sim(type, index); #ifdef PHONEBOOK_EXTENSION if ((sim_result NEQ PHB_FAIL) AND (*ext_rcd_num NEQ 0xFF)) { pb_rem_ext_record_flag (type, *ext_rcd_num); pb_prepare_ext_data (NULL, 0, NULL, 0, pb_get_ext_file_id(type)); sim_result = pb_write_sim_ext (pb_get_ext_file_id(type), *ext_rcd_num); } #endif return (sim_result); } } return PHB_OK; } cur_index = phb_element[cur_index].next_rcd; } } return PHB_FAIL; } void copy_phb_element ( T_PHB_RECORD *entry, T_PHB_AFB_ELEMENT phb_element ) { memset (entry, 0xff, sizeof(T_PHB_RECORD)); entry->book = phb_element.type; entry->index = phb_element.entry.index; entry->tag_len = phb_element.entry.tag_len; memcpy((char *)entry->tag, (char *)phb_element.entry.tag, PHB_MAX_TAG_LEN); entry->len = phb_element.entry.len; entry->ton_npi = phb_element.entry.ton_npi; memcpy((char *)entry->number, (char *)phb_element.entry.number, PHB_PACKED_NUM_LEN); #ifdef PHONEBOOK_EXTENSION memcpy((char *)entry->subaddr, (char *)phb_element.entry.subaddr, PHB_PACKED_NUM_LEN); #endif entry->cc_id = phb_element.entry.cc_id; } void copy_phb_l_element ( T_PHB_RECORD *entry, T_PHB_RDM_ELEMENT phb_l_element ) { memset (entry, 0xff, sizeof(T_PHB_RECORD)); entry->book = phb_l_element.type; entry->index = phb_l_element.entry.index; entry->tag_len = phb_l_element.entry.tag_len; memcpy((char *)entry->tag, (char *)phb_l_element.entry.tag, PHB_MAX_TAG_LEN); entry->len = phb_l_element.entry.len; entry->ton_npi = phb_l_element.entry.ton_npi; memcpy((char *)entry->number, (char *)phb_l_element.entry.number, PHB_PACKED_NUM_LEN); #ifdef PHONEBOOK_EXTENSION memcpy((char *)entry->subaddr, (char *)phb_l_element.entry.subaddr, PHB_PACKED_NUM_LEN); #endif entry->cc_id = phb_l_element.entry.cc_id; entry->line = phb_l_element.entry.line; entry->year = phb_l_element.entry.year; entry->month = phb_l_element.entry.month; entry->day = phb_l_element.entry.day; entry->hour = phb_l_element.entry.hour; entry->minute = phb_l_element.entry.minute; entry->second = phb_l_element.entry.second; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_read_phys_record | +------------------------------------------------------------------------+ PURPOSE : Read one record according to physical index from phonebook. */ T_PHB_RETURN pb_read_phys_record(UBYTE type, SHORT index, T_PHB_RECORD *entry) { SHORT cur_index; SHORT i; /* TRACE_FUNCTION ("pb_read_phys_record()");*/ /* check whether this phonebook exists */ if (phb_ctb[type].mem EQ NO_PHB_ENTRY) return PHB_FAIL; if (index > phb_ctb[type].max_rcd) return PHB_INVALID_IDX; cur_index = phb_ctb[type].first_rcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; if (type EQ ECC OR type EQ ADN OR type EQ FDN OR type EQ BDN OR type EQ UPN OR type EQ SDN ) { for (i=0; i<phb_ctb[type].used_rcd; i++) { if (phb_element[cur_index].entry.index EQ index) { copy_phb_element (entry, phb_element[cur_index]); return PHB_OK; } cur_index = phb_element[cur_index].next_rcd; if (cur_index EQ UNUSED_INDEX) break; } } else if (type EQ LDN OR type EQ LRN OR type EQ LMN) { for (i=0; i<phb_ctb[type].used_rcd; i++) { if (phb_l_element[cur_index].entry.index EQ index) { copy_phb_l_element (entry, phb_l_element[cur_index]); return PHB_OK; } cur_index = phb_l_element[cur_index].next_rcd; if (cur_index EQ UNUSED_INDEX) break; } } return PHB_FAIL; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_read_index_record | +------------------------------------------------------------------------+ PURPOSE : Read one record according to index from phonebook. */ T_PHB_RETURN pb_read_index_record(UBYTE type, SHORT index, T_PHB_RECORD *entry) { SHORT cur_index; SHORT i; /* TRACE_FUNCTION ("pb_read_index_record()");*/ if (phb_ctb[type].mem EQ NO_PHB_ENTRY) return PHB_FAIL; if (index > phb_ctb[type].max_rcd) return PHB_INVALID_IDX; cur_index = phb_ctb[type].first_rcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; if (type EQ ECC OR type EQ ADN OR type EQ FDN OR type EQ BDN OR type EQ UPN OR type EQ SDN) { for (i=1; i<index; i++) { cur_index = phb_element[cur_index].next_rcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; } copy_phb_element (entry, phb_element[cur_index]); return PHB_OK; } else if (type EQ LDN OR type EQ LRN OR type EQ LMN) { for (i=1; i<index; i++) { cur_index = phb_l_element[cur_index].next_rcd; if (cur_index EQ UNUSED_BYTE_INDEX) return PHB_FAIL; } copy_phb_l_element (entry, phb_l_element[cur_index]); return PHB_OK; } return PHB_FAIL; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_read_alpha_record | +------------------------------------------------------------------------+ PURPOSE : Read one record according to alpha index from phonebook. */ T_PHB_RETURN pb_read_alpha_record(UBYTE type, SHORT index, T_PHB_RECORD *entry) { SHORT cur_index; SHORT i; /* TRACE_FUNCTION ("pb_read_alpha_record()");*/ if (type EQ ADN_FDN) { /* check whether this phonebook exists */ if ((phb_ctb[ADN].mem EQ NO_PHB_ENTRY) AND (phb_ctb[FDN].mem EQ NO_PHB_ENTRY)) return PHB_FAIL; cur_index = phb_ctb[ADN].first_mtrcd; if (cur_index EQ UNUSED_INDEX) cur_index = phb_ctb[FDN].first_mtrcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; for (i=1; i<index; i++) { cur_index = phb_element[cur_index].next_mtrcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; } copy_phb_element (entry, phb_element[cur_index]); return PHB_OK; } else if (type EQ ECC OR type EQ ADN OR type EQ FDN OR type EQ BDN OR type EQ SDN OR type EQ UPN) { /* check whether this phonebook exists */ if (phb_ctb[type].mem EQ NO_PHB_ENTRY) return PHB_FAIL; cur_index = phb_ctb[type].first_trcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; for (i=1; i<index; i++) { cur_index = phb_element[cur_index].next_trcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; } copy_phb_element (entry, phb_element[cur_index]); return PHB_OK; } else /* LDN, LRN, LMN */ return PHB_FAIL; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_read_number_record | +------------------------------------------------------------------------+ PURPOSE : Read one record according to number index from phonebook. */ T_PHB_RETURN pb_read_number_record(UBYTE type, SHORT index, T_PHB_RECORD *entry) { SHORT cur_index; SHORT i; /* TRACE_FUNCTION ("pb_read_number_record()");*/ if (type EQ ADN_FDN) { /* check whether this phonebook exists */ if ((phb_ctb[ADN].mem EQ NO_PHB_ENTRY) AND (phb_ctb[FDN].mem EQ NO_PHB_ENTRY)) return PHB_FAIL; cur_index = phb_ctb[ADN].first_mnrcd; if (cur_index EQ UNUSED_INDEX) cur_index = phb_ctb[FDN].first_mnrcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; for (i=1; i<index; i++) { cur_index = phb_element[cur_index].next_mnrcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; } copy_phb_element (entry, phb_element[cur_index]); return PHB_OK; } else if (type EQ ECC OR type EQ ADN OR type EQ FDN OR type EQ BDN OR type EQ SDN OR type EQ UPN) { /* check whether this phonebook exists */ if (phb_ctb[type].mem EQ NO_PHB_ENTRY) return PHB_FAIL; cur_index = phb_ctb[type].first_nrcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; for (i=1; i<index; i++) { cur_index = phb_element[cur_index].next_nrcd; if (cur_index EQ UNUSED_INDEX) return PHB_FAIL; } copy_phb_element (entry, phb_element[cur_index]); return PHB_OK; } else /* LDN, LRN, LMN */ return PHB_FAIL; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_search_name | +------------------------------------------------------------------------+ PURPOSE : Search the string from phonebook */ T_PHB_RETURN pb_search_name(T_ACI_CMD_SRC srcID, UBYTE type, T_ACI_PB_TEXT *search_tag, UBYTE mode, SHORT *first_ind, SHORT *result, T_PHB_RECORD *entry) { static SHORT ptr_index = UNUSED_INDEX; SHORT cur_index; SHORT index; int cmp_res; int cmp_len; int max_cmp_len; /* TRACE_FUNCTION ("pb_search_name()");*/ if (type EQ ADN_FDN) { /* check whether this phonebook exists */ if ((phb_ctb[ADN].mem EQ NO_PHB_ENTRY) AND (phb_ctb[FDN].mem EQ NO_PHB_ENTRY)) return PHB_FAIL; if ((phb_ctb[ADN].first_mtrcd EQ UNUSED_INDEX) AND (phb_ctb[FDN].first_mtrcd EQ UNUSED_INDEX)) return PHB_FAIL; } else { /* check whether this phonebook exists */ if (phb_ctb[type].mem EQ NO_PHB_ENTRY) return PHB_FAIL; } /* search string */ if ( mode EQ PHB_NEW_SEARCH ) { TRACE_EVENT("pb_search_name() DEB: mode EQ PHB_NEW_SEARCH"); ptr_index = UNUSED_INDEX; max_cmp_len = 0; index = 1; *result = 0; if (type EQ ADN_FDN) { if (phb_ctb[ADN].first_mtrcd != UNUSED_INDEX) cur_index = phb_ctb[ADN].first_mtrcd; else cur_index = phb_ctb[FDN].first_mtrcd; } else cur_index = phb_ctb[type].first_trcd; while (cur_index != UNUSED_INDEX) { /* this should not cause problems, because in both alphabets (GSM and ASCII) the most important chars are at the same positions (A-Z: 65-90 // a-z:97-122) */ if (ext_compare_fct != NULL) { cmp_res = ext_compare_fct (phb_element[cur_index].entry.tag, phb_element[cur_index].entry.tag_len, search_tag->data, search_tag->len); } else { cmp_res = pb_cmp_phb_entry ( phb_element[cur_index].entry.tag, phb_element[cur_index].entry.tag_len, search_tag ); } #if defined(MFW) OR defined (FF_MMI_RIV) if (srcID EQ CMD_SRC_LCL) { /* if search string is before entry in alphabet */ if (search_tag->len EQ 1 AND (cmp_res >= 0) AND (phb_element[cur_index].entry.tag[0] NEQ '\0')) { cmp_res = 0; } } else #endif { if (cmp_res EQ 0) /* If Searchstring matches the first letters of Phonebook */ { if (search_tag->len <= phb_element[cur_index].entry.tag_len) ; /* MATCH */ else cmp_res = search_tag->len + 1; } } if (cmp_res EQ 0) { cmp_len = MINIMUM(phb_element[cur_index].entry.tag_len, search_tag->len); if ( cmp_len > max_cmp_len ) { max_cmp_len = cmp_len; if ( ptr_index EQ UNUSED_INDEX ) { /* save the index of the first found record */ TRACE_EVENT("pb_search_name() DEB: first index"); } ptr_index = cur_index; *first_ind = index; } (*result)++; } if (type EQ ADN_FDN) cur_index = phb_element[cur_index].next_mtrcd; else cur_index = phb_element[cur_index].next_trcd; index++; } } else { TRACE_EVENT("pb_search_name() DEB: mode EQ PHB_NEXT_SEARCH"); } if ( ptr_index EQ UNUSED_INDEX ) { TRACE_EVENT("pb_search_name() ERR: name not found"); return PHB_FAIL; } /* copy the found record */ copy_phb_element( entry, phb_element[ptr_index] ); if (type EQ ADN_FDN) ptr_index = phb_element[ptr_index].next_mtrcd; else ptr_index = phb_element[ptr_index].next_trcd; return PHB_OK; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_search_number | +------------------------------------------------------------------------+ PURPOSE : */ T_PHB_RETURN pb_search_number(UBYTE type, UBYTE *number, UBYTE mode, SHORT *first_ind, SHORT *result, T_PHB_RECORD *entry) { static SHORT count = 0; static SHORT ptr_index; SHORT cur_index; UBYTE cur_byte_index; UBYTE flag; SHORT index; CHAR cur_number[MAX_PHB_NUM_LEN]; static CHAR search_number[MAX_PHB_NUM_LEN]; TRACE_FUNCTION ("pb_search_number()"); if (type EQ ADN_FDN) { /* check whether this phonebook exists */ if ((phb_ctb[ADN].mem EQ NO_PHB_ENTRY) AND (phb_ctb[FDN].mem EQ NO_PHB_ENTRY)) return PHB_FAIL; if ((phb_ctb[ADN].first_mnrcd EQ UNUSED_INDEX) AND (phb_ctb[FDN].first_mnrcd EQ UNUSED_INDEX)) return PHB_FAIL; } else { /* check whether this phonebook exists */ if (phb_ctb[type].mem EQ NO_PHB_ENTRY AND type NEQ ECC) return PHB_FAIL; } if (type EQ LDN OR type EQ LRN OR type EQ LMN) { *result = 0; if (!phb_ctb[type].used_rcd) return PHB_OK; cur_byte_index = (UBYTE) phb_ctb[type].first_rcd; while (cur_byte_index != UNUSED_BYTE_INDEX) { /* convert the number in BCD to string */ cmhPHB_getAdrStr(cur_number, MAX_PHB_NUM_LEN - 1, phb_l_element[cur_byte_index].entry.number, phb_l_element[cur_byte_index].entry.len); if (!strcmp((char *)cur_number, (char *)number)) { copy_phb_l_element(entry, phb_l_element[cur_byte_index]); *result = 1; return PHB_OK; } cur_byte_index = phb_l_element[cur_byte_index].next_rcd; } } /* check emergency call */ if (type EQ ECC) { *result = 0; /* if (!strcmp("112", (char *)number) || !strcmp("911", (char *)number) || !strcmp("999", (char *)number)) { entry->book = ECC; entry->index = 1; entry->tag_len = 0; entry->tag[0] = 0; cmhPHB_getAdrBcd ( entry->number, &entry->len, PHB_PACKED_NUM_LEN, (char *)number ); entry->ton_npi = 0xFF; entry->cc_id = 0xFF; *result = 1; return PHB_OK; }*/ if (!phb_ctb[type].used_rcd) return PHB_OK; cur_index = phb_ctb[type].first_nrcd; while (cur_index != UNUSED_INDEX) { /* convert the number in BCD to string */ cmhPHB_getAdrStr(cur_number, PHB_PACKED_NUM_LEN - 1, phb_element[cur_index].entry.number, phb_element[cur_index].entry.len); if (!strcmp((char *)cur_number, (char *)number)) { copy_phb_element (entry, phb_element[cur_index]); *result = 1; return PHB_OK; } cur_index = phb_element[cur_index].next_nrcd; } return PHB_OK; } /* search phone number */ if (mode EQ PHB_NEW_SEARCH) { count = 0; flag = 0; index = 1; strncpy(search_number, (char *)number, MAX_PHB_NUM_LEN-1); search_number[MAX_PHB_NUM_LEN-1] = '\0'; if (type EQ ADN_FDN) { if (phb_ctb[ADN].first_mnrcd != UNUSED_INDEX) cur_index = phb_ctb[ADN].first_mnrcd; else cur_index = phb_ctb[FDN].first_mnrcd; } else cur_index = phb_ctb[type].first_nrcd; while (cur_index != UNUSED_INDEX) { /* convert the number in BCD to string */ cmhPHB_getAdrStr(cur_number, MAX_PHB_NUM_LEN - 1, phb_element[cur_index].entry.number, phb_element[cur_index].entry.len); if (pb_check_number(cur_number, (char *)number)) { if (!flag) { ptr_index = cur_index; /* save the index of the first found record */ *first_ind = index; flag = 1; } count++; } if (type EQ ADN_FDN) cur_index = phb_element[cur_index].next_mnrcd; else cur_index = phb_element[cur_index].next_nrcd; index++; } *result = count; } if (mode EQ PHB_NEXT_SEARCH AND count) { while (ptr_index != UNUSED_INDEX) { /* convert the number in BCD to string */ cmhPHB_getAdrStr(cur_number, MAX_PHB_NUM_LEN - 1, phb_element[ptr_index].entry.number, phb_element[ptr_index].entry.len); if (pb_check_number(cur_number, search_number)) break; if (type EQ ADN_FDN) ptr_index = phb_element[ptr_index].next_mnrcd; else ptr_index = phb_element[ptr_index].next_nrcd; } } /* copy the found record */ if (count) { copy_phb_element( entry, phb_element[ptr_index] ); if (type EQ ADN_FDN) ptr_index = phb_element[ptr_index].next_mnrcd; else ptr_index = phb_element[ptr_index].next_nrcd; count--; } else return PHB_FAIL; return PHB_OK; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_rcd_chain | +------------------------------------------------------------------------+ PURPOSE : Chain the element according to record number. */ void pb_rcd_chain(UBYTE type, SHORT prev_index, SHORT cur_index, SHORT next_index) { /* TRACE_FUNCTION ("pb_rcd_chain()");*/ if ((phb_element[cur_index].prev_rcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_rcd EQ UNUSED_INDEX)) { phb_ctb[type].first_rcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_rcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_rcd EQ UNUSED_INDEX)) { phb_element[prev_index].next_rcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_rcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_rcd NEQ UNUSED_INDEX)) { phb_element[next_index].prev_rcd = UNUSED_INDEX; phb_element[cur_index].next_rcd = UNUSED_INDEX; /* ??? */ phb_ctb[type].first_rcd = next_index; } else if ((phb_element[cur_index].prev_rcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_rcd NEQ UNUSED_INDEX)) { phb_element[prev_index].next_rcd = phb_element[cur_index].next_rcd; phb_element[next_index].prev_rcd = phb_element[cur_index].prev_rcd; } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_l_rcd_chain | +------------------------------------------------------------------------+ PURPOSE : Chain the element according to record number. */ void pb_l_rcd_chain(UBYTE type, SHORT prev_index, SHORT cur_index, SHORT next_index) { /* TRACE_FUNCTION ("pb_l_rcd_chain()"); */ if ((phb_l_element[cur_index].prev_rcd EQ UNUSED_BYTE_INDEX) AND (phb_l_element[cur_index].next_rcd EQ UNUSED_BYTE_INDEX)) { phb_ctb[type].first_rcd = UNUSED_INDEX; } else if ((phb_l_element[cur_index].prev_rcd NEQ UNUSED_BYTE_INDEX) AND (phb_l_element[cur_index].next_rcd EQ UNUSED_BYTE_INDEX)) { phb_l_element[prev_index].next_rcd = UNUSED_BYTE_INDEX; phb_l_element[cur_index].prev_rcd = UNUSED_BYTE_INDEX; } else if ((phb_l_element[cur_index].prev_rcd EQ UNUSED_BYTE_INDEX) AND (phb_l_element[cur_index].next_rcd NEQ UNUSED_BYTE_INDEX)) { phb_l_element[next_index].prev_rcd = UNUSED_BYTE_INDEX; phb_l_element[cur_index].next_rcd = UNUSED_BYTE_INDEX; phb_ctb[type].first_rcd = (UBYTE)next_index; } else if ((phb_l_element[cur_index].prev_rcd NEQ UNUSED_BYTE_INDEX) AND (phb_l_element[cur_index].next_rcd NEQ UNUSED_BYTE_INDEX)) { phb_l_element[prev_index].next_rcd = phb_l_element[cur_index].next_rcd; phb_l_element[next_index].prev_rcd = phb_l_element[cur_index].prev_rcd; phb_l_element[cur_index].prev_rcd = UNUSED_BYTE_INDEX; phb_l_element[cur_index].prev_rcd = UNUSED_BYTE_INDEX; } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_name_chain | +------------------------------------------------------------------------+ PURPOSE : Chain the element according to alpha string. */ void pb_name_chain(UBYTE type, SHORT prev_index, SHORT cur_index, SHORT next_index) { SHORT ref_index; UBYTE flag; /* TRACE_FUNCTION ("pb_name_chain()");*/ if ((phb_element[cur_index].prev_trcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_trcd EQ UNUSED_INDEX)) { phb_ctb[type].first_trcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_trcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_trcd EQ UNUSED_INDEX)) { phb_element[prev_index].next_trcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_trcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_trcd NEQ UNUSED_INDEX)) { phb_element[next_index].prev_trcd = UNUSED_INDEX; phb_ctb[type].first_trcd = next_index; phb_element[cur_index].next_trcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_trcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_trcd NEQ UNUSED_INDEX)) { phb_element[prev_index].next_trcd = phb_element[cur_index].next_trcd; phb_element[next_index].prev_trcd = phb_element[cur_index].prev_trcd; } if (phb_ctb[type].first_trcd EQ cur_index) { flag = 0; ref_index = phb_element[cur_index].next_trcd; while (phb_element[ref_index].next_trcd) { if (!flag) { phb_ctb[type].first_trcd = ref_index; flag = 1; } ref_index = phb_element[ref_index].next_trcd; } if (!phb_element[ref_index].next_trcd AND !flag) phb_ctb[type].first_trcd = UNUSED_INDEX; } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_num_chain | +------------------------------------------------------------------------+ PURPOSE : Chain the element according to phone number. */ void pb_num_chain(UBYTE type, SHORT prev_index, SHORT cur_index, SHORT next_index) { SHORT ref_index; UBYTE flag; /* TRACE_FUNCTION ("pb_num_chain()");*/ if ((phb_element[cur_index].prev_nrcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_nrcd EQ UNUSED_INDEX)) { phb_ctb[type].first_nrcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_nrcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_nrcd EQ UNUSED_INDEX)) { phb_element[prev_index].next_nrcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_nrcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_nrcd NEQ UNUSED_INDEX)) { phb_element[next_index].prev_nrcd = UNUSED_INDEX; phb_ctb[type].first_nrcd = next_index; } else if ((phb_element[cur_index].prev_nrcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_nrcd NEQ UNUSED_INDEX)) { phb_element[prev_index].next_nrcd = phb_element[cur_index].next_nrcd; phb_element[next_index].prev_nrcd = phb_element[cur_index].prev_nrcd; } if (phb_ctb[type].first_nrcd EQ cur_index) { flag = 0; ref_index = phb_element[cur_index].next_nrcd; while (phb_element[ref_index].next_nrcd) { if (!flag) { phb_ctb[type].first_nrcd = ref_index; flag = 1; } ref_index = phb_element[ref_index].next_nrcd; } if (!phb_element[ref_index].next_nrcd AND !flag) phb_ctb[type].first_nrcd = UNUSED_INDEX; } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_mname_chain | +------------------------------------------------------------------------+ PURPOSE : Chain the element according to merged alpha string. */ void pb_mname_chain(UBYTE type, SHORT prev_index, SHORT cur_index, SHORT next_index) { SHORT ref_index; UBYTE flag; /* TRACE_FUNCTION ("pb_mname_chain()");*/ if ((phb_element[cur_index].prev_mtrcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_mtrcd EQ UNUSED_INDEX)) { phb_ctb[type].first_mtrcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_mtrcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_mtrcd EQ UNUSED_INDEX)) { phb_element[prev_index].next_mtrcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_mtrcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_mtrcd NEQ UNUSED_INDEX)) { phb_element[next_index].prev_mtrcd = UNUSED_INDEX; if (phb_ctb[ADN].used_rcd != 0) phb_ctb[ADN].first_mtrcd = next_index; else phb_ctb[FDN].first_mtrcd = next_index; } else if ((phb_element[cur_index].prev_mtrcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_mtrcd NEQ UNUSED_INDEX)) { phb_element[prev_index].next_mtrcd = phb_element[cur_index].next_mtrcd; phb_element[next_index].prev_mtrcd = phb_element[cur_index].prev_mtrcd; } if ((phb_ctb[ADN].first_mtrcd EQ cur_index) OR (phb_ctb[FDN].first_mtrcd EQ cur_index)) { flag = 0; ref_index = phb_element[cur_index].next_mtrcd; while (phb_element[ref_index].next_mtrcd) { if (!flag) { if (phb_ctb[ADN].used_rcd != 0) phb_ctb[ADN].first_mtrcd = ref_index; else phb_ctb[FDN].first_mtrcd = ref_index; flag = 1; } ref_index = phb_element[ref_index].next_mtrcd; } if (!phb_element[ref_index].next_mtrcd AND !flag) { phb_ctb[ADN].first_mtrcd = UNUSED_INDEX; phb_ctb[FDN].first_mtrcd = UNUSED_INDEX; } } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_mnum_chain | +------------------------------------------------------------------------+ PURPOSE : Chain the element according to phone number. */ void pb_mnum_chain(UBYTE type, SHORT prev_index, SHORT cur_index, SHORT next_index) { SHORT ref_index; UBYTE flag; /* TRACE_FUNCTION ("pb_mnum_chain()");*/ if ((phb_element[cur_index].prev_mnrcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_mnrcd EQ UNUSED_INDEX)) { phb_ctb[ADN].first_mnrcd = UNUSED_INDEX; phb_ctb[FDN].first_mnrcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_mnrcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_mnrcd EQ UNUSED_INDEX)) { phb_element[prev_index].next_mnrcd = UNUSED_INDEX; } else if ((phb_element[cur_index].prev_mnrcd EQ UNUSED_INDEX) AND (phb_element[cur_index].next_mnrcd NEQ UNUSED_INDEX)) { phb_element[next_index].prev_mnrcd = UNUSED_INDEX; if (phb_ctb[ADN].used_rcd != 0) phb_ctb[ADN].first_mnrcd = next_index; else phb_ctb[FDN].first_mnrcd = next_index; } else if ((phb_element[cur_index].prev_mnrcd NEQ UNUSED_INDEX) AND (phb_element[cur_index].next_mnrcd NEQ UNUSED_INDEX)) { phb_element[prev_index].next_mnrcd = phb_element[cur_index].next_mnrcd; phb_element[next_index].prev_mnrcd = phb_element[cur_index].prev_mnrcd; } if ((phb_ctb[ADN].first_mnrcd EQ cur_index) OR (phb_ctb[FDN].first_mnrcd EQ cur_index)) { flag = 0; ref_index = phb_element[cur_index].next_mnrcd; while (phb_element[ref_index].next_mnrcd) { if (!flag) { if (phb_ctb[ADN].used_rcd != 0) phb_ctb[ADN].first_mnrcd = ref_index; else phb_ctb[FDN].first_mnrcd = ref_index; flag = 1; } ref_index = phb_element[ref_index].next_mnrcd; } if (!phb_element[ref_index].next_mnrcd AND !flag) { phb_ctb[ADN].first_mnrcd = UNUSED_INDEX; phb_ctb[FDN].first_mnrcd = UNUSED_INDEX; } } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_read_status | +------------------------------------------------------------------------+ PURPOSE : */ T_PHB_RETURN pb_read_status(UBYTE type, UBYTE *service, SHORT *max_rcd, SHORT *used_rcd, UBYTE *tag_len, SHORT *avail_rcd, SHORT *max_ext, SHORT *used_ext) { SHORT i; SHORT count; UBYTE ext_type; TRACE_FUNCTION ("pb_read_status()"); TRACE_EVENT_P1("PHB get status of phonebook: %d", type); /* check whether this phonebook exists */ if (phb_ctb[type].mem EQ NO_PHB_ENTRY) { TRACE_EVENT("Phonebook is empty: return PHB_FAIL"); return PHB_FAIL; } *service = phb_ctb[type].service; *used_rcd = phb_ctb[type].used_rcd; /* ACI-SPR-9421 (mdf): reinstalled after storage increasement for phonebook */ *max_rcd = phb_ctb[type].max_rcd; *tag_len = MINIMUM ( phb_ctb[type].alpha_len, PHB_MAX_TAG_LEN ); *max_ext = 0; *used_ext = 0; count = 0; switch (type) { case ECC: case ADN: case FDN: case SDN: case BDN: case ADN_FDN: case UPN: for (i=0; i<MAX_AFB_RECORDS; i++) { if (phb_element[i].free EQ PHB_ELEMENT_FREE) count++; } TRACE_EVENT_P1("free records from count=%d",count); if ((phb_ctb[type].max_rcd-phb_ctb[type].used_rcd) >=count) { /* avail_rcd should be equal to free records not used records!!! */ *avail_rcd = count; } else { *avail_rcd = phb_ctb[type].max_rcd - phb_ctb[type].used_rcd; } break; case LDN: case LRN: case LMN: *max_rcd = phb_ctb[type].max_rcd; *avail_rcd = phb_ctb[type].max_rcd - phb_ctb[type].used_rcd; break; } #ifdef PHONEBOOK_EXTENSION ext_type = pb_get_ext_type(type); if(ext_type NEQ 0xFF) { pb_read_ext_status(ext_type, max_ext, used_ext); } #endif return PHB_OK; } /* +------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_get_fdn_mode | +------------------------------------------------------------------+ PURPOSE : */ void pb_status_req(UBYTE *mode) { /* TRACE_FUNCTION ("pb_status_req()");*/ *mode = phb_stat; } /* +------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_first_free | +------------------------------------------------------------------+ PURPOSE : On exit, "first_free" contains the index of the first free location in the specified phonebook. */ T_PHB_RETURN pb_first_free( UBYTE type, SHORT *first_free) { SHORT i,bit; UBYTE max_bitmap; UBYTE pos; TRACE_FUNCTION ("pb_first_free()"); if (first_free EQ NULL) { ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_Unknown); return(PHB_FAIL); } switch (type) { case SDN: case ADN: case FDN: case BDN: case UPN: case ECC: switch (type) { case ADN: max_bitmap=MAX_ADN_BITMAP; break; case FDN: max_bitmap=MAX_FDN_BITMAP; break; case BDN: max_bitmap=MAX_BDN_BITMAP; break; case UPN: max_bitmap=MAX_UPN_BITMAP; break; case SDN: max_bitmap=MAX_SDN_BITMAP; break; case ECC: max_bitmap=MAX_ECC_BITMAP; break; default: ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_Unknown); return(PHB_FAIL); } bit = 0; for (i=0; i<max_bitmap; i++) { pos = 0; while ((phb_ctb[type].rcd_bitmap[i] & (1<<pos))) { bit++; pos++; } if ((bit%8) OR !pos) { if (bit>=phb_ctb[type].max_rcd) { *first_free=0; return(PHB_FULL); } *first_free=bit+1; return(PHB_OK); } } *first_free=0; return(PHB_FULL); case LDN: case LMN: case LRN: /* * It is not possible to specify an index when writing to these * phonebooks. Whenever a number is added, it automatically goes * in the first entry of the list, hence it could be said that * the first free entry is always 1. */ *first_free=1; return(PHB_OK); default: break; } ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_Unknown); return(PHB_FAIL); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_switch_adn_fdn | +--------------------------------------------------------------------+ PURPOSE : */ T_PHB_RETURN pb_switch_adn_fdn(UBYTE mode, T_ACI_CLASS aci_classFDN) { UBYTE classFDN = (UBYTE) CLASS_None; TRACE_FUNCTION("pb_switch_adn_fdn()"); pb_set_fdn_input_classtype (aci_classFDN); if ((mode != FDN_DISABLE) AND (mode != FDN_ENABLE)) return PHB_FAIL; /* never used */ fdn_mode = mode; if ( fdn_classtype NEQ fdn_input_classtype) { fdn_classtype = fdn_input_classtype; classFDN = fdn_input_classtype; /* write to ffs */ #ifndef _SIMULATION_ if( ffs_fwrite("/mmi/fdnClassType", &classFDN, sizeof(classFDN)) < 1) { TRACE_FUNCTION("sAT_PlusCLCK: ME- failed to write ffs"); } #endif } pb_init_afb(); pb_start_build(FALSE); return PHB_OK; /* never used */ } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : cmpWild | +--------------------------------------------------------------------+ PURPOSE : compare two strings with wild character ('?') recognition in string1. Returns 0 on mismatch, otherwise 1. An empty string always match. */ UBYTE cmpWild (char *s1, char *s2) { int i1, i2; i1 = strlen(s1); i2 = strlen(s2); if ( i1 != i2 ) return 0; while (i1 AND i2) { i1--; i2--; if (s1[i1] != s2[i2] AND s1[i1] != '?') return 0; } return 1; } /* +--------------------------------------------------------------------+ | PROJECT : GSM-F&D (8411) MODULE : PHB | | STATE : code ROUTINE : cmpPHBString | +--------------------------------------------------------------------+ PURPOSE : get the length for PHB entry */ int pb_get_entry_len ( const UBYTE *pb_tag, UBYTE max_pb_len ) { int pb_len = 0; UBYTE inc_count = 1; BOOL ucs2 = FALSE; UBYTE chars = 0; if (*pb_tag EQ 0x80) { ucs2 = TRUE; inc_count = 2; /* check two bytes */ pb_len = 1; /* skip the 0x80 */ } else if (*pb_tag EQ 0x81 OR *pb_tag EQ 0x82) { if (*pb_tag EQ 0x81) pb_len = 3; /* 0x80 + len + pointer */ else pb_len = 4; /* 0x80 + len + 2xpointer */ chars = pb_tag[1]; pb_tag += pb_len; /* go to data */ while (chars) { if (*pb_tag++ & 0x80) pb_len+=2; else pb_len+=1; pb_tag++; chars--; } return MINIMUM(pb_len,max_pb_len); } while (pb_len < max_pb_len) { if (ucs2 EQ TRUE) { if (!(pb_len+1 < max_pb_len)) /* Check also if we traverse the upper bound */ break; /* so only a "half" UCS2 element is remaining */ } if (pb_tag[pb_len] EQ 0xFF) { /* one 0xFF indicates the end of a non UCS2 string */ if (ucs2 EQ FALSE) { break; } /* two 0xFF indicates the end of a UCS2 string */ if (pb_tag[pb_len + 1] EQ 0xFF) { break; } } pb_len += inc_count; } return (pb_len); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_cmp_phb_entry | +--------------------------------------------------------------------+ PURPOSE : compare PHB entry (SIM) with T_ACI_PB_TEXT. cannot compare pb_tag with search_tag return - 1 if pb_tag < search_tag return value < 0 if pb_tag = search_tag return value = 0 if pb_tag > search_tag return value > 0 */ static int pb_cmp_phb_entry ( UBYTE *pb_tag, UBYTE pb_len, T_ACI_PB_TEXT *search_tag ) { UBYTE cmp_len; UBYTE pb_tag_buf[PHB_MAX_TAG_LEN]; UBYTE *cmp_pb_tag; UBYTE search_tag_buf[PHB_MAX_TAG_LEN]; UBYTE *cmp_search_tag; int i; cmp_len = MINIMUM ( pb_len, search_tag->len ); /* convert to lower cases, when not Unicode */ if ( ( search_tag->cs EQ CS_Sim ) AND ( ( *search_tag->data NEQ 0x80 ) AND ( *pb_tag NEQ 0x80 ) ) ) { for (i = 0; i < cmp_len; i++) pb_tag_buf[i] = (UBYTE)tolower((int)pb_tag[i]); cmp_pb_tag = pb_tag_buf; for (i = 0; i < cmp_len; i++) search_tag_buf[i] = (UBYTE)tolower((int)search_tag->data[i]); cmp_search_tag = search_tag_buf; } else { cmp_pb_tag = pb_tag; cmp_search_tag = search_tag->data; } /* check the types */ if ( search_tag->cs EQ CS_Sim ) return ( cmpString ( cmp_pb_tag, cmp_search_tag, cmp_len ) ); if ( ( search_tag->cs EQ CS_Ucs2 ) AND ( *pb_tag EQ 0x80 ) ) return ( memcmp ( cmp_pb_tag + 1, cmp_search_tag, cmp_len ) ); if ( ( search_tag->cs EQ CS_Ucs2 ) AND ( *pb_tag NEQ 0x80 ) ) return pb_cmp2Bytes ( cmp_search_tag, cmp_pb_tag, cmp_len, 1 ); if ( ( search_tag->cs EQ CS_GsmDef ) AND ( *pb_tag EQ 0x80 ) ) return pb_cmp2Bytes ( cmp_search_tag, cmp_pb_tag + 1 , cmp_len, 2 ); if ( ( search_tag->cs EQ CS_GsmDef ) AND ( *pb_tag NEQ 0x80 ) ) { return ( memcmp ( cmp_pb_tag, cmp_search_tag, cmp_len ) ); } return ( -1 ); } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : cmpString | +--------------------------------------------------------------------+ PURPOSE : compare two strings. if s1 < s2 return value < 0 if s1 = s2 return value = 0 if s1 > s2 return value > 0 */ static int cmpString ( UBYTE *s1, UBYTE *s2, UBYTE len ) { int n = 0; /* TRACE_FUNCTION("cmpString()"); */ /* Called too often to trace */ if ((*s1 EQ 0x80) AND (*s2 NEQ 0x80) ) { s1++; len--; return pb_cmp2Bytes(s1, s2, len, 1); } else if ((*s1 NEQ 0x80) AND (*s2 EQ 0x80) ) { s2++; len--; return pb_cmp2Bytes(s1, s2, len, 2); } else { while (*s1 EQ *s2) { if (*s1 EQ 0xff) return 0; s1++; s2++; n++; if (n EQ len) return 0; } if ((*s1 > *s2) AND (*s1 NEQ 0xff)) return 1; return -1; } } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_cmp2Bytes | +--------------------------------------------------------------------+ PURPOSE : compare two strings. if s1 < s2 return value < 0 if s1 = s2 return value = 0 if s1 > s2 return value > 0 flag = 1, s1 is unicode flag = 2, s2 is unicode */ static int pb_cmp2Bytes(UBYTE *s1, UBYTE *s2, UBYTE len, UBYTE flag) { int n = 0; /* TRACE_FUNCTION("pb_cmp2Bytes()"); */ if (flag EQ 1) { while ( (*s1 EQ 0x00 OR *s1 EQ 0xFF ) AND ( *(s1+1) EQ *s2) ) { if (*s1 EQ 0xff AND *(s1+1) EQ 0xFF) return 0; s1 += 2; s2++; n += 2; if (n >= len) return 0; } if ( ( *s1 > 0 AND *s1 NEQ 0xff ) OR ( !*s1 AND ( *(s1+1) > *s2 ) ) ) return 1; return -1; } if (flag EQ 2) { while ((*s2 EQ 0x00 OR *s2 EQ 0xFF) AND (*s1 EQ *(s2+1))) { if (*s2 EQ 0xff AND *(s2+1) EQ 0xFF) return 0; s1++; s2 += 2; n += 2; if (n >= len) return 0; } if ((*s2 > 0 AND *s2 NEQ 0xff) OR (!*s2 AND (*(s2+1) > *s1)) ) return -1; return 1; } return -1; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_check_number | +--------------------------------------------------------------------+ PURPOSE : compare two numbers. If they are same, return 1. */ UBYTE pb_check_number(char *cur_number, char *number) { UBYTE len1; UBYTE len2; len1 = strlen(cur_number); len2 = strlen((char *)number); if (!len2) return 0; /* Bug Fix: the return value was "1" */ if ((len1>=6) AND (len2>=6)) { if (cmpWild (&cur_number[len1-6], (char *)&number[len2-6]) EQ 1) return 1; } else { if (cmpWild ((char *)cur_number, (char *)number) EQ 1) return 1; } return 0; } /* +--------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_check_fdn | +--------------------------------------------------------------------+ PURPOSE : check whether phone number is in FDN phonebook. */ GLOBAL T_PHB_RETURN pb_check_fdn (UBYTE toa, const UBYTE *number) { SHORT cur_index; CHAR cur_number[MAX_PHB_NUM_LEN]; CHAR new_number[MAX_PHB_NUM_LEN]; UBYTE len1; UBYTE len2; len1 = strlen((char *)number); cur_index = phb_ctb[FDN].first_nrcd; while (cur_index != UNUSED_INDEX) { memset(new_number, 0, sizeof(new_number)); cmhPHB_getAdrStr(cur_number, MAX_PHB_NUM_LEN - 1, phb_element[cur_index].entry.number, phb_element[cur_index].entry.len); len2 = strlen((char *)cur_number); if (len1 < len2 OR phb_element[cur_index].entry.len EQ 0) { cur_index = phb_element[cur_index].next_nrcd; continue; } else { strncpy(new_number, (char *)number, len2); if (cmpWild ((char *)&cur_number, new_number) EQ 1) { if ( toa NEQ 0 ) /* ACI-SPR-11927:check whether to test toa or not */ { if ((toa NEQ phb_element[cur_index].entry.ton_npi) AND (phb_element[cur_index].entry.ton_npi NEQ 0xFF) ) /* VO patch 02.03.01 */ { cur_index = phb_element[cur_index].next_nrcd; continue; } } causeMod = P_CEER_mod; /* Clear module which was set for ceer */ causeCeer = CEER_NotPresent; /* Reset cause - number to dial found in FDN list. */ return PHB_OK; } } cur_index = phb_element[cur_index].next_nrcd; } causeMod = P_CEER_sim; /* Set ceer module to sim */ causeCeer = P_CEER_InvalidFDN; /* Set cause - number to dial not found in FDN list.*/ return PHB_FAIL; } /* +------------------------------------------------- -------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_exit | +---------------------------------------------------------------+ PURPOSE : Save the phonebook in SIM card. */ void pb_exit() { TRACE_FUNCTION("pb_exit()"); pb_write_eeprom(); if(pb_init_sync_sim(LDN) EQ FALSE) pb_finish_sync_sim(); /* this will otherwise be called after the last record written*/ } /* +------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_write_sim_cb | +------------------------------------------------------------------+ PURPOSE : Call back for write phonebook in SIM card. */ void pb_write_sim_cb(SHORT table_id) { UBYTE type; TRACE_FUNCTION("pb_write_sim_cb()"); simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; if (simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR) { TRACE_ERROR("pb_write_sim_cb(): error for writing"); db_index = UNUSED_INDEX; phb_stat = PHB_READY; cmhPHB_StatIndication( PHB_WRITE_FAIL, (SHORT)cmhSIM_GetCmeFromSim( simShrdPrm.atb[table_id].errCode ), FALSE ); /* don't indicate for write */ return; } if (db_index NEQ UNUSED_INDEX) { switch (simShrdPrm.atb[table_id].reqDataFld) { case SIM_ADN: type = ADN; break; case SIM_FDN: type = FDN; break; case SIM_BDN: type = BDN; break; case SIM_SDN: type = SDN; break; case SIM_MSISDN: type = UPN; break; default: return; } pb_delete_sim_book(type); } else { phb_stat = PHB_READY; cmhPHB_StatIndication ( PHB_READY, CME_ERR_NotPresent, FALSE ); } } /* +-----------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_write_sim | +-----------------------------------------------------------------+ PURPOSE : Write phonebook in SIM card. */ T_PHB_RETURN pb_write_sim(UBYTE type, UBYTE rcd_num) { SHORT table_id; USHORT data_id; TRACE_FUNCTION("pb_write_sim()"); switch (type) { case ADN: data_id = SIM_ADN; break; case FDN: data_id = SIM_FDN; break; case BDN: data_id = SIM_BDN; break; case SDN: data_id = SIM_SDN; break; case UPN: data_id = SIM_MSISDN; break; case LDN: data_id = SIM_LND; break; default: return PHB_FAIL; } table_id = psaSIM_atbNewEntry(); if(table_id EQ NO_ENTRY) { TRACE_ERROR ("pb_write_sim(): 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 = data_id; simShrdPrm.atb[table_id].recNr = rcd_num; simShrdPrm.atb[table_id].dataLen = phb_ctb[type].alpha_len + 14; simShrdPrm.atb[table_id].exchData = data; simShrdPrm.atb[table_id].rplyCB = pb_write_sim_cb; simShrdPrm.aId = table_id; if(psaSIM_AccessSIMData() < 0) { TRACE_EVENT("pb_write_sim(): psaSIM_AccessSIMData() failed"); return (PHB_FAIL); } phb_stat = PHB_BUSY; cmhPHB_StatIndication ( PHB_BUSY, CME_ERR_NotPresent, FALSE ); return (PHB_EXCT); } #ifdef PHONEBOOK_EXTENSION /* +----------------------------------------------------------------------+ | PROJECT : MODULE : PHB | | STATE : code ROUTINE : pb_prepare_ext_data | +----------------------------------------------------------------------+ PURPOSE : Prepare the data for the extention record. If NULL pointer is given for number and subaddress then the extention record will marked as unused */ LOCAL void pb_prepare_ext_data(UBYTE *number, UBYTE no_len, UBYTE *subaddr, UBYTE sub_len, USHORT file_id) { memset(data, 0xFF, sizeof(data)); if ((subaddr != NULL) AND (*subaddr != 0xFF)) { TRACE_EVENT ("SUBADDRESS EXTENTION"); data[0] = 1; data[1] = sub_len; memcpy (data + 2, subaddr, 11); } else if (number != NULL) { data[0] = 2; data[1] = no_len - 10; memcpy (data + 2, number + 10, no_len); } } /* +----------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_write_sim_ext_cb | +----------------------------------------------------------------------+ PURPOSE : Call back for write phonebook in SIM card. */ void pb_write_sim_ext_cb(SHORT table_id) { /* USHORT ext_type; UBYTE rcd_num;*/ TRACE_FUNCTION("pb_write_sim_ext_cb"); simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; if (simShrdPrm.atb[table_id].errCode NEQ SIM_NO_ERROR) { TRACE_ERROR("pb_write_sim_ext_cb (): FATAL ERROR"); } } /* +-------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_write_sim_ext | +-------------------------------------------------------------------+ PURPOSE : Write phonebook in SIM card. */ T_PHB_RETURN pb_write_sim_ext(USHORT data_id, UBYTE rcd_num) { SHORT table_id; table_id = psaSIM_atbNewEntry(); if(table_id EQ NO_ENTRY) { TRACE_ERROR ("pb_write_sim_ext(): 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 = data_id; simShrdPrm.atb[table_id].recNr = rcd_num; simShrdPrm.atb[table_id].dataLen = 13; simShrdPrm.atb[table_id].exchData = data; simShrdPrm.atb[table_id].rplyCB = pb_write_sim_ext_cb; simShrdPrm.aId = table_id; if (psaSIM_AccessSIMData() < 0) { TRACE_ERROR("pb_write_sim_ext(): psaSIM_AccessSIMData() failed"); return (PHB_FAIL); } return (PHB_EXCT); } #endif /* PHONEBOOK_EXTENSION */ /* +------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_write_eepron_req | +------------------------------------------------------------------+ PURPOSE : Write phonebook in EEPROM. */ void pb_write_eeprom() { SHORT ptr_index; UBYTE ptr_byte_index; int i; UBYTE count; EF_UPN *p = (EF_UPN *)data; /* TRACE_FUNCTION ("pb_write_eeprom_req()"); */ /* Write Last Dialing Numbers */ ptr_byte_index = (UBYTE)phb_ctb[LDN].first_rcd; count = 0; for (i=0; i<phb_ctb[LDN].max_rcd; i++) { if (count < phb_ctb[LDN].used_rcd AND ptr_byte_index NEQ UNUSED_BYTE_INDEX) { TRACE_EVENT_P1("--- LDN: copy to eeprom for ptr_byte_index %d", ptr_byte_index); pb_copy_ldn_record((SHORT)ptr_byte_index, 1); } else memset(&data[0], 0xFF, SIZE_EF_LDN); if (pcm_WriteRecord((UBYTE *)EF_LDN_ID, (USHORT)(i+1), SIZE_EF_LDN, &data[0]) NEQ DRV_OK) break; if (ptr_byte_index NEQ UNUSED_BYTE_INDEX) ptr_byte_index = phb_l_element[ptr_byte_index].next_rcd; count++; } /* Write Last received Numbers */ ptr_byte_index = (UBYTE)phb_ctb[LRN].first_rcd; count = 0; for (i=0; i<phb_ctb[LRN].max_rcd; i++) { if (count < phb_ctb[LRN].used_rcd AND ptr_byte_index NEQ UNUSED_BYTE_INDEX) pb_copy_lrn_record(ptr_byte_index, 1); else memset(&data[0], 0xFF, SIZE_EF_LRN); if (pcm_WriteRecord((UBYTE *)EF_LRN_ID, (USHORT)(i+1), SIZE_EF_LRN, &data[0]) NEQ DRV_OK) break; if (ptr_byte_index NEQ UNUSED_BYTE_INDEX) ptr_byte_index = phb_l_element[ptr_byte_index].next_rcd; count++; } /* Write Last missed Numbers */ ptr_byte_index = (UBYTE)phb_ctb[LMN].first_rcd; count = 0; for (i=0; i<phb_ctb[LMN].max_rcd; i++) { if (count < phb_ctb[LMN].used_rcd AND ptr_byte_index NEQ UNUSED_BYTE_INDEX) pb_copy_lmn_record(ptr_byte_index, 1); else memset(&data[0], 0xFF, SIZE_EF_LMN); if (pcm_WriteRecord((UBYTE *)EF_LMN_ID, (USHORT)(i+1), SIZE_EF_LMN, &data[0]) NEQ DRV_OK) break; if (ptr_byte_index NEQ UNUSED_BYTE_INDEX) ptr_byte_index = phb_l_element[ptr_byte_index].next_rcd; count++; } /* Write user person Numbers */ if (phb_ctb[UPN].mem EQ TE_MEMORY) { ptr_index = phb_ctb[UPN].first_rcd; count = 0; for (i=0; i<phb_ctb[UPN].max_rcd; i++) { if (count < phb_ctb[UPN].used_rcd AND ptr_index NEQ UNUSED_INDEX) { /* copy record */ memcpy(p->alphId, phb_element[ptr_index].entry.tag, 10*sizeof(UBYTE)); p->len = phb_element[ptr_index].entry.len; p->numTp = phb_element[ptr_index].entry.ton_npi; memcpy(p->usrNum, phb_element[ptr_index].entry.number, 10*sizeof(UBYTE)); p->ccp = phb_element[ptr_index].entry.cc_id; } else memset(&data[0], 0xFF, SIZE_EF_UPN); if (pcm_WriteRecord((UBYTE *)EF_UPN_ID, (USHORT)(i+1), SIZE_EF_UPN, &data[0]) NEQ DRV_OK) break; if (ptr_index NEQ UNUSED_INDEX) ptr_index = phb_element[ptr_index].next_rcd; count++; } } } /* +------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_copy_ldn_record | +------------------------------------------------------------------+ PURPOSE : Copy a LDN record. flag = 0: from EEPROM to local flag = 1: from local to EEPROM */ void pb_copy_ldn_record(SHORT index, UBYTE flag) { EF_LDN *p = (EF_LDN *)data; /* TRACE_FUNCTION ("pb_copy_ldn_record()");*/ if (!flag) { phb_l_element[index].entry.year = p->year; phb_l_element[index].entry.month = p->month; phb_l_element[index].entry.day = p->day; phb_l_element[index].entry.hour = p->hour; phb_l_element[index].entry.minute = p->minute; phb_l_element[index].entry.second = p->second; phb_l_element[index].entry.len = p->len; phb_l_element[index].entry.ton_npi = p->numTp; memcpy((char *)phb_l_element[index].entry.number, (char *)&p->dldNum, 10); phb_l_element[index].entry.cc_id = p->ccp; } if (flag EQ 1) { p->calDrMsb = 0xFF; p->calDrLsb = 0xFF; p->year = phb_l_element[index].entry.year; p->month = phb_l_element[index].entry.month; p->day = phb_l_element[index].entry.day; p->hour = phb_l_element[index].entry.hour; p->minute = phb_l_element[index].entry.minute; p->second = phb_l_element[index].entry.second; p->len = phb_l_element[index].entry.len; p->numTp = phb_l_element[index].entry.ton_npi; memcpy((char *)p->dldNum, (char *)phb_l_element[index].entry.number, 10); p->ccp = phb_l_element[index].entry.cc_id; p->ext1 = 0xFF; } } /* +------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_copy_lrn_record | +------------------------------------------------------------------+ PURPOSE : Copy a LRN record. flag = 0: from EEPROM to local flag = 1: from local to EEPROM */ void pb_copy_lrn_record(SHORT index, UBYTE flag) { EF_LRN *p = (EF_LRN *)data; /* TRACE_FUNCTION ("pb_copy_lrn_record()");*/ if (!flag) { phb_l_element[index].entry.year = p->year; phb_l_element[index].entry.month = p->month; phb_l_element[index].entry.day = p->day; phb_l_element[index].entry.hour = p->hour; phb_l_element[index].entry.minute = p->minute; phb_l_element[index].entry.second = p->second; phb_l_element[index].entry.len = p->len; phb_l_element[index].entry.ton_npi = p->numTp; memcpy((char *)phb_l_element[index].entry.number, (char *)p->dldNum, 10); phb_l_element[index].entry.cc_id = p->ccp; } if (flag EQ 1) { p->calDrMsb = 0xFF; p->calDrLsb = 0xFF; p->year = phb_l_element[index].entry.year; p->month = phb_l_element[index].entry.month; p->day = phb_l_element[index].entry.day; p->hour = phb_l_element[index].entry.hour; p->minute = phb_l_element[index].entry.minute; p->second = phb_l_element[index].entry.second; p->id = 0xFF; p->len = phb_l_element[index].entry.len; p->numTp = phb_l_element[index].entry.ton_npi; memcpy((char *)p->dldNum, (char *)phb_l_element[index].entry.number, 10); p->ccp = phb_l_element[index].entry.cc_id; p->ext1 = 0xFF; } } /* +------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE : pb_copy_lmn_record | +------------------------------------------------------------------+ PURPOSE : Copy a LMN record. flag = 0: from EEPROM to local flag = 1: from local to EEPROM */ void pb_copy_lmn_record(SHORT index, UBYTE flag) { EF_LMN *p = (EF_LMN *)data; /* TRACE_FUNCTION ("pb_copy_lmn_record()");*/ if (!flag) { phb_l_element[index].entry.year = p->year; phb_l_element[index].entry.month = p->month; phb_l_element[index].entry.day = p->day; phb_l_element[index].entry.hour = p->hour; phb_l_element[index].entry.minute = p->minute; phb_l_element[index].entry.second = p->second; phb_l_element[index].entry.len = p->len; phb_l_element[index].entry.ton_npi = p->numTp; memcpy((char *)phb_l_element[index].entry.number, (char *)p->dldNum, 10); phb_l_element[index].entry.cc_id = p->ccp; } if (flag EQ 1) { p->year = phb_l_element[index].entry.year; p->month = phb_l_element[index].entry.month; p->day = phb_l_element[index].entry.day; p->hour = phb_l_element[index].entry.hour; p->minute = phb_l_element[index].entry.minute; p->second = phb_l_element[index].entry.second; p->id = 0xFF; p->len = phb_l_element[index].entry.len; p->numTp = phb_l_element[index].entry.ton_npi; memcpy((char *)p->dldNum, (char *)phb_l_element[index].entry.number, 10); p->ccp = phb_l_element[index].entry.cc_id; p->ext1 = 0xFF; } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_delete_book | +------------------------------------------------------------------------+ PURPOSE : Delete a phonebook in SIM card. */ T_PHB_RETURN pb_delete_book(UBYTE book) { SHORT cur_index; TRACE_FUNCTION("pb_delete_book()"); /* check whether this phonebook exists */ if (phb_ctb[book].mem EQ NO_PHB_ENTRY) return PHB_FAIL; phb_stat = PHB_BUSY; cmhPHB_StatIndication ( PHB_BUSY, CME_ERR_NotPresent, FALSE ); cur_index = phb_ctb[book].first_rcd; while (cur_index != UNUSED_INDEX) { phb_element[cur_index].free = PHB_ELEMENT_FREE; if ((book EQ ADN) OR (book EQ FDN)) { pb_mname_chain(book, phb_element[cur_index].prev_mtrcd, cur_index, phb_element[cur_index].next_mtrcd); pb_mnum_chain(book, phb_element[cur_index].prev_mnrcd, cur_index, phb_element[cur_index].next_mnrcd); } cur_index = phb_element[cur_index].next_rcd; } phb_ctb[book].used_rcd = 0; /* phb_ctb[book].first_rcd = UNUSED_INDEX;*/ phb_ctb[book].first_trcd = UNUSED_INDEX; phb_ctb[book].first_nrcd = UNUSED_INDEX; phb_ctb[book].first_mtrcd = UNUSED_INDEX; /* ??? */ phb_ctb[book].first_mnrcd = UNUSED_INDEX; /* ??? */ switch (book) { case ADN: memset(phb_ctb[book].rcd_bitmap, 0, MAX_ADN_BITMAP); break; case FDN: memset(phb_ctb[book].rcd_bitmap, 0, MAX_FDN_BITMAP); break; case BDN: memset(phb_ctb[book].rcd_bitmap, 0, MAX_BDN_BITMAP); break; case SDN: memset(phb_ctb[book].rcd_bitmap, 0, MAX_SDN_BITMAP); break; case UPN: memset(phb_ctb[book].rcd_bitmap, 0, MAX_UPN_BITMAP); break; default: break; } pb_delete_sim_book(book); return PHB_OK; } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_delete_sim_book | +------------------------------------------------------------------------+ PURPOSE : Delete a phonebook in SIM card. */ void pb_delete_sim_book(UBYTE book) { if (db_index EQ UNUSED_INDEX) { db_index = phb_ctb[book].first_rcd; phb_ctb[book].first_rcd = UNUSED_INDEX; } else db_index = phb_element[db_index].next_rcd; if (db_index NEQ UNUSED_INDEX) { memset(data, 0xFF, sizeof(data)); if (pb_write_sim(book, phb_element[db_index].entry.index) EQ PHB_FAIL) { db_index = UNUSED_INDEX; phb_stat = PHB_READY; cmhPHB_StatIndication ( PHB_READY, CME_ERR_NotPresent, FALSE ); } //TISH delete related EXT element #ifdef PHONEBOOK_EXTENSION else { if (phb_element[db_index].entry.ext_rcd_num!=0xFF) { USHORT file_id = 0; pb_rem_ext_record_flag (book, phb_element[db_index].entry.ext_rcd_num); file_id = pb_get_ext_file_id (book); pb_prepare_ext_data (NULL, 0, NULL, 0, file_id); pb_write_sim_ext(file_id, phb_element[db_index].entry.ext_rcd_num); } } #endif } else { db_index = UNUSED_INDEX; phb_stat = PHB_READY; cmhPHB_StatIndication ( PHB_READY, CME_ERR_NotPresent, FALSE ); } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_update_ecc_fu | +------------------------------------------------------------------------+ PURPOSE : Read emergency call numbers from SIM card. */ #ifdef SIM_TOOLKIT BOOL pb_update_ecc_fu(int ref, T_SIM_FILE_UPDATE_IND *fu) { BOOL found = FALSE; UBYTE i; TRACE_FUNCTION ("pb_update_ecc_fu()"); for (i = 0; i < (int)fu->val_nr; i++) { if (!found AND fu->file_info[i].v_path_info EQ TRUE AND fu->file_info[i].path_info.df_level1 EQ SIM_DF_GSM AND fu->file_info[i].path_info.v_df_level2 EQ FALSE AND fu->file_info[i].datafield EQ SIM_ECC) { found = TRUE; } } if (found) { simShrdPrm.fuRef = ref; pb_update_ecc(); return FALSE; /* reading files */ } else { return TRUE; /* nothing to do */ } } #endif /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_update_ecc | +------------------------------------------------------------------------+ PURPOSE : Read emergency call numbers from SIM card. */ void pb_update_ecc(void) { TRACE_FUNCTION("pb_update_ecc()"); if ((fdn_mode != NO_OPERATION) AND (simShrdPrm.fuRef EQ -1)) return; phb_ctb[ECC].mem = SIM_MEMORY; phb_ctb[ECC].type = ECC; phb_ctb[ECC].first_trcd = UNUSED_INDEX; pb_read_sim_ecc(); } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_read_sim_ecc | +------------------------------------------------------------------------+ PURPOSE : Read EC number from SIM card. */ void pb_read_sim_ecc (void) { TRACE_FUNCTION ("pb_read_sim_ecc()"); if (pb_read_sim_dat(SIM_ECC, NOT_PRESENT_8BIT, (UBYTE)256) EQ FALSE ) /* give the max length 256 */ pb_read_eeprom_ecc(); } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_read_eeprom_ecc | +------------------------------------------------------------------------+ PURPOSE : Read EC number from EEPROM. */ void pb_read_eeprom_ecc (void) { EF_ECC efecc; UBYTE *data_ptr; UBYTE version; int i; phb_ctb[ECC].mem = TE_MEMORY; phb_ctb[ECC].type = ECC; phb_ctb[ECC].max_rcd = MAX_ECC_RCD; phb_ctb[ECC].first_trcd = UNUSED_INDEX; if (pcm_ReadFile((UBYTE *)EF_ECC_ID, SIZE_EF_ECC, (UBYTE *)&efecc, &version) EQ DRV_OK) { { /* workaround when invalid data stored on PCM */ CHAR ecc_number[MAX_PHB_NUM_LEN]; int j; data_ptr = &efecc.ecc1[0]; for (i=0; i < phb_ctb[ECC].max_rcd; i++) { if (*data_ptr NEQ 0xFF) { cmhPHB_getAdrStr (ecc_number, MAX_PHB_NUM_LEN - 1, data_ptr, 3); for (j = 0; j < 3; j++) { if (!isdigit (ecc_number[j])) { TRACE_EVENT_P2 ("[ERR] pb_read_eeprom_ecc(): invalid character found %c (%d)", ecc_number[j], i); return; } } } data_ptr += 3; } } /* workaround end */ data_ptr = &efecc.ecc1[0]; for (i=0; i < phb_ctb[ECC].max_rcd; i++) { pb_copy_ecc_entry(data_ptr, (UBYTE)i); data_ptr += 3; } } } /* +------------------------------------------------------------------------+ | PROJECT : MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE : pb_copy_ecc_entry | +------------------------------------------------------------------------+ PURPOSE : Read EC number from EEPROM. */ void pb_copy_ecc_entry (UBYTE *ecc, UBYTE num) { SHORT index; /* TRACE_FUNCTION("pb_copy_ecc_entry()"); */ if (*ecc NEQ 0xff) { /* search a free element in phonebook element table */ if (pb_create_memory(&index) NEQ PHB_OK) return; phb_ctb[ECC].used_rcd++; phb_ctb[ECC].rcd_bitmap[0] |= (UBYTE)(0x01 << num); phb_element[index].type = ECC; phb_element[index].entry.index = (UBYTE)(num+1); phb_element[index].entry.len = 3; memcpy(phb_element[index].entry.number, ecc, 3); pb_record_sort(index); pb_num_sort(index); phb_element[index].prev_trcd = UNUSED_INDEX; phb_element[index].next_trcd = UNUSED_INDEX; } } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_sim_dat | +----------------------------------------------------------------------+ PURPOSE : Request to read SIM card. */ BOOL pb_read_sim_dat(USHORT data_id, UBYTE len, UBYTE max_length) { SHORT table_id; TRACE_FUNCTION ("pb_read_sim_dat()"); table_id = psaSIM_atbNewEntry(); if(table_id NEQ NO_ENTRY) { 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_dat_cb; simShrdPrm.aId = table_id; if(psaSIM_AccessSIMData() < 0) { TRACE_EVENT("FATAL ERROR"); return FALSE; } return TRUE; } return FALSE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE: PHB | | STATE : code ROUTINE: pb_read_sim_dat_cb | +----------------------------------------------------------------------+ PURPOSE : Call back for SIM read. */ void pb_read_sim_dat_cb(SHORT table_id) { int i; UBYTE *data_ptr; TRACE_FUNCTION ("pb_read_sim_dat_cb()"); switch (simShrdPrm.atb[table_id].reqDataFld) { case SIM_ECC: data_ptr = simShrdPrm.atb[table_id].exchData; if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR ) { phb_ctb[ECC].max_rcd = (SHORT)simShrdPrm.atb[table_id].dataLen/3; for (i=0; i < phb_ctb[ECC].max_rcd; i++) { pb_copy_ecc_entry(data_ptr, (UBYTE)i); data_ptr += 3; } #ifdef SIM_TOOLKIT if (simShrdPrm.fuRef >= 0) { psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_SUCCESS); } #endif } else { #ifdef SIM_TOOLKIT if (simShrdPrm.fuRef >= 0) { psaSAT_FUConfirm (simShrdPrm.fuRef, SIM_FU_ERROR); } #endif pb_read_eeprom_ecc(); } break; case SIM_SST: data_ptr = simShrdPrm.atb[table_id].exchData; if ( simShrdPrm.atb[table_id].errCode EQ SIM_NO_ERROR ) { /* copy SIM service table */ memset(sim_service_table, 0, sizeof(sim_service_table)); memcpy(sim_service_table, simShrdPrm.atb[table_id].exchData, MINIMUM(MAX_SRV_TBL, simShrdPrm.atb[table_id].dataLen)); /* initialisation of the all SIM phonebooks */ pb_sat_update_reset(SIM_ADN); pb_sat_update_reset(SIM_FDN); pb_sat_update_reset(SIM_BDN); pb_sat_update_reset(SIM_SDN); pb_sat_update_reset(SIM_MSISDN); /* start reading SIM phonebook */ pb_start_build(FALSE); } else pb_start_build(FALSE); break; default: break; } simShrdPrm.atb[table_id].ntryUsdFlg = FALSE; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE : PHB | | STATE : code ROUTINE: pb_set_compare | +----------------------------------------------------------------------+ PURPOSE : set a external MMI compare function for phonebook entries */ void pb_set_compare_fct (T_PHB_EXT_CMP_FCT compare_fct) { ext_compare_fct = compare_fct; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE : PHB | | STATE : code ROUTINE: pb_get_fdn_input_classtype | +----------------------------------------------------------------------+ PURPOSE : get fdn_input_classtype */ T_ACI_CLASS pb_get_fdn_input_classtype (void) { return fdn_input_classtype; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE : PHB | | STATE : code ROUTINE: pb_set_fdn_input_classtype | +----------------------------------------------------------------------+ PURPOSE : set fdn_input_classtype */ void pb_set_fdn_input_classtype (T_ACI_CLASS classtype) { fdn_input_classtype = classtype; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE : PHB | | STATE : code ROUTINE: pb_get_fdn_classtype | +----------------------------------------------------------------------+ PURPOSE : get fdn_classtype */ T_ACI_CLASS pb_get_fdn_classtype (void) { return fdn_classtype; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE : PHB | | STATE : code ROUTINE: pb_set_fdn_classtype | +----------------------------------------------------------------------+ PURPOSE : set fdn_classtype */ void pb_set_fdn_classtype (T_ACI_CLASS classtype) { fdn_classtype = classtype; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE : PHB | | STATE : code ROUTINE: pb_get_fdn_mode | +----------------------------------------------------------------------+ PURPOSE : get fdn_mode */ UBYTE pb_get_fdn_mode (void) { return fdn_mode; } /* +----------------------------------------------------------------------+ | PROJECT: MMI-Framework MODULE : PHB | | STATE : code ROUTINE: pb_set_fdn_mode | +----------------------------------------------------------------------+ PURPOSE : set fdn_mode */ void pb_set_fdn_mode (UBYTE fdnmode) { fdn_mode = fdnmode; } /* +--------------------------------------------------------------------+ | PROJECT: MMI-Framework (8417) MODULE : PHB | | STATE : code ROUTINE: pb_free_used_record | +--------------------------------------------------------------------+ PURPOSE : Making used record as free, whenever extension record is not free while adding an entry with extension data */ LOCAL void pb_free_used_record(UBYTE type, SHORT index, UBYTE rec_num) { UBYTE n,m; TRACE_FUNCTION ("pb_free_used_record()"); phb_element[index].free = PHB_ELEMENT_FREE; /* Update used records */ phb_ctb[type].used_rcd--; if ((type EQ ADN) OR (type EQ FDN)) { phb_ctb[ADN_FDN].used_rcd--; } /* Update record bitmap */ n = (UBYTE)rec_num/8; m = rec_num%8; phb_ctb[type].rcd_bitmap[n] ^= 0x01 << m; } #endif /* #ifndef TI_PS_FFS_PHB */