FreeCalypso > hg > fc-magnetite
diff src/g23m-aci/aci/aci_util.c @ 162:53929b40109c
src/g23m-aci: initial import from TCS3.2/LoCosto
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Tue, 11 Oct 2016 02:02:43 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-aci/aci/aci_util.c Tue Oct 11 02:02:43 2016 +0000 @@ -0,0 +1,3514 @@ +/* ++----------------------------------------------------------------------------- +| Project : GSM-PS (6147) +| Modul : ACI_UTIL ++----------------------------------------------------------------------------- +| 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 module defines the utility functions for the AT +| command interpreter. ++----------------------------------------------------------------------------- +*/ + + + +#ifndef ACI_UTIL_C +#define ACI_UTIL_C +#endif + +#include "aci_all.h" + +#include "aci_cmh.h" +#include "ati_cmd.h" + +#include "aci_cmd.h" + +#ifdef FAX_AND_DATA +#include "aci_fd.h" +#endif /* of #ifdef FAX_AND_DATA */ + +#include "psa.h" +#include "psa_sms.h" +#include "phb.h" +#include "cmh.h" +#include "cmh_sms.h" + +#if defined (FF_ATI) || defined (FF_BAT) +#include "aci_mem.h" +#include "aci_lst.h" +#include "aci_io.h" +#include "ksd.h" +#include "cmh_ss.h" +#include "psa_ss.h" +#endif +#ifdef FF_ATI +#include "ati_int.h" +#endif +#ifdef FF_BAT +#include "aci_bat_cb.h" +#endif + +#ifdef GPRS +#include "gaci_cmh.h" +#endif /* GPRS */ + +#ifdef TI_PS_OP_CNV_TAB_ROMBASED + #include "rom_tables.h" +#endif /* TI_PS_OP_CNV_TAB_ROMBASED */ + + +#ifdef TI_PS_OP_CNV_TAB_ROMBASED + /* If this flag is enabled CSCS_CHSET_Chars is defined in rom_tables.h file */ +#else + #define CSCS_CHSET_Chars 256 +#endif + +/*==== CONSTANTS ==================================================*/ +#ifdef REL99 +#define NUM_EXT_TABLE_CHARS 9 +#define NUM_IRA_8859_TABLE_CHARS 1 +#endif + + +/*==== TYPES ======================================================*/ + +/*==== EXPORT =====================================================*/ +/* This fucntion cuts the pathname from the file + used by ACI_ASSERT makro*/ +GLOBAL char * getFileName(char * file) +{ + char *cursor = file; + do { + #ifdef _SIMULATION_ + if(*cursor EQ '\\') { file = cursor+1;} + #else + if(*cursor EQ '/') { file = cursor+1;} + #endif + cursor++; + } while(*cursor NEQ '\0'); + return file; +} + + +LOCAL USHORT utl_ucs2FromGsm ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT maxOutLen, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm, + T_ACI_CSCS_ALPHA alphabet ); + +/*==== VARIABLES ==================================================*/ +#ifdef TI_PS_OP_CNV_TAB_ROMBASED +/* Changes for ROM data */ +/* NHK: + * Once the tables chset and gsmToAsciiTable go to ROM, their names below should match corresponding ROM addresses + * KSR: Moved to g23m\condat\com\src\drivers\rom_tables + */ +#else +GLOBAL const UBYTE chset [CSCS_CHSET_Tables][CSCS_CHSET_Chars] = +{ +/* + *------------------------------------------------------------------- + * Conversion table: IRA -> internal GSM + *------------------------------------------------------------------- + */ +/* 0x00 */ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x08 */ 0x00, 0x00, 0x8A, 0x00, 0x00, 0x8D, 0x00, 0x00, +/* 0x10 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x18 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x20 */ 0xA0, 0xA1, 0xA2, 0xA3, 0x82, 0xA5, 0xA6, 0xA7, +/* 0x28 */ 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, +/* 0x30 */ 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, +/* 0x38 */ 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, +/* 0x40 */ 0x80, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, +/* 0x48 */ 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, +/* 0x50 */ 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, +/* 0x58 */ 0xD8, 0xD9, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x91/*00*/, +/* 0x60 */ 0x00, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, +/* 0x68 */ 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, +/* 0x70 */ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, +/* 0x78 */ 0xF8, 0xF9, 0xFA, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x80 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x88 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x90 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x98 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xA0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xA8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xB0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xB8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xC0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xC8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xD0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xD8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xE0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xE8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xF0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xF8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + +/* + *------------------------------------------------------------------- + * Conversion table: PC Danish/Norwegian -> internal GSM + *------------------------------------------------------------------- + */ +/* 0x00 */ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x08 */ 0x00, 0x00, 0x8A, 0x00, 0x00, 0x8D, 0x00, 0x00, +/* 0x10 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xDF, 0x00, 0x00, +/* 0x18 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x20 */ 0xA0, 0xA1, 0xA2, 0xA3, 0x82, 0xA5, 0xA6, 0xA7, +/* 0x28 */ 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, +/* 0x30 */ 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, +/* 0x38 */ 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, +/* 0x40 */ 0x80, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, +/* 0x48 */ 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, +/* 0x50 */ 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, +/* 0x58 */ 0xD8, 0xD9, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x91/*00*/, +/* 0x60 */ 0x00, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, +/* 0x68 */ 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, +/* 0x70 */ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, +/* 0x78 */ 0xF8, 0xF9, 0xFA, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x80 */ 0x89, 0xFE, 0x85, 0xE1, 0xFB, 0xFF, 0x8F, 0x89, +/* 0x88 */ 0xE5, 0xE5, 0x84, 0xE9, 0xE9, 0x87, 0xDB, 0x8E, +/* 0x90 */ 0x9F/*C5*/, 0x9D, 0x9C, 0xEF, 0xFC, 0x88, 0xF5/*E5*/, 0x86, +/* 0x98 */ 0xF9/*E9*/, 0xDC, 0xDE, 0x8C, 0x81, 0x8B, 0x00, 0x00, +/* 0xA0 */ 0xE1, 0xE9, 0xEF, 0xF5, 0xFD, 0xDD, 0x00, 0x00, +/* 0xA8 */ 0xE0, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, +/* 0xB0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xB8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xC0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xC8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xD0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xD8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xE0 */ 0x00, 0x9E, 0x93, 0x00, 0x98, 0x00, 0x00, 0x00, +/* 0xE8 */ 0x92, 0x99, 0x95, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xF0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xF8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + +/* + *------------------------------------------------------------------- + * Conversion table: ISO 8859 Latin 1 -> internal GSM + *------------------------------------------------------------------- + */ +/* 0x00 */ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x08 */ 0x00, 0x00, 0x8A, 0x00, 0x00, 0x8D, 0x00, 0x00, +/* 0x10 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x18 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x20 */ 0xA0, 0xA1, 0xA2, 0xA3, 0x82, 0xA5, 0xA6, 0xA7, +/* 0x28 */ 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, +/* 0x30 */ 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, +/* 0x38 */ 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, +/* 0x40 */ 0x80, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, +/* 0x48 */ 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, +/* 0x50 */ 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, +/* 0x58 */ 0xD8, 0xD9, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x91/*00*/, +/* 0x60 */ 0x00, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, +/* 0x68 */ 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, +/* 0x70 */ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, +/* 0x78 */ 0xF8, 0xF9, 0xFA, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x80 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x88 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x90 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x98 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xA0 */ 0x00, 0xC0, 0x00, 0x81, 0xA4, 0x83, 0x00, 0xDF, +/* 0xA8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xB0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xB8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xE0, +/* 0xC0 */ 0xC1, 0xC1, 0xC1, 0xC1, 0xDB, 0x8E, 0x9C, 0x89, +/* 0xC8 */ 0xC5, 0x9F/*C5*/, 0xC5, 0xC5, 0xC9, 0xC9, 0xC9, 0xC9, +/* 0xD0 */ 0x00, 0xDD, 0xCF, 0xCF, 0xCF, 0xCF, 0xDC, 0x00, +/* 0xD8 */ 0x8B, 0xD5, 0xD5, 0xD5, 0xDE, 0xD9, 0x00, 0x9E, +/* 0xE0 */ 0xFF, 0xE1, 0xE1, 0xE1, 0xFB, 0x8F, 0x9D, 0x89, +/* 0xE8 */ 0x84, 0x85, 0xE5, 0xE5, 0x87, 0xE9, 0xE9, 0xE9, +/* 0xF0 */ 0x00, 0xFD, 0x88, 0xEF, 0xEF, 0xEF, 0xFC, 0x00, +/* 0xF8 */ 0x8C, 0x86, 0xF5, 0xF5, 0xFE, 0xF9, 0x00, 0xF9 }, + +/* + *------------------------------------------------------------------- + * Conversion table: PC Code Page 437 -> internal GSM + *------------------------------------------------------------------- + */ +/* 0x00 */ { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x08 */ 0x00, 0x00, 0x8A, 0x00, 0x00, 0x8D, 0x00, 0x00, +/* 0x10 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0xDF, 0x00, 0x00, +/* 0x18 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x20 */ 0xA0, 0xA1, 0xA2, 0xA3, 0x82, 0xA5, 0xA6, 0xA7, +/* 0x28 */ 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, +/* 0x30 */ 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, +/* 0x38 */ 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, +/* 0x40 */ 0x80, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, +/* 0x48 */ 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, +/* 0x50 */ 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, +/* 0x58 */ 0xD8, 0xD9, 0xDA, 0x00, 0x00, 0x00, 0x00, 0x91/*00*/, +/* 0x60 */ 0x00, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, +/* 0x68 */ 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, +/* 0x70 */ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, +/* 0x78 */ 0xF8, 0xF9, 0xFA, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x80 */ 0x89, 0xFE, 0x85, 0xE1, 0xFB, 0xFF, 0x8F, 0x89, +/* 0x88 */ 0xE5, 0xE5, 0x84, 0xE9, 0xE9, 0x87, 0xDB, 0x8E, +/* 0x90 */ 0x9F/*C5*/, 0x9D, 0x9C, 0xEF, 0xFC, 0x88, 0xF5/*E5*/, 0x86, +/* 0x98 */ 0xF9/*E9*/, 0xDC, 0xDE, 0x00, 0x81, 0x83, 0x00, 0x00, +/* 0xA0 */ 0xE1, 0xE9, 0xEF, 0xF5, 0xFD, 0xDD, 0x00, 0x00, +/* 0xA8 */ 0xE0, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, +/* 0xB0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xB8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xC0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xC8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xD0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xD8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xE0 */ 0x00, 0x9E, 0x93, 0x00, 0x98, 0x00, 0x00, 0x00, +/* 0xE8 */ 0x92, 0x99, 0x95, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xF0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xF8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, + +/* + *------------------------------------------------------------------- + * Conversion table: GSM -> internal GSM + *------------------------------------------------------------------- + */ +/* 0x00 */ { 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, +/* 0x08 */ 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, +/* 0x10 */ 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, +/* 0x18 */ 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, +/* 0x20 */ 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, +/* 0x28 */ 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, +/* 0x30 */ 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, +/* 0x38 */ 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, +/* 0x40 */ 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, +/* 0x48 */ 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, +/* 0x50 */ 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, +/* 0x58 */ 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, +/* 0x60 */ 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, +/* 0x68 */ 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, +/* 0x70 */ 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, +/* 0x78 */ 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, +/* 0x80 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x88 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x90 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0x98 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xA0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xA8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xB0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xB8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xC0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xC8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xD0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xD8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xE0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xE8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xF0 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +/* 0xF8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } +}; + + +/* + *------------------------------------------------------------------- + * Conversion table: ASCII <-> internal GSM + * ( needed for the conversion of UCS2 <-> internal GSM ) + *------------------------------------------------------------------- + */ +/* GSM alphabet characters unknown in the ASCII table have been + replaced by <SP> characters */ +LOCAL const UBYTE gsmToAsciiTable[128] = +{ + /*n = 0 1 2 3 4 5 6 7 8 9 A B C D E F */ +/* 0x0n */ 64,163, 36,165,232,233,249,236,242,199, 10,216,248, 13,197,229, +/* 0x1n */ 128, 95,129,130,131,132,133,134,135,136,137, 27,198,230,223,201, +/* 0x2n */ 32, 33, 34, 35,164, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, +/* 0x3n */ 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, +/* 0x4n */ 161, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, +/* 0x5n */ 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,196,214,209,220,167, +/* 0x6n */ 191, 97, 98, 99,100,101,102,103,104,105,106,107,108,109,110,111, +/* 0x7n */ 112,113,114,115,116,117,118,119,120,121,122,228,246,241,252,224 +}; + +LOCAL const UBYTE hexVal[] = {"0123456789ABCDEF"}; + +#endif + +/* + * These tables are moved out of TI_PS_OP_CNV_TAB_ROMBASED + */ + +#ifdef REL99 +/* + *------------------------------------------------------------------- + * Conversion table: Extension character table that can be used for + mapping IRA or PC D/N or ISO 8859 Latin 1 or PCCP 437 + characters to GSM 7 extension table characters + * The first column contains the GSM 7 extension table character value and + * the second column contains the corresponding character in the other + * character sets + * Ref: 23.038 Sec 6.2.1.1 + *------------------------------------------------------------------- + */ +GLOBAL const UBYTE ext_common_chset_map [NUM_EXT_TABLE_CHARS][2] = +{ + { 0x14, 0x5E }, /* ^ */ + { 0x1B, 0x20 }, /* Reserved for another extension table. To be replaced by space */ + { 0x28, 0x7B }, /* { */ + { 0x29, 0x7D }, /* } */ + { 0x2F, 0x5C }, /* \ */ + { 0x3C, 0x5B }, /* [ */ + { 0x3D, 0x7E }, /* ~ */ + { 0x3E, 0x5D }, /* ] */ + { 0x40, 0x7C } /* | */ +}; + +/* + *------------------------------------------------------------------- + * Conversion table: Extension table character that is used only for + IRA OR ISO 8859 Latin 1, in addition to the character table given + above. + * Ref: 23.038 Sec 6.2.1.1 + * The Euro character is treated separately as it there is no mapping + * character in PCCP 437 and PCDN. + *------------------------------------------------------------------- + */ +GLOBAL const UBYTE ext_ira_8859_chset_map [NUM_IRA_8859_TABLE_CHARS][2] = +{ + { 0x65, 0x80 } /* Euro symbol */ +}; +#endif + + +/* +static const unsigned char +gsm_2_ascii_table[128] = +{ + 0x40, 0x9C, 0x24, 0x9D, 0x8A, 0x82, 0x97, 0x8D, 0x95, 0x80, 0x0A, 0x02, 0x07, 0x0D, 0x8F, 0x86, + 0x04, 0x5F, 0xE8, 0xE2, 0xEF, 0xEA, 0xE3, 0x05, 0xE6, 0xE9, 0xF0, 0x20, 0x92, 0x91, 0xE1, 0x90, + 0x20, 0x21, 0x22, 0x23, 0x01, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, + 0xAD, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x8E, 0x99, 0xA5, 0x9A, 0x06, + 0xA8, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x84, 0x94, 0xA4, 0x81, 0x85 +}; +*/ + +/*==== FUNCTIONS ==================================================*/ +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : strupper | ++-------------------------------------------------------------------+ + + PURPOSE : Converts all characters from 'a' to 'z' to capital + characters from 'A' to 'Z'. +*/ +GLOBAL char* strupper ( char* s ) +{ + USHORT i = 0; + + while ( s NEQ 0 AND s[i] NEQ '\0') + { + if ( s[i] >= 0x61 AND s[i] <= 0x7a ) + + s[i] = s[i] - 0x20; + + i++; + } + + return s; +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_chsetToSim | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the character set used within the AT command interpreter + to the SIM GSM character set. +*/ +GLOBAL void utl_chsetToSim ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm ) +{ + UBYTE cvtdVal; + USHORT outIdx = 0; + USHORT inIdx; + UBYTE corr = ( gsm EQ GSM_ALPHA_Int ? 0xFF : 0x7F ); + T_ACI_CSCS_CHSET cscsChset; + UBYTE srcId = srcId_cb; + + cscsChset = ati_user_output_cfg[srcId].cscsChset; + + if ( cscsChset EQ CSCS_CHSET_Hex ) + { + utl_hexToGsm ( in, inLen, out, outLen, gsm, CSCS_ALPHA_8_Bit ); + } + else if ( cscsChset EQ CSCS_CHSET_Ucs2 ) + { + /* If the user chooses UCS2, then the best mode of coding should be + * used to store the characters in the SIM */ + utl_ucs2ToSim(in, inLen, out, outLen, gsm, CSCS_ALPHA_8_Bit); + } + else + { + for ( inIdx = 0; inIdx < inLen; inIdx++ ) + { + cvtdVal = chset[cscsChset][( UBYTE ) in[inIdx]]; + + if ( cvtdVal NEQ 0x00 ) + { + out[outIdx] = ( CHAR ) cvtdVal & corr; + outIdx++; + } + } + + if ( gsm EQ GSM_ALPHA_Int ) + out[outIdx] = '\0'; + + *outLen = outIdx; + } +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_codeUcs2 | ++-------------------------------------------------------------------+ + + PURPOSE : This function finds optimal coding format to store the + UCS2 character string in the phone book. +*/ +GLOBAL void utl_ucs2ToSim( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm, + T_ACI_CSCS_ALPHA alphabet) +{ + int i; + BOOL flag = TRUE; + UBYTE hexOut[MAX_ALPHA_LEN * 4]; + USHORT hexOutLen = 0; + + /* Convert the hex character string to actual hex values */ + hexOutLen = utl_HexStrToBin(in, inLen, hexOut, (MAX_ALPHA_LEN * 4)); + + /* Initial check is done for GSM or ASCII only characters */ + for(i = 0; i < (hexOutLen/2); i++) + { + if(( hexOut[i*2] NEQ 0x00 )) + { + flag = FALSE; + break; + } + } + if (flag EQ TRUE) + { + utl_ConvUcs2ToGSM(hexOut, hexOutLen, out, outLen, gsm, alphabet); + if (*outLen) + return; + } + + /* If possible UCS2 character string is coded in 0x81 format which + uses a one byte base pointer */ + utl_Ucs2InFormat1 (hexOut, hexOutLen, out, outLen); + if (*outLen) + return; + + /* If possible UCS2 character string is coded in 0x82 format which + uses two byte base pointer */ + utl_Ucs2InFormat2 (hexOut, hexOutLen, out, outLen); + if (*outLen) + return; + + /* If none of the above work, UCS2 character string is coded in 0x80 */ + *out = 0x80; + utl_hexToGsm ( in, inLen, out + 1, outLen, gsm, CSCS_ALPHA_8_Bit ); + (*outLen)++; +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_ConvUcs2ToGSM | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts UCS2 charecter string consisting of + only ASCII charecters to default GSM values. +*/ +GLOBAL void utl_ConvUcs2ToGSM ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm, + T_ACI_CSCS_ALPHA alphabet ) +{ + int i, j; + BOOL flag; + UBYTE val = 0x00; + USHORT len; + UBYTE tmpOut; + USHORT outIdx = 0; + UBYTE corr = ( gsm EQ GSM_ALPHA_Int ? 0xFF : 0x7F ); + + len = inLen/2; + for (i = 0;i < len; i++) + { + tmpOut = in[(i*2) + 1]; + /* convert the hexadecimal ASCII value to GSM, if the value is + * not convertible then we exit */ + if ( tmpOut EQ ( gsmToAsciiTable[tmpOut])) /* ASCII and GSM are identical */ + { + val = tmpOut; + } + else /* find match in the table and copy index of match */ + { + flag = FALSE; + for (j=0; j<128; j++) + { + if (tmpOut EQ gsmToAsciiTable[j]) + { + val = (UBYTE)j; + flag = TRUE; + break; + } + #ifdef REL99 + else + { + /* There is a chance that this is in the mapping table */ + UBYTE ext_tbl_idx = 0; + while( ext_tbl_idx < NUM_EXT_TABLE_CHARS AND + ext_common_chset_map[ext_tbl_idx][1] NEQ tmpOut ) + { + ext_tbl_idx++; + } + if(ext_tbl_idx < NUM_EXT_TABLE_CHARS) + { + /*Insert the escape character, 0x1B, to output stream*/ + out[outIdx++] = 0x1B |(corr &0x80); + /* Insert the mapping character into the output stream */ + val = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80); + flag = TRUE; + break; + } + } +#endif /* REL99 */ + } + if (!flag) + { + *outLen = 0; + return; + } + } + + /* if necessary, cut the GSM value to 7bit */ + if ( alphabet EQ CSCS_ALPHA_7_Bit AND !( val & 0x80 ) ) + { + if ( gsm EQ GSM_ALPHA_Int ) + { + out[outIdx++] = val | 0x80; + } + else + { + out[outIdx++] = val; + } + } + else + { + out[outIdx++] = val; + } + } + + if ( gsm EQ GSM_ALPHA_Int ) + { + out[outIdx] = '\0'; + } + + /* set the outlength */ + *outLen = outIdx; +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_Ucs2InFormat1 | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the UCS2 character string in the + 0x81 coding scheme for UCS2. + Octet 1: 0x81 + Octet 2: Num of Characters + Octet 3: Bits 15 to 8 of Base pointer + Octet 4 onwards: Characters +*/ +GLOBAL void utl_Ucs2InFormat1( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen) +{ + int i, j; + UBYTE base_ptr = 0x00; + UBYTE temp_ptr; + USHORT len = inLen/2; + USHORT tmp_base; + USHORT tmp; + USHORT outIdx = 0; + UBYTE corr = 0x7F; + + + /* We first check if the UCS2 string can be coded + * using a single base pointer */ + for (i = 0; i < len; i++) + { + if (in[i*2]) + { + if ((in[i*2] & 0x80)) + { + *outLen = 0; + return; + } + temp_ptr = in[i*2] & 0x7f; + temp_ptr <<= 1; + temp_ptr |= ((in[(i*2)+1] & 0x80) >> 7); + + if (base_ptr) + { + if (temp_ptr NEQ base_ptr) + { + *outLen = 0; + return; + } + } else + { + base_ptr = temp_ptr; + } + } + } + + + /* Characters are coded using the base pointer below */ + /* For details, see GSM 11.11 Annex B (normative) */ + out[0] = 0x81; + if (len < PHB_MAX_TAG_LEN - 3) + { + out[1] = (UBYTE)len; + } else + { + out[1] = PHB_MAX_TAG_LEN - 3; + } + out[2] = base_ptr; + tmp_base = 0; + tmp_base = base_ptr << 7; + outIdx = 3; + + len = out[1]; + for (i = 0; i < len; i++) + { + if (in[i*2]) + { + tmp = 0; + tmp = in[i*2] << 8; + tmp |= in[(i*2)+1]; + out[outIdx++] = (tmp - tmp_base) | 0x80; + } else + { + for (j=0; j<128; j++) + { + if (in[(i*2)+1] EQ gsmToAsciiTable[j]) + { + out[outIdx++] = (UBYTE)j; + break; + } + #ifdef REL99 + else + { + /* There is a chance that this is in the mapping table */ + UBYTE ext_tbl_idx = 0; + while( ext_tbl_idx < NUM_EXT_TABLE_CHARS AND + ext_common_chset_map[ext_tbl_idx][1] NEQ in[(i*2)+1] ) + { + ext_tbl_idx++; + } + if(ext_tbl_idx < NUM_EXT_TABLE_CHARS) + { + /*Insert the escape character, 0x1B, to output stream*/ + out[outIdx++] = 0x1B |(corr &0x80); + /* Insert the mapping character into the output stream */ + out[outIdx++] = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80); + break; + } + } +#endif /* REL99 */ + } + } + /* If the charecter cannot be found in ASCII table exit */ + if (j EQ 128) + { + *outLen = 0; + return ; + } + } + +#ifdef REL99 + if (outIdx -3 > len) + { + if (outIdx >= PHB_MAX_TAG_LEN) + { + if (out[PHB_MAX_TAG_LEN - 1] EQ 0x1B) + { + outIdx = PHB_MAX_TAG_LEN - 1; + out[1] = PHB_MAX_TAG_LEN - 4; + } + else + { + outIdx = PHB_MAX_TAG_LEN; + out[1] = PHB_MAX_TAG_LEN - 3; + } + } + else + { + out[1] = outIdx -3; + } + } +#endif /* REL99 */ + + *outLen = outIdx; +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_Ucs2InFormat2 | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the UCS2 character string in the + 0x82 coding scheme for UCS2. + Octet 1: 0x82 + Octet 2: Number of characters + Octet 3 and Octet 4: 2 byte base pointer + Octet 5 onwards: Characters + +*/ +GLOBAL void utl_Ucs2InFormat2( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen) +{ + int i, j; + USHORT len = inLen/2; + USHORT lowest_ch = 0; + USHORT highest_ch = 0; + USHORT tmp; + USHORT outIdx = 0; + UBYTE corr = 0x7F; + + /* We first check if the UCS2 string can be coded + * using a smallest char as the base pointer */ + for (i = 0; i < len; i++) + { + if (in[i*2]) + { + tmp = 0; + tmp = in[i*2] << 8; + tmp |= in[(i*2)+1]; + + if (lowest_ch EQ 0 OR tmp < lowest_ch) + lowest_ch = tmp; + + if (tmp > highest_ch) + highest_ch = tmp; + } + } + + /* To use lowest char can be used as the base pointer, the distance + * between the lowest and highest char must not be more then 128 */ + /* correct here: must not equal or more then 128. the max offset will be less then 0x80 = 128 */ +//TI-SH-TEST-PATCH for CSR OMAPS00168884 + if ((highest_ch - lowest_ch) >= 0x80) + { + *outLen = 0; + return; + } + + /* Characters are coded using the base pointer below */ + /* For details, see GSM 11.11 Annex B (normative) */ + out[0] = 0x82; + if (len < PHB_MAX_TAG_LEN - 4) + { + out[1] = (UBYTE)len; + } else + { + out[1] = PHB_MAX_TAG_LEN - 4; + } + out[2] = (lowest_ch & 0xff00) >> 8; + out[3] = (lowest_ch & 0x00ff); + outIdx = 4; + + len = out[1]; + for (i = 0; i < len; i++) + { + if (in[i*2]) + { + tmp = 0; + tmp = in[i*2] << 8; + tmp |= in[(i*2)+1]; + out[outIdx++] = (tmp - lowest_ch) | 0x80; + } else + { + for (j=0; j<128; j++) + { + if (in[(i*2)+1] EQ gsmToAsciiTable[j]) + { + out[outIdx++] = (UBYTE)j; + break; + } + #ifdef REL99 + else + { + /* There is a chance that this is in the mapping table */ + UBYTE ext_tbl_idx = 0; + while( ext_tbl_idx < NUM_EXT_TABLE_CHARS AND + ext_common_chset_map[ext_tbl_idx][1] NEQ in[(i*2)+1] ) + { + ext_tbl_idx++; + } + if(ext_tbl_idx < NUM_EXT_TABLE_CHARS) + { + /*Insert the escape character, 0x1B, to output stream*/ + out[outIdx++] = 0x1B |(corr &0x80); + /* Insert the mapping character into the output stream */ + out[outIdx++] = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80); + break; + } + } +#endif /* REL99 */ + } + + /* If the charecter cannot be found in ASCII table exit */ + if (j EQ 128) + { + *outLen = 0; + return ; + } + } + } + +#ifdef REL99 + if (outIdx -4 > len) + { + if (outIdx >= PHB_MAX_TAG_LEN) + { + if (out[PHB_MAX_TAG_LEN - 1] EQ 0x1B) + { + outIdx = PHB_MAX_TAG_LEN - 1; + out[1] = PHB_MAX_TAG_LEN - 5; + } + else + { + outIdx = PHB_MAX_TAG_LEN; + out[1] = PHB_MAX_TAG_LEN - 4; + } + } + else + { + out[1] = outIdx -4; + } + } +#endif /* REL99 */ + + *outLen = outIdx; +} +#endif + +#ifdef FF_ATI + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_chsetToGsm | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the character set used within the AT command interpreter + to the ACI internal GSM character set. The outBufLen was added + so that buffer overflow is kept in check when replacing one + non-GSM character with two characters - an escape character 0x1B + and a character from the extension table. +*/ +GLOBAL void utl_chsetToGsm ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen, +#ifdef REL99 + USHORT outBufLen, +#endif + T_ACI_GSM_ALPHA gsm ) +{ + UBYTE cvtdVal; + USHORT outIdx = 0; + USHORT inIdx; + UBYTE corr = ( gsm EQ GSM_ALPHA_Int ? 0xFF : 0x7F ); + T_ACI_CSCS_CHSET cscsChset; + UBYTE srcId = srcId_cb; + + cscsChset = ati_user_output_cfg[srcId].cscsChset; + + if ( ati_user_output_cfg[srcId].cscsChset EQ CSCS_CHSET_Hex ) + { + utl_hexToGsm ( in, inLen, out, outLen, gsm, CSCS_ALPHA_8_Bit ); + } + else if ( cscsChset EQ CSCS_CHSET_Ucs2 ) + { + utl_ucs2ToGsm ( in, inLen, out, outLen, gsm, CSCS_ALPHA_8_Bit ); + } + else + { +#ifndef REL99 + for ( inIdx = 0; inIdx < inLen; inIdx++ ) + { + cvtdVal = chset[cscsChset][( UBYTE ) in[inIdx]]; + if ( cvtdVal NEQ 0x00 ) + { + out[outIdx] = ( CHAR ) cvtdVal & corr; + outIdx++; + } + } +#else + for ( inIdx = 0; inIdx < inLen AND outIdx < outBufLen; inIdx++ ) + { + cvtdVal = chset[cscsChset][( UBYTE ) in[inIdx]]; + + if ( cvtdVal NEQ 0x00 ) + { + out[outIdx] = ( CHAR ) cvtdVal & corr; + outIdx++; + } + else + { + /* There is a chance that this is in the mapping table */ + UBYTE ext_tbl_idx = 0; + while( ext_tbl_idx < NUM_EXT_TABLE_CHARS AND + ext_common_chset_map[ext_tbl_idx][1] NEQ in[inIdx] ) + { + ext_tbl_idx++; + } + if(ext_tbl_idx < NUM_EXT_TABLE_CHARS) + { + /*Insert the escape character, 0x1B, to output stream*/ + out[outIdx++] = 0x1B |(corr &0x80); + /* Check that output buffer limit has not been reached */ + if(outIdx < outBufLen) + { + /* Insert the mapping character into the output stream */ + out[outIdx++] = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80); + } + } + else if ( ( cscsChset EQ CSCS_CHSET_Ira ) OR ( cscsChset EQ CSCS_CHSET_8859_1 ) ) + { + /* Check if the character is present in ext_ira_8859_chset_map */ + ext_tbl_idx = 0; + + while( ext_tbl_idx < NUM_IRA_8859_TABLE_CHARS AND + ext_ira_8859_chset_map[ext_tbl_idx][1] NEQ in[inIdx] ) + { + ext_tbl_idx++; + } + + if( ext_tbl_idx < NUM_IRA_8859_TABLE_CHARS ) + { + /*Insert the escape character, 0x1B, to output stream*/ + out[outIdx++] = 0x1B |(corr &0x80); + /* Check that output buffer limit has not been reached */ + if(outIdx < outBufLen) + { + /* Insert the mapping character into the output stream */ + out[outIdx++] = ( UBYTE )ext_ira_8859_chset_map[ext_tbl_idx][0] |(corr &0x80); + } + } + } + } + } +#endif /* ifndef REL99 */ + + if ( gsm EQ GSM_ALPHA_Int ) + out[outIdx] = '\0'; + + *outLen = outIdx; + } +} +#endif + + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_hexFromAlpha | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the SIM with UCS2 form 0x81 or 0x82 to 16 Bit hex values. + see GSM 11.11 Annex B Coding of Alpha fields in the SIM for UCS2 + UCS2 form 0x81: + - octet 1 = 0x81 + - octet 2 = length + - octet 3 = Bits 15 to 8 of the base pointer to a half page in the UCS2 code space + 0hhh hhhh h000 0000 , with h = bits of the half page base pointer + 16... .... .... ...1 + + UCS2 form 0x82: + - octet 1 = 0x81 + - octet 2 = length + - octet 3 = upper 8 Bit of 16 Bit base pointer to a half page in the UCS2 code space + - octet 4 = lower 8 Bit of 16 Bit base pointer to a half page in the UCS2 code space +*/ +GLOBAL void utl_hexFromUCS2 ( UBYTE *in, + UBYTE *out, + USHORT maxOutlen, + USHORT *outlen, + T_ACI_GSM_ALPHA gsm) +{ + USHORT outIdx = 0; + USHORT base_pointer; + USHORT length = in[1]; + USHORT tmp; + UBYTE corr = ( gsm EQ GSM_ALPHA_Int ? 0x00 : 0x80 ); + + if (*in EQ 0x81) + { + base_pointer = in[2] << 7; + in += 3; + } + else /* if (*in EQ 0x82) */ + { + base_pointer = in[2]<<8 | in[3]; + in += 4; + } + + while ( length-- AND outIdx < maxOutlen-2) + { + if (*in & 0x80) + { + tmp = base_pointer + (*in & 0x7F); + } + else if((*in | corr) NEQ 0x9B) + { + tmp = 0x0000 + gsmToAsciiTable[*in]; + } + #ifdef REL99 + else + { + UBYTE ext_tbl_idx = 0; + BOOL mapping_char_found = FALSE; + in++; + + while( ext_tbl_idx < NUM_EXT_TABLE_CHARS AND + ext_common_chset_map[ext_tbl_idx][0] NEQ (*in & 0x7F)) + { + ext_tbl_idx++; + } + if( ext_tbl_idx < NUM_EXT_TABLE_CHARS ) + { + /* Insert the mapping character into the output stream */ + tmp = 0x0000 + ( UBYTE )ext_common_chset_map[ext_tbl_idx][1]; + } + } +#endif + out[outIdx++] = hexVal[(tmp >> 12) & 0x0F ]; + out[outIdx++] = hexVal[(tmp >> 8) & 0x0F ]; + out[outIdx++] = hexVal[(tmp >> 4) & 0x0F ]; + out[outIdx++] = hexVal[(tmp ) & 0x0F ]; + + in++; + } + + out[outIdx] = '\0'; + *outlen = outIdx; +} +#endif + + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_chsetFromSim | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the SIM format to the character set + used within the AT command interpreter. +*/ +GLOBAL void utl_chsetFromSim ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT maxOutLen, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm ) +{ + T_ACI_CSCS_CHSET cscsChset; + UBYTE srcId = srcId_cb; + + cscsChset = ati_user_output_cfg[srcId].cscsChset; + + if ( cscsChset EQ CSCS_CHSET_Ucs2 AND + (( *in EQ 0x80 ) OR ( *in EQ 0x81 ) OR ( *in EQ 0x82 )) ) + { + /* UCS2 with form 0x81 or 0x82 as HEX string */ + if (( *in EQ 0x81 ) OR ( *in EQ 0x82 )) + { + utl_hexFromUCS2 ( in, out, maxOutLen, outLen, gsm); + return; + } + + /* UCS2 form 0x80 as HEX string */ + utl_hexFromGsm ( in + 1, (USHORT)( inLen - 1 ), out, maxOutLen, outLen, + gsm, CSCS_ALPHA_8_Bit ); + } + else + { + utl_chsetFromGsm ( in, inLen, out, maxOutLen, outLen, gsm ); + } +} +#endif /* #ifdef FF_ATI */ + +#if defined(FF_ATI) || defined(FF_BAT) +#ifdef TI_PS_OP_CNV_TAB_ROMBASED +#endif + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_chsetFromGsm | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the ACI internal GSM character set to the character set + used within the AT command interpreter. +*/ + +GLOBAL USHORT utl_chsetFromGsm( + UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT maxOutLen, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm) +{ + USHORT outIdx = 0; + USHORT inIdx = 0; + USHORT actLen = ( gsm EQ GSM_ALPHA_Int ? + ( USHORT ) strlen ( ( CHAR* ) in ) : inLen ); + UBYTE corr = ( gsm EQ GSM_ALPHA_Int ? 0x00 : 0x80 ); + T_ACI_CSCS_CHSET cscsChset; + UBYTE srcId = srcId_cb; + USHORT tblIdx; + + cscsChset = ati_user_output_cfg[srcId].cscsChset; + + if ( cscsChset EQ CSCS_CHSET_Hex ) + { + return utl_hexFromGsm ( in, inLen, out, maxOutLen, outLen, gsm, CSCS_ALPHA_8_Bit ); + } + else if ( cscsChset EQ CSCS_CHSET_Ucs2 ) + { + return utl_ucs2FromGsm ( in, inLen, out, maxOutLen, outLen, gsm, CSCS_ALPHA_8_Bit ); + } + else + { +#ifndef REL99 + + while ( inIdx < actLen AND outIdx < maxOutLen - 1 ) + { + tblIdx = 0; + + + while ( tblIdx <= 0xFF AND + chset[cscsChset][tblIdx] NEQ (( UBYTE )in[inIdx] | corr )) + tblIdx++; + if ( tblIdx <= 0xFF ) + { + out[outIdx] = ( UBYTE )tblIdx; + outIdx++; + } + + inIdx++; + } + +#else + /* TODO: What if the CSCS is GSM7 itself. Do we have to do this? The following check + if( cscsChset NEQ CSCS_CHSET_Gsm AND gsm EQ GSM_ALPHA_Def */ + while ( inIdx < actLen AND outIdx < maxOutLen - 1 ) + { + /* Check if the character is a escape to an extension of the GSM 7 bit + * default alphabet table. */ + if( cscsChset NEQ CSCS_CHSET_Gsm AND ((in[inIdx] | corr) EQ 0x9B) ) + { + UBYTE ext_tbl_idx = 0; + BOOL mapping_char_found = FALSE; + inIdx++; + + /* Check if the end of the array is reached */ + if(inIdx EQ actLen) + { + break; + } + + while( ext_tbl_idx < NUM_EXT_TABLE_CHARS AND + ext_common_chset_map[ext_tbl_idx][0] NEQ (in[inIdx] & 0x7F)) + { + ext_tbl_idx++; + } + if( ext_tbl_idx < NUM_EXT_TABLE_CHARS ) + { + /* Insert the mapping character into the output stream */ + out[outIdx++] = ( UBYTE )ext_common_chset_map[ext_tbl_idx][1]; + mapping_char_found = TRUE; + } + else if( cscsChset EQ CSCS_CHSET_Ira OR cscsChset EQ CSCS_CHSET_8859_1 ) + { + ext_tbl_idx = 0; + + while( ext_tbl_idx < NUM_IRA_8859_TABLE_CHARS AND + ext_ira_8859_chset_map[ext_tbl_idx][0] NEQ (in[inIdx]&0x7F)) + { + ext_tbl_idx++; + } + + if(ext_tbl_idx < NUM_IRA_8859_TABLE_CHARS) + { + /* Insert the mapping character into the output stream */ + out[outIdx++] = ( UBYTE )ext_ira_8859_chset_map[ext_tbl_idx][1]; + mapping_char_found = TRUE; + } + } + + if(mapping_char_found EQ FALSE) + { + /* From 23.038: In the event that an MS receives a code where a symbol + is not represented in the extension table then the MS shall display + the character shown in the main GSM 7 bit default alphabet table */ + tblIdx = 0; + while ( tblIdx <= 0xFF AND + chset[cscsChset][tblIdx] NEQ (( UBYTE )in[inIdx] | corr )) + tblIdx++; + + if ( tblIdx <= 0xFF ) + { + out[outIdx] = ( UBYTE )tblIdx; + outIdx++; + } + + } + } + else + { + tblIdx = 0; + + while ( tblIdx <= 0xFF AND + chset[cscsChset][tblIdx] NEQ (( UBYTE )in[inIdx] | corr )) + tblIdx++; + + if ( tblIdx <= 0xFF ) + { + out[outIdx] = ( UBYTE )tblIdx; + outIdx++; + } + + } + + inIdx++; + } +#endif + + out[outIdx] = '\0'; + *outLen = outIdx; + + return inIdx; + } +} +#endif + + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_sprints | ++-------------------------------------------------------------------+ + + PURPOSE : This function writes a not null terminated string to a + buffer. +*/ +GLOBAL USHORT sprints ( CHAR* buf, CHAR* arg, USHORT len ) +{ + buf[0] = '\"'; + + memcpy ( &buf[1], arg, len ); + + buf[len + 1] = '\"'; + buf[len + 2] = '\0'; + + return (len + 2); +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_sprintq | ++-------------------------------------------------------------------+ + + PURPOSE : This function writes a not null terminated string to a + buffer. +*/ +GLOBAL USHORT sprintq ( CHAR* buf, CHAR* arg, USHORT len ) +{ + memcpy ( &buf[0], arg, len ); + + buf[len] = '\0'; + + return (len); +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_hexToIntGsm | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the "HEX" character set to the ACI internal GSM + character set. +*/ +GLOBAL void utl_hexToGsm ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm, + T_ACI_CSCS_ALPHA alphabet ) +{ + SHORT val = 0; + UBYTE digit; + USHORT inIdx = 0; + USHORT outIdx = 0; + SHORT base = 0x10; + + while ( inIdx < inLen ) + { + if ( in[inIdx] >= 0x30 AND in[inIdx] <= 0x39 ) /* '0' ... '9' */ + { + digit = in[inIdx] - 0x30; /* ->0 ... 9 */ + } + else if ( in[inIdx] >= 0x61 AND in[inIdx] <= 0x66 ) /* 'a' ... 'f' */ + { + digit = in[inIdx] - 0x61 + 0x0A; /* ->0x0a...0x0f */ + } + else if ( in[inIdx] >= 0x41 AND in[inIdx] <= 0x46 ) /* 'A' ... 'F' */ + { + digit = in[inIdx] - 0x41 + 0x0A; /* ->0x0a...0x0f */ + } + else + { + digit = 0xFF; + } + + if ( digit NEQ 0xFF ) /* skip invalid digit */ + { + if ( base EQ 0x10 ) + { + val = digit << 4; + } + else + { + val |= digit; + + if ( alphabet EQ CSCS_ALPHA_7_Bit AND !( val & 0x80 ) ) + { + if ( gsm EQ GSM_ALPHA_Int ) + { + out[outIdx++] = ( CHAR ) val | 0x80; + } + else + { + out[outIdx++] = ( CHAR ) val; + } + } + else if ( alphabet NEQ CSCS_ALPHA_7_Bit ) + { + out[outIdx++] = ( CHAR ) val; + } + } + + base ^= 0x10; + } + + inIdx++; + } + + if ( gsm EQ GSM_ALPHA_Int ) + out[outIdx] = '\0'; + + *outLen = outIdx; +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_ucs2ToGsm | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the "UCS2" character set to the ACI internal GSM + character set. +*/ +GLOBAL void utl_ucs2ToGsm ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm, + T_ACI_CSCS_ALPHA alphabet ) +{ + int i, j; + UBYTE val; + USHORT len; + UBYTE tmpIn[2]; /* store temporary two chars (HEX conversion) */ + UBYTE tmpInIdx; /* holds a temporary index for two chars (HEX conversion)*/ + UBYTE digit; /* holds a digit (HEX conversion) */ + SHORT tmpVal; /* hold a temporary value (HEX conversion) */ + UBYTE tmpOut; /* the HEX output (HEX conversion) */ + SHORT base = 0x10; + USHORT outIdx = 0; + UBYTE corr = ( gsm EQ GSM_ALPHA_Int ? 0xFF : 0x7F ); + + /* TRACE_FUNCTION(" utl_ucs2ToGsm() "); */ + + len = inLen/4; + + for (i=0;i<len;i++) + { + /* check if this is a UCS2 character in 00xy format */ + if ( ( in[i*4] EQ '0' ) AND ( in[i*4+1] EQ '0' ) ) + { + /* convert the next two character to HEX */ + tmpIn[0] = in[i*4+2]; + tmpIn[1] = in[i*4+3]; + + tmpVal = tmpOut = val = 0; + + /* convert the two characters into the real hexadecimal ASCII value */ + for( tmpInIdx=0; tmpInIdx<2; tmpInIdx++ ) + { + if ( tmpIn[tmpInIdx] >= '0' AND tmpIn[tmpInIdx] <= '9' ) + { + digit = tmpIn[tmpInIdx] - '0'; + } + else if ( tmpIn[tmpInIdx] >= 'a' AND tmpIn[tmpInIdx] <= 'f' ) + { + digit = tmpIn[tmpInIdx] - 'a' + 0x0A; + } + else if ( tmpIn[tmpInIdx] >= 'A' AND tmpIn[tmpInIdx] <= 'F' ) + { + digit = tmpIn[tmpInIdx] - 'A' + 0x0A; + } + else + { + digit = 0xFF; + } + + if ( digit NEQ 0xFF ) + { + if ( base EQ 0x10 ) + { + tmpVal = digit * 0x10; + } + else + { + tmpVal += digit; + tmpOut = (UBYTE) tmpVal; + } + + base ^= 0x10; + } + } + + /* convert the hexadecimal ASCII value to GSM */ + if (!(tmpOut & 0x80)) + { + if ( tmpOut EQ ( gsmToAsciiTable[tmpOut])) /* ASCII and GSM are identical */ + { + val = tmpOut; + } + else /* find match in the table and copy index of match */ + { + for (j=0; j<128; j++) + { + if (tmpOut EQ gsmToAsciiTable[j]) + { + val = (UBYTE)j; + break; + } + #ifdef REL99 + else + { + /* There is a chance that this is in the mapping table */ + UBYTE ext_tbl_idx = 0; + while( ext_tbl_idx < NUM_EXT_TABLE_CHARS AND + ext_common_chset_map[ext_tbl_idx][1] NEQ tmpOut ) + { + ext_tbl_idx++; + } + if(ext_tbl_idx < NUM_EXT_TABLE_CHARS) + { + /*Insert the escape character, 0x1B, to output stream*/ + out[outIdx++] = 0x1B |(corr &0x80); + /* Insert the mapping character into the output stream */ + val = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80); + break; + } + } +#endif /* REL99 */ + } + } + } + else /* find match in the table and copy index of match */ + { + for (j=0; j<128; j++) + { + if (tmpOut EQ gsmToAsciiTable[j]) + { + val = (UBYTE)j; + break; + } +#ifdef REL99 + else + { + /* There is a chance that this is in the mapping table */ + UBYTE ext_tbl_idx = 0; + while( ext_tbl_idx < NUM_EXT_TABLE_CHARS AND + ext_common_chset_map[ext_tbl_idx][1] NEQ tmpOut ) + { + ext_tbl_idx++; + } + if(ext_tbl_idx < NUM_EXT_TABLE_CHARS) + { + /*Insert the escape character, 0x1B, to output stream*/ + out[outIdx++] = 0x1B |(corr &0x80); + /* Insert the mapping character into the output stream */ + val = ( UBYTE )ext_common_chset_map[ext_tbl_idx][0] |(corr &0x80); + break; + } + } +#endif /* REL99 */ + } + } + + /* if necessary, cut the GSM value to 7bit */ + if ( alphabet EQ CSCS_ALPHA_7_Bit AND !( val & 0x80 ) ) + { + if ( gsm EQ GSM_ALPHA_Int ) + { + out[outIdx++] = val | 0x80; + } + else + { + out[outIdx++] = val; + } + } + else + { + out[outIdx++] = val; + } + } + + else /* unknown char, skip it */ + { + /* TRACE_EVENT("UCS2 MISMATCH: Unknown UCS2 entry, character skipped!"); */ + /* out[outIdx++] = '?'; */ + } + } + + if ( gsm EQ GSM_ALPHA_Int ) + { + out[outIdx] = '\0'; + } + + /* set the outlength */ + *outLen = outIdx; + +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_hexFromGsm | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the ACI internal GSM character set to the "HEX" + character set. +*/ +GLOBAL USHORT utl_hexFromGsm ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT maxOutLen, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm, + T_ACI_CSCS_ALPHA alphabet ) +{ + USHORT inIdx = 0; + USHORT outIdx = 0; + + while ( inIdx < inLen AND outIdx < maxOutLen - 2 ) + { + if ( alphabet NEQ CSCS_ALPHA_7_Bit OR + ( gsm EQ GSM_ALPHA_Def AND !( in[inIdx] & 0x80 ) ) OR + ( gsm EQ GSM_ALPHA_Int AND ( in[inIdx] & 0x80 ) ) ) + { + /* Convert to 7bit default alphabet only if the data is + coded in internal GSM character set */ + if ( gsm EQ GSM_ALPHA_Int AND ( in[inIdx] & 0x80 ) ) + { + out[outIdx++] = hexVal[ (in[inIdx] & 0x7F) >> 4 ]; + } + else + { + out[outIdx++] = hexVal[ in[inIdx] >> 4 ]; + } + out[outIdx++] = hexVal[ in[inIdx] & 0x0F ]; + } + + inIdx++; + } + + out[outIdx] = '\0'; + *outLen = outIdx; + + return inIdx; +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_ucs2FromGsm | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the ACI internal GSM character set to the "UCS2" + character set. +*/ +LOCAL USHORT utl_ucs2FromGsm (UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT maxOutLen, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm, + T_ACI_CSCS_ALPHA alphabet ) +{ + USHORT inIdx = 0; + USHORT outIdx = 0; + UBYTE corr = ( gsm EQ GSM_ALPHA_Int ? 0x00 : 0x80 ); + + while ( inIdx < inLen AND outIdx < maxOutLen - 4 ) + { + if ( alphabet NEQ CSCS_ALPHA_7_Bit OR + ( gsm EQ GSM_ALPHA_Def AND !( in[inIdx] & 0x80 ) ) OR + ( gsm EQ GSM_ALPHA_Int AND ( in[inIdx] & 0x80 ) ) ) + { + /* Insert two leading Os, convert GSM to ASCII and print out as HEX */ + out[outIdx++] = '0'; + out[outIdx++] = '0'; + #ifdef REL99 + if( (in[inIdx] | corr) EQ 0x9B) + { + UBYTE ext_tbl_idx = 0; + inIdx++; + while( ext_tbl_idx < NUM_EXT_TABLE_CHARS AND + ext_common_chset_map[ext_tbl_idx][0] NEQ (in[inIdx] & 0x7F)) + { + ext_tbl_idx++; + } + if( ext_tbl_idx < NUM_EXT_TABLE_CHARS ) + { + /* Insert the mapping character into the output stream */ + out[outIdx++] = hexVal[(ext_common_chset_map[ext_tbl_idx][1] & 0x7F) >> 4 ]; + out[outIdx++] = hexVal[(ext_common_chset_map[ext_tbl_idx][1] & 0x7F) & 0x0F ]; + } + } + else + { + #endif /* REL99 */ + out[outIdx++] = hexVal[ gsmToAsciiTable[in[inIdx] & 0x7F] >> 4 ]; + out[outIdx++] = hexVal[ gsmToAsciiTable[in[inIdx] & 0x7F] & 0x0F ]; + #ifdef REL99 + } + #endif /* REL99 */ + + } + + inIdx++; + } + + out[outIdx] = '\0'; + *outLen = outIdx; + + return inIdx; + +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_ucs2FromGsm_ussd | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of USSD string from + the ACI internal GSM character set to the "UCS2" + character set with 2 bytes only. +*/ +GLOBAL USHORT utl_ucs2FromGsm_ussd(UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT maxOutLen, + USHORT* outLen, + T_ACI_GSM_ALPHA gsm, + T_ACI_CSCS_ALPHA alphabet ) +{ + USHORT inIdx = 0; + USHORT outIdx = 0; + + while ( inIdx < inLen AND outIdx < maxOutLen - 4 ) + { + if ( alphabet NEQ CSCS_ALPHA_7_Bit OR + ( gsm EQ GSM_ALPHA_Def AND !( in[inIdx] & 0x80 ) ) OR + ( gsm EQ GSM_ALPHA_Int AND ( in[inIdx] & 0x80 ) ) ) + { + /* 2 bytes for convertion from GSM to UCS2 */ + out[outIdx++] = 0x00; + out[outIdx++] = gsmToAsciiTable[in[inIdx] & 0x7F]; + } + + inIdx++; + } + + out[outIdx] = '\0'; + *outLen = outIdx; + + return inIdx; + +} +#endif +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_smDtaToTe | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the SM data in the format + specified in Rec. GSM 07.05, message data parameter + <data>, to the format used by the AT Command Interface. +*/ +GLOBAL void utl_smDtaToTe ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT maxOutLen, + USHORT* outLen, + UBYTE fo, + UBYTE dcs ) +{ + UBYTE alphabet = cmhSMS_getAlphabetPp ( dcs ); + + if ( alphabet EQ CSCS_ALPHA_7_Bit AND + (fo & TP_UDHI_MASK) EQ TP_UDHI_WITHOUT_HEADER ) + { + utl_chsetFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def ); + } + else if ( alphabet NEQ CSCS_ALPHA_7_Bit OR + (fo & TP_UDHI_MASK) EQ TP_UDHI_WITH_HEADER ) + { + utl_hexFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def, + CSCS_ALPHA_8_Bit ); + } + else + { + *outLen = MINIMUM ( inLen, maxOutLen - 1 ); + memcpy ( out, in, *outLen ); + out[*outLen] = '\0'; + } +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_smDtaFromTe | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the SM data in the format used + by the AT Command Interface to the format specified in + Rec. GSM 07.05, message data parameter <data>. +*/ +GLOBAL void utl_smDtaFromTe ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen, +#ifdef REL99 + USHORT outBufLen, +#endif + UBYTE fo, + UBYTE dcs ) +{ + UBYTE alphabet = cmhSMS_getAlphabetPp ( dcs ); + + if ( alphabet EQ CSCS_ALPHA_7_Bit AND + ( fo & TP_UDHI_MASK ) EQ TP_UDHI_WITHOUT_HEADER ) + { +#ifdef REL99 + utl_chsetToGsm ( in, inLen, out, outLen, outBufLen, GSM_ALPHA_Def ); +#else + utl_chsetToGsm ( in, inLen, out, outLen, GSM_ALPHA_Def ); +#endif + + } + else if ( alphabet NEQ CSCS_ALPHA_7_Bit OR + ( fo & TP_UDHI_MASK ) EQ TP_UDHI_WITH_HEADER ) + { + utl_hexToGsm ( in, inLen, out, outLen, GSM_ALPHA_Def, (T_ACI_CSCS_ALPHA)alphabet ); + } + else + { + memcpy ( out, in, inLen ); + *outLen = inLen; + } +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_ussdDtaFromTe | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the USSD data in the format used + by the AT Command Interface to the format specified in + Rec. GSM 07.07. +*/ +GLOBAL void utl_ussdDtaFromTe ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT* outLen, +#ifdef REL99 + USHORT outBufLen, +#endif + UBYTE dcs ) +{ + /* Implements Measure 25 */ + UBYTE alphabet = cmh_getAlphabetCb ( dcs ); + + if ( alphabet EQ CSCS_ALPHA_7_Bit ) + { +#ifdef REL99 + utl_chsetToGsm ( in, inLen, out, outLen, outBufLen, GSM_ALPHA_Def ); +#else + utl_chsetToGsm ( in, inLen, out, outLen, GSM_ALPHA_Def ); +#endif + + } + else + { + utl_hexToGsm ( in, inLen, out, outLen, GSM_ALPHA_Def, (T_ACI_CSCS_ALPHA)alphabet ); + } +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_ussdDtaToTe | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the USSD data in the format + specified in Rec. GSM 07.07 to the format used + by the AT Command Interface. +*/ + +GLOBAL USHORT utl_ussdDtaToTe ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT maxOutLen, + USHORT* outLen, + UBYTE dcs ) +{ + /* Implements Measure 25 */ + UBYTE alphabet = cmh_getAlphabetCb ( dcs ); + if ( alphabet EQ CSCS_ALPHA_7_Bit ) + { + return utl_chsetFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def ); + } + else + { + return utl_hexFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def, (T_ACI_CSCS_ALPHA)alphabet ); + } +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_cbmDtaToTe | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the CBM data in the format + specified in Rec. GSM 07.05, message data parameter + <data>, to the format used by the AT Command Interface. +*/ +GLOBAL void utl_cbmDtaToTe ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT maxOutLen, + USHORT* outLen, + UBYTE fo, + UBYTE dcs ) +{ + /* Implements Measure 25 */ + UBYTE alphabet = cmh_getAlphabetCb ( dcs ); + if ( alphabet EQ CSCS_ALPHA_7_Bit AND + ( fo & TP_UDHI_MASK ) EQ TP_UDHI_WITHOUT_HEADER ) + { + utl_chsetFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def ); + } + else if ( alphabet NEQ CSCS_ALPHA_7_Bit OR + ( fo & TP_UDHI_MASK ) EQ TP_UDHI_WITH_HEADER ) + { + utl_hexFromGsm ( in, inLen, out, maxOutLen, outLen, GSM_ALPHA_Def, (T_ACI_CSCS_ALPHA)alphabet ); + } + else + { + *outLen = MINIMUM ( inLen, maxOutLen ); + memcpy ( out, in, *outLen ); + } +} +#endif + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_cvtGsmIra | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the characters of a string from + the ACI internal GSM character set to the IRA character + set or vice versa. +*/ +GLOBAL BOOL utl_cvtGsmIra ( UBYTE* in, + USHORT inLen, + UBYTE* out, + USHORT outLen, + T_ACI_CSCS_DIR dir ) +{ + USHORT inIdx = 0; + USHORT outIdx = 0; + USHORT tblIdx; + UBYTE cvtdVal; + + TRACE_FUNCTION("utl_cvtGsmIra()"); + + + if ( inLen > outLen ) + { + return ( FALSE ); + } + + if ( dir EQ CSCS_DIR_GsmToIra ) + { + while ( inIdx < inLen ) + { + tblIdx = 0; + + while ( tblIdx <= 0xFF AND + chset[CSCS_CHSET_Ira][tblIdx] NEQ (( UBYTE )in[inIdx] | 0x80 )) + tblIdx++; + + if ( tblIdx <= 0xFF ) + { + out[outIdx] = ( UBYTE )tblIdx; + outIdx++; + } + else + { + return ( FALSE ); + } + + inIdx++; + } + } + else if ( dir EQ CSCS_DIR_IraToGsm ) + { + for ( inIdx = 0; inIdx < inLen; inIdx++ ) + { + cvtdVal = chset[CSCS_CHSET_Ira][( UBYTE ) in[inIdx]]; + + if ( cvtdVal NEQ 0x00 ) + { + out[outIdx] = ( CHAR ) cvtdVal & 0x7F; + outIdx++; + } + else + { + return ( FALSE ); + } + } + + } + else + { + return ( FALSE ); + } + + return ( TRUE ); +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_binToHex | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts a binary string of bytes with a + given length into an null terminated ASCII string + representation. +*/ +GLOBAL void utl_binToHex (UBYTE* in, + SHORT inLen, + CHAR* out ) +{ + SHORT idx = 0; + UBYTE hNib; + UBYTE lNib; + + while( idx < inLen ) + { + hNib = (in[idx]&0xF0)>>4; + + if( hNib > 9 ) *out = (hNib-10)+0x41; + else *out = hNib + 0x30; + + out++; + + lNib = in[idx]&0x0F; + + if( lNib > 9 ) *out = (lNib-10)+0x41; + else *out = lNib + 0x30; + + out++; + idx++; + } + *out = 0x0; +} + + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM MODULE : ACI_UTIL | +| STATE : code ROUTINE : utl_HexStrToBin | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts a null terminated string of HEX + values in a binary buffer. + RETURN: byte count. +*/ +GLOBAL USHORT utl_HexStrToBin (UBYTE *in, + USHORT inLen, + UBYTE *out, + USHORT outLen) +{ + USHORT inIdx = 0; + USHORT outIdx = 0; + UBYTE value; + BOOL hNib = TRUE; + + while ((inIdx < inLen) AND (outIdx < outLen)) + { + if ((in[inIdx] >= 0x30) AND (in[inIdx] <= 0x39)) + { + value = in[inIdx] - 0x30; + } + else if ((in[inIdx] >= 0x61) AND (in[inIdx] <= 0x66)) + { + value = in[inIdx] - 0x61 + 0x0A; + } + else if ((in[inIdx] >= 0x41) AND (in[inIdx] <= 0x46)) + { + value = in[inIdx] - 0x41 + 0x0A; + } + else + { + return (0); + } + + if (hNib) + { + out[outIdx] = (value << 0x04) & 0xF0; + hNib = FALSE; + } + else + { + out[outIdx] |= value & 0x0F; + hNib = TRUE; + outIdx++; + } + inIdx++; + } + + return (outIdx); +} +#endif + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : trace_cmd_line | ++-------------------------------------------------------------------+ + + PURPOSE : This function trace the command line and check + this string for % character +*/ + +GLOBAL void trace_cmd_line (char *prefix, char *output, UBYTE srcId, USHORT output_len) +{ + char trcBuf[80]; + int dst_i; + + dst_i = sprintf (trcBuf, "%s(Src %d)[lth %d]", (prefix) ? prefix : "", srcId, output_len); + + strncpy(&trcBuf[dst_i], output, 79-dst_i); + trcBuf[79] = '\0'; + + if (trcBuf[76]) + { + trcBuf[76] = trcBuf[77] = trcBuf[78] = '.'; /* add trailing "..." if string is >=76 */ + } + + /* Send the trace if either EVENT or CLASS8 is turned on */ + TRACE_USER_CLASS_P1(TC_EVENT|TC_USER8, "%s",trcBuf); +} +#endif + + +#ifdef FF_ATI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : trace_cmd_state | ++-------------------------------------------------------------------+ + + PURPOSE : This function trace the command line state +*/ + +GLOBAL void trace_cmd_state (UBYTE srcId, + T_ATI_CMD_STATE old_state, + T_ATI_CMD_STATE new_state) +{ + char trcBuf[50]; + + if (old_state EQ new_state) + { + return; + } + + sprintf (trcBuf, "(Src %d) cmd_state: ", srcId ); + + switch (old_state) + { + case (CMD_IDLE): + strcat (trcBuf, "CMD_IDLE -> "); + break; + case (CMD_TYPING): + strcat (trcBuf, "CMD_TYPING -> "); + break; + case (CMD_RUNNING): + strcat (trcBuf, "CMD_RUNNING -> "); + break; + default: + strcat (trcBuf, "CMD_UNKNOWN ! "); + } + + switch (new_state) + { + case (CMD_IDLE): + strcat (trcBuf, "CMD_IDLE"); + break; + case (CMD_TYPING): + strcat (trcBuf, "CMD_TYPING"); + break; + case (CMD_RUNNING): + strcat (trcBuf, "CMD_RUNNING"); + break; + default: + strcat (trcBuf, "CMD_UNKNOWN !"); + } + + TRACE_EVENT_P1("%s",trcBuf); +} +#endif + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | +| STATE : code ROUTINE : toa_merge | ++--------------------------------------------------------------------+ + + PURPOSE : builds type of address octet from TOA structure + +*/ + +GLOBAL UBYTE toa_merge (T_ACI_TOA type) +{ + +return ((type.ton << 4) & 0xF0) + | ( type.npi & 0x0F) + | 0x80; +} + + + +#ifdef GPRS +/* + +----------------------------------------------------------------------------- + | Function : utl_create_pco + +----------------------------------------------------------------------------- + | Description : The function create_pco() creates protocol configuration + | options needed to activate a PDPcontext. + | + | Parameters : buffer - buffer to write the PCOs + | length - on call: buffer size; on return: written bytes + | content - mask to specify the PCO content + | config_prot - used configuration protocol (currently PPP) + | auth_prot - authentication protocol (currently PAP) + | user_name - string with the user name + | password - string with the password + | dns1 - requested primary DNS address + | dns2 - requested secondary DNS address + | + | Return : 0 - operation successful + | -1 - operation fails + | + +----------------------------------------------------------------------------- +*/ +GLOBAL int utl_create_pco (UBYTE* buffer, + USHORT* length, + ULONG content, + UBYTE config_prot, + USHORT auth_prot, + UBYTE* user_name, + UBYTE* password, + ULONG dns1, + ULONG dns2) +{ + USHORT size; + USHORT temp_len; + USHORT len_user; + USHORT len_pwd; + USHORT written; + UBYTE* pos; + UBYTE* len_pos1; + UBYTE* len_pos2; + + TRACE_FUNCTION( "create_pco" ); + + /* + * store buffer size + */ + size = *length; + /* + * initialize values + */ + *length = 0; + written = 0; + pos = buffer; + /* + * calculate if requested content is writeable + */ + temp_len = 1; + if(content & ACI_PCO_CONTENTMASK_AUTH) + { + len_user = strlen((char*)user_name); + len_pwd = strlen((char*)password); + temp_len+= ACI_PCO_PAP_OVERHEAD + len_user + len_pwd; + } + if((content & ACI_PCO_CONTENTMASK_DNS1) || + (content & ACI_PCO_CONTENTMASK_DNS2)) + { + temp_len+= ACI_PCO_IPCP_OVERHEAD; + if(content & ACI_PCO_CONTENTMASK_DNS1) + temp_len+= ACI_PCO_IPCP_LENGTH_DNS1; + if(content & ACI_PCO_CONTENTMASK_DNS2) + temp_len+= ACI_PCO_IPCP_LENGTH_DNS2; + } + TRACE_EVENT_P2("temp_len=%d size=%d", temp_len, size); + if(temp_len > size) + { + /* + * content is to long + */ + return -1; + } + /* + * set configuration protocol identifier + */ + *pos = 0x80 | config_prot; + pos++; + written++; + + /* + * authentication + */ + if(content & ACI_PCO_CONTENTMASK_AUTH) + { + /* + * set authentication protocol + */ + *pos = (UBYTE)((auth_prot >> 8) & 0x00ff); + pos++; + written++; + *pos = (UBYTE)(auth_prot & 0x00ff); + pos++; + written++; + /* + * store first length position + */ + len_pos1 = pos; + pos++; + written++; + /* + * Code field + */ + *pos = ACI_PCO_PAP_AUTH_REQ; + pos++; + written++; + /* + * Identifier field (just some value) + */ + *pos = 0x01; + pos++; + written++; + /* + * Length field (store length position) + */ + *pos = 0x00; + pos++; + written++; + len_pos2 = pos; + pos++; + written++; + /* + * User Name Length field + */ + *pos = (UBYTE)(/*lint -e(644) */len_user & 0x00ff); + pos++; + written++; + /* + * User Name field + */ + memcpy(pos, user_name, len_user); + pos += len_user; + written+= len_user; + /* + * Password Length field + */ + *pos = (UBYTE)(/*lint -e(644) */len_pwd & 0x00ff); + pos++; + written++; + /* + * Password field + */ + memcpy(pos, password, len_pwd); + pos += len_pwd; + written+= len_pwd; + /* + * fill length fields + */ + *len_pos1 = (UBYTE)(pos - len_pos1 - 1); + *len_pos2 = *len_pos1; + } + /* + * DNS addresses + */ + if((content & ACI_PCO_CONTENTMASK_DNS1) || + (content & ACI_PCO_CONTENTMASK_DNS2)) + { + /* + * set IPCP protocol + */ + *pos = ACI_PCO_IPCP_PROT_MSB; + pos++; + written++; + *pos = ACI_PCO_IPCP_PROT_LSB; + pos++; + written++; + /* + * store first length position + */ + len_pos1 = pos; + pos++; + written++; + /* + * Code field + */ + *pos = ACI_PCO_IPCP_CONF_REQ; + pos++; + written++; + /* + * Identifier field (just some value) + */ + *pos = 0x01; + pos++; + written++; + /* + * Length field (store length position) + */ + *pos = 0x00; + pos++; + written++; + len_pos2 = pos; + pos++; + written++; + /* + * primary DNS address + */ + if(content & ACI_PCO_CONTENTMASK_DNS1) + { + /* + * Type field + */ + *pos = ACI_PCO_IPCP_TYPE_DNS1; + pos++; + written++; + /* + * Length field + */ + *pos = ACI_PCO_IPCP_LENGTH_DNS1; + pos++; + written++; + /* + * primary DNS address + */ + *pos = (UBYTE)((dns1 >> 24) & 0x000000ff); + pos++; + written++; + *pos = (UBYTE)((dns1 >> 16) & 0x000000ff); + pos++; + written++; + *pos = (UBYTE)((dns1 >> 8) & 0x000000ff); + pos++; + written++; + *pos = (UBYTE)(dns1 & 0x000000ff); + pos++; + written++; + } + /* + * secondary DNS address + */ + if(content & ACI_PCO_CONTENTMASK_DNS2) + { + /* + * Type field + */ + *pos = ACI_PCO_IPCP_TYPE_DNS2; + pos++; + written++; + /* + * Length field + */ + *pos = ACI_PCO_IPCP_LENGTH_DNS2; + pos++; + written++; + /* + * primary DNS address + */ + *pos = (UBYTE)((dns2 >> 24) & 0x000000ff); + pos++; + written++; + *pos = (UBYTE)((dns2 >> 16) & 0x000000ff); + pos++; + written++; + *pos = (UBYTE)((dns2 >> 8) & 0x000000ff); + pos++; + written++; + *pos = (UBYTE)(dns2 & 0x000000ff); + pos++; + written++; + } + /* + * fill length fields + */ + *len_pos1 = (UBYTE)(pos - len_pos1 - 1); + *len_pos2 = *len_pos1; + } + /* + * pass written bytes to caller + */ + *length = written; + /* + * return result + */ + return 0; +} /* utl_create_pco() */ + + + +/* + +----------------------------------------------------------------------------- + | Function : utl_analyze_pco + +----------------------------------------------------------------------------- + | Description : The function analyze_pco() analyzes the response protocol + | configuration from the network + | + | Parameters : buffer - buffer with the response PCOs + | length - length of PCOs + | dns1 - returns primary DNS address + | dns2 - returns secondary DNS address + | gateway - returns Gateway address + | + | Return : 0 - operation successful + | -1 - operation fails + | + +----------------------------------------------------------------------------- +*/ +GLOBAL int utl_analyze_pco (UBYTE* buffer, + USHORT length, + ULONG* dns1, + ULONG* dns2, + ULONG* gateway) +{ + UBYTE* pos; + USHORT pos_len; + USHORT packet_len; + USHORT start_pos; + USHORT dist_to_next; + UBYTE type_len; + + TRACE_FUNCTION( "utl_analyze_pco" ); + + /* + * initialize values + */ + pos = buffer; + pos_len = 0; + *dns1 = 0; + *dns2 = 0; + *gateway = 0; + /* + * check configuration protocol + */ + if( (length <= pos_len) || + !(*pos & 0x80) ) + { + return -1; + } + +#if 0 + /* Table 10.5.154/3GPP TS 24.008 states: + "All other values are interpreded as PPP in this version of the protocol. + so the next check should not be performed + */ + if((*pos & 0x07) NEQ ACI_PCO_CONFIG_PROT_PPP) + { + /* + * configuration protocol is not PPP + */ + return 0; + } +#endif + + pos++; + pos_len++; + + /* + * search for IPCP packet + */ + while(length > (pos_len + ACI_PCO_IPCP_OVERHEAD)) + { + /* + * initialize distance to next packet + */ + dist_to_next = *(pos + 2) + 3; + /* + * check for IPCP packet + */ + if((*pos EQ ACI_PCO_IPCP_PROT_MSB) AND + (*(pos + 1) EQ ACI_PCO_IPCP_PROT_LSB)) + { + /* + * check for correct length field + */ + pos += 2; + pos_len += 2; + dist_to_next-= 2; + packet_len = *(pos + 3); + packet_len = packet_len << 8; + packet_len += *(pos + 4); + if((packet_len EQ *pos) AND + (length > (pos_len + packet_len))) + { + pos++; + pos_len++; + dist_to_next--; + /* + * check of code field + */ + start_pos = pos_len; + switch(*pos) + { + case ACI_PCO_IPCP_CONF_REQ: + /* + * search for Gateway address + */ + pos += 4; + pos_len+= 4; + while((pos_len + 1 - start_pos) < packet_len) + { + type_len = *(pos + 1); + if((*pos EQ ACI_PCO_IPCP_TYPE_IP) AND + (type_len EQ ACI_PCO_IPCP_LENGTH_IP) AND + ((pos_len + + ACI_PCO_IPCP_LENGTH_IP - + start_pos) <= packet_len)) + { + *gateway = *(pos + 2); + *gateway = ((*gateway) << 8); + *gateway+= *(pos + 3); + *gateway = ((*gateway) << 8); + *gateway+= *(pos + 4); + *gateway = ((*gateway) << 8); + *gateway+= *(pos + 5); + } + pos += type_len; + pos_len+= type_len; + } + if((pos_len - start_pos) <= packet_len) + { + dist_to_next = packet_len + start_pos - pos_len; + } + else + { + dist_to_next = 0; + pos -= (pos_len - start_pos - packet_len); + pos_len -= (pos_len - start_pos - packet_len); + } + break; + + case ACI_PCO_IPCP_CONF_ACK: + case ACI_PCO_IPCP_CONF_NAK: + /* + * search for DNS addresses + */ + pos += 4; + pos_len+= 4; + while((pos_len + 1 - start_pos) < packet_len) + { + type_len = *(pos + 1); + if((*pos EQ ACI_PCO_IPCP_TYPE_DNS1) AND + (type_len EQ ACI_PCO_IPCP_LENGTH_DNS1) AND + ((pos_len + + ACI_PCO_IPCP_LENGTH_DNS1 - + start_pos) <= packet_len)) + { + *dns1 = *(pos + 2); + *dns1 = ((*dns1) << 8); + *dns1+= *(pos + 3); + *dns1 = ((*dns1) << 8); + *dns1+= *(pos + 4); + *dns1 = ((*dns1) << 8); + *dns1+= *(pos + 5); + } + else if((*pos EQ ACI_PCO_IPCP_TYPE_DNS2) AND + (type_len EQ ACI_PCO_IPCP_LENGTH_DNS2) AND + ((pos_len + + ACI_PCO_IPCP_LENGTH_DNS2 - + start_pos) <= packet_len)) + { + *dns2 = *(pos + 2); + *dns2 = ((*dns2) << 8); + *dns2+= *(pos + 3); + *dns2 = ((*dns2) << 8); + *dns2+= *(pos + 4); + *dns2 = ((*dns2) << 8); + *dns2+= *(pos + 5); + } + pos += type_len; + pos_len+= type_len; + } + if((pos_len - start_pos) <= packet_len) + { + dist_to_next = packet_len + start_pos - pos_len; + } + else + { + dist_to_next = 0; + pos -= (pos_len - start_pos - packet_len); + pos_len -= (pos_len - start_pos - packet_len); + } + break; + } + } + } + /* + * go to next packet + */ + pos_len+= dist_to_next; + pos += dist_to_next; + } + /* + * return + */ + return 0; +} /* utl_analyze_pco() */ + + + + +GLOBAL int utl_strcasecmp (const char *s1, const char *s2) +{ + char c1, c2; + int i; + + int len1 = (s1 EQ NULL) ? 0 : strlen(s1); + int len2 = (s2 EQ NULL) ? 0 : strlen(s2); + + if (len1 > len2) + { + return (1); + } + if(len1 < len2) + { + return (-1); + } + for (i = 0; i < len1; i++) + { + c1 = s1[i]; /*lint !e613 (Warning -- 613: Possible use of null pointer 's1' in left argument to operator '[' [Reference: file condat\ms\src\aci\aci_util.c: line 2349] ) */ + c2 = s2[i]; /*lint !e613 (Warning -- 613: Possible use of null pointer 's2' in left argument to operator '[' [Reference: file condat\ms\src\aci\aci_util.c: line 2349] ) */ + if (c1 EQ c2) + { + continue ; + } + if (c1 >= 'a' AND c1 <= 'z') + { + c1 = c1 - ('a'-'A'); + } + if (c2 >= 'a' AND c2 <= 'z') + { + c2 = c2 - ('a'-'A'); + } + if (c1 NEQ c2) + { + return (1); + } + } + return (0); +} + + +#endif /* GPRS */ + + + +#if defined (FF_ATI) || defined (FF_BAT) + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : ACI_UTIL | +| STATE : code ROUTINE : rci_display_USSD | ++--------------------------------------------------------------------+ + + PURPOSE : used by rCI_PlusCUSD and utl_cb_percentKSIR +*/ +GLOBAL void rci_display_USSD (UBYTE srcId, + T_ACI_CUSD_MOD mode, + UBYTE *ussd_str, + UBYTE ussd_len, + BOOL cvtStr, + SHORT dcs ) +{ + SHORT pos = 0; + USHORT chunksize; + USHORT lenCvtdStr; + CHAR sa[80]; + + + TRACE_FUNCTION("rci_display_USSD()"); + + pos = sprintf(sa,"+CUSD: "); + + if (mode NEQ CUSD_MOD_NotPresent) + { + pos += sprintf(sa+pos,"%d,",mode); + } + else + pos += sprintf(sa+pos,","); + + if(ussd_str NEQ NULL) + { + pos += sprintf(sa+pos,"\""); /* beginning double quote */ + while (ussd_len) + { + if( cvtStr EQ CONVERT_STRING ) + { + chunksize = utl_ussdDtaToTe( ussd_str, + (USHORT)ussd_len, + (UBYTE*)(sa + pos), + sizeof(sa)-pos, + &lenCvtdStr, + (UBYTE)dcs ); + + pos += lenCvtdStr; + } + else + { + /* + * How much space do we have left in the output array? + */ + chunksize=(sizeof(sa)-pos)-1; + + if (ussd_len<chunksize) + { + /* + * Remaining data fits within the output array. + */ + chunksize=ussd_len; + } + else if (chunksize>3) + { + /* + * If the remaining data will not fit in the output + * array, and we have more than 3 bytes available (which + * we will), make sure that the amount of data output + * divides by 4. This is so we don't split UCS2 characters + * between two lines of output. + */ + chunksize &= ~0x3; + } + + memcpy(sa+pos,ussd_str,chunksize); + + pos += chunksize; + + sa[pos]=0; + } + ussd_len-=chunksize; + ussd_str+=chunksize; + + if (ussd_len OR (sizeof(sa)-pos) < 10) + { +#ifdef _SIMULATION_ + io_sendMessage(srcId, sa, ATI_NORMAL_OUTPUT); /* append CR+LF only for testcase */ +#else + io_sendMessage(srcId, sa, ATI_ECHO_OUTPUT); /* normal output a chunk */ +#endif + pos=0; + memset(sa, 0, 80); + } + } + + pos+=sprintf(sa+pos,"\","); /* ending double quote */ + + if (dcs EQ ACI_NumParmNotPresent) + { + /* see 07.07: default is 0 */ + dcs = 0; + } + + pos+=sprintf(sa+pos,"%d",dcs); + } + + ci_remTrailCom(sa, pos); + io_sendMessage(srcId, sa, ATI_NORMAL_OUTPUT); +} + +/* + **************************************************************** + */ +LOCAL void utl_cvtCLIRStat ( UBYTE clirOpt, + UBYTE ssSt, + T_ACI_CLIR_STAT *clirStat ) +{ + if ( clirOpt EQ KSD_CO_NOT_VALID ) + { + /* SS Status of class - T_ACI_KSD_ST */ + if ( ssSt EQ KSD_ST_NOT_VALID ) + *clirStat = CLIR_STAT_Unknown; + else if ( ssSt & SSS_P ) + *clirStat = CLIR_STAT_Permanent; + else + *clirStat = CLIR_STAT_NotProv; + } + else + { + switch ( clirOpt ) + { + case( CLIR_OPT_PERMANENT ): + *clirStat = CLIR_STAT_Permanent; + break; + + case( CLIR_OPT_TEMPORARY ): + *clirStat = CLIR_STAT_RestrictTemp; + break; + + case( CLIR_OPT_ALLOWED ): + *clirStat = CLIR_STAT_AllowTemp; + break; + + default: + *clirStat = CLIR_STAT_Unknown; + break; + } + } +} + +/* + **************************************************************** + */ +LOCAL void utl_cb_ccbs( UBYTE srcId, T_ACI_KSIR * ksStat ) +{ + T_ACI_CCBS_SET *CCBS_Setting = NULL; + + T_ACI_CCBS_STAT status; + T_basicService basicServ; + int i; + T_CC_FEAT *ccbs_features; + + TRACE_FUNCTION("utl_cb_ccbs()"); + + /* SS Status of CCBS */ + if (ksStat->ir.rKSCC.ssSt EQ KSD_ST_NOT_VALID) + status = CCBS_STAT_NotPresent; + else if (!(ksStat->ir.rKSCC.ssSt & SSS_P)) + status = CCBS_STAT_NotProvisioned; + else if (ksStat->ir.rKSCC.ssSt & SSS_A) + status = CCBS_STAT_Active; + else + status = CCBS_STAT_Provisioned; + + ACI_MALLOC(CCBS_Setting, sizeof(T_ACI_CCBS_SET)); + + /* CCBS_Setting infos */ + if (!ksStat->ir.rKSCC.c_ccFeatLst) + { + TRACE_EVENT("KSD_CMD_CCBS: no feature list"); + + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + rCI_PercentCCBS(CCBS_IND_IrgtResult, + status, + CCBS_Setting, + TRUE); + } +#ifdef FF_BAT + else /* CMD_MODE_BAT */ + { + rBAT_PercentCCBS(CCBS_IND_IrgtResult, + status, + CCBS_Setting, + TRUE); + } +#endif + return; + } + + for (i=0; i<ksStat->ir.rKSCC.c_ccFeatLst; i++) + { + ccbs_features = ksStat->ir.rKSCC.ccFeatLst + i; + + memcpy( CCBS_Setting->number, ccbs_features->num, MAX_B_SUBSCR_NUM_LEN); + memcpy( CCBS_Setting->subaddr, ccbs_features->sub, MAX_SUBADDR_LEN); + + CCBS_Setting->type.npi = ccbs_features->npi NEQ 0xFF + ? (T_ACI_TOA_NPI)ccbs_features->npi + : NPI_NotPresent; + CCBS_Setting->type.ton = ccbs_features->ton NEQ 0xFF + ? (T_ACI_TOA_TON)ccbs_features->ton + : TON_NotPresent; + CCBS_Setting->satype.tos = ccbs_features->tos NEQ 0xFF + ? (T_ACI_TOS_TOS)ccbs_features->tos + : TOS_NotPresent; + CCBS_Setting->satype.oe = ccbs_features->oe NEQ 0xFF + ? (T_ACI_TOS_OE)ccbs_features->oe + : OE_NotPresent; + + if( ccbs_features->bsTp EQ BS_TELE_SRV ) + { + basicServ.v_teleservice = TRUE; + basicServ.v_bearerService = FALSE; + basicServ.teleservice = ccbs_features->bsCd; + } + else /* if( p_servType EQ BS_BEAR_SRV ) */ + { + basicServ.v_bearerService = TRUE; + basicServ.v_teleservice = FALSE; + basicServ.bearerService = ccbs_features->bsCd; + } + + CCBS_Setting->class_type = cmhSS_GetClass( &basicServ ); + + CCBS_Setting->idx = ccbs_features->idx NEQ 0xFF + ? ccbs_features->idx + : ACI_NumParmNotPresent; + + CCBS_Setting->alrtPtn = ALPT_NotPresent; + + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + rCI_PercentCCBS(CCBS_IND_IrgtResult, + status, + CCBS_Setting, + TRUE); + } +#ifdef FF_BAT + else /* CMD_MODE_BAT */ + { + rBAT_PercentCCBS(CCBS_IND_IrgtResult, + status, + CCBS_Setting, + TRUE); + } +#endif + } + + ACI_MFREE( CCBS_Setting ); +} + +/* + **************************************************************** + */ +LOCAL void utl_cb_callwaiting( UBYTE srcId, T_ACI_KSIR *ksStat ) +{ + T_ACI_CLSSTAT classStat; + UBYTE idx; + T_ACI_TOA type; + + TRACE_FUNCTION("utl_cb_callwaiting()"); + + if ( ksStat->ir.rKSCW.opCd NEQ KSD_OP_IRGT ) + return; + + /* SS Status of class - T_ACI_KSD_ST */ + if ( ksStat->ir.rKSCW.ssSt EQ KSD_ST_NOT_VALID ) + { + classStat.status = STATUS_NotPresent; + } + else if ( ksStat->ir.rKSCW.ssSt & KSD_ST_A ) + { + classStat.status = STATUS_Active; + } + else + { + classStat.status = STATUS_NotActive; + } + + /* init parameter type: */ + type.npi = NPI_NotPresent; + type.ton = TON_NotPresent; + + for( idx = 0; idx < ksStat->ir.rKSCW.c_cwBSGLst; idx++ ) + { + /* type of class */ + classStat.class_type = cmhSS_GetClassType(ksStat->ir.rKSCW.cwBSGLst[idx].bsTp, + ksStat->ir.rKSCW.cwBSGLst[idx].bsCd); + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + } + else /* CMD_MODE_BAT */ + { + } + + rCI_PlusCCWA(&classStat,"\0", &type, MNCC_PRES_NOT_PRES, CLASS_NotPresent, NULL); + } +} + +/* + **************************************************************** + */ +LOCAL void utl_cb_lineidentification( UBYTE srcId, T_ACI_KSIR * ksStat ) +{ + T_ACI_CLIP_STAT clipStat; + T_ACI_CLIR_MOD clirMode; + T_ACI_CLIR_STAT clirStat; + T_ACI_COLP_STAT colpStat; + T_ACI_COLR_STAT colrStat; + + TRACE_FUNCTION("utl_cb_lineidentification()"); + + if ( ksStat->ir.rKSCL.opCd NEQ KSD_OP_IRGT ) + return; + + switch ( ksStat->ir.rKSCL.ssCd ) + { + case KSD_SS_CLIP: + { + /* SS Status of class - T_ACI_KSD_ST */ + if ( ksStat->ir.rKSCL.ssSt EQ KSD_ST_NOT_VALID ) + clipStat = CLIP_STAT_Unknown; + else if ( ksStat->ir.rKSCL.ssSt & SSS_P ) + clipStat = CLIP_STAT_Prov; + else + clipStat = CLIP_STAT_NotProv; + + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + rCI_PlusCLIP ( clipStat, NULL, NULL, MNCC_PRES_NOT_PRES, NULL, NULL, NULL ); + } +#ifdef FF_BAT + else /* CMD_MODE_BAT */ + { + rBAT_PlusCLIP ( clipStat, NULL, NULL, MNCC_PRES_NOT_PRES, NULL, NULL, NULL ); + } +#endif + break; + } + case KSD_SS_CLIR: + { + clirMode = ksStat->ir.rKSCL.mode; + utl_cvtCLIRStat(ksStat->ir.rKSCL.clirOpt, + ksStat->ir.rKSCL.ssSt, + &clirStat); + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + rCI_PlusCLIR (clirMode, clirStat); + } +#ifdef FF_BAT + else /* CMD_MODE_BAT */ + { + rBAT_PlusCLIR (clirMode, clirStat); + } +#endif + break; + } + case KSD_SS_COLP: + { + /* SS Status of class - T_ACI_KSD_ST */ + if ( ksStat->ir.rKSCL.ssSt EQ KSD_ST_NOT_VALID ) + colpStat = COLP_STAT_Unknown; + else if ( ksStat->ir.rKSCL.ssSt & SSS_P ) + colpStat = COLP_STAT_Prov; + else + colpStat = COLP_STAT_NotProv; + + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + rCI_PlusCOLP ( colpStat, NULL, NULL, NULL, NULL, NULL ); + } +#ifdef FF_BAT + else /* CMD_MODE_BAT */ + { + rBAT_PlusCOLP ( colpStat, NULL, NULL, NULL, NULL, NULL ); + } +#endif + break; + } + case KSD_SS_COLR: + { + /* SS Status of class - T_ACI_KSD_ST */ + if ( ksStat->ir.rKSCL.ssSt EQ KSD_ST_NOT_VALID ) + colrStat = COLR_STAT_Unknown; + else if ( ksStat->ir.rKSCL.ssSt & SSS_P ) + colrStat = COLR_STAT_Prov; + else + colrStat = COLR_STAT_NotProv; + + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + rCI_PercentCOLR(colrStat); + } +#ifdef FF_BAT + else /* CMD_MODE_BAT */ + { + rBAT_PercentCOLR(colrStat); + } +#endif + break; + } + } +} + +/* + **************************************************************** + */ +LOCAL void utl_cb_callforwarding( UBYTE srcId, T_ACI_KSIR * ksStat ) +{ + T_ACI_CCFC_SET ccfcSetting; + UBYTE idx; + + TRACE_FUNCTION("utl_cb_callforwarding()"); + + if ( ksStat->ir.rKSCF.opCd NEQ KSD_OP_IRGT ) + return; + + for( idx = 0; idx < ksStat->ir.rKSCF.c_cfFeatLst; idx++ ) + { + /* SS Status of class - T_ACI_KSD_ST */ + if ( ksStat->ir.rKSCF.cfFeatLst[idx].ssSt EQ KSD_ST_NOT_VALID ) + ccfcSetting.clsstat.status = STATUS_NotPresent; + else if ( ksStat->ir.rKSCF.cfFeatLst[idx].ssSt & SSS_A ) + ccfcSetting.clsstat.status = STATUS_Active; + else + ccfcSetting.clsstat.status = STATUS_NotActive; + /* type of class */ + if ( ksStat->ir.rKSCF.cfFeatLst[idx].bsTp EQ KSD_BS_TP_None + AND ksStat->ir.rKSCF.cfFeatLst[idx].bsCd EQ KSD_BS_TeleBearerUnknown) + { + if (ccfcSetting.clsstat.status EQ STATUS_NotPresent) + ccfcSetting.clsstat.class_type = CLASS_None; + else + ccfcSetting.clsstat.class_type = CLASS_VceDatFax; + } + else + ccfcSetting.clsstat.class_type = cmhSS_GetClassType(ksStat->ir.rKSCF.cfFeatLst[idx].bsTp, + ksStat->ir.rKSCF.cfFeatLst[idx].bsCd); + /* number */ + strcpy(ccfcSetting.number, (char *)ksStat->ir.rKSCF.cfFeatLst[idx].num); + if ( !strlen ( ccfcSetting.number )) + { + ccfcSetting.type.npi = NPI_NotPresent; + ccfcSetting.type.ton = TON_NotPresent; + ccfcSetting.subaddr[0] = 0x0; + ccfcSetting.satype.tos = TOS_NotPresent; + ccfcSetting.satype.oe = OE_NotPresent; + ccfcSetting.time = ACI_NumParmNotPresent; + } + else + { + T_CF_FEAT *cfFeat = &ksStat->ir.rKSCF.cfFeatLst[idx]; + /* toa */ + ccfcSetting.type.ton = cfFeat->ton NEQ 0xFF + ? (T_ACI_TOA_TON)cfFeat->ton + : TON_NotPresent; + ccfcSetting.type.npi = cfFeat->npi NEQ 0xFF + ? (T_ACI_TOA_NPI)cfFeat->npi + : NPI_NotPresent; + /* subaddr */ + strcpy(ccfcSetting.subaddr, (char *)ksStat->ir.rKSCF.cfFeatLst[idx].sub); + /* tos */ + ccfcSetting.satype.tos = cfFeat->tos NEQ 0xFF + ? (T_ACI_TOS_TOS)cfFeat->tos + : TOS_NotPresent; + ccfcSetting.satype.oe = cfFeat->oe NEQ 0xFF + ? (T_ACI_TOS_OE)cfFeat->oe + : OE_NotPresent; + /* time */ + ccfcSetting.time = cfFeat->time NEQ 0xFF + ? cfFeat->time + : ACI_NumParmNotPresent; + } + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + rCI_PlusCCFC (&ccfcSetting); + } +#ifdef FF_BAT + else + { + rBAT_PlusCCFC (&ccfcSetting); + } +#endif + } +} + +/* + **************************************************************** + */ +LOCAL void utl_cb_callbarring( UBYTE srcId, T_ACI_KSIR * ksStat ) +{ + T_ACI_CLSSTAT classStat; + UBYTE idx; + + TRACE_FUNCTION("utl_cb_callbarring()"); + + if (ksStat->ir.rKSCB.opCd NEQ KSD_OP_IRGT) + { + return; + } + for (idx = 0; idx < ksStat->ir.rKSCB.c_cbInfoLst; idx++) + { + /* type of class */ + classStat.class_type = cmhSS_GetCbClassType(ksStat->ir.rKSCB.cbInfoLst[idx].bsTp, + ksStat->ir.rKSCB.cbInfoLst[idx].bsCd); + + /* SS Status of class */ + if (classStat.class_type EQ CLASS_VceDatFaxSms + OR classStat.class_type EQ CLASS_None) + { + classStat.status = STATUS_NotActive; + } + else + { + classStat.status = STATUS_Active; + } + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + rCI_PlusCLCK(&classStat); + } +#ifdef FF_BAT + else /* CMD_MODE_BAT */ + { + rBAT_PlusCLCK(&classStat); + } +#endif + } +} + +/* + **************************************************************** + */ +LOCAL void utl_cb_imei( UBYTE srcId, T_ACI_KSIR * ksStat ) +{ + TRACE_FUNCTION("utl_cb_imei()"); + + sprintf ( g_sa, + "%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d%d", + (ksStat->ir.rKSIMEI.tac1 >> 4) & 0x0F, + ksStat->ir.rKSIMEI.tac1 & 0x0F, + + (ksStat->ir.rKSIMEI.tac2 >> 4) & 0x0F, + ksStat->ir.rKSIMEI.tac2 & 0x0F, + + (ksStat->ir.rKSIMEI.tac3 >> 4) & 0x0F, + ksStat->ir.rKSIMEI.tac3 & 0x0F, + + (ksStat->ir.rKSIMEI.fac >> 4) & 0x0F, + ksStat->ir.rKSIMEI.fac & 0x0F, + + (ksStat->ir.rKSIMEI.snr1 >> 4) & 0x0F, + ksStat->ir.rKSIMEI.snr1 & 0x0F, + + (ksStat->ir.rKSIMEI.snr2 >> 4) & 0x0F, + ksStat->ir.rKSIMEI.snr2 & 0x0F, + + (ksStat->ir.rKSIMEI.snr3 >> 4) & 0x0F, + ksStat->ir.rKSIMEI.snr3 & 0x0F, + + ksStat->ir.rKSIMEI.cd, + (ksStat->ir.rKSIMEI.svn >> 4) & 0x0F, + ksStat->ir.rKSIMEI.svn & 0x0F ); + + io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT ); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-F&D (8411) MODULE : ACI_UTIL | +| STATE : code ROUTINE : | ++--------------------------------------------------------------------+ + + PURPOSE : handles PercentKSIR call back + +*/ +GLOBAL void utl_cb_percentKSIR (U8 srcId, T_ACI_KSIR *ksStat) +{ +#ifdef FF_BAT + T_ACI_USSD_DATA ussd; +#endif /* FF_BAT */ + + TRACE_FUNCTION("utl_cb_percentKSIR()"); + + switch (ksStat->ksdCmd) + { + case (KSD_CMD_IMEI): + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + utl_cb_imei(srcId, ksStat); + } +#ifdef FF_BAT + else /* CMD_MODE_BAT */ + { + rBAT_PercentIMEI(&(ksStat->ir.rKSIMEI)); + } +#endif + break; + + case (KSD_CMD_CB): + utl_cb_callbarring(srcId, ksStat); + break; + + case (KSD_CMD_CF): + utl_cb_callforwarding(srcId, ksStat); + break; + + case (KSD_CMD_CL): + utl_cb_lineidentification(srcId, ksStat); + break; + + case (KSD_CMD_CW): + utl_cb_callwaiting(srcId, ksStat); + break; + + case (KSD_CMD_PWD): + /* no specific answer to +CPWD which is the corresponding AT cmd */ + break; + + case (KSD_CMD_UBLK): + /* no specific answer to +CPIN which is the corresponding AT cmd */ + break; + + case (KSD_CMD_USSD): + if (aci_cmd_src_mode_get((T_ACI_CMD_SRC)srcId) EQ CMD_MODE_ATI) + { + rci_display_USSD(srcId, + ksStat->ir.rKSUS.mode, + (UBYTE *)ksStat->ir.rKSUS.ussd, + ksStat->ir.rKSUS.len, + FALSE, /* means DO NOT CONVERT STRING */ + ksStat->ir.rKSUS.dcs); + } +#ifdef FF_BAT + else /* CMD_MODE_BAT */ + { + ussd.len = ksStat->ir.rKSUS.len; + memcpy (ussd.data, (UBYTE *)ksStat->ir.rKSUS.ussd, ussd.len); + rBAT_PlusCUSD(ksStat->ir.rKSUS.mode, &ussd, ksStat->ir.rKSUS.dcs); + } +#endif + break; + + case (KSD_CMD_CCBS): + utl_cb_ccbs(srcId, ksStat); + break; + } + +} +#endif /* defined (FF_ATI) || defined (FF_BAT) */