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         memcpy(other_address_obj->address, address, strlen(address));
2303         other_address_obj->address_len = strlen(address);
2304
2305         if (address)
2306                 g_free(address);
2307
2308         dbg("destination address(%s)", other_address_obj->address);
2309         *consumed_data_len = 2+address_len;
2310         return TCORE_SAT_SUCCESS;
2311 }
2312
2313 static enum tcore_sat_result _sat_decode_uicc_terminal_interface_tlv(unsigned char* tlv_str,
2314                 int tlv_len, int curr_offset, struct tel_sat_uicc_terminal_interface_transport_level *level_obj,
2315                 int* consumed_data_len)
2316 {
2317         int index;
2318         unsigned char* src_data;
2319
2320         if (tlv_str == NULL || consumed_data_len == NULL || level_obj == NULL) {
2321                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || level_obj == NULL");
2322                 return TCORE_SAT_ERROR_FATAL;
2323         }
2324
2325         if (tlv_len <= (curr_offset+1)+SATK_UICC_ME_TRANS_INTERFACE_LEVEL_LENGTH) {
2326                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
2327                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2328         }
2329
2330         //tag
2331         index = curr_offset;
2332         src_data = &tlv_str[0];
2333         if ((src_data[index++]&0x7F) != SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG) {
2334                 dbg("[SAT] SAT PARSER - UICC/TERMINAL Interface transport level tag missing.");
2335                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2336         }
2337
2338         //length
2339         if (src_data[index++] != SATK_UICC_ME_TRANS_INTERFACE_LEVEL_LENGTH) {
2340                 dbg("[SAT] SAT PARSER -  incorrect length");
2341                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2342         }
2343
2344         level_obj->protocol_type = src_data[index++];
2345         level_obj->port_number = src_data[index++] << 8;
2346         level_obj->port_number |= src_data[index];
2347
2348         *consumed_data_len = 2+SATK_UICC_ME_TRANS_INTERFACE_LEVEL_LENGTH;
2349         dbg("[SAT] SAT PARSER -  protocol type(%d) , port number(%d)", level_obj->protocol_type, level_obj->port_number);
2350         return TCORE_SAT_SUCCESS;
2351 }
2352
2353 static enum tcore_sat_result _sat_decode_remote_entity_address_tlv(unsigned char* tlv_str,
2354                 int tlv_len, int curr_offset, struct tel_sat_remote_entity_address *remote_address_obj,
2355                 int* consumed_data_len)
2356 {
2357         int index = 0;
2358         int len_of_len = 0, remote_data_len = 0;
2359         unsigned char* src_data;
2360
2361         if (tlv_str == NULL || consumed_data_len == NULL || remote_address_obj == NULL) {
2362                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || remote_address_obj == NULL");
2363                 return TCORE_SAT_ERROR_FATAL;
2364         }
2365
2366         if (tlv_len <= (curr_offset+1)) {
2367                 dbg("[SAT] SAT PARSER - incorrect length original_command_len=%d", tlv_len);
2368                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2369         }
2370
2371         //tag
2372         index = curr_offset;
2373         src_data = &tlv_str[0];
2374         if ((src_data[index]&0x7F) != SATK_REMOTE_ENTITY_ADDRESS_TAG) {
2375                 dbg("[SAT] SAT PARSER - tag not found.=%d",src_data[index]);
2376                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2377         }
2378
2379         //length
2380         len_of_len = _get_length_filed_size(src_data[index]);
2381         if (!len_of_len) {
2382                 err("[SAT] parser: invalid length.");
2383                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2384         }
2385
2386         remote_data_len = src_data[index+len_of_len-1];
2387         dbg("[SAT] parser: remote_data_len=%d",remote_data_len);
2388         index += len_of_len;
2389
2390         //data
2391         switch(src_data[index++]) {
2392                 case REMOTE_ENTITY_ADDR_CODING_TYPE_IEEE802_48BIT:
2393                         remote_address_obj->coding_type = REMOTE_ENTITY_ADDR_CODING_TYPE_IEEE802_48BIT;
2394                         break;
2395                 case REMOTE_ENTITY_ADDR_CODING_TYPE_IRDA_32BIT:
2396                         remote_address_obj->coding_type = REMOTE_ENTITY_ADDR_CODING_TYPE_IRDA_32BIT;
2397                         break;
2398                 default:
2399                         remote_address_obj->coding_type =REMOTE_ENTITY_ADDR_CODING_TYPE_RESERVED;
2400                         break;
2401         }
2402
2403         remote_address_obj->length = remote_data_len - 1;
2404         memcpy(remote_address_obj->remote_entity_address, &src_data[index], remote_address_obj->length);
2405
2406         *consumed_data_len = 1+len_of_len+remote_data_len;
2407         return TCORE_SAT_SUCCESS;
2408 }
2409
2410 static enum tcore_sat_result _sat_decode_network_access_name_tlv(unsigned char* tlv_str,
2411                 int tlv_len, int curr_offset, struct tel_sat_network_access_name *access_name_obj,
2412                 int* consumed_data_len)
2413 {
2414         int index, idx, name_idx, name_length;
2415         unsigned char* src_data;
2416
2417         if (tlv_str == NULL || consumed_data_len == NULL || access_name_obj == NULL) {
2418                 dbg("[SAT] SAT PARSER -  tlv_str == NULL || consumed_data_len == NULL || access_name_obj == NULL");
2419                 return TCORE_SAT_ERROR_FATAL;
2420         }
2421
2422         if (tlv_len <= (curr_offset+1)) {
2423                 dbg("[SAT] SAT PARSER -  incorrect length original_command_len=%d", tlv_len);
2424                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2425         }
2426
2427         //tag
2428         index = curr_offset;
2429         src_data = &tlv_str[0];
2430         if ((src_data[index++]&0x7F) != SATK_NETWORK_ACCESS_TAG) {
2431                 dbg("[SAT] SAT PARSER -  network access name tag missing.");
2432                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
2433         }
2434
2435         //length
2436         name_length = src_data[index++];
2437         if ((index+name_length) > tlv_len) {
2438                 dbg("[SAT] SAT PARSER -  incorrect cmd len, expected len = %d, orig_len=%d", (index+name_length),tlv_len);
2439                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2440         }
2441
2442         access_name_obj->length = name_length;
2443         if (access_name_obj->length > SAT_NET_ACC_NAM_LEN_MAX) {
2444                 dbg("[SAT] SAT PARSER - network access name is longer than capability");
2445                 return TCORE_SAT_BEYOND_ME_CAPABILITY;
2446         }
2447
2448         name_idx = 0;
2449         for(idx = 0; idx < access_name_obj->length; idx++) {
2450                 dbg("data (%c) Bool(%d)",src_data[index], g_ascii_isalpha(src_data[index]) );
2451
2452                 if ( g_ascii_isalpha(src_data[index]) ) {
2453                         access_name_obj->network_access_name[name_idx] = src_data[index];
2454                         name_idx++;
2455                 }
2456                 else{
2457
2458                         if (src_data[index] == 0x02) {//02 convert to "."
2459                                 access_name_obj->network_access_name[name_idx] = '.';
2460                                 name_idx++;
2461                         }
2462                 }
2463                 index++;
2464         }
2465
2466         //network access name
2467         dbg("network access name(%s)", access_name_obj->network_access_name);
2468
2469         *consumed_data_len = 2+name_length;
2470         return TCORE_SAT_SUCCESS;
2471 }
2472
2473 //decode proactive cmd
2474 //6.4.1 DISPLAY TEXT
2475 static enum tcore_sat_result _sat_decode_display_text(unsigned char* o_cmd_data, int o_length,
2476                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2477 {
2478         int index = 0;
2479         int data_len_consumed=0;
2480         unsigned char dev_id[4];
2481         unsigned char* cmd_data = NULL;
2482         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2483
2484         if (o_cmd_data == NULL) {
2485                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2486                 return TCORE_SAT_ERROR_FATAL;
2487         }
2488
2489         cmd_data = &o_cmd_data[0];
2490         index = curr_offset+2;
2491         sat_cmd_ind_data->data.display_text.command_detail.cmd_num = cmd_data[index++];
2492         sat_cmd_ind_data->data.display_text.command_detail.cmd_type = cmd_data[index++];
2493
2494         /* ******decode command qualifier****** */
2495         if (cmd_data[index] & 0x01) {
2496                 sat_cmd_ind_data->data.display_text.command_detail.cmd_qualifier.display_text.text_priority =
2497                                 TEXT_PRIORITY_HIGH;
2498                 dbg("[SAT] SAT PARSER -  msg_prio=TAPI_SAT_MSG_PRIORITY_HIGH.");
2499         }
2500         else {
2501                 sat_cmd_ind_data->data.display_text.command_detail.cmd_qualifier.display_text.text_priority =
2502                                 TEXT_PRIORITY_NORMAL;
2503                 dbg("[SAT] SAT PARSER - : msg_prio=TAPI_SAT_MSG_PRIORITY_NORMAL.");
2504         }
2505
2506         if (cmd_data[index] & 0x80) {
2507                 sat_cmd_ind_data->data.display_text.command_detail.cmd_qualifier.display_text.text_clear_type =
2508                                 TEXT_WAIT_FOR_USER_TO_CLEAR_MSG;
2509                 dbg("[SAT] SAT PARSER - : msgClear=TAPI_SAT_WAIT_FOR_USER_TO_CLEAR_MSG.");
2510         }
2511         else {
2512                 sat_cmd_ind_data->data.display_text.command_detail.cmd_qualifier.display_text.text_clear_type =
2513                                 TEXT_AUTO_CLEAR_MSG_AFTER_A_DELAY;
2514                 dbg("[SAT] SAT PARSER -  msgClear=TAPI_SAT_AUTO_CLEAR_MSG_AFTER_A_DELAY.");
2515         }
2516
2517         index++;
2518         memcpy(dev_id,&cmd_data[index],4);
2519         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.display_text.device_id);
2520         if (rv != TCORE_SAT_SUCCESS)
2521                 return rv;
2522
2523         index+=4;
2524         rv = _sat_decode_text_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.display_text.text, &data_len_consumed);
2525         if (rv != TCORE_SAT_SUCCESS)
2526                 return rv;
2527
2528         if (sat_cmd_ind_data->data.display_text.text.string_length <= 0) {
2529                 err("[SAT] SAT PARSER - :string length is 0");
2530                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2531         }
2532
2533         dbg("[SAT] SAT PARSER  text(%s)",sat_cmd_ind_data->data.display_text.text.string);
2534         dbg("[SAT] SAT PARSER o_len(%d) index(%d) data_len_consumed(%d)",o_length , index, data_len_consumed);
2535
2536         if (index+data_len_consumed > o_length) {
2537                 err("[SAT] SAT PARSER - Wrong String TLV");
2538                 return TCORE_SAT_BEYOND_ME_CAPABILITY;
2539         }
2540         else if (index+data_len_consumed == o_length) {
2541                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2542                 return TCORE_SAT_SUCCESS;
2543         }
2544
2545         //icon identifier
2546         index+=data_len_consumed;
2547         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
2548                 data_len_consumed = 0;
2549                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.display_text.icon_id, &data_len_consumed);
2550
2551                 if (rv != TCORE_SAT_SUCCESS) {
2552                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
2553                 }
2554
2555                 if (index+data_len_consumed >= o_length) {
2556                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2557                         return TCORE_SAT_SUCCESS;
2558                 }
2559
2560                 index+=data_len_consumed; //index pointing to the Tag of next TLV
2561         }
2562
2563         //immediate response
2564         sat_cmd_ind_data->data.display_text.immediate_response_requested = FALSE;
2565         if ((cmd_data[index]&0x7F) == SATK_IMMEDIATE_RESPONSE_TAG) {
2566                 dbg("[SAT] SAT PARSER - :immediate response required.");
2567                 sat_cmd_ind_data->data.display_text.immediate_response_requested = TRUE;
2568                 index+=2;
2569         }
2570
2571         if (index >= o_length) {
2572                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2573                 return TCORE_SAT_SUCCESS;
2574         }
2575
2576         //time duration
2577         if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
2578                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.display_text.duration, &data_len_consumed);
2579                 if (rv != TCORE_SAT_SUCCESS) {
2580                         return rv; //SEND TR
2581                 }
2582         }
2583
2584         dbg("[SAT] SAT PARSER - :decoding done!.");
2585         return TCORE_SAT_SUCCESS;
2586 }
2587
2588 //6.4.2 GET INKEY
2589 static enum tcore_sat_result _sat_decode_get_inkey(unsigned char* o_cmd_data, int o_length,
2590                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2591 {
2592         int index = 0;
2593         int data_len_consumed=0;
2594         unsigned char dev_id[4];
2595         unsigned char* cmd_data = NULL;
2596         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2597
2598         if (o_cmd_data == NULL) {
2599                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2600                 return TCORE_SAT_ERROR_FATAL;
2601         }
2602
2603         cmd_data = &o_cmd_data[0];
2604         index = curr_offset+2;
2605         sat_cmd_ind_data->data.get_inkey.command_detail.cmd_num = cmd_data[index++];
2606         sat_cmd_ind_data->data.get_inkey.command_detail.cmd_type = cmd_data[index++];
2607
2608         /* ******decode command qualifier****** */
2609         if (cmd_data[index] & 0x01) {
2610                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.alphabet_set = TRUE;
2611                 dbg("[SAT] SAT PARSER - Alphabet set");
2612         }
2613
2614         if (cmd_data[index]&0x02) {
2615                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.alphabet_type = INPUT_ALPHABET_TYPE_UCS2;
2616                 dbg("[SAT] SAT PARSER -  INPUT_ALPHABET_TYPE_UCS2");
2617         }
2618         else{
2619                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.alphabet_type = INPUT_ALPHABET_TYPE_SMS_DEFAULT;
2620                 dbg("[SAT] SAT PARSER -  INPUT_ALPHABET_TYPE_SMS_DEFAULT");
2621         }
2622
2623         if (cmd_data[index]&0x04) {
2624                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.inkey_type = INKEY_TYPE_YES_NO_REQUESTED;
2625                 dbg("[SAT] SAT PARSER -  INKEY_TYPE_YES_NO_REQUESTED");
2626         }
2627         else{
2628                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.inkey_type = INKEY_TYPE_CHARACTER_SET_ENABLED;
2629                 dbg("[SAT] SAT PARSER -  INKEY_TYPE_YES_NO_REQUESTED");
2630         }
2631
2632         if (cmd_data[index]&0x08) {
2633                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.immediate_rsp_required = TRUE;
2634                 dbg("[SAT] SAT PARSER -  immediate response requested");
2635         }
2636
2637         if (cmd_data[index] & 0x80) {
2638                 sat_cmd_ind_data->data.get_inkey.command_detail.cmd_qualifier.get_inkey.help_info = TRUE;
2639                 dbg("[SAT] SAT PARSER - Help info");
2640         }
2641
2642         //device identities
2643         index++;
2644         memcpy(dev_id,&cmd_data[index],4);
2645         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.get_inkey.device_id);
2646         if (rv != TCORE_SAT_SUCCESS)
2647                 return rv;
2648
2649         //text
2650         index+=4;
2651         rv = _sat_decode_text_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.get_inkey.text, &data_len_consumed);
2652         if (rv != TCORE_SAT_SUCCESS)
2653                 return rv;
2654
2655         if (sat_cmd_ind_data->data.get_inkey.text.string_length <= 0) {
2656                 err("[SAT] SAT PARSER - :string length is 0");
2657                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2658         }
2659
2660         dbg("[SAT] SAT PARSER  text(%s)",sat_cmd_ind_data->data.get_inkey.text.string);
2661         dbg("[SAT] SAT PARSER o_len(%d) index(%d) data_len_consumed(%d)",o_length , index, data_len_consumed);
2662
2663         if (index+data_len_consumed > o_length) {
2664                 err("[SAT] SAT PARSER - Wrong String TLV");
2665                 return TCORE_SAT_BEYOND_ME_CAPABILITY;
2666         }
2667         else if (index+data_len_consumed == o_length) {
2668                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2669                 return TCORE_SAT_SUCCESS;
2670         }
2671
2672         //icon identifier
2673         index+=data_len_consumed;
2674         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
2675                 data_len_consumed = 0;
2676                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.get_inkey.icon_id, &data_len_consumed);
2677
2678                 if (rv != TCORE_SAT_SUCCESS) {
2679                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
2680                 }
2681
2682                 if (index+data_len_consumed >= o_length) {
2683                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2684                         return TCORE_SAT_SUCCESS;
2685                 }
2686
2687                 index+=data_len_consumed; //index pointing to the Tag of next TLV
2688         }
2689
2690         //time duration
2691         if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
2692                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.get_inkey.duration, &data_len_consumed);
2693                 if (rv != TCORE_SAT_SUCCESS) {
2694                         return rv; //SEND TR
2695                 }
2696         }
2697
2698         dbg("[SAT] SAT PARSER - :decoding done!.");
2699         return TCORE_SAT_SUCCESS;
2700 }
2701
2702 //6.4.3 GET INPUT
2703 static enum tcore_sat_result _sat_decode_get_input(unsigned char* o_cmd_data, int o_length,
2704                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2705 {
2706         int index = 0;
2707         int data_len_consumed=0;
2708         unsigned char dev_id[4];
2709         unsigned char* cmd_data = NULL;
2710         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2711
2712         if (o_cmd_data == NULL) {
2713                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2714                 return TCORE_SAT_ERROR_FATAL;
2715         }
2716
2717         cmd_data = &o_cmd_data[0];
2718         index = curr_offset+2;
2719         sat_cmd_ind_data->data.get_input.command_detail.cmd_num = cmd_data[index++];
2720         sat_cmd_ind_data->data.get_input.command_detail.cmd_type = cmd_data[index++];
2721
2722         /* ******decode command qualifier****** */
2723         if (cmd_data[index] & 0x01) {
2724                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.alphabet_set = TRUE;
2725                 dbg("[SAT] SAT PARSER - Alphabet set");
2726         }
2727         else{
2728                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.alphabet_set = FALSE;
2729                 dbg("[SAT] SAT PARSER - Numeric info");
2730         }
2731
2732         if (cmd_data[index]&0x02) {
2733                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.alphabet_type = INPUT_ALPHABET_TYPE_UCS2;
2734                 dbg("[SAT] SAT PARSER -  INPUT_ALPHABET_TYPE_UCS2");
2735         }
2736         else{
2737                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.alphabet_type = INPUT_ALPHABET_TYPE_SMS_DEFAULT;
2738                 dbg("[SAT] SAT PARSER -  INPUT_ALPHABET_TYPE_SMS_DEFAULT");
2739         }
2740
2741         if (cmd_data[index]&0x04) {
2742                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.me_echo_user_input = FALSE;
2743                 dbg("[SAT] SAT PARSER -  user input not be revealed");
2744         }
2745         else{
2746                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.me_echo_user_input = TRUE;
2747                 dbg("[SAT] SAT PARSER -  Me echo user input");
2748         }
2749
2750         if (cmd_data[index]&0x08) {
2751                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.user_input_unpacked_format = FALSE;
2752                 dbg("[SAT] SAT PARSER - packing required");
2753         }
2754         else{
2755                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.user_input_unpacked_format = TRUE;
2756                 dbg("[SAT] SAT PARSER - unpacked format");
2757         }
2758
2759         if (cmd_data[index] & 0x80) {
2760                 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.help_info = TRUE;
2761                 dbg("[SAT] SAT PARSER - Help info");
2762         }
2763
2764         //device identities
2765         index++;
2766         memcpy(dev_id,&cmd_data[index],4);
2767         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.get_input.device_id);
2768         if (rv != TCORE_SAT_SUCCESS)
2769                 return rv;
2770
2771         //text
2772         index+=4;
2773         rv = _sat_decode_text_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.get_input.text, &data_len_consumed);
2774         if (rv != TCORE_SAT_SUCCESS)
2775                 return rv;
2776
2777         if (sat_cmd_ind_data->data.get_input.text.string_length <= 0) {
2778                 err("[SAT] SAT PARSER - :string length is 0");
2779         }
2780         dbg("[SAT] SAT PARSER  text(%s)",sat_cmd_ind_data->data.get_input.text.string);
2781
2782         //response length
2783         index+=data_len_consumed;
2784         rv = _sat_decode_response_length_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.get_input.rsp_len, &data_len_consumed);
2785         if (rv != TCORE_SAT_SUCCESS)
2786                 return rv;
2787
2788         if (index+data_len_consumed >= o_length) {
2789                 err("[SAT] SAT PARSER - no more TLVs");
2790                 return TCORE_SAT_SUCCESS;
2791         }
2792
2793         //default text
2794         index+=data_len_consumed;
2795         if ((o_cmd_data[index]&0x7F) == SATK_DEFAULT_TEXT_TAG) {
2796                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.get_input.default_text, &data_len_consumed);
2797                 if (rv != TCORE_SAT_SUCCESS)
2798                         return rv;
2799
2800                 if (sat_cmd_ind_data->data.get_input.default_text.string_length <= 0) {
2801                         err("[SAT] SAT PARSER - :string length is 0");
2802                 }
2803                 dbg("[SAT] SAT PARSER default text(%s)",sat_cmd_ind_data->data.get_input.default_text.string);
2804                 index+=data_len_consumed;
2805         }
2806
2807         //icon identifier
2808         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
2809                 data_len_consumed = 0;
2810                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.display_text.icon_id, &data_len_consumed);
2811
2812                 if (rv != TCORE_SAT_SUCCESS) {
2813                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
2814                 }
2815
2816                 if (index+data_len_consumed >= o_length) {
2817                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2818                         return TCORE_SAT_SUCCESS;
2819                 }
2820
2821                 index+=data_len_consumed; //index pointing to the Tag of next TLV
2822         }
2823
2824         dbg("[SAT] SAT PARSER - :decoding done!.");
2825         return TCORE_SAT_SUCCESS;
2826 }
2827
2828 //6.4.4 MORE TIME
2829 static enum tcore_sat_result _sat_decode_more_time(unsigned char* o_cmd_data, int o_length,
2830                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2831 {
2832         int index = 0;
2833         unsigned char dev_id[4];
2834         unsigned char* cmd_data = NULL;
2835         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2836
2837         if (o_cmd_data == NULL) {
2838                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2839                 return TCORE_SAT_ERROR_FATAL;
2840         }
2841
2842         //command detail
2843         cmd_data = &o_cmd_data[0];
2844         index = curr_offset+2;
2845         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_num = cmd_data[index++];
2846         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_type = cmd_data[index++];
2847
2848         //device identifier
2849         index++;
2850         memcpy(dev_id,&cmd_data[index],4);
2851         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_event_list.device_id);
2852         if (rv != TCORE_SAT_SUCCESS)
2853                 return rv;
2854
2855         index+=4;
2856         dbg("[SAT] SAT PARSER - :decoding done!.");
2857         return TCORE_SAT_SUCCESS;
2858 }
2859
2860 //6.4.5 PLAY TONE
2861 static enum tcore_sat_result _sat_decode_play_tone(unsigned char* o_cmd_data, int o_length,
2862                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2863 {
2864         int index = 0, data_len_consumed = 0;
2865         unsigned char dev_id[4];
2866         unsigned char* cmd_data = NULL;
2867         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2868
2869         if (o_cmd_data == NULL) {
2870                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2871                 return TCORE_SAT_ERROR_FATAL;
2872         }
2873
2874         //command detail
2875         cmd_data = &o_cmd_data[0];
2876         index = curr_offset+2;
2877         sat_cmd_ind_data->data.play_tone.command_detail.cmd_num = cmd_data[index++];
2878         sat_cmd_ind_data->data.play_tone.command_detail.cmd_type = cmd_data[index++];
2879
2880         /* ******decode command qualifier****** */
2881         if (cmd_data[index] & 0x01)
2882                 sat_cmd_ind_data->data.play_tone.command_detail.cmd_qualifier.play_tone.vibration_alert = VIBRATE_ALERT_REQUIRED;
2883         else
2884                 sat_cmd_ind_data->data.play_tone.command_detail.cmd_qualifier.play_tone.vibration_alert = VIBRATE_ALERT_OPTIONAL;
2885
2886         //device identifier
2887         index++;
2888         memcpy(dev_id,&cmd_data[index],4);
2889         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.play_tone.device_id);
2890         if (rv != TCORE_SAT_SUCCESS)
2891                 return rv;
2892
2893         //alpha id - optional
2894         index+=4;
2895         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
2896                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.play_tone.alpha_id, &data_len_consumed);
2897                 if (rv != TCORE_SAT_SUCCESS) {
2898                         return rv;
2899                 }
2900
2901                 index+=data_len_consumed;
2902                 if (index >= o_length) {
2903                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2904                         dbg("[SAT] SAT PARSER - default value is set - tone type, duration");
2905                         sat_cmd_ind_data->data.play_tone.tone.tone_type = GENERAL_BEEP;
2906                         sat_cmd_ind_data->data.play_tone.duration.time_unit = TIME_UNIT_SECONDS;
2907                         sat_cmd_ind_data->data.play_tone.duration.time_interval = 2;
2908                         return TCORE_SAT_SUCCESS;
2909                 }
2910         }
2911
2912         //tone - optional
2913         if ((cmd_data[index]&0x7F) == SATK_TONE_TAG) {
2914                 rv = _sat_decode_tone_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.play_tone.tone, &data_len_consumed);
2915                 if (rv != TCORE_SAT_SUCCESS) {
2916                         return rv;
2917                 }
2918                 index+=data_len_consumed;
2919         }
2920         else{
2921                 sat_cmd_ind_data->data.play_tone.tone.tone_type = GENERAL_BEEP;
2922         }
2923
2924         //time duration - optional
2925         if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
2926                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.play_tone.duration, &data_len_consumed);
2927                 if (rv != TCORE_SAT_SUCCESS) {
2928                         return rv; //SEND TR
2929                 }
2930
2931                 index+=data_len_consumed;
2932                 if (index >= o_length) {
2933                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2934                         return TCORE_SAT_SUCCESS;
2935                 }
2936         }
2937         else{
2938                 dbg("[SAT] SAT PARSER -  Duration TLV not present, ME should use a default value.");
2939                 sat_cmd_ind_data->data.play_tone.duration.time_unit = TIME_UNIT_SECONDS;
2940                 sat_cmd_ind_data->data.play_tone.duration.time_interval = 2;
2941         }
2942
2943         //icon identifier
2944         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
2945                 data_len_consumed = 0;
2946                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.play_tone.icon_id, &data_len_consumed);
2947
2948                 if (rv != TCORE_SAT_SUCCESS) {
2949                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
2950                 }
2951
2952                 if (index+data_len_consumed >= o_length) {
2953                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2954                         return TCORE_SAT_SUCCESS;
2955                 }
2956
2957                 index+=data_len_consumed; //index pointing to the Tag of next TLV
2958         }
2959
2960 //ToDo:  Text Attribute and frames
2961         dbg("[SAT] SAT PARSER - :decoding done!.");
2962         return TCORE_SAT_SUCCESS;
2963 }
2964
2965 //6.4.7 REFRESH
2966 static enum tcore_sat_result _sat_decode_refresh(unsigned char* o_cmd_data, int o_length,
2967                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
2968 {
2969         int index = 0, data_len_consumed = 0;
2970         unsigned char dev_id[4];
2971         unsigned char* cmd_data = NULL;
2972         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2973
2974         if (o_cmd_data == NULL) {
2975                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
2976                 return TCORE_SAT_ERROR_FATAL;
2977         }
2978
2979         //command detail
2980         cmd_data = &o_cmd_data[0];
2981         index = curr_offset+2;
2982         sat_cmd_ind_data->data.refresh.command_detail.cmd_num = cmd_data[index++];
2983         sat_cmd_ind_data->data.refresh.command_detail.cmd_type = cmd_data[index++];
2984
2985         /* ******decode command qualifier****** */
2986         switch(cmd_data[index]) {
2987                 case REFRESH_SIM_INIT_AND_FULL_FCN:
2988                 case REFRESH_FCN:
2989                 case REFRESH_SIM_INIT_AND_FCN:
2990                 case REFRESH_SIM_INIT   :
2991                 case REFRESH_SIM_RESET:
2992                         sat_cmd_ind_data->data.refresh.command_detail.cmd_qualifier.refresh.refresh = cmd_data[index];
2993                         dbg("[SAT] SAT PARSER - : refresh mode=[0x%02x]:0-init&FFCN, 1-FCN, 2-init&FCN, 3-init, 4-reset", cmd_data[index]);
2994                         break;
2995
2996                 case REFRESH_3G_APPLICATION_RESET:
2997                 case REFRESH_3G_SESSION_RESET:
2998                 case REFRESH_RESERVED:
2999                 default:
3000                         dbg("[SAT] SAT PARSER - : refresh mode=0x%02x Not Supported", cmd_data[index]);
3001                         return TCORE_SAT_BEYOND_ME_CAPABILITY;
3002                         break;
3003         }
3004
3005         //device identifier
3006         index++;
3007         memcpy(dev_id,&cmd_data[index],4);
3008         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.refresh.device_id);
3009         if (rv != TCORE_SAT_SUCCESS)
3010                 return rv;
3011
3012         //check file list
3013         index+=4;
3014         if ( (sat_cmd_ind_data->data.refresh.command_detail.cmd_qualifier.refresh.refresh == REFRESH_FCN)
3015                 || (sat_cmd_ind_data->data.refresh.command_detail.cmd_qualifier.refresh.refresh == REFRESH_SIM_INIT_AND_FCN) ) {
3016
3017                 rv = _sat_decode_file_list_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.refresh.file_list, &data_len_consumed);
3018                 if (rv != TCORE_SAT_SUCCESS)
3019                         return rv;
3020         }
3021         else
3022                 sat_cmd_ind_data->data.refresh.file_list.file_count = 0;
3023
3024         dbg("[SAT] SAT PARSER - :decoding done!.");
3025         return TCORE_SAT_SUCCESS;
3026 }
3027
3028 //6.4.8 SETUP MENU
3029 static enum tcore_sat_result _sat_decode_setup_menu(unsigned char* tlv_str, int tlv_len,
3030                 int curr_offset, struct tcore_sat_proactive_command *pactive_cmd_ind_obj)
3031 {
3032         int index = 0;
3033         int data_len_consumed=0;
3034         unsigned char dev_id[4];
3035         unsigned char* src_data;
3036         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3037
3038         //access command detail
3039         index = curr_offset+2; //move the index to command detail info +2(tag and length)
3040         src_data = &tlv_str[0];
3041
3042 // In this time, the point of index is COMMAND NUMBER
3043 // [1] insert command detail information into each proactive command data structure.
3044         pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_num = src_data[index++];
3045         pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_type = src_data[index++];
3046
3047 // [2] decode COMMAND QUALIFIER
3048 /*
3049 -bit 1: 0 = no selection preference;
3050                 1 = selection using soft key preferred.
3051 -bits 2 to 7:   = RFU.
3052 -bit 8: 0 = no help information available;
3053                 1 = help information available.
3054 */
3055
3056 //[2-1] selection preference
3057         if (src_data[index] & 0x01) {
3058                 pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_qualifier.setup_menu.select_preference =
3059                                 SELECTION_PREFERENCE_USING_SOFT_KEY;
3060                 dbg("[SAT] SAT PARSER -  sel_pref=SAT_SELECTION_PREFERENCE_USING_SOFT_KEY.");
3061         }
3062         else {
3063                 pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_qualifier.setup_menu.select_preference =
3064                                 SELECTION_PREFERENCE_NONE_REQUESTED;
3065                 dbg("[SAT] SAT PARSER - : sel_pref=SAT_SELECTION_PREFERENCE_NONE_REQUESTED.");
3066         }
3067
3068 //[2-2] help available
3069         if (src_data[index] & 0x80) {
3070                 pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_qualifier.setup_menu.help_info =
3071                                 TRUE;
3072                 ;dbg("[SAT] SAT PARSER - : is help Available=TRUE.");
3073         }
3074         else {
3075                 pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_qualifier.setup_menu.help_info =
3076                                 FALSE;
3077                 dbg("[SAT] SAT PARSER -  is help Available=FALSE.");
3078         }
3079
3080 // In this time, the point of index is DEVICE IDENTITIES.
3081 //[3] decode DEVICE IDENTITIES TLV
3082         index++;
3083         memcpy(dev_id, &src_data[index], 4);
3084         rv = _sat_decode_device_identities_tlv(dev_id, &pactive_cmd_ind_obj->data.setup_menu.device_id);
3085         if (rv != TCORE_SAT_SUCCESS) {
3086                 //send TR in SatkProcessProactiveCmdInd()
3087                 return rv;
3088         }
3089
3090
3091 // In this time, the point of index is ALPHA IDENTIFIER. 11 or 12.
3092 //[4] decode ALPHA IDENTIFIER TLV
3093         index+=4;
3094         dbg("[SAT] SAT PARSER - :index=%d",index);
3095         rv = _sat_decode_alpha_identifier_tlv(src_data, tlv_len, index,
3096                         &pactive_cmd_ind_obj->data.setup_menu.alpha_id, &data_len_consumed);
3097         if (rv != TCORE_SAT_SUCCESS) {
3098                 return rv;
3099         }
3100
3101 // In this time, the point of index is ITEM  TLV
3102 //[5] decode ITEM LIST (at least one is mandatory)
3103         index+= data_len_consumed;
3104         pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt = 0;
3105         do{
3106                 data_len_consumed=0;
3107                 if ((src_data[index]&0x7F) == SATK_ITEM_TAG) {
3108                         rv = _sat_decode_item_tlv(src_data, tlv_len, index,
3109                                                 &pactive_cmd_ind_obj->data.setup_menu.menu_item[pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt],
3110                                                 &data_len_consumed);
3111
3112                         if (rv != TCORE_SAT_SUCCESS)
3113                                 return rv;
3114                 }
3115                 else {
3116                         if (pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt == 0) {
3117                                 dbg("menu item is not exist.");
3118                                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
3119                         }
3120                         //else
3121                         break;  //???
3122                 }
3123                 pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt++;
3124                 index += data_len_consumed;
3125
3126                 if (index >= tlv_len)
3127                         break;
3128         }while(pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt < SAT_MENU_ITEM_COUNT_MAX);
3129
3130         dbg("[SAT] SAT PARSER - :setup menu item_count=%d",pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt);
3131         if (index >= tlv_len) {
3132                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
3133                 //send TR in SatkProcessProactiveCmdInd()
3134                 return TCORE_SAT_SUCCESS;
3135         }
3136
3137 //[6] (optional TLV) decode ITEMS NEXT ACTION INDICATOR TLV
3138         if ((src_data[index]&0x7F) == SATK_ITEMS_NEXT_ACTION_INDICATOR_TAG) {
3139                 data_len_consumed = 0;
3140                 rv = _sat_decode_item_next_action_indicator_tlv(tlv_str, tlv_len, index,
3141                                 &pactive_cmd_ind_obj->data.setup_menu.next_act_ind_list, &data_len_consumed);
3142                 if (rv!=TCORE_SAT_SUCCESS) return rv;
3143
3144                 if (index+data_len_consumed >= tlv_len) {
3145                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3146                         //send the data to Noti manager.
3147                         return TCORE_SAT_SUCCESS;
3148                 }
3149
3150                 index+=data_len_consumed; //index pointing to the Tag of next TLV
3151         }
3152         else {
3153                 dbg("[SAT] SAT PARSER -  ITEMS NEXT ACTION INDICATOR TLV Not present");
3154         }
3155
3156 //[7] (optional TLV) decode ICON IDENTIFIER TLV
3157         if ((src_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3158                 data_len_consumed = 0;
3159                 rv = _sat_decode_icon_identifier_tlv(tlv_str, tlv_len, index,
3160                                 &pactive_cmd_ind_obj->data.setup_menu.icon_id, &data_len_consumed);
3161                 if (rv !=TCORE_SAT_SUCCESS) return rv;
3162
3163                 if (index+data_len_consumed >= tlv_len) {
3164                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3165                         //send the data to Noti manager.
3166                         return TCORE_SAT_SUCCESS;
3167                 }
3168
3169                 index+=data_len_consumed; //index pointing to the Tag of next TLV
3170         }
3171         else{
3172                 dbg("[SAT] SAT PARSER - ICON IDENTIFIER TLV Not present");
3173         }
3174
3175 //[8] (optional TLV) decode ICON IDENTIFIER LIST TLV
3176         if ((src_data[index]&0x7F) == SATK_ITEM_ICON_IDENTIFIER_LIST_TAG) {
3177                 data_len_consumed = 0;
3178                 rv = _sat_decode_icon_identifier_list_tlv(tlv_str, tlv_len, index,
3179                                 &pactive_cmd_ind_obj->data.setup_menu.icon_list, &data_len_consumed);
3180                 if (rv !=TCORE_SAT_SUCCESS) return rv; //SEND TR
3181
3182                 if (index+data_len_consumed >= tlv_len) {
3183                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3184                         //send the data to Noti manager.
3185                         return TCORE_SAT_SUCCESS;
3186                 }
3187                 index+=data_len_consumed; //index pointing to the Tag of next TLV
3188
3189         }
3190         else {
3191                 dbg("[SAT] SAT PARSER - ICON IDENTIFIER LIST TLV not present");
3192         }
3193
3194 //ToDo:  Text Attribute, Text Attribute list. refer ETSI 102.223.
3195         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3196         return TCORE_SAT_SUCCESS;
3197 }
3198
3199 //6.4.9 SELECT ITEM
3200 static enum tcore_sat_result _sat_decode_select_item(unsigned char* o_cmd_data, int o_length,
3201                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3202 {
3203         int index = 0;
3204         int data_len_consumed=0;
3205         unsigned char dev_id[4];
3206         unsigned char* cmd_data = NULL;
3207         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3208
3209         if (o_cmd_data == NULL) {
3210                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3211                 return TCORE_SAT_ERROR_FATAL;
3212         }
3213
3214         cmd_data = &o_cmd_data[0];
3215         index = curr_offset+2;
3216         sat_cmd_ind_data->data.select_item.command_detail.cmd_num = cmd_data[index++];
3217         sat_cmd_ind_data->data.select_item.command_detail.cmd_type = cmd_data[index++];
3218
3219         /* ******decode command qualifier****** */
3220         if (cmd_data[index] & 0x01) {
3221                 if (cmd_data[index] & 0x02) {
3222                         sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.presentation_type = PRESENTATION_TYPE_NAVIGATION_OPTION;
3223                         dbg("[SAT] SAT PARSER - PRESENTATION_TYPE_NAVIGATION_OPTION");
3224                 }
3225                 else{
3226                         sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.presentation_type = PRESENTATION_TYPE_DATA_VALUE;
3227                         dbg("[SAT] SAT PARSER - PRESENTATION_TYPE_DATA_VALUE");
3228                 }
3229         }
3230         else {
3231                 sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.presentation_type = PRESENTATION_TYPE_NOT_SPECIFIED;
3232                 dbg("[SAT] SAT PARSER - PRESENTATION_TYPE_NOT_SPECIFIED");
3233         }
3234
3235         if (cmd_data[index] & 0x04) {
3236                 sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.select_preference = SELECTION_PREFERENCE_USING_SOFT_KEY;
3237                 dbg("[SAT] SAT PARSER - SELECTION_PREFERENCE_USING_SOFT_KEY");
3238         }
3239         else {
3240                 sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.select_preference = SELECTION_PREFERENCE_NONE_REQUESTED;
3241                 dbg("[SAT] SAT PARSER - SELECTION_PREFERENCE_NONE_REQUESTED");
3242         }
3243
3244         if (cmd_data[index] & 0x80) {
3245                 sat_cmd_ind_data->data.select_item.command_detail.cmd_qualifier.select_item.help_info = TRUE;
3246                 dbg("[SAT] SAT PARSER - Help info");
3247         }
3248
3249         //device identities
3250         index++;
3251         memcpy(dev_id,&cmd_data[index],4);
3252         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.select_item.device_id);
3253         if (rv != TCORE_SAT_SUCCESS)
3254                 return rv;
3255
3256         //alpha identifier
3257         index+=4;
3258         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
3259                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.select_item.alpha_id, &data_len_consumed);
3260                 if (rv != TCORE_SAT_SUCCESS) {
3261                         return rv;
3262                 }
3263                 index+=data_len_consumed;
3264         }
3265
3266         //item objects
3267         sat_cmd_ind_data->data.select_item.menu_item_cnt = 0;
3268         do{
3269                 data_len_consumed=0;
3270
3271                 if ((cmd_data[index]&0x7F) == SATK_ITEM_TAG) {
3272                         rv = _sat_decode_item_tlv(o_cmd_data, o_length, index,
3273                                 &sat_cmd_ind_data->data.select_item.menu_item[sat_cmd_ind_data->data.select_item.menu_item_cnt],
3274                                 &data_len_consumed);
3275
3276                         if (rv != TCORE_SAT_SUCCESS)
3277                                 return rv;
3278                 }
3279                 else {
3280                         if (sat_cmd_ind_data->data.select_item.menu_item_cnt == 0) {
3281                                 dbg("menu item is not exist.");
3282                                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
3283                         }
3284                         //else
3285                         break;  //???
3286                 }
3287                 sat_cmd_ind_data->data.select_item.menu_item_cnt++;
3288                 index += data_len_consumed;
3289
3290                 if (index >= o_length)
3291                         break;
3292
3293         }while(sat_cmd_ind_data->data.select_item.menu_item_cnt < SAT_MENU_ITEM_COUNT_MAX);
3294
3295         dbg("[SAT] SAT PARSER - select menu item_count=%d",sat_cmd_ind_data->data.select_item.menu_item_cnt);
3296         if (index >= o_length) {
3297                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
3298                 return TCORE_SAT_SUCCESS;
3299         }
3300
3301         //item next action indicator
3302         if ((cmd_data[index]&0x7F) == SATK_ITEMS_NEXT_ACTION_INDICATOR_TAG) {
3303                 data_len_consumed = 0;
3304                 rv = _sat_decode_item_next_action_indicator_tlv(o_cmd_data, o_length, index,
3305                                 &sat_cmd_ind_data->data.select_item.item_next_act_ind_list, &data_len_consumed);
3306                 if (rv!=TCORE_SAT_SUCCESS)
3307                         return rv;
3308
3309                 if (index+data_len_consumed >= o_length) {
3310                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3311                         return TCORE_SAT_SUCCESS;
3312                 }
3313
3314                 index+=data_len_consumed;
3315         }
3316
3317         //item identifier
3318         if ((cmd_data[index]&0x7F) == SATK_ITEM_IDENTIFIER_TAG) {
3319                 data_len_consumed = 0;
3320                 rv = _sat_decode_item_identifier_tlv(o_cmd_data, o_length, index,
3321                                 &sat_cmd_ind_data->data.select_item.item_identifier, &data_len_consumed);
3322                 if (rv !=TCORE_SAT_SUCCESS)
3323                         return rv;
3324
3325                 if (index+data_len_consumed >= o_length) {
3326                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3327                         return TCORE_SAT_SUCCESS;
3328                 }
3329
3330                 index+=data_len_consumed; //index pointing to the Tag of next TLV
3331         }
3332
3333         //icon identifier
3334         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3335                 data_len_consumed = 0;
3336                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index,
3337                                 &sat_cmd_ind_data->data.select_item.icon_id, &data_len_consumed);
3338
3339                 if (rv != TCORE_SAT_SUCCESS) {
3340                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3341                 }
3342
3343                 if (index+data_len_consumed >= o_length) {
3344                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3345                         return TCORE_SAT_SUCCESS;
3346                 }
3347
3348                 index+=data_len_consumed; //index pointing to the Tag of next TLV
3349         }
3350
3351         if ((cmd_data[index]&0x7F) == SATK_ITEM_ICON_IDENTIFIER_LIST_TAG) {
3352                 data_len_consumed = 0;
3353                 rv = _sat_decode_icon_identifier_list_tlv(o_cmd_data, o_length, index,
3354                                 &sat_cmd_ind_data->data.select_item.icon_list, &data_len_consumed);
3355                 if (rv !=TCORE_SAT_SUCCESS)
3356                         return rv; //SEND TR
3357
3358                 if (index+data_len_consumed >= o_length) {
3359                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3360                         return TCORE_SAT_SUCCESS;
3361                 }
3362                 index+=data_len_consumed; //index pointing to the Tag of next TLV
3363         }
3364
3365         dbg("[SAT] SAT PARSER - :decoding done!.");
3366         return TCORE_SAT_SUCCESS;
3367 }
3368
3369 //6.4.10 SEND SMS
3370 static enum tcore_sat_result _sat_decode_send_sms(unsigned char* o_cmd_data, int o_length,
3371                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3372 {
3373         int index = 0;
3374         int data_len_consumed=0;
3375         unsigned char dev_id[4];
3376         unsigned char* cmd_data = NULL;
3377         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3378
3379         if (o_cmd_data == NULL) {
3380                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3381                 return TCORE_SAT_ERROR_FATAL;
3382         }
3383
3384         cmd_data = &o_cmd_data[0];
3385         index = curr_offset+2;
3386         sat_cmd_ind_data->data.send_sms.command_detail.cmd_num = cmd_data[index++];
3387         sat_cmd_ind_data->data.send_sms.command_detail.cmd_type = cmd_data[index++];
3388
3389         /* ******decode command qualifier****** */
3390         if (cmd_data[index] & 0x01) {
3391                 sat_cmd_ind_data->data.send_sms.command_detail.cmd_qualifier.send_sms.packing_by_me_required = TRUE;
3392         }
3393         else {
3394                 sat_cmd_ind_data->data.send_sms.command_detail.cmd_qualifier.send_sms.packing_by_me_required = FALSE;
3395                 dbg("[SAT] SAT PARSER - packing by me required is false");
3396         }
3397
3398         //device identities
3399         index++;
3400         memcpy(dev_id,&cmd_data[index],4);
3401         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_sms.device_id);
3402         if (rv != TCORE_SAT_SUCCESS)
3403                 return rv;
3404
3405         //alpha identifier
3406         index+=4;
3407         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
3408                 data_len_consumed = 0;
3409                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_sms.alpha_id, &data_len_consumed);
3410                 if (rv != TCORE_SAT_SUCCESS) {
3411                         return rv;
3412                 }
3413                 index+=data_len_consumed;
3414         }
3415
3416         //address
3417         if ((cmd_data[index]&0x7F) == SATK_ADDRESS_TAG) {
3418                 data_len_consumed = 0;
3419                 rv = _sat_decode_address_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_sms.address, &data_len_consumed);
3420                 if (rv != TCORE_SAT_SUCCESS) {
3421                         return rv;
3422                 }
3423                 index+=data_len_consumed;
3424         }
3425
3426         //SMS-TPDU
3427         data_len_consumed = 0;
3428         rv = _sat_decode_sms_tpdu_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_sms.sms_tpdu, &data_len_consumed);
3429         if (rv != TCORE_SAT_SUCCESS)
3430                 return rv;
3431
3432         if (index+data_len_consumed >= o_length) {
3433                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3434                 return TCORE_SAT_SUCCESS;
3435         }
3436
3437         //icon identifier
3438         index+=data_len_consumed;
3439         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3440                 data_len_consumed = 0;
3441                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index,
3442                                 &sat_cmd_ind_data->data.select_item.icon_id, &data_len_consumed);
3443
3444                 if (rv != TCORE_SAT_SUCCESS) {
3445                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3446                 }
3447
3448                 if (index+data_len_consumed >= o_length) {
3449                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3450                         return TCORE_SAT_SUCCESS;
3451                 }
3452
3453                 index+=data_len_consumed; //index pointing to the Tag of next TLV
3454         }
3455
3456         dbg("[SAT] SAT PARSER - :decoding done!.");
3457         return TCORE_SAT_SUCCESS;
3458 }
3459
3460 //6.4.11 SEND SS
3461 static enum tcore_sat_result _sat_decode_send_ss(unsigned char* o_cmd_data, int o_length,
3462                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3463 {
3464         int index = 0, data_len_consumed = 0;
3465         unsigned char dev_id[4];
3466         unsigned char* cmd_data = NULL;
3467         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3468
3469         if (o_cmd_data == NULL || sat_cmd_ind_data == NULL) {
3470                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3471                 return TCORE_SAT_ERROR_FATAL;
3472         }
3473
3474         cmd_data = &o_cmd_data[0];
3475         index = curr_offset+2;
3476         sat_cmd_ind_data->data.send_ss.command_detail.cmd_num = cmd_data[index++];
3477         sat_cmd_ind_data->data.send_ss.command_detail.cmd_type = cmd_data[index++];
3478
3479         /** command detail **/
3480         index++; //RFU
3481
3482         //device identities
3483         memcpy(dev_id,&cmd_data[index],4);
3484         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_ss.device_id);
3485         if (rv != TCORE_SAT_SUCCESS)
3486                 return rv;
3487
3488         //alpha identifier - optional
3489         index += 4;
3490         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
3491                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_ss.alpha_id, &data_len_consumed);
3492                 if (rv != TCORE_SAT_SUCCESS) {
3493                         return rv;
3494                 }
3495                 index+=data_len_consumed;
3496         }
3497
3498         //ss string
3499         rv = _sat_decode_ss_string_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_ss.ss_string, &data_len_consumed);
3500         if (rv != TCORE_SAT_SUCCESS)
3501                 return rv;
3502
3503         //icon identifier- optional
3504         index+=data_len_consumed;
3505         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3506                 data_len_consumed = 0;
3507
3508                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_ss.icon_id, &data_len_consumed);
3509                 if (rv != TCORE_SAT_SUCCESS) {
3510                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3511                 }
3512
3513         }
3514
3515         dbg("[SAT] SAT PARSER - :decoding done!.");
3516         return TCORE_SAT_SUCCESS;
3517 }
3518
3519 //6.4.12 SEND USSD
3520 static enum tcore_sat_result _sat_decode_send_ussd(unsigned char* o_cmd_data, int o_length,
3521                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3522 {
3523         int index = 0, data_len_consumed = 0;
3524         unsigned char dev_id[4];
3525         unsigned char* cmd_data = NULL;
3526         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3527
3528         if (o_cmd_data == NULL || sat_cmd_ind_data == NULL) {
3529                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3530                 return TCORE_SAT_ERROR_FATAL;
3531         }
3532
3533         cmd_data = &o_cmd_data[0];
3534         index = curr_offset+2;
3535         sat_cmd_ind_data->data.send_ussd.command_detail.cmd_num = cmd_data[index++];
3536         sat_cmd_ind_data->data.send_ussd.command_detail.cmd_type = cmd_data[index++];
3537
3538         /** command detail **/
3539         index++; //RFU
3540
3541         //device identities
3542         memcpy(dev_id,&cmd_data[index],4);
3543         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_ussd.device_id);
3544         if (rv != TCORE_SAT_SUCCESS)
3545                 return rv;
3546
3547         //alpha identifier - optional
3548         index += 4;
3549         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
3550                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_ussd.alpha_id, &data_len_consumed);
3551                 if (rv != TCORE_SAT_SUCCESS) {
3552                         return rv;
3553                 }
3554                 index+=data_len_consumed;
3555         }
3556
3557         //ussd string
3558         rv = _sat_decode_ussd_string_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_ussd.ussd_string, &data_len_consumed);
3559         if (rv != TCORE_SAT_SUCCESS)
3560                 return rv;
3561
3562         //icon identifier- optional
3563         index+=data_len_consumed;
3564         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3565                 data_len_consumed = 0;
3566
3567                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_ussd.icon_id, &data_len_consumed);
3568                 if (rv != TCORE_SAT_SUCCESS) {
3569                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3570                 }
3571
3572         }
3573
3574         dbg("[SAT] SAT PARSER - :decoding done!.");
3575         return TCORE_SAT_SUCCESS;
3576 }
3577
3578 //6.4.13 SETUP CALL
3579 static enum tcore_sat_result _sat_decode_setup_call(unsigned char* o_cmd_data, int o_length,
3580                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3581 {
3582         int index = 0, data_len_consumed = 0;
3583         unsigned char dev_id[4];
3584         unsigned char* cmd_data = NULL;
3585         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3586
3587         if (o_cmd_data == NULL || sat_cmd_ind_data == NULL) {
3588                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3589                 return TCORE_SAT_ERROR_FATAL;
3590         }
3591
3592         //command detail
3593         cmd_data = &o_cmd_data[0];
3594         index = curr_offset+2;
3595         sat_cmd_ind_data->data.setup_call.command_detail.cmd_num = cmd_data[index++];
3596         sat_cmd_ind_data->data.setup_call.command_detail.cmd_type = cmd_data[index++];
3597
3598         /* ******decode command qualifier****** */
3599         switch(cmd_data[index]) {
3600                 case SETUP_CALL_IF_ANOTHER_CALL_NOT_BUSY:
3601                 case SETUP_CALL_IF_ANOTHER_CALL_NOT_BUSY_WITH_REDIAL:
3602                 case SETUP_CALL_PUT_ALL_OTHER_CALLS_ON_HOLD:
3603                 case SETUP_CALL_PUT_ALL_OTHER_CALLS_ON_HOLD_WITH_REDIAL:
3604                 case SETUP_CALL_DISCONN_ALL_OTHER_CALLS:
3605                 case SETUP_CALL_DISCONN_ALL_OTHER_CALLS_WITH_REDIAL:
3606                         sat_cmd_ind_data->data.setup_call.command_detail.cmd_qualifier.setup_call.setup_call = cmd_data[index];
3607                         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);
3608                         break;
3609                 case SETUP_CALL_RESERVED:
3610                 default:
3611                         dbg("[SAT] SAT PARSER -  setup_call.cmd_qualifier= 0x%02x", cmd_data[index]);
3612                         return TCORE_SAT_BEYOND_ME_CAPABILITY;
3613                         break;
3614         }
3615
3616         //device identifier
3617         index++;
3618         memcpy(dev_id,&cmd_data[index],4);
3619         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_call.device_id);
3620         if (rv != TCORE_SAT_SUCCESS)
3621                 return rv;
3622
3623         //alpha identifier (user confirmation) - optional
3624         index+=4;
3625         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
3626                 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);
3627                 if (rv != TCORE_SAT_SUCCESS) {
3628                         return rv;
3629                 }
3630                 index+=data_len_consumed;
3631         }
3632
3633         //address
3634         rv = _sat_decode_address_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.setup_call.address, &data_len_consumed);
3635         if (rv != TCORE_SAT_SUCCESS) {
3636                 return rv;
3637         }
3638
3639         index+=data_len_consumed;
3640         if (index >= o_length) {
3641                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3642                 return TCORE_SAT_SUCCESS;
3643         }
3644
3645         //capability configuration parameter - optional
3646         if ((cmd_data[index]&0x7F)==SATK_CAPABILITY_CONFIGURATION_PARAMETERS_TAG) {
3647                 rv =_sat_decode_ccp_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.setup_call.ccp, &data_len_consumed);
3648                 if (rv != TCORE_SAT_SUCCESS) {
3649                         return rv; //SEND TR
3650                 }
3651
3652                 index+=data_len_consumed;
3653                 if (index >= o_length) {
3654                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3655                         return TCORE_SAT_SUCCESS;
3656                 }
3657         }
3658
3659         //sub address - optional
3660         if ((cmd_data[index]&0x7F)==SATK_SUB_ADDRESS_TAG) {
3661                 rv =_sat_decode_sub_address_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.setup_call.subaddress, &data_len_consumed);
3662                 if (rv != TCORE_SAT_SUCCESS) {
3663                         return rv; //SEND TR
3664                 }
3665
3666                 index+=data_len_consumed;
3667                 if (index >= o_length) {
3668                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3669                         return TCORE_SAT_SUCCESS;
3670                 }
3671         }
3672
3673         //time duration - optional
3674         if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
3675                 rv =_sat_decode_duration_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.setup_call.duration, &data_len_consumed);
3676                 if (rv != TCORE_SAT_SUCCESS) {
3677                         return rv; //SEND TR
3678                 }
3679
3680                 index+=data_len_consumed;
3681                 if (index >= o_length) {
3682                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3683                         return TCORE_SAT_SUCCESS;
3684                 }
3685         }
3686
3687         //icon identifier (user confirmation) - optional
3688         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3689                 data_len_consumed = 0;
3690                 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);
3691
3692                 if (rv != TCORE_SAT_SUCCESS) {
3693                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3694                 }
3695
3696                 index+=data_len_consumed;
3697                 if (index >= o_length) {
3698                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3699                         return TCORE_SAT_SUCCESS;
3700                 }
3701         }
3702
3703         //alpha identifier (call setup) - optional
3704         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
3705                 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);
3706                 if (rv != TCORE_SAT_SUCCESS) {
3707                         return rv;
3708                 }
3709
3710                 index+=data_len_consumed;
3711                 if (index >= o_length) {
3712                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3713                         return TCORE_SAT_SUCCESS;
3714                 }
3715         }
3716
3717         //icon identifier (call setup) - optional
3718         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3719                 data_len_consumed = 0;
3720                 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);
3721
3722                 if (rv != TCORE_SAT_SUCCESS) {
3723                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3724                 }
3725
3726                 index+=data_len_consumed;
3727                 if (index >= o_length) {
3728                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3729                         return TCORE_SAT_SUCCESS;
3730                 }
3731         }
3732
3733         //ToDo:  Text Attribute (user_confirmation , call_setup)
3734
3735         dbg("[SAT] SAT PARSER - :decoding done!.");
3736         return TCORE_SAT_SUCCESS;
3737 }
3738
3739 //6.4.15 PROVIDE LOCAL INFO
3740 static enum tcore_sat_result _sat_decode_provide_local_info(unsigned char* o_cmd_data, int o_length,
3741                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3742 {
3743         int index = 0;
3744         unsigned char dev_id[4];
3745         unsigned char* cmd_data = NULL;
3746         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3747
3748         if (o_cmd_data == NULL) {
3749                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3750                 return TCORE_SAT_ERROR_FATAL;
3751         }
3752
3753         //command detail
3754         cmd_data = &o_cmd_data[0];
3755         index = curr_offset+2;
3756         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_num = cmd_data[index++];
3757         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_type = cmd_data[index++];
3758
3759         /* ******decode command qualifier****** */
3760         switch(cmd_data[index]) {
3761                 case LOCAL_INFO_DATE_TIME_AND_TIMEZONE:
3762                 case LOCAL_INFO_LANGUAGE:
3763                         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_qualifier.provide_local_info.provide_local_info = cmd_data[index];
3764                         break;
3765                 //TODO - Other cases
3766                 default:
3767                         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_qualifier.provide_local_info.provide_local_info = LOCAL_INFO_RESERVED;
3768                         break;
3769         }
3770
3771         //device identifier
3772         index++;
3773         memcpy(dev_id,&cmd_data[index],4);
3774         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_event_list.device_id);
3775         if (rv != TCORE_SAT_SUCCESS)
3776                 return rv;
3777
3778         //TODO - UTRAN Measurement Qualifier
3779
3780         dbg("[SAT] SAT PARSER - :decoding done!.");
3781         return TCORE_SAT_SUCCESS;
3782 }
3783
3784 //6.4.16 SETUP EVENT LIST
3785 static enum tcore_sat_result _sat_decode_setup_event_list(unsigned char* o_cmd_data, int o_length,
3786                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3787 {
3788         int index = 0, data_len_consumed = 0;
3789         unsigned char dev_id[4];
3790         unsigned char* cmd_data = NULL;
3791         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3792
3793         if (o_cmd_data == NULL) {
3794                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3795                 return TCORE_SAT_ERROR_FATAL;
3796         }
3797
3798         //command detail
3799         cmd_data = &o_cmd_data[0];
3800         index = curr_offset+2;
3801         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_num = cmd_data[index++];
3802         sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_type = cmd_data[index++];
3803
3804         //device identifier
3805         index++;
3806         memcpy(dev_id,&cmd_data[index],4);
3807         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_event_list.device_id);
3808         if (rv != TCORE_SAT_SUCCESS)
3809                 return rv;
3810
3811         //event list
3812         index+=4;
3813         rv = _sat_decode_event_list_tlv(o_cmd_data, o_length, index,
3814                         &sat_cmd_ind_data->data.setup_event_list.event_list,
3815                         &sat_cmd_ind_data->data.setup_event_list.event_list, &data_len_consumed);
3816
3817         dbg("[SAT] SAT PARSER - :decoding done!.");
3818         return TCORE_SAT_SUCCESS;
3819 }
3820
3821 //6.4.22 SETUP IDLE MODE TEXT
3822 static enum tcore_sat_result _sat_decode_setup_idle_mode_text(unsigned char* o_cmd_data, int o_length,
3823                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3824 {
3825         int index = 0, data_len_consumed = 0;
3826         unsigned char dev_id[4];
3827         unsigned char* cmd_data = NULL;
3828         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3829
3830         if (o_cmd_data == NULL) {
3831                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3832                 return TCORE_SAT_ERROR_FATAL;
3833         }
3834
3835         //command detail
3836         cmd_data = &o_cmd_data[0];
3837         index = curr_offset+2;
3838         sat_cmd_ind_data->data.setup_idle_mode_text.command_detail.cmd_num = cmd_data[index++];
3839         sat_cmd_ind_data->data.setup_idle_mode_text.command_detail.cmd_type = cmd_data[index++];
3840
3841         //device identifier
3842         index++;
3843         memcpy(dev_id,&cmd_data[index],4);
3844         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.setup_idle_mode_text.device_id);
3845         if (rv != TCORE_SAT_SUCCESS)
3846                 return rv;
3847
3848         //text string
3849         index+=4;
3850         rv = _sat_decode_text_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.setup_idle_mode_text.text, &data_len_consumed);
3851         if (rv != TCORE_SAT_SUCCESS)
3852                 return rv;
3853
3854         if (sat_cmd_ind_data->data.setup_idle_mode_text.text.string_length <= 0) {
3855                 err("[SAT] SAT PARSER - :string length is 0");
3856                 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
3857         }
3858
3859         dbg("[SAT] SAT PARSER  text(%s)",sat_cmd_ind_data->data.setup_idle_mode_text.text.string);
3860         dbg("[SAT] SAT PARSER o_len(%d) index(%d) data_len_consumed(%d)",o_length , index, data_len_consumed);
3861
3862         if (index+data_len_consumed > o_length) {
3863                 err("[SAT] SAT PARSER - Wrong String TLV");
3864                 return TCORE_SAT_BEYOND_ME_CAPABILITY;
3865         }
3866         else if (index+data_len_consumed == o_length) {
3867                 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
3868                 return TCORE_SAT_SUCCESS;
3869         }
3870
3871         //icon identifier
3872         index+=data_len_consumed;
3873         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3874                 data_len_consumed = 0;
3875                 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);
3876
3877                 if (rv != TCORE_SAT_SUCCESS) {
3878                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3879                 }
3880
3881                 if (index+data_len_consumed >= o_length) {
3882                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3883                         return TCORE_SAT_SUCCESS;
3884                 }
3885
3886                 index+=data_len_consumed; //index pointing to the Tag of next TLV
3887         }
3888
3889         //ToDo:  Text Attribute
3890         dbg("[SAT] SAT PARSER - :decoding done!.");
3891         return TCORE_SAT_SUCCESS;
3892 }
3893
3894 //6.4.24 SEND DTMF
3895 static enum tcore_sat_result _sat_decode_send_dtmf(unsigned char* o_cmd_data, int o_length,
3896                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3897 {
3898         int index = 0, data_len_consumed = 0;
3899         unsigned char dev_id[4];
3900         unsigned char* cmd_data = NULL;
3901         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3902
3903         if (o_cmd_data == NULL) {
3904                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3905                 return TCORE_SAT_ERROR_FATAL;
3906         }
3907
3908         //command detail
3909         cmd_data = &o_cmd_data[0];
3910         index = curr_offset+2;
3911         sat_cmd_ind_data->data.send_dtmf.command_detail.cmd_num = cmd_data[index++];
3912         sat_cmd_ind_data->data.send_dtmf.command_detail.cmd_type = cmd_data[index++];
3913
3914         //device identifier
3915         index++;
3916         memcpy(dev_id,&cmd_data[index],4);
3917         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_dtmf.device_id);
3918         if (rv != TCORE_SAT_SUCCESS)
3919                 return rv;
3920
3921         //alpha identifier - optional
3922         index+=4;
3923         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
3924                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_dtmf.alpha_id, &data_len_consumed);
3925                 if (rv != TCORE_SAT_SUCCESS) {
3926                         return rv;
3927                 }
3928                 index+=data_len_consumed;
3929         }
3930
3931         // DTMF string - mandatory
3932         if ((cmd_data[index] & 0x7F) == SATK_DTMF_STRING_TAG) {
3933                 rv = _sat_decode_dtmf_string_tlv(o_cmd_data, o_length, index,
3934                                 &sat_cmd_ind_data->data.send_dtmf.dtmf_string, &data_len_consumed);
3935                 if (rv != TCORE_SAT_SUCCESS) {
3936                         return rv;
3937                 }
3938
3939                 if (index + data_len_consumed >= o_length) {
3940                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3941                         return TCORE_SAT_SUCCESS;
3942                 }
3943                 index += data_len_consumed;
3944         } else {
3945                 dbg("[SAT] SAT PARSER - DTMF tlv is missed.");
3946                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
3947         }
3948
3949         //icon identifier - optional
3950         if ((cmd_data[index] & 0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3951                 data_len_consumed = 0;
3952                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index,
3953                                 &sat_cmd_ind_data->data.setup_idle_mode_text.icon_id, &data_len_consumed);
3954
3955                 if (rv != TCORE_SAT_SUCCESS) {
3956                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
3957                 }
3958
3959                 if (index + data_len_consumed >= o_length) {
3960                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3961                         return TCORE_SAT_SUCCESS;
3962                 }
3963                 index += data_len_consumed; //index pointing to the Tag of next TLV
3964         }
3965
3966         //ToDo:  Text Attribute, Frame Identifier
3967         dbg("[SAT] SAT PARSER - :decoding done!.");
3968         return TCORE_SAT_SUCCESS;
3969 }
3970
3971 //6.4.25 LANGUAGE NOTIFICATION
3972 static enum tcore_sat_result _sat_decode_language_notification(unsigned char* o_cmd_data, int o_length,
3973                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
3974 {
3975         int index = 0;
3976         unsigned char dev_id[4];
3977         unsigned char* cmd_data = NULL;
3978         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3979
3980         if (o_cmd_data == NULL) {
3981                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
3982                 return TCORE_SAT_ERROR_FATAL;
3983         }
3984
3985         //command detail
3986         cmd_data = &o_cmd_data[0];
3987         index = curr_offset+2;
3988         sat_cmd_ind_data->data.language_notification.command_detail.cmd_num = cmd_data[index++];
3989         sat_cmd_ind_data->data.language_notification.command_detail.cmd_type = cmd_data[index++];
3990
3991         /* ******decode command qualifier****** */
3992         if (cmd_data[index]&0x01)
3993                 sat_cmd_ind_data->data.language_notification.command_detail.cmd_qualifier.language_notification.specific_language = TRUE;
3994         else
3995                 sat_cmd_ind_data->data.language_notification.command_detail.cmd_qualifier.language_notification.specific_language = FALSE;
3996
3997         //device identifier
3998         index++;
3999         memcpy(dev_id,&cmd_data[index],4);
4000         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.language_notification.device_id);
4001         if (rv != TCORE_SAT_SUCCESS)
4002                 return rv;
4003
4004         //language - conditional
4005         index+=4;
4006         if (sat_cmd_ind_data->data.language_notification.command_detail.cmd_qualifier.language_notification.specific_language == TRUE) {
4007                 if ((cmd_data[index]&0x7F) == SATK_LANGUAGE_TAG) {
4008                         rv = _sat_decode_language_tlv(cmd_data, o_length, index, &sat_cmd_ind_data->data.language_notification.language);
4009                         if (rv != TCORE_SAT_SUCCESS)
4010                                 return rv;
4011                 } else  {
4012                         dbg("[SAT] SAT PARSER -  Language TLV is required but missing.");
4013                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4014                 }
4015         } else {
4016                 sat_cmd_ind_data->data.language_notification.language = SIM_LANG_UNSPECIFIED;
4017                 dbg("[SAT] SAT PARSER -  non-specific language");
4018         }
4019
4020         dbg("[SAT] SAT PARSER - :decoding done!.");
4021         return TCORE_SAT_SUCCESS;
4022 }
4023
4024 //6.4.26 LAUNCH BROWSER
4025 static enum tcore_sat_result _sat_decode_launch_browser(unsigned char* o_cmd_data, int o_length,
4026                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4027 {
4028         int index = 0, data_len_consumed = 0;
4029         unsigned char dev_id[4];
4030         unsigned char* cmd_data = NULL;
4031         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4032
4033         if (o_cmd_data == NULL) {
4034                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4035                 return TCORE_SAT_ERROR_FATAL;
4036         }
4037
4038         //command detail
4039         cmd_data = &o_cmd_data[0];
4040         index = curr_offset+2;
4041         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_num = cmd_data[index++];
4042         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_type = cmd_data[index++];
4043
4044         // decode command qualifier
4045         switch (cmd_data[index]) {
4046                 case 0x00:
4047                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4048                                         LAUNCH_BROWSER_IF_NOT_ALREADY_LAUNCHED;
4049                         break;
4050                 case 0x01:
4051                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4052                                         LAUNCH_BROWSER_NOT_USED;
4053                         break;
4054                 case 0x02:
4055                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4056                                         LAUNCH_BROWSER_USE_EXISTING_BROWSER;
4057                         break;
4058                 case 0x03:
4059                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4060                                         LAUNCH_BROWSER_CLOSE_AND_LAUNCH_NEW_BROWSER;
4061                         break;
4062                 case 0x04:
4063                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4064                                         LAUNCH_BROWSER_NOT_USED2;
4065                         break;
4066                 default:
4067                         sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4068                                         LAUNCH_BROWSER_RESERVED;
4069                         break;
4070         }
4071
4072         //device identifier
4073         index++;
4074         memcpy(dev_id,&cmd_data[index],4);
4075         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.language_notification.device_id);
4076         if (rv != TCORE_SAT_SUCCESS)
4077                 return rv;
4078
4079         index += 4;
4080
4081         //Browser Identity TLV - Optional
4082         if ((cmd_data[index] & 0x7F) == SATK_BROWSER_IDENTITY_TAG) {
4083                 rv = _sat_decode_browser_identity_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.launch_browser.browser_id, &data_len_consumed);
4084                 if (rv != TCORE_SAT_SUCCESS)
4085                         return rv;
4086                 index += data_len_consumed;
4087         } else {
4088                 dbg("[SAT] SAT PARSER - Browser ID NOT present");
4089         }
4090
4091         //URL TLV - Mandatory
4092         if ((cmd_data[index] & 0x7F) == SATK_URL_TAG) {
4093                 rv = _sat_decode_url_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.launch_browser.url, &data_len_consumed);
4094                 if (rv != TCORE_SAT_SUCCESS)
4095                         return rv;
4096
4097                 if (index + data_len_consumed >= o_length) {
4098                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4099                         return TCORE_SAT_SUCCESS;
4100                 } else {
4101                         dbg("[SAT] SAT PARSER -  more TLVs to decode, decoding continue.");
4102                         index += data_len_consumed;
4103                 }
4104         } else {
4105                 dbg("[SAT] SAT PARSER - Browser URL NOT present! BUG! this value is mandatory!!!");
4106                 return TCORE_SAT_REQUIRED_VALUE_MISSING;
4107         }
4108
4109         //bearer - optional
4110         if ((cmd_data[index] & 0x7F) == SATK_BEARER_TAG) {
4111                 rv = _sat_decode_bearer_tlv(o_cmd_data, o_length, index,        &sat_cmd_ind_data->data.launch_browser.bearer, &data_len_consumed);
4112                 if (rv != TCORE_SAT_SUCCESS)
4113                         return rv;
4114
4115                 if (index + data_len_consumed >= o_length) {
4116                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4117                         return TCORE_SAT_SUCCESS;
4118                 } else {
4119                         index += data_len_consumed;
4120                 }
4121         } else {
4122                 dbg("[SAT] SAT PARSER -  Bearer TLV Not present.");
4123         }
4124
4125         //Provisioning reference file - optional
4126         sat_cmd_ind_data->data.launch_browser.file_ref_count = 0;
4127         while ((cmd_data[index] & 0x7F) == SATK_PROVISIONING_REF_FILE_TAG) {
4128                 if (sat_cmd_ind_data->data.launch_browser.file_ref_count >= SAT_PROVISIONING_REF_MAX_COUNT) {
4129                         dbg("[SAT] SAT PARSER -  More number of PRF entries than can be handled");
4130                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4131                 }
4132
4133                 rv = _sat_decode_provisioning_file_ref_tlv(
4134                                                                 o_cmd_data,
4135                                                                 o_length,
4136                                                                 index,
4137                                                                 &sat_cmd_ind_data->data.launch_browser.file_list[sat_cmd_ind_data->data.launch_browser.file_ref_count],
4138                                                                 &data_len_consumed);
4139                 if (rv != TCORE_SAT_SUCCESS) {
4140                         return rv;
4141                 } else {
4142                         sat_cmd_ind_data->data.launch_browser.file_ref_count++;
4143                 }
4144
4145                 if (index + data_len_consumed >= o_length) {
4146                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4147                         return TCORE_SAT_SUCCESS;
4148                 } else {
4149                         index += data_len_consumed;
4150                 }
4151         }
4152
4153         //text string(gateway/proxy identity) - optional
4154         if ((cmd_data[index] & 0x7F) == SATK_TEXT_STRING_TAG) {
4155                 rv = _sat_decode_text_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.launch_browser.gateway_proxy_text, &data_len_consumed);
4156                 if (rv != TCORE_SAT_SUCCESS)
4157                         return rv;
4158
4159                 if (index + data_len_consumed >= o_length) {
4160                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4161                         return TCORE_SAT_SUCCESS;
4162                 } else {
4163                         index += data_len_consumed;
4164                 }
4165         }
4166
4167         //alpha identifier - optional
4168         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
4169                 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);
4170                 if (rv != TCORE_SAT_SUCCESS) {
4171                         return rv;
4172                 }
4173                 if (index + data_len_consumed >= o_length) {
4174                         dbg("[SAT] SAT PARSER -  No more TLVs to decode, decoding done.");
4175                         return TCORE_SAT_SUCCESS;
4176                 }
4177                 index+=data_len_consumed;
4178         } else {
4179                 dbg("[SAT] SAT PARSER -  No Alpha ID TLV.");
4180         }
4181
4182         //icon identifier - optional
4183         if ((cmd_data[index] & 0x7F) == SATK_ICON_IDENTIFIER_TAG) {
4184                 data_len_consumed = 0;
4185                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index,
4186                                 &sat_cmd_ind_data->data.launch_browser.user_confirm_icon_id, &data_len_consumed);
4187
4188                 if (rv != TCORE_SAT_SUCCESS) {
4189                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4190                 }
4191
4192                 if (index + data_len_consumed >= o_length) {
4193                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4194                         return TCORE_SAT_SUCCESS;
4195                 }
4196                 index += data_len_consumed; //index pointing to the Tag of next TLV
4197         }
4198
4199         //ToDo:  Text Attribute, Frame Identifier
4200         dbg("[SAT] SAT PARSER - :decoding done!.");
4201         return TCORE_SAT_SUCCESS;
4202 }
4203
4204 //6.4.27 OPEN CHANNEL
4205 static enum tcore_sat_result _sat_decode_open_channel(unsigned char* o_cmd_data, int o_length,
4206                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4207 {
4208         int index = 0;
4209         gboolean b_1st_duration = FALSE;
4210         int bearer_desc_len =0, data_len_consumed=0;
4211         unsigned char dev_id[4];
4212         unsigned char* cmd_data = NULL;
4213         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4214
4215         if (o_cmd_data == NULL) {
4216                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4217                 return TCORE_SAT_ERROR_FATAL;
4218         }
4219
4220         cmd_data = &o_cmd_data[0];
4221         index = curr_offset+2;
4222         sat_cmd_ind_data->data.open_channel.command_detail.cmd_num = cmd_data[index++];
4223         sat_cmd_ind_data->data.open_channel.command_detail.cmd_type = cmd_data[index++];
4224
4225         /** command detail **/
4226         sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.immediate_link = FALSE;
4227         sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.automatic_reconnection = FALSE;
4228         sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.background_mode = FALSE;
4229
4230         if (cmd_data[index]&0x01) {
4231                 sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.immediate_link = TRUE;
4232                 dbg("[SAT] SAT PARSER - Immediate Link Establishment");
4233         }
4234
4235         if (cmd_data[index]&0x02) {
4236                 sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.automatic_reconnection = TRUE;
4237                 dbg("[SAT] SAT PARSER - Auto Reconnection");
4238         }
4239
4240         if (cmd_data[index]&0x04) {
4241                 sat_cmd_ind_data->data.open_channel.command_detail.cmd_qualifier.open_channel.background_mode = TRUE;
4242                 dbg("[SAT] SAT PARSER - Background mode");
4243         }
4244
4245         //device identities
4246         index++;
4247         memcpy(dev_id,&cmd_data[index],4);
4248         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.open_channel.device_id);
4249         if (rv != TCORE_SAT_SUCCESS)
4250                 return rv;
4251
4252         //alpha identifier - optional
4253         index += 4;
4254         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
4255                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.open_channel.alpha_id, &data_len_consumed);
4256                 if (rv != TCORE_SAT_SUCCESS) {
4257                         return rv;
4258                 }
4259                 index+=data_len_consumed;
4260         }
4261
4262         //icon id - optional
4263         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
4264                 data_len_consumed = 0;
4265                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.open_channel.icon_id, &data_len_consumed);
4266                 if (rv != TCORE_SAT_SUCCESS) {
4267                         return rv; //SEND TR
4268                 }
4269                 index+=data_len_consumed; //index pointing to the Tag of next TLV
4270         }
4271
4272         //bearer description
4273         rv =_sat_decode_bearer_description_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.open_channel.bearer_desc, &data_len_consumed);
4274         bearer_desc_len = data_len_consumed;
4275         if (rv != TCORE_SAT_SUCCESS)
4276                 return rv;
4277         //TODO UICC SERVER MODE
4278
4279         switch(sat_cmd_ind_data->data.open_channel.bearer_desc.bearer_type) {
4280                 case BEARER_CSD:
4281
4282                         //address
4283                         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);
4284                         if (rv != TCORE_SAT_SUCCESS) {
4285                                 return rv;
4286                         }
4287                         index+=data_len_consumed;
4288
4289                         //sub address - optional
4290                         if ((cmd_data[index]&0x7F) == SATK_SUB_ADDRESS_TAG) {
4291                                 data_len_consumed = 0;
4292                                 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);
4293                                 if (rv != TCORE_SAT_SUCCESS) {
4294                                         return rv;
4295                                 }
4296                                 index+=data_len_consumed;
4297                         }
4298
4299                         //time duration 1- optional
4300                         if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
4301                                 data_len_consumed = 0;
4302                                 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);
4303                                 if (rv != TCORE_SAT_SUCCESS) {
4304                                         return rv; //SEND TR
4305                                 }
4306                                 index+=data_len_consumed;
4307                                 b_1st_duration = TRUE;
4308                         }
4309
4310                         //time duration 2- optional
4311                         if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
4312
4313                                 if (!b_1st_duration) {
4314                                         dbg("duration 1 does not present!");
4315                                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4316                                 }
4317
4318                                 data_len_consumed = 0;
4319                                 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);
4320                                 if (rv != TCORE_SAT_SUCCESS) {
4321                                         return rv; //SEND TR
4322                                 }
4323                                 index+=data_len_consumed;
4324                         }
4325
4326                         //bearer description - already did it
4327                         index+=bearer_desc_len;
4328
4329                         //buffer size
4330                         rv =_sat_decode_buffer_size_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.open_channel.buffer_size, &data_len_consumed);
4331                         if (rv != TCORE_SAT_SUCCESS) {
4332                                 return rv; //SEND TR
4333                         }
4334
4335                         index+=data_len_consumed;
4336                         if (index >= o_length) {
4337                                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4338                                 return TCORE_SAT_SUCCESS;
4339                         }
4340
4341                         //other address - optional
4342                         if ((cmd_data[index]&0x7F)==SATK_OTHER_ADDRESS_TAG) {
4343                                 data_len_consumed = 0;
4344                                 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);
4345                                 if (rv != TCORE_SAT_SUCCESS) {
4346                                         return rv; //SEND TR
4347                                 }
4348
4349                                 index+=data_len_consumed;
4350                                 if (index >= o_length) {
4351                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4352                                         return TCORE_SAT_SUCCESS;
4353                                 }
4354                         }
4355
4356                         //text string - user login - optional
4357                         if ((cmd_data[index]&0x7F)==SATK_TEXT_STRING_TAG) {
4358                                 data_len_consumed = 0;
4359                                 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);
4360                                 if (rv != TCORE_SAT_SUCCESS)
4361                                         return rv;
4362
4363                                 index+=data_len_consumed;
4364                                 if (index >= o_length) {
4365                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4366                                         return TCORE_SAT_SUCCESS;
4367                                 }
4368                         }
4369
4370                         //text string - user password - optional
4371                         if ((cmd_data[index]&0x7F)==SATK_TEXT_STRING_TAG) {
4372                                 data_len_consumed = 0;
4373                                 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);
4374                                 if (rv != TCORE_SAT_SUCCESS)
4375                                         return rv;
4376
4377                                 index+=data_len_consumed;
4378                                 if (index >= o_length) {
4379                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4380                                         return TCORE_SAT_SUCCESS;
4381                                 }
4382                         }
4383
4384                         //UICC/TERMINAL interface transport level - optional
4385                         if ((cmd_data[index]&0x7F)==SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG) {
4386                                 data_len_consumed = 0;
4387                                 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);
4388                                 if (rv != TCORE_SAT_SUCCESS)
4389                                         return rv;
4390
4391                                 index+=data_len_consumed;
4392                                 if (index >= o_length) {
4393                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4394                                         return TCORE_SAT_SUCCESS;
4395                                 }
4396                         }
4397
4398                         //destination address - optional
4399                         if ((cmd_data[index]&0x7F)==SATK_OTHER_ADDRESS_TAG) {
4400                                 data_len_consumed = 0;
4401                                 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);
4402                                 if (rv != TCORE_SAT_SUCCESS) {
4403                                         return rv; //SEND TR
4404                                 }
4405
4406                                 index+=data_len_consumed;
4407                                 if (index >= o_length) {
4408                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4409                                         return TCORE_SAT_SUCCESS;
4410                                 }
4411                         }
4412
4413                         break;
4414                 case BEARER_GPRS:
4415                         //bearer description - already did it
4416                         index+=bearer_desc_len;
4417
4418                         //buffer size
4419                         rv =_sat_decode_buffer_size_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.open_channel.buffer_size, &data_len_consumed);
4420                         if (rv != TCORE_SAT_SUCCESS) {
4421                                 return rv; //SEND TR
4422                         }
4423
4424                         index+=data_len_consumed;
4425                         if (index >= o_length) {
4426                                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4427                                 return TCORE_SAT_SUCCESS;
4428                         }
4429
4430                         //Network Access Name - optional
4431                         if ((cmd_data[index]&0x7F)==SATK_NETWORK_ACCESS_TAG) {
4432                                 data_len_consumed = 0;
4433                                 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);
4434                                 if (rv != TCORE_SAT_SUCCESS) {
4435                                         return rv; //SEND TR
4436                                 }
4437
4438                                 index+=data_len_consumed;
4439                                 if (index >= o_length) {
4440                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4441                                         return TCORE_SAT_SUCCESS;
4442                                 }
4443                         }
4444
4445                         //other address - optional
4446                         if ((cmd_data[index]&0x7F)==SATK_OTHER_ADDRESS_TAG) {
4447                                 data_len_consumed = 0;
4448                                 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);
4449                                 if (rv != TCORE_SAT_SUCCESS) {
4450                                         return rv; //SEND TR
4451                                 }
4452
4453                                 index+=data_len_consumed;
4454                                 if (index >= o_length) {
4455                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4456                                         return TCORE_SAT_SUCCESS;
4457                                 }
4458                         }
4459
4460                         //text string - user login - optional
4461                         if ((cmd_data[index]&0x7F)==SATK_TEXT_STRING_TAG) {
4462                                 data_len_consumed = 0;
4463                                 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);
4464                                 if (rv != TCORE_SAT_SUCCESS)
4465                                         return rv;
4466
4467                                 index+=data_len_consumed;
4468                                 if (index >= o_length) {
4469                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4470                                         return TCORE_SAT_SUCCESS;
4471                                 }
4472                         }
4473
4474                         //text string - user password - optional
4475                         if ((cmd_data[index]&0x7F)==SATK_TEXT_STRING_TAG) {
4476                                 data_len_consumed = 0;
4477                                 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);
4478                                 if (rv != TCORE_SAT_SUCCESS)
4479                                         return rv;
4480
4481                                 index+=data_len_consumed;
4482                                 if (index >= o_length) {
4483                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4484                                         return TCORE_SAT_SUCCESS;
4485                                 }
4486                         }
4487
4488                         //UICC/TERMINAL interface transport level - optional
4489                         if ((cmd_data[index]&0x7F)==SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG) {
4490                                 data_len_consumed = 0;
4491                                 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);
4492                                 if (rv != TCORE_SAT_SUCCESS)
4493                                         return rv;
4494
4495                                 index+=data_len_consumed;
4496                                 if (index >= o_length) {
4497                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4498                                         return TCORE_SAT_SUCCESS;
4499                                 }
4500                         }
4501
4502                         dbg("the value (0x%x) after interface transport level", cmd_data[index]&0x7F);
4503
4504                         //destination address - optional
4505                         if ((cmd_data[index]&0x7F)==SATK_OTHER_ADDRESS_TAG) {
4506                                 data_len_consumed = 0;
4507                                 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);
4508                                 if (rv != TCORE_SAT_SUCCESS) {
4509                                         return rv; //SEND TR
4510                                 }
4511
4512                                 index+=data_len_consumed;
4513                                 if (index >= o_length) {
4514                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4515                                         return TCORE_SAT_SUCCESS;
4516                                 }
4517                         }
4518
4519                         break;
4520                 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:
4521                         //bearer description - already did it
4522                         index+=bearer_desc_len;
4523
4524                         //buffer size
4525                         rv =_sat_decode_buffer_size_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.open_channel.buffer_size, &data_len_consumed);
4526                         if (rv != TCORE_SAT_SUCCESS) {
4527                                 return rv; //SEND TR
4528                         }
4529
4530                         index+=data_len_consumed;
4531                         if (index >= o_length) {
4532                                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4533                                 return TCORE_SAT_SUCCESS;
4534                         }
4535
4536                         //other address - optional
4537                         if ((cmd_data[index]&0x7F)==SATK_OTHER_ADDRESS_TAG) {
4538                                 data_len_consumed = 0;
4539                                 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);
4540                                 if (rv != TCORE_SAT_SUCCESS) {
4541                                         return rv; //SEND TR
4542                                 }
4543
4544                                 index+=data_len_consumed;
4545                                 if (index >= o_length) {
4546                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4547                                         return TCORE_SAT_SUCCESS;
4548                                 }
4549                         }
4550
4551                         //text string - user login - optional
4552                         if ((cmd_data[index]&0x7F)==SATK_TEXT_STRING_TAG) {
4553                                 data_len_consumed = 0;
4554                                 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);
4555                                 if (rv != TCORE_SAT_SUCCESS)
4556                                         return rv;
4557
4558                                 index+=data_len_consumed;
4559                                 if (index >= o_length) {
4560                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4561                                         return TCORE_SAT_SUCCESS;
4562                                 }
4563                         }
4564
4565                         //text string - user password - optional
4566                         if ((cmd_data[index]&0x7F)==SATK_TEXT_STRING_TAG) {
4567                                 data_len_consumed = 0;
4568                                 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);
4569                                 if (rv != TCORE_SAT_SUCCESS)
4570                                         return rv;
4571
4572                                 index+=data_len_consumed;
4573                                 if (index >= o_length) {
4574                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4575                                         return TCORE_SAT_SUCCESS;
4576                                 }
4577                         }
4578
4579                         //UICC/TERMINAL interface transport level - optional
4580                         if ((cmd_data[index]&0x7F)==SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG) {
4581                                 data_len_consumed = 0;
4582                                 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);
4583                                 if (rv != TCORE_SAT_SUCCESS)
4584                                         return rv;
4585
4586                                 index+=data_len_consumed;
4587                                 if (index >= o_length) {
4588                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4589                                         return TCORE_SAT_SUCCESS;
4590                                 }
4591                         }
4592
4593                         //destination address - optional
4594                         if ((cmd_data[index]&0x7F)==SATK_OTHER_ADDRESS_TAG) {
4595                                 data_len_consumed = 0;
4596                                 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);
4597                                 if (rv != TCORE_SAT_SUCCESS) {
4598                                         return rv; //SEND TR
4599                                 }
4600
4601                                 index+=data_len_consumed;
4602                                 if (index >= o_length) {
4603                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4604                                         return TCORE_SAT_SUCCESS;
4605                                 }
4606                         }
4607
4608                         break;
4609                 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:
4610
4611                         //time duration 1- optional
4612                         if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
4613                                 data_len_consumed = 0;
4614                                 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);
4615                                 if (rv != TCORE_SAT_SUCCESS) {
4616                                         return rv; //SEND TR
4617                                 }
4618                                 index+=data_len_consumed;
4619                                 b_1st_duration = TRUE;
4620                         }
4621
4622                         //time duration 2- optional
4623                         if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
4624
4625                                 if (!b_1st_duration) {
4626                                         dbg("duration 1 does not present!");
4627                                         return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4628                                 }
4629
4630                                 data_len_consumed = 0;
4631                                 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);
4632                                 if (rv != TCORE_SAT_SUCCESS) {
4633                                         return rv; //SEND TR
4634                                 }
4635                                 index+=data_len_consumed;
4636                         }
4637
4638                         //bearer description - already did it
4639                         index+=bearer_desc_len;
4640
4641                         //buffer size
4642                         rv =_sat_decode_buffer_size_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.open_channel.buffer_size, &data_len_consumed);
4643                         if (rv != TCORE_SAT_SUCCESS) {
4644                                 return rv; //SEND TR
4645                         }
4646
4647                         index+=data_len_consumed;
4648                         if (index >= o_length) {
4649                                 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4650                                 return TCORE_SAT_SUCCESS;
4651                         }
4652
4653                         //text string - user password - optional
4654                         if ((cmd_data[index]&0x7F)==SATK_TEXT_STRING_TAG) {
4655                                 data_len_consumed = 0;
4656                                 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);
4657                                 if (rv != TCORE_SAT_SUCCESS)
4658                                         return rv;
4659
4660                                 index+=data_len_consumed;
4661                                 if (index >= o_length) {
4662                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4663                                         return TCORE_SAT_SUCCESS;
4664                                 }
4665                         }
4666
4667                         //UICC/TERMINAL interface transport level - optional
4668                         if ((cmd_data[index]&0x7F)==SATK_USIM_ME_INTERFACE_TRANSPORT_LEVEL_TAG) {
4669                                 data_len_consumed = 0;
4670                                 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);
4671                                 if (rv != TCORE_SAT_SUCCESS)
4672                                         return rv;
4673
4674                                 index+=data_len_consumed;
4675                                 if (index >= o_length) {
4676                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4677                                         return TCORE_SAT_SUCCESS;
4678                                 }
4679                         }
4680
4681                         //destination address - optional
4682                         if ((cmd_data[index]&0x7F)==SATK_OTHER_ADDRESS_TAG) {
4683                                 data_len_consumed = 0;
4684                                 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);
4685                                 if (rv != TCORE_SAT_SUCCESS) {
4686                                         return rv; //SEND TR
4687                                 }
4688
4689                                 index+=data_len_consumed;
4690                                 if (index >= o_length) {
4691                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4692                                         return TCORE_SAT_SUCCESS;
4693                                 }
4694                         }
4695
4696                         //remote entity address - optional
4697                         if ((cmd_data[index]&0x7F)==SATK_REMOTE_ENTITY_ADDRESS_TAG) {
4698                                 data_len_consumed = 0;
4699                                 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);
4700                                 if (rv != TCORE_SAT_SUCCESS) {
4701                                         return rv; //SEND TR
4702                                 }
4703
4704                                 index+=data_len_consumed;
4705                                 if (index >= o_length) {
4706                                         dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4707                                         return TCORE_SAT_SUCCESS;
4708                                 }
4709                         }
4710
4711                         break;
4712                 default:
4713                         break;
4714         }//end of switch
4715
4716         dbg("[SAT] SAT PARSER - :decoding done!.");
4717         return TCORE_SAT_SUCCESS;
4718 }
4719
4720 //6.4.28 CLOSE CHANNEL
4721 static enum tcore_sat_result _sat_decode_close_channel(unsigned char* o_cmd_data, int o_length,
4722                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4723 {
4724         int index = 0;
4725         int data_len_consumed=0;
4726         unsigned char dev_id[4];
4727         unsigned char* cmd_data = NULL;
4728         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4729
4730         if (o_cmd_data == NULL) {
4731                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4732                 return TCORE_SAT_ERROR_FATAL;
4733         }
4734
4735         cmd_data = &o_cmd_data[0];
4736         index = curr_offset+2;
4737         sat_cmd_ind_data->data.close_channel.command_detail.cmd_num = cmd_data[index++];
4738         sat_cmd_ind_data->data.close_channel.command_detail.cmd_type = cmd_data[index++];
4739
4740         /** command detail **/
4741         index++; //RFU
4742
4743         //device identities
4744         memcpy(dev_id,&cmd_data[index],4);
4745         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.close_channel.device_id);
4746         if (rv != TCORE_SAT_SUCCESS)
4747                 return rv;
4748
4749         //alpha identifier - optional
4750         index += 4;
4751         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
4752                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.close_channel.alpha_id, &data_len_consumed);
4753                 if (rv != TCORE_SAT_SUCCESS) {
4754                         return rv;
4755                 }
4756                 index+=data_len_consumed;
4757         }
4758
4759         //icon id - optional
4760         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
4761                 data_len_consumed = 0;
4762                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.close_channel.icon_id, &data_len_consumed);
4763                 if (rv != TCORE_SAT_SUCCESS) {
4764                         return rv; //SEND TR
4765                 }
4766                 index+=data_len_consumed; //index pointing to the Tag of next TLV
4767         }
4768
4769         //ToDo:  Text Attribute and frames
4770
4771         dbg("[SAT] SAT PARSER - :decoding done!.");
4772         return TCORE_SAT_SUCCESS;
4773 }
4774
4775 //6.4.29 RECEIVE DATA
4776 static enum tcore_sat_result _sat_decode_receive_data(unsigned char* o_cmd_data, int o_length,
4777                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4778 {
4779         int index = 0;
4780         int data_len_consumed=0;
4781         unsigned char dev_id[4];
4782         unsigned char* cmd_data = NULL;
4783         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4784
4785         if (o_cmd_data == NULL) {
4786                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4787                 return TCORE_SAT_ERROR_FATAL;
4788         }
4789
4790         cmd_data = &o_cmd_data[0];
4791         index = curr_offset+2;
4792         sat_cmd_ind_data->data.receive_data.command_detail.cmd_num = cmd_data[index++];
4793         sat_cmd_ind_data->data.receive_data.command_detail.cmd_type = cmd_data[index++];
4794
4795         /** command detail **/
4796         index++; //RFU
4797
4798         //device identities
4799         memcpy(dev_id,&cmd_data[index],4);
4800         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.receive_data.device_id);
4801         if (rv != TCORE_SAT_SUCCESS)
4802                 return rv;
4803
4804         //alpha identifier - optional
4805         index += 4;
4806         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
4807                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.receive_data.alpha_id, &data_len_consumed);
4808                 if (rv != TCORE_SAT_SUCCESS) {
4809                         return rv;
4810                 }
4811                 index+=data_len_consumed;
4812         }
4813
4814         //icon id - optional
4815         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
4816                 data_len_consumed = 0;
4817                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.receive_data.icon_id, &data_len_consumed);
4818                 if (rv != TCORE_SAT_SUCCESS) {
4819                         return rv; //SEND TR
4820                 }
4821                 index+=data_len_consumed; //index pointing to the Tag of next TLV
4822         }
4823
4824         //channel data length
4825         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);
4826         if (rv != TCORE_SAT_SUCCESS) {
4827                 return rv; //SEND TR
4828         }
4829
4830         //ToDo:  Text Attribute and frames
4831
4832         dbg("[SAT] SAT PARSER - :decoding done!.");
4833         return TCORE_SAT_SUCCESS;
4834 }
4835
4836 //6.4.30 SEND DATA
4837 static enum tcore_sat_result _sat_decode_send_data(unsigned char* o_cmd_data, int o_length,
4838                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4839 {
4840         int index = 0;
4841         int data_len_consumed=0;
4842         unsigned char dev_id[4];
4843         unsigned char* cmd_data = NULL;
4844         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4845
4846         if (o_cmd_data == NULL) {
4847                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4848                 return TCORE_SAT_ERROR_FATAL;
4849         }
4850
4851         cmd_data = &o_cmd_data[0];
4852         index = curr_offset+2;
4853         sat_cmd_ind_data->data.send_data.command_detail.cmd_num = cmd_data[index++];
4854         sat_cmd_ind_data->data.send_data.command_detail.cmd_type = cmd_data[index++];
4855
4856         /** command detail **/
4857         sat_cmd_ind_data->data.send_data.command_detail.cmd_qualifier.send_data.send_data_immediately = FALSE;
4858         if (cmd_data[index]&0x01) {
4859                 sat_cmd_ind_data->data.send_data.command_detail.cmd_qualifier.send_data.send_data_immediately = TRUE;
4860                 dbg("[SAT] SAT PARSER - Send data immediately");
4861         }
4862
4863         //device identities
4864         index++;
4865         memcpy(dev_id,&cmd_data[index],4);
4866         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.send_data.device_id);
4867         if (rv != TCORE_SAT_SUCCESS)
4868                 return rv;
4869
4870         //alpha identifier - optional
4871         index += 4;
4872         if ((cmd_data[index]&0x7F) == SATK_ALPHA_IDENTIFIER_TAG) {
4873                 rv = _sat_decode_alpha_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_data.alpha_id, &data_len_consumed);
4874                 if (rv != TCORE_SAT_SUCCESS) {
4875                         return rv;
4876                 }
4877                 index+=data_len_consumed;
4878         }
4879
4880         //icon id - optional
4881         if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
4882                 data_len_consumed = 0;
4883                 rv = _sat_decode_icon_identifier_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_data.icon_id, &data_len_consumed);
4884                 if (rv != TCORE_SAT_SUCCESS) {
4885                         return rv; //SEND TR
4886                 }
4887                 index+=data_len_consumed; //index pointing to the Tag of next TLV
4888         }
4889
4890         //channel data
4891         rv =_sat_decode_channel_data_tlv(o_cmd_data, o_length, index, &sat_cmd_ind_data->data.send_data.channel_data, &data_len_consumed);
4892         if (rv != TCORE_SAT_SUCCESS) {
4893                 return rv; //SEND TR
4894         }
4895
4896         //ToDo:  Text Attribute and frames
4897
4898         dbg("[SAT] SAT PARSER - :decoding done!.");
4899         return TCORE_SAT_SUCCESS;
4900 }
4901
4902 //6.4.31 GET CHANNEL STATUS
4903 static enum tcore_sat_result _sat_decode_get_channel_status(unsigned char* o_cmd_data, int o_length,
4904                 int curr_offset, struct tcore_sat_proactive_command *sat_cmd_ind_data)
4905 {
4906         int index = 0;
4907         unsigned char dev_id[4];
4908         unsigned char* cmd_data = NULL;
4909         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4910
4911         if (o_cmd_data == NULL) {
4912                 dbg("[SAT] SAT PARSER -  o_cmd_data == NULL");
4913                 return TCORE_SAT_ERROR_FATAL;
4914         }
4915
4916         cmd_data = &o_cmd_data[0];
4917         index = curr_offset+2;
4918         sat_cmd_ind_data->data.get_channel_status.command_detail.cmd_num = cmd_data[index++];
4919         sat_cmd_ind_data->data.get_channel_status.command_detail.cmd_type = cmd_data[index++];
4920
4921         /** command detail **/
4922         index++; //RFU
4923
4924         //device identities
4925         memcpy(dev_id,&cmd_data[index],4);
4926         rv = _sat_decode_device_identities_tlv(dev_id, &sat_cmd_ind_data->data.get_channel_status.device_id);
4927         if (rv != TCORE_SAT_SUCCESS)
4928                 return rv;
4929
4930         dbg("[SAT] SAT PARSER - :decoding done!.");
4931         return TCORE_SAT_SUCCESS;
4932 }
4933
4934 int tcore_sat_decode_proactive_command(unsigned char* tlv_origin, unsigned int tlv_length,
4935                 struct tcore_sat_proactive_command* decoded_tlv)
4936 {
4937         unsigned int index = 0;
4938         int length_field_len = 0;
4939         enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4940
4941         if (tlv_origin == NULL || tlv_length <=2) {
4942                 dbg("[SAT] SAT PARSER - pointer pData passed is NULL or invalid length.");
4943                 return TCORE_SAT_ERROR_FATAL;
4944         }
4945
4946         //tag
4947         if (tlv_origin[index++]!= SATK_PROACTIVE_CMD_TAG) {
4948                 dbg("[SAT] SAT PARSER - Did not find Proactive command tag.tag=%d", tlv_origin[index-1]);
4949                 return TCORE_SAT_ERROR_FATAL;
4950         }
4951
4952         //length
4953         length_field_len = _get_length_filed_size(tlv_origin[index]);
4954         if (length_field_len == 0) {
4955                 dbg("[SAT] SAT PARSER - Invalid length.");
4956                 return TCORE_SAT_ERROR_FATAL;
4957         }
4958
4959         index+=length_field_len;
4960
4961         //check command validation
4962         if (tlv_length < index+5+4)//command detail(5) and device identities(4)
4963                 return TCORE_SAT_ERROR_FATAL;
4964
4965         //check comprehensive value
4966         if ((tlv_origin[index] | 0x7F) != 0x7F) {
4967                 dbg("comprehensive value 0x%x", tlv_origin[index] | 0x7F);
4968                 b_comprehensive = TRUE;
4969         }
4970
4971         if ( (tlv_origin[index] & 0x7F) != SATK_COMMAND_DETAILS_TAG) {
4972                 err("[SAT] no command detail info");
4973                 return TCORE_SAT_ERROR_FATAL;
4974         }
4975
4976         if ( tlv_origin[index+1] != SATK_COMMAND_DETAILS_LENGTH) {
4977                 err("[SAT] invalid command detail length");
4978                 return TCORE_SAT_ERROR_FATAL;
4979         }
4980
4981         decoded_tlv->cmd_num= tlv_origin[index+2];
4982         decoded_tlv->cmd_type = tlv_origin[index+3];
4983
4984         switch(decoded_tlv->cmd_type) {
4985                 case SAT_PROATV_CMD_DISPLAY_TEXT: //6.4.1
4986                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_DISPLAY_TEXT");
4987                         rv = _sat_decode_display_text(tlv_origin, tlv_length, index, decoded_tlv);
4988                         break;
4989                 case SAT_PROATV_CMD_GET_INKEY: //6.4.2
4990                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_GET_INKEY");
4991                         rv = _sat_decode_get_inkey(tlv_origin, tlv_length, index, decoded_tlv);
4992                         break;
4993                 case SAT_PROATV_CMD_GET_INPUT: //6.4.3
4994                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_GET_INPUT");
4995                         rv = _sat_decode_get_input(tlv_origin, tlv_length, index, decoded_tlv);
4996                         break;
4997                 case SAT_PROATV_CMD_MORE_TIME: //6.4.4
4998                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_MORE_TIME");
4999                         rv = _sat_decode_more_time(tlv_origin, tlv_length, index, decoded_tlv);
5000                         break;
5001                 case SAT_PROATV_CMD_PLAY_TONE: //6.4.5
5002                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_PLAY TONE");
5003                         rv = _sat_decode_play_tone(tlv_origin, tlv_length, index, decoded_tlv);
5004                         break;
5005                 //case POLL INTERVAL //6.4.6 processing by cp
5006                 case SAT_PROATV_CMD_REFRESH: //6.4.7
5007                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_REFRESH");
5008                         rv = _sat_decode_refresh(tlv_origin, tlv_length, index, decoded_tlv);
5009                         break;
5010                 case SAT_PROATV_CMD_SETUP_MENU: //6.4.8
5011                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_SETUP_MENU");
5012                         rv = _sat_decode_setup_menu(tlv_origin, tlv_length, index, decoded_tlv);
5013                         break;
5014                 case SAT_PROATV_CMD_SELECT_ITEM: //6.4.9
5015                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SELECT_ITEM");
5016                         rv = _sat_decode_select_item(tlv_origin, tlv_length, index, decoded_tlv);
5017                         break;
5018                 case SAT_PROATV_CMD_SEND_SMS: //6.4.10
5019                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SEND_SMS");
5020                         rv = _sat_decode_send_sms(tlv_origin, tlv_length, index, decoded_tlv);
5021                         break;
5022                 case SAT_PROATV_CMD_SEND_SS: //6.4.11
5023                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SEND_SS");
5024                         rv = _sat_decode_send_ss(tlv_origin, tlv_length, index, decoded_tlv);
5025                         break;
5026                 case SAT_PROATV_CMD_SEND_USSD: //6.4.12
5027                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SEND_USSD");
5028                         rv = _sat_decode_send_ussd(tlv_origin, tlv_length, index, decoded_tlv);
5029                         break;
5030                 case SAT_PROATV_CMD_SETUP_CALL: //6.4.13
5031                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SETUP_CALL");
5032                         rv = _sat_decode_setup_call(tlv_origin, tlv_length, index, decoded_tlv);
5033                         break;
5034                 case SAT_PROATV_CMD_PROVIDE_LOCAL_INFO: //6.4.15
5035                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_PROVIDE_LOCAL_INFO");
5036                         rv = _sat_decode_provide_local_info(tlv_origin, tlv_length, index, decoded_tlv);
5037                         break;
5038                 case SAT_PROATV_CMD_SETUP_EVENT_LIST: //6.4.16
5039                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SETUP_EVENT_LIST");
5040                         rv = _sat_decode_setup_event_list(tlv_origin, tlv_length, index, decoded_tlv);
5041                         break;
5042                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT: //6.4.22
5043                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT");
5044                         rv = _sat_decode_setup_idle_mode_text(tlv_origin, tlv_length, index, decoded_tlv);
5045                         break;
5046                 case SAT_PROATV_CMD_SEND_DTMF: //6.4.24
5047                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_SEND_DTMF");
5048                         rv = _sat_decode_send_dtmf(tlv_origin, tlv_length, index, decoded_tlv);
5049                         break;
5050                 case SAT_PROATV_CMD_LANGUAGE_NOTIFICATION: //6.4.25
5051                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_LANGUAGE_NOTIFICATION");
5052                         rv = _sat_decode_language_notification(tlv_origin, tlv_length, index, decoded_tlv);
5053                         break;
5054                 case SAT_PROATV_CMD_LAUNCH_BROWSER: //6.4.26
5055                         dbg("[SAT] SAT PARSER - SAT_PROATV_CMD_LAUNCH_BROWSER");
5056                         rv = _sat_decode_launch_browser(tlv_origin, tlv_length, index, decoded_tlv);
5057                         break;
5058                 case SAT_PROATV_CMD_OPEN_CHANNEL://6.4.27
5059                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_OPEN_CHANNEL");
5060                         rv = _sat_decode_open_channel(tlv_origin, tlv_length, index, decoded_tlv);
5061                         break;
5062                 case SAT_PROATV_CMD_CLOSE_CHANNEL://6.4.28
5063                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_CLOSE_CHANNEL");
5064                         rv = _sat_decode_close_channel(tlv_origin, tlv_length, index, decoded_tlv);
5065                         break;
5066                 case SAT_PROATV_CMD_RECEIVE_DATA://6.4.29
5067                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_RECEIVE_DATA");
5068                         rv = _sat_decode_receive_data(tlv_origin, tlv_length, index, decoded_tlv);
5069                         break;
5070                 case SAT_PROATV_CMD_SEND_DATA://6.4.30
5071                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_SEND_DATA");
5072                         rv = _sat_decode_send_data(tlv_origin, tlv_length, index, decoded_tlv);
5073                         break;
5074                 case SAT_PROATV_CMD_GET_CHANNEL_STATUS://6.4.31
5075                         dbg("[SAT] SAT PARSER - SAT_CMD_TYPE_GET_CHANNEL_STATUS");
5076                         rv = _sat_decode_get_channel_status(tlv_origin, tlv_length, index, decoded_tlv);
5077                         break;
5078                 default:
5079                         dbg("[SAT] SAT PARSER - ME cannot perform this command =0x[%02x]", decoded_tlv->cmd_type);
5080                         //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.
5081                         rv = TCORE_SAT_BEYOND_ME_CAPABILITY;
5082                         break;
5083         }
5084
5085         //return value will be success if the proactive command has been successfuly decoded, then send it to clients.
5086         dbg("[SAT] SAT PARSER - each command parsing done.");
5087         return rv;
5088 }
5089
5090 static unsigned char _sat_encode_dcs_tlv(const struct data_coding_scheme* src)
5091 {
5092         unsigned char rv = 0x00;
5093
5094         if (src == NULL)
5095                 return 0;
5096
5097         if (src->is_compressed_format)
5098                 rv |= 0x20;
5099
5100         //msg class
5101         switch(src->m_class) {
5102                 case MSG_CLASS_0:
5103                 case MSG_CLASS_1:
5104                 case MSG_CLASS_2:
5105                 case MSG_CLASS_3:
5106                         rv |= 0x10;
5107                         rv |= src->m_class;
5108                 break;
5109
5110                 case MSG_CLASS_RESERVED:
5111                 case MSG_CLASS_NONE:
5112                 default:
5113                         rv &= 0xEF;
5114                         break;
5115         }
5116
5117         //alphabet format
5118         switch(src->a_format)
5119         {
5120                 case ALPHABET_FORMAT_SMS_DEFAULT:
5121                         rv &= 0xF3;
5122                         break;
5123
5124                 case ALPHABET_FORMAT_8BIT_DATA:
5125                         rv |= 0x04;
5126                         break;
5127
5128                 case ALPHABET_FORMAT_UCS2:
5129                         rv |= 0x08;
5130                         break;
5131
5132                 default:
5133                         rv |= 0x0C;
5134                         break;
5135         }
5136
5137         return rv;
5138 }
5139
5140 static int _sat_encode_command_detail_tlv(const struct tel_sat_cmd_detail_info* src, char *dst, int current_index)
5141 {
5142         dst[current_index++] = (b_comprehensive ? (SATK_COMMAND_DETAILS_TAG | 0x80) : SATK_COMMAND_DETAILS_TAG);
5143         dst[current_index++] = SATK_COMMAND_DETAILS_LENGTH;
5144         dst[current_index++] = src->cmd_num;
5145         dst[current_index++] = src->cmd_type;
5146         dst[current_index] = 0x00;
5147
5148         switch(src->cmd_type) {
5149                 case SAT_PROATV_CMD_DISPLAY_TEXT:{
5150                         //command detail text priority
5151                         if (src->cmd_qualifier.display_text.text_priority == TEXT_PRIORITY_HIGH)
5152                                 dst[current_index] += 0x01;
5153
5154                         //command detail text clear type
5155                         if (src->cmd_qualifier.display_text.text_clear_type == TEXT_WAIT_FOR_USER_TO_CLEAR_MSG)
5156                                 dst[current_index] += 0x80;
5157                 }break;
5158                 case SAT_PROATV_CMD_GET_INKEY:{
5159                         //command detail alphabet set
5160                         if (src->cmd_qualifier.get_inkey.alphabet_set)
5161                                 dst[current_index] += 0x01;
5162
5163                         //command detail alphabet type
5164                         if (src->cmd_qualifier.get_inkey.alphabet_type == INPUT_ALPHABET_TYPE_UCS2)
5165                                 dst[current_index] += 0x02;
5166
5167                         //command detail get inkey type
5168                         if (src->cmd_qualifier.get_inkey.inkey_type == INKEY_TYPE_YES_NO_REQUESTED)
5169                                 dst[current_index] += 0x04;
5170
5171
5172                         //command detail immediate response required
5173                         if (src->cmd_qualifier.get_inkey.immediate_rsp_required)
5174                                 dst[current_index] += 0x08;
5175
5176                         //command detail help available
5177                         if (src->cmd_qualifier.get_inkey.help_info)
5178                                 dst[current_index] += 0x80;
5179                 }break;
5180                 case SAT_PROATV_CMD_GET_INPUT:{
5181                         //command detail alphabet set
5182                         if (src->cmd_qualifier.get_input.alphabet_set)
5183                                 dst[current_index] += 0x01;
5184
5185                         //command detail alphabet type
5186                         if (src->cmd_qualifier.get_input.alphabet_type == INPUT_ALPHABET_TYPE_UCS2)
5187                                 dst[current_index] += 0x02;
5188
5189                         //command detail echo user input
5190                         if (!src->cmd_qualifier.get_input.me_echo_user_input)
5191                                 dst[current_index] += 0x04;
5192
5193                         //command detail user input unpacked format
5194                         if (!src->cmd_qualifier.get_input.user_input_unpacked_format)
5195                                 dst[current_index] += 0x08;
5196
5197                         //command detail help available
5198                         if (src->cmd_qualifier.get_input.help_info)
5199                                 dst[current_index] += 0x80;
5200                 }break;
5201                 case SAT_PROATV_CMD_MORE_TIME:{
5202                         dbg("more time : 1bit RFU")
5203                 }break;
5204                 case SAT_PROATV_CMD_PLAY_TONE:{
5205                         //command detail vibration alert
5206                         if (src->cmd_qualifier.play_tone.vibration_alert == VIBRATE_ALERT_REQUIRED)
5207                                 dst[current_index] += 0x01;
5208                 }break;
5209                 case SAT_PROATV_CMD_REFRESH:{
5210                         //command detail refresh command
5211                         dst[current_index] += src->cmd_qualifier.refresh.refresh;
5212                 }break;
5213                 case SAT_PROATV_CMD_SETUP_MENU:{
5214                         //command detail preferences
5215                         if (src->cmd_qualifier.setup_menu.select_preference == SELECTION_PREFERENCE_USING_SOFT_KEY)
5216                                 dst[current_index] += 0x01;
5217
5218                         //command detail help available
5219                         if (src->cmd_qualifier.setup_menu.help_info)
5220                                 dst[current_index] += 0x80;
5221                 }break;
5222                 case SAT_PROATV_CMD_SELECT_ITEM:{
5223                         //command detail presentation
5224                         if (src->cmd_qualifier.select_item.presentation_type != PRESENTATION_TYPE_NOT_SPECIFIED) {
5225                                 dst[current_index] += 0x01;
5226                                 if (src->cmd_qualifier.select_item.presentation_type == PRESENTATION_TYPE_NAVIGATION_OPTION) {
5227                                         dst[current_index] += PRESENTATION_TYPE_NAVIGATION_OPTION;
5228                                 }
5229                         }
5230
5231                         //command detail selection preference
5232                         if (src->cmd_qualifier.select_item.select_preference == SELECTION_PREFERENCE_USING_SOFT_KEY)
5233                                 dst[current_index] += 0x04;
5234
5235                         //command detail help available
5236                         if (src->cmd_qualifier.select_item.help_info)
5237                                 dst[current_index] += 0x80;
5238                 }break;
5239                 case SAT_PROATV_CMD_SEND_SMS:{
5240                         //command detail sms packing by me required
5241                         if (src->cmd_qualifier.send_sms.packing_by_me_required)
5242                                 dst[current_index] += 0x01;
5243                 }break;
5244                 case SAT_PROATV_CMD_SETUP_CALL:{
5245                         //command detail setup call command;
5246                         dst[current_index] += src->cmd_qualifier.setup_call.setup_call;
5247                 }break;
5248                 case SAT_PROATV_CMD_SETUP_EVENT_LIST:{
5249                         dbg("setup evnet list : 1bit RFU")
5250                 }break;
5251                 case SAT_PROATV_CMD_OPEN_CHANNEL:{
5252                         if (src->cmd_qualifier.open_channel.immediate_link)
5253                                 dst[current_index] += 0x01;
5254                         if (src->cmd_qualifier.open_channel.automatic_reconnection)
5255                                 dst[current_index] += 0x02;
5256                         if (src->cmd_qualifier.open_channel.background_mode)
5257                                 dst[current_index] += 0x04;
5258                 }break;
5259                 case SAT_PROATV_CMD_SEND_DATA:{
5260                         if (src->cmd_qualifier.send_data.send_data_immediately)
5261                                 dst[current_index] += 0x01;
5262                 }break;
5263                 case SAT_PROATV_CMD_PROVIDE_LOCAL_INFO:{
5264                         dst[current_index] += src->cmd_qualifier.provide_local_info.provide_local_info;
5265                 }break;
5266                 case SAT_PROATV_CMD_LANGUAGE_NOTIFICATION:{
5267                         if (src->cmd_qualifier.language_notification.specific_language)
5268                                 dst[current_index] += 0x01;
5269                 }break;
5270                 case SAT_PROATV_CMD_LAUNCH_BROWSER:{
5271                                 dst[current_index] += src->cmd_qualifier.launch_browser.launch_browser;
5272                 }break;
5273                 default:
5274                         err("no matched cmd type(%d)", src->cmd_type);
5275                         break;
5276         }
5277
5278         return 5;
5279 }
5280
5281 static int _sat_encode_device_identities_tlv(const struct tel_sat_device_identities* src, char *dst, int current_index)
5282 {
5283         dst[current_index++] = (b_comprehensive ? (SATK_DEVICE_IDENTITY_TAG | 0x80) : SATK_DEVICE_IDENTITY_TAG);
5284         dst[current_index++] =SATK_DEVICE_IDENTITY_LENGTH;
5285         dst[current_index++] = src->src;
5286         dst[current_index++] = src->dest;
5287
5288         //device identities total len 4
5289         return 4;
5290 }
5291
5292 static int _sat_encode_item_identifier_tlv(const struct tel_sat_item_identifier* src, char *dst, int current_index)
5293 {
5294         dst[current_index++] =SATK_ITEM_IDENTIFIER_TAG;
5295         dst[current_index++] =SATK_ITEM_IDENTIFIER_LENGTH;
5296         dst[current_index++] = src->item_identifier;
5297
5298         //item identifier total len 3
5299         return 3;
5300 }
5301
5302 /*static int _sat_encode_duration_tlv(const struct tel_sat_duration* src, char *dst, int current_index)
5303 {
5304         dst[current_index++] =SATK_DURATION_TAG;
5305         dst[current_index++] =SATK_DURATION_LENGTH;
5306         dst[current_index++] = src->time_unit;
5307         dst[current_index++] = src->time_interval;
5308
5309         //duration total len 4
5310         return 4;
5311 }*/
5312
5313 static int _sat_encode_text_tlv(const struct tel_sat_text_string_object* src, char *dst, int current_index, gboolean raw_dcs)
5314 {
5315         int total_len = 0;
5316         int length_index = 0;
5317
5318         //tag
5319         dst[current_index++] =SATK_TEXT_STRING_TAG;
5320
5321         //length
5322         if (src->string_length <= 0x7F) {
5323                 dst[current_index++] =SATK_DCS_LENGTH+src->string_length;
5324                 length_index = 1;
5325         }
5326         else{
5327                 dst[current_index++] = 0x81;
5328                 dst[current_index++] =SATK_DCS_LENGTH+src->string_length;
5329                 length_index = 2;
5330         }
5331
5332         //dcs
5333         if (raw_dcs)
5334                 dst[current_index++] = src->dcs.raw_dcs;
5335         else
5336                 dst[current_index++] =_sat_encode_dcs_tlv(&(src->dcs));
5337
5338         //value
5339         if (src->string_length > 0) {
5340                 memcpy(&(dst[current_index]), src->string, src->string_length);
5341         }
5342
5343         //tag+index+dcs+data
5344         total_len = 1+length_index+1+src->string_length;
5345
5346         return total_len;
5347 }
5348
5349 static int _sat_encode_eventlist_tlv(const enum event_list src, char *dst, int current_index)
5350 {
5351         dst[current_index++] =SATK_EVENT_LIST_TAG;
5352         dst[current_index++] =0x01;
5353         dst[current_index++] =src;
5354
5355         return 3;
5356 }
5357
5358 static int _sat_encode_date_time_and_timezone_tlv(const struct tel_sat_date_time_and_timezone *src, char *dst, int current_index)
5359 {
5360         dst[current_index++] = SATK_DATE_TIME_AND_TIME_ZONE_TAG;
5361         dst[current_index++] = SATK_DATE_TIME_AND_TIME_ZONE_LENGTH;
5362         dst[current_index++] = src->year;
5363         dst[current_index++] = src->month;
5364         dst[current_index++] = src->day;
5365         dst[current_index++] = src->hour;
5366         dst[current_index++] = src->minute;
5367         dst[current_index++] = src->second;
5368         dst[current_index++] = src->timeZone;
5369
5370         return 1+1+SATK_DATE_TIME_AND_TIME_ZONE_LENGTH; //tag length+len field length+value length;
5371 }
5372
5373 static int _sat_encode_language_tlv(const enum tel_sim_language_type src, char *dst, int current_index)
5374 {
5375         dst[current_index++] =SATK_LANGUAGE_TAG;
5376         dst[current_index++] =SATK_LANGUAGE_LENGTH;
5377
5378         dbg("language (%d)", src);
5379
5380         switch(src) {
5381
5382                 case SIM_LANG_GERMAN :
5383                         dst[current_index++] = 'd';
5384                         dst[current_index++] = 'e';
5385                         break;
5386
5387                 case SIM_LANG_ENGLISH :
5388                         dst[current_index++] = 'e';
5389                         dst[current_index++] = 'n';
5390                         break;
5391
5392                 case SIM_LANG_ITALIAN :
5393                         dst[current_index++] = 'i';
5394                         dst[current_index++] = 't';
5395                         break;
5396
5397                 case SIM_LANG_FRENCH :
5398                         dst[current_index++] = 'f';
5399                         dst[current_index++] = 'r';
5400                         break;
5401
5402                 case SIM_LANG_SPANISH :
5403                         dst[current_index++] = 'e';
5404                         dst[current_index++] = 's';
5405                         break;
5406
5407                 case SIM_LANG_DUTCH :
5408                         dst[current_index++] = 'n';
5409                         dst[current_index++] = 'l';
5410                         break;
5411
5412                 case SIM_LANG_SWEDISH :
5413                         dst[current_index++] = 's';
5414                         dst[current_index++] = 'v';
5415                         break;
5416
5417                 case SIM_LANG_DANISH :
5418                         dst[current_index++] = 'd';
5419                         dst[current_index++] = 'a';
5420                         break;
5421
5422                 case SIM_LANG_PORTUGUESE :
5423                         dst[current_index++] = 'p';
5424                         dst[current_index++] = 't';
5425                         break;
5426
5427                 case SIM_LANG_FINNISH :
5428                         dst[current_index++] = 'f';
5429                         dst[current_index++] = 'i';
5430                         break;
5431
5432                 case SIM_LANG_NORWEGIAN :
5433                         dst[current_index++] = 'n';
5434                         dst[current_index++] = 'b';
5435                         break;
5436
5437                 case SIM_LANG_GREEK :
5438                         dst[current_index++] = 'e';
5439                         dst[current_index++] = 'l';
5440                         break;
5441
5442                 case SIM_LANG_TURKISH :
5443                         dst[current_index++] = 't';
5444                         dst[current_index++] = 'k';
5445                         break;
5446
5447                 case SIM_LANG_HUNGARIAN :
5448                         dst[current_index++] = 'h';
5449                         dst[current_index++] = 'u';
5450                         break;
5451
5452                 case SIM_LANG_POLISH :
5453                         dst[current_index++] = 'p';
5454                         dst[current_index++] = 'l';
5455                         break;
5456
5457                 default:{
5458                         dst[current_index++] = 'e';
5459                         dst[current_index++] = 'n';
5460                         dbg("[SAT] SAT PARSER - Unknown Language: 0x%x",src);
5461                         break;
5462                 }
5463         }
5464         return 4;
5465 }
5466
5467 static int _sat_encode_browser_termination_tlv(const enum browser_termination_cause src, char *dst, int current_index)
5468 {
5469         dst[current_index++] =SATK_BROWSER_TERMINATION_CAUSE_TAG;
5470         dst[current_index++] =SATK_BROWSER_TERMINATION_CAUSE_LENGTH;
5471         dst[current_index++] =src;
5472
5473         return 3;
5474 }
5475
5476 static int _sat_encode_bearer_desc_tlv(const struct tel_sat_bearer_description* src, char *dst, int current_index)
5477 {
5478         int total_len = 0;
5479         int length_index = 0;
5480
5481         dst[current_index++] =SATK_BEARER_DISCRIPTION_TAG;
5482
5483         //length index
5484         length_index = current_index++;
5485
5486         //bearer type
5487         dst[current_index++] = src->bearer_type;
5488
5489         switch(src->bearer_type) {
5490                 case BEARER_CSD:{
5491                         dst[current_index++] = src->bearer_parameter.cs_bearer_param.data_rate;
5492                         dst[current_index++] = src->bearer_parameter.cs_bearer_param.service_type;
5493                         dst[current_index++] = src->bearer_parameter.cs_bearer_param.connection_element_type;
5494                 }break;
5495                 case BEARER_GPRS:{
5496                         dst[current_index++] = src->bearer_parameter.ps_bearer_param.precedence_class;
5497                         dst[current_index++] = src->bearer_parameter.ps_bearer_param.delay_class;
5498                         dst[current_index++] = src->bearer_parameter.ps_bearer_param.reliability_class;
5499                         dst[current_index++] = src->bearer_parameter.ps_bearer_param.peak_throughput_class;
5500                         dst[current_index++] = src->bearer_parameter.ps_bearer_param.mean_throughput_class;
5501                         dst[current_index++] = src->bearer_parameter.ps_bearer_param.pdp_type;
5502                 }break;
5503                 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:
5504                 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:
5505                 default:
5506                 break;
5507         }
5508
5509         dst[length_index] = (current_index-1) - length_index;
5510         total_len = (current_index-1) - length_index + 2; //tag and length
5511
5512         return total_len;
5513 }
5514
5515 static int _sat_encode_buffer_size_tlv(const struct tel_sat_buffer_size* src, char *dst, int current_index)
5516 {
5517         dst[current_index++] = SATK_BUFFER_SIZE_TAG;
5518         dst[current_index++] = SATK_BUFFER_SIZE_LENGTH;
5519         dst[current_index++] = src->size[0];
5520         dst[current_index++] = src->size[1];
5521
5522         return 4;
5523 }
5524
5525 static int _sat_encode_channel_data_tlv(const struct tel_sat_channel_data* src, char *dst, int current_index)
5526 {
5527         int total_len = 0;
5528         int length_index = 0;
5529
5530         dst[current_index++] = SATK_CHANNEL_DATA_TAG;
5531
5532         if (src->data_string_len <= 0x7F) {
5533                 dst[current_index++] = src->data_string_len;
5534                 length_index = 1;
5535         }
5536         else{
5537                 dst[current_index++] = 0x81;
5538                 dst[current_index++] = src->data_string_len;
5539                 length_index = 2;
5540         }
5541
5542         memcpy(&(dst[current_index]), src->data_string, src->data_string_len);
5543
5544         total_len = 1+length_index+src->data_string_len;
5545
5546         return total_len;
5547 }
5548
5549 static int _sat_encode_channel_data_length_tlv(const struct tel_sat_channel_data_len* src, char *dst, int current_index)
5550 {
5551         dst[current_index++] = SATK_CHANNEL_DATA_LEN_TAG;
5552         dst[current_index++] = SATK_CHANNEL_DATA_LENGTH_VALUE_LENGTH;
5553         dst[current_index++] = src->data_len;
5554
5555         return 3;
5556 }
5557
5558 static int _sat_encode_channel_status_tlv(const struct tel_sat_channel_status* src, char *dst, int current_index)
5559 {
5560         dst[current_index++] = SATK_CHANNEL_STATUS_TAG;
5561         dst[current_index++] = SATK_CHANNEL_STATUS_LENGTH;
5562
5563         if (src->status == link_or_packet_service_activated) //(bit 8)
5564                 dst[current_index] += 0x80;
5565
5566         dst[current_index++] += src->channel_id; //(bit 1~3)
5567         dst[current_index++] = src->status_info;
5568
5569         return 4;
5570 }
5571
5572 static int _sat_encode_download_event(const struct tel_sat_envelop_event_download_tlv *evt_dl, char *dst_envelop)
5573 {
5574         int index = 2;
5575         int encoded_len = 0;
5576
5577         dbg("event type(%d)", evt_dl->event);
5578
5579         //event list
5580         encoded_len = _sat_encode_eventlist_tlv(evt_dl->event, dst_envelop, index);
5581         index += encoded_len;
5582
5583         //device id - len 4
5584         encoded_len =_sat_encode_device_identities_tlv(&(evt_dl->device_identitie), dst_envelop, index);
5585         index += encoded_len;
5586
5587         switch(evt_dl->event) {
5588                 case EVENT_LANGUAGE_SELECTION:
5589                         encoded_len = _sat_encode_language_tlv(evt_dl->language, dst_envelop, index);
5590                         index += encoded_len;
5591                         break;
5592                 case EVENT_BROWSER_TERMINATION:
5593                         encoded_len = _sat_encode_browser_termination_tlv(evt_dl->browser_termination, dst_envelop, index);
5594                         index += encoded_len;
5595                         break;
5596                 case EVENT_DATA_AVAILABLE:
5597                         encoded_len = _sat_encode_channel_status_tlv(&(evt_dl->channel_status), dst_envelop, index);
5598                         index += encoded_len;
5599
5600                         encoded_len = _sat_encode_channel_data_length_tlv(&(evt_dl->channel_data_len), dst_envelop, index);
5601                         index += encoded_len;
5602                         break;
5603                 case EVENT_CHANNEL_STATUS:
5604                         encoded_len = _sat_encode_channel_status_tlv(&(evt_dl->channel_status), dst_envelop, index);
5605                         index += encoded_len;
5606                         break;
5607                 default:
5608                         break;
5609         }
5610
5611         dst_envelop[0] = SATK_EVENT_DOWNLOAD_TAG;
5612         dst_envelop[1] = index-2;
5613
5614         dbg("download envelop cmd len(%d)", index);
5615
5616         if (index-2 > 0x7F) {
5617                 int idx = 0;
5618                 for(idx = index; idx > 0; idx--) {
5619                         dst_envelop[idx] = dst_envelop[idx+1];
5620                 }
5621                 dst_envelop[1] = 0x81;
5622                 index += 1;
5623                 dbg("download envelop added cmd len(%d)", index);
5624         }
5625
5626         return index;
5627 }
5628
5629 int tcore_sat_encode_envelop_cmd(const struct treq_sat_envelop_cmd_data *src_envelop, char *dst_envelop)
5630 {
5631         int index = 0, encoded_len= 0;
5632
5633         if (!dst_envelop)
5634                 return 0;
5635
5636         if (src_envelop->sub_cmd == ENVELOP_MENU_SELECTION) {
5637                 index = 2; //set the cursor to device identity
5638                 dbg("item id(%d)", src_envelop->envelop_data.menu_select.item_identifier.item_identifier);
5639                 encoded_len =_sat_encode_device_identities_tlv(&(src_envelop->envelop_data.menu_select.device_identitie), dst_envelop, index);
5640                 index += encoded_len;
5641
5642                 //item identifier
5643                 encoded_len = _sat_encode_item_identifier_tlv(&(src_envelop->envelop_data.menu_select.item_identifier), dst_envelop, index);
5644                 index += encoded_len;
5645
5646                 if (src_envelop->envelop_data.menu_select.help_request) {
5647                         encoded_len = 2;//help request
5648                         dst_envelop[index++] = SATK_HELP_REQUEST_TAG;
5649                         dst_envelop[index++] = SATK_HELP_REQUEST_LENGTH;
5650                 }
5651
5652                 dbg("menu selection cmd len(%d)", index);
5653
5654                 //main cmd
5655                 dst_envelop[0] = SATK_MENU_SELECTION_TAG;
5656                 dst_envelop[1] = index-2;
5657         }
5658         else if (src_envelop->sub_cmd == ENVELOP_EVENT_DOWNLOAD) {
5659                 index = _sat_encode_download_event(&(src_envelop->envelop_data.event_download),dst_envelop);
5660         }
5661
5662         return index;
5663 }
5664
5665
5666
5667 static int _sat_encode_display_text(const struct tel_sat_tr_display_text_tlv *src_tr, char *dst_tr)
5668 {
5669         int index = 0, encoded_len = 0;
5670
5671         //set command detail info
5672         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5673         index += encoded_len;
5674
5675         //set device identities info
5676         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5677         index += encoded_len;
5678
5679         //set result info
5680         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);
5681         switch(src_tr->result_type) {
5682                 case RESULT_SUCCESS:
5683                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
5684                 case RESULT_SUCCESS_WITH_MISSING_INFO:
5685                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
5686                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
5687                 case RESULT_BACKWARD_MOVE_BY_USER:
5688                 case RESULT_NO_RESPONSE_FROM_USER:
5689                 case RESULT_BEYOND_ME_CAPABILITIES:
5690                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
5691                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
5692                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
5693                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
5694                         dst_tr[index++] = 1;
5695                         dst_tr[index++] = src_tr->result_type;
5696                         break;
5697                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
5698                 case RESULT_FRAMES_ERROR:
5699                         dst_tr[index++] = 2;
5700                         dst_tr[index++] = src_tr->result_type;
5701                         dst_tr[index++] = src_tr->me_problem_type;
5702                         break;
5703                 default:
5704                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5705                         index = 0;
5706                         break;
5707         }
5708
5709         return index;
5710 }
5711
5712 static int _sat_encode_get_inkey(const struct tel_sat_tr_get_inkey_tlv *src_tr, char *dst_tr)
5713 {
5714         int index = 0, encoded_len = 0;
5715
5716         //set command detail info
5717         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5718         index += encoded_len;
5719
5720         //set device identities info
5721         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5722         index += encoded_len;
5723
5724         //set result info
5725         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
5726
5727         switch(src_tr->result_type) {
5728                 case RESULT_SUCCESS:
5729                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
5730                 case RESULT_SUCCESS_WITH_MISSING_INFO:
5731                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
5732                         dst_tr[index++] = 1;
5733                         dst_tr[index++] = src_tr->result_type;
5734
5735                         encoded_len = _sat_encode_text_tlv(&(src_tr->text), dst_tr, index, FALSE);
5736                         index += encoded_len;
5737                         break;
5738                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
5739                 case RESULT_BACKWARD_MOVE_BY_USER:
5740                 case RESULT_HELP_INFO_REQUIRED_BY_USER:
5741                 case RESULT_BEYOND_ME_CAPABILITIES:
5742                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
5743                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
5744                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
5745                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
5746                 case RESULT_NO_RESPONSE_FROM_USER:
5747                         dst_tr[index++] = 1;
5748                         dst_tr[index++] = src_tr->result_type;
5749                         break;
5750                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
5751                 case RESULT_FRAMES_ERROR:
5752                         dst_tr[index++] = 2;
5753                         dst_tr[index++] = src_tr->result_type;
5754                         dst_tr[index++] = src_tr->me_problem_type;
5755                         break;
5756                 default:
5757                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5758                         index = 0;
5759                         break;
5760         }
5761
5762         return index;
5763 }
5764
5765 static int _sat_encode_get_input(const struct tel_sat_tr_get_input_tlv *src_tr, char *dst_tr)
5766 {
5767         int index = 0, encoded_len = 0;
5768
5769         //set command detail info
5770         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5771         index += encoded_len;
5772
5773         //set device identities info
5774         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5775         index += encoded_len;
5776
5777         //set result info
5778         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
5779
5780         switch(src_tr->result_type) {
5781                 case RESULT_SUCCESS:
5782                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
5783                 case RESULT_SUCCESS_WITH_MISSING_INFO:
5784                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
5785                         dst_tr[index++] = 1;
5786                         dst_tr[index++] = src_tr->result_type;
5787
5788                         encoded_len = _sat_encode_text_tlv(&(src_tr->text), dst_tr, index, FALSE);
5789                         index += encoded_len;
5790                         break;
5791                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
5792                 case RESULT_BACKWARD_MOVE_BY_USER:
5793                 case RESULT_NO_RESPONSE_FROM_USER:
5794                 case RESULT_HELP_INFO_REQUIRED_BY_USER:
5795                 case RESULT_BEYOND_ME_CAPABILITIES:
5796                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
5797                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
5798                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
5799                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
5800                         dst_tr[index++] = 1;
5801                         dst_tr[index++] = src_tr->result_type;
5802                         break;
5803                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
5804                 case RESULT_FRAMES_ERROR:
5805                         dst_tr[index++] = 2;
5806                         dst_tr[index++] = src_tr->result_type;
5807                         dst_tr[index++] = src_tr->me_problem_type;
5808                         break;
5809                 default:
5810                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5811                         index =0;
5812                         break;
5813         }
5814
5815         return index;
5816 }
5817
5818 static int _sat_encode_more_time(const struct tel_sat_tr_more_time_tlv *src_tr, char *dst_tr)
5819 {
5820         int index = 0, encoded_len = 0;
5821
5822         //set command detail info
5823         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5824         index += encoded_len;
5825
5826         //set device identities info
5827         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5828         index += encoded_len;
5829
5830         //set result info
5831         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
5832
5833         switch(src_tr->result_type) {
5834                 case RESULT_SUCCESS:
5835                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
5836                 case RESULT_SUCCESS_WITH_MISSING_INFO:
5837                 case RESULT_BEYOND_ME_CAPABILITIES:
5838                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
5839                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
5840                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
5841                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
5842                         dst_tr[index++] = 1;
5843                         dst_tr[index++] = src_tr->result_type;
5844                         break;
5845                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
5846                         dst_tr[index++] = 2;
5847                         dst_tr[index++] = src_tr->result_type;
5848                         dst_tr[index++] = src_tr->me_problem_type;
5849                         break;
5850                 default:
5851                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5852                         index = 0;
5853                         break;
5854         }
5855
5856         return index;
5857 }
5858
5859 static int _sat_encode_play_tone(const struct tel_sat_tr_play_tone_tlv *src_tr, char *dst_tr)
5860 {
5861         int index = 0, encoded_len = 0;
5862
5863         //set command detail info
5864         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5865         index += encoded_len;
5866
5867         //set device identities info
5868         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5869         index += encoded_len;
5870
5871         //set result info
5872         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
5873
5874         switch(src_tr->result_type) {
5875                 case RESULT_SUCCESS:
5876                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
5877                 case RESULT_SUCCESS_WITH_MISSING_INFO:
5878                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
5879                 case RESULT_SUCCESS_BUT_TONE_NOT_PLAYED:
5880                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
5881                 case RESULT_BEYOND_ME_CAPABILITIES:
5882                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
5883                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
5884                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
5885                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
5886                         dst_tr[index++] = 1;
5887                         dst_tr[index++] = src_tr->result_type;
5888                         break;
5889                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
5890                 case RESULT_FRAMES_ERROR:
5891                         dst_tr[index++] = 2;
5892                         dst_tr[index++] = src_tr->result_type;
5893                         dst_tr[index++] = src_tr->me_problem_type;
5894                         break;
5895                 default:
5896                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5897                         index = 0;
5898                         break;
5899         }
5900
5901         return index;
5902 }
5903
5904 static int _sat_encode_refresh(const struct tel_sat_tr_refresh_tlv *src_tr, char *dst_tr)
5905 {
5906         int index = 0, encoded_len = 0;
5907
5908         //set command detail info
5909         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5910         index += encoded_len;
5911
5912         //set device identities info
5913         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5914         index += encoded_len;
5915
5916         //set result info
5917         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
5918
5919         switch(src_tr->result_type) {
5920                 case RESULT_SUCCESS:
5921                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
5922                 case RESULT_SUCCESS_WITH_MISSING_INFO:
5923                 case RESULT_REFRESH_PERFORMED_WITH_ADDITIONAL_EFS_READ:
5924                 case RESULT_REFRESH_PRFRMD_BUT_INDICATED_USIM_NOT_ACTIVE:
5925                 case RESULT_BEYOND_ME_CAPABILITIES:
5926                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
5927                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
5928                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
5929                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
5930                         dst_tr[index++] = 1;
5931                         dst_tr[index++] = src_tr->result_type;
5932                         break;
5933                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
5934                         dst_tr[index++] = 2;
5935                         dst_tr[index++] = src_tr->result_type;
5936                         dst_tr[index++] = src_tr->me_problem_type;
5937                         break;
5938                 default:
5939                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5940                         index = 0;
5941                         break;
5942         }
5943
5944         return index;
5945 }
5946
5947 static int _sat_encode_setup_menu(const struct tel_sat_tr_setup_menu_tlv *src_tr, char *dst_tr)
5948 {
5949         int index = 0, encoded_len = 0;
5950
5951         //set command detail info
5952         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5953         index += encoded_len;
5954
5955         //set device identities info
5956         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5957         index += encoded_len;
5958
5959         //set result info
5960         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
5961         switch(src_tr->result_type) {
5962                 case RESULT_SUCCESS:
5963                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
5964                 case RESULT_SUCCESS_WITH_MISSING_INFO:
5965                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
5966                 case RESULT_BEYOND_ME_CAPABILITIES:
5967                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
5968                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
5969                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
5970                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
5971                         dst_tr[index++] = 1;
5972                         dst_tr[index++] = src_tr->result_type;
5973                         break;
5974                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
5975                         dst_tr[index++] = 2;
5976                         dst_tr[index++] = src_tr->result_type;
5977                         dst_tr[index++] = src_tr->me_problem_type;
5978                         break;
5979                 default:
5980                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5981                         index = 0;
5982                         break;
5983         }
5984
5985         return index;
5986 }
5987
5988 static int _sat_encode_select_item(const struct tel_sat_tr_select_item_tlv *src_tr, char *dst_tr)
5989 {
5990         int index = 0, encoded_len = 0;
5991
5992         //set command detail info
5993         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5994         index += encoded_len;
5995
5996         //set device identities info
5997         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5998         index += encoded_len;
5999
6000         //set result info
6001         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6002
6003         switch(src_tr->result_type) {
6004                 case RESULT_SUCCESS:
6005                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6006                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6007                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6008                 case RESULT_HELP_INFO_REQUIRED_BY_USER:
6009                         dst_tr[index++] = 1;
6010                         dst_tr[index++] = src_tr->result_type;
6011                         encoded_len = _sat_encode_item_identifier_tlv(&(src_tr->item_identifier), dst_tr, index);
6012                         index += encoded_len;
6013                         break;
6014                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6015                 case RESULT_BACKWARD_MOVE_BY_USER:
6016                 case RESULT_NO_RESPONSE_FROM_USER:
6017                 case RESULT_BEYOND_ME_CAPABILITIES:
6018                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6019                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6020                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6021                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6022                         dst_tr[index++] = 1;
6023                         dst_tr[index++] = src_tr->result_type;
6024                         break;
6025                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6026                 case RESULT_FRAMES_ERROR:
6027                         dst_tr[index++] = 2;
6028                         dst_tr[index++] = src_tr->result_type;
6029                         dst_tr[index++] = src_tr->me_problem_type;
6030                         break;
6031                 default:
6032                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6033                         index = 0;
6034                         break;
6035         }
6036
6037         return index;
6038 }
6039
6040 static int _sat_encode_send_sms(const struct tel_sat_tr_send_sms_tlv *src_tr, char *dst_tr)
6041 {
6042         int index = 0, encoded_len = 0;
6043
6044         //set command detail info
6045         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6046         index += encoded_len;
6047
6048         //set device identities info
6049         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6050         index += encoded_len;
6051
6052         //set result info
6053         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6054
6055         switch(src_tr->result_type) {
6056                 case RESULT_SUCCESS:
6057                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6058                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6059                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6060                         dst_tr[index++] = 1;
6061                         dst_tr[index++] = src_tr->result_type;
6062                         break;
6063                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6064                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6065                 case RESULT_BEYOND_ME_CAPABILITIES:
6066                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6067                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6068                 case RESULT_SMS_RP_ERROR:
6069                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
6070                         dst_tr[index++] = 2;
6071                         dst_tr[index++] = src_tr->result_type;
6072                         dst_tr[index++] = src_tr->me_problem_type;
6073                         break;
6074                 default:
6075                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6076                         index = 0;
6077                         break;
6078         }
6079
6080         return index;
6081 }
6082
6083 static int _sat_encode_send_ss(const struct tel_sat_tr_send_ss_tlv *src_tr, char *dst_tr)
6084 {
6085         int index = 0, encoded_len = 0;
6086
6087         //set command detail info
6088         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6089         index += encoded_len;
6090
6091         //set device identities info
6092         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6093         index += encoded_len;
6094
6095         //set result info
6096         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6097
6098         switch(src_tr->result_type) {
6099                 case RESULT_SUCCESS:
6100                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6101                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6102                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6103                 case RESULT_SUCCESS_BUT_MODIFIED_BY_CALL_CONTROL_BY_SIM:
6104                 case RESULT_USSD_OR_SS_TRANSACTION_TERMINATED_BY_USER:
6105                         dst_tr[index++] = 1;
6106                         dst_tr[index++] = src_tr->result_type;
6107
6108                         memcpy(&(dst_tr[index]), src_tr->text.string, src_tr->text.string_length);
6109                         encoded_len = src_tr->text.string_length;
6110                         index += encoded_len;
6111                         break;
6112                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6113                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6114                         dst_tr[index++] = 2;
6115                         dst_tr[index++] = src_tr->result_type;
6116                         dst_tr[index++] = src_tr->me_problem_type;
6117                         break;
6118                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
6119                         dst_tr[index++] = 2;
6120                         dst_tr[index++] = src_tr->result_type;
6121                         dst_tr[index++] = src_tr->cc_problem_type;
6122                         break;
6123                 case RESULT_SS_RETURN_ERROR:
6124                         dst_tr[index++] = 2;
6125                         dst_tr[index++] = src_tr->result_type;
6126                         dst_tr[index++] = src_tr->ss_problem;
6127                         break;
6128                 default:
6129                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6130                         index = 0;
6131                         break;
6132         }
6133
6134         return index;
6135 }
6136
6137 static int _sat_encode_send_ussd(const struct tel_sat_tr_send_ussd_tlv *src_tr, char *dst_tr)
6138 {
6139         int index = 0, encoded_len = 0;
6140
6141         //set command detail info
6142         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6143         index += encoded_len;
6144
6145         //set device identities info
6146         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6147         index += encoded_len;
6148
6149         //set result info
6150         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6151
6152         switch(src_tr->result_type) {
6153                 case RESULT_SUCCESS:
6154                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6155                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6156                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6157                 case RESULT_SUCCESS_BUT_MODIFIED_BY_CALL_CONTROL_BY_SIM:
6158                 case RESULT_USSD_OR_SS_TRANSACTION_TERMINATED_BY_USER:
6159                         dst_tr[index++] = 1;
6160                         dst_tr[index++] = src_tr->result_type;
6161
6162                         encoded_len = _sat_encode_text_tlv(&(src_tr->text), dst_tr, index, TRUE);
6163                         index += encoded_len;
6164                         break;
6165                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6166                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6167                         dst_tr[index++] = 2;
6168                         dst_tr[index++] = src_tr->result_type;
6169                         dst_tr[index++] = src_tr->me_problem_type;
6170                         break;
6171                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
6172                         dst_tr[index++] = 2;
6173                         dst_tr[index++] = src_tr->result_type;
6174                         dst_tr[index++] = src_tr->cc_problem_type;
6175                         break;
6176                 case RESULT_USSD_RETURN_ERROR:
6177                         dst_tr[index++] = 2;
6178                         dst_tr[index++] = src_tr->result_type;
6179                         dst_tr[index++] = src_tr->ussd_problem;
6180                         break;
6181                 default:
6182                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6183                         index = 0;
6184                         break;
6185         }
6186
6187         return index;
6188 }
6189
6190 static int _sat_encode_setup_call(const struct tel_sat_tr_setup_call_tlv *src_tr, char *dst_tr)
6191 {
6192         int index = 0, encoded_len = 0;
6193
6194         //set command detail info
6195         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6196         index += encoded_len;
6197
6198         //set device identities info
6199         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6200         index += encoded_len;
6201
6202         //set result info
6203         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6204
6205         switch(src_tr->result_type) {
6206                 case RESULT_SUCCESS:
6207                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6208                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6209                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6210                 case RESULT_SUCCESS_BUT_MODIFIED_BY_CALL_CONTROL_BY_SIM:
6211                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6212                 case RESULT_BEYOND_ME_CAPABILITIES:
6213                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6214                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6215                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6216                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6217                 case RESULT_SS_RETURN_ERROR:
6218                         dst_tr[index++] = 1;
6219                         dst_tr[index++] = src_tr->result_type;
6220                         break;
6221                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6222                 case RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ:
6223                 case RESULT_USER_CLEAR_DOWN_CALL_BEFORE_CONN:
6224                 case RESULT_FRAMES_ERROR:
6225                         dst_tr[index++] = 2;
6226                         dst_tr[index++] = src_tr->result_type;
6227                         dst_tr[index++] = src_tr->me_problem_type;
6228                         break;
6229                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6230                         dst_tr[index++] = 2;
6231                         dst_tr[index++] = src_tr->result_type;
6232                         dst_tr[index++] = src_tr->network_problem_type;
6233                         break;
6234                 case RESULT_INTRCTN_WITH_CC_OR_SMS_CTRL_PRMNT_PRBLM:
6235                         dst_tr[index++] = 2;
6236                         dst_tr[index++] = src_tr->result_type;
6237                         dst_tr[index++] = src_tr->cc_problem_type;
6238                         break;
6239                 default:
6240                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6241                         index = 0;
6242                         break;
6243         }
6244
6245         return index;
6246 }
6247
6248 static int _sat_encode_provide_local_info(const struct tel_sat_tr_provide_local_info_tlv *src_tr, char *dst_tr)
6249 {
6250         int index = 0, encoded_len = 0;
6251
6252         //set command detail info
6253         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6254         index += encoded_len;
6255
6256         //set device identities info
6257         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6258         index += encoded_len;
6259
6260         //set result info
6261         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6262         switch(src_tr->result_type) {
6263                 case RESULT_SUCCESS:
6264                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6265                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6266                 case RESULT_SUCCESS_LIMITED_SERVICE:
6267                         dst_tr[index++] = 1;
6268                         dst_tr[index++] = src_tr->result_type;
6269                         switch(src_tr->command_detail.cmd_qualifier.provide_local_info.provide_local_info) {
6270                                 case LOCAL_INFO_DATE_TIME_AND_TIMEZONE:
6271                                         encoded_len = _sat_encode_date_time_and_timezone_tlv(&(src_tr->other.date_time_and_timezone), dst_tr, index);
6272                                         break;
6273                                 case LOCAL_INFO_LANGUAGE:
6274                                         encoded_len = _sat_encode_language_tlv(src_tr->other.language, dst_tr, index);
6275                                         break;
6276                                 default:
6277                                         dbg("local info type[%d] is not handled", src_tr->command_detail.cmd_qualifier.provide_local_info.provide_local_info);
6278                                         break;
6279                         }
6280                         index += encoded_len;
6281                         break;
6282                 case RESULT_BEYOND_ME_CAPABILITIES:
6283                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6284                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6285                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6286                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6287                         dst_tr[index++] = 1;
6288                         dst_tr[index++] = src_tr->result_type;
6289                         break;
6290                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6291                         dst_tr[index++] = 2;
6292                         dst_tr[index++] = src_tr->result_type;
6293                         dst_tr[index++] = src_tr->me_problem_type;
6294                         break;
6295                 default:
6296                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6297                         index = 0;
6298                         break;
6299         }
6300
6301         return index;
6302 }
6303
6304 static int _sat_encode_setup_event_list(const struct tel_sat_tr_setup_event_list_tlv *src_tr, char *dst_tr)
6305 {
6306         int index = 0, encoded_len = 0;
6307
6308         //set command detail info
6309         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6310         index += encoded_len;
6311
6312         //set device identities info
6313         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6314         index += encoded_len;
6315
6316         //set result info
6317         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6318         switch(src_tr->result_type) {
6319                 case RESULT_SUCCESS:
6320                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6321                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6322                 case RESULT_BEYOND_ME_CAPABILITIES:
6323                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6324                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6325                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6326                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6327                         dst_tr[index++] = 1;
6328                         dst_tr[index++] = src_tr->result_type;
6329                         break;
6330                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6331                         dst_tr[index++] = 2;
6332                         dst_tr[index++] = src_tr->result_type;
6333                         dst_tr[index++] = src_tr->me_problem_type;
6334                         break;
6335                 default:
6336                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6337                         index = 0;
6338                         break;
6339         }
6340
6341         return index;
6342 }
6343
6344 static int _sat_encode_setup_idle_mode_text(const struct tel_sat_tr_setup_idle_mode_text_tlv *src_tr, char *dst_tr)
6345 {
6346         int index = 0, encoded_len = 0;
6347
6348         //set command detail info
6349         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6350         index += encoded_len;
6351
6352         //set device identities info
6353         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6354         index += encoded_len;
6355
6356         //set result info
6357         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6358
6359         switch(src_tr->result_type) {
6360                 case RESULT_SUCCESS:
6361                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6362                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6363                 case RESULT_BEYOND_ME_CAPABILITIES:
6364                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6365                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6366                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6367                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6368                         dst_tr[index++] = 1;
6369                         dst_tr[index++] = src_tr->result_type;
6370                         break;
6371                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6372                 case RESULT_FRAMES_ERROR:
6373                         dst_tr[index++] = 2;
6374                         dst_tr[index++] = src_tr->result_type;
6375                         dst_tr[index++] = src_tr->me_problem_type;
6376                         break;
6377                 default:
6378                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6379                         index = 0;
6380                         break;
6381         }
6382
6383         return index;
6384 }
6385
6386 static int _sat_encode_send_dtmf(const struct tel_sat_tr_send_dtmf_tlv *src_tr, char *dst_tr)
6387 {
6388         int index = 0, encoded_len = 0;
6389
6390         //set command detail info
6391         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6392         index += encoded_len;
6393
6394         //set device identities info
6395         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6396         index += encoded_len;
6397
6398         //set result info
6399         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6400
6401         switch(src_tr->result_type) {
6402                 case RESULT_SUCCESS:
6403                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6404                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6405                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6406                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6407                 case RESULT_BEYOND_ME_CAPABILITIES:
6408                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6409                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6410                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6411                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6412                         dst_tr[index++] = 1;
6413                         dst_tr[index++] = src_tr->result_type;
6414                         break;
6415                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6416                         dst_tr[index++] = 2;
6417                         dst_tr[index++] = src_tr->result_type;
6418                         dst_tr[index++] = src_tr->me_problem_type;
6419                         break;
6420                 default:
6421                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6422                         index = 0;
6423                         break;
6424         }
6425
6426         return index;
6427 }
6428
6429 static int _sat_encode_language_notification(const struct tel_sat_tr_language_notification_tlv *src_tr, char *dst_tr)
6430 {
6431         int index = 0, encoded_len = 0;
6432
6433         //set command detail info
6434         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6435         index += encoded_len;
6436
6437         //set device identities info
6438         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6439         index += encoded_len;
6440
6441         //set result info
6442         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6443
6444         switch(src_tr->result_type) {
6445                 case RESULT_SUCCESS:
6446                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6447                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6448                 case RESULT_BEYOND_ME_CAPABILITIES:
6449                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6450                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6451                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6452                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6453                         dst_tr[index++] = 1;
6454                         dst_tr[index++] = src_tr->result_type;
6455                         break;
6456                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6457                 case RESULT_FRAMES_ERROR:
6458                         dst_tr[index++] = 2;
6459                         dst_tr[index++] = src_tr->result_type;
6460                         dst_tr[index++] = src_tr->me_problem_type;
6461                         break;
6462                 default:
6463                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6464                         index = 0;
6465                         break;
6466         }
6467
6468         return index;
6469 }
6470
6471 static int _sat_encode_launch_browser(const struct tel_sat_tr_launch_browser_tlv *src_tr, char *dst_tr)
6472 {
6473         int index = 0, encoded_len = 0;
6474
6475         //set command detail info
6476         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6477         index += encoded_len;
6478
6479         //set device identities info
6480         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6481         index += encoded_len;
6482
6483         //set result info
6484         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6485
6486         switch(src_tr->result_type) {
6487                 case RESULT_SUCCESS:
6488                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6489                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6490                 case RESULT_BEYOND_ME_CAPABILITIES:
6491                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6492                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6493                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6494                         dst_tr[index++] = 1;
6495                         dst_tr[index++] = src_tr->result_type;
6496                         break;
6497                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6498                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6499                 case RESULT_FRAMES_ERROR:
6500                         dst_tr[index++] = 2;
6501                         dst_tr[index++] = src_tr->result_type;
6502                         dst_tr[index++] = src_tr->me_problem_type;
6503                         break;
6504                 case RESULT_LAUNCH_BROWSER_GENERIC_ERROR_CODE:
6505                         dst_tr[index++] = 2;
6506                         dst_tr[index++] = src_tr->result_type;
6507                         dst_tr[index++] = src_tr->browser_problem_type;
6508                         break;
6509                 default:
6510                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6511                         index = 0;
6512                         break;
6513         }
6514
6515         return index;
6516 }
6517
6518 static int _sat_encode_open_channel(const struct tel_sat_tr_open_channel_tlv *src_tr, char *dst_tr)
6519 {
6520         int index = 0, encoded_len = 0;
6521
6522         //set command detail info
6523         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6524         index += encoded_len;
6525
6526         //set device identities info
6527         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6528         index += encoded_len;
6529
6530         //set result info
6531         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6532         switch(src_tr->result_type) {
6533                 case RESULT_SUCCESS:
6534                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6535                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6536                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6537                 case RESULT_SUCCESS_WITH_MODIFICATION:
6538                         dst_tr[index++] = 1;
6539                         dst_tr[index++] = src_tr->result_type;
6540
6541                         //set channel status
6542                         encoded_len = _sat_encode_channel_status_tlv(&(src_tr->channel_status), dst_tr, index);
6543                         index += encoded_len;
6544                         break;
6545                 case RESULT_REFRESH_PRFRMD_BUT_INDICATED_USIM_NOT_ACTIVE:
6546                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6547                 case RESULT_INTERACTION_WITH_CC_BY_SIM_IN_TMP_PRBLM:
6548                 case RESULT_BEYOND_ME_CAPABILITIES:
6549                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6550                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6551                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6552                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6553                 case RESULT_USER_DID_NOT_ACCEPT_CALL_SETUP_REQ:
6554                         dst_tr[index++] = 1;
6555                         dst_tr[index++] = src_tr->result_type;
6556                         break;
6557                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6558                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6559                 case RESULT_FRAMES_ERROR:
6560                         dst_tr[index++] = 2;
6561                         dst_tr[index++] = src_tr->result_type;
6562                         dst_tr[index++] = src_tr->me_problem_type;
6563                         break;
6564                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
6565                         dst_tr[index++] = 2;
6566                         dst_tr[index++] = src_tr->result_type;
6567                         dst_tr[index++] = src_tr->bip_problem_type;
6568                         break;
6569                 default:
6570                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6571                         return 0;
6572                         break;
6573         }
6574
6575         //set buffer desc
6576         encoded_len = _sat_encode_bearer_desc_tlv(&(src_tr->bearer_desc), dst_tr, index);
6577         index += encoded_len;
6578
6579         //set buffer size
6580         encoded_len = _sat_encode_buffer_size_tlv(&(src_tr->buffer_size), dst_tr, index);
6581         index += encoded_len;
6582
6583         return index;
6584 }
6585
6586 static int _sat_encode_close_channel(const struct tel_sat_tr_close_channel_tlv *src_tr, char *dst_tr)
6587 {
6588         int index = 0, encoded_len = 0;
6589
6590         //set command detail info
6591         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6592         index += encoded_len;
6593
6594         //set device identities info
6595         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6596         index += encoded_len;
6597
6598         //set result info
6599         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6600         switch(src_tr->result_type) {
6601                 case RESULT_SUCCESS:
6602                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6603                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6604                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6605                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6606                 case RESULT_BEYOND_ME_CAPABILITIES:
6607                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6608                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6609                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6610                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6611                         dst_tr[index++] = 1;
6612                         dst_tr[index++] = src_tr->result_type;
6613                         break;
6614                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6615                 case RESULT_FRAMES_ERROR:
6616                         dst_tr[index++] = 2;
6617                         dst_tr[index++] = src_tr->result_type;
6618                         dst_tr[index++] = src_tr->me_problem_type;
6619                         break;
6620                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
6621                         dst_tr[index++] = 2;
6622                         dst_tr[index++] = src_tr->result_type;
6623                         dst_tr[index++] = src_tr->bip_problem_type;
6624                         break;
6625                 default:
6626                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6627                         index = 0;
6628                         break;
6629         }
6630
6631         return index;
6632 }
6633
6634 static int _sat_encode_send_data(const struct tel_sat_tr_send_data_tlv *src_tr, char *dst_tr)
6635 {
6636         int index = 0, encoded_len = 0;
6637
6638         //set command detail info
6639         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6640         index += encoded_len;
6641
6642         //set device identities info
6643         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6644         index += encoded_len;
6645
6646         //set result info
6647         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6648         switch(src_tr->result_type) {
6649                 case RESULT_SUCCESS:
6650                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6651                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6652                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6653                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6654                 case RESULT_BEYOND_ME_CAPABILITIES:
6655                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6656                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6657                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6658                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6659                         dst_tr[index++] = 1;
6660                         dst_tr[index++] = src_tr->result_type;
6661                         encoded_len = _sat_encode_channel_data_length_tlv(&(src_tr->channel_data_len), dst_tr, index);
6662                         index += encoded_len;
6663                         break;
6664                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6665                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6666                 case RESULT_FRAMES_ERROR:
6667                         dst_tr[index++] = 2;
6668                         dst_tr[index++] = src_tr->result_type;
6669                         dst_tr[index++] = src_tr->me_problem_type;
6670                         break;
6671
6672                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
6673                         dst_tr[index++] = 2;
6674                         dst_tr[index++] = src_tr->result_type;
6675                         dst_tr[index++] = src_tr->bip_problem_type;
6676                         break;
6677                 default:
6678                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6679                         index = 0;
6680                         break;
6681         }
6682
6683         return index;
6684 }
6685
6686 static int _sat_encode_receive_data(const struct tel_sat_tr_receive_data_tlv *src_tr, char *dst_tr)
6687 {
6688         int index = 0, encoded_len = 0;
6689
6690         //set command detail info
6691         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6692         index += encoded_len;
6693
6694         //set device identities info
6695         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6696         index += encoded_len;
6697
6698         //set result info
6699         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6700         switch(src_tr->result_type) {
6701                 case RESULT_SUCCESS:
6702                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6703                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6704                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6705                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6706                 case RESULT_BEYOND_ME_CAPABILITIES:
6707                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6708                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6709                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6710                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6711                         dst_tr[index++] = 1;
6712                         dst_tr[index++] = src_tr->result_type;
6713                         encoded_len = _sat_encode_channel_data_tlv(&(src_tr->channel_data), dst_tr, index);
6714                         index += encoded_len;
6715                         encoded_len = _sat_encode_channel_data_length_tlv(&(src_tr->channel_data_len), dst_tr, index);
6716                         index += encoded_len;
6717                         break;
6718                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6719                 case RESULT_FRAMES_ERROR:
6720                         dst_tr[index++] = 2;
6721                         dst_tr[index++] = src_tr->result_type;
6722                         dst_tr[index++] = src_tr->me_problem_type;
6723                         break;
6724
6725                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
6726                         dst_tr[index++] = 2;
6727                         dst_tr[index++] = src_tr->result_type;
6728                         dst_tr[index++] = src_tr->bip_problem_type;
6729                         break;
6730                 default:
6731                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6732                         index = 0;
6733                         break;
6734         }
6735
6736         return index;
6737 }
6738
6739 static int _sat_encode_get_channel_status(const struct tel_sat_tr_get_channel_status_tlv *src_tr, char *dst_tr)
6740 {
6741         int index = 0, encoded_len = 0;
6742
6743         //set command detail info
6744         encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6745         index += encoded_len;
6746
6747         //set device identities info
6748         encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6749         index += encoded_len;
6750
6751         //set result info
6752         dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
6753         switch(src_tr->result_type) {
6754                 case RESULT_SUCCESS:
6755                 case RESULT_SUCCESS_WITH_PARTIAL_COMPREHENSION:
6756                 case RESULT_SUCCESS_WITH_MISSING_INFO:
6757                 case RESULT_SUCCESS_BUT_REQUESTED_ICON_NOT_DISPLAYED:
6758                         dst_tr[index++] = 1;
6759                         dst_tr[index++] = src_tr->result_type;
6760                         encoded_len = _sat_encode_channel_status_tlv(&(src_tr->channel_status), dst_tr, index);
6761                         index += encoded_len;
6762                         break;
6763                 case RESULT_PROACTIVE_SESSION_TERMINATED_BY_USER:
6764                 case RESULT_BEYOND_ME_CAPABILITIES:
6765                 case RESULT_COMMAND_TYPE_NOT_UNDERSTOOD_BY_ME:
6766                 case RESULT_COMMAND_DATA_NOT_UNDERSTOOD_BY_ME:
6767                 case RESULT_COMMAND_NUMBER_NOT_KNOWN_BY_ME:
6768                 case RESULT_ERROR_REQUIRED_VALUES_ARE_MISSING:
6769                         dst_tr[index++] = 1;
6770                         dst_tr[index++] = src_tr->result_type;
6771                         break;
6772                 case RESULT_ME_UNABLE_TO_PROCESS_COMMAND:
6773                 case RESULT_NETWORK_UNABLE_TO_PROCESS_COMMAND:
6774                         dst_tr[index++] = 2;
6775                         dst_tr[index++] = src_tr->result_type;
6776                         dst_tr[index++] = src_tr->me_problem_type;
6777                         break;
6778                 case RESULT_BEARER_INDEPENDENT_PROTOCOL_ERROR:
6779                         dst_tr[index++] = 2;
6780                         dst_tr[index++] = src_tr->result_type;
6781                         dst_tr[index++] = src_tr->bip_problem_type;
6782                         break;
6783                 default:
6784                         dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6785                         index = 0;
6786                         break;
6787         }
6788
6789         return index;
6790 }
6791
6792 int tcore_sat_encode_terminal_response(const struct treq_sat_terminal_rsp_data *src_tr, char *dst_tr) {
6793         int tr_len = 0;
6794
6795         if (!dst_tr)
6796                 return 0;
6797
6798         switch(src_tr->cmd_type) {
6799                 case SAT_PROATV_CMD_DISPLAY_TEXT:{
6800                         tr_len = _sat_encode_display_text(&(src_tr->terminal_rsp_data.display_text), dst_tr);
6801                 }break;
6802                 case SAT_PROATV_CMD_GET_INKEY:{
6803                         tr_len = _sat_encode_get_inkey(&(src_tr->terminal_rsp_data.get_inkey), dst_tr);
6804                 }break;
6805                 case SAT_PROATV_CMD_GET_INPUT:{
6806                         tr_len = _sat_encode_get_input(&(src_tr->terminal_rsp_data.get_input), dst_tr);
6807                 }break;
6808                 case SAT_PROATV_CMD_MORE_TIME:{
6809                         tr_len = _sat_encode_more_time(&(src_tr->terminal_rsp_data.more_time), dst_tr);
6810                 }break;
6811                 case SAT_PROATV_CMD_PLAY_TONE:{
6812                         tr_len = _sat_encode_play_tone(&(src_tr->terminal_rsp_data.play_tone), dst_tr);
6813                 }break;
6814                 case SAT_PROATV_CMD_REFRESH:{
6815                         tr_len = _sat_encode_refresh(&(src_tr->terminal_rsp_data.refresh), dst_tr);
6816                 }break;
6817                 case SAT_PROATV_CMD_SETUP_MENU:{
6818                         tr_len = _sat_encode_setup_menu(&(src_tr->terminal_rsp_data.setup_menu), dst_tr);
6819                 }break;
6820                 case SAT_PROATV_CMD_SELECT_ITEM:{
6821                         tr_len = _sat_encode_select_item(&(src_tr->terminal_rsp_data.select_item), dst_tr);
6822                 }break;
6823                 case SAT_PROATV_CMD_SEND_SMS:{
6824                         tr_len = _sat_encode_send_sms(&(src_tr->terminal_rsp_data.send_sms), dst_tr);
6825                 }break;
6826                 case SAT_PROATV_CMD_SEND_SS:{
6827                         tr_len = _sat_encode_send_ss(&(src_tr->terminal_rsp_data.send_ss), dst_tr);
6828                 }break;
6829                 case SAT_PROATV_CMD_SEND_USSD:{
6830                         tr_len = _sat_encode_send_ussd(&(src_tr->terminal_rsp_data.send_ussd), dst_tr);
6831                 }break;
6832                 case SAT_PROATV_CMD_SETUP_CALL:{
6833                         tr_len = _sat_encode_setup_call(&(src_tr->terminal_rsp_data.setup_call), dst_tr);
6834                 }break;
6835                 case SAT_PROATV_CMD_PROVIDE_LOCAL_INFO:{
6836                         tr_len = _sat_encode_provide_local_info(&(src_tr->terminal_rsp_data.provide_local_info), dst_tr);
6837                 }break;
6838                 case SAT_PROATV_CMD_SETUP_EVENT_LIST:{
6839                         tr_len = _sat_encode_setup_event_list(&(src_tr->terminal_rsp_data.setup_event_list), dst_tr);
6840                 }break;
6841                 case SAT_PROATV_CMD_SETUP_IDLE_MODE_TEXT:{
6842                         tr_len = _sat_encode_setup_idle_mode_text(&(src_tr->terminal_rsp_data.setup_idle_mode_text), dst_tr);
6843                 }break;
6844                 case SAT_PROATV_CMD_SEND_DTMF:{
6845                         tr_len = _sat_encode_send_dtmf(&(src_tr->terminal_rsp_data.send_dtmf), dst_tr);
6846                 }break;
6847                 case SAT_PROATV_CMD_LANGUAGE_NOTIFICATION:{
6848                         tr_len = _sat_encode_language_notification(&(src_tr->terminal_rsp_data.language_notification), dst_tr);
6849                 }break;
6850                 case SAT_PROATV_CMD_LAUNCH_BROWSER:{
6851                         tr_len = _sat_encode_launch_browser(&(src_tr->terminal_rsp_data.launch_browser), dst_tr);
6852                 }break;
6853                 case SAT_PROATV_CMD_OPEN_CHANNEL:{
6854                         tr_len = _sat_encode_open_channel(&(src_tr->terminal_rsp_data.open_channel), dst_tr);
6855                 }break;
6856                 case SAT_PROATV_CMD_CLOSE_CHANNEL:{
6857                         tr_len = _sat_encode_close_channel(&(src_tr->terminal_rsp_data.close_channel), dst_tr);
6858                 }break;
6859                 case SAT_PROATV_CMD_SEND_DATA:{
6860                         tr_len = _sat_encode_send_data(&(src_tr->terminal_rsp_data.send_data), dst_tr);
6861                 }break;
6862                 case SAT_PROATV_CMD_RECEIVE_DATA:{
6863                         tr_len = _sat_encode_receive_data(&(src_tr->terminal_rsp_data.receive_data), dst_tr);
6864                 }break;
6865                 case SAT_PROATV_CMD_GET_CHANNEL_STATUS:{
6866                         tr_len = _sat_encode_get_channel_status(&(src_tr->terminal_rsp_data.get_channel_status), dst_tr);
6867                 }break;
6868                 default:
6869                         err("no matched cmd type(%d)", src_tr->cmd_type);
6870                         break;
6871         }
6872
6873         return tr_len;
6874 }
6875
6876 void tcore_sat_override_ops(CoreObject *o, struct tcore_sat_operations *sat_ops)
6877 {
6878         struct private_object_data *po = NULL;
6879
6880         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_SAT);
6881
6882         po = (struct private_object_data *)tcore_object_ref_object(o);
6883         if (!po) {
6884                 return;
6885         }
6886
6887         if (sat_ops) {
6888                 _clone_sat_operations(po, sat_ops);
6889         }
6890
6891         return;
6892 }
6893
6894 CoreObject *tcore_sat_new(TcorePlugin *p,
6895                         struct tcore_sat_operations *ops, TcoreHal *hal)
6896 {
6897         CoreObject *o = NULL;
6898         struct private_object_data *po = NULL;
6899
6900         if (!p)
6901                 return NULL;
6902
6903         o = tcore_object_new(p, hal);
6904         if (!o)
6905                 return NULL;
6906
6907         po = calloc(1, sizeof(struct private_object_data));
6908         if (!po) {
6909                 tcore_object_free(o);
6910                 return NULL;
6911         }
6912
6913         po->ops = ops;
6914
6915         tcore_object_set_type(o, CORE_OBJECT_TYPE_SAT);
6916         tcore_object_link_object(o, po);
6917         tcore_object_set_clone_hook(o, _clone_hook);
6918         tcore_object_set_free_hook(o, _free_hook);
6919         tcore_object_set_dispatcher(o, _dispatcher);
6920
6921         return o;
6922 }
6923
6924 void tcore_sat_free(CoreObject *o)
6925 {
6926         struct private_object_data *po = NULL;
6927
6928         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_SAT);
6929
6930         po = tcore_object_ref_object(o);
6931         if (!po)
6932                 return;
6933
6934         free(po);
6935         tcore_object_free(o);
6936 }