FreeCalypso > hg > fc-magnetite
diff src/aci2/mfw/mfw_ss.c @ 3:93999a60b835
src/aci2, src/condat2: import of g23m/condat source pieces from TCS211
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Mon, 26 Sep 2016 00:29:36 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/aci2/mfw/mfw_ss.c Mon Sep 26 00:29:36 2016 +0000 @@ -0,0 +1,2434 @@ +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) $Workfile:: mfw_ss.c $| +| $Author:: Vo $Revision:: 1 $| +| CREATED: 25.1.99 $Modtime:: 24.03.00 9:48 $| +| STATE : code | ++--------------------------------------------------------------------+ + + MODULE : MFW_SS + + PURPOSE : This modul contains the functions for supplementary management. + + + $History:: mfw_ss.c $ + + Dec 16, 2005 REF: OMAPS00053316 x0018858 + Description: E-Sample 2.58 compiler code crashes when accessing the Voicemail service in the Messages + Solution: Added a NULL Check for the USSD pointer that is being received. + + Jul 05, 2005 REF: CRR 22565 a0876501 + Description: IMEI display on handset through atd*#06# was swapped. + Solution: Byte swapping corrected for IMEI decoding. + + Mar 30, 2005 REF: CRR 29986 xpradipg + Description: Optimisation 1: Removal of unused variables and dynamically + allocate/ deallocate mbndata + Solution: unused variables are removed + + Apr 06 2005 REF: CRR 29989 xpradipg + Description: Optimisation 3: replace the static global data with dynamic + allocation / deallocation + Solution: The static global variables are dynamically allocated and + deallocated + + Aug 16, 2004 REF: CRR 24323 Deepa M.D + Bug:Clenup of sprintf used for tracing + Fix:Replace the char buf[]; sprintf (buf, "...", ...); TRACE_EVENT (buf); statements by TRACE_EVENT_PX + + Jul 15, 2004 REF: CRR 13873 xkundadu + Description: Make an incoming call, the end user pressing 0+send will + pick up the call. Instead, 0+send should reject the incoming + call. + Solution: Added the handling of 0/1/2 SEND for a waiting call. + Modified the ss_decode() function in the + mfw_ss.c file to search the sequential table in the case of + waiting call also. Made changes in mfw_cm.c file also + * + * ***************** Version 24 ***************** + * User: Vo Date: 24.03.00 Time: 10:18 + * Updated in $/GSM/Condat/MS/SRC/MFW + * Bug fix: result of IMEI + * New: notice PIN type of SS string for PIN change/PIN unblock + * + * ***************** Version 23 ***************** + * User: Vo Date: 10.01.00 Time: 16:09 + * Updated in $/GSM/Condat/MS/SRC/MFW + * new function ss_exit() + * + * ***************** Version 22 ***************** + * User: Vo Date: 10.01.00 Time: 13:32 + * Updated in $/GSM/Condat/MS/SRC/MFW + * + * ***************** Version 21 ***************** + * User: Ak Date: 10.01.00 Time: 13:14 + * Updated in $/GSM/Condat/MS/SRC/MFW + * + * ***************** Version 20 ***************** + * User: Ak Date: 21.10.99 Time: 11:56 + * Updated in $/GSM/Condat/MS/SRC/MFW + * Why: Improvement + * What: Passing of network basic service codes instead of GSM 2.30 + * codes for SS control string results and invocations + * + * ***************** Version 19 ***************** + * User: Ak Date: 29.09.99 Time: 8:37 + * Updated in $/GSM/DEV/MS/SRC/MFW + * Why: bug fix + * What: strcpy do not check a NULL pointer argument, corrected + * + * ***************** Version 18 ***************** + * User: Ak Date: 28.09.99 Time: 14:16 + * Updated in $/GSM/DEV/MS/SRC/MFW + * Why: bug fix + * What: strcpy do not check a NULL pointer argument, corrected + * + * ***************** Version 17 ***************** + * User: Es Date: 16.09.99 Time: 17:25 + * Updated in $/GSM/DEV/MS/SRC/MFW + * include SENSEI patch 13/09/99 + * two minor fixes + * + * ***************** Version 16 ***************** + * User: Vo Date: 12.09.99 Time: 14:16 + * Updated in $/GSM/DEV/MS/SRC/MFW + * New: USSD handle + * + * ***************** Version 15 ***************** + * User: Vo Date: 30.08.99 Time: 12:08 + * Updated in $/GSM/DEV/MS/SRC/MFW + * SS string for PIN unblock + * + * ***************** Version 14 ***************** + * User: Vo Date: 9.08.99 Time: 16:53 + * Updated in $/GSM/DEV/MS/SRC/MFW + * SS result from network + * present IMEI + * different handling of network password and PIN1/PIN2 password + * + * ***************** Version 13 ***************** + * User: Vo Date: 21.07.99 Time: 14:44 + * Updated in $/GSM/DEV/MS/SRC/MFW + * + * ***************** Version 12 ***************** + * User: Vo Date: 16.07.99 Time: 10:39 + * Updated in $/GSM/DEV/MS/SRC/MFW + * + * ***************** Version 11 ***************** + * User: Vo Date: 9.07.99 Time: 14:56 + * Updated in $/GSM/DEV/MS/SRC/MFW + * + * ***************** Version 1 ***************** + * User: Vo Date: 10.02.99 Time: 12:41 + * Created in $/GSM/DEV/MS/SRC/MFW + +*/ +#define ENTITY_MFW + +#include <string.h> +#include <stdio.h> +#include <stdlib.h> + +#if defined (NEW_FRAME) + +#include "typedefs.h" +#include "vsi.h" +#include "custom.h" +#include "gsm.h" + +#else + +#include "STDDEFS.H" +#include "custom.h" +#include "gsm.h" +#include "vsi.h" + +#endif + +#include "message.h" +#include "prim.h" +#include "aci_cmh.h" + +#include "cus_aci.h" +#include "ksd.h" +#include "prim.h" +#ifndef PCM_2_FFS +#include "pcm.h" +#else +#include "prim.h" +#include "Gsm.h" +#endif + + +#include "psa.h" +#include "psa_sim.h" + +#include "mfw_mfw.h" +#include "mfw_nm.h" +#include "mfw_sim.h" +#include "mfw_sima.h" +#include "mfw_nmi.h" +#include "mfw_simi.h" +#include "mfw_nma.h" +#include "mfw_phb.h" +#include "mfw_cm.h" +#include "mfw_cmi.h" +#include "mfw_ss.h" +#include "mfw_ssi.h" +#include "mfw_win.h" +#include "mfw_phbi.h" + +#include <string.h> + + +/*************** Variables ******************************************/ +// Mar 30, 2005 REF: CRR 29986 xpradipg +// remove unused variables +#ifndef FF_MMI_OPTIM +static T_MFW_SS_SUPORT ss_suport; +#endif +// Apr 06 2005 REF: CRR 29989 xpradipg +// This scope of the variable lies within a function hence it is made as local +#ifndef FF_MMI_OPTIM +static T_MFW_SS_NOTIFY notify; +#endif + +// Apr 06 2005 REF: CRR 29989 xpradipg +// The below static globals are dynamically allocated in rAT_PercentKSIR where +// the data is populated for the supplementary services response and +// deallocated once the ss_signal function is executed where in the contents +// are copied onto another variable +#ifdef FF_MMI_OPTIM +T_MFW_SS_CF_CNF *cf_cnf = NULL; +T_MFW_SS_CB_CNF *cb_cnf = NULL; +T_MFW_SS_CLI_CNF *cli_cnf = NULL; +T_MFW_SS_CW_CNF *cw_cnf = NULL; +T_MFW_SS_PW_CNF *pw_cnf = NULL; +T_MFW_IMEI *imei_info = NULL; +#else +static T_MFW_SS_CF_CNF cf_cnf; +static T_MFW_SS_CB_CNF cb_cnf; +static T_MFW_SS_CLI_CNF cli_cnf; +static T_MFW_SS_CW_CNF cw_cnf; +static T_MFW_SS_PW_CNF pw_cnf; +static T_MFW_SS_RES ss_res; +static T_MFW_IMEI imei_info; +#endif +static T_MFW_SS_USSD ussd_info; +// Mar 30, 2005 REF: CRR 29986 xpradipg +// remove unused variables +#ifndef FF_MMI_OPTIM +static U8 clip_status; +static U8 colp_status; +static U8 clir_status; +static U8 clir_prefix; +static U8 colr_status; +#endif +static U8 clck_flag; +static U8 pwd_flag; /* 1 for change PIN */ + + + +#define CF_LST_SIZE (sizeof(T_MFW_FEATURE) *MFW_MAX_FEAT_NR) +#define CB_LST_SIZE (sizeof(T_MFW_TELECOM) *MFW_MAX_TELE_NR) +#define CW_LST_SIZE (sizeof(T_MFW_SRV_GROUP)*MFW_MAX_SRV_NR) + +#define MAX_LST_BUF (MAXIMUM(MAXIMUM(CF_LST_SIZE,\ + CB_LST_SIZE),\ + CW_LST_SIZE)) + +#define LANG_RESET "*#0" /*mc, SPR 1111 beginning of language reset pseudo-SS string*/ +#define TTY_NEXTCALL_ON "*55#" /* SPR#1352 - SH - Pseudo-SS string to switch on TTY on next call */ +#define TTY_NEXTCALL_OFF "#55#" /* SPR#1352 - SH - Pseudo-SS string to switch off TTY on next call */ + +static ULONG ssLstBuf[MAX_LST_BUF/sizeof(ULONG)]; +EXTERN MfwHdr * current_mfw_elem; + +// July 09, 2005 REF : MMI-22565 - a0876501 +extern UBYTE cmhSS_getCdFromImei (T_ACI_IMEI* imei); + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_mfw_init | ++--------------------------------------------------------------------+ + + + PURPOSE : + +*/ + +void ss_mfw_init(void) +{ +// Mar 30, 2005 REF: CRR 29986 xpradipg +// remove reundant code since the values assigned here are never referenced + +#ifndef PCM_2_FFS + + #ifndef FF_MMI_OPTIM + EF_MSCAP mscap; + EF_MSSUP mssup; + EF_MSSET msset; + UBYTE version; + + /* Read the Mobile Capabilities from EEPROM */ + + if (pcm_ReadFile((UBYTE *)EF_MSCAP_ID, + SIZE_EF_MSCAP, + (UBYTE *)&mscap, + &version) EQ PCM_OK) + { + ss_suport.speech = (UBYTE)FldGet(mscap.chnMode,spchSupV1); + ss_suport.data = (UBYTE)FldGet(mscap.datCap1,datSup); + ss_suport.asyn = (UBYTE)FldGet(mscap.datCap1,AsySup); + ss_suport.syn = (UBYTE)FldGet(mscap.datCap1,NTSynSup); + } + + if (pcm_ReadFile((UBYTE *)EF_MSSUP_ID, + SIZE_EF_MSSUP, + (UBYTE *)&mssup, + &version) EQ PCM_OK) + { + ss_suport.aoc = (UBYTE)FldGet(mssup.feat1,AoC); + ss_suport.dtmf = (UBYTE)FldGet(mssup.feat1,DTMF); + ss_suport.cf = (UBYTE)FldGet(mssup.feat1,CF); + ss_suport.cb = (UBYTE)FldGet(mssup.feat1,CB); + ss_suport.ussd = (UBYTE)FldGet(mssup.feat1,USSD); + ss_suport.etc = (UBYTE)FldGet(mssup.feat1,ETC); + } + + if (pcm_ReadFile((UBYTE *)EF_MSSET_ID, + SIZE_EF_MSSET, + (UBYTE *)&msset, + &version) EQ PCM_OK) + { + ss_suport.clire = (UBYTE)FldGet(msset.misc,clir); + ss_suport.clipr = (UBYTE)FldGet(msset.misc,clip); + } +#endif +#endif + pwd_flag = 0; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_exit | ++--------------------------------------------------------------------+ + + + PURPOSE : + +*/ + +void ss_exit(void) +{ + TRACE_FUNCTION("ss_exit()"); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_create | ++--------------------------------------------------------------------+ + + + PURPOSE : create event for supplementary management + +*/ + +T_MFW_HND ss_create(T_MFW_HND hWin, T_MFW_EVENT event, T_MFW_CB cbfunc) +{ + T_MFW_HDR *hdr; + T_MFW_SS *ss_para; + MfwHdr * insert_status =0; + + TRACE_FUNCTION("ss_create()"); + + hdr = (T_MFW_HDR *) mfwAlloc(sizeof (T_MFW_HDR)); + ss_para = (T_MFW_SS *) mfwAlloc(sizeof (T_MFW_SS)); + + if (!hdr OR !ss_para) + { + TRACE_ERROR("ERROR: ss_create() Mem Alloc Failed."); + + if(hdr) + mfwFree((U8*)hdr,sizeof(MfwHdr)); + + if(ss_para) + mfwFree((U8*)ss_para,sizeof(T_MFW_SS)); + + return FALSE; + } + + /* + * initialisation of the handler + */ + ss_para->emask = event; + ss_para->handler = cbfunc; + + hdr->data = ss_para; /* store parameter in node */ + hdr->type = MFW_TYP_SS; /* store type of event handler */ + + /* + * installation of the handler + */ + insert_status = mfwInsert((T_MFW_HDR *)hWin, hdr); + + if(!insert_status) + { + TRACE_ERROR("ERROR: ss_create() Failed to Install Handler. "); + mfwFree((U8*)hdr,sizeof(MfwHdr)); + mfwFree((U8*)ss_para,sizeof(T_MFW_SS)); + return 0; + } + return insert_status; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_delete | ++--------------------------------------------------------------------+ + + + PURPOSE : delete a event for supplementary management + +*/ + +T_MFW_RES ss_delete(T_MFW_HND h) +{ + TRACE_FUNCTION("ss_delete()"); + + if (!h OR !((T_MFW_HDR *)h)->data) + return MFW_RES_ILL_HND; + + if (!mfwRemove((T_MFW_HDR *)h)) + return MFW_RES_ILL_HND; + + mfwFree((U8 *)(((T_MFW_HDR *) h)->data),sizeof(T_MFW_SS)); + mfwFree((U8 *)h,sizeof(T_MFW_HDR)); + + return MFW_RES_OK; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_sign_exec | ++--------------------------------------------------------------------+ + + + PURPOSE : Send a signal if SS management handler. + +*/ + +BOOL ss_sign_exec (T_MFW_HDR * cur_elem, T_MFW_EVENT event, T_MFW_SS_PARA * para) +{ + TRACE_FUNCTION ("ss_sign_exec()"); + + while (cur_elem) + { + /* + * event handler is available + */ + if (cur_elem->type EQ MFW_TYP_SS) + { + T_MFW_SS * ss_data; + /* + * handler is SS management handler + */ + ss_data = (T_MFW_SS *)cur_elem->data; + if (ss_data->emask & event) + { + /* + * event is expected by the call back function + */ + ss_data->event = event; + switch (event) + { + case E_SS_NOTIFY: + memcpy (&ss_data->para.notify, para, sizeof (T_MFW_SS_NOTIFY)); + break; + + case E_SS_CF_CNF: + case E_SS_CF_ICN_UPD: + memcpy (&ss_data->para.cf_cnf, para, sizeof (T_MFW_SS_CF_CNF)); + break; + + case E_SS_CB_CNF: + memcpy (&ss_data->para.cb_cnf, para, sizeof (T_MFW_SS_CB_CNF)); + break; + + case E_SS_CW_CNF: + memcpy (&ss_data->para.cw_cnf, para, sizeof (T_MFW_SS_CW_CNF)); + break; + + case E_SS_CLI_CNF: + memcpy (&ss_data->para.cli_cnf, para, sizeof (T_MFW_SS_CLI_CNF)); + break; + + case E_SS_RES: + memcpy (&ss_data->para.ss_res, para, sizeof (T_MFW_SS_RES)); + break; + + case E_SS_GET_PW: + memcpy (&ss_data->para.pw_cnf, para, sizeof (T_MFW_SS_PW_CNF)); + break; + + case E_SS_IMEI: + memcpy (&ss_data->para.imei_info, para, sizeof (T_MFW_IMEI)); + break; + + case E_SS_USSD_REQ: + memcpy (&ss_data->para.ussd_info, para, sizeof (T_MFW_SS_USSD)); + break; + + case E_SS_USSD_CNF: + memcpy (&ss_data->para.ussd_info, para, sizeof (T_MFW_SS_USSD)); + break; + } + + /* + * if call back defined, call it + */ + if (ss_data->handler) + { + // PATCH LE 06.06.00 + // store current mfw elem + current_mfw_elem = cur_elem; + // END PATCH LE 06.06.00 + + if ((*(ss_data->handler)) (ss_data->event, (void *)&ss_data->para)) + return TRUE; + } + } + } + cur_elem = cur_elem->next; + } + return FALSE; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_signal | ++--------------------------------------------------------------------+ + + PURPOSE : send a event signal. + +*/ + +void ss_signal(T_MFW_EVENT event, void * para) +{ + UBYTE temp; + TRACE_FUNCTION ("ss_signal()"); + +temp = dspl_Enable(0); +if (mfwSignallingMethod EQ 0) + { + /* + * focus is on a window + */ + if (mfwFocus) + /* + * send event to sim management + * handler if available + */ + if (ss_sign_exec (mfwFocus, event, para)) + { + dspl_Enable(temp); + return; + } + + /* + * acutal focussed window is not available + * or has no network management registration + * handler, then search all nodes from the root. + */ + if (mfwRoot) + ss_sign_exec (mfwRoot, event, para); + } + else + { + MfwHdr * h = 0; + + /* + * Focus set, then start here + */ + if (mfwFocus) + h = mfwFocus; + /* + * Focus not set, then start root + */ + if (!h) + h = mfwRoot; + + /* + * No elements available, return + */ + + while (h) + + + { + /* + * Signal consumed, then return + */ + if (ss_sign_exec (h, event, para)) + { + dspl_Enable(temp); + return; + } + + /* + * All windows tried inclusive root + */ + if (h == mfwRoot) + { + dspl_Enable(temp); + return; + } + /* + * get parent window + */ + h = mfwParent(mfwParent(h)); + if(h) + h = ((MfwWin * )(h->data))->elems; + } + ss_sign_exec (mfwRoot, event, para); + } + dspl_Enable(temp); +} + + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_check_ss_string | ++--------------------------------------------------------------------+ + + + PURPOSE : Check SS string + +*/ + +T_MFW_SS_RETURN ss_check_ss_string(UBYTE *string) +{ + T_MFW_SS_RETURN ss_group; + T_KSD_SEQGRP grp; + CHAR *rest; + T_KSD_SEQPARAM para; + SHORT id; + int string_length; + UBYTE call_active=FALSE; + + TRACE_FUNCTION("ss_check_ss_string"); + + #define MFW_MAX_DIAL_SHORT_STRING_LEN 2 + + /* check the type of destination address */ + if ((cm_search_callId(CAL_STAT_Held, &id) == CM_OK) + OR (cm_search_callId(CAL_STAT_Active, &id) == CM_OK)) + { + call_active = TRUE; + ksd_decode((CHAR *)string, TRUE, &grp, &rest, ¶); + } + else + ksd_decode((CHAR *)string, FALSE, &grp, &rest, ¶); + + /* check short string */ + + string_length = strlen((char*)string); + + TRACE_EVENT_P2("ksd_decode(""%s"") returns -> %d",(char*)string,grp); + + + switch (grp) + { + case (SEQGRP_DIAL): /*JVJ CQ 6242 */ + if (string_length<=MFW_MAX_DIAL_SHORT_STRING_LEN) + { + /* If the call is active, the short string will be USSD in all the cases not described in ETSI 2.30*/ + if (call_active) + grp = SEQGRP_USSD; + /* If the call is not active, the short strings 1x will be DIAL, the rest USSD*/ + else if ((string_length EQ 1)||(*(string) NEQ '1')) + grp = SEQGRP_USSD; + } + break; + case (SEQGRP_SUP_CLIR): /* JGG/JVJ - CQ 6537 */ + case (SEQGRP_INV_CLIR): + if (strlen(rest)!=0) + { + T_MFW_SS_RETURN rest_ss_group; + + /*check to make sure that the number is a real dial string */ + rest_ss_group = ss_check_ss_string((UBYTE*)rest); + if (rest_ss_group EQ MFW_SS_DIAL) /*If rest is a dial string, then the whole string is dial */ + ss_group = MFW_SS_DIAL; + else + ss_group = MFW_SS_UNKNOWN; + + TRACE_EVENT_P2("ss_check_ss_string(""%s"") returns -> %d",(char*)string,ss_group); + return ss_group; + } + break; + default: + break; + } + + ss_group = ss_check_group(grp, para); + + TRACE_EVENT_P2("ss_check_ss_string(""%s"") returns -> %d",(char*)string,ss_group); + + return ss_group; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_decode | ++--------------------------------------------------------------------+ + + + PURPOSE : Decode SS string + +*/ + +T_MFW_SS_RETURN ss_decode(UBYTE *string, CHAR **rt, T_KSD_SEQPARAM *p) +{ + T_KSD_SEQGRP grp; + CHAR *rest; + T_KSD_SEQPARAM para; + SHORT id; + BOOL bRetVal; + + TRACE_FUNCTION("ss_decode()"); + +// Added the checking of wait call to solve the bug MMI-SPR 13873. +// If the call is a waiting also pass TRUE as the second parameter to the +// function ksd_decode() to decode the entered number. In ksd_decode only if +// the second parameter is TRUE the sequential table is searched to find out +// the group where the user entered string belongs to. + if ((cm_search_callId(CAL_STAT_Held, &id) == CM_OK) + OR (cm_search_callId(CAL_STAT_Active, &id) == CM_OK) + OR (cm_search_callId(CAL_STAT_Wait, &id) == CM_OK)) + { + bRetVal = ksd_decode((CHAR *)string, TRUE, &grp, &rest, ¶); + if (!bRetVal) + *rest = 0; + } + else + { + bRetVal = ksd_decode((CHAR *)string, FALSE, &grp, &rest, ¶); + if (!bRetVal) + *rest = 0; + } + + if (!bRetVal) + return MFW_SS_FAIL; + + *rt = rest; + + if (grp == SEQGRP_UNKNOWN) + return MFW_SS_UNKNOWN; + + memcpy(p, ¶, sizeof(T_KSD_SEQPARAM)); + return(ss_check_group(grp, para)); +} + + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_check_group | ++--------------------------------------------------------------------+ + + + PURPOSE : returns the group of SS string + +*/ + +T_MFW_SS_RETURN ss_check_group(T_KSD_SEQGRP grp, T_KSD_SEQPARAM para) +{ + TRACE_EVENT_P1("ss_check_group: grp=%d", grp); + + switch (grp) + { + case SEQGRP_DIAL: + /*SPR#1352 - SH - Check for TTY On Next Call psuedo-ss strings*/ + if (!strncmp((char*)para.ussd.ussd, TTY_NEXTCALL_ON, strlen(TTY_NEXTCALL_ON))) + return MFW_SS_TTY_NEXTCALL_ON; + if (!strncmp((char*)para.ussd.ussd, TTY_NEXTCALL_OFF, strlen(TTY_NEXTCALL_OFF))) + return MFW_SS_TTY_NEXTCALL_OFF; + /*SH end*/ + return MFW_SS_DIAL; + + case SEQGRP_DIAL_IDX: + return MFW_SS_DIAL_IDX; + + case SEQGRP_DTMF: + return MFW_SS_DTMF; + + case SEQGRP_USSD: + /*MC, SPR 1111 check for LANGUAGE reset code*/ + + if (!strncmp((char*)para.ussd.ussd, LANG_RESET, strlen(LANG_RESET)) && para.ussd.ussd[6]=='#') + return MFW_SS_LANG_RESET; + /*MC end*/ + return MFW_SS_USSD; + + case SEQGRP_ACT_SIM_LOCK: /* lock SIM card */ + case SEQGRP_DEACT_SIM_LOCK: /* unlock SIM card */ + case SEQGRP_INTRGT_SIM_LOCK: + return MFW_SS_SIM_LOCK; + + case SEQGRP_CHANGE_REGISTER: + case SEQGRP_SET_REGISTER: + case SEQGRP_START_REGISTER: + return MFW_SS_REG_PW; + + case SEQGRP_CF: + return MFW_SS_CF; + + case SEQGRP_CB: /* barring services */ + return MFW_SS_CB; + + case SEQGRP_SUP_CLIR: + case SEQGRP_INV_CLIR: + return MFW_SS_CLIR; + + case SEQGRP_SUP_CLIP: + case SEQGRP_INV_CLIP: + return MFW_SS_CLIP; + + case SEQGRP_SUP_COLR: + case SEQGRP_INV_COLR: + return MFW_SS_COLR; + + case SEQGRP_SUP_COLP: + case SEQGRP_INV_COLP: + return MFW_SS_COLP; + + case SEQGRP_CL: + switch (para.cl.ssCd) + { + case KSD_SS_CLIP: + return MFW_SS_CLIP; + case KSD_SS_CLIR: + return MFW_SS_CLIR; + case KSD_SS_COLP: + return MFW_SS_COLP; + case KSD_SS_COLR: + return MFW_SS_COLR; + } + return MFW_SS_UNKNOWN; + + case SEQGRP_PWD: + switch(para.pwd.ssCd) + { +/* case KSD_SS_CCBS: CCBS has nothing to do with PWD! */ + case KSD_SS_ALL_CBSS: + case KSD_SS_BOC: + case KSD_SS_BAOC: + case KSD_SS_BOIC: + case KSD_SS_BOICXH: + case KSD_SS_BIC: + case KSD_SS_BAIC: + case KSD_SS_BICRM: + + /*NM 190602*/ + case KSD_SS_ALL_SERV: + + return MFW_SS_REG_PW; + + case KSD_SS_PIN1: + case KSD_SS_PIN2: + return MFW_SS_SIM_REG_PW; + } + return MFW_SS_UNKNOWN; + + case SEQGRP_UBLK: + return MFW_SS_SIM_UNBLCK_PIN; + + case SEQGRP_CW: + return MFW_SS_WAIT; + + case SEQGRP_CCBS: + return MFW_SS_CCBS; + + case SEQGRP_PRSNT_IMEI: + return MFW_SS_MMI; + + case SEQGRP_CHLD: + /*MC 11.04.02 */ + if (para.chld.mode == CHLD_MOD_Ect) + return MFW_SS_ECT; + else if (para.chld.mode == CHLD_MOD_Ccbs) + return MFW_SS_CCBS; + else + /*MC*/ + return MFW_SS_HOLD; + + case SEQGRP_UNKNOWN: + return MFW_SS_UNKNOWN; + + default: + return MFW_SS_UNKNOWN; + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : ss_execute_transaction | ++-------------------------------------------------------------------+ + + PURPOSE : Start a SS transaction + +*/ + +T_MFW_SS_RETURN ss_execute_transaction(UBYTE *ss_string, + UBYTE ussd_mand) +{ + T_ACI_RETURN res; + + TRACE_FUNCTION("ss_execute_transaction()"); + + res = sAT_Dn(CMD_SRC_LCL, (CHAR *)ss_string, -1, -1, -1); + if( (res != AT_EXCT) AND (res != AT_CMPL)) + { + TRACE_EVENT("sAT_D error"); + return MFW_SS_FAIL; + } + + return ss_check_ss_string(ss_string); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_cvtCssuCodes | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the CSSU mode + used by ACI to the CSSU mode used by MFW. + +*/ + +T_MFW_SS_NOTIFY_CODES ss_cvtCssuCodes(T_ACI_CSSU_CODE code) +{ + switch (code) + { + case CSSU_CODE_ForwardedCall: return MFW_SS_MT_FORWARDED; + case CSSU_CODE_CUGCall: return MFW_SS_MT_CUG_CALL; + case CSSU_CODE_Multiparty: return MFW_SS_NOTIFY_MULTIPARTY; + case CSSU_CODE_HeldCallRel: return MFW_SS_NOTIFY_holdRELEASED; + case CSSU_CODE_FwrdCheckSS: return MFW_SS_NOTIFY_checkSS; + case CSSU_CODE_ECTAlert: return MFW_SS_NOTIFY_ectALERT; + case CSSU_CODE_ECTConnect: return MFW_SS_NOTIFY_ectCONNECT; + case CSSU_CODE_DeflectedCall: return MFW_SS_MT_DEFLECTED; + default: return MFW_SS_NOTIFY_UNKNOWN; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_cvtCssiCodes | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the CSSI mode + used by ACI to the CSSI mode used by MFW. + +*/ + +T_MFW_SS_NOTIFY_CODES ss_cvtCssiCodes(T_ACI_CSSI_CODE code) +{ + switch (code) + { + case CSSI_CODE_CFUActive: return MFW_SS_MO_unconFORWARD; + case CSSI_CODE_SomeCCFActive: return MFW_SS_MO_conFORWARD; + case CSSI_CODE_ForwardedCall: return MFW_SS_MO_FORWARDED; + case CSSI_CODE_CallWaiting: return MFW_SS_MO_WAITING; + case CSSI_CODE_CUGCall: return MFW_SS_MO_CUG_CALL; + case CSSI_CODE_OutCallsBarred: return MFW_SS_MO_moBARRED; + case CSSI_CODE_IncCallsBarred: return MFW_SS_MO_mtBARRED; + case CSSI_CODE_CLIRSupRej: return MFW_SS_MO_CLIR; + case CSSI_CODE_DeflectedCall: return MFW_SS_MO_DEFLECTED; + default: return MFW_SS_NOTIFY_UNKNOWN; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_notify | ++--------------------------------------------------------------------+ + + + PURPOSE : Change of SS status from the network. + +*/ + +void ss_notify(T_MFW_SS_NOTIFY_CODES code, + SHORT index, + UBYTE *number, + UBYTE *subaddr) +{ +// Apr 06 2005 REF: CRR 29989 xpradipg +// defined the variable locally since the scope lies within this function +#ifdef FF_MMI_OPTIM + T_MFW_SS_NOTIFY notify; +#endif + memset(¬ify, 0, sizeof(T_MFW_SS_NOTIFY)); + + notify.code = code; + + if(number) + strcpy((char *)notify.number, (char *)number); + if (subaddr) + strcpy((char *)notify.subaddr, (char *)subaddr); + + //PATCH TB 1309: Wrong codes tested + if ((code == MFW_SS_MO_CUG_CALL) OR + (code == MFW_SS_MT_CUG_CALL)) + notify.index = (UBYTE)index; + /* END PATCH TB */ + + { + /***************************Go-lite Optimization changes Start***********************/ + //Aug 16, 2004 REF: CRR 24323 Deepa M.D + TRACE_EVENT_P1 ("SS notify code = %d", notify.code); + /***************************Go-lite Optimization changes end***********************/ + } + + ss_signal(E_SS_NOTIFY, ¬ify); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : ss_cvtOCode | ++--------------------------------------------------------------------+ + + + PURPOSE : Convert operation codes + +*/ + +T_MFW ss_cvtOCode(T_ACI_KSD_OP code) +{ + switch (code) + { + case KSD_OP_IRGT: return SS_INTERROGATION; + case KSD_OP_REG: return SS_REGISTRATION; + case KSD_OP_ERS: return SS_ERASURE; + case KSD_OP_ACT: return SS_ACTIVATION; + case KSD_OP_DEACT: return SS_DEACTIVATION; + default: return SS_CODES_UNKNOWN; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : ss_cvtSCodes | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the SS code + used by ACI to the SS code used by MFW. + +*/ + +T_MFW ss_cvtSCode(T_ACI_KSD_SS code) +{ + switch (code) + { + case KSD_SS_CLIP: return SS_CLIP; + case KSD_SS_CLIR: return SS_CLIR; + case KSD_SS_COLP: return SS_COLP; + case KSD_SS_COLR: return SS_COLR; + case KSD_SS_CW: return SS_CW; + case KSD_SS_BAIC: return SS_CB_BAIC; + case KSD_SS_BAOC: return SS_CB_BAOC; + case KSD_SS_ALL_CBSS: return SS_CB_ALL; + case KSD_SS_BICRM: return SS_CB_BAICroam; + case KSD_SS_BIC: return SS_CB_ALL_BAIC; + case KSD_SS_BOICXH: return SS_CB_BAOICexH; + case KSD_SS_BOIC: return SS_CB_BAOIC; + case KSD_SS_BOC: return SS_CB_ALL_BAOC; + case KSD_SS_CFB: return SS_CF_CFB; + case KSD_SS_CFNRC: return SS_CF_CFNR; + case KSD_SS_CFNRY: return SS_CF_CFNRy; + case KSD_SS_CFU: return SS_CF_CFU; + case KSD_SS_ALL_CFWSS: return SS_CF_ALL_COND; + case KSD_SS_ALL_FWSS: return SS_CF_ALL; + case KSD_SS_CCBS: return SS_CCBS; + case KSD_SS_PIN1: return SS_PIN1; + case KSD_SS_PIN2: return SS_PIN2; + default: return SS_CODES_UNKNOWN; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : ss_cvtCLStatus | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the CL status + used by ACI to the CL status used by MFW. + +*/ + +T_MFW ss_cvtCLStatus(T_ACI_KSD_CLIR_OP stat) +{ + switch (stat) + { + case KSD_CO_PERMANENT: return MFW_CL_PERM; + case KSD_CO_TEMPORARY: return MFW_CL_TEMP_DEF_REST; + case KSD_CO_ALLOWED: return MFW_CL_TEMP_DEF_ALLOWED; + default: return MFW_CL_UNKNOWN; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : ss_cvtCLOvrd | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the override status of + CLIR used by ACI to the override status of CLIR used by + MFW. + +*/ + +T_MFW ss_cvtCLOvrd(T_ACI_KSD_OVRD_CTG ovrd) +{ + switch (ovrd) + { + case KSD_OVR_CAT_ENABLED: return MFW_OV_ENABLED; + case KSD_OVR_CAT_DISABLED: return MFW_OV_DISABLED; + default: return MFW_OV_UNKNOWN; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : ss_cvtErrCode | ++--------------------------------------------------------------------+ + + + PURPOSE : This function is used to convert the error code used + by ACI to the error code used by MFW. + +*/ + +T_MFW ss_cvtErrCode(T_ACI_KSD_ERR err) +{ + switch (err) + { + case KSD_NO_ERROR: return MFW_SS_NO_ERROR; + case KSD_ERR_UNKNOWN_SUBSCRIBER: return MFW_SS_ERR_UNKNOWN_SUBSCRIBER; + case KSD_ERR_ILLEGAL_SUBSCRIBER: return MFW_SS_ERR_ILLEGAL_SUBSCRIBER; + case KSD_ERR_BEARER_SVC_NOT_PROV: return MFW_SS_ERR_BEARER_SVC_NOT_PROV; + case KSD_ERR_TELE_SVC_NOT_PROV: return MFW_SS_ERR_TELE_SVC_NOT_PROV; + case KSD_ERR_ILLEGAL_EQUIPMENT: return MFW_SS_ERR_ILLEGAL_EQUIPMENT; + case KSD_ERR_CALL_BARRED: return MFW_SS_ERR_CALL_BARRED; + case KSD_ERR_ILLEGAL_SS_OPERATION: return MFW_SS_ERR_ILLEGAL_SS_OPERATION; + case KSD_ERR_SS_ERR_STATUS: return MFW_SS_ERR_SS_ERR_STATUS; + case KSD_ERR_SS_NOT_AVAIL: return MFW_SS_ERR_SS_NOT_AVAIL; + case KSD_ERR_SS_SUBS_VIOLATION: return MFW_SS_ERR_SS_SUBS_VIOLATION; + case KSD_ERR_SS_INCOMP: return MFW_SS_ERR_SS_INCOMP; + case KSD_ERR_FAC_NOT_SUPPORTED: return MFW_SS_ERR_FAC_NOT_SUPPORTED; + case KSD_ERR_ABSENT_SUBS: return MFW_SS_ERR_ABSENT_SUBS; + case KSD_ERR_SYSTEM_FAIL: return MFW_SS_ERR_SYSTEM_FAIL; + case KSD_ERR_DATA_MISSING: return MFW_SS_ERR_DATA_MISSING; + case KSD_ERR_UNEXPECT_DATA: return MFW_SS_ERR_UNEXPECT_DATA; + case KSD_ERR_PWD_REG_FAIL: return MFW_SS_ERR_PWD_REG_FAIL; + case KSD_ERR_NEG_PWD_CHECK: return MFW_SS_ERR_NEG_PWD_CHECK; + case KSD_ERR_NUM_PWD_VIOLATION: return MFW_SS_ERR_NUM_PWD_VIOLATION; + case KSD_ERR_UNKNOWN_ALPHA: return MFW_SS_ERR_UNKNOWN_ALPHA; + case KSD_ERR_USSD_BUSY: return MFW_SS_ERR_USSD_BUSY; + case KSD_ERR_MAX_NUM_MPTY_EXCEED: return MFW_SS_ERR_MAX_NUM_MPTY_EXCEED; + case KSD_ERR_RESOURCE_NOT_AVAIL: return MFW_SS_ERR_RESOURCE_NOT_AVAIL; + case KSD_GEN_PROB_UNRECOG_CMP: return MFW_SS_GEN_PROB_UNRECOG_CMP; + case KSD_GEN_PROB_MISTYPED_CMP: return MFW_SS_GEN_PROB_MISTYPED_CMP; + case KSD_GEN_PROB_BAD_STRUCT_CMP: return MFW_SS_GEN_PROB_BAD_STRUCT_CMP; + case KSD_INV_PROB_DUPL_INV_ID: return MFW_SS_INV_PROB_DUPL_INV_ID; + case KSD_INV_PROB_UNRECOG_OP: return MFW_SS_INV_PROB_UNRECOG_OP; + case KSD_INV_PROB_MISTYPED_PAR: return MFW_SS_INV_PROB_MISTYPED_PAR; + case KSD_INV_PROB_RESOURCE_LIM: return MFW_SS_INV_PROB_RESOURCE_LIM; + case KSD_INV_PROB_INIT_RELEASE: return MFW_SS_INV_PROB_INIT_RELEASE; + case KSD_INV_PROB_UNRECOG_LNK_ID: return MFW_SS_INV_PROB_UNRECOG_LNK_ID; + case KSD_INV_PROB_LNK_RES_UNEXP: return MFW_SS_INV_PROB_LNK_RES_UNEXP; + case KSD_INV_PROB_UNEXP_LNK_OP: return MFW_SS_INV_PROB_UNEXP_LNK_OP; + case KSD_RES_PROB_UNRECOG_INV_ID: return MFW_SS_RES_PROB_UNRECOG_INV_ID; + case KSD_RES_PROB_RET_RES_UNEXP: return MFW_SS_RES_PROB_RET_RES_UNEXP; + case KSD_RES_PROB_MISTYPED_PAR: return MFW_SS_RES_PROB_MISTYPED_PAR; + case KSD_ERR_PROB_UNRECOG_INV_ID: return MFW_SS_ERR_PROB_UNRECOG_INV_ID; + case KSD_ERR_PROB_RET_ERR_UNEXP: return MFW_SS_ERR_PROB_RET_ERR_UNEXP; + case KSD_ERR_PROB_UNRECOG_ERR: return MFW_SS_ERR_PROB_UNRECOG_ERR; + case KSD_ERR_PROB_UNEXP_ERR: return MFW_SS_ERR_PROB_UNEXP_ERR; + case KSD_ERR_PROB_MISTYPED_PAR: return MFW_SS_ERR_PROB_MISTYPED_PAR; + case KSD_ERR_FATAL_INV_RESULT: return MFW_SS_ERR_FATAL_INV_RESULT; + case KSD_ERR_FATAL_CCD_DEC: return MFW_SS_ERR_FATAL_CCD_DEC; + case KSD_ERR_FATAL_SS_ENT: return MFW_SS_ERR_FATAL_SS_ENT; + default: return MFW_SS_ERR_UNKNOWN; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : ss_decode_imei | ++--------------------------------------------------------------------+ + + + PURPOSE : convert imei (packed bcd to ASCII) + +*/ + +void ss_decode_imei(T_ACI_KSIR *ksStat) +{ +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + memset(imei_info, 0, sizeof(T_MFW_IMEI)); + + imei_info->imei_number[0] = ( ksStat->ir.rKSIMEI.tac1 & 0xF0 ) >> 4 | 0x30; + imei_info->imei_number[1] = ( ksStat->ir.rKSIMEI.tac1 ) & 0x0F | 0x30; + imei_info->imei_number[2] = ( ksStat->ir.rKSIMEI.tac2 & 0xF0 ) >> 4 | 0x30; + imei_info->imei_number[3] = ( ksStat->ir.rKSIMEI.tac2 ) & 0x0F | 0x30; + imei_info->imei_number[4] = ( ksStat->ir.rKSIMEI.tac3 & 0xF0 ) >> 4 | 0x30; + imei_info->imei_number[5] = ( ksStat->ir.rKSIMEI.tac3 ) & 0x0F | 0x30; + imei_info->imei_number[6] = ( ksStat->ir.rKSIMEI.fac & 0xF0 ) >> 4 | 0x30; + imei_info->imei_number[7] = ( ksStat->ir.rKSIMEI.fac ) & 0x0F | 0x30; + imei_info->imei_number[8] = ( ksStat->ir.rKSIMEI.snr1 & 0xF0 ) >> 4 | 0x30; + imei_info->imei_number[9] = ( ksStat->ir.rKSIMEI.snr1 ) & 0x0F | 0x30; + imei_info->imei_number[10] = ( ksStat->ir.rKSIMEI.snr2 & 0xF0 ) >> 4 | 0x30; + imei_info->imei_number[11] = ( ksStat->ir.rKSIMEI.snr2 ) & 0x0F | 0x30; + imei_info->imei_number[12] = ( ksStat->ir.rKSIMEI.snr3 & 0xF0 ) >> 4 | 0x30; + imei_info->imei_number[13] = ( ksStat->ir.rKSIMEI.snr3 ) & 0x0F | 0x30; +//a0876501 - Check byte comes before the Software version during display. + imei_info->imei_number[14] = ( ksStat->ir.rKSIMEI.cd & 0x0F ) | 0x30; + imei_info->imei_number[15] = ( ksStat->ir.rKSIMEI.svn & 0xF0 ) >> 4 | 0x30; + imei_info->imei_number[16] = ( ksStat->ir.rKSIMEI.svn ) & 0x0F | 0x30; + imei_info->imei_number[17] = '\0'; +#else + memset(&imei_info, 0, sizeof(imei_info)); +// Jul 05 2005 REF: CRR 22565 a0876501 +// Fixed the issue of byte swapping. + + imei_info.imei_number[0] = ( ksStat->ir.rKSIMEI.tac1 & 0xF0 ) >> 4 | 0x30; + imei_info.imei_number[1] = ( ksStat->ir.rKSIMEI.tac1 ) & 0x0F | 0x30; + imei_info.imei_number[2] = ( ksStat->ir.rKSIMEI.tac2 & 0xF0 ) >> 4 | 0x30; + imei_info.imei_number[3] = ( ksStat->ir.rKSIMEI.tac2 ) & 0x0F | 0x30; + imei_info.imei_number[4] = ( ksStat->ir.rKSIMEI.tac3 & 0xF0 ) >> 4 | 0x30; + imei_info.imei_number[5] = ( ksStat->ir.rKSIMEI.tac3 ) & 0x0F | 0x30; + imei_info.imei_number[6] = ( ksStat->ir.rKSIMEI.fac & 0xF0 ) >> 4 | 0x30; + imei_info.imei_number[7] = ( ksStat->ir.rKSIMEI.fac ) & 0x0F | 0x30; + imei_info.imei_number[8] = ( ksStat->ir.rKSIMEI.snr1 & 0xF0 ) >> 4 | 0x30; + imei_info.imei_number[9] = ( ksStat->ir.rKSIMEI.snr1 ) & 0x0F | 0x30; + imei_info.imei_number[10] = ( ksStat->ir.rKSIMEI.snr2 & 0xF0 ) >> 4 | 0x30; + imei_info.imei_number[11] = ( ksStat->ir.rKSIMEI.snr2 ) & 0x0F | 0x30; + imei_info.imei_number[12] = ( ksStat->ir.rKSIMEI.snr3 & 0xF0 ) >> 4 | 0x30; + imei_info.imei_number[13] = ( ksStat->ir.rKSIMEI.snr3 ) & 0x0F | 0x30; +//a0876501 - Check byte comes before the Software version during display. + imei_info.imei_number[14] = ( ksStat->ir.rKSIMEI.cd & 0x0F ) | 0x30; + imei_info.imei_number[15] = ( ksStat->ir.rKSIMEI.svn & 0xF0 ) >> 4 | 0x30; + imei_info.imei_number[16] = ( ksStat->ir.rKSIMEI.svn ) & 0x0F | 0x30; + imei_info.imei_number[17] = '\0'; + + TRACE_EVENT_P8("ss_decode_imei IMEI: TAC %1c%1c%1c%1c%1c%1c%1c%1c", + imei_info.imei_number[0], imei_info.imei_number[1], imei_info.imei_number[2], imei_info.imei_number[3], + imei_info.imei_number[4], imei_info.imei_number[5], imei_info.imei_number[6], imei_info.imei_number[7]); + TRACE_EVENT_P6("ss_decode_imei IMEI: SNR %1c%1c%1c%1c%1c%1c", + imei_info.imei_number[8], imei_info.imei_number[9], imei_info.imei_number[10], imei_info.imei_number[11], + imei_info.imei_number[12], imei_info.imei_number[13]); + TRACE_EVENT_P4("ss_decode_imei IMEI: SV CD %1c%1c%1c%1c", + imei_info.imei_number[14], imei_info.imei_number[15], imei_info.imei_number[16],imei_info.imei_number[17]); + +#endif +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : getCdByteFromImei | ++--------------------------------------------------------------------+ + + + PURPOSE : Get CD byte from IMEI. +// July 23, 2005 REF : MMI-22565 - a0876501 +*/ + +UBYTE getCdByteFromImei(UBYTE *imei) +{ + T_ACI_IMEI aci_imei; + +// July 23, 2005 REF : MMI-22565 - a0876501 +// For calculating the Cd byte, copy the buffer contents. + aci_imei.tac1 = imei[0]; + aci_imei.tac2 = imei[1]; + aci_imei.tac3 = imei[2]; + aci_imei.fac = imei[3]; + aci_imei.snr1 = imei[4]; + aci_imei.snr2 = imei[5]; + aci_imei.snr3 = imei[6]; + aci_imei.svn = imei[7]; +#ifndef NEPTUNE_BOARD + + return(cmhSS_getCdFromImei(&aci_imei)); + +#endif + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: rAT_PercentKSIR | ++--------------------------------------------------------------------+ + + + PURPOSE : Network response for key sequences + +*/ + +void rAT_PercentKSIR ( T_ACI_KSIR *ksStat) +{ + UBYTE idx; + T_MFW_TELECOM *p_tele; + T_MFW_FEATURE *p_feat; + T_MFW_SRV_GROUP *p_srv; + + TRACE_FUNCTION("rAT_PercentKSIR()"); + TRACE_EVENT_P1("ksStat->ksdCmd %d", ksStat->ksdCmd); + + switch (ksStat->ksdCmd) + { + case KSD_CMD_CB: + TRACE_EVENT("KSD_CMD_CB"); + TRACE_EVENT_P1("ksStat->ir.rKSCB.ssCd %d", ksStat->ir.rKSCB.ssCd); + TRACE_EVENT_P1("ksStat->ir.rKSCB.opCd %d", ksStat->ir.rKSCB.opCd); + TRACE_EVENT_P1("ksStat->ir.rKSCB.ssErr %d", ksStat->ir.rKSCB.ssErr); + TRACE_EVENT_P1("ksStat->ir.rKSCB.c_cbInfoLst %d", ksStat->ir.rKSCB.c_cbInfoLst); + if (ksStat->ir.rKSCB.c_cbInfoLst) + { + int i; + for (i = 0; i < ksStat->ir.rKSCB.c_cbInfoLst; i++) + { + TRACE_EVENT_P2("ksStat->ir.rKSCB.cbInfoLst[%d].bsTp %d", i, ksStat->ir.rKSCB.cbInfoLst[i].bsTp); + TRACE_EVENT_P2("ksStat->ir.rKSCB.cbInfoLst[%d].bsCd %d", i, ksStat->ir.rKSCB.cbInfoLst[i].bsCd); + TRACE_EVENT_P2("ksStat->ir.rKSCB.cbInfoLst[%d].ssSt %d", i, ksStat->ir.rKSCB.cbInfoLst[i].ssSt); + } + } + p_tele = (T_MFW_TELECOM *) ssLstBuf; +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + cb_cnf = (T_MFW_SS_CB_CNF*)mfwAlloc(sizeof(T_MFW_SS_CB_CNF)); + if(NULL != cb_cnf) + { + TRACE_EVENT_P2("Mem Aloc for cb_cnf = %x Size = %d",cb_cnf,sizeof(T_MFW_SS_CB_CNF)); + cb_cnf->ss_code = ss_cvtSCode(ksStat->ir.rKSCB.ssCd); + cb_cnf->ss_category = ss_cvtOCode(ksStat->ir.rKSCB.opCd); + cb_cnf->ss_error = ss_cvtErrCode(ksStat->ir.rKSCB.ssErr); + cb_cnf->ss_telecom_list = p_tele; + } + else + return; +#else + cb_cnf.ss_code = (T_MFW_SS_CODES) ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCB.ssCd); + cb_cnf.ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCB.opCd); + cb_cnf.ss_error = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCB.ssErr); + cb_cnf.ss_telecom_list = p_tele; +#endif + + for( idx = 0; + idx < ksStat->ir.rKSCB.c_cbInfoLst AND + idx < MFW_MAX_TELE_NR; + idx++, p_tele++ ) + { + p_tele->ss_telecom_type = ksStat->ir.rKSCB. + cbInfoLst[idx].bsTp; + p_tele->ss_telecom_service = ksStat->ir.rKSCB. + cbInfoLst[idx].bsCd; + p_tele->ss_status = ksStat->ir.rKSCB. + cbInfoLst[idx].ssSt; + } +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + if(NULL != cb_cnf) + cb_cnf->ss_telecom_count = idx; +#else + cb_cnf.ss_telecom_count = idx; +#endif + break; + + case KSD_CMD_CF: + TRACE_EVENT("KSD_CMD_CF"); + TRACE_EVENT_P1("ksStat->ir.rKSCF.ssCd %d", ksStat->ir.rKSCF.ssCd); + TRACE_EVENT_P1("ksStat->ir.rKSCF.opCd %d", ksStat->ir.rKSCF.opCd); + TRACE_EVENT_P1("ksStat->ir.rKSCF.ssErr %d", ksStat->ir.rKSCF.ssErr); + TRACE_EVENT_P1("ksStat->ir.rKSCF.c_cfFeatLst %d", ksStat->ir.rKSCF.c_cfFeatLst); + if (ksStat->ir.rKSCF.c_cfFeatLst) + { + int i; + for (i = 0; i < ksStat->ir.rKSCF.c_cfFeatLst; i++) + { + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].bsTp %d", i, ksStat->ir.rKSCF.cfFeatLst[i].bsTp); + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].bsCd %d", i, ksStat->ir.rKSCF.cfFeatLst[i].bsCd); + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].ssSt %d", i, ksStat->ir.rKSCF.cfFeatLst[i].ssSt); + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].num %s", i, ksStat->ir.rKSCF.cfFeatLst[i].num); + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].ton 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].ton); + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].npi 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].npi); + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].sub %s", i, ksStat->ir.rKSCF.cfFeatLst[i].sub); + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].tos 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].tos); + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].oe 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].oe); + TRACE_EVENT_P2("ksStat->ir.rKSCF.cfFeatLst[%d].time 0x%02X", i, ksStat->ir.rKSCF.cfFeatLst[i].time); + } + } + p_feat = (T_MFW_FEATURE *) ssLstBuf; +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + cf_cnf = (T_MFW_SS_CF_CNF*)mfwAlloc(sizeof(T_MFW_SS_CF_CNF)); + if(NULL != cf_cnf) + { + TRACE_EVENT_P2("Mem Loc = %x, allocates size = %d",cf_cnf,sizeof(T_MFW_SS_CF_CNF)); + cf_cnf->ss_code = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCF.ssCd); + cf_cnf->ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCF.opCd); + cf_cnf->ss_error = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCF.ssErr); + cf_cnf->ss_feature_list = p_feat; + } +#else + cf_cnf.ss_code = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCF.ssCd); + cf_cnf.ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCF.opCd); + cf_cnf.ss_error = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCF.ssErr); + + cf_cnf.ss_feature_list = p_feat; +#endif + for( idx = 0; + idx < ksStat->ir.rKSCF.c_cfFeatLst AND + idx < MFW_MAX_FEAT_NR; + idx++, p_feat++ ) + { + p_feat->ss_telecom_type = ksStat->ir.rKSCF. + cfFeatLst[idx].bsTp; + p_feat->ss_telecom_service = ksStat->ir.rKSCF. + cfFeatLst[idx].bsCd; + p_feat->ss_status = ksStat->ir.rKSCF.cfFeatLst[idx].ssSt; + p_feat->ss_numbering_type = phb_cvtTon(ksStat->ir.rKSCF. + cfFeatLst[idx].ton); + p_feat->ss_numbering_plan = (UBYTE)phb_cvtNpi(ksStat->ir.rKSCF. + cfFeatLst[idx].npi); + strncpy((char *)p_feat->ss_forwarded_to_number, + (char *)ksStat->ir.rKSCF.cfFeatLst[idx].num, + MFW_SS_NUM_LEN); + strncpy((char *)p_feat->ss_forwarded_to_subaddress, + (char *)ksStat->ir.rKSCF.cfFeatLst[idx].sub, + MFW_SS_SUBADR_LEN); + p_feat->ss_no_reply_condition_time = ksStat->ir.rKSCF. + cfFeatLst[idx].time; + } +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + if(NULL != cf_cnf) + cf_cnf->ss_feature_count = idx; +#else + cf_cnf.ss_feature_count = idx; +#endif + TRACE_EVENT("rat_percentksir->KSD_CMD_CF"); + if (ksStat->srcId != CMD_SRC_LCL) +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + { + + ss_signal(E_SS_CF_ICN_UPD,cf_cnf); + } +#else + ss_signal(E_SS_CF_ICN_UPD, &cf_cnf); +#endif + + break; + + case KSD_CMD_CL: + TRACE_EVENT("KSD_CMD_CL"); + TRACE_EVENT_P1("ksStat->ir.rKSCL.ssCd %d", ksStat->ir.rKSCL.ssCd); + TRACE_EVENT_P1("ksStat->ir.rKSCL.opCd %d", ksStat->ir.rKSCL.opCd); + TRACE_EVENT_P1("ksStat->ir.rKSCL.ssErr %d", ksStat->ir.rKSCL.ssErr); + TRACE_EVENT_P1("ksStat->ir.rKSCL.ssSt %d", ksStat->ir.rKSCL.ssSt); + TRACE_EVENT_P1("ksStat->ir.rKSCL.mode %d", ksStat->ir.rKSCL.mode); + TRACE_EVENT_P1("ksStat->ir.rKSCL.clirOpt %d", ksStat->ir.rKSCL.clirOpt); + TRACE_EVENT_P1("ksStat->ir.rKSCL.ovrdCtg %d", ksStat->ir.rKSCL.ovrdCtg); +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + cli_cnf = (T_MFW_SS_CLI_CNF*)mfwAlloc(sizeof(T_MFW_SS_CLI_CNF)); + if(NULL != cli_cnf) + { + cli_cnf->ss_code = ss_cvtSCode(ksStat->ir.rKSCL.ssCd); + cli_cnf->ss_category = ss_cvtOCode(ksStat->ir.rKSCL.opCd); + cli_cnf->ss_error = ss_cvtErrCode(ksStat->ir.rKSCL.ssErr); + cli_cnf->ss_status = ksStat->ir.rKSCL.ssSt; + cli_cnf->ss_clir_option = ss_cvtCLStatus(ksStat->ir.rKSCL.clirOpt); + cli_cnf->ss_ovrd_ctgry = ss_cvtCLOvrd(ksStat->ir.rKSCL.ovrdCtg); + } +#else + cli_cnf.ss_code = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCL.ssCd); + cli_cnf.ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCL.opCd); + cli_cnf.ss_error = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCL.ssErr); + + cli_cnf.ss_status = ksStat->ir.rKSCL.ssSt; + cli_cnf.ss_clir_option = (T_MFW_SS_ERROR)ss_cvtCLStatus((T_ACI_KSD_CLIR_OP)ksStat->ir.rKSCL.clirOpt); + cli_cnf.ss_ovrd_ctgry = (T_MFW_OV_CTGRY)ss_cvtCLOvrd((T_ACI_KSD_OVRD_CTG)ksStat->ir.rKSCL.ovrdCtg); +#endif + break; + + case KSD_CMD_CW: + TRACE_EVENT("KSD_CMD_CW"); + TRACE_EVENT_P1("ksStat->ir.rKSCW.ssCd %d", ksStat->ir.rKSCW.ssCd); + TRACE_EVENT_P1("ksStat->ir.rKSCW.opCd %d", ksStat->ir.rKSCW.opCd); + TRACE_EVENT_P1("ksStat->ir.rKSCW.ssErr %d", ksStat->ir.rKSCW.ssErr); + TRACE_EVENT_P1("ksStat->ir.rKSCW.ssSt %d", ksStat->ir.rKSCW.ssSt); + TRACE_EVENT_P1("ksStat->ir.rKSCW.c_cwBSGLst %d", ksStat->ir.rKSCW.c_cwBSGLst); + if (ksStat->ir.rKSCW.c_cwBSGLst) + { + int i; + for (i = 0; i < ksStat->ir.rKSCW.c_cwBSGLst; i++) + { + TRACE_EVENT_P2("ksStat->ir.rKSCW.cwBSGLst[%d].bsTp %d", i, ksStat->ir.rKSCW.cwBSGLst[i].bsTp); + TRACE_EVENT_P2("ksStat->ir.rKSCW.cwBSGLst[%d].bsCd %d", i, ksStat->ir.rKSCW.cwBSGLst[i].bsCd); + } + } + p_srv = (T_MFW_SRV_GROUP *) ssLstBuf; +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + cw_cnf = (T_MFW_SS_CW_CNF*)mfwAlloc(sizeof(T_MFW_SS_CW_CNF)); + if(cw_cnf != NULL) + { + cw_cnf->ss_code = ss_cvtSCode(ksStat->ir.rKSCW.ssCd); + cw_cnf->ss_category = ss_cvtOCode(ksStat->ir.rKSCW.opCd); + cw_cnf->ss_error = ss_cvtErrCode(ksStat->ir.rKSCW.ssErr); + cw_cnf->ss_status = ksStat->ir.rKSCW.ssSt; + cw_cnf->ss_service_list = p_srv; + } + +#else + cw_cnf.ss_code = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSCW.ssCd); + cw_cnf.ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSCW.opCd); + cw_cnf.ss_error = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSCW.ssErr); + cw_cnf.ss_status = ksStat->ir.rKSCW.ssSt; + + cw_cnf.ss_service_list = p_srv; +#endif + for( idx = 0; + idx < ksStat->ir.rKSCW.c_cwBSGLst AND + idx < MFW_MAX_SRV_NR; + idx++, p_srv++ ) + { + p_srv->ss_telecom_type = ksStat->ir.rKSCW. + cwBSGLst[idx].bsTp; + p_srv->ss_telecom_service = ksStat->ir.rKSCW. + cwBSGLst[idx].bsCd; + } +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + if(NULL != cw_cnf) + cw_cnf->ss_service_count = idx; +#else + cw_cnf.ss_service_count = idx; +#endif + break; + + case KSD_CMD_PWD: + TRACE_EVENT("KSD_CMD_PWD"); + TRACE_EVENT_P1("ksStat->ir.rKSPW.ssCd %d", ksStat->ir.rKSPW.ssCd); + TRACE_EVENT_P1("ksStat->ir.rKSPW.opCd %d", ksStat->ir.rKSPW.opCd); + TRACE_EVENT_P1("ksStat->ir.rKSPW.ssErr %d", ksStat->ir.rKSPW.ssErr); + TRACE_EVENT_P1("ksStat->ir.rKSPW.newPwd %s", ksStat->ir.rKSPW.newPwd); +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + pw_cnf = (T_MFW_SS_PW_CNF*)mfwAlloc(sizeof(T_MFW_SS_PW_CNF)); + if( NULL != pw_cnf) + { + pw_cnf->ss_code = ss_cvtSCode(ksStat->ir.rKSPW.ssCd); + pw_cnf->ss_category = ss_cvtOCode(ksStat->ir.rKSPW.opCd); + pw_cnf->ss_error = ss_cvtErrCode(ksStat->ir.rKSPW.ssErr); + + strncpy( (char *)pw_cnf->ss_new_pwd, (char *)ksStat->ir.rKSPW.newPwd, + MFW_SS_PWD_LEN); + } +#else + pw_cnf.ss_code = (T_MFW_SS_CODES)ss_cvtSCode((T_ACI_KSD_SS)ksStat->ir.rKSPW.ssCd); + pw_cnf.ss_category = (T_MFW_SS_CATEGORY)ss_cvtOCode((T_ACI_KSD_OP)ksStat->ir.rKSPW.opCd); + pw_cnf.ss_error = (T_MFW_SS_ERROR)ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSPW.ssErr); + + strncpy( (char *)pw_cnf.ss_new_pwd, (char *)ksStat->ir.rKSPW.newPwd, + MFW_SS_PWD_LEN); +#endif + break; + + case KSD_CMD_IMEI: + TRACE_EVENT("KSD_CMD_IMEI"); + TRACE_EVENT_P1("ksStat->ir.rKSIMEI.tac1 %d", ksStat->ir.rKSIMEI.tac1); + TRACE_EVENT_P1("ksStat->ir.rKSIMEI.tac2 %d", ksStat->ir.rKSIMEI.tac2); + TRACE_EVENT_P1("ksStat->ir.rKSIMEI.tac3 %d", ksStat->ir.rKSIMEI.tac3); + TRACE_EVENT_P1("ksStat->ir.rKSIMEI.fac %d", ksStat->ir.rKSIMEI.fac); + TRACE_EVENT_P1("ksStat->ir.rKSIMEI.snr1 %d", ksStat->ir.rKSIMEI.snr1); + TRACE_EVENT_P1("ksStat->ir.rKSIMEI.snr2 %d", ksStat->ir.rKSIMEI.snr2); + TRACE_EVENT_P1("ksStat->ir.rKSIMEI.snr3 %d", ksStat->ir.rKSIMEI.snr3); + TRACE_EVENT_P1("ksStat->ir.rKSIMEI.svn %d", ksStat->ir.rKSIMEI.svn); + TRACE_EVENT_P1("ksStat->ir.rKSIMEI.cd %d", ksStat->ir.rKSIMEI.cd); +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + imei_info = (T_MFW_IMEI*)mfwAlloc(sizeof(T_MFW_IMEI)); + if( NULL != imei_info) + { +#endif + ss_decode_imei(ksStat); +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + imei_info->error = MFW_SS_NO_ERROR; + ss_signal(E_SS_IMEI, imei_info); + } +#else + imei_info.error = MFW_SS_NO_ERROR; + ss_signal(E_SS_IMEI, &imei_info); +#endif + break; + + case KSD_CMD_USSD: + TRACE_EVENT("KSD_CMD_USSD"); + TRACE_EVENT_P1("ksStat->ir.rKSUS.ussd %s", ksStat->ir.rKSUS.ussd); + TRACE_EVENT_P1("ksStat->ir.rKSUS.dcs 0x%02X", ksStat->ir.rKSUS.dcs); + TRACE_EVENT_P1("ksStat->ir.rKSUS.mode %d", ksStat->ir.rKSUS.mode); + TRACE_EVENT_P1("ksStat->ir.rKSUS.ssErr %d", ksStat->ir.rKSUS.ssErr); + memset(&ussd_info, 0, sizeof(ussd_info)); + ussd_info.len = strlen((char *)ksStat->ir.rKSUS.ussd); + strcpy((char*)ussd_info.ussd, (char *)ksStat->ir.rKSUS.ussd); + ussd_info.dcs = MFW_ASCII; + ussd_info.error = ss_cvtErrCode((T_ACI_KSD_ERR)ksStat->ir.rKSUS.ssErr); + break; + + default: + TRACE_EVENT("default"); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_command_info | ++--------------------------------------------------------------------+ + + + PURPOSE : Notify for send a SS string from ACI + +*/ + +void ss_command_info(T_ACI_CLOG* cmd) +{ +// Apr 06 2005 REF: CRR 29989 xpradipg +// the variable is made local since the scope lies within this function +#ifdef FF_MMI_OPTIM + T_MFW_SS_RES ss_res; +#endif + TRACE_FUNCTION("ss_command_info()"); + + if (cmd->cmdPrm.sCFUN.srcId != CMD_SRC_LCL) + return; + + switch (cmd->atCmd) + { + case KSD_CMD_CB: + ss_res.type = ss_cvtSCode((T_ACI_KSD_SS)cmd->cmdPrm.sKSCB.ssCd); + ss_res.category = ss_cvtOCode((T_ACI_KSD_OP)cmd->cmdPrm.sKSCB.opCd); + if( cmd->cmdPrm.sKSCB.pwd ) + strncpy(ss_res.ppn, (char *)cmd->cmdPrm.sKSCB.pwd, + MAX_PWD_LEN); + else + ss_res.ppn[0] = 0; + ss_res.pwd[0] = 0; + ss_res.bs = cmd->cmdPrm.sKSCB.bsCd; + ss_res.time = 0; + ss_signal(E_SS_RES, &ss_res); + break; + + case KSD_CMD_CF: + ss_res.type = ss_cvtSCode((T_ACI_KSD_SS)cmd->cmdPrm.sKSCF.ssCd); + ss_res.category = ss_cvtOCode((T_ACI_KSD_OP)cmd->cmdPrm.sKSCF.opCd); + ss_res.ppn[0] = 0; + ss_res.pwd[0] = 0; + ss_res.bs = cmd->cmdPrm.sKSCF.bsCd; + ss_res.time = cmd->cmdPrm.sKSCF.time; + ss_signal(E_SS_RES, &ss_res); + break; + + case KSD_CMD_CW: + ss_res.type = SS_CW; + ss_res.category = ss_cvtOCode((T_ACI_KSD_OP)cmd->cmdPrm.sKSCW.opCd); + ss_res.ppn[0] = 0; + ss_res.pwd[0] = 0; + ss_res.bs = cmd->cmdPrm.sKSCW.bsCd; + ss_res.time = 0; + ss_signal(E_SS_RES, &ss_res); + break; + + case KSD_CMD_PWD: + switch(cmd->cmdPrm.sKSPW.ssCd) + { + case KSD_SS_CCBS: + case KSD_SS_ALL_CBSS: + case KSD_SS_BOC: + case KSD_SS_BAOC: + case KSD_SS_BOIC: + case KSD_SS_BOICXH: + case KSD_SS_BIC: + case KSD_SS_BAIC: + case KSD_SS_BICRM: + + + /*NM 190602*/ + case KSD_SS_ALL_SERV : + + + ss_res.type = ss_cvtSCode((T_ACI_KSD_SS)cmd->cmdPrm.sKSPW.ssCd); + ss_res.category = SS_REGISTRATION; + if( cmd->cmdPrm.sKSPW.oldPwd ) + strncpy(ss_res.ppn, (char *)cmd->cmdPrm.sKSPW.oldPwd, + MAX_PWD_LEN); + else + ss_res.ppn[0] = 0; + if( cmd->cmdPrm.sKSPW.newPwd ) + strncpy(ss_res.pwd, (char *)cmd->cmdPrm.sKSPW.newPwd, + MAX_PWD_LEN); + else + ss_res.pwd[0] = 0; + ss_res.bs = 0; + ss_res.time = 0; + ss_signal(E_SS_RES, &ss_res); + break; + + case KSD_SS_PIN1: + pwd_flag = 1; + sim_pin_ident(MFW_SIM_PIN1); + break; + case KSD_SS_PIN2: + pwd_flag = 1; + sim_pin_ident(MFW_SIM_PIN2); + break; + } + break; + + case KSD_CMD_UBLK: + switch(cmd->cmdPrm.sKSPW.ssCd) + { + case KSD_SS_PIN1: + pwd_flag = 1; + sim_pin_ident(MFW_SIM_PUK1); + break; + case KSD_SS_PIN2: + pwd_flag = 1; + sim_pin_ident(MFW_SIM_PUK2); + break; + } + break; + + case KSD_CMD_CL: + ss_res.type = ss_cvtSCode((T_ACI_KSD_SS)cmd->cmdPrm.sKSCL.ssCd); + ss_res.category = ss_cvtOCode((T_ACI_KSD_OP)cmd->cmdPrm.sKSCL.opCd); + ss_res.ppn[0] = 0; + ss_res.pwd[0] = 0; + ss_res.bs = 0; + ss_res.time = 0; + ss_signal(E_SS_RES, &ss_res); + break; + + case KSD_CMD_USSD: + memset(&ussd_info, 0, sizeof(ussd_info)); + if( cmd->cmdPrm.sKSUS.ussd ) + { + ussd_info.len = strlen((char *)cmd->cmdPrm.sKSUS.ussd); + strcpy((char*)ussd_info.ussd, (char *)cmd->cmdPrm.sKSUS.ussd); + } + else + ussd_info.ussd[0] = 0; + ussd_info.dcs = MFW_ASCII; + //PATCH TB 1509 + ss_res.type = SS_USSD; + ss_res.category = SS_CTG_UNKNOWN; + ss_res.ppn[0] = 0; + ss_res.pwd[0] = 0; + ss_res.bs = 0; + ss_res.time = 0; + ss_signal(E_SS_RES, &ss_res); + //END PATCH TB + break; + + case AT_CMD_CUSD: + memset(&ussd_info, 0, sizeof(ussd_info)); + ussd_info.len = cmd->cmdPrm.sCUSD.str->len; + memcpy((char*)ussd_info.ussd, cmd->cmdPrm.sCUSD.str->data, cmd->cmdPrm.sCUSD.str->len); + ussd_info.dcs = (T_MFW_DCS)cmd->cmdPrm.sCUSD.dcs; +/* SPR#CQ3204 -JVJ - USSD call back sent to MMI */ + ss_res.type = SS_USSD; + ss_res.category = SS_CTG_UNKNOWN; + ss_res.ppn[0] = 0; + ss_res.pwd[0] = 0; + ss_res.bs = 0; + ss_res.time = 0; + ss_signal(E_SS_RES, &ss_res); +/* SPR#CQ3204 -JVJ */ + break; + default: + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_ok_string | ++--------------------------------------------------------------------+ + + + PURPOSE : Send of SS string is successful. + +*/ + +void ss_ok_string(T_ACI_AT_CMD cmdId) +{ + TRACE_FUNCTION("ss_ok_string()"); + + switch (cmdId) + { + case KSD_CMD_CB: +// Apr 06 2005 REF: CRR 29989 xpradipg +// free the allocated memory once the ss_signal() execution is done +#ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_CB"); + if(cb_cnf) + { + ss_signal(E_SS_CB_CNF, cb_cnf); + mfwFree((U8*)cb_cnf, sizeof(T_MFW_SS_CB_CNF)); + } +#else + ss_signal(E_SS_CB_CNF, &cb_cnf); +#endif + break; + case KSD_CMD_CF: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_CF"); + if(cf_cnf) + { + ss_signal(E_SS_CF_CNF, cf_cnf); + mfwFree((U8*)cf_cnf, sizeof(T_MFW_SS_CF_CNF)); + } +#else + ss_signal(E_SS_CF_CNF, &cf_cnf); +#endif + + break; + case KSD_CMD_CW: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_CW"); + if(cw_cnf) + { + ss_signal(E_SS_CW_CNF, cw_cnf); + mfwFree((U8*)cw_cnf, sizeof(T_MFW_SS_CW_CNF)); + } +#else + ss_signal(E_SS_CW_CNF, &cw_cnf); +#endif + break; + case KSD_CMD_PWD: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_PW"); + if(pw_cnf) + { + if (!pwd_flag) + ss_signal(E_SS_GET_PW, pw_cnf); + mfwFree((U8*)pw_cnf,sizeof(T_MFW_SS_PW_CNF)); + } +#else + if (!pwd_flag) + ss_signal(E_SS_GET_PW, &pw_cnf); +#endif + + if (pwd_flag == 1) + { + pwd_flag = 0; + sim_ok_cpinc(); + } + break; + case KSD_CMD_UBLK: + sim_ss_unblock(SIM_UBLK_OK, CME_ERR_NotPresent); + break; + case KSD_CMD_CL: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_CLI"); + if(cli_cnf) + { + ss_signal(E_SS_CLI_CNF,(void*) cli_cnf); + mfwFree((U8*)cli_cnf, sizeof(T_MFW_SS_CLI_CNF)); + } +#else + ss_signal(E_SS_CLI_CNF,&cli_cnf); +#endif + break; + case KSD_CMD_IMEI: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + if( imei_info) + { + imei_info->error = MFW_SS_NO_ERROR; + ss_signal(E_SS_IMEI, imei_info); + mfwFree((U8*)imei_info,sizeof(T_MFW_IMEI)); + } +#else + imei_info.error = MFW_SS_NO_ERROR; + ss_signal(E_SS_IMEI, &imei_info); +#endif + break; + default: + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_error_string | ++--------------------------------------------------------------------+ + + + PURPOSE : Send of SS string is failed. + +*/ + +void ss_error_string(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR reason) +{ + TRACE_FUNCTION("ss_error_string()"); + + switch (cmdId) + { + case KSD_CMD_CB: +// Apr 06 2005 REF: CRR 29989 xpradipg +// deallocation occurs either in ok/ error since the response is always is +// either one of them + #ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_CB"); + if(cb_cnf) + { + ss_signal(E_SS_CB_CNF, cb_cnf); + mfwFree((U8*)cb_cnf,sizeof(T_MFW_SS_CB_CNF)); + } +#else + ss_signal(E_SS_CB_CNF, &cb_cnf); +#endif + break; + case KSD_CMD_CF: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_CF"); + if(cf_cnf) + { + ss_signal(E_SS_CF_CNF, cf_cnf); + mfwFree((U8*)cf_cnf,sizeof(T_MFW_SS_CF_CNF)); + TRACE_FUNCTION("memory freed for cf_cnf"); + } +#else + ss_signal(E_SS_CF_CNF, &cf_cnf); +#endif + break; + case KSD_CMD_CW: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_CW"); + if(cw_cnf) + { + ss_signal(E_SS_CW_CNF, cw_cnf); + mfwFree((U8*)E_SS_CW_CNF,sizeof(T_MFW_SS_CW_CNF)); + } +#else + ss_signal(E_SS_CW_CNF, &cw_cnf); +#endif + break; + case KSD_CMD_PWD: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_PW"); + if(pw_cnf) + { + if (!pwd_flag) + ss_signal(E_SS_GET_PW, pw_cnf); + mfwFree((U8*)pw_cnf,sizeof(T_MFW_SS_PW_CNF)); + } +#else + if (!pwd_flag) + ss_signal(E_SS_GET_PW, &pw_cnf); +#endif + if (pwd_flag == 1) + { + pwd_flag = 0; + sim_error_cpinc(); + } + break; + case KSD_CMD_UBLK: + sim_ss_unblock(SIM_UBLK_ERROR, reason); + break; + case KSD_CMD_CL: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + TRACE_EVENT("KSD_CMD_CLI"); + if(cli_cnf) + { + ss_signal(E_SS_CLI_CNF, cli_cnf); + mfwFree((U8*)cli_cnf,sizeof(T_MFW_SS_CLI_CNF)); + } +#else + ss_signal(E_SS_CLI_CNF,&cli_cnf); +#endif + case KSD_CMD_IMEI: +// Apr 06 2005 REF: CRR 29989 xpradipg +#ifdef FF_MMI_OPTIM + if( imei_info) + { + imei_info->error = MFW_SS_ERROR; + ss_signal(E_SS_IMEI, imei_info); + mfwFree((U8*)imei_info,sizeof(T_MFW_IMEI)); + } +#else + imei_info.error = MFW_SS_ERROR; + ss_signal(E_SS_IMEI, &imei_info); +#endif + break; + default: + break; + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_set_clck | ++--------------------------------------------------------------------+ + + + PURPOSE : This function execute the facility lock command. + +*/ + +T_MFW ss_set_clck(T_ACI_CLCK_FAC fac, + T_ACI_CLCK_MOD mode, + CHAR *passwd, + T_ACI_CLASS class_type, + UBYTE modul) +{ + TRACE_EVENT("ss_set_clck()"); + + clck_flag = modul; + + if (sAT_PlusCLCK(CMD_SRC_LCL, fac,mode, passwd, class_type) != AT_EXCT) + return MFW_SS_FAIL; + return MFW_SS_OK; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : ss_ok_clck | ++--------------------------------------------------------------------+ + + PURPOSE : The executing of the facility lock command is successful. + +*/ + +void ss_ok_clck() +{ + TRACE_FUNCTION("ss_ok_clck()"); + + switch (clck_flag) + { + case MFW_PHB: + phb_ok_clck(); + break; + case MFW_SIM_CPIND: + sim_ok_cpind(); + break; + case MFW_SIM_CPINE: + sim_ok_cpine(); + break; + } + clck_flag = MFW_MODUL_UNKNOWN; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MMI-Framework (8417) MODULE : MFW_SS | +| STATE : code ROUTINE : ss_error_clck | ++--------------------------------------------------------------------+ + + PURPOSE : The executing of the facility lock command is failed. + +*/ + +void ss_error_clck() +{ + TRACE_FUNCTION("ss_error_clck()"); + + switch (clck_flag) + { + case MFW_PHB: + phb_error_clck(); + break; + case MFW_SIM_CPIND: + sim_error_cpind(); + break; + case MFW_SIM_CPINE: + sim_error_cpine(); + break; + } + clck_flag = MFW_MODUL_UNKNOWN; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_DMY | +| STATE : code ROUTINE: ss_send_ussd | ++--------------------------------------------------------------------+ + + + PURPOSE : Send USSD string. + Note: ASCII is not allowed to use. + +*/ + +T_MFW ss_send_ussd(T_MFW_SS_USSD *ussd_info) +{ + T_ACI_USSD_DATA str; + T_ACI_RETURN res; + + TRACE_FUNCTION("ss_send_ussd()"); + + if (!ussd_info->len OR !ussd_info->ussd) + return MFW_SS_FAIL; + + if (ussd_info->dcs == MFW_ASCII) + return MFW_SS_FAIL; + + if (ussd_info->len > MAX_USSD_LEN) + { + str.len = MAX_USSD_LEN; + memcpy(str.data, ussd_info->ussd, MAX_USSD_LEN); + } + else + { + str.len = ussd_info->len; + memcpy(str.data, ussd_info->ussd, ussd_info->len); + } + + res = sAT_PlusCUSD(CMD_SRC_LCL, &str, (SHORT)ussd_info->dcs); + if ((res != AT_EXCT) AND (res != AT_CMPL)) + return MFW_SS_FAIL; + + return MFW_SS_OK; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_DMY | +| STATE : code ROUTINE: rAT_PlusCUSD | ++--------------------------------------------------------------------+ + + + PURPOSE : Notify or response for USSD from ACI + +*/ + +void rAT_PlusCUSD(T_ACI_CUSD_MOD m, T_ACI_USSD_DATA *ussd, SHORT dcs) +{ + TRACE_FUNCTION("rAT_PlusCUSD()"); +//Dec 16, 2005 OMAPS00053316 x0018858 +//Added the NullCheck to ensure that we dont access the elements when the pointer is NULL. +//Begin OMAPS00053316 +if(ussd != NULL) +{ + ussd_info.len = ussd->len; + memcpy(ussd_info.ussd, ussd->data, sizeof(ussd_info.ussd)); + +} +else +{ + ussd_info.len = 0; + memset(ussd_info.ussd, 0x00, sizeof(ussd_info.ussd)); +} +//End OMAPS00053316 + ussd_info.dcs = (T_MFW_DCS)dcs; + ussd_info.error = MFW_SS_NO_ERROR; + + if (m == CUSD_MOD_YesActReq) + ss_signal(E_SS_USSD_REQ, &ussd_info); + if (m == CUSD_MOD_NoActReq) + ss_signal(E_SS_USSD_CNF, &ussd_info); +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_DMY | +| STATE : code ROUTINE: ss_ok_ussd | ++--------------------------------------------------------------------+ + + + PURPOSE : USSD process is successful. + +*/ + +void ss_ok_ussd(T_ACI_AT_CMD cmdId) +{ + TRACE_FUNCTION("ss_ok_ussd()"); + + if (cmdId == KSD_CMD_USSD) + { + ussd_info.error = MFW_SS_NO_ERROR; + ss_signal(E_SS_USSD_CNF, &ussd_info); + } +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_error_ussd | ++--------------------------------------------------------------------+ + + + PURPOSE : USSD process is failed. + +*/ + +void ss_error_ussd(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR reason) +{ + TRACE_FUNCTION("ss_error_ussd()"); + +// ussd_info.error = ss_cvtErrCode(reason); + ss_signal(E_SS_USSD_CNF, &ussd_info); +} + +/* ++---------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_abort_transaction | ++---------------------------------------------------------------------+ + + + PURPOSE : Abort executing of SS transaction + +*/ + +T_MFW ss_abort_transaction(void) +{ + TRACE_FUNCTION("ss_abort_transaction()"); + + if (sAT_Abort(CMD_SRC_LCL, AT_CMD_CUSD) EQ AT_CMPL) + return TRUE; + else + { + if (sAT_Abort(CMD_SRC_LCL, AT_CMD_D) EQ AT_CMPL) + return TRUE; + } + return FALSE; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_set_cug | ++--------------------------------------------------------------------+ + + + PURPOSE : set parameter of close user group + +*/ +T_MFW_SS_RETURN ss_set_cug (T_MFW_SS_CUG_PARA *cug_param) +{ + T_ACI_CCUG_MOD cug_mode = CCUG_MOD_NotPresent; + T_ACI_CCUG_IDX cug_index = CCUG_IDX_NotPresent; + T_ACI_CCUG_INFO cug_info = CCUG_INFO_NotPresent; + + TRACE_FUNCTION("ss_set_cug()"); + +/* check cug mode */ + switch(cug_param->mode) + { + case MFW_SS_CUG_TMP_DISABLE: + cug_mode = CCUG_MOD_DisableTmp; + break; + case MFW_SS_CUG_TMP_ENABLE: + cug_mode = CCUG_MOD_EnableTmp; /* enable to control cug info */ + break; + default: /* ACI keep last valid value */ + break; + } +/* check cug index */ + switch(cug_param->index) + { + case MFW_SS_CUG_INDEX0: + cug_index = CCUG_IDX_0; + break; + case MFW_SS_CUG_INDEX1: + cug_index = CCUG_IDX_1; + break; + case MFW_SS_CUG_INDEX2: + cug_index = CCUG_IDX_2; + break; + case MFW_SS_CUG_INDEX3: + cug_index = CCUG_IDX_3; + break; + case MFW_SS_CUG_INDEX4: + cug_index = CCUG_IDX_4; + break; + case MFW_SS_CUG_INDEX5: + cug_index = CCUG_IDX_5; + break; + case MFW_SS_CUG_INDEX6: + cug_index = CCUG_IDX_6; + break; + case MFW_SS_CUG_INDEX7: + cug_index = CCUG_IDX_7; + break; + case MFW_SS_CUG_INDEX8: + cug_index = CCUG_IDX_8; + break; + case MFW_SS_CUG_INDEX9: + cug_index = CCUG_IDX_9; + break; + case MFW_SS_CUG_NO_INDEX: + cug_index = CCUG_IDX_No; /* preferred CUG taken from subscriber data */ + break; + default: /* ACI keep last valid value */ + break; + } + +/* check cug info */ + switch(cug_param->info) + { + case MFW_SS_CUG_SUPP_OA: + cug_info = CCUG_INFO_SuppOa; /* suppress outgoing access */ + break; + case MFW_SS_CUG_SUPP_PREF: + cug_info = CCUG_INFO_SuppPrefCug; /* suppress preferential closed user group */ + break; + case MFW_SS_CUG_SUPP_BOTH: + cug_info = CCUG_INFO_SuppBoth; /* suppress outgoing access and preferential cug */ + break; + case MFW_SS_CUG_INFO_NO: /* no cug info */ + cug_info = CCUG_INFO_No; + break; + default: /* ACI keep last valid value */ + break; + } + if(sAT_PlusCCUG(CMD_SRC_LCL,cug_mode,cug_index,cug_info) EQ AT_CMPL) /* set in ACI cug parameters */ + return MFW_SS_OK; + else + return MFW_SS_FAIL; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_get_cug | ++--------------------------------------------------------------------+ + + + PURPOSE : get parameter of close user group + +*/ + +T_MFW_SS_RETURN ss_get_cug(T_MFW_SS_CUG_PARA *cug_param) +{ + T_ACI_CCUG_MOD cug_mode; + T_ACI_CCUG_IDX cug_index; + T_ACI_CCUG_INFO cug_info; + + cug_param->mode = MFW_SS_CUG_MODE_Not_Present; + cug_param->index = MFW_SS_CUG_INDEX_Not_Present; + cug_param->info = MFW_SS_CUG_INFO_Not_Present; + + TRACE_FUNCTION("ss_get_cug()"); + + if(qAT_PlusCCUG(CMD_SRC_LCL,&cug_mode,&cug_index,&cug_info) NEQ AT_CMPL) /* get cug parameters of ACI */ + return MFW_SS_FAIL; + else + { + cug_param->mode = (T_MFW_SS_CUG_MODE)cug_mode; + cug_param->index = (T_MFW_SS_CUG_INDEX)cug_index; + cug_param->info = (T_MFW_SS_CUG_INFO)cug_info; + return MFW_SS_OK; + } +} +//PATCH TB 1309 +/* ++--------------------------------------------------------------------+ +| PROJECT: MMI-Framework (8417) MODULE: MFW_SS | +| STATE : code ROUTINE: ss_command_abort | ++--------------------------------------------------------------------+ + + + PURPOSE : + +*/ +T_MFW ss_command_abort(void) +{ + TRACE_FUNCTION ("ss_command_abort()"); + + // Abort SS transaction. + // Any SS AT_CMD will clear all SS (any) transaction(s) + if (sAT_Abort(CMD_SRC_LCL, AT_CMD_CUSD) == AT_CMPL) + return TRUE; + else + return FALSE; +} +//END PATCH TB +//CQ-16432 start +void ss_sat_passwdReqd(T_ACI_AT_CMD cmdId, T_ACI_CME_ERR err) +{ + TRACE_FUNCTION("ss_sat_passwdReqd"); + ss_signal(E_SS_SAT_CPWD,&cmdId); + return; +} +//CQ-16432 end