src/co_sat.c

   1 /*
   2  * libtcore
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <glib.h>
  26
  27 #include "tcore.h"
  28 #include "plugin.h"
  29 #include "queue.h"
  30 #include "user_request.h"
  31 #include "core_object.h"
  32 #include "util.h"
  33 #include "co_sat.h"
  34
  35 #define SATK_PROACTIVE_CMD_TAG  0xD0  /*Proactive Command Tag*/
  36 #define SATK_MENU_SELECTION_TAG 0xD3  /*Menu Selection Tag*/
  37 #define SATK_EVENT_DOWNLOAD_TAG 0xD6  /*Event Download Tag*/
  38
  39 /*Tag Values (without Comprehension bit)*/
  40 #define SATK_COMMAND_DETAILS_TAG        0x01 /* COMMAND DETAILS TAG */
  41 #define SATK_DEVICE_IDENTITY_TAG        0x02 /* DEVICE IDENTITY TAG */
  42 #define SATK_RESULT_TAG 0x03 /* RESULT TAG */
  43 #define SATK_DURATION_TAG       0x04 /* DURATION TAG */
  44 #define SATK_ALPHA_IDENTIFIER_TAG       0x05 /* ALPHA IDENTIFIER TAG */
  45 #define SATK_ADDRESS_TAG        0x06 /* ADDRESS TAG */
  46 #define SATK_CAPABILITY_CONFIGURATION_PARAMETERS_TAG    0x07 /* CAPABILITY CONFIGURATION PARAMETERS TAG */
  47 #define SATK_SUB_ADDRESS_TAG    0x08 /* SUB ADDRESS TAG */
  48 #define SATK_SS_STRING_TAG      0x09 /* SS STRING TAG */
  49 #define SATK_USSD_STRING_TAG    0x0A /* USSD STRING TAG */
  50 #define SATK_SMS_TPDU_TAG       0x0B /* SMS TPDU TAG */
  51 #define SATK_CELL_BROADCAST_PAGE_TAG    0x0C /* CELL BROADCAST PAGE TAG */
  52 #define SATK_TEXT_STRING_TAG    0x0D /* TEXT STRING TAG */
  53 #define SATK_TONE_TAG   0x0E /* TONE TAG */
  54 #define SATK_ITEM_TAG   0x0F /* ITEM TAG */
  55 #define SATK_ITEM_IDENTIFIER_TAG        0x10 /* ITEM IDENTIFIER TAG */
  56 #define SATK_RESPONSE_LENGTH_TAG        0x11 /* RESPONSE LENGTH TAG */
  57 #define SATK_FILE_LIST_TAG      0x12 /* FILE LIST TAG */
  58 #define SATK_LOCATION_INFORMATION_TAG   0x13 /* LOCATION INFORMATION TAG */
  59 #define SATK_IMEI_TAG   0x14 /* IMEI TAG */
  60 #define SATK_HELP_REQUEST_TAG   0x15 /* HELP REQUEST TAG */
  61 #define SATK_NETWORK_MEASUREMENT_RESULTS_TAG    0x16 /* NETWORK MEASUREMENT RESULTS TAG */
  62 #define SATK_DEFAULT_TEXT_TAG   0x17 /* DEFAULT TEXT TAG */
  63 #define SATK_ITEMS_NEXT_ACTION_INDICATOR_TAG    0x18 /* ITEMS NEXT ACTION INDICATOR TAG */
  64 #define SATK_EVENT_LIST_TAG     0x19 /* EVENT LIST TAG */
  65 #define SATK_CAUSE_TAG  0x1A /* CAUSE TAG */
  66 #define SATK_LOCATION_STATUS_TAG        0x1B /* LOCATION STATUS TAG */
  67 #define SATK_BCCH_CHANNEL_LIST_TAG      0x1D /* BCCH CHANNEL LIST TAG */
  68 #define SATK_ICON_IDENTIFIER_TAG        0x1E /* ICON IDENTIFIER TAG */
  69 #define SATK_ITEM_ICON_IDENTIFIER_LIST_TAG      0x1F /* ITEM ICON IDENTIFIER LIST TAG */
  70 #define SATK_DATE_TIME_AND_TIME_ZONE_TAG        0x26 /* DATE TIME AND TIME ZONE TAG */
  71 #define SATK_CALL_CONTROL_REQUESTED_ACTION_TAG  0x27 /* CALL CONTROL REQUESTED ACTION TAG */
  72 #define SATK_AT_COMMAND_TAG     0x28 /* AT COMMAND TAG */
  73 #define SATK_AT_RESPONSE_TAG    0x29 /* AT RESPONSE TAG */
  74 #define SATK_BC_REPEAT_INDICATOR_TAG    0x2A /* BC REPEAT INDICATOR TAG */
  75 #define SATK_IMMEDIATE_RESPONSE_TAG     0x2B /* IMMEDIATE RESPONSE TAG */
  76 #define SATK_DTMF_STRING_TAG    0x2C /* DTMF STRING TAG */
  77 #define SATK_LANGUAGE_TAG       0x2D /* LANGUAGE TAG */
  78 #define SATK_BROWSER_IDENTITY_TAG       0x30 /* BROWSER IDENTITY TAG */
  79 #define SATK_URL_TAG    0x31 /* URL TAG */
  80 #define SATK_BEARER_TAG 0x32 /* BEARER TAG */
  81 #define SATK_PROVISIONING_REF_FILE_TAG  0x33 /* PROVISIONING REFERENCE FILE TAG */
  82 #define SATK_BROWSER_TERMINATION_CAUSE_TAG      0x34 /* BROWSER TERMINATION CAUSE TAG */
  83 #define SATK_BEARER_DISCRIPTION_TAG     0x35 /* BEARER DISCRIPTION TAG */
  84 #define SATK_CHANNEL_DATA_TAG   0x36 /* CHANNEL DATA TAG */
  85 #define SATK_CHANNEL_DATA_LEN_TAG       0x37 /* CHANNEL DATA LEN TAG */
  86 #define SATK_CHANNEL_STATUS_TAG 0x38 /* CHANNEL STATUS TAG */
  87 #define SATK_BUFFER_SIZE_TAG    0x39 /* BUFFER SIZE TAG */
  88 #define SATK_CARD_READER_IDENTIFIER_TAG 0x3A /* CARD READER IDENTIFIER TAG */
  89 #define SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG      0x3C /* USIM ME INTERFACE TRANSPORT LEVEL  */
  90 #define SATK_OTHER_ADDRESS_TAG  0x3E /* OTHER ADDRESS        */
  91 #define SATK_NETWORK_ACCESS_TAG 0x47 /* NETWORK ACCESS NAME TAG */
  92 #define SATK_CDMA_SMS_TPDU_TAG  0x48 /* CDMA SMS TPDU TAG */
  93 #define SATK_REMOTE_ENTITY_ADDRESS_TAG  0x49 /* REMOTE ENTITY ADDRESS TAG */
  94 #define SATK_TEXT_ATTRIBUTE_TAG 0x50    /* TEXT ATTRIBUTE TAG */
  95 #define SATK_TEXT_ATTRIBUTE_LIST_TAG    0x51    /* TEXT ATTRIBUTE LIST TAG */
  96
  97 /* general data object lengths */
  98 #define SATK_DCS_LENGTH 0x01
  99 #define SATK_COMMAND_DETAILS_LENGTH     0x03  /*  COMMAND DETAILS LENGTH */
 100 #define SATK_DEVICE_IDENTITY_LENGTH     0x02  /*  DEVICE IDENTITY LENGTH */
 101 #define SATK_ICON_IDENTITY_LENGTH       0x02  /*  ICON IDENTITY LENGTH */
 102 #define SATK_DURATION_LENGTH    0x02  /*  DURATION LENGTH */
 103 #define SATK_ITEM_IDENTIFIER_LENGTH     0x01  /*  ITEM IDENTIFIER LENGTH */
 104 #define SATK_LOCATION_INFORMATION_LENGTH        0x07  /*  LOCATION INFORMATION LENGTH */
 105 #define SATK_HELP_REQUEST_LENGTH        0x00  /*  HELP REQUEST LENGTH */
 106 #define SATK_LOCATION_STATUS_LENGTH     0x01  /*  LOCATION STATUS LENGTH */
 107 #define SATK_DATE_TIME_AND_TIME_ZONE_LENGTH     0x07  /*  DATE TIME AND TIME ZONE LENGTH */
 108 #define SATK_LANGUAGE_LENGTH    0x02  /*  LANGUAGE LENGTH */
 109 #define SATK_BC_REPEAT_IND_LENGTH       0x01  /*  BC REPEAT INDICATION LENGTH */
 110 #define SATK_RESPONSE_LENGTH_LENGTH     0x02  /*  RESPONSE LENGTH LENGTH */
 111 #define SATK_TONE_LENGTH        0x01  /*  TONE LENGTH */
 112 #define SATK_BROWSER_ID_LENGTH  0x01  /*  BROWSER ID LENGTH */
 113 #define SATK_BROWSER_TERMINATION_CAUSE_LENGTH   0x01  /*  BROWSER TERMINATION CAUSE LENGTH */
 114 #define SATK_BUFFER_SIZE_LENGTH 0x02 /*  BUFFER SIZE LENGTH */
 115 #define SATK_UICC_ME_TRANS_INTERFACE_LEVEL_LENGTH       0x03 /*  UICC TERMINAL TRANSPORT INTERFACE LEVEL LENGTH */
 116 #define SATK_CHANNEL_DATA_LENGTH_VALUE_LENGTH   0x01 /*  CHANNEL DATA LENGTH VALUE LENGTH */
 117 #define SATK_CHANNEL_STATUS_LENGTH      0x02 /*  CHANNEL STATUS LENGTH */
 118
 119 struct private_object_data {
 120         struct tcore_sat_operations *ops;
 121 };
 122
 123 gboolean b_comprehensive = FALSE;
 124
 125 static TReturn _dispatcher(CoreObject *o, UserRequest *ur)
 126 {
 127         enum tcore_request_command command;
 128         struct private_object_data *po = NULL;
 129
 130         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_SAT, TCORE_RETURN_EINVAL);
 131
 132         po = tcore_object_ref_object(o);
 133         if (!po || !po->ops)
 134                 return TCORE_RETURN_ENOSYS;
 135
 136         command = tcore_user_request_get_command(ur);
 137         switch (command) {
 138                 case TREQ_SAT_REQ_ENVELOPE:
 139                         if (!po->ops->envelope)
 140                                 return TCORE_RETURN_ENOSYS;
 141
 142                         return po->ops->envelope(o, ur);
 143                         break;
 144
 145                 case TREQ_SAT_REQ_TERMINALRESPONSE:
 146                         if (!po->ops->terminal_response)
 147                                 return TCORE_RETURN_ENOSYS;
 148
 149                         return po->ops->terminal_response(o, ur);
 150                         break;
 151
 152                 case TREQ_SAT_REQ_USERCONFIRMATION:
 153                         if (!po->ops->user_confirmation)
 154                                 return TCORE_RETURN_ENOSYS;
 155
 156                         return po->ops->user_confirmation(o, ur);
 157                         break;
 158
 159                 default:
 160                         break;
 161         }
 162
 163         return TCORE_RETURN_SUCCESS;
 164 }
 165
 166 static void _clone_hook(CoreObject *src, CoreObject *dest)
 167 {
 168         struct private_object_data *src_po = NULL;
 169         struct private_object_data *dest_po = NULL;
 170
 171         if (!src || !dest)
 172                 return;
 173
 174         dest_po = calloc(1, sizeof(struct private_object_data));
 175         if (!dest_po) {
 176                 tcore_object_link_object(dest, NULL);
 177                 return;
 178         }
 179
 180         src_po = tcore_object_ref_object(src);
 181         dest_po->ops = src_po->ops;
 182
 183         tcore_object_link_object(dest, dest_po);
 184 }
 185
 186 static void _free_hook(CoreObject *o)
 187 {
 188         struct private_object_data *po = NULL;
 189
 190         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_SAT);
 191
 192         po = tcore_object_ref_object(o);
 193         if (po) {
 194                 free(po);
 195                 tcore_object_link_object(o, NULL);
 196         }
 197 }
 198
 199 static gboolean _check_file_for_refresh(enum tel_sim_file_id file_id)
 200 {
 201         int i;
 202         enum tel_sim_file_id ef_under_mf[3] = { SIM_EF_DIR, SIM_EF_ELP, SIM_EF_ICCID };
 203         enum tel_sim_file_id ef_under_df[29] = {
 204                 SIM_EF_IMSI,    SIM_EF_SST,
 205                 SIM_EF_EST,     SIM_EF_OPLMN_ACT,
 206                 SIM_EF_GID1, SIM_EF_GID2,
 207                 SIM_EF_LP, SIM_EF_ECC,
 208                 SIM_EF_SPN,     SIM_EF_SPDI,
 209                 SIM_EF_PNN,     SIM_EF_OPL,
 210                 SIM_EF_MBDN,    SIM_EF_MSISDN,
 211                 SIM_EF_USIM_MBI, SIM_EF_USIM_MWIS,
 212                 SIM_EF_USIM_CFIS,       SIM_EF_CPHS_VOICE_MSG_WAITING,
 213                 SIM_EF_CPHS_SERVICE_STRING_TABLE, SIM_EF_CPHS_CALL_FORWARD_FLAGS,
 214                 SIM_EF_CPHS_OPERATOR_NAME_STRING,       SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE,
 215                 SIM_EF_CPHS_CPHS_INFO,  SIM_EF_CPHS_MAILBOX_NUMBERS,
 216                 SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING, SIM_EF_CPHS_INFORMATION_NUMBERS,
 217                 SIM_EF_CPHS_DYNAMICFLAGS, SIM_EF_CPHS_DYNAMIC2FLAG,
 218                 SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE_LINE2 };
 219
 220         dbg("[SAT] SAT PARSER - FILE ID=0x%04x", (unsigned int)file_id);
 221
 222         if( (file_id & 0x2F00) == 0x2F00 )
 223         {
 224                 dbg("[SAT] SAT PARSER - MF, EF=0x%04x",file_id);
 225                 for(i=0;i<3;i++){
 226                         if(file_id == ef_under_mf[i]){
 227                                 dbg("[SAT] SAT PARSER - MATCH!");
 228                                 return TRUE;
 229                         }
 230                 }
 231         }
 232         else if( (file_id & 0x6F00) == 0x6F00)
 233         {
 234                 dbg("[SAT] SAT PARSER - ADF_USIM EF=0x%04x",file_id);
 235                 for(i=0;i<29;i++){
 236                         if(file_id == ef_under_df[i]){
 237                                 dbg("[SAT] SAT PARSER - MATCH!");
 238                                 return TRUE;
 239                         }
 240                 }
 241         }
 242         return FALSE;
 243 }
 244
 245 static int _get_length_filed_size(unsigned char firstLenByte)
 246 {
 247         if (firstLenByte <= 0x7F) return 1;
 248         else if (firstLenByte == 0x81) return 2;
 249         else return 0; //return zero, as the length field can only be 1 or 2.
 250 }
 251
 252 static void _get_string_data(unsigned char* src, int len,
 253                 struct tel_sat_text_string_object *text_obj)
 254 {
 255         if (!src || !text_obj) return;
 256
 257         switch (text_obj->dcs.a_format) {
 258                 case ALPHABET_FORMAT_SMS_DEFAULT: {
 259                         char* unpacked_str;
 260
 261                         text_obj->string_length = 0;
 262                         unpacked_str = (char *)tcore_util_unpack_gsm7bit(src, (unsigned int)len);
 263                         if (!unpacked_str) return;
 264
 265                         text_obj->dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
 266                         text_obj->string_length = strlen(unpacked_str);
 267
 268                         if (text_obj->string_length >= SAT_TEXT_STRING_LEN_MAX) {
 269                                 text_obj->string_length = SAT_TEXT_STRING_LEN_MAX;
 270                                 memcpy(text_obj->string, unpacked_str, SAT_TEXT_STRING_LEN_MAX);
 271                                 text_obj->string[SAT_TEXT_STRING_LEN_MAX] = 0x00;
 272                         }
 273                         else {
 274                                 memcpy(text_obj->string, unpacked_str, text_obj->string_length);
 275                                 text_obj->string[text_obj->string_length] = 0x00;
 276                         }
 277
 278                         g_free(unpacked_str);
 279                 }break;
 280                 case ALPHABET_FORMAT_UCS2:
 281                 case ALPHABET_FORMAT_8BIT_DATA: {
 282                         text_obj->string_length = len;
 283                         if (text_obj->string_length >= SAT_TEXT_STRING_LEN_MAX) {
 284                                 text_obj->string_length = SAT_TEXT_STRING_LEN_MAX;
 285                                 memcpy(text_obj->string, src, SAT_TEXT_STRING_LEN_MAX);
 286                                 text_obj->string[SAT_TEXT_STRING_LEN_MAX] = 0x00;
 287                         }
 288                         else {
 289                                 memcpy(text_obj->string, src, text_obj->string_length);
 290                                 text_obj->string[text_obj->string_length+1] = 0x00;
 291                         }
 292                 }break;
 293                 default: {
 294                         dbg("[SAT] SAT PARSER -  Unknown alphabet format(%d)", text_obj->dcs.a_format);
 295                 }break;
 296         }
 297
 298         return;
 299 }
 300
 301 static void _sat_decode_dcs(unsigned char dcs, struct data_coding_scheme* dsc_obj)
 302 {
 303         dbg("[SAT] SAT PARSER - dcs=[0x%x]", dcs);
 304         dsc_obj->raw_dcs = dcs;
 305         //bit 5 of DCS byte will tell us if the text is compressed or not.
 306
 307         if (dcs & 0x20)
 308                 dsc_obj->is_compressed_format = TRUE;
 309         else
 310                 dsc_obj->is_compressed_format = FALSE;
 311
 312         //bit 4 when set, indicates that bits 0 & 1 have message class meaning.
 313         dsc_obj->m_class = MSG_CLASS_NONE;
 314         if (dcs & 0x10) {
 315                 switch (dcs & 0x03) {
 316                         case 0x00:
 317                                 dsc_obj->m_class = MSG_CLASS_0;
 318                                 break;
 319                         case 0x01:
 320                                 dsc_obj->m_class = MSG_CLASS_1;
 321                                 break;
 322                         case 0x02:
 323                                 dsc_obj->m_class = MSG_CLASS_2;
 324                                 break;
 325                         case 0x03:
 326                                 dsc_obj->m_class = MSG_CLASS_3;
 327                                 break;
 328                         default:
 329                                 err("invalid dcs type");
 330                                 break;
 331                 }
 332         }
 333
 334         /*bits 2 & 3 indicate the character set being used*/
 335         switch (dcs & 0x0C) {
 336                 case 0x00:
 337                 case 0x0C:
 338                         dsc_obj->a_format = ALPHABET_FORMAT_SMS_DEFAULT;
 339                         break;
 340
 341                 case 0x04:
 342                         dsc_obj->a_format = ALPHABET_FORMAT_8BIT_DATA;
 343                         break;
 344
 345                 case 0X08:
 346                         dsc_obj->a_format = ALPHABET_FORMAT_UCS2;
 347                         break;
 348
 349                 default:
 350                         dsc_obj->a_format = ALPHABET_FORMAT_RESERVED;
 351                         break;
 352         }
 353
 354         dbg("[SAT] SAT PARSER - is_compressed_format(%d), msgClass(0x%x), alpha_format(0x%x)",
 355                         dsc_obj->is_compressed_format, dsc_obj->m_class, dsc_obj->a_format);
 356
 357         return;
 358 }
 359
 360 static void _sat_decode_ton_npi(unsigned char ton_npi, enum type_of_number *ton, enum numbering_plan_identifier *npi)
 361 {
 362         int ton_value = 0;
 363         int npi_value = 0;
 364
 365         if(!ton || !npi)
 366                 return;
 367
 368         ton_value = (ton_npi & 0x70) >> 4;
 369         *ton = ton_value;
 370         if(*ton > TON_NETWORK_SPECIFIC)
 371                 *ton = TON_RESERVED_FOR_EXT;
 372
 373         npi_value = (ton_npi & 0x0F);
 374         switch(npi_value){
 375                 case NPI_ISDN_TEL:
 376                 case NPI_DATA_NUMBERING_PLAN:
 377                 case NPI_TELEX:
 378                 case NPI_PRIVATE:
 379                 case NPI_RESERVED_FOR_EXT:
 380                         *npi = npi_value;
 381                         break;
 382                 default:
 383                         *npi = NPI_UNKNOWN;
 384                         break;
 385         }
 386
 387         dbg("[SAT] SAT PATSER - ton(0x%x) npi(0x%x)", *ton, *npi);
 388         return;
 389 }
 390
 391 static enum tel_sim_language_type _sat_decode_language(unsigned char byte1, unsigned char byte2)
 392 {
 393         if((byte1 == 'e')&&(byte2 == 'n')){
 394                 return SIM_LANG_ENGLISH;
 395         } else if((byte1 == 'd')&&(byte2 == 'e')){
 396                 return SIM_LANG_GERMAN;
 397         } else if((byte1 == 'i')&&(byte2 == 't')){
 398                 return SIM_LANG_ITALIAN;
 399         } else if((byte1 == 'f')&&(byte2 == 'r')){
 400                 return SIM_LANG_FRENCH;
 401         } else if((byte1 == 'e')&&(byte2 == 's')){
 402                 return SIM_LANG_SPANISH;
 403         } else if((byte1 == 'n')&&(byte2 == 'l')){
 404                 return SIM_LANG_DUTCH;
 405         } else if((byte1 == 's')&&(byte2 == 'v')){
 406                 return SIM_LANG_SWEDISH;
 407         } else if((byte1 == 'd')&&(byte2 == 'a')){
 408                 return SIM_LANG_DANISH;
 409         } else if((byte1 == 'p')&&(byte2 == 't')){
 410                 return SIM_LANG_PORTUGUESE;
 411         } else if((byte1 == 'f')&&(byte2 == 'i')){
 412                 return SIM_LANG_FINNISH;
 413         } else if((byte1 == 'n')&&(byte2 == 'o')){
 414                 return SIM_LANG_NORWEGIAN;
 415         } else if((byte1 == 'e')&&(byte2 == 'l')){
 416                 return SIM_LANG_GREEK;
 417         } else if((byte1 == 't')&&(byte2 == 'r')){
 418                 return SIM_LANG_TURKISH;
 419         } else if((byte1 == 'h')&&(byte2 == 'u')){
 420                 return SIM_LANG_HUNGARIAN;
 421         } else if((byte1 == 'p')&&(byte2 == 'i')){
 422                 return SIM_LANG_POLISH;
 423         } else  {
 424                 dbg("[SAT] SAT PARSER -  unknown language, default to english.");
 425                 return SIM_LANG_ENGLISH;
 426         }
 427 }
 428
 429 /*
 430  * Decode TLV data object
 431  */
 432 static enum tcore_sat_result _sat_decode_address_tlv(unsigned char* tlv_str, int tlv_len,
 433                 int curr_offset, struct tel_sat_address* address_obj, int* consumed_data_len)
 434 {
 435         unsigned char* src_data;
 436         int temp_index, len_of_len = 0;
 437         int address_len = 0;
 438         gboolean comprehensive_req = FALSE;
 439
 440         if (tlv_str == NULL || consumed_data_len == NULL || address_obj == NULL) {
 441                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || address_obj == NULL");
 442                 return TCORE_SAT_ERROR_FATAL;
 443         }
 444
 445         if (tlv_len <= (curr_offset + 1)) {
 446                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
 447                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 448         }
 449
 450         //tag
 451         temp_index = curr_offset;
 452         src_data = &tlv_str[0];
 453         if ((src_data[temp_index] & 0x7F) != SATK_ADDRESS_TAG) {
 454                 dbg("[SAT] SAT PARSER -  address TAG missing");
 455                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
 456         }
 457
 458         //comprehensive required
 459         if((src_data[temp_index++] & 0x80))
 460                 comprehensive_req = TRUE;
 461
 462         //length
 463         len_of_len = _get_length_filed_size(src_data[temp_index]);
 464         if (!len_of_len) {
 465                 dbg("[SAT] SAT PARSER -  incorrect length");
 466                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 467         }
 468         address_len = src_data[temp_index + len_of_len - 1];
 469
 470         //check the address length
 471         temp_index += len_of_len;
 472         if ((temp_index + address_len) > tlv_len) {
 473                 dbg("[SAT] SAT PARSER  -  incorrect length");
 474                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 475         }
 476
 477         address_obj->dialing_number_len = 0;
 478         if(address_len > 1){
 479                 char* str_ascii = NULL;
 480                 _sat_decode_ton_npi(src_data[temp_index++], &address_obj->ton, &address_obj->npi);
 481                 str_ascii = tcore_util_convert_bcd2ascii((const char*)&src_data[temp_index], address_len-1, SAT_DIALING_NUMBER_LEN_MAX);
 482                 if(str_ascii){
 483                         memcpy(address_obj->dialing_number, str_ascii, strlen(str_ascii));
 484                         address_obj->dialing_number_len = strlen(str_ascii);
 485                         g_free(str_ascii);
 486                 }
 487         }
 488
 489         if(address_obj->dialing_number_len == 0){
 490                 if(comprehensive_req){
 491                         err("[SAT] SAT PARSER -  incorrect address");
 492                         return TCORE_SAT_REQUIRED_VALUE_MISSING;
 493                 }
 494                 dbg("comprehensive partial proactive command");
 495                 //global variable (comprehensive_partial= TRUE)
 496         }
 497
 498         *consumed_data_len = 1 + len_of_len + address_len;
 499         return TCORE_SAT_SUCCESS;
 500 }
 501
 502 static enum tcore_sat_result _sat_decode_subaddress_tlv(unsigned char* tlv_str, int tlv_len,
 503                 int curr_offset, struct tel_sat_subaddress* sub_address_obj, int* consumed_data_len)
 504 {
 505         unsigned char* src_data;
 506         int temp_index, len_of_len = 0;
 507         int sub_address_len = 0;
 508         gboolean comprehensive_req = FALSE;
 509
 510         if (tlv_str == NULL || consumed_data_len == NULL || sub_address_obj == NULL) {
 511                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || sub_address_obj == NULL");
 512                 return TCORE_SAT_ERROR_FATAL;
 513         }
 514
 515         if (tlv_len <= (curr_offset + 1)) {
 516                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
 517                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 518         }
 519
 520         //tag
 521         temp_index = curr_offset;
 522         src_data = &tlv_str[0];
 523         if ((src_data[temp_index] & 0x7F) != SATK_SUB_ADDRESS_TAG) {
 524                 dbg("[SAT] SAT PARSER -  sub address TAG missing");
 525                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
 526         }
 527
 528         //comprehensive required
 529         if((src_data[temp_index++] & 0x80))
 530                 comprehensive_req = TRUE;
 531
 532         //length
 533         len_of_len = _get_length_filed_size(src_data[temp_index]);
 534         if (!len_of_len) {
 535                 dbg("[SAT] SAT PARSER -  incorrect length");
 536                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 537         }
 538         sub_address_len = src_data[temp_index + len_of_len - 1];
 539
 540         //check the address length
 541         temp_index += len_of_len;
 542         if ((temp_index + sub_address_len) > tlv_len) {
 543                 dbg("[SAT] SAT PARSER  -  incorrect length");
 544                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 545         }
 546
 547         //sub address
 548         if(sub_address_len <= 0){
 549                 dbg("[SAT] SAT PARSER - no sub address data");
 550                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 551         }
 552
 553         sub_address_obj->subaddress_len = sub_address_len;
 554         if( sub_address_obj->subaddress_len > SAT_CCP_DATA_LEN_MAX){
 555                 if(comprehensive_req){
 556                         dbg("[SAT] SAT PARSER - sub address is too big");
 557                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 558                 }
 559                 else{
 560                         //bIsComprehensionPartial = TRUE;
 561                         sub_address_obj->subaddress_len = 0;
 562                 }
 563         }
 564         else{
 565                 memcpy(sub_address_obj->subaddress, &src_data[temp_index], sub_address_obj->subaddress_len);
 566         }
 567
 568         *consumed_data_len = 1 + len_of_len + sub_address_len;
 569         return TCORE_SAT_SUCCESS;
 570 }
 571
 572 static enum tcore_sat_result _sat_decode_alpha_identifier_tlv(unsigned char* tlv_str, int tlv_len,
 573                 int curr_offset, struct tel_sat_alpha_identifier* alpha_id_obj, int* consumed_data_len)
 574 {
 575         unsigned char* src_data;
 576         int temp_index, len_of_len = 0;
 577         int alpha_len = 0;
 578
 579         if (tlv_str == NULL || consumed_data_len == NULL || alpha_id_obj == NULL) {
 580                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || alpha_id_obj == NULL");
 581                 return TCORE_SAT_ERROR_FATAL;
 582         }
 583
 584         if (tlv_len <= (curr_offset + 1)) {
 585                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
 586                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 587         }
 588
 589         //tag
 590         temp_index = curr_offset;
 591         src_data = &tlv_str[0];
 592         if ((src_data[temp_index++] & 0x7F) != SATK_ALPHA_IDENTIFIER_TAG) {
 593                 dbg("[SAT] SAT PARSER -  alphaID TAG missing");
 594                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 595         }
 596
 597         //length
 598         alpha_id_obj->is_exist = TRUE;
 599         len_of_len = _get_length_filed_size(src_data[temp_index]);
 600         if (!len_of_len) {
 601                 dbg("[SAT] SAT PARSER -  incorrect length");
 602                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 603         }
 604         alpha_len = alpha_id_obj->alpha_data_len = src_data[temp_index + len_of_len - 1];
 605
 606         //alpha identifier
 607         temp_index += len_of_len;
 608         if ((temp_index + alpha_len) > tlv_len) {
 609                 dbg("[SAT] SAT PARSER  -  incorrect length");
 610                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 611         }
 612
 613         if (alpha_id_obj->alpha_data_len > 0) {
 614
 615                 unsigned char dcs;
 616
 617                 if (alpha_id_obj->alpha_data_len >= SAT_ALPHA_ID_LEN_MAX)
 618                         alpha_id_obj->alpha_data_len = SAT_ALPHA_ID_LEN_MAX - 1;
 619
 620                 memcpy(alpha_id_obj->alpha_data, &src_data[temp_index], alpha_id_obj->alpha_data_len);
 621                 alpha_id_obj->alpha_data[alpha_id_obj->alpha_data_len] = 0x00;
 622
 623                 if (src_data[temp_index] == 0x80 || src_data[temp_index] == 0x81 || src_data[temp_index] == 0x82)
 624                         dcs = 0X08;
 625                 else
 626                         dcs = 0x04;
 627
 628                 _sat_decode_dcs(dcs, &alpha_id_obj->dcs);
 629         }
 630
 631         *consumed_data_len = 1 + len_of_len + alpha_len;
 632         dbg("[SAT] SAT PARSER alphaId= %s", alpha_id_obj->alpha_data);
 633         return TCORE_SAT_SUCCESS;
 634 }
 635
 636 static enum tcore_sat_result _sat_decode_sub_address_tlv(unsigned char* tlv_str, int tlv_len,
 637                 int curr_offset, struct tel_sat_subaddress* sub_address_obj, int* consumed_data_len)
 638 {
 639         int i = 0;
 640         int temp_index, len_of_len = 0;
 641         int sub_address_len = 0;
 642         unsigned char* src_data;
 643         gboolean comprehension_req = FALSE;
 644
 645         if (tlv_str == NULL || consumed_data_len == NULL || sub_address_obj == NULL) {
 646                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || sub_address_obj == NULL");
 647                 return TCORE_SAT_ERROR_FATAL;
 648         }
 649
 650         if (tlv_len <= (curr_offset + 1)) {
 651                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
 652                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 653         }
 654
 655         //tag
 656         temp_index = curr_offset;
 657         src_data = &tlv_str[0];
 658         if ((src_data[temp_index] & 0x7F) != SATK_SUB_ADDRESS_TAG) {
 659                 dbg("[SAT] SAT PARSER -  address TAG missing");
 660                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
 661         }
 662
 663         //comprehensive required
 664         if((src_data[temp_index++] & 0x80))
 665                 comprehension_req = TRUE;
 666
 667         //length
 668         len_of_len = _get_length_filed_size(src_data[temp_index]);
 669         if (!len_of_len) {
 670                 dbg("[SAT] SAT PARSER -  incorrect length");
 671                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 672         }
 673         sub_address_len = src_data[temp_index + len_of_len - 1];
 674
 675         //check the address length
 676         temp_index += len_of_len;
 677         if ((temp_index + sub_address_len) > tlv_len) {
 678                 dbg("[SAT] SAT PARSER  -  incorrect length");
 679                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 680         }
 681
 682         if(sub_address_len <= 0){
 683                 dbg("[SAT] SAT PARSER  -  no sub address");
 684                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 685         }
 686
 687         sub_address_obj->subaddress_len = sub_address_len;
 688         if(sub_address_obj->subaddress_len > SAT_SUB_ADDR_LEN_MAX){
 689                 if(comprehension_req)
 690                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 691                 else
 692                         sub_address_obj->subaddress_len = 0;
 693         }
 694         else{
 695                 memcpy(sub_address_obj->subaddress, &src_data[temp_index],sub_address_obj->subaddress_len);
 696         }
 697
 698         dbg("[SAT] SAT PARSER -  subAddressLen=%d",sub_address_obj->subaddress_len);
 699         for(i=0;i<sub_address_obj->subaddress_len;i++)
 700                 dbg("[SAT] SAT PARSER - 0x%02x\t",sub_address_obj->subaddress[i]);
 701
 702         *consumed_data_len = 1+len_of_len+sub_address_len;
 703         return TCORE_SAT_SUCCESS;
 704 }
 705
 706 static enum tcore_sat_result _sat_decode_ccp_tlv(unsigned char* tlv_str, int tlv_len,
 707                 int curr_offset, struct tel_sat_ccp* ccp_obj, int* consumed_data_len)
 708 {
 709         int i = 0;
 710         int temp_index, len_of_len = 0;
 711         int ccp_len = 0;
 712         unsigned char* src_data;
 713         gboolean comprehension_req = FALSE;
 714
 715         if (tlv_str == NULL || consumed_data_len == NULL || ccp_obj == NULL) {
 716                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || ccp_obj == NULL");
 717                 return TCORE_SAT_ERROR_FATAL;
 718         }
 719
 720         if (tlv_len <= (curr_offset + 1)) {
 721                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
 722                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 723         }
 724
 725         //tag
 726         temp_index = curr_offset;
 727         src_data = &tlv_str[0];
 728         if ((src_data[temp_index] & 0x7F) != SATK_CAPABILITY_CONFIGURATION_PARAMETERS_TAG) {
 729                 dbg("[SAT] SAT PARSER -  CCP TAG missing");
 730                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
 731         }
 732
 733         //comprehensive required
 734         if((src_data[temp_index++] & 0x80))
 735                 comprehension_req = TRUE;
 736
 737         //length
 738         len_of_len = _get_length_filed_size(src_data[temp_index]);
 739         if (!len_of_len) {
 740                 dbg("[SAT] SAT PARSER -  incorrect length");
 741                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 742         }
 743         ccp_len = src_data[temp_index + len_of_len - 1];
 744
 745         //check the address length
 746         temp_index += len_of_len;
 747         if ((temp_index + ccp_len) > tlv_len) {
 748                 dbg("[SAT] SAT PARSER  -  incorrect length");
 749                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 750         }
 751
 752         if(ccp_len <= 0){
 753                 dbg("[SAT] SAT PARSER  -  no ccp data");
 754                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 755         }
 756
 757         ccp_obj->data_len = ccp_len;
 758         if(ccp_obj->data_len > SAT_CCP_DATA_LEN_MAX){
 759                 if(comprehension_req)
 760                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 761                 else
 762                         ccp_obj->data_len = 0;
 763         }
 764         else{
 765                 memcpy(ccp_obj->data, &src_data[temp_index],ccp_obj->data_len);
 766         }
 767
 768         dbg("[SAT] SAT PARSER -  ccp len=%d",ccp_obj->data_len);
 769         for(i=0;i<ccp_obj->data_len;i++)
 770                 dbg("[SAT] SAT PARSER - 0x%02x\t",ccp_obj->data[i]);
 771
 772         *consumed_data_len = 1+len_of_len+ccp_len;
 773         return TCORE_SAT_SUCCESS;
 774 }
 775
 776 static enum tcore_sat_result _sat_decode_device_identities_tlv(unsigned char* tlv_str,
 777                 struct tel_sat_device_identities* dev_id_obj)
 778 {
 779         int temp_index = 0, i;
 780
 781         if (tlv_str == NULL || dev_id_obj == NULL) {
 782                 dbg("[SAT] SAT PARSER -  tlv_str ==NULL || dev_id_obj == NULL");
 783                 return TCORE_SAT_ERROR_FATAL;
 784         }
 785
 786         if ((tlv_str[temp_index++] & 0x7F) != SATK_DEVICE_IDENTITY_TAG) {
 787                 dbg("[SAT] SAT PARSER -  device identity tag missing.");
 788                 return TCORE_SAT_REQUIRED_VALUE_MISSING; //send TR
 789         }
 790
 791         if (tlv_str[temp_index++] != SATK_DEVICE_IDENTITY_LENGTH) {
 792                 dbg("[SAT] SAT PARSER -  device identity length incorrect.");
 793                 return TCORE_SAT_REQUIRED_VALUE_MISSING; //send TR
 794         }
 795
 796         for (i = 0; i < 2; i++) {
 797                 switch (tlv_str[temp_index]) {
 798                         case DEVICE_ID_KEYPAD:
 799                         case DEVICE_ID_DISPLAY:
 800                         case DEVICE_ID_EARPIECE:
 801                         case DEVICE_ID_SIM:
 802                         case DEVICE_ID_ME:
 803                         case DEVICE_ID_NETWORK:
 804                                 if (i == 0) dev_id_obj->src = tlv_str[temp_index];
 805                                 if (i == 1) dev_id_obj->dest = tlv_str[temp_index];
 806                                 break;
 807                         default:{
 808                                 if(tlv_str[temp_index] >= 0x21 && tlv_str[temp_index] <= 0x27){
 809                                         dbg("BIP channel id(0x%x)", tlv_str[temp_index])
 810                                         if (i == 0) dev_id_obj->src = tlv_str[temp_index];
 811                                         if (i == 1) dev_id_obj->dest = tlv_str[temp_index];
 812                                 }
 813                                 else{
 814                                         dbg("unmatched device id");
 815                                         return TCORE_SAT_REQUIRED_VALUE_MISSING;
 816                                 }
 817                         }break;
 818                 }
 819                 temp_index++;
 820         }
 821
 822         dbg("[SAT] SAT PARSER -  source=%d, dest=%d", dev_id_obj->src, dev_id_obj->dest);
 823         return TCORE_SAT_SUCCESS;
 824 }
 825
 826 static enum tcore_sat_result _sat_decode_duration_tlv(unsigned char* tlv_str, int tlv_len,
 827                 int curr_offset, struct tel_sat_duration *duration_obj, int* consumed_data_len)
 828 {
 829         int temp_index = 0;
 830         unsigned char* src_data = NULL;
 831
 832         if (!tlv_str || !duration_obj || !consumed_data_len) {
 833                 err("[SAT] SAT PARSER data is null");
 834                 return TCORE_SAT_ERROR_FATAL;
 835         }
 836
 837         if (tlv_len < curr_offset + 3) {
 838                 err("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
 839                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 840         }
 841
 842         temp_index = curr_offset;
 843         src_data = &tlv_str[0];
 844         if ((src_data[temp_index++] & 0x7F) != SATK_DURATION_TAG) {
 845                 err("[SAT] SAT PARSER -  duration tag missing.");
 846                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
 847         }
 848
 849         if (src_data[temp_index++] != SATK_DURATION_LENGTH) {
 850                 err("[SAT] SAT PARSER -  incorrect length value.");
 851                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
 852         }
 853
 854         //time unit
 855         switch (src_data[temp_index]) {
 856                 case TIME_UNIT_MINUTES:
 857                 case TIME_UNIT_SECONDS:
 858                 case TIME_UNIT_TENTHS_OF_SECONDS:
 859                         duration_obj->time_unit = src_data[temp_index];
 860                         break;
 861                 default:
 862                         duration_obj->time_unit = TIME_UNIT_RESERVED;
 863                         break;
 864         }
 865
 866         //interval
 867         temp_index++;
 868         duration_obj->time_interval = src_data[temp_index];
 869         *consumed_data_len = 4;
 870
 871         dbg("[SAT] SAT PARSER -  timeUnit=%d, interval=%d", duration_obj->time_unit, duration_obj->time_interval);
 872
 873         return TCORE_SAT_SUCCESS;
 874 }
 875
 876 static enum tcore_sat_result _sat_decode_item_tlv(unsigned char* tlv_str, int tlv_len,
 877                 int curr_offset, struct tel_sat_item_info* item_obj, int* consumed_data_len)
 878 {
 879         int temp_index, len_of_len=0, i=0;
 880         int item_len =0;
 881         unsigned char dcs;
 882         unsigned char* src_data = NULL;
 883
 884         if(tlv_str == NULL || consumed_data_len == NULL || item_obj == NULL) {
 885                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || item_obj == NULL");
 886                 return TCORE_SAT_ERROR_FATAL;
 887         }
 888
 889         if(tlv_len <= (curr_offset+1)) {
 890                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
 891                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 892         }
 893
 894         //tag
 895         temp_index = curr_offset;
 896         src_data = &tlv_str[0];
 897         if((src_data[temp_index++]&0x7F) != SATK_ITEM_TAG){
 898                 dbg("[SAT] SAT PARSER -  tag not found.=%d",src_data[temp_index-1]);
 899                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 900         }
 901
 902         //length
 903         len_of_len = _get_length_filed_size(src_data[temp_index]);
 904         if(!len_of_len){
 905                 dbg("[SAT] SAT PARSER -  incorrect length");
 906                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 907         }
 908         item_len = src_data[temp_index+len_of_len-1];
 909
 910         temp_index+=len_of_len; //temp_index pointing to item.
 911         if((temp_index+item_len) > tlv_len){
 912                 dbg("[SAT] SAT PARSER -  incorrect length");
 913                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 914         }
 915
 916         memset(item_obj->text, 0x00,(SAT_ITEM_TEXT_LEN_MAX+1));
 917         if(item_len <= 0){
 918                 dbg("[SAT] SAT PARSER -  menu_text is NULL, remove the menu");
 919                 *consumed_data_len = 1+len_of_len+item_len;
 920                 return TCORE_SAT_SUCCESS;
 921         }
 922
 923         //item
 924         item_obj->item_id = src_data[temp_index++];
 925         // fix for orange SIM issue
 926         // H0100078487 Strange Character display on SIM SAT
 927         // The string length was less than its real length
 928         // So garbage characters was displayed. To fix it, we would recalculate the real length.
 929         for(i=0; i<item_len-1;i++){
 930                 dbg("[SAT] %d: %c", i, src_data[temp_index+i]);
 931                 if(src_data[temp_index+i] == 0xFF) break;
 932         }
 933         item_obj->text_len = i;
 934
 935         if(item_obj->text_len <= 0){
 936                 dbg("[SAT] SAT PARSER -  text len = 0");
 937                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 938         }
 939
 940         if(item_obj->text_len >= SAT_ITEM_TEXT_LEN_MAX)
 941                 item_obj->text_len = SAT_ITEM_TEXT_LEN_MAX-1;
 942
 943         memcpy(item_obj->text, &src_data[temp_index], item_obj->text_len);
 944         if (src_data[temp_index] == 0x80 || src_data[temp_index] == 0x81 || src_data[temp_index] == 0x82)
 945                 dcs = 0X08;
 946         else
 947                 dcs = 0x04;
 948
 949         _sat_decode_dcs(dcs, &item_obj->dcs);
 950
 951
 952         dbg("[SAT] SAT PARSER -  item_text=%s", item_obj->text);
 953         *consumed_data_len = 1+len_of_len+item_len;
 954         return TCORE_SAT_SUCCESS;
 955 }
 956
 957 static enum tcore_sat_result _sat_decode_response_length_tlv(unsigned char* tlv_str, int tlv_len,
 958                 int curr_offset, struct tel_sat_response_length *response_obj, int* consumed_data_len)
 959 {
 960         int temp_index = 0;
 961         unsigned char* src_data = NULL;
 962
 963         if (!tlv_str || !response_obj || !consumed_data_len) {
 964                 err("[SAT] SAT PARSER data is null");
 965                 return TCORE_SAT_ERROR_FATAL;
 966         }
 967
 968         if (tlv_len <= curr_offset + 1) {
 969                 err("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
 970                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 971         }
 972
 973         temp_index = curr_offset;
 974         src_data = &tlv_str[0];
 975         if ((src_data[temp_index++] & 0x7F) != SATK_RESPONSE_LENGTH_TAG) {
 976                 err("[SAT] SAT PARSER -  response length tag missing.");
 977                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
 978         }
 979
 980         if (src_data[temp_index++] != SATK_RESPONSE_LENGTH_LENGTH) {
 981                 err("[SAT] SAT PARSER -  incorrect length value.");
 982                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
 983         }
 984
 985         response_obj->min = src_data[temp_index++];
 986         response_obj->max = src_data[temp_index++];
 987         dbg("[SAT] SAT PARSER  min length(%d), max length(%d)", response_obj->min, response_obj->max);
 988
 989         *consumed_data_len = 4;
 990         if(response_obj->min > response_obj->max){
 991                 err("[SAT] SAT PARSER - : min length is larger than max length");
 992                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
 993         }
 994
 995         return TCORE_SAT_SUCCESS;
 996 }
 997
 998 static enum tcore_sat_result _sat_decode_sms_tpdu_tlv(unsigned char* tlv_str, int tlv_len,
 999                 int curr_offset, struct tel_sat_sms_tpdu *sms_tpdu_obj, int* consumed_data_len)
1000 {
1001         int temp_index = 0, len_of_len = 0;
1002         int tpdu_len = 0;
1003         unsigned char* src_data = NULL;
1004
1005         if (!tlv_str || !sms_tpdu_obj || !consumed_data_len) {
1006                 err("[SAT] SAT PARSER data is null");
1007                 return TCORE_SAT_ERROR_FATAL;
1008         }
1009
1010         if (tlv_len <= curr_offset + 1) {
1011                 err("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
1012                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1013         }
1014
1015         temp_index = curr_offset;
1016         src_data = &tlv_str[0];
1017         if ((src_data[temp_index++] & 0x7F) != SATK_SMS_TPDU_TAG) {
1018                 err("[SAT] SAT PARSER -  sat tpdu tag missing.");
1019                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1020         }
1021
1022         //length
1023         len_of_len = _get_length_filed_size(src_data[temp_index]);
1024         if(!len_of_len){
1025                 err("[SAT] parser: invalid length.");
1026                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1027         }
1028         tpdu_len = src_data[temp_index+len_of_len-1];
1029         temp_index += len_of_len;
1030
1031         if(tpdu_len <= 0)
1032                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
1033
1034         //data len
1035         sms_tpdu_obj->data_len = tpdu_len;
1036         if(sms_tpdu_obj->data_len > SAT_SMS_TPDU_SMS_DATA_LEN_MAX){
1037                 sms_tpdu_obj->data_len = SAT_SMS_TPDU_SMS_DATA_LEN_MAX;
1038         }
1039
1040         //data
1041         memcpy(sms_tpdu_obj->data, &src_data[temp_index], sms_tpdu_obj->data_len);
1042         dbg("[SAT] SAT PARSER tpdu_len (%d)", sms_tpdu_obj->data_len);
1043
1044         *consumed_data_len = 1+len_of_len+tpdu_len;
1045         return TCORE_SAT_SUCCESS;
1046 }
1047
1048 static enum tcore_sat_result _sat_decode_item_identifier_tlv(unsigned char* tlv_str, int tlv_len,
1049                 int curr_offset, struct tel_sat_item_identifier *item_identifier_obj, int* consumed_data_len)
1050 {
1051         int temp_index = 0;
1052         unsigned char* src_data = NULL;
1053
1054         if (!tlv_str || !item_identifier_obj || !consumed_data_len) {
1055                 err("[SAT] SAT PARSER data is null");
1056                 return TCORE_SAT_ERROR_FATAL;
1057         }
1058
1059         if (tlv_len <= curr_offset + 1) {
1060                 err("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
1061                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1062         }
1063
1064         temp_index = curr_offset;
1065         src_data = &tlv_str[0];
1066         if ((src_data[temp_index++] & 0x7F) != SATK_ITEM_IDENTIFIER_TAG) {
1067                 err("[SAT] SAT PARSER -  Item identifier tag missing.");
1068                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1069         }
1070
1071         if (src_data[temp_index++] != SATK_ITEM_IDENTIFIER_LENGTH) {
1072                 err("[SAT] SAT PARSER -  incorrect length value.");
1073                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1074         }
1075
1076         item_identifier_obj->item_identifier = src_data[temp_index++];
1077         *consumed_data_len = 3;
1078         dbg("[SAT] SAT PARSER item identifier(0x%02x)", item_identifier_obj->item_identifier);
1079
1080         return TCORE_SAT_SUCCESS;
1081 }
1082
1083 static enum tcore_sat_result _sat_decode_ss_string_tlv(unsigned char* tlv_str, int tlv_len,
1084                 int curr_offset, struct tel_sat_ss_string *ss_str_obj, int* consumed_data_len)
1085 {
1086         char* str_ascii = NULL;
1087         int temp_index, len_of_len=0;
1088         int ss_len =0;
1089         unsigned char* src_data;
1090         gboolean comprehension_req = FALSE;
1091
1092         if (!tlv_str || !ss_str_obj || !consumed_data_len) {
1093                 err("[SAT] SAT PARSER data is null");
1094                 return TCORE_SAT_ERROR_FATAL;
1095         }
1096
1097         if (tlv_len <= curr_offset + 1) {
1098                 err("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
1099                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1100         }
1101
1102         temp_index = curr_offset;
1103         src_data = &tlv_str[0];
1104         if ((src_data[temp_index] & 0x7F) != SATK_SS_STRING_TAG) {
1105                 err("[SAT] SAT PARSER -  SS string tag missing.");
1106                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1107         }
1108
1109         if(src_data[temp_index++]&0x80)
1110                 comprehension_req = TRUE;
1111
1112         dbg("comprehension_req=[%d]", comprehension_req);
1113
1114         //length
1115         len_of_len = _get_length_filed_size(src_data[temp_index]);
1116         if(!len_of_len){
1117                 err("[SAT] parser: invalid length.");
1118                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1119         }
1120
1121         ss_len = src_data[temp_index+len_of_len-1];
1122         dbg("[SAT] parser: ss_tlv len=%d",ss_len);
1123
1124         temp_index += len_of_len;
1125         ss_str_obj->string_len = 0;
1126
1127         //ss data
1128         if(ss_len <= 1)
1129                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
1130
1131         _sat_decode_ton_npi(src_data[temp_index++], &ss_str_obj->ton, &ss_str_obj->npi);
1132         str_ascii = tcore_util_convert_bcd2ascii((const char*)&src_data[temp_index], ss_len-1, SAT_SS_STRING_LEN_MAX);
1133         if(str_ascii){
1134                 memcpy(ss_str_obj->ss_string, str_ascii, strlen(str_ascii));
1135                 ss_str_obj->string_len = strlen(str_ascii);
1136                 g_free(str_ascii);
1137         }
1138
1139          // 1 is the length of Tag.
1140         *consumed_data_len = 1 + len_of_len + ss_len;
1141         return TCORE_SAT_SUCCESS;
1142 }
1143
1144 static enum tcore_sat_result _sat_decode_text_tlv(unsigned char* tlv_str, int tlv_len,
1145                 int curr_offset, struct tel_sat_text_string_object *text_obj, int* consumed_data_len)
1146 {
1147         int temp_index, len_of_len=0;
1148         int text_len =0;
1149         unsigned char* src_data;
1150         gboolean comprehension_req = FALSE;
1151
1152         if (!tlv_str || !consumed_data_len ) {
1153                 err("[SAT] parser: data is null");
1154                 return TCORE_SAT_ERROR_FATAL;
1155         }
1156
1157         if(tlv_len <= (curr_offset+1)){
1158                 err("[SAT] parser: incorrect length");
1159                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1160         }
1161
1162         //tag
1163         temp_index = curr_offset;
1164         src_data = &tlv_str[0];
1165         if((src_data[temp_index]&0x7F) != SATK_TEXT_STRING_TAG && (src_data[temp_index]&0x7F) != SATK_DEFAULT_TEXT_TAG){
1166                 err("[SAT] parser: text string tag missing, tag=0x%x",src_data[temp_index]);
1167                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1168         }
1169
1170         if(src_data[temp_index++]&0x80)
1171                 comprehension_req = TRUE;
1172
1173         dbg("comprehension_req=[%d]", comprehension_req);
1174
1175         //length
1176         len_of_len = _get_length_filed_size(src_data[temp_index]);
1177         if(!len_of_len){
1178                 err("[SAT] parser: invalid length.");
1179                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1180         }
1181
1182         text_len = src_data[temp_index+len_of_len-1];
1183         temp_index += len_of_len;
1184         memset(text_obj->string, 0x00, SAT_TEXT_STRING_LEN_MAX);
1185
1186         //text
1187         if(text_len <=1){
1188                 text_obj->string_length = 0;
1189         }else{
1190                 _sat_decode_dcs(src_data[temp_index++], &text_obj->dcs);
1191                 _get_string_data(&src_data[temp_index], text_len-1, text_obj);
1192         }
1193
1194         dbg("[SAT] parser: text_tlv_len=%d, parsed text length=%d", text_len, text_obj->string_length);
1195
1196         // 1 is the length of Tag.
1197         *consumed_data_len = 1 + len_of_len + text_len;
1198
1199         return TCORE_SAT_SUCCESS;
1200 }
1201
1202 static enum tcore_sat_result _sat_decode_tone_tlv(unsigned char* tlv_str, int tlv_len,
1203                 int curr_offset, struct tel_sat_tone *tone_obj, int* consumed_data_len)
1204 {
1205         int temp_index;
1206         unsigned char* src_data;
1207         gboolean comprehension_req = FALSE;
1208
1209         if(tlv_str == NULL || consumed_data_len == NULL || tone_obj == NULL) {
1210                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || tone_obj == NULL");
1211                 return TCORE_SAT_ERROR_FATAL;
1212         }
1213
1214         if(tlv_len <= (curr_offset+1)) {
1215                 dbg("[SAT] SAT PARSER - incorrect length original_command_len=%d", tlv_len);
1216                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1217         }
1218
1219         //tag
1220         temp_index = curr_offset;
1221         src_data = &tlv_str[0];
1222         if((src_data[temp_index]&0x7F) != SATK_TONE_TAG){
1223                 err("[SAT] parser: tone tag missing");
1224                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1225         }
1226
1227         if(src_data[temp_index++]&0x80)
1228                 comprehension_req = TRUE;
1229
1230         //length
1231         if (src_data[temp_index++] != SATK_TONE_LENGTH) {
1232                 err("[SAT] SAT PARSER -  incorrect length value.");
1233                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1234         }
1235
1236         if((temp_index+SATK_TONE_LENGTH) > tlv_len)
1237         {
1238                 err("[SAT] SAT PARSER -  incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+SATK_TONE_LENGTH),tlv_len);
1239                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1240         }
1241
1242         //tone
1243         switch(src_data[temp_index])
1244         {
1245                 // standard supervisory tones
1246                 case DIAL_TONE:
1247                 case CALLED_SUBSCRIBER_BUSY     :
1248                 case CONGESTION :
1249                 case RADIO_PATH_ACK:
1250                 case RADIO_PATH_NOT_AVAILABLE_CALL_DROPPED:
1251                 case ERR_SPECIAL_INFO:
1252                 case CALL_WAITING_TONE:
1253                 case RINGING_TONE:
1254                 // ME proprietary tones
1255                 case GENERAL_BEEP:
1256                 case POSITIVE_ACK_TONE:
1257                 case NEGATIVE_ACK_OR_ERROR_TONE:
1258                 case RINGING_TONE_SLCTD_BY_USR_FOR_INCOM_SPEECH_CALL:
1259                 case ALERT_TONE_SELECTED_BY_USER_FOR_INCOMING_SMS:
1260                 case CRITICAL_ALERT:
1261                 //Themed tones
1262                 case HAPPY_TONE:
1263                 case SAD_TONE:
1264                 case URGENT_ACTION_TONE :
1265                 case QUESTION_TONE:
1266                 case MESSAGE_RECEIVED_TONE      :
1267                 //Melody tones
1268                 case MELODY_1:
1269                 case MELODY_2:
1270                 case MELODY_3:
1271                 case MELODY_4:
1272                 case MELODY_5:
1273                 case MELODY_6:
1274                 case MELODY_7:
1275                 case MELODY_8:
1276                         dbg("[SAT] SAT PARSER -  Tone =0x%x", src_data[temp_index]);
1277                         tone_obj->tone_type = src_data[temp_index];
1278                         break;
1279
1280                 case TONE_TYPE_RESERVED:
1281                 default:
1282                         dbg("[SAT] SAT PARSER -  Reserved value of Tone =0x%x", src_data[temp_index]);
1283                         if(comprehension_req)
1284                                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1285                         break;
1286         }
1287
1288         *consumed_data_len = 3;
1289         return TCORE_SAT_SUCCESS;
1290 }
1291
1292 static enum tcore_sat_result _sat_decode_ussd_string_tlv(unsigned char* tlv_str, int tlv_len,
1293                 int curr_offset, struct tel_sat_ussd_string *ussd_str_obj, int* consumed_data_len)
1294 {
1295         int temp_index, len_of_len=0;
1296         int ussd_len =0;
1297         unsigned char* src_data;
1298         gboolean comprehension_req = FALSE;
1299
1300         if (!tlv_str || !ussd_str_obj || !consumed_data_len) {
1301                 err("[SAT] SAT PARSER data is null");
1302                 return TCORE_SAT_ERROR_FATAL;
1303         }
1304
1305         if (tlv_len <= curr_offset + 1) {
1306                 err("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
1307                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1308         }
1309
1310         temp_index = curr_offset;
1311         src_data = &tlv_str[0];
1312         if ((src_data[temp_index] & 0x7F) != SATK_USSD_STRING_TAG) {
1313                 err("[SAT] SAT PARSER -  SS string tag missing.");
1314                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1315         }
1316
1317         if(src_data[temp_index++]&0x80)
1318                 comprehension_req = TRUE;
1319
1320         dbg("comprehension_req=[%d]", comprehension_req);
1321
1322         //length
1323         len_of_len = _get_length_filed_size(src_data[temp_index]);
1324         if(!len_of_len){
1325                 err("[SAT] parser: invalid length.");
1326                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1327         }
1328
1329         ussd_len = src_data[temp_index+len_of_len-1];
1330         dbg("[SAT] parser: ussd_tlv len=%d",ussd_len);
1331
1332         temp_index += len_of_len;
1333         ussd_str_obj->string_len = 0;
1334
1335         //ussd data
1336         if(ussd_len <= 1)
1337                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
1338
1339         _sat_decode_dcs(src_data[temp_index++], &ussd_str_obj->dsc);
1340         ussd_str_obj->string_len = ussd_len - 1;
1341         memcpy(ussd_str_obj->ussd_string, &src_data[temp_index], ussd_str_obj->string_len);
1342
1343          // 1 is the length of Tag.
1344         *consumed_data_len = 1 + len_of_len + ussd_len;
1345         return TCORE_SAT_SUCCESS;
1346 }
1347
1348 static enum tcore_sat_result _sat_decode_file_list_tlv(unsigned char* tlv_str, int tlv_len,
1349                 int curr_offset, struct tel_sat_file_list *file_list_obj, int* consumed_data_len)
1350 {
1351         //tmp
1352         int tmp_cnt;
1353         int f_count;
1354         unsigned int ef = 0x0000;
1355
1356         int temp_index, len_of_len=0;
1357         int file_list_len = 0;
1358         unsigned char* src_data;
1359
1360         if(tlv_str == NULL || consumed_data_len == NULL || file_list_obj == NULL) {
1361                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || file_list_obj == NULL");
1362                 return TCORE_SAT_ERROR_FATAL;
1363         }
1364
1365         if(tlv_len <= (curr_offset+1)) {
1366                 dbg("[SAT] SAT PARSER - incorrect length original_command_len=%d", tlv_len);
1367                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1368         }
1369
1370         //tag
1371         temp_index = curr_offset;
1372         src_data = &tlv_str[0];
1373         if((src_data[temp_index]&0x7F) != SATK_FILE_LIST_TAG){
1374                 err("[SAT] parser: tag missing, tag=0x%x",src_data[temp_index]);
1375                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1376         }
1377
1378         //length
1379         len_of_len = _get_length_filed_size(src_data[temp_index]);
1380         if(!len_of_len){
1381                 err("[SAT] parser: invalid length.");
1382                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1383         }
1384         file_list_len = src_data[temp_index+len_of_len-1];
1385         temp_index += len_of_len;
1386
1387         if((temp_index+file_list_len) > tlv_len) {
1388                 dbg("[SAT] SAT PARSER - incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+file_list_len),tlv_len);
1389                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1390         }
1391
1392         tmp_cnt = src_data[temp_index++];
1393         file_list_obj->file_count = 0;
1394         memset(file_list_obj->file_id, 0, SAT_FILE_ID_LIST_MAX_COUNT);
1395
1396         if(!tmp_cnt){
1397                 dbg("file cnt = 0");
1398                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1399         }
1400
1401         f_count = 0;
1402         do{
1403                 ef = 0x0000;
1404                 if( src_data[temp_index] != 0x3F || src_data[temp_index+1] != 0x00){
1405                         temp_index++;
1406                         if(temp_index > tlv_len) break;
1407                         else continue;
1408                 }
1409                 temp_index+=2; //MASTER FILE (DIR) 0x3F00
1410
1411                 if(src_data[temp_index] == 0x2F){
1412                 //ELEMENTRY FILE (VALUE)
1413                         ef = src_data[temp_index] << 8;
1414                         temp_index++;
1415                         ef = ef | src_data[temp_index];
1416
1417                         if( _check_file_for_refresh((enum tel_sim_file_id)ef) ){//check file registered for refresh?
1418                                 file_list_obj->file_id[file_list_obj->file_count] = ef;
1419                                 file_list_obj->file_count++;
1420                         }
1421                 }
1422                 else if(src_data[temp_index] == 0x7F && src_data[temp_index+1] == 0xFF){
1423                 //USIM DIRECTORY FILE (DIR) 0x7FFF
1424                         temp_index+=2;
1425                         if(src_data[temp_index] == 0x6F){
1426                                 ef = 0x6A << 8;
1427                                 temp_index++;
1428                                 ef = ef | src_data[temp_index];
1429
1430                                 if( _check_file_for_refresh((enum tel_sim_file_id)ef) ){//check file registered for refresh?
1431                                         file_list_obj->file_id[file_list_obj->file_count] = ef;
1432                                         file_list_obj->file_count++;
1433                                 }
1434                         }
1435                         else{
1436                                 temp_index++;
1437                         }
1438                 }
1439                 else if(src_data[temp_index] == 0x7F && (src_data[temp_index+1] == 0x10 || src_data[temp_index+1] == 0x20) ){
1440                 //TELECOM DIRECTORY FILE 0x7F10 or GSM DIRECTORY FILE 0x7F20
1441                         temp_index+=2;
1442                         if(src_data[temp_index] == 0x6F){
1443                                 ef = src_data[temp_index] << 8;
1444                                 temp_index++;
1445                                 ef = ef | src_data[temp_index];
1446
1447                                 if( _check_file_for_refresh((enum tel_sim_file_id)ef) ){//check file registered for refresh?
1448                                         file_list_obj->file_id[file_list_obj->file_count] = ef;
1449                                         file_list_obj->file_count++;
1450                                 }
1451                         }
1452                         else{
1453                                 temp_index++;
1454                         }
1455                 }
1456
1457                 f_count++;
1458                 temp_index++;
1459         }while( f_count < tmp_cnt);
1460
1461         dbg("[SAT] SAT PARSER -  total file count=%d, PDA file count = %d", tmp_cnt, file_list_obj->file_count);
1462         *consumed_data_len = 1 + len_of_len + file_list_len;
1463         return TCORE_SAT_SUCCESS;
1464 }
1465
1466 static enum tcore_sat_result _sat_decode_item_next_action_indicator_tlv(unsigned char* tlv_str,
1467                 int tlv_len, int curr_offset,
1468                 struct tel_sat_item_next_action_indicatior_list* item_next_act_indi_obj,
1469                 int* consumed_data_len)
1470 {
1471         int temp_index;
1472         int item_nai_len;
1473         unsigned char* src_data;
1474         gboolean comprehension_req = FALSE;
1475
1476         if(tlv_str == NULL || consumed_data_len == NULL || item_next_act_indi_obj == NULL) {
1477                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || item_next_act_indi_obj == NULL");
1478                 return TCORE_SAT_ERROR_FATAL;
1479         }
1480
1481         if(tlv_len <= (curr_offset+1)) {
1482                 dbg("[SAT] SAT PARSER - incorrect length original_command_len=%d", tlv_len);
1483                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1484         }
1485
1486         //tag
1487         temp_index = curr_offset;
1488         src_data = &tlv_str[0];
1489         if((src_data[temp_index]&0x7F) != SATK_ITEMS_NEXT_ACTION_INDICATOR_TAG){
1490                 dbg("[SAT] SAT PARSER - tag not found.=%d",src_data[temp_index]);
1491                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1492         }
1493
1494         if((src_data[temp_index++]&0x7F))
1495                 comprehension_req = TRUE;
1496
1497         //item cnt
1498         item_nai_len = item_next_act_indi_obj->cnt = src_data[temp_index++];
1499         if((temp_index+item_nai_len) > tlv_len) {
1500                 dbg("[SAT] SAT PARSER - incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+item_nai_len),tlv_len);
1501                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1502         }
1503
1504         if(item_next_act_indi_obj->cnt > SAT_ITEMS_NEXT_ACTION_INDI_LIST_MAX_COUNT) {
1505                 if(comprehension_req == TRUE) {
1506                         dbg("[SAT] SAT PARSER - list count exceeds maximum allowed count=%d",item_next_act_indi_obj->cnt);
1507                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1508                 }
1509                 item_next_act_indi_obj->cnt = 0;
1510         }
1511
1512         memset(item_next_act_indi_obj->indicator_list, 0xFF, SAT_ITEMS_NEXT_ACTION_INDI_LIST_MAX_COUNT);
1513         if(item_next_act_indi_obj->cnt > 0)
1514                 memcpy(item_next_act_indi_obj->indicator_list, &src_data[temp_index], item_next_act_indi_obj->cnt);
1515
1516         *consumed_data_len = 1+1+item_nai_len;
1517         dbg("[SAT] SAT PARSER - listCount=%d, consumed_data_len = %d",item_next_act_indi_obj->cnt, *consumed_data_len);
1518         return TCORE_SAT_SUCCESS;
1519 }
1520
1521 static enum tcore_sat_result _sat_decode_event_list_tlv(unsigned char* tlv_str, int tlv_len,
1522                 int curr_offset, struct tel_sat_event_list* event_list_obj, int* consumed_data_len)
1523 {
1524         int i = 0;
1525         int temp_index, len_of_len=0;
1526         int evt_list_len;
1527         unsigned char* src_data;
1528         gboolean comprehension_req = FALSE;
1529
1530         if(tlv_str == NULL || consumed_data_len == NULL || event_list_obj == NULL) {
1531                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || event_list_obj == NULL");
1532                 return TCORE_SAT_ERROR_FATAL;
1533         }
1534
1535         if(tlv_len <= (curr_offset+1)) {
1536                 dbg("[SAT] SAT PARSER - incorrect length original_command_len=%d", tlv_len);
1537                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1538         }
1539
1540         //tag
1541         temp_index = curr_offset;
1542         src_data = &tlv_str[0];
1543         if((src_data[temp_index]&0x7F) != SATK_EVENT_LIST_TAG){
1544                 dbg("[SAT] SAT PARSER - tag not found.=%d",src_data[temp_index]);
1545                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1546         }
1547
1548         if((src_data[temp_index++]&0x80))
1549                 comprehension_req = TRUE;
1550
1551         //length
1552         len_of_len = _get_length_filed_size(src_data[temp_index]);
1553         if(!len_of_len){
1554                 err("[SAT] parser: invalid length.");
1555                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1556         }
1557
1558         evt_list_len = src_data[temp_index+len_of_len-1];
1559         dbg("[SAT] parser: evt_list_len=%d",evt_list_len);
1560         temp_index += len_of_len;
1561
1562         if((temp_index+evt_list_len) > tlv_len) {
1563                 dbg("[SAT] SAT PARSER - incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+evt_list_len),tlv_len);
1564                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1565         }
1566
1567         if(evt_list_len > SAT_EVENT_LIST_MAX){
1568                 dbg("[SAT] SAT PARSER - event list contains more items than it is supposed to have! len=%d", evt_list_len);
1569                 if(comprehension_req)
1570                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1571                 else
1572                         evt_list_len = SAT_EVENT_LIST_MAX;
1573         }
1574
1575         event_list_obj->event_list_cnt = 0;
1576         memset(event_list_obj->evt_list, 0xFF, SAT_EVENT_LIST_MAX);
1577
1578         //event list
1579         for(i = 0; i < evt_list_len; i++){
1580                 dbg("[SAT] SAT PARSER - event[%d]=0x%x", i, src_data[temp_index]);
1581                 switch(src_data[temp_index]){
1582                         /*PDA events*/
1583                         case EVENT_USER_ACTIVITY:
1584                         case EVENT_IDLE_SCREEN_AVAILABLE:
1585                         case EVENT_LANGUAGE_SELECTION:
1586                         case EVENT_BROWSER_TERMINATION:
1587                         case EVENT_DATA_AVAILABLE:
1588                         case EVENT_CHANNEL_STATUS:
1589                         case EVENT_MT_CALL      :
1590                         case EVENT_CALL_CONNECTED:
1591                         case EVENT_CALL_DISCONNECTED:
1592                         case EVENT_LOCATION_STATUS:
1593                         case EVENT_ACCESS_TECHNOLOGY_CHANGED:
1594                                 event_list_obj->evt_list[i] = src_data[temp_index];
1595                                 event_list_obj->event_list_cnt++;
1596                                 break;
1597                         case EVENT_UNKNOWN:
1598                         default:
1599                                 if(comprehension_req)
1600                                         return TCORE_SAT_BEYOND_ME_CAPABILITY;
1601                                 break;
1602                 }
1603                 temp_index++;
1604         }
1605
1606          // 1 is the length of Tag.
1607         *consumed_data_len = 1 + len_of_len + evt_list_len;
1608         return TCORE_SAT_SUCCESS;
1609 }
1610
1611 static enum tcore_sat_result _sat_decode_icon_identifier_tlv(unsigned char* tlv_str, int tlv_len,
1612                 int curr_offset, struct tel_sat_icon_identifier* icon_id_obj, int* consumed_data_len)
1613 {
1614         unsigned char* src_data;
1615         int temp_index = 0;
1616
1617         if(tlv_str == NULL || icon_id_obj == NULL ||consumed_data_len == NULL)  {
1618                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || icon_id_obj == NULL ||consumed_data_len == NULL");
1619                 return TCORE_SAT_ERROR_FATAL;
1620         }
1621
1622         if(tlv_len <= (curr_offset+1)) {//length of icon id tlv is 4
1623                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
1624                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1625         }
1626
1627         //tag
1628         temp_index = curr_offset;
1629         src_data = &tlv_str[0];
1630         if((src_data[temp_index++]&0x7F) != SATK_ICON_IDENTIFIER_TAG) {
1631                 dbg("[SAT] SAT PARSER -  icon identity tag missing.");
1632                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1633         }
1634
1635         if(src_data[temp_index++] != SATK_ICON_IDENTITY_LENGTH) {
1636                 dbg("[SAT] SAT PARSER -  incorrect length value.");
1637                 return FALSE; //send TR
1638         }
1639
1640         if((temp_index+SATK_ICON_IDENTITY_LENGTH) > tlv_len) {
1641                 dbg("[SAT] SAT PARSER -  incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+SATK_ICON_IDENTITY_LENGTH),tlv_len);
1642                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1643         }
1644         icon_id_obj->is_exist = TRUE;
1645
1646         if((src_data[temp_index++]&0x01))
1647                 icon_id_obj->icon_qualifer = ICON_QUALI_NOT_SELF_EXPLANATORY;
1648         else
1649                 icon_id_obj->icon_qualifer = ICON_QUALI_SELF_EXPLANATORY;
1650
1651         if(src_data[temp_index] > 0x00) {
1652                 icon_id_obj->icon_identifier = src_data[temp_index];
1653         }
1654         else {
1655                 dbg("[SAT] SAT PARSER -  incorrect icon identifier");
1656                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1657         }
1658
1659         dbg("[SAT] SAT PARSER -  icon_qual=%d, iconId=%d",icon_id_obj->icon_qualifer, icon_id_obj->icon_identifier);
1660         *consumed_data_len = 4;
1661         return TCORE_SAT_SUCCESS;
1662 }
1663
1664 static enum tcore_sat_result _sat_decode_icon_identifier_list_tlv(unsigned char* tlv_str,
1665                 int tlv_len, int curr_offset, struct tel_sat_icon_identifier_list* icon_list_obj,
1666                 int* consumed_data_len)
1667 {
1668         int temp_index, i;
1669         int len_value =0;
1670         unsigned char* src_data;
1671         gboolean comprehension_req = FALSE;
1672
1673         if(tlv_str == NULL || consumed_data_len == NULL || icon_list_obj == NULL) {
1674                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || icon_list_obj == NULL");
1675                 return TCORE_SAT_ERROR_FATAL;
1676         }
1677
1678         if(tlv_len <= (curr_offset+1)+1) {
1679                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
1680                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1681         }
1682
1683         //tag
1684         temp_index = curr_offset;
1685         src_data = &tlv_str[0];
1686         if((src_data[temp_index]&0x7F) != SATK_ITEM_ICON_IDENTIFIER_LIST_TAG) {
1687                 dbg("[SAT] SAT PARSER -  icon identity tag missing.");
1688                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1689         }
1690
1691         icon_list_obj->is_exist = TRUE;
1692         if(src_data[temp_index++]&0x80)
1693                 comprehension_req = TRUE;
1694
1695         len_value = src_data[temp_index++];
1696         if(src_data[temp_index++]&0x01)
1697                 icon_list_obj->icon_qualifer = ICON_QUALI_NOT_SELF_EXPLANATORY;
1698         else
1699                 icon_list_obj->icon_qualifer = ICON_QUALI_SELF_EXPLANATORY;
1700
1701         icon_list_obj->icon_cnt = len_value-1;
1702         if(icon_list_obj->icon_cnt > SAT_ICON_LIST_MAX_COUNT){
1703                 if(comprehension_req == TRUE) {
1704                         dbg("[SAT] SAT PARSER -  list count exceeds maximum allowed count=%d",icon_list_obj->icon_cnt);
1705                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1706                 }
1707                 icon_list_obj->icon_cnt = 0;
1708         }
1709         else{
1710
1711                 for(i=0;i<icon_list_obj->icon_cnt;i++) {
1712                         if(src_data[temp_index] > 0x00) {
1713                                 icon_list_obj->icon_id_list[i]= src_data[temp_index++];
1714                         } else  {
1715                                 dbg("[SAT] SAT PARSER -  incorrect icon identifier");
1716                                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1717                         }
1718                 }
1719         }
1720
1721         *consumed_data_len = 1+1+len_value;
1722         dbg("[SAT] SAT PARSER -  icon_qual=%d, iconCount=%d",icon_list_obj->icon_qualifer, icon_list_obj->icon_cnt);
1723         return TCORE_SAT_SUCCESS;
1724 }
1725
1726 static enum tcore_sat_result _sat_decode_dtmf_string_tlv(unsigned char* tlv_str, int tlv_len,
1727                 int curr_offset, struct tel_sat_dtmf_string* dtmf_string_obj, int* consumed_data_len)
1728 {
1729         unsigned char* src_data;
1730         int temp_index, len_of_len = 0;
1731         int dtmf_len = 0;
1732         gboolean comprehension_req = FALSE;
1733         char* str_ascii = NULL;
1734
1735         if (tlv_str == NULL || consumed_data_len == NULL || dtmf_string_obj == NULL) {
1736                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || dtmf_string_obj == NULL");
1737                 return TCORE_SAT_ERROR_FATAL;
1738         }
1739
1740         src_data = &tlv_str[0];
1741
1742         if (tlv_len <= (curr_offset + 1)) {
1743                 dbg("[SAT] SAT PARSER - incorrect length original_command_len=%d", tlv_len);
1744                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1745         }
1746
1747         //Tag
1748         temp_index = curr_offset;
1749         if ((src_data[temp_index] & 0x7F) != SATK_DTMF_STRING_TAG) {
1750                 dbg("[SAT] SAT PARSER - address tag missing");
1751                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
1752         }
1753
1754         //comprehensive required
1755         if((src_data[temp_index++] & 0x80))
1756                 comprehension_req = TRUE;
1757
1758         dbg("comprehension_req=[%d]", comprehension_req);
1759
1760         //length
1761         len_of_len = _get_length_filed_size(src_data[temp_index]);
1762         if(!len_of_len){
1763                 err("[SAT] parser: invalid length.");
1764                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1765         }
1766
1767         dtmf_len = src_data[temp_index + len_of_len - 1];
1768         temp_index += len_of_len; //temp_index pointing to TON/NPI
1769
1770         if ((temp_index + dtmf_len) > tlv_len) {
1771                 dbg("[SAT] SAT PARSER - incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+dtmf_len), tlv_len);
1772                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1773         }
1774
1775         dtmf_string_obj->dtmf_length = 0;
1776
1777         if(dtmf_len > 0){
1778                 str_ascii = tcore_util_convert_bcd2ascii((const char*)&src_data[temp_index], dtmf_len, SAT_DTMF_STRING_LEN_MAX);
1779                 if(str_ascii){
1780                         memcpy(dtmf_string_obj->dtmf_string, str_ascii, strlen(str_ascii));
1781                         dtmf_string_obj->dtmf_length = strlen(str_ascii);
1782                         g_free(str_ascii);
1783                 }
1784         }
1785
1786         if (dtmf_string_obj->dtmf_length == 0) {
1787                 dbg("[SAT] SAT PARSER - DTMF string length is either 0 or it is too long for the ME to handle.");
1788                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1789         }
1790
1791         *consumed_data_len = 1 + len_of_len + dtmf_len;
1792         return TCORE_SAT_SUCCESS;
1793 }
1794
1795 static enum tcore_sat_result _sat_decode_language_tlv(unsigned char* tlv_str, int tlv_len,
1796                 int curr_offset, enum tel_sim_language_type* language_obj)
1797 {
1798         unsigned char* src_data;
1799         int temp_index = 0;
1800
1801         if(tlv_len <= (curr_offset+1)) {
1802                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
1803                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1804         }
1805
1806         src_data = &tlv_str[0];
1807         temp_index = curr_offset;
1808
1809         if((src_data[temp_index++]&0x7F) != SATK_LANGUAGE_TAG)  {
1810                 dbg("[SAT] SAT PARSER -  Language tag missing.");
1811                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1812         }
1813         if(src_data[temp_index++] != SATK_LANGUAGE_LENGTH) {
1814                 dbg("[SAT] SAT PARSER -  incorrect length value.");
1815                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1816         }
1817
1818         if((temp_index+SATK_LANGUAGE_LENGTH) > tlv_len) {
1819                 dbg("[SAT] SAT PARSER -  incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+SATK_LANGUAGE_LENGTH),tlv_len);
1820                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1821         }
1822         *language_obj = _sat_decode_language(src_data[temp_index], src_data[temp_index+1]);
1823         dbg("[SAT] SAT PARSER -  <in> %c %c, <out> %d", src_data[temp_index], src_data[temp_index+1], *language_obj);
1824         return TCORE_SAT_SUCCESS;
1825 }
1826
1827 static enum tcore_sat_result _sat_decode_browser_identity_tlv(unsigned char* tlv_str, int tlv_len, int curr_offset,
1828                 enum browser_identity* browser_id, int* consumed_data_len)
1829 {
1830         unsigned char* src_data;
1831         int temp_index = 0;
1832
1833         if (tlv_str == NULL || browser_id == NULL || consumed_data_len == NULL) {
1834                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || browser_id == NULL ||consumed_data_len == NULL");
1835                 return TCORE_SAT_ERROR_FATAL;
1836         }
1837
1838         if (tlv_len <= (curr_offset + 1)) {
1839                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
1840                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1841         }
1842
1843         temp_index = curr_offset;
1844         src_data = &tlv_str[0];
1845
1846         if ((src_data[temp_index++] & 0x7F) != SATK_BROWSER_IDENTITY_TAG) {
1847                 dbg("[SAT] SAT PARSER -  Browser ID tag missing.");
1848                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1849         }
1850         if (src_data[temp_index++] != SATK_BROWSER_ID_LENGTH) {
1851                 dbg("[SAT] SAT PARSER -  incorrect length value.");
1852                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1853         }
1854
1855         dbg("[SAT] SAT PARSER - : browser ID value:ox%x", src_data[temp_index]);
1856
1857         switch (src_data[temp_index]) {
1858                 case 0x00:
1859                         *browser_id = BROWSER_ID_DEFAULT;
1860                         break;
1861                 case 0x01:
1862                         *browser_id = BROWSER_ID_WML;
1863                         break;
1864                 case 0x02:
1865                         *browser_id = BROWSER_ID_HTML;
1866                         break;
1867                 case 0x03:
1868                         *browser_id = BROWSER_ID_XHTML;
1869                         break;
1870                 case 0x04:
1871                         *browser_id = BROWSER_ID_CHTML;
1872                         break;
1873                 default:
1874                         *browser_id = BROWSER_ID_RESERVED;
1875                         break;
1876         }
1877
1878         *consumed_data_len = 3;
1879         return TCORE_SAT_SUCCESS;
1880 }
1881
1882 static enum tcore_sat_result _sat_decode_url_tlv(unsigned char* tlv_str, int tlv_len, int curr_offset,
1883                 struct tel_sat_url* url, int* consumed_data_len)
1884 {
1885         unsigned char* src_data;
1886         int temp_index= curr_offset;
1887         int len_of_len=0, url_len=0;
1888
1889         if (tlv_str == NULL || url == NULL || consumed_data_len == NULL)        {
1890                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || url == NULL ||consumed_data_len == NULL");
1891                 return TCORE_SAT_ERROR_FATAL;
1892         }
1893
1894         src_data = &tlv_str[0];
1895         if(tlv_len <= (curr_offset+1)) {
1896                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
1897                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1898         }
1899
1900         if((src_data[temp_index++]&0x7F) != SATK_URL_TAG) {
1901                 dbg("[SAT] SAT PARSER -  Browser URL tag missing.");
1902                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
1903         }
1904
1905         //length
1906         len_of_len = _get_length_filed_size(src_data[temp_index]);
1907         if(!len_of_len){
1908                 err("[SAT] parser: invalid length.");
1909                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1910         }
1911
1912         url_len =  src_data[temp_index+len_of_len-1];
1913         url->url_length = url_len;
1914         temp_index+=len_of_len; //temp_index pointing to url.
1915         dbg("URL length (%d)", url_len);
1916
1917         if(url_len < 0){
1918                 dbg("[SAT] URL is null");
1919                 *consumed_data_len = 1+len_of_len+url_len;
1920                 return TCORE_SAT_SUCCESS;
1921         }
1922
1923         if(url_len > SAT_URL_LEN_MAX){
1924                 dbg("[SAT] URL length is wrong");
1925                 *consumed_data_len = 1+len_of_len+url_len;
1926                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1927         }
1928
1929         memcpy(url->url, &src_data[temp_index], url_len);
1930         dbg("[SAT] url(%s)", url->url);
1931         *consumed_data_len = 1+len_of_len+url_len;
1932
1933         return TCORE_SAT_SUCCESS;
1934 }
1935
1936 static enum tcore_sat_result _sat_decode_bearer_tlv(unsigned char* tlv_str, int tlv_len, int curr_offset,
1937                 struct tel_sat_bearer_list* satk_bearer, int* consumed_data_len)
1938 {
1939         unsigned char* src_data;
1940         int temp_index, len_of_len = 0;
1941         int list_len = 0, list_idx = 0;
1942
1943         if (tlv_str == NULL || consumed_data_len == NULL || satk_bearer == NULL) {
1944                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || satk_bearer == NULL");
1945                 return TCORE_SAT_ERROR_FATAL;
1946         }
1947
1948         if (tlv_len <= (curr_offset + 1)) {
1949                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d",     tlv_len);
1950                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1951         }
1952
1953         src_data = &tlv_str[0];
1954         temp_index = curr_offset;
1955
1956         if ((src_data[temp_index++] & 0x7F) != SATK_BEARER_TAG) {
1957                 dbg("[SAT] SAT PARSER - _sat_decode_bearer_tlv: alphaID TAG missing");
1958                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1959         }
1960
1961         //length
1962         len_of_len = _get_length_filed_size(src_data[temp_index]);
1963         if(!len_of_len){
1964                 err("[SAT] parser: invalid length.");
1965                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1966         }
1967
1968         satk_bearer->count = src_data[temp_index + len_of_len - 1];
1969         list_len = satk_bearer->count;
1970         temp_index += len_of_len;
1971
1972         if ((temp_index + list_len) > tlv_len) {
1973                 dbg("[SAT] SAT PARSER -  incorrect cmd len, expected len = %d, orig_len=%d",    (temp_index + list_len), tlv_len);
1974                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1975         }
1976
1977         if (satk_bearer->count > 0) {
1978                 if (list_len > SAT_BEARER_LIST_MAX_COUNT)
1979                         list_len = SAT_BEARER_LIST_MAX_COUNT;
1980
1981                 for (list_idx = 0; list_idx < list_len; list_idx++) {
1982                         switch (src_data[temp_index]) {
1983                                 case 0x00:
1984                                         satk_bearer->bear[list_idx] = BEARER_LIST_SMS;
1985                                         break;
1986                                 case 0x01:
1987                                         satk_bearer->bear[list_idx] = BEARER_LIST_CSD;
1988                                         break;
1989                                 case 0x02:
1990                                         satk_bearer->bear[list_idx] = BEARER_LIST_USSD;
1991                                         break;
1992                                 case 0x03:
1993                                         satk_bearer->bear[list_idx] = BEARER_LIST_GPRS;
1994                                         break;
1995                                 default:
1996                                         satk_bearer->bear[list_idx] = BEARER_LIST_RESERVED;
1997                                         break;
1998                         }
1999                         dbg("[SAT] SAT PARSER -  bearer[%d]=0x%x", list_idx, satk_bearer->bear[list_idx]);
2000                         temp_index++;
2001                 }
2002         } else {
2003                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2004         }
2005
2006         *consumed_data_len = 1 + len_of_len + list_len;
2007         return TCORE_SAT_SUCCESS;
2008 }
2009
2010 static enum tcore_sat_result _sat_decode_provisioning_file_ref_tlv(unsigned char* tlv_str,
2011                 int tlv_len, int curr_offset, struct tel_sat_provisioning_file_ref* prf, int* data_len_consumed)
2012 {
2013         unsigned char* src_data;
2014         int temp_index = curr_offset;
2015         int len_of_len = 0, prf_len = 0;
2016
2017         if (tlv_str == NULL || prf == NULL || data_len_consumed == NULL) {
2018                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || prf == NULL ||data_len_consumed == NULL");
2019                 return TCORE_SAT_ERROR_FATAL;
2020         }
2021
2022         src_data = &tlv_str[0];
2023         if (tlv_len <= (curr_offset + 1)) {
2024                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d",tlv_len);
2025                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2026         }
2027
2028         if ((src_data[temp_index++] & 0x7F) != SATK_PROVISIONING_REF_FILE_TAG) {
2029                 dbg("[SAT] SAT PARSER -  PRF tag missing.");
2030                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2031         }
2032
2033         //length
2034         len_of_len = _get_length_filed_size(src_data[temp_index]);
2035         if(!len_of_len){
2036                 err("[SAT] parser: invalid length.");
2037                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2038         }
2039
2040         prf_len = src_data[temp_index + len_of_len - 1];
2041         prf->file_path_length = prf_len;
2042         temp_index += len_of_len; //temp_index pointing to prf.
2043
2044         if (prf_len > 0) {
2045                 if (prf_len > SAT_PROVISIONING_FILE_PATH_LEN_MAX)
2046                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2047                 else
2048                         memcpy(prf->file_path, &src_data[temp_index], prf_len);
2049         } else {
2050                 dbg("[SAT] SAT PARSER -  NULL string for PRF");
2051                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2052         }
2053
2054         *data_len_consumed = 1 + len_of_len + prf_len;
2055         return TCORE_SAT_SUCCESS;
2056 }
2057
2058 static enum tcore_sat_result _sat_decode_bearer_description_tlv(unsigned char* tlv_str,
2059                 int tlv_len, int curr_offset, struct tel_sat_bearer_description *bearer_desc_obj,
2060                 int* consumed_data_len)
2061 {
2062         int temp_index, length=0;
2063         unsigned char* src_data;
2064
2065         if(tlv_len <= (curr_offset+1)+1) {
2066                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
2067                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2068         }
2069
2070         temp_index = curr_offset;
2071         src_data = &tlv_str[0];
2072         while(1){
2073                 if(temp_index >= tlv_len){
2074                         dbg("bearer desc cannot find. UICC Server mode");
2075                         *consumed_data_len = 0;
2076                         return TCORE_SAT_SUCCESS;
2077                 }
2078
2079                 if( (src_data[temp_index]&0x7F) == SATK_BEARER_DISCRIPTION_TAG ){
2080                         dbg("find bearer description tag temp_index(%d)", temp_index);
2081                         temp_index++;
2082                         break;
2083                 }
2084                 temp_index++;
2085         }
2086
2087         //length
2088         length = src_data[temp_index++];
2089         dbg("bearer description length (%d)", length);
2090
2091         //bearer parameter
2092         switch(src_data[temp_index++]){
2093                 case BEARER_CSD:
2094                         bearer_desc_obj->bearer_type = BEARER_CSD;
2095                         bearer_desc_obj->bearer_parameter.cs_bearer_param.data_rate = src_data[temp_index++];
2096                         bearer_desc_obj->bearer_parameter.cs_bearer_param.service_type = src_data[temp_index++];
2097                         bearer_desc_obj->bearer_parameter.cs_bearer_param.connection_element_type = src_data[temp_index++];
2098                         break;
2099                 case BEARER_GPRS:
2100                         bearer_desc_obj->bearer_type = BEARER_GPRS;
2101                         bearer_desc_obj->bearer_parameter.ps_bearer_param.precedence_class = src_data[temp_index++];
2102                         bearer_desc_obj->bearer_parameter.ps_bearer_param.delay_class = src_data[temp_index++];
2103                         bearer_desc_obj->bearer_parameter.ps_bearer_param.reliability_class = src_data[temp_index++];
2104                         bearer_desc_obj->bearer_parameter.ps_bearer_param.peak_throughput_class = src_data[temp_index++];
2105                         bearer_desc_obj->bearer_parameter.ps_bearer_param.mean_throughput_class = src_data[temp_index++];
2106                         bearer_desc_obj->bearer_parameter.ps_bearer_param.pdp_type = BIP_GPRS_PDP_TYPE_RESERVED;
2107                         if(src_data[temp_index] == BIP_GPRS_PDP_TYPE_IP)
2108                                 bearer_desc_obj->bearer_parameter.ps_bearer_param.pdp_type = BIP_GPRS_PDP_TYPE_IP;
2109                         break;
2110                 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:
2111                         bearer_desc_obj->bearer_type = BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER;
2112                         break;
2113                 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:
2114                         bearer_desc_obj->bearer_type = BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER;
2115                         break;
2116                 default:
2117                         bearer_desc_obj->bearer_type = BEARER_RESERVED;
2118                         dbg("bearer type not supported");
2119                         return TCORE_SAT_BEYOND_ME_CAPABILITY;
2120         }
2121
2122         *consumed_data_len = 1+1+length;
2123         return TCORE_SAT_SUCCESS;
2124 }
2125
2126 static enum tcore_sat_result _sat_decode_channel_data_tlv(unsigned char* tlv_str,
2127                 int tlv_len, int curr_offset, struct tel_sat_channel_data *channel_data_obj,
2128                 int* consumed_data_len)
2129 {
2130         int temp_index = 0;
2131         int len_of_len = 0, channel_data_len = 0;
2132         unsigned char* src_data;
2133
2134         if(tlv_str == NULL || consumed_data_len == NULL || channel_data_obj == NULL) {
2135                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || channel_data_obj == NULL");
2136                 return TCORE_SAT_ERROR_FATAL;
2137         }
2138
2139         if(tlv_len <= (curr_offset+1)) {
2140                 dbg("[SAT] SAT PARSER - incorrect length original_command_len=%d", tlv_len);
2141                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2142         }
2143
2144         //tag
2145         temp_index = curr_offset;
2146         src_data = &tlv_str[0];
2147         if((src_data[temp_index++]&0x7F) != SATK_CHANNEL_DATA_TAG){
2148                 dbg("[SAT] SAT PARSER - tag not found.=%d",src_data[temp_index]);
2149                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2150         }
2151
2152         //length
2153         len_of_len = _get_length_filed_size(src_data[temp_index]);
2154         if(!len_of_len){
2155                 err("[SAT] parser: invalid length.");
2156                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2157         }
2158
2159         channel_data_len = src_data[temp_index+len_of_len-1];
2160         dbg("[SAT] parser: channel_data_len=%d",channel_data_len);
2161         temp_index += len_of_len;
2162
2163         if((temp_index+channel_data_len) > tlv_len) {
2164                 dbg("[SAT] SAT PARSER - incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+channel_data_len),tlv_len);
2165                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2166         }
2167
2168         //data
2169         channel_data_obj->data_string_len = channel_data_len;
2170         memcpy(channel_data_obj->data_string, &src_data[temp_index], channel_data_len);
2171
2172         *consumed_data_len = 1+len_of_len+channel_data_len;
2173         return TCORE_SAT_SUCCESS;
2174 }
2175
2176 static enum tcore_sat_result _sat_decode_channel_data_length_tlv(unsigned char* tlv_str,
2177                 int tlv_len, int curr_offset, struct tel_sat_channel_data_len *data_len_obj,
2178                 int* consumed_data_len)
2179 {
2180         int temp_index;
2181         unsigned char* src_data;
2182
2183         if(tlv_str == NULL || consumed_data_len == NULL || data_len_obj == NULL) {
2184                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || data_len_obj == NULL");
2185                 return TCORE_SAT_ERROR_FATAL;
2186         }
2187
2188         //tag
2189         temp_index = curr_offset;
2190         src_data = &tlv_str[0];
2191         if((src_data[temp_index++]&0x7F) != SATK_CHANNEL_DATA_LEN_TAG) {
2192                 dbg("[SAT] SAT PARSER -  channel data tag missing.");
2193                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2194         }
2195
2196         //length
2197         if(src_data[temp_index++] != SATK_CHANNEL_DATA_LENGTH_VALUE_LENGTH) {
2198                 dbg("[SAT] SAT PARSER -  incorrect length");
2199                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2200         }
2201
2202         //data
2203         data_len_obj->data_len = src_data[temp_index];
2204
2205         *consumed_data_len = 3;
2206         return TCORE_SAT_SUCCESS;
2207 }
2208
2209 static enum tcore_sat_result _sat_decode_buffer_size_tlv(unsigned char* tlv_str,
2210                 int tlv_len, int curr_offset, struct tel_sat_buffer_size *buffer_size_obj,
2211                 int* consumed_data_len)
2212 {
2213         int temp_index;
2214         unsigned char* src_data;
2215
2216         if(tlv_str == NULL || consumed_data_len == NULL || buffer_size_obj == NULL) {
2217                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || buffer_size_obj == NULL");
2218                 return TCORE_SAT_ERROR_FATAL;
2219         }
2220
2221         if(tlv_len <= (curr_offset+1)+SATK_BUFFER_SIZE_LENGTH) {
2222                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
2223                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2224         }
2225
2226         //tag
2227         temp_index = curr_offset;
2228         src_data = &tlv_str[0];
2229         if((src_data[temp_index++]&0x7F) != SATK_BUFFER_SIZE_TAG) {
2230                 dbg("[SAT] SAT PARSER -  buffer size tag missing.");
2231                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2232         }
2233
2234         //length
2235         if(src_data[temp_index++] != SATK_BUFFER_SIZE_LENGTH) {
2236                 dbg("[SAT] SAT PARSER -  incorrect length");
2237                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2238         }
2239
2240         buffer_size_obj->size[0] = src_data[temp_index++];
2241         buffer_size_obj->size[1] = src_data[temp_index];
2242
2243         *consumed_data_len = 4;
2244         dbg("[SAT] SAT PARSER -  buffer size = 0x%x%x", buffer_size_obj->size[0], buffer_size_obj->size[1]);
2245         return TCORE_SAT_SUCCESS;
2246 }
2247
2248 static enum tcore_sat_result _sat_decode_other_address_tlv(unsigned char* tlv_str,
2249                 int tlv_len, int curr_offset, struct tel_sat_other_address *other_address_obj,
2250                 int* consumed_data_len)
2251 {
2252         gchar* address = NULL;
2253         int temp_index, address_len;
2254         unsigned char* src_data;
2255
2256         if(tlv_str == NULL || consumed_data_len == NULL || other_address_obj == NULL) {
2257                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || other_address_obj == NULL");
2258                 return TCORE_SAT_ERROR_FATAL;
2259         }
2260
2261         if(tlv_len <= (curr_offset+1)) {
2262                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
2263                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2264         }
2265
2266         //tag
2267         temp_index = curr_offset;
2268         src_data = &tlv_str[0];
2269         if((src_data[temp_index++]&0x7F) != SATK_OTHER_ADDRESS_TAG) {
2270                 dbg("[SAT] SAT PARSER -  other address tag missing.");
2271                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2272         }
2273
2274         //length
2275         address_len = src_data[temp_index++];
2276         if((temp_index+address_len) > tlv_len) {
2277                 dbg("[SAT] SAT PARSER -  incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+address_len),tlv_len);
2278                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2279         }
2280
2281         if(address_len-1 > SAT_OTHER_ADDR_LEN_MAX){
2282                 dbg("[SAT] SAT PARSER - address is longer than capability");
2283                 return TCORE_SAT_BEYOND_ME_CAPABILITY;
2284         }
2285
2286         //other address type
2287         switch(src_data[temp_index++]){
2288                 case ADDR_TYPE_IPv4:{
2289                         other_address_obj->address_type = ADDR_TYPE_IPv4;
2290                         address = g_strdup_printf("%d.%d.%d.%d", src_data[temp_index], src_data[temp_index+1], src_data[temp_index+2], src_data[temp_index+3]);
2291                 }break;
2292                 case ADDR_TYPE_IPv6:{
2293                         other_address_obj->address_type = ADDR_TYPE_IPv6;
2294                         address = g_strdup_printf("%x%x:%x%x:%x%x:%x%x:%x%x:%x%x:%x%x:%x%x:",
2295                                         src_data[temp_index], src_data[temp_index+1], src_data[temp_index+2], src_data[temp_index+3],
2296                                         src_data[temp_index+4], src_data[temp_index+5], src_data[temp_index+6], src_data[temp_index+7],
2297                                         src_data[temp_index+8], src_data[temp_index+9], src_data[temp_index+10], src_data[temp_index+11],
2298                                         src_data[temp_index+12], src_data[temp_index+13], src_data[temp_index+14], src_data[temp_index+15]);
2299                 }break;
2300                 default:{
2301                         other_address_obj->address_type = ADDR_RESERVED;
2302                         address = g_strdup("");
2303                 }break;
2304         }//end of switch
2305
2306         //address
2307         if (address) {
2308                 memcpy(other_address_obj->address, address, strlen(address));
2309                 other_address_obj->address_len = strlen(address);
2310
2311                 g_free(address);
2312                 dbg("destination address(%s)", other_address_obj->address);
2313         }
2314
2315         *consumed_data_len = 2+address_len;
2316         return TCORE_SAT_SUCCESS;
2317 }
2318
2319 static enum tcore_sat_result _sat_decode_uicc_terminal_interface_tlv(unsigned char* tlv_str,
2320                 int tlv_len, int curr_offset, struct tel_sat_uicc_terminal_interface_transport_level *level_obj,
2321                 int* consumed_data_len)
2322 {
2323         int temp_index;
2324         unsigned char* src_data;
2325
2326         if(tlv_str == NULL || consumed_data_len == NULL || level_obj == NULL) {
2327                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || level_obj == NULL");
2328                 return TCORE_SAT_ERROR_FATAL;
2329         }
2330
2331         if(tlv_len <= (curr_offset+1)+SATK_UICC_ME_TRANS_INTERFACE_LEVEL_LENGTH) {
2332                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
2333                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2334         }
2335
2336         //tag
2337         temp_index = curr_offset;
2338         src_data = &tlv_str[0];
2339         if((src_data[temp_index++]&0x7F) != SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG) {
2340                 dbg("[SAT] SAT PARSER - UICC/TERMINAL Interface transport level tag missing.");
2341                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2342         }
2343
2344         //length
2345         if(src_data[temp_index++] != SATK_UICC_ME_TRANS_INTERFACE_LEVEL_LENGTH) {
2346                 dbg("[SAT] SAT PARSER -  incorrect length");
2347                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2348         }
2349
2350         level_obj->protocol_type = src_data[temp_index++];
2351         level_obj->port_number = src_data[temp_index++] << 8;
2352         level_obj->port_number |= src_data[temp_index];
2353
2354         *consumed_data_len = 2+SATK_UICC_ME_TRANS_INTERFACE_LEVEL_LENGTH;
2355         dbg("[SAT] SAT PARSER -  protocol type(%d) , port number(%d)", level_obj->protocol_type, level_obj->port_number);
2356         return TCORE_SAT_SUCCESS;
2357 }
2358
2359 static enum tcore_sat_result _sat_decode_remote_entity_address_tlv(unsigned char* tlv_str,
2360                 int tlv_len, int curr_offset, struct tel_sat_remote_entity_address *remote_address_obj,
2361                 int* consumed_data_len)
2362 {
2363         int temp_index = 0;
2364         int len_of_len = 0, remote_data_len = 0;
2365         unsigned char* src_data;
2366
2367         if(tlv_str == NULL || consumed_data_len == NULL || remote_address_obj == NULL) {
2368                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || remote_address_obj == NULL");
2369                 return TCORE_SAT_ERROR_FATAL;
2370         }
2371
2372         if(tlv_len <= (curr_offset+1)) {
2373                 dbg("[SAT] SAT PARSER - incorrect length original_command_len=%d", tlv_len);
2374                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2375         }
2376
2377         //tag
2378         temp_index = curr_offset;
2379         src_data = &tlv_str[0];
2380         if((src_data[temp_index]&0x7F) != SATK_REMOTE_ENTITY_ADDRESS_TAG){
2381                 dbg("[SAT] SAT PARSER - tag not found.=%d",src_data[temp_index]);
2382                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2383         }
2384
2385         //length
2386         len_of_len = _get_length_filed_size(src_data[temp_index]);
2387         if(!len_of_len){
2388                 err("[SAT] parser: invalid length.");
2389                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2390         }
2391
2392         remote_data_len = src_data[temp_index+len_of_len-1];
2393         dbg("[SAT] parser: remote_data_len=%d",remote_data_len);
2394         temp_index += len_of_len;
2395
2396         //data
2397         switch(src_data[temp_index++]){
2398                 case REMOTE_ENTITY_ADDR_CODING_TYPE_IEEE802_48BIT:
2399                         remote_address_obj->coding_type = REMOTE_ENTITY_ADDR_CODING_TYPE_IEEE802_48BIT;
2400                         break;
2401                 case REMOTE_ENTITY_ADDR_CODING_TYPE_IRDA_32BIT:
2402                         remote_address_obj->coding_type = REMOTE_ENTITY_ADDR_CODING_TYPE_IRDA_32BIT;
2403                         break;
2404                 default:
2405                         remote_address_obj->coding_type =REMOTE_ENTITY_ADDR_CODING_TYPE_RESERVED;
2406                         break;
2407         }
2408
2409         remote_address_obj->length = remote_data_len - 1;
2410         memcpy(remote_address_obj->remote_entity_address, &src_data[temp_index], remote_address_obj->length);
2411
2412         *consumed_data_len = 1+len_of_len+remote_data_len;
2413         return TCORE_SAT_SUCCESS;
2414 }
2415
2416 static enum tcore_sat_result _sat_decode_network_access_name_tlv(unsigned char* tlv_str,
2417                 int tlv_len, int curr_offset, struct tel_sat_network_access_name *access_name_obj,
2418                 int* consumed_data_len)
2419 {
2420         int temp_index, idx, name_idx, name_length;
2421         unsigned char* src_data;
2422
2423         if(tlv_str == NULL || consumed_data_len == NULL || access_name_obj == NULL) {
2424                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || access_name_obj == NULL");
2425                 return TCORE_SAT_ERROR_FATAL;
2426         }
2427
2428         if(tlv_len <= (curr_offset+1)) {
2429                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
2430                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2431         }
2432
2433         //tag
2434         temp_index = curr_offset;
2435         src_data = &tlv_str[0];
2436         if((src_data[temp_index++]&0x7F) != SATK_NETWORK_ACCESS_TAG) {
2437                 dbg("[SAT] SAT PARSER -  network access name tag missing.");
2438                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2439         }
2440
2441         //length
2442         name_length = src_data[temp_index++];
2443         if((temp_index+name_length) > tlv_len) {
2444                 dbg("[SAT] SAT PARSER -  incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+name_length),tlv_len);
2445                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2446         }
2447
2448         access_name_obj->length = name_length;
2449         if(access_name_obj->length > SAT_NET_ACC_NAM_LEN_MAX){
2450                 dbg("[SAT] SAT PARSER - network access name is longer than capability");
2451                 return TCORE_SAT_BEYOND_ME_CAPABILITY;
2452         }
2453
2454         name_idx = 0;
2455         for(idx = 0; idx < access_name_obj->length; idx++){
2456                 dbg("data (%c) Bool(%d)",src_data[temp_index], g_ascii_isalpha(src_data[temp_index]) );
2457
2458                 if( g_ascii_isalpha(src_data[temp_index]) ){
2459                         access_name_obj->network_access_name[name_idx] = src_data[temp_index];
2460                         name_idx++;
2461                 }
2462                 else{
2463
2464                         if(src_data[temp_index] == 0x02){//02 convert to "."
2465                                 access_name_obj->network_access_name[name_idx] = '.';
2466                                 name_idx++;
2467                         }
2468                 }
2469                 temp_index++;
2470         }
2471
2472         //network access name
2473         dbg("network access name(%s)", access_name_obj->network_access_name);
2474
2475         *consumed_data_len = 2+name_length;
2476         return TCORE_SAT_SUCCESS;
2477 }
2478
2479 static enum tcore_sat_result _sat_decode_text_attribute_tlv(unsigned char* tlv_str,
2480                 int tlv_len, int curr_offset, struct tel_sat_text_attribute *text_attribute_obj,
2481                 int* consumed_data_len)
2482 {
2483         int temp_index, length;
2484         unsigned char* src_data;
2485
2486         if(tlv_str == NULL || consumed_data_len == NULL || text_attribute_obj == NULL) {
2487                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || text_attribute_obj == NULL");
2488                 return TCORE_SAT_ERROR_FATAL;
2489         }
2490
2491         if(tlv_len <= (curr_offset+1)) {
2492                 dbg("[SAT] SAT PARSER - incorrect length original_command_len=%d", tlv_len);
2493                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2494         }
2495
2496         //tag
2497         temp_index = curr_offset;
2498         src_data = &tlv_str[0];
2499         if((src_data[temp_index++]&0x7F) != SATK_TEXT_ATTRIBUTE_TAG) {
2500                 dbg("[SAT] SAT PARSER - text attribute tag is missing");
2501                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2502         }
2503
2504         //length
2505         length = src_data[temp_index++];
2506         if((temp_index+length) > tlv_len) {
2507                 dbg("[SAT] SAT PARSER -  incorrect cmd len, expected len = %d, orig_len=%d", (temp_index+length),tlv_len);
2508                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2509         }
2510
2511         //attribute data
2512         text_attribute_obj->b_txt_attr = TRUE;
2513         memcpy(text_attribute_obj->text_formatting, &src_data[temp_index], length);
2514
2515         *consumed_data_len = 2+length;
2516         return TCORE_SAT_SUCCESS;
2517 }
2518
2519 //decode proactive cmd
2520 //6.4.1 DISPLAY TEXT
2521 static enum tcore_sat_result _sat_decode_display_text(unsigned char* o_cmd_data, int o_length,
2522                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2523 {
2524         int temp_index = 0;
2525         int tlv_length = 0, remain_len = 0, expected_len = 0;
2526         int data_len_consumed=0;
2527         unsigned char dev_id[4];
2528         unsigned char* cmd_data = NULL;
2529         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2530
2531         if(o_cmd_data == NULL){
2532                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2533                 return TCORE_SAT_ERROR_FATAL;
2534         }
2535
2536         cmd_data = &o_cmd_data[0];
2537         tlv_length = cmd_data[curr_offset-1];
2538         temp_index = curr_offset+2;
2539         sat_cmd_ind_data->data.display_text.command_detail.cmd_num = cmd_data[temp_index++];
2540         sat_cmd_ind_data->data.display_text.command_detail.cmd_type = cmd_data[temp_index++];
2541
2542         /* ******decode command qualifier****** */
2543         if (cmd_data[temp_index] & 0x01) {
2544                 sat_cmd_ind_data->data.display_text.command_detail.cmd_qualifier.display_text.text_priority =
2545                                 TEXT_PRIORITY_HIGH;
2546                 dbg("[SAT] SAT PARSER -  msg_prio=TAPI_SAT_MSG_PRIORITY_HIGH.");
2547         }
2548         else {
2549                 sat_cmd_ind_data->data.display_text.command_detail.cmd_qualifier.display_text.text_priority =
2550                                 TEXT_PRIORITY_NORMAL;
2551                 dbg("[SAT] SAT PARSER - : msg_prio=TAPI_SAT_MSG_PRIORITY_NORMAL.");
2552         }
2553
2554         if (cmd_data[temp_index] & 0x80) {
2555                 sat_cmd_ind_data->data.display_text.command_detail.cmd_qualifier.display_text.text_clear_type =
2556                                 TEXT_WAIT_FOR_USER_TO_CLEAR_MSG;
2557                 dbg("[SAT] SAT PARSER - : msgClear=TAPI_SAT_WAIT_FOR_USER_TO_CLEAR_MSG.");
2558         }
2559         else {
2560                 sat_cmd_ind_data->data.display_text.command_detail.cmd_qualifier.display_text.text_clear_type =
2561                                 TEXT_AUTO_CLEAR_MSG_AFTER_A_DELAY;
2562                 dbg("[SAT] SAT PARSER -  msgClear=TAPI_SAT_AUTO_CLEAR_MSG_AFTER_A_DELAY.");
2563         }
2564
2565         temp_index++;
2566         memcpy(dev_id,&cmd_data[temp_index],4);
2567         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.display_text.device_id);
2568         if(rv != TCORE_SAT_SUCCESS)
2569                 return rv;
2570
2571         temp_index+=4; // device identities consumes 4 bytes.
2572
2573         remain_len = o_length-temp_index;
2574         expected_len = tlv_length-5-4;
2575         if(remain_len!=expected_len){
2576                 dbg("[SAT] SAT PARSER - : mismatch!! remain_len=%d, expected_len=%d", remain_len, expected_len);
2577                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2578         }
2579
2580         rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.display_text.text, &data_len_consumed);
2581         if(rv != TCORE_SAT_SUCCESS)
2582                 return rv;
2583
2584         if(sat_cmd_ind_data->data.display_text.text.string_length <= 0){
2585                 err("[SAT] SAT PARSER - :string length is 0");
2586                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2587         }
2588
2589         dbg("[SAT] SAT PARSER  text(%s)",sat_cmd_ind_data->data.display_text.text.string);
2590         dbg("[SAT] SAT PARSER o_len(%d) temp_index(%d) data_len_consumed(%d)",o_length , temp_index, data_len_consumed);
2591
2592         if(o_length-temp_index < data_len_consumed){
2593                 dbg("[SAT] SAT PARSER - :wrong text TLV.");
2594                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2595         }
2596
2597         if(o_length-temp_index == data_len_consumed){
2598                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2599                 return TCORE_SAT_SUCCESS;
2600         }
2601         temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2602
2603         //icon identifier
2604         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
2605                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.display_text.icon_id, &data_len_consumed);
2606
2607                 if(rv != TCORE_SAT_SUCCESS){
2608                         return rv; //SEND TR
2609                 }
2610
2611                 if(o_length-temp_index == data_len_consumed){
2612                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2613                         return TCORE_SAT_SUCCESS;
2614                 }
2615                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2616         }
2617
2618         //immediate response
2619         sat_cmd_ind_data->data.display_text.immediate_response_requested = FALSE;
2620         if((cmd_data[temp_index]&0x7F) == SATK_IMMEDIATE_RESPONSE_TAG){
2621                 data_len_consumed = 2;
2622                 dbg("[SAT] SAT PARSER - :immediate response required.");
2623                 sat_cmd_ind_data->data.display_text.immediate_response_requested = TRUE;
2624                 if(o_length-temp_index == data_len_consumed){
2625                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2626                         return TCORE_SAT_SUCCESS;
2627                 }
2628                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2629         }
2630
2631         //time duration - optional
2632         if((cmd_data[temp_index]&0x7F)==SATK_DURATION_TAG){
2633                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.display_text.duration, &data_len_consumed);
2634                 if(rv != TCORE_SAT_SUCCESS){
2635                         return rv; //SEND TR
2636                 }
2637
2638                 if(o_length-temp_index == data_len_consumed){
2639                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2640                         return TCORE_SAT_SUCCESS;
2641                 }
2642                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2643         }
2644
2645         //text attribute - optional
2646         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_ATTRIBUTE_TAG){
2647                 rv =_sat_decode_text_attribute_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.display_text.text_attribute, &data_len_consumed);
2648                 if(rv != TCORE_SAT_SUCCESS){
2649                         return rv; //SEND TR
2650                 }
2651
2652                 if(o_length-temp_index == data_len_consumed){
2653                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2654                         return TCORE_SAT_SUCCESS;
2655                 }
2656                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2657         }
2658
2659         if(o_length > temp_index){
2660                 dbg("[SAT] SAT PARSER - : wrong text TLV, remaining data is found!!");
2661                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2662         }
2663
2664         dbg("[SAT] SAT PARSER - :decoding done!.");
2665         return TCORE_SAT_SUCCESS;
2666 }
2667
2668 //6.4.2 GET INKEY
2669 static enum tcore_sat_result _sat_decode_get_inkey(unsigned char* o_cmd_data, int o_length,
2670                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2671 {
2672         int temp_index = 0;
2673         int tlv_length = 0, remain_len = 0, expected_len = 0;
2674         int data_len_consumed=0;
2675         unsigned char dev_id[4];
2676         unsigned char* cmd_data = NULL;
2677         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2678
2679         if(o_cmd_data == NULL){
2680                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2681                 return TCORE_SAT_ERROR_FATAL;
2682         }
2683
2684         cmd_data = &o_cmd_data[0];
2685         tlv_length = cmd_data[curr_offset-1];
2686         temp_index = curr_offset+2;
2687         sat_cmd_ind_data->data.get_inkey.command_detail.cmd_num = cmd_data[temp_index++];
2688         sat_cmd_ind_data->data.get_inkey.command_detail.cmd_type = cmd_data[temp_index++];
2689
2690         /* ******decode command qualifier****** */
2691         if (cmd_data[temp_index] & 0x01) {
2692                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.alphabet_set = TRUE;
2693                 dbg("[SAT] SAT PARSER - Alphabet set");
2694         }
2695
2696         if(cmd_data[temp_index]&0x02){
2697                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.alphabet_type = INPUT_ALPHABET_TYPE_UCS2;
2698                 dbg("[SAT] SAT PARSER -  INPUT_ALPHABET_TYPE_UCS2");
2699         }
2700         else{
2701                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.alphabet_type = INPUT_ALPHABET_TYPE_SMS_DEFAULT;
2702                 dbg("[SAT] SAT PARSER -  INPUT_ALPHABET_TYPE_SMS_DEFAULT");
2703         }
2704
2705         if(cmd_data[temp_index]&0x04){
2706                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.inkey_type = INKEY_TYPE_YES_NO_REQUESTED;
2707                 dbg("[SAT] SAT PARSER -  INKEY_TYPE_YES_NO_REQUESTED");
2708         }
2709         else{
2710                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.inkey_type = INKEY_TYPE_CHARACTER_SET_ENABLED;
2711                 dbg("[SAT] SAT PARSER -  INKEY_TYPE_YES_NO_REQUESTED");
2712         }
2713
2714         if(cmd_data[temp_index]&0x08){
2715                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.immediate_rsp_required = TRUE;
2716                 dbg("[SAT] SAT PARSER -  immediate response requested");
2717         }
2718
2719         if (cmd_data[temp_index] & 0x80) {
2720                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.help_info = TRUE;
2721                 dbg("[SAT] SAT PARSER - Help info");
2722         }
2723
2724         //device identities
2725         temp_index++;
2726         memcpy(dev_id,&cmd_data[temp_index],4);
2727         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.get_inkey.device_id);
2728         if(rv != TCORE_SAT_SUCCESS)
2729                 return rv;
2730
2731         //text
2732         temp_index+=4;
2733
2734         remain_len = o_length-temp_index;
2735         expected_len = tlv_length-5-4;
2736         if(remain_len!=expected_len){
2737                 dbg("[SAT] SAT PARSER - : mismatch!! remain_len=%d, expected_len=%d", remain_len, expected_len);
2738                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2739         }
2740
2741         rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.get_inkey.text, &data_len_consumed);
2742         if(rv != TCORE_SAT_SUCCESS)
2743                 return rv;
2744
2745         if(sat_cmd_ind_data->data.get_inkey.text.string_length <= 0){
2746                 err("[SAT] SAT PARSER - :string length is 0");
2747                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2748         }
2749
2750         dbg("[SAT] SAT PARSER  text(%s)",sat_cmd_ind_data->data.get_inkey.text.string);
2751         dbg("[SAT] SAT PARSER o_len(%d) temp_index(%d) data_len_consumed(%d)",o_length , temp_index, data_len_consumed);
2752
2753         if(o_length-temp_index < data_len_consumed){
2754                 dbg("[SAT] SAT PARSER - :wrong text TLV.");
2755                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2756         }
2757
2758         if(o_length-temp_index == data_len_consumed){
2759                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2760                 return TCORE_SAT_SUCCESS;
2761         }
2762         temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2763
2764         //icon identifier - optional
2765         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
2766                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.get_inkey.icon_id, &data_len_consumed);
2767
2768                 if(rv != TCORE_SAT_SUCCESS){
2769                         return rv; //SEND TR
2770                 }
2771
2772                 if(o_length-temp_index == data_len_consumed){
2773                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2774                         return TCORE_SAT_SUCCESS;
2775                 }
2776                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2777         }
2778
2779         //time duration - optional
2780         if((cmd_data[temp_index]&0x7F)==SATK_DURATION_TAG){
2781                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.get_inkey.duration, &data_len_consumed);
2782                 if(rv != TCORE_SAT_SUCCESS){
2783                         return rv; //SEND TR
2784                 }
2785
2786                 if(o_length-temp_index == data_len_consumed){
2787                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2788                         return TCORE_SAT_SUCCESS;
2789                 }
2790                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2791         }
2792
2793         //text attribute - optional
2794         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_ATTRIBUTE_TAG){
2795                 rv =_sat_decode_text_attribute_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.get_inkey.text_attribute, &data_len_consumed);
2796                 if(rv != TCORE_SAT_SUCCESS){
2797                         return rv; //SEND TR
2798                 }
2799
2800                 if(o_length-temp_index == data_len_consumed){
2801                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2802                         return TCORE_SAT_SUCCESS;
2803                 }
2804                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2805         }
2806
2807         if(o_length > temp_index){
2808                 dbg("[SAT] SAT PARSER - : wrong text TLV, remaining data is found!!");
2809                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2810         }
2811
2812         dbg("[SAT] SAT PARSER - :decoding done!.");
2813         return TCORE_SAT_SUCCESS;
2814 }
2815
2816 //6.4.3 GET INPUT
2817 static enum tcore_sat_result _sat_decode_get_input(unsigned char* o_cmd_data, int o_length,
2818                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2819 {
2820         int temp_index = 0;
2821         int tlv_length = 0, remain_len = 0, expected_len = 0;
2822         int data_len_consumed=0;
2823         unsigned char dev_id[4];
2824         unsigned char* cmd_data = NULL;
2825         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2826
2827         if(o_cmd_data == NULL){
2828                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2829                 return TCORE_SAT_ERROR_FATAL;
2830         }
2831
2832         cmd_data = &o_cmd_data[0];
2833         tlv_length = cmd_data[curr_offset-1];
2834         temp_index = curr_offset+2;
2835         sat_cmd_ind_data->data.get_input.command_detail.cmd_num = cmd_data[temp_index++];
2836         sat_cmd_ind_data->data.get_input.command_detail.cmd_type = cmd_data[temp_index++];
2837
2838         /* ******decode command qualifier****** */
2839         if (cmd_data[temp_index] & 0x01) {
2840                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.alphabet_set = TRUE;
2841                 dbg("[SAT] SAT PARSER - Alphabet set");
2842         }
2843         else{
2844                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.alphabet_set = FALSE;
2845                 dbg("[SAT] SAT PARSER - Numeric info");
2846         }
2847
2848         if(cmd_data[temp_index]&0x02){
2849                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.alphabet_type = INPUT_ALPHABET_TYPE_UCS2;
2850                 dbg("[SAT] SAT PARSER -  INPUT_ALPHABET_TYPE_UCS2");
2851         }
2852         else{
2853                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.alphabet_type = INPUT_ALPHABET_TYPE_SMS_DEFAULT;
2854                 dbg("[SAT] SAT PARSER -  INPUT_ALPHABET_TYPE_SMS_DEFAULT");
2855         }
2856
2857         if(cmd_data[temp_index]&0x04){
2858                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.me_echo_user_input = FALSE;
2859                 dbg("[SAT] SAT PARSER -  user input not be revealed");
2860         }
2861         else{
2862                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.me_echo_user_input = TRUE;
2863                 dbg("[SAT] SAT PARSER -  Me echo user input");
2864         }
2865
2866         if(cmd_data[temp_index]&0x08){
2867                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.user_input_unpacked_format = FALSE;
2868                 dbg("[SAT] SAT PARSER - packing required");
2869         }
2870         else{
2871                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.user_input_unpacked_format = TRUE;
2872                 dbg("[SAT] SAT PARSER - unpacked format");
2873         }
2874
2875         if (cmd_data[temp_index] & 0x80) {
2876                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.help_info = TRUE;
2877                 dbg("[SAT] SAT PARSER - Help info");
2878         }
2879
2880         //device identities
2881         temp_index++;
2882         memcpy(dev_id,&cmd_data[temp_index],4);
2883         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.get_input.device_id);
2884         if(rv != TCORE_SAT_SUCCESS)
2885                 return rv;
2886
2887         //text - mandatory
2888         temp_index+=4;
2889
2890         remain_len = o_length-temp_index;
2891         expected_len = tlv_length-5-4;
2892         if(remain_len!=expected_len){
2893                 dbg("[SAT] SAT PARSER - : mismatch!! remain_len=%d, expected_len=%d", remain_len, expected_len);
2894                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2895         }
2896
2897         rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.get_input.text, &data_len_consumed);
2898         if(rv != TCORE_SAT_SUCCESS)
2899                 return rv;
2900
2901         if(sat_cmd_ind_data->data.get_input.text.string_length <= 0){
2902                 err("[SAT] SAT PARSER - :string length is 0");
2903         }
2904         dbg("[SAT] SAT PARSER  text(%s)",sat_cmd_ind_data->data.get_input.text.string);
2905         dbg("[SAT] SAT PARSER o_len(%d) temp_index(%d) data_len_consumed(%d)",o_length , temp_index, data_len_consumed);
2906
2907         if(o_length-temp_index < data_len_consumed){
2908                 dbg("[SAT] SAT PARSER - :wrong text TLV.");
2909                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2910         }
2911
2912         if(o_length-temp_index == data_len_consumed){
2913                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2914                 return TCORE_SAT_SUCCESS;
2915         }
2916         temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2917
2918         //response length - mandatory
2919         rv = _sat_decode_response_length_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.get_input.rsp_len, &data_len_consumed);
2920         if(rv != TCORE_SAT_SUCCESS)
2921                 return rv;
2922
2923         if(o_length-temp_index == data_len_consumed){
2924                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2925                 return TCORE_SAT_SUCCESS;
2926         }
2927         temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2928
2929         //default text - optional
2930         if((o_cmd_data[temp_index]&0x7F) == SATK_DEFAULT_TEXT_TAG){
2931                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.get_input.default_text, &data_len_consumed);
2932                 if(rv != TCORE_SAT_SUCCESS)
2933                         return rv;
2934
2935                 if(sat_cmd_ind_data->data.get_input.default_text.string_length <= 0){
2936                         err("[SAT] SAT PARSER - :string length is 0");
2937                 }
2938                 dbg("[SAT] SAT PARSER default text(%s)",sat_cmd_ind_data->data.get_input.default_text.string);
2939                 if(o_length-temp_index == data_len_consumed){
2940                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2941                         return TCORE_SAT_SUCCESS;
2942                 }
2943                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2944         }
2945
2946         //icon identifier
2947         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
2948                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.get_input.icon_id, &data_len_consumed);
2949
2950                 if(rv != TCORE_SAT_SUCCESS){
2951                         return rv; //SEND TR
2952                 }
2953
2954                 if(o_length-temp_index == data_len_consumed){
2955                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2956                         return TCORE_SAT_SUCCESS;
2957                 }
2958                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2959         }
2960
2961         //text attribute - optional
2962         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_ATTRIBUTE_TAG){
2963                 rv =_sat_decode_text_attribute_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.get_input.text_attribute, &data_len_consumed);
2964                 if(rv != TCORE_SAT_SUCCESS){
2965                         return rv; //SEND TR
2966                 }
2967
2968                 if(o_length-temp_index == data_len_consumed){
2969                         dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2970                         return TCORE_SAT_SUCCESS;
2971                 }
2972                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
2973         }
2974
2975         if(o_length > temp_index){
2976                 dbg("[SAT] SAT PARSER - : wrong text TLV, remaining data is found!!");
2977                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2978         }
2979
2980         dbg("[SAT] SAT PARSER - :decoding done!.");
2981         return TCORE_SAT_SUCCESS;
2982 }
2983
2984 //6.4.4 MORE TIME
2985 static enum tcore_sat_result _sat_decode_more_time(unsigned char* o_cmd_data, int o_length,
2986                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2987 {
2988         int temp_index = 0;
2989         unsigned char dev_id[4];
2990         unsigned char* cmd_data = NULL;
2991         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2992
2993         if(o_cmd_data == NULL){
2994                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2995                 return TCORE_SAT_ERROR_FATAL;
2996         }
2997
2998         //command detail
2999         cmd_data = &o_cmd_data[0];
3000         temp_index = curr_offset+2;
3001         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_num = cmd_data[temp_index++];
3002         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_type = cmd_data[temp_index++];
3003
3004         //device identifier
3005         temp_index++;
3006         memcpy(dev_id,&cmd_data[temp_index],4);
3007         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_event_list.device_id);
3008         if(rv != TCORE_SAT_SUCCESS)
3009                 return rv;
3010
3011         temp_index+=4;
3012         dbg("[SAT] SAT PARSER - :decoding done!.");
3013         return TCORE_SAT_SUCCESS;
3014 }
3015
3016 //6.4.5 PLAY TONE
3017 static enum tcore_sat_result _sat_decode_play_tone(unsigned char* o_cmd_data, int o_length,
3018                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3019 {
3020         int temp_index = 0, data_len_consumed = 0;
3021         unsigned char dev_id[4];
3022         unsigned char* cmd_data = NULL;
3023         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3024
3025         if(o_cmd_data == NULL){
3026                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3027                 return TCORE_SAT_ERROR_FATAL;
3028         }
3029
3030         //command detail
3031         cmd_data = &o_cmd_data[0];
3032         temp_index = curr_offset+2;
3033         sat_cmd_ind_data->data.play_tone.command_detail.cmd_num = cmd_data[temp_index++];
3034         sat_cmd_ind_data->data.play_tone.command_detail.cmd_type = cmd_data[temp_index++];
3035
3036         /* ******decode command qualifier****** */
3037         if (cmd_data[temp_index] & 0x01)
3038                 sat_cmd_ind_data->data.play_tone.command_detail.cmd_qualifier.play_tone.vibration_alert = VIBRATE_ALERT_REQUIRED;
3039         else
3040                 sat_cmd_ind_data->data.play_tone.command_detail.cmd_qualifier.play_tone.vibration_alert = VIBRATE_ALERT_OPTIONAL;
3041
3042         //device identifier
3043         temp_index++;
3044         memcpy(dev_id,&cmd_data[temp_index],4);
3045         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.play_tone.device_id);
3046         if(rv != TCORE_SAT_SUCCESS)
3047                 return rv;
3048
3049         //alpha id - optional
3050         temp_index+=4;
3051         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
3052                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.play_tone.alpha_id, &data_len_consumed);
3053                 if(rv != TCORE_SAT_SUCCESS) {
3054                         return rv;
3055                 }
3056
3057                 temp_index+=data_len_consumed;
3058                 if(temp_index >= o_length){
3059                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3060                         dbg("[SAT] SAT PARSER - default value is set - tone type, duration");
3061                         sat_cmd_ind_data->data.play_tone.tone.tone_type = GENERAL_BEEP;
3062                         sat_cmd_ind_data->data.play_tone.duration.time_unit = TIME_UNIT_SECONDS;
3063                         sat_cmd_ind_data->data.play_tone.duration.time_interval = 2;
3064                         return TCORE_SAT_SUCCESS;
3065                 }
3066         }
3067
3068         //tone - optional
3069         if((cmd_data[temp_index]&0x7F) == SATK_TONE_TAG){
3070                 rv = _sat_decode_tone_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.play_tone.tone, &data_len_consumed);
3071                 if(rv != TCORE_SAT_SUCCESS) {
3072                         return rv;
3073                 }
3074                 temp_index+=data_len_consumed;
3075         }
3076         else{
3077                 sat_cmd_ind_data->data.play_tone.tone.tone_type = GENERAL_BEEP;
3078         }
3079
3080         //time duration - optional
3081         if((cmd_data[temp_index]&0x7F)==SATK_DURATION_TAG){
3082                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.play_tone.duration, &data_len_consumed);
3083                 if(rv != TCORE_SAT_SUCCESS){
3084                         return rv; //SEND TR
3085                 }
3086
3087                 temp_index+=data_len_consumed;
3088                 if(temp_index >= o_length){
3089                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3090                         return TCORE_SAT_SUCCESS;
3091                 }
3092         }
3093         else{
3094                 dbg("[SAT] SAT PARSER -  Duration TLV not present, ME should use a default value.");
3095                 sat_cmd_ind_data->data.play_tone.duration.time_unit = TIME_UNIT_SECONDS;
3096                 sat_cmd_ind_data->data.play_tone.duration.time_interval = 2;
3097         }
3098
3099         //icon identifier
3100         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
3101                 data_len_consumed = 0;
3102                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.play_tone.icon_id, &data_len_consumed);
3103
3104                 if(rv != TCORE_SAT_SUCCESS){
3105                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3106                 }
3107
3108                 if(temp_index+data_len_consumed >= o_length){
3109                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3110                         return TCORE_SAT_SUCCESS;
3111                 }
3112
3113                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3114         }
3115
3116         //text attribute - optional
3117         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_ATTRIBUTE_TAG){
3118                 rv =_sat_decode_text_attribute_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.play_tone.text_attribute, &data_len_consumed);
3119                 if(rv != TCORE_SAT_SUCCESS){
3120                         return rv; //SEND TR
3121                 }
3122
3123                 if(temp_index+data_len_consumed >= o_length){
3124                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3125                         return TCORE_SAT_SUCCESS;
3126                 }
3127
3128                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3129         }
3130
3131 //ToDo: frames
3132
3133         dbg("[SAT] SAT PARSER - :decoding done!.");
3134         return TCORE_SAT_SUCCESS;
3135 }
3136
3137 //6.4.7 REFRESH
3138 static enum tcore_sat_result _sat_decode_refresh(unsigned char* o_cmd_data, int o_length,
3139                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3140 {
3141         int temp_index = 0, data_len_consumed = 0;
3142         unsigned char dev_id[4];
3143         unsigned char* cmd_data = NULL;
3144         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3145
3146         if(o_cmd_data == NULL){
3147                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3148                 return TCORE_SAT_ERROR_FATAL;
3149         }
3150
3151         //command detail
3152         cmd_data = &o_cmd_data[0];
3153         temp_index = curr_offset+2;
3154         sat_cmd_ind_data->data.refresh.command_detail.cmd_num = cmd_data[temp_index++];
3155         sat_cmd_ind_data->data.refresh.command_detail.cmd_type = cmd_data[temp_index++];
3156
3157         /* ******decode command qualifier****** */
3158         switch(cmd_data[temp_index]){
3159                 case SIM_REFRESH_CMD_INIT_AND_FULL_FCN:
3160                 case SIM_REFRESH_CMD_FCN:
3161                 case SIM_REFRESH_CMD_INIT_AND_FCN:
3162                 case SIM_REFRESH_CMD_INIT       :
3163                 case SIM_REFRESH_CMD_RESET:
3164                         sat_cmd_ind_data->data.refresh.command_detail.cmd_qualifier.refresh.refresh = cmd_data[temp_index];
3165                         dbg("[SAT] SAT PARSER - : refresh mode=[0x%02x]:0-init&FFCN, 1-FCN, 2-init&FCN, 3-init, 4-reset", cmd_data[temp_index]);
3166                         break;
3167
3168                 case SIM_REFRESH_CMD_3G_APPLICATION_RESET:
3169                 case SIM_REFRESH_CMD_3G_SESSION_RESET:
3170                 case SIM_REFRESH_CMD_RESERVED:
3171                 default:
3172                         dbg("[SAT] SAT PARSER - : refresh mode=0x%02x Not Supported", cmd_data[temp_index]);
3173                         return TCORE_SAT_BEYOND_ME_CAPABILITY;
3174                         break;
3175         }
3176
3177         //device identifier
3178         temp_index++;
3179         memcpy(dev_id,&cmd_data[temp_index],4);
3180         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.refresh.device_id);
3181         if(rv != TCORE_SAT_SUCCESS)
3182                 return rv;
3183
3184         //check file list
3185         temp_index+=4;
3186         if( (sat_cmd_ind_data->data.refresh.command_detail.cmd_qualifier.refresh.refresh == SIM_REFRESH_CMD_FCN)
3187                 || (sat_cmd_ind_data->data.refresh.command_detail.cmd_qualifier.refresh.refresh == SIM_REFRESH_CMD_INIT_AND_FCN) ){
3188
3189                 rv = _sat_decode_file_list_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.refresh.file_list, &data_len_consumed);
3190                 if(rv != TCORE_SAT_SUCCESS)
3191                         return rv;
3192         }
3193         else
3194                 sat_cmd_ind_data->data.refresh.file_list.file_count = 0;
3195
3196         dbg("[SAT] SAT PARSER - :decoding done!.");
3197         return TCORE_SAT_SUCCESS;
3198 }
3199
3200 //6.4.8 SETUP MENU
3201 static enum tcore_sat_result _sat_decode_setup_menu(unsigned char* tlv_str, int tlv_len,
3202                 int curr_offset, struct tcore_sat_proactive_command *pactive_cmd_ind_obj)
3203 {
3204         int temp_index = 0;
3205         int data_len_consumed=0;
3206         unsigned char dev_id[4];
3207         unsigned char* src_data;
3208         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3209
3210         //access command detail
3211         temp_index = curr_offset+2; //move the temp_index to command detail info +2(tag and length)
3212         src_data = &tlv_str[0];
3213
3214 // In this time, the point of temp_index is COMMAND NUMBER
3215 // [1] insert command detail information into each proactive command data structure.
3216         pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_num = src_data[temp_index++];
3217         pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_type = src_data[temp_index++];
3218
3219 // [2] decode COMMAND QUALIFIER
3220 /*
3221 -bit 1: 0 = no selection preference;
3222                 1 = selection using soft key preferred.
3223 -bits 2 to 7:   = RFU.
3224 -bit 8: 0 = no help information available;
3225                 1 = help information available.
3226 */
3227
3228 //[2-1] selection preference
3229         if (src_data[temp_index] & 0x01) {
3230                 pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_qualifier.setup_menu.select_preference =
3231                                 SELECTION_PREFERENCE_USING_SOFT_KEY;
3232                 dbg("[SAT] SAT PARSER -  sel_pref=SAT_SELECTION_PREFERENCE_USING_SOFT_KEY.");
3233         }
3234         else {
3235                 pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_qualifier.setup_menu.select_preference =
3236                                 SELECTION_PREFERENCE_NONE_REQUESTED;
3237                 dbg("[SAT] SAT PARSER - : sel_pref=SAT_SELECTION_PREFERENCE_NONE_REQUESTED.");
3238         }
3239
3240 //[2-2] help available
3241         if (src_data[temp_index] & 0x80) {
3242                 pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_qualifier.setup_menu.help_info =
3243                                 TRUE;
3244                 ;dbg("[SAT] SAT PARSER - : is help Available=TRUE.");
3245         }
3246         else {
3247                 pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_qualifier.setup_menu.help_info =
3248                                 FALSE;
3249                 dbg("[SAT] SAT PARSER -  is help Available=FALSE.");
3250         }
3251
3252 // In this time, the point of temp_index is DEVICE IDENTITIES.
3253 //[3] decode DEVICE IDENTITIES TLV
3254         temp_index++;
3255         memcpy(dev_id, &src_data[temp_index], 4);
3256         rv = _sat_decode_device_identities_tlv(dev_id, &pactive_cmd_ind_obj->data.setup_menu.device_id);
3257         if (rv != TCORE_SAT_SUCCESS) {
3258                 //send TR in SatkProcessProactiveCmdInd()
3259                 return rv;
3260         }
3261
3262
3263 // In this time, the point of temp_index is ALPHA IDENTIFIER. 11 or 12.
3264 //[4] decode ALPHA IDENTIFIER TLV
3265         temp_index+=4;
3266         dbg("[SAT] SAT PARSER - :temp_index=%d",temp_index);
3267         rv = _sat_decode_alpha_identifier_tlv(src_data, tlv_len, temp_index,
3268                         &pactive_cmd_ind_obj->data.setup_menu.alpha_id, &data_len_consumed);
3269         if(rv != TCORE_SAT_SUCCESS) {
3270                 return rv;
3271         }
3272
3273 // In this time, the point of temp_index is ITEM  TLV
3274 //[5] decode ITEM LIST (at least one is mandatory)
3275         temp_index+= data_len_consumed;
3276         pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt = 0;
3277         do{
3278                 data_len_consumed=0;
3279                 if((src_data[temp_index]&0x7F) == SATK_ITEM_TAG) {
3280                         rv = _sat_decode_item_tlv(src_data, tlv_len, temp_index,
3281                                                 &pactive_cmd_ind_obj->data.setup_menu.menu_item[pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt],
3282                                                 &data_len_consumed);
3283
3284                         if(rv != TCORE_SAT_SUCCESS)
3285                                 return rv;
3286
3287                         if(!pactive_cmd_ind_obj->data.setup_menu.menu_item[0].text_len)
3288                                 break;
3289                 }
3290                 else {
3291                         if(pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt == 0) {
3292                                 dbg("menu item is not exist.");
3293                                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
3294                         }
3295                         //else
3296                         break;  //???
3297                 }
3298                 pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt++;
3299                 temp_index += data_len_consumed;
3300
3301                 if(temp_index >= tlv_len)
3302                         break;
3303         }while(pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt < SAT_MENU_ITEM_COUNT_MAX);
3304
3305         dbg("[SAT] SAT PARSER - :setup menu item_count=%d",pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt);
3306         if(temp_index >= tlv_len){
3307                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
3308                 //send TR in SatkProcessProactiveCmdInd()
3309                 return TCORE_SAT_SUCCESS;
3310         }
3311
3312 //[6] (optional TLV) decode ITEMS NEXT ACTION INDICATOR TLV
3313         if((src_data[temp_index]&0x7F) == SATK_ITEMS_NEXT_ACTION_INDICATOR_TAG) {
3314                 data_len_consumed = 0;
3315                 rv = _sat_decode_item_next_action_indicator_tlv(tlv_str, tlv_len, temp_index,
3316                                 &pactive_cmd_ind_obj->data.setup_menu.next_act_ind_list, &data_len_consumed);
3317                 if(rv!=TCORE_SAT_SUCCESS) return rv;
3318
3319                 if(temp_index+data_len_consumed >= tlv_len) {
3320                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3321                         //send the data to Noti manager.
3322                         return TCORE_SAT_SUCCESS;
3323                 }
3324
3325                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3326         }
3327         else {
3328                 dbg("[SAT] SAT PARSER -  ITEMS NEXT ACTION INDICATOR TLV Not present");
3329         }
3330
3331 //[7] (optional TLV) decode ICON IDENTIFIER TLV
3332         if((src_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3333                 data_len_consumed = 0;
3334                 rv = _sat_decode_icon_identifier_tlv(tlv_str, tlv_len, temp_index,
3335                                 &pactive_cmd_ind_obj->data.setup_menu.icon_id, &data_len_consumed);
3336                 if(rv !=TCORE_SAT_SUCCESS) return rv;
3337
3338                 if(temp_index+data_len_consumed >= tlv_len) {
3339                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3340                         //send the data to Noti manager.
3341                         return TCORE_SAT_SUCCESS;
3342                 }
3343
3344                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3345         }
3346         else{
3347                 dbg("[SAT] SAT PARSER - ICON IDENTIFIER TLV Not present");
3348         }
3349
3350 //[8] (optional TLV) decode ICON IDENTIFIER LIST TLV
3351         if((src_data[temp_index]&0x7F) == SATK_ITEM_ICON_IDENTIFIER_LIST_TAG) {
3352                 data_len_consumed = 0;
3353                 rv = _sat_decode_icon_identifier_list_tlv(tlv_str, tlv_len, temp_index,
3354                                 &pactive_cmd_ind_obj->data.setup_menu.icon_list, &data_len_consumed);
3355                 if(rv !=TCORE_SAT_SUCCESS) return rv; //SEND TR
3356
3357                 if(temp_index+data_len_consumed >= tlv_len){
3358                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3359                         //send the data to Noti manager.
3360                         return TCORE_SAT_SUCCESS;
3361                 }
3362                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3363
3364         }
3365         else {
3366                 dbg("[SAT] SAT PARSER - ICON IDENTIFIER LIST TLV not present");
3367         }
3368
3369         //text attribute - optional
3370         if((src_data[temp_index]&0x7F)==SATK_TEXT_ATTRIBUTE_TAG){
3371                 rv =_sat_decode_text_attribute_tlv(tlv_str, tlv_len, temp_index, &pactive_cmd_ind_obj->data.setup_menu.text_attribute, &data_len_consumed);
3372                 if(rv != TCORE_SAT_SUCCESS){
3373                         return rv; //SEND TR
3374                 }
3375
3376                 if(temp_index+data_len_consumed >= tlv_len){
3377                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3378                         return TCORE_SAT_SUCCESS;
3379                 }
3380
3381                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3382         }
3383
3384         //text attribute list - optional
3385         if((src_data[temp_index]&0x7F) == SATK_TEXT_ATTRIBUTE_LIST_TAG){
3386                 int attr_item_temp_index = 0, item_cnt = 0;
3387                 int txt_attr_list_len = 0;
3388
3389                 struct tel_sat_text_attribute_list *txt_attr_list = NULL;
3390
3391                 txt_attr_list = &pactive_cmd_ind_obj->data.setup_menu.text_attribute_list;
3392
3393                 //length
3394                 temp_index++;
3395                 txt_attr_list_len = src_data[temp_index];
3396                 if(txt_attr_list_len == 0){
3397                         dbg("[SAT] - Text Attribute List is nothing");
3398                         return TCORE_SAT_REQUIRED_VALUE_MISSING;
3399                 }
3400
3401                 //item cnt - each text attribute length is 4byte
3402                 item_cnt = txt_attr_list_len/4;
3403                 txt_attr_list->list_cnt = item_cnt;
3404                 dbg("[SAT] - text attribute item cnt(%d)", item_cnt);
3405
3406                 //get attribute data
3407                 temp_index++;
3408                 for(attr_item_temp_index = 0; attr_item_temp_index < item_cnt; attr_item_temp_index++){
3409                         memcpy(txt_attr_list->text_attribute_list[attr_item_temp_index].text_formatting, &src_data[temp_index], 4);
3410                         temp_index += 4;
3411                 }
3412
3413                 dbg("[SAT] SAT PARSER - done to decode text attribute list");
3414         }
3415
3416         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3417         return TCORE_SAT_SUCCESS;
3418 }
3419
3420 //6.4.9 SELECT ITEM
3421 static enum tcore_sat_result _sat_decode_select_item(unsigned char* o_cmd_data, int o_length,
3422                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3423 {
3424         int temp_index = 0;
3425         int data_len_consumed=0;
3426         unsigned char dev_id[4];
3427         unsigned char* cmd_data = NULL;
3428         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3429
3430         if(o_cmd_data == NULL){
3431                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3432                 return TCORE_SAT_ERROR_FATAL;
3433         }
3434
3435         cmd_data = &o_cmd_data[0];
3436         temp_index = curr_offset+2;
3437         sat_cmd_ind_data->data.select_item.command_detail.cmd_num = cmd_data[temp_index++];
3438         sat_cmd_ind_data->data.select_item.command_detail.cmd_type = cmd_data[temp_index++];
3439
3440         /* ******decode command qualifier****** */
3441         if (cmd_data[temp_index] & 0x01) {
3442                 if (cmd_data[temp_index] & 0x02) {
3443                         sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.presentation_type = PRESENTATION_TYPE_NAVIGATION_OPTION;
3444                         dbg("[SAT] SAT PARSER - PRESENTATION_TYPE_NAVIGATION_OPTION");
3445                 }
3446                 else{
3447                         sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.presentation_type = PRESENTATION_TYPE_DATA_VALUE;
3448                         dbg("[SAT] SAT PARSER - PRESENTATION_TYPE_DATA_VALUE");
3449                 }
3450         }
3451         else {
3452                 sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.presentation_type = PRESENTATION_TYPE_NOT_SPECIFIED;
3453                 dbg("[SAT] SAT PARSER - PRESENTATION_TYPE_NOT_SPECIFIED");
3454         }
3455
3456         if (cmd_data[temp_index] & 0x04) {
3457                 sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.select_preference = SELECTION_PREFERENCE_USING_SOFT_KEY;
3458                 dbg("[SAT] SAT PARSER - SELECTION_PREFERENCE_USING_SOFT_KEY");
3459         }
3460         else {
3461                 sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.select_preference = SELECTION_PREFERENCE_NONE_REQUESTED;
3462                 dbg("[SAT] SAT PARSER - SELECTION_PREFERENCE_NONE_REQUESTED");
3463         }
3464
3465         if (cmd_data[temp_index] & 0x80) {
3466                 sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.help_info = TRUE;
3467                 dbg("[SAT] SAT PARSER - Help info");
3468         }
3469
3470         //device identities
3471         temp_index++;
3472         memcpy(dev_id,&cmd_data[temp_index],4);
3473         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.select_item.device_id);
3474         if(rv != TCORE_SAT_SUCCESS)
3475                 return rv;
3476
3477         //alpha identifier
3478         temp_index+=4;
3479         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
3480                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.select_item.alpha_id, &data_len_consumed);
3481                 if(rv != TCORE_SAT_SUCCESS) {
3482                         return rv;
3483                 }
3484                 temp_index+=data_len_consumed;
3485         }
3486
3487         //item objects
3488         sat_cmd_ind_data->data.select_item.menu_item_cnt = 0;
3489         do{
3490                 data_len_consumed=0;
3491
3492                 if((cmd_data[temp_index]&0x7F) == SATK_ITEM_TAG) {
3493                         rv = _sat_decode_item_tlv(o_cmd_data, o_length, temp_index,
3494                                 &sat_cmd_ind_data->data.select_item.menu_item[sat_cmd_ind_data->data.select_item.menu_item_cnt],
3495                                 &data_len_consumed);
3496
3497                         if(rv != TCORE_SAT_SUCCESS)
3498                                 return rv;
3499                 }
3500                 else {
3501                         if(sat_cmd_ind_data->data.select_item.menu_item_cnt == 0) {
3502                                 dbg("menu item is not exist.");
3503                                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
3504                         }
3505                         //else
3506                         break;  //???
3507                 }
3508                 sat_cmd_ind_data->data.select_item.menu_item_cnt++;
3509                 temp_index += data_len_consumed;
3510
3511                 if(temp_index >= o_length)
3512                         break;
3513
3514         }while(sat_cmd_ind_data->data.select_item.menu_item_cnt < SAT_MENU_ITEM_COUNT_MAX);
3515
3516         dbg("[SAT] SAT PARSER - select menu item_count=%d",sat_cmd_ind_data->data.select_item.menu_item_cnt);
3517         if(temp_index >= o_length){
3518                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
3519                 return TCORE_SAT_SUCCESS;
3520         }
3521
3522         //item next action indicator
3523         if((cmd_data[temp_index]&0x7F) == SATK_ITEMS_NEXT_ACTION_INDICATOR_TAG) {
3524                 data_len_consumed = 0;
3525                 rv = _sat_decode_item_next_action_indicator_tlv(o_cmd_data, o_length, temp_index,
3526                                 &sat_cmd_ind_data->data.select_item.item_next_act_ind_list, &data_len_consumed);
3527                 if(rv!=TCORE_SAT_SUCCESS)
3528                         return rv;
3529
3530                 if(temp_index+data_len_consumed >= o_length) {
3531                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3532                         return TCORE_SAT_SUCCESS;
3533                 }
3534
3535                 temp_index+=data_len_consumed;
3536         }
3537
3538         //item identifier
3539         if((cmd_data[temp_index]&0x7F) == SATK_ITEM_IDENTIFIER_TAG) {
3540                 data_len_consumed = 0;
3541                 rv = _sat_decode_item_identifier_tlv(o_cmd_data, o_length, temp_index,
3542                                 &sat_cmd_ind_data->data.select_item.item_identifier, &data_len_consumed);
3543                 if(rv !=TCORE_SAT_SUCCESS)
3544                         return rv;
3545
3546                 if(temp_index+data_len_consumed >= o_length) {
3547                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3548                         return TCORE_SAT_SUCCESS;
3549                 }
3550
3551                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3552         }
3553
3554         //icon identifier
3555         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
3556                 data_len_consumed = 0;
3557                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index,
3558                                 &sat_cmd_ind_data->data.select_item.icon_id, &data_len_consumed);
3559
3560                 if(rv != TCORE_SAT_SUCCESS){
3561                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3562                 }
3563
3564                 if(temp_index+data_len_consumed >= o_length){
3565                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3566                         return TCORE_SAT_SUCCESS;
3567                 }
3568
3569                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3570         }
3571
3572         if((cmd_data[temp_index]&0x7F) == SATK_ITEM_ICON_IDENTIFIER_LIST_TAG) {
3573                 data_len_consumed = 0;
3574                 rv = _sat_decode_icon_identifier_list_tlv(o_cmd_data, o_length, temp_index,
3575                                 &sat_cmd_ind_data->data.select_item.icon_list, &data_len_consumed);
3576                 if(rv !=TCORE_SAT_SUCCESS)
3577                         return rv; //SEND TR
3578
3579                 if(temp_index+data_len_consumed >= o_length){
3580                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3581                         return TCORE_SAT_SUCCESS;
3582                 }
3583                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3584         }
3585
3586         //text attribute - optional
3587         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_ATTRIBUTE_TAG){
3588                 rv =_sat_decode_text_attribute_tlv(o_cmd_data, o_length, temp_index,
3589                                 &sat_cmd_ind_data->data.select_item.text_attribute, &data_len_consumed);
3590                 if(rv != TCORE_SAT_SUCCESS){
3591                         return rv; //SEND TR
3592                 }
3593
3594                 if(temp_index+data_len_consumed >= o_length){
3595                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3596                         return TCORE_SAT_SUCCESS;
3597                 }
3598
3599                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3600         }
3601
3602         //text attribute list - optional
3603         if((cmd_data[temp_index]&0x7F) == SATK_TEXT_ATTRIBUTE_LIST_TAG){
3604                 int attr_item_temp_index = 0, item_cnt = 0;
3605                 int txt_attr_list_len = 0;
3606
3607                 struct tel_sat_text_attribute_list *txt_attr_list = NULL;
3608
3609                 txt_attr_list = &sat_cmd_ind_data->data.select_item.text_attribute_list;
3610
3611                 //length
3612                 temp_index++;
3613                 txt_attr_list_len = cmd_data[temp_index];
3614                 if(txt_attr_list_len == 0){
3615                         dbg("[SAT] - Text Attribute List is nothing");
3616                         return TCORE_SAT_REQUIRED_VALUE_MISSING;
3617                 }
3618
3619                 //item cnt - each text attribute length is 4byte
3620                 item_cnt = txt_attr_list_len/4;
3621                 txt_attr_list->list_cnt = item_cnt;
3622                 dbg("[SAT] - text attribute item cnt(%d)", item_cnt);
3623
3624                 //get attribute data
3625                 temp_index++;
3626                 for(attr_item_temp_index = 0; attr_item_temp_index < item_cnt; attr_item_temp_index++){
3627                         memcpy(txt_attr_list->text_attribute_list[attr_item_temp_index].text_formatting, &cmd_data[temp_index], 4);
3628                         temp_index += 4;
3629                 }
3630
3631                 dbg("[SAT] SAT PARSER - done to decode text attribute list");
3632         }
3633
3634         dbg("[SAT] SAT PARSER - :decoding done!.");
3635         return TCORE_SAT_SUCCESS;
3636 }
3637
3638 //6.4.10 SEND SMS
3639 static enum tcore_sat_result _sat_decode_send_sms(unsigned char* o_cmd_data, int o_length,
3640                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3641 {
3642         int temp_index = 0;
3643         int data_len_consumed=0;
3644         unsigned char dev_id[4];
3645         unsigned char* cmd_data = NULL;
3646         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3647
3648         if(o_cmd_data == NULL){
3649                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3650                 return TCORE_SAT_ERROR_FATAL;
3651         }
3652
3653         cmd_data = &o_cmd_data[0];
3654         temp_index = curr_offset+2;
3655         sat_cmd_ind_data->data.send_sms.command_detail.cmd_num = cmd_data[temp_index++];
3656         sat_cmd_ind_data->data.send_sms.command_detail.cmd_type = cmd_data[temp_index++];
3657
3658         /* ******decode command qualifier****** */
3659         if (cmd_data[temp_index] & 0x01) {
3660                 sat_cmd_ind_data->data.send_sms.command_detail.cmd_qualifier.send_sms.packing_by_me_required = TRUE;
3661         }
3662         else {
3663                 sat_cmd_ind_data->data.send_sms.command_detail.cmd_qualifier.send_sms.packing_by_me_required = FALSE;
3664                 dbg("[SAT] SAT PARSER - packing by me required is false");
3665         }
3666
3667         //device identities
3668         temp_index++;
3669         memcpy(dev_id,&cmd_data[temp_index],4);
3670         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_sms.device_id);
3671         if(rv != TCORE_SAT_SUCCESS)
3672                 return rv;
3673
3674         //alpha identifier
3675         temp_index+=4;
3676         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
3677                 data_len_consumed = 0;
3678                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_sms.alpha_id, &data_len_consumed);
3679                 if(rv != TCORE_SAT_SUCCESS) {
3680                         return rv;
3681                 }
3682                 temp_index+=data_len_consumed;
3683         }
3684
3685         //address
3686         if((cmd_data[temp_index]&0x7F) == SATK_ADDRESS_TAG){
3687                 data_len_consumed = 0;
3688                 rv = _sat_decode_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_sms.address, &data_len_consumed);
3689                 if(rv != TCORE_SAT_SUCCESS) {
3690                         return rv;
3691                 }
3692                 temp_index+=data_len_consumed;
3693         }
3694
3695         //SMS-TPDU
3696         data_len_consumed = 0;
3697         rv = _sat_decode_sms_tpdu_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_sms.sms_tpdu, &data_len_consumed);
3698         if(rv != TCORE_SAT_SUCCESS)
3699                 return rv;
3700
3701         if(temp_index+data_len_consumed >= o_length){
3702                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3703                 return TCORE_SAT_SUCCESS;
3704         }
3705
3706         //icon identifier
3707         temp_index+=data_len_consumed;
3708         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
3709                 data_len_consumed = 0;
3710                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index,
3711                                 &sat_cmd_ind_data->data.send_sms.icon_id, &data_len_consumed);
3712
3713                 if(rv != TCORE_SAT_SUCCESS){
3714                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3715                 }
3716
3717                 if(temp_index+data_len_consumed >= o_length){
3718                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3719                         return TCORE_SAT_SUCCESS;
3720                 }
3721
3722                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
3723         }
3724
3725         dbg("[SAT] SAT PARSER - :decoding done!.");
3726         return TCORE_SAT_SUCCESS;
3727 }
3728
3729 //6.4.11 SEND SS
3730 static enum tcore_sat_result _sat_decode_send_ss(unsigned char* o_cmd_data, int o_length,
3731                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3732 {
3733         int temp_index = 0, data_len_consumed = 0;
3734         unsigned char dev_id[4];
3735         unsigned char* cmd_data = NULL;
3736         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3737
3738         if(o_cmd_data == NULL || sat_cmd_ind_data == NULL){
3739                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3740                 return TCORE_SAT_ERROR_FATAL;
3741         }
3742
3743         cmd_data = &o_cmd_data[0];
3744         temp_index = curr_offset+2;
3745         sat_cmd_ind_data->data.send_ss.command_detail.cmd_num = cmd_data[temp_index++];
3746         sat_cmd_ind_data->data.send_ss.command_detail.cmd_type = cmd_data[temp_index++];
3747
3748         /** command detail **/
3749         temp_index++; //RFU
3750
3751         //device identities
3752         memcpy(dev_id,&cmd_data[temp_index],4);
3753         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_ss.device_id);
3754         if(rv != TCORE_SAT_SUCCESS)
3755                 return rv;
3756
3757         //alpha identifier - optional
3758         temp_index += 4;
3759         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
3760                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_ss.alpha_id, &data_len_consumed);
3761                 if(rv != TCORE_SAT_SUCCESS) {
3762                         return rv;
3763                 }
3764                 temp_index+=data_len_consumed;
3765         }
3766
3767         //ss string
3768         rv = _sat_decode_ss_string_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_ss.ss_string, &data_len_consumed);
3769         if(rv != TCORE_SAT_SUCCESS)
3770                 return rv;
3771
3772         //icon identifier- optional
3773         temp_index+=data_len_consumed;
3774         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
3775                 data_len_consumed = 0;
3776
3777                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_ss.icon_id, &data_len_consumed);
3778                 if(rv != TCORE_SAT_SUCCESS){
3779                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3780                 }
3781
3782         }
3783
3784         dbg("[SAT] SAT PARSER - :decoding done!.");
3785         return TCORE_SAT_SUCCESS;
3786 }
3787
3788 //6.4.12 SEND USSD
3789 static enum tcore_sat_result _sat_decode_send_ussd(unsigned char* o_cmd_data, int o_length,
3790                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3791 {
3792         int temp_index = 0, data_len_consumed = 0;
3793         unsigned char dev_id[4];
3794         unsigned char* cmd_data = NULL;
3795         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3796
3797         if(o_cmd_data == NULL || sat_cmd_ind_data == NULL){
3798                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3799                 return TCORE_SAT_ERROR_FATAL;
3800         }
3801
3802         cmd_data = &o_cmd_data[0];
3803         temp_index = curr_offset+2;
3804         sat_cmd_ind_data->data.send_ussd.command_detail.cmd_num = cmd_data[temp_index++];
3805         sat_cmd_ind_data->data.send_ussd.command_detail.cmd_type = cmd_data[temp_index++];
3806
3807         /** command detail **/
3808         temp_index++; //RFU
3809
3810         //device identities
3811         memcpy(dev_id,&cmd_data[temp_index],4);
3812         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_ussd.device_id);
3813         if(rv != TCORE_SAT_SUCCESS)
3814                 return rv;
3815
3816         //alpha identifier - optional
3817         temp_index += 4;
3818         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
3819                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_ussd.alpha_id, &data_len_consumed);
3820                 if(rv != TCORE_SAT_SUCCESS) {
3821                         return rv;
3822                 }
3823                 temp_index+=data_len_consumed;
3824         }
3825
3826         //ussd string
3827         rv = _sat_decode_ussd_string_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_ussd.ussd_string, &data_len_consumed);
3828         if(rv != TCORE_SAT_SUCCESS)
3829                 return rv;
3830
3831         //icon identifier- optional
3832         temp_index+=data_len_consumed;
3833         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
3834                 data_len_consumed = 0;
3835
3836                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_ussd.icon_id, &data_len_consumed);
3837                 if(rv != TCORE_SAT_SUCCESS){
3838                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3839                 }
3840
3841         }
3842
3843         dbg("[SAT] SAT PARSER - :decoding done!.");
3844         return TCORE_SAT_SUCCESS;
3845 }
3846
3847 //6.4.13 SETUP CALL
3848 static enum tcore_sat_result _sat_decode_setup_call(unsigned char* o_cmd_data, int o_length,
3849                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3850 {
3851         int temp_index = 0, data_len_consumed = 0;
3852         unsigned char dev_id[4];
3853         unsigned char* cmd_data = NULL;
3854         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3855
3856         if(o_cmd_data == NULL || sat_cmd_ind_data == NULL){
3857                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3858                 return TCORE_SAT_ERROR_FATAL;
3859         }
3860
3861         //command detail
3862         cmd_data = &o_cmd_data[0];
3863         temp_index = curr_offset+2;
3864         sat_cmd_ind_data->data.setup_call.command_detail.cmd_num = cmd_data[temp_index++];
3865         sat_cmd_ind_data->data.setup_call.command_detail.cmd_type = cmd_data[temp_index++];
3866
3867         /* ******decode command qualifier****** */
3868         switch(cmd_data[temp_index]){
3869                 case SETUP_CALL_IF_ANOTHER_CALL_NOT_BUSY:
3870                 case SETUP_CALL_IF_ANOTHER_CALL_NOT_BUSY_WITH_REDIAL:
3871                 case SETUP_CALL_PUT_ALL_OTHER_CALLS_ON_HOLD:
3872                 case SETUP_CALL_PUT_ALL_OTHER_CALLS_ON_HOLD_WITH_REDIAL:
3873                 case SETUP_CALL_DISCONN_ALL_OTHER_CALLS:
3874                 case SETUP_CALL_DISCONN_ALL_OTHER_CALLS_WITH_REDIAL:
3875                         sat_cmd_ind_data->data.setup_call.command_detail.cmd_qualifier.setup_call.setup_call = cmd_data[temp_index];
3876                         dbg("[SAT] SAT PARSER -  setup_call.cmd_qualifier= 0x%02x", sat_cmd_ind_data->data.setup_call.command_detail.cmd_qualifier.setup_call.setup_call);
3877                         break;
3878                 case SETUP_CALL_RESERVED:
3879                 default:
3880                         dbg("[SAT] SAT PARSER -  setup_call.cmd_qualifier= 0x%02x", cmd_data[temp_index]);
3881                         return TCORE_SAT_BEYOND_ME_CAPABILITY;
3882                         break;
3883         }
3884
3885         //device identifier
3886         temp_index++;
3887         memcpy(dev_id,&cmd_data[temp_index],4);
3888         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_call.device_id);
3889         if(rv != TCORE_SAT_SUCCESS)
3890                 return rv;
3891
3892         //alpha identifier (user confirmation) - optional
3893         temp_index+=4;
3894         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
3895                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_call.user_confirm_alpha_id, &data_len_consumed);
3896                 if(rv != TCORE_SAT_SUCCESS) {
3897                         return rv;
3898                 }
3899                 temp_index+=data_len_consumed;
3900         }
3901
3902         //address
3903         rv = _sat_decode_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_call.address, &data_len_consumed);
3904         if(rv != TCORE_SAT_SUCCESS) {
3905                 return rv;
3906         }
3907
3908         temp_index+=data_len_consumed;
3909         if(temp_index >= o_length){
3910                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3911                 return TCORE_SAT_SUCCESS;
3912         }
3913
3914         //capability configuration parameter - optional
3915         if((cmd_data[temp_index]&0x7F)==SATK_CAPABILITY_CONFIGURATION_PARAMETERS_TAG){
3916                 rv =_sat_decode_ccp_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_call.ccp, &data_len_consumed);
3917                 if(rv != TCORE_SAT_SUCCESS){
3918                         return rv; //SEND TR
3919                 }
3920
3921                 temp_index+=data_len_consumed;
3922                 if(temp_index >= o_length){
3923                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3924                         return TCORE_SAT_SUCCESS;
3925                 }
3926         }
3927
3928         //sub address - optional
3929         if((cmd_data[temp_index]&0x7F)==SATK_SUB_ADDRESS_TAG){
3930                 rv =_sat_decode_sub_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_call.subaddress, &data_len_consumed);
3931                 if(rv != TCORE_SAT_SUCCESS){
3932                         return rv; //SEND TR
3933                 }
3934
3935                 temp_index+=data_len_consumed;
3936                 if(temp_index >= o_length){
3937                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3938                         return TCORE_SAT_SUCCESS;
3939                 }
3940         }
3941
3942         //time duration - optional
3943         if((cmd_data[temp_index]&0x7F)==SATK_DURATION_TAG){
3944                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_call.duration, &data_len_consumed);
3945                 if(rv != TCORE_SAT_SUCCESS){
3946                         return rv; //SEND TR
3947                 }
3948
3949                 temp_index+=data_len_consumed;
3950                 if(temp_index >= o_length){
3951                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3952                         return TCORE_SAT_SUCCESS;
3953                 }
3954         }
3955
3956         //icon identifier (user confirmation) - optional
3957         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
3958                 data_len_consumed = 0;
3959                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_call.user_confirm_icon_id, &data_len_consumed);
3960
3961                 if(rv != TCORE_SAT_SUCCESS){
3962                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3963                 }
3964
3965                 temp_index+=data_len_consumed;
3966                 if(temp_index >= o_length){
3967                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3968                         return TCORE_SAT_SUCCESS;
3969                 }
3970         }
3971
3972         //alpha identifier (call setup) - optional
3973         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
3974                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_call.call_setup_alpha_id, &data_len_consumed);
3975                 if(rv != TCORE_SAT_SUCCESS) {
3976                         return rv;
3977                 }
3978
3979                 temp_index+=data_len_consumed;
3980                 if(temp_index >= o_length){
3981                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3982                         return TCORE_SAT_SUCCESS;
3983                 }
3984         }
3985
3986         //icon identifier (call setup) - optional
3987         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
3988                 data_len_consumed = 0;
3989                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_call.call_setup_icon_id, &data_len_consumed);
3990
3991                 if(rv != TCORE_SAT_SUCCESS){
3992                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3993                 }
3994
3995                 temp_index+=data_len_consumed;
3996                 if(temp_index >= o_length){
3997                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3998                         return TCORE_SAT_SUCCESS;
3999                 }
4000         }
4001
4002         //ToDo:  Text Attribute (user_confirmation , call_setup)
4003
4004         dbg("[SAT] SAT PARSER - :decoding done!.");
4005         return TCORE_SAT_SUCCESS;
4006 }
4007
4008 //6.4.15 PROVIDE LOCAL INFO
4009 static enum tcore_sat_result _sat_decode_provide_local_info(unsigned char* o_cmd_data, int o_length,
4010                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4011 {
4012         int temp_index = 0;
4013         unsigned char dev_id[4];
4014         unsigned char* cmd_data = NULL;
4015         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4016
4017         if(o_cmd_data == NULL){
4018                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4019                 return TCORE_SAT_ERROR_FATAL;
4020         }
4021
4022         //command detail
4023         cmd_data = &o_cmd_data[0];
4024         temp_index = curr_offset+2;
4025         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_num = cmd_data[temp_index++];
4026         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_type = cmd_data[temp_index++];
4027
4028         /* ******decode command qualifier****** */
4029         switch(cmd_data[temp_index]){
4030                 case LOCAL_INFO_DATE_TIME_AND_TIMEZONE:
4031                 case LOCAL_INFO_LANGUAGE:
4032                         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_qualifier.provide_local_info.provide_local_info = cmd_data[temp_index];
4033                         break;
4034                 //TODO - Other cases
4035                 default:
4036                         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_qualifier.provide_local_info.provide_local_info = LOCAL_INFO_RESERVED;
4037                         break;
4038         }
4039
4040         //device identifier
4041         temp_index++;
4042         memcpy(dev_id,&cmd_data[temp_index],4);
4043         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_event_list.device_id);
4044         if(rv != TCORE_SAT_SUCCESS)
4045                 return rv;
4046
4047         //TODO - UTRAN Measurement Qualifier
4048
4049         dbg("[SAT] SAT PARSER - :decoding done!.");
4050         return TCORE_SAT_SUCCESS;
4051 }
4052
4053 //6.4.16 SETUP EVENT LIST
4054 static enum tcore_sat_result _sat_decode_setup_event_list(unsigned char* o_cmd_data, int o_length,
4055                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4056 {
4057         int temp_index = 0, data_len_consumed = 0;
4058         unsigned char dev_id[4];
4059         unsigned char* cmd_data = NULL;
4060         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4061
4062         if(o_cmd_data == NULL){
4063                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4064                 return TCORE_SAT_ERROR_FATAL;
4065         }
4066
4067         //command detail
4068         cmd_data = &o_cmd_data[0];
4069         temp_index = curr_offset+2;
4070         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_num = cmd_data[temp_index++];
4071         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_type = cmd_data[temp_index++];
4072
4073         //device identifier
4074         temp_index++;
4075         memcpy(dev_id,&cmd_data[temp_index],4);
4076         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_event_list.device_id);
4077         if(rv != TCORE_SAT_SUCCESS)
4078                 return rv;
4079
4080         //event list
4081         temp_index+=4;
4082         rv = _sat_decode_event_list_tlv(o_cmd_data, o_length, temp_index,
4083                         &sat_cmd_ind_data->data.setup_event_list.event_list, &data_len_consumed);
4084
4085         dbg("[SAT] SAT PARSER - :decoding done!.");
4086         return TCORE_SAT_SUCCESS;
4087 }
4088
4089 //6.4.22 SETUP IDLE MODE TEXT
4090 static enum tcore_sat_result _sat_decode_setup_idle_mode_text(unsigned char* o_cmd_data, int o_length,
4091                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4092 {
4093         int temp_index = 0, data_len_consumed = 0;
4094         unsigned char dev_id[4];
4095         unsigned char* cmd_data = NULL;
4096         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4097
4098         if(o_cmd_data == NULL){
4099                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4100                 return TCORE_SAT_ERROR_FATAL;
4101         }
4102
4103         //command detail
4104         cmd_data = &o_cmd_data[0];
4105         temp_index = curr_offset+2;
4106         sat_cmd_ind_data->data.setup_idle_mode_text.command_detail.cmd_num = cmd_data[temp_index++];
4107         sat_cmd_ind_data->data.setup_idle_mode_text.command_detail.cmd_type = cmd_data[temp_index++];
4108
4109         //device identifier
4110         temp_index++;
4111         memcpy(dev_id,&cmd_data[temp_index],4);
4112         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_idle_mode_text.device_id);
4113         if(rv != TCORE_SAT_SUCCESS)
4114                 return rv;
4115
4116         //text string
4117         temp_index+=4;
4118         rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_idle_mode_text.text, &data_len_consumed);
4119         if(rv != TCORE_SAT_SUCCESS)
4120                 return rv;
4121
4122         if(sat_cmd_ind_data->data.setup_idle_mode_text.text.string_length < 0){
4123                 err("[SAT] SAT PARSER - :string length is less than 0");
4124                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4125         }
4126
4127         dbg("[SAT] SAT PARSER  text(%s)",sat_cmd_ind_data->data.setup_idle_mode_text.text.string);
4128         dbg("[SAT] SAT PARSER o_len(%d) temp_index(%d) data_len_consumed(%d)",o_length , temp_index, data_len_consumed);
4129
4130         if(temp_index+data_len_consumed > o_length){
4131                 err("[SAT] SAT PARSER - Wrong String TLV");
4132                 return TCORE_SAT_BEYOND_ME_CAPABILITY;
4133         }
4134         else if(temp_index+data_len_consumed == o_length){
4135                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
4136                 return TCORE_SAT_SUCCESS;
4137         }
4138
4139         //icon identifier
4140         temp_index+=data_len_consumed;
4141         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
4142                 data_len_consumed = 0;
4143                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.setup_idle_mode_text.icon_id, &data_len_consumed);
4144
4145                 if(rv != TCORE_SAT_SUCCESS){
4146                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
4147                 }
4148
4149                 if(temp_index+data_len_consumed >= o_length){
4150                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4151                         return TCORE_SAT_SUCCESS;
4152                 }
4153
4154                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
4155         }
4156
4157         //ToDo:  Text Attribute
4158         dbg("[SAT] SAT PARSER - :decoding done!.");
4159         return TCORE_SAT_SUCCESS;
4160 }
4161
4162 //6.4.24 SEND DTMF
4163 static enum tcore_sat_result _sat_decode_send_dtmf(unsigned char* o_cmd_data, int o_length,
4164                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4165 {
4166         int temp_index = 0, data_len_consumed = 0;
4167         unsigned char dev_id[4];
4168         unsigned char* cmd_data = NULL;
4169         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4170
4171         if(o_cmd_data == NULL){
4172                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4173                 return TCORE_SAT_ERROR_FATAL;
4174         }
4175
4176         //command detail
4177         cmd_data = &o_cmd_data[0];
4178         temp_index = curr_offset+2;
4179         sat_cmd_ind_data->data.send_dtmf.command_detail.cmd_num = cmd_data[temp_index++];
4180         sat_cmd_ind_data->data.send_dtmf.command_detail.cmd_type = cmd_data[temp_index++];
4181
4182         //device identifier
4183         temp_index++;
4184         memcpy(dev_id,&cmd_data[temp_index],4);
4185         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_dtmf.device_id);
4186         if(rv != TCORE_SAT_SUCCESS)
4187                 return rv;
4188
4189         //alpha identifier - optional
4190         temp_index+=4;
4191         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
4192                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_dtmf.alpha_id, &data_len_consumed);
4193                 if(rv != TCORE_SAT_SUCCESS) {
4194                         return rv;
4195                 }
4196                 temp_index+=data_len_consumed;
4197         }
4198
4199         // DTMF string - mandatory
4200         if ((cmd_data[temp_index] & 0x7F) == SATK_DTMF_STRING_TAG) {
4201                 rv = _sat_decode_dtmf_string_tlv(o_cmd_data, o_length, temp_index,
4202                                 &sat_cmd_ind_data->data.send_dtmf.dtmf_string, &data_len_consumed);
4203                 if (rv != TCORE_SAT_SUCCESS) {
4204                         return rv;
4205                 }
4206
4207                 if (temp_index + data_len_consumed >= o_length) {
4208                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4209                         return TCORE_SAT_SUCCESS;
4210                 }
4211                 temp_index += data_len_consumed;
4212         } else {
4213                 dbg("[SAT] SAT PARSER - DTMF tlv is missed.");
4214                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
4215         }
4216
4217         //icon identifier - optional
4218         if ((cmd_data[temp_index] & 0x7F) == SATK_ICON_IDENTIFIER_TAG) {
4219                 data_len_consumed = 0;
4220                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index,
4221                                 &sat_cmd_ind_data->data.send_dtmf.icon_id, &data_len_consumed);
4222
4223                 if (rv != TCORE_SAT_SUCCESS) {
4224                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4225                 }
4226
4227                 if (temp_index + data_len_consumed >= o_length) {
4228                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4229                         return TCORE_SAT_SUCCESS;
4230                 }
4231                 temp_index += data_len_consumed; //temp_index pointing to the Tag of next TLV
4232         }
4233
4234         //ToDo:  Text Attribute, Frame Identifier
4235         dbg("[SAT] SAT PARSER - :decoding done!.");
4236         return TCORE_SAT_SUCCESS;
4237 }
4238
4239 //6.4.25 LANGUAGE NOTIFICATION
4240 static enum tcore_sat_result _sat_decode_language_notification(unsigned char* o_cmd_data, int o_length,
4241                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4242 {
4243         int temp_index = 0;
4244         unsigned char dev_id[4];
4245         unsigned char* cmd_data = NULL;
4246         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4247
4248         if(o_cmd_data == NULL){
4249                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4250                 return TCORE_SAT_ERROR_FATAL;
4251         }
4252
4253         //command detail
4254         cmd_data = &o_cmd_data[0];
4255         temp_index = curr_offset+2;
4256         sat_cmd_ind_data->data.language_notification.command_detail.cmd_num = cmd_data[temp_index++];
4257         sat_cmd_ind_data->data.language_notification.command_detail.cmd_type = cmd_data[temp_index++];
4258
4259         /* ******decode command qualifier****** */
4260         if(cmd_data[temp_index]&0x01)
4261                 sat_cmd_ind_data->data.language_notification.command_detail.cmd_qualifier.language_notification.specific_language = TRUE;
4262         else
4263                 sat_cmd_ind_data->data.language_notification.command_detail.cmd_qualifier.language_notification.specific_language = FALSE;
4264
4265         //device identifier
4266         temp_index++;
4267         memcpy(dev_id,&cmd_data[temp_index],4);
4268         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.language_notification.device_id);
4269         if(rv != TCORE_SAT_SUCCESS)
4270                 return rv;
4271
4272         //language - conditional
4273         temp_index+=4;
4274         if (sat_cmd_ind_data->data.language_notification.command_detail.cmd_qualifier.language_notification.specific_language == TRUE) {
4275                 if((cmd_data[temp_index]&0x7F) == SATK_LANGUAGE_TAG) {
4276                         rv = _sat_decode_language_tlv(cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.language_notification.language);
4277                         if(rv != TCORE_SAT_SUCCESS)
4278                                 return rv;
4279                 } else  {
4280                         dbg("[SAT] SAT PARSER -  Language TLV is required but missing.");
4281                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4282                 }
4283         } else {
4284                 sat_cmd_ind_data->data.language_notification.language = SIM_LANG_UNSPECIFIED;
4285                 dbg("[SAT] SAT PARSER -  non-specific language");
4286         }
4287
4288         dbg("[SAT] SAT PARSER - :decoding done!.");
4289         return TCORE_SAT_SUCCESS;
4290 }
4291
4292 //6.4.26 LAUNCH BROWSER
4293 static enum tcore_sat_result _sat_decode_launch_browser(unsigned char* o_cmd_data, int o_length,
4294                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4295 {
4296         int temp_index = 0, data_len_consumed = 0;
4297         unsigned char dev_id[4];
4298         unsigned char* cmd_data = NULL;
4299         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4300
4301         if(o_cmd_data == NULL){
4302                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4303                 return TCORE_SAT_ERROR_FATAL;
4304         }
4305
4306         //command detail
4307         cmd_data = &o_cmd_data[0];
4308         temp_index = curr_offset+2;
4309         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_num = cmd_data[temp_index++];
4310         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_type = cmd_data[temp_index++];
4311
4312         // decode command qualifier
4313         switch (cmd_data[temp_index]) {
4314                 case 0x00:
4315                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4316                                         LAUNCH_BROWSER_IF_NOT_ALREADY_LAUNCHED;
4317                         break;
4318                 case 0x01:
4319                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4320                                         LAUNCH_BROWSER_NOT_USED;
4321                         break;
4322                 case 0x02:
4323                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4324                                         LAUNCH_BROWSER_USE_EXISTING_BROWSER;
4325                         break;
4326                 case 0x03:
4327                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4328                                         LAUNCH_BROWSER_CLOSE_AND_LAUNCH_NEW_BROWSER;
4329                         break;
4330                 case 0x04:
4331                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4332                                         LAUNCH_BROWSER_NOT_USED2;
4333                         break;
4334                 default:
4335                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4336                                         LAUNCH_BROWSER_RESERVED;
4337                         break;
4338         }
4339
4340         //device identifier
4341         temp_index++;
4342         memcpy(dev_id,&cmd_data[temp_index],4);
4343         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.language_notification.device_id);
4344         if(rv != TCORE_SAT_SUCCESS)
4345                 return rv;
4346
4347         temp_index += 4;
4348
4349         //Browser Identity TLV - Optional
4350         if ((cmd_data[temp_index] & 0x7F) == SATK_BROWSER_IDENTITY_TAG) {
4351                 rv = _sat_decode_browser_identity_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.launch_browser.browser_id, &data_len_consumed);
4352                 if(rv != TCORE_SAT_SUCCESS)
4353                         return rv;
4354                 temp_index += data_len_consumed;
4355         } else {
4356                 dbg("[SAT] SAT PARSER - Browser ID NOT present");
4357         }
4358
4359         //URL TLV - Mandatory
4360         if ((cmd_data[temp_index] & 0x7F) == SATK_URL_TAG) {
4361                 rv = _sat_decode_url_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.launch_browser.url, &data_len_consumed);
4362                 if(rv != TCORE_SAT_SUCCESS)
4363                         return rv;
4364
4365                 if (temp_index + data_len_consumed >= o_length) {
4366                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4367                         return TCORE_SAT_SUCCESS;
4368                 } else {
4369                         dbg("[SAT] SAT PARSER -  more TLVs to decode, decoding continue.");
4370                         temp_index += data_len_consumed;
4371                 }
4372         } else {
4373                 dbg("[SAT] SAT PARSER - Browser URL NOT present! BUG! this value is mandatory!!!");
4374                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
4375         }
4376
4377         //bearer - optional
4378         if ((cmd_data[temp_index] & 0x7F) == SATK_BEARER_TAG) {
4379                 rv = _sat_decode_bearer_tlv(o_cmd_data, o_length, temp_index,   &sat_cmd_ind_data->data.launch_browser.bearer, &data_len_consumed);
4380                 if(rv != TCORE_SAT_SUCCESS)
4381                         return rv;
4382
4383                 if (temp_index + data_len_consumed >= o_length) {
4384                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4385                         return TCORE_SAT_SUCCESS;
4386                 } else {
4387                         temp_index += data_len_consumed;
4388                 }
4389         } else {
4390                 dbg("[SAT] SAT PARSER -  Bearer TLV Not present.");
4391         }
4392
4393         //Provisioning reference file - optional
4394         sat_cmd_ind_data->data.launch_browser.file_ref_count = 0;
4395         while ((cmd_data[temp_index] & 0x7F) == SATK_PROVISIONING_REF_FILE_TAG) {
4396                 if (sat_cmd_ind_data->data.launch_browser.file_ref_count >= SAT_PROVISIONING_REF_MAX_COUNT) {
4397                         dbg("[SAT] SAT PARSER -  More number of PRF entries than can be handled");
4398                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4399                 }
4400
4401                 rv = _sat_decode_provisioning_file_ref_tlv(
4402                                                                 o_cmd_data,
4403                                                                 o_length,
4404                                                                 temp_index,
4405                                                                 &sat_cmd_ind_data->data.launch_browser.file_list[sat_cmd_ind_data->data.launch_browser.file_ref_count],
4406                                                                 &data_len_consumed);
4407                 if(rv != TCORE_SAT_SUCCESS) {
4408                         return rv;
4409                 } else {
4410                         sat_cmd_ind_data->data.launch_browser.file_ref_count++;
4411                 }
4412
4413                 if (temp_index + data_len_consumed >= o_length) {
4414                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4415                         return TCORE_SAT_SUCCESS;
4416                 } else {
4417                         temp_index += data_len_consumed;
4418                 }
4419         }
4420
4421         //text string(gateway/proxy identity) - optional
4422         if ((cmd_data[temp_index] & 0x7F) == SATK_TEXT_STRING_TAG) {
4423                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.launch_browser.gateway_proxy_text, &data_len_consumed);
4424                 if(rv != TCORE_SAT_SUCCESS)
4425                         return rv;
4426
4427                 if (temp_index + data_len_consumed >= o_length) {
4428                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4429                         return TCORE_SAT_SUCCESS;
4430                 } else {
4431                         temp_index += data_len_consumed;
4432                 }
4433         }
4434
4435         //alpha identifier - optional
4436         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
4437                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.launch_browser.user_confirm_alpha_id, &data_len_consumed);
4438                 if(rv != TCORE_SAT_SUCCESS) {
4439                         return rv;
4440                 }
4441                 if (temp_index + data_len_consumed >= o_length) {
4442                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4443                         return TCORE_SAT_SUCCESS;
4444                 }
4445                 temp_index+=data_len_consumed;
4446         } else {
4447                 dbg("[SAT] SAT PARSER -  No Alpha ID TLV.");
4448         }
4449
4450         //icon identifier - optional
4451         if ((cmd_data[temp_index] & 0x7F) == SATK_ICON_IDENTIFIER_TAG) {
4452                 data_len_consumed = 0;
4453                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index,
4454                                 &sat_cmd_ind_data->data.launch_browser.user_confirm_icon_id, &data_len_consumed);
4455
4456                 if (rv != TCORE_SAT_SUCCESS) {
4457                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4458                 }
4459
4460                 if (temp_index + data_len_consumed >= o_length) {
4461                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4462                         return TCORE_SAT_SUCCESS;
4463                 }
4464                 temp_index += data_len_consumed; //temp_index pointing to the Tag of next TLV
4465         }
4466
4467         //ToDo:  Text Attribute, Frame Identifier
4468         dbg("[SAT] SAT PARSER - :decoding done!.");
4469         return TCORE_SAT_SUCCESS;
4470 }
4471
4472 //6.4.27 OPEN CHANNEL
4473 static enum tcore_sat_result _sat_decode_open_channel(unsigned char* o_cmd_data, int o_length,
4474                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4475 {
4476         int temp_index = 0;
4477         gboolean b_1st_duration = FALSE;
4478         int bearer_desc_len =0, data_len_consumed=0;
4479         unsigned char dev_id[4];
4480         unsigned char* cmd_data = NULL;
4481         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4482
4483         if(o_cmd_data == NULL){
4484                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4485                 return TCORE_SAT_ERROR_FATAL;
4486         }
4487
4488         cmd_data = &o_cmd_data[0];
4489         temp_index = curr_offset+2;
4490         sat_cmd_ind_data->data.open_channel.command_detail.cmd_num = cmd_data[temp_index++];
4491         sat_cmd_ind_data->data.open_channel.command_detail.cmd_type = cmd_data[temp_index++];
4492
4493         /** command detail **/
4494         sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.immediate_link = FALSE;
4495         sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.automatic_reconnection = FALSE;
4496         sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.background_mode = FALSE;
4497
4498         if(cmd_data[temp_index]&0x01){
4499                 sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.immediate_link = TRUE;
4500                 dbg("[SAT] SAT PARSER - Immediate Link Establishment");
4501         }
4502
4503         if(cmd_data[temp_index]&0x02){
4504                 sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.automatic_reconnection = TRUE;
4505                 dbg("[SAT] SAT PARSER - Auto Reconnection");
4506         }
4507
4508         if(cmd_data[temp_index]&0x04){
4509                 sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.background_mode = TRUE;
4510                 dbg("[SAT] SAT PARSER - Background mode");
4511         }
4512
4513         //device identities
4514         temp_index++;
4515         memcpy(dev_id,&cmd_data[temp_index],4);
4516         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.open_channel.device_id);
4517         if(rv != TCORE_SAT_SUCCESS)
4518                 return rv;
4519
4520         //alpha identifier - optional
4521         temp_index += 4;
4522         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
4523                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.alpha_id, &data_len_consumed);
4524                 if(rv != TCORE_SAT_SUCCESS) {
4525                         return rv;
4526                 }
4527                 temp_index+=data_len_consumed;
4528         }
4529
4530         //icon id - optional
4531         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
4532                 data_len_consumed = 0;
4533                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.icon_id, &data_len_consumed);
4534                 if(rv != TCORE_SAT_SUCCESS){
4535                         return rv; //SEND TR
4536                 }
4537                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
4538         }
4539
4540         //bearer description
4541         rv =_sat_decode_bearer_description_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_desc, &data_len_consumed);
4542         bearer_desc_len = data_len_consumed;
4543         if(rv != TCORE_SAT_SUCCESS)
4544                 return rv;
4545         //TODO UICC SERVER MODE
4546
4547         switch(sat_cmd_ind_data->data.open_channel.bearer_desc.bearer_type){
4548                 case BEARER_CSD:
4549
4550                         //address
4551                         rv = _sat_decode_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.cs_bearer.address, &data_len_consumed);
4552                         if(rv != TCORE_SAT_SUCCESS) {
4553                                 return rv;
4554                         }
4555                         temp_index+=data_len_consumed;
4556
4557                         //sub address - optional
4558                         if((cmd_data[temp_index]&0x7F) == SATK_SUB_ADDRESS_TAG){
4559                                 data_len_consumed = 0;
4560                                 rv = _sat_decode_subaddress_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.cs_bearer.subaddress, &data_len_consumed);
4561                                 if(rv != TCORE_SAT_SUCCESS) {
4562                                         return rv;
4563                                 }
4564                                 temp_index+=data_len_consumed;
4565                         }
4566
4567                         //time duration 1- optional
4568                         if((cmd_data[temp_index]&0x7F)==SATK_DURATION_TAG){
4569                                 data_len_consumed = 0;
4570                                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.cs_bearer.duration1, &data_len_consumed);
4571                                 if(rv != TCORE_SAT_SUCCESS){
4572                                         return rv; //SEND TR
4573                                 }
4574                                 temp_index+=data_len_consumed;
4575                                 b_1st_duration = TRUE;
4576                         }
4577
4578                         //time duration 2- optional
4579                         if((cmd_data[temp_index]&0x7F)==SATK_DURATION_TAG){
4580
4581                                 if(!b_1st_duration){
4582                                         dbg("duration 1 does not present!");
4583                                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4584                                 }
4585
4586                                 data_len_consumed = 0;
4587                                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.cs_bearer.duration2, &data_len_consumed);
4588                                 if(rv != TCORE_SAT_SUCCESS){
4589                                         return rv; //SEND TR
4590                                 }
4591                                 temp_index+=data_len_consumed;
4592                         }
4593
4594                         //bearer description - already did it
4595                         temp_index+=bearer_desc_len;
4596
4597                         //buffer size
4598                         rv =_sat_decode_buffer_size_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.buffer_size, &data_len_consumed);
4599                         if(rv != TCORE_SAT_SUCCESS){
4600                                 return rv; //SEND TR
4601                         }
4602
4603                         temp_index+=data_len_consumed;
4604                         if(temp_index >= o_length){
4605                                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4606                                 return TCORE_SAT_SUCCESS;
4607                         }
4608
4609                         //other address - optional
4610                         if((cmd_data[temp_index]&0x7F)==SATK_OTHER_ADDRESS_TAG){
4611                                 data_len_consumed = 0;
4612                                 rv =_sat_decode_other_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.cs_bearer.other_address, &data_len_consumed);
4613                                 if(rv != TCORE_SAT_SUCCESS){
4614                                         return rv; //SEND TR
4615                                 }
4616
4617                                 temp_index+=data_len_consumed;
4618                                 if(temp_index >= o_length){
4619                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4620                                         return TCORE_SAT_SUCCESS;
4621                                 }
4622                         }
4623
4624                         //text string - user login - optional
4625                         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_STRING_TAG){
4626                                 data_len_consumed = 0;
4627                                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.cs_bearer.text_user_login, &data_len_consumed);
4628                                 if(rv != TCORE_SAT_SUCCESS)
4629                                         return rv;
4630
4631                                 temp_index+=data_len_consumed;
4632                                 if(temp_index >= o_length){
4633                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4634                                         return TCORE_SAT_SUCCESS;
4635                                 }
4636                         }
4637
4638                         //text string - user password - optional
4639                         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_STRING_TAG){
4640                                 data_len_consumed = 0;
4641                                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.cs_bearer.text_user_pwd, &data_len_consumed);
4642                                 if(rv != TCORE_SAT_SUCCESS)
4643                                         return rv;
4644
4645                                 temp_index+=data_len_consumed;
4646                                 if(temp_index >= o_length){
4647                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4648                                         return TCORE_SAT_SUCCESS;
4649                                 }
4650                         }
4651
4652                         //UICC/TERMINAL interface transport level - optional
4653                         if((cmd_data[temp_index]&0x7F)==SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG){
4654                                 data_len_consumed = 0;
4655                                 rv = _sat_decode_uicc_terminal_interface_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.interface_transport_level, &data_len_consumed);
4656                                 if(rv != TCORE_SAT_SUCCESS)
4657                                         return rv;
4658
4659                                 temp_index+=data_len_consumed;
4660                                 if(temp_index >= o_length){
4661                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4662                                         return TCORE_SAT_SUCCESS;
4663                                 }
4664                         }
4665
4666                         //destination address - optional
4667                         if((cmd_data[temp_index]&0x7F)==SATK_OTHER_ADDRESS_TAG){
4668                                 data_len_consumed = 0;
4669                                 rv =_sat_decode_other_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.data_destination_address, &data_len_consumed);
4670                                 if(rv != TCORE_SAT_SUCCESS){
4671                                         return rv; //SEND TR
4672                                 }
4673
4674                                 temp_index+=data_len_consumed;
4675                                 if(temp_index >= o_length){
4676                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4677                                         return TCORE_SAT_SUCCESS;
4678                                 }
4679                         }
4680
4681                         break;
4682                 case BEARER_GPRS:
4683                         //bearer description - already did it
4684                         temp_index+=bearer_desc_len;
4685
4686                         //buffer size
4687                         rv =_sat_decode_buffer_size_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.buffer_size, &data_len_consumed);
4688                         if(rv != TCORE_SAT_SUCCESS){
4689                                 return rv; //SEND TR
4690                         }
4691
4692                         temp_index+=data_len_consumed;
4693                         if(temp_index >= o_length){
4694                                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4695                                 return TCORE_SAT_SUCCESS;
4696                         }
4697
4698                         //Network Access Name - optional
4699                         if((cmd_data[temp_index]&0x7F)==SATK_NETWORK_ACCESS_TAG){
4700                                 data_len_consumed = 0;
4701                                 rv =_sat_decode_network_access_name_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.ps_bearer.network_access_name, &data_len_consumed);
4702                                 if(rv != TCORE_SAT_SUCCESS){
4703                                         return rv; //SEND TR
4704                                 }
4705
4706                                 temp_index+=data_len_consumed;
4707                                 if(temp_index >= o_length){
4708                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4709                                         return TCORE_SAT_SUCCESS;
4710                                 }
4711                         }
4712
4713                         //other address - optional
4714                         if((cmd_data[temp_index]&0x7F)==SATK_OTHER_ADDRESS_TAG){
4715                                 data_len_consumed = 0;
4716                                 rv =_sat_decode_other_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.ps_bearer.other_address, &data_len_consumed);
4717                                 if(rv != TCORE_SAT_SUCCESS){
4718                                         return rv; //SEND TR
4719                                 }
4720
4721                                 temp_index+=data_len_consumed;
4722                                 if(temp_index >= o_length){
4723                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4724                                         return TCORE_SAT_SUCCESS;
4725                                 }
4726                         }
4727
4728                         //text string - user login - optional
4729                         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_STRING_TAG){
4730                                 data_len_consumed = 0;
4731                                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.ps_bearer.text_user_login, &data_len_consumed);
4732                                 if(rv != TCORE_SAT_SUCCESS)
4733                                         return rv;
4734
4735                                 temp_index+=data_len_consumed;
4736                                 if(temp_index >= o_length){
4737                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4738                                         return TCORE_SAT_SUCCESS;
4739                                 }
4740                         }
4741
4742                         //text string - user password - optional
4743                         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_STRING_TAG){
4744                                 data_len_consumed = 0;
4745                                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.ps_bearer.text_user_pwd, &data_len_consumed);
4746                                 if(rv != TCORE_SAT_SUCCESS)
4747                                         return rv;
4748
4749                                 temp_index+=data_len_consumed;
4750                                 if(temp_index >= o_length){
4751                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4752                                         return TCORE_SAT_SUCCESS;
4753                                 }
4754                         }
4755
4756                         //UICC/TERMINAL interface transport level - optional
4757                         if((cmd_data[temp_index]&0x7F)==SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG){
4758                                 data_len_consumed = 0;
4759                                 rv = _sat_decode_uicc_terminal_interface_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.interface_transport_level, &data_len_consumed);
4760                                 if(rv != TCORE_SAT_SUCCESS)
4761                                         return rv;
4762
4763                                 temp_index+=data_len_consumed;
4764                                 if(temp_index >= o_length){
4765                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4766                                         return TCORE_SAT_SUCCESS;
4767                                 }
4768                         }
4769
4770                         dbg("the value (0x%x) after interface transport level", cmd_data[temp_index]&0x7F);
4771
4772                         //destination address - optional
4773                         if((cmd_data[temp_index]&0x7F)==SATK_OTHER_ADDRESS_TAG){
4774                                 data_len_consumed = 0;
4775                                 rv =_sat_decode_other_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.data_destination_address, &data_len_consumed);
4776                                 if(rv != TCORE_SAT_SUCCESS){
4777                                         return rv; //SEND TR
4778                                 }
4779
4780                                 temp_index+=data_len_consumed;
4781                                 if(temp_index >= o_length){
4782                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4783                                         return TCORE_SAT_SUCCESS;
4784                                 }
4785                         }
4786
4787                         break;
4788                 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:
4789                         //bearer description - already did it
4790                         temp_index+=bearer_desc_len;
4791
4792                         //buffer size
4793                         rv =_sat_decode_buffer_size_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.buffer_size, &data_len_consumed);
4794                         if(rv != TCORE_SAT_SUCCESS){
4795                                 return rv; //SEND TR
4796                         }
4797
4798                         temp_index+=data_len_consumed;
4799                         if(temp_index >= o_length){
4800                                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4801                                 return TCORE_SAT_SUCCESS;
4802                         }
4803
4804                         //other address - optional
4805                         if((cmd_data[temp_index]&0x7F)==SATK_OTHER_ADDRESS_TAG){
4806                                 data_len_consumed = 0;
4807                                 rv =_sat_decode_other_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.default_bearer.other_address, &data_len_consumed);
4808                                 if(rv != TCORE_SAT_SUCCESS){
4809                                         return rv; //SEND TR
4810                                 }
4811
4812                                 temp_index+=data_len_consumed;
4813                                 if(temp_index >= o_length){
4814                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4815                                         return TCORE_SAT_SUCCESS;
4816                                 }
4817                         }
4818
4819                         //text string - user login - optional
4820                         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_STRING_TAG){
4821                                 data_len_consumed = 0;
4822                                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.default_bearer.text_user_login, &data_len_consumed);
4823                                 if(rv != TCORE_SAT_SUCCESS)
4824                                         return rv;
4825
4826                                 temp_index+=data_len_consumed;
4827                                 if(temp_index >= o_length){
4828                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4829                                         return TCORE_SAT_SUCCESS;
4830                                 }
4831                         }
4832
4833                         //text string - user password - optional
4834                         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_STRING_TAG){
4835                                 data_len_consumed = 0;
4836                                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.default_bearer.text_user_pwd, &data_len_consumed);
4837                                 if(rv != TCORE_SAT_SUCCESS)
4838                                         return rv;
4839
4840                                 temp_index+=data_len_consumed;
4841                                 if(temp_index >= o_length){
4842                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4843                                         return TCORE_SAT_SUCCESS;
4844                                 }
4845                         }
4846
4847                         //UICC/TERMINAL interface transport level - optional
4848                         if((cmd_data[temp_index]&0x7F)==SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG){
4849                                 data_len_consumed = 0;
4850                                 rv = _sat_decode_uicc_terminal_interface_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.interface_transport_level, &data_len_consumed);
4851                                 if(rv != TCORE_SAT_SUCCESS)
4852                                         return rv;
4853
4854                                 temp_index+=data_len_consumed;
4855                                 if(temp_index >= o_length){
4856                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4857                                         return TCORE_SAT_SUCCESS;
4858                                 }
4859                         }
4860
4861                         //destination address - optional
4862                         if((cmd_data[temp_index]&0x7F)==SATK_OTHER_ADDRESS_TAG){
4863                                 data_len_consumed = 0;
4864                                 rv =_sat_decode_other_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.data_destination_address, &data_len_consumed);
4865                                 if(rv != TCORE_SAT_SUCCESS){
4866                                         return rv; //SEND TR
4867                                 }
4868
4869                                 temp_index+=data_len_consumed;
4870                                 if(temp_index >= o_length){
4871                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4872                                         return TCORE_SAT_SUCCESS;
4873                                 }
4874                         }
4875
4876                         break;
4877                 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:
4878
4879                         //time duration 1- optional
4880                         if((cmd_data[temp_index]&0x7F)==SATK_DURATION_TAG){
4881                                 data_len_consumed = 0;
4882                                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.local_bearer.duration1, &data_len_consumed);
4883                                 if(rv != TCORE_SAT_SUCCESS){
4884                                         return rv; //SEND TR
4885                                 }
4886                                 temp_index+=data_len_consumed;
4887                                 b_1st_duration = TRUE;
4888                         }
4889
4890                         //time duration 2- optional
4891                         if((cmd_data[temp_index]&0x7F)==SATK_DURATION_TAG){
4892
4893                                 if(!b_1st_duration){
4894                                         dbg("duration 1 does not present!");
4895                                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4896                                 }
4897
4898                                 data_len_consumed = 0;
4899                                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.local_bearer.duration2, &data_len_consumed);
4900                                 if(rv != TCORE_SAT_SUCCESS){
4901                                         return rv; //SEND TR
4902                                 }
4903                                 temp_index+=data_len_consumed;
4904                         }
4905
4906                         //bearer description - already did it
4907                         temp_index+=bearer_desc_len;
4908
4909                         //buffer size
4910                         rv =_sat_decode_buffer_size_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.buffer_size, &data_len_consumed);
4911                         if(rv != TCORE_SAT_SUCCESS){
4912                                 return rv; //SEND TR
4913                         }
4914
4915                         temp_index+=data_len_consumed;
4916                         if(temp_index >= o_length){
4917                                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4918                                 return TCORE_SAT_SUCCESS;
4919                         }
4920
4921                         //text string - user password - optional
4922                         if((cmd_data[temp_index]&0x7F)==SATK_TEXT_STRING_TAG){
4923                                 data_len_consumed = 0;
4924                                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.local_bearer.text_user_pwd, &data_len_consumed);
4925                                 if(rv != TCORE_SAT_SUCCESS)
4926                                         return rv;
4927
4928                                 temp_index+=data_len_consumed;
4929                                 if(temp_index >= o_length){
4930                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4931                                         return TCORE_SAT_SUCCESS;
4932                                 }
4933                         }
4934
4935                         //UICC/TERMINAL interface transport level - optional
4936                         if((cmd_data[temp_index]&0x7F)==SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG){
4937                                 data_len_consumed = 0;
4938                                 rv = _sat_decode_uicc_terminal_interface_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.interface_transport_level, &data_len_consumed);
4939                                 if(rv != TCORE_SAT_SUCCESS)
4940                                         return rv;
4941
4942                                 temp_index+=data_len_consumed;
4943                                 if(temp_index >= o_length){
4944                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4945                                         return TCORE_SAT_SUCCESS;
4946                                 }
4947                         }
4948
4949                         //destination address - optional
4950                         if((cmd_data[temp_index]&0x7F)==SATK_OTHER_ADDRESS_TAG){
4951                                 data_len_consumed = 0;
4952                                 rv =_sat_decode_other_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.data_destination_address, &data_len_consumed);
4953                                 if(rv != TCORE_SAT_SUCCESS){
4954                                         return rv; //SEND TR
4955                                 }
4956
4957                                 temp_index+=data_len_consumed;
4958                                 if(temp_index >= o_length){
4959                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4960                                         return TCORE_SAT_SUCCESS;
4961                                 }
4962                         }
4963
4964                         //remote entity address - optional
4965                         if((cmd_data[temp_index]&0x7F)==SATK_REMOTE_ENTITY_ADDRESS_TAG){
4966                                 data_len_consumed = 0;
4967                                 rv =_sat_decode_remote_entity_address_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.open_channel.bearer_detail.local_bearer.remote_entity_address, &data_len_consumed);
4968                                 if(rv != TCORE_SAT_SUCCESS){
4969                                         return rv; //SEND TR
4970                                 }
4971
4972                                 temp_index+=data_len_consumed;
4973                                 if(temp_index >= o_length){
4974                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4975                                         return TCORE_SAT_SUCCESS;
4976                                 }
4977                         }
4978
4979                         break;
4980                 default:
4981                         break;
4982         }//end of switch
4983
4984         dbg("[SAT] SAT PARSER - :decoding done!.");
4985         return TCORE_SAT_SUCCESS;
4986 }
4987
4988 //6.4.28 CLOSE CHANNEL
4989 static enum tcore_sat_result _sat_decode_close_channel(unsigned char* o_cmd_data, int o_length,
4990                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4991 {
4992         int temp_index = 0;
4993         int data_len_consumed=0;
4994         unsigned char dev_id[4];
4995         unsigned char* cmd_data = NULL;
4996         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4997
4998         if(o_cmd_data == NULL){
4999                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
5000                 return TCORE_SAT_ERROR_FATAL;
5001         }
5002
5003         cmd_data = &o_cmd_data[0];
5004         temp_index = curr_offset+2;
5005         sat_cmd_ind_data->data.close_channel.command_detail.cmd_num = cmd_data[temp_index++];
5006         sat_cmd_ind_data->data.close_channel.command_detail.cmd_type = cmd_data[temp_index++];
5007
5008         /** command detail **/
5009         temp_index++; //RFU
5010
5011         //device identities
5012         memcpy(dev_id,&cmd_data[temp_index],4);
5013         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.close_channel.device_id);
5014         if(rv != TCORE_SAT_SUCCESS)
5015                 return rv;
5016
5017         //alpha identifier - optional
5018         temp_index += 4;
5019         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
5020                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.close_channel.alpha_id, &data_len_consumed);
5021                 if(rv != TCORE_SAT_SUCCESS) {
5022                         return rv;
5023                 }
5024                 temp_index+=data_len_consumed;
5025         }
5026
5027         //icon id - optional
5028         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
5029                 data_len_consumed = 0;
5030                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.close_channel.icon_id, &data_len_consumed);
5031                 if(rv != TCORE_SAT_SUCCESS){
5032                         return rv; //SEND TR
5033                 }
5034                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
5035         }
5036
5037         //ToDo:  Text Attribute and frames
5038
5039         dbg("[SAT] SAT PARSER - :decoding done!.");
5040         return TCORE_SAT_SUCCESS;
5041 }
5042
5043 //6.4.29 RECEIVE DATA
5044 static enum tcore_sat_result _sat_decode_receive_data(unsigned char* o_cmd_data, int o_length,
5045                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
5046 {
5047         int temp_index = 0;
5048         int data_len_consumed=0;
5049         unsigned char dev_id[4];
5050         unsigned char* cmd_data = NULL;
5051         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
5052
5053         if(o_cmd_data == NULL){
5054                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
5055                 return TCORE_SAT_ERROR_FATAL;
5056         }
5057
5058         cmd_data = &o_cmd_data[0];
5059         temp_index = curr_offset+2;
5060         sat_cmd_ind_data->data.receive_data.command_detail.cmd_num = cmd_data[temp_index++];
5061         sat_cmd_ind_data->data.receive_data.command_detail.cmd_type = cmd_data[temp_index++];
5062
5063         /** command detail **/
5064         temp_index++; //RFU
5065
5066         //device identities
5067         memcpy(dev_id,&cmd_data[temp_index],4);
5068         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.receive_data.device_id);
5069         if(rv != TCORE_SAT_SUCCESS)
5070                 return rv;
5071
5072         //alpha identifier - optional
5073         temp_index += 4;
5074         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
5075                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.receive_data.alpha_id, &data_len_consumed);
5076                 if(rv != TCORE_SAT_SUCCESS) {
5077                         return rv;
5078                 }
5079                 temp_index+=data_len_consumed;
5080         }
5081
5082         //icon id - optional
5083         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
5084                 data_len_consumed = 0;
5085                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.receive_data.icon_id, &data_len_consumed);
5086                 if(rv != TCORE_SAT_SUCCESS){
5087                         return rv; //SEND TR
5088                 }
5089                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
5090         }
5091
5092         //channel data length
5093         rv =_sat_decode_channel_data_length_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.receive_data.channel_data_len, &data_len_consumed);
5094         if(rv != TCORE_SAT_SUCCESS){
5095                 return rv; //SEND TR
5096         }
5097
5098         //ToDo:  Text Attribute and frames
5099
5100         dbg("[SAT] SAT PARSER - :decoding done!.");
5101         return TCORE_SAT_SUCCESS;
5102 }
5103
5104 //6.4.30 SEND DATA
5105 static enum tcore_sat_result _sat_decode_send_data(unsigned char* o_cmd_data, int o_length,
5106                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
5107 {
5108         int temp_index = 0;
5109         int data_len_consumed=0;
5110         unsigned char dev_id[4];
5111         unsigned char* cmd_data = NULL;
5112         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
5113
5114         if(o_cmd_data == NULL){
5115                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
5116                 return TCORE_SAT_ERROR_FATAL;
5117         }
5118
5119         cmd_data = &o_cmd_data[0];
5120         temp_index = curr_offset+2;
5121         sat_cmd_ind_data->data.send_data.command_detail.cmd_num = cmd_data[temp_index++];
5122         sat_cmd_ind_data->data.send_data.command_detail.cmd_type = cmd_data[temp_index++];
5123
5124         /** command detail **/
5125         sat_cmd_ind_data->data.send_data.command_detail.cmd_qualifier.send_data.send_data_immediately = FALSE;
5126         if(cmd_data[temp_index]&0x01){
5127                 sat_cmd_ind_data->data.send_data.command_detail.cmd_qualifier.send_data.send_data_immediately = TRUE;
5128                 dbg("[SAT] SAT PARSER - Send data immediately");
5129         }
5130
5131         //device identities
5132         temp_index++;
5133         memcpy(dev_id,&cmd_data[temp_index],4);
5134         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_data.device_id);
5135         if(rv != TCORE_SAT_SUCCESS)
5136                 return rv;
5137
5138         //alpha identifier - optional
5139         temp_index += 4;
5140         if((cmd_data[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
5141                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_data.alpha_id, &data_len_consumed);
5142                 if(rv != TCORE_SAT_SUCCESS) {
5143                         return rv;
5144                 }
5145                 temp_index+=data_len_consumed;
5146         }
5147
5148         //icon id - optional
5149         if((cmd_data[temp_index]&0x7F) == SATK_ICON_IDENTIFIER_TAG){
5150                 data_len_consumed = 0;
5151                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_data.icon_id, &data_len_consumed);
5152                 if(rv != TCORE_SAT_SUCCESS){
5153                         return rv; //SEND TR
5154                 }
5155                 temp_index+=data_len_consumed; //temp_index pointing to the Tag of next TLV
5156         }
5157
5158         //channel data
5159         rv =_sat_decode_channel_data_tlv(o_cmd_data, o_length, temp_index, &sat_cmd_ind_data->data.send_data.channel_data, &data_len_consumed);
5160         if(rv != TCORE_SAT_SUCCESS){
5161                 return rv; //SEND TR
5162         }
5163
5164         //ToDo:  Text Attribute and frames
5165
5166         dbg("[SAT] SAT PARSER - :decoding done!.");
5167         return TCORE_SAT_SUCCESS;
5168 }
5169
5170 //6.4.31 GET CHANNEL STATUS
5171 static enum tcore_sat_result _sat_decode_get_channel_status(unsigned char* o_cmd_data, int o_length,
5172                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
5173 {
5174         int temp_index = 0;
5175         unsigned char dev_id[4];
5176         unsigned char* cmd_data = NULL;
5177         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
5178
5179         if(o_cmd_data == NULL){
5180                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
5181                 return TCORE_SAT_ERROR_FATAL;
5182         }
5183
5184         cmd_data = &o_cmd_data[0];
5185         temp_index = curr_offset+2;
5186         sat_cmd_ind_data->data.get_channel_status.command_detail.cmd_num = cmd_data[temp_index++];
5187         sat_cmd_ind_data->data.get_channel_status.command_detail.cmd_type = cmd_data[temp_index++];
5188
5189         /** command detail **/
5190         temp_index++; //RFU
5191
5192         //device identities
5193         memcpy(dev_id,&cmd_data[temp_index],4);
5194         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.get_channel_status.device_id);
5195         if(rv != TCORE_SAT_SUCCESS)
5196                 return rv;
5197
5198         dbg("[SAT] SAT PARSER - :decoding done!.");
5199         return TCORE_SAT_SUCCESS;
5200 }
5201
5202 //6.4.XX Unsupported Command
5203 static enum tcore_sat_result _sat_decode_unsupported_command(unsigned char* o_cmd_data, int o_length,
5204                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
5205 {
5206         int temp_index = 0;
5207         unsigned char dev_id[4];
5208         unsigned char* cmd_data = NULL;
5209         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
5210
5211         if(o_cmd_data == NULL){
5212                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
5213                 return TCORE_SAT_ERROR_FATAL;
5214         }
5215
5216         cmd_data = &o_cmd_data[0];
5217         temp_index = curr_offset+2;
5218         sat_cmd_ind_data->data.unsupport_cmd.command_detail.cmd_num = cmd_data[temp_index++];
5219         sat_cmd_ind_data->data.unsupport_cmd.command_detail.cmd_type = cmd_data[temp_index++];
5220
5221         /** command detail **/
5222         temp_index++; //RFU
5223
5224         //device identities
5225         memcpy(dev_id,&cmd_data[temp_index],4);
5226         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.unsupport_cmd.device_id);
5227         if(rv != TCORE_SAT_SUCCESS)
5228                 return rv;
5229
5230         dbg("[SAT] SAT PARSER - :decoding done!.");
5231         return TCORE_SAT_SUCCESS;
5232 }
5233
5234 int tcore_sat_decode_proactive_command(unsigned char* tlv_origin, unsigned int tlv_length,
5235                 struct tcore_sat_proactive_command* decoded_tlv)
5236 {
5237         unsigned int temp_index = 0;
5238         int length_field_len = 0;
5239         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
5240
5241         if(tlv_origin == NULL || tlv_length <=2) {
5242                 dbg("[SAT] SAT PARSER - pointer pData passed is NULL or invalid length.");
5243                 return TCORE_SAT_ERROR_FATAL;
5244         }
5245
5246         //tag
5247         if(tlv_origin[temp_index++]!= SATK_PROACTIVE_CMD_TAG) {
5248                 dbg("[SAT] SAT PARSER - Did not find Proactive command tag.tag=%d", tlv_origin[temp_index-1]);
5249                 return TCORE_SAT_ERROR_FATAL;
5250         }
5251
5252         //length
5253         length_field_len = _get_length_filed_size(tlv_origin[temp_index]);
5254         if(length_field_len == 0) {
5255                 dbg("[SAT] SAT PARSER - Invalid length.");
5256                 return TCORE_SAT_ERROR_FATAL;
5257         }
5258         //length
5259         dbg("[SAT] SAT PARSER - tlv_length=%d", tlv_length);
5260         temp_index+=length_field_len;
5261
5262         //check command validation
5263         if(tlv_length < temp_index+5+4)//command detail(5) and device identities(4)
5264                 return TCORE_SAT_ERROR_FATAL;
5265
5266         //check comprehensive value
5267         if((tlv_origin[temp_index] | 0x7F) != 0x7F){
5268                 dbg("comprehensive value 0x%x", tlv_origin[temp_index] | 0x7F);
5269                 b_comprehensive = TRUE;
5270         }
5271
5272         if( (tlv_origin[temp_index] & 0x7F) != SATK_COMMAND_DETAILS_TAG){
5273                 err("[SAT] no command detail info");
5274                 return TCORE_SAT_ERROR_FATAL;
5275         }
5276
5277         if( tlv_origin[temp_index+1] != SATK_COMMAND_DETAILS_LENGTH){
5278                 err("[SAT] invalid command detail length");
5279                 return TCORE_SAT_ERROR_FATAL;
5280         }
5281
5282         decoded_tlv->cmd_num= tlv_origin[temp_index+2];
5283         decoded_tlv->cmd_type = tlv_origin[temp_index+3];
5284
5285         switch(decoded_tlv->cmd_type) {
5286                 case SAT_PROATV_CMD_DISPLAY_TEXT: //6.4.1
5287                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_DISPLAY_TEXT");
5288                         rv = _sat_decode_display_text(tlv_origin, tlv_length, temp_index, decoded_tlv);
5289                         break;
5290                 case SAT_PROATV_CMD_GET_INKEY: //6.4.2
5291                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_GET_INKEY");
5292                         rv = _sat_decode_get_inkey(tlv_origin, tlv_length, temp_index, decoded_tlv);
5293                         break;
5294                 case SAT_PROATV_CMD_GET_INPUT: //6.4.3
5295                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_GET_INPUT");
5296                         rv = _sat_decode_get_input(tlv_origin, tlv_length, temp_index, decoded_tlv);
5297                         break;
5298                 case SAT_PROATV_CMD_MORE_TIME: //6.4.4
5299                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_MORE_TIME");
5300                         rv = _sat_decode_more_time(tlv_origin, tlv_length, temp_index, decoded_tlv);
5301                         break;
5302                 case SAT_PROATV_CMD_PLAY_TONE: //6.4.5
5303                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_PLAY TONE");
5304                         rv = _sat_decode_play_tone(tlv_origin, tlv_length, temp_index, decoded_tlv);
5305                         break;
5306                 //case POLL INTERVAL //6.4.6 processing by cp
5307                 case SAT_PROATV_CMD_REFRESH: //6.4.7
5308                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_REFRESH");
5309                         rv = _sat_decode_refresh(tlv_origin, tlv_length, temp_index, decoded_tlv);
5310                         break;
5311                 case SAT_PROATV_CMD_SETUP_MENU: //6.4.8
5312                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_SETUP_MENU");
5313                         rv = _sat_decode_setup_menu(tlv_origin, tlv_length, temp_index, decoded_tlv);
5314                         break;
5315                 case SAT_PROATV_CMD_SELECT_ITEM: //6.4.9
5316                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SELECT_ITEM");
5317                         rv = _sat_decode_select_item(tlv_origin, tlv_length, temp_index, decoded_tlv);
5318                         break;
5319                 case SAT_PROATV_CMD_SEND_SMS: //6.4.10
5320                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SEND_SMS");
5321                         rv = _sat_decode_send_sms(tlv_origin, tlv_length, temp_index, decoded_tlv);
5322                         break;
5323                 case SAT_PROATV_CMD_SEND_SS: //6.4.11
5324                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SEND_SS");
5325                         rv = _sat_decode_send_ss(tlv_origin, tlv_length, temp_index, decoded_tlv);
5326                         break;
5327                 case SAT_PROATV_CMD_SEND_USSD: //6.4.12
5328                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SEND_USSD");
5329                         rv = _sat_decode_send_ussd(tlv_origin, tlv_length, temp_index, decoded_tlv);
5330                         break;
5331                 case SAT_PROATV_CMD_SETUP_CALL: //6.4.13
5332                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SETUP_CALL");
5333                         rv = _sat_decode_setup_call(tlv_origin, tlv_length, temp_index, decoded_tlv);
5334                         break;
5335                 case SAT_PROATV_CMD_PROVIDE_LOCAL_INFO: //6.4.15
5336                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_PROVIDE_LOCAL_INFO");
5337                         rv = _sat_decode_provide_local_info(tlv_origin, tlv_length, temp_index, decoded_tlv);
5338                         break;
5339                 case SAT_PROATV_CMD_SETUP_EVENT_LIST: //6.4.16
5340                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SETUP_EVENT_LIST");
5341                         rv = _sat_decode_setup_event_list(tlv_origin, tlv_length, temp_index, decoded_tlv);
5342                         break;
5343                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT: //6.4.22
5344                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT");
5345                         rv = _sat_decode_setup_idle_mode_text(tlv_origin, tlv_length, temp_index, decoded_tlv);
5346                         break;
5347                 case SAT_PROATV_CMD_SEND_DTMF: //6.4.24
5348                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_SEND_DTMF");
5349                         rv = _sat_decode_send_dtmf(tlv_origin, tlv_length, temp_index, decoded_tlv);
5350                         break;
5351                 case SAT_PROATV_CMD_LANGUAGE_NOTIFICATION: //6.4.25
5352                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_LANGUAGE_NOTIFICATION");
5353                         rv = _sat_decode_language_notification(tlv_origin, tlv_length, temp_index, decoded_tlv);
5354                         break;
5355                 case SAT_PROATV_CMD_LAUNCH_BROWSER: //6.4.26
5356                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_LAUNCH_BROWSER");
5357                         rv = _sat_decode_launch_browser(tlv_origin, tlv_length, temp_index, decoded_tlv);
5358                         break;
5359                 case SAT_PROATV_CMD_OPEN_CHANNEL://6.4.27
5360                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_OPEN_CHANNEL");
5361                         rv = _sat_decode_open_channel(tlv_origin, tlv_length, temp_index, decoded_tlv);
5362                         break;
5363                 case SAT_PROATV_CMD_CLOSE_CHANNEL://6.4.28
5364                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_CLOSE_CHANNEL");
5365                         rv = _sat_decode_close_channel(tlv_origin, tlv_length, temp_index, decoded_tlv);
5366                         break;
5367                 case SAT_PROATV_CMD_RECEIVE_DATA://6.4.29
5368                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_RECEIVE_DATA");
5369                         rv = _sat_decode_receive_data(tlv_origin, tlv_length, temp_index, decoded_tlv);
5370                         break;
5371                 case SAT_PROATV_CMD_SEND_DATA://6.4.30
5372                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SEND_DATA");
5373                         rv = _sat_decode_send_data(tlv_origin, tlv_length, temp_index, decoded_tlv);
5374                         break;
5375                 case SAT_PROATV_CMD_GET_CHANNEL_STATUS://6.4.31
5376                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_GET_CHANNEL_STATUS");
5377                         rv = _sat_decode_get_channel_status(tlv_origin, tlv_length, temp_index, decoded_tlv);
5378                         break;
5379                 default:
5380                         dbg("[SAT] SAT PARSER - ME cannot perform this command =0x[%02x]", decoded_tlv->cmd_type);
5381                         rv = _sat_decode_unsupported_command(tlv_origin, tlv_length, temp_index, decoded_tlv);
5382                         break;
5383         }
5384
5385         dbg("[SAT] SAT PARSER - each command parsing done.");
5386         return rv;
5387 }
5388
5389 int tcore_sat_decode_call_control_result(unsigned char* tlv_origin, unsigned int tlv_length, struct tnoti_sat_call_control_result_ind* call_ctrl_result_tlv)
5390 {
5391         unsigned int temp_index = 0;
5392         int length = 0, data_len = 0, data_len_consumed = 0;
5393         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
5394
5395         if(tlv_origin == NULL || tlv_length <=2) {
5396                 dbg("[SAT] SAT PARSER - pointer pData passed is NULL or invalid length.");
5397                 return TCORE_SAT_ERROR_FATAL;
5398         }
5399
5400         //call conrol result
5401         call_ctrl_result_tlv->cc_result = tlv_origin[temp_index++];
5402         length = _get_length_filed_size(tlv_origin[temp_index]);
5403         if(length == 0){
5404                 dbg("[SAT] fail to get the call control result length");
5405                 return TCORE_SAT_ERROR_FATAL;
5406         }
5407         temp_index = temp_index+length-1;
5408         data_len = tlv_origin[temp_index];
5409         dbg("[SAT] call control result (%d), data len(%d)",call_ctrl_result_tlv->cc_result, data_len);
5410         if(data_len == 0){
5411                 dbg("no more call control result - decoding done");
5412                 return rv;
5413         }
5414         temp_index++;
5415
5416         //address - optional (voice call)
5417         if((tlv_origin[temp_index]&0x7F) == SATK_ADDRESS_TAG){
5418                 rv = _sat_decode_address_tlv(tlv_origin, tlv_length, temp_index, &call_ctrl_result_tlv->address, &data_len_consumed);
5419                 if(rv != TCORE_SAT_SUCCESS) {
5420                         return rv;
5421                 }
5422                 temp_index+=data_len_consumed;
5423
5424                 if(temp_index >= tlv_length){
5425                         dbg("[SAT] call control decoding done");
5426                         return TCORE_SAT_SUCCESS;
5427                 }
5428         }
5429
5430         //ss string - optional (ss)
5431         if((tlv_origin[temp_index]&0x7F) == SATK_SS_STRING_TAG){
5432                 rv = _sat_decode_ss_string_tlv(tlv_origin, tlv_length, temp_index, &call_ctrl_result_tlv->ss_string, &data_len_consumed);
5433                 if(rv != TCORE_SAT_SUCCESS) {
5434                         return rv;
5435                 }
5436                 temp_index+=data_len_consumed;
5437
5438                 if(temp_index >= tlv_length){
5439                         dbg("[SAT] call control decoding done");
5440                         return TCORE_SAT_SUCCESS;
5441                 }
5442         }
5443
5444         //ccp1 - optional
5445         if((tlv_origin[temp_index]&0x7F)==SATK_CAPABILITY_CONFIGURATION_PARAMETERS_TAG){
5446                 rv =_sat_decode_ccp_tlv(tlv_origin, tlv_length, temp_index, &call_ctrl_result_tlv->ccp1, &data_len_consumed);
5447                 if(rv != TCORE_SAT_SUCCESS){
5448                         return rv; //SEND TR
5449                 }
5450                 temp_index+=data_len_consumed;
5451
5452                 if(temp_index >= tlv_length){
5453                         dbg("[SAT] call control decoding done");
5454                         return TCORE_SAT_SUCCESS;
5455                 }
5456         }
5457
5458         //sub address
5459         if((tlv_origin[temp_index]&0x7F) == SATK_SUB_ADDRESS_TAG){
5460                 rv = _sat_decode_sub_address_tlv(tlv_origin, tlv_length, temp_index, &call_ctrl_result_tlv->sub_address, &data_len_consumed);
5461                 if(rv != TCORE_SAT_SUCCESS) {
5462                         return rv;
5463                 }
5464                 temp_index+=data_len_consumed;
5465
5466                 if(temp_index >= tlv_length){
5467                         dbg("[SAT] call control decoding done");
5468                         return TCORE_SAT_SUCCESS;
5469                 }
5470         }
5471
5472         //alpha id
5473         if((tlv_origin[temp_index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG){
5474                 rv = _sat_decode_alpha_identifier_tlv(tlv_origin, tlv_length, temp_index, &call_ctrl_result_tlv->alpha_id, &data_len_consumed);
5475                 if(rv != TCORE_SAT_SUCCESS) {
5476                         return rv;
5477                 }
5478                 temp_index+=data_len_consumed;
5479
5480                 if(temp_index >= tlv_length){
5481                         dbg("[SAT] call control decoding done");
5482                         return TCORE_SAT_SUCCESS;
5483                 }
5484         }
5485
5486         //bc repeated indicator
5487         if((tlv_origin[temp_index]&0x7F) == SATK_BC_REPEAT_INDICATOR_TAG){
5488                 int tag = 0;
5489                 int bc_repeat_ind_len = 0;
5490
5491                 tag = tlv_origin[temp_index++];
5492                 bc_repeat_ind_len = tlv_origin[temp_index++];
5493                 call_ctrl_result_tlv->bc_repeat_type.bc_indi_repeat_type = tlv_origin[temp_index++];
5494
5495                 dbg("bc repeated indication tag(%x) len(%x) type(%x)", tag, bc_repeat_ind_len, call_ctrl_result_tlv->bc_repeat_type.bc_indi_repeat_type);
5496                 if(temp_index >= tlv_length){
5497                         dbg("[SAT] call control decoding done");
5498                         return TCORE_SAT_SUCCESS;
5499                 }
5500         }
5501
5502         //ccp2
5503         if((tlv_origin[temp_index]&0x7F)==SATK_CAPABILITY_CONFIGURATION_PARAMETERS_TAG){
5504                 rv =_sat_decode_ccp_tlv(tlv_origin, tlv_length, temp_index, &call_ctrl_result_tlv->ccp2, &data_len_consumed);
5505                 if(rv != TCORE_SAT_SUCCESS){
5506                         return rv; //SEND TR
5507                 }
5508                 temp_index+=data_len_consumed;
5509
5510                 if(temp_index >= tlv_length){
5511                         dbg("[SAT] call control decoding done");
5512                         return TCORE_SAT_SUCCESS;
5513                 }
5514         }
5515
5516         return rv;
5517 }
5518
5519 static unsigned char _sat_encode_dcs_tlv(const struct data_coding_scheme* src)
5520 {
5521         unsigned char rv = 0x00;
5522
5523         if(src == NULL)
5524                 return 0;
5525
5526         if(src->is_compressed_format)
5527                 rv |= 0x20;
5528
5529         //msg class
5530         switch(src->m_class){
5531                 case MSG_CLASS_0:
5532                 case MSG_CLASS_1:
5533                 case MSG_CLASS_2:
5534                 case MSG_CLASS_3:
5535                         rv |= 0x10;
5536                         rv |= src->m_class;
5537                 break;
5538
5539                 case MSG_CLASS_RESERVED:
5540                 case MSG_CLASS_NONE:
5541                 default:
5542                         rv &= 0xEF;
5543                         break;
5544         }
5545
5546         //alphabet format
5547         switch(src->a_format)
5548         {
5549                 case ALPHABET_FORMAT_SMS_DEFAULT:
5550                         rv &= 0xF3;
5551                         break;
5552
5553                 case ALPHABET_FORMAT_8BIT_DATA:
5554                         rv |= 0x04;
5555                         break;
5556
5557                 case ALPHABET_FORMAT_UCS2:
5558                         rv |= 0x08;
5559                         break;
5560
5561                 default:
5562                         rv |= 0x0C;
5563                         break;
5564         }
5565
5566         return rv;
5567 }
5568
5569 static int _sat_encode_command_detail_tlv(const struct tel_sat_cmd_detail_info* src, char *dst, int current_temp_index)
5570 {
5571         dst[current_temp_index++] = (b_comprehensive ? (SATK_COMMAND_DETAILS_TAG | 0x80) : SATK_COMMAND_DETAILS_TAG);
5572         dst[current_temp_index++] = SATK_COMMAND_DETAILS_LENGTH;
5573         dst[current_temp_index++] = src->cmd_num;
5574         dst[current_temp_index++] = src->cmd_type;
5575         dst[current_temp_index] = 0x00;
5576
5577         switch(src->cmd_type){
5578                 case SAT_PROATV_CMD_DISPLAY_TEXT:{
5579                         //command detail text priority
5580                         if (src->cmd_qualifier.display_text.text_priority == TEXT_PRIORITY_HIGH)
5581                                 dst[current_temp_index] += 0x01;
5582
5583                         //command detail text clear type
5584                         if (src->cmd_qualifier.display_text.text_clear_type == TEXT_WAIT_FOR_USER_TO_CLEAR_MSG)
5585                                 dst[current_temp_index] += 0x80;
5586                 }break;
5587                 case SAT_PROATV_CMD_GET_INKEY:{
5588                         //command detail alphabet set
5589                         if(src->cmd_qualifier.get_inkey.alphabet_set)
5590                                 dst[current_temp_index] += 0x01;
5591
5592                         //command detail alphabet type
5593                         if(src->cmd_qualifier.get_inkey.alphabet_type == INPUT_ALPHABET_TYPE_UCS2)
5594                                 dst[current_temp_index] += 0x02;
5595
5596                         //command detail get inkey type
5597                         if(src->cmd_qualifier.get_inkey.inkey_type == INKEY_TYPE_YES_NO_REQUESTED)
5598                                 dst[current_temp_index] += 0x04;
5599
5600
5601                         //command detail immediate response required
5602                         if(src->cmd_qualifier.get_inkey.immediate_rsp_required)
5603                                 dst[current_temp_index] += 0x08;
5604
5605                         //command detail help available
5606                         if (src->cmd_qualifier.get_inkey.help_info)
5607                                 dst[current_temp_index] += 0x80;
5608                 }break;
5609                 case SAT_PROATV_CMD_GET_INPUT:{
5610                         //command detail alphabet set
5611                         if(src->cmd_qualifier.get_input.alphabet_set)
5612                                 dst[current_temp_index] += 0x01;
5613
5614                         //command detail alphabet type
5615                         if(src->cmd_qualifier.get_input.alphabet_type == INPUT_ALPHABET_TYPE_UCS2)
5616                                 dst[current_temp_index] += 0x02;
5617
5618                         //command detail echo user input
5619                         if(!src->cmd_qualifier.get_input.me_echo_user_input)
5620                                 dst[current_temp_index] += 0x04;
5621
5622                         //command detail user input unpacked format
5623                         if(!src->cmd_qualifier.get_input.user_input_unpacked_format)
5624                                 dst[current_temp_index] += 0x08;
5625
5626                         //command detail help available
5627                         if (src->cmd_qualifier.get_input.help_info)
5628                                 dst[current_temp_index] += 0x80;
5629                 }break;
5630                 case SAT_PROATV_CMD_MORE_TIME:{
5631                         dbg("more time : 1bit RFU")
5632                 }break;
5633                 case SAT_PROATV_CMD_PLAY_TONE:{
5634                         //command detail vibration alert
5635                         if(src->cmd_qualifier.play_tone.vibration_alert == VIBRATE_ALERT_REQUIRED)
5636                                 dst[current_temp_index] += 0x01;
5637                 }break;
5638                 case SAT_PROATV_CMD_REFRESH:{
5639                         //command detail refresh command
5640                         dst[current_temp_index] += src->cmd_qualifier.refresh.refresh;
5641                 }break;
5642                 case SAT_PROATV_CMD_SETUP_MENU:{
5643                         //command detail preferences
5644                         if (src->cmd_qualifier.setup_menu.select_preference == SELECTION_PREFERENCE_USING_SOFT_KEY)
5645                                 dst[current_temp_index] += 0x01;
5646
5647                         //command detail help available
5648                         if (src->cmd_qualifier.setup_menu.help_info)
5649                                 dst[current_temp_index] += 0x80;
5650                 }break;
5651                 case SAT_PROATV_CMD_SELECT_ITEM:{
5652                         //command detail presentation
5653                         if(src->cmd_qualifier.select_item.presentation_type != PRESENTATION_TYPE_NOT_SPECIFIED){
5654                                 dst[current_temp_index] += 0x01;
5655                                 if(src->cmd_qualifier.select_item.presentation_type == PRESENTATION_TYPE_NAVIGATION_OPTION){
5656                                         dst[current_temp_index] += PRESENTATION_TYPE_NAVIGATION_OPTION;
5657                                 }
5658                         }
5659
5660                         //command detail selection preference
5661                         if(src->cmd_qualifier.select_item.select_preference == SELECTION_PREFERENCE_USING_SOFT_KEY)
5662                                 dst[current_temp_index] += 0x04;
5663
5664                         //command detail help available
5665                         if (src->cmd_qualifier.select_item.help_info)
5666                                 dst[current_temp_index] += 0x80;
5667                 }break;
5668                 case SAT_PROATV_CMD_SEND_SMS:{
5669                         //command detail sms packing by me required
5670                         if(src->cmd_qualifier.send_sms.packing_by_me_required)
5671                                 dst[current_temp_index] += 0x01;
5672                 }break;
5673                 case SAT_PROATV_CMD_SETUP_CALL:{
5674                         //command detail setup call command;
5675                         dst[current_temp_index] += src->cmd_qualifier.setup_call.setup_call;
5676                 }break;
5677                 case SAT_PROATV_CMD_SETUP_EVENT_LIST:{
5678                         dbg("setup evnet list : 1bit RFU")
5679                 }break;
5680                 case SAT_PROATV_CMD_OPEN_CHANNEL:{
5681                         if(src->cmd_qualifier.open_channel.immediate_link)
5682                                 dst[current_temp_index] += 0x01;
5683                         if(src->cmd_qualifier.open_channel.automatic_reconnection)
5684                                 dst[current_temp_index] += 0x02;
5685                         if(src->cmd_qualifier.open_channel.background_mode)
5686                                 dst[current_temp_index] += 0x04;
5687                 }break;
5688                 case SAT_PROATV_CMD_SEND_DATA:{
5689                         if(src->cmd_qualifier.send_data.send_data_immediately)
5690                                 dst[current_temp_index] += 0x01;
5691                 }break;
5692                 case SAT_PROATV_CMD_PROVIDE_LOCAL_INFO:{
5693                         dst[current_temp_index] += src->cmd_qualifier.provide_local_info.provide_local_info;
5694                 }break;
5695                 case SAT_PROATV_CMD_LANGUAGE_NOTIFICATION:{
5696                         if(src->cmd_qualifier.language_notification.specific_language)
5697                                 dst[current_temp_index] += 0x01;
5698                 }break;
5699                 case SAT_PROATV_CMD_LAUNCH_BROWSER:{
5700                                 dst[current_temp_index] += src->cmd_qualifier.launch_browser.launch_browser;
5701                 }break;
5702                 default:
5703                         err("no matched cmd type(%d)", src->cmd_type);
5704                         break;
5705         }
5706
5707         return 5;
5708 }
5709
5710 static int _sat_encode_device_identities_tlv(const struct tel_sat_device_identities* src, char *dst, int current_temp_index)
5711 {
5712         dst[current_temp_index++] = SATK_DEVICE_IDENTITY_TAG;
5713         dst[current_temp_index++] = SATK_DEVICE_IDENTITY_LENGTH;
5714         dst[current_temp_index++] = src->src;
5715         dst[current_temp_index++] = src->dest;
5716
5717         //device identities total len 4
5718         return 4;
5719 }
5720
5721 static int _sat_encode_item_identifier_tlv(const struct tel_sat_item_identifier* src, char *dst, int current_temp_index)
5722 {
5723         dst[current_temp_index++] =SATK_ITEM_IDENTIFIER_TAG;
5724         dst[current_temp_index++] =SATK_ITEM_IDENTIFIER_LENGTH;
5725         dst[current_temp_index++] = src->item_identifier;
5726
5727         //item identifier total len 3
5728         return 3;
5729 }
5730
5731 /*static int _sat_encode_duration_tlv(const struct tel_sat_duration* src, char *dst, int current_temp_index)
5732 {
5733         dst[current_temp_index++] =SATK_DURATION_TAG;
5734         dst[current_temp_index++] =SATK_DURATION_LENGTH;
5735         dst[current_temp_index++] = src->time_unit;
5736         dst[current_temp_index++] = src->time_interval;
5737
5738         //duration total len 4
5739         return 4;
5740 }*/
5741
5742 static int _sat_encode_text_tlv(const struct tel_sat_text_string_object* src, char *dst, int current_temp_index, gboolean raw_dcs)
5743 {
5744         int total_len = 0;
5745         int length_temp_index = 0;
5746
5747         //tag
5748         dst[current_temp_index++] =SATK_TEXT_STRING_TAG;
5749
5750         //length
5751         if(src->string_length <= 0x7F){
5752                 dst[current_temp_index++] =SATK_DCS_LENGTH+src->string_length;
5753                 length_temp_index = 1;
5754         }
5755         else{
5756                 dst[current_temp_index++] = 0x81;
5757                 dst[current_temp_index++] =SATK_DCS_LENGTH+src->string_length;
5758                 length_temp_index = 2;
5759         }
5760
5761         //dcs
5762         if(raw_dcs)
5763                 dst[current_temp_index++] = src->dcs.raw_dcs;
5764         else
5765                 dst[current_temp_index++] =_sat_encode_dcs_tlv(&(src->dcs));
5766
5767         //value
5768         if(src->string_length > 0){
5769                 memcpy(&(dst[current_temp_index]), src->string, src->string_length);
5770         }
5771
5772         //tag+temp_index+dcs+data
5773         total_len = 1+length_temp_index+1+src->string_length;
5774
5775         return total_len;
5776 }
5777
5778 static int _sat_encode_eventlist_tlv(const enum event_list src, char *dst, int current_temp_index)
5779 {
5780         dst[current_temp_index++] =SATK_EVENT_LIST_TAG;
5781         dst[current_temp_index++] =0x01;
5782         dst[current_temp_index++] =src;
5783
5784         return 3;
5785 }
5786
5787 static int _sat_encode_date_time_and_timezone_tlv(const struct tel_sat_date_time_and_timezone *src, char *dst, int current_temp_index)
5788 {
5789         dst[current_temp_index++] = SATK_DATE_TIME_AND_TIME_ZONE_TAG;
5790         dst[current_temp_index++] = SATK_DATE_TIME_AND_TIME_ZONE_LENGTH;
5791         dst[current_temp_index++] = src->year;
5792         dst[current_temp_index++] = src->month;
5793         dst[current_temp_index++] = src->day;
5794         dst[current_temp_index++] = src->hour;
5795         dst[current_temp_index++] = src->minute;
5796         dst[current_temp_index++] = src->second;
5797         dst[current_temp_index++] = src->timeZone;
5798
5799         return 1+1+SATK_DATE_TIME_AND_TIME_ZONE_LENGTH; //tag length+len field length+value length;
5800 }
5801
5802 static int _sat_encode_language_tlv(const enum tel_sim_language_type src, char *dst, int current_temp_index)
5803 {
5804         dst[current_temp_index++] =SATK_LANGUAGE_TAG;
5805         dst[current_temp_index++] =SATK_LANGUAGE_LENGTH;
5806
5807         dbg("language (%d)", src);
5808
5809         switch(src){
5810
5811                 case SIM_LANG_GERMAN :
5812                         dst[current_temp_index++] = 'd';
5813                         dst[current_temp_index++] = 'e';
5814                         break;
5815
5816                 case SIM_LANG_ENGLISH :
5817                         dst[current_temp_index++] = 'e';
5818                         dst[current_temp_index++] = 'n';
5819                         break;
5820
5821                 case SIM_LANG_ITALIAN :
5822                         dst[current_temp_index++] = 'i';
5823                         dst[current_temp_index++] = 't';
5824                         break;
5825
5826                 case SIM_LANG_FRENCH :
5827                         dst[current_temp_index++] = 'f';
5828                         dst[current_temp_index++] = 'r';
5829                         break;
5830
5831                 case SIM_LANG_SPANISH :
5832                         dst[current_temp_index++] = 'e';
5833                         dst[current_temp_index++] = 's';
5834                         break;
5835
5836                 case SIM_LANG_DUTCH :
5837                         dst[current_temp_index++] = 'n';
5838                         dst[current_temp_index++] = 'l';
5839                         break;
5840
5841                 case SIM_LANG_SWEDISH :
5842                         dst[current_temp_index++] = 's';
5843                         dst[current_temp_index++] = 'v';
5844                         break;
5845
5846                 case SIM_LANG_DANISH :
5847                         dst[current_temp_index++] = 'd';
5848                         dst[current_temp_index++] = 'a';
5849                         break;
5850
5851                 case SIM_LANG_PORTUGUESE :
5852                         dst[current_temp_index++] = 'p';
5853                         dst[current_temp_index++] = 't';
5854                         break;
5855
5856                 case SIM_LANG_FINNISH :
5857                         dst[current_temp_index++] = 'f';
5858                         dst[current_temp_index++] = 'i';
5859                         break;
5860
5861                 case SIM_LANG_NORWEGIAN :
5862                         dst[current_temp_index++] = 'n';
5863                         dst[current_temp_index++] = 'b';
5864                         break;
5865
5866                 case SIM_LANG_GREEK :
5867                         dst[current_temp_index++] = 'e';
5868                         dst[current_temp_index++] = 'l';
5869                         break;
5870
5871                 case SIM_LANG_TURKISH :
5872                         dst[current_temp_index++] = 't';
5873                         dst[current_temp_index++] = 'k';
5874                         break;
5875
5876                 case SIM_LANG_HUNGARIAN :
5877                         dst[current_temp_index++] = 'h';
5878                         dst[current_temp_index++] = 'u';
5879                         break;
5880
5881                 case SIM_LANG_POLISH :
5882                         dst[current_temp_index++] = 'p';
5883                         dst[current_temp_index++] = 'l';
5884                         break;
5885
5886                 case SIM_LANG_KOREAN :
5887                         dst[current_temp_index++] = 'k';
5888                         dst[current_temp_index++] = 'o';
5889                         break;
5890
5891                 case SIM_LANG_CHINESE :
5892                         dst[current_temp_index++] = 'z';
5893                         dst[current_temp_index++] = 'h';
5894                         break;
5895
5896                 case SIM_LANG_RUSSIAN :
5897                         dst[current_temp_index++] = 'r';
5898                         dst[current_temp_index++] = 'u';
5899                         break;
5900
5901                 case SIM_LANG_JAPANESE:
5902                         dst[current_temp_index++] = 'j';
5903                         dst[current_temp_index++] = 'a';
5904                         break;
5905
5906                 default:{
5907                         dst[current_temp_index++] = 'e';
5908                         dst[current_temp_index++] = 'n';
5909                         dbg("[SAT] SAT PARSER - Unknown Language: 0x%x",src);
5910                         break;
5911                 }
5912         }
5913         return 4;
5914 }
5915
5916 static int _sat_encode_browser_termination_tlv(const enum browser_termination_cause src, char *dst, int current_temp_index)
5917 {
5918         dst[current_temp_index++] =SATK_BROWSER_TERMINATION_CAUSE_TAG;
5919         dst[current_temp_index++] =SATK_BROWSER_TERMINATION_CAUSE_LENGTH;
5920         dst[current_temp_index++] =src;
5921
5922         return 3;
5923 }
5924 #if 0
5925 static int _sat_encode_bearer_desc_tlv(const struct tel_sat_bearer_description* src, char *dst, int current_temp_index)
5926 {
5927         int total_len = 0;
5928         int length_temp_index = 0;
5929
5930         dst[current_temp_index++] =SATK_BEARER_DISCRIPTION_TAG;
5931
5932         //length temp_index
5933         length_temp_index = current_temp_index++;
5934
5935         //bearer type
5936         dst[current_temp_index++] = src->bearer_type;
5937
5938         switch(src->bearer_type){
5939                 case BEARER_CSD:{
5940                         dst[current_temp_index++] = src->bearer_parameter.cs_bearer_param.data_rate;
5941                         dst[current_temp_index++] = src->bearer_parameter.cs_bearer_param.service_type;
5942                         dst[current_temp_index++] = src->bearer_parameter.cs_bearer_param.connection_element_type;
5943                 }break;
5944                 case BEARER_GPRS:{
5945                         dst[current_temp_index++] = src->bearer_parameter.ps_bearer_param.precedence_class;
5946                         dst[current_temp_index++] = src->bearer_parameter.ps_bearer_param.delay_class;
5947                         dst[current_temp_index++] = src->bearer_parameter.ps_bearer_param.reliability_class;
5948                         dst[current_temp_index++] = src->bearer_parameter.ps_bearer_param.peak_throughput_class;
5949                         dst[current_temp_index++] = src->bearer_parameter.ps_bearer_param.mean_throughput_class;
5950                         dst[current_temp_index++] = src->bearer_parameter.ps_bearer_param.pdp_type;
5951                 }break;
5952                 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:
5953                 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:
5954                 default:
5955                 break;
5956         }
5957
5958         dst[length_temp_index] = (current_temp_index-1) - length_temp_index;
5959         total_len = (current_temp_index-1) - length_temp_index + 2; //tag and length
5960
5961         return total_len;
5962 }
5963
5964 static int _sat_encode_buffer_size_tlv(const struct tel_sat_buffer_size* src, char *dst, int current_temp_index)
5965 {
5966         dst[current_temp_index++] = SATK_BUFFER_SIZE_TAG;
5967         dst[current_temp_index++] = SATK_BUFFER_SIZE_LENGTH;
5968         dst[current_temp_index++] = src->size[0];
5969         dst[current_temp_index++] = src->size[1];
5970
5971         return 4;
5972 }
5973 #endif
5974 static int _sat_encode_channel_data_tlv(const struct tel_sat_channel_data* src, char *dst, int current_temp_index)
5975 {
5976         int total_len = 0;
5977         int length_temp_index = 0;
5978
5979         dst[current_temp_index++] = SATK_CHANNEL_DATA_TAG;
5980
5981         if(src->data_string_len <= 0x7F){
5982                 dst[current_temp_index++] = src->data_string_len;
5983                 length_temp_index = 1;
5984         }
5985         else{
5986                 dst[current_temp_index++] = 0x81;
5987                 dst[current_temp_index++] = src->data_string_len;
5988                 length_temp_index = 2;
5989         }
5990
5991         memcpy(&(dst[current_temp_index]), src->data_string, src->data_string_len);
5992
5993         total_len = 1+length_temp_index+src->data_string_len;
5994
5995         return total_len;
5996 }
5997
5998 static int _sat_encode_channel_data_length_tlv(const struct tel_sat_channel_data_len* src, char *dst, int current_temp_index)
5999 {
6000         dst[current_temp_index++] = SATK_CHANNEL_DATA_LEN_TAG;
6001         dst[current_temp_index++] = SATK_CHANNEL_DATA_LENGTH_VALUE_LENGTH;
6002         dst[current_temp_index++] = src->data_len;
6003
6004         return 3;
6005 }
6006
6007 static int _sat_encode_channel_status_tlv(const struct tel_sat_channel_status* src, char *dst, int current_temp_index)
6008 {
6009         dst[current_temp_index++] = SATK_CHANNEL_STATUS_TAG;
6010         dst[current_temp_index++] = SATK_CHANNEL_STATUS_LENGTH;
6011
6012         if(src->status == link_or_packet_service_activated) //(bit 8)
6013                 dst[current_temp_index] += 0x80;
6014
6015         dst[current_temp_index++] += src->channel_id; //(bit 1~3)
6016         dst[current_temp_index++] = src->status_info;
6017
6018         return 4;
6019 }
6020
6021 static int _sat_encode_download_event(const struct tel_sat_envelop_event_download_tlv *evt_dl, char *dst_envelop)
6022 {
6023         int temp_index = 2;
6024         int encoded_len = 0;
6025
6026         dbg("event type(%d)", evt_dl->event);
6027
6028         //event list
6029         encoded_len = _sat_encode_eventlist_tlv(evt_dl->event, dst_envelop, temp_index);
6030         temp_index += encoded_len;
6031
6032         //device id - len 4
6033         encoded_len =_sat_encode_device_identities_tlv(&(evt_dl->device_identitie), dst_envelop, temp_index);
6034         temp_index += encoded_len;
6035
6036         switch(evt_dl->event){
6037                 case EVENT_LANGUAGE_SELECTION:
6038                         encoded_len = _sat_encode_language_tlv(evt_dl->language, dst_envelop, temp_index);
6039                         temp_index += encoded_len;
6040                         break;
6041                 case EVENT_BROWSER_TERMINATION:
6042                         encoded_len = _sat_encode_browser_termination_tlv(evt_dl->browser_termination, dst_envelop, temp_index);
6043                         temp_index += encoded_len;
6044                         break;
6045                 case EVENT_DATA_AVAILABLE:
6046                         encoded_len = _sat_encode_channel_status_tlv(&(evt_dl->channel_status), dst_envelop, temp_index);
6047                         temp_index += encoded_len;
6048
6049                         encoded_len = _sat_encode_channel_data_length_tlv(&(evt_dl->channel_data_len), dst_envelop, temp_index);
6050                         temp_index += encoded_len;
6051                         break;
6052                 case EVENT_CHANNEL_STATUS:
6053                         encoded_len = _sat_encode_channel_status_tlv(&(evt_dl->channel_status), dst_envelop, temp_index);
6054                         temp_index += encoded_len;
6055                         break;
6056                 default:
6057                         break;
6058         }
6059
6060         dst_envelop[0] = SATK_EVENT_DOWNLOAD_TAG;
6061         dst_envelop[1] = temp_index-2;
6062
6063         dbg("download envelop cmd len(%d)", temp_index);
6064
6065         if(temp_index-2 > 0x7F){
6066                 int idx = 0;
6067                 for(idx = temp_index; idx > 0; idx--){
6068                         dst_envelop[idx] = dst_envelop[idx+1];
6069                 }
6070                 dst_envelop[1] = 0x81;
6071                 temp_index += 1;
6072                 dbg("download envelop added cmd len(%d)", temp_index);
6073         }
6074
6075         return temp_index;
6076 }
6077
6078 int tcore_sat_encode_envelop_cmd(const struct treq_sat_envelop_cmd_data *src_envelop, char *dst_envelop)
6079 {
6080         int temp_index = 0, encoded_len= 0;
6081
6082         if(!dst_envelop)
6083                 return 0;
6084
6085         if(src_envelop->sub_cmd == ENVELOP_MENU_SELECTION){
6086                 temp_index = 2; //set the cursor to device identity
6087                 dbg("item id(%d)", src_envelop->envelop_data.menu_select.item_identifier.item_identifier);
6088                 encoded_len =_sat_encode_device_identities_tlv(&(src_envelop->envelop_data.menu_select.device_identitie), dst_envelop, temp_index);
6089                 temp_index += encoded_len;
6090
6091                 //item identifier
6092                 encoded_len = _sat_encode_item_identifier_tlv(&(src_envelop->envelop_data.menu_select.item_identifier), dst_envelop, temp_index);
6093                 temp_index += encoded_len;
6094
6095                 if(src_envelop->envelop_data.menu_select.help_request){
6096                         encoded_len = 2;//help request
6097                         dst_envelop[temp_index++] = SATK_HELP_REQUEST_TAG;
6098                         dst_envelop[temp_index++] = SATK_HELP_REQUEST_LENGTH;
6099                 }
6100
6101                 dbg("menu selection cmd len(%d)", temp_index);
6102
6103                 //main cmd
6104                 dst_envelop[0] = SATK_MENU_SELECTION_TAG;
6105                 dst_envelop[1] = temp_index-2;
6106         }
6107         else if(src_envelop->sub_cmd == ENVELOP_EVENT_DOWNLOAD){
6108                 temp_index = _sat_encode_download_event(&(src_envelop->envelop_data.event_download),dst_envelop);
6109         }
6110
6111         return temp_index;
6112 }
6113
6114
6115
6116 static int _sat_encode_display_text(const struct tel_sat_tr_display_text_tlv *src_tr, char *dst_tr)
6117 {
6118         int temp_index = 0, encoded_len = 0;
6119
6120         //set command detail info
6121         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6122         temp_index += encoded_len;
6123
6124         //set device identities info
6125         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6126         temp_index += encoded_len;
6127
6128         //set result info
6129         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);
6130         switch(src_tr->result_type){
6131                 case RESULT_SUCCESS:
6132                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6133                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6134                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6135                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6136                 case RESULT_BACKWARD_MOVE_BY_USER:
6137                 case RESULT_NO_RESPONSE_FROM_USER:
6138                 case RESULT_BEYOND_ME_CAPABILITIES:
6139                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6140                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6141                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6142                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6143                         dst_tr[temp_index++] = 1;
6144                         dst_tr[temp_index++] = src_tr->result_type;
6145                         break;
6146                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6147                 case RESULT_FRAMES_ERROR:
6148                         dst_tr[temp_index++] = 2;
6149                         dst_tr[temp_index++] = src_tr->result_type;
6150                         dst_tr[temp_index++] = src_tr->me_problem_type;
6151                         break;
6152                 default:
6153                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6154                         temp_index = 0;
6155                         break;
6156         }
6157
6158         return temp_index;
6159 }
6160
6161 static int _sat_encode_get_inkey(const struct tel_sat_tr_get_inkey_tlv *src_tr, char *dst_tr)
6162 {
6163         int temp_index = 0, encoded_len = 0;
6164
6165         //set command detail info
6166         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6167         temp_index += encoded_len;
6168
6169         //set device identities info
6170         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6171         temp_index += encoded_len;
6172
6173         //set result info
6174         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6175
6176         switch(src_tr->result_type){
6177                 case RESULT_SUCCESS:
6178                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6179                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6180                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6181                         dst_tr[temp_index++] = 1;
6182                         dst_tr[temp_index++] = src_tr->result_type;
6183
6184                         encoded_len = _sat_encode_text_tlv(&(src_tr->text), dst_tr, temp_index, FALSE);
6185                         temp_index += encoded_len;
6186                         break;
6187                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6188                 case RESULT_BACKWARD_MOVE_BY_USER:
6189                 case RESULT_HELP_INFO_REQUIRED_BY_USER:
6190                 case RESULT_BEYOND_ME_CAPABILITIES:
6191                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6192                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6193                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6194                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6195                 case RESULT_NO_RESPONSE_FROM_USER:
6196                         dst_tr[temp_index++] = 1;
6197                         dst_tr[temp_index++] = src_tr->result_type;
6198                         break;
6199                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6200                 case RESULT_FRAMES_ERROR:
6201                         dst_tr[temp_index++] = 2;
6202                         dst_tr[temp_index++] = src_tr->result_type;
6203                         dst_tr[temp_index++] = src_tr->me_problem_type;
6204                         break;
6205                 default:
6206                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6207                         temp_index = 0;
6208                         break;
6209         }
6210
6211         return temp_index;
6212 }
6213
6214 static int _sat_encode_get_input(const struct tel_sat_tr_get_input_tlv *src_tr, char *dst_tr)
6215 {
6216         int temp_index = 0, encoded_len = 0;
6217
6218         //set command detail info
6219         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6220         temp_index += encoded_len;
6221
6222         //set device identities info
6223         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6224         temp_index += encoded_len;
6225
6226         //set result info
6227         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6228
6229         switch(src_tr->result_type){
6230                 case RESULT_SUCCESS:
6231                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6232                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6233                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6234                         dst_tr[temp_index++] = 1;
6235                         dst_tr[temp_index++] = src_tr->result_type;
6236
6237                         encoded_len = _sat_encode_text_tlv(&(src_tr->text), dst_tr, temp_index, FALSE);
6238                         temp_index += encoded_len;
6239                         break;
6240                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6241                 case RESULT_BACKWARD_MOVE_BY_USER:
6242                 case RESULT_NO_RESPONSE_FROM_USER:
6243                 case RESULT_HELP_INFO_REQUIRED_BY_USER:
6244                 case RESULT_BEYOND_ME_CAPABILITIES:
6245                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6246                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6247                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6248                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6249                         dst_tr[temp_index++] = 1;
6250                         dst_tr[temp_index++] = src_tr->result_type;
6251                         break;
6252                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6253                 case RESULT_FRAMES_ERROR:
6254                         dst_tr[temp_index++] = 2;
6255                         dst_tr[temp_index++] = src_tr->result_type;
6256                         dst_tr[temp_index++] = src_tr->me_problem_type;
6257                         break;
6258                 default:
6259                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6260                         temp_index =0;
6261                         break;
6262         }
6263
6264         return temp_index;
6265 }
6266
6267 static int _sat_encode_more_time(const struct tel_sat_tr_more_time_tlv *src_tr, char *dst_tr)
6268 {
6269         int temp_index = 0, encoded_len = 0;
6270
6271         //set command detail info
6272         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6273         temp_index += encoded_len;
6274
6275         //set device identities info
6276         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6277         temp_index += encoded_len;
6278
6279         //set result info
6280         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6281
6282         switch(src_tr->result_type){
6283                 case RESULT_SUCCESS:
6284                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6285                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6286                 case RESULT_BEYOND_ME_CAPABILITIES:
6287                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6288                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6289                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6290                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6291                         dst_tr[temp_index++] = 1;
6292                         dst_tr[temp_index++] = src_tr->result_type;
6293                         break;
6294                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6295                         dst_tr[temp_index++] = 2;
6296                         dst_tr[temp_index++] = src_tr->result_type;
6297                         dst_tr[temp_index++] = src_tr->me_problem_type;
6298                         break;
6299                 default:
6300                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6301                         temp_index = 0;
6302                         break;
6303         }
6304
6305         return temp_index;
6306 }
6307
6308 static int _sat_encode_play_tone(const struct tel_sat_tr_play_tone_tlv *src_tr, char *dst_tr)
6309 {
6310         int temp_index = 0, encoded_len = 0;
6311
6312         //set command detail info
6313         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6314         temp_index += encoded_len;
6315
6316         //set device identities info
6317         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6318         temp_index += encoded_len;
6319
6320         //set result info
6321         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6322
6323         switch(src_tr->result_type){
6324                 case RESULT_SUCCESS:
6325                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6326                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6327                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6328                 case RESULT_SUCCESS_BUT_TONE_NOT_PLAYED:
6329                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6330                 case RESULT_BEYOND_ME_CAPABILITIES:
6331                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6332                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6333                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6334                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6335                         dst_tr[temp_index++] = 1;
6336                         dst_tr[temp_index++] = src_tr->result_type;
6337                         break;
6338                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6339                 case RESULT_FRAMES_ERROR:
6340                         dst_tr[temp_index++] = 2;
6341                         dst_tr[temp_index++] = src_tr->result_type;
6342                         dst_tr[temp_index++] = src_tr->me_problem_type;
6343                         break;
6344                 default:
6345                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6346                         temp_index = 0;
6347                         break;
6348         }
6349
6350         return temp_index;
6351 }
6352
6353 static int _sat_encode_refresh(const struct tel_sat_tr_refresh_tlv *src_tr, char *dst_tr)
6354 {
6355         int temp_index = 0, encoded_len = 0;
6356
6357         //set command detail info
6358         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6359         temp_index += encoded_len;
6360
6361         //set device identities info
6362         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6363         temp_index += encoded_len;
6364
6365         //set result info
6366         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6367
6368         switch(src_tr->result_type){
6369                 case RESULT_SUCCESS:
6370                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6371                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6372                 case RESULT_REFRESH_PERFORMED_WITH_ADDITIONAL_EFS_READ:
6373                 case RESULT_REFRESH_PRFRMD_BUT_INDICATED_USIM_NOT_ACTIVE:
6374                 case RESULT_BEYOND_ME_CAPABILITIES:
6375                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6376                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6377                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6378                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6379                         dst_tr[temp_index++] = 1;
6380                         dst_tr[temp_index++] = src_tr->result_type;
6381                         break;
6382                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6383                         dst_tr[temp_index++] = 2;
6384                         dst_tr[temp_index++] = src_tr->result_type;
6385                         dst_tr[temp_index++] = src_tr->me_problem_type;
6386                         break;
6387                 default:
6388                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6389                         temp_index = 0;
6390                         break;
6391         }
6392
6393         return temp_index;
6394 }
6395
6396 static int _sat_encode_setup_menu(const struct tel_sat_tr_setup_menu_tlv *src_tr, char *dst_tr)
6397 {
6398         int temp_index = 0, encoded_len = 0;
6399
6400         //set command detail info
6401         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6402         temp_index += encoded_len;
6403
6404         //set device identities info
6405         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6406         temp_index += encoded_len;
6407
6408         //set result info
6409         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6410         switch(src_tr->result_type){
6411                 case RESULT_SUCCESS:
6412                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6413                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6414                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6415                 case RESULT_BEYOND_ME_CAPABILITIES:
6416                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6417                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6418                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6419                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6420                         dst_tr[temp_index++] = 1;
6421                         dst_tr[temp_index++] = src_tr->result_type;
6422                         break;
6423                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6424                         dst_tr[temp_index++] = 2;
6425                         dst_tr[temp_index++] = src_tr->result_type;
6426                         dst_tr[temp_index++] = src_tr->me_problem_type;
6427                         break;
6428                 default:
6429                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6430                         temp_index = 0;
6431                         break;
6432         }
6433
6434         return temp_index;
6435 }
6436
6437 static int _sat_encode_select_item(const struct tel_sat_tr_select_item_tlv *src_tr, char *dst_tr)
6438 {
6439         int temp_index = 0, encoded_len = 0;
6440
6441         //set command detail info
6442         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6443         temp_index += encoded_len;
6444
6445         //set device identities info
6446         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6447         temp_index += encoded_len;
6448
6449         //set result info
6450         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6451
6452         switch(src_tr->result_type){
6453                 case RESULT_SUCCESS:
6454                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6455                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6456                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6457                 case RESULT_HELP_INFO_REQUIRED_BY_USER:
6458                         dst_tr[temp_index++] = 1;
6459                         dst_tr[temp_index++] = src_tr->result_type;
6460                         encoded_len = _sat_encode_item_identifier_tlv(&(src_tr->item_identifier), dst_tr, temp_index);
6461                         temp_index += encoded_len;
6462                         break;
6463                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6464                 case RESULT_BACKWARD_MOVE_BY_USER:
6465                 case RESULT_NO_RESPONSE_FROM_USER:
6466                 case RESULT_BEYOND_ME_CAPABILITIES:
6467                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6468                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6469                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6470                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6471                         dst_tr[temp_index++] = 1;
6472                         dst_tr[temp_index++] = src_tr->result_type;
6473                         break;
6474                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6475                 case RESULT_FRAMES_ERROR:
6476                         dst_tr[temp_index++] = 2;
6477                         dst_tr[temp_index++] = src_tr->result_type;
6478                         dst_tr[temp_index++] = src_tr->me_problem_type;
6479                         break;
6480                 default:
6481                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6482                         temp_index = 0;
6483                         break;
6484         }
6485
6486         return temp_index;
6487 }
6488
6489 static int _sat_encode_send_sms(const struct tel_sat_tr_send_sms_tlv *src_tr, char *dst_tr)
6490 {
6491         int temp_index = 0, encoded_len = 0;
6492
6493         //set command detail info
6494         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6495         temp_index += encoded_len;
6496
6497         //set device identities info
6498         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6499         temp_index += encoded_len;
6500
6501         //set result info
6502         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6503
6504         switch(src_tr->result_type){
6505                 case RESULT_SUCCESS:
6506                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6507                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6508                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6509                         dst_tr[temp_index++] = 1;
6510                         dst_tr[temp_index++] = src_tr->result_type;
6511                         break;
6512                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6513                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6514                 case RESULT_BEYOND_ME_CAPABILITIES:
6515                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6516                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6517                 case RESULT_SMS_RP_ERROR:
6518                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6519                         dst_tr[temp_index++] = 2;
6520                         dst_tr[temp_index++] = src_tr->result_type;
6521                         dst_tr[temp_index++] = src_tr->me_problem_type;
6522                         break;
6523                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
6524                         dst_tr[temp_index++] = 2;
6525                         dst_tr[temp_index++] = src_tr->result_type;
6526                         dst_tr[temp_index++] = src_tr->cc_problem_type;
6527                         break;
6528                 default:
6529                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6530                         temp_index = 0;
6531                         break;
6532         }
6533
6534         return temp_index;
6535 }
6536
6537 static int _sat_encode_send_ss(const struct tel_sat_tr_send_ss_tlv *src_tr, char *dst_tr)
6538 {
6539         int temp_index = 0, encoded_len = 0;
6540
6541         //set command detail info
6542         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6543         temp_index += encoded_len;
6544
6545         //set device identities info
6546         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6547         temp_index += encoded_len;
6548
6549         //set result info
6550         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6551
6552         switch(src_tr->result_type){
6553                 case RESULT_SUCCESS:
6554                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6555                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6556                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6557                 case RESULT_SUCCESS_BUT_MODIFIED_BY_CALL_CONTROL_BY_SIM:
6558                 case RESULT_USSD_OR_SS_TRANSACTION_TERMINATED_BY_USER:
6559                         dst_tr[temp_index++] = 1+src_tr->text.string_length;
6560                         dst_tr[temp_index++] = src_tr->result_type;
6561
6562                         memcpy(&(dst_tr[temp_index]), src_tr->text.string, src_tr->text.string_length);
6563                         encoded_len = src_tr->text.string_length;
6564                         temp_index += encoded_len;
6565                         break;
6566                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6567                         dst_tr[temp_index++] = 1;
6568                         dst_tr[temp_index++] = src_tr->result_type;
6569                         break;
6570                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6571                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6572                         dst_tr[temp_index++] = 2;
6573                         dst_tr[temp_index++] = src_tr->result_type;
6574                         dst_tr[temp_index++] = src_tr->me_problem_type;
6575                         break;
6576                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
6577                         dst_tr[temp_index++] = 2;
6578                         dst_tr[temp_index++] = src_tr->result_type;
6579                         dst_tr[temp_index++] = src_tr->cc_problem_type;
6580                         break;
6581                 case RESULT_SS_RETURN_ERROR:
6582                         dst_tr[temp_index++] = 2;
6583                         dst_tr[temp_index++] = src_tr->result_type;
6584                         dst_tr[temp_index++] = src_tr->ss_problem;
6585                         break;
6586                 case RESULT_BEYOND_ME_CAPABILITIES:
6587                         dst_tr[temp_index++] = 1;
6588                         dst_tr[temp_index++] = src_tr->result_type;
6589                         break;
6590                 default:
6591                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6592                         temp_index = 0;
6593                         break;
6594         }
6595
6596         return temp_index;
6597 }
6598
6599 static int _sat_encode_send_ussd(const struct tel_sat_tr_send_ussd_tlv *src_tr, char *dst_tr)
6600 {
6601         int temp_index = 0, encoded_len = 0;
6602
6603         //set command detail info
6604         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6605         temp_index += encoded_len;
6606
6607         //set device identities info
6608         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6609         temp_index += encoded_len;
6610
6611         //set result info
6612         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6613
6614         switch(src_tr->result_type){
6615                 case RESULT_SUCCESS:
6616                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6617                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6618                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6619                 case RESULT_SUCCESS_BUT_MODIFIED_BY_CALL_CONTROL_BY_SIM:
6620                 case RESULT_USSD_OR_SS_TRANSACTION_TERMINATED_BY_USER:
6621                         dst_tr[temp_index++] = 1;
6622                         dst_tr[temp_index++] = src_tr->result_type;
6623
6624                         encoded_len = _sat_encode_text_tlv(&(src_tr->text), dst_tr, temp_index, TRUE);
6625                         temp_index += encoded_len;
6626                         break;
6627                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6628                 case RESULT_BEYOND_ME_CAPABILITIES:
6629                         dst_tr[temp_index++] = 1;
6630                         dst_tr[temp_index++] = src_tr->result_type;
6631                         break;
6632                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6633                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6634                         dst_tr[temp_index++] = 2;
6635                         dst_tr[temp_index++] = src_tr->result_type;
6636                         dst_tr[temp_index++] = src_tr->me_problem_type;
6637                         break;
6638                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
6639                         dst_tr[temp_index++] = 2;
6640                         dst_tr[temp_index++] = src_tr->result_type;
6641                         dst_tr[temp_index++] = src_tr->cc_problem_type;
6642                         break;
6643                 case RESULT_USSD_RETURN_ERROR:
6644                         dst_tr[temp_index++] = 2;
6645                         dst_tr[temp_index++] = src_tr->result_type;
6646                         dst_tr[temp_index++] = src_tr->ussd_problem;
6647                         break;
6648                 default:
6649                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6650                         temp_index = 0;
6651                         break;
6652         }
6653
6654         return temp_index;
6655 }
6656
6657 static int _sat_encode_setup_call(const struct tel_sat_tr_setup_call_tlv *src_tr, char *dst_tr)
6658 {
6659         int temp_index = 0, encoded_len = 0;
6660
6661         //set command detail info
6662         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6663         temp_index += encoded_len;
6664
6665         //set device identities info
6666         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6667         temp_index += encoded_len;
6668
6669         //set result info
6670         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6671
6672         switch(src_tr->result_type){
6673                 case RESULT_SUCCESS:
6674                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6675                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6676                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6677                 case RESULT_SUCCESS_BUT_MODIFIED_BY_CALL_CONTROL_BY_SIM:
6678                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6679                 case RESULT_BEYOND_ME_CAPABILITIES:
6680                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6681                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6682                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6683                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6684                 case RESULT_SS_RETURN_ERROR:
6685                         dst_tr[temp_index++] = 1;
6686                         dst_tr[temp_index++] = src_tr->result_type;
6687                         break;
6688                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6689                 case RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ:
6690                 case RESULT_USER_CLEAR_DOWN_CALL_BEFORE_CONN:
6691                 case RESULT_FRAMES_ERROR:
6692                         dst_tr[temp_index++] = 2;
6693                         dst_tr[temp_index++] = src_tr->result_type;
6694                         dst_tr[temp_index++] = src_tr->me_problem_type;
6695                         break;
6696                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6697                         dst_tr[temp_index++] = 2;
6698                         dst_tr[temp_index++] = src_tr->result_type;
6699                         dst_tr[temp_index++] = src_tr->network_problem_type;
6700                         break;
6701                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
6702                         dst_tr[temp_index++] = 2;
6703                         dst_tr[temp_index++] = src_tr->result_type;
6704                         dst_tr[temp_index++] = src_tr->cc_problem_type;
6705                         break;
6706                 default:
6707                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6708                         temp_index = 0;
6709                         break;
6710         }
6711
6712         return temp_index;
6713 }
6714
6715 static int _sat_encode_provide_local_info(const struct tel_sat_tr_provide_local_info_tlv *src_tr, char *dst_tr)
6716 {
6717         int temp_index = 0, encoded_len = 0;
6718
6719         //set command detail info
6720         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6721         temp_index += encoded_len;
6722
6723         //set device identities info
6724         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6725         temp_index += encoded_len;
6726
6727         //set result info
6728         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6729         switch(src_tr->result_type){
6730                 case RESULT_SUCCESS:
6731                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6732                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6733                 case RESULT_SUCCESS_LIMITED_SERVICE:
6734                         dst_tr[temp_index++] = 1;
6735                         dst_tr[temp_index++] = src_tr->result_type;
6736                         switch(src_tr->command_detail.cmd_qualifier.provide_local_info.provide_local_info){
6737                                 case LOCAL_INFO_DATE_TIME_AND_TIMEZONE:
6738                                         encoded_len = _sat_encode_date_time_and_timezone_tlv(&(src_tr->other.date_time_and_timezone), dst_tr, temp_index);
6739                                         break;
6740                                 case LOCAL_INFO_LANGUAGE:
6741                                         encoded_len = _sat_encode_language_tlv(src_tr->other.language, dst_tr, temp_index);
6742                                         break;
6743                                 default:
6744                                         dbg("local info type[%d] is not handled", src_tr->command_detail.cmd_qualifier.provide_local_info.provide_local_info);
6745                                         break;
6746                         }
6747                         temp_index += encoded_len;
6748                         break;
6749                 case RESULT_BEYOND_ME_CAPABILITIES:
6750                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6751                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6752                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6753                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6754                         dst_tr[temp_index++] = 1;
6755                         dst_tr[temp_index++] = src_tr->result_type;
6756                         break;
6757                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6758                         dst_tr[temp_index++] = 2;
6759                         dst_tr[temp_index++] = src_tr->result_type;
6760                         dst_tr[temp_index++] = src_tr->me_problem_type;
6761                         break;
6762                 default:
6763                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6764                         temp_index = 0;
6765                         break;
6766         }
6767
6768         return temp_index;
6769 }
6770
6771 static int _sat_encode_setup_event_list(const struct tel_sat_tr_setup_event_list_tlv *src_tr, char *dst_tr)
6772 {
6773         int temp_index = 0, encoded_len = 0;
6774
6775         //set command detail info
6776         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6777         temp_index += encoded_len;
6778
6779         //set device identities info
6780         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6781         temp_index += encoded_len;
6782
6783         //set result info
6784         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6785         switch(src_tr->result_type){
6786                 case RESULT_SUCCESS:
6787                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6788                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6789                 case RESULT_BEYOND_ME_CAPABILITIES:
6790                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6791                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6792                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6793                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6794                         dst_tr[temp_index++] = 1;
6795                         dst_tr[temp_index++] = src_tr->result_type;
6796                         break;
6797                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6798                         dst_tr[temp_index++] = 2;
6799                         dst_tr[temp_index++] = src_tr->result_type;
6800                         dst_tr[temp_index++] = src_tr->me_problem_type;
6801                         break;
6802                 default:
6803                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6804                         temp_index = 0;
6805                         break;
6806         }
6807
6808         return temp_index;
6809 }
6810
6811 static int _sat_encode_setup_idle_mode_text(const struct tel_sat_tr_setup_idle_mode_text_tlv *src_tr, char *dst_tr)
6812 {
6813         int temp_index = 0, encoded_len = 0;
6814
6815         //set command detail info
6816         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6817         temp_index += encoded_len;
6818
6819         //set device identities info
6820         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6821         temp_index += encoded_len;
6822
6823         //set result info
6824         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6825
6826         switch(src_tr->result_type){
6827                 case RESULT_SUCCESS:
6828                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6829                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6830                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6831                 case RESULT_BEYOND_ME_CAPABILITIES:
6832                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6833                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6834                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6835                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6836                         dst_tr[temp_index++] = 1;
6837                         dst_tr[temp_index++] = src_tr->result_type;
6838                         break;
6839                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6840                 case RESULT_FRAMES_ERROR:
6841                         dst_tr[temp_index++] = 2;
6842                         dst_tr[temp_index++] = src_tr->result_type;
6843                         dst_tr[temp_index++] = src_tr->me_problem_type;
6844                         break;
6845                 default:
6846                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6847                         temp_index = 0;
6848                         break;
6849         }
6850
6851         return temp_index;
6852 }
6853
6854 static int _sat_encode_send_dtmf(const struct tel_sat_tr_send_dtmf_tlv *src_tr, char *dst_tr)
6855 {
6856         int temp_index = 0, encoded_len = 0;
6857
6858         //set command detail info
6859         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6860         temp_index += encoded_len;
6861
6862         //set device identities info
6863         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6864         temp_index += encoded_len;
6865
6866         //set result info
6867         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6868
6869         switch(src_tr->result_type){
6870                 case RESULT_SUCCESS:
6871                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6872                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6873                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6874                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6875                 case RESULT_BEYOND_ME_CAPABILITIES:
6876                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6877                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6878                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6879                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6880                         dst_tr[temp_index++] = 1;
6881                         dst_tr[temp_index++] = src_tr->result_type;
6882                         break;
6883                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6884                         dst_tr[temp_index++] = 2;
6885                         dst_tr[temp_index++] = src_tr->result_type;
6886                         dst_tr[temp_index++] = src_tr->me_problem_type;
6887                         break;
6888                 default:
6889                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6890                         temp_index = 0;
6891                         break;
6892         }
6893
6894         return temp_index;
6895 }
6896
6897 static int _sat_encode_language_notification(const struct tel_sat_tr_language_notification_tlv *src_tr, char *dst_tr)
6898 {
6899         int temp_index = 0, encoded_len = 0;
6900
6901         //set command detail info
6902         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6903         temp_index += encoded_len;
6904
6905         //set device identities info
6906         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6907         temp_index += encoded_len;
6908
6909         //set result info
6910         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6911
6912         switch(src_tr->result_type){
6913                 case RESULT_SUCCESS:
6914                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6915                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6916                 case RESULT_BEYOND_ME_CAPABILITIES:
6917                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6918                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6919                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6920                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6921                         dst_tr[temp_index++] = 1;
6922                         dst_tr[temp_index++] = src_tr->result_type;
6923                         break;
6924                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6925                 case RESULT_FRAMES_ERROR:
6926                         dst_tr[temp_index++] = 2;
6927                         dst_tr[temp_index++] = src_tr->result_type;
6928                         dst_tr[temp_index++] = src_tr->me_problem_type;
6929                         break;
6930                 default:
6931                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6932                         temp_index = 0;
6933                         break;
6934         }
6935
6936         return temp_index;
6937 }
6938
6939 static int _sat_encode_launch_browser(const struct tel_sat_tr_launch_browser_tlv *src_tr, char *dst_tr)
6940 {
6941         int temp_index = 0, encoded_len = 0;
6942
6943         //set command detail info
6944         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6945         temp_index += encoded_len;
6946
6947         //set device identities info
6948         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
6949         temp_index += encoded_len;
6950
6951         //set result info
6952         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6953
6954         switch(src_tr->result_type){
6955                 case RESULT_SUCCESS:
6956                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6957                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6958                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6959                 case RESULT_BACKWARD_MOVE_BY_USER:
6960                 case RESULT_NO_RESPONSE_FROM_USER:
6961                 case RESULT_BEYOND_ME_CAPABILITIES:
6962                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6963                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6964                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6965                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6966                         dst_tr[temp_index++] = 1;
6967                         dst_tr[temp_index++] = src_tr->result_type;
6968                         break;
6969                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6970                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6971                 case RESULT_FRAMES_ERROR:
6972                         dst_tr[temp_index++] = 2;
6973                         dst_tr[temp_index++] = src_tr->result_type;
6974                         dst_tr[temp_index++] = src_tr->me_problem_type;
6975                         break;
6976                 case RESULT_LAUNCH_BROWSER_GENERIC_ERROR_CODE:
6977                         dst_tr[temp_index++] = 2;
6978                         dst_tr[temp_index++] = src_tr->result_type;
6979                         dst_tr[temp_index++] = src_tr->browser_problem_type;
6980                         break;
6981                 default:
6982                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6983                         temp_index = 0;
6984                         break;
6985         }
6986
6987         return temp_index;
6988 }
6989
6990 static int _sat_encode_open_channel(const struct tel_sat_tr_open_channel_tlv *src_tr, char *dst_tr)
6991 {
6992         int temp_index = 0, encoded_len = 0;
6993
6994         //set command detail info
6995         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
6996         temp_index += encoded_len;
6997
6998         //set device identities info
6999         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
7000         temp_index += encoded_len;
7001
7002         //set result info
7003         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
7004         switch(src_tr->result_type){
7005                 case RESULT_SUCCESS:
7006                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
7007                 case RESULT_SUCCESS_WITH_MISSING_INFO:
7008                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
7009                 case RESULT_SUCCESS_WITH_MODIFICATION:
7010                         dst_tr[temp_index++] = 1;
7011                         dst_tr[temp_index++] = src_tr->result_type;
7012
7013                         //set channel status
7014                         encoded_len = _sat_encode_channel_status_tlv(&(src_tr->channel_status), dst_tr, temp_index);
7015                         temp_index += encoded_len;
7016                         break;
7017                 case RESULT_REFRESH_PRFRMD_BUT_INDICATED_USIM_NOT_ACTIVE:
7018                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
7019                 case RESULT_INTERACTION_WITH_CC_BY_SIM_IN_TMP_PRBLM:
7020                 case RESULT_BEYOND_ME_CAPABILITIES:
7021                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
7022                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
7023                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
7024                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
7025                 case RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ:
7026                         dst_tr[temp_index++] = 1;
7027                         dst_tr[temp_index++] = src_tr->result_type;
7028                         break;
7029                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
7030                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
7031                 case RESULT_FRAMES_ERROR:
7032                         dst_tr[temp_index++] = 2;
7033                         dst_tr[temp_index++] = src_tr->result_type;
7034                         dst_tr[temp_index++] = src_tr->me_problem_type;
7035                         break;
7036                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
7037                         dst_tr[temp_index++] = 2;
7038                         dst_tr[temp_index++] = src_tr->result_type;
7039                         dst_tr[temp_index++] = src_tr->bip_problem_type;
7040                         break;
7041                 default:
7042                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
7043                         return 0;
7044                         break;
7045         }
7046
7047         return temp_index;
7048 }
7049
7050 static int _sat_encode_close_channel(const struct tel_sat_tr_close_channel_tlv *src_tr, char *dst_tr)
7051 {
7052         int temp_index = 0, encoded_len = 0;
7053
7054         //set command detail info
7055         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
7056         temp_index += encoded_len;
7057
7058         //set device identities info
7059         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
7060         temp_index += encoded_len;
7061
7062         //set result info
7063         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
7064         switch(src_tr->result_type){
7065                 case RESULT_SUCCESS:
7066                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
7067                 case RESULT_SUCCESS_WITH_MISSING_INFO:
7068                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
7069                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
7070                 case RESULT_BEYOND_ME_CAPABILITIES:
7071                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
7072                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
7073                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
7074                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
7075                         dst_tr[temp_index++] = 1;
7076                         dst_tr[temp_index++] = src_tr->result_type;
7077                         break;
7078                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
7079                 case RESULT_FRAMES_ERROR:
7080                         dst_tr[temp_index++] = 2;
7081                         dst_tr[temp_index++] = src_tr->result_type;
7082                         dst_tr[temp_index++] = src_tr->me_problem_type;
7083                         break;
7084                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
7085                         dst_tr[temp_index++] = 2;
7086                         dst_tr[temp_index++] = src_tr->result_type;
7087                         dst_tr[temp_index++] = src_tr->bip_problem_type;
7088                         break;
7089                 default:
7090                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
7091                         temp_index = 0;
7092                         break;
7093         }
7094
7095         return temp_index;
7096 }
7097
7098 static int _sat_encode_send_data(const struct tel_sat_tr_send_data_tlv *src_tr, char *dst_tr)
7099 {
7100         int temp_index = 0, encoded_len = 0;
7101
7102         //set command detail info
7103         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
7104         temp_index += encoded_len;
7105
7106         //set device identities info
7107         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
7108         temp_index += encoded_len;
7109
7110         //set result info
7111         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
7112         switch(src_tr->result_type){
7113                 case RESULT_SUCCESS:
7114                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
7115                 case RESULT_SUCCESS_WITH_MISSING_INFO:
7116                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
7117                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
7118                 case RESULT_BEYOND_ME_CAPABILITIES:
7119                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
7120                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
7121                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
7122                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
7123                         dst_tr[temp_index++] = 1;
7124                         dst_tr[temp_index++] = src_tr->result_type;
7125                         encoded_len = _sat_encode_channel_data_length_tlv(&(src_tr->channel_data_len), dst_tr, temp_index);
7126                         temp_index += encoded_len;
7127                         break;
7128                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
7129                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
7130                 case RESULT_FRAMES_ERROR:
7131                         dst_tr[temp_index++] = 2;
7132                         dst_tr[temp_index++] = src_tr->result_type;
7133                         dst_tr[temp_index++] = src_tr->me_problem_type;
7134                         break;
7135
7136                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
7137                         dst_tr[temp_index++] = 2;
7138                         dst_tr[temp_index++] = src_tr->result_type;
7139                         dst_tr[temp_index++] = src_tr->bip_problem_type;
7140                         break;
7141                 default:
7142                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
7143                         temp_index = 0;
7144                         break;
7145         }
7146
7147         return temp_index;
7148 }
7149
7150 static int _sat_encode_receive_data(const struct tel_sat_tr_receive_data_tlv *src_tr, char *dst_tr)
7151 {
7152         int temp_index = 0, encoded_len = 0;
7153
7154         //set command detail info
7155         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
7156         temp_index += encoded_len;
7157
7158         //set device identities info
7159         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
7160         temp_index += encoded_len;
7161
7162         //set result info
7163         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
7164         switch(src_tr->result_type){
7165                 case RESULT_SUCCESS:
7166                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
7167                 case RESULT_SUCCESS_WITH_MISSING_INFO:
7168                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
7169                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
7170                 case RESULT_BEYOND_ME_CAPABILITIES:
7171                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
7172                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
7173                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
7174                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
7175                         dst_tr[temp_index++] = 1;
7176                         dst_tr[temp_index++] = src_tr->result_type;
7177                         encoded_len = _sat_encode_channel_data_tlv(&(src_tr->channel_data), dst_tr, temp_index);
7178                         temp_index += encoded_len;
7179                         encoded_len = _sat_encode_channel_data_length_tlv(&(src_tr->channel_data_len), dst_tr, temp_index);
7180                         temp_index += encoded_len;
7181                         break;
7182                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
7183                 case RESULT_FRAMES_ERROR:
7184                         dst_tr[temp_index++] = 2;
7185                         dst_tr[temp_index++] = src_tr->result_type;
7186                         dst_tr[temp_index++] = src_tr->me_problem_type;
7187                         break;
7188
7189                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
7190                         dst_tr[temp_index++] = 2;
7191                         dst_tr[temp_index++] = src_tr->result_type;
7192                         dst_tr[temp_index++] = src_tr->bip_problem_type;
7193                         break;
7194                 default:
7195                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
7196                         temp_index = 0;
7197                         break;
7198         }
7199
7200         return temp_index;
7201 }
7202
7203 static int _sat_encode_get_channel_status(const struct tel_sat_tr_get_channel_status_tlv *src_tr, char *dst_tr)
7204 {
7205         int temp_index = 0, encoded_len = 0;
7206
7207         //set command detail info
7208         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
7209         temp_index += encoded_len;
7210
7211         //set device identities info
7212         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
7213         temp_index += encoded_len;
7214
7215         //set result info
7216         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
7217         switch(src_tr->result_type){
7218                 case RESULT_SUCCESS:
7219                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
7220                 case RESULT_SUCCESS_WITH_MISSING_INFO:
7221                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
7222                         dst_tr[temp_index++] = 1;
7223                         dst_tr[temp_index++] = src_tr->result_type;
7224                         encoded_len = _sat_encode_channel_status_tlv(&(src_tr->channel_status), dst_tr, temp_index);
7225                         temp_index += encoded_len;
7226                         break;
7227                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
7228                 case RESULT_BEYOND_ME_CAPABILITIES:
7229                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
7230                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
7231                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
7232                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
7233                         dst_tr[temp_index++] = 1;
7234                         dst_tr[temp_index++] = src_tr->result_type;
7235                         break;
7236                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
7237                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
7238                         dst_tr[temp_index++] = 2;
7239                         dst_tr[temp_index++] = src_tr->result_type;
7240                         dst_tr[temp_index++] = src_tr->me_problem_type;
7241                         break;
7242                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
7243                         dst_tr[temp_index++] = 2;
7244                         dst_tr[temp_index++] = src_tr->result_type;
7245                         dst_tr[temp_index++] = src_tr->bip_problem_type;
7246                         break;
7247                 default:
7248                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
7249                         temp_index = 0;
7250                         break;
7251         }
7252
7253         return temp_index;
7254 }
7255
7256 static int _sat_encode_unsupport_command(const struct tel_sat_tr_unsupport_command_tlv *src_tr, char *dst_tr)
7257 {
7258         int temp_index = 0, encoded_len = 0;
7259
7260         //set command detail info
7261         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, temp_index);
7262         temp_index += encoded_len;
7263
7264         //set device identities info
7265         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, temp_index);
7266         temp_index += encoded_len;
7267
7268         //set result info
7269         dst_tr[temp_index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
7270         dst_tr[temp_index++] = 1;
7271         dst_tr[temp_index++] = src_tr->result_type;
7272
7273         return temp_index;
7274 }
7275
7276 int tcore_sat_encode_terminal_response(const struct treq_sat_terminal_rsp_data *src_tr, char *dst_tr){
7277         int tr_len = 0;
7278
7279         if(!dst_tr)
7280                 return 0;
7281
7282         switch(src_tr->cmd_type){
7283                 case SAT_PROATV_CMD_DISPLAY_TEXT:{
7284                         tr_len = _sat_encode_display_text(&(src_tr->terminal_rsp_data.display_text), dst_tr);
7285                 }break;
7286                 case SAT_PROATV_CMD_GET_INKEY:{
7287                         tr_len = _sat_encode_get_inkey(&(src_tr->terminal_rsp_data.get_inkey), dst_tr);
7288                 }break;
7289                 case SAT_PROATV_CMD_GET_INPUT:{
7290                         tr_len = _sat_encode_get_input(&(src_tr->terminal_rsp_data.get_input), dst_tr);
7291                 }break;
7292                 case SAT_PROATV_CMD_MORE_TIME:{
7293                         tr_len = _sat_encode_more_time(&(src_tr->terminal_rsp_data.more_time), dst_tr);
7294                 }break;
7295                 case SAT_PROATV_CMD_PLAY_TONE:{
7296                         tr_len = _sat_encode_play_tone(&(src_tr->terminal_rsp_data.play_tone), dst_tr);
7297                 }break;
7298                 case SAT_PROATV_CMD_REFRESH:{
7299                         tr_len = _sat_encode_refresh(&(src_tr->terminal_rsp_data.refresh), dst_tr);
7300                 }break;
7301                 case SAT_PROATV_CMD_SETUP_MENU:{
7302                         tr_len = _sat_encode_setup_menu(&(src_tr->terminal_rsp_data.setup_menu), dst_tr);
7303                 }break;
7304                 case SAT_PROATV_CMD_SELECT_ITEM:{
7305                         tr_len = _sat_encode_select_item(&(src_tr->terminal_rsp_data.select_item), dst_tr);
7306                 }break;
7307                 case SAT_PROATV_CMD_SEND_SMS:{
7308                         tr_len = _sat_encode_send_sms(&(src_tr->terminal_rsp_data.send_sms), dst_tr);
7309                 }break;
7310                 case SAT_PROATV_CMD_SEND_SS:{
7311                         tr_len = _sat_encode_send_ss(&(src_tr->terminal_rsp_data.send_ss), dst_tr);
7312                 }break;
7313                 case SAT_PROATV_CMD_SEND_USSD:{
7314                         tr_len = _sat_encode_send_ussd(&(src_tr->terminal_rsp_data.send_ussd), dst_tr);
7315                 }break;
7316                 case SAT_PROATV_CMD_SETUP_CALL:{
7317                         tr_len = _sat_encode_setup_call(&(src_tr->terminal_rsp_data.setup_call), dst_tr);
7318                 }break;
7319                 case SAT_PROATV_CMD_PROVIDE_LOCAL_INFO:{
7320                         tr_len = _sat_encode_provide_local_info(&(src_tr->terminal_rsp_data.provide_local_info), dst_tr);
7321                 }break;
7322                 case SAT_PROATV_CMD_SETUP_EVENT_LIST:{
7323                         tr_len = _sat_encode_setup_event_list(&(src_tr->terminal_rsp_data.setup_event_list), dst_tr);
7324                 }break;
7325                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:{
7326                         tr_len = _sat_encode_setup_idle_mode_text(&(src_tr->terminal_rsp_data.setup_idle_mode_text), dst_tr);
7327                 }break;
7328                 case SAT_PROATV_CMD_SEND_DTMF:{
7329                         tr_len = _sat_encode_send_dtmf(&(src_tr->terminal_rsp_data.send_dtmf), dst_tr);
7330                 }break;
7331                 case SAT_PROATV_CMD_LANGUAGE_NOTIFICATION:{
7332                         tr_len = _sat_encode_language_notification(&(src_tr->terminal_rsp_data.language_notification), dst_tr);
7333                 }break;
7334                 case SAT_PROATV_CMD_LAUNCH_BROWSER:{
7335                         tr_len = _sat_encode_launch_browser(&(src_tr->terminal_rsp_data.launch_browser), dst_tr);
7336                 }break;
7337                 case SAT_PROATV_CMD_OPEN_CHANNEL:{
7338                         tr_len = _sat_encode_open_channel(&(src_tr->terminal_rsp_data.open_channel), dst_tr);
7339                 }break;
7340                 case SAT_PROATV_CMD_CLOSE_CHANNEL:{
7341                         tr_len = _sat_encode_close_channel(&(src_tr->terminal_rsp_data.close_channel), dst_tr);
7342                 }break;
7343                 case SAT_PROATV_CMD_SEND_DATA:{
7344                         tr_len = _sat_encode_send_data(&(src_tr->terminal_rsp_data.send_data), dst_tr);
7345                 }break;
7346                 case SAT_PROATV_CMD_RECEIVE_DATA:{
7347                         tr_len = _sat_encode_receive_data(&(src_tr->terminal_rsp_data.receive_data), dst_tr);
7348                 }break;
7349                 case SAT_PROATV_CMD_GET_CHANNEL_STATUS:{
7350                         tr_len = _sat_encode_get_channel_status(&(src_tr->terminal_rsp_data.get_channel_status), dst_tr);
7351                 }break;
7352                 default:{
7353                         tr_len = _sat_encode_unsupport_command(&(src_tr->terminal_rsp_data.unsupport_cmd), dst_tr);
7354                 }break;
7355         }
7356
7357         return tr_len;
7358 }
7359
7360 CoreObject *tcore_sat_new(TcorePlugin *p, const char *name,
7361                 struct tcore_sat_operations *ops, TcoreHal *hal)
7362 {
7363         CoreObject *o = NULL;
7364         struct private_object_data *po = NULL;
7365
7366         if (!p)
7367                 return NULL;
7368
7369         o = tcore_object_new(p, name, hal);
7370         if (!o)
7371                 return NULL;
7372
7373         po = calloc(1, sizeof(struct private_object_data));
7374         if (!po) {
7375                 tcore_object_free(o);
7376                 return NULL;
7377         }
7378
7379         po->ops = ops;
7380
7381         tcore_object_set_type(o, CORE_OBJECT_TYPE_SAT);
7382         tcore_object_link_object(o, po);
7383         tcore_object_set_clone_hook(o, _clone_hook);
7384         tcore_object_set_free_hook(o, _free_hook);
7385         tcore_object_set_dispatcher(o, _dispatcher);
7386
7387         return o;
7388 }
7389
7390 void tcore_sat_free(CoreObject *o)
7391 {
7392         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_SAT);
7393
7394         tcore_object_free(o);
7395 }
7396
7397 void tcore_sat_set_ops(CoreObject *o, struct tcore_sat_operations *ops)
7398 {
7399         struct private_object_data *po = NULL;
7400
7401         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_SAT);
7402
7403         po = (struct private_object_data *)tcore_object_ref_object(o);
7404         if (!po) {
7405                 return;
7406         }
7407
7408         po->ops = ops;
7409 }