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