4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Ja-young Gu <jygu@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
30 #include "user_request.h"
31 #include "core_object.h"
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*/
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 */
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 */
117 struct private_object_data {
118 struct tcore_sat_operations *ops;
121 gboolean b_comprehensive = FALSE;
123 static void _clone_sat_operations(struct private_object_data *po, struct tcore_sat_operations *sat_ops)
125 if (sat_ops->envelope) {
126 po->ops->envelope = sat_ops->envelope;
128 if (sat_ops->terminal_response) {
129 po->ops->terminal_response = sat_ops->terminal_response;
135 static TReturn _dispatcher(CoreObject *o, UserRequest *ur)
137 enum tcore_request_command command;
138 struct private_object_data *po = NULL;
140 CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_SAT, TCORE_RETURN_EINVAL);
142 po = tcore_object_ref_object(o);
144 return TCORE_RETURN_ENOSYS;
146 command = tcore_user_request_get_command(ur);
148 case TREQ_SAT_REQ_ENVELOPE:
149 if (!po->ops->envelope)
150 return TCORE_RETURN_ENOSYS;
152 return po->ops->envelope(o, ur);
155 case TREQ_SAT_REQ_TERMINALRESPONSE:
156 if (!po->ops->terminal_response)
157 return TCORE_RETURN_ENOSYS;
159 return po->ops->terminal_response(o, ur);
166 return TCORE_RETURN_SUCCESS;
169 static void _clone_hook(CoreObject *src, CoreObject *dest)
171 struct private_object_data *src_po = NULL;
172 struct private_object_data *dest_po = NULL;
177 dest_po = calloc(1, sizeof(struct private_object_data));
179 tcore_object_link_object(dest, NULL);
183 src_po = tcore_object_ref_object(src);
184 dest_po->ops = src_po->ops;
186 tcore_object_link_object(dest, dest_po);
189 static void _free_hook(CoreObject *o)
191 struct private_object_data *po = NULL;
193 CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_SAT);
195 po = tcore_object_ref_object(o);
198 tcore_object_link_object(o, NULL);
202 static gboolean _check_file_for_refresh(enum tel_sim_file_id file_id)
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 };
223 dbg("[SAT] SAT PARSER - FILE ID=0x%04x", (unsigned int)file_id);
225 if ( (file_id & 0x2F00) == 0x2F00 )
227 dbg("[SAT] SAT PARSER - MF, EF=0x%04x",file_id);
229 if (file_id == ef_under_mf[i]) {
230 dbg("[SAT] SAT PARSER - MATCH!");
235 else if ( (file_id & 0x6F00) == 0x6F00)
237 dbg("[SAT] SAT PARSER - ADF_USIM EF=0x%04x",file_id);
239 if (file_id == ef_under_df[i]) {
240 dbg("[SAT] SAT PARSER - MATCH!");
248 static int _get_length_filed_size(unsigned char firstLenByte)
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.
255 static void _get_string_data(unsigned char* src, int len,
256 struct tel_sat_text_string_object *text_obj)
258 if (!src || !text_obj) return;
260 switch (text_obj->dcs.a_format) {
261 case ALPHABET_FORMAT_SMS_DEFAULT: {
264 text_obj->string_length = 0;
265 unpacked_str = (char *)tcore_util_unpack_gsm7bit(src, (unsigned int)len);
266 if (!unpacked_str) return;
268 text_obj->dcs.a_format = ALPHABET_FORMAT_8BIT_DATA;
269 text_obj->string_length = strlen(unpacked_str);
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;
277 memcpy(text_obj->string, unpacked_str, text_obj->string_length);
278 text_obj->string[text_obj->string_length] = 0x00;
281 g_free(unpacked_str);
283 case ALPHABET_FORMAT_UCS2:
284 case ALPHABET_FORMAT_8BIT_DATA: {
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;
292 memcpy(text_obj->string, src, text_obj->string_length);
293 text_obj->string[text_obj->string_length] = 0x00;
297 dbg("[SAT] SAT PARSER - Unknown alphabet format(%d)", text_obj->dcs.a_format);
304 static void _sat_decode_dcs(unsigned char dcs, struct data_coding_scheme* dsc_obj)
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.
311 dsc_obj->is_compressed_format = TRUE;
313 dsc_obj->is_compressed_format = FALSE;
315 //bit 4 when set, indicates that bits 0 & 1 have message class meaning.
316 dsc_obj->m_class = MSG_CLASS_NONE;
318 switch (dcs & 0x03) {
320 dsc_obj->m_class = MSG_CLASS_0;
323 dsc_obj->m_class = MSG_CLASS_1;
326 dsc_obj->m_class = MSG_CLASS_2;
329 dsc_obj->m_class = MSG_CLASS_3;
332 dsc_obj->m_class = MSG_CLASS_RESERVED;
337 /*bits 2 & 3 indicate the character set being used*/
338 switch (dcs & 0x0C) {
341 dsc_obj->a_format = ALPHABET_FORMAT_SMS_DEFAULT;
345 dsc_obj->a_format = ALPHABET_FORMAT_8BIT_DATA;
349 dsc_obj->a_format = ALPHABET_FORMAT_UCS2;
353 dsc_obj->a_format = ALPHABET_FORMAT_RESERVED;
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);
363 static void _sat_decode_ton_npi(unsigned char ton_npi, enum type_of_number *ton, enum numbering_plan_identifier *npi)
371 ton_value = (ton_npi & 0x70) >> 4;
373 if (*ton > TON_NETWORK_SPECIFIC)
376 npi_value = (ton_npi & 0x0F);
379 case NPI_DATA_NUMBERING_PLAN:
382 case NPI_RESERVED_FOR_EXT:
390 dbg("[SAT] SAT PATSER - ton(0x%x) npi(0x%x)", *ton, *npi);
394 static enum tel_sim_language_type _sat_decode_language(unsigned char byte1, unsigned char byte2)
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;
427 dbg("[SAT] SAT PARSER - unknown language, default to english.");
428 return SIM_LANG_ENGLISH;
433 * Decode TLV data object
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)
438 unsigned char* src_data;
439 int index, len_of_len = 0;
441 gboolean comprehensive_req = FALSE;
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;
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;
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;
461 //comprehensive required
462 if ((src_data[index++] & 0x80))
463 comprehensive_req = TRUE;
466 len_of_len = _get_length_filed_size(src_data[index]);
468 dbg("[SAT] SAT PARSER - incorrect length");
469 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
471 address_len = src_data[index + len_of_len - 1];
473 //check the address length
475 if ((index + address_len) > tlv_len) {
476 dbg("[SAT] SAT PARSER - incorrect length");
477 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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);
486 memcpy(address_obj->dialing_number, str_ascii, strlen(str_ascii));
487 address_obj->dialing_number_len = strlen(str_ascii);
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;
497 dbg("comprehensive partial proactive command");
498 //global variable (comprehensive_partial= TRUE)
501 *consumed_data_len = 1 + len_of_len + address_len;
502 return TCORE_SAT_SUCCESS;
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)
508 unsigned char* src_data;
509 int index, len_of_len = 0;
510 int sub_address_len = 0;
511 gboolean comprehensive_req = FALSE;
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;
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;
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;
531 //comprehensive required
532 if ((src_data[index++] & 0x80))
533 comprehensive_req = TRUE;
536 len_of_len = _get_length_filed_size(src_data[index]);
538 dbg("[SAT] SAT PARSER - incorrect length");
539 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
541 sub_address_len = src_data[index + len_of_len - 1];
543 //check the address length
545 if ((index + sub_address_len) > tlv_len) {
546 dbg("[SAT] SAT PARSER - incorrect length");
547 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
551 if (sub_address_len <= 0) {
552 dbg("[SAT] SAT PARSER - no sub address data");
553 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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;
563 //bIsComprehensionPartial = TRUE;
564 sub_address_obj->subaddress_len = 0;
568 memcpy(sub_address_obj->subaddress, &src_data[index], sub_address_obj->subaddress_len);
571 *consumed_data_len = 1 + len_of_len + sub_address_len;
572 return TCORE_SAT_SUCCESS;
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)
578 unsigned char* src_data;
579 int index, len_of_len = 0;
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;
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;
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;
601 alpha_id_obj->is_exist = TRUE;
602 len_of_len = _get_length_filed_size(src_data[index]);
604 dbg("[SAT] SAT PARSER - incorrect length");
605 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
607 alpha_len = alpha_id_obj->alpha_data_len = src_data[index + len_of_len - 1];
611 if ((index + alpha_len) > tlv_len) {
612 dbg("[SAT] SAT PARSER - incorrect length");
613 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
616 if (alpha_id_obj->alpha_data_len > 0) {
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;
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;
626 if (src_data[index] == 0x80 || src_data[index] == 0x81 || src_data[index] == 0x82)
631 _sat_decode_dcs(dcs, &alpha_id_obj->dcs);
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;
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)
643 int index, len_of_len = 0;
644 int sub_address_len = 0;
645 unsigned char* src_data;
646 gboolean comprehension_req = FALSE;
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;
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;
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;
666 //comprehensive required
667 if ((src_data[index++] & 0x80))
668 comprehension_req = TRUE;
671 len_of_len = _get_length_filed_size(src_data[index]);
673 dbg("[SAT] SAT PARSER - incorrect length");
674 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
676 sub_address_len = src_data[index + len_of_len - 1];
678 //check the address length
680 if ((index + sub_address_len) > tlv_len) {
681 dbg("[SAT] SAT PARSER - incorrect length");
682 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
685 if (sub_address_len <= 0) {
686 dbg("[SAT] SAT PARSER - no sub address");
687 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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;
695 sub_address_obj->subaddress_len = 0;
698 memcpy(sub_address_obj->subaddress, &src_data[index],sub_address_obj->subaddress_len);
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]);
705 *consumed_data_len = 1+len_of_len+sub_address_len;
706 return TCORE_SAT_SUCCESS;
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)
713 int index, len_of_len = 0;
715 unsigned char* src_data;
716 gboolean comprehension_req = FALSE;
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;
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;
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;
736 //comprehensive required
737 if ((src_data[index++] & 0x80))
738 comprehension_req = TRUE;
741 len_of_len = _get_length_filed_size(src_data[index]);
743 dbg("[SAT] SAT PARSER - incorrect length");
744 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
746 ccp_len = src_data[index + len_of_len - 1];
748 //check the address length
750 if ((index + ccp_len) > tlv_len) {
751 dbg("[SAT] SAT PARSER - incorrect length");
752 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
756 dbg("[SAT] SAT PARSER - no ccp data");
757 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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;
765 ccp_obj->data_len = 0;
768 memcpy(ccp_obj->data, &src_data[index],ccp_obj->data_len);
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]);
775 *consumed_data_len = 1+len_of_len+ccp_len;
776 return TCORE_SAT_SUCCESS;
779 static enum tcore_sat_result _sat_decode_device_identities_tlv(unsigned char* tlv_str,
780 struct tel_sat_device_identities* dev_id_obj)
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;
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
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
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:
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];
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];
817 dbg("unmatched device id");
818 return TCORE_SAT_REQUIRED_VALUE_MISSING;
825 dbg("[SAT] SAT PARSER - source=%d, dest=%d", dev_id_obj->src, dev_id_obj->dest);
826 return TCORE_SAT_SUCCESS;
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)
833 unsigned char* src_data = NULL;
835 if (!tlv_str || !duration_obj || !consumed_data_len) {
836 err("[SAT] SAT PARSER data is null");
837 return TCORE_SAT_ERROR_FATAL;
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;
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
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
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];
865 duration_obj->time_unit = TIME_UNIT_RESERVED;
871 duration_obj->time_interval = src_data[index];
872 *consumed_data_len = 4;
874 dbg("[SAT] SAT PARSER - timeUnit=%d, interval=%d", duration_obj->time_unit, duration_obj->time_interval);
876 return TCORE_SAT_SUCCESS;
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)
882 int index, len_of_len=0, i=0;
884 unsigned char* src_data = NULL;
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;
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;
899 /* ITEM TAG - 0x0F */
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;
908 len_of_len = _get_length_filed_size(src_data[index]);
910 err("[SAT PARSER] Incorrect length");
911 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
913 item_len = src_data[index+len_of_len-1];
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;
921 memset(item_obj->text, 0x00,(SAT_ITEM_TEXT_LEN_MAX+1));
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;
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)
941 item_obj->text_len = i;
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;
948 if (item_obj->text_len > SAT_ITEM_TEXT_LEN_MAX)
949 item_obj->text_len = SAT_ITEM_TEXT_LEN_MAX;
951 memcpy(item_obj->text, &src_data[index], item_obj->text_len);
952 dbg("[SAT PARSER] Item Text: [%s]", item_obj->text);
954 *consumed_data_len = 1+len_of_len+item_len;
956 return TCORE_SAT_SUCCESS;
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)
963 unsigned char* src_data = NULL;
965 if (!tlv_str || !response_obj || !consumed_data_len) {
966 err("[SAT] SAT PARSER data is null");
967 return TCORE_SAT_ERROR_FATAL;
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;
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
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
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);
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;
997 return TCORE_SAT_SUCCESS;
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)
1003 int index = 0, len_of_len = 0;
1005 unsigned char* src_data = NULL;
1007 if (!tlv_str || !sms_tpdu_obj || !consumed_data_len) {
1008 err("[SAT] SAT PARSER data is null");
1009 return TCORE_SAT_ERROR_FATAL;
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;
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;
1025 len_of_len = _get_length_filed_size(src_data[index]);
1027 err("[SAT] parser: invalid length.");
1028 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1030 tpdu_len = src_data[index+len_of_len-1];
1031 index += len_of_len;
1034 return TCORE_SAT_REQUIRED_VALUE_MISSING;
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;
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);
1046 *consumed_data_len = 1+len_of_len+tpdu_len;
1047 return TCORE_SAT_SUCCESS;
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)
1054 unsigned char* src_data = NULL;
1056 if (!tlv_str || !item_identifier_obj || !consumed_data_len) {
1057 err("[SAT] SAT PARSER data is null");
1058 return TCORE_SAT_ERROR_FATAL;
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;
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
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
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);
1082 return TCORE_SAT_SUCCESS;
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)
1088 char* str_ascii = NULL;
1089 int index, len_of_len=0;
1091 unsigned char* src_data;
1092 gboolean comprehension_req = FALSE;
1094 if (!tlv_str || !ss_str_obj || !consumed_data_len) {
1095 err("[SAT] SAT PARSER data is null");
1096 return TCORE_SAT_ERROR_FATAL;
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;
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
1111 if (src_data[index++]&0x80)
1112 comprehension_req = TRUE;
1115 len_of_len = _get_length_filed_size(src_data[index]);
1117 err("[SAT] parser: invalid length.");
1118 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1121 ss_len = src_data[index+len_of_len-1];
1122 dbg("[SAT] parser: ss_tlv len=%d",ss_len);
1124 index += len_of_len;
1125 ss_str_obj->string_len = 0;
1129 return TCORE_SAT_REQUIRED_VALUE_MISSING;
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);
1134 memcpy(ss_str_obj->ss_string, str_ascii, strlen(str_ascii));
1135 ss_str_obj->string_len = strlen(str_ascii);
1139 // 1 is the length of Tag.
1140 *consumed_data_len = 1 + len_of_len + ss_len;
1141 return TCORE_SAT_SUCCESS;
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)
1147 int index, len_of_len=0;
1149 unsigned char* src_data;
1150 gboolean comprehension_req = FALSE;
1152 if (!tlv_str || !consumed_data_len ) {
1153 err("[SAT] parser: data is null");
1154 return TCORE_SAT_ERROR_FATAL;
1157 if (tlv_len <= (curr_offset+1)) {
1158 err("[SAT] parser: incorrect length");
1159 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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;
1170 if (src_data[index++]&0x80)
1171 comprehension_req = TRUE;
1174 len_of_len = _get_length_filed_size(src_data[index]);
1176 err("[SAT] parser: invalid length.");
1177 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1180 text_len = src_data[index+len_of_len-1];
1181 dbg("[SAT] parser: text_tlv_len=%d",text_len);
1183 index += len_of_len;
1184 memset(text_obj->string, 0x00, SAT_TEXT_STRING_LEN_MAX);
1188 text_obj->string_length = 0;
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);
1195 // 1 is the length of Tag.
1196 *consumed_data_len = 1 + len_of_len + text_len;
1198 return TCORE_SAT_SUCCESS;
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)
1205 unsigned char* src_data;
1206 gboolean comprehension_req = FALSE;
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;
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;
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;
1226 if (src_data[index++]&0x80)
1227 comprehension_req = TRUE;
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
1235 if ((index+SATK_TONE_LENGTH) > tlv_len)
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;
1242 switch(src_data[index])
1244 // standard supervisory tones
1246 case CALLED_SUBSCRIBER_BUSY :
1248 case RADIO_PATH_ACK:
1249 case RADIO_PATH_NOT_AVAILABLE_CALL_DROPPED:
1250 case ERR_SPECIAL_INFO:
1251 case CALL_WAITING_TONE:
1253 // ME proprietary tones
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:
1263 case URGENT_ACTION_TONE :
1265 case MESSAGE_RECEIVED_TONE :
1275 dbg("[SAT] SAT PARSER - Tone =0x%x", src_data[index]);
1276 tone_obj->tone_type = src_data[index];
1279 case TONE_TYPE_RESERVED:
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;
1287 *consumed_data_len = 3;
1288 return TCORE_SAT_SUCCESS;
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)
1294 int index, len_of_len=0;
1296 unsigned char* src_data;
1297 gboolean comprehension_req = FALSE;
1299 if (!tlv_str || !ussd_str_obj || !consumed_data_len) {
1300 err("[SAT] SAT PARSER data is null");
1301 return TCORE_SAT_ERROR_FATAL;
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;
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
1316 if (src_data[index++]&0x80)
1317 comprehension_req = TRUE;
1320 len_of_len = _get_length_filed_size(src_data[index]);
1322 err("[SAT] parser: invalid length.");
1323 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1326 ussd_len = src_data[index+len_of_len-1];
1327 dbg("[SAT] parser: ussd_tlv len=%d",ussd_len);
1329 index += len_of_len;
1330 ussd_str_obj->string_len = 0;
1334 return TCORE_SAT_REQUIRED_VALUE_MISSING;
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);
1340 // 1 is the length of Tag.
1341 *consumed_data_len = 1 + len_of_len + ussd_len;
1342 return TCORE_SAT_SUCCESS;
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)
1349 int tmp_cnt, tmp_path_len;
1351 unsigned int ef = 0x0000;
1353 int index, len_of_len=0;
1354 int file_list_len = 0;
1355 unsigned char* src_data;
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;
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;
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;
1376 len_of_len = _get_length_filed_size(src_data[index]);
1378 err("[SAT] parser: invalid length.");
1379 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1381 file_list_len = src_data[index+len_of_len-1];
1382 index += len_of_len;
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;
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);
1395 dbg("file cnt = 0");
1396 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1402 if ( src_data[index] != 0x3F || src_data[index+1] != 0x00) {
1404 if (index > tlv_len) break;
1407 index+=2; //MASTER FILE (DIR) 0x3F00
1409 if (src_data[index] == 0x2F) {
1410 //ELEMENTRY FILE (VALUE)
1411 ef = src_data[index] << 8;
1413 ef = ef | src_data[index];
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++;
1420 else if (src_data[index] == 0x7F && src_data[index+1] == 0xFF) {
1421 //USIM DIRECTORY FILE (DIR) 0x7FFF
1423 if (src_data[index] == 0x6F) {
1426 ef = ef | src_data[index];
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++;
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
1440 if (src_data[index] == 0x6F) {
1441 ef = src_data[index] << 8;
1443 ef = ef | src_data[index];
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++;
1457 }while( f_count < tmp_cnt);
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;
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)
1471 unsigned char* src_data;
1472 gboolean comprehension_req = FALSE;
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;
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;
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;
1492 if ((src_data[index++]&0x7F))
1493 comprehension_req = TRUE;
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;
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;
1507 item_next_act_indi_obj->cnt = 0;
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);
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;
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)
1523 int index, len_of_len=0;
1525 unsigned char* src_data;
1526 gboolean comprehension_req = FALSE;
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;
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;
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;
1546 if ((src_data[index++]&0x80))
1547 comprehension_req = TRUE;
1550 len_of_len = _get_length_filed_size(src_data[index]);
1552 err("[SAT] parser: invalid length.");
1553 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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;
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;
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;
1570 evt_list_len = SAT_EVENT_LIST_MAX;
1573 event_list_obj->event_list_cnt = 0;
1574 memset(event_list_obj->evt_list, 0xFF, SAT_EVENT_LIST_MAX);
1576 modem_event_list_obj->event_list_cnt = 0;
1577 memset(modem_event_list_obj->evt_list, 0xFF, SAT_EVENT_LIST_MAX);
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]) {
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++;
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++;
1604 if (comprehension_req)
1605 return TCORE_SAT_BEYOND_ME_CAPABILITY;
1611 // 1 is the length of Tag.
1612 *consumed_data_len = 1 + len_of_len + evt_list_len;
1613 return TCORE_SAT_SUCCESS;
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)
1619 unsigned char* src_data;
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;
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;
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
1640 if (src_data[index++] != SATK_ICON_IDENTITY_LENGTH) {
1641 dbg("[SAT] SAT PARSER - incorrect length value.");
1642 return FALSE; //send TR
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;
1649 icon_id_obj->is_exist = TRUE;
1651 if ((src_data[index++]&0x01))
1652 icon_id_obj->icon_qualifer = ICON_QUALI_NOT_SELF_EXPLANATORY;
1654 icon_id_obj->icon_qualifer = ICON_QUALI_SELF_EXPLANATORY;
1656 if (src_data[index] > 0x00) {
1657 icon_id_obj->icon_identifier = src_data[index];
1660 dbg("[SAT] SAT PARSER - incorrect icon identifier");
1661 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
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;
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)
1675 unsigned char* src_data;
1676 gboolean comprehension_req = FALSE;
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;
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;
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
1696 icon_list_obj->is_exist = TRUE;
1697 if (src_data[index++]&0x80)
1698 comprehension_req = TRUE;
1700 len_value = src_data[index++];
1701 if (src_data[index++]&0x01)
1702 icon_list_obj->icon_qualifer = ICON_QUALI_NOT_SELF_EXPLANATORY;
1704 icon_list_obj->icon_qualifer = ICON_QUALI_SELF_EXPLANATORY;
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;
1712 icon_list_obj->icon_cnt = 0;
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++];
1720 dbg("[SAT] SAT PARSER - incorrect icon identifier");
1721 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //send TR
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;
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)
1734 unsigned char* src_data;
1735 int index, len_of_len = 0;
1737 gboolean comprehension_req = FALSE;
1738 char* str_ascii = NULL;
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;
1745 src_data = &tlv_str[0];
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;
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;
1759 //comprehensive required
1760 if ((src_data[index++] & 0x80))
1761 comprehension_req = TRUE;
1764 len_of_len = _get_length_filed_size(src_data[index]);
1766 err("[SAT] parser: invalid length.");
1767 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1770 dtmf_len = src_data[index + len_of_len - 1];
1771 index += len_of_len; //index pointing to TON/NPI
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;
1778 dtmf_string_obj->dtmf_length = 0;
1781 str_ascii = tcore_util_convert_bcd2ascii((const char*)&src_data[index], dtmf_len, SAT_DTMF_STRING_LEN_MAX);
1783 memcpy(dtmf_string_obj->dtmf_string, str_ascii, strlen(str_ascii));
1784 dtmf_string_obj->dtmf_length = strlen(str_ascii);
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;
1794 *consumed_data_len = 1 + len_of_len + dtmf_len;
1795 return TCORE_SAT_SUCCESS;
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)
1801 unsigned char* src_data;
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;
1809 src_data = &tlv_str[0];
1810 index = curr_offset;
1812 if ((src_data[index++]&0x7F) != SATK_LANGUAGE_TAG) {
1813 dbg("[SAT] SAT PARSER - Language tag missing.");
1814 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1816 if (src_data[index++] != SATK_LANGUAGE_LENGTH) {
1817 dbg("[SAT] SAT PARSER - incorrect length value.");
1818 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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;
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;
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)
1833 unsigned char* src_data;
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;
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;
1846 index = curr_offset;
1847 src_data = &tlv_str[0];
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;
1853 if (src_data[index++] != SATK_BROWSER_ID_LENGTH) {
1854 dbg("[SAT] SAT PARSER - incorrect length value.");
1855 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1858 dbg("[SAT] SAT PARSER - : browser ID value:ox%x", src_data[index]);
1860 switch (src_data[index]) {
1862 *browser_id = BROWSER_ID_DEFAULT;
1865 *browser_id = BROWSER_ID_WML;
1868 *browser_id = BROWSER_ID_HTML;
1871 *browser_id = BROWSER_ID_XHTML;
1874 *browser_id = BROWSER_ID_CHTML;
1877 *browser_id = BROWSER_ID_RESERVED;
1881 *consumed_data_len = 3;
1882 return TCORE_SAT_SUCCESS;
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)
1888 unsigned char* src_data;
1889 int index= curr_offset;
1890 int len_of_len=0, url_len=0;
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;
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;
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
1909 len_of_len = _get_length_filed_size(src_data[index]);
1911 err("[SAT] parser: invalid length.");
1912 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1915 url_len = src_data[index+len_of_len-1];
1916 index+=len_of_len; //index pointing to url.
1919 if (url_len > SAT_URL_LEN_MAX)
1920 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1922 memcpy(url->url, &src_data[index], url_len);
1924 dbg("[SAT] SAT PARSER - NULL string for URL");
1927 *consumed_data_len = 1+len_of_len+url_len;
1928 return TCORE_SAT_SUCCESS;
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)
1934 unsigned char* src_data;
1935 int index, len_of_len = 0;
1936 int list_len = 0, list_idx = 0;
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;
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;
1948 src_data = &tlv_str[0];
1949 index = curr_offset;
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;
1957 len_of_len = _get_length_filed_size(src_data[index]);
1959 err("[SAT] parser: invalid length.");
1960 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
1963 satk_bearer->count = src_data[index + len_of_len - 1];
1964 list_len = satk_bearer->count;
1965 index += len_of_len;
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;
1972 if (satk_bearer->count > 0) {
1973 if (list_len > SAT_BEARER_LIST_MAX_COUNT)
1974 list_len = SAT_BEARER_LIST_MAX_COUNT;
1976 for (list_idx = 0; list_idx < list_len; list_idx++) {
1977 switch (src_data[index]) {
1979 satk_bearer->bear[list_idx] = BEARER_LIST_SMS;
1982 satk_bearer->bear[list_idx] = BEARER_LIST_CSD;
1985 satk_bearer->bear[list_idx] = BEARER_LIST_USSD;
1988 satk_bearer->bear[list_idx] = BEARER_LIST_GPRS;
1991 satk_bearer->bear[list_idx] = BEARER_LIST_RESERVED;
1994 dbg("[SAT] SAT PARSER - bearer[%d]=0x%x", list_idx, satk_bearer->bear[list_idx]);
1998 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2001 *consumed_data_len = 1 + len_of_len + list_len;
2002 return TCORE_SAT_SUCCESS;
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)
2008 unsigned char* src_data;
2009 int index = curr_offset;
2010 int len_of_len = 0, prf_len = 0;
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;
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;
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
2029 len_of_len = _get_length_filed_size(src_data[index]);
2031 err("[SAT] parser: invalid length.");
2032 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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.
2040 if (prf_len > SAT_PROVISIONING_FILE_PATH_LEN_MAX)
2041 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2043 memcpy(prf->file_path, &src_data[index], prf_len);
2045 dbg("[SAT] SAT PARSER - NULL string for PRF");
2046 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
2049 *data_len_consumed = 1 + len_of_len + prf_len;
2050 return TCORE_SAT_SUCCESS;
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)
2057 int index, length=0;
2058 unsigned char* src_data;
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;
2065 index = curr_offset;
2066 src_data = &tlv_str[0];
2068 if (index >= tlv_len) {
2069 dbg("bearer desc cannot find. UICC Server mode");
2070 *consumed_data_len = 0;
2071 return TCORE_SAT_SUCCESS;
2074 if ( (src_data[index]&0x7F) == SATK_BEARER_DISCRIPTION_TAG ) {
2075 dbg("find bearer description tag index(%d)", index);
2083 length = src_data[index++];
2084 dbg("bearer description length (%d)", length);
2087 switch(src_data[index++]) {
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++];
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;
2105 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:
2106 bearer_desc_obj->bearer_type = BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER;
2108 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:
2109 bearer_desc_obj->bearer_type = BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER;
2112 bearer_desc_obj->bearer_type = BEARER_RESERVED;
2113 dbg("bearer type not supported");
2114 return TCORE_SAT_BEYOND_ME_CAPABILITY;
2117 *consumed_data_len = 1+1+length;
2118 return TCORE_SAT_SUCCESS;
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)
2126 int len_of_len = 0, channel_data_len = 0;
2127 unsigned char* src_data;
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;
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;
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;
2148 len_of_len = _get_length_filed_size(src_data[index]);
2150 err("[SAT] parser: invalid length.");
2151 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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;
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;
2164 channel_data_obj->data_string_len = channel_data_len;
2165 memcpy(channel_data_obj->data_string, &src_data[index], channel_data_len);
2167 *consumed_data_len = 1+len_of_len+channel_data_len;
2168 return TCORE_SAT_SUCCESS;
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)
2176 unsigned char* src_data;
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;
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
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
2198 data_len_obj->data_len = src_data[index];
2200 *consumed_data_len = 3;
2201 return TCORE_SAT_SUCCESS;
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)
2209 unsigned char* src_data;
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;
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;
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
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
2235 buffer_size_obj->size[0] = src_data[index++];
2236 buffer_size_obj->size[1] = src_data[index];
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;
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)
2247 gchar* address = NULL;
2248 int index, address_len;
2249 unsigned char* src_data;
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;
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;
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
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;
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;
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]);
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]);
2296 other_address_obj->address_type = ADDR_RESERVED;
2297 address = g_strdup("");
2302 memcpy(other_address_obj->address, address, strlen(address));
2303 other_address_obj->address_len = strlen(address);
2308 dbg("destination address(%s)", other_address_obj->address);
2309 *consumed_data_len = 2+address_len;
2310 return TCORE_SAT_SUCCESS;
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)
2318 unsigned char* src_data;
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;
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;
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
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
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];
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;
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)
2358 int len_of_len = 0, remote_data_len = 0;
2359 unsigned char* src_data;
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;
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;
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;
2380 len_of_len = _get_length_filed_size(src_data[index]);
2382 err("[SAT] parser: invalid length.");
2383 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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;
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;
2395 case REMOTE_ENTITY_ADDR_CODING_TYPE_IRDA_32BIT:
2396 remote_address_obj->coding_type = REMOTE_ENTITY_ADDR_CODING_TYPE_IRDA_32BIT;
2399 remote_address_obj->coding_type =REMOTE_ENTITY_ADDR_CODING_TYPE_RESERVED;
2403 remote_address_obj->length = remote_data_len - 1;
2404 memcpy(remote_address_obj->remote_entity_address, &src_data[index], remote_address_obj->length);
2406 *consumed_data_len = 1+len_of_len+remote_data_len;
2407 return TCORE_SAT_SUCCESS;
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)
2414 int index, idx, name_idx, name_length;
2415 unsigned char* src_data;
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;
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;
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
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;
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;
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]) );
2452 if ( g_ascii_isalpha(src_data[index]) ) {
2453 access_name_obj->network_access_name[name_idx] = src_data[index];
2458 if (src_data[index] == 0x02) {//02 convert to "."
2459 access_name_obj->network_access_name[name_idx] = '.';
2466 //network access name
2467 dbg("network access name(%s)", access_name_obj->network_access_name);
2469 *consumed_data_len = 2+name_length;
2470 return TCORE_SAT_SUCCESS;
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)
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;
2484 if (o_cmd_data == NULL) {
2485 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
2486 return TCORE_SAT_ERROR_FATAL;
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++];
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 =
2498 dbg("[SAT] SAT PARSER - msg_prio=TAPI_SAT_MSG_PRIORITY_HIGH.");
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.");
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.");
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.");
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)
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)
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;
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);
2536 if (index+data_len_consumed > o_length) {
2537 err("[SAT] SAT PARSER - Wrong String TLV");
2538 return TCORE_SAT_BEYOND_ME_CAPABILITY;
2540 else if (index+data_len_consumed == o_length) {
2541 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2542 return TCORE_SAT_SUCCESS;
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);
2551 if (rv != TCORE_SAT_SUCCESS) {
2552 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
2555 if (index+data_len_consumed >= o_length) {
2556 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2557 return TCORE_SAT_SUCCESS;
2560 index+=data_len_consumed; //index pointing to the Tag of next TLV
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;
2571 if (index >= o_length) {
2572 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2573 return TCORE_SAT_SUCCESS;
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
2584 dbg("[SAT] SAT PARSER - :decoding done!.");
2585 return TCORE_SAT_SUCCESS;
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)
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;
2598 if (o_cmd_data == NULL) {
2599 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
2600 return TCORE_SAT_ERROR_FATAL;
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++];
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");
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");
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");
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");
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");
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");
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");
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)
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)
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;
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);
2663 if (index+data_len_consumed > o_length) {
2664 err("[SAT] SAT PARSER - Wrong String TLV");
2665 return TCORE_SAT_BEYOND_ME_CAPABILITY;
2667 else if (index+data_len_consumed == o_length) {
2668 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
2669 return TCORE_SAT_SUCCESS;
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);
2678 if (rv != TCORE_SAT_SUCCESS) {
2679 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
2682 if (index+data_len_consumed >= o_length) {
2683 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2684 return TCORE_SAT_SUCCESS;
2687 index+=data_len_consumed; //index pointing to the Tag of next TLV
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
2698 dbg("[SAT] SAT PARSER - :decoding done!.");
2699 return TCORE_SAT_SUCCESS;
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)
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;
2712 if (o_cmd_data == NULL) {
2713 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
2714 return TCORE_SAT_ERROR_FATAL;
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++];
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");
2728 sat_cmd_ind_data->data.get_input.command_detail.cmd_qualifier.get_input.alphabet_set = FALSE;
2729 dbg("[SAT] SAT PARSER - Numeric info");
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");
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");
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");
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");
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");
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");
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");
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)
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)
2777 if (sat_cmd_ind_data->data.get_input.text.string_length <= 0) {
2778 err("[SAT] SAT PARSER - :string length is 0");
2780 dbg("[SAT] SAT PARSER text(%s)",sat_cmd_ind_data->data.get_input.text.string);
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)
2788 if (index+data_len_consumed >= o_length) {
2789 err("[SAT] SAT PARSER - no more TLVs");
2790 return TCORE_SAT_SUCCESS;
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)
2800 if (sat_cmd_ind_data->data.get_input.default_text.string_length <= 0) {
2801 err("[SAT] SAT PARSER - :string length is 0");
2803 dbg("[SAT] SAT PARSER default text(%s)",sat_cmd_ind_data->data.get_input.default_text.string);
2804 index+=data_len_consumed;
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);
2812 if (rv != TCORE_SAT_SUCCESS) {
2813 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
2816 if (index+data_len_consumed >= o_length) {
2817 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2818 return TCORE_SAT_SUCCESS;
2821 index+=data_len_consumed; //index pointing to the Tag of next TLV
2824 dbg("[SAT] SAT PARSER - :decoding done!.");
2825 return TCORE_SAT_SUCCESS;
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)
2833 unsigned char dev_id[4];
2834 unsigned char* cmd_data = NULL;
2835 enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
2837 if (o_cmd_data == NULL) {
2838 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
2839 return TCORE_SAT_ERROR_FATAL;
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++];
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)
2856 dbg("[SAT] SAT PARSER - :decoding done!.");
2857 return TCORE_SAT_SUCCESS;
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)
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;
2869 if (o_cmd_data == NULL) {
2870 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
2871 return TCORE_SAT_ERROR_FATAL;
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++];
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;
2884 sat_cmd_ind_data->data.play_tone.command_detail.cmd_qualifier.play_tone.vibration_alert = VIBRATE_ALERT_OPTIONAL;
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)
2893 //alpha id - optional
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) {
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;
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) {
2918 index+=data_len_consumed;
2921 sat_cmd_ind_data->data.play_tone.tone.tone_type = GENERAL_BEEP;
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
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;
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;
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);
2948 if (rv != TCORE_SAT_SUCCESS) {
2949 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
2952 if (index+data_len_consumed >= o_length) {
2953 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
2954 return TCORE_SAT_SUCCESS;
2957 index+=data_len_consumed; //index pointing to the Tag of next TLV
2960 //ToDo: Text Attribute and frames
2961 dbg("[SAT] SAT PARSER - :decoding done!.");
2962 return TCORE_SAT_SUCCESS;
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)
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;
2974 if (o_cmd_data == NULL) {
2975 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
2976 return TCORE_SAT_ERROR_FATAL;
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++];
2985 /* ******decode command qualifier****** */
2986 switch(cmd_data[index]) {
2987 case REFRESH_SIM_INIT_AND_FULL_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]);
2996 case REFRESH_3G_APPLICATION_RESET:
2997 case REFRESH_3G_SESSION_RESET:
2998 case REFRESH_RESERVED:
3000 dbg("[SAT] SAT PARSER - : refresh mode=0x%02x Not Supported", cmd_data[index]);
3001 return TCORE_SAT_BEYOND_ME_CAPABILITY;
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)
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) ) {
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)
3022 sat_cmd_ind_data->data.refresh.file_list.file_count = 0;
3024 dbg("[SAT] SAT PARSER - :decoding done!.");
3025 return TCORE_SAT_SUCCESS;
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)
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;
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];
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++];
3047 // [2] decode COMMAND QUALIFIER
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.
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.");
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.");
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 =
3072 ;dbg("[SAT] SAT PARSER - : is help Available=TRUE.");
3075 pactive_cmd_ind_obj->data.setup_menu.command_detail.cmd_qualifier.setup_menu.help_info =
3077 dbg("[SAT] SAT PARSER - is help Available=FALSE.");
3080 // In this time, the point of index is DEVICE IDENTITIES.
3081 //[3] decode DEVICE IDENTITIES TLV
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()
3091 // In this time, the point of index is ALPHA IDENTIFIER. 11 or 12.
3092 //[4] decode ALPHA IDENTIFIER TLV
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) {
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;
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);
3112 if (rv != TCORE_SAT_SUCCESS)
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;
3123 pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt++;
3124 index += data_len_consumed;
3126 if (index >= tlv_len)
3128 }while(pactive_cmd_ind_obj->data.setup_menu.menu_item_cnt < SAT_MENU_ITEM_COUNT_MAX);
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;
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;
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;
3150 index+=data_len_consumed; //index pointing to the Tag of next TLV
3153 dbg("[SAT] SAT PARSER - ITEMS NEXT ACTION INDICATOR TLV Not present");
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;
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;
3169 index+=data_len_consumed; //index pointing to the Tag of next TLV
3172 dbg("[SAT] SAT PARSER - ICON IDENTIFIER TLV Not present");
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
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;
3187 index+=data_len_consumed; //index pointing to the Tag of next TLV
3191 dbg("[SAT] SAT PARSER - ICON IDENTIFIER LIST TLV not present");
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;
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)
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;
3209 if (o_cmd_data == NULL) {
3210 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
3211 return TCORE_SAT_ERROR_FATAL;
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++];
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");
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");
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");
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");
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");
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");
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)
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) {
3263 index+=data_len_consumed;
3267 sat_cmd_ind_data->data.select_item.menu_item_cnt = 0;
3269 data_len_consumed=0;
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);
3276 if (rv != TCORE_SAT_SUCCESS)
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;
3287 sat_cmd_ind_data->data.select_item.menu_item_cnt++;
3288 index += data_len_consumed;
3290 if (index >= o_length)
3293 }while(sat_cmd_ind_data->data.select_item.menu_item_cnt < SAT_MENU_ITEM_COUNT_MAX);
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;
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)
3309 if (index+data_len_consumed >= o_length) {
3310 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3311 return TCORE_SAT_SUCCESS;
3314 index+=data_len_consumed;
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)
3325 if (index+data_len_consumed >= o_length) {
3326 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3327 return TCORE_SAT_SUCCESS;
3330 index+=data_len_consumed; //index pointing to the Tag of next TLV
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);
3339 if (rv != TCORE_SAT_SUCCESS) {
3340 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3343 if (index+data_len_consumed >= o_length) {
3344 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3345 return TCORE_SAT_SUCCESS;
3348 index+=data_len_consumed; //index pointing to the Tag of next TLV
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
3358 if (index+data_len_consumed >= o_length) {
3359 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3360 return TCORE_SAT_SUCCESS;
3362 index+=data_len_consumed; //index pointing to the Tag of next TLV
3365 dbg("[SAT] SAT PARSER - :decoding done!.");
3366 return TCORE_SAT_SUCCESS;
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)
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;
3379 if (o_cmd_data == NULL) {
3380 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
3381 return TCORE_SAT_ERROR_FATAL;
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++];
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;
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");
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)
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) {
3413 index+=data_len_consumed;
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) {
3423 index+=data_len_consumed;
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)
3432 if (index+data_len_consumed >= o_length) {
3433 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3434 return TCORE_SAT_SUCCESS;
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);
3444 if (rv != TCORE_SAT_SUCCESS) {
3445 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3448 if (index+data_len_consumed >= o_length) {
3449 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3450 return TCORE_SAT_SUCCESS;
3453 index+=data_len_consumed; //index pointing to the Tag of next TLV
3456 dbg("[SAT] SAT PARSER - :decoding done!.");
3457 return TCORE_SAT_SUCCESS;
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)
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;
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;
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++];
3479 /** command detail **/
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)
3488 //alpha identifier - optional
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) {
3495 index+=data_len_consumed;
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)
3503 //icon identifier- optional
3504 index+=data_len_consumed;
3505 if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3506 data_len_consumed = 0;
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
3515 dbg("[SAT] SAT PARSER - :decoding done!.");
3516 return TCORE_SAT_SUCCESS;
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)
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;
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;
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++];
3538 /** command detail **/
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)
3547 //alpha identifier - optional
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) {
3554 index+=data_len_consumed;
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)
3562 //icon identifier- optional
3563 index+=data_len_consumed;
3564 if ((cmd_data[index]&0x7F) == SATK_ICON_IDENTIFIER_TAG) {
3565 data_len_consumed = 0;
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
3574 dbg("[SAT] SAT PARSER - :decoding done!.");
3575 return TCORE_SAT_SUCCESS;
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)
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;
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;
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++];
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);
3609 case SETUP_CALL_RESERVED:
3611 dbg("[SAT] SAT PARSER - setup_call.cmd_qualifier= 0x%02x", cmd_data[index]);
3612 return TCORE_SAT_BEYOND_ME_CAPABILITY;
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)
3623 //alpha identifier (user confirmation) - optional
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) {
3630 index+=data_len_consumed;
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) {
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;
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
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;
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
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;
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
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;
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);
3692 if (rv != TCORE_SAT_SUCCESS) {
3693 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
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;
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) {
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;
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);
3722 if (rv != TCORE_SAT_SUCCESS) {
3723 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
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;
3733 //ToDo: Text Attribute (user_confirmation , call_setup)
3735 dbg("[SAT] SAT PARSER - :decoding done!.");
3736 return TCORE_SAT_SUCCESS;
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)
3744 unsigned char dev_id[4];
3745 unsigned char* cmd_data = NULL;
3746 enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3748 if (o_cmd_data == NULL) {
3749 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
3750 return TCORE_SAT_ERROR_FATAL;
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++];
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];
3765 //TODO - Other cases
3767 sat_cmd_ind_data->data.setup_event_list.command_detail.cmd_qualifier.provide_local_info.provide_local_info = LOCAL_INFO_RESERVED;
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)
3778 //TODO - UTRAN Measurement Qualifier
3780 dbg("[SAT] SAT PARSER - :decoding done!.");
3781 return TCORE_SAT_SUCCESS;
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)
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;
3793 if (o_cmd_data == NULL) {
3794 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
3795 return TCORE_SAT_ERROR_FATAL;
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++];
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)
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);
3817 dbg("[SAT] SAT PARSER - :decoding done!.");
3818 return TCORE_SAT_SUCCESS;
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)
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;
3830 if (o_cmd_data == NULL) {
3831 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
3832 return TCORE_SAT_ERROR_FATAL;
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++];
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)
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)
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;
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);
3862 if (index+data_len_consumed > o_length) {
3863 err("[SAT] SAT PARSER - Wrong String TLV");
3864 return TCORE_SAT_BEYOND_ME_CAPABILITY;
3866 else if (index+data_len_consumed == o_length) {
3867 dbg("[SAT] SAT PARSER - :no more TLVs to decode.");
3868 return TCORE_SAT_SUCCESS;
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);
3877 if (rv != TCORE_SAT_SUCCESS) {
3878 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD; //SEND TR
3881 if (index+data_len_consumed >= o_length) {
3882 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3883 return TCORE_SAT_SUCCESS;
3886 index+=data_len_consumed; //index pointing to the Tag of next TLV
3889 //ToDo: Text Attribute
3890 dbg("[SAT] SAT PARSER - :decoding done!.");
3891 return TCORE_SAT_SUCCESS;
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)
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;
3903 if (o_cmd_data == NULL) {
3904 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
3905 return TCORE_SAT_ERROR_FATAL;
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++];
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)
3921 //alpha identifier - optional
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) {
3928 index+=data_len_consumed;
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) {
3939 if (index + data_len_consumed >= o_length) {
3940 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3941 return TCORE_SAT_SUCCESS;
3943 index += data_len_consumed;
3945 dbg("[SAT] SAT PARSER - DTMF tlv is missed.");
3946 return TCORE_SAT_REQUIRED_VALUE_MISSING;
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);
3955 if (rv != TCORE_SAT_SUCCESS) {
3956 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
3959 if (index + data_len_consumed >= o_length) {
3960 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
3961 return TCORE_SAT_SUCCESS;
3963 index += data_len_consumed; //index pointing to the Tag of next TLV
3966 //ToDo: Text Attribute, Frame Identifier
3967 dbg("[SAT] SAT PARSER - :decoding done!.");
3968 return TCORE_SAT_SUCCESS;
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)
3976 unsigned char dev_id[4];
3977 unsigned char* cmd_data = NULL;
3978 enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
3980 if (o_cmd_data == NULL) {
3981 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
3982 return TCORE_SAT_ERROR_FATAL;
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++];
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;
3995 sat_cmd_ind_data->data.language_notification.command_detail.cmd_qualifier.language_notification.specific_language = FALSE;
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)
4004 //language - conditional
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)
4012 dbg("[SAT] SAT PARSER - Language TLV is required but missing.");
4013 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4016 sat_cmd_ind_data->data.language_notification.language = SIM_LANG_UNSPECIFIED;
4017 dbg("[SAT] SAT PARSER - non-specific language");
4020 dbg("[SAT] SAT PARSER - :decoding done!.");
4021 return TCORE_SAT_SUCCESS;
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)
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;
4033 if (o_cmd_data == NULL) {
4034 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
4035 return TCORE_SAT_ERROR_FATAL;
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++];
4044 // decode command qualifier
4045 switch (cmd_data[index]) {
4047 sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4048 LAUNCH_BROWSER_IF_NOT_ALREADY_LAUNCHED;
4051 sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4052 LAUNCH_BROWSER_NOT_USED;
4055 sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4056 LAUNCH_BROWSER_USE_EXISTING_BROWSER;
4059 sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4060 LAUNCH_BROWSER_CLOSE_AND_LAUNCH_NEW_BROWSER;
4063 sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4064 LAUNCH_BROWSER_NOT_USED2;
4067 sat_cmd_ind_data->data.launch_browser.command_detail.cmd_qualifier.launch_browser.launch_browser =
4068 LAUNCH_BROWSER_RESERVED;
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)
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)
4086 index += data_len_consumed;
4088 dbg("[SAT] SAT PARSER - Browser ID NOT present");
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)
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;
4101 dbg("[SAT] SAT PARSER - more TLVs to decode, decoding continue.");
4102 index += data_len_consumed;
4105 dbg("[SAT] SAT PARSER - Browser URL NOT present! BUG! this value is mandatory!!!");
4106 return TCORE_SAT_REQUIRED_VALUE_MISSING;
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)
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;
4119 index += data_len_consumed;
4122 dbg("[SAT] SAT PARSER - Bearer TLV Not present.");
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;
4133 rv = _sat_decode_provisioning_file_ref_tlv(
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) {
4142 sat_cmd_ind_data->data.launch_browser.file_ref_count++;
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;
4149 index += data_len_consumed;
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)
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;
4163 index += data_len_consumed;
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) {
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;
4177 index+=data_len_consumed;
4179 dbg("[SAT] SAT PARSER - No Alpha ID TLV.");
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);
4188 if (rv != TCORE_SAT_SUCCESS) {
4189 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
4192 if (index + data_len_consumed >= o_length) {
4193 dbg("[SAT] SAT PARSER - no more TLVs to decode.");
4194 return TCORE_SAT_SUCCESS;
4196 index += data_len_consumed; //index pointing to the Tag of next TLV
4199 //ToDo: Text Attribute, Frame Identifier
4200 dbg("[SAT] SAT PARSER - :decoding done!.");
4201 return TCORE_SAT_SUCCESS;
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)
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;
4215 if (o_cmd_data == NULL) {
4216 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
4217 return TCORE_SAT_ERROR_FATAL;
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++];
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;
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");
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");
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");
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)
4252 //alpha identifier - optional
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) {
4259 index+=data_len_consumed;
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
4269 index+=data_len_consumed; //index pointing to the Tag of next TLV
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)
4277 //TODO UICC SERVER MODE
4279 switch(sat_cmd_ind_data->data.open_channel.bearer_desc.bearer_type) {
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) {
4287 index+=data_len_consumed;
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) {
4296 index+=data_len_consumed;
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
4306 index+=data_len_consumed;
4307 b_1st_duration = TRUE;
4310 //time duration 2- optional
4311 if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
4313 if (!b_1st_duration) {
4314 dbg("duration 1 does not present!");
4315 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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
4323 index+=data_len_consumed;
4326 //bearer description - already did it
4327 index+=bearer_desc_len;
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
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;
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
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;
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)
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;
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)
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;
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)
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;
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
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;
4415 //bearer description - already did it
4416 index+=bearer_desc_len;
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
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;
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
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;
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
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;
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)
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;
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)
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;
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)
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;
4502 dbg("the value (0x%x) after interface transport level", cmd_data[index]&0x7F);
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
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;
4520 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:
4521 //bearer description - already did it
4522 index+=bearer_desc_len;
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
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;
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
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;
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)
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;
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)
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;
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)
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;
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
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;
4609 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:
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
4618 index+=data_len_consumed;
4619 b_1st_duration = TRUE;
4622 //time duration 2- optional
4623 if ((cmd_data[index]&0x7F)==SATK_DURATION_TAG) {
4625 if (!b_1st_duration) {
4626 dbg("duration 1 does not present!");
4627 return TCORE_SAT_COMMAND_NOT_UNDERSTOOD;
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
4635 index+=data_len_consumed;
4638 //bearer description - already did it
4639 index+=bearer_desc_len;
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
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;
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)
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;
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)
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;
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
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;
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
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;
4716 dbg("[SAT] SAT PARSER - :decoding done!.");
4717 return TCORE_SAT_SUCCESS;
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)
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;
4730 if (o_cmd_data == NULL) {
4731 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
4732 return TCORE_SAT_ERROR_FATAL;
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++];
4740 /** command detail **/
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)
4749 //alpha identifier - optional
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) {
4756 index+=data_len_consumed;
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
4766 index+=data_len_consumed; //index pointing to the Tag of next TLV
4769 //ToDo: Text Attribute and frames
4771 dbg("[SAT] SAT PARSER - :decoding done!.");
4772 return TCORE_SAT_SUCCESS;
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)
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;
4785 if (o_cmd_data == NULL) {
4786 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
4787 return TCORE_SAT_ERROR_FATAL;
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++];
4795 /** command detail **/
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)
4804 //alpha identifier - optional
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) {
4811 index+=data_len_consumed;
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
4821 index+=data_len_consumed; //index pointing to the Tag of next TLV
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
4830 //ToDo: Text Attribute and frames
4832 dbg("[SAT] SAT PARSER - :decoding done!.");
4833 return TCORE_SAT_SUCCESS;
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)
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;
4846 if (o_cmd_data == NULL) {
4847 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
4848 return TCORE_SAT_ERROR_FATAL;
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++];
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");
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)
4870 //alpha identifier - optional
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) {
4877 index+=data_len_consumed;
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
4887 index+=data_len_consumed; //index pointing to the Tag of next TLV
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
4896 //ToDo: Text Attribute and frames
4898 dbg("[SAT] SAT PARSER - :decoding done!.");
4899 return TCORE_SAT_SUCCESS;
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)
4907 unsigned char dev_id[4];
4908 unsigned char* cmd_data = NULL;
4909 enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
4911 if (o_cmd_data == NULL) {
4912 dbg("[SAT] SAT PARSER - o_cmd_data == NULL");
4913 return TCORE_SAT_ERROR_FATAL;
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++];
4921 /** command detail **/
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)
4930 dbg("[SAT] SAT PARSER - :decoding done!.");
4931 return TCORE_SAT_SUCCESS;
4934 int tcore_sat_decode_proactive_command(unsigned char* tlv_origin, unsigned int tlv_length,
4935 struct tcore_sat_proactive_command* decoded_tlv)
4937 unsigned int index = 0;
4938 int length_field_len = 0;
4939 enum tcore_sat_result rv = TCORE_SAT_SUCCESS;
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;
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;
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;
4959 index+=length_field_len;
4961 //check command validation
4962 if (tlv_length < index+5+4)//command detail(5) and device identities(4)
4963 return TCORE_SAT_ERROR_FATAL;
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;
4971 if ( (tlv_origin[index] & 0x7F) != SATK_COMMAND_DETAILS_TAG) {
4972 err("[SAT] no command detail info");
4973 return TCORE_SAT_ERROR_FATAL;
4976 if ( tlv_origin[index+1] != SATK_COMMAND_DETAILS_LENGTH) {
4977 err("[SAT] invalid command detail length");
4978 return TCORE_SAT_ERROR_FATAL;
4981 decoded_tlv->cmd_num= tlv_origin[index+2];
4982 decoded_tlv->cmd_type = tlv_origin[index+3];
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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;
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.");
5090 static unsigned char _sat_encode_dcs_tlv(const struct data_coding_scheme* src)
5092 unsigned char rv = 0x00;
5097 if (src->is_compressed_format)
5101 switch(src->m_class) {
5110 case MSG_CLASS_RESERVED:
5111 case MSG_CLASS_NONE:
5118 switch(src->a_format)
5120 case ALPHABET_FORMAT_SMS_DEFAULT:
5124 case ALPHABET_FORMAT_8BIT_DATA:
5128 case ALPHABET_FORMAT_UCS2:
5140 static int _sat_encode_command_detail_tlv(const struct tel_sat_cmd_detail_info* src, char *dst, int current_index)
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;
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;
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;
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;
5163 //command detail alphabet type
5164 if (src->cmd_qualifier.get_inkey.alphabet_type == INPUT_ALPHABET_TYPE_UCS2)
5165 dst[current_index] += 0x02;
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;
5172 //command detail immediate response required
5173 if (src->cmd_qualifier.get_inkey.immediate_rsp_required)
5174 dst[current_index] += 0x08;
5176 //command detail help available
5177 if (src->cmd_qualifier.get_inkey.help_info)
5178 dst[current_index] += 0x80;
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;
5185 //command detail alphabet type
5186 if (src->cmd_qualifier.get_input.alphabet_type == INPUT_ALPHABET_TYPE_UCS2)
5187 dst[current_index] += 0x02;
5189 //command detail echo user input
5190 if (!src->cmd_qualifier.get_input.me_echo_user_input)
5191 dst[current_index] += 0x04;
5193 //command detail user input unpacked format
5194 if (!src->cmd_qualifier.get_input.user_input_unpacked_format)
5195 dst[current_index] += 0x08;
5197 //command detail help available
5198 if (src->cmd_qualifier.get_input.help_info)
5199 dst[current_index] += 0x80;
5201 case SAT_PROATV_CMD_MORE_TIME:{
5202 dbg("more time : 1bit RFU");
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;
5209 case SAT_PROATV_CMD_REFRESH:{
5210 //command detail refresh command
5211 dst[current_index] += src->cmd_qualifier.refresh.refresh;
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;
5218 //command detail help available
5219 if (src->cmd_qualifier.setup_menu.help_info)
5220 dst[current_index] += 0x80;
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;
5231 //command detail selection preference
5232 if (src->cmd_qualifier.select_item.select_preference == SELECTION_PREFERENCE_USING_SOFT_KEY)
5233 dst[current_index] += 0x04;
5235 //command detail help available
5236 if (src->cmd_qualifier.select_item.help_info)
5237 dst[current_index] += 0x80;
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;
5244 case SAT_PROATV_CMD_SETUP_CALL:{
5245 //command detail setup call command;
5246 dst[current_index] += src->cmd_qualifier.setup_call.setup_call;
5248 case SAT_PROATV_CMD_SETUP_EVENT_LIST:{
5249 dbg("setup evnet list : 1bit RFU");
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;
5259 case SAT_PROATV_CMD_SEND_DATA:{
5260 if (src->cmd_qualifier.send_data.send_data_immediately)
5261 dst[current_index] += 0x01;
5263 case SAT_PROATV_CMD_PROVIDE_LOCAL_INFO:{
5264 dst[current_index] += src->cmd_qualifier.provide_local_info.provide_local_info;
5266 case SAT_PROATV_CMD_LANGUAGE_NOTIFICATION:{
5267 if (src->cmd_qualifier.language_notification.specific_language)
5268 dst[current_index] += 0x01;
5270 case SAT_PROATV_CMD_LAUNCH_BROWSER:{
5271 dst[current_index] += src->cmd_qualifier.launch_browser.launch_browser;
5274 err("no matched cmd type(%d)", src->cmd_type);
5281 static int _sat_encode_device_identities_tlv(const struct tel_sat_device_identities* src, char *dst, int current_index)
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;
5288 //device identities total len 4
5292 static int _sat_encode_item_identifier_tlv(const struct tel_sat_item_identifier* src, char *dst, int current_index)
5294 dst[current_index++] =SATK_ITEM_IDENTIFIER_TAG;
5295 dst[current_index++] =SATK_ITEM_IDENTIFIER_LENGTH;
5296 dst[current_index++] = src->item_identifier;
5298 //item identifier total len 3
5302 /*static int _sat_encode_duration_tlv(const struct tel_sat_duration* src, char *dst, int current_index)
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;
5309 //duration total len 4
5313 static int _sat_encode_text_tlv(const struct tel_sat_text_string_object* src, char *dst, int current_index, gboolean raw_dcs)
5316 int length_index = 0;
5319 dst[current_index++] =SATK_TEXT_STRING_TAG;
5322 if (src->string_length <= 0x7F) {
5323 dst[current_index++] =SATK_DCS_LENGTH+src->string_length;
5327 dst[current_index++] = 0x81;
5328 dst[current_index++] =SATK_DCS_LENGTH+src->string_length;
5334 dst[current_index++] = src->dcs.raw_dcs;
5336 dst[current_index++] =_sat_encode_dcs_tlv(&(src->dcs));
5339 if (src->string_length > 0) {
5340 memcpy(&(dst[current_index]), src->string, src->string_length);
5343 //tag+index+dcs+data
5344 total_len = 1+length_index+1+src->string_length;
5349 static int _sat_encode_eventlist_tlv(const enum event_list src, char *dst, int current_index)
5351 dst[current_index++] =SATK_EVENT_LIST_TAG;
5352 dst[current_index++] =0x01;
5353 dst[current_index++] =src;
5358 static int _sat_encode_date_time_and_timezone_tlv(const struct tel_sat_date_time_and_timezone *src, char *dst, int current_index)
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;
5370 return 1+1+SATK_DATE_TIME_AND_TIME_ZONE_LENGTH; //tag length+len field length+value length;
5373 static int _sat_encode_language_tlv(const enum tel_sim_language_type src, char *dst, int current_index)
5375 dst[current_index++] =SATK_LANGUAGE_TAG;
5376 dst[current_index++] =SATK_LANGUAGE_LENGTH;
5378 dbg("language (%d)", src);
5382 case SIM_LANG_GERMAN :
5383 dst[current_index++] = 'd';
5384 dst[current_index++] = 'e';
5387 case SIM_LANG_ENGLISH :
5388 dst[current_index++] = 'e';
5389 dst[current_index++] = 'n';
5392 case SIM_LANG_ITALIAN :
5393 dst[current_index++] = 'i';
5394 dst[current_index++] = 't';
5397 case SIM_LANG_FRENCH :
5398 dst[current_index++] = 'f';
5399 dst[current_index++] = 'r';
5402 case SIM_LANG_SPANISH :
5403 dst[current_index++] = 'e';
5404 dst[current_index++] = 's';
5407 case SIM_LANG_DUTCH :
5408 dst[current_index++] = 'n';
5409 dst[current_index++] = 'l';
5412 case SIM_LANG_SWEDISH :
5413 dst[current_index++] = 's';
5414 dst[current_index++] = 'v';
5417 case SIM_LANG_DANISH :
5418 dst[current_index++] = 'd';
5419 dst[current_index++] = 'a';
5422 case SIM_LANG_PORTUGUESE :
5423 dst[current_index++] = 'p';
5424 dst[current_index++] = 't';
5427 case SIM_LANG_FINNISH :
5428 dst[current_index++] = 'f';
5429 dst[current_index++] = 'i';
5432 case SIM_LANG_NORWEGIAN :
5433 dst[current_index++] = 'n';
5434 dst[current_index++] = 'b';
5437 case SIM_LANG_GREEK :
5438 dst[current_index++] = 'e';
5439 dst[current_index++] = 'l';
5442 case SIM_LANG_TURKISH :
5443 dst[current_index++] = 't';
5444 dst[current_index++] = 'k';
5447 case SIM_LANG_HUNGARIAN :
5448 dst[current_index++] = 'h';
5449 dst[current_index++] = 'u';
5452 case SIM_LANG_POLISH :
5453 dst[current_index++] = 'p';
5454 dst[current_index++] = 'l';
5458 dst[current_index++] = 'e';
5459 dst[current_index++] = 'n';
5460 dbg("[SAT] SAT PARSER - Unknown Language: 0x%x",src);
5467 static int _sat_encode_browser_termination_tlv(const enum browser_termination_cause src, char *dst, int current_index)
5469 dst[current_index++] =SATK_BROWSER_TERMINATION_CAUSE_TAG;
5470 dst[current_index++] =SATK_BROWSER_TERMINATION_CAUSE_LENGTH;
5471 dst[current_index++] =src;
5476 static int _sat_encode_bearer_desc_tlv(const struct tel_sat_bearer_description* src, char *dst, int current_index)
5479 int length_index = 0;
5481 dst[current_index++] =SATK_BEARER_DISCRIPTION_TAG;
5484 length_index = current_index++;
5487 dst[current_index++] = src->bearer_type;
5489 switch(src->bearer_type) {
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;
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;
5503 case BEARER_DEFAULT_BEARER_FROM_TRANSPORT_LAYER:
5504 case BEARER_LOCAL_LINK_TECHNOLOGY_INDEPENDENT:
5509 dst[length_index] = (current_index-1) - length_index;
5510 total_len = (current_index-1) - length_index + 2; //tag and length
5515 static int _sat_encode_buffer_size_tlv(const struct tel_sat_buffer_size* src, char *dst, int current_index)
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];
5525 static int _sat_encode_channel_data_tlv(const struct tel_sat_channel_data* src, char *dst, int current_index)
5528 int length_index = 0;
5530 dst[current_index++] = SATK_CHANNEL_DATA_TAG;
5532 if (src->data_string_len <= 0x7F) {
5533 dst[current_index++] = src->data_string_len;
5537 dst[current_index++] = 0x81;
5538 dst[current_index++] = src->data_string_len;
5542 memcpy(&(dst[current_index]), src->data_string, src->data_string_len);
5544 total_len = 1+length_index+src->data_string_len;
5549 static int _sat_encode_channel_data_length_tlv(const struct tel_sat_channel_data_len* src, char *dst, int current_index)
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;
5558 static int _sat_encode_channel_status_tlv(const struct tel_sat_channel_status* src, char *dst, int current_index)
5560 dst[current_index++] = SATK_CHANNEL_STATUS_TAG;
5561 dst[current_index++] = SATK_CHANNEL_STATUS_LENGTH;
5563 if (src->status == link_or_packet_service_activated) //(bit 8)
5564 dst[current_index] += 0x80;
5566 dst[current_index++] += src->channel_id; //(bit 1~3)
5567 dst[current_index++] = src->status_info;
5572 static int _sat_encode_download_event(const struct tel_sat_envelop_event_download_tlv *evt_dl, char *dst_envelop)
5575 int encoded_len = 0;
5577 dbg("event type(%d)", evt_dl->event);
5580 encoded_len = _sat_encode_eventlist_tlv(evt_dl->event, dst_envelop, index);
5581 index += encoded_len;
5584 encoded_len =_sat_encode_device_identities_tlv(&(evt_dl->device_identitie), dst_envelop, index);
5585 index += encoded_len;
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;
5592 case EVENT_BROWSER_TERMINATION:
5593 encoded_len = _sat_encode_browser_termination_tlv(evt_dl->browser_termination, dst_envelop, index);
5594 index += encoded_len;
5596 case EVENT_DATA_AVAILABLE:
5597 encoded_len = _sat_encode_channel_status_tlv(&(evt_dl->channel_status), dst_envelop, index);
5598 index += encoded_len;
5600 encoded_len = _sat_encode_channel_data_length_tlv(&(evt_dl->channel_data_len), dst_envelop, index);
5601 index += encoded_len;
5603 case EVENT_CHANNEL_STATUS:
5604 encoded_len = _sat_encode_channel_status_tlv(&(evt_dl->channel_status), dst_envelop, index);
5605 index += encoded_len;
5611 dst_envelop[0] = SATK_EVENT_DOWNLOAD_TAG;
5612 dst_envelop[1] = index-2;
5614 dbg("download envelop cmd len(%d)", index);
5616 if (index-2 > 0x7F) {
5618 for(idx = index; idx > 0; idx--) {
5619 dst_envelop[idx] = dst_envelop[idx+1];
5621 dst_envelop[1] = 0x81;
5623 dbg("download envelop added cmd len(%d)", index);
5629 int tcore_sat_encode_envelop_cmd(const struct treq_sat_envelop_cmd_data *src_envelop, char *dst_envelop)
5631 int index = 0, encoded_len= 0;
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;
5643 encoded_len = _sat_encode_item_identifier_tlv(&(src_envelop->envelop_data.menu_select.item_identifier), dst_envelop, index);
5644 index += encoded_len;
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;
5652 dbg("menu selection cmd len(%d)", index);
5655 dst_envelop[0] = SATK_MENU_SELECTION_TAG;
5656 dst_envelop[1] = index-2;
5658 else if (src_envelop->sub_cmd == ENVELOP_EVENT_DOWNLOAD) {
5659 index = _sat_encode_download_event(&(src_envelop->envelop_data.event_download),dst_envelop);
5667 static int _sat_encode_display_text(const struct tel_sat_tr_display_text_tlv *src_tr, char *dst_tr)
5669 int index = 0, encoded_len = 0;
5671 //set command detail info
5672 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5673 index += encoded_len;
5675 //set device identities info
5676 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5677 index += encoded_len;
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;
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;
5704 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5712 static int _sat_encode_get_inkey(const struct tel_sat_tr_get_inkey_tlv *src_tr, char *dst_tr)
5714 int index = 0, encoded_len = 0;
5716 //set command detail info
5717 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5718 index += encoded_len;
5720 //set device identities info
5721 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5722 index += encoded_len;
5725 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
5735 encoded_len = _sat_encode_text_tlv(&(src_tr->text), dst_tr, index, FALSE);
5736 index += encoded_len;
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;
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;
5757 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5765 static int _sat_encode_get_input(const struct tel_sat_tr_get_input_tlv *src_tr, char *dst_tr)
5767 int index = 0, encoded_len = 0;
5769 //set command detail info
5770 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5771 index += encoded_len;
5773 //set device identities info
5774 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5775 index += encoded_len;
5778 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
5788 encoded_len = _sat_encode_text_tlv(&(src_tr->text), dst_tr, index, FALSE);
5789 index += encoded_len;
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;
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;
5810 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5818 static int _sat_encode_more_time(const struct tel_sat_tr_more_time_tlv *src_tr, char *dst_tr)
5820 int index = 0, encoded_len = 0;
5822 //set command detail info
5823 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5824 index += encoded_len;
5826 //set device identities info
5827 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5828 index += encoded_len;
5831 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
5851 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5859 static int _sat_encode_play_tone(const struct tel_sat_tr_play_tone_tlv *src_tr, char *dst_tr)
5861 int index = 0, encoded_len = 0;
5863 //set command detail info
5864 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5865 index += encoded_len;
5867 //set device identities info
5868 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5869 index += encoded_len;
5872 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
5896 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5904 static int _sat_encode_refresh(const struct tel_sat_tr_refresh_tlv *src_tr, char *dst_tr)
5906 int index = 0, encoded_len = 0;
5908 //set command detail info
5909 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5910 index += encoded_len;
5912 //set device identities info
5913 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5914 index += encoded_len;
5917 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
5939 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5947 static int _sat_encode_setup_menu(const struct tel_sat_tr_setup_menu_tlv *src_tr, char *dst_tr)
5949 int index = 0, encoded_len = 0;
5951 //set command detail info
5952 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5953 index += encoded_len;
5955 //set device identities info
5956 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5957 index += encoded_len;
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;
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;
5980 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
5988 static int _sat_encode_select_item(const struct tel_sat_tr_select_item_tlv *src_tr, char *dst_tr)
5990 int index = 0, encoded_len = 0;
5992 //set command detail info
5993 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
5994 index += encoded_len;
5996 //set device identities info
5997 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
5998 index += encoded_len;
6001 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
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;
6032 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6040 static int _sat_encode_send_sms(const struct tel_sat_tr_send_sms_tlv *src_tr, char *dst_tr)
6042 int index = 0, encoded_len = 0;
6044 //set command detail info
6045 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6046 index += encoded_len;
6048 //set device identities info
6049 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6050 index += encoded_len;
6053 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
6075 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6083 static int _sat_encode_send_ss(const struct tel_sat_tr_send_ss_tlv *src_tr, char *dst_tr)
6085 int index = 0, encoded_len = 0;
6087 //set command detail info
6088 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6089 index += encoded_len;
6091 //set device identities info
6092 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6093 index += encoded_len;
6096 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
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;
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;
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;
6129 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6137 static int _sat_encode_send_ussd(const struct tel_sat_tr_send_ussd_tlv *src_tr, char *dst_tr)
6139 int index = 0, encoded_len = 0;
6141 //set command detail info
6142 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6143 index += encoded_len;
6145 //set device identities info
6146 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6147 index += encoded_len;
6150 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
6162 encoded_len = _sat_encode_text_tlv(&(src_tr->text), dst_tr, index, TRUE);
6163 index += encoded_len;
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;
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;
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;
6182 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6190 static int _sat_encode_setup_call(const struct tel_sat_tr_setup_call_tlv *src_tr, char *dst_tr)
6192 int index = 0, encoded_len = 0;
6194 //set command detail info
6195 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6196 index += encoded_len;
6198 //set device identities info
6199 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6200 index += encoded_len;
6203 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
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;
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;
6240 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6248 static int _sat_encode_provide_local_info(const struct tel_sat_tr_provide_local_info_tlv *src_tr, char *dst_tr)
6250 int index = 0, encoded_len = 0;
6252 //set command detail info
6253 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6254 index += encoded_len;
6256 //set device identities info
6257 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6258 index += encoded_len;
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);
6273 case LOCAL_INFO_LANGUAGE:
6274 encoded_len = _sat_encode_language_tlv(src_tr->other.language, dst_tr, index);
6277 dbg("local info type[%d] is not handled", src_tr->command_detail.cmd_qualifier.provide_local_info.provide_local_info);
6280 index += encoded_len;
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;
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;
6296 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6304 static int _sat_encode_setup_event_list(const struct tel_sat_tr_setup_event_list_tlv *src_tr, char *dst_tr)
6306 int index = 0, encoded_len = 0;
6308 //set command detail info
6309 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6310 index += encoded_len;
6312 //set device identities info
6313 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6314 index += encoded_len;
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;
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;
6336 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6344 static int _sat_encode_setup_idle_mode_text(const struct tel_sat_tr_setup_idle_mode_text_tlv *src_tr, char *dst_tr)
6346 int index = 0, encoded_len = 0;
6348 //set command detail info
6349 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6350 index += encoded_len;
6352 //set device identities info
6353 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6354 index += encoded_len;
6357 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
6378 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6386 static int _sat_encode_send_dtmf(const struct tel_sat_tr_send_dtmf_tlv *src_tr, char *dst_tr)
6388 int index = 0, encoded_len = 0;
6390 //set command detail info
6391 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6392 index += encoded_len;
6394 //set device identities info
6395 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6396 index += encoded_len;
6399 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
6421 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6429 static int _sat_encode_language_notification(const struct tel_sat_tr_language_notification_tlv *src_tr, char *dst_tr)
6431 int index = 0, encoded_len = 0;
6433 //set command detail info
6434 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6435 index += encoded_len;
6437 //set device identities info
6438 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6439 index += encoded_len;
6442 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
6463 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6471 static int _sat_encode_launch_browser(const struct tel_sat_tr_launch_browser_tlv *src_tr, char *dst_tr)
6473 int index = 0, encoded_len = 0;
6475 //set command detail info
6476 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6477 index += encoded_len;
6479 //set device identities info
6480 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6481 index += encoded_len;
6484 dst_tr[index++] = (b_comprehensive ? (SATK_RESULT_TAG | 0x80) : SATK_RESULT_TAG);;
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;
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;
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;
6510 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6518 static int _sat_encode_open_channel(const struct tel_sat_tr_open_channel_tlv *src_tr, char *dst_tr)
6520 int index = 0, encoded_len = 0;
6522 //set command detail info
6523 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6524 index += encoded_len;
6526 //set device identities info
6527 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6528 index += encoded_len;
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;
6541 //set channel status
6542 encoded_len = _sat_encode_channel_status_tlv(&(src_tr->channel_status), dst_tr, index);
6543 index += encoded_len;
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;
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;
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;
6570 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6576 encoded_len = _sat_encode_bearer_desc_tlv(&(src_tr->bearer_desc), dst_tr, index);
6577 index += encoded_len;
6580 encoded_len = _sat_encode_buffer_size_tlv(&(src_tr->buffer_size), dst_tr, index);
6581 index += encoded_len;
6586 static int _sat_encode_close_channel(const struct tel_sat_tr_close_channel_tlv *src_tr, char *dst_tr)
6588 int index = 0, encoded_len = 0;
6590 //set command detail info
6591 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6592 index += encoded_len;
6594 //set device identities info
6595 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6596 index += encoded_len;
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;
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;
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;
6626 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6634 static int _sat_encode_send_data(const struct tel_sat_tr_send_data_tlv *src_tr, char *dst_tr)
6636 int index = 0, encoded_len = 0;
6638 //set command detail info
6639 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6640 index += encoded_len;
6642 //set device identities info
6643 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6644 index += encoded_len;
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;
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;
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;
6678 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6686 static int _sat_encode_receive_data(const struct tel_sat_tr_receive_data_tlv *src_tr, char *dst_tr)
6688 int index = 0, encoded_len = 0;
6690 //set command detail info
6691 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6692 index += encoded_len;
6694 //set device identities info
6695 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6696 index += encoded_len;
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;
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;
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;
6731 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6739 static int _sat_encode_get_channel_status(const struct tel_sat_tr_get_channel_status_tlv *src_tr, char *dst_tr)
6741 int index = 0, encoded_len = 0;
6743 //set command detail info
6744 encoded_len = _sat_encode_command_detail_tlv(&(src_tr->command_detail), dst_tr, index);
6745 index += encoded_len;
6747 //set device identities info
6748 encoded_len = _sat_encode_device_identities_tlv(&(src_tr->device_id), dst_tr, index);
6749 index += encoded_len;
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;
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;
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;
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;
6784 dbg("invalid response value[0x%x] in current TR",src_tr->result_type);
6792 int tcore_sat_encode_terminal_response(const struct treq_sat_terminal_rsp_data *src_tr, char *dst_tr) {
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);
6802 case SAT_PROATV_CMD_GET_INKEY:{
6803 tr_len = _sat_encode_get_inkey(&(src_tr->terminal_rsp_data.get_inkey), dst_tr);
6805 case SAT_PROATV_CMD_GET_INPUT:{
6806 tr_len = _sat_encode_get_input(&(src_tr->terminal_rsp_data.get_input), dst_tr);
6808 case SAT_PROATV_CMD_MORE_TIME:{
6809 tr_len = _sat_encode_more_time(&(src_tr->terminal_rsp_data.more_time), dst_tr);
6811 case SAT_PROATV_CMD_PLAY_TONE:{
6812 tr_len = _sat_encode_play_tone(&(src_tr->terminal_rsp_data.play_tone), dst_tr);
6814 case SAT_PROATV_CMD_REFRESH:{
6815 tr_len = _sat_encode_refresh(&(src_tr->terminal_rsp_data.refresh), dst_tr);
6817 case SAT_PROATV_CMD_SETUP_MENU:{
6818 tr_len = _sat_encode_setup_menu(&(src_tr->terminal_rsp_data.setup_menu), dst_tr);
6820 case SAT_PROATV_CMD_SELECT_ITEM:{
6821 tr_len = _sat_encode_select_item(&(src_tr->terminal_rsp_data.select_item), dst_tr);
6823 case SAT_PROATV_CMD_SEND_SMS:{
6824 tr_len = _sat_encode_send_sms(&(src_tr->terminal_rsp_data.send_sms), dst_tr);
6826 case SAT_PROATV_CMD_SEND_SS:{
6827 tr_len = _sat_encode_send_ss(&(src_tr->terminal_rsp_data.send_ss), dst_tr);
6829 case SAT_PROATV_CMD_SEND_USSD:{
6830 tr_len = _sat_encode_send_ussd(&(src_tr->terminal_rsp_data.send_ussd), dst_tr);
6832 case SAT_PROATV_CMD_SETUP_CALL:{
6833 tr_len = _sat_encode_setup_call(&(src_tr->terminal_rsp_data.setup_call), dst_tr);
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);
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);
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);
6844 case SAT_PROATV_CMD_SEND_DTMF:{
6845 tr_len = _sat_encode_send_dtmf(&(src_tr->terminal_rsp_data.send_dtmf), dst_tr);
6847 case SAT_PROATV_CMD_LANGUAGE_NOTIFICATION:{
6848 tr_len = _sat_encode_language_notification(&(src_tr->terminal_rsp_data.language_notification), dst_tr);
6850 case SAT_PROATV_CMD_LAUNCH_BROWSER:{
6851 tr_len = _sat_encode_launch_browser(&(src_tr->terminal_rsp_data.launch_browser), dst_tr);
6853 case SAT_PROATV_CMD_OPEN_CHANNEL:{
6854 tr_len = _sat_encode_open_channel(&(src_tr->terminal_rsp_data.open_channel), dst_tr);
6856 case SAT_PROATV_CMD_CLOSE_CHANNEL:{
6857 tr_len = _sat_encode_close_channel(&(src_tr->terminal_rsp_data.close_channel), dst_tr);
6859 case SAT_PROATV_CMD_SEND_DATA:{
6860 tr_len = _sat_encode_send_data(&(src_tr->terminal_rsp_data.send_data), dst_tr);
6862 case SAT_PROATV_CMD_RECEIVE_DATA:{
6863 tr_len = _sat_encode_receive_data(&(src_tr->terminal_rsp_data.receive_data), dst_tr);
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);
6869 err("no matched cmd type(%d)", src_tr->cmd_type);
6876 void tcore_sat_override_ops(CoreObject *o, struct tcore_sat_operations *sat_ops)
6878 struct private_object_data *po = NULL;
6880 CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_SAT);
6882 po = (struct private_object_data *)tcore_object_ref_object(o);
6888 _clone_sat_operations(po, sat_ops);
6894 CoreObject *tcore_sat_new(TcorePlugin *p,
6895 struct tcore_sat_operations *ops, TcoreHal *hal)
6897 CoreObject *o = NULL;
6898 struct private_object_data *po = NULL;
6903 o = tcore_object_new(p, hal);
6907 po = calloc(1, sizeof(struct private_object_data));
6909 tcore_object_free(o);
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);
6924 void tcore_sat_free(CoreObject *o)
6926 struct private_object_data *po = NULL;
6928 CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_SAT);
6930 po = tcore_object_ref_object(o);
6935 tcore_object_free(o);