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